#You could move the following settings to the botconfig
#In order to make sure you are not putting stuff to the wrong bot, add the bot as user to your bot, 
#and update idlereap(bot) to reflect the gamebots user handle in the bot
set idlereap(user) "dex"
set idlereap(pass) "palare"
set idlereap(bot)  "multirpg"
set idlereap(defaultalign) "undead"
set idlereap(bankkeep) 200

#---------------
package require http
namespace path {::tcl::mathop ::tcl::mathfunc}

bind join - * idlereap:join
proc idlereap:join {nick host hand chan} {
	global idlereap
	if {[isbotnick $nick] && [hand2nick $idlereap(bot) $chan] != ""} {
		dotimer 5 idlereap:login
	} elseif {$hand == $idlereap(bot)} {
		idlereap:login
	}
}

#Sp00kie, with his level 9 Hero [2090/3195][2320/3546] has attacked a Skeleton [684/800] and killed it! 0 days, 00:32:53 is removed from Sp00kie's clock. Sp00kie reaches level 40 in 0 days, 14:04:19
bind pubm - *attacked* idlereap:pubm:attackstats
proc idlereap:pubm:attackstats {nick host hand chan args} {
	global idlereap
	if {$hand != $idlereap(bot)} { return 0 }
	set args [stripcodes bcuarg [lindex $args 0]]
	set offset [+ [lsearch -exact $args "attacked"] 1]
	set creep [lindex $args [+ $offset 1]]
	set roll [str2int [lindex [split [lindex $args [+ $offset 2]] /] 0]]
	lappend idlereap(stats,$creep) $roll
}

#Moonlander found 139 gold pieces in Skeleton's hands. Moonlander picks them up and now sums 181 total gold.
bind pubm - *hands* idlereap:pubm:payoutstats
proc idlereap:pubm:payoutstats {nick host hand chan args} {
	global idlereap
	if {$hand != $idlereap(bot)} { return 0 }
	set args [stripcodes bcuarg [lindex $args 0]]
	set offset [+ [lsearch -exact $args "found"] 1]
	set creep [lindex $args [+ $offset 4]]
	set payout [lindex $args $offset]
	set creep [string range $creep 0 [- [string length $creep] 3]]
	lappend idlereap(stats,$creep,payout) $payout
}

#I-Know, with his/her level 9 Hero [2768/4480][3072/4973] has tried to slay a Medusa [779/3577] and killed it! 1 day, 02:44:02 is removed from I-Know's clock. I-Know reaches level 52 in 10 days, 00:36:22.
bind pubm - *slay* idlereap:pubm:slaystats
proc idlereap:pubm:slaystats {nick host hand chan args} {
	global idlereap
	if {$hand != $idlereap(bot)} { return 0 }
	set args [stripcodes bcuarg [lindex $args 0]]
	set offset [+ [lsearch -exact $args "slay"] 2]
	set creep [lindex $args $offset]
	set roll [str2int [lindex [split [lindex $args [+ $offset 1]] /] 0]]
	lappend idlereap(stats,$creep) $roll
}

#I-Know found 153 gold pieces in Medusa's treasure chest. I-Know picks them up and now sums 224 total gold.
bind pubm - *chest* idlereap:pubm:slaypayout
proc idlereap:pubm:slaypayout {nick host hand chan args} {
	global idlereap
	if {$hand != $idlereap(bot)} { return 0 }
	set args [stripcodes bcuarg [lindex $args 0]]
	set offset [+ [lsearch -exact $args "found"] 1]
	set creep [lindex $args [+ $offset 4]]
	set payout [lindex $args $offset]
	set creep [string range $creep 0 [- [string length $creep] 3]]
	lappend idlereap(stats,$creep,payout) $payout
}

