Hook de Resolução - WYD Client Source (TMProject)

**Mauzyn** · 46 minutos atrás

# 📥 Instalação do Hook de Resolução - WYD Client Source

## 🎯 Objetivo

Este tutorial mostra **exatamente** como instalar e configurar o sistema de resoluções no código fonte do cliente WYD sem arquivos externos.

---

## 📋 Pré-requisitos

- ✅ Visual Studio (2019 ou superior)

- ✅ Projeto WYD Client Source compilável

- ✅ Acesso aos arquivos: `NewApp.h` e `NewApp.cpp`

---

## 📚 Documentação Adicional

Para mais informações, consulte:

- `TUTORIAL_RESOLUCAO.md` - Tutorial completo

- `README_RESOLUCAO.md` - Guia rápido

Spoiler

## 🔧 Passo 1: Modificar NewApp.h

### Localização do Arquivo:

```

SOURCE CLIENTE/Projects/TMProject/NewApp.h

```

### 1.1 Adicionar Estrutura stRes (Antes da classe NewApp)

**Localize:**

```cpp

struct SaveUpdatAndConfig

{

short Version;

short Config[14];

};

```

**Adicione APÓS essa estrutura:**

```cpp

struct stRes

{

unsigned int dwWidth;

unsigned int dwHeight;

unsigned int dwBit;

};

```

### 1.2 Adicionar Declaração da Função

**Localize a seção pública da classe NewApp:**

```cpp

bool CheckResolution(DWORD x, DWORD y, DWORD bpp);

```

**Adicione APÓS essa linha:**

```cpp

bool ApplyResolutionHook();

```

### ✅ Resultado Esperado:

```cpp

struct SaveUpdatAndConfig

{

short Version;

short Config[14];

};

struct stRes

{

unsigned int dwWidth;

unsigned int dwHeight;

unsigned int dwBit;

};

class NewApp

{

public:

// ... outras declarações ...

bool CheckResolution(DWORD x, DWORD y, DWORD bpp);

bool ApplyResolutionHook();

// ... resto do código ...

};

```

---

## 🔧 Passo 2: Modificar NewApp.cpp - Parte 1: Lista de Resoluções

### Localização do Arquivo:

```

SOURCE CLIENTE/Projects/TMProject/NewApp.cpp

```

### 2.1 Localizar a Função Initialize()

**Encontre a linha:**

```cpp

HRESULT NewApp::Initialize(HINSTANCE hInstance, int nFull)

{

struct stRes

{

unsigned int dwWidth;

unsigned int dwHeight;

unsigned int dwBit;

} stResList[11];

```

### 2.2 REMOVER a Declaração Local de stRes

**SUBSTITUA:**

```cpp

struct stRes

{

unsigned int dwWidth;

unsigned int dwHeight;

unsigned int dwBit;

} stResList[11];

```

**POR:**

```cpp

stRes stResList[11];

```

### 2.3 Atualizar a Lista de Resoluções

**Localize onde as resoluções são definidas (após `BASE_InitEffectString();`)**

**SUBSTITUA toda a seção de resoluções por:**

```cpp

BASE_InitEffectString();

// Lista de resoluções atualizada - todas em 32 bits

// Resolução 1 - 1366x768 (PADRÃO)

stResList[0].dwWidth = 1366;

stResList[0].dwHeight = 768;

stResList[0].dwBit = 32;

// Resolução 2

stResList[1].dwWidth = 800;

stResList[1].dwHeight = 600;

stResList[1].dwBit = 32;

// Resolução 3

stResList[2].dwWidth = 1024;

stResList[2].dwHeight = 768;

stResList[2].dwBit = 32;

// Resolução 4

stResList[3].dwWidth = 1280;

stResList[3].dwHeight = 720;

stResList[3].dwBit = 32;

// Resolução 5

stResList[4].dwWidth = 1280;

stResList[4].dwHeight = 800;

stResList[4].dwBit = 32;

// Resolução 6

stResList[5].dwWidth = 1280;

stResList[5].dwHeight = 960;

stResList[5].dwBit = 32;

// Resolução 7

stResList[6].dwWidth = 1280;

stResList[6].dwHeight = 1024;

stResList[6].dwBit = 32;

// Resolução 8

stResList[7].dwWidth = 1440;

stResList[7].dwHeight = 900;

stResList[7].dwBit = 32;

// Resolução 9

stResList[8].dwWidth = 1600;

stResList[8].dwHeight = 900;

stResList[8].dwBit = 32;

// Resolução 10

stResList[9].dwWidth = 1600;

stResList[9].dwHeight = 1024;

stResList[9].dwBit = 32;

// Resolução 11

stResList[10].dwWidth = 1920;

stResList[10].dwHeight = 1080;

stResList[10].dwBit = 32;

// Valor padrão: 1 = 1366x768

int nResIndex = 1;

```

