I’ve been getting into these indie games lately, and I must say they’re quite fun to play – and on top of that, you can quit after 15 minutes. That is amazing. One of these games I’ve been playing is called Terraria. It’s been topping the Steam listings for a week or three now, and a few of my friends told me to get it, so I decided it may be worth the 10 quid, and gave it a go.

Now, the problem with these games is that I don’t really like playing solo. When I play these games, I love to do multiplayer with some mates, and have a go at things. Problem is you need a server to do so, because Terraria doesn’t support peer to peer, which is a good thing! However, when the developers launched with that idea, they didn’t figure out they may want to provide server software so third party hosters could host Terraria for us to play on! Instead, you have to run the game twice, sort your port forwarding, or use the ever-so-tedious Hamachi. You can’t run the server on a serverbox, because the game client requires Direct3D, direct 3D requires a graphics card, and server boxes do not have graphics cards. On top of that you need a whole lot of XNA and Visual Studio crap. Luckily for me, I already had those, so it wasn’t too much of a hassle.

There is a bright side to all this misery though; Terraria is written in C# .NET, and exposes its entire API. I think. Well, most of it anyway. That’s why I’ll be focusing the coming week on developing a server client for this which relies solely on the Terraria assembly, and can actually run on my server box. I’ll be posting the progress on here, and I’ll figure out what I do with the release – it may be open source, but I’m not sure what the Terraria devs think about that, so I guess I’ll contact them first. Hey, at least I’m not decompiling their assemblies and ripping their code to make a server (which required Direct3D still, so it still sucked) like the guy on their forums, who got banned by the way.

I’ve given it a spin for an hour or two earlier today, and turns out I can already have the client find the server across the internet, so I don’t think the rest will be a problem. What I do find worrying is that you can apparently connect to any TcpClient across the net with Terraria, and who knows what they stream at you through it? I don’t. If Terraria is to grow, they will most certainly need to step up their security, otherwise it’s going to be really easy for malicious developers to pull tricks with those servers.

See you in a few days when the first few screenshots, and perhaps a few lines of code can be spilled. Who knows!

ps. I’m going to have a good laugh if I beat the Terraria devs to making a properly working server package. Really.
ps 2. Yes, the entire thing will be freeware. Period. I’m not going to charge for something which compliments a successful game like this. Don’t worry!

The attached IDA 32-bit database features:

• Rebased to 0×1000 for relative address space.
• Renamed all engine functions and LUA’s.
• Generic awesomeness.

Enjoy reversing and updating!

Download (21.99 MB) [*.r00 (WinRAR)]

Here’s a quick property to cycle through the selected process’ modules, and pick the one we’re after:

/// <summary>
        /// Gets or sets the process.
        /// </summary>
        /// <value>The process.</value>
        /// 14/10/2010 16:52
        public static Process Process { get; set; }

        /// <summary>
        /// Gets the base address of the World of Warcraft application.
        /// </summary>
        /// <value>The [IntPtr] BaseAddress.</value>
        /// 14/10/2010 16:55
        public static IntPtr BaseAddress
        {
            get
            {
                var ret = new IntPtr();
                var modules = Process.Modules;

                for (var i=0; i<modules.Count;i++)
                {
                    if (modules[i].ModuleName.Contains("Wow")) ret = modules[i].BaseAddress;
                }

                return ret;
            }
        }

Obviously you could also fetch Process.MainModule.BaseAddress, but again, I’d rather keep the loop – assuming there is no second module with Wow in it – this code will keep working even if at some point Wow isn’t its own main module. (Which would be odd, but hey)

Well, it’s been a while, but I think I have something big to announce here today. Pretty much, everyone’s heard about cloud computing by now, and if you haven’t, you’re probably either above the age of 50, or you have been living under a rock for the past few years. Can’t miss on that one.

Now, cloud computing is all fine and dandy, and the idea is absolutely brilliant, but we’re really, really far away from a proper implementation of it – that is, where it can actually replace your hard drive, which is the way Google presented the idea as. Now, we may be far away from that, but we’re not far away from applying the basic principle of cloud computing on a somewhat smaller scale.