bind pubm - * idlereap:pubm
proc idlereap:pubm {nick host hand chan args} {
	global idlereap
	if {$hand != $idlereap(bot)} { return 0 }
	set args [stripcodes bcuarg [lindex $args 0]]

	#IdleReap, the level 3 The Scripted One, is now online from ScaryNet, nickname IdleReap. He reaches level 4 in 0 days, 00:14:37.
	if {[string match "$idlereap(user), the level * is now online from *" $args]} {
		dotimer 1 "idlereap:send RAWSTATS2"
		return
	}

	#IdleReap, The Scripted One, has attained level 2! He reaches level 3 in 0 days, 00:13:27.
	if {[string match "$idlereap(user), * has attained level *" $args]} {
		dotimer 1 "idlereap:send RAWSTATS2"
		return
	}

	#Royal Tournament Round 1, Fight 24: IdleReap [19/347] vs Mientje [127/294] ... Mientje advances and gets 20 gold from IdleReap!
	if {[string match "* advances and gets * from $idlereap(user)!" $args]} {
		if {[info exists idlereap(goldtournament)]} { unset idlereap(goldtournament) }
		if {[info exists idlereap(runningtournament)]} {
			dotimer 1 "idlereap:send RAWSTATS2"
			unset idlereap(runningtournament)
		}
		return
	}

	#Low-Level Quick Round 3, Fight 2: bbwoIf [373/1351] vs Zer0n [131/607] ... bbwoIf advances!
	if {[string match "* Round * Fight * ... * advances!" $args] && [string match "*$idlereap(user)*" $args]} {
		if {[lindex $args [llength $args]-2] != $idlereap(user)} {
			if {[info exists idlereap(goldtournament)]} { unset idlereap(goldtournament)}
			if {[info exists idlereap(runningtournament)]} {
				dotimer 1 "idlereap:send RAWSTATS2"
				unset idlereap(runningtournament)
			}
		}
		return
	}
	
	#s0lid_ found 1858 gold pieces in Sphinx's treasure chest. s0lid_ picks them up and now sums 2330 total gold.
	if {[string match "$idlereap(user) found * gold pieces*" $args]} {
		dotimer 10 "idlereap:send RAWSTATS2"
		return
	}

        #The Royal Tournament is starting!
        if {[string match "The * is starting!" $args]} {
                set idlereap(runningtournament) 1
        }

        #The Gold Tournament is finished. Congrats RadioWest!
        if {[string match "The * is finished.*" $args]} {
                if {[info exists idlereap(goldtournament)]} { unset idlereap(goldtournament) }
                if {[info exists idlereap(runningtournament)]} {
                        dotimer 1 "idlereap:send RAWSTATS2"
                        unset idlereap(runningtournament)
                }
                idlereap:gettournamenttimers
                return
        }
}

