Project BabBot

[tanis]

Project BabBot
==============

.Introduction
-------------

It looks like with the latest patch, a lot of bots have been taken offline due to legal problems with their authors. If you've been following the cases, all of them were related to money being made out of such programs. This made me think about giving a kick to this whole affair of closed source bots and get something going within the community to have a working bot that is made by those who use it. Some months ago, me and a friend, decided to write our own bot in C#, mainly as a test of what could be done and in part because of the lack of features of other bots available for free. The idea, now, would be to let other developers jump on the boat and give them full access to the source code and start releasing it to the community in a completely free form.

.Management
-----------

Management of the project will be on a controlled open source (pass me the term), meaning that sources will be held on a private repository and access to them will be given to developers willing to join the project. The only reason to this is to prevent the source code to leak easily to Blizzard or any of their affiliates. This should reduce the chances of having them on our tail from day one.
All of the releases will be free, with no payments, donations or anything going on. We do not want to offer Blizzard any hook to shut us down.
Me and the co-author of the bot will maintain the role of guiding the project throughout its evolution and we will of course keep working on the code along with the other developers involved. But, as stated before, this will be a community project and thus it will be the community itself to suggest us where to go.

.Current Status
---------------

At the time I'm writing this, the bot is working with version 3.0.9 of the client and I have to test it with 3.1.0
There is a basic framework that lets the bot interact with the client without any code injection, there's support for external C# scripts that can be loaded at runtime to provide all the logic of the bot that can thus be further enhanced by anyone in the community who can code a few lines of C#.
Basic movement, anti-stuck and combat functions are already in.
Some parts still need to be completed, like the waypoint navigation system, key bindings, a better timing function.. there's a lot to do and a lot to enhance to have a complete bot, but I'm pretty sure that if there's enough interest and enough people willing to contribute we could pull this off in a very short time.

.So what are you looking for?
-----------------------------

I'm looking for replies to this post to evaluate if this project can be shared by some or most of the community or if it's just like shooting into a pool of water. If there's enough interest, I'll get this rolling. At the same time, I'm more than willing to listen to different proposal, if any. The goal is still the same: having a free working bot to which different people can contribute to further enhance it.
On a side note, it would have been better if Panda opened his zolobot to the community as it would have been a far better starting point. But his decision is his only. So.. here we are.

[bobbysing]

The only reason to this is to prevent the source code to leak easily to Blizzard or any of their affiliates. This should reduce the chances of having them on our tail from day one.

That's absurd, either you do it completely open source or not. With or without the sourcecode, it's no problem to catch it.

On a side note, it would have been better if Panda opened his zolobot to the community as it would have been a far better starting point. But his decision is his only. So.. here we are.

Those three sentences kill all the motivation you (may have) built up before.


I wish you good luck with your project!

[j1gs4w]

tttttttttttttaaaaaaaaaaaaaaaannnnnnnnnnniiiiiiiiiiiiisssssssssss...... ........................are you from Blizzard?

[galpha]

It's an awsome idea, but as bobby said, it needs to be completly open source or else it's the same principle as Zolo / Glider, which means only a small portion (the developpers) have access to the source, which means it's not open source...

[MyZt]

Isn't "tanis" the name of an area in World of Warcraft?

[furious]

Isn't "tanis" the name of an area in World of Warcraft?

No it's called Tanaris It's the area that has the city gadgetzan in it same with the caverns of time

[tanis]

That's absurd, either you do it completely open source or not. With or without the sourcecode, it's no problem to catch it.


Those three sentences kill all the motivation you (may have) built up before.


I wish you good luck with your project!

I guess that you know just as well as me that an open source bot is going to be investigated, eviscerated and put into the detection engine of warden in no time. Although I like the ideal o having a source code that acts in a "viral" way, meaning that even if Blizzard comes at us and shuts us down, someone else will continue with a spinoff, this would just make things easier for Blizzard to get on our tail.

And the point of having the source code in the hands of non-developers.. well.. what's the point? I mean.. if you're a developer and you want to contribute to the project you will have access to the source code just like every other developer. Giving the source code to someone who couldn't even read and understand it doesn't make sense. My aim is at having a bot that doesn't cost a thing and that more and more developers can contribute to as time goes by. That should be the main focus because it would allow the whole community to benefit from this.

I'm not stubborn. Speak your reasons and I might agree with you at opening the source code to anybody, but prove me how it is worth it.


And that thing about zolo is just a matter of fact. That bot has a lot of features that this one lacks, so it would be a better starting point just like any commercial bot could be. That doesn't mean we can't get it to have as many features as zolo in a short time, given there's enough interest and enough developers working on it.

[bobbysing]

I guess that you know just as well as me that an open source bot is going to be investigated, eviscerated and put into the detection engine of warden in no time.

It doesn't matter if the source is open or not, they can detect such an application anyways. And they will, as soon as it's used by a relatively large amount of people.

