Blizzhackers

Hello I play a game called Flash flash revolution which can be found at flashflashrevolution.com. I usually play this game on a standalone flash player and was wondering how I would go about creating a bot using AutoIt to automatically hit the arrows I need it to hit in order to perfect any song. If there's no way to do this using a standalone player how would I go about doing it while playing within the browser? Thank you.

I want to make a Diablo 3 bot for Royal Crypts urns/coffins farming. I've seen some bots, but they're slow and stupid and I have my char tweaked for botting (265% gf and 50 yards gold radius pickup, which equal to a whole screen pickup @ 1920x1200 resolution). I would like to make a bot which would be left/right clicking and using spells (1-4 on keyboard) and just sweeping the area in 30-60 secs, as I do it in about 1-1.5 min, and I'm not the fastest guy around, and certainly cant compare to a scripted bot.

Any hints or tutorials would be really helpful. (On a side note, I'm a programmer my self, just don't know the syntax or semantics of AutoIt)

Hello all past and future posters!

I just wanted to let everyone know that I was banned back on: Mon Apr 20, 2009 5:37 pm.

I was unbanned a couple of hours ago (thank you, lord2800)!

You tag won't change though. If DM logs into the ACP BH is down again :p

I like it! I am the only "banned" user who can post!

Nope

You are polluting my beautiful thread.

Hello.

NOTE:
This entire point of this post is for educational purposes only; not to do anything malicious.
Please do note: Using bots or hacks or external 3rd party programs (even AutoIt3) is against the ToS / EULA on Diablo II / Battle.net.

Today, we're going to create a genetic algorithm with AutoIt3 for the sole purpose of logging onto a character with Diablo II.

We're going to use three include files with our script. We'll call our script "AI.au3."


We're going to structure this after a procedural C program.


Then we're going to sit down and design this program instead of randomly copying and pasting stuff that we found on an internet forum on the internet.
Perhaps I'll post the source code (script code?) at the very end, just so you can copy/paste it and run it/use it/whatever it is you choose to do.

Let's first address the problems and outline our basic criteria of the problem. We need to ask ourselves a lot of questions and provide ourselves with a lot of answers.

Here's a small criteria list outlining what we desire this particular *.au3 script to do:

• Select a desired character by referencing a 'character slot' (1-8) with random pathing of N number of moves at maximum (no minimum)

Sounds like a tall order to be made! Let's get to it, shall we?

We're going to need some basic data to start off with. What will we need inside of the main() function?

• Starting character position
• Target character to stop on (referenced by slot 1-8)
• An array to hold all the individual moves to be made

These sound like simple variables and not functions. Let's fill in the gaps and see what we have so far (because we're kids from 2000-2005 and demand instant gratification):


This looks fairly simple so far. Let's add some more complexity, shall we? We'll let our imagination fly initially.


Now we need to describe what generateRandomPath() should actually do. I think we already did that, though. I'll do it again for completeness.

• Return an array of moves to make at random (the last Nth moves should place you on the target slot)

Okay. What now? We're in a bind! We need to think about how generateRandomPath() will generate random moves.
First: We'll need an array. That sounds in order. We'll also need to loop through this array, assigning each element a value that represents a move-to-make. Then return the array to the caller.

The data that the array should hold should be some form of encoded data that represents moves. We can use a global enumeration data-type to represent the individual moves.

Let's get crackin'!


Great. We have an array of Nth elements. We loop through our entire array. We return our array. Now all we need to do is modify the contents of the array.

We could just return a random value from: $MOVE_UP to $MOVE_RIGHT, but that would be boring! Watch:


That's a solution, but it's too low quality for myself. I prefer to write things that actually work. I don't like writing dirty things anymore than I like being dirty!

We should probably write another function to deal with generating random moves. I'll call it: generateRandomMove()! It only needs to know our current slot.
This function will return a random and legal (sanitized data) move to the caller. This in turn will populate the array of random moves.



That's better. Now we're tasked with describing what generateRandomMove($curSlot) should do. How do we prevent invalid (illegal) moves?
We can review the data we're working with. This is kind of a quirky thing to do, but hey! It works. It's math.

We have 1-8 character slots:


We can clearly see that characters on the left side of the wall are all odd numbers. Those on the opposing side are even numbers.
We can then say: For if a number is odd: It can not travel left anymore. For if a number is even: It cannot travel right anymore.
We must also declare that: For if a number is on the location of 2 or less: It cannot travel up. For if a number is 7 or more: It cannot travel down.

These rules can be cut up into functions themselves! We will call these: Helper functions. We can describe a function per rule.


Now we have a quick way of deciding what is or is not a valid move. Let's re-examine our function body:


Not too exciting (yet)... We should perhaps use an array to hold all valid moves, then select one randomly and return it. Sounds like a good time for yet, another function!
What should we name this function? I'm thinking: getValidMoves()! Sounds very explicit and unambiguous.

It definitely needs to know our current standing position, so we'll pass it that data. It doesn't look like we'll need anything else.


We have a clear-cut objective within this function. It needs to return all possible moves we can take from our current position and return this array of data to the caller.


Now we can see a little better of how generateRandomMove() might look:


This is excellent! So to fall back on some basic math and diagram (because everyone loves diagrams) to help explain this.

If we're currently on slot #1:


Our valid options are only: $MOVE_RIGHT and $MOVE_DOWN (slot #2 and slot #3 respectively).
The array will be populated like so: $validMoves = [ $MOVE_DOWN, $MOVE_RIGHT ]

What else is left to do in: generateRandomMove() you may wonder? Of course! We need to randomly select from the array and return it.


Then: We need to update our player's current position in "Bob's" brain (I've decided to refer to this as a human named "Bob").


What sounds like a good function name? I'll go with... updateCurSlotPos()! Seems logical. We will need to pass it the last made move ($path[$n]) and our current slot position:


Oh wait! Wrong one. We need to create a helper function named: updateCurSlotPos() first, huh?


This about wraps everything up! We've a complete script that generates a random path starting from Nth position and stops at... Oh! No! It doesn't stop on the desired slot.

We merely need to append to the array that holds our path and redirect it to our desired target slot, then return the array!
Let's re-cap on what we have in total so far (from top to bottom):


To find the shortest path to the target slot is fairly simple. We need to know how many elements we need to add to the array first (we also need to know if we're already on it, by chance).


This will return the distance (in terms of "moves" needed to be made; which is perfect) between your current slot and the target slot.

Ready for another diagram? Nah! You can scroll up. If we're on slot #1 at the end and we're trying to get to slot #8: We need to make: 4 moves (RIGHT, DOWN, DOWN, DOWN; or any variation).

This feels so straight-forward: We only need to loop N amount of times and call on _AddArray() per random move towards the target slot.


Add a dash of randomization to it:


... Voila! We're done.

The program now looks like this (the entire thing):


Of course: This is only the portion of a script that would be utilized after you've successfully entered the character selection screen.

This could be used on Single Player just as well as it could be used on Open Battle.net or even Battle.net itself.

This is a sample of the output with 20 maxMoves being made (starting position: slot #1; ending positon: slot #8):

This project was started by: WiseWolf.
His thread: WiseWolf's account refresher.

- main.au3


- D2Functions.au3


This another prime example of how even a simple language such as AutoIt3 can be bent into something useful.