Source Fake Online + Guia

# Guía de Integración FakeOnline v4 En base a files muemu

## 0. Preparación

1. Asegúrate de tener una copia de seguridad de todos los archivos antes de hacer cambios.
2. Los archivos base (FakeOnline.h, FakeOnline.cpp, FakeOnlineDefine.h) ya deben estar copiados.
3. Sigue los pasos en orden exacto.

## 1. Archivos a Modificar

### 1.1 GameServer.cpp
Ubicación: /GameServer/GameServer/GameServer.cpp

1. Agregar include (línea 33, después de `#include "IpManager.h"`):
```cpp
#include "FakeOnline.h"
```

2. Agregar menús de FakeOnline (dentro del switch de WM_COMMAND, antes de `case IDM_RELOAD_RELOADCASHSHOP:`):
```cpp
#if USE_FAKE_ONLINE == TRUE
//==========FakeOnline   
case ID_FAKEONLINE_RELOADDATA:
    s_FakeOnline.LoadFakeData(".\\AutoTrain.xml");
    break;
case ID_FAKEONLINE_ADDFAKEONLINE:
{
    if (gJoinServerConnection.CheckState() != 0 && gDataServerConnection.CheckState() != 0)
    {
        s_FakeOnline.RestoreFakeOnline();
    }
}
    break;
case ID_FAKEONLINE_DELFAKEONLINE:
{
    for (int n = OBJECT_START_USER; n < MAX_OBJECT; n++)
    {
        if (gObjIsConnectedGP(n) != 0 && gObj[n].IsFakeOnline)
        {
            s_FakeOnline.OnAttackAlreadyConnected(&gObj[n]);
            LogAdd(LOG_RED, "[ FakeOnline ] Disconnect Account");
        }
    }
}
    break;
#endif
```



### 1.1 ServerInfo.h
Ubicación: /GameServer/GameServer/ServerInfo.h

1. Agregar include (línea 10, después de `#include "User.h"`):
```cpp
#include "FakeOnlineDefine.h"
```

2. Agregar función (línea 43, después de `void ReloadAll();`):
```cpp
#if USE_FAKE_ONLINE == 1
    void ReloadBotFakeUserOnline();
#endif
```

### 1.2 Party.cpp
Ubicación: /GameServer/GameServer/Party.cpp

1. Agregar include (línea 14, después de `#include "Message.h"`):
```cpp
#include "FakeOnline.h"
```

2. Modificar CGPartyRequestRecv (línea 320, antes de `LPOBJ lpObj = &gObj[aIndex];`):
```cpp
#if USE_FAKE_ONLINE == 1
    // Verificar si el usuario que envía la invitación es un usuario fake
    if (s_FakeOnline.IsFakeUser(aIndex)) {
        return;
    }
    // Verificar si el objetivo es un usuario fake
    if (s_FakeOnline.IsFakeUser(lpMsg->index)) {
        s_FakeOnline.OnFakeUserPartyRequest(aIndex, lpMsg->index);
        return;
    }
#endif
```

3. Modificar AddMember (línea 181, antes del primer if):
```cpp
#if USE_FAKE_ONLINE == 1
    if (s_FakeOnline.IsFakeUser(aIndex)) {
        s_FakeOnline.OnFakeUserJoinParty(index, aIndex);
    }
#endif
```

4. Modificar DelMember (línea 208, antes del primer if):
```cpp
#if USE_FAKE_ONLINE == 1
    if (s_FakeOnline.IsFakeUser(aIndex)) {
        s_FakeOnline.OnFakeUserLeaveParty(index, aIndex);
    }
#endif
```

### 1.3 EventPvP.cpp
Ubicación: /GameServer/GameServer/EventPvP.cpp

1. Agregar include (línea 15, después de `#include "Util.h"`):
```cpp
#include "FakeOnline.h"
```

2. Modificar EventPvPDead (línea 232, al inicio de la función):
```cpp
#if USE_FAKE_ONLINE == 1
    if (s_FakeOnline.IsFakeUser(aIndex) || s_FakeOnline.IsFakeUser(bIndex)) {
        s_FakeOnline.OnFakeUserPvPDeath(aIndex, bIndex);
        return;
    }
#endif
```

3. Modificar EventPvPTradeJoin (línea 187, al inicio de la función):
```cpp
#if USE_FAKE_ONLINE == 1
    if (s_FakeOnline.IsFakeUser(aIndex) || s_FakeOnline.IsFakeUser(bIndex)) {
        return false; // Los usuarios fake no pueden participar en duelos por comercio
    }
#endif
```

### 1.4 Protocol.cpp
Ubicación: /GameServer/GameServer/Protocol.cpp

1. Agregar include (línea 82, después de `#include "InvasionManager.h"`):
```cpp
#include "FakeOnline.h"
```

2. Modificar CGChatRecv (línea 1396, después de `gFilter.CheckSyntax(lpMsg->message);`):
```cpp
#if USE_FAKE_ONLINE == 1
    // Verificar si es un comando de FakeOnline
    if (s_FakeOnline.ProcessChatCommand(lpObj, lpMsg->message)) {
        return;
    }
#endif
```

### 1.5 Message.cpp
Ubicación: /GameServer/GameServer/Message.cpp

1. Agregar include (línea 9, después de `#include "User.h"`):
```cpp
#include "FakeOnline.h"
```

2. Modificar Load (línea 47, dentro del try, después de la inserción del mensaje):
```cpp
#if USE_FAKE_ONLINE == 1
    // Agregar mensajes específicos para el sistema FakeOnline
    MESSAGE_INFO info;
   
    info.Index = 9000;
    strcpy_s(info.Message, "[FakeOnline] %s ha entrado al juego");
    this->m_MessageInfo.insert(std::pair<int,MESSAGE_INFO>(info.Index,info));
   
    info.Index = 9001;
    strcpy_s(info.Message, "[FakeOnline] %s ha salido del juego");
    this->m_MessageInfo.insert(std::pair<int,MESSAGE_INFO>(info.Index,info));
   
    info.Index = 9002;
    strcpy_s(info.Message, "[FakeOnline] %s se ha unido al party");
    this->m_MessageInfo.insert(std::pair<int,MESSAGE_INFO>(info.Index,info));
   
    info.Index = 9003;
    strcpy_s(info.Message, "[FakeOnline] %s ha dejado el party");
    this->m_MessageInfo.insert(std::pair<int,MESSAGE_INFO>(info.Index,info));
#endif
```

## 2. Estructura de Datos FakeOnline

### 2.1 Campos Principales en OBJECTSTRUCT

Los siguientes campos se agregan a la estructura OBJECTSTRUCT cuando USE_FAKE_ONLINE está habilitado:

```cpp
// Campos principales de FakeOnline
bool IsFakeOnline;          // Indica si el usuario es un usuario falso en línea
DWORD m_OfflineMoveDelay;   // Retraso entre acciones de movimiento
bool IsFakeRegen;           // Bandera para regeneración falsa
int IsFakePVPMode;          // Estado del modo PvP para usuario falso
int IsFakePartyMode;        // Estado del modo Party para usuario falso
int IsFakeMoveRange;        // Rango de movimiento para usuario falso
DWORD IsFakeTimeLag;        // Simulación de retraso de tiempo
DWORD IsFakeSendParty;      // Temporización relacionada con party

// Campos de recolección de items
BYTE ObtainPickNear;        // Recoger items cercanos
BYTE ObtainPickSelected;    // Recoger items seleccionados
BYTE ObtainPickJewels;      // Recoger joyas
BYTE ObtainPickAncient;     // Recoger items antiguos
BYTE ObtainPickMoney;       // Recoger dinero
BYTE ObtainPickExcellent;   // Recoger items excelentes
BYTE ObtainPickExtra;       // Recoger items extra
char ObtainPickItemList[12][16]; // Lista de items para recoger
int ObtainPickExtraCount;   // Contador de items extra a recoger

// Campos de posicionamiento
short m_OfflineCoordX;      // Coordenada X para posición offline
short m_OfflineCoordY;      // Coordenada Y para posición offline
DWORD m_OfflineTimeResetMove; // Tiempo para reiniciar movimiento
```

