Untitled

objectdef AuctionHouse
{
	variable string QueryText
	
	method Query(string Name, int Page=0)
	{
		This:Reset
		QueryText:Set[${Name}]
		WoWScript QueryAuctionItems(\"${QueryText}\",\"\",\"\",nil,nil,nil,${Page},nil,nil);
	}

	member Count()
	{
		return ${WoWScript["GetNumAuctionItems(\"list\")",2]}
	}

	member Pages()
	{
		return ${Math.Calc[${This.Count} / 50].Int}
	}

	member NaturalPrice(int Price)
	{
		variable int gold = 0
		variable int silver = 0
		variable int copper = 0
		
		gold:Set[${Math.Calc[${Price} / 10000].Int}]
		silver:Set[${Math.Calc[(${Price} / 100) % 100].Int}]
		copper:Set[${Math.Calc[${Price} % 100].Int}]

		return "${gold}g ${silver}s ${copper}c"
	}
	
	;
	;
	;
	;
	
	method PlaceBid(int Index, int Bid)
	{
		WoWScript "PlaceAuctionBid(\"list\",${Index},${Bid})"
	}
		
	method BuyOut(int Index)
	{
		This:PlaceBid[${Index},${This.BuyoutPrice[${Index}]}]
		
	}
	
	;
	;
	;
	;
	
	member AuctionItemCount()
	{
		return "${WoWScript[GetAuctionSellItemInfo(),3]}"
	}
	
	;
	;
	;
	;

	member TimeLeft(int Index)
	{
		return ${WoWScript["GetAuctionTimeLeft(\"list\",${Index})",1]}
	}
	
	member HighBidder(int Index)
	{
		return "${WoWScript["GetAuctionItemInfo(\"list\",${Index})",11].Equal[1]}"
	}

	member ItemName(int Index)
	{
		return "${WoWScript["GetAuctionItemInfo(\"list\",${Index})",1]}"
	}
	
	member Owner(int Index)
	{
		return "${WoWScript["GetAuctionItemInfo(\"list\",${Index})",12]}"
	}
	
	member StackCount(int Index)
	{
		return ${WoWScript["GetAuctionItemInfo(\"list\",${Index})",3]}
	}
	
	;
	;
	;
	;
	
	member MinBid(int Index)
	{
		return ${Math.Calc[${WoWScript["GetAuctionItemInfo(\"list\",${Index})",7]}].Int}
	}

	member MinIncrement(int Index)
	{
		return ${Math.Calc[${WoWScript["GetAuctionItemInfo(\"list\",${Index})",8]}].Int}
	}
	
	member CurrentBid(int Index)
	{
		return ${Math.Calc[${WoWScript["GetAuctionItemInfo(\"list\",${Index})",10]}].Int}
	}
	
	member CurrentPrice(int Index)
	{
		variable int price
		if ${This.CurrentBid[${Index}]} == 0
		{
			price:Set[${This.MinBid[${Index}]}]
		}
		else
		{
			price:Set[${This.CurrentBid[${Index}]}]
		}
		if ${This.StackCount[${Index}]} > 1
		{
			price:Set[${price} / ${This.StackCount[${Index}]}]
		}
		
		if ${This.CurrentBid[${Index}]} != 0
		{
			price:Inc[${This.MinIncrement[${Index}]}]
		}
		
		return ${price}
	}
	
	member BuyoutPrice(int Index)
	{
		;gold = / 10000
		return ${Math.Calc[${WoWScript["GetAuctionItemInfo(\"list\",${Index})",9]}].Int}
	}
	
	;
	;
	;
	;
	
	method Reset()
	{
		QueryText:Set[""]
		Count:Set[0]
		Pages:Set[0]
	}
	
	member Busy()
	{
		if ${WoWScript["CanSendAuctionQuery()",1]} == 1
		{
			return FALSE
		}
		return TRUE
	}
	
	
}