bind msgm - * idlereap:msgm
proc idlereap:msgm {nick host hand args} {
	global idlereap
	if {$hand != $idlereap(bot)} { return 0 }
	set args [stripcodes bcuarg [lindex $args 0]]

	#You have deposited 577 gold into the bank.
	if {[string match "You have deposited * gold into the bank." $args]} {
		set amount [lindex $args 3]
		if {[info exists idlereap(bank)]} {
			incr idlereap(bank) $amount
		} else {
			set idlereap(bank) $amount
		}
		incr idlereap(gold) -$amount
		return
	}

	#You have withdrawn 146 gold from the bank
	if {[string match "You have withdrawn * gold from the bank." $args]} {
		set amount [lindex $args 3]

		if {[info exists idlereap(bank)]} {
			incr idlereap(bank) -$amount
		} else {
			set idlereap(bank) 0
		}
		incr idlereap(gold) $amount

		if {[info exists idlereap(goldtournament)]} { return }
		if {$idlereap(level) < 15} { return }

		if {$idlereap(gold) >= $idlereap(bankkeep) && $idlereap(bets) < 5 && $idlereap(level) >= 30} {
			idlereap:dobet [- 5 $idlereap(bets)]
			return
		}

		for {set i 0} {$i < 100} {incr i} {
			if {$idlereap(gold) >= 1000} {
				if {$idlereap(engineer) == 0} {
					idlereap:send "HIRE engineer"
					incr idlereap(gold) -1000
					set idlereap(engineer) 1
					continue
				}
				if {$idlereap(hero) == 0 && $idlereap(itemsum) > 1000} {
					idlereap:send "SUMMON hero"
					incr idlereap(gold) -1000
					set idlereap(hero) 1
					continue
				}
			}
			if {$idlereap(gold) >= 200} {
				if {$idlereap(engineer,level) < 9 && $idlereap(engineer) == 1} {
					idlereap:send "ENGINEER level"
					incr idlereap(gold) -200
					incr idlereap(engineer,level)
					continue
				}
				if {$idlereap(hero,level) < 9 && $idlereap(hero) == 1} {
					idlereap:send "HERO level"
					incr idlereap(gold) -200
					incr idlereap(hero,level)
					continue
				}
				#if {$idlereap(itemsum) >= 10000 && $idlereap(hero,level) == 9 && $idlereap(potion,power) < 2} {
				#	idlereap:send "BUY power"
				#	incr idlereap(gold) -200
				#	incr idlereap(potion,power)
				#	continue
				#}
				if {$idlereap(itemsum) >= 10000 && $idlereap(hero,level) == 9 && $idlereap(potion,luck) < 2} {
					idlereap:send "BUY luck"
					incr idlereap(gold) -200
					incr idlereap(potion,luck)
					continue
				}
			}
			if {$idlereap(engineer) == 1 && $idlereap(engineer,level) == 9} {
				set items "ring amulet charm weapon helm tunic gloves leggings shield boots"
				set bought 0
				foreach item $items {
					if {![info exists idlereap(item,$item)]} { continue }
					if {$idlereap(item,$item) >= [* $idlereap(level) 2]} { continue }
	
					set idiff [- [* $idlereap(level) 2] $idlereap(item,$item)]
					set imaxbuy [expr floor($idlereap(gold) / 3)]
					if {$imaxbuy > [* $idlereap(level) 2]} { set imaxbuy [* $idlereap(level) 2] }
					if {$imaxbuy < $idlereap(item,$item)} { continue }
	
					set icost_buy [* $imaxbuy 3]
					set icost_upg [* $idiff 20]
					if {$icost_upg < $icost_buy && $idlereap(gold) > $icost_buy} {
						set imaxbuy [expr round($imaxbuy)]
						idlereap:send "BUY $item $imaxbuy"
						set idlereap(item,$item) $imaxbuy
						incr idlereap(gold) -$icost_buy
						set bought 1
					}
				}
				if {$bought == 1} { continue }

				if {$idlereap(gold) >= 20} {
					set lowest ""
					set lcount 99999999
					foreach item $items {
						if {![info exists idlereap(item,$item)]} { continue }
						if {$idlereap(gold) < 20} { break }
						if {$idlereap(item,$item) >= [* $idlereap(level) 2] && $idlereap(item,$item) < $lcount} {
							set lowest $item
							set lcount $idlereap(item,$item)
						}
					}
					if {$lowest != ""} {
						set amount [/ $idlereap(gold) 20]
						if {$amount > 10} { set amount 10 }
						idlereap:send "UPGRADE $lowest $amount"
						incr idlereap(item,$lowest) $amount
						incr idlereap(itemsum) $amount
						incr idlereap(gold) -[* $amount 20]
					}
				}
			}
		}

		if {$idlereap(gold) > 0} { idlereap:send "BANK deposit all" }
		return
	}

	#You have 59 gold in the bank, and are carrying 300 gold.
	if {[string match "You have * gold in the bank, and are carrying * gold." $args]} {
		dccbroadcast $args
		return
	}

	if {[string match "level *" $args]} {
		set idlereap(level) [str2int [lindex $args [lsearch -exact $args "level"]+1]]
		set idlereap(gold) [str2int [lindex $args [lsearch -exact $args "gold"]+1]]
		set idlereap(bank) [str2int [lindex $args [lsearch -exact $args "bank"]+1]]
		set idlereap(itemsum) [str2int [lindex $args [lsearch -exact $args "sum"]+1]]
		set idlereap(item,ring) [str2int [lindex $args [lsearch -exact $args "ring"]+1]]
		set idlereap(item,amulet) [str2int [lindex $args [lsearch -exact $args "amulet"]+1]]
		set idlereap(item,charm) [str2int [lindex $args [lsearch -exact $args "charm"]+1]]
		set idlereap(item,weapon) [str2int [lindex $args [lsearch -exact $args "weapon"]+1]]
		set idlereap(item,helm) [str2int [lindex $args [lsearch -exact $args "helm"]+1]]
		set idlereap(item,tunic) [str2int [lindex $args [lsearch -exact $args "tunic"]+1]]
		set idlereap(item,gloves) [str2int [lindex $args [lsearch -exact $args "gloves"]+1]]
		set idlereap(item,leggings) [str2int [lindex $args [lsearch -exact $args "leggings"]+1]]
		set idlereap(item,shield) [str2int [lindex $args [lsearch -exact $args "shield"]+1]]
		set idlereap(item,boots) [str2int [lindex $args [lsearch -exact $args "boots"]+1]]
		set idlereap(potion,power) [str2int [lindex $args [lsearch -exact $args "powerpots"]+1]]
		set idlereap(potion,luck) [str2int [lindex $args [lsearch -exact $args "luckpots"]+1]]
		set idlereap(fights) [str2int [lindex $args [lsearch -exact $args "fights"]+1]]
		set idlereap(bets) [str2int [lindex $args [lsearch -exact $args "bets"]+1]]
		set idlereap(hero) [str2int [lindex $args [lsearch -exact $args "hero"]+1]]
		set idlereap(hero,level) [str2int [lindex $args [lsearch -exact $args "hlevel"]+1]]
		set idlereap(engineer) [str2int [lindex $args [lsearch -exact $args "engineer"]+1]]
		set idlereap(engineer,level) [str2int [lindex $args [lsearch -exact $args "englevel"]+1]]

		set align [lindex $args [lsearch -exact $args "align"]+1]
		switch -- $align {
			"g" { set idlereap(align) "priest" }
			"n" { set idlereap(align) "human" }
			"u" { set idlereap(align) "undead" }
		}

		if {$idlereap(bets) < 5 && $idlereap(level) >= 30 && $idlereap(gold) >= $idlereap(bankkeep)} {
			idlereap:dobet [- 5 $idlereap(bets)]
			return
		}

		set attack [str2int [lindex $args [lsearch -exact $args "attackttl"]+1]]
                if {$idlereap(level) >= 10} {
                        dotimer [+ $attack 10] idlereap:doattack
                }

		set slay [str2int [lindex $args [lsearch -exact $args "slayttl"]+1]]
                if {$idlereap(level) >= 40} {
                        dotimer [+ $slay 10] idlereap:doslay
                }

		set challenge [str2int [lindex $args [lsearch -exact $args "challengettl"]+1]]
                if {$idlereap(level) >= 35} {
                        dotimer [+ $challenge 10] "idlereap:send CHALLENGE"
                }

		set idlereap(ttl) [str2int [lindex $args [lsearch -exact $args "ttl"]+1]]
		if {$idlereap(ttl) > 30} {
			dotimer [- $idlereap(ttl) 30] "idlereap:align priest"
		} elseif {$idlereap(ttl) > 120} {
			idlereap:align
		}

		if {$idlereap(level) < 15} {
			if {$idlereap(gold) > 0 && ![info exists idlereap(goldtournament)]} {
				idlereap:send "BANK deposit all"
			}
		} else {
			set sum [+ [- $idlereap(bank) $idlereap(bankkeep)] $idlereap(gold)]
			set withdraw 0

			if {$idlereap(level)>=30 && [info exists idlereap(bets)] && $idlereap(bets)<5 && $sum >= $idlereap(bankkeep) && $idlereap(gold) < $idlereap(bankkeep)} {
				idlereap:send "BANK withdraw [- $idlereap(bankkeep) $idlereap(gold)]"
				return
			} elseif {$idlereap(engineer) == 0 && $sum >= [expr ($idlereap(level)<29?1000:1100)]} {
				set withdraw 1
			} elseif {$idlereap(engineer) == 1 && $idlereap(engineer,level) < 10 && $sum >= [expr ($idlereap(level)<29?200:100)]} {
				set withdraw 1
			}

			if {$idlereap(hero) == 0 && $idlereap(itemsum) > 1000 && $idlereap(level) >= 30 && $sum < 1100} {
				set withdraw 0
			}

			if {$idlereap(bank) > [expr ($idlereap(level)<29?0:100)] && $withdraw == 1} {
				idlereap:send "BANK withdraw [expr $idlereap(bank) - ($idlereap(level)<29?0:100)]"
			} elseif { $idlereap(gold) > 0 && ![info exists idlereap(goldtournament)]} {
				idlereap:send "BANK deposit all"
			}
		}

		if {$idlereap(fights) < 5 && $idlereap(level) >= 10} {
			idlereap:dofight [- 5 $idlereap(fights)]
		}
		return
	}
}

