# Guia de Uso - WydBot
Este guia fornece instruções passo a passo sobre como configurar, executar e operar o WydBot para automação do seu gameplay.
## 1. Preparação do Ambiente
Antes de iniciar, certifique-se de ter os seguintes pré-requisitos instalados:
- **Docker** e **Docker Compose**.
- Arquivos de mapa do cliente WYD: `HeightMap.raw` e `AttributeMap.dat`.
- (Opcional) Arquivos `.ovpn` caso deseje utilizar VPN isolada por instância.
### Organização de Arquivos
Coloque os arquivos de mapa na pasta de recursos do backend:
`backend/Sharp.Wyd.Api/Resource/HeightMap.raw`
`backend/Sharp.Wyd.Api/Resource/AttributeMap.dat`
Se for utilizar VPN, coloque seus arquivos `.ovpn` em uma pasta acessível (ex: `C:/vpn/surfshark`).
## 2. Inicialização do Sistema
Abra o terminal na raiz do projeto e execute:
```bash
docker-compose up -d
```
Isso iniciará:
- **Frontend**: Disponível em `[Hidden Content]`
- **Backend**: Servidor WebSocket e API.
- **RavenDB**: Banco de dados NoSQL (Painel em `[Hidden Content]`).
- **Docker-in-Docker**: Para gestão de VPNs.
## 3. Primeiro Acesso e Configuração de Instâncias
1. Acesse `[Hidden Content]`.
2. No menu lateral, clique em **Instances**.
3. Clique em **Create New Instance**:
- **Username/Password**: Suas credenciais da conta WYD.
- **Numeric**: Sua senha numérica de 6 dígitos.
- **Server/Version**: Selecione a versão compatível com o seu servidor.
- **Proxy**: Se configurado, selecione o provedor de VPN.
4. Clique em **Save**.
## 4. Conectando ao Mundo
1. Na lista de instâncias, clique no botão de **Connect** (ícone de play).
2. O bot passará pelas fases: `Connecting` -> `Logged` -> `CharList`.
3. Selecione o personagem desejado na lista que aparecerá.
4. O bot entrará no mundo (`World`) e você verá o HP/MP e as coordenadas atualizadas em tempo real.
## 5. Configuração de Macros
O WydBot possui sistemas de automação especializados:
### 5.1 Skill Macro (Combate)
Acesse a aba **Macros > Skill** na instância:
- **Buffs**: Selecione as habilidades de suporte que o bot deve manter ativas.
- **Attacks**: Selecione as skills de ataque e defina a prioridade.
- **Targeting**: O bot selecionará automaticamente alvos dentro do alcance da skill.
### 5.2 Drop Macro (Coleta)
Acesse a aba **Macros > Drop**:
- **Item Filter**: Adicione IDs de itens que deseja coletar, ignorar ou vender.
- **Auto-Cargo**: Ative para que o bot leve itens valiosos ao baú automaticamente quando o inventário estiver cheio.
- **Stacking**: O bot tentará agrupar itens iguais para otimizar espaço.
### 5.3 Lan Macro (Zonas Especiais)
Acesse **Macros > Lan**:
- Escolha o **Spot** desejado.
- O bot comprará entradas no NPC Aki automaticamente se acabarem.
## 6. Gestão de Proxies (VPN)
Para rodar múltiplos bots sem ser bloqueado por limite de IP:
1. Vá em **Proxies**.
2. O sistema listará os arquivos `.ovpn` encontrados na pasta configurada.
3. Ao criar ou editar uma instância, vincule-a a um desses proxies.
4. O backend criará um container isolado que servirá de túnel apenas para aquele bot.
## 7. Dicas de Segurança e Estabilidade
- **Anti-Idle**: O bot possui um `SignalWorker` integrado que envia pacotes de keep-alive. Não desative-o.
- **Delay Humano**: Evite configurar tempos de uso de skill muito baixos (abaixo de 1000ms) para não gerar padrões suspeitos no servidor.
- **Monitoramento**: Utilize a aba de **Logs** para verificar se o bot está recebendo mensagens de administradores (GMs).
---
*Dúvidas técnicas?
# Memória Arquitetural - WydBot
Este documento consolida o conhecimento sobre a arquitetura e o funcionamento do projeto WydBot, um sistema moderno de automação e gerenciamento para o ecossistema WYD (With Your Destiny).
## 1. Visão Geral do Sistema
O sistema é composto por três camadas principais:
- **Frontend (Svelte)**: Interface web para controle de instâncias, configuração de macros e monitoramento em tempo real.
- **Backend (Sharp.Wyd.Wss)**: Servidor WebSocket que gerencia o ciclo de vida dos bots, executa comandos vindos do frontend e persiste configurações.
- **SDK (WYD.Sdk)**: O coração técnico do projeto, implementando o protocolo de rede WYD, estruturas de dados e lógica de jogo.
## 2. Arquitetura do WYD.Sdk
A SDK foi desenvolvida em C# e reflete a engenharia reversa do protocolo binário do WYD.
### 2.1 Protocolo de Rede
O sistema utiliza um cabeçalho de rede personalizado de 12 bytes:
- `Size` (2 bytes)
- `Key` (1 byte)
- `Checksum` (1 byte)
- `PacketId` (2 bytes) - Identificador do tipo de pacote (ex: 0x36C para movimento).
- `ClientId` (2 bytes)
- `Timestamp` (4 bytes)
A interpretação de pacotes é centralizada no `ServerInterpreter`, que despacha os dados para módulos como `Player`, `Bag`, `World` e `Social`.
### 2.2 Estruturas Core (Structs)
As estruturas de dados mapeiam o layout binário do jogo:
- **NetworkMob**: Representa entidades (players/mobs) no mundo, incluindo equipamentos, buffs (affects) e status.
- **NetworkCharStatus**: Mapeia atributos de combate (HP, MP, Ataque, Defesa, Atributos base).
- **NetworkItem**: Estrutura de itens e seus efeitos.
### 2.3 Sistema de Mapas e Movimentação
- **MapService**: Carrega arquivos originais do jogo (`HeightMap.raw` e `AttributeMap.dat`) para reconstruir o grid de 4096x4096.
- **Pathfinding**: Utiliza a biblioteca `RogueSharp` para cálculo de rotas.
- **MoveWorker**: Implementa lógica avançada de deslocamento, considerando o uso de portais e pergaminhos de teleporte para otimizar trajetos.
## 3. Automação e Workers
A lógica de "bot" é implementada através de **Workers**, que operam de forma assíncrona para cada cliente:
- **MoveWorker**: Gerencia o deslocamento do personagem.
- **SkillWorker**: Automação de uso de habilidades.
- **DropWorker**: Lógica para coleta e gerenciamento de drops.
- **SignalWorker**: Mantém a conexão ativa (keep-alive).
## 4. Integração Backend-Frontend
A comunicação entre a interface web e o motor de bot ocorre via WebSockets:
1. O frontend envia um comando JSON (ex: `MovePlayer`).
2. O `SocketHandler` no backend instancia o comando correspondente via Reflection.
3. O comando é executado sobre a instância do `Client` no `GamePool`, que por sua vez envia o pacote binário criptografado para o servidor do jogo.
## 5. Princípios de Design
- **Notação Húngara**: Uso consistente em structs para manter compatibilidade com o legado C++.
- **Composição**: A classe `Client` é composta por múltiplos módulos especializados, facilitando a manutenção.
- **Segurança**: Implementação de codificação de login e tratamento de pacotes para evitar instabilidades.
---
*Documento gerado para fixação de memória técnica em 2026-04-01.*
# Estudo Detalhado do Projeto WydBot
Este documento apresenta uma análise profunda e técnica do projeto WydBot, cobrindo requisitos, arquitetura, fluxos e um plano de domínio tecnológico.
## 1. Análise de Requisitos
### 1.1 Requisitos Funcionais (RF)
- **RF01 - Simulação Headless**: O sistema deve simular um cliente WYD completo sem necessidade de renderização gráfica.
- **RF02 - Gestão de Instâncias**: Permitir a criação, execução e monitoramento de múltiplas contas simultaneamente.
- **RF03 - Autenticação Avançada**: Suporte a login, senha numérica e seleção de personagem.
- **RF04 - Sistema de Movimentação**: Navegação inteligente entre mapas usando A*, portais e pergaminhos de teleporte.
- **RF05 - Macros de Combate (Skill)**: Automação de buffs e ataques com suporte a multi-alvo e redução de delay por refinação.
- **RF06 - Macros de Coleta (Drop)**: Filtragem de itens, empilhamento automático e transferência para o baú (Cargo).
- **RF07 - Automação de LAN**: Compra automática de entradas, uso e posicionamento em spots específicos.
- **RF08 - Automação de Eventos**: Busca de NPCs de evento, interação (click/quiz) e trocas de itens.
- **RF09 - Isolamento de Rede (VPN)**: Cada instância deve ser capaz de rodar sob uma VPN dedicada via container Docker.
- **RF10 - Interface Web**: Controle total das instâncias e configurações via navegador.
### 1.2 Requisitos Não-Funcionais (RNF)
- **RNF01 - Escalabilidade**: Capacidade de rodar centenas de instâncias em uma única máquina/servidor.
- **RNF02 - Performance**: Baixo consumo de CPU e memória por instância (foco em I/O e lógica de pacotes).
- **RNF03 - Segurança**: Implementação fiel da criptografia original (Keytable) para evitar detecção e garantir conexão.
- **RNF04 - Persistência**: Uso de banco de dados NoSQL (RavenDB) para armazenamento rápido de estados e logs.
- **RNF05 - Portabilidade**: Deploy via Docker Compose para garantir consistência entre ambientes.
---
## 2. Arquitetura do Sistema
### 2.1 Visão Geral (Diagrama de Blocos)
```mermaid
graph TD
UI[Frontend - SvelteKit] <-->|WebSocket/JSON| API[Backend - Sharp.Wyd.Api]
API <--> DB[(RavenDB)]
API <-->|Reflection| CMD[Commands]
CMD --> SDK[WYD.Sdk]
SDK <-->|Binary/TCP| GS[Game Server]
API <-->|Docker API| DIND[Docker-in-Docker / VPN]
```
### 2.2 Módulos Principais
- **WYD.Sdk**: Camada de domínio e protocolo. Implementa as structs binárias e a lógica de baixo nível do jogo.
- **Sharp.Wyd.Wss**: Gerenciador de conexões WebSocket e execução de comandos vindos da UI.
- **Sharp.Wyd.Data**: Camada de acesso a dados usando RavenDB.
- **Frontend**: Aplicação SPA em SvelteKit que consome a API WSS.
---
## 3. Fluxos de Trabalho (Workflows)
### 3.1 Fluxo de Movimentação (MoveWorker)
```mermaid
sequenceDiagram
participant P as Player
participant W as MoveWorker
participant S as MapService
participant GS as GameServer
P->>W: SetDestination(X, Y)
W->>S: DrawPath(current, target)
S-->>W: List of Coordinates
loop for each point
W->>GS: SendMovePacket(X, Y)
GS-->>P: UpdatePosition
W->>W: Sleep(calculated speed)
end
```
---
## 4. Pontos Críticos e Desafios Técnicos
1. **Sincronização de Structs**: Qualquer alteração na `NetworkMob` ou `NetworkItem` que não respeite o alinhamento de bytes (`Pack = 1`) quebrará a comunicação.
2. **Criptografia (Keytable)**: A tabela de chaves em `GameSecurity.cs` é estática e específica para cada versão/servidor.
3. **Gerenciamento de Recursos**: O carregamento de `HeightMap.raw` consome memória inicial e deve ser compartilhado entre instâncias.
4. **Isolamento VPN**: A estabilidade dos containers `openvpn-socks5` é vital para o bypass de limites de IP.
---
## 5. Plano de Estudo e Cronograma
### Fase 1: Domínio do Protocolo (Semana 1)
- Estudo das structs em `WYD.Sdk.Packets`.
- Entendimento do `ServerInterpreter` e despacho de pacotes.
- Exercício: Implementar o log de um novo tipo de pacote não mapeado.
### Fase 2: Motor de Automação (Semana 2)
- Análise profunda do `WorkerBase` e ciclo de vida dos workers.
- Customização do `SkillWorker` para novas classes (ex: Huntress).
- Exercício: Criar um worker simples para uso automático de poções de HP/MP.
### Fase 3: Infraestrutura e Backend (Semana 3)
- Estudo do RavenDB e modelagem das entidades.
- Configuração e troubleshooting do Docker-in-Docker.
- Exercício: Adicionar um novo campo de configuração na `Instance` e persistir no DB.
### Fase 4: Frontend e UX (Semana 4)
- Integração de novos comandos no `socketService.ts`.
- Criação de novos componentes UI para monitoramento avançado.
- Exercício: Criar um gráfico de ganho de XP/Hora na interface.
---
## 6. Sugestões de Melhorias
- **M01**: Implementar um sistema de plugins para workers, permitindo carregar novas lógicas sem recompilar a SDK.
- **M02**: Adicionar suporte a múltiplos protocolos de VPN (Wireguard, Proxy HTTPS).
- **M03**: Criar uma API REST para consulta de status (além do WSS).
- **M04**: Implementar notificações via Telegram/Discord em caso de morte ou desconexão.