The big difference is obviously the way its coded, what's implemented, how you use what's implemented, and how to further implement things.
For instance, on server may handle packets in the following manner:
Code:
switch (Type) // switch the packet type)
{
/*...*/
case 0x111: ProcessThisPacket(Client, Packet, ...otherargs...); break;
/*...*/
}
In which above you can see the example the client, packet and other argument are passed to a
function of the same root class of the processor where as in another, it could be like the following:
Code:
switch (Type)
{
case 0x111:
{
SomePacket p = new SomePacket(Packet);
p.Process(Client, ...);
break;
}
}
In which in this case it implies you should create a new class (or structure) for each of your packets and implement a Process() routine.
All in all, if the source works, you should be able to find similarities, and even build interoperability if you wanted to be able to port code from one source to another, the main thing I find that you'd want to look into is what exploit are known in the source(s). Because the sources are coded by different people, you'll also notice different styles used. For example, I know programmers who would rather PInvoke a method like this:
Code:
public static extern WSAStartup(short wVersion, ref WSADATA lpWSAData);
over this:
Code:
public static extern WSAStartup(short wVersion, WSADATA* lpWSAData);
Now for example, if the 1st one is used, the person coding the source is probably sticking to standardized-reccomended-C# practices. You'll probably never see unsafe code used and their methods so to speak will be "safe". Now below implies the person is using pointer-logic. This can be a double-edged sword, as in, if the person who coded the source knows well what they're doing it'll work perfectly, however, it may be more confusing to someone who doesn't have a background in one of the low-level languages, or doesn't understand pointer logic, and doesn't want to learn it. If the person carelessly uses pointer-logic throughout their server (or any application) it may result in "random" crashes making them extremely hard to debug as you may not get a .NET exception error thrown and your application may just close.