---

## 🔧 Passo 3: Modificar NewApp.cpp - Parte 2: Configuração Padrão

### 3.1 Atualizar Valor Padrão do Config

**Localize a seção onde o Config padrão é definido (quando o arquivo não existe):**

**Encontre:**

```cpp

else

{

Config.Version = 7000;

Config.Config[0] = 7;

// ... resto ...

}

```

**SUBSTITUA `Config.Config[0] = 7;` por:**

```cpp

Config.Config[0] = 1; // Resolução padrão: 1 = 1366x768

```

### 3.2 Adicionar Validação de Índice

**Após a linha `nResIndex = Config.Config[0];` adicione:**

```cpp

nResIndex = Config.Config[0];

// Garantir que nResIndex está dentro dos limites válidos (1-11)

if (nResIndex < 1 || nResIndex > 11)

nResIndex = 1; // Default para primeira resolução

```

---

## 🔧 Passo 4: Modificar NewApp.cpp - Parte 3: Sistema de Fallback

### 4.1 Atualizar Aplicação de Resolução

**Localize onde a resolução é aplicada:**

```cpp

m_dwScreenWidth = stResList[nResIndex - 1].dwWidth;

m_dwScreenHeight = stResList[nResIndex - 1].dwHeight;

m_dwColorBit = stResList[nResIndex - 1].dwBit;

if (!CheckResolution(m_dwScreenWidth, m_dwScreenHeight, m_dwColorBit))

{

m_dwScreenWidth = stResList[1].dwWidth;

m_dwScreenHeight = stResList[1].dwHeight;

m_dwColorBit = stResList[1].dwBit;

}

```

**SUBSTITUA por:**

```cpp

// Aplicar resolução selecionada com verificação de limites

int nResArrayIndex = nResIndex - 1;

if (nResArrayIndex < 0)

nResArrayIndex = 0;

if (nResArrayIndex >= 11)

nResArrayIndex = 10;

m_dwScreenWidth = stResList[nResArrayIndex].dwWidth;

m_dwScreenHeight = stResList[nResArrayIndex].dwHeight;

m_dwColorBit = stResList[nResArrayIndex].dwBit;

// Se a resolução não for suportada, tentar uma resolução padrão

if (!CheckResolution(m_dwScreenWidth, m_dwScreenHeight, m_dwColorBit))

{

// Tentar resolução padrão (1366x768 - primeira da lista)

m_dwScreenWidth = stResList[0].dwWidth;

m_dwScreenHeight = stResList[0].dwHeight;

m_dwColorBit = stResList[0].dwBit;

// Se ainda não funcionar, tentar 800x600

if (!CheckResolution(m_dwScreenWidth, m_dwScreenHeight, m_dwColorBit))

{

m_dwScreenWidth = stResList[1].dwWidth;

m_dwScreenHeight = stResList[1].dwHeight;

m_dwColorBit = stResList[1].dwBit;

}

```

---

## 🔧 Passo 5: Modificar NewApp.cpp - Parte 4: Ajuste de Fontes

### 5.1 Atualizar Switch de Fontes

**Localize o switch que define o tamanho da fonte:**

```cpp

int _nFontSize = 14;

switch (m_dwScreenWidth)

{

case 640:

_nFontSize = 11;

break;

case 800:

_nFontSize = 12;

break;

// ... resto ...

}

```

**SUBSTITUA por:**

```cpp

int _nFontSize = 14;

switch (m_dwScreenWidth)

{

case 640:

_nFontSize = 11;

break;

case 800:

_nFontSize = 12;

break;

case 1024:

_nFontSize = 12;

break;

case 1280:

if (m_dwScreenHeight == 720)

_nFontSize = 14;

else if (m_dwScreenHeight == 800)

_nFontSize = 14;

else if (m_dwScreenHeight == 960)

_nFontSize = 14;

else if (m_dwScreenHeight == 1024)

_nFontSize = 14;

else

_nFontSize = 14;

break;

case 1366:

_nFontSize = 13;

break;

case 1440:

_nFontSize = 18;

break;

case 1600:

if (m_dwScreenHeight == 900)

_nFontSize = 15;

else if (m_dwScreenHeight == 1024)

_nFontSize = 15;

else

_nFontSize = 15;

break;

case 1920:

_nFontSize = 18;

break;

default:

_nFontSize = 12;

break;

}

```

---

## 🔧 Passo 6: Modificar NewApp.cpp - Parte 5: Chamada do Hook

### 6.1 Adicionar Chamada do Hook

**Localize onde `RenderDevice::m_nFontSize` é definido:**