bind notc - * idlereap:notc
proc idlereap:notc {nick host hand args {dest ""}} {
	global idlereap botnick
	if {$hand != $idlereap(bot)} { return 0 }
	if {$dest == ""} { set dest $botnick }
	set args [stripcodes bcuarg $args]

	#Logon successful. You reach level 4 in 0 days, 00:14:37.
	if {[string match "Logon successful. You reach level *" $args]} {
		set idlereap(nextlevel) [lrange $args 7 e]
		return
	}

	#Sorry, no such account name. Note that account names are case sensitive.
	if {[string match "Sorry, no such account name. Note that account names are case sensitive." $args]} {
		idlereap:send "REGISTER $idlereap(user) $idlereap(pass) The Scripted One"
		idlereap:send "AGE 0"
		idlereap:send "SEX Male"
		idlereap:send "REALNAME Cooked Egg"
		idlereap:send "LOCATION In a friggin shellbox"
		idlereap:send "EMAIL lamer@aol.com"
		idlereap:send "AVATAR http://www.andrew.cmu.edu/user/sahuber/rpd/Pictures/Broken%20Egg.JPG"
	}
}

proc idlereap:doattack {} {
	global idlereap
	set creeps "Bush Locust Spider Goblin Lich Skeleton Ghost Shadow Troll Cyclop Mutant Monkey Phoenix Minotaur Beholder"
	set target [idlereap:creepfinder $creeps]
	#set target ""

	if {$target == ""} {
		set target "Bush"
		if {$idlereap(level) >  10} { set target "Locust" }
		if {$idlereap(level) >= 15} { set target "Spider" }
		if {$idlereap(level) >= 20} { set target "Goblin" }
		if {$idlereap(level) >= 30} { set target "Lich" }
		if {$idlereap(level) >= 40} { set target "Skeleton" }
		if {$idlereap(level) >= 50} { set target "Ghost" }
		if {$idlereap(level) >= 60} { set target "Shadow" }
		if {$idlereap(level) >= 70} { set target "Troll" }
		if {$idlereap(level) >= 80} { set target "Cyclop" }
		if {$idlereap(level) >= 90} { set target "Mutant" }
		if {$idlereap(level) >= 100} { set target "Monkey" }
		if {$idlereap(level) >= 110} { set target "Phoenix" }
		if {$idlereap(level) >= 120} { set target "Minotaur" }
		if {$idlereap(level) >= 130} { set target "Beholder" }
	}

	idlereap:send "ATTACK $target"
}

