quests;
+ // ... implementation
+ return quests;
+}
+```
+
+**Key Points:**
+- Use 4 spaces for indentation (no tabs)
+- Opening braces on the same line for functions
+- Use meaningful variable names
+- Add comments for complex logic
+- Follow existing patterns in the codebase
+
+#### Lua Code (for examples/tests)
+
+```lua
+-- Use local variables
+local QUEST_STATUS_COMPLETE = 1
+
+-- Clear, descriptive function names
+local function OnQuestComplete(event, player, quest)
+ if not player or not quest then
+ return
+ end
+
+ local questId = quest:GetId()
+ print("Player", player:GetName(), "completed quest", questId)
+end
+
+-- Register with clear event IDs
+RegisterPlayerEvent(8, OnQuestComplete) -- PLAYER_EVENT_ON_QUEST_COMPLETE
+```
+
+### Testing Your Changes
+
+Before submitting a PR:
+
+1. **Compile the code** without errors
+2. **Test basic functionality** with your changes
+3. **Test edge cases** (nil values, invalid input, etc.)
+4. **Verify no regressions** (existing features still work)
+5. **Test on a real server** if possible
+
+## 🐛 Reporting Issues
+
+Good bug reports help us fix problems faster!
+
+### Before Reporting
+
+1. **Search existing issues** to avoid duplicates
+2. **Test on latest version** to ensure it's not already fixed
+3. **Gather information** about your setup and the problem
+
+### Creating a Good Issue Report
+
+Use this template:
+
+```markdown
+**Describe the bug**
+A clear description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Load script '...'
+2. Trigger event '...'
+3. See error
+
+**Expected behavior**
+What you expected to happen.
+
+**Actual behavior**
+What actually happened.
+
+**Environment:**
+- AzerothCore version: [e.g., commit hash]
+- ALE version: [e.g., commit hash]
+- Lua version: [e.g., LuaJIT, Lua 5.2]
+- OS: [e.g., Ubuntu 20.04]
+
+**Script/Code:**
+```lua
+-- Minimal script that reproduces the issue
+local function OnLogin(event, player)
+ -- problematic code
+end
+RegisterPlayerEvent(3, OnLogin)
+```
+
+**Error messages:**
+```
+Paste any error messages from the log here
+```
+
+**Additional context**
+Any other information that might be helpful.
+```
+
+## 📖 Improving Documentation
+
+Documentation is crucial for helping users understand ALE.
+
+### What to Document
+
+- **API Functions**: Descriptions, parameters, return values, examples
+- **Events**: When they trigger, what parameters they pass
+- **Best Practices**: Common patterns and anti-patterns
+- **Examples**: Real-world use cases and complete scripts
+
+### Documentation Workflow
+
+1. Fork the repository
+2. Edit documentation files in the `docs/` folder
+3. Use clear, concise language
+4. Add code examples where helpful
+5. Test any code examples you include
+6. Submit a Pull Request
+
+### Markdown Tips
+
+```markdown
+# Use headers for structure
+
+## Subsections help organize content
+
+**Bold** for emphasis
+
+`code` for inline code
+
+```lua
+-- Code blocks for examples
+```
+
+> [!TIP]
+> Use callouts for important information
+
+- Lists
+- Keep
+- Things
+- Organized
+```
+
+## 🎮 Creating Scripts
+
+Share your scripts with the community!
+
+### Where to Share
+
+- **Discord**: [ALE Community](https://discord.com/invite/bx3y5Qmy)
+- **GitHub Discussions**: For detailed explanations
+- **Pull Requests**: Add example scripts to the repository
+
+### Script Quality Guidelines
+
+Good example scripts should:
+
+1. **Be Well Commented**: Explain what the code does
+2. **Handle Edge Cases**: Check for nil values, validate input
+3. **Follow Best Practices**: Use local variables, cache data, etc.
+4. **Include Usage Instructions**: How to install and configure
+5. **Be Self-Contained**: Include all necessary code
+
+### Example Template
+
+```lua
+--[[
+Script Name: Player Welcome System
+Description: Sends customized welcome message based on player level
+Author: YourName
+Version: 1.0
+Date: 2025-01-09
+
+Installation:
+1. Place this file in lua_scripts folder
+2. Configure MESSAGES table below
+3. Restart server
+
+Features:
+- Different messages for different level ranges
+- Personalized with player name
+- Configurable message tiers
+]]
+
+-- Configuration
+local MESSAGES = {
+ [1] = "Welcome to the server, %s! Enjoy your adventure!",
+ [10] = "Welcome back, %s! You've grown stronger!",
+ [60] = "Greetings, veteran %s! The endgame awaits!",
+ [80] = "Welcome, champion %s! You've mastered your class!"
+}
+
+-- Get appropriate message for player level
+local function GetWelcomeMessage(player)
+ local level = player:GetLevel()
+ local message = MESSAGES[1] -- Default message
+
+ -- Find highest tier message player qualifies for
+ for minLevel, msg in pairs(MESSAGES) do
+ if level >= minLevel then
+ message = msg
+ end
+ end
+
+ return string.format(message, player:GetName())
+end
+
+-- Event handler
+local function OnLogin(event, player)
+ if not player then
+ return
+ end
+
+ local message = GetWelcomeMessage(player)
+ player:SendBroadcastMessage(message)
+end
+
+-- Register the event
+RegisterPlayerEvent(3, OnLogin) -- PLAYER_EVENT_ON_LOGIN
+```
+
+## 🔨 Development Guidelines
+
+### Project Structure
+
+```
+mod-ale/
+├── src/
+│ └── LuaEngine/ # Core ALE source code
+│ ├── docs/ # Source documentation
+│ ├── methods/ # API method implementations
+│ └── hooks/ # Event hook implementations
+├── docs/ # User-facing documentation
+├── conf/ # Configuration file templates
+└── README.md # Project overview
+```
+
+### Branch Strategy
+
+- **master**: Stable, production-ready code
+- **feature/**: New features (e.g., `feature/add-new-hook`)
+- **fix/**: Bug fixes (e.g., `fix/player-null-check`)
+- **docs/**: Documentation updates (e.g., `docs/update-install-guide`)
+
+### Pull Request Guidelines
+
+**Good PR:**
+- Single, focused change
+- Clear title and description
+- Links related issues
+- Passes compilation
+- Includes documentation updates if needed
+
+**PR Template:**
+
+```markdown
+## Description
+Brief description of the changes
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Documentation update
+- [ ] Performance improvement
+
+## Testing
+Describe how you tested your changes
+
+## Related Issues
+Fixes #123
+Related to #456
+
+## Checklist
+- [ ] Code compiles without errors
+- [ ] Tested on a running server
+- [ ] Updated documentation
+- [ ] Followed code style guidelines
+```
+
+---
+
+## 🌟 Acknowledgements
+
+ALE is built upon the foundation of the [Eluna Lua Engine](https://github.com/ElunaLuaEngine/Eluna). We acknowledge and thank the Eluna team for their pioneering work in Lua scripting for World of Warcraft server emulators.
+
+- **[Original Eluna Repository](https://github.com/ElunaLuaEngine/Eluna)**
+- **[Eluna Discord Community](https://discord.gg/bjkCVWqqfX)**
+
+---
+
+
+Developed with ❤️ by the AzerothCore and ALE community
+
+Thank you for contributing! 🎉
+
+[⬆ Back to Top](#-contributing-to-ale)
+
diff --git a/docs/IMPL_DETAILS.md b/docs/IMPL_DETAILS.md
new file mode 100644
index 0000000..80c5e8d
--- /dev/null
+++ b/docs/IMPL_DETAILS.md
@@ -0,0 +1,430 @@
+
+
+# ⚙️ ALE Implementation Details
+
+*Advanced features and technical documentation for ALE*
+
+[](https://discord.com/invite/ZKSVREE7)
+[](http://www.azerothcore.org/)
+
+---
+
+
+> [!IMPORTANT]
+> This document covers advanced implementation details and best practices for ALE (AzerothCore Lua Engine). For basic usage, see the [Usage Guide](USAGE.md).
+
+## 📋 Table of Contents
+
+- [Configuration](#-configuration)
+- [Script Management](#-script-management)
+- [Advanced Features](#-advanced-features)
+- [Database Integration](#-database-integration)
+- [Performance Tips](#-performance-tips)
+- [Debugging](#-debugging)
+
+## ⚙️ Configuration
+
+### Server Configuration File
+
+ALE settings are located in the AzerothCore server configuration file.
+
+> [!WARNING]
+> **Important:** Always use the new configuration file generated after compiling with ALE. Without it, error logging and output may not function correctly.
+
+### Available Settings
+
+- **Enable/Disable ALE**: Toggle the Lua engine on or off
+- **Traceback Function**: Enable detailed debug information in error messages
+- **Script Folder Location**: Configure where ALE looks for script files
+- **Logging Settings**: Control log verbosity and output destinations
+
+## 🔄 Script Management
+
+### Script Reloading
+
+Reload scripts during development with:
+
+```
+.reload eluna
+```
+
+> [!CAUTION]
+> **Development Only:** This command is for testing purposes only. For production use or troubleshooting, always restart the server.
+
+**Limitations:**
+- Events are not re-triggered for existing entities (e.g., logged-in players)
+- Some state may persist from the previous load
+- Race conditions may occur with active scripts
+
+### Script Loading
+
+#### Default Behavior
+
+- **Default Folder**: `lua_scripts` (configurable in server config)
+- **Hidden Folders**: Ignored during loading
+- **File Names**: Must be unique across all subdirectories
+- **Loading Order**: Not guaranteed to be alphabetical
+
+#### Load Priority
+
+Files with `.ext` extension load before standard `.lua` files:
+- `init.ext` loads before `script.lua`
+
+> [!TIP]
+> Instead of using `.ext`, prefer the standard Lua `require()` function for better maintainability.
+
+#### Using Require
+
+The entire script folder structure is added to Lua's require path:
+
+```lua
+-- Require file: lua_scripts/utilities/helpers.lua
+require("utilities/helpers")
+
+-- Or simply (if in root)
+require("helpers")
+```
+
+**Note:** Omit the `.lua` extension when using `require()`.
+
+## 🎯 Advanced Features
+
+### Automatic Type Conversion
+
+In C++, you must explicitly cast between types:
+```cpp
+Unit* unit = ...;
+Player* player = unit->ToPlayer(); // Manual cast required
+```
+
+In ALE, this happens automatically:
+```lua
+-- unit is automatically converted to the most specific type
+-- No manual casting needed!
+local name = unit:GetName() -- Works for Unit, Player, Creature, etc.
+```
+
+All objects are automatically converted to their most specific type, giving you full access to all available methods.
+
+### Storing Userdata Objects
+
+> [!CAUTION]
+> **Critical:** Never store C++-managed userdata objects in global variables or across events!
+
+#### The Problem
+
+C++ manages object lifetimes. A stored pointer can become invalid when:
+- A player logs out
+- A creature despawns
+- An object is deleted by the core
+
+Accessing invalid pointers causes crashes.
+
+#### The Solution
+
+Objects are automatically set to `nil` when they become unsafe (usually when the hook function ends).
+
+**Instead of storing objects:**
+
+```lua
+-- ❌ WRONG: Don't do this
+local savedPlayer = nil
+
+local function OnLogin(event, player)
+ savedPlayer = player -- Bad! Will be nil after function ends
+end
+
+local function OnLogout(event, player)
+ savedPlayer:SendMessage("Test") -- CRASH! savedPlayer is nil
+end
+```
+
+**Store GUIDs instead:**
+
+```lua
+-- ✅ CORRECT: Store GUID and retrieve object when needed
+local playerGUID = nil
+
+local function OnLogin(event, player)
+ playerGUID = player:GetGUID()
+end
+
+local function SomeLaterEvent(event, ...)
+ local player = GetPlayerByGUID(playerGUID)
+ if player then
+ player:SendMessage("Test") -- Safe!
+ end
+end
+```
+
+#### Safe to Store
+
+These userdata objects are Lua-managed and safe to store:
+- Query results (`ElunaQuery`)
+- World packets (`WorldPacket`)
+- 64-bit numbers (`uint64`, `int64`)
+
+### Userdata Metamethods
+
+#### ToString Support
+
+All userdata objects implement `tostring`:
+
+```lua
+print(player) -- Outputs: Player (Name: "John", GUID: 123456)
+print(creature) -- Outputs: Creature (Entry: 1234, GUID: 789012)
+```
+
+#### Global Metatables
+
+Each class has a global table containing its methods:
+
+```lua
+-- These global tables exist:
+Player = { GetName = function(...) end, ... }
+Creature = { GetEntry = function(...) end, ... }
+GameObject = { GetDisplayId = function(...) end, ... }
+```
+
+#### Custom Methods
+
+You can extend classes with custom methods:
+
+```lua
+function Player:CustomGreeting()
+ self:SendBroadcastMessage("Welcome, " .. self:GetName() .. "!")
+end
+
+function GameObject:IsChest()
+ return self:GetGoType() == 3
+end
+
+-- Usage:
+player:CustomGreeting()
+if gameobject:IsChest() then
+ print("Found a chest!")
+end
+```
+
+> [!WARNING]
+> Avoid modifying or deleting global class tables in normal code, as this can break other scripts.
+
+## 🗄️ Database Integration
+
+### Query Performance
+
+> [!IMPORTANT]
+> Database queries are slow! The entire server waits while data is fetched from disk.
+
+#### Synchronous vs Asynchronous
+
+**Use `Execute` for non-SELECT queries:**
+```lua
+-- Asynchronous - doesn't block server
+WorldDBExecute("UPDATE creature SET level = 80 WHERE entry = 1234")
+```
+
+**Use `Query` only when you need results:**
+```lua
+-- Synchronous - blocks server until complete
+local result = WorldDBQuery("SELECT name FROM creature_template WHERE entry = 1234")
+```
+
+#### Best Practices
+
+1. **Cache at Startup**: Load data once during server start or script load
+2. **Use Tables**: Store frequently accessed data in Lua tables
+3. **Batch Operations**: Combine multiple queries when possible
+4. **Async When Possible**: Use `Execute` instead of `Query` if you don't need results
+
+```lua
+-- ✅ Good: Cache data at startup
+local creatureNames = {}
+
+local function LoadCreatureNames()
+ local query = WorldDBQuery("SELECT entry, name FROM creature_template")
+ if query then
+ repeat
+ local entry = query:GetUInt32(0)
+ local name = query:GetString(1)
+ creatureNames[entry] = name
+ until not query:NextRow()
+ end
+end
+
+-- Call once at server start
+RegisterServerEvent(33, LoadCreatureNames) -- SERVER_EVENT_ON_CONFIG_LOAD
+
+-- Now use cached data
+local function OnSpawn(event, creature)
+ local name = creatureNames[creature:GetEntry()]
+ print("Spawned:", name)
+end
+```
+
+### Database Types
+
+> [!CAUTION]
+> **Critical:** Use the correct getter function for each database type!
+
+MySQL performs math in specific formats. Using the wrong getter can return incorrect values on different systems.
+
+#### Type Mapping Table
+
+| Base Type | Defined Type | Database Type | Query Getter |
+|---------------------------|--------------|-----------------------|-------------------|
+| char | int8 | tinyint(3) | `GetInt8()` |
+| short int | int16 | smallint(5) | `GetInt16()` |
+| (long int / int) | int32 | mediumint(8) | `GetInt32()` |
+| (long int / int) | int32 | int(10) | `GetInt32()` |
+| long long int | int64 | bigint(20) | `GetInt64()` |
+| unsigned char | uint8 | tinyint(3) unsigned | `GetUInt8()` |
+| unsigned short int | uint16 | smallint(5) unsigned | `GetUInt16()` |
+| unsigned (long int / int) | uint32 | mediumint(8) unsigned | `GetUInt32()` |
+| unsigned (long int / int) | uint32 | int(10) unsigned | `GetUInt32()` |
+| unsigned long long int | uint64 | bigint(20) unsigned | `GetUInt64()` |
+| float | float | float | `GetFloat()` |
+| double | double | double, decimal | `GetDouble()` |
+| std::string | std::string | varchar, text, etc. | `GetString()` |
+
+#### Example
+
+```lua
+-- ❌ WRONG: Can return 0 or 1 depending on system
+local result = WorldDBQuery("SELECT 1")
+local value = result:GetUInt32(0) -- Incorrect type!
+
+-- ✅ CORRECT: Always returns 1
+local result = WorldDBQuery("SELECT 1")
+local value = result:GetInt64(0) -- Correct type for literal numbers
+```
+
+## ⚡ Performance Tips
+
+### Variable Scope
+
+```lua
+-- ✅ Fast: Local variables
+local count = 0
+for i = 1, 1000 do
+ count = count + 1
+end
+
+-- ❌ Slow: Global variables
+count = 0
+for i = 1, 1000 do
+ count = count + 1
+end
+```
+
+### Table Efficiency
+
+```lua
+-- ❌ Avoid: Creating tables in loops
+for i = 1, 1000 do
+ local data = {i, i*2, i*3} -- 1000 table allocations!
+end
+
+-- ✅ Better: Reuse tables
+local data = {}
+for i = 1, 1000 do
+ data[1], data[2], data[3] = i, i*2, i*3
+end
+```
+
+### Cache Frequently Used Values
+
+```lua
+-- ❌ Avoid: Repeated method calls
+for i = 1, 100 do
+ player:GetName() -- Calls C++ function 100 times
+end
+
+-- ✅ Better: Cache the value
+local playerName = player:GetName()
+for i = 1, 100 do
+ -- Use playerName
+end
+```
+
+### Minimize Database Access
+
+```lua
+-- ❌ Bad: Query in a loop
+for entry = 1, 100 do
+ local query = WorldDBQuery("SELECT name FROM creature_template WHERE entry = " .. entry)
+end
+
+-- ✅ Good: Single query with IN clause
+local query = WorldDBQuery("SELECT entry, name FROM creature_template WHERE entry BETWEEN 1 AND 100")
+```
+
+## 🐛 Debugging
+
+### Print Debugging
+
+```lua
+-- Basic output
+print("Debug: Function called")
+
+-- With variables
+print("Player:", player:GetName(), "Level:", player:GetLevel())
+
+-- Object inspection
+print(player) -- Uses tostring metamethod
+```
+
+### Error Logs
+
+Check these locations for errors:
+- **Server Console**: Real-time output
+- **Log File**: Persistent record in server folder
+
+### Traceback
+
+Enable traceback in the server config for detailed error information:
+```
+Eluna.TraceBack = 1
+```
+
+This adds call stack information to errors.
+
+### Incremental Testing
+
+1. **Start Small**: Test basic functionality first
+2. **Add Gradually**: Implement features one at a time
+3. **Test Each Step**: Verify each addition works before moving on
+4. **Use Reload**: Use `.reload eluna` for quick iteration (dev only)
+5. **Full Restart**: Always do final testing with a server restart
+
+### Common Issues
+
+**Objects becoming nil:**
+- You're storing userdata objects instead of GUIDs
+- See [Storing Userdata Objects](#storing-userdata-objects)
+
+**Wrong database values:**
+- Using incorrect getter function for database type
+- See [Database Types](#database-types)
+
+**Script not loading:**
+- Check for duplicate filenames
+- Check log for syntax errors
+- Verify script folder configuration
+
+---
+
+## 🌟 Acknowledgements
+
+ALE is built upon the foundation of the [Eluna Lua Engine](https://github.com/ElunaLuaEngine/Eluna). We acknowledge and thank the Eluna team for their pioneering work in Lua scripting for World of Warcraft server emulators.
+
+- **[Original Eluna Repository](https://github.com/ElunaLuaEngine/Eluna)**
+- **[Eluna Discord Community](https://discord.gg/bjkCVWqqfX)**
+
+---
+
+
+Developed with ❤️ by the AzerothCore and ALE community
+
+[⬆ Back to Top](#-ale-implementation-details)
+
diff --git a/docs/INSTALL.md b/docs/INSTALL.md
new file mode 100644
index 0000000..c28dba3
--- /dev/null
+++ b/docs/INSTALL.md
@@ -0,0 +1,316 @@
+
+
+# 🔧 ALE Installation Guide
+
+*Step-by-step instructions for installing ALE on AzerothCore*
+
+[](https://discord.com/invite/ZKSVREE7)
+[](http://www.azerothcore.org/)
+
+---
+
+
+> [!IMPORTANT]
+> ALE is designed specifically for **AzerothCore**. If you're looking for compatibility with other emulators, check out [ElunaAzerothCore](https://github.com/Eluna-Ports/ElunaAzerothCore) for original Eluna compatibility.
+
+## 📋 Table of Contents
+
+- [Requirements](#-requirements)
+- [Installation](#-installation)
+- [Configuration](#-configuration)
+- [Updating](#-updating)
+- [Troubleshooting](#-troubleshooting)
+- [Next Steps](#-next-steps)
+
+## ⚡ Requirements
+
+Before installing ALE, ensure you have:
+
+### System Requirements
+
+- **AzerothCore Server**: A working AzerothCore installation
+- **Git**: Version control system for cloning repositories
+- **CMake**: Build system (3.16 or higher recommended)
+- **Compiler with C++11 Support**:
+ - Windows: Visual Studio 2019 or later
+ - Linux: GCC 7+ or Clang 5+
+ - macOS: Xcode 10+
+
+### Build Dependencies
+
+ALE can use either:
+- **ACE** (ADAPTIVE Communication Environment), or
+- **Boost** (for filesystem library)
+
+These should already be available if you have AzerothCore set up.
+
+## 🚀 Installation
+
+### Step 1: Navigate to Modules Directory
+
+Open your terminal (or Git Bash on Windows) and navigate to your AzerothCore modules directory:
+
+```bash
+cd /modules
+```
+
+**Example:**
+```bash
+cd /home/user/azerothcore/modules
+```
+
+### Step 2: Clone the Repository
+
+Clone the mod-ale repository into your modules folder:
+
+```bash
+git clone https://github.com/azerothcore/mod-ale.git
+```
+
+This will create a `mod-ale` folder containing all necessary files.
+
+### Step 3: Configure Build
+
+Navigate to your AzerothCore build directory and configure with CMake:
+
+```bash
+cd
+cmake ../ -DLUA_VERSION=luajit
+```
+
+#### Lua Version Options
+
+Choose your preferred Lua version with the `-DLUA_VERSION` flag:
+
+| Version | Flag | Notes |
+|---------|------|-------|
+| **LuaJIT** | `luajit` | **Recommended** - Best performance via JIT compilation |
+| **Lua 5.2** | `lua52` | **Default** - Used if no version specified |
+| **Lua 5.3** | `lua53` | Newer features, compatible |
+| **Lua 5.4** | `lua54` | Latest version, all features |
+
+**Examples:**
+
+```bash
+# Using LuaJIT (recommended for performance)
+cmake ../ -DLUA_VERSION=luajit
+
+# Using Lua 5.3
+cmake ../ -DLUA_VERSION=lua53
+
+# Using default (Lua 5.2)
+cmake ../
+```
+
+### Step 4: Compile
+
+Compile AzerothCore with the newly added module:
+
+**Linux/macOS:**
+```bash
+make -j$(nproc)
+```
+
+**Windows:**
+```bash
+cmake --build . --config Release
+```
+
+> [!TIP]
+> The `-j$(nproc)` flag uses all available CPU cores for faster compilation.
+
+### Step 5: Update Configuration
+
+> [!CAUTION]
+> **Critical Step:** After compiling, you must use the newly generated configuration files!
+
+The compilation process generates updated config files with ALE settings. Without these, ALE may not function correctly (no error messages, logging issues, etc.).
+
+**Location of config files:**
+- Usually in your server's `etc/` or `configs/` directory
+- Look for files like `worldserver.conf`
+
+Copy the new `.conf.dist` files:
+
+```bash
+# Example - adjust paths as needed
+cp worldserver.conf.dist worldserver.conf
+```
+
+Then edit `worldserver.conf` and configure ALE settings (see [Configuration](#-configuration) below).
+
+## ⚙️ Configuration
+
+### ALE Settings in worldserver.conf
+
+After installation, configure ALE by editing your `worldserver.conf` file:
+
+```ini
+###################################################################################################
+# ALE (AZEROTHCORE LUA ENGINE)
+###################################################################################################
+
+# Enable or disable ALE
+# Default: 1 (enabled)
+Eluna.Enabled = 1
+
+# Enable traceback for detailed error information
+# Useful for debugging but has performance overhead
+# Default: 1 (enabled)
+Eluna.TraceBack = 1
+
+# Script folder location (relative to server binary)
+# Default: "lua_scripts"
+Eluna.ScriptPath = "lua_scripts"
+
+# Logging level
+# 0 = Disabled
+# 1 = Errors only
+# 2 = Errors and warnings
+# 3 = All messages (debug)
+# Default: 2
+Eluna.LogLevel = 2
+```
+
+### Creating the Scripts Folder
+
+Create the scripts folder next to your server executable:
+
+```bash
+mkdir lua_scripts
+```
+
+Place your `.lua` script files in this folder. ALE will automatically load them on server start.
+
+## 🔄 Updating
+
+Keep your ALE installation up to date with the latest features and bug fixes.
+
+### Update Steps
+
+1. **Navigate to the mod-ale directory:**
+
+```bash
+cd /modules/mod-ale
+```
+
+2. **Pull the latest changes:**
+
+```bash
+git pull
+```
+
+3. **Navigate to your build directory:**
+
+```bash
+cd
+```
+
+4. **Reconfigure if needed (optional):**
+
+```bash
+cmake ../ -DLUA_VERSION=luajit
+```
+
+5. **Recompile:**
+
+```bash
+# Linux/macOS
+make -j$(nproc)
+
+# Windows
+cmake --build . --config Release
+```
+
+6. **Restart your server** to load the updated version
+
+> [!TIP]
+> Always backup your database and scripts before updating!
+
+## 🔧 Troubleshooting
+
+### ALE Not Loading
+
+**Check these things:**
+
+1. **Config file**: Ensure you're using the new `worldserver.conf` generated after compilation
+2. **Enabled setting**: Verify `Eluna.Enabled = 1` in config
+3. **Script path**: Ensure `lua_scripts` folder exists in the correct location
+4. **Logs**: Check server logs for error messages
+
+### No Error Messages
+
+If you're not seeing ALE errors:
+
+- **Solution**: You're using an old config file. Copy the new `.conf.dist` file and reconfigure.
+
+### Compilation Errors
+
+**"Lua headers not found":**
+- ALE should automatically download Lua dependencies
+- Ensure you have internet connection during CMake configuration
+
+**C++11 errors:**
+- Update your compiler to one that supports C++11 or later
+
+**ACE/Boost errors:**
+- These should be installed with AzerothCore
+- Check your AzerothCore installation
+
+### Scripts Not Loading
+
+1. **Check file extension**: Must be `.lua`
+2. **Check file names**: Must be unique across all subdirectories
+3. **Check syntax**: Look for errors in the log file
+4. **Check location**: Scripts must be in the configured `ScriptPath` folder
+
+### Getting Help
+
+If you encounter issues:
+
+- **GitHub Issues**: [Report problems](https://github.com/azerothcore/mod-ale/issues)
+- **Discord**: [Join our community](https://discord.com/invite/bx3y5Qmy)
+- **AzerothCore Discord**: [Get support](http://www.azerothcore.org/)
+
+## 📚 Next Steps
+
+Now that ALE is installed, you're ready to start scripting!
+
+### Recommended Reading
+
+1. **[Usage Guide](USAGE.md)** - Learn how to write your first script
+2. **[Implementation Details](IMPL_DETAILS.md)** - Advanced features and best practices
+3. **[API Documentation](https://www.azerothcore.org/eluna/)** - Complete API reference
+4. **[Hooks Reference](https://github.com/azerothcore/mod-ale/blob/master/src/LuaEngine/Hooks.h)** - Available event hooks
+
+### Example Scripts
+
+Create a test script to verify everything works:
+
+**File:** `lua_scripts/test.lua`
+```lua
+local function OnServerStartup()
+ print("ALE is working! Server started successfully.")
+end
+
+RegisterServerEvent(33, OnServerStartup) -- SERVER_EVENT_ON_CONFIG_LOAD
+```
+
+Restart your server and look for the message in the console.
+
+---
+
+## 🌟 Acknowledgements
+
+ALE is built upon the foundation of the [Eluna Lua Engine](https://github.com/ElunaLuaEngine/Eluna). We acknowledge and thank the Eluna team for their pioneering work in Lua scripting for World of Warcraft server emulators.
+
+- **[Original Eluna Repository](https://github.com/ElunaLuaEngine/Eluna)**
+- **[Eluna Discord Community](https://discord.gg/bjkCVWqqfX)**
+
+---
+
+
+Developed with ❤️ by the AzerothCore and ALE community
+
+[⬆ Back to Top](#-ale-installation-guide)
+
diff --git a/docs/MERGING.md b/docs/MERGING.md
new file mode 100644
index 0000000..0fa2323
--- /dev/null
+++ b/docs/MERGING.md
@@ -0,0 +1,407 @@
+
+
+# 🔀 Advanced ALE Integration
+
+*Customizing and extending ALE for your specific needs*
+
+[](https://discord.com/invite/ZKSVREE7)
+[](http://www.azerothcore.org/)
+
+---
+
+
+> [!IMPORTANT]
+> ALE is distributed as an AzerothCore module. Unlike traditional forks, you don't need to merge code. However, this guide covers advanced integration scenarios for custom AzerothCore builds.
+
+## 📋 Table of Contents
+
+- [Standard Installation](#-standard-installation)
+- [Custom AzerothCore Builds](#-custom-azerothcore-builds)
+- [Maintaining Custom Changes](#-maintaining-custom-changes)
+- [Updating ALE](#-updating-ale)
+- [Contributing Back](#-contributing-back)
+- [Troubleshooting](#-troubleshooting)
+
+## ✅ Standard Installation
+
+For most users, installing ALE is straightforward:
+
+```bash
+# Navigate to modules directory
+cd /modules
+
+# Clone ALE
+git clone https://github.com/azerothcore/mod-ale.git
+
+# Rebuild AzerothCore
+cd
+cmake ../ -DLUA_VERSION=luajit
+make -j$(nproc)
+```
+
+> [!TIP]
+> If you're using the standard AzerothCore setup, see the [Installation Guide](INSTALL.md) instead. This guide is for advanced scenarios only.
+
+## 🔧 Custom AzerothCore Builds
+
+### Working with Forked AzerothCore
+
+If you maintain a fork of AzerothCore with custom modifications:
+
+#### Step 1: Add ALE as a Submodule (Recommended)
+
+```bash
+cd
+
+# Add ALE as a submodule
+git submodule add https://github.com/azerothcore/mod-ale.git modules/mod-ale
+
+# Initialize and update
+git submodule init
+git submodule update
+
+# Commit the submodule addition
+git add .gitmodules modules/mod-ale
+git commit -m "Add mod-ale as submodule"
+```
+
+**Benefits:**
+- Easy updates with `git submodule update`
+- Tracks specific ALE versions
+- Clean separation between your code and ALE
+
+#### Step 2: Configure Build
+
+Your CMake configuration should automatically detect the module:
+
+```bash
+cd build
+cmake ../ -DLUA_VERSION=luajit
+make -j$(nproc)
+```
+
+### Alternative: Clone Directly
+
+If you prefer not to use submodules:
+
+```bash
+cd /modules
+git clone https://github.com/azerothcore/mod-ale.git
+```
+
+> [!WARNING]
+> **Not Recommended:** Avoid adding the `modules/mod-ale` directory to your fork's git repository. It makes updates more difficult.
+
+Add to your `.gitignore`:
+```
+modules/mod-ale/
+```
+
+## 🛠️ Maintaining Custom Changes
+
+### Modifying ALE for Your Server
+
+If you need to customize ALE:
+
+#### Option 1: Fork ALE (Recommended)
+
+1. **Fork the repository** on GitHub
+2. **Clone your fork** instead of the official repository:
+ ```bash
+ cd modules
+ git clone https://github.com/YOUR_USERNAME/mod-ale.git
+ ```
+3. **Make your changes** in a feature branch
+4. **Keep in sync** with upstream:
+ ```bash
+ git remote add upstream https://github.com/azerothcore/mod-ale.git
+ git fetch upstream
+ git merge upstream/master
+ ```
+
+#### Option 2: Patch Files
+
+For small changes, create patch files:
+
+```bash
+# Make your changes to ALE
+cd modules/mod-ale
+
+# Create a patch
+git diff > ../../patches/ale-custom-changes.patch
+
+# Apply the patch after updating
+git pull
+git apply ../../patches/ale-custom-changes.patch
+```
+
+### Recommended Approach: Extension Scripts
+
+Instead of modifying ALE core, create extension scripts:
+
+**File:** `lua_scripts/extensions/custom_functions.lua`
+```lua
+-- Extend existing classes with custom methods
+function Player:CustomMethod()
+ -- Your custom functionality
+end
+
+function Creature:CustomBehavior()
+ -- Your custom functionality
+end
+```
+
+**Benefits:**
+- No ALE core modifications needed
+- Easy to update ALE
+- Clean separation of custom code
+- Portable across ALE versions
+
+## 🔄 Updating ALE
+
+### Standard Update Process
+
+For standard installations:
+
+```bash
+cd modules/mod-ale
+git pull
+cd ../../build
+make -j$(nproc)
+```
+
+### Updating with Submodules
+
+If you added ALE as a submodule:
+
+```bash
+# Update to latest ALE
+git submodule update --remote modules/mod-ale
+
+# Or update all submodules
+git submodule update --remote
+
+# Commit the update
+git add modules/mod-ale
+git commit -m "Update mod-ale to latest version"
+```
+
+### Updating with Custom Changes
+
+If you maintain a fork:
+
+```bash
+cd modules/mod-ale
+
+# Fetch upstream changes
+git fetch upstream
+
+# Merge or rebase your changes
+git merge upstream/master
+# or
+git rebase upstream/master
+
+# Resolve any conflicts
+# Then rebuild
+cd ../../build
+make -j$(nproc)
+```
+
+### Version Pinning
+
+To pin a specific ALE version:
+
+```bash
+cd modules/mod-ale
+
+# List available tags
+git tag
+
+# Checkout specific version
+git checkout v1.2.3
+
+# Or specific commit
+git checkout abc123def
+```
+
+> [!TIP]
+> Pin versions in production environments for stability. Use latest in development for new features.
+
+## 🤝 Contributing Back
+
+If you've made improvements that could benefit others:
+
+### Preparing a Contribution
+
+1. **Ensure it's generic**: Your change should be useful for the broader community
+2. **Follow coding standards**: See [Contributing Guide](CONTRIBUTING.md)
+3. **Test thoroughly**: Verify your changes don't break existing functionality
+4. **Document changes**: Add comments and update documentation
+
+### Submission Process
+
+1. **Fork the official repository**
+2. **Create a feature branch**:
+ ```bash
+ git checkout -b feature/my-improvement
+ ```
+3. **Make your changes**
+4. **Push to your fork**:
+ ```bash
+ git push origin feature/my-improvement
+ ```
+5. **Open a Pull Request** on GitHub
+
+See the [Contributing Guide](CONTRIBUTING.md) for detailed instructions.
+
+## 🔧 Troubleshooting
+
+### Merge Conflicts
+
+If you encounter conflicts when updating:
+
+```bash
+# Check which files have conflicts
+git status
+
+# Edit conflicting files to resolve
+# Look for conflict markers: <<<<<<<, =======, >>>>>>>
+
+# Mark as resolved
+git add
+
+# Complete the merge
+git merge --continue
+```
+
+### Module Not Loading
+
+**Check CMake configuration:**
+```bash
+cd build
+cmake ../ -DLUA_VERSION=luajit
+```
+
+Look for output like:
+```
+-- ALE module found: /path/to/modules/mod-ale
+```
+
+**Verify module directory structure:**
+```
+modules/
+└── mod-ale/
+ ├── CMakeLists.txt
+ ├── src/
+ │ └── LuaEngine/
+ └── conf/
+```
+
+### Build Errors After Update
+
+**Clean build recommended:**
+```bash
+cd build
+rm -rf *
+cmake ../ -DLUA_VERSION=luajit
+make -j$(nproc)
+```
+
+### Submodule Issues
+
+**Submodule not initialized:**
+```bash
+git submodule init
+git submodule update
+```
+
+**Submodule in detached HEAD state:**
+```bash
+cd modules/mod-ale
+git checkout master
+git pull
+```
+
+## 🎯 Advanced Scenarios
+
+### Multiple ALE Versions
+
+Testing with different ALE versions:
+
+```bash
+# Clone to different directories
+cd modules
+git clone https://github.com/azerothcore/mod-ale.git mod-ale-stable
+git clone https://github.com/azerothcore/mod-ale.git mod-ale-dev
+
+# Switch between them
+ln -sf mod-ale-stable mod-ale # Use stable
+ln -sf mod-ale-dev mod-ale # Use dev
+```
+
+### Custom Lua Version
+
+Using a custom Lua installation:
+
+```bash
+cmake ../ \
+ -DLUA_VERSION=custom \
+ -DLUA_INCLUDE_DIR=/path/to/lua/include \
+ -DLUA_LIBRARIES=/path/to/lua/lib/liblua.a
+```
+
+### Automated Updates
+
+Create an update script:
+
+**File:** `scripts/update-ale.sh`
+```bash
+#!/bin/bash
+
+cd modules/mod-ale || exit 1
+
+echo "Fetching latest ALE..."
+git fetch upstream
+
+echo "Current version: $(git rev-parse --short HEAD)"
+echo "Latest version: $(git rev-parse --short upstream/master)"
+
+read -p "Update to latest? (y/n) " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+ git merge upstream/master
+ cd ../../build
+ make -j$(nproc)
+ echo "ALE updated successfully!"
+fi
+```
+
+## 📚 Additional Resources
+
+- **[Installation Guide](INSTALL.md)** - Standard installation process
+- **[Contributing Guide](CONTRIBUTING.md)** - How to contribute changes
+- **[Usage Guide](USAGE.md)** - Getting started with scripting
+- **[AzerothCore Documentation](http://www.azerothcore.org/)** - Core documentation
+
+### Getting Help
+
+- **GitHub Issues**: [Report problems](https://github.com/azerothcore/mod-ale/issues)
+- **Discord**: [Join our community](https://discord.com/invite/bx3y5Qmy)
+- **AzerothCore Discord**: [Get support](http://www.azerothcore.org/)
+
+---
+
+## 🌟 Acknowledgements
+
+ALE is built upon the foundation of the [Eluna Lua Engine](https://github.com/ElunaLuaEngine/Eluna). We acknowledge and thank the Eluna team for their pioneering work in Lua scripting for World of Warcraft server emulators.
+
+- **[Original Eluna Repository](https://github.com/ElunaLuaEngine/Eluna)**
+- **[Eluna Discord Community](https://discord.gg/bjkCVWqqfX)**
+
+---
+
+
+Developed with ❤️ by the AzerothCore and ALE community
+
+[⬆ Back to Top](#-advanced-ale-integration)
+
diff --git a/docs/USAGE.md b/docs/USAGE.md
new file mode 100644
index 0000000..7c3083e
--- /dev/null
+++ b/docs/USAGE.md
@@ -0,0 +1,279 @@
+
+
+# 📖 ALE Usage Guide
+
+*Learn how to create powerful Lua scripts for your AzerothCore server*
+
+[](https://discord.com/invite/ZKSVREE7)
+[](http://www.lua.org/manual/5.2/)
+
+---
+
+
+> [!IMPORTANT]
+> This guide is for **ALE (AzerothCore Lua Engine)**, which is specifically designed for AzerothCore. Scripts and APIs may differ from other Lua engines.
+
+## 📋 Table of Contents
+
+- [Prerequisites](#-prerequisites)
+- [Your First Script](#-your-first-script)
+- [Lua Basics](#-lua-basics)
+- [ALE Basics](#-ale-basics)
+- [Script Reloading](#-script-reloading)
+- [Getting Help](#-getting-help)
+
+## ✅ Prerequisites
+
+This guide assumes you have already installed ALE successfully. If you have not, see the [Installation Guide](INSTALL.md) or the [Installation section](../README.md#-installation) in the README.
+
+## 🚀 Your First Script
+
+Let's create a simple "Hello World" script to get you started.
+
+### Creating the Script File
+
+Create a file named `hello_world.lua` in your scripts folder. By default, this folder is called `lua_scripts` and is located in your server folder (the folder containing server executables).
+
+```lua
+local PLAYER_EVENT_ON_LOGIN = 3
+
+local function OnLogin(event, player)
+ player:SendBroadcastMessage("Hello world from ALE!")
+end
+
+RegisterPlayerEvent(PLAYER_EVENT_ON_LOGIN, OnLogin)
+```
+
+### Running the Script
+
+1. Restart your AzerothCore server
+2. Log in to the game
+3. You should see "Hello world from ALE!" in your chat
+
+### What Just Happened?
+
+No core compiling was needed! Your script runs directly from the file you created.
+
+Here's what the script does:
+- The file is compiled and run by the Lua engine when the server starts
+- The code registers a function to be executed when a player logs in
+- When the event triggers, the function sends a message to the player
+
+## 📚 Lua Basics
+
+Before diving deep into ALE scripting, it's helpful to understand some Lua fundamentals.
+
+### Learning Resources
+
+- **Lua Users Wiki**
+ - [Lua Directory](http://lua-users.org/wiki/LuaDirectory)
+ - [Tutorial Directory](http://lua-users.org/wiki/TutorialDirectory)
+ - [Sample Code](http://lua-users.org/wiki/SampleCode)
+- **[Programming in Lua](http://www.lua.org/pil/1.html)** - Comprehensive guide
+- **[Lua 5.2 Reference Manual](http://www.lua.org/manual/5.2/)** - Official documentation
+
+### Essential Concepts
+
+#### Debugging with Print
+
+The `print()` function outputs to the server console - perfect for debugging:
+
+```lua
+print("Debug message here")
+print("Player name:", player:GetName())
+```
+
+#### Control Structures
+
+Learn about loops and conditionals:
+- [Control Structure Tutorial](http://lua-users.org/wiki/ControlStructureTutorial)
+- [Lua Manual - Control Structures](http://www.lua.org/manual/5.2/manual.html#3.3.5)
+
+#### String Manipulation
+
+Essential for text processing:
+- [String Library Tutorial](http://lua-users.org/wiki/StringLibraryTutorial)
+- [Pattern Matching](http://www.wowwiki.com/Pattern_matching)
+
+#### Tables
+
+Tables are Lua's only data structure (arrays and hash maps combined):
+- [Table Functions](http://www.lua.org/manual/5.2/manual.html#6.5)
+- [Table Semantics](http://www.lua.org/manual/5.2/manual.html#4.3)
+- [Tables Tutorial](http://lua-users.org/wiki/TablesTutorial)
+- [Programming in Lua - Tables](http://www.lua.org/pil/2.5.html)
+
+#### Variable Scope
+
+**Important:** Prefer local variables over global variables!
+
+```lua
+-- Good: Local variable
+local playerName = "John"
+
+-- Avoid: Global variable
+playerName = "John"
+```
+
+Global variables can create conflicts with other scripts. Local variables outside functions are shared within the same script file (locally global).
+
+## ⚡ ALE Basics
+
+### Documentation Resources
+
+- **[ALE API Documentation](https://www.azerothcore.org/eluna/)** - Complete API reference
+- **[Hooks Documentation](https://github.com/azerothcore/mod-ale/blob/master/src/LuaEngine/Hooks.h)** - Available event hooks
+- **[Implementation Details](IMPL_DETAILS.md)** - Advanced features and best practices
+
+### Error Messages
+
+ALE outputs errors to:
+- Server console (real-time)
+- Log file in the server folder (persistent)
+
+If your script doesn't work, check the log file for errors. You can configure logging settings in the server configuration file.
+
+### Global Functions
+
+Global functions can be called from anywhere without requiring an object.
+
+Besides standard Lua functions like `print()`, ALE provides its own global functions. Find them in the documentation under the `Global` class: [Global Functions](https://www.azerothcore.org/eluna/Global/index.html).
+
+```lua
+-- Example: Get the Lua engine name
+print(GetLuaEngine())
+
+-- Example: Get current game time
+local time = GetGameTime()
+```
+
+### Member Functions (Methods)
+
+Methods require a userdata object to run. Different object types (Player, Creature, GameObject, etc.) have different available methods.
+
+#### Class Inheritance
+
+Classes inherit from each other. For example:
+- `Player` and `Creature` both inherit from `Unit`
+- This means both players and creatures can use `Unit` methods
+
+#### Calling Methods
+
+Use the `:` notation to call methods on objects:
+
+```lua
+-- Get player name
+local name = player:GetName()
+
+-- Get creature level
+local level = creature:GetLevel()
+```
+
+#### Example: Creature Combat Script
+
+```lua
+local entry = 6 -- Creature entry ID
+local on_combat = 1 -- Event ID for combat start
+
+local function OnCombat(event, creature, target)
+ -- creature is of type Creature
+ -- target is of type Creature or Player
+
+ print("Creature level:", creature:GetLevel())
+ print("Target level:", target:GetLevel())
+
+ creature:SendUnitYell("You dare challenge me?!", 0)
+end
+
+RegisterCreatureEvent(entry, on_combat, OnCombat)
+```
+
+### Registering Event Handlers
+
+Scripts work by registering functions to events. When the event occurs, your function executes.
+
+#### Finding Register Functions
+
+Search for "register" in the [ALE documentation](https://www.azerothcore.org/eluna/) to find all available register functions:
+- `RegisterPlayerEvent`
+- `RegisterCreatureEvent`
+- `RegisterServerEvent`
+- And many more...
+
+#### Event IDs
+
+Each register function requires an event ID. Find these IDs in the function's documentation page.
+
+#### Function Parameters
+
+ALE automatically passes parameters to your registered functions. The parameters are always in the same order, but you can name them anything you want.
+
+Example: `PLAYER_EVENT_ON_LOGIN` passes:
+1. Event ID (number)
+2. Player object (Player)
+
+```lua
+local function OnLogin(event, player)
+ -- event = event ID number
+ -- player = Player object
+end
+```
+
+#### Return Values
+
+Some events allow your function to return values to modify behavior. Check the event's documentation to see what can be returned.
+
+```lua
+local function OnChat(event, player, msg, type, lang)
+ if msg == "blocked" then
+ return false -- Blocks the chat message
+ end
+end
+```
+
+## 🔄 Script Reloading
+
+For quick testing during development, you can reload scripts without restarting:
+
+```
+.reload eluna
+```
+
+> [!WARNING]
+> **Development Only:** Use `.reload eluna` only for development. For production or if experiencing issues, always restart the server.
+
+**Important Limitations:**
+- Reloading doesn't trigger events like login for already-connected players
+- Some state may not reset properly
+- Always do final testing with a full server restart
+
+## 💬 Getting Help
+
+### Support Channels
+
+- **GitHub Issues**: [Report bugs or request features](https://github.com/azerothcore/mod-ale/issues)
+- **Discord Community**: [Join our Discord server](https://discord.com/invite/bx3y5Qmy)
+- **AzerothCore Discord**: [Official AzerothCore support](http://www.azerothcore.org/)
+
+### Additional Resources
+
+- [Lua Programming Guide](http://www.lua.org/)
+- [AzerothCore Documentation](http://www.azerothcore.org/)
+- [Implementation Details](IMPL_DETAILS.md) - Advanced ALE features
+
+---
+
+## 🌟 Acknowledgements
+
+ALE is built upon the foundation of the [Eluna Lua Engine](https://github.com/ElunaLuaEngine/Eluna). We acknowledge and thank the Eluna team for their pioneering work in Lua scripting for World of Warcraft server emulators.
+
+- **[Original Eluna Repository](https://github.com/ElunaLuaEngine/Eluna)**
+- **[Eluna Discord Community](https://discord.gg/bjkCVWqqfX)**
+
+---
+
+
+Developed with ❤️ by the AzerothCore and ALE community
+
+[⬆ Back to Top](#-ale-usage-guide)
+
diff --git a/src/LuaEngine/docs/CONTRIBUTING.md b/src/LuaEngine/docs/CONTRIBUTING.md
deleted file mode 100644
index 2a287f4..0000000
--- a/src/LuaEngine/docs/CONTRIBUTING.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Contributing
-Eluna uses C for the Lua engine, C++ for the server modifications and system code, Lua for scripting side code and scripts, python for the web documentation generation - but you do not have to be able to code to help.
-
-You can contribute to Eluna in various ways:
-* Improve our documentation: [Documentation generation](DOC_GEN.md)
-* Create new features or enhance old features: [Eluna source](https://github.com/ElunaLuaEngine/Eluna)
-* Notify us about your concerns, problems and needs regarding Eluna: [Issue tracker](https://github.com/ElunaLuaEngine/Eluna/issues)
-* Create and improve Lua scripts, systems, releases and guides: [Eluna forum section](https://www.getmangos.eu/forums/forum/118-eluna-lua-engine/)
-
-### Features and documentation
-To contribute to the source code and documentation within it, create a pull request for our github repository:
-
-1. [Set up git](https://help.github.com/articles/set-up-git/)
-2. [Fork](https://help.github.com/articles/fork-a-repo/) our repository: [Eluna repository](https://github.com/ElunaLuaEngine/Eluna)
-3. Create a branch: `git checkout -b mybranch`
-4. Make your contribution changes
-5. Commit your changes `git commit -a -m "commit message"`
-6. Push your commit to github: `git push`
-7. Open a [pull request](https://help.github.com/articles/using-pull-requests/)
diff --git a/src/LuaEngine/docs/IMPL_DETAILS.md b/src/LuaEngine/docs/IMPL_DETAILS.md
deleted file mode 100644
index 2041dae..0000000
--- a/src/LuaEngine/docs/IMPL_DETAILS.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# Eluna features
-This article contains information about features and important notes regarding Eluna.
-
-## Settings
-Eluna has some settings in the server configuration file.
-It is important that you use the new configuration file that you get from compiling after adding Eluna. If the new configuration file is not used you will not receive any error log or output to console.
-
-The configuration file includes at least the following settings:
-- enable and disable Eluna
-- enable and disable traceback function - this adds extra debug information if you have the default Eluna extensions.
-- configure script folder location
-- configure Eluna logging settings
-
-## Reloading
-To make testing easier it is good to know that Eluna scripts can be reloaded by using the command `.reload eluna`.
-However this command should be used for development purposes __ONLY__. If you are having issues getting something working __restart__ the server.
-
-It is important to know that reloading does not trigger for example the login hook for players that are already logged in when reloading.
-
-## Script loading
-Eluna loads scripts from the `lua_scripts` folder by default. You can configure the folder name and location in the server configuration file.
-Any hidden folders are not loaded. All script files must have an unique name, otherwise an error is printed and only the first file found is loaded.
-
-The loading order is not guaranteed to be alphabetic.
-Any file having `.ext` extension, for example `test.ext`, is loaded before normal lua files.
-
-Instead of the ext special feature however it is recommended to use the basic lua `require` function.
-The whole script folder structure is added automatically to the lua require path so using require is as simple as providing the file name without any extension for example `require("runfirst")` to require the file `runfirst.lua`.
-
-## Automatic conversion
-In C++ level code you have types like `Unit` and `Creature` and `Player`.
-When in code you have an object of type `Unit` you need to convert it to a `Creature` or a `Player` object to be able to access the methods of the subclass.
-
-In Eluna this is automatic. All objects are automatically converted to the correct type and you will always have full access to all member functions of an object.
-
-## Storing userdata
-Storing userdata objects over time that are memory managed by C++ is a bad idea.
-For example you should never save a player to a global variable and then try access it in a timed event. The reason is that the player object in C++ is a pointer to an object that C++ can delete at any time. When time passes the player may have logged out and using the pointer after player object no longer exists can be catastrophic.
-
-To prevent users from doing this objects that are memory managed by C++ are automatically turned into nil when they are no longer safe to be accessed - this means usually after the hooked function ends.
-Instead of storing the object itself you can use store guids `player:GetGUID()` and fetch the object by the guid with `map:GetWorldObject(guid)`.
-
-Any userdata object that is memory managed by lua is safe to store over time. These objects include but are not limited to: query results, worldpackets, uint64 and int64 numbers.
-
-## Userdata metamethods
-All userdata objects in Eluna have tostring metamethod implemented.
-This allows you to print the player object for example and to use `tostring(player)`.
-
-The userdata uses metatables that contain the methods and functions it uses.
-These tables are globally accessible by using the type name. For example `Player` is a global table containing all Player methods.
-
-You can define new methods in lua for a class using these global tables.
-```lua
-function Player:CustomFunc(param1)
- -- self is the player the method is used on
- self:SendBroadcastMessage(param1)
-end
-
-function GameObject:CustomFunc(param1)
- -- self is the gameobject the method is used on
- print(self:GetName())
-end
-
--- Example use:
-player:CustomFunc("test")
-gob:CustomFunc("test2")
-```
-
-It is recommended that in normal code these global tables and their names (variables starting with capital letters like Player, Creature, GameObject, Spell..) are avoided so they are not unintentionally edited or deleted causing other scripts possibly not to function.
-
-## Database
-Database is a great thing, but it has it's own issues.
-
-### Querying
-Database queries are slow. The whole server has to wait for the script to fetch the data from disk before continuing. Compared to reading cache or RAM reading from disk is the same as going to the moon to fetch the data (no pun intended).
-
-Depending on what you need, prefer database Execute over Query when not selecting anything from the database. Database Executes are made asynchronously and they will not keep the server waiting.
-
-Move all database queries possible to the script loading, server startup or similar one time event and use cache tables to manage the data in scripts.
-
-### Types
-__Database types should be followed strictly.__
-Mysql does math in bigint and decimal formats which is why a simple select like `SELECT 1;` actually returns a bigint.
-If you fetch a bigint or decimal using a function for a smaller type it is possible the value is read incorrectly.
-
-For example the same code for fetching the result of `SELECT 1;` returned 1 on one machine and 0 on another. Using the correct function, in this case GetInt64, the right result was returned on both. https://github.com/ElunaLuaEngine/Eluna/issues/89#issuecomment-64121361
-
-| base type | defined type | database type |
-|---------------------------|--------------|-----------------------|
-| char | int8 | tinyint(3) |
-| short int | int16 | smallint(5) |
-| (long int / int) | int32 | mediumint(8) |
-| (long int / int) | int32 | int(10) |
-| long long int | int64 | bigint(20) |
-| unsigned char | uint8 | tinyint(3) unsigned |
-| unsigned short int | uint16 | smallint(5) unsigned |
-| unsigned (long int / int) | uint32 | mediumint(8) unsigned |
-| unsigned (long int / int) | uint32 | int(10) unsigned |
-| unsigned long long int | uint64 | bigint(20) unsigned |
-| float | float | float |
-| double | double | double and decimal |
-| std::string | std::string | any text type |
diff --git a/src/LuaEngine/docs/INSTALL.md b/src/LuaEngine/docs/INSTALL.md
deleted file mode 100644
index 6affaac..0000000
--- a/src/LuaEngine/docs/INSTALL.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Installing and updating
-This page will help you get a cMaNGOS and a TrinityCore source with Eluna.
-
-If you are looking to get MaNGOS source with Eluna head over to [MaNGOS forum](http://getmangos.eu/) for the installation and updating instructions - however read this page also as it contains important information.
-
-If you are having trouble with the installation or updating the core source, head over to our [support forum](../README.md#documentation).
-If you are looking for a way to merge eluna with a fork of the official repositories see [merging](MERGING.md).
-
-### Requirements and dependencies:
-**Eluna uses `C++11` so you need a compiler that supports it.**
-**Eluna can use ACE or BOOST for filesystem library.**
-Additionally see you desired core's documentation and installation instructions for it's requirements and dependencies.
-
-### Installation
-1. Open [git bash](http://git-scm.com/) and navigate to where you want the core source
-2. Choose the git address of your desired core and patch below and clone the core with `git clone `.
-For example `git clone https://github.com/ElunaLuaEngine/ElunaTrinityWotlk.git`
- * TrinityCore WoTLK: `https://github.com/ElunaLuaEngine/ElunaTrinityWotlk.git`
- * cMaNGOS Classic: `https://github.com/ElunaLuaEngine/ElunaMangosClassic.git`
- * cMaNGOS TBC: `https://github.com/ElunaLuaEngine/ElunaMangosTbc.git`
- * cMaNGOS WoTLK: `https://github.com/ElunaLuaEngine/ElunaMangosWotlk.git`
-3. Navigate to the newly created source folder with `git bash`
-4. Use the git command `git submodule init` followed by `git submodule update`
- * If you really do not get how to use git bash (and do try!) you can navigate to the `LuaEngine` folder and clone the [eluna repository](https://github.com/ElunaLuaEngine/Eluna) there. This is not recommended though.
-4. Continue compiling the core normally using the official instructions
- * [TrinityCore](http://collab.kpsn.org/display/tc/Installation+Guide)
- * [cMaNGOS](https://github.com/cmangos/issues/wiki/Installation-Instructions)
-
-__Important!__ After compiling use the new configuration files. They contain Eluna settings and without them Eluna may not function correctly. For example you do not get any error messages or error log.
-
-After installing Eluna you should check out these:
-- [Eluna getting started](USAGE.md)
-- [Eluna features](IMPL_DETAILS.md)
-
-### Updating
-Updating is essentially handled in the same manner as you would normally update the core and database.
-To get the newest core source code open `git bash` and navigate to your local source folder.
-Then execute use `git pull` followed by `git submodule init` and `git submodule update`.
-After updating the source you need to recompile the core normally. Simply use `CMake` if needed and compile.
-To update the databases refer to the core's or database's official updating documents:
- * [TrinityCore](http://collab.kpsn.org/display/tc/Databases+Installation)
- * [cMaNGOS](https://github.com/cmangos/issues/wiki/Installation-Instructions)
diff --git a/src/LuaEngine/docs/MERGING.md b/src/LuaEngine/docs/MERGING.md
deleted file mode 100644
index 2e488e4..0000000
--- a/src/LuaEngine/docs/MERGING.md
+++ /dev/null
@@ -1,42 +0,0 @@
-# Merging Eluna
-Eluna can be added to various sources by applying the core changes required for Eluna to function.
-Below you find the guides for merging Eluna with each core or a fork of it.
-If you choose to merge you should be able to maintain and update yourself - we do not maintain your core. View Unofficial Merging below.
-We also do not fix any merging errors you may have, but you are free to ask about them on the [support forum](../README.md#documentation) and we may assist.
-
-We recommend using the [installation guide](INSTALL.md) especially if you are not familiar with git and updating the code.
-It allows you to simply use `git pull` followed by `git submodule update` to update your source and we will handle the merging and maintenance with the official core source. Naturally you still need to handle updating the database as instructed by the core's wiki or instructions.
-
-### Merging Eluna with MaNGOS
-Eluna is merged with [official MaNGOS](http://getmangos.eu/) by default.
-
-### Merging Eluna with cMaNGOS
-```
-git clone https://github.com/cmangos/mangos-wotlk.git
-cd mangos-wotlk
-git pull --recurse-submodules https://github.com/ElunaLuaEngine/ElunaMangosWotlk.git
-```
-Steps explained:
-1. clone the core or fork source or get the it by other means
-2. navigate to the source folder
-3. pull the Eluna fork. This will fetch the repository and merge it with your source.
- * `--recurse-submodules` will automatically pull the submodules (Eluna repository). You may need to use `git submodule init` followed by `git submodule update` if your Eluna folder is empty
- * it is important that you choose the correct Eluna fork for your core andpatch:
- * [Eluna cMaNGOS Classic](https://github.com/ElunaLuaEngine/ElunaMangosClassic)
- * [Eluna cMaNGOS TBC](https://github.com/ElunaLuaEngine/ElunaMangosTbc)
- * [Eluna cMaNGOS WotLK](https://github.com/ElunaLuaEngine/ElunaMangosWotlk)
-
-### Merging Eluna with TrinityCore
-```
-git clone https://github.com/TrinityCore/TrinityCore.git -b3.3.5
-cd TrinityCore
-git pull --recurse-submodules https://github.com/ElunaLuaEngine/ElunaTrinityWotlk.git
-```
-Steps explained:
-1. clone the core or fork source or get the it by other means
-2. navigate to the source folder
-3. pull the Eluna fork. This will fetch the repository and merge it with your source.
- * `--recurse-submodules` will automatically pull the submodules (Eluna repository). You may need to use `git submodule init` followed by `git submodule update` if your Eluna folder is empty
- * it is important that you choose the correct Eluna fork for your core and patch:
- * [Eluna TrinityCore WotLK](https://github.com/ElunaLuaEngine/ElunaTrinityWotlk)
- * [Eluna TrinityCore Cataclysm](https://github.com/ElunaLuaEngine/ElunaTrinityCata)
diff --git a/src/LuaEngine/docs/USAGE.md b/src/LuaEngine/docs/USAGE.md
deleted file mode 100644
index 12a899c..0000000
--- a/src/LuaEngine/docs/USAGE.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# Using Eluna
-Eluna is a lua engine implementation for world of warcraft emulators.
-It can be used to create different kind of scripts from AI to events.
-This article helps you to get started with Eluna. We go through adding a simple script, where to get information from and a few language basics.
-
-This article assumes you have already installed Eluna successfully. If you have not, see [installation](INSTALL.md).
-
-## Basic script
-Here is a simple "Hello world" example.
-Create a file named `hello world.lua` that contains the following code and place the file inside the scripts folder in your server folder. By default the scripts folder is called `lua_scripts`. The server folder is the folder which contains server executables.
-```lua
-local PLAYER_EVENT_ON_LOGIN = 3
-
-local function OnLogin(event, player)
- player:SendBroadcastMessage("Hello world")
-end
-
-RegisterPlayerEvent(PLAYER_EVENT_ON_LOGIN, OnLogin)
-```
-If you now restart your server and log in game you are greeted with "Hello world" in your chat.
-
-### What happened
-As you have witnessed here no core compiling was needed and your script runs from the file you just created.
-
-The file is compiled and run by the lua engine when the server starts up or Eluna is reloaded.
-The code in the file registers a function to be run when a player logs in and the function sends a message to the player that logged in.
-
-## Lua basics
-It is good to get to know a bit of lua to code lua scripts. In this article we do not go that much into explaining lua syntax. Here are some pointers to important sources of information and things to get to know about.
-
-### Sources of information
-- lua users wiki
- - http://lua-users.org/wiki/LuaDirectory
- - http://lua-users.org/wiki/TutorialDirectory
- - http://lua-users.org/wiki/SampleCode
-- programming in lua http://www.lua.org/pil/1.html
-- lua reference manual http://www.lua.org/manual/5.2/
-
-### some highlights
-- Print function outputs to server console. Very useful for simple debugging `print("anything here")`.
-- control structures - especially loops:
- - http://lua-users.org/wiki/ControlStructureTutorial
- - http://www.lua.org/manual/5.2/manual.html#3.3.5
-- lua string library:
- - http://lua-users.org/wiki/StringLibraryTutorial
- - http://www.wowwiki.com/Pattern_matching
-- Lua tables are the only container in lua and they are essential for good code. Lua tables can be compared to arrays and hash maps.
-Table functions and tutorials:
- - http://www.lua.org/manual/5.2/manual.html#6.5
- - http://www.lua.org/manual/5.2/manual.html#4.3
- - http://lua-users.org/wiki/TablesTutorial
- - http://www.lua.org/pil/2.5.html
-- prefer local variables over global. While global variables may work they can create issues with other scripts that use same variable names.
-All local variables outside of functions in a script are shared by everything running the same script - the variables are locally global.
-
-## Eluna basics
-It is good to know where you can find information about Eluna and Eluna's API as well as the basic elements of a script. Here are links to the main sources of information:
-
-- Eluna features [Eluna details](IMPL_DETAILS.md)
-- Eluna documentation http://elunaluaengine.github.io/
-
-### Error messages
-If Eluna is installed correctly, the default installation should make errors output to the console as well as a log file in the server folder. If you can not get your script to work, be sure to check the log file for any errors you might have missed.
-
-Check out the configuration file for settings if you want to tweak the logging settings.
-
-### Global functions
-Global functions are functions you can run from anywhere in a script file and they do not require any object to be run.
-In addition to normal global functions lua provides like `print` Eluna has it's own gobal functions. You can find them in the documentation under `global` class: [global functions](http://elunaluaengine.github.io/Global/index.html).
-
-```lua
--- print the return value of GetLuaEngine function
-print(GetLuaEngine())
-```
-
-### Member functions
-Member functions, also called methods, are functions that require an userdata object to run. There are several different classes of objects that have different member functions. You can find all the member functions and their documentations from the [Eluna documentation](http://elunaluaengine.github.io/).
-
-Classes in C++ inherit each other. In Eluna member functions are also inherited. For example objects of classes `Player` and `Creature` inherit all methods from `Unit` class.
-
-Methods are called by using `:` notation on the object. For example to get the player name you can call the GetName methods like this: `player:GetName()`
-
-```lua
-local entry = 6
-local on_combat = 1
-local function OnCombat(event, creature, target)
- -- creature is of type Creature
- -- target is of type Creature or Player depending on who the creature is attacking
- print(creature:GetLevel())
- print(target:GetLevel())
-end
-
-RegisterCreatureEvent(entry, on_combat, OnCombat)
-```
-
-### Registering functions to events
-Scripts register functions to events and the functions are executed when the event happens.
-There are special global functions in Eluna API for registering functions for events.
-You should be able to find all such functions from [Eluna documentation](http://elunaluaengine.github.io/) by searching `register`.
-
-Functions used to register other functions for events need the ID of the event you want the hook to be registered for passed to them. You can find these ID numbers from the registering function documentation page.
-
-Eluna passes some arguments to the functions executed. The arguments are always in same order. You can name them in any way you want. In the above script example the event `PLAYER_EVENT_ON_LOGIN` passes the event id and the player who logs in to the registered function. This is why the registered function has these parameters defined: `(event, player)`.
-
-Some events allow the registered function to return different values. Sometimes you can return more than one value. The possibility to return is documented on the registering function's documentation page. Simply using the `return` keyword returns normally as if the function would end.
-
-For example in this script we register the function `OnCombat` to be run on event `1`, which triggers on combat, for the creature entry `6`. All needed information can be found here: http://elunaluaengine.github.io/Global/RegisterCreatureEvent.html
-```lua
-local entry = 6
-local on_combat = 1
-local function OnCombat(event, creature, target)
- creature:SendUnitYell("Yiee, me run!", 0)
-end
-
-RegisterCreatureEvent(entry, on_combat, OnCombat)
-```