### 2.2 Modo Offline y Helper

Cuando OFFLINE_MODE_NEW está habilitado:
```cpp
OFFLINE_MODE_DATA OfflineMode;  // Estructura de datos del modo offline

// Si USE_OFFLINEMODE_HELPER_PICK está habilitado
int MuHelperItemsCount;      // Contador de items para el helper
int MuHelperItems[100];      // Array de items del helper
BYTE HelperItems[12][16];   // Configuración de items del helper
```

### 2.3 Control del Modo Offline
```cpp
bool m_OfflineSocket;       // Estado del socket para modo offline
int m_OfflineMode;         // Estado del modo offline
int MuOffHelperTime;       // Temporización del helper en modo offline
```

## 3. Implementación de Funciones Principales

### 3.1 Gestión de Datos y Conexión

```cpp
// Carga la configuración de usuarios falsos desde XML
void LoadFakeData(char* path)

// Restaura los usuarios falsos en el servidor
void RestoreFakeOnline()

// Obtiene información de un usuario falso
OFFEXP_DATA* GetOffExpInfo(LPOBJ lpObj)
OFFEXP_DATA* GetOffExpInfoByAccount(LPOBJ lpObj)
```

### 3.2 Movimiento y Animación

```cpp
// Maneja el movimiento de usuarios falsos
void FakeAnimationMove(int aIndex, int x, int y, bool dixa)

// Retorna al usuario a su posición original
void QuayLaiToaDoGoc(int aIndex)
```

### 3.3 Combate y Habilidades

```cpp
// Procesa ataques de usuarios falsos
void FakeAttackProc(LPOBJ lpObj)
void Attack(int aIndex)

// Gestiona el uso automático de habilidades
void TuDongDanhSkill(int aIndex)
void TuDongBuffSkill(int aIndex)

// Envía diferentes tipos de ataques
void SendSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)
void SendMultiSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)
void SendDurationSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)
void SendRFSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)
```

### 3.4 Recolección de Items

```cpp
// Verifica si un item es una joya
bool FakeisJewels(int index)

// Verifica si un item está en la lista de recolección
bool FakeitemListPickUp(int Index, int Level, LPOBJ lpObj)

// Procesa la recolección de items
int NhatItem(int aIndex)
```

### 3.5 Sistema de Party

```cpp
// Envía solicitud de party
void GuiYCParty(int aIndex, int bIndex)

// Obtiene objetivo para party
bool GetTargetPlayer(LPOBJ lpObj, int SkillNumber, int* MonsterIndex)
```

### 3.6 Mantenimiento y Soporte

```cpp
// Repara items automáticamente
void FakeAutoRepair(int aIndex)

// Gestiona el uso de pociones
void SuDungMauMana(int aIndex)

// Envía mensajes al chat
void PostChatMSG(LPOBJ lpObj)
```

## 4. Integración con el Bucle Principal

### 4.1 GameMain.cpp

El sistema FakeOnline se integra en el bucle principal del juego a través del temporizador QUEUE_TIMER_VIEWPORT en la función QueueTimerCallback:

```cpp
case QUEUE_TIMER_VIEWPORT:
    gObjViewportProc();
    #if USE_FAKE_ONLINE == TRUE
    for (int n = OBJ_STARTUSERINDEX; n < MAX_OBJECT; n++)
    {
        if(gObj[n].Type != OBJECT_USER) {
            continue;
        }

        // Verificación anti-hack (si está habilitado)
        #if(ANTIHACKGS)
        gBProtect.KiemTraDiChuyen(n);   
        #endif

        // Procesar recolección y movimiento offline
        g_OfflineMode.PickUP(n);
        g_OfflineMode.regresar(n);

        // Procesar funciones de FakeOnline
        s_FakeOnline.NhatItem(n);         // Recolección de items
        s_FakeOnline.QuayLaiToaDoGoc(n);  // Retorno a posición base

        // Integración con otros sistemas (si están habilitados)
        #if(CHIEN_TRUONG_CO)
        gChienTruongCo.CheckTimeInCTC(n);
        #endif
    }
    #endif
```

Esta integración asegura que:
1. Los usuarios falsos sean procesados en cada ciclo del viewport
2. La recolección de items y el movimiento se realicen de forma automática
3. El sistema esté sincronizado con otros componentes del juego
4. Se mantenga la compatibilidad con sistemas anti-hack

### 4.2 Orden de Ejecución

1. Primero se procesa el viewport normal (gObjViewportProc)
2. Luego se procesan los usuarios falsos:
   - Verificación de tipo de objeto
   - Verificaciones anti-hack
   - Recolección de items offline
   - Retorno a posición base offline
   - Recolección de items FakeOnline
   - Retorno a posición base FakeOnline
3. Finalmente se procesan integraciones con otros sistemas

### 4.3 Gestión de Objetos

Los objetos falsos se gestionan a través del sistema ObjectManager, que proporciona las siguientes funcionalidades clave:

1. Inicialización de Objetos:
   ```cpp
   void ObjectSetStateCreate(int aIndex)
   ```
   - Maneja la creación y estado inicial de objetos
   - Gestiona el teletransporte de usuarios y monstruos
   - Configura las posiciones iniciales

2. Procesamiento de Estado:
   ```cpp
   void ObjectStateProc(LPOBJ lpObj, int MessageCode, int aIndex, int SubCode)
   ```
   - Procesa mensajes y estados de objetos
   - Maneja cambios de estado para usuarios falsos
   - Coordina acciones entre objetos

3. Movimiento y Posicionamiento:
   ```cpp
   void ObjectMoveProc()
   ```
   - Gestiona el movimiento de todos los objetos
   - Actualiza posiciones en tiempo real
   - Sincroniza movimientos con otros jugadores

4. Atributos y Cálculos:
   ```cpp
   void CharacterCalcAttribute(int aIndex)
   ```
   - Calcula atributos de personajes
   - Aplica modificadores de estado
   - Actualiza estadísticas en tiempo real

La integración con FakeOnline requiere:

1. Verificar que los objetos falsos estén marcados correctamente con:
   ```cpp
   lpObj->Type == OBJECT_USER
   lpObj->IsFakeOnline == TRUE
   ```

2. Asegurar que los estados se procesen en el orden correcto:
   - Creación de objeto
   - Inicialización de atributos
   - Procesamiento de movimiento
   - Actualización de viewport

3. Mantener la sincronización con:
   - Sistema de combate
   - Recolección de items
   - Interacciones con otros jugadores
   - Sistema anti-hack

### 4.4 Sistema de Ataque

El sistema de ataque personalizado (CustomAttack) proporciona las siguientes funcionalidades:

1. Tipos de Ataques:
   ```cpp
   // Ataque básico con una habilidad
   void SendSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)

   // Ataque múltiple a objetivos en rango
   void SendMultiSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)

   // Ataque con duración (buffs/debuffs)
   void SendDurationSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)

   // Ataque especial para Rage Fighter
   void SendRFSkillAttack(LPOBJ lpObj, int aIndex, int SkillNumber)
   ```

2. Selección de Objetivos:
   ```cpp
   // Buscar monstruos cercanos
   bool GetTargetMonster(LPOBJ lpObj, int SkillNumber, int* MonsterIndex)

   // Buscar miembros del party para buffs
   void GetTargetParty(LPOBJ lpObj, int SkillNumber)
   ```

3. Habilidades de Soporte:
   ```cpp
   // Buffs automáticos para Elf
   void ElfBuffs(LPOBJ lpObj)
   {
       // Verificar y aplicar buffs:
       // - Greater Defense
       // - Greater Damage
       // - Heal
       // - Infinity Arrow
   }
   ```

