Source [MuEmu] Source Add 3 Fenrir [1.04e] [COMPLETO]

[Dakosmu]

Este es un source para complementar este otro post: http://tuservermu.com.ve/index.php?topic=29568.0
Creo que fue creado por melo920 asi que los creditos para el.
Agrega 3 Fenrir Custom, no se la manera para agregar mas, si alguien la aporta bienvenido sea.
Esto ya esta posteado pero la intención es que busquemos otra manera de agregar mas fenrir y las personas que sepan y quieran ayudar lo hagan.

Descarga para cliente :

You require the following to view this post content:

• You require a post count of at least 1, you need another 1 posts.

dentro de la funcion void CObjectManager::CharacterMakePreviewCharSet(int aIndex)

Code: [Select]
else if((lpObj->Inventory[8].m_NewOption & != 0)
      {
         lpObj->CharSet[16] |= 250 << 1;
      }
      else if((lpObj->Inventory[8].m_NewOption & 16) != 0)
      {
         lpObj->CharSet[16] |= 251 << 1;
      }
      else if((lpObj->Inventory[8].m_NewOption & 32) != 0)
      {
         lpObj->CharSet[16] |= 252 << 1;
      }

DSProtocol.cpp dentro de la funcion void DGCharacterListRecv(SDHP_CHARACTER_LIST_RECV* lpMsg) // OK

Code: [Select]
         else if ((lpInfo->Inventory[42] & != 0)
         {
            info.CharSet[16] |= 250 << 1;
         }
         else if ((lpInfo->Inventory[42] & 16) != 0)
         {
            info.CharSet[16] |= 251 << 1;
         }
         else if ((lpInfo->Inventory[42] & 32) != 0)
         {
            info.CharSet[16] |= 252 << 1;
         }

MAIN

En main.cpp agregar gNewPets.Load(); y agregar #include "Fenrir.h" al inicio.

Agregar #include "Fenrir.h" al inicio de Item.cpp

Item.cpp dentro de void ItemModelLoad()
   
Code: [Select]
pLoadModel(PetWhiteTiger, "Data\\Item\\", "fenril_tiger", -1);
   pLoadModel(PetHullWolf, "Data\\Item\\", "fenril_wolf", -1);
   pLoadModel(PetBeast, "Data\\Item\\", "lfenril_beast", -1);

Item.cpp dentro de void ItemTextureLoad()
Code: [Select]
   pLoadTexture(PetWhiteTiger, "Item\\", GL_REPEAT, GL_NEAREST, GL_TRUE);
   pLoadTexture(PetHullWolf, "Item\\", GL_REPEAT, GL_NEAREST, GL_TRUE);
   pLoadTexture(PetBeast, "Item\\", GL_REPEAT, GL_NEAREST, GL_TRUE);

Crear Fenrir.h
Code: [Select]
#pragma once

#include "Object.h"
typedef unsigned char byte;
#define PetWhiteTiger   0x1833
#define PetHullWolf      0x1834
#define PetBeast      0x1835

class NewPets
{
public:
   void         Load();
   static int      GetFenrirSkillColor(ObjectPreview * gPreview);
};
extern NewPets gNewPets;

Agregar en Pet.cpp despues del BYTE CustomPets = CharSet[15] >> 1;

Code: [Select]
   if ((CharSet[11] & 4) == 4)
   {
      lpObj->PetSlot = 7864;
      BYTE v17 = CharSet[15] & 3; // era 3
      if (CharSet[16] & 1)
         v17 = 4;
      if (CustomPets == 122)
         v17 = 8;
      else if (CustomPets == 123)
         v17 = 16;
      else if (CustomPets == 124)
         v17 = 32;


      lpObj->PetExcellent = v17;

      switch (v17)
      {
      case 1:
         if (Mode)
            sub_5013B0(384, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(384, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;

      case 2:
         if (Mode)
            sub_5013B0(386, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(386, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;

      case 4:
         if (Mode)
            sub_5013B0(387, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(387, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;

      case 8:
         if (Mode)
            sub_5013B0(0x1833, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(0x1833, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;

      case 16:
         if (Mode)
            sub_5013B0(0x1834, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(0x1834, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;

      case 32:
         if (Mode)
            sub_5013B0(0x1835, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(0x1835, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;

      default:
         if (Mode)
            sub_5013B0(385, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, Mode, 0);
         else
            sub_501700(385, (int)&lpObj->m_Model + 252, (int)&lpObj->m_Model, 0, 0);
         break;
      }
   }
//#endif
}

Crear Fenrir.cpp

Code: [Select]
#include "stdafx.h"
#include "TMemory.h"
#include "Import.h"
#include "Defines.h"
#include "Item.h"
#include "Fenrir.h"
#include "CustomItem.h"
#include "CustomJewel.h"
#include "CustomWing.h"
#include "Util.h"

NewPets   gNewPets;

Naked(SetNewPetSkins)
{
   DWORD Adr, Adr1, Adr2, Adr3;
   _asm
   {
WhiteTiger:
      MOV ECX, DWORD PTR SS : [EBP + 8]
      MOVZX EDX, BYTE PTR DS : [ECX + 0x17]
      CMP EDX, 8      // Exc Option
      JNE HullWolf   // Siguiente fenrir
      push 0
      push 0
      MOV EAX, DWORD PTR SS : [EBP - 4]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 4]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH PetWhiteTiger //Fenrir name
      mov Adr, 0x00501700
      CALL Adr
      ADD ESP, 0x14
      mov Adr2, 0x008360DD
      JMP SHORT Adr2

HullWolf:
      MOV ECX, DWORD PTR SS : [EBP + 8]
      MOVZX EDX, BYTE PTR DS : [ECX + 0x17]
      CMP EDX, 16      // Exc option
      JNE Beast   // Siguiente fenrir
      push 0
      push 0
      MOV EAX, DWORD PTR SS : [EBP - 4]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 4]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH PetHullWolf //Fenrir name
      mov Adr, 0x00501700
      CALL Adr
      ADD ESP, 0x14
      mov Adr2, 0x008360DD
      JMP SHORT Adr2

Beast:
      MOV ECX, DWORD PTR SS : [EBP + 8]
      MOVZX EDX, BYTE PTR DS : [ECX + 0x17]
      CMP EDX, 32      // Exc option
      JNE FenrirRed   // Siguiente fenrir
      push 0
      push 0
      MOV EAX, DWORD PTR SS : [EBP - 4]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 4]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH PetBeast //Fenrir name
      mov Adr, 0x00501700
      CALL Adr
      ADD ESP, 0x14
      mov Adr2, 0x008360DD
      JMP SHORT Adr2

FenrirRed:
      push 0
      push 0
      MOV EAX, DWORD PTR SS : [EBP - 4]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 4]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH 0x181 //Fenrir name
      mov Adr3, 0x00501700
      CALL Adr3
      ADD ESP, 0x14
      mov Adr2, 0x008360DD
      JMP SHORT Adr2
   }
}

Naked(FixVisualBug)
{
   DWORD Adr, Adr1, Adr2, Adr3;
   _asm
   {
WhiteTiger:
      MOVZX ECX, BYTE PTR SS : [EBP - 2]
      CMP ECX, 8      // Exc Option
      JNE HullWolf   // Siguiente fenrir
      push 0
      push 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH PetWhiteTiger //Fenrir name
      mov Adr, 0x00501700
      CALL Adr
      ADD ESP, 0x14
      mov Adr2, 0x00641914
      JMP SHORT Adr2

HullWolf:
      MOVZX ECX, BYTE PTR SS : [EBP - 2]
      CMP ECX, 16      // Exc Option
      JNE Beast   // Siguiente fenrir
      push 0
      push 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH PetHullWolf //Fenrir name
      mov Adr, 0x00501700
      CALL Adr
      ADD ESP, 0x14
      mov Adr2, 0x00641914
      JMP SHORT Adr2

Beast:
      MOVZX ECX, BYTE PTR SS : [EBP - 2]
      CMP ECX, 32      // Exc Option
      JNE FenrirRed      // Siguiente fenrir
      push 0
      push 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH PetBeast //Fenrir name
      mov Adr, 0x00501700
      CALL Adr
      ADD ESP, 0x14
      mov Adr2, 0x00641914
      JMP SHORT Adr2

FenrirRed:
      push 0
      push 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH 0x181 //Fenrir name
      mov Adr3, 0x00501700
      CALL Adr3
      ADD ESP, 0x14
      mov Adr2, 0x00641914
      JMP SHORT Adr2
   }
}

Naked(AsmTest3)
{
   DWORD Adr1, Adr2;
   _asm
   {
WhiteTiger:
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      MOVZX ECX, BYTE PTR DS : [EAX + 0x29B]
      CMP ECX, 0x8                     // Excelent option for new pet
      JNE SHORT HullWolf                  // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x18]
      ADD EDX, 0x604
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      ADD EAX, 0x374
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x18]
      ADD ECX, 0x470
      PUSH ECX
      PUSH PetWhiteTiger                  // Fenrir name
      mov Adr1, 0x005013B0
      CALL Adr1
      ADD ESP, 0x18
      mov Adr2, 0x0048FAAC
      JMP SHORT Adr1

HullWolf:
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      MOVZX ECX, BYTE PTR DS : [EAX + 0x29B]
      CMP ECX, 0x16                     // Excelent option for new pet
      JNE SHORT Beast                     // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x18]
      ADD EDX, 0x604
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      ADD EAX, 0x374
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x18]
      ADD ECX, 0x470
      PUSH ECX
      PUSH PetHullWolf                  // Fenrir name
      mov Adr1, 0x005013B0
      CALL Adr1
      ADD ESP, 0x18
      mov Adr2, 0x0048FAAC
      JMP SHORT Adr1
Beast:
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      MOVZX ECX, BYTE PTR DS : [EAX + 0x29B]
      CMP ECX, 0x32                     // Excelent option for new pet
      JNE SHORT Here                       // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x18]
      ADD EDX, 0x604
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      ADD EAX, 0x374
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x18]
      ADD ECX, 0x470
      PUSH ECX
      PUSH PetBeast                  // Fenrir name
      mov Adr1, 0x005013B0
      CALL Adr1
      ADD ESP, 0x18
      mov Adr2, 0x0048FAAC
      JMP SHORT Adr1

Here:
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x18]
      ADD EDX, 0x604
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x18]
      ADD EAX, 0x374
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x18]
      ADD ECX, 0x470
      PUSH ECX
      PUSH 0x181               // Fenrir name
      mov Adr1, 0x005013B0
      CALL Adr1
      ADD ESP, 0x18
      mov Adr2, 0x0048FAAC
      JMP SHORT Adr1
   }
}

Naked(AsmTest4)
{
   DWORD Adr1, Adr2;
   _asm
   {
WhiteTiger:
      MOV ECX, DWORD PTR SS : [EBP - 0x0C]
      MOVZX EDX, BYTE PTR DS : [ECX + 0x17]
      CMP EDX, 0x8                     // Exc Option
      JNE SHORT HullWolf                 // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EAX, DWORD PTR SS : [EBP - 0x10]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x10]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH PetWhiteTiger                  // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x005C7AD6
      JMP SHORT Adr2

HullWolf:
      MOV ECX, DWORD PTR SS : [EBP - 0x0C]
      MOVZX EDX, BYTE PTR DS : [ECX + 0x17]
      CMP EDX, 0x16                     // Exc Option
      JNE SHORT Beast                    // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EAX, DWORD PTR SS : [EBP - 0x10]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x10]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH PetHullWolf               // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x005C7AD6
      JMP SHORT Adr2
Beast:
      MOV ECX, DWORD PTR SS : [EBP - 0x0C]
      MOVZX EDX, BYTE PTR DS : [ECX + 0x17]
      CMP EDX, 0x32                  // Exc Option
      JNE SHORT Here                    // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EAX, DWORD PTR SS : [EBP - 0x10]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x10]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH PetBeast               // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x005C7AD6
      JMP SHORT Adr2

Here:
      PUSH 0
      PUSH 0
      MOV EAX, DWORD PTR SS : [EBP - 0x10]
      PUSH EAX
      MOV ECX, DWORD PTR SS : [EBP - 0x10]
      ADD ECX, 0x0FC   //252
      PUSH ECX
      PUSH 0x181                     // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x005C7AD6
      JMP SHORT Adr2
   }
}

Naked(AsmTest5)
{
   DWORD Adr1, Adr2;
   _asm
   {
WhiteTiger:
      MOVZX ECX, BYTE PTR SS : [EBP - 0x2]
      CMP ECX, 0x8                     // Exc Option
      JNE SHORT HullWolf                 // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH PetWhiteTiger                  // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x00641914
      JMP SHORT Adr2
      //
HullWolf:
      MOVZX ECX, BYTE PTR SS : [EBP - 0x2]
      CMP ECX, 0x16                  // Exc Option
      JNE SHORT Beast                 // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH PetHullWolf                  // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x00641914
      JMP SHORT Adr2
      //
Beast:
      MOVZX ECX, BYTE PTR SS : [EBP - 0x2]
      CMP ECX, 0x32                  // Exc Option
      JNE SHORT Here                 // Siguiente fenrir
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH PetBeast                   // Fenrir name
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x00641914
      JMP SHORT Adr2
      //

Here :
      PUSH 0
      PUSH 0
      MOV EDX, DWORD PTR SS : [EBP - 0x14]
      PUSH EDX
      MOV EAX, DWORD PTR SS : [EBP - 0x14]
      ADD EAX, 0x0FC   //252
      PUSH EAX
      PUSH 0x181
      mov Adr1, 0x00501700
      CALL Adr1
      ADD ESP, 14
      mov Adr2, 0x00641914
      JMP SHORT Adr2
   }
}

Naked(AsmTest6)
{
   DWORD Adr1, Adr2;
   _asm
   {
      MOV ECX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [ECX + 0x30], 0x180
      JE SHORT Here
      MOV ECX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [ECX + 0x30], 0x181
      JE SHORT Here
      MOV ECX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [ECX + 0x30], 0x182
      JE SHORT Here
      MOV ECX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [ECX + 0x30], 0x183
      JE SHORT Here
      MOV EDX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [EDX + 0x30], PetWhiteTiger
      JE SHORT Here
      MOV EDX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [EDX + 0x30], PetHullWolf
      JE SHORT Here
      MOV EDX, DWORD PTR SS : [EBP + 0x8]
      CMP DWORD PTR DS : [EDX + 0x30], PetBeast
      JE SHORT Here

      Here :
      mov Adr1, 0x0050387C
      JMP Adr1
   }
}

Naked(SetNewPetMovement)
{
   DWORD Adr1,Adr2;
   _asm
   {
      CMP DWORD PTR SS:[EBP-0x124],0x180 //Red Fenrir
      JLE SHORT Here
      CMP DWORD PTR SS:[EBP-0x124],0x181 //Black Fenrir
      JLE SHORT Here
      CMP DWORD PTR SS:[EBP-0x124],0x182 //Blue Fenrir
      JLE SHORT Here
      CMP DWORD PTR SS:[EBP-0x124],0x183 //Golden Fenrir
      JLE SHORT Here
      CMP DWORD PTR SS:[EBP-0x124], PetWhiteTiger
      JE SHORT Here
      CMP DWORD PTR SS:[EBP-0x124], PetHullWolf
      JE SHORT Here
      CMP DWORD PTR SS:[EBP-0x124], PetBeast
      JE SHORT Here

      MOV Adr2, 0x0050339A
      JMP Adr2
Here:
      MOV Adr1, 0x0050190F
      JMP Adr1
   }
}

Naked(SetNewPetScale)
{
   DWORD Adr1,Adr2,Adr3;
   _asm
   {
      MOV DWORD PTR SS:[EBP-0x04],EAX
      CMP DWORD PTR SS:[EBP-0x04],0x0E9
      JE ScaleItNow

      MOV DWORD PTR SS:[EBP-0x04],EAX
      CMP DWORD PTR SS:[EBP-0x04],0x143
      JE ScaleItNow

      MOV DWORD PTR SS:[EBP-0x04],EAX
      CMP DWORD PTR SS:[EBP-0x04],0x0E2
      JE ScaleItNow

      MOV DWORD PTR SS:[EBP-0x04],EAX
      CMP DWORD PTR SS:[EBP-0x04],PetWhiteTiger
      JE ScaleItNow

      MOV DWORD PTR SS:[EBP-0x04],EAX
      CMP DWORD PTR SS:[EBP-0x04],PetHullWolf
      JE ScaleItNow

      MOV DWORD PTR SS:[EBP-0x04],EAX
      CMP DWORD PTR SS:[EBP-0x04],PetBeast
      JE ScaleItNow

      CMP DWORD PTR SS:[EBP-0x04],0x183 //Golden fenrir
      JG DontScale   

      CMP DWORD PTR SS:[EBP-0x04],0x180 //Red Fenrir
      JGE ScaleItNow

      MOV Adr3,0x0050153E
      JMP Adr3
DontScale:
      MOV Adr1,0x0050155E
      JMP SHORT Adr1
ScaleItNow:
      MOV Adr2,0x00501579
      JMP SHORT Adr2
   }
}

struct TestStruct
{
   byte Gap[8];
   int Texture;
   int EffectID;
   byte Gap2[56];
   float R;
   float G;
   float B;
};
TestStruct *Temp1;

Naked(SetNewPetSkillEffect)
{
   DWORD Adr1,Adr2;
   _asm
   {
      mov Adr1, EDX
   }

   Temp1 = (TestStruct*) Adr1;

   if (&Temp1->EffectID)
   {
      switch (Temp1->EffectID)
      {
      
      case 1:
         Temp1->Texture = 0x7D86u;
         Temp1->R = 1.0;
         Temp1->G = 0.6;
         Temp1->B = 0.6;
         break;
      case 2:
         Temp1->Texture = 0x7D86u;
         Temp1->R = 0.7;
         Temp1->G = 0.7;
         Temp1->B = 1.0;
         break;
      case 3:
         Temp1->Texture = 0x7D86u;
         Temp1->R = 0.9;
         Temp1->G = 0.9;
         Temp1->B = 0.3;
         break;
      case 4:
         Temp1->Texture = 0x7DECu;
         Temp1->R = 0.1;
         Temp1->G = 0.8;
         Temp1->B = 0.1;
         break;
      case 5:
         Temp1->Texture = 0x7DECu;
         Temp1->R = 1.0;
         Temp1->G = 0.3;
         Temp1->B = 0.2;
         break;
      case 6:
         Temp1->Texture = 0x7DECu;
         Temp1->R = 0.2;
         Temp1->G = 0.3;
         Temp1->B = 1.0;
         break;
      case 7:
         Temp1->Texture = 0x7DECu;
         Temp1->R = 0.8;
         Temp1->G = 0.8;
         Temp1->B = 0.1;
         break;

   //WHITE TIGER
      case 8:
         Temp1->Texture = 0x7D1Au;
         Temp1->R = 0.5;
         Temp1->G = 0.01;
         Temp1->B = 0.01;
         break;
      case 11:
         Temp1->Texture = 0x7D1Au;
         Temp1->R = 0.5;
         Temp1->G = 0.01;
         Temp1->B = 0.01;
         break;
      case 12:
         Temp1->Texture = 0x7D1Au;
         Temp1->R = 0.3;
         Temp1->G = 0.01;
         Temp1->B = 0.4;
         break;

   //HULL WOLF (Ice Effect)
      case 13:
         Temp1->Texture = 0x7E35;
         Temp1->R = 0.1;
         Temp1->G = 0.1;
         Temp1->B = 1.0;
         break;
      case 16:
         Temp1->Texture = 0x7E36;
         Temp1->R = 0.1;
         Temp1->G = 0.1;
         Temp1->B = 1.0;
         break;
      case 17:
         Temp1->Texture = 0x7E36;
         Temp1->R = 0.1;
         Temp1->G = 0.1;
         Temp1->B = 1.0;
         break;

   //BEAST
      case 18:
         Temp1->Texture = 0x7D1E;
         Temp1->R = 1.0;
         Temp1->G = 0.35;
         Temp1->B = 0.0;
         break;
      case 21:
         Temp1->Texture = 0x7D1F;
         Temp1->R = 1.0;
         Temp1->G = 0.35;
         Temp1->B = 0.0;
         break;
      case 22:
         Temp1->Texture = 0x7D1C;
         Temp1->R = 1.0;
         Temp1->G = 0.35;
         Temp1->B = 0.0;
         break;


      default:
         Temp1->Texture = 0x7D86u;
         Temp1->R = 0.7;
         Temp1->G = 1.0;
         Temp1->B = 0.7;
      }
   }

   _asm
   {
      MOV Adr2, 0x00730079
      JMP Adr2
   }

}

Naked(SetNewPetItemLevelTooltipLines)
{
   DWORD Addr1, Addr2;

   _asm
   {
      MOV Addr1, 0x007E3FC3
      MOV Addr2, 0x007E3FDE
//Golden Fenrir
      MOV EDX,DWORD PTR SS:[EBP+0x10]
      MOVZX EAX,BYTE PTR DS:[EDX+0x17]
      CMP EAX, 4                     //Exc Option
      JNZ SHORT WhiteTiger              // Siguiente fenrir
      MOV ECX,DWORD PTR SS:[EBP-0x13C8]
      MOV DWORD PTR DS:[ECX+0x11BB64],0x03 //Linea 91 en ItemLevelTooltip_spn

WhiteTiger:
      MOV EDX,DWORD PTR SS:[EBP+0x10]
      MOVZX EAX,BYTE PTR DS:[EDX+0x17]
      CMP EAX, 8                     //Exc Option
      JNZ SHORT HullWolf              // Siguiente fenrir
      MOV ECX,DWORD PTR SS:[EBP-0x13C8]
      MOV DWORD PTR DS:[ECX+0x11BB64],17   //Linea 105 en ItemLevelTooltip_spn

HullWolf:
      MOV EDX,DWORD PTR SS:[EBP+0x10]
      MOVZX EAX,BYTE PTR DS:[EDX+0x17]
      CMP EAX, 16                     //Exc Option
      JNZ SHORT Beast                 // Siguiente fenrir
      MOV ECX,DWORD PTR SS:[EBP-0x13C8]
      MOV DWORD PTR DS:[ECX+0x11BB64],18   //Linea 106 en ItemLevelTooltip_spn

Beast:
      MOV EDX,DWORD PTR SS:[EBP+0x10]
      MOVZX EAX,BYTE PTR DS:[EDX+0x17]
      CMP EAX, 32                     //Exc Option
      JNZ SHORT TheExit                  // Siguiente fenrir
      MOV ECX,DWORD PTR SS:[EBP-0x13C8]
      MOV DWORD PTR DS:[ECX+0x11BB64],19   //Linea 107 en ItemLevelTooltip_spn

TheExit:
      JMP SHORT Addr1
   }
}

ObjectItem *TheItem;
Naked(SetNewPetItemNameColor)
{
   DWORD Adr1,Adr2;
   _asm
   {
      MOV EBX, DWORD PTR SS:[EBP+0x10]
      MOV Adr1, EBX
   }

   TheItem = (ObjectItem*) Adr1;

   if(TheItem->ItemID == ITEM(13,37) && TheItem->ExcellentOption == 1)
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x2 //My New Item Name Color
      }
   }

   else if(TheItem->ItemID == ITEM(13,37) && TheItem->ExcellentOption == 2)
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x3 //My New Item Name Color
      }
   }

   else if(TheItem->ItemID == ITEM(13,37) && TheItem->ExcellentOption == 4)
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x4 //My New Item Name Color
      }
   }

   else if(TheItem->ItemID == ITEM(13,37) && TheItem->ExcellentOption ==
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x7 //My New Item Name Color
      }
   }

   else if(TheItem->ItemID == ITEM(13,37) && TheItem->ExcellentOption == 16)
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x7 //My New Item Name Color
      }
   }

   else if(TheItem->ItemID == ITEM(13,37) && TheItem->ExcellentOption == 32)
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x7 //My New Item Name Color
      }
   }


   else
   {
      _asm
      {
         MOV DWORD PTR SS:[EBP-0x6C],0x1 //
      }
   }

   _asm
   {
      MOV Adr2, 0x007E48FA
      JMP Adr2
   }
}