Just count the amount of “small programs” you have on your computer, and if you’re someone who does more on his computer than just hanging around on MSN and playing a game every now and then, they can sum up to quite a few. All of these applications aren’t too large, something like 500KB up to 5MB, right? However, the developers of these applications often do still push updates for them.  Keeping them up to date and even organised can become quite a hectic and tedious process, the more of them you get.

This is the reason Symphonix was designed. It was designed to launch small (1KB – 20MB) applications entirely from the internet. Of course you do need to download them, but Symphonix takes care of all this for you. This way, all applications are at the developer’s ‘place’, and the customer can launch the most recent version whenever they need it, while their configuration files and preferences are stored by Symphonix, so the applications still adapt to their preferences.

Right now I can’t tell you too much about it, but what I can in fact tell is that Symphonix is compatible with over 99% of the world’s regular, http websites. Meaning you don’t have to have a special web-server of any sort, your current web host will most likely be able to host a program for Symphonix to run, in the near future.

And no, it’s not Blizzard’s. This is a custom, yet fully supporting Battle.net Authenticator to run on your PC.

Currently, this authenticator features the following:

• Full support for Battle.net accounts.
• Support for both EU and US.
• It’s always synced perfectly.

So, you don’t have to buy an authenticator, nor do you have to have your iPhone handy at all times to login to your account. You can now do all that, easily, and securely using this very authenticator. And of course, credtis to Kynox for his lib!

Oh, and for those of you who don’t know how the fuck to read a NFO:

http://pastebin.com/haaWRvzi

Download v1.0 – 201007061809 – tested and verified

Make sure to read the NFO, and extract with WinRAR. Enjoy!

Originally posted by PiroX:

New Detection Information:
Very important! CTM seems to be unsafe at the moment. Disable CTM (Click to move) in bot under Main

Detection Status
– Safe with memory reading (pvpTool without Mem options)
– CTM seems to be unsafe
– MemLooting seems to be safe

Let me clear one thing up for you (or remind you, perhaps?) PiroX’s pvpTool is written in AutoIt. AutoIt CAN NOT HOOK. Which means it has to resort to direct memory writes to a pulsed struct to achieve something like CTM. Now, wouldn’t it be down-right easy for Warden to determine if the stuff in the CTM struct originates from an engine call or from an external program? (The CTM actions are timestamped, mind you. And 9.99/10 people don’t timestamp when they remotely write to the CTM struct)

Long story short, if you hook, and you do it properly; you’ll probably be safe until they nail your hook. If you write to the struct? You may end up with a ban, who knows. Warden is packed since 3.3.5, and no one really knows what it does yet.

I’m glad Blizzard is back into the anti-cheating stuff, being a bad kid gets boring if no one is watching the playground.

Originally Posted by Ski

What does that even mean? How would “CTM” be detectable? Its an ingame option that thousands of people, botters and nonbotters alike, use.

Rofl. I assumed a moderator of the Buddy Team would know his stuff. I assumed wrong.

So, dig it up in IDA, and look for the following:

.text:006D855E                 test    eax, eax
.text:006D8560                 jz      short loc_6D8589
.text:006D8562                 test    dword ptr [eax+0A30h], 200000h
.text:006D856C                 jz      short loc_6D8589

Now, say after me, eax is where the local player is stored, and eax+0A30h is being compared to 0×200000, eax+0a30h is very likely to return whether we’re swimming or not.

public bool IsSwimming
{
	return ObjectManager.Memory.ReadInt(BaseAddress + 0xA30h) == 0x200000;
}

Should therefore make sense, right?

IsMounted is reversed in the same manner, and uses the exact same field, just a different flag:

.text:006D865E                 test    eax, eax
.text:006D8660                 jz      short loc_6D8692
.text:006D8662                 cmp     dword ptr [eax+9C0h], 0
.text:006D8669                 jle     short loc_6D8692
.text:006D866B                 test    dword ptr [eax+0A30h], 10000000h
.text:006D8675                 jnz     short loc_6D8692

public bool IsMounted
{
	return ObjectManager.Memory.ReadInt(BaseAddress + 0x0A30h) == 0x10000000;
}

I haven't tested this code personally, but I'm pretty confident it's accurate.

As you may know, I’m currently working on a small gathering bot, which uses the Spectre Framework by Seifer as its main interface to World of Warcraft.