4. Configuración y Control:
   - Temporizadores para ataques y buffs
   - Verificación de requisitos de nivel y reset
   - Control de modo offline
   - Gestión de consumo de recursos

5. Integración con FakeOnline:
   - Los usuarios falsos utilizan el mismo sistema de ataque
   - Se mantiene la sincronización con el viewport
   - Se respetan las restricciones de mapa y estado
   - Se gestionan los efectos y buffs automáticamente

## 5. Estructura de Datos

### 5.1 Estructura OFFEXP_DATA

La estructura OFFEXP_DATA almacena la información de cada usuario falso:

```cpp
struct OFFEXP_DATA
{
    char Account[11];     // Cuenta del usuario falso
    char Password[11];    // Contraseña
    char Name[11];        // Nombre del personaje

    WORD SkillID;         // ID de la habilidad principal
    WORD UseBuffs[3];     // Buffs a utilizar
    int TuNhatItem;       // Config. de recolección de items

    int TuDongReset;      // Auto-reset habilitado
    int GateNumber;       // Portal de spawn
    int MapX;             // Coordenada X en el mapa
    int MapY;             // Coordenada Y en el mapa
    int PhamViTrain;      // Rango de entrenamiento
    int TimeReturn;       // Tiempo de retorno
    int PostKhiDie;       // Comportamiento al morir
    int PVPMode;          // Modo PvP
    int PartyMode;        // Modo Party
    int MoveRange;        // Rango de movimiento
};
```

### 5.2 Clase CFakeOnline

La clase CFakeOnline gestiona toda la funcionalidad de usuarios falsos:

1. Gestión de Datos:
   ```cpp
   void LoadFakeData(char* path);      // Carga datos desde archivo
   void RestoreFakeOnline();          // Restaura usuarios falsos
   void AddToList(LPOBJ lpObj);       // Añade usuario a la lista
   void DelFromList(char* account);    // Elimina usuario de la lista
   void WriteToFile();                // Guarda datos en archivo
   ```

2. Acceso a Datos:
   ```cpp
   OFFEXP_DATA* GetOffExpInfo(LPOBJ lpObj);
   OFFEXP_DATA* GetOffExpInfoByAccount(LPOBJ lpObj);
   ```

3. Combate y Habilidades:
   ```cpp
   void FakeAttackProc(LPOBJ lpObj);   // Procesa ataques
   void Attack(int UserIndex);         // Realiza ataque
   void TuDongDanhSkill(int aIndex);   // Auto-skill
   void TuDongBuffSkill(int aIndex);   // Auto-buff
   ```

4. Movimiento y Posicionamiento:
   ```cpp
   void QuayLaiToaDoGoc(int aIndex);   // Retorno a posición
   ```

5. Interacción Social:
   ```cpp
   void PostChatMSG(LPOBJ lpObj);      // Envía mensajes
   void GuiYCParty(int aIndex, int bIndex); // Solicitud party
   ```

6. Atributos Principales:
   ```cpp
   std::map<std::string, OFFEXP_DATA> m_Data; // Datos de usuarios
   int AccountsRestored;    // Contador de cuentas restauradas
   DWORD TimeFakeLogIn;    // Tiempo de último login
   ```

## 6. Manejo de Inventario e Items

### 6.1 Estructura del Inventario

El sistema utiliza las siguientes constantes para definir las áreas del inventario:

```cpp
#define INVENTORY_WEAR_SIZE     12  // Slots de equipamiento
#define INVENTORY_MAIN_SIZE     76  // Inventario principal
#define INVENTORY_EXT1_SIZE    108  // Primera extensión
#define INVENTORY_EXT2_SIZE    140  // Segunda extensión
#define INVENTORY_EXT3_SIZE    172  // Tercera extensión
#define INVENTORY_EXT4_SIZE    204  // Cuarta extensión
```

### 6.2 Gestión de Items

La clase CItemManager proporciona las siguientes funcionalidades:

1. Validación de Items:
   ```cpp
   bool CheckItemRequireLevel(LPOBJ lpObj, CItem* lpItem);
   bool CheckItemRequireClass(LPOBJ lpObj, int index);
   bool IsValidItem(LPOBJ lpObj, CItem* lpItem);
   ```

2. Movimiento de Items:
   ```cpp
   BYTE MoveItemToInventoryFromInventory(LPOBJ lpObj, BYTE SourceSlot, BYTE TargetSlot, BYTE TargetFlag);
   BYTE InventoryAddItem(int aIndex, CItem item, int slot);
   void InventoryDelItem(int aIndex, int slot);
   ```

3. Gestión de Espacio:
   ```cpp
   int GetInventoryEmptySlotCount(LPOBJ lpObj);
   BYTE InventoryRectCheck(int aIndex, int x, int y, int width, int height);
   bool CheckItemInventorySpace(LPOBJ lpObj, int width, int height);
   ```

### 6.3 Integración con FakeOnline

Los usuarios falsos utilizan el mismo sistema de inventario con algunas consideraciones especiales:

1. Inicialización:
   - Al crear un usuario falso, se debe inicializar su inventario
   - Los items equipados se cargan desde la configuración

2. Recolección Automática:
   ```cpp
   // Verificar si un item es válido para recolección
   bool FakeisJewels(int index);
   bool FakeitemListPickUp(int Index, int Level, LPOBJ lpObj);

   // Procesar recolección
   int NhatItem(int aIndex);
   ```

3. Mantenimiento:
   ```cpp
   // Reparación automática de items
   void FakeAutoRepair(int aIndex);

   // Gestión de consumibles
   void SuDungMauMana(int aIndex);
   ```

4. Restricciones:
   - Los usuarios falsos no pueden comerciar items
   - No pueden usar el almacén
   - No pueden participar en eventos especiales

### 6.4 Sincronización

El sistema mantiene la sincronización del inventario mediante:

1. Actualización de Viewport:
   ```cpp
   void UpdateInventoryViewport(int aIndex, int slot);
   void GCItemEquipmentSend(int aIndex);
   ```

2. Notificaciones:
   ```cpp
   void GCItemChangeSend(int aIndex, BYTE slot);
   void GCItemDeleteSend(int aIndex, BYTE slot, BYTE flag);
   void GCItemDurSend(int aIndex, BYTE slot, BYTE dur, BYTE flag);
   ```

## 7. Sistema de Movimiento y Posicionamiento

### 7.1 Sistema de Mapas

El sistema utiliza la clase CMap para gestionar los mapas del juego:

```cpp
#define MAX_MAP_WIDTH 256
#define MAX_MAP_HEIGHT 256
#define MAP_RANGE(x) (((x)<0)?0:((x)>=MAX_MAP)?0:1)
```

Funciones principales:

```cpp
BYTE GetAttr(int x, int y);  // Obtener atributos de una posición
bool CheckAttr(int x, int y, BYTE attr);  // Verificar atributos
bool CheckStandAttr(int x, int y);  // Verificar si se puede estar de pie
```

### 7.2 Sistema de Movimiento

La clase CMove maneja el movimiento de los personajes:

1. Estructura de Movimiento:
   ```cpp
   struct MOVE_INFO {
       int Index;
       char Name[32];
       int Money;
       int MinLevel;
       int MaxLevel;
       int MinReset;
       int MaxReset;
       int AccountLevel;
       int Gate;
   };
   ```

2. Funciones Principales:
   ```cpp
   void Move(LPOBJ lpObj, int index);  // Mover a una ubicación
   void GCTeleportSend(int aIndex, int gate, BYTE map, BYTE x, BYTE y, BYTE dir);
   ```

### 7.3 Integración con FakeOnline

Los usuarios falsos tienen consideraciones especiales para el movimiento:

1. Inicialización de Posición:
   ```cpp
   // Establecer posición inicial
   lpObj->X = gate->X;
   lpObj->Y = gate->Y;
   lpObj->TX = gate->X;
   lpObj->TY = gate->Y;
   lpObj->Map = gate->Map;
   ```