proc idlereap:doslay {} {
	global idlereap
	set creeps "Medusa Centaur Mammoth Vampire Dragon Sphinx Hippogriff"
	set target [idlereap:creepfinder $creeps]

	if {$target == ""} {
		if {$idlereap(itemsum) >= 11000} {
			set target "Hippogriff"
		} elseif {$idlereap(itemsum) >= 10000} {
			set target "Sphinx"
		} elseif {$idlereap(itemsum) >= 9000} {
			set target "Dragon"
		} elseif {$idlereap(itemsum) >= 8000} {
			set target "Vampire"
		} elseif {$idlereap(itemsum) >= 7000} {
			set target "Mammoth"
		} elseif {$idlereap(itemsum) >= 6000} {
			set target "Centaur"
		} else {
			set target "Medusa"
		}
	}

	if {$idlereap(potion,power) > 0 && $idlereap(itemsum) >= 15000} {
		idlereap:send "LOAD power 1"
		incr idlereap(potion,power) -1
	} elseif {$idlereap(potion,luck) > 0 && $idlereap(itemsum) >= 15000} {
		idlereap:send "LOAD luck 1"
		incr idlereap(potion,luck) -1
	}
	idlereap:send "SLAY $target"
}

proc idlereap:dofight {{count 5}} {
	global idlereap
	set token [::http::geturl "http://idlerpg.org/rawplayers3.php"]
	if {[::http::ncode $token] != 200} { return }
	set data [::http::data $token]
	::http::cleanup $token
	set lowest 99999999999
	set victim ""
	set vlevel 0
	set valign ""

	set refsum $idlereap(itemsum)
	#if {$idlereap(hero,level) > 0} {
	#	set refsum [+ $refsum [* [/ $refsum 100] [+ 2 $idlereap(hero,level)]]]
	#}

	foreach data [split $data "\n"] {
		set char [lindex $data [lsearch -exact $data "char"]+1]
		set level [lindex $data [lsearch -exact $data "level"]+1]
		set online [lindex $data [lsearch -exact $data "online"]+1]
		if {$level < $idlereap(level) || $online == "0"} { continue }
		if {$char == $idlereap(user)} { continue }

		set itemsum [str2int [lindex $data [lsearch -exact $data "amulet"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "charm"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "helm"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "boots"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "gloves"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "ring"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "leggings"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "shield"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "tunic"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "weapon"]+1]]

		set tmpsum $itemsum
		if {[str2int [lindex $data [lsearch -exact $data "powerpots"]+1]]>0} {
			set itemsum [+ $itemsum [/ $tmpsum 10]]
		}
		if {[str2int [lindex $data [lsearch -exact $data "luckpots"]+1]]>0} {
			set itemsum [+ $itemsum [/ $tmpsum 10]]
		}
		if {[str2int [lindex $data [lsearch -exact $data "hero"]+1]]>0} {
			set hlevel [+ 2 [str2int [lindex $data [lsearch -exact $data "hlevel"]+1]]]
			set itemsum [+ $itemsum [* [/ $tmpsum 100] $hlevel]]
		}
		set align [lindex $data [lsearch -exact $data "align"]]
		if {$align == "g"} {
			set itemsum [+ $itemsum [/ $tmpsum 10]]
		}
		if {$align == "u"} {
			set itemsum [+ $itemsum [/ $tmpsum 10]]
		}

#		if {$refsum < $itemsum} {continue}
		
		if {$itemsum < $lowest} {
			set lowest $itemsum
			set victim $char
			set vlevel $level
			set valign $align
		}
	}

	if {$victim != ""} {
		dccbroadcast "Fighting $victim \[L$vlevel:S$lowest:A$valign\]"
		if {$valign == "u"} {
			idlereap:align human
		} elseif {$valign == "g"} {
			idlereap:align undead
		} else {
			idlereap:align priest
		}
		for {set i 0} {$i < $count} {incr i} {
			idlereap:send "FIGHT $victim"
			incr idlereap(fights)
		}
	} else {
		dccbroadcast "No victim found to fight ?!?!?"
	}
	idlereap:align
}