Now, I’ve coded a small, 20~ line of code class, which replicates exactly what the GSpellTimer did. And as per usual, some demo code:

public SpellTimer GlobalCooldown = new SpellTimer(1500);

if (GlobalCooldown.IsReady)
Logging.Write(“Global cooldown finished.”);

Enjoy.

Let’s shed some light on the structure of the application first, so you know what we’re working with:

• One central Order class. This contains all the properties related to the orders.
• One central List<Order>, containing all the Orders we have stored in our application.
• Various methods, ie. Insert, Update, Delete. These manipulate the objects in the list, in a straight-forward manner.

So, with that out of the way, there are a few things I highly recommend you read up on – it’ll make your life a lot easier!

We’ll be working with a List<T>, where T is the type of object the list holds. This can be – for example – a string, integer, you name it, but also an object, such as our Order object! A list is a Collection. There are multiple collections available, but for what we’re going to do today – a List will suffice in all our requirements. Read the (very short) article about collection on MSDN here. And next, you will want to read up on the List<T> specifically here. We’ll be using the foreach loop extensively too, so I _highly_ recommend you know what it’s doing, and why it is useful!

Let’s get going, shall we?

Step 1 – Setting up our project

To start your project, go to New -> New Project, select a Windows Forms Application, and name it whatever the hell you like.
After that, go to Project -> Add Class and add a file called Order.cs. That will be the main order object we’ll be working with.

Step 2 – Defining the Order object

There’s not much we can do with an empty object. Therefore, we’ll be giving it some “body”. First off, declare the Order class as public, by adding the “public” keyword before the class definition; as so: public class Order. The reason we do this is so that any application, including our own, which refers to our application can use the Order class.

Next,we’ll be declaring two properties in the Order object. If you wonder why I don’t declare a field and a property, it’s because a Property holds a field internally. This basically means they’re the same, and a property can hold a value like a field can – so there’s absolutely no need to declare a field here:

public class Order
{
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name=”id”>Order ID</param>
/// <param name=”name”>Order Name</param>
public Order(int id, string name)
{
ID = id;
Name = name;
}

/// <summary>
/// The ID of the Order.
/// </summary>
public int ID { get; set; }

/// <summary>
/// The Order’s name.
/// </summary>
public string Name { get; set; }
}

This allows us to call Order.Name, and Order.ID! Isn’t it amazingly simple? If you’re wondering what get; set; means; it delcares what we can do with the property. The get accessor allows us to – logically? – GET the value of the property, and the set allows us to – stunningly – SET the value of the property. If we would declare them with just “get”, we can not change the property’s value. So Object.ID = 1; would throw an error at us, because we didn’t declare a set accessor. Easy enough, isn’t it?

Step 3 – Declaring the Order list

First off, rename Form1 to Main. Then, open it up in the code editor (Right click -> View Code), and put the following code inside the class definition, but not inside a method:

public List<Order> Orders = new List<Order>();

This provides us with a basic list, which we can access to keep track of our orders.

Step 4 – Creating some objects to work with

Now that we have the list pointed down, we’ll need some objects to work with. At the same time, we’ll be using the Add() method of the Collection, so pay close attention, you may pick up a bit for later on. We’ll also be using a for loop. This isn’t as complicated as it looks, and I’ll explain it in the code. First off, double click inside the form, when viewing it in Design view. This will create a Main_Load(object sender, EventArgs e) in your code, which will be executed when the form loads. This is known as the load event, any code we put in it will be executed when the form loads.

Add the following foreach loop to that Load event:

// i = 0, if i is less or equal to 100, do i + 1.
for (int i=0; i<=100; i++)
{
// Add a new order, give it the ID of i, and the name ORDDER(i)
Orders.Add(new Order(i, “ORDER” + i));
}

Code should be self explanatory, together with the comments.

Step 5 – Creating a method to add an Order

This step is straight forward as can be. Basically, we want a method that takes two arguments: ID and Name. Then we create a new object which adds that to the list with Orders:

public void AddOrder(int id, string name)
{
Orders.Add(new Order(id, name));
}

Always – and I mean always – add a new instance of Order to the list, using the new keyword. As you can see, we are using the Add() method of the list to add an object to it.

Step 5 – Searching by ID