2. Movimiento Automático:
   ```cpp
   // Verificar si el movimiento es válido
   bool CanMove(LPOBJ lpObj, int x, int y);

   // Procesar movimiento
   void ProcessMovement(LPOBJ lpObj);
   ```

3. Restricciones:
   - No pueden moverse a mapas restringidos
   - Deben respetar los atributos del mapa
   - No pueden usar teletransporte manual

### 7.4 Sincronización

El sistema mantiene la sincronización de posición mediante:

1. Actualización de Viewport:
   ```cpp
   void ViewportCreate(LPOBJ lpObj);
   void ViewportDestroy(LPOBJ lpObj);
   ```

2. Notificaciones:
   ```cpp
   void GCPositionSend(int aIndex, BYTE x, BYTE y);
   void GCMapAttrSend(int aIndex, BYTE type, BYTE attr, BYTE flag);
   ```

## 8. Sistema de Combate y Habilidades

### 8.1 Sistema de Habilidades

La clase CSkillManager gestiona las habilidades del juego:

1. Estructura de Habilidad:
   ```cpp
   struct SKILL_INFO {
       int Index;
       char Name[32];
       int Damage;
       int Mana;
       int BP;
       int Range;
       int Radio;
       int Delay;
       int Type;
       int Effect;
       int RequireLevel;
       int RequireEnergy;
       int RequireLeadership;
       int RequireClass[MAX_CLASS];
   };
   ```

2. Tipos de Habilidades:
   ```cpp
   enum eSkillNumber {
       SKILL_NONE = 0,
       SKILL_POISON = 1,
       SKILL_METEORITE = 2,
       SKILL_LIGHTNING = 3,
       // ... más habilidades
   };
   ```

### 8.2 Sistema de Combate

La clase CAttack maneja el sistema de combate:

1. Funciones Principales:
   ```cpp
   bool Attack(LPOBJ lpObj, LPOBJ lpTarget, CSkill* lpSkill, bool send, BYTE flag, int damage, int count, bool combo);
   bool MissCheck(LPOBJ lpObj, LPOBJ lpTarget, CSkill* lpSkill, int send, int count, BYTE* miss);
   int GetAttackDamage(LPOBJ lpObj, LPOBJ lpTarget, CSkill* lpSkill, WORD* effect, int TargetDefense);
   ```

2. Cálculo de Daño:
   ```cpp
   // Daño base
   int GetTargetDefense(LPOBJ lpObj, LPOBJ lpTarget, WORD* effect);
   
   // Modificadores
   void WingSprite(LPOBJ lpObj, LPOBJ lpTarget, int* damage);
   void HelperSprite(LPOBJ lpObj, LPOBJ lpTarget, int* damage);
   ```

### 8.3 Integración con FakeOnline

Los usuarios falsos tienen consideraciones especiales para el combate:

1. Selección de Habilidades:
   ```cpp
   // Verificar si una habilidad es válida
   bool CanUseSkill(LPOBJ lpObj, int skill);

   // Seleccionar habilidad
   int SelectSkill(LPOBJ lpObj, LPOBJ lpTarget);
   ```

2. Procesamiento de Combate:
   ```cpp
   // Procesar ataque
   void ProcessAttack(LPOBJ lpObj);

   // Procesar defensa
   void ProcessDefense(LPOBJ lpObj);
   ```

3. Restricciones:
   - Solo pueden usar habilidades predefinidas
   - No pueden usar combos manuales
   - Tienen patrones de ataque predefinidos

### 8.4 Sincronización

El sistema mantiene la sincronización del combate mediante:

1. Notificaciones de Ataque:
   ```cpp
   void GCAttackSend(LPOBJ lpObj, int aIndex, int type);
   void GCDamageSend(int aIndex, int target, int damage, int type);
   ```

2. Notificaciones de Habilidad:
   ```cpp
   void GCSkillAttackSend(LPOBJ lpObj, int aIndex, int skill);
   void GCMagicAttackNumberSend(LPOBJ lpObj, int skill, int aIndex, int success);
   ```

## 9. Sistema de Party

### 9.1 Estructura del Party

La clase CParty gestiona los grupos de jugadores:

1. Constantes y Estructuras:
   ```cpp
   #define MAX_PARTY_USER 10
   #define MAX_PARTY_DISTANCE 10

   struct PARTY_INFO {
       int Count;
       int Index[MAX_PARTY_USER];
   };
   ```

2. Información de Miembros:
   ```cpp
   struct PMSG_PARTY_LIST {
       char name[10];
       BYTE number;
       BYTE map;
       BYTE x;
       BYTE y;
       DWORD CurLife;
       DWORD MaxLife;
       DWORD CurMana;
       DWORD MaxMana;
   };
   ```

### 9.2 Gestión de Party

Funciones principales para manejar grupos:

1. Verificación de Estado:
   ```cpp
   bool IsParty(int index);
   bool IsLeader(int index, int aIndex);
   bool IsMember(int index, int aIndex);
   ```

2. Administración de Miembros:
   ```cpp
   bool Create(int aIndex);
   bool Destroy(int index);
   bool AddMember(int index, int aIndex);
   bool DelMember(int index, int aIndex);
   void ChangeLeader(int index, int number);
   ```

### 9.3 Integración con FakeOnline

Los usuarios falsos tienen consideraciones especiales para el sistema de party:

1. Creación de Party:
   ```cpp
   // Verificar si se puede crear party
   bool CanCreateParty(LPOBJ lpObj);

   // Procesar creación
   void ProcessPartyCreation(LPOBJ lpObj);
   ```

2. Gestión de Miembros:
   ```cpp
   // Verificar si se puede unir
   bool CanJoinParty(LPOBJ lpObj, LPOBJ lpLeader);

   // Procesar unión
   void ProcessPartyJoin(LPOBJ lpObj, LPOBJ lpLeader);
   ```

3. Restricciones:
   - Solo pueden unirse a parties de usuarios reales
   - No pueden ser líderes de party
   - Tienen límites de distancia máxima

### 9.4 Sincronización

El sistema mantiene la sincronización del party mediante:

1. Notificaciones de Estado:
   ```cpp
   void GCPartyResultSend(int aIndex, BYTE result);
   void GCPartyListSend(int index);
   void GCPartyDelMemberSend(int aIndex);
   ```

2. Actualizaciones de Vida y Mana:
   ```cpp
   void GCPartyLifeSend(int index);
   struct PMSG_PARTY_LIFE {
       BYTE life;
       BYTE mana;
       char name[11];
   };
   ```

## 10. Sistema de Viewport

### 10.1 Estructura del Viewport

La clase CViewport gestiona la visibilidad de objetos en el juego:

1. Estados del Viewport:
   ```cpp
   enum eViewportState {
       VIEWPORT_NONE = 0,
       VIEWPORT_SEND = 1,
       VIEWPORT_WAIT = 2,
       VIEWPORT_DESTROY = 3
   };
   ```

2. Estructuras de Datos:
   ```cpp
   // Información de jugador en viewport
   struct PMSG_VIEWPORT_PLAYER {
       BYTE index[2];
       BYTE x;
       BYTE y;
       BYTE CharSet[18];
       char name[10];
       BYTE tx;
       BYTE ty;
       BYTE DirAndPkLevel;
       BYTE attribute;
       BYTE level[2];
       BYTE MaxHP[4];
       BYTE CurHP[4];
   };

   // Información de monstruo en viewport
   struct PMSG_VIEWPORT_MONSTER {
       BYTE index[2];
       BYTE type[2];
       BYTE x;
       BYTE y;
       BYTE tx;
       BYTE ty;
       BYTE DirAndPkLevel;
   };
   ```

### 10.2 Gestión del Viewport

Funciones principales para manejar la visibilidad:

1. Verificación de Posición:
   ```cpp
   bool CheckViewportObjectPosition(int aIndex, int map, int x, int y, int view);
   bool CheckViewportObject1(int aIndex, int bIndex, int type);
   bool CheckViewportObject2(int aIndex, int bIndex, int type);
   ```

2. Administración de Objetos:
   ```cpp
   bool AddViewportObject1(int aIndex, int bIndex, int type);
   void DestroyViewportPlayer1(int aIndex);
   void CreateViewportPlayer(int aIndex);
   void CreateViewportMonster(int aIndex);
   ```

### 10.3 Integración con FakeOnline

Los usuarios falsos tienen consideraciones especiales para el viewport:

1. Creación y Destrucción:
   ```cpp
   // Inicializar viewport
   void InitFakeViewport(LPOBJ lpObj);

   // Procesar destrucción
   void ProcessViewportDestroy(LPOBJ lpObj);
   ```

2. Actualización de Estado:
   ```cpp
   // Actualizar posición
   void UpdateViewportPosition(LPOBJ lpObj);

   // Procesar cambios
   void ProcessViewportUpdate(LPOBJ lpObj);
   ```

3. Restricciones:
   - Solo procesan objetos relevantes
   - Tienen un rango de visión limitado
   - No requieren actualizaciones constantes

### 10.4 Sincronización

El sistema mantiene la sincronización visual mediante:

1. Notificaciones de Creación:
   ```cpp
   void GCViewportCreate(int aIndex);
   void GCViewportPlayerCreate(int aIndex, int index);
   void GCViewportMonsterCreate(int aIndex, int index);
   ```

2. Notificaciones de Destrucción:
   ```cpp
   void GCViewportDestroy(int aIndex);
   void GCViewportPlayerDestroy(int aIndex, int index);
   struct PMSG_VIEWPORT_DESTROY {
       BYTE index[2];
   };
   ```

## 11. Sistema de Configuración

### 11.1 Estructura de Configuración

La clase CServerInfo gestiona la configuración del servidor:

1. Funciones de Lectura:
   ```cpp
   void ReadInit();
   void ReadCustomInfo();
   void ReadCharacterInfo();
   void ReloadBotFakeUserOnline();
   ```

2. Configuraciones Principales:
   ```cpp
   // Información del Servidor
   char m_ServerName[32];
   long m_ServerCode;
   long m_ServerPort;
   long m_ServerMaxUserNumber;

   // Límites y Restricciones
   int m_ServerMinLevel;
   int m_ServerMaxLevel;
   int m_ServerMinReset;
   int m_ServerMaxReset;
   ```

### 11.2 Configuración de FakeOnline

Opciones específicas para usuarios falsos:

1. Parámetros Básicos:
   ```cpp
   struct FAKE_ONLINE_CONFIG {
       int Enabled;
       int MaxUsers;
       int UpdateTime;
       int SafeZoneOnly;
   };
   ```

2. Configuración de Comportamiento:
   ```cpp
   struct FAKE_ONLINE_BEHAVIOR {
       int MovementEnabled;
       int MovementFrequency;
       int CombatEnabled;
       int CombatFrequency;
   };
   ```

### 11.3 Integración con FakeOnline

Los usuarios falsos tienen configuraciones especiales:

1. Verificaciones de Seguridad:
   ```cpp
   // Verificar zona segura
   bool InSafeZone(int aIndex);

   // Verificar límites
   bool CheckLimits(LPOBJ lpObj);
   ```

2. Gestión de Configuración:
   ```cpp
   // Cargar configuración
   void LoadFakeConfig();

   // Aplicar configuración
   void ApplyFakeConfig(LPOBJ lpObj);
   ```

3. Restricciones:
   - Limitados por zonas seguras
   - Configuración de comportamiento
   - Límites de nivel y reset

### 11.4 Archivo de Configuración

Ejemplo de configuración en ServerInfo.ini:

```ini
[FakeOnline]
Enabled = 1
MaxUsers = 100
UpdateTime = 1000
SafeZoneOnly = 1

[FakeOnlineBehavior]
MovementEnabled = 1
MovementFrequency = 5000
CombatEnabled = 1
CombatFrequency = 3000

[FakeOnlineLimits]
MinLevel = 1
MaxLevel = 400
MinReset = 0
MaxReset = 100
```

## 12. Sistema de Mensajes

### 12.1 Estructura de Mensajes

El sistema de mensajes utiliza diferentes protocolos para la comunicación:

1. Protocolos Principales:
   ```cpp
   // Protocolo Cliente-Servidor
   CSProtocol.h/cpp

   // Protocolo Base de Datos
   DSProtocol.h/cpp

   // Protocolo Join Server
   JSProtocol.h/cpp
   ```

2. Estructuras de Mensajes:
   ```cpp
   // Encabezado de mensaje
   struct PBMSG_HEAD {
       BYTE type;
       BYTE size;
       BYTE head;
   };

   // Encabezado extendido
   struct PWMSG_HEAD {
       BYTE type;
       BYTE size[2];
       BYTE head;
   };
   ```

### 12.2 Tipos de Mensajes

Mensajes específicos para usuarios falsos:

1. Mensajes de Estado:
   ```cpp
   // Actualización de estado
   struct PMSG_FAKE_STATUS {
       PBMSG_HEAD header;
       BYTE state;
       BYTE level;
       WORD experience;
   };

   // Actualización de posición
   struct PMSG_FAKE_POSITION {
       PBMSG_HEAD header;
       BYTE x;
       BYTE y;
       BYTE map;
   };
   ```

2. Mensajes de Interacción:
   ```cpp
   // Mensaje de chat
   struct PMSG_FAKE_CHAT {
       PBMSG_HEAD header;
       char message[90];
   };

   // Mensaje de acción
   struct PMSG_FAKE_ACTION {
       PBMSG_HEAD header;
       BYTE action;
       BYTE target[2];
   };
   ```

### 12.3 Integración con FakeOnline

Los usuarios falsos tienen consideraciones especiales para mensajes:

1. Procesamiento de Mensajes:
   ```cpp
   // Procesar mensaje entrante
   void ProcessIncomingMessage(LPOBJ lpObj, BYTE* msg);

   // Enviar mensaje
   void SendFakeMessage(LPOBJ lpObj, BYTE* msg, int size);
   ```

2. Gestión de Eventos:
   ```cpp
   // Notificar evento
   void NotifyFakeEvent(LPOBJ lpObj, int eventType);

   // Procesar respuesta
   void ProcessFakeResponse(LPOBJ lpObj, int eventType);
   ```

3. Restricciones:
   - No procesan todos los tipos de mensajes
   - Tienen prioridad reducida
   - Mensajes simplificados

### 12.4 Sincronización

El sistema mantiene la sincronización mediante:

1. Mensajes de Control:
   ```cpp
   // Sincronización de estado
   void GCSyncFakeStatus(int aIndex);

   // Sincronización de posición
   void GCSyncFakePosition(int aIndex);
   ```

2. Mensajes de Sistema:
   ```cpp
   // Notificación de sistema
   void GCSystemMessageSend(int aIndex, char* message);

   // Notificación de error
   void GCErrorMessageSend(int aIndex, int errorCode);
   ```

## 13. Sistema de Eventos y Notificaciones

### 13.1 Sistema de Notificaciones

La clase CNotice gestiona las notificaciones del servidor:

1. Estructuras de Notificación:
   ```cpp
   // Notificación estándar
   struct PMSG_NOTICE_SEND {
       PBMSG_HEAD header;
       BYTE type;
       BYTE count;
       BYTE opacity;
       WORD delay;
       DWORD color;
       BYTE speed;
       char message[256];
   };

   // Información de notificación
   struct NOTICE_INFO {
       char Message[128];
       int Type;
       int Count;
       int Opacity;
       int Delay;
       int Color;
       int Speed;
       int RepeatTime;
   };
   ```