```cpp

RenderDevice::m_nFontSize = _nFontSize;

RenderDevice::m_nFontTextureSize = 512;

```

**Adicione APÓS essas linhas:**

```cpp

RenderDevice::m_nFontSize = _nFontSize;

RenderDevice::m_nFontTextureSize = 512;

// Tentar aplicar hook de resoluções (patch de memória) se os endereços existirem

// Isso é apenas para compatibilidade com executáveis compilados anteriormente

// Se não funcionar, as resoluções já estão configuradas corretamente no código acima

ApplyResolutionHook();

InitServerName2();

InitServerName();

```

---

## 🔧 Passo 7: Adicionar Função ApplyResolutionHook()

### 7.1 Localizar Fim da Função CheckResolution()

**Encontre a função:**

```cpp

bool NewApp::CheckResolution(DWORD x, DWORD y, DWORD bpp)

{

// ... código ...

return false;

}

```

### 7.2 Adicionar Função Completa APÓS CheckResolution()

**Adicione o código completo da função:**

```cpp

bool NewApp::ApplyResolutionHook()

{

__try

{

// Obter o base address do módulo atual

HMODULE hModule = GetModuleHandle(NULL);

if (!hModule)

return false;

DWORD dwBaseAddress = reinterpret_cast<DWORD>(hModule);

// Endereços relativos ao base address (0x400000 é o base address padrão do executável)

// Se o executável usar outro base address, os offsets serão calculados corretamente

const DWORD BASE_OFFSET = 0x400000;

// Função helper para calcular endereço real

auto CalcAddress = [dwBaseAddress, BASE_OFFSET](DWORD address) -> DWORD

{

return dwBaseAddress + (address - BASE_OFFSET);

};

// Função helper para verificar se o endereço é válido

auto IsValidAddress = [](DWORD address) -> bool

{

MEMORY_BASIC_INFORMATION mbi = { 0 };

if (VirtualQuery(reinterpret_cast<LPCVOID>(address), &mbi, sizeof(mbi)) == 0)

return false;

// Verificar se a memória é acessível

return (mbi.Protect & (PAGE_READWRITE | PAGE_EXECUTE_READWRITE | PAGE_READONLY | PAGE_EXECUTE_READ)) != 0;

};

// Função helper para aplicar patch de memória (WORD) com verificação

auto SetValueWORD = [IsValidAddress](DWORD address, WORD value) -> bool

{

if (!IsValidAddress(address))

return false;

DWORD oldProtect = 0;

if (VirtualProtect(reinterpret_cast<LPVOID>(address), sizeof(WORD), PAGE_EXECUTE_READWRITE, &oldProtect) == 0)

return false;

__try

{

*(WORD*)address = value;

}

__except (EXCEPTION_EXECUTE_HANDLER)

{

VirtualProtect(reinterpret_cast<LPVOID>(address), sizeof(WORD), oldProtect, &oldProtect);

return false;

}

if (VirtualProtect(reinterpret_cast<LPVOID>(address), sizeof(WORD), oldProtect, &oldProtect) == 0)

return false;

FlushInstructionCache(GetCurrentProcess(), reinterpret_cast<LPCVOID>(address), sizeof(WORD));

return true;

};

// Função helper para aplicar patch de memória (DWORD) com verificação

auto SetValueDWORD = [IsValidAddress](DWORD address, DWORD value) -> bool

{

if (!IsValidAddress(address))

return false;

DWORD oldProtect = 0;

if (VirtualProtect(reinterpret_cast<LPVOID>(address), sizeof(DWORD), PAGE_EXECUTE_READWRITE, &oldProtect) == 0)

return false;

__try

{

*(DWORD*)address = value;

}

__except (EXCEPTION_EXECUTE_HANDLER)

{

VirtualProtect(reinterpret_cast<LPVOID>(address), sizeof(DWORD), oldProtect, &oldProtect);

return false;

}

if (VirtualProtect(reinterpret_cast<LPVOID>(address), sizeof(DWORD), oldProtect, &oldProtect) == 0)

return false;

FlushInstructionCache(GetCurrentProcess(), reinterpret_cast<LPCVOID>(address), sizeof(DWORD));

return true;

};

// Proteger uma região grande de memória antes de aplicar os patches

// Isso é necessário para evitar problemas de permissão

DWORD dwRegionStart = CalcAddress(0x00547000);

DWORD dwRegionSize = 0x2000; // ~8KB de região

DWORD dwOldProtectRegion = 0;

bool bRegionProtected = false;

if (IsValidAddress(dwRegionStart))

{

if (VirtualProtect(reinterpret_cast<LPVOID>(dwRegionStart), dwRegionSize, PAGE_EXECUTE_READWRITE, &dwOldProtectRegion) != 0)

{

bRegionProtected = true;

}

int nPatchesApplied = 0;

// Set Width x Height x 32 Bits (usando DWORD para valores grandes)

if (SetValueDWORD(CalcAddress(0x005475FF) + 6, 800)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547609) + 6, 600)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547613) + 6, 32)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054761D) + 6, 1024)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547627) + 6, 768)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547631) + 6, 32)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054763B) + 6, 1280)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547645) + 6, 720)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054764F) + 6, 32)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547659) + 6, 1280)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547663) + 6, 800)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054766D) + 6, 32)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547677) + 6, 1280)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547681) + 6, 960)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054768B) + 6, 32)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547695) + 6, 1280)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054769F) + 6, 1024)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x005476B3) + 6, 1440)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x005476BD) + 6, 900)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x005476D1) + 6, 1600)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x005476DB) + 6, 900)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x005476EF) + 6, 1600)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x005476F9) + 6, 1024)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x0054770D) + 6, 1920)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547717) + 6, 1080)) nPatchesApplied++;

// Proteger região para os patches de CMP e FontSize

DWORD dwRegionStart2 = CalcAddress(0x00547F00);

DWORD dwRegionSize2 = 0x1000;

DWORD dwOldProtectRegion2 = 0;

bool bRegion2Protected = false;

if (IsValidAddress(dwRegionStart2))

{

if (VirtualProtect(reinterpret_cast<LPVOID>(dwRegionStart2), dwRegionSize2, PAGE_EXECUTE_READWRITE, &dwOldProtectRegion2) != 0)

{

bRegion2Protected = true;

}

// Set New CMP Widths + FontSize

if (SetValueDWORD(CalcAddress(0x00547FB3) + 3, 800)) nPatchesApplied++;

if (SetValueWORD(CalcAddress(0x00547FBC) + 6, 12)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00547FDB) + 3, 1024)) nPatchesApplied++;

if (SetValueWORD(CalcAddress(0x00547FE4) + 6, 12)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00548000) + 3, 1280)) nPatchesApplied++;

if (SetValueWORD(CalcAddress(0x00548009) + 6, 14)) nPatchesApplied++;

if (SetValueDWORD(CalcAddress(0x00548025) + 3, 1440)) nPatchesApplied++;

if (SetValueWORD(CalcAddress(0x0054802E) + 6, 18)) nPatchesApplied++;

if (SetValueWORD(CalcAddress(0x00548044) + 6, 18)) nPatchesApplied++;

// Restaurar proteção da região se foi alterada

if (bRegionProtected && dwOldProtectRegion != 0)

VirtualProtect(reinterpret_cast<LPVOID>(dwRegionStart), dwRegionSize, dwOldProtectRegion, &dwOldProtectRegion);

if (bRegion2Protected && dwOldProtectRegion2 != 0)

VirtualProtect(reinterpret_cast<LPVOID>(dwRegionStart2), dwRegionSize2, dwOldProtectRegion2, &dwOldProtectRegion2);

// Retornar true se pelo menos alguns patches foram aplicados

// Isso permite que o código continue mesmo se alguns endereços não existirem

return nPatchesApplied > 0;

}

__except (EXCEPTION_EXECUTE_HANDLER)

{

// Se houver exceção, significa que os endereços não são válidos

// Isso pode acontecer se o executável foi compilado com base address diferente

// Ou se ASLR está habilitado

return false;

}

```