proc idlereap:gettournamenttimers {} {
	global idlereap
	set token [::http::geturl "http://idlerpg.org/timers.php"]
	if {[::http::ncode $token] != 200} { return }
	set datahttp [::http::data $token]
	::http::cleanup $token
	foreach data [split $datahttp "\n"] {
		if {[string match "*displayTimer('*',*);*" $data] && ![string match "*setTimeout*" $data]} {
			regsub -all -- "'" [string range [string trim $data] 14 [expr [string length [string trim $data]] -3]] "" usable
			set tdata [split $usable ,]
			set ttype [lindex $tdata 0]
			if {$ttype == "rt" && $idlereap(level) < 16} { continue }
			if {$ttype == "dm" && $idlereap(level) < 16} { continue }
			if {$ttype == "it" && $idlereap(level) < 25} { continue }
			if {$ttype == "lr1" && $idlereap(level) < 5} { continue }
			if {$ttype == "lr2" && $idlereap(level) < 5} { continue }
			if {$ttype == "gt" && $idlereap(level) < 20} { continue }
			if {$ttype == "cl" && $idlereap(level) < 40} { continue }
			if {$ttype == "cl" || $ttype =="rt" || $ttype == "dm" || $ttype == "gt"} {
				set remain [expr [lindex $tdata 1] - [unixtime] - 10]
				if {$remain > 0} {
					dotimer $remain "idlereap:preparetournament $ttype"
				}
			}
		}
	}
}

proc idlereap:preparetournament {type} {
	global idlereap
	if {$type == "cl" || $type =="rt" || $type == "dm" || $type == "gt"} {
		if {$idlereap(gold)<20 && $idlereap(bank) >= [expr 20 - $idlereap(gold)]} {
			idlereap:send "BANK withdraw [expr 20 - $idlereap(gold)]"
			set idlereap(goldtournament) 1
		}
	}
}

