What Language?

[[GM]Zan]

What language is Dekaron Coded in?

then i mean.
When i making my own dekaron server what language do i write it on.
(Computer Language)

[[DEV]Harmony]

It will be English if you will use english files unless u use dekaron kr files it will be on korean.

[[GM]Zan]

i mean what programming language.

[gedimazs]

you don't need to know any programming language to open dekaron server except you want to modify dekaronserver.exe or dekaron.exe to load new stuff like aloken, mavrics and etc. and btw you must know how to create new dlls too Good luck

[MMOPerfection©]

If you want to add aloken into the exe you'll need to know the
ASM language.

[bottomy]

Dekaron was coded in C++, but like Xplicit said you'll need to know asm if you want to implement new features. Even if you aren't going to need to code any assembly, you'll still need to know it so you can reverse their executables and workout how you're going to implement such things.

@gedimazs You don't 'need' to know how to create DLL's to implement new features to the game, it's only one of the ways of implementing those features. But yes it's generally the quicker way to implement features.

[Zombe]

If you'd like to get into serious reversing (Like I'm trying to now ), heres what you do:

1. You learn C++. Kind of good tutorial (At least I didn't find a better one):


2. You learn ASM. Heres the best ASM utorial you'll ever find, I finished it ~3 years ago, and I still haven't seen a better, more in-depth tutorial, ever. Here's the link:


3. Get a decompiling program or a few. Here's two c++ decompilers I'd suggest:



And here's a good article about decompiling:



After that, you wont need to make a dll, you will be able to modify the exe itself using it's source code, since you'll have a pretty good (well, good enough to modify it) source code of the exe.

But if you decide to take upon the mission of learning C++ and ASM, heres a warning... Well, I'll put it this way: I've learned PHP in 2-3 days. I've been learning C++ and ASM for 3 years, and still learning.
Soo, you'll have to be pretty dedicated to that... Dedicated enough to not get laid with your girlfriend for a year... Although that's a different story, and it wasn't my fault. But you get the idea.

Good luck, future adventurers! >=O



Ok, I just realized this is completely off-topic. Its coded in C++ so that you'd know.

[bottomy]

Originally Posted by Zombe

3. Get a decompiling program or a few. Here's two c++ decompilers I'd suggest:

Just a note though to any who are thinking about decompiling dekaron's executable(s). It's unlikely that it will even be able to decompile it for starters since because of just the size of the executable. But even if it does decompile it there may be problems like, un-meaningful variable names/function names, depending on what optimizations were used might affect the actual output, if any functions were declared in another section than the .text segment it may not be shown as a function and it's code, if text or variables info is stored within the .text segment it might get translated into C/C++ code, if there's any encryption of obfuscation used that will cause problems, then one main problem is data types (specifically distinguishing between what data type they were declared as).

For instance say you have the following assembly:
AT&T

 Spoiler

leal	-21(%ebp), %eax
movl	%eax, -16(%ebp)    ;Pointer has been declared, type unknown (let's call it Ptr1)
leal	-21(%ebp), %eax
movl	%eax, -12(%ebp)    ;Second pointer has been declared, type also unknown (let's call it Ptr2)
movl	-16(%ebp), %eax
movb	 $0, (%eax)   ;Moving byte value 0x00 into what 1st pointer is pointing to, so Ptr1 might have been declared as a 'char'
movl	-12(%ebp), %eax
movl	$0, (%eax)    ;Moving dword value 0x00000000 into what the 2nd pointer is pointing to, so Ptr2 might have been declared as an 'int'
movl	-16(%ebp), %eax	
movl	$0, (%eax)    ;Moving dword value 0x00000000 into what the 1st pointer is pointing to, so Ptr1 might have actually been declared as an 'int' or was being typecast as a 'char' before, or maybe it's being typecast as an 'int' here.

INTEL

 Spoiler

lea eax,dword ptr [ebp-21]
mov dword ptr [ebp-16],eax    ;Pointer has been declared, type unknown (let's call it Ptr1)
lea eax,dword ptr [ebp-21]
mov dword ptr [ebp-12]    ;Second pointer has been declared, type also unknown (let's call it Ptr2)
mov eax,dword ptr [ebp-16]
mov byte ptr [eax],0     ;Moving byte value 0x00 into what 1st pointer is pointing to, so Ptr1 might have been declared as a 'char'
mov eax,dword ptr [ebp-12]
mov dword ptr [eax],0    ;Moving dword value 0x00000000 into what the 2nd pointer is pointing to, so Ptr2 might have been declared as an 'int'
mov eax,dword ptr [ebp-16]
mov dword ptr [eax],0    ;Moving dword value 0x00000000 into what the 1st pointer is pointing to, so Ptr1 might have actually been declared as an 'int' or was being typecast as a 'char' before, or maybe it's being typecast as an 'int' here.

So see you don't know what the pointer was actually declared as, like it could have been the following:

char *s = variable;
int *i = (int*)variable;

*s = 0;
*i = 0;
*(int*)&s = 0;

So the decompiler may declare the pointers as type void *. But it's not just variables that are declared as pointers where the problem lies.


AT&T

 Spoiler

movl	$2, -12(%ebp) ;Our first variable declared
movl	-12(%ebp), %eax
addl	$4, %eax
movl	$1, (%eax)
leal	-12(%ebp), %eax
addl	$20, %eax
movl	$4, (%eax)

movl	$2, -16(%ebp) ;Our second variable declared
movl	-16(%ebp), %eax
addl	$4, %eax
movl	$1, (%eax)
leal	-16(%ebp), %eax
addl	$20, %eax
movl	$4, (%eax)

INTEL

 Spoiler

mov dword ptr [ebp-12],2 ;Our first variable declared
mov eax,dword ptr [ebp-12]
add eax,4
mov dword ptr [eax],1
lea eax, dword ptr [ebp-12]
add eax,14
mov dword ptr [eax],4

mov dword ptr [ebp-16],2 ;Our second variable declared
mov eax,dword ptr [ebp-16]
add eax,4
mov dword ptr [eax],1
lea eax, dword ptr [ebp-16]
add eax,14
mov dword ptr [eax],4

So here we have exactly the same code as one another, only different points on the stack. But here's what the actual C/C++ code might look like.

int a = 2;
((int*)a)[1] = 1;
(&a)[5] = 4;

int *c = (int*)2;
*(c + 1) = 1;
(&c)[5] = (int*)4;

So what the decompiler might do is just declare them both as int, and cast them like the variable a. This can create hard to understand code, so all in all decompilers aren't going to give you that much more information then if you were to just read the disassembled code.