---

## ✅ Passo 8: Verificação e Compilação

### 8.1 Verificar Includes Necessários

**Confirme que `NewApp.cpp` contém:**

```cpp

#include "NewApp.h"

#include <windows.h> // Para VirtualProtect, GetModuleHandle, etc.

```

### 8.2 Compilar o Projeto

1. **Abra o Visual Studio**

2. **Abra o projeto**: `TMProject.vcxproj`

3. **Verifique se não há erros de compilação**

4. **Build > Build Solution** (ou F7)

5. **Verifique se compilou sem erros**

### 8.3 Testar

1. **Execute o jogo**

2. **Verifique se a resolução padrão (1366x768) está sendo aplicada**

3. **Teste diferentes resoluções via arquivo Config.bin**

---

## 📋 Checklist de Instalação

Use este checklist para verificar se tudo foi instalado corretamente:

### NewApp.h

- [ ] Estrutura `stRes` adicionada (global)

- [ ] Função `ApplyResolutionHook()` declarada na classe NewApp

### NewApp.cpp

- [ ] Declaração local de `stRes` removida

- [ ] Lista de resoluções atualizada (11 resoluções)

- [ ] Resolução padrão definida como 1 (1366x768)

- [ ] Validação de índice adicionada

- [ ] Sistema de fallback implementado

- [ ] Switch de fontes atualizado