[galpha]

Tanis, the point is, you're either going throught the same path as Glider or Zolo (only the developper will have access to source, which means it's NOT open source) or you open it completly under an open source license and not risk any problems.

Notice that all the WoW Emulator's that are STILL alive are all Open Source because blizzard can't come back to them.

[tanis]

Don't get me wrong. I've been involved in plenty of open source projects in the past and I love the philosophy. And the real argument here shouldn't be "shall we go open source or not". I am eager at going fully open source as long as we do not end up in troubles because, after all, we are coding a bot that interacts with a game in a way that is against the terms of service of the game itself and that is in parts derived through reverse engineering of the client itself (which is illegal in most countries).

That said, let's go completely open source if that means that we get more developers joining forces. That's the main focus. To get as many talented developers together working on a featurful bot that doesn't cost anything. This should be the aim

[Livefire]

i think this is a great idea, i think you should sign me up to beta test it, work on combat scripts and any and all other testing. i could possibly implement healbot, autobuffing and other nifty addons. with acess to framework. wooot opensource

[VisualPerfection]

OpenSource lets people work of a base and create undetected bots... Detecting anything public isn't very hard.

[morgalis]

To be honest Tanis has right about not going full opensource , it has no sence to give an source code to people that cant understand it , maybe just some coders doing the core in private.

Offsets need to be in an file , so even after some troubles people could contineu using it just by adding them , except big changements ofcourse, that need to be fixed in the core.

Implementing Spidermonkey like zolo did is positive and will make the community bigger , cos more people can script then code.

Ofcourse zolo is an great bot but isxwow is the best i ever saw. Pathing , talents , items ,bg, routines and much more.... Why , cos it had an javascript like engine. Much people where contributing to it.

This is the script of a FULL working auctionhouse bot , i made tons of gold with it. And alot of fun tweaking it.

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
		echo ${Math.Calc[${WoWScript["GetAuctionItemInfo(\"list\",${Index})",9]}].Int}
		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
		}
	}
}	

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 Page = 0
	variable int Index = 0
	variable int AuctionPrice = 0
	variable int SellPrice = 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[AuctionFrame: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}]
				
				ah:Query[${AuctionItemIterator.Key}]
				wait 300 !${ah.Busy}
				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["Ritur"]} && !${ah.Owner[${Index}].Equal["Isje"]} && !${ah.Owner[${Index}].Equal[${Me.Name}]} && ${ah.ItemName[${Index}].Equal[${AuctionItemIterator.Key}]} && ${ah.CurrentPrice[${Index}]} < ${AuctionPrice} && !${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)} && ${Math.Calc[${Me.Coinage}/10000]} > 1
				{
					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},${SellPrice},24*60)
				}
			}
			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"
}

Auctionhouse settings in xml

- <InnerSpaceSettings>
- <Set Name="AuctionItems">
- <Set Name="Primal Water">
  <Setting Name="Sell price">420000</Setting> 
  </Set>
- <Set Name="Primal Life">
  <Setting Name="Sell price">150000</Setting> 
  </Set>
- <Set Name="Primal Air">
  <Setting Name="Sell price">300000</Setting> 
  </Set>
- <Set Name="Primal Fire">
  <Setting Name="Sell price">400000</Setting> 
  </Set>
- <Set Name="Primal Mana">
  <Setting Name="Sell price">330000</Setting> 
  </Set>
- <Set Name="Blood Garnet">
  <Setting Name="Sell price">40000</Setting> 
  </Set>
- <Set Name="Shadow Draenite">
  <Setting Name="Sell price">40000</Setting> 
  </Set>
- <Set Name="Netherweb Spider Silk">
  <Setting Name="Sell price">40000</Setting> 
  </Set>
- <Set Name="Golden Draenite">
  <Setting Name="Sell price">40000</Setting> 
  </Set>
- <Set Name="Deep Peridot">
  <Setting Name="Sell price">40000</Setting> 
  </Set>
- <Set Name="Living Ruby">
  <Setting Name="Sell price">450000</Setting> 
  </Set>
  </Set>
  </InnerSpaceSettings>

As community this will creat alot of fun .... go for it...

[tanis]

Quick update: I'm finishing setting up the repository and some tools to manage the project. I'll get in touch with those interested in contributing soon.

[tanis]

The project is set up at SourceForge. As it is Open Source, everyone has anonymous access to the SVN to grab the source code.

If you're interested in testing, just register on the forums at the project's page and let me know that you're interested in getting in the "test" team so that we can come up with a list of people to send compiled binaries to when we need to test some features.

If you are interested in helping with the development, please register at Sourceforge and let me know either there or through a PM here your username and specialization (in case we haven't talked already) and I'll make sure to add you to the developers list on SourceForge.

Here's the project URL: http://sourceforge.net/projects/babbot/