function WalkTo(float X, float Y)
{
	face ${X} ${Y}
	wait 30 !${ISXWoW.Facing}
	if ${Math.Distance[${Me.X},${Me.Y},${X},${Y}]} > 2
	{
		wowpress -hold moveforward
		do
		{
			waitframe
			if ${Movement.Moving} == 0
			{
				wowpress -hold moveforward
			}
		}
		while ${Math.Distance[${Me.X},${Me.Y},${X},${Y}]} > 2
		wowpress -release moveforward
	}
}

function FetchMail()
{
	variable float X
	variable float Y

	if ${Object["Mailbox"].Distance} > 5
	{
		X:Set[-4937]
		Y:Set[-934]
		call WalkTo ${X} ${Y}
		call WalkTo ${Object["Mailbox"].X} ${Object["Mailbox"].Y}
	}
	
	if ${Object["Mailbox"].Distance} < 5
	{
		Object["Mailbox"]:Use
		wait 100 ${WoWScript[InboxFrame:IsShown()].Equal[1]}
		WoWScript "CheckInbox()"
		wait 30
		while ${WoWScript[GetInboxNumItems()]} > 0
		{
			WoWScript Postal_OpenAll:OpenAll()
			wait 300
		}
		WoWConsole reloadui
		wait 200
	}
}	

function OpenAuctionHouse()
{
	variable float X
	variable float Y

	if ${Unit["Auctioneer Redmuse"].Distance} > 5
	{
		X:Set[-4937]
		Y:Set[-934]
		call WalkTo ${X} ${Y}
		call WalkTo ${Unit["Auctioneer Redmuse"].X} ${Unit["Auctioneer Redmuse"].Y}
	}
	
	if ${Unit["Auctioneer Redmuse"].Distance} < 5
	{
		Unit["Auctioneer Redmuse"]:Use
		wait 100 ${WoWScript[AuctionFrameBrowse:IsShown()].Equal[1]}
		wait 20
		wait 300 !${ah.Busy}
	}
}

function Log(string Text)
{
	UIElement[Status@monopoly]:Echo["${Time.Time24} ${Text}"]
}

function PlaceAuctionItem(string ItemName)
{
	variable int BagIndex = 0
	variable int SlotIndex = 0
	variable int FreeSlots = 0
	
	if !${Item[${ItemName}](exists)}
	{
		return
	}
	
	do
	{
		FreeSlots:Inc[${Me.Bag[${BagIndex}].EmptySlots}]
	}
	while ${Me.Bag[${BagIndex:Inc}](exists)}
	
	BagIndex:Set[0]
	do
	{
		SlotIndex:Set[1]
		do
		{
			if ${Me.Bag[${BagIndex}].Item[${SlotIndex}].Name(exists)} && ${Me.Bag[${BagIndex}].Item[${SlotIndex}].Name.Equal[${ItemName}]} && ${FreeSlots} > 5
			{
				Me.Bag[${BagIndex}].Item[${SlotIndex}]:PickUp
				wait 5
				WoWScript ClickAuctionSellItemButton()
				return
			}
		}
		while ${SlotIndex:Inc} <= ${Me.Bag[${BagIndex}].Slots}
	}
	while ${Me.Bag[${BagIndex:Inc}](exists)} && ${FreeSlots} > 5
	
	
}