- [ ] Chamada `ApplyResolutionHook()` adicionada

- [ ] Função `ApplyResolutionHook()` implementada

- [ ] Compilação sem erros

- [ ] Teste executado com sucesso

---

## 🐛 Problemas Comuns Durante Instalação

### Erro: "stRes não foi declarado"

**Solução:** Verifique se a estrutura `stRes` foi adicionada em `NewApp.h` antes da classe `NewApp`.

### Erro: "ApplyResolutionHook não foi declarado"

**Solução:** Verifique se a função foi declarada na classe `NewApp` em `NewApp.h`.

### Erro: "VirtualProtect não foi declarado"

**Solução:** Adicione `#include <windows.h>` no início de `NewApp.cpp`.

### Erro de Compilação: Sintaxe

**Solução:** Verifique se todas as chaves `{}` estão fechadas corretamente.

### Hook não funciona (sem erro)

**Solução:** Isso é normal! O hook é opcional. O código usa as resoluções definidas no código fonte mesmo se o hook falhar.

---

## 📝 Resumo das Modificações

### Arquivos Modificados:

1. **NewApp.h**

- Adicionada estrutura `stRes`

- Adicionada declaração `ApplyResolutionHook()`

2. **NewApp.cpp**

- Removida declaração local de `stRes`

- Atualizada lista de resoluções

- Adicionada validação de índices

- Implementado sistema de fallback

- Atualizado switch de fontes

- Adicionada chamada do hook

- Implementada função `ApplyResolutionHook()`

### Linhas Aproximadas Modificadas:

- **NewApp.h**: ~2-3 linhas adicionadas

- **NewApp.cpp**: ~200+ linhas modificadas/adicionadas

---

## 🎯 Resultado Final

Após a instalação completa, você terá:

✅ **11 resoluções disponíveis** (todas em 32 bits)

✅ **Resolução padrão: 1366x768**

✅ **Sistema de fallback automático**

✅ **Tamanhos de fonte ajustados**

✅ **Hook de memória opcional** (compatibilidade)

✅ **Validação de resoluções**

---

## 📞 Próximos Passos

1. **Compile o projeto**

2. **Teste a resolução padrão (1366x768)**

3. **Teste outras resoluções via Config.bin**

4. **Verifique se tudo está funcionando corretamente**

---

**Fim da Instalação**

Se encontrar problemas, revise este tutorial passo a passo e verifique o checklist.

Spoiler

# Tutorial: Configuração de Resoluções - WYD Client

## 📋 Índice