proc idlereap:dobet {{count 5}} {
	global idlereap
	set token [::http::geturl "http://idlerpg.org/rawplayers3.php"]
	if {[::http::ncode $token] != 200} { return }
	set datahttp [::http::data $token]
	::http::cleanup $token
	set idlereap(players) ""

	foreach data [split $datahttp "\n"] {
		set char [lindex $data [lsearch -exact $data "char"]+1]
		set level [lindex $data [lsearch -exact $data "level"]+1]
		set online [lindex $data [lsearch -exact $data "online"]+1]
		if {$online == "0" || $online == "" || $level < 30} { continue }

		lappend idlereap(players) $char
		set idlereap($char,level) $level
		set idlereap($char,bdiff) [- [str2int [lindex $data [lsearch -exact $data "bwon"]+1]] [str2int [lindex $data [lsearch -exact $data "blost"]+1]]]

		set itemsum [str2int [lindex $data [lsearch -exact $data "amulet"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "charm"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "helm"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "boots"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "gloves"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "ring"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "leggings"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "shield"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "tunic"]+1]]
		incr itemsum [str2int [lindex $data [lsearch -exact $data "weapon"]+1]]
		set idlereap($char,itemsum) $itemsum
	}

	set bestratio 0
	set bestsource ""
	set bestdest ""

	set bestratio2 0
	set bestsource2 ""
	set bestdest2 ""

	foreach source $idlereap(players) {
		foreach dest $idlereap(players) {
			if {$idlereap($source,level) > $idlereap($dest,level)} { continue }
			if {$idlereap($source,itemsum) < $idlereap($dest,itemsum)} { continue }
			set ratio [/ $idlereap($source,itemsum) [double $idlereap($dest,itemsum)]]
			if {$ratio > $bestratio} {
				set bestratio2 $bestratio
				set bestsource2 $bestsource
				set bestdest2 $bestdest

				set bestratio $ratio
				set bestsource $source
				set bestdest $dest	
			}
		}
	}

	if {$bestsource == "" || $bestdest == ""} { return }
	putlog "Best bet: $bestsource \[L$idlereap($bestsource,level):S$idlereap($bestsource,itemsum):D$idlereap($bestsource,bdiff)\] vs $bestdest \[L$idlereap($bestdest,level):S$idlereap($bestdest,itemsum):D$idlereap($bestdest,bdiff)\] \($bestratio\)"
	putlog "Best alt: $bestsource2 \[L$idlereap($bestsource2,level):S$idlereap($bestsource2,itemsum):D$idlereap($bestsource2,bdiff)\] vs $bestdest2 \[L$idlereap($bestdest2,level):S$idlereap($bestdest2,itemsum):D$idlereap($bestdest2,bdiff)\] \($bestratio2\)"

	if {$count == 0} {return}

	if {$idlereap(level) >= 30} {
		if {$idlereap(gold) < 100 && $idlereap(bank) > [expr 100-$idlereap(gold)]} {
			set amount [- 100 $idlereap(gold)]
			idlereap:send "BANK withdraw $amount"
		} elseif {$idlereap(gold) < 100} {
			return
		}

		for {set i 0} {$i < $count} {incr i} {
			if {$bestdest2 == ""} {
				idlereap:send "BET $bestsource $bestdest 100"
			} else {
				idlereap:send "BET $bestsource2 $bestdest2 100"
			}
			incr idlereap(bets)
		}
		idlereap:send RAWSTATS2
	}
}

proc idlereap:creepfinder { creeps } {
	global idlereap
        set payout 0
	set recovery 0

        set refsum $idlereap(itemsum)
        if {$idlereap(hero,level) > 0} {
                set refsum [+ $refsum [* [/ $refsum 100] [+ 2 $idlereap(hero,level)]]]
        }

        foreach creep $creeps {
                switch -- $creep {
                        Bush     { if {$idlereap(level) >=  11} { continue } else { set recovery 1 }}
                        Locust   { if {$idlereap(level) >=  15} { continue } else { set recovery 1 }}
                        Spider   { if {$idlereap(level) >=  20} { continue } else { set recovery 2 }}
                        Goblin   { if {$idlereap(level) >=  30} { continue } else { set recovery 2 }}
                        Lich     { if {$idlereap(level) >=  40} { continue } else { set recovery 2 }}
                        Skeleton { if {$idlereap(level) >=  50} { continue } else { set recovery 2 }}
                        Ghost    { if {$idlereap(level) >=  60} { continue } else { set recovery 2 }}
                        Shadow   { if {$idlereap(level) >=  70} { continue } else { set recovery 2 }}
                        Troll    { if {$idlereap(level) >=  80} { continue } else { set recovery 3 }}
                        Cyclop   { if {$idlereap(level) >=  90} { continue } else { set recovery 3 }}
                        Mutant   { if {$idlereap(level) >=  100} { continue } else { set recovery 3 }}
                        Monkey   { if {$idlereap(level) >=  110} { continue } else { set recovery 3 }}
                        Phoenix  { if {$idlereap(level) >=  120} { continue } else { set recovery 4 }}
                        Minotaur { if {$idlereap(level) >=  130} { continue } else { set recovery 4 }}
                }
                if {[info exists idlereap(stats,$creep,payout)] && [info exists idlereap(stats,$creep)]} {
                        set avgroll [/ [+ {*}$idlereap(stats,$creep)] [double [llength $idlereap(stats,$creep)]]]
                        if {$avgroll > [/ $refsum 2]} { continue }

                        set payavg [/ [+ {*}$idlereap(stats,$creep,payout)] [double [llength $idlereap(stats,$creep,payout)]]]
			if {$recovery != 0} {
	                        set paymax [/ [double $payavg] [* $idlereap(level) $recovery]]
			} else {
				set paymax $payavg
			}
                        if {$paymax > $payout} {
                                set target $creep
                                set payout $payavg
                        }
                }
		set maxsize 20
		if {[info exists idlereap(stats,$creep)] && [llength $idlereap(stats,$creep)] > $maxsize} {
			set idlereap(stats,$creep) [lrange $idlereap(stats,$creep) [- [llength $idlereap(stats,$creep)] $maxsize] e]

		}
		if {[info exists idlereap(stats,$creep,payout)] && [llength $idlereap(stats,$creep,payout)] > $maxsize} {
			set idlereap(stats,$creep,payout) [lrange $idlereap(stats,$creep,payout) [- [llength $idlereap(stats,$creep,payout)] $maxsize] e]
		}
        }
	return $target
}