function main()
{
	variable string ConfigDir = "c:/program files/innerspace/scripts/monopoly/"
	variable string ConfigFile = "monopoly.xml"
	variable settingsetref AuctionItems
	variable settingsetref AuctionItem
	variable iterator AuctionItemIterator
	variable AuctionHouse ah 
	variable int ItemCount = 0
	variable int Page = 0
	variable int Index = 0
	variable int AuctionPrice = 0
	variable int SellPrice = 0
	variable int BuyoutPrice = 0
	variable int BuyPrice = 0
	variable bool Quit = FALSE
	
	echo "Monopoly starting."
	
	LavishSettings:Clear
	LavishSettings:AddSet["monopoly"]
	LavishSettings["monopoly"]:Import[${ConfigDir}${ConfigFile}]
	AuctionItems:Set[${LavishSettings["monopoly"].FindSet["AuctionItems"]}]

	UI -load "c:/program files/innerspace/scripts/monopoly/gui.xml"

	do
	{
		if ${WoWScript[HasNewMail()].Equal[1]}
		{
			call Log "Fetching mail"
			call FetchMail
		}
		
		if !${WoWScript[AuctionFrameBrowse:IsShown()].Equal[1]}
		{
			call Log "Opening auction house"
			call OpenAuctionHouse
		}
		
		AuctionItems:GetSetIterator[AuctionItemIterator]
		if ${AuctionItemIterator:First(exists)} 
		{
			do
			{
				call Log "Scanning for ${AuctionItemIterator.Key}"
				AuctionItem:Set[${AuctionItems.FindSet[${AuctionItemIterator.Key}]}]
				AuctionPrice:Set[${AuctionItem.FindSetting["Sell Price"].Int}]
				BuyoutPrice:Set[${AuctionItem.FindSetting["Buyout Price"].Int}]
				BuyPrice:Set[${AuctionItem.FindSetting["Buyout Price"].Int}]
				
				ah:Query[${AuctionItemIterator.Key}]
				wait 300 !${ah.Busy}
				ItemCount:Set[${ah.Count}]
				if ${ah.Count}
				{
					Page:Set[0]
					do
					{
						Index:Set[1]
						ah:Query[${AuctionItemIterator.Key},${Page}]
						wait 300 !${ah.Busy}

						do
						{
							if !${ah.Owner[${Index}].Equal[${Me.Name}]} && ${ah.ItemName[${Index}].Equal[${AuctionItemIterator.Key}]} && ${ah.CurrentPrice[${Index}]} < ${BuyPrice} && !${ah.HighBidder[${Index}]} && ${Math.Calc[${Me.Coinage}/10000]} > 30
							{
								if ${ah.BuyoutPrice[${Index}]} < ${AuctionPrice} && ${ah.BuyoutPrice[${Index}]} != 0
								{
									call Log "Buying out ${AuctionItemIterator.Key} from ${ah.Owner[${Index}]}, price ${ah.NaturalPrice[${Math.Calc[${ah.CurrentPrice[${Index}]} * ${ah.StackCount[${Index}]}]}]}"
									ah:BuyOut[${Index}]
								}
								else
								{
									call Log "Placing bid on ${AuctionItemIterator.Key} from ${ah.Owner[${Index}]}, price ${ah.NaturalPrice[${Math.Calc[${ah.CurrentPrice[${Index}]} * ${ah.StackCount[${Index}]}]}]}"
									ah:PlaceBid[${Index},${Math.Calc[${ah.CurrentPrice[${Index}]} * ${ah.StackCount[${Index}]}]}]
								}
								wait 10
							}
						}
						while !${ah.Owner[${Index:Inc}].Equal["NULL"]}
					}
					while ${Page:Inc} <= ${ah.Pages}
				}
				
				;
				; Sell here
				;
				if ${Item[${AuctionItemIterator.Key}](exists)} && ${ItemCount} <= 8
				{
					do
					{
						call PlaceAuctionItem "${AuctionItemIterator.Key}"
						wait 30
						SellPrice:Set[${Math.Calc[${AuctionPrice} * ${ah.AuctionItemCount}]}]
						call Log "Creating auction ${AuctionItemIterator.Key} x ${ah.AuctionItemCount} for ${ah.NaturalPrice[${SellPrice}]}"
						WoWScript StartAuction(${SellPrice},${BuyoutPrice},24*60)
						wait 20
					}
					while ${Math.Calc[${Me.Coinage}/10000]} > 1 && ${Item[${AuctionItemIterator.Key}](exists)} 
				}
			}
			while ${AuctionItemIterator:Next(exists)}
		}
		
		ISXWoW:ResetIdle
		call Log "Sleeping..."
		wait 1200
	} 
	while !${Quit}
}

function atexit()
{
	UI -unload "c:/program files/innerspace/scripts/monopoly/gui.xml"
	echo "Monopoly exiting"
}