1. [Visão Geral](#visão-geral)

2. [O que foi Implementado](#o-que-foi-implementado)

3. [Estrutura de Arquivos Modificados](#estrutura-de-arquivos-modificados)

4. [Lista de Resoluções Disponíveis](#lista-de-resoluções-disponíveis)

5. [Como Configurar a Resolução](#como-configurar-a-resolução)

6. [Instalação e Compilação](#instalação-e-compilação)

7. [Solução de Problemas](#solução-de-problemas)

8. [Detalhes Técnicos](#detalhes-técnicos)

---

## 🎯 Visão Geral

Este tutorial documenta as modificações realizadas no código fonte do cliente WYD para suportar múltiplas resoluções em 32 bits, incluindo a resolução padrão de **1366x768**.

### Objetivos Alcançados:

- ✅ Suporte para múltiplas resoluções (11 resoluções diferentes)

- ✅ Todas as resoluções configuradas para 32 bits

- ✅ Sistema de fallback automático para resoluções suportadas

- ✅ Tamanhos de fonte ajustados automaticamente por resolução

- ✅ Hook de memória para compatibilidade com executáveis compilados

---

## 📦 O que foi Implementado

### 1. Estrutura `stRes` Global

A estrutura de resolução foi movida para o arquivo `NewApp.h` como declaração global, permitindo acesso em todo o projeto.

```cpp

struct stRes

{

unsigned int dwWidth;

unsigned int dwHeight;

unsigned int dwBit;

};

```

### 2. Lista de Resoluções Atualizada

A lista de resoluções foi completamente reconfigurada no arquivo `NewApp.cpp`, incluindo:

- 11 resoluções diferentes

- Todas configuradas para 32 bits

- Resolução 1366x768 como padrão (índice 1)

### 3. Função `ApplyResolutionHook()`

Implementada função para aplicar patches de memória (compatibilidade com executáveis compilados):

- Calcula endereços dinamicamente baseado no base address do módulo

- Verifica validade dos endereços antes de modificar

- Tratamento de exceções para evitar crashes

- Suporte para valores WORD e DWORD

### 4. Sistema de Fontes Ajustável

Tamanhos de fonte são ajustados automaticamente baseado na resolução selecionada.

### 5. Validação e Fallback

Sistema de validação que:

- Verifica se a resolução selecionada é suportada pelo sistema

- Aplica fallback automático para resoluções compatíveis

- Previne crashes por resoluções inválidas

---

## 📁 Estrutura de Arquivos Modificados

### Arquivos Alterados:

1. **`NewApp.h`**

- Adicionada estrutura `stRes` global

- Adicionada declaração da função `ApplyResolutionHook()`

2. **`NewApp.cpp`**

- Lista de resoluções atualizada (linhas ~93-147)

- Validação de índices (linhas ~190-192)

- Sistema de fallback (linhas ~263-278)

- Ajuste de fontes por resolução (linhas ~280-320)

- Implementação de `ApplyResolutionHook()` (linhas ~1362-1547)

---

## 🖥️ Lista de Resoluções Disponíveis

|--------|--------------|---------|--------|------|-------------|

| 1 | 1366x768 | 1366 | 768 | 32 | **PADRÃO** |

| 2 | 800x600 | 800 | 600 | 32 | Disponível |

| 3 | 1024x768 | 1024 | 768 | 32 | Disponível |

| 4 | 1280x720 | 1280 | 720 | 32 | Disponível |

| 5 | 1280x800 | 1280 | 800 | 32 | Disponível |

| 6 | 1280x960 | 1280 | 960 | 32 | Disponível |

| 7 | 1280x1024 | 1280 | 1024 | 32 | Disponível |

| 8 | 1440x900 | 1440 | 900 | 32 | Disponível |

| 9 | 1600x900 | 1600 | 900 | 32 | Disponível |

| 10 | 1600x1024 | 1600 | 1024 | 32 | Disponível |

| 11 | 1920x1080 | 1920 | 1080 | 32 | Disponível |

### Tamanhos de Fonte por Resolução:

- **640x480**: 11px

- **800x600**: 12px

- **1024x768**: 12px

- **1280x***: 14px

- **1366x768**: 13px

- **1440x900**: 18px

- **1600x***: 15px

- **1920x1080**: 18px

---

## ⚙️ Como Configurar a Resolução

### Método 1: Configuração Automática (Recomendado)

A resolução padrão é **1366x768** (índice 1). Se não existir o arquivo `Config.bin`, esta resolução será aplicada automaticamente.

### Método 2: Via Arquivo de Configuração

1. **Localize o arquivo `Config.bin`** na pasta do executável do jogo

2. **Abra o arquivo** com um editor hexadecimal ou um programa que permita editar arquivos binários

3. **Edite o primeiro byte** (`Config.Config[0]`) com o índice da resolução desejada:

- `1` = 1366x768 (Padrão)

- `2` = 800x600

- `3` = 1024x768

- `4` = 1280x720

- `5` = 1280x800

- `6` = 1280x960

- `7` = 1280x1024

- `8` = 1440x900

- `9` = 1600x900

- `10` = 1600x1024

- `11` = 1920x1080

4. **Salve o arquivo** e execute o jogo

### Método 3: Modificar no Código Fonte

Para alterar a resolução padrão diretamente no código:

1. Abra o arquivo `NewApp.cpp`

2. Localize a linha ~150: `int nResIndex = 1;`

3. Altere o valor para o índice desejado (1-11)

4. Localize a linha ~172: `Config.Config[0] = 1;`

5. Altere o valor para o mesmo índice

6. Recompile o projeto

### Método 4: Deletar Arquivo de Configuração

1. Delete o arquivo `Config.bin` na pasta do jogo

2. Execute o jogo

3. Um novo arquivo será criado com as configurações padrão (1366x768)

---

## 🔧 Instalação e Compilação

### Pré-requisitos:

- Visual Studio (2019 ou superior recomendado)

- Projeto WYD Client compilável

- Acesso aos arquivos fonte

### Passos para Compilação:

1. **Abra o projeto no Visual Studio**

```

Abra: SOURCE CLIENTE/Projects/TMProject/TMProject.vcxproj

```

2. **Verifique as modificações**

- Confirme que `NewApp.h` contém a estrutura `stRes`

- Confirme que `NewApp.cpp` contém a lista de resoluções atualizada

3. **Compile o projeto**

- Selecione a configuração desejada (Debug/Release)

- Build > Build Solution (ou pressione F7)

4. **Execute o jogo**

- O executável será gerado na pasta de output

- A resolução padrão (1366x768) será aplicada automaticamente

### Verificação Pós-Compilação:

1. Execute o jogo

2. Verifique se a resolução está correta

3. Se necessário, ajuste via arquivo `Config.bin`

---

## 🐛 Solução de Problemas

### Problema: Resolução não está sendo aplicada

**Solução:**

1. Verifique se o arquivo `Config.bin` existe e está correto

2. Delete o arquivo `Config.bin` para forçar criação de um novo

3. Verifique se a resolução está na lista de resoluções suportadas

4. Confirme que a resolução é suportada pelo seu monitor

### Problema: Jogo crasha ao iniciar

**Solução:**

1. Verifique se a resolução selecionada é suportada pelo sistema

2. O sistema de fallback deve aplicar uma resolução compatível automaticamente

3. Verifique os logs de erro do jogo

4. Tente usar uma resolução mais baixa (800x600 ou 1024x768)

### Problema: Tamanho de fonte incorreto

**Solução:**

1. Verifique se o switch de fontes está correto no código

2. Confirme que a resolução está mapeada corretamente

3. Ajuste manualmente os tamanhos de fonte no código se necessário

### Problema: Hook de memória não funciona

**Solução:**

1. O hook de memória é opcional e funciona apenas com executáveis compilados

2. Se não funcionar, o código usa as resoluções definidas no código fonte

3. Isso é normal e não afeta o funcionamento do jogo

### Problema: Resolução não aparece no menu do jogo

**Solução:**

1. As resoluções são definidas no código fonte, não no menu

2. Para alterar, use o arquivo `Config.bin` ou modifique o código

3. Se houver um menu de resoluções, ele pode precisar ser atualizado separadamente

---

## 🔍 Detalhes Técnicos

### Estrutura de Dados:

```cpp

struct stRes

{

unsigned int dwWidth; // Largura da resolução

unsigned int dwHeight; // Altura da resolução

unsigned int dwBit; // Profundidade de cor (32 bits)

};

```

### Arquivo de Configuração:

O arquivo `Config.bin` contém uma estrutura `SaveUpdatAndConfig`:

```cpp

struct SaveUpdatAndConfig

{

short Version; // Versão da configuração

short Config[14]; // Array de configurações

};

```

- `Config[0]`: Índice da resolução (1-11)

- `Config[1]`: Smooth/Tesselação

- `Config[2]`: Som

- `Config[3]`: Música

- `Config[5]`: Brilho

- `Config[6]`: Cursor

- `Config[8]`: Modo janela (0 = Fullscreen, 1 = Windowed)

- E outros...

### Função ApplyResolutionHook():

Esta função tenta aplicar patches de memória nos endereços do executável compilado:

- **Base Address**: Calculado dinamicamente via `GetModuleHandle(NULL)`

- **Endereços**: Relativos ao base address padrão (0x400000)

- **Validação**: Verifica se os endereços são válidos antes de modificar

- **Segurança**: Usa `__try/__except` para evitar crashes

**Nota**: Esta função é opcional. Se não funcionar, o jogo usa as resoluções definidas no código fonte.

### Sistema de Fallback:

```cpp

1. Tenta aplicar a resolução selecionada (nResIndex)

2. Se não suportada, tenta 1366x768 (padrão)

3. Se ainda não suportada, tenta 800x600

4. Se nenhuma funcionar, o jogo pode não iniciar

```

### Validação de Resoluções:

A função `CheckResolution()` verifica se uma resolução é suportada pelo sistema usando `EnumDisplaySettings()`:

```cpp

bool NewApp::CheckResolution(DWORD x, DWORD y, DWORD bpp)

{

// Enumera todas as resoluções disponíveis

// Verifica se a resolução solicitada existe

// Retorna true se suportada, false caso contrário

}

```

---

## 📝 Notas Importantes

1. **Todas as resoluções estão em 32 bits**: Não há suporte para 16 bits

2. **Resolução padrão é 1366x768**: Definida como índice 1

3. **Sistema de fallback automático**: Tenta resoluções compatíveis se a selecionada não funcionar

4. **Hook de memória é opcional**: Funciona apenas com executáveis compilados específicos

5. **Arquivo Config.bin**: Mantém as configurações entre execuções

6. **Tamanhos de fonte**: Ajustados automaticamente por resolução

---

## 🔄 Atualizações Futuras

### Possíveis Melhorias:

- [ ] Adicionar mais resoluções (ex: 2560x1440, 3840x2160)

- [ ] Interface gráfica para seleção de resolução

- [ ] Suporte para resoluções personalizadas

- [ ] Detecção automática da melhor resolução

- [ ] Salvamento automático da resolução selecionada

### Para Adicionar uma Nova Resolução:

1. Abra `NewApp.cpp`

2. Localize a lista de resoluções (linha ~93)

3. Adicione uma nova entrada no array `stResList[]`

4. Adicione o caso no switch de fontes (linha ~280)

5. Atualize o limite máximo de resoluções (atualmente 11)

6. Recompile o projeto

Exemplo:

```cpp

// Resolução 12

stResList[11].dwWidth = 2560;

stResList[11].dwHeight = 1440;

stResList[11].dwBit = 32;

```

---

## 📞 Suporte

Se encontrar problemas ou tiver dúvidas:

1. Verifique este tutorial primeiro

2. Consulte a seção de Solução de Problemas

3. Verifique os logs de erro do jogo

4. Revise o código fonte para entender melhor a implementação

---

## 📄 Licença e Créditos

Este tutorial documenta as modificações realizadas no código fonte do cliente WYD para suportar múltiplas resoluções.

**Data da Implementação**: 2024

**Versão do Tutorial**: 1.0

---

## ✅ Checklist de Instalação

- [ ] Projeto compilado com sucesso

- [ ] Resolução padrão (1366x768) funcionando

- [ ] Arquivo `Config.bin` criado corretamente

- [ ] Testado em diferentes resoluções

- [ ] Sistema de fallback funcionando

- [ ] Tamanhos de fonte corretos

- [ ] Sem crashes ao iniciar o jogo

---

**Fim do Tutorial**

Para mais informações, consulte os arquivos fonte:

- `NewApp.h`: Estruturas e declarações

- `NewApp.cpp`: Implementação das resoluções

**Créditos Mauzyn**

Spoiler

# 🔧 Guia Rápido: Configuração de Resoluções

## ⚡ Início Rápido

### Resolução Padrão: **1366x768**

O jogo já vem configurado com **1366x768** como resolução padrão. Basta compilar e executar!

---

## 📋 Resoluções Disponíveis

| Índice | Resolução | Status |

|--------|-----------|--------|

| **1** | **1366x768** | **PADRÃO** |

| 2 | 800x600 | ✅ |

| 3 | 1024x768 | ✅ |

| 4 | 1280x720 | ✅ |

| 5 | 1280x800 | ✅ |

| 6 | 1280x960 | ✅ |

| 7 | 1280x1024 | ✅ |

| 8 | 1440x900 | ✅ |

| 9 | 1600x900 | ✅ |

| 10 | 1600x1024 | ✅ |

| 11 | 1920x1080 | ✅ |

**Todas as resoluções estão em 32 bits.**

---

## 🚀 Como Alterar a Resolução

### Opção 1: Deletar Config.bin (Mais Fácil)

1. Delete o arquivo `Config.bin` na pasta do jogo

2. Execute o jogo

3. Será criado um novo arquivo com resolução padrão (1366x768)

### Opção 2: Editar Config.bin

1. Abra `Config.bin` com editor hexadecimal

2. Altere o **primeiro byte** para o índice desejado (1-11)

3. Salve e execute o jogo

### Opção 3: Modificar no Código

1. Abra `NewApp.cpp`

2. Linha ~150: Altere `int nResIndex = 1;` para o índice desejado

3. Linha ~172: Altere `Config.Config[0] = 1;` para o mesmo índice

4. Recompile

---

## 📁 Arquivos Modificados

- ✅ `NewApp.h` - Estrutura `stRes` adicionada

- ✅ `NewApp.cpp` - Lista de resoluções atualizada

- ✅ `NewApp.cpp` - Função `ApplyResolutionHook()` implementada

- ✅ `NewApp.cpp` - Sistema de fallback automático

---

## 🛠️ Compilação

```bash

1. Abra o projeto no Visual Studio

2. Build > Build Solution (F7)

3. Execute o jogo

4. Resolução padrão será aplicada automaticamente

```

---

## ❗ Problemas Comuns

### Resolução não aplica?

- Delete `Config.bin` e execute novamente

- Verifique se a resolução é suportada pelo monitor

### Jogo crasha?

- Use uma resolução mais baixa (800x600)

- Verifique os logs de erro

### Fonte muito pequena/grande?

- O tamanho de fonte é ajustado automaticamente

- Se necessário, modifique no código (linha ~280)

---

## 📖 Documentação Completa

Para mais detalhes, consulte: **`TUTORIAL_RESOLUCAO.md`**

---

## ✅ Checklist

- [x] Resolução padrão: 1366x768

- [x] 11 resoluções disponíveis

- [x] Todas em 32 bits

- [x] Sistema de fallback automático

- [x] Tamanhos de fonte ajustados

- [x] Validação de resoluções

---

**Última Atualização**: 2025

**Créditos Mauzyn**

---

É necessário se cadastrar para acessar o conteúdo.

Créditos Mauzyn

Entrar

Quem está por aqui 0 membros estão online

Hook de Resolução - WYD Client Source (TMProject)

Posts Recomendados

Mauzyn 774

Link para o comentário

Compartilhar em outros sites

Participe da Conversa

Fóruns

Todas Atividades

Lojinha WC

Informação Importante