Olá, Imperyânus.
Trouxe algumas coisas minhas que lhes podem ser útil, antes que eu seja banido novamente. (Não que eu ligue pra isso.)
Para o servidor:
- Otimização no uso da memória:
* Remove a alocação da classe MultiHackAttackCheck. Essa classe não é utilizada em nada no GS da 97d, apenas para ocupar mais memória. #webzendafuk
Código:*(BYTE*)(0x42D250) = 0xC3;
*(BYTE*)(0x42D251) = 0x90;
*(BYTE*)(0x401B0E) = 0xC3;
*(BYTE*)(0x401B0F) = 0x90;
*(BYTE*)(0x4022DE) = 0xC3;
*(BYTE*)(0x4022DF) = 0x90;
for (BYTE i = 0; i != 20; i++)
{
*(BYTE*)(0x45B55E + i) = 0x90;
}
- Asas nível 1 com adicionais excelentes:
Código:*(DWORD*)(0x47E353) = 0x180;
*(DWORD*)(0x47E672) = 0x180;
*(DWORD*)(0x47E98E) = 0x180;
*(DWORD*)(0x47F495) = 0x180;
*(BYTE*)(0x47EE70) = 0xE9;
*(DWORD*)(0x47EE71) = 0xAA;
*(BYTE*)(0x47EE97) = 0xE9;
*(DWORD*)(0x47EE98) = 0xF8;
*(BYTE*)(0x47EE70) = 0xE9;
*(DWORD*)(0x47EE71) = 0xAA;
*(BYTE*)(0x47EEDB) = 0xE9;
*(DWORD*)(0x47EEDC) = 0x119;
- LevelUp atualizando atributos e adição de pontos (sem relogar):
* Necessita da parte do cliente para funcionar como o esperado.
Código:struct Header
{
BYTE Packet;
BYTE Size;
BYTE Head;
};
struct LevelUpSend
{
Header Head;
BYTE Code;
short Level;
WORD LevelUpPoint;
UINT Experience;
UINT NextExp;
WORD Strength;
WORD Dexterity;
WORD Vitality;
WORD Energy;
WORD MaxLife;
WORD MaxMana;
WORD MaxBP;
WORD AddPoint;
WORD MaxAddPoint;
};
struct AddPoints
{
Header Head;
BYTE Code;
BYTE Section;
WORD Points;
WORD MaxLifeAndMana;
WORD MaxBP;
};
void UpdateCharacter(int aIndex)
{
LevelUpSend Data;
Data.Head.Packet = 0xC1;
Data.Head.Size = sizeof(Data);
Data.Head.Head = 0xFE;
Data.Code = 0x01;
Data.Level = gObj[aIndex].Level;
Data.LevelUpPoint = (WORD)(gObj[aIndex].LevelUpPoint);
Data.Experience = gObj[aIndex].Experience;
Data.NextExp = gObj[aIndex].NextExp;
Data.Strength = gObj[aIndex].Strength;
Data.Dexterity = gObj[aIndex].Dexterity;
Data.Vitality = gObj[aIndex].Vitality;
Data.Energy = gObj[aIndex].Energy;
Data.MaxLife = (WORD)(gObj[aIndex].MaxLife + gObj[aIndex].AddLife);
Data.MaxMana = (WORD)(gObj[aIndex].MaxMana + gObj[aIndex].AddMana);
Data.MaxBP = (WORD)(gObj[aIndex].MaxBP + gObj[aIndex].AddBP);
Data.AddPoint = 0;
Data.MaxAddPoint = 0;
eDataSend(Index, (LPBYTE)(&Data), Data.Head.Size);
}
void AddPoints(int aIndex, BYTE Type, int Value)
{
gObj[aIndex].LevelUpPoint -= Value;
switch (Section)
{
case 0:
gObj[aIndex].Strength += (WORD)(Value);
break;
case 1:
gObj[aIndex].Dexterity = (WORD)(Value);
break;
case 2:
gObj[aIndex].Vitality = (WORD)(Value);
gObj[aIndex].MaxLife = gObj[aIndex].VitalityToLife * (float)(gObj[aIndex].Vitality);
egObjCalcMaxLifePower(aIndex);
break;
case 3:
gObj[aIndex].Energy = (WORD)(Value);
gObj[aIndex].MaxMana = gObj[aIndex].EnergyToMana * (float)(gObj[aIndex].Energy);
break;
}
egObjSetBP(aIndex);
AddPoints AddPoint;
AddPoint.Packet = 0xC1;
AddPoint.Size = sizeof(AddPoint);
AddPoint.Head = 0xFE;
AddPoint.Code = 0x02;
AddPoint.Section = Section;
AddPoint.Points = (WORD)(Value - 1);
AddPoint.MaxLife = (WORD)(gObj[aIndex].MaxLife + gObj[aIndex].AddLife);
AddPoint.MaxMana = (WORD)(gObj[aIndex].MaxMana + gObj[aIndex].AddMana);
AddPoint.MaxBP = (WORD)(gObj[aIndex].MaxBP + gObj[aIndex].AddBP);
eDataSend(aIndex, (LPBYTE)(&AddPoint), AddPoint.Size);
egObjCalCharacter(aIndex);
}
Para o cliente:
- Otimização no uso da CPU:
Código:*(BYTE*)(0x521608) = 0x6A;
*(BYTE*)(0x521609) = 0x01;
*(BYTE*)(0x52160A) = 0xFF;
*(BYTE*)(0x52160B) = 0x15;
*(BYTE*)(0x52160C) = 0x24;
*(BYTE*)(0x52160D) = 0xD1;
*(BYTE*)(0x52160E) = 0x54;
*(BYTE*)(0x52160F) = 0x00;
for (BYTE i = 0; i != 10; i++)
{
*(BYTE*)(0x521610 + i) = 0x90;
}
*(BYTE*)(0x52161A) = 0xEB;
*(BYTE*)(0x52161B) = 0xD1;
// Desativa o GameGuard
*(BYTE*)(0x41E3FC) = 0xEB;
*(BYTE*)(0x41E25B) = 0x74;
*(BYTE*)(0x53853B) = 0xEB;
- Asas nível 1 com adicionais excelentes:
Código:*(BYTE*)(0x4BFF9B) = 0x80;
*(BYTE*)(0x4C0D81) = 0x80;
*(BYTE*)(0x4796D7) = 0x80;
*(BYTE*)(0x4798CF) = 0x80;
*(BYTE*)(0x479A99) = 0x80;
*(BYTE*)(0x479AFE) = 0x80;
- Modo Janela: (Valeu navossoco! :D)
* Necessita da biblioteca detours.
Código:#define eWndProc (WNDPROC) (0x414190)
HWND(WINAPI* pCreateWindowEx)(DWORD, LPCSTR, LPCSTR, DWORD, int, int, int, int, HWND, HMENU, HINSTANCE, LPVOID) = CreateWindowEx;
LONG(WINAPI* pChangeDisplaySettings)(DEVMODEA*, DWORD) = ChangeDisplaySettings;
HWND WINAPI dCreateWindowEx(DWORD ExStyle, LPCSTR ClassName, LPCSTR WindowName, DWORD Style, int X, int Y, int Width, int Height, HWND Parent, HMENU Menu, HINSTANCE Instance, LPVOID Parameter)
{
if (IS_INTRESOURCE(ClassName))
{
return pCreateWindowEx(ExStyle, ClassName, WindowName, Style, X, Y, Width, Height, Parent, Menu, Instance, Parameter);
}
if (_stricmp(ClassName, VMProtectDecryptStringA("MU")) == 0)
{
int SizeX = Width,
SizeY = Height,
ScreenX = GetSystemMetrics(SM_CXSCREEN),
ScreenY = GetSystemMetrics(SM_CYSCREEN),
X2 = (ScreenX / 2) - (SizeX / 2),
Y2 = (ScreenY / 2) - (SizeY / 2);
HWND Window = pCreateWindowEx(0, ClassName, WindowName, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_BORDER, X2, Y2, SizeX, SizeY, 0, 0, Instance, Parameter);
SetWindowPos(Window, nullptr, X2, Y2, 0, 0, SWP_NOSIZE);
return Window;
}
return pCreateWindowEx(ExStyle, ClassName, WindowName, Style, X, Y, Width, Height, Parent, Menu, Instance, Parameter);
}
LONG WINAPI dChangeDisplaySettings(DEVMODEA* DevMode, DWORD Flag)
{
return DISP_CHANGE_SUCCESSFUL;
}
LRESULT CALLBACK WndProc(HWND Window, UINT Message, WPARAM W, LPARAM L)
{
switch (Message)
{
case WM_NCACTIVATE:
return 0;
}
return CallWindowProc(eWndProc, Window, Message, W, L);
}
void Hook()
{
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach((&(LPVOID&)(pCreateWindowEx)), dCreateWindowEx);
DetourAttach((&(LPVOID&)(pChangeDisplaySettings)), dChangeDisplaySettings);
DetourTransactionCommit();
*(DWORD*)(0x41D37B) = (DWORD)(&WndProc);
}
void Unhook()
{
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourDetach((&(LPVOID&)(pCreateWindowEx)), dCreateWindowEx);
DetourDetach((&(LPVOID&)(pChangeDisplaySettings)), dChangeDisplaySettings);
DetourTransactionCommit();
}
- LevelUp atualizando atributos e adição de pontos (sem relogar):
* Diferente daquele sistema bosta do Haziel, onde o personagem fica piscando (como se tivesse teleportado) cada vez que atualiza os atributos do personagem, esse atualiza sem piscadinhas. RSRSRS. ;)
Poderá ser usado para Reset/MR ou o que mais você necessitar.
* Necessita da parte do servidor para funcionar como o esperado.
Código:struct Header
{
BYTE Packet;
BYTE Size;
BYTE Head;
};
struct HeaderCode
{
Header Head;
BYTE Code;
};
struct HeaderResult
{
Header Head;
BYTE Code;
BYTE Result;
};
struct LevelUpSend
{
Header Head;
BYTE Code;
short Level;
WORD LevelUpPoint;
UINT Experience;
UINT NextExp;
WORD Strength;
WORD Dexterity;
WORD Vitality;
WORD Energy;
WORD MaxLife;
WORD MaxMana;
WORD MaxBP;
WORD AddPoint;
WORD MaxAddPoint;
};
struct LevelUp
{
Header Head;
BYTE Code;
short Level;
WORD LevelUpPoints;
WORD MaxLife;
WORD MaxMana;
WORD MaxBP;
WORD AddPoint;
WORD MaxAddPoint;
};
struct AddPoints
{
Header Head;
BYTE Code;
BYTE Section;
WORD Points;
WORD MaxLifeAndMana;
WORD MaxBP;
};
struct AddPointsResult
{
Header Head;
BYTE Code;;
BYTE Result;
WORD MaxLifeAndMana;
WORD MaxBP;
};
short Level = 0;
WORD LevelUpPoints = 0;
DWORD Experience = 0;
DWORD NextExp = 0;
DWORD ObtainedExp = 0;
WORD Strength = 0;
WORD Dexterity = 0;
WORD Vitality = 0;
WORD Energy = 0;
WORD MaxLife = 0;
WORD MaxMana = 0;
WORD MaxBP = 0;
#define eGCClientLevelUpPointAdd ((void (*)(AddPointsResult*)) (0x430A80))
#define eGCClientLevelUpMsgSend ((void (*)(LevelUp*)) (0x430780))
void ProtocolCore(LPBYTE Data)
{
switch (Data[0])
{
case 0xC1:
case 0xC3:
{
HeaderCode* Header = (HeaderCode*)(Data);
switch (Header->Head.Head)
{
case 0xF3:
{
if (Header->Code == 0x06)
{
LevelUpPoints = 0;
Strength = 0;
Dexterity = 0;
Vitality = 0;
Energy = 0;
}
}
break;
case 0xFE:
{
switch (Header->Code)
{
case 0x01:
{
LevelUpSend* Value = (LevelUpSend*)(Data);
LevelUp Up;
memset(&Up, 0, sizeof(Up));
Up.Head.Packet = 0xC1;
Up.Head.Size = sizeof(Up);
Up.Head.Head = 0xF3;
Up.Code = 0x05;
Level = Value->Level;
LevelUpPoints = Value->LevelUpPoint;
Strength = Value->Strength;
Dexterity = Value->Dexterity;
Vitality = Value->Vitality;
Energy = Value->Energy;
MaxLife = Value->MaxLife;
MaxMana = Value->MaxMana;
MaxBP = Value->MaxBP;
Experience = Value->Experience;
NextExp = Value->NextExp;
eGCClientLevelUpMsgSend(&Up);
}
break;
case 0x02:
{
AddPoints* Value = (AddPoints*)(Data);
AddPointsResult Result;
Result.Head.Packet = 0xC1;
Result.Head.Size = sizeof(Result);
Result.Head.Head = 0xF3;
Result.Code = 0x06;
Result.Result = 0x10 + Value->Section;
Result.MaxLifeAndMana = Value->MaxLifeAndMana;
Result.MaxBP = Value->MaxBP;
LevelUpPoints = Value->Points;
Strength = 0;
Dexterity = 0;
Vitality = 0;
Energy = 0;
switch (Value->Section)
{
case 0:
Strength = Value->Points;
break;
case 1:
Dexterity = Value->Points;
break;
case 2:
Vitality = Value->Points;
break;
case 3:
Energy = Value->Points;
break;
}
eGCClientLevelUpPointAdd(&Result);
}
break;
}
}
break;
}
}
break;
}
}
DWORD nProtocolCoreBack = 0x4384FB;
LPBYTE nProtocolCoreData = nullptr;
void __declspec(naked) nProtocolCore()
{
__asm
{
MOV nProtocolCoreData, EBP;
PUSHAD;
}
ProtocolCore(nProtocolCoreData);
__asm
{
POPAD;
MOV EDX, DWORD PTR DS : [0x8311134];
JMP nProtocolCoreBack;
}
}
DWORD nLevelUpBack = 0x430942;
void __declspec(naked) nLevelUp()
{
__asm
{
MOV EAX, DWORD PTR DS : [0x81F135C];
MOV CX, Level;
MOV WORD PTR DS : [EAX + 0x0E], CX;
MOV EDX, Experience;
MOV DWORD PTR DS : [EAX + 0x10], EDX;
MOV EDX, NextExp;
MOV DWORD PTR DS : [EAX + 0x34], EDX;
MOV CX, Strength;
MOV WORD PTR DS : [EAX + 0x14], CX;
MOV CX, Dexterity;
MOV WORD PTR DS : [EAX + 0x16], CX;
MOV CX, Vitality;
MOV WORD PTR DS : [EAX + 0x18], CX;
MOV CX, Energy;
MOV WORD PTR DS : [EAX + 0x1A], CX;
MOV CX, MaxLife;
MOV WORD PTR DS : [EAX + 0x1C], CX;
MOV WORD PTR DS : [EAX + 0x20], CX;
MOV CX, MaxMana;
MOV WORD PTR DS : [EAX + 0x1E], CX;
MOV WORD PTR DS : [EAX + 0x22], CX;
MOV CX, MaxBP;
MOV WORD PTR DS : [EAX + 0x24], CX;
MOV WORD PTR DS : [EAX + 0x26], CX;
MOV WORD PTR DS : [EAX + 0x2E], 0;
MOV WORD PTR DS : [EAX + 0x30], 0;
MOV CX, LevelUpPoints;
MOV WORD PTR DS : [EAX + 0x54], CX;
JMP nLevelUpBack;
}
}
DWORD nAddPointsBack = 0x430B57;
void __declspec(naked) nAddPoints()
{
__asm
{
MOV EAX, DWORD PTR DS : [0x81F135C];
MOV CX, Strength;
ADD WORD PTR DS : [EAX + 0x14], CX;
MOV CX, Dexterity;
ADD WORD PTR DS : [EAX + 0x16], CX;
MOV CX, Vitality;
ADD WORD PTR DS : [EAX + 0x18], CX;
MOV CX, Energy;
ADD WORD PTR DS : [EAX + 0x1A], CX;
MOV CX, LevelUpPoints;
SUB WORD PTR DS : [EAX + 0x54], CX;
JMP nAddPointsBack;
}
}
void Hook()
{
*(BYTE*)(0x4384F5) = 0xE9;
*(DWORD*)(0x4384F5 + 1) = (DWORD)(&nProtocolCore) - (0x4384F5 + 5);
*(BYTE*)(0x4384FA) = 0x90;
*(BYTE*)(0x4308FD) = 0xE9;
*(DWORD*)(0x4308FD + 1) = (DWORD)(&nLevelUp) - (0x4308FD + 5);
*(BYTE*)(0x430B52) = 0xE9;
*(DWORD*)(0x430B52 + 1) = (DWORD)(&nAddPoints) - (0x430B52 + 5);
}
Em breve, trago uns eventos, caso eu não seja banido até lá. rsrs.
Beijos de Lux.
[Only registered and activated users can see links. Click Here To Register...]
Seja bem-vindo de volta.
Depois de me banirem que fizeram as novas regras.
Mas eu cago e ando pra isso. Só quis liberar algumas utilidades por causa de uma corja que tem por aí, e que provavelmente já tem eles em mãos.
Vlw.
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.vBulletin Security provided by vBSecurity (Lite) - vBulletin Mods & Addons Copyright © 2024 DragonByte Technologies Ltd.