2. Funciones de Notificación:
   ```cpp
   void GCNoticeSend(int aIndex, BYTE type, BYTE count, BYTE opacity, WORD delay, DWORD color, BYTE speed, char* message);
   void GCNoticeSendToAll(BYTE type, BYTE count, BYTE opacity, WORD delay, DWORD color, BYTE speed, char* message);
   ```

### 13.2 Sistema de Eventos

El servidor incluye varios tipos de eventos:

1. Eventos Estándar:
   ```cpp
   // Eventos PvP
   EventPvP.h/cpp

   // Eventos TvT (Team vs Team)
   EventTvT.h/cpp

   // Eventos de Buscar y Esconder
   EventHideAndSeek.h/cpp
   ```

2. Eventos Personalizados:
   ```cpp
   // Eventos de Drop
   CustomEventDrop.h/cpp

   // Eventos Temporizados
   CustomEventTime.h/cpp
   ```

### 13.3 Integración con FakeOnline

Los usuarios falsos tienen consideraciones especiales para eventos:

1. Participación en Eventos:
   ```cpp
   // Verificar participación
   bool CanJoinEvent(LPOBJ lpObj, int eventType);

   // Procesar participación
   void ProcessEventParticipation(LPOBJ lpObj, int eventType);
   ```

2. Gestión de Eventos:
   ```cpp
   // Manejar evento
   void HandleFakeEvent(LPOBJ lpObj, int eventType);

   // Procesar recompensa
   void ProcessEventReward(LPOBJ lpObj, int eventType);
   ```

3. Restricciones:
   - Participación limitada en eventos
   - Comportamiento predefinido
   - Sin recompensas especiales

### 13.4 Notificaciones Especiales

El sistema incluye notificaciones específicas para usuarios falsos:

1. Notificaciones de Estado:
   ```cpp
   // Notificación de conexión
   void GCFakeConnectionNotice(int aIndex);

   // Notificación de evento
   void GCFakeEventNotice(int aIndex, int eventType);
   ```

2. Mensajes del Sistema:
   ```cpp
   // Mensaje de estado
   void GCFakeStatusMessage(int aIndex, char* message);

   // Mensaje de error
   void GCFakeErrorMessage(int aIndex, int errorCode);
   ```

## 14. Sistema de Depuración y Registro

### 14.1 Sistema de Registro (Logging)

La clase CLog gestiona el registro de eventos del servidor:

1. Tipos de Registro:
   ```cpp
   enum eLogType {
       LOG_GENERAL = 0,
       LOG_CHAT = 1,
       LOG_COMMAND = 2,
       LOG_TRADE = 3,
       LOG_CONNECT = 4,
       LOG_HACK = 5,
       LOG_CASH_SHOP = 6,
       LOG_CHAOS_MIX = 7
   };
   ```

2. Estructura de Registro:
   ```cpp
   struct LOG_INFO {
       BOOL Active;
       char Directory[256];
       int Day;
       int Month;
       int Year;
       char Filename[256];
       HANDLE File;
   };
   ```

### 14.2 Registro de FakeOnline

Registros específicos para usuarios falsos:

1. Eventos de Conexión:
   ```cpp
   // Registro de conexión
   void LogFakeConnection(LPOBJ lpObj);

   // Registro de desconexión
   void LogFakeDisconnection(LPOBJ lpObj);
   ```

2. Eventos de Actividad:
   ```cpp
   // Registro de movimiento
   void LogFakeMovement(LPOBJ lpObj, int x, int y, int map);

   // Registro de acción
   void LogFakeAction(LPOBJ lpObj, int actionType);
   ```

### 14.3 Depuración

Herramientas para depurar usuarios falsos:

1. Funciones de Depuración:
   ```cpp
   // Verificar estado
   void DebugFakeState(LPOBJ lpObj);

   // Verificar posición
   void DebugFakePosition(LPOBJ lpObj);

   // Verificar inventario
   void DebugFakeInventory(LPOBJ lpObj);
   ```

2. Mensajes de Depuración:
   ```cpp
   // Mensaje de depuración
   void DebugMessageSend(LPOBJ lpObj, char* message);

   // Mensaje de error
   void DebugErrorSend(LPOBJ lpObj, int errorCode);
   ```

### 14.4 Monitoreo

Herramientas para monitorear usuarios falsos:

1. Estadísticas:
   ```cpp
   // Estadísticas generales
   void GetFakeStatistics();

   // Estadísticas por usuario
   void GetFakeUserStatistics(LPOBJ lpObj);
   ```

2. Rendimiento:
   ```cpp
   // Monitoreo de rendimiento
   void MonitorFakePerformance();

   // Monitoreo de recursos
   void MonitorFakeResources();
   ```

### 14.5 Archivos de Registro

Estructura de archivos de registro:

```plaintext
/GameServer/LOG/
  ├── FakeOnline/
  │   ├── Connection/
  │   │   ├── YYYY-MM-DD_connection.log
  │   │   └── YYYY-MM-DD_disconnection.log
  │   ├── Activity/
  │   │   ├── YYYY-MM-DD_movement.log
  │   │   └── YYYY-MM-DD_action.log
  │   └── Debug/
  │       ├── YYYY-MM-DD_state.log
  │       └── YYYY-MM-DD_error.log
  └── ...
```

## 15. Sistema de Seguridad y Validación

### 15.1 Validación de Usuarios

Sistema de validación para usuarios falsos:

1. Validación de Datos:
   ```cpp
   // Validar datos básicos
   bool ValidateFakeUserData(LPOBJ lpObj) {
       // Verificar nombre
       if (!CheckFakeUserName(lpObj->Name)) return false;

       // Verificar nivel
       if (!CheckFakeUserLevel(lpObj->Level)) return false;

       // Verificar clase
       if (!CheckFakeUserClass(lpObj->Class)) return false;

       return true;
   }

   // Validar equipamiento
   bool ValidateFakeUserItems(LPOBJ lpObj) {
       // Verificar items equipados
       if (!CheckFakeUserEquipment(lpObj)) return false;

       // Verificar inventario
       if (!CheckFakeUserInventory(lpObj)) return false;

       return true;
   }
   ```

2. Validación de Acciones:
   ```cpp
   // Validar movimiento
   bool ValidateFakeMovement(LPOBJ lpObj, int x, int y, int map) {
       // Verificar coordenadas
       if (!CheckFakeCoordinates(x, y, map)) return false;

       // Verificar distancia
       if (!CheckFakeDistance(lpObj, x, y)) return false;

       return true;
   }

   // Validar acción
   bool ValidateFakeAction(LPOBJ lpObj, int actionType) {
       // Verificar tipo de acción
       if (!CheckFakeActionType(actionType)) return false;

       // Verificar permisos
       if (!CheckFakePermissions(lpObj, actionType)) return false;

       return true;
   }
   ```

### 15.2 Medidas de Seguridad

Sistema de seguridad para usuarios falsos:

1. Protección Básica:
   ```cpp
   // Protección de datos
   void ProtectFakeUserData(LPOBJ lpObj) {
       // Encriptar datos sensibles
       EncryptFakeData(lpObj);

       // Aplicar hash a valores críticos
       HashFakeCriticalValues(lpObj);
   }

   // Protección de acciones
   void ProtectFakeUserActions(LPOBJ lpObj) {
       // Validar secuencia de acciones
       ValidateFakeActionSequence(lpObj);

       // Prevenir acciones inválidas
       PreventFakeInvalidActions(lpObj);
   }
   ```

2. Detección de Anomalías:
   ```cpp
   // Detectar comportamiento anómalo
   void DetectFakeAnomalies(LPOBJ lpObj) {
       // Verificar patrones de movimiento
       CheckFakeMovementPatterns(lpObj);

       // Verificar patrones de acción
       CheckFakeActionPatterns(lpObj);
   }

   // Respuesta a anomalías
   void HandleFakeAnomalies(LPOBJ lpObj, int anomalyType) {
       // Registrar anomalía
       LogFakeAnomaly(lpObj, anomalyType);

       // Aplicar medidas correctivas
       ApplyFakeCorrectiveMeasures(lpObj, anomalyType);
   }
   ```