void NewPets::Load()
{

   SetOp((LPVOID)0x005803E5, (LPVOID)0x0058056F, ASM::JMP); // New Pets fix
   SetByte(0x005803EA, 0x90); // New Pets fix

   // Set New Pets Skins
   SetRange((LPVOID)0x008360BF, 27, ASM::NOP);
   SetOp((LPVOID)0x008360BF, SetNewPetSkins, ASM::CALL);

   SetRange((LPVOID)0x006418F5, 28, ASM::NOP);
   SetOp((LPVOID)0x006418F5, FixVisualBug, ASM::CALL);
   
   SetRange((LPVOID)0x0048FA7E, 42, ASM::NOP);
   SetOp((LPVOID)0x0048FA7E, AsmTest3, ASM::CALL);

   SetRange((LPVOID)0x005C7AB8, 26, ASM::NOP);
   SetOp((LPVOID)0x005C7AB8, AsmTest4, ASM::CALL);

   SetRange((LPVOID)0x006418F5, 27, ASM::NOP);
   SetOp((LPVOID)0x006418F5, AsmTest5, ASM::CALL);
   
   SetRange((LPVOID)0x00503868, 11, ASM::NOP);
   SetOp((LPVOID)0x00503868, AsmTest6, ASM::CALL);

   SetRange((LPVOID)0x005018E9, 16, ASM::NOP);
   SetOp((LPVOID)0x005018E9, SetNewPetMovement, ASM::CALL);

   SetRange((LPVOID)0x00501529, 20, ASM::NOP);
   SetOp((LPVOID)0x00501529, SetNewPetScale, ASM::CALL);

   SetRange((LPVOID)0x0054E8A0, 76, ASM::NOP);
   SetOp((LPVOID)0x0054E8A0, this->GetFenrirSkillColor, ASM::JMP);

   SetRange((LPVOID)0x0072FEBB, 54, ASM::NOP);
   SetOp((LPVOID)0x0072FEBB, SetNewPetSkillEffect, ASM::JMP);

   //Nombre en ItemLevelTooltip
   SetRange((LPVOID)0x007E3FA5, 29, ASM::NOP);
   SetOp((LPVOID)0x007E3FA5, SetNewPetItemLevelTooltipLines, ASM::JMP);

   //Color caja de nombre
   SetRange((LPVOID)0x007E48F3, 7, ASM::NOP);
   SetOp((LPVOID)0x007E48F3, SetNewPetItemNameColor, ASM::JMP);
}

int NewPets::GetFenrirSkillColor(ObjectPreview * gPreview)
{
   int result = 1;

   switch ( gPreview->PetExcellent )
   {
   case 1:
      result = 0;
      break;
   case 2:
      result = 2;
      break;
   case 4:
      result = 3;
      break;
   case 8:
      result = 8;
      break;
   case 16:
      result = 13;
      break;
   case 32:
      result = 18;
      break;

   default:
      result = 1;
      break;
   }
   return result;
}

//#endif

Para editarlos:
Citar
/make 13 37 15 1 1 7 8 -> PetWhiteTiger
/make 13 37 15 1 1 7 16 -> PetHullWolf
/make 13 37 15 1 1 7 32 -> PetBeast