bind dcc n dosend idlereap:dcc:send
proc idlereap:dcc:send {from idx args} {
	set args [lindex $args 0]
	idlereap:send $args
	putallbots "send $args"
}

bind dcc n dobank idlereap:dcc:bank
proc idlereap:dcc:bank {from idx args} {
	idlereap:send BANK
	putallbots "bank"
}

bind dcc n doupdate idlereap:dcc:doupdate
proc idlereap:dcc:doupdate {from idx args} {
	idlereap:send RAWSTATS2
	putallbots "update"
}

bind dcc n rehashall idlereap:dcc:rehashall
proc idlereap:dcc:rehashall {from idx args} {
	putallbots "rehash"
	rehash
}

bind dcc - bestbet idlereap:dcc:bestbet
proc idlereap:dcc:bestbet {from idx args} {
	idlereap:dobet 0
}

bind dcc - bestattack idlereap:dcc:bestattack
proc idlereap:dcc:bestattack {from idx args} {
	set creeps "Bush Locust Spider Goblin Lich Skeleton Ghost Shadow Troll Cyclop Mutant Monkey Phoenix Minotaur Beholder"
	putlog [idlereap:creepfinder $creeps]
}

bind dcc - bestslay idlereap:dcc:bestslay
proc idlereap:dcc:bestslay {from idx args} {
	set creeps "Medusa Centaur Mammoth Vampire Dragon Sphinx Hippogriff"
	putlog [idlereap:creepfinder $creeps]
}

bind bot - rehash idlereap:bot
bind bot - login idlereap:bot
bind bot - update idlereap:bot
bind bot - bank idlereap:bot
bind bot - send idlereap:bot

proc idlereap:bot {from cmd args} {
	set args [lindex $args 0]
	switch -- $cmd {
		"send" {
			idlereap:send $args
		}
		"rehash" {
			dccbroadcast "Rehashing..."
			rehash
		}
		"login" {
			idlereap:login
		}
		"update" {
			idlereap:send RAWSTATS2
			idlereap:gettournamenttimers
		}
		"bank" {
			idlereap:send BANK
		}
	}
}

proc idlereap:login {} {
	global idlereap
	idlereap:send "LOGIN $idlereap(user) $idlereap(pass)"
}

proc idlereap:align {{align ""}} {
	global idlereap
	if {$align == ""} { set align $idlereap(defaultalign) }
	if {$idlereap(align) != $align} {
		idlereap:send "ALIGN $align"
		set idlereap(align) $align
	}
}

proc idlereap:send {message} {
	global idlereap
	dccbroadcast "Sending $message"
	putmsg [hand2nick $idlereap(bot)] $message
}

proc dotimer {time command} {
	foreach utime [utimers] {
		if {[lindex $utime 1] == $command} {
			killutimer [lindex $utime end]
		}
	}
	return [utimer $time $command]
}

proc str2int {data} {
	set tmp ""
	for {set i 0} {$i < [string length $data]} { incr i } {
		if {[regexp -nocase "\[0-9\]" [string index $data $i] match]} {
			set tmp "$tmp$match"
		}
	}
	return $tmp
}