### 15.3 Restricciones

Limitaciones de seguridad para usuarios falsos:

1. Restricciones de Acceso:
   - No pueden acceder a áreas restringidas
   - No pueden realizar acciones administrativas
   - No pueden modificar datos críticos

2. Restricciones de Interacción:
   - Interacción limitada con usuarios reales
   - No pueden comerciar items valiosos
   - No pueden participar en eventos especiales

### 15.4 Monitoreo de Seguridad

Sistema de monitoreo para usuarios falsos:

1. Monitoreo en Tiempo Real:
   ```cpp
   // Monitorear actividad
   void MonitorFakeActivity(LPOBJ lpObj) {
       // Verificar acciones actuales
       CheckFakeCurrentActions(lpObj);

       // Verificar estado actual
       CheckFakeCurrentState(lpObj);
   }

   // Generar alertas
   void GenerateFakeAlerts(LPOBJ lpObj, int alertType) {
       // Notificar administradores
       NotifyFakeAdmins(lpObj, alertType);

       // Registrar alerta
       LogFakeAlert(lpObj, alertType);
   }
   ```

## 16. Verificación y Pruebas

### 16.1 Lista de Verificación

Antes de implementar en producción, verificar:

1. Configuración Básica:
   - [ ] Archivo ServerInfo.ini configurado correctamente
   - [ ] Límites y restricciones establecidos
   - [ ] Directorios de log creados y con permisos

2. Funcionalidad:
   - [ ] Conexión de usuarios falsos
   - [ ] Movimiento y posicionamiento
   - [ ] Combate y habilidades
   - [ ] Inventario y equipamiento
   - [ ] Party y grupos
   - [ ] Eventos y notificaciones

3. Seguridad:
   - [ ] Validaciones implementadas
   - [ ] Restricciones aplicadas
   - [ ] Sistema de logs funcionando
   - [ ] Monitoreo activo

### 16.2 Pruebas Recomendadas

1. Pruebas Unitarias:
   ```cpp
   // Prueba de conexión
   void TestFakeConnection() {
       // Crear usuario falso
       LPOBJ lpObj = CreateFakeUser();
       
       // Verificar conexión
       ASSERT(lpObj->Connected == 3);
       ASSERT(lpObj->IsFakeOnline == 1);
   }

   // Prueba de movimiento
   void TestFakeMovement() {
       // Mover usuario
       ASSERT(MoveFakeUser(lpObj, x, y) == 1);
       
       // Verificar posición
       ASSERT(lpObj->X == x);
       ASSERT(lpObj->Y == y);
   }
   ```

2. Pruebas de Integración:
   ```cpp
   // Prueba de interacción
   void TestFakeInteraction() {
       // Crear party
       ASSERT(CreatePartyWithFakeUser() == 1);
       
       // Verificar comercio
       ASSERT(TestTradeWithFakeUser() == 0);
   }

   // Prueba de eventos
   void TestFakeEvents() {
       // Participar en evento
       ASSERT(JoinEventWithFakeUser() == 1);
       
       // Verificar recompensas
       ASSERT(CheckFakeRewards() == 1);
   }
   ```

## 17. Solución de Problemas

### 17.1 Problemas Comunes

1. Problemas de Conexión:
   ```plaintext
   Problema: Los usuarios falsos no se conectan
   Solución:
   - Verificar configuración en ServerInfo.ini
   - Comprobar límites de usuarios
   - Revisar logs de conexión
   ```

2. Problemas de Movimiento:
   ```plaintext
   Problema: Usuarios falsos no se mueven
   Solución:
   - Verificar coordenadas válidas
   - Comprobar restricciones de mapa
   - Revisar temporizadores de movimiento
   ```

3. Problemas de Combate:
   ```plaintext
   Problema: Habilidades no funcionan
   Solución:
   - Verificar configuración de skills
   - Comprobar equipamiento
   - Revisar logs de combate
   ```

### 17.2 Herramientas de Diagnóstico

1. Comandos de Depuración:
   ```plaintext
   /fakestatus - Muestra estado de usuarios falsos
   /fakeinfo - Muestra información detallada
   /fakedebug - Activa modo debug
   /fakelog - Muestra últimos logs
   ```

2. Archivos de Log:
   ```plaintext
   FakeOnline/Connection/ - Logs de conexión
   FakeOnline/Activity/ - Logs de actividad
   FakeOnline/Debug/ - Logs de depuración
   ```

## 18. Mantenimiento

### 18.1 Tareas Periódicas

1. Diarias:
   - Revisar logs de errores
   - Verificar conexiones activas
   - Monitorear rendimiento

2. Semanales:
   - Analizar patrones de uso
   - Limpiar logs antiguos
   - Actualizar configuraciones

3. Mensuales:
   - Revisar estadísticas
   - Optimizar rendimiento
   - Actualizar documentación

### 18.2 Actualizaciones

1. Proceso de Actualización:
   ```plaintext
   1. Respaldar configuración actual
   2. Aplicar nuevos cambios
   3. Verificar funcionalidad
   4. Actualizar documentación
   ```

2. Compatibilidad:
   ```plaintext
   - Mantener versión mínima del servidor
   - Verificar dependencias
   - Probar en ambiente de desarrollo
   ```

### 18.3 Contacto y Soporte

Para reportar problemas o solicitar soporte:

1. Correo Electrónico:
   ```plaintext
   soporte@servidor.com
   desarrollo@servidor.com
   ```

2. Documentación Adicional:
   ```plaintext
   /docs/FakeOnline/ - Documentación técnica
   /docs/API/ - Referencia de API
   /docs/Examples/ - Ejemplos de uso
   ```

## 19. Resumen y Referencias

### 19.1 Resumen de Componentes

1. Componentes Principales:
   ```plaintext
   - Sistema de Usuarios Falsos
   - Sistema de Movimiento
   - Sistema de Combate
   - Sistema de Inventario
   - Sistema de Party
   - Sistema de Eventos
   ```

2. Sistemas de Soporte:
   ```plaintext
   - Sistema de Mensajes
   - Sistema de Registro
   - Sistema de Seguridad
   - Sistema de Monitoreo
   ```

### 19.2 Archivos Clave

1. Archivos de Código:
   ```plaintext
   /GameServer/GameServer/
   ├── FakeOnline.h - Definiciones principales
   ├── FakeOnline.cpp - Implementación principal
   ├── User.h - Estructura de usuario
   ├── Protocol.h - Protocolos de comunicación
   ├── Move.h - Sistema de movimiento
   ├── Attack.h - Sistema de combate
   ├── InventoryEquipment.h - Sistema de inventario
   ├── Party.h - Sistema de grupos
   ├── Notice.h - Sistema de notificaciones
   └── Log.h - Sistema de registro
   ```

2. Archivos de Configuración:
   ```plaintext
   /GameServer/Data/
   ├── ServerInfo.ini - Configuración principal
   ├── FakeOnline.xml - Datos de usuarios falsos
   └── GameServerInfo - Configuración del servidor
   ```

### 19.3 Referencias

1. Documentación Técnica:
   ```plaintext
   - Manual del Servidor v3.0
   - Guía de Protocolos v2.5
   - Especificación de Mensajes v1.8
   ```

2. Recursos Adicionales:
   ```plaintext
   - Foro de Desarrollo: https://dev.servidor.com
   - Wiki: https://wiki.servidor.com/fakeonline
   - Repositorio: https://repo.servidor.com/gameserver
   ```

### 19.4 Historial de Versiones

1. Versión Actual (4.0):
   ```plaintext
   - Implementación completa de FakeOnline
   - Sistemas de seguridad mejorados
   - Integración con eventos
   ```

