Siga-nos em...
Follow us on Twitter Follow us on Facebook Watch us on YouTube
Registro

Alpha Servers
Resultados 1 a 4 de 4
  1. #1

    Avatar de EitaGiovanna
    Data de Ingresso
    Dec 2016
    Localização
    ?
    Idade
    32
    Posts
    2
    Agradecido
    3
    Agradeceu
    2
    Peso da Avaliação
    0

    Padrão Utilidades para 97d.

    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! )
      * 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.

  2. Os Seguintes 2 Usuários Agradeceram você EitaGiovanna Por este Post Útil:


  3. #2


    Avatar de Agathos
    Data de Ingresso
    Oct 2014
    Localização
    BRA
    Idade
    40
    Posts
    341
    Agradecido
    150
    Agradeceu
    91
    Peso da Avaliação
    13

    Padrão

    Aqui ninguém é banido se cumprir as regras. Que por sinal são bem fáceis de seguir.

    [Somente usuários registrados podem vem os links. ]

    Seja bem-vindo de volta.
    Você pode descobrir mais a respeito de uma pessoa numa hora de jogo do que num ano de conversação.
    ( Platão )

  4. #3

    Avatar de EitaGiovanna
    Data de Ingresso
    Dec 2016
    Localização
    ?
    Idade
    32
    Posts
    2
    Agradecido
    3
    Agradeceu
    2
    Peso da Avaliação
    0

    Padrão

    Quando eu fui banido, eu estava seguindo as regras. Hahaha.
    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.

  5. O Seguinte Usuário Agradeceu EitaGiovanna Por este Post Útil:


  6. #4

    Avatar de MisoGrandelle
    Data de Ingresso
    Nov 2014
    Localização
    miso
    Posts
    45
    Agradecido
    23
    Agradeceu
    17
    Peso da Avaliação
    0

    Padrão

    saudades das nossas conversas seu corno <3

 

 

Informações de Tópico

Usuários Navegando neste Tópico

Há 1 usuários navegando neste tópico. (0 registrados e 1 visitantes)

Tópicos Similares

  1. |Tutorial| Milkshape 3D comandos e utilidades.
    Por Maicon Cazeloto no fórum Tutoriais
    Respostas: 0
    Último Post: 16-06-2012, 02:28 PM

Marcadores

Permissões de Postagem

  • Você não pode iniciar novos tópicos
  • Você não pode enviar respostas
  • Você não pode enviar anexos
  • Você não pode editar suas mensagens
  •