This step of the tutorial is a small step up from adding an object, as we actually have to loop through all the objects. This is where the foreach loop becomes key, so I hope you have read up on it, and know what it’s doing.

The concept is simple. We take the ID as a parameter of our method, then loop through all objects in the Objects list, and check if the ID == our ID argument.
If so, we add it to a local list of results, and at the end, we return that list. This is why the return type of the method is List<Order>. If you don’t know what a return type is, read up on MSDN here.

Anyway, onto the code:

public List<Order> Search(int id)
{
// The list we use for objects that matches the ID.
List<Order> ret = new List<Order>();

// Check all objects in the list, and see if the ID is what we’re looking for.
foreach (Order o in Orders)
{
if (o.ID == id)
{
// If so, add it to the return list.
ret.Add(o);
}
}

// Return the list of results.
return ret;
}

Looks a bit more complicated, I know. Just take a few minutes to comprehend it, and read the comments. It’s still pretty basic stuff!

Next thing is, how do we use this? That’s easy too, to search for the orders, we use the following code:

var res = Search(Convert.ToInt32(txt_SearchID.Text));

foreach (Order o in res)
{
lst_IDResult.Items.Add(o.ID + ” | ” + o.Name);
}

We’re using a ListBox called lst_IDResults to show our results. As you can see, we use another foreach loop. However, this time, we use the list that Search provided us with, not the global Orders list! Meaning the list only contains those objects we were searching!

Step 6 – Updating a list entry

This one gets a bit tricky. It combines the search, and the listBox elements to update an item in the Order list.

If we want to update an object in the list, we’ll have to know what its index is. The index is simply defined as the number it has in the list; the first object added will have number 0, the second will have 1, the third will have 2, and so on. The index is zero-based, meaning it starts at 0, and goes up from there.

When we dump all the objects into a listBox, using a simple foreach loop, they will have the exact same index as they have in the Orders list. This means we can use the index of the listBox as a secure and narrowed down point for updating objects.

First off, add a new property to the Order object, called Index. It’s an int. We don’t add this to our constructor, as we’ll only use it for updating.
Also, add public Order curObj { get; set; } to your Main.cs file. This is the object we have selected for updating, and we use this for easy reference later on.

Now, we want to populate the listBox with all items that Orders holds. To do this, we use the following code in the Show Objects button:

// Clear the list.
lst_Update.Items.Clear();

foreach (Order o in Orders)
{
lst_Update.Items.Add(o.ID + ” | ” + o.Name);
}

Then, under the Select this Item button, we define the following:

// Sets the curObj to the index we have selected in the list.
curObj = Orders[lst_Update.SelectedIndex];

// Set the Index property to the index of this object in the listBox.
curObj.Index = lst_Update.SelectedIndex;

// Set the Textboxes to the object’s name and ID.
txt_OrderID.Text = curObj.ID.ToString();
txt_OrderName.Text = curObj.Name;

This uses the Index I was talking about earlier. If you are unsure about what the Index is, check the “Inserting elements” section of this page. And if still unsure, Google around a bit.

And finally, to execute the update:

// Make sure an item is selected.
if (curObj != null)
{
// Change the values.
Orders[curObj.Index].ID = Convert.ToInt32(txt_OrderID.Text);
Orders[curObj.Index].Name = txt_OrderName.Text;
}

There is really not much to explain about the update code, and it is one way of doing it, there are multiple ways to update items in a list.

I suggest you look up the methods of the List<T> collection, and do a Google search on how to achieve these various tasks aside from this tutorial. Maybe I have over-complicated it, I don’t know.

I’m attaching two pieces of source code, one written for this very tutorial, and one I had laying around. Both will demonstrate how to achieve these tasks perfectly, and they both work. Learn as much as you can from it, and read up on a dozen of tutorials on the internet, and you will be fine.

The source of this tutorial:
http://release.aevitas.in/BackToBasic-Lists.rar

Similar source I made earlier:
http://release.aevitas.in/PObjects.rar

Good luck!

It’ll be a ‘basic’ out-of-process bot for World of Warcraft, which may even end up being open-source and available to the general public.
Along with Spectre, I’ll be updating this journal again; posting some interesting pieces of code, and general methods and approaches.

So stay tuned, and it’ll definitely be worth your while dropping by every now and then!