2. Actualizaciones Futuras:
   ```plaintext
   - Mejoras en IA de usuarios falsos
   - Nuevos tipos de eventos
   - Optimizaciones de rendimiento
   ```

---

Fin de la Guía de Integración FakeOnline v4.0
Última actualización: 16 de Febrero de 2025
   - FakeOnline.cpp
   - FakeOnlineDefine.h

2. Verifica que todas las modificaciones se hayan realizado en las líneas exactas especificadas.

3. Compila el proyecto y verifica que no haya errores.

4. Prueba las funcionalidades básicas:
   - Comandos de chat para FakeOnline
   - Mensajes del sistema
   - Interacciones con party
   - Interacciones PvP
   - Recolección automática de items
   - Movimiento de personajes falsos
   - Funcionamiento del modo offline

### 1.6 GameServer.rc
Ubicación: /GameServer/GameServer/GameServer.rc

1. Agregar el menú de FakeOnline (dentro del menú principal, antes de `POPUP "Invasion"`):
```rc
    POPUP "FakeOnline"
    BEGIN
        MENUITEM "Reload Data",               ID_FAKEONLINE_RELOADDATA
        MENUITEM "Add FakeOnline",            ID_FAKEONLINE_ADDFAKEONLINE
        MENUITEM "Del FakeOnline",            ID_FAKEONLINE_DELFAKEONLINE
    END
```

### 1.7 DSProtocol.cpp
Ubicación: /GameServer/GameServer/DSProtocol.cpp

1. Agregar include:
```cpp
#include "FakeOnline.h"
```

2. En la función donde se manejan las conexiones de usuario, agregar:
```cpp
OFFEXP_DATA *info = s_FakeOnline.GetOffExpInfo(lpObj);
// ... verificar info ...
lpObj->IsFakeOnline = true;
```

### 1.8 CustomAttack.cpp
Ubicación: /GameServer/GameServer/CustomAttack.cpp

1. Agregar include:
```cpp
#include "FakeOnline.h"
```

2. En la función de procesamiento de ataques, agregar:
```cpp
s_FakeOnline.FakeAttackProc(lpObj); //Attack, Di Chuyen, Move
```

### 1.9 GameMain.cpp
Ubicación: /GameServer/GameServer/GameMain.cpp

1. Agregar include:
```cpp
#include "FakeOnline.h"
```

2. En el bucle principal de procesamiento, agregar:
```cpp
//===Fake
s_FakeOnline.NhatItem(n);
s_FakeOnline.QuayLaiToaDoGoc(n);
```

### 1.10 User.cpp
Ubicación: /GameServer/GameServer/User.cpp

1. Agregar include:
```cpp
#include "FakeOnline.h"
```

2. En la inicialización del objeto del usuario, agregar:
```cpp
lpObj->IsFakeOnline = false;
lpObj->IsFakeRegen = false;
lpObj->IsFakePVPMode = 0;
lpObj->IsFakePartyMode = 0;
lpObj->IsFakeMoveRange = 0;
lpObj->IsFakeTimeLag = 0;
lpObj->IsFakeSendParty = 0;
```

3. En el manejo de muertes de usuario:
```cpp
if (lpTarget->Type == OBJECT_USER && lpObj->IsFakeOnline == true) //Neu bi nguoi kill
{
    lpObj->IsFakeRegen = false;
    s_FakeOnline.PostChatMSG(lpObj);
}
```

4. En el procesamiento de usuario:
```cpp
s_FakeOnline.FakeAttackProc(lpObj); //Attack, Di Chuyen, Move
```

### 1.11 JSProtocol.cpp
Ubicación: /GameServer/GameServer/JSProtocol.cpp

1. Agregar include:
```cpp
#include "FakeOnline.h"
```

2. En el manejo de conexiones:
```cpp
OFFEXP_DATA* info = s_FakeOnline.GetOffExpInfoByAccount(&gObj[lpMsg->index]);
// ... verificar info ...
gObj[lpMsg->index].IsFakeOnline = true;
```

3. En el manejo de desconexión:
```cpp
s_FakeOnline.OnAttackAlreadyConnected(&gObj[lpMsg->index]);
```

### 1.12 ObjectManager.cpp
Ubicación: /GameServer/GameServer/ObjectManager.cpp

1. Agregar include:
```cpp
#include "FakeOnline.h"
```

2. En el procesamiento de objetos:
```cpp
s_FakeOnline.Attack(gObj[n].Index);
```

### 1.13 FakeOnline.h y FakeOnline.cpp
Ubicación: /GameServer/GameServer/FakeOnline.h y FakeOnline.cpp

Estos son los archivos principales del sistema FakeOnline. Contienen todas las funcionalidades necesarias:

1. Gestión de usuarios fake:
   - RestoreFakeOnline(): Restaura usuarios fake
   - OnAttackAlreadyConnected(): Maneja usuarios ya conectados
   - GetOffExpInfo(): Obtiene información de experiencia offline

2. Sistema de combate:
   - FakeAttackProc(): Procesa ataques de usuarios fake
   - Attack(): Maneja ataques básicos
   - TuDongDanhSkill(): Sistema de ataque automático
   - SendSkillAttack(): Envía ataques de habilidades
   - SendMultiSkillAttack(): Ataques múltiples
   - SendDurationSkillAttack(): Ataques de duración
   - SendRFSkillAttack(): Ataques RF

3. Sistema de movimiento y posicionamiento:
   - QuayLaiToaDoGoc(): Retorno a posición original
   - NhatItem(): Recolección de items

4. Sistema de buffs y consumibles:
   - SuDungMauMana(): Uso de pociones
   - TuDongBuffSkill(): Sistema de buffs automáticos

5. Sistema de targeting:
   - GetTargetMonster(): Obtiene objetivo monstruo
   - GetTargetPlayer(): Obtiene objetivo jugador

6. Sistema de party:
   - GuiYCParty(): Manejo de invitaciones a party

Copiar estos archivos completos desde la versión old a la nueva, manteniendo todas las funcionalidades.

### 1.10 resource.h
Ubicación: /GameServer/GameServer/resource.h

1. Agregar los IDs para los menús de FakeOnline (antes de `#define IDM_STARTSKYEVENT`):
```cpp
#define ID_FAKEONLINE_RELOADDATA        32803  // reload data fakeonline
#define ID_FAKEONLINE_ADDFAKEONLINE     32804  // add user fakeonline
#define ID_FAKEONLINE_DELFAKEONLINE     32805  // eliminat user fakeuser
```

## 3. Solución de Problemas

Si encuentras algún error:

1. Verifica que USE_FAKE_ONLINE esté definido como 1 en FakeOnlineDefine.h
2. Asegúrate de que todas las funciones mencionadas en los includes existan
3. Comprueba que los índices de mensajes (9000-9003) no estén siendo usados por otro sistema
4. Verifica que las rutas de include sean correctas según tu estructura de directorios

https://www.mediafire.com/file/e5uuy1mov0pl4d6/source.zip/file

Creditos
Guia: Erafox

source don't have file FakeOnlineDefine.h

falta el archivo dentro del zip para descargar y  FakeOnlineDefine.h

Could share full gameserver source? :)

falta el archivo dentro del zip para descargar y  FakeOnlineDefine.h

I downloaded the zip file, it only has fakeonline.h and fakeonline.cpp, no fakeonlinedefines.h file

Could share full gameserver source? :)

https://tuservermu.com.ve/index.php?topic=78349.0

fakeonline không check skill client thì fix thế nào bro ?

fakeonline không check skill client thì fix thế nào bro ?

fakeonline không check skill client thì fix thế nào bro ?

espero darme a entender un poco

usted debe crear el personaje . con los skill requerido en su archivo xml ejemplo

Usted debe crear CON UN EDITOR el personaje con toda la referencia del archivo xml.