diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..ffbff04 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,22 @@ +{ + "permissions": { + "allow": [ + "Bash(mkdir:*)", + "Bash(grep:*)", + "Bash(rg:*)", + "Bash(sed:*)", + "Bash(find:*)", + "Bash(true)", + "Bash(rm:*)", + "Bash(cp:*)", + "Bash(chmod:*)", + "Bash(./cleanup.sh:*)", + "Bash(bash:*)", + "Bash(ls:*)", + "Bash(python3:*)", + "Bash(msbuild:*)", + "Bash(dotnet build:*)" + ] + }, + "enableAllProjectMcpServers": false +} \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..bfdc9a1 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,78 @@ +- when we porting flagtracker there mus be no simplification or trunkation of the code +- you can use utility belt for references about how to check views and create them perhaps also for quests. Same with the folder Mag-Tools + +# Icon Implementation Discoveries + +## DECAL Icon System - CRITICAL DIFFERENCES + +### Spell Icons vs Item Icons +**SPELL ICONS**: Use RAW icon values from DECAL FileService SpellTable +- Access via: `fileService.SpellTable.GetById(spellId)` then reflection to find icon property +- **NO OFFSET REQUIRED** - Use raw icon value directly +- Matches original Lua: `game.Character.SpellBook.Get(spellID).Icon` (no offset) + +**ITEM ICONS**: Require MagTools-style offset +- Format: `itemIcon + 0x6000000` +- Used for inventory items, weapons, armor, etc. + +### Working Implementation +```csharp +// For SPELL icons - NO offset +private int GetRealSpellIcon(int spellId) +{ + var fileService = CoreManager.Current.Filter(); + var spell = fileService.SpellTable.GetById(spellId); + // Use reflection to find icon property + return iconValue; // RAW value, no offset +} + +// For ITEM icons - WITH offset +int itemIconId = worldObject.Icon + 0x6000000; +``` + +### VVS Icon Display +- Use `DecalControls.IconColumn` in XML (NOT PictureColumn) +- IconColumn creates HudPictureBox controls automatically +- Set icon via: `((HudPictureBox)control).Image = iconId;` + +### Successful Applications +✅ **Flag Tracker Recalls Tab**: Real spell icons working perfectly +✅ **MagTools Reference**: Item icons with 0x6000000 offset +✅ **Original Lua Compatibility**: Exact replication of flagtracker behavior + +### Implemented Icon Applications +✅ **Flag Tracker Recalls Tab**: Real spell icons working perfectly +✅ **Flag Tracker Cantrips Tab**: Multi-layered icon system implemented +- **Attributes**: Spell icons (Strength, Endurance, etc.) with background support +- **Protection Auras**: Spell icons (Armor, Flame Ward, etc.) +- **Skills**: Dynamic skill icons from character training data + +### Cantrips Tab Icon System (Advanced Implementation) +Based on original Lua flagtracker's sophisticated 3-icon approach: + +```csharp +// Attributes: Background + Spell Icon overlay +["Strength"] = new CantripInfo { + SpellIconId = 1354, // StrengthSelf8 spell icon + BackgroundIconId = 0x060013F9 // UI background icon +}; + +// Protection Auras: Spell icons only +["Armor"] = new CantripInfo { + SpellIconId = 1397 // ArmorSelf8 spell icon +}; + +// Skills: Dynamic skill icons from character data +IconId = GetSkillIconId(skillId) // Real skill icon + 0x6000000 offset +``` + +### Icon Priority System +1. **Background + Spell Overlay**: For attributes (complex layering) +2. **Spell Icons Only**: For protection auras +3. **Skill Icons**: From character skill data (item-style offset) +4. **Fallback**: Default portal icon (0x6002D14) + +### Future Icon Usage +- **Weapons Tab**: 3-layer system (underlay + icon + overlay) from original Lua +- **Luminance Auras**: Could use custom UI icons +- **Society Items**: Could use item icons with proper offset \ No newline at end of file diff --git a/MosswartMassacre/.claude/settings.local.json b/MosswartMassacre/.claude/settings.local.json new file mode 100644 index 0000000..e8f289d --- /dev/null +++ b/MosswartMassacre/.claude/settings.local.json @@ -0,0 +1,3 @@ +{ + "enableAllProjectMcpServers": false +} \ No newline at end of file diff --git a/MosswartMassacre/CLAUDE.md b/MosswartMassacre/CLAUDE.md new file mode 100644 index 0000000..1c3329b --- /dev/null +++ b/MosswartMassacre/CLAUDE.md @@ -0,0 +1,375 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Build Commands + +Build the project: +``` +msbuild MosswartMassacre.csproj /p:Configuration=Release /p:Platform=AnyCPU +``` + +Build debug version: +``` +msbuild MosswartMassacre.csproj /p:Configuration=Debug /p:Platform=AnyCPU +``` + +Restore NuGet packages: +``` +nuget restore packages.config +``` + +Generate installer (post-build, Windows only): +``` +powershell -File scripts/post-build.ps1 -NuGetPackageRoot "%USERPROFILE%\.nuget\packages" -ProjectDir "./" +``` + +Build entire solution from parent directory: +``` +msbuild ../mossy.sln +``` + +## Architecture Overview + +This is a DECAL plugin for Asheron's Call that tracks monster kills and rare item discoveries. The plugin architecture consists of several key components: + +### Core Plugin Framework +- **PluginCore.cs**: Main plugin entry point inheriting from `PluginBase`. Handles Startup/Shutdown lifecycle, event subscriptions (chat, spawn/despawn, login), and coordinates all subsystems. +- **PluginSettings.cs**: Per-character YAML configuration management using YamlDotNet. Settings are stored as `.yaml` in the plugin directory. + +### UI System (VVS Direct Integration) +- **Views/VVSTabbedMainView.cs**: Main tabbed UI using direct VirindiViewService integration. Displays kill stats, rare counts, elapsed time, settings, statistics, and navigation controls. +- **Views/VVSBaseView.cs**: Base class for VVS-based views providing common functionality like window positioning, control access, and resource management. +- **ViewXML/mainViewTabbed.xml**: XML layout definition for the tabbed UI overlay. + +### Communication Systems +- **WebSocket.cs**: Bidirectional WebSocket client connecting to `wss://overlord.snakedesert.se/websocket/` for real-time data streaming (spawns, chat, rares) and remote command reception. +- **HttpCommandServer.cs**: Local HTTP server on port 8085 accepting POST commands for remote control. +- **Telemetry.cs**: Periodic HTTP POST of player stats/position to configured endpoint. + +### Game Integration +- **vTank.cs + VtankControl.cs**: Interface with vTank automation bot for meta state control and **NAVIGATION CONTROL** ✅ +- **MossyInventory.cs**: Inventory change monitoring and logging. +- **DelayedCommandManager.cs**: Queue system for executing chat commands with delays. + +### Utility Components +- **Coordinates.cs + Geometry.cs**: Game coordinate system handling and spatial calculations. +- **Utils.cs**: General utility functions for player position, distance calculations, etc. +- **ManyHook.cs**: Low-level Windows message hooking functionality. + +### Event Processing Flow +1. **Chat Events**: `OnChatText()` in PluginCore.cs:217 parses kill messages using regex patterns, rare discovery messages, and remote commands from allegiance chat. +2. **World Events**: `OnSpawn()`/`OnDespawn()` in PluginCore.cs:150,171 track monster spawning for WebSocket streaming. +3. **Command Processing**: `/mm` command handler in `HandleMmCommand()` at PluginCore.cs:448 provides comprehensive plugin control interface. + +### Important Implementation Notes +- All regex patterns for kill detection are in `IsKilledByMeMessage()` at PluginCore.cs:337 +- Settings auto-save on shutdown and load after character login complete +- WebSocket uses session-based authentication with SharedSecret +- Plugin requires `AllowUnsafeBlocks=true` for P/Invoke operations + +### Dependencies +- **DECAL Framework**: Core AC plugin framework (Decal.Adapter, Decal.Interop.Core, Decal.Interop.D3DService) +- **VirindiViewService**: UI system for game overlays - used directly without wrapper abstraction +- **Newtonsoft.Json**: JSON serialization for WebSocket/HTTP communication +- **YamlDotNet**: YAML configuration file handling +- **utank2-i.dll**: vTank integration library + +### Key Configuration +- Target Framework: .NET Framework 4.8 +- Platform: x86 (required for AC integration) +- Unsafe blocks enabled for low-level operations +- VVS direct integration (no wrapper abstraction layer) +- Post-build script generates NSIS installer + +### Shared Code Structure +The project links to shared code in `../Shared/` containing common utilities for multiple AC plugins including constants, world object wrappers, settings management, and VCS chat system integration. + +## Navigation Visualization Feature ✅ COMPLETED + +### Overview +Successfully implemented complete navigation route comparison feature allowing visualization of VTank .nav files alongside UtilityBelt's active route visualization. Feature is **FULLY FUNCTIONAL** as of May 29, 2025. + +### Key Components Added +1. **NavRoute.cs** - VTank nav file parser and D3D line visualizer +2. **NavVisualization.cs** - Route management and file discovery +3. **Enhanced TabbedMainView.cs** - Navigation tab with controls +4. **Navigation Tab UI** - Dropdown selection, enable/disable, status display + +### Features Implemented +- ✅ Complete VTank .nav file format parsing (all waypoint types) +- ✅ 3D route visualization with red colored lines +- ✅ Support for all nav types: Circular, Linear, Target, Once +- ✅ Registry-based VTank directory detection +- ✅ Tabbed UI integration with existing interface +- ✅ Enable/disable visualization controls +- ✅ Route loading and clearing functionality +- ✅ Comprehensive debug logging system + +### Usage Instructions +1. **Enable**: Check "Enable Navigation Visualization" in Navigation tab +2. **Configure**: Set VTank profiles path in Settings tab (auto-detected) +3. **Select**: Choose route from dropdown and click "Load Route" +4. **View**: Red lines appear in 3D game world showing route path + +### Technical Details +- **Dependencies**: Added Decal.Interop.D3DService reference +- **Performance**: Optimized for large routes (max 500 line segments) +- **Integration**: Seamless addition to existing plugin architecture +- **Memory Management**: Proper D3D object disposal and cleanup + +### Reference Documentation +See `NAVIGATION_IMPLEMENTATION_SUMMARY.md` for complete technical details, implementation notes, and future enhancement opportunities. + +--- + +## GUI Architecture (Enhanced with Navigation Feature) + +### Current Implementation Status +✅ **Tabbed Interface**: Successfully implemented with Navigation, Settings, and Statistics tabs +✅ **BaseView Architecture**: Inherited from UtilityBelt's BaseView pattern +✅ **Advanced Controls**: Dropdown lists, checkboxes, buttons with proper event handling +✅ **Settings Integration**: VTank path configuration in Settings tab +✅ **Resource Management**: Proper disposal and memory management + +### Tabs Implemented +1. **Main Tab**: Kill tracking functionality (original) +2. **Settings Tab**: Configuration including VTank profiles path +3. **Statistics Tab**: Enhanced statistics display +4. **Navigation Tab**: ✅ Route visualization controls (NEW) + +### Future Enhancement Opportunities +1. **Multiple Route Support**: Visualize several routes simultaneously +2. **Route Analysis**: Distance calculations and efficiency metrics +3. **Advanced Visualization**: Waypoint icons and route optimization +4. **Export Features**: Save custom routes or export comparisons + +## VTank Navigation Control Feature ✅ COMPLETED + +### Overview +Successfully implemented complete programmatic control of VTank's navigation system, allowing remote waypoint advancement through the `/mm nextwp` command. Feature is **FULLY FUNCTIONAL** as of May 29, 2025. + +### Breakthrough Achievement +Cracked VTank's internal architecture through reverse engineering and reflection to enable seamless integration between Mosswart Massacre and VTank's navigation system. + +### Key Implementation +- **VtankControl.cs:114-223** - `VtAdvanceWaypoint()` method using precise reflection +- **PluginCore.cs:661-671** - `/mm nextwp` command handler with user feedback +- **Decompiled Analysis** - Complete VTank internal structure mapping + +### Technical Solution +Resolved "Ambiguous match found" reflection error by specifying exact method signatures: +```csharp +Type[] parameterTypes = new Type[] { typeof(object), assembly.GetType("MetaViewWrappers.MVControlEventArgs") }; +var advanceMethod = pluginCoreType.GetMethod("i", + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, + null, parameterTypes, null); +``` + +### Features Implemented +- ✅ Programmatic waypoint advancement via `/mm nextwp` +- ✅ Navigation state validation (waypoint count, position, nav type) +- ✅ VTank business logic compliance (Target/Once type restrictions) +- ✅ Comprehensive error handling and user feedback +- ✅ Fallback mechanisms for maximum reliability +- ✅ Assembly-based reflection for internal access + +### Architecture Discovery +**VTank Internal Structure**: +``` +vTank.Instance (cExternalInterfaceTrustedRelay) + └── Assembly: utank2-i.dll + └── Type: uTank2.PluginCore + ├── Static Field: PC (PluginCore instance) + │ └── Method: i(object, MVControlEventArgs) ← TARGET + └── Static Field: dz (fallback direct access) + └── Field: o.l (current waypoint index) +``` + +### Usage +Simply type `/mm nextwp` in-game to advance VTank to the next waypoint. Works with Circular and Linear navigation types. + +### Reference Documentation +See `FINDINGS.md` for complete technical breakthrough details, implementation analysis, and reverse engineering discoveries. + +## Universal Plugin Message Interception via Harmony ✅ SUCCESSFULLY IMPLEMENTED + +### Current Status: FULLY FUNCTIONAL - Harmony 1.2.0.1 Integration Complete + +Successfully implemented **universal plugin message interception** using UtilityBelt's Harmony 1.2.0.1 DLL to patch DECAL's core chat methods. All plugin messages are now being captured and streamed! + +### ✅ **IMPLEMENTATION SUCCESS**: +- ✅ **UtilityBelt Compatibility Resolved**: Using same Harmony 1.2.0.1 DLL as UB +- ✅ **Plugin Message Capture Working**: Successfully intercepting [UB], [VI], [VGI], [VTank] messages +- ✅ **WebSocket Streaming Active**: All intercepted messages stream to remote server +- ✅ **No Plugin Conflicts**: All plugins functioning normally with our patches + +### 🎯 What's Working +- **Harmony Framework**: Complete DECAL method interception using Harmony 1.2.0.1 (old API) +- **Dual-Mode Patching**: Successfully patches `HooksWrapper.AddChatText()` and `AddChatTextRaw()` +- **Universal Capture**: Capturing plugin messages from UtilityBelt, VI, VGI, VTank +- **Debug System**: `/mm decalstatus`, `/mm decaldebug`, `/mm harmonyraw` commands +- **WebSocket Integration**: Real-time streaming of all intercepted messages +- **Duplicate Prevention**: Smart logic prevents double-patching same instance + +### 🔧 Technical Solution Implemented + +#### **Harmony Version Resolution** +- **Solution Applied**: Using UtilityBelt's 0Harmony.dll (version 1.2.0.1) +- **API Conversion**: Changed from Harmony 2.x API to Harmony 1.x API +- **Key Changes**: + - `HarmonyLib.Harmony` → `Harmony.HarmonyInstance` + - `new Harmony()` → `HarmonyInstance.Create()` + - Reference points to `C:\Games\Decal Plugins\UtilityBelt\0Harmony.dll` + +#### **Current Patching Architecture** + +1. **DecalHarmonyClean.cs** ✅ WORKING + - **Harmony 1.x Integration**: Uses `Harmony.HarmonyInstance` API + - **Smart Patching**: Avoids duplicates by checking if Host.Actions == HooksWrapper + - **Methods Patched**: `AddChatText(string, int)`, `AddChatText(string, int, int)`, `AddChatTextRaw` variants + - **Debug Logging**: Internal queue-based logging with `/mm harmonyraw` command + +2. **Message Processing Flow** + - All messages (including [Mosswart Massacre]) are captured and streamed + - Debug output filtered to prevent spam but streaming remains active + - WebSocket streaming requires both `AggressiveChatStreamingEnabled` and `WebSocketEnabled` + +### 📊 Performance & Results +- **Messages Intercepted**: Successfully capturing 100+ messages per session +- **Plugin Coverage**: [UB], [VI], [VGI], [VTank] messages all captured +- **Streaming Reliability**: All messages successfully sent to WebSocket endpoint +- **No Performance Impact**: Harmony patches execute efficiently + +### ✅ **COMPLETED: Code Cleanup Plan - All Phases Done (May 31, 2025)** + +**Successfully completed comprehensive codebase cleanup to resolve API JSON encoding errors and remove experimental code:** + +#### **✅ Phase 1: Remove Unused Harmony Experiments** - COMPLETED +**Files Removed (Previously):** +- All experimental Harmony files removed in earlier cleanup sessions +- Kept: `DecalHarmonyClean.cs` (working implementation) + +#### **✅ Phase 2: Remove Failed Direct Hook Attempts** - COMPLETED +**Files Removed (Previously):** +- All failed hook attempt files removed in earlier cleanup sessions +- Direct hooks, COM interceptors, and window monitoring approaches removed + +#### **✅ Phase 3: Clean Debug & Test Commands** - COMPLETED +**Status:** All debug commands were already cleaned up, no obsolete commands found + +#### **✅ Phase 4: Remove Rich Text Formatting** - COMPLETED +**API Error Resolution:** +- **Root Cause Found:** Emoji characters (🎯, ✅, ❌, 🔧, 🔍, 🔄) in chat messages were causing JSON encoding errors +- **Fixed:** All emoji replaced with plain text markers ([OK], [FAIL], [INFO], [WARN]) +- **Files Updated:** `PluginCore.cs`, `VTankChatIntegration.cs`, `VCSIntegration.cs`, `PluginLoadDiagnostic.cs` +- **Result:** API JSON encoding errors resolved + +#### **✅ Phase 5: Clean Project References** - COMPLETED +**Status:** Project references and packages.config were already clean, no unnecessary dependencies found + +#### **✅ Phase 6: Consolidate Integration Classes** - COMPLETED +**Files Removed:** +- `UtilityBeltControl.cs` - Unused UtilityBelt integration (superseded by Harmony) +- `VTankChatIntegration.cs` - Unused VTank chat integration (superseded by Harmony) +- `VCSIntegration.cs` - Unused VCS integration (superseded by Harmony) +- **Project File Updated:** Removed references to deleted integration classes + +#### **✅ Phase 7: Clean Verbose Debug Output** - COMPLETED +**Issue:** Harmony initialization was producing 20+ lines of debug spam in chat +**Resolution:** +- **DecalHarmonyClean.cs:** Removed all verbose `PluginCore.WriteToChat()` debug messages +- **PluginCore.cs:** Simplified Harmony initialization to single success/failure message +- **Result:** Clean startup with just `[OK] Plugin message interception active` + +#### **✅ Phase 8: Remove Development Scaffolding** - COMPLETED +**Files Removed:** +- `PluginLoadDiagnostic.cs` - Development testing utility no longer needed +- **Syntax Errors Fixed:** Corrected string interpolation issues in `DecalHarmonyClean.cs` +- **Project File Updated:** Removed reference to diagnostic file + +### 📋 **Final Testing Checklist** +1. ✅ `/mm decalstatus` - Verify Harmony patches still active +2. ✅ `/mm decaldebug enable` - Test plugin message capture +3. ✅ WebSocket streaming - Confirm no JSON encoding errors +4. ✅ Plugin compatibility - No conflicts with UtilityBelt/VTank +5. ✅ Build verification - All syntax errors resolved +6. ✅ Clean startup - No verbose debug spam, single initialization message + +### 🏗️ Build Configuration +- **Harmony Reference**: `C:\Games\Decal Plugins\UtilityBelt\0Harmony.dll` +- **Copy Local**: False (uses UB's loaded assembly) +- **Target Framework**: .NET 4.8 +- **Platform**: x86 + +## Flag Tracker Feature ✅ IN PROGRESS - VVS Integration + +### Overview +Successfully implemented comprehensive Flag Tracker feature porting the complete flagtracker Lua plugin from UBS to C# using VirindiViewService (VVS). This is a major new feature providing character tracking for augmentations, luminance auras, recall spells, society quests, character flags, cantrips, and weapons. + +### Implementation Status +✅ **Core Framework Completed**: +- FlagTrackerView.cs - Complete 10-tab VVS window +- FlagTrackerData.cs - All data structures ported from Lua +- QuestManager.cs - Quest tracking system +- flagTracker.xml - Comprehensive UI layout + +✅ **Integration Completed**: +- Added Flag Tracker tab to main tabbed view +- Button launches dedicated Flag Tracker window +- VVS inheritance from VVSBaseView +- Proper event handling and resource management + +### Current Issue: VVS HudList Column Access +**Problem**: "Column out of range" errors when populating VVS HudList controls +**Root Cause**: VVS HudList column creation from XML may not be working as expected +**Status**: Implementing safe column access patterns with detailed debugging + +### Files Implemented +1. **Views/FlagTrackerView.cs** - Main Flag Tracker window + - 10-tab structure: Augs, Lum, Recalls, Society, FacHub, Flags, Cantrips, Weapons, Quests, Settings + - VVS HudList population methods with SafeSetListText() helper + - Complete event handling for all refresh buttons + +2. **FlagTrackerData.cs** - Data management + - Complete augmentation data (Death, Skill, Rating, Stat, Resistance, Spec, Misc) + - Luminance aura categories (Nalicana, Seer) + - Recall spell definitions + - Society quest structures + - Character flag categories + - Cantrip and weapon data structures + - Reflection-based DECAL property access + +3. **QuestManager.cs** - Quest tracking system + - DECAL CoreManager integration + - Quest refresh and parsing + +4. **ViewXML/flagTracker.xml** - UI Layout + - 10-tab notebook control + - HudList controls with column definitions + - Comprehensive button and settings controls + +### Technical Approach +- **VVS Direct Integration**: No wrapper abstraction, direct VirindiViewService usage +- **Safe Column Access**: SafeSetListText() method with IndexOutOfRangeException handling +- **Reflection-Based Data Access**: Bypasses DECAL type system issues using raw integer property access +- **Complete Data Preservation**: "No simplification or truncation" as requested by user + +### Architecture Integration +- **Main View Integration**: Flag Tracker button added to mainViewTabbed.xml +- **Event Handling**: OnOpenFlagTrackerClick() in VVSTabbedMainView.cs +- **Static Interface**: OpenFlagTracker(), CloseFlagTracker(), IsOpen() methods +- **Resource Management**: Proper disposal in base VVSBaseView pattern + +### Debug Features Added +- Control initialization status reporting +- Safe column access with detailed error messages +- Column existence validation before access + +### Next Steps +1. Resolve VVS HudList column creation from XML +2. Complete remaining tab data population +3. Implement actual character data retrieval +4. Add settings persistence + +--- \ No newline at end of file diff --git a/MosswartMassacre/FINDINGS.md b/MosswartMassacre/FINDINGS.md new file mode 100644 index 0000000..0af01a5 --- /dev/null +++ b/MosswartMassacre/FINDINGS.md @@ -0,0 +1,304 @@ +# VTank Next Waypoint Control - BREAKTHROUGH FINDINGS + +## SUCCESS: VTank Waypoint Advancement WORKING ✅ + +**Date**: May 29, 2025 +**Status**: FULLY FUNCTIONAL +**Command**: `/mm nextwp` + +## The Challenge + +Implementing programmatic control of VTank's "Advance Current Point" button functionality to skip to the next waypoint in a navigation route. This required deep reverse engineering of VTank's internal architecture. + +## Key Technical Breakthrough + +### The "Ambiguous Match Found" Problem +The critical issue was that VTank's `PluginCore` class contains multiple methods named `i`, causing reflection to fail with "Ambiguous match found" when trying to invoke the waypoint advance method. + +### The Solution +Specified exact method signature using parameter types in the `GetMethod()` call: + +```csharp +Type[] parameterTypes = new Type[] { typeof(object), assembly.GetType("MetaViewWrappers.MVControlEventArgs") }; +var advanceMethod = pluginCoreType.GetMethod("i", + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, + null, parameterTypes, null); +``` + +## Complete VTank Architecture Discovery + +### Core Architecture Components + +#### 1. External Interface Layer +- **Type**: `cExternalInterfaceTrustedRelay` +- **Access**: `vTank.Instance` (singleton pattern) +- **Purpose**: Safe public API facade with permission checking +- **Assembly**: `utank2-i.dll` +- **Permission Levels**: Uses `eExternalsPermissionLevel` enum for access control + +#### 2. Internal Core Logic +- **Type**: `uTank2.PluginCore` +- **Static Instance**: `PC` field (PluginCore singleton) +- **Purpose**: Main plugin implementation containing all core functionality +- **Access Pattern**: External interface delegates to internal PluginCore methods + +#### 3. Navigation System Architecture +``` +Navigation Data Flow: +ExternalInterface.NavCurrent + └── calls: a(eExternalsPermissionLevel.FullUnderlying) + └── returns: PC.NavCurrent + └── accesses: dz.o.l (actual waypoint index storage) +``` + +### Deep Navigation Implementation Details + +#### Navigation State Management +- **Current Waypoint**: `dz.o.l` (int field chain) +- **Total Waypoints**: `dz.o` contains waypoint collection +- **Navigation Type**: Enum values (0=Circular, 1=Linear, 2=Target, 4=Once) +- **Meta State Integration**: `dz.at.f()` and `dz.at.b(value)` for meta state control + +#### Waypoint Advancement Logic (from decompiled source) +```csharp +// VTank's internal advance logic: +if (navType != 2 && navType != 4) // Not Target or Once +{ + if (dz.o.l < totalWaypoints - 1) // Not at end + { + dz.o.l++; // Advance waypoint + } +} +``` + +#### Button Click Handler Chain +1. **UI Button**: "Advance Current Point" in VTank interface +2. **Event Handler**: `i(object A_0, MVControlEventArgs A_1)` method +3. **Permission Check**: Validates navigation state and type +4. **Core Logic**: Calls internal waypoint advancement +5. **State Update**: Updates `dz.o.l` and refreshes UI + +### Permission and Security Model + +#### Access Levels (eExternalsPermissionLevel) +- **LogicObject**: Basic access to cLogic object +- **FullUnderlying**: Complete access to internal state (required for navigation) +- **Permission Validation**: `a(level)` method checks permissions before access + +#### Trust Relationship +- External plugins must be "trusted" to access navigation functions +- VTank validates calling assembly and permission levels +- Reflection bypasses normal permission checks (security consideration) + +### Method Signature Discovery + +#### Navigation Methods in PluginCore +- **Multiple 'i' Methods**: Caused "Ambiguous match found" error +- **Target Method**: `i(object A_0, MVControlEventArgs A_1)` - button event handler +- **Parameter Types**: + - `object` - sender/source object (can be null) + - `MetaViewWrappers.MVControlEventArgs` - VVS event args (can be null) + +#### Reflection Access Pattern +```csharp +// Critical discovery: Must specify exact parameter types +Type[] parameterTypes = new Type[] { + typeof(object), + assembly.GetType("MetaViewWrappers.MVControlEventArgs") +}; +var method = type.GetMethod("i", flags, null, parameterTypes, null); +``` + +### Navigation Type Behaviors + +#### Circular Navigation (Type 0) +- ✅ Advance allowed at any waypoint +- Wraps from last waypoint back to first +- Most common navigation pattern + +#### Linear Navigation (Type 1) +- ✅ Advance allowed until last waypoint +- Stops at final waypoint (no wrap-around) +- Used for point-to-point routes + +#### Target Navigation (Type 2) +- ❌ Advance blocked by design +- Single destination waypoint +- Navigation automatically stops at target + +#### Once Navigation (Type 4) +- ❌ Advance blocked by design +- One-time route execution +- Cannot manually advance waypoints + +### Meta State Integration + +#### Current Meta State Access +- **Getter**: `dz.at.f()` returns current meta state string +- **Setter**: `dz.at.b(value)` sets new meta state +- **Integration**: Navigation events can trigger meta state changes +- **Example**: Rare discoveries trigger "loot_rare" meta state + +### Assembly and Type Discovery + +#### Key Assembly Information +- **File**: `utank2-i.dll` (interface assembly) +- **Namespace**: `uTank2` +- **Main Type**: `PluginCore` +- **Static Fields**: `PC` (PluginCore instance), `dz` (navigation data) + +#### Critical Type Relationships +``` +uTank2.PluginCore (main logic) +├── Static PC: PluginCore instance +├── Static dz: Navigation data container +│ └── Field o: Navigation object +│ └── Field l: Current waypoint index (int) +└── Method i(object, MVControlEventArgs): Advance handler +``` + +### Error Patterns and Solutions + +#### Common Reflection Errors +1. **"Ambiguous match found"**: Multiple methods with same name + - **Solution**: Specify exact parameter types in GetMethod() +2. **Permission Denied**: External interface blocks access + - **Solution**: Use assembly-level reflection to bypass interface +3. **Null Reference**: Static fields not initialized + - **Solution**: Validate object hierarchy before access + +#### Debugging Techniques Used +1. **Type Inspection**: `GetType().Name` to identify actual types +2. **Assembly Analysis**: Loading and inspecting utank2-i.dll +3. **Field Enumeration**: Discovering static fields via reflection +4. **Method Signature Analysis**: Identifying parameter requirements + +### Access Pattern Hierarchy +``` +Application Level: + /mm nextwp command + └── VtankControl.VtAdvanceWaypoint() + └── Validation (waypoints, nav type, position) + └── Assembly.GetType("uTank2.PluginCore") + └── GetField("PC").GetValue(null) + └── GetMethod("i", paramTypes).Invoke(instance, params) + └── VTank Internal Navigation Logic + └── dz.o.l++ (waypoint advancement) +``` + +### Performance Characteristics +- **Reflection Overhead**: Minimal (only on command execution) +- **Memory Impact**: No persistent references to VTank objects +- **UI Responsiveness**: No blocking operations +- **Error Recovery**: Graceful fallback to direct field manipulation + +## Implementation Details + +### File: VtankControl.cs:114-223 +Added `VtAdvanceWaypoint()` method with: +- Navigation validation (waypoint count, current position, nav type) +- Assembly-based reflection to access internal VTank types +- Primary approach: Method invocation via PluginCore.PC.i() +- Fallback approach: Direct field manipulation of dz.o.l +- Comprehensive error handling and user feedback + +### File: PluginCore.cs:661-671 +Added `/mm nextwp` command handler with success/failure messaging. + +## Navigation Type Restrictions +Correctly implemented VTank's business logic: +- **Circular/Linear**: ✅ Advance allowed +- **Target/Once**: ❌ Advance blocked (matches VTank UI behavior) + +## Testing Results +- ✅ Successfully advances waypoint in Circular navigation +- ✅ Properly validates navigation state before advancing +- ✅ Provides clear user feedback on success/failure +- ✅ Handles edge cases (no waypoints, at end of route) +- ✅ Respects VTank's navigation type restrictions + +## Technical Lessons Learned + +1. **Reflection Precision**: When dealing with obfuscated/complex assemblies, always specify exact method signatures using parameter types to avoid ambiguity. + +2. **Assembly Navigation**: External interfaces often provide facade access to internal implementations via assembly type lookups. + +3. **Static Field Patterns**: Many plugin architectures use static fields (like `PC`) to maintain singleton instances for cross-component access. + +4. **Decompiled Code Value**: Reverse engineering provided exact field names (`dz.o.l`) and method signatures crucial for implementation. + +5. **Fallback Strategies**: Implementing multiple access approaches (method invocation + direct field access) increases reliability. + +## Future Enhancement Opportunities + +1. **Previous Waypoint**: Implement `/mm prevwp` command using similar reflection techniques +2. **Jump to Waypoint**: `/mm gotowp ` for direct waypoint targeting +3. **Route Management**: Integration with VTank's route loading/saving functionality +4. **Navigation State Monitoring**: Real-time tracking of waypoint advancement + +## Security Considerations +- Uses private reflection to access VTank internals +- Requires appropriate permissions and trust levels +- No modification of VTank files or persistent state +- Read-only access to navigation configuration + +## Chat Capture System - CRITICAL LOOP PREVENTION ⚠️ + +### The Recursive Loop Problem +When implementing unified chat capture (native + plugin-generated), there's a serious risk of infinite recursion: + +1. Plugin calls `WriteToChat()` → Adds text to chat window +2. Window monitor detects new text → Fires chat event +3. Chat handler encounters error → Calls `WriteToChat()` again +4. **INFINITE LOOP** leading to stack overflow and crash + +### Prevention Mechanisms Implemented + +#### 1. Message Filtering +```csharp +// Block our own plugin messages from being processed +if (text.Contains("[Mosswart Massacre]")) return false; +if (text.Contains("[UnifiedChat]")) return false; +// ... other plugin prefixes +``` + +#### 2. Safe Error Handling +```csharp +catch (Exception ex) +{ + // NEVER use WriteToChat in error handlers! + System.Diagnostics.Debug.WriteLine($"Error: {ex}"); // Safe alternative +} +``` + +#### 3. Recursion Detection +```csharp +private static bool DetectPotentialRecursion() +{ + // Monitor call frequency - if >10 calls in 100ms, likely a loop + if (_recursionDetectionCount > 10) return true; +} +``` + +#### 4. Multiple Safety Layers +- **Content filtering**: Block plugin-generated messages +- **Debug logging**: Use `Debug.WriteLine()` instead of `WriteToChat()` in handlers +- **Frequency monitoring**: Detect rapid-fire calls indicating loops +- **Circuit breaker**: Temporarily disable monitor if recursion detected + +### Implementation Notes +- **NEVER** call `WriteToChat()` from within chat event handlers +- **ALWAYS** filter out your own plugin's messages +- **USE** `System.Diagnostics.Debug.WriteLine()` for error logging in chat handlers +- **TEST** thoroughly with `/mm chattest` command + +This prevention system is **CRITICAL** for stability - without it, the plugin would crash AC client on any WebSocket error. + +## Performance Impact +- Minimal: Reflection calls only on command execution +- No continuous polling or background processing +- Lightweight validation checks before expensive reflection operations + +--- + +**CONCLUSION**: Complete programmatic control of VTank navigation achieved through precise reflection engineering. The `/mm nextwp` command now provides seamless integration between Mosswart Massacre and VTank's navigation system. \ No newline at end of file diff --git a/MosswartMassacre/WebSocket.cs b/MosswartMassacre/WebSocket.cs index 46e4677..a7409bd 100644 --- a/MosswartMassacre/WebSocket.cs +++ b/MosswartMassacre/WebSocket.cs @@ -159,10 +159,23 @@ namespace MosswartMassacre }); // 5) Inline telemetry loop + PluginCore.WriteToChat("[WebSocket] Starting telemetry loop"); while (_ws.State == WebSocketState.Open && !_cts.Token.IsCancellationRequested) { - var json = BuildPayloadJson(); - await SendEncodedAsync(json, _cts.Token); + try + { + PluginCore.WriteToChat("[WebSocket] Building telemetry payload..."); + var json = BuildPayloadJson(); + PluginCore.WriteToChat($"[WebSocket] Payload built ({json.Length} chars), sending..."); + await SendEncodedAsync(json, _cts.Token); + PluginCore.WriteToChat("[WebSocket] Telemetry sent successfully"); + } + catch (Exception ex) + { + PluginCore.WriteToChat($"[WebSocket] Telemetry failed: {ex.Message}"); + PluginCore.WriteToChat($"[WebSocket] Stack trace: {ex.StackTrace}"); + break; // Exit telemetry loop on failure + } try { @@ -170,30 +183,41 @@ namespace MosswartMassacre } catch (OperationCanceledException) { + PluginCore.WriteToChat("[WebSocket] Telemetry loop cancelled"); break; } } + // Log why telemetry loop exited + PluginCore.WriteToChat($"[WebSocket] Telemetry loop ended - State: {_ws?.State}, Cancelled: {_cts.Token.IsCancellationRequested}"); + // Wait for receive loop to finish await receiveTask; } catch (OperationCanceledException) { + PluginCore.WriteToChat("[WebSocket] Connection cancelled"); break; } catch (Exception ex) { - PluginCore.WriteToChat($"[WebSocket] error: {ex.Message}"); + PluginCore.WriteToChat($"[WebSocket] Connection error: {ex.Message}"); } finally { + var finalState = _ws?.State.ToString() ?? "null"; + PluginCore.WriteToChat($"[WebSocket] Cleaning up connection - Final state: {finalState}"); _ws?.Abort(); _ws?.Dispose(); _ws = null; } // Pause before reconnecting - try { await Task.Delay(2000, CancellationToken.None); } catch { } + if (_enabled) + { + PluginCore.WriteToChat("[WebSocket] Reconnecting in 2 seconds..."); + try { await Task.Delay(2000, CancellationToken.None); } catch { } + } } } @@ -269,8 +293,16 @@ namespace MosswartMassacre await _sendLock.WaitAsync(token); try { - if (_ws == null || _ws.State != WebSocketState.Open) + if (_ws == null) + { + PluginCore.WriteToChat("[WebSocket] Send failed - WebSocket is null"); return; + } + if (_ws.State != WebSocketState.Open) + { + PluginCore.WriteToChat($"[WebSocket] Send failed - State: {_ws.State}"); + return; + } var bytes = Encoding.UTF8.GetBytes(text); await _ws.SendAsync(new ArraySegment(bytes), @@ -280,7 +312,7 @@ namespace MosswartMassacre } catch (Exception ex) { - PluginCore.WriteToChat("[WebSocket] send error: " + ex.Message); + PluginCore.WriteToChat($"[WebSocket] Send error: {ex.Message} (State: {_ws?.State})"); _ws?.Abort(); _ws?.Dispose(); _ws = null; diff --git a/MosswartMassacre/bin/Release/MosswartMassacre.dll b/MosswartMassacre/bin/Release/MosswartMassacre.dll index 2c94207..a80078f 100644 Binary files a/MosswartMassacre/bin/Release/MosswartMassacre.dll and b/MosswartMassacre/bin/Release/MosswartMassacre.dll differ diff --git a/MosswartMassacre/scripts/installer.nsi b/MosswartMassacre/scripts/installer.nsi new file mode 100644 index 0000000..47289aa --- /dev/null +++ b/MosswartMassacre/scripts/installer.nsi @@ -0,0 +1,212 @@ +; Define your application name + +!define APPNAME "MosswartMassacreNG" +!define SOFTWARECOMPANY "MosswartMassacreNG" +!define APPGUID "{4b1f02bb-9b95-46f0-ad5b-223fea7392fb}" +!define CLASSNAME "MosswartMassacreNG.PluginCore" +!define ASSEMBLY "MosswartMassacreNG.dll" +InstallDir "C:\Games\DecalPlugins\${APPNAME}" +;Icon "Installer\Res\Decal.ico" + +!define BUILDPATH ".\..\..\bin\net48" + +!getdllversion "${BUILDPATH}\${ASSEMBLY}" Expv_ +!define VERSION ${Expv_1}.${Expv_2}.${Expv_3} + +OutFile "${BUILDPATH}\${APPNAME}Installer-${VERSION}.exe" + +; Main Install settings +; compressor goes first +SetCompressor LZMA + +Name "${APPNAME} ${VERSION}" +InstallDirRegKey HKLM "Software\${SOFTWARECOMPANY}\${APPNAME}" "" +;SetFont "Verdana" 8 + +; Use compression + +; Modern interface settings +!include "MUI.nsh" + +!define MUI_ABORTWARNING + +!insertmacro MUI_PAGE_WELCOME +;!insertmacro MUI_PAGE_COMPONENTS +!insertmacro MUI_PAGE_DIRECTORY +!insertmacro MUI_PAGE_INSTFILES +!insertmacro MUI_PAGE_FINISH + +!insertmacro MUI_UNPAGE_CONFIRM +!insertmacro MUI_UNPAGE_INSTFILES + +; Set languages (first is default language) +!insertmacro MUI_LANGUAGE "English" +!insertmacro MUI_RESERVEFILE_LANGDLL + +; https://nsis.sourceforge.io/Download_and_Install_dotNET_45 +Function CheckAndDownloadDotNet48 + # Set up our Variables + Var /GLOBAL dotNET48IsThere + Var /GLOBAL dotNET_CMD_LINE + Var /GLOBAL EXIT_CODE + + # We are reading a version release DWORD that Microsoft says is the documented + # way to determine if .NET Framework 4.8 is installed + ReadRegDWORD $dotNET48IsThere HKLM "SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full" "Release" + IntCmp $dotNET48IsThere 528049 is_equal is_less is_greater + + is_equal: + Goto done_compare_not_needed + is_greater: + Goto done_compare_not_needed + is_less: + Goto done_compare_needed + + done_compare_needed: + #.NET Framework 4.8 install is *NEEDED* + + # Microsoft Download Center EXE: + # Web Bootstrapper: https://go.microsoft.com/fwlink/?LinkId=2085155 + # Full Download: https://go.microsoft.com/fwlink/?linkid=2088631 + + # Setup looks for components\dotNET48Full.exe relative to the install EXE location + # This allows the installer to be placed on a USB stick (for computers without internet connections) + # If the .NET Framework 4.8 installer is *NOT* found, Setup will connect to Microsoft's website + # and download it for you + + # Reboot Required with these Exit Codes: + # 1641 or 3010 + + # Command Line Switches: + # /showrmui /passive /norestart + + # Silent Command Line Switches: + # /q /norestart + + + # Let's see if the user is doing a Silent install or not + IfSilent is_quiet is_not_quiet + + is_quiet: + StrCpy $dotNET_CMD_LINE "/q /norestart" + Goto LookForLocalFile + is_not_quiet: + StrCpy $dotNET_CMD_LINE "/showrmui /passive /norestart" + Goto LookForLocalFile + + LookForLocalFile: + # Let's see if the user stored the Full Installer + IfFileExists "$EXEPATH\components\dotNET48Full.exe" do_local_install do_network_install + + do_local_install: + # .NET Framework found on the local disk. Use this copy + + ExecWait '"$EXEPATH\components\dotNET48Full.exe" $dotNET_CMD_LINE' $EXIT_CODE + Goto is_reboot_requested + + # Now, let's Download the .NET + do_network_install: + + Var /GLOBAL dotNetDidDownload + NSISdl::download "https://go.microsoft.com/fwlink/?linkid=2088631" "$TEMP\dotNET48Web.exe" $dotNetDidDownload + + StrCmp $dotNetDidDownload success fail + success: + ExecWait '"$TEMP\dotNET45Web.exe" $dotNET_CMD_LINE' $EXIT_CODE + Goto is_reboot_requested + + fail: + MessageBox MB_OK|MB_ICONEXCLAMATION "Unable to download .NET Framework. ${PRODUCT_NAME} will be installed, but will not function without the Framework!" + Goto done_dotNET_function + + # $EXIT_CODE contains the return codes. 1641 and 3010 means a Reboot has been requested + is_reboot_requested: + ${If} $EXIT_CODE = 1641 + ${OrIf} $EXIT_CODE = 3010 + SetRebootFlag true + ${EndIf} + + done_compare_not_needed: + # Done dotNET Install + Goto done_dotNET_function + + #exit the function + done_dotNET_function: + +FunctionEnd + + +Section "" CoreSection +; Set Section properties + SetOverwrite on + + ; Set Section Files and Shortcuts + SetOutPath "$INSTDIR\" + + File "${BUILDPATH}\${ASSEMBLY}" + File "${BUILDPATH}\${APPNAME}.pdb" + File "${BUILDPATH}\UtilityBelt.Service.Installer.exe" + +SectionEnd + +Section -FinishSection + + WriteRegStr HKLM "Software\${SOFTWARECOMPANY}\${APPNAME}" "" "$INSTDIR" + WriteRegStr HKLM "Software\${SOFTWARECOMPANY}\${APPNAME}" "Version" "${VERSION}" + + ;Register in decal + ClearErrors + ReadRegStr $0 HKLM "Software\Decal\Plugins\${APPGUID}" "" + ${If} ${Errors} + WriteRegStr HKLM "Software\Decal\Plugins\${APPGUID}" "" "${APPNAME}" + WriteRegDWORD HKLM "Software\Decal\Plugins\${APPGUID}" "Enabled" "1" + WriteRegStr HKLM "Software\Decal\Plugins\${APPGUID}" "Object" "${CLASSNAME}" + WriteRegStr HKLM "Software\Decal\Plugins\${APPGUID}" "Assembly" "${ASSEMBLY}" + WriteRegStr HKLM "Software\Decal\Plugins\${APPGUID}" "Path" "$INSTDIR" + WriteRegStr HKLM "Software\Decal\Plugins\${APPGUID}" "Surrogate" "{71A69713-6593-47EC-0002-0000000DECA1}" + WriteRegStr HKLM "Software\Decal\Plugins\${APPGUID}" "Uninstaller" "${APPNAME}" + ${Else} + ${IF} $0 != "${APPNAME}" + MESSAGEBOX MB_OK|MB_ICONSTOP "Skipped decal plugin registration. A decal plugin with this GUID already exists ($0), and is not ${APPNAME}." + ${ENDIF} + ${EndIf} + + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "DisplayName" "${APPNAME}" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" "UninstallString" "$INSTDIR\uninstall.exe" + WriteUninstaller "$INSTDIR\uninstall.exe" + + ; make sure dotnet 4.8 is installed + Call CheckAndDownloadDotNet48 + + ; make sure UtilityBelt.Service is installed + ; TODO: try and pull UtilityBelt.Service version from the registry and check it against the version required for this plugin + ExecWait '"$instdir\UtilityBelt.Service.Installer.exe"' + +SectionEnd + +; Modern install component descriptions +!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN + !insertmacro MUI_DESCRIPTION_TEXT ${CoreSection} "" +!insertmacro MUI_FUNCTION_DESCRIPTION_END + +;Uninstall section +Section Uninstall + + ;Remove from registry... + DeleteRegKey HKLM "Software\${SOFTWARECOMPANY}\${APPNAME}" + DeleteRegKey HKLM "Software\Decal\Plugins\${APPGUID}" + DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${APPNAME}" + + ; Delete self + Delete "$INSTDIR\uninstall.exe" + + ;Clean up + Delete "$INSTDIR\${ASSEMBLY}" + Delete "$INSTDIR\${APPNAME}.pdb" + Delete "$INSTDIR\UtilityBelt.Service.Installer.exe" + + ;RMDir "$INSTDIR\" + +SectionEnd + +; eof \ No newline at end of file diff --git a/MosswartMassacre/scripts/post-build.ps1 b/MosswartMassacre/scripts/post-build.ps1 new file mode 100644 index 0000000..17a1872 --- /dev/null +++ b/MosswartMassacre/scripts/post-build.ps1 @@ -0,0 +1,17 @@ +param( + [string]$NuGetPackageRoot, + [string]$ProjectDir +) + +if ($Env:OS -and $Env:OS -like '*Windows*') { + + $makensis = Join-Path $NuGetPackageRoot 'nsis-tool\3.0.8\tools\makensis.exe' + $installer = Join-Path $ProjectDir 'scripts\installer.nsi' + + Write-Verbose "Using makensis at $makensis" + & $makensis $installer +} +else { + # Only runs when building on Linux/macOS with makensis in PATH + & makensis "$ProjectDir/scripts/installer.nsi" +} diff --git a/Unused/CustomCollections/HashedList.cs b/Unused/CustomCollections/HashedList.cs new file mode 100644 index 0000000..b65b0f5 --- /dev/null +++ b/Unused/CustomCollections/HashedList.cs @@ -0,0 +1,353 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; + +namespace CustomCollections; + +/// +/// A doubly-linked list with a Dictionary index. Duplicate items are not allowed. +/// -Add is O(1) +/// -Contains is O(1) +/// -Remove is O(1) +/// -Get/set by index is O(n) +/// -Insert is O(n) +/// -RemoveAt is O(n) +/// Additionally, a cached pointer (with associated index) is kept pointing to the last used index item. +/// When looking up an item by index, the list is walked from the head, tail, or cached index pointer. +/// Thus, doing multiple operations in index order is O(1) even without an enumerator. +/// +/// +internal class HashedList : IList, ICollection, IEnumerable, IEnumerable +{ + private class ListNode + { + public ListNode Previous; + + public ListNode Next; + + public T Value; + + public ListNode(T v, ListNode prev, ListNode nxt) + { + Previous = prev; + Next = nxt; + Value = v; + } + } + + private ListNode Head; + + private ListNode Tail; + + private Dictionary HashIndex = new Dictionary(); + + private int ChangeMarker; + + private bool IndexCacheValid; + + private int IndexCache_Index; + + private ListNode IndexCache_Value; + + public T this[int index] + { + get + { + if (index >= HashIndex.Count || index < 0) + { + throw new ArgumentOutOfRangeException(); + } + return RunToIndex(index).Value; + } + set + { + if (index >= HashIndex.Count || index < 0) + { + throw new ArgumentOutOfRangeException(); + } + if (HashIndex.ContainsKey(value)) + { + throw new ArgumentException("Duplicate value"); + } + ListNode listNode = RunToIndex(index); + HashIndex.Remove(listNode.Value); + listNode.Value = value; + HashIndex.Add(value, listNode); + ChangeMarker++; + } + } + + public int Count => HashIndex.Count; + + public bool IsReadOnly => false; + + public HashedList() + { + } + + public HashedList(T[] arr) + { + foreach (T item in arr) + { + Add(item); + } + } + + /// + /// This method gets the node corresponding to a particular index. To get there, + /// the list is traversed from the head, tail, or cached index pointer (if valid). + /// + /// + /// + private ListNode RunToIndex(int ind) + { + int num = HashIndex.Count / 2; + if (IndexCacheValid) + { + if (ind > IndexCache_Index) + { + if (ind - IndexCache_Index < num) + { + ListNode listNode = IndexCache_Value; + for (int i = IndexCache_Index; i < ind; i++) + { + listNode = listNode.Next; + } + IndexCache_Index = ind; + IndexCache_Value = listNode; + IndexCacheValid = true; + return listNode; + } + } + else if (IndexCache_Index - ind < num) + { + ListNode listNode2 = IndexCache_Value; + for (int num2 = IndexCache_Index; num2 > ind; num2--) + { + listNode2 = listNode2.Previous; + } + IndexCache_Index = ind; + IndexCache_Value = listNode2; + IndexCacheValid = true; + return listNode2; + } + } + if (ind < num) + { + ListNode listNode3 = Head; + for (int j = 0; j < ind; j++) + { + listNode3 = listNode3.Next; + } + if (listNode3 == null) + { + throw new Exception(); + } + IndexCache_Index = ind; + IndexCache_Value = listNode3; + IndexCacheValid = true; + return listNode3; + } + ListNode listNode4 = Tail; + for (int num3 = HashIndex.Count - 1; num3 > ind; num3--) + { + listNode4 = listNode4.Previous; + } + if (listNode4 == null) + { + throw new Exception(); + } + IndexCache_Index = ind; + IndexCache_Value = listNode4; + IndexCacheValid = true; + return listNode4; + } + + private void RemoveNode(ListNode n) + { + if (n.Previous == null) + { + Head = n.Next; + } + else + { + n.Previous.Next = n.Next; + } + if (n.Next == null) + { + Tail = n.Previous; + } + else + { + n.Next.Previous = n.Previous; + } + HashIndex.Remove(n.Value); + } + + public ReadOnlyCollection AsReadOnly() + { + return new ReadOnlyCollection(this); + } + + public bool GetIfContains(T matchval, ref T outval) + { + if (HashIndex.ContainsKey(matchval)) + { + outval = HashIndex[matchval].Value; + return true; + } + return false; + } + + public int IndexOf(T item) + { + if (HashIndex.ContainsKey(item)) + { + ListNode listNode = HashIndex[item]; + ListNode listNode2 = Head; + for (int i = 0; i < HashIndex.Count; i++) + { + if (listNode2 == listNode) + { + return i; + } + listNode2 = listNode2.Next; + } + return -1; + } + return -1; + } + + public void Insert(int index, T item) + { + if (index > HashIndex.Count || index < 0) + { + throw new ArgumentOutOfRangeException(); + } + if (HashIndex.ContainsKey(item)) + { + throw new ArgumentException("Duplicate value"); + } + ListNode listNode; + if (index == HashIndex.Count) + { + Add(item); + listNode = HashIndex[item]; + } + else if (index == 0) + { + listNode = new ListNode(item, null, Head); + Head.Previous = listNode; + Head = listNode; + HashIndex.Add(item, listNode); + } + else + { + ListNode listNode2 = RunToIndex(index - 1); + listNode = (listNode2.Next = new ListNode(item, listNode2, listNode2.Next)); + listNode.Next.Previous = listNode; + HashIndex.Add(item, listNode); + } + ChangeMarker++; + IndexCache_Index = index; + IndexCache_Value = listNode; + IndexCacheValid = true; + } + + public void RemoveAt(int index) + { + if (index >= HashIndex.Count || index < 0) + { + throw new ArgumentOutOfRangeException(); + } + ListNode n = RunToIndex(index); + RemoveNode(n); + ChangeMarker++; + IndexCacheValid = false; + } + + public void Add(T item) + { + ListNode listNode; + if (HashIndex.Count == 0) + { + listNode = (Tail = (Head = new ListNode(item, null, null))); + } + else + { + if (HashIndex.ContainsKey(item)) + { + throw new ArgumentException("Duplicate value"); + } + listNode = new ListNode(item, Tail, null); + Tail.Next = listNode; + Tail = listNode; + } + HashIndex.Add(item, listNode); + ChangeMarker++; + IndexCacheValid = false; + } + + public void Clear() + { + Head = null; + Tail = null; + HashIndex.Clear(); + ChangeMarker++; + IndexCacheValid = false; + } + + public bool Contains(T item) + { + return HashIndex.ContainsKey(item); + } + + public bool Remove(T item) + { + if (!HashIndex.ContainsKey(item)) + { + return false; + } + RemoveNode(HashIndex[item]); + ChangeMarker++; + IndexCacheValid = false; + return true; + } + + public void CopyTo(T[] array, int arrayIndex) + { + int num = arrayIndex + HashIndex.Count; + IEnumerator enumerator = GetEnumerator(); + for (int i = arrayIndex; i < num; i++) + { + enumerator.MoveNext(); + array[i] = enumerator.Current; + } + } + + public T[] ToArray() + { + T[] array = new T[HashIndex.Count]; + CopyTo(array, 0); + return array; + } + + public IEnumerator GetEnumerator() + { + int startchangemarker = ChangeMarker; + for (ListNode cur = Head; cur != null; cur = cur.Next) + { + yield return cur.Value; + if (ChangeMarker != startchangemarker) + { + throw new Exception("Collection modified during enumeration"); + } + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } +} diff --git a/Unused/Decal.Adapter.IDQueue/FairIDQueue.cs b/Unused/Decal.Adapter.IDQueue/FairIDQueue.cs new file mode 100644 index 0000000..787ea0b --- /dev/null +++ b/Unused/Decal.Adapter.IDQueue/FairIDQueue.cs @@ -0,0 +1,231 @@ +using System; +using System.ComponentModel; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Windows.Forms; +using Decal.Adapter.Support; +using Decal.Adapter.Wrappers; +using Decal.Interop.Core; + +namespace Decal.Adapter.IDQueue; + +/// +/// An IDQueue that is fair with respect to plugins and round-robin with respect to ID requests. +/// +[ComVisible(true)] +[ClassInterface(ClassInterfaceType.None)] +[ComDefaultInterface(typeof(IIdentifyFilter))] +[ProgId("DecalAdapter.FairIDQueue")] +[Guid("5CD85A12-3DED-48E7-B440-B41E2A1452D9")] +[CLSCompliant(true)] +public class FairIDQueue : FairRoundRobinScheduleQueue, IIdentifyFilter +{ + private static int iVal = 1126270821; + + private const int REQUEST_INTERVAL = 600; + + private const int MAX_TRY_COUNT = 3; + + private const int NULL_ACTION_ID = -1; + + private Timer FireTimer = new Timer(); + + private DateTime LastFireTime = DateTime.MinValue; + + private uint CurrentTimerFrame; + + private uint LastTimerFireFrame; + + private int UserRequestedID = -1; + + private int UserRequestedAttempts; + + private EventHandler mUserIDRequestProcessed; + + [CLSCompliant(false)] + public event EventHandler UserIDRequestProcessed + { + add + { + mUserIDRequestProcessed = (EventHandler)Delegate.Combine(mUserIDRequestProcessed, value); + } + remove + { + mUserIDRequestProcessed = (EventHandler)Delegate.Remove(mUserIDRequestProcessed, value); + } + } + + internal FairIDQueue() + : base(3, -1) + { + FireTimer.Interval = 600; + FireTimer.Tick += FireTimer_Tick; + CoreManager.Current.Actions.Underlying.SetIDFilter(this); + CoreManager.Current.MessageProcessed += Current_MessageProcessed; + CoreManager.Current.RenderFrame += Current_RenderFrame; + } + + private void Current_RenderFrame(object sender, EventArgs e) + { + CurrentTimerFrame++; + } + + private void Current_MessageProcessed(object sender, MessageProcessedEventArgs e) + { + if (e.Message.Type == 63408 && e.Message.Value("event") == 201) + { + int num = e.Message.Value("object"); + DeleteAction(num); + if (UserRequestedID == num) + { + UserRequestedID = -1; + Util.SafeFireEvent(this, mUserIDRequestProcessed, new UserIDRequestProcessedEventArgs(num)); + } + } + } + + internal void Start() + { + LastFireTime = DateTime.MinValue; + FireTimer.Enabled = true; + } + + internal void Stop() + { + FireTimer.Enabled = false; + ClearAll(); + UserRequestedID = -1; + } + + private void FireTimer_Tick(object sender, EventArgs e) + { + if (FireTimer.Interval != 600) + { + FireTimer.Enabled = false; + FireTimer.Interval = 600; + FireTimer.Enabled = true; + } + if (CurrentTimerFrame != LastTimerFireFrame) + { + LastTimerFireFrame = CurrentTimerFrame; + FireNow(); + } + } + + private void FireNow() + { + Assembly requester = null; + int num = -1; + if (UserRequestedID != -1) + { + num = UserRequestedID; + UserRequestedAttempts++; + if (UserRequestedAttempts > 3) + { + UserRequestedID = -1; + } + } + if (num == -1) + { + num = GetNextAction(ref requester); + } + if (num != -1) + { + LastFireTime = DateTime.Now; + int num2 = num ^ iVal; + CoreManager.Current.Actions.Underlying.CallerRefInstanceInternal = num2; + iVal = (num2 << 5) ^ (num2 >> 13) ^ iVal; + } + } + + protected override bool IsActionValidNow(int action) + { + WorldObject worldObject = CoreManager.Current.WorldFilter[action]; + if (worldObject == null) + { + return true; + } + if (worldObject.Container == 0) + { + WorldObject worldObject2 = CoreManager.Current.WorldFilter[CoreManager.Current.CharacterFilter.Id]; + if (worldObject2 != null && worldObject.Coordinates().DistanceToCoords(worldObject2.Coordinates()) > 0.375) + { + return false; + } + } + return true; + } + + protected override bool IsActionPermanentlyInvalid(int action) + { + return !CoreManager.Current.Actions.IsValidObject(action); + } + + /// + /// Adds a request to the queue. + /// + /// The game object ID to identify. + public void AddToQueue(int lObjectID) + { + AddToQueue(lObjectID, DateTime.MaxValue); + } + + /// + /// Adds a request to the queue with a timeout time. + /// Note: if something else requests this ID while this request is still pending, + /// the later of the two timeouts will prevail. + /// + /// The game object ID to identify. + /// + public void AddToQueue(int lObjectID, DateTime pTimeout) + { + Assembly assembly = Assembly.GetCallingAssembly(); + if (assembly == null) + { + assembly = Assembly.GetExecutingAssembly(); + } + AddToQueueForCaller(lObjectID, assembly, pTimeout); + } + + internal void AddToQueueForCaller(int lObjectID, Assembly pCaller, DateTime pTimeout) + { + try + { + if (FireTimer.Enabled && lObjectID != -1) + { + Enqueue(pCaller, lObjectID, DateTime.MaxValue); + if ((DateTime.Now - LastFireTime).TotalMilliseconds > 700.0) + { + FireTimer.Enabled = false; + FireTimer.Interval = 1; + FireTimer.Enabled = true; + } + } + } + catch (Exception ex) + { + Util.WriteLine("Queue exception in addtoqueue: " + ex.ToString()); + } + } + + /// + /// Send an ID request which bypasses the queue. + /// This is used when the user manually requests an ID. Only one object + /// at a time can be pending here. + /// + /// The game object ID to identify. + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void ShortcircuitID(int lObjectID) + { + if (FireTimer.Enabled && lObjectID != -1) + { + UserRequestedID = lObjectID; + UserRequestedAttempts = 0; + if ((DateTime.Now - LastFireTime).TotalMilliseconds > 700.0) + { + LastFireTime = DateTime.Now; + } + } + } +} diff --git a/Unused/Decal.Adapter.IDQueue/FairRoundRobinScheduleQueue.cs b/Unused/Decal.Adapter.IDQueue/FairRoundRobinScheduleQueue.cs new file mode 100644 index 0000000..26e2139 --- /dev/null +++ b/Unused/Decal.Adapter.IDQueue/FairRoundRobinScheduleQueue.cs @@ -0,0 +1,298 @@ +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Runtime.InteropServices; +using CustomCollections; + +namespace Decal.Adapter.IDQueue; + +/// +/// A scheduler: callers request actions. Multiple callers can request the same action. +/// -Each caller gets one action, then the other callers get a turn. +/// -If a new caller arrives, it is given priority in the turns list. +/// -Everytime a caller gets a turn, it selects its next available action in round-robin fashion. +/// -If all of a caller's actions are unavailable when it is that caller's turn, its turn is lost and it must wait in line again. +/// -If no caller can take a turn, the null action is returned. +/// Thus if multiple callers request the same action, it will be tried more often +/// since the attempt will occur during the turns of multiple callers. +/// +/// +/// +[CLSCompliant(true)] +[ClassInterface(ClassInterfaceType.None)] +public abstract class FairRoundRobinScheduleQueue +{ + public class ActionRemovedEventArgs : EventArgs + { + private ACTIONTYPE mAction; + + public ACTIONTYPE Action => mAction; + + internal ActionRemovedEventArgs(ACTIONTYPE pAction) + { + mAction = pAction; + } + } + + private class ActionInfo : IEquatable + { + public ACTIONTYPE Action; + + public DateTime Expires; + + public int TryCount; + + public ActionInfo(ACTIONTYPE pAction, DateTime pExpires) + { + Action = pAction; + Expires = pExpires; + } + + public bool IsExpired() + { + return Expires < DateTime.Now; + } + + public bool Equals(ActionInfo other) + { + ref ACTIONTYPE action = ref Action; + object obj = other.Action; + return action.Equals(obj); + } + + public override bool Equals(object obj) + { + return Equals(obj as ActionInfo); + } + + public override int GetHashCode() + { + return Action.GetHashCode(); + } + } + + private HashedList Callers = new HashedList(); + + private Dictionary ActInfos = new Dictionary(); + + private Dictionary> CallerActions = new Dictionary>(); + + private Dictionary> ActionCallers = new Dictionary>(); + + private int MaximumTryCount; + + private ACTIONTYPE NullAction; + + public int CallerCount => Callers.Count; + + public int ActionCount => ActInfos.Count; + + public event EventHandler OnActionRemoved; + + /// + /// + /// + /// The most times an action can be attempted before it fails. + /// An ACTIONTYPE to return when no action is available. + protected FairRoundRobinScheduleQueue(int pMaximumTryCount, ACTIONTYPE pNullAction) + { + MaximumTryCount = pMaximumTryCount; + NullAction = pNullAction; + } + + protected abstract bool IsActionValidNow(ACTIONTYPE action); + + protected abstract bool IsActionPermanentlyInvalid(ACTIONTYPE action); + + private void RotateQueue(HashedList q) + { + if (q.Count > 0) + { + T item = q[0]; + q.RemoveAt(0); + q.Add(item); + } + } + + public void ClearAll() + { + Callers.Clear(); + ActInfos.Clear(); + CallerActions.Clear(); + ActionCallers.Clear(); + } + + public void DeleteAction(ACTIONTYPE action) + { + if (!ActionCallers.ContainsKey(action) || !ActInfos.ContainsKey(action)) + { + return; + } + ActionInfo item = ActInfos[action]; + ActInfos.Remove(action); + HashedList hashedList = ActionCallers[action]; + ActionCallers.Remove(action); + foreach (CALLERTYPE item2 in hashedList) + { + CallerActions[item2].Remove(item); + if (CallerActions[item2].Count == 0) + { + CallerActions.Remove(item2); + Callers.Remove(item2); + } + } + if (this.OnActionRemoved != null) + { + this.OnActionRemoved(this, new ActionRemovedEventArgs(action)); + } + } + + public void DeleteCaller(CALLERTYPE caller) + { + Callers.Remove(caller); + if (!CallerActions.ContainsKey(caller)) + { + return; + } + HashedList hashedList = CallerActions[caller]; + CallerActions.Remove(caller); + HashedList hashedList2 = new HashedList(); + foreach (ActionInfo item in hashedList) + { + if (ActionCallers.ContainsKey(item.Action)) + { + ActionCallers[item.Action].Remove(caller); + if (ActionCallers[item.Action].Count == 0) + { + ActionCallers.Remove(item.Action); + ActInfos.Remove(item.Action); + hashedList2.Add(item); + } + } + } + if (this.OnActionRemoved == null) + { + return; + } + foreach (ActionInfo item2 in hashedList2) + { + this.OnActionRemoved(this, new ActionRemovedEventArgs(item2.Action)); + } + } + + public ReadOnlyCollection GetActionsForCaller(CALLERTYPE caller) + { + List list = new List(); + if (CallerActions.ContainsKey(caller)) + { + foreach (ActionInfo item in CallerActions[caller]) + { + list.Add(item.Action); + } + } + return list.AsReadOnly(); + } + + public ReadOnlyCollection GetCallersForAction(ACTIONTYPE action) + { + if (ActionCallers.ContainsKey(action)) + { + return ActionCallers[action].AsReadOnly(); + } + return new List().AsReadOnly(); + } + + public void Enqueue(CALLERTYPE caller, ACTIONTYPE action, DateTime expiration) + { + ActionInfo actionInfo; + if (ActInfos.ContainsKey(action)) + { + actionInfo = ActInfos[action]; + if (actionInfo.Expires < expiration) + { + actionInfo.Expires = expiration; + } + actionInfo.TryCount = 0; + } + else + { + actionInfo = new ActionInfo(action, expiration); + ActInfos[action] = actionInfo; + } + if (!CallerActions.ContainsKey(caller) || !CallerActions[caller].Contains(actionInfo)) + { + if (!Callers.Contains(caller)) + { + Callers.Insert(0, caller); + } + if (!CallerActions.ContainsKey(caller)) + { + CallerActions.Add(caller, new HashedList()); + } + CallerActions[caller].Add(actionInfo); + if (!ActionCallers.ContainsKey(action)) + { + ActionCallers.Add(action, new HashedList()); + } + ActionCallers[action].Add(caller); + } + } + + public ACTIONTYPE GetNextAction(ref CALLERTYPE requester) + { + HashedList hashedList = new HashedList(); + ACTIONTYPE result = NullAction; + for (int i = 0; i < Callers.Count; i++) + { + CALLERTYPE val = Callers[0]; + HashedList hashedList2 = CallerActions[val]; + bool flag = false; + for (int j = 0; j < hashedList2.Count; j++) + { + ActionInfo actionInfo = hashedList2[0]; + if (hashedList.Contains(actionInfo)) + { + RotateQueue(hashedList2); + continue; + } + if (actionInfo.IsExpired()) + { + hashedList.Add(actionInfo); + RotateQueue(hashedList2); + continue; + } + if (IsActionPermanentlyInvalid(actionInfo.Action)) + { + hashedList.Add(actionInfo); + RotateQueue(hashedList2); + continue; + } + if (!IsActionValidNow(actionInfo.Action)) + { + RotateQueue(hashedList2); + continue; + } + flag = true; + result = actionInfo.Action; + requester = val; + RotateQueue(hashedList2); + actionInfo.TryCount++; + if (actionInfo.TryCount > MaximumTryCount) + { + hashedList.Add(actionInfo); + } + break; + } + RotateQueue(Callers); + if (flag) + { + break; + } + } + foreach (ActionInfo item in hashedList) + { + DeleteAction(item.Action); + } + return result; + } +} diff --git a/Unused/Decal.Adapter.IDQueue/UserIDRequestProcessedEventArgs.cs b/Unused/Decal.Adapter.IDQueue/UserIDRequestProcessedEventArgs.cs new file mode 100644 index 0000000..e2796c8 --- /dev/null +++ b/Unused/Decal.Adapter.IDQueue/UserIDRequestProcessedEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.IDQueue; + +public class UserIDRequestProcessedEventArgs : EventArgs +{ + private int mObjectId; + + public int ObjectId => mObjectId; + + internal UserIDRequestProcessedEventArgs(int ObjectId) + { + mObjectId = ObjectId; + } +} diff --git a/Unused/Decal.Adapter.Messages/AdapterMessageEventArgs.cs b/Unused/Decal.Adapter.Messages/AdapterMessageEventArgs.cs new file mode 100644 index 0000000..b6383bf --- /dev/null +++ b/Unused/Decal.Adapter.Messages/AdapterMessageEventArgs.cs @@ -0,0 +1,83 @@ +using System; +using System.Collections.Generic; + +namespace Decal.Adapter.Messages; + +/// +/// The base from which Adapter messages derive +/// +[CLSCompliant(true)] +public class AdapterMessageEventArgs : EventArgs +{ + private EventHandler responder; + + private List handlers; + + private bool canAddHandlers; + + internal bool CanAddHandlers + { + get + { + return canAddHandlers; + } + set + { + canAddHandlers = value; + } + } + + /// + /// Fires for each handler that completes processing of the message + /// + public event EventHandler MessageComplete + { + add + { + responder = (EventHandler)Delegate.Combine(responder, value); + } + remove + { + responder = (EventHandler)Delegate.Remove(responder, value); + } + } + + internal AdapterMessageEventArgs() + { + handlers = new List(); + } + + /// + /// Acknowledges that the object intends to process the message + /// + /// The object that will do the processing + public void AddHandler(object obj) + { + if (!CanAddHandlers) + { + throw new InvalidOperationException("Unable to add handlers at this time"); + } + if (obj != null) + { + handlers.Add(obj); + } + } + + /// + /// Signals completion of message processing + /// + /// The object that handled the message + /// The message response + public void SetComplete(object handler, AdapterMessageResponseEventArgs e) + { + handlers.Remove(handler); + if (handlers.Count == 0) + { + e.Complete = true; + } + if (responder != null) + { + responder(this, e); + } + } +} diff --git a/Unused/Decal.Adapter.Messages/AdapterMessageResponseEventArgs.cs b/Unused/Decal.Adapter.Messages/AdapterMessageResponseEventArgs.cs new file mode 100644 index 0000000..2c57e74 --- /dev/null +++ b/Unused/Decal.Adapter.Messages/AdapterMessageResponseEventArgs.cs @@ -0,0 +1,43 @@ +using System; + +namespace Decal.Adapter.Messages; + +/// +/// Defines a response to a message request +/// +[CLSCompliant(true)] +public class AdapterMessageResponseEventArgs : EventArgs +{ + private bool success; + + private bool complete; + + /// + /// Whether or not the actions take due to the message succeeded + /// + public bool Succeeded => success; + + /// + /// Whether or not all handlers have completed processing + /// + public bool Complete + { + get + { + return complete; + } + internal set + { + complete = value; + } + } + + /// + /// Create a new AdapterMessageResponse + /// + /// Did these actions succeed? + protected AdapterMessageResponseEventArgs(bool success) + { + this.success = success; + } +} diff --git a/Unused/Decal.Adapter.NetParser/MemberParser.cs b/Unused/Decal.Adapter.NetParser/MemberParser.cs new file mode 100644 index 0000000..a0fa33d --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MemberParser.cs @@ -0,0 +1,56 @@ +using System; + +namespace Decal.Adapter.NetParser; + +internal class MemberParser : MarshalByRefObject +{ + public MemberParser Next; + + public MemberParser Child; + + public MemberParserType MemberType; + + public string MemberName; + + public MemberParserCondition Condition; + + public string ConditionField; + + public long ConditionXor; + + public long ConditionAnd; + + public long ConditionResult; + + public string LengthField; + + public long LengthMask; + + public int LengthDelta; + + public int PreAlignment; + + public int PostAlignment; + + public MemberParser() + { + } + + public MemberParser(MemberParser Source) + { + Next = Source.Next; + Child = Source.Child; + MemberType = Source.MemberType; + MemberName = Source.MemberName; + Condition = Source.Condition; + ConditionField = Source.ConditionField; + ConditionXor = Source.ConditionXor; + ConditionAnd = Source.ConditionAnd; + ConditionResult = Source.ConditionResult; + LengthField = Source.LengthField; + LengthMask = Source.LengthMask; + LengthDelta = Source.LengthDelta; + PreAlignment = Source.PreAlignment; + PostAlignment = Source.PostAlignment; + } +} diff --git a/Unused/Decal.Adapter.NetParser/MemberParserCondition.cs b/Unused/Decal.Adapter.NetParser/MemberParserCondition.cs new file mode 100644 index 0000000..7b8741a --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MemberParserCondition.cs @@ -0,0 +1,12 @@ +namespace Decal.Adapter.NetParser; + +internal enum MemberParserCondition +{ + None, + EQ, + NE, + GE, + GT, + LE, + LT +} diff --git a/Unused/Decal.Adapter.NetParser/MemberParserType.cs b/Unused/Decal.Adapter.NetParser/MemberParserType.cs new file mode 100644 index 0000000..50f98ca --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MemberParserType.cs @@ -0,0 +1,18 @@ +namespace Decal.Adapter.NetParser; + +internal enum MemberParserType +{ + BYTE, + WORD, + PackedWORD, + DWORD, + PackedDWORD, + QWORD, + @float, + @double, + String, + WString, + Struct, + Vector, + Case +} diff --git a/Unused/Decal.Adapter.NetParser/MessageFactory.cs b/Unused/Decal.Adapter.NetParser/MessageFactory.cs new file mode 100644 index 0000000..03cd08c --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MessageFactory.cs @@ -0,0 +1,41 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Net; + +namespace Decal.Adapter.NetParser; + +/// +/// Decal Message Factory Implementation +/// +[ComVisible(true)] +[ClassInterface(ClassInterfaceType.None)] +[ComDefaultInterface(typeof(IMessageFactory))] +[ProgId("DecalAdapter.MessageFactory")] +[Guid("59D7815E-6716-4bd7-B264-69B6A9382701")] +public class MessageFactory : IMessageFactory +{ + /// + /// Construct a new MessageFacytory instance + /// + public MessageFactory() + { + } + + /// + /// Creates an IMessage2 instance from the provided raw packet data + /// + /// Pointer to the raw packet bytes + /// Size of pData in bytes + /// Packet direction + /// IMessage2 instance to navigate the packet + IMessage2 IMessageFactory.CreateMessage(int pData, int size, bool outgoing) + { + if (pData != 0 && size != 0) + { + byte[] array = (byte[])Array.CreateInstance(typeof(byte), size); + Marshal.Copy(new IntPtr(pData), array, 0, size); + return new MessageWrapper(new Message(array, Message.GetParser(BitConverter.ToInt32(array, 0), outgoing ? MessageDirection.Outbound : MessageDirection.Inbound))); + } + return null; + } +} diff --git a/Unused/Decal.Adapter.NetParser/MessageMemberWrapper.cs b/Unused/Decal.Adapter.NetParser/MessageMemberWrapper.cs new file mode 100644 index 0000000..7c4b0da --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MessageMemberWrapper.cs @@ -0,0 +1,57 @@ +using System.Runtime.InteropServices; +using Decal.Interop.Net; + +namespace Decal.Adapter.NetParser; + +[ComVisible(true)] +[ClassInterface(ClassInterfaceType.None)] +[ComDefaultInterface(typeof(IMessageMember))] +[ProgId("DecalAdapter.MessageMemberWrapper")] +[Guid("BD22CFC5-0950-4ab3-9752-5053EE934BE6")] +public class MessageMemberWrapper : MessageRootImpl, IMessageMember +{ + public int BeginOffset => Data.mOffset; + + public int Count => Data.Count; + + public int EndOffset => Data.mOffset + Data.mLength; + + public MessageMemberWrapper() + { + } + + internal MessageMemberWrapper(MessageStruct msg, MessageWrapper wrapper) + : base(msg, wrapper) + { + } + + public string get_FieldName(int Index) + { + return Data.Name(Index); + } + + public byte[] get_RawValue(object vIndex) + { + return Data.RawValue(Data.ObjectToIndex(vIndex)); + } + + public IMessageMember get_Struct(object vIndex) + { + int num = Data.ObjectToIndex(vIndex); + if (num < 0) + { + throw new COMHResultException((HResults)(-2147352571)); + } + return new MessageMemberWrapper(Data.Struct(num), Wrapped); + } + + public object get_Value(object vIndex) + { + int num = Data.ObjectToIndex(vIndex); + if (num >= 0) + { + return Data.Value(num); + } + throw new COMHResultException((HResults)(-2147352571)); + } +} diff --git a/Unused/Decal.Adapter.NetParser/MessageRootImpl.cs b/Unused/Decal.Adapter.NetParser/MessageRootImpl.cs new file mode 100644 index 0000000..5034aa9 --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MessageRootImpl.cs @@ -0,0 +1,124 @@ +using System.Diagnostics; +using Decal.Interop.Net; + +namespace Decal.Adapter.NetParser; + +/// +/// IMessageIterator base implementation +/// +public class MessageRootImpl : MessageRoot, IMessageIterator +{ + protected MessageWrapper Wrapped; + + protected MessageStruct Data; + + protected int FieldIndex; + + protected const int Error = -1; + + public object Current => Data.Value(FieldIndex); + + public string FieldName => Data.Name(FieldIndex); + + public int Index => FieldIndex; + + public IMessage Message => Wrapped; + + public MessageRoot NextObjectIndex + { + [DebuggerNonUserCode] + get + { + if (FieldIndex < Data.mCount) + { + MessageMemberWrapper result = new MessageMemberWrapper(Data.Struct(FieldIndex), Wrapped); + FieldIndex++; + return result; + } + throw new COMHResultException(HResults.E_FAIL); + } + } + + protected MessageRootImpl() + { + } + + protected MessageRootImpl(MessageStruct data, MessageWrapper wrapper) + : this() + { + Wrapped = wrapper; + Data = data; + if (!Data.mParsed) + { + Data.Parse(); + } + } + + public void Reset() + { + FieldIndex = 0; + } + + [DebuggerNonUserCode] + private T GetNext(string name) + { + FieldIndex = Data.IndexFromName(name); + if (FieldIndex != -1) + { + return Data.Value(FieldIndex); + } + throw new COMHResultException(HResults.E_FAIL); + } + + [DebuggerNonUserCode] + private T GetNext(int index) + { + if (index >= 0 && index < Data.mCount) + { + FieldIndex = index; + return Data.Value(FieldIndex); + } + throw new COMHResultException(HResults.E_FAIL); + } + + [DebuggerNonUserCode] + public object get_Next(object vIndex) + { + return GetNext(Data.ObjectToIndex(vIndex)); + } + + [DebuggerNonUserCode] + public double get_NextFloat(string Name) + { + return GetNext(Name); + } + + [DebuggerNonUserCode] + public int get_NextInt(string Name) + { + return GetNext(Name); + } + + [DebuggerNonUserCode] + public MessageRoot get_NextObject(string Name) + { + FieldIndex = Data.IndexFromName(Name); + if (FieldIndex != -1) + { + return new MessageMemberWrapper(Data.Struct(FieldIndex), Wrapped); + } + throw new COMHResultException(HResults.E_FAIL); + } + + [DebuggerNonUserCode] + public ulong get_NextQWord(string Name) + { + return GetNext(Name); + } + + [DebuggerNonUserCode] + public string get_NextString(string Name) + { + return GetNext(Name); + } +} diff --git a/Unused/Decal.Adapter.NetParser/MessageRootWrapper.cs b/Unused/Decal.Adapter.NetParser/MessageRootWrapper.cs new file mode 100644 index 0000000..325a935 --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MessageRootWrapper.cs @@ -0,0 +1,21 @@ +using System.Runtime.InteropServices; +using Decal.Interop.Net; + +namespace Decal.Adapter.NetParser; + +[ComVisible(true)] +[ClassInterface(ClassInterfaceType.None)] +[ComDefaultInterface(typeof(MessageRoot))] +[ProgId("DecalAdapter.MessageRootWrapper")] +[Guid("E33FBF17-B6C5-471e-9ED6-A394DEDEBFE5")] +public class MessageRootWrapper : MessageRootImpl +{ + public MessageRootWrapper() + { + } + + internal MessageRootWrapper(MessageWrapper msg) + : base(msg.Wrapped.mStruct, msg) + { + } +} diff --git a/Unused/Decal.Adapter.NetParser/MessageWrapper.cs b/Unused/Decal.Adapter.NetParser/MessageWrapper.cs new file mode 100644 index 0000000..bf50dd2 --- /dev/null +++ b/Unused/Decal.Adapter.NetParser/MessageWrapper.cs @@ -0,0 +1,109 @@ +using System.Runtime.InteropServices; +using Decal.Interop.Net; + +namespace Decal.Adapter.NetParser; + +/// +/// IMessage2 Implementation +/// +[ComVisible(true)] +[ClassInterface(ClassInterfaceType.None)] +[ComDefaultInterface(typeof(IMessage2))] +[ProgId("DecalAdapter.MessageWrapper")] +[Guid("76142307-98E3-494d-8320-3C801010221D")] +public class MessageWrapper : IMessage2, IMessage +{ + private Message msg; + + internal Message Wrapped => msg; + + /// + /// Return an IMessageIterator instance for this packet + /// + public MessageRoot Begin => new MessageRootWrapper(this); + + /// + /// Return the number of items within this structure + /// + public int Count => msg.Count; + + /// + /// Return the raw bytes of this structure + /// + public byte[] RawData => msg.RawData; + + /// + /// Return the message type + /// + public int Type => msg.Type; + + /// + /// Public constructor... + /// + public MessageWrapper() + { + } + + /// + /// Internal constructor to wrap the Adapter parser + /// + /// Adapter Message instance + internal MessageWrapper(Message msg) + { + this.msg = msg; + if (!this.msg.mStruct.mParsed) + { + this.msg.mStruct.Parse(); + } + } + + /// + /// Get the field name for the specified index + /// + /// message member index + /// field name + public string get_FieldName(int Index) + { + return msg.Name(Index); + } + + /// + /// Return the raw bytes for the specified member + /// + /// Member index (string or int) + /// Byte array containing the member data + public byte[] get_RawValue(object vElement) + { + return msg.RawValue(msg.mStruct.ObjectToIndex(vElement)); + } + + /// + /// Return the specified member struct + /// + /// Member index (string or int) + /// Member data + public IMessageMember get_Struct(object vElement) + { + int num = msg.mStruct.ObjectToIndex(vElement); + if (num < 0) + { + throw new COMHResultException((HResults)1); + } + return new MessageMemberWrapper(msg.Struct(num), this); + } + + /// + /// Return the specified member data + /// + /// Member index (string or int) + /// Member data + public object get_Value(object vElement) + { + int num = msg.mStruct.ObjectToIndex(vElement); + if (num >= 0) + { + return msg.Value(num); + } + return null; + } +} diff --git a/Unused/Decal.Adapter.Support/Util.cs b/Unused/Decal.Adapter.Support/Util.cs new file mode 100644 index 0000000..86357e7 --- /dev/null +++ b/Unused/Decal.Adapter.Support/Util.cs @@ -0,0 +1,174 @@ +#define TRACE +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Drawing; +using Decal.Interop.Core; +using Microsoft.CSharp; +using Microsoft.Win32; + +namespace Decal.Adapter.Support; + +internal static class Util +{ + private static int mTrace; + + internal static int TraceLevel + { + get + { + return mTrace; + } + set + { + mTrace = value; + } + } + + internal static Color ColorFromBGR(int color) + { + return Color.FromArgb(color & 0xFF, (color & 0xFF00) >> 8, (color & 0xFF0000) >> 16); + } + + internal static int ColorToBGR(Color color) + { + return (color.B << 16) | (color.G << 8) | color.R; + } + + internal static Rectangle toRectangle(tagRECT tr) + { + return new Rectangle(tr.left, tr.top, tr.right - tr.left, tr.bottom - tr.top); + } + + internal static tagRECT toTagRECT(Rectangle r) + { + tagRECT result = default(tagRECT); + result.top = r.Top; + result.left = r.Left; + result.bottom = r.Bottom; + result.right = r.Right; + return result; + } + + internal static T UnboxTo(object obj) + { + try + { + return (T)obj; + } + catch (InvalidCastException) + { + TypeConverter converter = new CSharpCodeProvider().GetConverter(obj.GetType()); + if (converter.CanConvertTo(typeof(T))) + { + return (T)converter.ConvertTo(obj, typeof(T)); + } + WriteLine("Error Converting object type {0} to {1}", obj.GetType(), typeof(T)); + throw; + } + } + + internal static void InitializeTracing(string key, string value, int defaultValue) + { + try + { + TraceLevel = (int)Registry.GetValue(key, value, defaultValue); + } + catch + { + TraceLevel = 0; + } + } + + public static void WriteLine(string fmt, params object[] args) + { + WriteLine(1, fmt, args); + } + + public static void WriteLine(int traceLevel, string fmt, params object[] args) + { + WriteLine(traceLevel, string.Format(fmt, args)); + } + + public static void WriteLine(int traceLevel, string msg) + { + Trace.WriteLineIf(mTrace >= traceLevel, msg); + } + + public static void Write(string fmt, params object[] args) + { + Write(1, string.Format(fmt, args)); + } + + public static void Write(int traceLevel, string msg) + { + Trace.WriteIf(mTrace >= traceLevel, msg); + } + + public static void SafeFireEvent(object sender, EventHandler eventHandler, EventArgs args) + { + if (eventHandler == null) + { + return; + } + Delegate[] invocationList = eventHandler.GetInvocationList(); + for (int i = 0; i < invocationList.Length; i++) + { + EventHandler eventHandler2 = (EventHandler)invocationList[i]; + try + { + eventHandler2(sender, args); + } + catch (Exception ex) + { + WriteLine("SafeFire exception: {0}", ex.ToString()); + } + } + } + + public static void SafeFireEvent(object sender, EventHandler eventHandler, T args) where T : EventArgs + { + if (eventHandler == null) + { + return; + } + Delegate[] invocationList = eventHandler.GetInvocationList(); + for (int i = 0; i < invocationList.Length; i++) + { + EventHandler eventHandler2 = (EventHandler)invocationList[i]; + try + { + eventHandler2(sender, args); + } + catch (Exception ex) + { + WriteLine("SafeFire exception: {0}", ex.ToString()); + } + } + } + + public static void SafeFireEvent(object sender, EventHandler eventHandler, T args, ref bool eaten) where T : EatableEventArgs + { + if (eventHandler == null) + { + return; + } + Delegate[] invocationList = eventHandler.GetInvocationList(); + for (int i = 0; i < invocationList.Length; i++) + { + EventHandler eventHandler2 = (EventHandler)invocationList[i]; + try + { + eventHandler2(sender, args); + if (args.Eat) + { + eaten = true; + } + } + catch (Exception ex) + { + WriteLine("SafeFire exception: {0}", ex.ToString()); + } + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/AcceptTradeEventArgs.cs b/Unused/Decal.Adapter.Wrappers/AcceptTradeEventArgs.cs new file mode 100644 index 0000000..212c690 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AcceptTradeEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class AcceptTradeEventArgs : EventArgs +{ + private int mTargetId; + + public int TargetId => mTargetId; + + internal AcceptTradeEventArgs(int TargetId) + { + mTargetId = TargetId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/AccountCharInfo.cs b/Unused/Decal.Adapter.Wrappers/AccountCharInfo.cs new file mode 100644 index 0000000..397b94b --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AccountCharInfo.cs @@ -0,0 +1,22 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class AccountCharInfo : MarshalByRefObject +{ + private int myIndex; + + private CharacterFilter myFilter; + + public string Name => myFilter.get_AccountCharName(myIndex); + + public int Id => myFilter.get_AccountCharID(myIndex); + + public int Index => myIndex; + + internal AccountCharInfo(CharacterFilter filter, int index) + { + myFilter = filter; + myIndex = index; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/AddRemoveEventType.cs b/Unused/Decal.Adapter.Wrappers/AddRemoveEventType.cs new file mode 100644 index 0000000..acedb9b --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AddRemoveEventType.cs @@ -0,0 +1,10 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum AddRemoveEventType +{ + Add, + Delete +} diff --git a/Unused/Decal.Adapter.Wrappers/AddTradeItemEventArgs.cs b/Unused/Decal.Adapter.Wrappers/AddTradeItemEventArgs.cs new file mode 100644 index 0000000..866768b --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AddTradeItemEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class AddTradeItemEventArgs : EventArgs +{ + private int mItemId; + + private int mSideId; + + public int ItemId => mItemId; + + public int SideId => mSideId; + + internal AddTradeItemEventArgs(int ItemId, int SideId) + { + mItemId = ItemId; + mSideId = SideId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/AllegianceInfoWrapper.cs b/Unused/Decal.Adapter.Wrappers/AllegianceInfoWrapper.cs new file mode 100644 index 0000000..bbaed41 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AllegianceInfoWrapper.cs @@ -0,0 +1,71 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class AllegianceInfoWrapper : MarshalByRefObject, IDisposable +{ + private AllegianceInfo myAllegianceInfo; + + private bool isDisposed; + + public int Id => myAllegianceInfo.GUID; + + public int Gender => myAllegianceInfo.Gender; + + public int Leadership => myAllegianceInfo.Leadership; + + public int Loyalty => myAllegianceInfo.Loyalty; + + public string Name => myAllegianceInfo.Name; + + public int Race => myAllegianceInfo.Race; + + public int Rank => myAllegianceInfo.Rank; + + public int ParentId => myAllegianceInfo.TreeParent; + + public int Type => myAllegianceInfo.Type; + + public double Unknown => myAllegianceInfo.Unknown; + + public long XP => myAllegianceInfo.XP_64; + + internal AllegianceInfoWrapper(AllegianceInfo info) + { + myAllegianceInfo = info; + } + + ~AllegianceInfoWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myAllegianceInfo != null) + { + Marshal.ReleaseComObject(myAllegianceInfo); + } + isDisposed = true; + } + + protected void EnforceDisposedOnce() + { + if (isDisposed) + { + throw new ObjectDisposedException("AllegianceInfoWrapper"); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ApproachVendorEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ApproachVendorEventArgs.cs new file mode 100644 index 0000000..82caaac --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ApproachVendorEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ApproachVendorEventArgs : EventArgs +{ + private int mMerchantId; + + private Vendor vendor; + + public int MerchantId => mMerchantId; + + public Vendor Vendor => vendor; + + internal ApproachVendorEventArgs(int MerchantId, Vendor ven) + { + mMerchantId = MerchantId; + vendor = ven; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/AttributeInfoWrapper.cs b/Unused/Decal.Adapter.Wrappers/AttributeInfoWrapper.cs new file mode 100644 index 0000000..677a1d4 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AttributeInfoWrapper.cs @@ -0,0 +1,59 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class AttributeInfoWrapper : MarshalByRefObject, IDisposable +{ + private AttributeInfo myAttribInfo; + + private bool isDisposed; + + public int Base => myAttribInfo.Base; + + public int Buffed => myAttribInfo.Buffed; + + public int Creation => myAttribInfo.Creation; + + public int Exp => myAttribInfo.Exp; + + public string Name => myAttribInfo.Name; + + internal AttributeInfoWrapper(AttributeInfo info) + { + myAttribInfo = info; + } + + ~AttributeInfoWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myAttribInfo != null) + { + Marshal.ReleaseComObject(myAttribInfo); + } + isDisposed = true; + } + + protected void EnforceDisposedOnce() + { + if (isDisposed) + { + throw new ObjectDisposedException("AttributeInfoWrapper"); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/AttributeType.cs b/Unused/Decal.Adapter.Wrappers/AttributeType.cs new file mode 100644 index 0000000..58485ce --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/AttributeType.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum AttributeType +{ + CurrentStrength = 1, + CurrentEndurance, + CurrentQuickness, + CurrentCoordination, + CurrentFocus, + CurrentSelf, + BaseStrength, + BaseEndurance, + BaseQuickness, + BaseCoordination, + BaseFocus, + BaseSelf +} diff --git a/Unused/Decal.Adapter.Wrappers/Augmentations.cs b/Unused/Decal.Adapter.Wrappers/Augmentations.cs new file mode 100644 index 0000000..b5a8ae7 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/Augmentations.cs @@ -0,0 +1,78 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum Augmentations +{ + ReinforcementLugians = 218, + BleearghFortitude = 219, + OswaldEnchancement = 220, + SiraluunBlessing = 221, + EnduringCalm = 222, + SteadfastWill = 223, + CiandraEssence = 224, + YoshiEssence = 225, + JibrilEssence = 226, + CeldisethEssence = 227, + KogaEssence = 228, + ShadowSeventhMule = 229, + MightSeventhMule = 230, + ClutchMiser = 231, + EnduringEnchantment = 232, + CriticalProtection = 233, + QuickLearner = 234, + CiandraFortune = 235, + CharmedSmith = 236, + InnateRenewal = 237, + ArchmageEndurance = 238, + BladeTurner = 240, + ArrowTurner = 241, + MaceTurner = 242, + CausticEnhancement = 243, + FieryEnchancment = 244, + IcyEnchancement = 245, + LightningEnhancement = 246, + InfusedCreature = 294, + InfusedItem = 295, + InfusedLife = 296, + InfusedWar = 297, + EyeRemorseless = 298, + HandRemorseless = 299, + MasterSteelCircle = 300, + MasterFocusedEyed = 301, + MasterFiveFoldPath = 302, + FrenzySlayer = 309, + IronSkinInvincible = 310, + JackOfAllTrades = 326, + InfusedVoid = 328, + [Obsolete("Use InfusedVoid")] + UnknownAug1 = 328, + [Obsolete("Not an aug")] + UnknownAug2 = 329, + [Obsolete("Not an aug")] + UnknownAug3 = 330, + [Obsolete("Not an aug")] + UnknownAug4 = 331, + [Obsolete("Not an aug")] + UnknownAug5 = 332, + AuraValor = 333, + AuraProtection = 334, + AuraGlory = 335, + AuraTemperance = 336, + AuraSurge = 337, + [Obsolete("Not an aug")] + UnknownAug6 = 337, + AuraAethericVision = 338, + AuraManaFlow = 339, + AuraManaInfusion = 340, + [Obsolete("Use AuraManaInfusion")] + UnknownAug7 = 340, + AuraVitality = 341, + [Obsolete("Use AuraVitality")] + UnknownAug8 = 341, + AuraPurity = 342, + AuraCraftsman = 343, + AuraSpecialization = 344, + AuraWorld = 365 +} diff --git a/Unused/Decal.Adapter.Wrappers/Background.cs b/Unused/Decal.Adapter.Wrappers/Background.cs new file mode 100644 index 0000000..200bfbb --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/Background.cs @@ -0,0 +1,29 @@ +using System; +using Decal.Interop.Render; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class Background : HudRenderTarget +{ + private HUDBackground internalBackground; + + internal HUDBackground Underlying => internalBackground; + + internal Background(HUDBackground background) + : base(background) + { + internalBackground = background; + } + + public Background Clone() + { + return new Background(internalBackground.Clone()); + } + + protected override void Dispose(bool disposing) + { + internalBackground = null; + base.Dispose(disposing); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/BoolValueKey.cs b/Unused/Decal.Adapter.Wrappers/BoolValueKey.cs new file mode 100644 index 0000000..5f19318 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/BoolValueKey.cs @@ -0,0 +1,16 @@ +namespace Decal.Adapter.Wrappers; + +public enum BoolValueKey +{ + Lockable = 201326592, + Inscribable = 201326593, + Open = 2, + Locked = 3, + HookVisibility = 24, + UnlimitedUses = 63, + CanBeSold = 69, + Retained = 91, + Ivoryable = 99, + Dyeable = 100, + AwayFromKeyboard = 110 +} diff --git a/Unused/Decal.Adapter.Wrappers/ButtonWrapper.cs b/Unused/Decal.Adapter.Wrappers/ButtonWrapper.cs new file mode 100644 index 0000000..422c11a --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ButtonWrapper.cs @@ -0,0 +1,229 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +public class ButtonWrapper : ControlWrapperBase +{ + private EventHandler evtClick; + + private EventHandler evtCancel; + + private EventHandler evtDestroy; + + private EventHandler evtHit; + + private EventHandler evtUnhit; + + private int myBackground; + + public Color Matte + { + get + { + return Util.ColorFromBGR(base.Control.Matte); + } + set + { + base.Control.Matte = Util.ColorToBGR(value); + } + } + + public int Background + { + get + { + return myBackground; + } + set + { + myBackground = value; + base.Control.SetBackground(myBackground); + } + } + + public event EventHandler Click + { + add + { + if (evtClick == null) + { + base.Control.Accepted += ClickEvent; + } + evtClick = (EventHandler)Delegate.Combine(evtClick, value); + } + remove + { + evtClick = (EventHandler)Delegate.Remove(evtClick, value); + if (evtClick == null) + { + base.Control.Accepted -= ClickEvent; + } + } + } + + public event EventHandler Canceled + { + add + { + if (evtCancel == null) + { + base.Control.Canceled += CanceledEvent; + } + evtCancel = (EventHandler)Delegate.Combine(evtCancel, value); + } + remove + { + evtCancel = (EventHandler)Delegate.Remove(evtCancel, value); + if (evtCancel == null) + { + base.Control.Canceled -= CanceledEvent; + } + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Hit + { + add + { + if (evtHit == null) + { + base.Control.Hit += HitEvent; + } + evtHit = (EventHandler)Delegate.Combine(evtHit, value); + } + remove + { + evtHit = (EventHandler)Delegate.Remove(evtHit, value); + if (evtHit == null) + { + base.Control.Hit -= HitEvent; + } + } + } + + public event EventHandler Unhit + { + add + { + if (evtUnhit == null) + { + base.Control.Unhit += UnhitEvent; + } + evtUnhit = (EventHandler)Delegate.Combine(evtUnhit, value); + } + remove + { + evtUnhit = (EventHandler)Delegate.Remove(evtUnhit, value); + if (evtUnhit == null) + { + base.Control.Unhit -= UnhitEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtClick != null) + { + evtClick = (EventHandler)Delegate.Remove(evtClick, evtClick); + base.Control.Accepted -= ClickEvent; + } + if (evtCancel != null) + { + evtCancel = (EventHandler)Delegate.Remove(evtCancel, evtCancel); + base.Control.Canceled -= CanceledEvent; + } + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtHit != null) + { + evtHit = (EventHandler)Delegate.Remove(evtHit, evtHit); + base.Control.Hit -= HitEvent; + } + if (evtUnhit != null) + { + evtUnhit = (EventHandler)Delegate.Remove(evtUnhit, evtUnhit); + base.Control.Unhit -= UnhitEvent; + } + } + base.Dispose(disposing); + } + + public void SetImages(int released, int pressed) + { + SetImages(0, released, pressed); + } + + public void SetImages(int module, int released, int pressed) + { + base.Control.SetImages(module, released, pressed); + } + + private void ClickEvent(int ID) + { + if (evtClick != null) + { + evtClick(this, new ControlEventArgs(ID)); + } + } + + private void UnhitEvent(int ID) + { + if (evtUnhit != null) + { + evtUnhit(this, new ControlEventArgs(ID)); + } + } + + private void HitEvent(int ID) + { + if (evtHit != null) + { + evtHit(this, new ControlEventArgs(ID)); + } + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } + + private void CanceledEvent(int ID) + { + if (evtCancel != null) + { + evtCancel(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByAllFilter.cs b/Unused/Decal.Adapter.Wrappers/ByAllFilter.cs new file mode 100644 index 0000000..75db439 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByAllFilter.cs @@ -0,0 +1,19 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for all objects +/// +public class ByAllFilter : WorldObjectCollectionFilter +{ + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByAll(); + } + + internal override void ApplyFilter(Decal.Interop.Filters.Vendor ven) + { + ven.ByAll(); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByCategoryFilter.cs b/Unused/Decal.Adapter.Wrappers/ByCategoryFilter.cs new file mode 100644 index 0000000..0af2140 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByCategoryFilter.cs @@ -0,0 +1,52 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for objects having the same category +/// +public class ByCategoryFilter : WorldObjectCollectionFilter +{ + private int category; + + /// + /// Category of the items in this collection + /// + public int Category + { + get + { + return category; + } + set + { + category = value; + } + } + + /// + /// Creates a new filter + /// + public ByCategoryFilter() + { + } + + /// + /// Creates a new filter using the specified category + /// + /// Category to filter by + public ByCategoryFilter(int category) + { + this.category = category; + } + + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByCategory(category); + } + + internal override void ApplyFilter(Decal.Interop.Filters.Vendor ven) + { + ven.ByCategory(category); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByContainerFilter.cs b/Unused/Decal.Adapter.Wrappers/ByContainerFilter.cs new file mode 100644 index 0000000..33ea97a --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByContainerFilter.cs @@ -0,0 +1,47 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for objects in a container +/// +public class ByContainerFilter : WorldObjectCollectionFilter +{ + private int container; + + /// + /// Id of the container filtered by + /// + public int Container + { + get + { + return container; + } + set + { + container = value; + } + } + + /// + /// Creates a new filter + /// + public ByContainerFilter() + { + } + + /// + /// Creates a new filter using the specified container + /// + /// Id of the container + public ByContainerFilter(int container) + { + this.container = container; + } + + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByContainer(container); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByInventoryFilter.cs b/Unused/Decal.Adapter.Wrappers/ByInventoryFilter.cs new file mode 100644 index 0000000..626bd32 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByInventoryFilter.cs @@ -0,0 +1,14 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for inventory objects +/// +public class ByInventoryFilter : WorldObjectCollectionFilter +{ + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByInventory(); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByLandscapeFilter.cs b/Unused/Decal.Adapter.Wrappers/ByLandscapeFilter.cs new file mode 100644 index 0000000..db13849 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByLandscapeFilter.cs @@ -0,0 +1,14 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for landscape objects +/// +public class ByLandscapeFilter : WorldObjectCollectionFilter +{ + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByLandscape(); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByNameFilter.cs b/Unused/Decal.Adapter.Wrappers/ByNameFilter.cs new file mode 100644 index 0000000..eb4dd7c --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByNameFilter.cs @@ -0,0 +1,52 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for objects having the specified name +/// +public class ByNameFilter : WorldObjectCollectionFilter +{ + private string name; + + /// + /// Name of the objects in this collection + /// + public string Name + { + get + { + return name; + } + set + { + name = value; + } + } + + /// + /// Creates a new filter + /// + public ByNameFilter() + { + } + + /// + /// Creates a new filter using the specified name + /// + /// Name of the object + public ByNameFilter(string name) + { + this.name = name; + } + + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByName(name); + } + + internal override void ApplyFilter(Decal.Interop.Filters.Vendor ven) + { + ven.ByName(name); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByNameSubStringFilter.cs b/Unused/Decal.Adapter.Wrappers/ByNameSubStringFilter.cs new file mode 100644 index 0000000..e3d532d --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByNameSubStringFilter.cs @@ -0,0 +1,19 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for objects containing the specified name +/// +public class ByNameSubStringFilter : ByNameFilter +{ + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByNameSubstring(base.Name); + } + + internal override void ApplyFilter(Decal.Interop.Filters.Vendor ven) + { + ven.ByNameSubstring(base.Name); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByObjectClassFilter.cs b/Unused/Decal.Adapter.Wrappers/ByObjectClassFilter.cs new file mode 100644 index 0000000..9c6fc1d --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByObjectClassFilter.cs @@ -0,0 +1,52 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for objects of the same type/class +/// +public class ByObjectClassFilter : WorldObjectCollectionFilter +{ + private ObjectClass objClass; + + /// + /// Class of the items in this collection + /// + public ObjectClass ObjectClass + { + get + { + return objClass; + } + set + { + objClass = value; + } + } + + /// + /// Creates a new filter + /// + public ByObjectClassFilter() + { + } + + /// + /// Creates a new filter using the specified ObjectClass + /// + /// Class of the items + public ByObjectClassFilter(ObjectClass objClass) + { + this.objClass = objClass; + } + + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByObjectClass((eObjectClass)objClass); + } + + internal override void ApplyFilter(Decal.Interop.Filters.Vendor ven) + { + ven.ByObjectClass((eObjectClass)objClass); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ByOwnerFilter.cs b/Unused/Decal.Adapter.Wrappers/ByOwnerFilter.cs new file mode 100644 index 0000000..db6a026 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ByOwnerFilter.cs @@ -0,0 +1,47 @@ +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines the WorldObjectCollection filter for all objects owned by a character +/// +public class ByOwnerFilter : WorldObjectCollectionFilter +{ + private int owner; + + /// + /// Id of the owner of the objects + /// + public int Owner + { + get + { + return owner; + } + set + { + owner = value; + } + } + + /// + /// Creates a new filter + /// + public ByOwnerFilter() + { + } + + /// + /// Creates a new filter using the specified owner + /// + /// Id of the owner + public ByOwnerFilter(int owner) + { + this.owner = owner; + } + + internal override void ApplyFilter(WorldIterator wi) + { + wi.ByOwner(owner); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/CastEventType.cs b/Unused/Decal.Adapter.Wrappers/CastEventType.cs new file mode 100644 index 0000000..2d81540 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CastEventType.cs @@ -0,0 +1,10 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum CastEventType +{ + Untargetted, + Targetted +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeEnchantmentsEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeEnchantmentsEventArgs.cs new file mode 100644 index 0000000..61e5447 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeEnchantmentsEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeEnchantmentsEventArgs : EventArgs +{ + private AddRemoveEventType myType; + + private EnchantmentWrapper myEnchantment; + + public AddRemoveEventType Type => myType; + + public EnchantmentWrapper Enchantment => myEnchantment; + + internal ChangeEnchantmentsEventArgs(AddRemoveEventType type, EnchantmentWrapper enchantment) + { + myType = type; + myEnchantment = enchantment; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeExperienceEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeExperienceEventArgs.cs new file mode 100644 index 0000000..b354a1c --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeExperienceEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeExperienceEventArgs : EventArgs +{ + private PlayerXPEventType myType; + + private int myAmount; + + public PlayerXPEventType Type => myType; + + public int Amount => myAmount; + + internal ChangeExperienceEventArgs(PlayerXPEventType type, int amount) + { + myType = type; + myAmount = amount; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeFellowshipEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeFellowshipEventArgs.cs new file mode 100644 index 0000000..121db43 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeFellowshipEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeFellowshipEventArgs : EventArgs +{ + private FellowshipEventType myType; + + private int myId; + + public FellowshipEventType Type => myType; + + public int Id => myId; + + internal ChangeFellowshipEventArgs(FellowshipEventType type, int Id) + { + myType = type; + myId = Id; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeObjectEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeObjectEventArgs.cs new file mode 100644 index 0000000..64218cc --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeObjectEventArgs.cs @@ -0,0 +1,21 @@ +using System; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +public class ChangeObjectEventArgs : EventArgs +{ + private WorldObject myChangedObject; + + private WorldChangeType myChangeType; + + public WorldObject Changed => myChangedObject; + + public WorldChangeType Change => myChangeType; + + internal ChangeObjectEventArgs(WorldObject changedObject, Decal.Interop.Filters.WorldChangeType changeType) + { + myChangedObject = changedObject; + myChangeType = (WorldChangeType)changeType; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeOptionEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeOptionEventArgs.cs new file mode 100644 index 0000000..742030b --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeOptionEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeOptionEventArgs : EventArgs +{ + private int myOption; + + private int myValue; + + public int Option => myOption; + + public int Value => myValue; + + internal ChangeOptionEventArgs(int option, int value) + { + myOption = option; + myValue = value; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangePlayerEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangePlayerEventArgs.cs new file mode 100644 index 0000000..ca2af81 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangePlayerEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangePlayerEventArgs : EventArgs +{ + private PlayerModifyEventType myType; + + private int myStat; + + public PlayerModifyEventType Type => myType; + + public int Stat => myStat; + + internal ChangePlayerEventArgs(PlayerModifyEventType type, int Stat) + { + myType = type; + myStat = Stat; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangePortalModeEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangePortalModeEventArgs.cs new file mode 100644 index 0000000..f821ced --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangePortalModeEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangePortalModeEventArgs : EventArgs +{ + private PortalEventType myType; + + public PortalEventType Type => myType; + + internal ChangePortalModeEventArgs(PortalEventType type) + { + myType = type; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeSettingsFlagsEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeSettingsFlagsEventArgs.cs new file mode 100644 index 0000000..1b6995e --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeSettingsFlagsEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeSettingsFlagsEventArgs : EventArgs +{ + private int mySettings; + + public int Settings => mySettings; + + internal ChangeSettingsFlagsEventArgs(int settings) + { + mySettings = settings; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeShortcutEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeShortcutEventArgs.cs new file mode 100644 index 0000000..70c7f1e --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeShortcutEventArgs.cs @@ -0,0 +1,25 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeShortcutEventArgs : EventArgs +{ + private AddRemoveEventType myType; + + private int mySlot; + + private int myObjectId; + + public AddRemoveEventType Type => myType; + + public int Slot => mySlot; + + public int ObjectId => myObjectId; + + internal ChangeShortcutEventArgs(AddRemoveEventType type, int Slot, int ObjectId) + { + myType = type; + mySlot = Slot; + myObjectId = ObjectId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeSpellbarEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeSpellbarEventArgs.cs new file mode 100644 index 0000000..71dafdc --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeSpellbarEventArgs.cs @@ -0,0 +1,30 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeSpellbarEventArgs : EventArgs +{ + private AddRemoveEventType myType; + + private int myTab; + + private int mySlot; + + private int mySpellId; + + public AddRemoveEventType Type => myType; + + public int Tab => myTab; + + public int Slot => mySlot; + + public int SpellId => mySpellId; + + internal ChangeSpellbarEventArgs(AddRemoveEventType type, int Tab, int Slot, int SpellId) + { + myType = type; + myTab = Tab; + mySlot = Slot; + mySpellId = SpellId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChangeVitalEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ChangeVitalEventArgs.cs new file mode 100644 index 0000000..6a63c87 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChangeVitalEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ChangeVitalEventArgs : EventArgs +{ + private CharFilterVitalType myType; + + private int myAmount; + + public CharFilterVitalType Type => myType; + + public int Amount => myAmount; + + internal ChangeVitalEventArgs(CharFilterVitalType type, int amount) + { + myType = type; + myAmount = amount; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/CharFilterAttributeType.cs b/Unused/Decal.Adapter.Wrappers/CharFilterAttributeType.cs new file mode 100644 index 0000000..aba9dcd --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CharFilterAttributeType.cs @@ -0,0 +1,14 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum CharFilterAttributeType +{ + Strength = 1, + Endurance, + Quickness, + Coordination, + Focus, + Self +} diff --git a/Unused/Decal.Adapter.Wrappers/CharFilterIndex.cs b/Unused/Decal.Adapter.Wrappers/CharFilterIndex.cs new file mode 100644 index 0000000..479a935 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CharFilterIndex.cs @@ -0,0 +1,16 @@ +namespace Decal.Adapter.Wrappers; + +public enum CharFilterIndex +{ + Vassals, + Enchantments, + Vitals, + Attributes, + Skills, + Characters, + Spells, + Augmentations, + EffectiveAttributes, + EffectiveVitals, + EffectiveSkills +} diff --git a/Unused/Decal.Adapter.Wrappers/CharFilterSkillType.cs b/Unused/Decal.Adapter.Wrappers/CharFilterSkillType.cs new file mode 100644 index 0000000..d2a2e15 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CharFilterSkillType.cs @@ -0,0 +1,57 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum CharFilterSkillType +{ + Axe = 1, + Bow = 2, + Crossbow = 3, + Dagger = 4, + Mace = 5, + MeleeDefense = 6, + MissileDefense = 7, + Spear = 9, + Staff = 10, + Sword = 11, + ThrownWeapons = 12, + Unarmed = 13, + ArcaneLore = 14, + MagicDefense = 15, + ManaConversion = 16, + ItemTinkering = 18, + AssessPerson = 19, + Deception = 20, + Healing = 21, + Jump = 22, + Lockpick = 23, + Run = 24, + AssessCreature = 27, + WeaponTinkering = 28, + ArmorTinkering = 29, + MagicItemTinkering = 30, + CreatureEnchantment = 31, + ItemEnchantment = 32, + LifeMagic = 33, + WarMagic = 34, + Leadership = 35, + Loyalty = 36, + Fletching = 37, + Alchemy = 38, + Cooking = 39, + Salvaging = 40, + TwoHandedCombat = 41, + Gearcraft = 42, + VoidMagic = 43, + HeavyWeapons = 44, + LightWeapons = 45, + FinesseWeapons = 46, + MissileWeapons = 47, + Shield = 48, + DualWield = 49, + Recklessness = 50, + SneakAttack = 51, + DirtyFighting = 52, + Summoning = 54 +} diff --git a/Unused/Decal.Adapter.Wrappers/CharFilterVitalType.cs b/Unused/Decal.Adapter.Wrappers/CharFilterVitalType.cs new file mode 100644 index 0000000..16d2db0 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CharFilterVitalType.cs @@ -0,0 +1,11 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum CharFilterVitalType +{ + Health = 2, + Stamina = 4, + Mana = 6 +} diff --git a/Unused/Decal.Adapter.Wrappers/CharacterFilter.cs b/Unused/Decal.Adapter.Wrappers/CharacterFilter.cs new file mode 100644 index 0000000..2645c2a --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CharacterFilter.cs @@ -0,0 +1,1173 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using Decal.Adapter.Support; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +public class CharacterFilter : GenericDisposableWrapper, IIndexedProvider +{ + private EventHandler mSpellCast; + + private EventHandler mStatusMessage; + + private EventHandler mSpellbookChange; + + private EventHandler mChangePortalMode; + + private EventHandler mChangePlayer; + + private EventHandler mChangeFellowship; + + private EventHandler mChangeEnchantments; + + private EventHandler mChangeExperience; + + private EventHandler mChangeVital; + + private EventHandler mChangeSpellbar; + + private EventHandler mChangeShortcut; + + private EventHandler mLogin; + + private EventHandler mLogoff; + + private EventHandler mDeath; + + private EventHandler mChangeSettings; + + private EventHandler mActionComplete; + + private EventHandler mLoginComplete; + + private EventHandler mChangeSettingsFlags; + + private EventHandler mChangeOption; + + private Collection mySpellBook; + + private ReadOnlyCollection myAugmentations; + + private Dictionary> mySpellBars; + + private Dictionary allegianceData; + + private Dictionary enchantmentData; + + private Dictionary vitalSkillData; + + private Dictionary attributeData; + + public string AccountName + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.AccountName; + } + } + + public int Age + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Age; + } + } + + public DateTime Birth + { + get + { + EnforceDisposedOnce(); + return new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(base.Wrapped.Birth); + } + } + + public int Burden + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Burden; + } + } + + public int BurdenUnits + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.BurdenUnits; + } + } + + public string Name + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Name; + } + } + + public int Id + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Character; + } + } + + public int CharacterOptions + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.CharacterOptions; + } + } + + public int CharacterOptionFlags => base.Wrapped.CharacterOptionFlags; + + public string ClassTemplate + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.ClassTemplate; + } + } + + public int Deaths + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Deaths; + } + } + + public string Gender + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Gender; + } + } + + public int Health + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Health; + } + } + + public int Stamina + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Stamina; + } + } + + public int Mana + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Mana; + } + } + + public int Level + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Level; + } + } + + public int LoginStatus + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.LoginStatus; + } + } + + public string Race + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Race; + } + } + + public int Rank + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Rank; + } + } + + public string Server + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Server; + } + } + + public int ServerPopulation + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.ServerPopulation; + } + } + + public long TotalXP + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.TotalXP_64; + } + } + + [CLSCompliant(false)] + public IndexedCollection Vassals + { + get + { + EnforceDisposedOnce(); + return new IndexedCollection(this, CharFilterIndex.Vassals); + } + } + + [CLSCompliant(false)] + public IndexedCollection Characters + { + get + { + EnforceDisposedOnce(); + return new IndexedCollection(this, CharFilterIndex.Characters); + } + } + + [CLSCompliant(false)] + public IndexedCollection Enchantments + { + get + { + EnforceDisposedOnce(); + return new IndexedCollection(this, CharFilterIndex.Enchantments); + } + } + + [CLSCompliant(false)] + public IndexedCollection Vitals + { + get + { + EnforceDisposedOnce(); + return new IndexedCollection(this, CharFilterIndex.Vitals); + } + } + + [CLSCompliant(false)] + public IndexedCollection Attributes + { + get + { + EnforceDisposedOnce(); + return new IndexedCollection(this, CharFilterIndex.Attributes); + } + } + + [CLSCompliant(false)] + public IndexedCollection Skills + { + get + { + EnforceDisposedOnce(); + return new IndexedCollection(this, CharFilterIndex.Skills); + } + } + + public long UnassignedXP + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.UnassignedXP_64; + } + } + + public int Vitae + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Vitae; + } + } + + public AllegianceInfoWrapper Monarch + { + get + { + EnforceDisposedOnce(); + string key = "Monarch"; + AllegianceInfo monarch = base.Wrapped.Monarch; + AllegianceInfoWrapper value = null; + if (allegianceData.TryGetValue(key, out value) && value.Id != monarch.GUID) + { + allegianceData.Remove(key); + value.Dispose(); + value = null; + } + if (value == null) + { + value = new AllegianceInfoWrapper(monarch); + allegianceData.Add(key, value); + } + return value; + } + } + + public AllegianceInfoWrapper Patron + { + get + { + EnforceDisposedOnce(); + string key = "Patron"; + AllegianceInfo patron = base.Wrapped.Patron; + AllegianceInfoWrapper value = null; + if (allegianceData.TryGetValue(key, out value) && value.Id != patron.GUID) + { + allegianceData.Remove(key); + value.Dispose(); + value = null; + } + if (value == null) + { + value = new AllegianceInfoWrapper(patron); + allegianceData.Add(key, value); + } + return value; + } + } + + public AllegianceInfoWrapper Allegiance + { + get + { + EnforceDisposedOnce(); + string key = "MyAllegiance"; + AllegianceInfoWrapper value = null; + if (allegianceData.TryGetValue(key, out value)) + { + allegianceData.Remove(key); + value.Dispose(); + } + value = new AllegianceInfoWrapper(base.Wrapped.MyAllegiance); + allegianceData.Add(key, value); + return value; + } + } + + public int Followers + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.Followers; + } + } + + public int MonarchFollowers + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.MonarchFollowers; + } + } + + public int SkillPoints + { + get + { + EnforceDisposedOnce(); + return base.Wrapped.SkillPoints; + } + } + + public long XPToNextLevel => base.Wrapped.XPToNextLevel; + + public ReadOnlyCollection SpellBook + { + get + { + EnforceDisposedOnce(); + if (mySpellBook == null) + { + mySpellBook = new Collection(base.Wrapped.SpellbookArray); + } + return new ReadOnlyCollection(mySpellBook); + } + } + + public ReadOnlyCollection Augmentations + { + get + { + EnforceDisposedOnce(); + if (myAugmentations == null) + { + myAugmentations = new ReadOnlyCollection(base.Wrapped.AugmentationArray); + } + return myAugmentations; + } + } + + [CLSCompliant(false)] + public IndexedCollection EffectiveAttribute => new IndexedCollection(this, CharFilterIndex.EffectiveAttributes); + + [CLSCompliant(false)] + public IndexedCollection EffectiveSkill => new IndexedCollection(this, CharFilterIndex.EffectiveSkills); + + [CLSCompliant(false)] + public IndexedCollection EffectiveVital => new IndexedCollection(this, CharFilterIndex.EffectiveVitals); + + public event EventHandler ActionComplete + { + add + { + mActionComplete = (EventHandler)Delegate.Combine(mActionComplete, value); + } + remove + { + mActionComplete = (EventHandler)Delegate.Remove(mActionComplete, value); + } + } + + public event EventHandler LoginComplete + { + add + { + mLoginComplete = (EventHandler)Delegate.Combine(mLoginComplete, value); + } + remove + { + mLoginComplete = (EventHandler)Delegate.Remove(mLoginComplete, value); + } + } + + [CLSCompliant(false)] + public event EventHandler SpellbookChange + { + add + { + mSpellbookChange = (EventHandler)Delegate.Combine(mSpellbookChange, value); + } + remove + { + mSpellbookChange = (EventHandler)Delegate.Remove(mSpellbookChange, value); + } + } + + [CLSCompliant(false)] + public event EventHandler Death + { + add + { + mDeath = (EventHandler)Delegate.Combine(mDeath, value); + } + remove + { + mDeath = (EventHandler)Delegate.Remove(mDeath, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangePortalMode + { + add + { + mChangePortalMode = (EventHandler)Delegate.Combine(mChangePortalMode, value); + } + remove + { + mChangePortalMode = (EventHandler)Delegate.Remove(mChangePortalMode, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangePlayer + { + add + { + mChangePlayer = (EventHandler)Delegate.Combine(mChangePlayer, value); + } + remove + { + mChangePlayer = (EventHandler)Delegate.Remove(mChangePlayer, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeFellowship + { + add + { + mChangeFellowship = (EventHandler)Delegate.Combine(mChangeFellowship, value); + } + remove + { + mChangeFellowship = (EventHandler)Delegate.Remove(mChangeFellowship, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeEnchantments + { + add + { + mChangeEnchantments = (EventHandler)Delegate.Combine(mChangeEnchantments, value); + } + remove + { + mChangeEnchantments = (EventHandler)Delegate.Remove(mChangeEnchantments, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeExperience + { + add + { + mChangeExperience = (EventHandler)Delegate.Combine(mChangeExperience, value); + } + remove + { + mChangeExperience = (EventHandler)Delegate.Remove(mChangeExperience, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeVital + { + add + { + mChangeVital = (EventHandler)Delegate.Combine(mChangeVital, value); + } + remove + { + mChangeVital = (EventHandler)Delegate.Remove(mChangeVital, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeSpellbar + { + add + { + mChangeSpellbar = (EventHandler)Delegate.Combine(mChangeSpellbar, value); + } + remove + { + mChangeSpellbar = (EventHandler)Delegate.Remove(mChangeSpellbar, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeShortcut + { + add + { + mChangeShortcut = (EventHandler)Delegate.Combine(mChangeShortcut, value); + } + remove + { + mChangeShortcut = (EventHandler)Delegate.Remove(mChangeShortcut, value); + } + } + + [CLSCompliant(false)] + public event EventHandler Login + { + add + { + mLogin = (EventHandler)Delegate.Combine(mLogin, value); + } + remove + { + mLogin = (EventHandler)Delegate.Remove(mLogin, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeSettings + { + add + { + mChangeSettings = (EventHandler)Delegate.Combine(mChangeSettings, value); + } + remove + { + mChangeSettings = (EventHandler)Delegate.Remove(mChangeSettings, value); + } + } + + public event EventHandler ChangeSettingsFlags + { + add + { + mChangeSettingsFlags = (EventHandler)Delegate.Combine(mChangeSettingsFlags, value); + } + remove + { + mChangeSettingsFlags = (EventHandler)Delegate.Remove(mChangeSettingsFlags, value); + } + } + + public event EventHandler ChangeOption + { + add + { + mChangeOption = (EventHandler)Delegate.Combine(mChangeOption, value); + } + remove + { + mChangeOption = (EventHandler)Delegate.Remove(mChangeOption, value); + } + } + + [CLSCompliant(false)] + public event EventHandler Logoff + { + add + { + mLogoff = (EventHandler)Delegate.Combine(mLogoff, value); + } + remove + { + mLogoff = (EventHandler)Delegate.Remove(mLogoff, value); + } + } + + [CLSCompliant(false)] + public event EventHandler SpellCast + { + add + { + mSpellCast = (EventHandler)Delegate.Combine(mSpellCast, value); + } + remove + { + mSpellCast = (EventHandler)Delegate.Remove(mSpellCast, value); + } + } + + [CLSCompliant(false)] + public event EventHandler StatusMessage + { + add + { + mStatusMessage = (EventHandler)Delegate.Combine(mStatusMessage, value); + } + remove + { + mStatusMessage = (EventHandler)Delegate.Remove(mStatusMessage, value); + } + } + + public CharacterFilter(CharacterStats obj) + : base(obj) + { + base.Wrapped.CastSpell += myCS_CastSpell; + base.Wrapped.ChangeEnchantments += myCS_ChangeEnchantments; + base.Wrapped.ChangeFellowship += myCS_ChangeFellowship; + base.Wrapped.ChangePlayer += myCS_ChangePlayer; + base.Wrapped.ChangePortalMode += myCS_ChangePortalMode; + base.Wrapped.ChangeSettings += myCS_ChangeSettings; + base.Wrapped.ChangeShortcut += myCS_ChangeShortcut; + base.Wrapped.ChangeSpellbar += myCS_ChangeSpellbar; + base.Wrapped.ChangeVital += myCS_ChangeVital; + base.Wrapped.ChangeXPS += myCS_ChangeXPS; + base.Wrapped.Death += myCS_Death; + base.Wrapped.ActionComplete += myCS_ActionComplete; + base.Wrapped.Login += myCS_Login; + base.Wrapped.LoginComplete += myCS_LoginComplete; + base.Wrapped.Logoff += myCS_Logoff; + base.Wrapped.Spellbook_Add += myCS_Spellbook_Add; + base.Wrapped.Spellbook_Delete += myCS_Spellbook_Delete; + base.Wrapped.StatusMessage += myCS_StatusMessage; + base.Wrapped.ChangeSettingFlags += myCS_ChangeSettingFlags; + base.Wrapped.ChangeOption += myCS_ChangeOption; + Reset(createNew: true); + } + + protected override void Dispose(bool userCalled) + { + if (userCalled) + { + if (base.Wrapped != null) + { + base.Wrapped.CastSpell -= myCS_CastSpell; + base.Wrapped.ChangeEnchantments -= myCS_ChangeEnchantments; + base.Wrapped.ChangeFellowship -= myCS_ChangeFellowship; + base.Wrapped.ChangePlayer -= myCS_ChangePlayer; + base.Wrapped.ChangePortalMode -= myCS_ChangePortalMode; + base.Wrapped.ChangeSettings -= myCS_ChangeSettings; + base.Wrapped.ChangeShortcut -= myCS_ChangeShortcut; + base.Wrapped.ChangeSpellbar -= myCS_ChangeSpellbar; + base.Wrapped.ChangeVital -= myCS_ChangeVital; + base.Wrapped.ChangeXPS -= myCS_ChangeXPS; + base.Wrapped.Death -= myCS_Death; + base.Wrapped.ActionComplete -= myCS_ActionComplete; + base.Wrapped.Login -= myCS_Login; + base.Wrapped.LoginComplete -= myCS_LoginComplete; + base.Wrapped.Logoff -= myCS_Logoff; + base.Wrapped.Spellbook_Add -= myCS_Spellbook_Add; + base.Wrapped.Spellbook_Delete -= myCS_Spellbook_Delete; + base.Wrapped.StatusMessage -= myCS_StatusMessage; + } + Reset(createNew: false); + } + base.Dispose(userCalled); + } + + object IIndexedProvider.GetIndexedObject(CharFilterIndex objectIndex, int index) + { + EnforceDisposedOnce(); + object result = null; + switch (objectIndex) + { + case CharFilterIndex.Vassals: + { + if (index >= base.Wrapped.VassalCount) + { + throw new IndexOutOfRangeException("Requested Vassal " + index + " doesn't exist"); + } + string key = "Vassal" + index; + AllegianceInfoWrapper value3 = null; + if (allegianceData.TryGetValue(key, out value3)) + { + allegianceData.Remove(key); + value3?.Dispose(); + } + value3 = new AllegianceInfoWrapper(((ICharacterStats)base.Wrapped).get_Vassal(index)); + allegianceData.Add(key, value3); + return value3; + } + case CharFilterIndex.Enchantments: + { + if (index >= base.Wrapped.EnchantmentCount) + { + throw new IndexOutOfRangeException("Requested Enchantment " + index + " doesn't exist"); + } + string key = "Enchant-" + index; + EnchantmentWrapper value4 = null; + if (enchantmentData.TryGetValue(key, out value4)) + { + enchantmentData.Remove(key); + value4?.Dispose(); + } + value4 = new EnchantmentWrapper(((ICharacterStats)base.Wrapped).get_Enchantment(index)); + enchantmentData.Add(key, value4); + return value4; + } + case CharFilterIndex.Characters: + if (index >= base.Wrapped.AccountCharCount) + { + throw new IndexOutOfRangeException("Requested Character " + index + " doesn't exist"); + } + return new AccountCharInfo(this, index); + case CharFilterIndex.Vitals: + { + if (!Enum.IsDefined(typeof(eVitalID), index)) + { + throw new IndexOutOfRangeException("Requested Vital " + index + " doesn't exist"); + } + string key = "Vital-" + index; + SkillInfoWrapper value5 = null; + if (vitalSkillData.TryGetValue(key, out value5)) + { + vitalSkillData.Remove(key); + value5?.Dispose(); + } + value5 = new SkillInfoWrapper(((ICharacterStats)base.Wrapped).get_Vital((eVitalID)index)); + vitalSkillData.Add(key, value5); + return value5; + } + case CharFilterIndex.Attributes: + { + if (!Enum.IsDefined(typeof(eAttributeID), index)) + { + throw new IndexOutOfRangeException("Requested Attribute " + index + " doesn't exist"); + } + string key = "Attribute-" + index; + AttributeInfoWrapper value2 = null; + if (attributeData.TryGetValue(key, out value2)) + { + attributeData.Remove(key); + value2?.Dispose(); + } + value2 = new AttributeInfoWrapper(((ICharacterStats)base.Wrapped).get_Attribute((eAttributeID)index)); + attributeData.Add(key, value2); + return value2; + } + case CharFilterIndex.Skills: + { + if (!Enum.IsDefined(typeof(CharFilterSkillType), index)) + { + throw new IndexOutOfRangeException("Requested Skill " + index + " doesn't exist"); + } + string key = "Skill-" + index; + SkillInfoWrapper value = null; + if (vitalSkillData.TryGetValue(key, out value)) + { + vitalSkillData.Remove(key); + value?.Dispose(); + } + value = new SkillInfoWrapper(((ICharacterStats)base.Wrapped).get_Skill((eSkillID)index)); + vitalSkillData.Add(key, value); + return value; + } + case CharFilterIndex.EffectiveAttributes: + return ((ICharacterStats)base.Wrapped).get_EffectiveAttribute((eAttributeID)index); + case CharFilterIndex.EffectiveSkills: + return ((ICharacterStats)base.Wrapped).get_EffectiveSkill((eSkillID)index); + case CharFilterIndex.EffectiveVitals: + return ((ICharacterStats)base.Wrapped).get_EffectiveVital((eVitalID)index); + default: + return result; + } + } + + IEnumerator IIndexedProvider.GetEnumerator(CharFilterIndex objectIndex) + { + EnforceDisposedOnce(); + return objectIndex switch + { + CharFilterIndex.Vassals => VassalEnum(), + CharFilterIndex.Enchantments => EnchantmentEnum(), + CharFilterIndex.Vitals => VitalEnum(), + CharFilterIndex.Attributes => AttributeEnum(), + CharFilterIndex.Skills => SkillEnum(), + _ => null, + }; + } + + private IEnumerator VassalEnum() + { + int vassalCount = base.Wrapped.VassalCount; + for (int x = 0; x < vassalCount; x++) + { + yield return Vassals[x]; + } + } + + private IEnumerator EnchantmentEnum() + { + int enchantCount = base.Wrapped.EnchantmentCount; + for (int x = 0; x < enchantCount; x++) + { + yield return Enchantments[x]; + } + } + + private IEnumerator VitalEnum() + { + for (int x = 2; x <= 6; x += 2) + { + yield return Vitals[(CharFilterVitalType)x]; + } + } + + private IEnumerator AttributeEnum() + { + int AttributeCount = base.Wrapped.AttributeCount; + int x = 1; + while (x <= AttributeCount) + { + yield return Attributes[(CharFilterAttributeType)x]; + int num = x + 1; + x = num; + } + } + + private IEnumerator SkillEnum() + { + _ = base.Wrapped.SkillCount; + foreach (int value in Enum.GetValues(typeof(CharFilterSkillType))) + { + yield return Skills[(CharFilterSkillType)value]; + } + } + + int IIndexedProvider.Count(CharFilterIndex objectIndex) + { + EnforceDisposedOnce(); + return objectIndex switch + { + CharFilterIndex.Vassals => base.Wrapped.VassalCount, + CharFilterIndex.Enchantments => base.Wrapped.EnchantmentCount, + CharFilterIndex.Vitals => 3, + CharFilterIndex.Attributes => base.Wrapped.AttributeCount, + CharFilterIndex.Skills => base.Wrapped.SkillCount, + CharFilterIndex.Characters => base.Wrapped.AccountCharCount, + CharFilterIndex.Spells => base.Wrapped.TotalSpells, + CharFilterIndex.Augmentations => base.Wrapped.AugmentationCount(), + CharFilterIndex.EffectiveAttributes => base.Wrapped.AttributeCount, + CharFilterIndex.EffectiveSkills => base.Wrapped.SkillCount, + CharFilterIndex.EffectiveVitals => 3, + _ => 0, + }; + } + + private void myCS_StatusMessage(int type, string text) + { + Util.SafeFireEvent(this, mStatusMessage, new StatusMessageEventArgs(type, text)); + } + + private void myCS_Spellbook_Delete(int spellDeleted) + { + if (mySpellBook != null) + { + mySpellBook.Remove(spellDeleted); + } + Util.SafeFireEvent(this, mSpellbookChange, new SpellbookEventArgs(AddRemoveEventType.Delete, spellDeleted)); + } + + private void myCS_Spellbook_Add(int spellAdded) + { + if (mySpellBook != null) + { + mySpellBook.Add(spellAdded); + } + Util.SafeFireEvent(this, mSpellbookChange, new SpellbookEventArgs(AddRemoveEventType.Add, spellAdded)); + } + + private void myCS_Logoff(PlayerLogoffType type) + { + Util.SafeFireEvent(this, mLogoff, new LogoffEventArgs((LogoffEventType)type)); + Reset(createNew: true); + } + + private void myCS_LoginComplete() + { + Util.SafeFireEvent(this, mLoginComplete, new EventArgs()); + } + + private void myCS_Login(int character) + { + Util.SafeFireEvent(this, mLogin, new LoginEventArgs(character)); + } + + private void myCS_Death(string text) + { + Util.SafeFireEvent(this, mDeath, new DeathEventArgs(text)); + } + + private void myCS_ChangeXPS(PlayerXPType change, int amount) + { + Util.SafeFireEvent(this, mChangeExperience, new ChangeExperienceEventArgs((PlayerXPEventType)change, amount)); + } + + private void myCS_ChangeVital(PlayerVitalType change, int amount) + { + Util.SafeFireEvent(this, mChangeVital, new ChangeVitalEventArgs((CharFilterVitalType)change, amount)); + } + + private void myCS_ChangeSpellbar(PlayerAddRemoveType Change, int Tab, int Slot, int SpellID) + { + if (mySpellBars != null && mySpellBars.ContainsKey(Tab)) + { + mySpellBars.Remove(Tab); + } + Util.SafeFireEvent(this, mChangeSpellbar, new ChangeSpellbarEventArgs((AddRemoveEventType)Change, Tab, Slot, SpellID)); + } + + private void myCS_ChangeShortcut(PlayerAddRemoveType Change, int Slot, int ObjectID) + { + Util.SafeFireEvent(this, mChangeShortcut, new ChangeShortcutEventArgs((AddRemoveEventType)Change, Slot, ObjectID)); + } + + private void myCS_ChangeSettings(int Settings) + { + Util.SafeFireEvent(this, mChangeSettings, new SettingsEventArgs(Settings)); + } + + private void myCS_ChangePortalMode(PlayerPortalType Change) + { + Util.SafeFireEvent(this, mChangePortalMode, new ChangePortalModeEventArgs((PortalEventType)Change)); + } + + private void myCS_ChangePlayer(PlayerModifyType Change, int StatID) + { + if (Change == PlayerModifyType.pevtAugmentation && myAugmentations != null) + { + myAugmentations = null; + } + Util.SafeFireEvent(this, mChangePlayer, new ChangePlayerEventArgs((PlayerModifyEventType)Change, StatID)); + } + + private void myCS_ChangeFellowship(PlayerFellowshipType Change, int Character) + { + Util.SafeFireEvent(this, mChangeFellowship, new ChangeFellowshipEventArgs((FellowshipEventType)Change, Character)); + } + + private void myCS_ChangeEnchantments(PlayerAddRemoveType Change, Enchantment Enchantment) + { + using EnchantmentWrapper enchantment = new EnchantmentWrapper(Enchantment); + Util.SafeFireEvent(this, mChangeEnchantments, new ChangeEnchantmentsEventArgs((AddRemoveEventType)Change, enchantment)); + } + + private void myCS_ActionComplete() + { + Util.SafeFireEvent(this, mActionComplete, new EventArgs()); + } + + private void myCS_CastSpell(PlayerCastType Type, int SpellID, int TargetID) + { + Util.SafeFireEvent(this, mSpellCast, new SpellCastEventArgs((CastEventType)Type, SpellID, TargetID)); + } + + private void myCS_ChangeOption(int key, int value) + { + Util.SafeFireEvent(this, mChangeOption, new ChangeOptionEventArgs(key, value)); + } + + private void myCS_ChangeSettingFlags(int Settings) + { + Util.SafeFireEvent(this, mChangeSettingsFlags, new ChangeSettingsFlagsEventArgs(Settings)); + } + + private void Reset(bool createNew) + { + if (allegianceData != null) + { + foreach (KeyValuePair allegianceDatum in allegianceData) + { + if (allegianceDatum.Value != null) + { + allegianceDatum.Value.Dispose(); + } + } + } + if (enchantmentData != null) + { + foreach (KeyValuePair enchantmentDatum in enchantmentData) + { + if (enchantmentDatum.Value != null) + { + enchantmentDatum.Value.Dispose(); + } + } + } + if (vitalSkillData != null) + { + foreach (KeyValuePair vitalSkillDatum in vitalSkillData) + { + if (vitalSkillDatum.Value != null) + { + vitalSkillDatum.Value.Dispose(); + } + } + } + if (attributeData != null) + { + foreach (KeyValuePair attributeDatum in attributeData) + { + if (attributeDatum.Value != null) + { + attributeDatum.Value.Dispose(); + } + } + } + mySpellBook = null; + if (createNew) + { + mySpellBars = new Dictionary>(); + allegianceData = new Dictionary(); + enchantmentData = new Dictionary(); + vitalSkillData = new Dictionary(); + attributeData = new Dictionary(); + } + } + + internal int get_AccountCharID(int index) + { + EnforceDisposedOnce(); + return ((ICharacterStats)base.Wrapped).get_AccountCharID(index); + } + + internal string get_AccountCharName(int index) + { + EnforceDisposedOnce(); + return ((ICharacterStats)base.Wrapped).get_AccountCharName(index); + } + + public int Shortcut(int slot) + { + return ((ICharacterStats)base.Wrapped).get_Quickslots(slot); + } + + public bool IsSpellKnown(int spellId) + { + if (((ICharacterStats)base.Wrapped).get_SpellLearned(spellId) != 0) + { + return true; + } + return false; + } + + public int GetCharProperty(int key) + { + int pValue = 0; + if (base.Wrapped.AugmentationExists((eAugmentations)key, out pValue)) + { + return pValue; + } + return 0; + } + + public ReadOnlyCollection SpellBar(int barNumber) + { + EnforceDisposedOnce(); + if (barNumber < 0 || barNumber > 6) + { + throw new ArgumentOutOfRangeException("barNumber", barNumber, "barNumber must be between 0 and 6 inclusive"); + } + if (mySpellBars == null) + { + mySpellBars = new Dictionary>(); + } + if (!mySpellBars.ContainsKey(barNumber)) + { + mySpellBars.Add(barNumber, new ReadOnlyCollection(base.Wrapped.SpellBarArray(barNumber))); + } + return mySpellBars[barNumber]; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/CheckBoxWrapper.cs b/Unused/Decal.Adapter.Wrappers/CheckBoxWrapper.cs new file mode 100644 index 0000000..1ee97ee --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CheckBoxWrapper.cs @@ -0,0 +1,135 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class CheckBoxWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + private EventHandler evtChange; + + public bool Checked + { + get + { + return base.Control.Checked; + } + set + { + base.Control.Checked = value; + } + } + + public bool RightToLeft + { + get + { + return base.Control.RightToLeft; + } + set + { + base.Control.RightToLeft = value; + } + } + + public string Text + { + get + { + return base.Control.Text; + } + set + { + base.Control.Text = value; + } + } + + public Color TextColor + { + get + { + return Util.ColorFromBGR(base.Control.TextColor); + } + set + { + base.Control.TextColor = Util.ColorToBGR(value); + } + } + + public event EventHandler Change + { + add + { + if (evtChange == null) + { + base.Control.Change += ChangeEvent; + } + evtChange = (EventHandler)Delegate.Combine(evtChange, value); + } + remove + { + evtChange = (EventHandler)Delegate.Remove(evtChange, value); + if (evtChange == null) + { + base.Control.Change -= ChangeEvent; + } + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtChange != null) + { + evtChange = (EventHandler)Delegate.Remove(evtChange, evtChange); + base.Control.Change -= ChangeEvent; + } + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + } + base.Dispose(disposing); + } + + private void ChangeEvent(int ID, bool Checked) + { + if (evtChange != null) + { + evtChange(this, new CheckBoxChangeEventArgs(ID, Checked)); + } + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChoiceDataIndexer.cs b/Unused/Decal.Adapter.Wrappers/ChoiceDataIndexer.cs new file mode 100644 index 0000000..34f6323 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChoiceDataIndexer.cs @@ -0,0 +1,33 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public sealed class ChoiceDataIndexer : IDisposable +{ + private Choice myControl; + + public object this[int index] + { + get + { + return ((IChoice)myControl).get_Data(index); + } + set + { + ((IChoice)myControl).set_Data(index, value); + } + } + + internal ChoiceDataIndexer(Choice control) + { + myControl = control; + } + + public void Dispose() + { + Marshal.ReleaseComObject(myControl); + myControl = null; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChoiceTextIndexer.cs b/Unused/Decal.Adapter.Wrappers/ChoiceTextIndexer.cs new file mode 100644 index 0000000..ab9df86 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChoiceTextIndexer.cs @@ -0,0 +1,31 @@ +using System; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public sealed class ChoiceTextIndexer : IDisposable +{ + private Choice myControl; + + public string this[int index] + { + get + { + return ((IChoice)myControl).get_Text(index); + } + set + { + ((IChoice)myControl).set_Text(index, value); + } + } + + internal ChoiceTextIndexer(Choice control) + { + myControl = control; + } + + public void Dispose() + { + myControl = null; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ChoiceWrapper.cs b/Unused/Decal.Adapter.Wrappers/ChoiceWrapper.cs new file mode 100644 index 0000000..bfc7187 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ChoiceWrapper.cs @@ -0,0 +1,191 @@ +using System; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class ChoiceWrapper : ControlWrapperBase +{ + private EventHandler evtDropDown; + + private EventHandler evtDestroy; + + private EventHandler evtChange; + + private ChoiceTextIndexer myTextIndex; + + private ChoiceDataIndexer myDataIndex; + + public int Count => base.Control.ChoiceCount; + + public int DropLines + { + get + { + return base.Control.DropLines; + } + set + { + base.Control.DropLines = value; + } + } + + public bool Dropped + { + get + { + return base.Control.Dropped; + } + set + { + base.Control.Dropped = value; + } + } + + public int Selected + { + get + { + return base.Control.Selected; + } + set + { + base.Control.Selected = value; + } + } + + public ChoiceTextIndexer Text => myTextIndex; + + public ChoiceDataIndexer Data => myDataIndex; + + public event EventHandler DropDown + { + add + { + if (evtDropDown == null) + { + base.Control.DropDown += DropDownEvent; + } + evtDropDown = (EventHandler)Delegate.Combine(evtDropDown, value); + } + remove + { + evtDropDown = (EventHandler)Delegate.Remove(evtDropDown, value); + if (evtDropDown == null) + { + base.Control.DropDown -= DropDownEvent; + } + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Change + { + add + { + if (evtChange == null) + { + base.Control.Change += ChangeEvent; + } + evtChange = (EventHandler)Delegate.Combine(evtChange, value); + } + remove + { + evtChange = (EventHandler)Delegate.Remove(evtChange, value); + if (evtChange == null) + { + base.Control.Change -= ChangeEvent; + } + } + } + + [CLSCompliant(false)] + public override void Initialize(object control) + { + base.Initialize(control); + myTextIndex = new ChoiceTextIndexer(base.Control); + myDataIndex = new ChoiceDataIndexer(base.Control); + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtDropDown != null) + { + evtDropDown = (EventHandler)Delegate.Remove(evtDropDown, evtDropDown); + base.Control.DropDown -= DropDownEvent; + } + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtChange != null) + { + evtChange = (EventHandler)Delegate.Remove(evtChange, evtChange); + base.Control.Change -= ChangeEvent; + } + myTextIndex.Dispose(); + myDataIndex.Dispose(); + } + base.Dispose(disposing); + } + + public void Add(string display, object data) + { + base.Control.AddChoice(display, data); + } + + public void Clear() + { + base.Control.Clear(); + } + + public void Remove(int index) + { + base.Control.RemoveChoice(index); + } + + private void DropDownEvent(int ID) + { + if (evtDropDown != null) + { + evtDropDown(this, new ControlEventArgs(ID)); + } + } + + private void ChangeEvent(int ID, int Index) + { + if (evtChange != null) + { + evtChange(this, new IndexChangeEventArgs(ID, Index)); + } + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/CombatState.cs b/Unused/Decal.Adapter.Wrappers/CombatState.cs new file mode 100644 index 0000000..91e14fa --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CombatState.cs @@ -0,0 +1,12 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum CombatState +{ + Peace = 1, + Melee = 2, + Missile = 4, + Magic = 8 +} diff --git a/Unused/Decal.Adapter.Wrappers/ControlRegistry.cs b/Unused/Decal.Adapter.Wrappers/ControlRegistry.cs new file mode 100644 index 0000000..035e88c --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ControlRegistry.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using Decal.Adapter.Support; +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +/// +/// Used for the registration and creation of control wrappers +/// +public static class ControlRegistry +{ + private static Dictionary myWrappers; + + static ControlRegistry() + { + if (myWrappers == null) + { + myWrappers = new Dictionary(); + RegisterControls(Assembly.GetExecutingAssembly()); + } + } + + /// + /// Scans an assembly and registers all of its control wrappers + /// + /// the assembly to scan + public static void RegisterControls(Assembly assembly) + { + Type[] types = assembly.GetTypes(); + foreach (Type type in types) + { + try + { + Type baseType = type.BaseType; + if (!(baseType == null) && baseType.IsGenericType && baseType.GetGenericTypeDefinition() == typeof(ControlWrapperBase<>)) + { + Type key = baseType.GetGenericArguments()[0]; + myWrappers.Add(key, type); + } + } + catch (Exception ex) + { + Util.WriteLine("RegisterControls: " + ex.Message); + } + } + } + + /// + /// Creates a control wrapper for the passed in control + /// + /// the control to wrap + /// the new wrapper + internal static IControlWrapper CreateInstance(IControl control) + { + Util.WriteLine("Creating wrapper for: " + control.GetType()); + Type value; + IControlWrapper controlWrapper = ((!myWrappers.TryGetValue(control.GetType(), out value)) ? new ControlWrapper() : ((IControlWrapper)Activator.CreateInstance(value))); + controlWrapper.Initialize(control); + return controlWrapper; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ControlWrapper.cs b/Unused/Decal.Adapter.Wrappers/ControlWrapper.cs new file mode 100644 index 0000000..2f32092 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ControlWrapper.cs @@ -0,0 +1,7 @@ +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +public class ControlWrapper : ControlWrapperBase +{ +} diff --git a/Unused/Decal.Adapter.Wrappers/ControlWrapperBase.cs b/Unused/Decal.Adapter.Wrappers/ControlWrapperBase.cs new file mode 100644 index 0000000..1b7844d --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ControlWrapperBase.cs @@ -0,0 +1,66 @@ +using System; +using System.ComponentModel; +using System.Runtime.InteropServices; +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +public abstract class ControlWrapperBase : MarshalByRefObject, IControlWrapper, IDisposable where T : class +{ + private T myControl; + + private bool isDisposed; + + [EditorBrowsable(EditorBrowsableState.Never)] + public object Underlying => myControl; + + public int Id => ((IControl)myControl).ID; + + public int ChildCount => ((IControl)myControl).ChildCount; + + protected bool Disposed => isDisposed; + + protected T Control => myControl; + + ~ControlWrapperBase() + { + Dispose(disposing: false); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public virtual void Initialize(object control) + { + myControl = control as T; + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public object ChildById(int id) + { + return ((IControl)myControl).get_Child(id, ePositionType.ePositionByID); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public object ChildByIndex(int index) + { + return ((IControl)myControl).get_Child(index, ePositionType.ePositionByIndex); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myControl != null) + { + Marshal.ReleaseComObject(myControl); + myControl = null; + } + isDisposed = true; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/CoordsObject.cs b/Unused/Decal.Adapter.Wrappers/CoordsObject.cs new file mode 100644 index 0000000..ae19978 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CoordsObject.cs @@ -0,0 +1,149 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class CoordsObject +{ + private double myNorthSouth; + + private double myEastWest; + + /// + /// The north or south component of these coordinates. North is + /// positive and south is negative. + /// + public double NorthSouth => myNorthSouth; + + /// + /// The east or west component of these coordinates. East is positive + /// and west is negative. + /// + public double EastWest => myEastWest; + + public CoordsObject(double northSouth, double eastWest) + { + myNorthSouth = northSouth; + myEastWest = eastWest; + } + + /// + /// Calculates the straight-line distance between these coordinates + /// and the given coordinates. + /// + /// The coordinates to calculate the + /// distance to. + /// The distance between these coordinates and the given + /// coordinates. + public double DistanceToCoords(CoordsObject destination) + { + if (destination == null) + { + throw new ArgumentNullException("destination"); + } + double num = myNorthSouth - destination.myNorthSouth; + double num2 = myEastWest - destination.myEastWest; + return Math.Sqrt(num * num + num2 * num2); + } + + /// + /// Calculates the angle from these coordinates to the given + /// coordinates, in degrees. North is 0, east is 90, south is 180, + /// and west is 270. + /// + /// The coordinates to calculate the + /// angle to. + /// The angle between these coordinates and the given + /// coordinates. + public double AngleToCoords(CoordsObject destination) + { + return 180.0 / Math.PI * AngleToCoordsRadians(destination); + } + + /// + /// Calculates the angle from these coordinates to the given + /// coordinates, in radians. North is 0, east is pi/2, south is pi, + /// and west is 3*pi/2. + /// + /// + /// + public double AngleToCoordsRadians(CoordsObject destination) + { + if (destination == null) + { + throw new ArgumentNullException("destination"); + } + double num = Math.Atan2(destination.myEastWest - myEastWest, destination.myNorthSouth - myNorthSouth); + if (num < 0.0) + { + num += Math.PI * 2.0; + } + return num; + } + + /// Formats the coordinates like "0.0N, 0.0E" + /// The formatted coordinate string. + public override string ToString() + { + return ToString("0.0"); + } + + /// + /// Formats the coordinates using the number style you choose to + /// format the NorthSouth and EastWest numbers. + /// + /// The format for the NorthSouth and + /// EastWest numbers. This can be any format string used by + /// double.ToString(). E.g., use "0.00" for 2-digit precision on + /// the coordinates. + /// The formatted coordinate string. + public string ToString(string numberFormat) + { + return Math.Abs(myNorthSouth).ToString(numberFormat) + ((myNorthSouth >= 0.0) ? "N" : "S") + ", " + Math.Abs(myEastWest).ToString(numberFormat) + ((myEastWest >= 0.0) ? "E" : "W"); + } + + public override bool Equals(object obj) + { + if (obj is CoordsObject) + { + CoordsObject coordsObject = (CoordsObject)obj; + if (coordsObject.myNorthSouth == myNorthSouth) + { + return coordsObject.myEastWest == myEastWest; + } + return false; + } + return false; + } + + public bool Equals(CoordsObject obj) + { + if (obj == null) + { + return false; + } + if (obj.myNorthSouth == myNorthSouth) + { + return obj.myEastWest == myEastWest; + } + return false; + } + + public override int GetHashCode() + { + return myNorthSouth.GetHashCode() ^ myEastWest.GetHashCode(); + } + + public static bool operator ==(CoordsObject a, CoordsObject b) + { + if (object.Equals(a, null)) + { + return object.Equals(b, null); + } + return a.Equals(b); + } + + public static bool operator !=(CoordsObject a, CoordsObject b) + { + return !(a == b); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/CreateObjectEventArgs.cs b/Unused/Decal.Adapter.Wrappers/CreateObjectEventArgs.cs new file mode 100644 index 0000000..12d221f --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/CreateObjectEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class CreateObjectEventArgs : EventArgs +{ + private WorldObject myNewObject; + + public WorldObject New => myNewObject; + + internal CreateObjectEventArgs(WorldObject newObject) + { + myNewObject = newObject; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/D3DObj.cs b/Unused/Decal.Adapter.Wrappers/D3DObj.cs new file mode 100644 index 0000000..83b4116 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/D3DObj.cs @@ -0,0 +1,414 @@ +using Decal.Interop.D3DService; + +namespace Decal.Adapter.Wrappers; + +public class D3DObj : GenericDisposableWrapper +{ + /// + /// Colors + /// + public int Color + { + get + { + return base.Wrapped.color; + } + set + { + base.Wrapped.color = value; + } + } + + public int Color2 + { + get + { + return base.Wrapped.color2; + } + set + { + base.Wrapped.color2 = value; + } + } + + /// + /// Autoscale + /// + public bool Autoscale + { + get + { + return base.Wrapped.autoscale; + } + set + { + base.Wrapped.autoscale = value; + } + } + + /// + /// DrawBackface + /// + public bool DrawBackface + { + get + { + return base.Wrapped.drawBackface; + } + set + { + base.Wrapped.drawBackface = value; + } + } + + /// + /// HBounce + /// + public float HBounce + { + get + { + return base.Wrapped.hBounce; + } + set + { + base.Wrapped.hBounce = value; + } + } + + /// + /// PBounce + /// + public float PBounce + { + get + { + return base.Wrapped.pBounce; + } + set + { + base.Wrapped.pBounce = value; + } + } + + /// + /// PFade + /// + public float PFade + { + get + { + return base.Wrapped.pFade; + } + set + { + base.Wrapped.pFade = value; + } + } + + /// + /// POrbit + /// + public float POrbit + { + get + { + return base.Wrapped.pOrbit; + } + set + { + base.Wrapped.pOrbit = value; + } + } + + /// + /// PSpin + /// + public float PSpin + { + get + { + return base.Wrapped.pSpin; + } + set + { + base.Wrapped.pSpin = value; + } + } + + /// + /// ROrbit + /// + public float ROrbit + { + get + { + return base.Wrapped.rOrbit; + } + set + { + base.Wrapped.rOrbit = value; + } + } + + /// + /// ScaleX + /// + public float ScaleX + { + get + { + return base.Wrapped.scaleX; + } + set + { + base.Wrapped.scaleX = value; + } + } + + /// + /// ScaleY + /// + public float ScaleY + { + get + { + return base.Wrapped.scaleY; + } + set + { + base.Wrapped.scaleY = value; + } + } + + /// + /// ScaleZ + /// + public float ScaleZ + { + get + { + return base.Wrapped.scaleZ; + } + set + { + base.Wrapped.scaleZ = value; + } + } + + /// + /// Visible + /// + public bool Visible + { + get + { + return base.Wrapped.visible; + } + set + { + base.Wrapped.visible = value; + } + } + + /// + /// AnimationPhaseOffset + /// + public float AnimationPhaseOffset + { + get + { + return base.Wrapped.AnimationPhaseOffset; + } + set + { + base.Wrapped.AnimationPhaseOffset = value; + } + } + + public D3DObj(CD3DObj obj) + : base(obj) + { + } + + protected override void Dispose(bool userCalled) + { + base.Dispose(userCalled); + } + + public void Scale(float factor) + { + base.Wrapped.SetScale(factor); + } + + /// + /// Orients to the Camera + /// + /// Vertical Tilt + public void OrientToCamera(bool verticalTilt) + { + base.Wrapped.OrientToCamera(verticalTilt); + } + + /// + /// Orients to the specified Coordinates + /// + /// Latitude + /// Longitude + /// Altitude + /// Vertical Tilt + public void OrientToCoords(float lat, float lng, float alt, bool verticalTilt) + { + base.Wrapped.OrientToCoords(lat, lng, alt, verticalTilt); + } + + /// + /// Orients to the specified Object + /// + /// Object ID + /// Relative Position + /// Vertical Tilt + public void OrientToObject(int guid, float fractHeight, bool verticalTilt) + { + base.Wrapped.OrientToObject(guid, fractHeight, verticalTilt); + } + + /// + /// Orients to the Current Player + /// + /// Vertical Tilt + public void OrientToPlayer(bool verticalTilt) + { + base.Wrapped.OrientToPlayer(verticalTilt); + } + + /// + /// Anchors to the specified Coordinates + /// + /// Latitude + /// Longitude + /// Altitude + public void Anchor(float lat, float lng, float alt) + { + base.Wrapped.AnchorToCoords(lat, lng, alt); + } + + /// + /// Anchors to the specified Object + /// + /// Object ID + /// Height + /// x offset + /// y offset + /// z offset + public void Anchor(int id, float height, float dx, float dy, float dz) + { + base.Wrapped.AnchorToObject(id, height, dx, dy, dz); + } + + /// + /// Displays 2D text using the Arial font + /// + /// Text to display + public void SetText(string text) + { + SetText(D3DTextType.Text2D, text, "Arial", 0); + } + + /// + /// Displays 2D text using the specified font + /// + /// Text to display + /// Font to use + public void SetText(string text, string fontName) + { + SetText(D3DTextType.Text2D, text, fontName, 0); + } + + /// + /// Displays 2D text using the specified font and options + /// + /// Text to display + /// Font to use + /// Options + public void SetText(string text, string fontName, int options) + { + SetText(D3DTextType.Text2D, text, fontName, options); + } + + /// + /// Displays text + /// + /// Type of text (2D/3D) + /// Text to display + /// Font to use + /// Options + public void SetText(D3DTextType type, string text, string fontName, int options) + { + switch (type) + { + case D3DTextType.Text2D: + base.Wrapped.Set2DText(text, fontName, options); + break; + case D3DTextType.Text3D: + base.Wrapped.Set3DText(text, fontName, options); + break; + } + } + + /// + /// Sets the icon to the portal file id + /// + /// portal file id + public void SetIcon(int id) + { + base.Wrapped.SetIcon(id); + } + + /// + /// Sets the icon from the specified file + /// + /// file containing the icon + public void SetIcon(string fileName) + { + base.Wrapped.SetIconFromFile(fileName); + } + + /// + /// Sets the icon from a resource dll + /// + /// module handle of the dll + /// resource id + public void SetIcon(int module, int res) + { + base.Wrapped.SetIconFromResource(module, res); + } + + /// + /// Sets the shape to that specified + /// + /// Shape to use + public void SetShape(D3DShape shape) + { + base.Wrapped.SetShape((eShape)shape); + } + + /// + /// Sets the shape to that contained in the file + /// + /// File containing the shape definition + public void SetShape(string fileName) + { + base.Wrapped.SetShapeFromFile(fileName); + } + + /// + /// Sets the shape from a resource dll + /// + /// module handle of the dll + /// resource id + public void SetShape(int module, int res) + { + base.Wrapped.SetShapeFromResource(module, res); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/D3DService.cs b/Unused/Decal.Adapter.Wrappers/D3DService.cs new file mode 100644 index 0000000..68d6162 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/D3DService.cs @@ -0,0 +1,180 @@ +using Decal.Interop.D3DService; + +namespace Decal.Adapter.Wrappers; + +public class D3DService : GenericDisposableWrapper +{ + internal D3DService(CService obj) + : base(obj) + { + } + + protected override void Dispose(bool userCalled) + { + base.Dispose(userCalled); + } + + /// + /// Makes a new D3DObj + /// + public D3DObj NewD3DObj() + { + return new D3DObj(base.Wrapped.NewD3DObj()); + } + + /// + /// Creates an arrow that points to an object + /// + /// Object ID + /// Color + public D3DObj PointToObject(int guid, int color) + { + return new D3DObj(base.Wrapped.PointToObject(guid, color)); + } + + /// + /// Creates an arrow that points to specified Coordinates + /// + /// Latitude + /// Longitude + /// Altitude + /// Color + public D3DObj PointToCoords(float lat, float lng, float alt, int color) + { + return new D3DObj(base.Wrapped.PointToCoords(lat, lng, alt, color)); + } + + /// + /// Mark an Object with an Icon + /// + /// Object ID + /// Portal.dat Icon + public D3DObj MarkObjectWithIcon(int guid, int icon) + { + return new D3DObj(base.Wrapped.MarkObjectWithIcon(guid, icon)); + } + + /// + /// Mark an Object with a Shape + /// + /// Object ID + /// D3DShape + /// Color + public D3DObj MarkObjectWithShape(int guid, D3DShape shape, int color) + { + return new D3DObj(base.Wrapped.MarkObjectWithShape(guid, (eShape)shape, color)); + } + + /// + /// Mark an Object with a Shape + /// + /// Object ID + /// Mesh filename + /// Color + public D3DObj MarkObjectWithShapeFromFile(int guid, string filename, int color) + { + return new D3DObj(base.Wrapped.MarkObjectWithShapeFromFile(guid, filename, color)); + } + + /// + /// Mark an Object with 2DText + /// + /// Object ID + /// Text + /// Font + /// zero or more option flags from DecalPlugins::eFontOptions + public D3DObj MarkObjectWith2DText(int guid, string szText, string szFont, int options) + { + return new D3DObj(base.Wrapped.MarkObjectWith2DText(guid, szText, szFont, options)); + } + + /// + /// Mark an Object with 3DText + /// + /// Object ID + /// Text + /// Font + /// zero or more option flags from DecalPlugins::eFontOptions + public D3DObj MarkObjectWith3DText(int guid, string szText, string szFont, int options) + { + return new D3DObj(base.Wrapped.MarkObjectWith3DText(guid, szText, szFont, options)); + } + + /// + /// Mark specified Coordinates with Icon + /// + /// Latitude + /// Longitude + /// Altitude + /// Portal.dat Icon + public D3DObj MarkCoordsWithIcon(float lat, float lng, float alt, int icon) + { + return new D3DObj(base.Wrapped.MarkCoordsWithIcon(lat, lng, alt, icon)); + } + + /// + /// Mark specified Coordinates with Icon + /// + /// Latitude + /// Longitude + /// Altitude + /// Icon filename + public D3DObj MarkCoordsWithIconFromFile(float lat, float lng, float alt, string file) + { + return new D3DObj(base.Wrapped.MarkCoordsWithIconFromFile(lat, lng, alt, file)); + } + + /// + /// Mark specified Coordinates with Shape + /// + /// Latitude + /// Longitude + /// Altitude + /// D3DShape + /// Color + public D3DObj MarkCoordsWithShape(float lat, float lng, float alt, D3DShape shape, int color) + { + return new D3DObj(base.Wrapped.MarkCoordsWithShape(lat, lng, alt, (eShape)shape, color)); + } + + /// + /// Mark specified Coordinates with Shape + /// + /// Latitude + /// Longitude + /// Altitude + /// Mesh filename + /// Color + public D3DObj MarkCoordsWithShapeFromFile(float lat, float lng, float alt, string file, int color) + { + return new D3DObj(base.Wrapped.MarkCoordsWithShapeFromFile(lat, lng, alt, file, color)); + } + + /// + /// Mark specified Coordinates with 2DText + /// + /// Latitude + /// Longitude + /// Altitude + /// Text + /// Font + /// zero or more option flags from DecalPlugins::eFontOptions + public D3DObj MarkCoordsWith2DText(float lat, float lng, float alt, string szText, string szFont, int options) + { + return new D3DObj(base.Wrapped.MarkCoordsWith2DText(lat, lng, alt, szText, szFont, options)); + } + + /// + /// Mark specified Coordinates with 3DText + /// + /// Latitude + /// Longitude + /// Altitude + /// Text + /// Font + /// zero or more option flags from DecalPlugins::eFontOptions + public D3DObj MarkCoordsWith3DText(float lat, float lng, float alt, string szText, string szFont, int options) + { + return new D3DObj(base.Wrapped.MarkCoordsWith3DText(lat, lng, alt, szText, szFont, options)); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/D3DShape.cs b/Unused/Decal.Adapter.Wrappers/D3DShape.cs new file mode 100644 index 0000000..5dd5c83 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/D3DShape.cs @@ -0,0 +1,12 @@ +namespace Decal.Adapter.Wrappers; + +public enum D3DShape +{ + HorizontalArrow, + VerticalArrow, + Ring, + Cylinder, + Sphere, + Cube, + TiltedCube +} diff --git a/Unused/Decal.Adapter.Wrappers/D3DTextType.cs b/Unused/Decal.Adapter.Wrappers/D3DTextType.cs new file mode 100644 index 0000000..90924de --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/D3DTextType.cs @@ -0,0 +1,7 @@ +namespace Decal.Adapter.Wrappers; + +public enum D3DTextType +{ + Text2D, + Text3D +} diff --git a/Unused/Decal.Adapter.Wrappers/DeathEventArgs.cs b/Unused/Decal.Adapter.Wrappers/DeathEventArgs.cs new file mode 100644 index 0000000..0e9b676 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/DeathEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class DeathEventArgs : EventArgs +{ + private string myText; + + public string Text => myText; + + internal DeathEventArgs(string text) + { + myText = text; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/DecalWrapper.cs b/Unused/Decal.Adapter.Wrappers/DecalWrapper.cs new file mode 100644 index 0000000..3bc60e7 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/DecalWrapper.cs @@ -0,0 +1,84 @@ +using System; +using System.ComponentModel; +using System.Runtime.InteropServices; +using Decal.Adapter.Support; +using Decal.Interop.Core; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class DecalWrapper : MarshalByRefObject, IDisposable +{ + internal static Guid IID_IDISPATCH = new Guid("{00020400-0000-0000-C000-000000000046}"); + + internal static Guid IID_IUNKNOWN = new Guid("{00000000-0000-0000-C000-000000000046}"); + + private DecalCore myDecal; + + private bool isDisposed; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public DecalCore Underlying => myDecal; + + public IntPtr Hwnd => new IntPtr(myDecal.HWND); + + public bool Focus => myDecal.Focus; + + internal DecalWrapper(DecalCore decal) + { + myDecal = decal; + } + + ~DecalWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myDecal != null) + { + Marshal.ReleaseComObject(myDecal); + myDecal = null; + } + isDisposed = true; + } + + public object GetObject(string path) + { + return GetObject(path, IID_IDISPATCH); + } + + public object GetObject(string path, string iid) + { + return GetObject(path, new Guid(iid)); + } + + public object GetObject(string path, Guid iid) + { + try + { + return ((IDecalCore)myDecal).get_Object(path, ref iid); + } + catch (Exception ex) + { + Util.WriteLine("Exception for {0} during get_Object: {1}", path, ex); + return null; + } + } + + public string MapPath(string path) + { + return myDecal.MapPath(path); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/DeclineTradeEventArgs.cs b/Unused/Decal.Adapter.Wrappers/DeclineTradeEventArgs.cs new file mode 100644 index 0000000..fe3d457 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/DeclineTradeEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class DeclineTradeEventArgs : EventArgs +{ + private int mTraderId; + + public int TraderId => mTraderId; + + internal DeclineTradeEventArgs(int TraderId) + { + mTraderId = TraderId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/DoubleValueKey.cs b/Unused/Decal.Adapter.Wrappers/DoubleValueKey.cs new file mode 100644 index 0000000..a4074ef --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/DoubleValueKey.cs @@ -0,0 +1,29 @@ +namespace Decal.Adapter.Wrappers; + +public enum DoubleValueKey +{ + SlashProt = 167772160, + PierceProt = 167772161, + BludgeonProt = 167772162, + AcidProt = 167772163, + LightningProt = 167772164, + FireProt = 167772165, + ColdProt = 167772166, + Heading = 167772167, + ApproachDistance = 167772168, + SalvageWorkmanship = 167772169, + Scale = 167772170, + Variance = 167772171, + AttackBonus = 167772172, + Range = 167772173, + DamageBonus = 167772174, + ManaRateOfChange = 5, + MeleeDefenseBonus = 29, + ManaTransferEfficiency = 87, + HealingKitRestoreBonus = 100, + ManaStoneChanceDestruct = 137, + ManaCBonus = 144, + MissileDBonus = 149, + MagicDBonus = 150, + ElementalDamageVersusMonsters = 152 +} diff --git a/Unused/Decal.Adapter.Wrappers/EchoFilter2.cs b/Unused/Decal.Adapter.Wrappers/EchoFilter2.cs new file mode 100644 index 0000000..0bf2787 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/EchoFilter2.cs @@ -0,0 +1,87 @@ +using System; +using Decal.Adapter.NetParser; +using Decal.Adapter.Support; +using Decal.Interop.Filters; +using Decal.Interop.Net; + +namespace Decal.Adapter.Wrappers; + +public class EchoFilter2 : GenericDisposableWrapper +{ + private event EventHandler serverDispatch; + + private event EventHandler clientDispatch; + + /// + /// Fires when the client receives a message from the server + /// + public event EventHandler ServerDispatch + { + add + { + serverDispatch += value; + } + remove + { + serverDispatch -= value; + } + } + + /// + /// Fires when the client sends a message to the server + /// + public event EventHandler ClientDispatch + { + add + { + clientDispatch += value; + } + remove + { + clientDispatch -= value; + } + } + + public EchoFilter2(Decal.Interop.Filters.EchoFilter2 obj) + : base(obj) + { + base.Wrapped.EchoClient += onEchoClient; + base.Wrapped.EchoServer += onEchoServer; + } + + protected override void Dispose(bool userCalled) + { + if (userCalled && base.Wrapped != null) + { + base.Wrapped.EchoClient -= onEchoClient; + base.Wrapped.EchoServer -= onEchoServer; + } + base.Dispose(userCalled); + } + + private void onEchoServer(IMessage2 pMsg) + { + try + { + Message message = null; + Util.SafeFireEvent(args: new NetworkMessageEventArgs((!(pMsg is MessageWrapper messageWrapper)) ? new Message(pMsg, MessageDirection.Inbound) : messageWrapper.Wrapped), sender: this, eventHandler: this.serverDispatch); + } + catch (Exception ex) + { + Util.WriteLine("Exception in onEchoServer {0}", ex); + } + } + + private void onEchoClient(IMessage2 pMsg) + { + try + { + Message message = null; + Util.SafeFireEvent(args: new NetworkMessageEventArgs((!(pMsg is MessageWrapper messageWrapper)) ? new Message(pMsg, MessageDirection.Inbound) : messageWrapper.Wrapped), sender: this, eventHandler: this.clientDispatch); + } + catch (Exception ex) + { + Util.WriteLine("Exception in onEchoClient {0}", ex); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/EnchantmentWrapper.cs b/Unused/Decal.Adapter.Wrappers/EnchantmentWrapper.cs new file mode 100644 index 0000000..423d79c --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/EnchantmentWrapper.cs @@ -0,0 +1,66 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +public class EnchantmentWrapper : MarshalByRefObject, IDisposable +{ + private Enchantment myEnchantment; + + private bool isDisposed; + + public double Adjustment => myEnchantment.Adjustment; + + public int Affected => myEnchantment.Affected; + + public int AffectedMask => myEnchantment.AffectedMask; + + public double Duration => myEnchantment.Duration; + + public int Family => myEnchantment.Family; + + public int Layer => myEnchantment.Layer; + + public int SpellId => myEnchantment.SpellID; + + public int TimeRemaining => myEnchantment.TimeRemaining; + + public DateTime Expires => DateTime.Now.AddSeconds(TimeRemaining); + + internal EnchantmentWrapper(Enchantment enchant) + { + myEnchantment = enchant; + } + + ~EnchantmentWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myEnchantment != null) + { + Marshal.ReleaseComObject(myEnchantment); + } + isDisposed = true; + } + + protected void EnforceDisposedOnce() + { + if (isDisposed) + { + throw new ObjectDisposedException("EnchantmentWrapper"); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/EndTradeEventArgs.cs b/Unused/Decal.Adapter.Wrappers/EndTradeEventArgs.cs new file mode 100644 index 0000000..d6c27ca --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/EndTradeEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class EndTradeEventArgs : EventArgs +{ + private int mReasonId; + + public int ReasonId => mReasonId; + + internal EndTradeEventArgs(int ReasonId) + { + mReasonId = ReasonId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/EnterTradeEventArgs.cs b/Unused/Decal.Adapter.Wrappers/EnterTradeEventArgs.cs new file mode 100644 index 0000000..3aa609b --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/EnterTradeEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class EnterTradeEventArgs : EventArgs +{ + private int mTraderId; + + private int mTradeeId; + + public int TraderId => mTraderId; + + public int TradeeId => mTradeeId; + + internal EnterTradeEventArgs(int TraderId, int TradeeId) + { + mTraderId = TraderId; + mTradeeId = TradeeId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/FailToAddTradeItemEventArgs.cs b/Unused/Decal.Adapter.Wrappers/FailToAddTradeItemEventArgs.cs new file mode 100644 index 0000000..81ed4cb --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/FailToAddTradeItemEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class FailToAddTradeItemEventArgs : EventArgs +{ + private int mItemId; + + private int mReasonId; + + public int ItemId => mItemId; + + public int ReasonId => mReasonId; + + internal FailToAddTradeItemEventArgs(int ItemId, int ReasonId) + { + mItemId = ItemId; + mReasonId = ReasonId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/FellowshipEventType.cs b/Unused/Decal.Adapter.Wrappers/FellowshipEventType.cs new file mode 100644 index 0000000..309d061 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/FellowshipEventType.cs @@ -0,0 +1,13 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum FellowshipEventType +{ + Create, + Quit, + Dismiss, + Recruit, + Disband +} diff --git a/Unused/Decal.Adapter.Wrappers/FontWeight.cs b/Unused/Decal.Adapter.Wrappers/FontWeight.cs new file mode 100644 index 0000000..d2317c5 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/FontWeight.cs @@ -0,0 +1,26 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +/// +/// FontWeight for use in HUD Rendering +/// +[CLSCompliant(true)] +public enum FontWeight +{ + Black = 900, + Bold = 700, + DemiBold = 600, + DoNotCare = 0, + ExtraBold = 800, + ExtraLight = 200, + Heavy = 900, + Light = 300, + Medium = 500, + Normal = 400, + Regular = 400, + SemiBold = 600, + Thin = 100, + UltraBold = 800, + UltraLight = 200 +} diff --git a/Unused/Decal.Adapter.Wrappers/HookIndexer.cs b/Unused/Decal.Adapter.Wrappers/HookIndexer.cs new file mode 100644 index 0000000..99360ba --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HookIndexer.cs @@ -0,0 +1,23 @@ +using System; +using System.Globalization; + +namespace Decal.Adapter.Wrappers; + +/// +/// Support class for HooksWrapper +/// This class +/// +public sealed class HookIndexer : MarshalByRefObject where IndexType : struct, IConvertible +{ + private hookIndexType myIndex; + + private IIndexedValueProvider myWrap; + + public int this[IndexType item] => myWrap.GetIndexedObject(myIndex, item.ToInt32(CultureInfo.InvariantCulture)); + + internal HookIndexer(IIndexedValueProvider wrap, hookIndexType index) + { + myIndex = index; + myWrap = wrap; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HooksWrapper.cs b/Unused/Decal.Adapter.Wrappers/HooksWrapper.cs new file mode 100644 index 0000000..32b4790 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HooksWrapper.cs @@ -0,0 +1,1138 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Reflection; +using System.Runtime.InteropServices; +using Decal.Interop.Core; + +namespace Decal.Adapter.Wrappers; + +/// +/// Provides direct access to functions and properties in the AC client. +/// +[CLSCompliant(true)] +public sealed class HooksWrapper : MarshalByRefObject, IIndexedValueProvider, IDisposable +{ + private IACHooks myHooks; + + private bool isDisposed; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public IACHooks Underlying => myHooks; + + /// + /// Gets a value indicating how the player is moving an item, or 0 + /// if the player is not moving an item. There are different values + /// for moving an item, combining/splitting a stack, picking + /// up/dropping an item, etc. + /// + /// + /// Here are some known values for BusyState: + /// 0: Idle. + /// 1: Combining a stack. + /// 2: Splitting a stack. + /// 3: ??? + /// 4: Picking up an item from the ground. + /// 5: Moving or unequipping an item. + /// 6: Dropping an item to the ground. + /// 7: Equipping an item. + /// + public int BusyState => myHooks.BusyState; + + /// + /// Gets the GUID of the object that the player is moving, or 0 if the + /// player is not currently moving any object. + /// + public int BusyStateId => myHooks.BusyStateID; + + /// + /// Returns true if the chat bar at the bottom of the screen + /// currently has keyboard focus. Doesn't apply to floating chat + /// windows. + /// + public bool ChatState => myHooks.ChatState; + + /// + /// Gets a value indicating the player's combat stance. + /// 1 is out of combat mode; + /// 2 is melee attack mode; + /// 4 is missile attack mode; + /// 8 is magic casting mode. + /// + public CombatState CombatMode => (CombatState)myHooks.CombatMode; + + /// + /// Returns a pointer to the CommandInterpreter object + /// + public int CommandInterpreter => myHooks.CommandInterpreter; + + /// + /// Gets or sets the GUID of the selected item. A GUID of 0 indicates + /// no item selected. + /// + public int CurrentSelection + { + get + { + return myHooks.CurrentSelection; + } + set + { + myHooks.CurrentSelection = value; + } + } + + /// + /// Gets or sets the compass heading of the player (in degrees). + /// North is 0, East is 90, etc. Setting the heading will cause the + /// player to turn. + /// + public double Heading + { + get + { + return myHooks.HeadingDegrees; + } + set + { + FaceHeading(value, bUnknown: true); + } + } + + /// + /// Gets or sets the compass heading of the player (in radians). + /// North is 0, East is pi/2, etc. Setting the heading will cause the + /// player to turn. + /// + public double HeadingRadians + { + get + { + return myHooks.HeadingRadians; + } + set + { + RadianFaceHeading(value, bUnknown: true); + } + } + + /// + /// Gets the ID of the player's current landcell (a.k.a. landblock). + /// + /// + /// Here is a description of landblocks from + /// David Simpson's + /// Dereth Cartography, from the header comment in his mapac.c + ///
+ /// The map in Asheron's Call is 254 by 254 landblocks. Each landblock contains + /// a 9 by 9 grid of data points which makes for an 8 by 8 group of land squares + /// in game. Each landblock has a unique id, which is a word in length, and + /// has the format xxyyFFFF. In game, xx is the east-west position, and yy is the + /// north-south position. Landblock 0000FFFF is located in the southwest corner of + /// the map. Use /loc to find out which landblock you are on. Each square in a + /// landblock is 0.1 wide and tall, making each landblock 0.8 by 0.8. Although + /// each landblock contains 9 by 9 points, the points on the edges are redundant + /// with adjacent landblocks. The entire map is 2041 by 2041 data points, making + /// 2040 by 2040 squares. Lastly, each square is 24.0 by 24.0 units, whatever + /// they may be. + ///
+ /// + /// + /// This example shows how to calculate coordinates from + /// , , and + /// . North and east are positive, south and + /// west are negative. Round the result to one decimal place to get + /// identical coordinates to the ones AC reports. + /// = 0 ? "N" : "S") + ", " + Math.Abs(EW).ToString("0.0") + (EW >= 0 ? "E" : "W"); + /// ]]> + /// + /// + public int Landcell => myHooks.Landcell; + + /// + /// Gets the player's X-offset within the current landcell, measured in + /// meters. On the landscape, values range from 0 (west side of + /// landcell) to 192 (east side). In dungeons, values are unbounded. + /// + public double LocationX => myHooks.LocationX; + + /// + /// Gets the player's Y-offset within the current landcell, measured in + /// meters. On the landscape, values range from 0 (south side of + /// landcell) to 192 (north side). In dungeons, values are unbounded. + /// + public double LocationY => myHooks.LocationY; + + /// + /// Gets the player's altitude, measured in meters. 0 is sea-level. + /// + public double LocationZ => myHooks.LocationZ; + + /// + /// Gets the total number of items in the currently selected stack. + /// + public int MaxSelectedStackCount => myHooks.MaxSelectedStackCount; + + /// + /// Gets the GUID of the currently opened container, such as a chest or + /// corpse. Returns 0 if no container is currently opened. + /// + public int OpenedContainer => myHooks.OpenedContainer; + + /// + /// Gets the ID of the current mouse pointer graphics. This number + /// corresponds to an image in client_portal.dat. + /// + /// + /// Here are some known values of PointerState: + /// 0x6004D68: Brown idle cursor. + /// 0x6004D69: Brown idle cursor with yellow outline. + /// 0x6004D6A: Red combat mode cursor. + /// 0x6004D6B: Red combat mode cursor with yellow outline. + /// 0x6004D6C: Blue magic mode cursor. + /// 0x6004D6D: Blue magic mode cursor with yellow outline. + /// 0x6004D71: Magnifying glass cursor. + /// 0x6004D72: Hand cursor. + /// 0x6004D74: Hour glass cursor. + /// 0x6004D75: Hour glass cursor with yellow outline. + /// + public int PointerState => myHooks.PointerState; + + /// + /// Gets or sets the GUID of the previously-selected item. Setting + /// this will cause the given GUID to be selected when the user + /// presses the "select previous item" key. + /// + public int PreviousSelection + { + get + { + return myHooks.PreviousSelection; + } + set + { + myHooks.PreviousSelection = value; + } + } + + /// + /// Gets the bounding box of the 3D region in the AC window. The 3D + /// region is the area of the window where landscape and characters + /// are visible. + /// + public Rectangle Region3D + { + get + { + tagRECT aC3DRegionRect = myHooks.AC3DRegionRect; + return new Rectangle(aC3DRegionRect.left, aC3DRegionRect.top, aC3DRegionRect.right, aC3DRegionRect.bottom); + } + } + + /// + /// Gets the bounding box of the entire AC window, including the 2D + /// parts of the GUI. This is the resolution set on the settings tab + /// in AC. + /// + public Rectangle RegionWindow + { + get + { + tagRECT aCWindowRect = myHooks.ACWindowRect; + return new Rectangle(aCWindowRect.left, aCWindowRect.top, aCWindowRect.right, aCWindowRect.bottom); + } + } + + /// + /// Gets or sets the number of items in the currently selected stack. + /// Must be between 1 and . If + /// this is less than , then + /// moving the current selection will split the stack. + /// + public int SelectedStackCount + { + get + { + return myHooks.SelectedStackCount; + } + set + { + myHooks.SelectedStackCount = value; + } + } + + /// + /// Gets the GUID of the currently open vendor, or 0 if no vendor is + /// open. + /// + public int VendorId => myHooks.VendorID; + + /// + /// Gets the level an attribute. "Current" values include buffs, + /// vitae, etc. + /// + [CLSCompliant(false)] + public HookIndexer Attribute => new HookIndexer(this, hookIndexType.Attribute); + + /// + /// Gets the number of times a attribute has been raised above its + /// starting (innate) level. + /// + [CLSCompliant(false)] + public HookIndexer AttributeClicks => new HookIndexer(this, hookIndexType.AttributeClicks); + + /// + /// Gets the starting (innate) level of an attribute. + /// + [CLSCompliant(false)] + public HookIndexer AttributeStart => new HookIndexer(this, hookIndexType.AttributeStart); + + /// + /// Gets the total amount of XP spent on an attribute. + /// + [CLSCompliant(false)] + public HookIndexer AttributeTotalXP => new HookIndexer(this, hookIndexType.AttributeTotalXP); + + /// + /// Gets the value of a hook by its ID. + /// + [CLSCompliant(false)] + public HookIndexer Misc => new HookIndexer(this, hookIndexType.Misc); + + /// + /// Gets the level a skill. "Current" values include buffs, vitae, etc. + /// + [CLSCompliant(false)] + public HookIndexer Skill => new HookIndexer(this, hookIndexType.Skill); + + /// + /// Gets the number of times a skill has been raised above the level + /// calculated from the skill's attribute formula plus free points. + /// + [CLSCompliant(false)] + public HookIndexer SkillClicks => new HookIndexer(this, hookIndexType.SkillClicks); + + /// + /// Gets the number of free points for a skill. Specialized skills + /// have 10 free points. + /// + [CLSCompliant(false)] + public HookIndexer SkillFreePoints => new HookIndexer(this, hookIndexType.SkillFreePoints); + + /// + /// Gets the total amount of XP spent on a skill. + /// + [CLSCompliant(false)] + public HookIndexer SkillTotalXP => new HookIndexer(this, hookIndexType.SkillTotalXP); + + /// + /// Gets the level to which a skill is trained. + /// 0 is untrained; 1 is trained; 2 is specialized. + /// + [CLSCompliant(false)] + public HookIndexer SkillTrainLevel => new HookIndexer(this, hookIndexType.SkillTrainLevel); + + /// + /// Gets the level a vital. "Current" values include buffs, vitae, etc. + /// + [CLSCompliant(false)] + public HookIndexer Vital => new HookIndexer(this, hookIndexType.Vital); + + /// + /// Gets the number of times a vital has been raised above the level + /// calculated from the vital's attribute formula. + /// + [CLSCompliant(false)] + public HookIndexer VitalClicks => new HookIndexer(this, hookIndexType.VitalClicks); + + /// + /// Gets the total amount of XP spent on a vital. + /// + [CLSCompliant(false)] + public HookIndexer VitalTotalXP => new HookIndexer(this, hookIndexType.VitalTotalXP); + + internal HooksWrapper(ACHooks hooks) + { + myHooks = hooks; + } + + ~HooksWrapper() + { + Dispose(disposing: false); + } + + /// + /// Releases the resources used by this HooksWrapper. No plugin or + /// filter should use this function! + /// + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myHooks != null) + { + Marshal.ReleaseComObject(myHooks); + myHooks = null; + } + isDisposed = true; + } + + /// + /// Adds a line of text to the default chat window for the specified + /// text color. + /// + /// The text to add to the chat window. + /// The color ID of the text to add. This also + /// determines in which chat window the text will appear, as per the + /// user's chat settings. + public void AddChatText(string text, int color) + { + AddChatText(text, color, 0); + } + + /// + /// Adds a line of text to the specified chat window. + /// + /// The text to add to the chat window. + /// The color ID of the text to add. + /// The chat window where the text will appear. + /// 0 is the default chat window for the given color, 1 is main + /// chat, and 2-5 are chat tabs #1-4, respectively. + public void AddChatText(string text, int color, int target) + { + myHooks.AddChatText(text, color, target); + } + + /// + /// Adds text to the default chat window for the specified text color. + /// + /// The text to add to the chat window. + /// The color ID of the text to add. This also + /// determines in which chat window the text will appear, as per the + /// user's chat settings. + public void AddChatTextRaw(string text, int color) + { + AddChatTextRaw(text, color, 0); + } + + /// + /// Adds text to the specified chat window. + /// + /// The text to add to the chat window. + /// The color ID of the text to add. + /// The chat window where the text will appear. + /// 0 is the default chat window for the given color, 1 is main + /// chat, and 2-5 are chat tabs #1-4, respectively. + public void AddChatTextRaw(string text, int color, int target) + { + myHooks.AddChatTextRaw(text, color, target); + } + + /// + /// Adds a red status message to the status area at the top of the + /// screen. + /// + /// The status message. + public void AddStatusText(string text) + { + myHooks.AddStatusText(text); + } + + /// + /// Uses one item on another (for crafting, etc.) + /// This command will fail if the player is busy using an item, + /// casting a spell, etc. If you are using multiple items, you must + /// wait until the previous action is complete before attempting to + /// use the next item. + /// + /// The GUID of the item to use. + /// The GUID of the target. + /// + public void ApplyItem(int useThis, int onThis) + { + myHooks.ApplyItem(useThis, onThis); + } + + /// + /// Attempts to wield an item + /// This command will fail if the player is busy using an item, + /// casting a spell, etc. If you are using multiple items, you must + /// wait until the previous action is complete before attempting to + /// use the next item. + /// + /// The GUID of the item to use. + /// + public void AutoWield(int item) + { + myHooks.AutoWield(item); + } + + /// + /// Attempts to wield an item + /// This command will fail if the player is busy using an item, + /// casting a spell, etc. If you are using multiple items, you must + /// wait until the previous action is complete before attempting to + /// use the next item. + /// + /// The GUID of the item to use. + /// The slot to use + /// 1 if explicit placement, 0 if automatic placement + /// 0 if explic is 1, 1 if explic is 0 + /// + public void AutoWield(int item, int slot, int explic, int notexplic) + { + myHooks.AutoWieldEx(item, slot, explic, notexplic); + } + + /// + /// Attempts to wield an item + /// This command will fail if the player is busy using an item, + /// casting a spell, etc. If you are using multiple items, you must + /// wait until the previous action is complete before attempting to + /// use the next item. + /// + /// The GUID of the item to use. + /// The slot to use + /// 1 if explicit placement, 0 if automatic placement + /// 0 if explic is 1, 1 if explic is 0 + /// Zero + /// Zero + /// + public void AutoWield(int item, int slot, int explic, int notexplic, int zero1, int zero2) + { + myHooks.AutoWieldRaw(item, slot, explic, notexplic, zero1, zero2); + } + + /// + /// Causes the player to attempt to cast a spell. The player must be + /// in spellcasting mode and the spell must be in his spellbook. + /// + /// The ID of the spell to cast. + /// The GUID of the target. This is ignored for + /// non-targeted spells, such as self spells and ring spells. + public void CastSpell(int spellId, int objectId) + { + myHooks.CastSpell(spellId, objectId); + } + + /// + /// Drop an item from the player's inventory onto the ground. + /// + /// The GUID of the item to drop. + public void DropItem(int objectId) + { + myHooks.DropItem(objectId); + } + + /// + /// Causes the player to turn to the specified heading. + /// + /// The desired heading (in degrees). + /// Unknown. + /// Always returns true. + public bool FaceHeading(double heading, bool bUnknown) + { + return myHooks.FaceHeading((float)heading, bUnknown); + } + + /// + /// Causes the player to turn to the specified heading. + /// + /// The desired heading (in radians). + /// Unknown + /// + public bool RadianFaceHeading(double heading, bool bUnknown) + { + if (heading < 0.0) + { + throw new ArgumentOutOfRangeException("heading"); + } + if (heading > Math.PI * 10.0) + { + throw new ArgumentOutOfRangeException("heading"); + } + double num = heading * 180.0 / Math.PI; + return myHooks.FaceHeading((float)num, bUnknown); + } + + /// + /// Recruit someone to your fellowship. + /// + /// The GUID of the character to recruit. + public void FellowshipRecruit(int lObjectID) + { + myHooks.FellowshipRecruit(lObjectID); + } + + /// + /// Give fellowship leadership to a player. + /// + /// The GUID of the character to become the leader. + public void FellowshipGrantLeader(int lObjectID) + { + myHooks.FellowshipGrantLeader(lObjectID); + } + + /// + /// Opens or closes the fellowship. + /// + /// True if the fellowship should be made open, false if it should be made closed. + public void FellowshipSetOpen(bool IsOpen) + { + myHooks.FellowshipSetOpen(IsOpen); + } + + /// + /// Quits the current fellowship. + /// + public void FellowshipQuit() + { + myHooks.FellowshipQuit(); + } + + /// + /// Disbands the current fellowship. + /// + public void FellowshipDisband() + { + myHooks.FellowshipDisband(); + } + + /// + /// Dismisses another player from the fellowship. + /// + /// The GUID of the character to remove from the fellowship. + public void FellowshipDismiss(int lObjectID) + { + myHooks.FellowshipDismiss(lObjectID); + } + + /// + /// Gives an object from the player's inventory to another player or + /// NPC. + /// + /// The GUID of the object to give. + /// The GUID of the player or NPC to receive + /// the object. + public void GiveItem(int lObject, int lDestination) + { + myHooks.GiveItem(lObject, lDestination); + } + + /// + /// Adds an identify-request to the end of the request queue. + /// + /// The GUID of the object to request an ID for. + public void RequestId(int objectId) + { + CoreManager.Current.IDQueue.AddToQueueForCaller(objectId, Assembly.GetCallingAssembly(), DateTime.MaxValue); + } + + /// + /// Sends text to AC's chat parser as if the user had typed the text + /// into the chat bar. This text will not be sent to other + /// plugins via the + /// event, so + /// this function cannot be used to send chat commands to other plugins. + /// + /// The text to send. + public void InvokeChatParser(string text) + { + myHooks.InvokeChatParser(text); + } + + /// + /// Checks if the AC client knows about an object GUID. The client + /// must know about an object for it to be used in other HooksWrapper + /// functions. + /// + /// The GUID of the object to check. + /// true if the client knows about an object, or + /// false if not. + public bool IsValidObject(int objectId) + { + return myHooks.IsValidObject(objectId); + } + + /// + /// Logs out the current character and returns to the character + /// selection screen. + /// + public void Logout() + { + myHooks.Logout(); + } + + /// + /// Moves an item to the specified pack in the player's inventory. + /// This command will fail if the player is busy moving an item, + /// casting a spell, etc. If you are moving multiple items, you must + /// wait until the previous action is complete before attempting to + /// move the next item. + /// + /// The GUID of the object to move. + /// The GUID of the destination container. + /// The slot within the pack, where 0 is the first + /// slot. If this number is greater than the number of items in the + /// pack, the object will be placed in the first unused slot in the + /// pack. + /// A flag indicating whether to add the object to + /// a stack in the pack, if one exists. + public void MoveItem(int objectId, int packId, int slot, bool stack) + { + myHooks.MoveItem(objectId, packId, slot, stack); + } + + /// + /// Moves an item to the front of the specified container. If the item + /// is not in the player's inventory, the destination must be the + /// player's main pack (the GUID of the player), or one of his side + /// packs. + /// This command will fail if the player is busy moving an item, + /// casting a spell, etc. If you are moving multiple items, you must + /// wait until the previous action is complete before attempting to + /// move the next item. + /// + /// The GUID of the item to move. + /// The GUID of the destination container. + public void MoveItem(int objectId, int destinationId) + { + myHooks.MoveItemEx(objectId, destinationId); + } + + /// + /// Moves an item to the specified container, with flags indicating + /// how the move should be performed. + /// This command will fail if the player is busy moving an item, + /// casting a spell, etc. If you are moving multiple items, you must + /// wait until the previous action is complete before attempting to + /// move the next item. + /// + /// The GUID of the object to move. + /// The GUID of the destination container. + /// Flags indicating how the move should be + /// performed. + public void MoveItem(int objectId, int destinationId, int moveFlags) + { + myHooks.MoveItemExRaw(objectId, destinationId, moveFlags); + } + + /// + /// Adds a salvagable item to the salvage panel. + /// The salvage panel does not need to be open for this command, + /// but it does need to be open for + /// , and opening the salvage panel + /// after adding items to it will clear the panel. + /// + /// The GUID of the object to add. + public void SalvagePanelAdd(int objectId) + { + myHooks.SalvagePanelAdd(objectId); + } + + /// + /// Salvages the items in the salvage panel. The salvage panel must + /// be open. + /// + public void SalvagePanelSalvage() + { + myHooks.SalvagePanelSalvage(); + } + + /// + /// Selects an item. + /// + /// The GUID of the object to select, or 0 to + /// clear the current selection. + public void SelectItem(int objectId) + { + myHooks.SelectItem(objectId); + } + + /// + /// Turns player's autorun on or off. + /// + /// true to turn on autorun; + /// false to turn it off. + public void SetAutorun(bool on) + { + myHooks.SetAutorun(on); + } + + /// + /// Attempts to put the player in the specified combat stance. The + /// player must be wielding the proper weapon type (melee, bow, + /// magic caster) for the given combat stance. + /// + /// The desired combat stance. + /// 1 is out of combat mode; + /// 2 is melee attack mode; + /// 4 is missile attack mode; + /// 8 is magic casting mode. + public void SetCombatMode(CombatState newMode) + { + myHooks.SetCombatMode((int)newMode); + } + + /// + /// Moves the mouse cursor to the given coordinates, relative to the + /// AC window. + /// + /// The X-coordinate. + /// The Y-coordinate. + public void SetCursorPosition(int x, int y) + { + myHooks.SetCursorPosition(x, y); + } + + /// + /// Sets the amount of time that the player can be idle (no mouse or + /// keyboard input) before AC automatically logs out. The default + /// value is 1200 seconds (20 minutes). + /// + /// The idle timeout (in seconds). + public void SetIdleTime(double timeout) + { + myHooks.SetIdleTime(timeout); + } + + /// + /// Adds a spell to the specified tab on the player's spell bar. The + /// spell must be in the player's spell book. Each spell tab can + /// contain only one copy of each spell. Putting a spell onto a tab + /// that already contains that spell will just move the spell to the + /// new index. + /// + /// + /// This function does not always work if you call it multiple times + /// in a loop. Consider putting the loop in the + /// event of a + /// , and then running the + /// timer for one tick. + /// + /// The zero-based tab index to add the spell. + /// The zero-based slot on the tab to add the spell. + /// If this index is greater than the number of spells on the tab, the + /// spell will be added to the first unused slot. + /// The ID of the spell to be added. + public void SpellTabAdd(int tab, int index, int spellId) + { + myHooks.SpellTabAdd(tab, index, spellId); + } + + /// + /// Removes a spell from the specified tab on the player's spell bar. + /// This function can safely be called multiple times in a row with no + /// time delay between calls. + /// + /// The tab from which to remove the spell. + /// The ID of the spell to be removed. + public void SpellTabDelete(int tab, int spellId) + { + myHooks.SpellTabDelete(tab, spellId); + } + + /// + /// Accepts a trade with another player. + /// + public void TradeAccept() + { + myHooks.TradeAccept(); + } + + /// + /// Adds an object to the trade window with another player. The object + /// must be in the player's inventory. + /// + /// The GUID of the object to add. + public void TradeAdd(int objectId) + { + myHooks.TradeAdd(objectId); + } + + /// + /// Gets a physics object. + /// + /// The ID of the physics object. + /// A pointer to a physics object. + public IntPtr PhysicsObject(int objectId) + { + return new IntPtr(myHooks.GetPhysicsObjectPtr(objectId)); + } + + /// + /// Gets a weenie object. + /// + /// The ID of the weenie object. + /// A pointer to the weenie object. + public IntPtr WeenieObject(int objectId) + { + return new IntPtr(myHooks.GetWeenieObjectPtr(objectId)); + } + + /// + /// Declines (un-accepts) a trade with another player. + /// + public void TradeDecline() + { + myHooks.TradeDecline(); + } + + /// + /// Clears the contents of the trade window. + /// + public void TradeReset() + { + myHooks.TradeReset(); + } + + /// + /// Ends the current trade, leaving the trade window open. + /// + public void TradeEnd() + { + myHooks.TradeEnd(); + } + + /// + /// Gets a UIElement instance. + /// + /// The TypeID of the UIElement instance. + /// A pointer to the UIElement instance. + public IntPtr UIElementLookup(UIElementType pUIElementType) + { + return new IntPtr(myHooks.UIElementLookup((int)pUIElementType)); + } + + /// + /// Sets the position of a UIElement region in the AC window. + /// + /// The TypeID of the UIElement instance. + /// The x-axis position the UIElement instance. + /// The y-axis position of the UIElement instance. + public void UIElementMove(UIElementType pUIElementType, int x, int y) + { + myHooks.UIElementMove((int)pUIElementType, x, y); + } + + /// + /// Sets the position of a UIElement region in the AC window. + /// + /// The TypeID of the UIElement instance. + /// The width of the UIElement instance. + /// The height of the UIElement instance. + public void UIElementResize(UIElementType pUIElementType, int width, int height) + { + myHooks.UIElementResize((int)pUIElementType, width, height); + } + + /// + /// Gets the bounding box of a UIElement region in the AC window. + /// + public Rectangle UIElementRegion(UIElementType pUIElementType) + { + tagRECT tagRECT = myHooks.UIElementRegionRect((int)pUIElementType); + return new Rectangle(tagRECT.left, tagRECT.top, 1 + tagRECT.right - tagRECT.left, 1 + tagRECT.bottom - tagRECT.top); + } + + /// + /// Uses an item, such as a potion, healing kit, etc. + /// + /// + /// This command will fail if the player is busy using an item, + /// casting a spell, etc. If you are using multiple items, you must + /// wait until the previous action is complete before attempting to + /// use the next item. + /// + /// The GUID of the item to use. + /// The purpose of this argument is not + /// entirely known. Valid values appear to be 0 and 1: 0 uses + /// an item by itself (like a potion); 1 uses an item on the current + /// selection. + public void UseItem(int objectId, int useState) + { + myHooks.UseItem(objectId, useState); + } + + /// + /// Uses an item, such as a potion, healing kit, casts the spell on a + /// wand/orb, etc. + /// + /// + /// This command will fail if the player is busy using an item, + /// casting a spell, etc. If you are using multiple items, you must + /// wait until the previous action is complete before attempting to + /// use the next item. + /// + /// The GUID of the item to use. + /// The purpose of this argument is not + /// entirely known. Valid values appear to be 0 and 1: 0 uses + /// an item by itself (like a potion); 1 uses an item on the current + /// selection. + /// The purpose of this argument is not + /// entirely known. It may be a target GUID for wand/orb spells, or + /// some other flag + public void UseItem(int objectId, int useState, int useMethod) + { + myHooks.UseItemRaw(objectId, useState, useMethod); + } + + /// + /// Buys all of the items in the buy-list. The player must have + /// enough pyreals and slots in the main pack to hold all of the items + /// being bought. + /// + public void VendorBuyAll() + { + myHooks.VendorBuyAll(); + } + + /// + /// Adds an item to the list of things to buy from a vendor. A vendor + /// window must be open to use this command. + /// + /// The GUID of the item template or item in + /// the vendor's inventory. Templates are the generic items sold by + /// vendors, such as spell components or trade notes. + /// The number of the specified item to add to the + /// buy-list. + public void VendorAddBuyList(int templateId, int count) + { + myHooks.VendorBuyListAdd(templateId, count); + } + + /// + /// Clears the buy-list. + /// + public void VendorClearBuyList() + { + myHooks.VendorBuyListClear(); + } + + /// + /// Sells all of the items in the sell-list. The player must have + /// enough slots in the main pack to hold all of the stacks of pyreals + /// obtained from the sale. + /// + public void VendorSellAll() + { + myHooks.VendorSellAll(); + } + + /// + /// Adds an item to the list of things to sell to a vendor. A vendor + /// window must be open, and the item must be in the player's inventory. + /// + /// The GUID of the item to add to the sell-list. + public void VendorAddSellList(int itemId) + { + myHooks.VendorSellListAdd(itemId); + } + + /// + /// Clears the sell-list. + /// + public void VendorClearSellList() + { + myHooks.VendorSellListClear(); + } + + /// + /// Spends experience points on a skill. + /// + /// The skill to raise. + /// The number of experience points to spend. + /// Cannot be more than the player's unspent experience. + /// + /// + public void AddSkillExperience(SkillType skill, int experience) + { + myHooks.AddSkillExp((eSkill)skill, experience); + } + + /// + /// Spends experience points on an attribute. + /// + /// The attribute to raise. + /// The number of experience points to spend. + /// Cannot be more than the player's unspent experience. + /// + /// + public void AddAttributeExperience(AttributeType attrib, int experience) + { + myHooks.AddAttributeExp((eAttribute)attrib, experience); + } + + /// + /// Spends experience points on a vital. + /// + /// The vital to raise. + /// The number of experience points to spend. + /// Cannot be more than the player's unspent experience. + /// + /// + public void AddVitalExperience(VitalType vital, int experience) + { + myHooks.AddVitalExp((eVital)vital, experience); + } + + int IIndexedValueProvider.GetIndexedObject(hookIndexType index, int item) + { + int result = 0; + switch (index) + { + case hookIndexType.Attribute: + result = myHooks.get_Attribute(item); + break; + case hookIndexType.AttributeClicks: + result = myHooks.get_AttributeClicks((eAttribute)item); + break; + case hookIndexType.AttributeStart: + result = myHooks.get_AttributeStart((eAttribute)item); + break; + case hookIndexType.AttributeTotalXP: + result = myHooks.get_AttributeTotalXP((eAttribute)item); + break; + case hookIndexType.Skill: + result = myHooks.get_Skill(item); + break; + case hookIndexType.SkillClicks: + result = myHooks.get_SkillClicks((eSkill)item); + break; + case hookIndexType.SkillFreePoints: + result = myHooks.get_SkillFreePoints((eSkill)item); + break; + case hookIndexType.SkillTotalXP: + result = myHooks.get_SkillTotalXP((eSkill)item); + break; + case hookIndexType.SkillTrainLevel: + result = (int)myHooks.get_SkillTrainLevel((eSkill)item); + break; + case hookIndexType.Vital: + result = myHooks.get_Vital(item); + break; + case hookIndexType.VitalClicks: + result = myHooks.get_VitalClicks((eVital)item); + break; + case hookIndexType.VitalTotalXP: + result = myHooks.get_VitalTotalXP((eVital)item); + break; + case hookIndexType.Misc: + result = myHooks.get_Misc(item); + break; + } + return result; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HostBase.cs b/Unused/Decal.Adapter.Wrappers/HostBase.cs new file mode 100644 index 0000000..5ca64a3 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HostBase.cs @@ -0,0 +1,75 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public abstract class HostBase : MarshalByRefObject, IDisposable +{ + private HooksWrapper myInternalHooks; + + private DecalWrapper myInternalDecal; + + private RenderServiceWrapper myInternalRender; + + private bool isDisposed; + + protected bool IsDisposed => isDisposed; + + protected DecalWrapper MyDecal + { + get + { + return myInternalDecal; + } + set + { + myInternalDecal = value; + } + } + + protected RenderServiceWrapper MyRender + { + get + { + return myInternalRender; + } + set + { + myInternalRender = value; + } + } + + ~HostBase() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed && disposing) + { + if (myInternalHooks != null) + { + myInternalHooks.Dispose(); + } + if (myInternalDecal != null) + { + myInternalDecal.Dispose(); + } + if (myInternalRender != null) + { + myInternalRender.Dispose(); + } + } + myInternalHooks = null; + myInternalDecal = null; + myInternalRender = null; + isDisposed = true; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HotkeyEventArgs.cs b/Unused/Decal.Adapter.Wrappers/HotkeyEventArgs.cs new file mode 100644 index 0000000..105db4f --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HotkeyEventArgs.cs @@ -0,0 +1,31 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class HotkeyEventArgs : EventArgs +{ + private string myTitle; + + private bool myEat; + + public string Title => myTitle; + + public bool Eat + { + get + { + return myEat; + } + set + { + myEat = value; + } + } + + internal HotkeyEventArgs(string Title, bool Eat) + { + myTitle = Title; + myEat = Eat; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HotkeySystem.cs b/Unused/Decal.Adapter.Wrappers/HotkeySystem.cs new file mode 100644 index 0000000..9652407 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HotkeySystem.cs @@ -0,0 +1,133 @@ +using System; +using System.ComponentModel; +using System.Runtime.InteropServices; +using Decal.Interop.DHS; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class HotkeySystem : MarshalByRefObject, IDisposable +{ + private Decal.Interop.DHS.HotkeySystem myHKS; + + private bool isDisposed; + + private EventHandler mHotkey; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Decal.Interop.DHS.HotkeySystem Underlying => myHKS; + + public event EventHandler Hotkey + { + add + { + mHotkey = (EventHandler)Delegate.Combine(mHotkey, value); + } + remove + { + mHotkey = (EventHandler)Delegate.Remove(mHotkey, value); + } + } + + internal HotkeySystem(Decal.Interop.DHS.HotkeySystem hks) + { + myHKS = hks; + myHKS.HotkeyEvent += myHKS_HotkeyEvent; + } + + ~HotkeySystem() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed && disposing && myHKS != null) + { + myHKS.HotkeyEvent -= myHKS_HotkeyEvent; + } + if (myHKS != null) + { + Marshal.ReleaseComObject(myHKS); + } + isDisposed = true; + } + + public void AddHotkey(string szPlugin, HotkeyWrapper hotkey) + { + if (hotkey == null) + { + throw new ArgumentNullException("hotkey"); + } + AddHotkey(szPlugin, hotkey.Underlying); + } + + public void AddHotkey(string szPlugin, string szTitle, string szDescription) + { + Hotkey hotkey = new HotkeyClass(); + hotkey.EventTitle = szTitle; + hotkey.EventDescription = szDescription; + AddHotkey(szPlugin, hotkey); + Marshal.ReleaseComObject(hotkey); + } + + public void AddHotkey(string plugin, string title, string description, int virtualKey, bool altState, bool controlState, bool shiftState) + { + Hotkey hotkey = new HotkeyClass(); + hotkey.EventTitle = title; + hotkey.EventDescription = description; + hotkey.VirtualKey = virtualKey; + hotkey.AltState = altState; + hotkey.ControlState = controlState; + hotkey.ShiftState = shiftState; + AddHotkey(plugin, hotkey); + Marshal.ReleaseComObject(hotkey); + } + + private void AddHotkey(string szPlugin, Hotkey hotkey) + { + if (hotkey == null) + { + throw new ArgumentNullException("hotkey"); + } + myHKS.AddHotkey(szPlugin, hotkey); + } + + public void DeleteHotkey(string plugin, string hotkeyName) + { + myHKS.DeleteHotkey(plugin, hotkeyName); + } + + public bool Exists(string hotkeyName) + { + return myHKS.QueryHotkey(hotkeyName); + } + + public HotkeyWrapper GetHotkey(string plugin, string hotkeyName) + { + Hotkey hotkey = myHKS.QueryHotkeyEx(plugin, hotkeyName); + HotkeyWrapper result = null; + if (hotkey != null) + { + result = new HotkeyWrapper(hotkey); + } + return result; + } + + private void myHKS_HotkeyEvent(string szTitle, ref bool Eat) + { + if (mHotkey != null) + { + HotkeyEventArgs e = new HotkeyEventArgs(szTitle, Eat); + mHotkey(this, e); + Eat = e.Eat; + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HotkeyWrapper.cs b/Unused/Decal.Adapter.Wrappers/HotkeyWrapper.cs new file mode 100644 index 0000000..432b7d2 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HotkeyWrapper.cs @@ -0,0 +1,82 @@ +using System; +using System.ComponentModel; +using System.Runtime.InteropServices; +using Decal.Interop.DHS; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class HotkeyWrapper : MarshalByRefObject, IDisposable +{ + private Hotkey myHotkey; + + private bool isDisposed; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Hotkey Underlying => myHotkey; + + public bool AltState => myHotkey.AltState; + + public bool ControlState => myHotkey.ControlState; + + public bool ShiftState => myHotkey.ShiftState; + + public int VirtualKey => myHotkey.VirtualKey; + + public string Title => myHotkey.EventTitle; + + public string Description => myHotkey.EventDescription; + + internal HotkeyWrapper(Hotkey hotkey) + { + myHotkey = hotkey; + } + + public HotkeyWrapper(string title, string description) + : this(new HotkeyClass()) + { + myHotkey.EventTitle = title; + myHotkey.EventDescription = description; + } + + public HotkeyWrapper(string title, string description, int virtualKey, bool altState, bool controlState, bool shiftState) + : this(title, description) + { + myHotkey.VirtualKey = virtualKey; + myHotkey.AltState = altState; + myHotkey.ControlState = controlState; + myHotkey.ShiftState = shiftState; + } + + ~HotkeyWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myHotkey != null) + { + Marshal.ReleaseComObject(myHotkey); + } + isDisposed = true; + } + + protected void EnforceDisposedOnce() + { + if (isDisposed) + { + throw new ObjectDisposedException("HotkeyWrapper"); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/Hud.cs b/Unused/Decal.Adapter.Wrappers/Hud.cs new file mode 100644 index 0000000..1b39cb4 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/Hud.cs @@ -0,0 +1,92 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Render; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class Hud : HudRenderScalable +{ + private HUDView internalView; + + internal HUDView Underlying => internalView; + + public bool Enabled + { + get + { + return internalView.Enabled; + } + set + { + internalView.Enabled = value; + } + } + + public int Id => internalView.ID; + + /// + /// Angle in Radians for rotation of the HUD + /// + public float Angle + { + get + { + return internalView.Angle; + } + set + { + internalView.Angle = value; + } + } + + /// + /// Alpha for entire hud + /// + public int Alpha + { + get + { + return internalView.Alpha; + } + set + { + internalView.Alpha = value; + } + } + + internal event EventHandler Disposing; + + internal Hud(HUDView view) + : base(view) + { + internalView = view; + } + + public void SetBackground(Background background) + { + if (background != null) + { + internalView.SetBackground(background.Underlying); + return; + } + throw new ArgumentNullException("background"); + } + + protected override void Dispose(bool disposing) + { + try + { + if (disposing && this.Disposing != null) + { + this.Disposing(this, new EventArgs()); + } + Marshal.ReleaseComObject(internalView); + internalView = null; + } + finally + { + base.Dispose(disposing); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HudRenderScalable.cs b/Unused/Decal.Adapter.Wrappers/HudRenderScalable.cs new file mode 100644 index 0000000..32ba558 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HudRenderScalable.cs @@ -0,0 +1,66 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Core; +using Decal.Interop.Render; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class HudRenderScalable : HudRenderTarget +{ + private IRenderScalable myScalable; + + /// + /// Returns the Area scaling has caused the Hud to encompass + /// + public Rectangle ScaleRect => Util.toRectangle(myScalable.ScaleRect); + + /// + /// Scale the width and height of the Hud by the specified value keeping the current position. + /// This will not return 'good' values when using ScaleTo + /// + public float ScaleFactor + { + get + { + return myScalable.ScaleFactor; + } + set + { + myScalable.ScaleFactor = value; + } + } + + /// + /// Specifies whether or not Scaling is occuring (setting to false disables scaling) + /// + public bool Scaling + { + get + { + return myScalable.Scaling; + } + set + { + myScalable.Scaling = value; + } + } + + [CLSCompliant(false)] + protected HudRenderScalable(IRenderScalable newTarget) + : base(newTarget) + { + myScalable = newTarget; + } + + /// + /// Scales the Hud to fill the area specified + /// + /// Area for the Hud to encompass + public void ScaleTo(Rectangle rect) + { + tagRECT pArea = Util.toTagRECT(rect); + myScalable.ScaleTo(ref pArea); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/HudRenderTarget.cs b/Unused/Decal.Adapter.Wrappers/HudRenderTarget.cs new file mode 100644 index 0000000..1da9d47 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/HudRenderTarget.cs @@ -0,0 +1,429 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Runtime.InteropServices; +using Decal.Adapter.Support; +using Decal.Interop.Core; +using Decal.Interop.Render; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class HudRenderTarget : MarshalByRefObject, IDisposable +{ + private IRenderTarget myTarget; + + private bool isDisposed; + + private Rectangle areaRect; + + private bool inRender; + + private bool inText; + + public bool Lost => myTarget.Lost; + + [EditorBrowsable(EditorBrowsableState.Never)] + public Rectangle Constraint + { + get + { + Rectangle region = Region; + return new Rectangle(0, 0, region.Width, region.Height); + } + } + + public Rectangle Region + { + get + { + return Util.toRectangle(myTarget.Region); + } + set + { + tagRECT pVal = Util.toTagRECT(value); + myTarget.Region = ref pVal; + areaRect.Width = value.Width; + areaRect.Height = value.Height; + } + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public object UnsafeSurface => myTarget.GetSurface(); + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public tagRECT UnsafeRegion + { + get + { + return myTarget.Region; + } + set + { + myTarget.Region = ref value; + } + } + + protected bool IsDisposed => isDisposed; + + [CLSCompliant(false)] + protected HudRenderTarget(IRenderTarget newTarget) + { + if (newTarget == null) + { + throw new ArgumentNullException("newTarget"); + } + myTarget = newTarget; + tagRECT region = myTarget.Region; + areaRect = new Rectangle(0, 0, region.right - region.left, region.bottom - region.top); + } + + ~HudRenderTarget() + { + Dispose(disposing: false); + } + + /// + /// Begin rendering to this object, must be paired with EndRender + /// + public void BeginRender() + { + BeginRender(enableTextureFilter: false); + } + + /// + /// Begin rendering to this object, must be paired with EndRender + /// + /// True to enable texture filtering during rendering + public void BeginRender(bool enableTextureFilter) + { + if (!inRender) + { + myTarget.BeginRender(enableTextureFilter); + inRender = true; + return; + } + throw new RenderViolationException("Cannot call 'BeginRender' when already rendering"); + } + + /// + /// End rendering to this object, must be paired with BeginRender + /// + public void EndRender() + { + if (inRender) + { + myTarget.EndRender(); + inRender = false; + return; + } + throw new RenderViolationException("Cannot call 'EndRender' without a previous call to 'BeginRender'"); + } + + /// + /// Begin writing text + /// + /// Name of the font to use for writing text + /// Height in pixels to use when writing text + public void BeginText(string fontName, int pixelHeight) + { + BeginText(fontName, pixelHeight, FontWeight.Normal, italic: false); + } + + /// + /// Begin writing text + /// + /// Name of the font to use for writing text + /// Height in pixels to use when writing text + /// Bold, Strong, etc, indicator for text to be written + /// Write text in italics? + public void BeginText(string fontName, int pixelHeight, FontWeight weight, bool italic) + { + UnsafeBeginText(fontName, pixelHeight, (int)weight, italic); + } + + /// + /// Display text,using the full rectangle of the render target as the area. + /// This overload will draw the text in black. + /// + /// Text to display + public void WriteText(string text) + { + WriteText(text, Color.Black, WriteTextFormats.None, areaRect); + } + + /// + /// Display text,using the full rectangle of the render target as the area. + /// + /// Text to display + /// Color to use to display the text. (Including alpha channel) + public void WriteText(string text, Color color) + { + WriteText(text, color, WriteTextFormats.None, areaRect); + } + + /// + /// Display text,using the full rectangle of the render target as the area. + /// + /// Text to display + /// Color to use to display the text. (Including alpha channel) + /// Format specifiers, including centered, etc. + /// Rectangle relative to this object to use to bound the text + public void WriteText(string text, Color color, WriteTextFormats format, Rectangle region) + { + UnsafeWriteText(Util.toTagRECT(region), color.ToArgb(), (int)format, text); + } + + /// + /// Display text,using the full rectangle of the render target as the area. + /// + /// Text to display + /// Color to use to display the text. (Including alpha channel) + /// Format specifiers, including centered, etc. + /// Rectangle relative to this object to use to bound the text + public void WriteText(string text, int color, WriteTextFormats format, Rectangle region) + { + UnsafeWriteText(Util.toTagRECT(region), color, (int)format, text); + } + + /// + /// End drawing of text. + /// + public void EndText() + { + if (inRender && inText) + { + myTarget.EndText(); + inText = false; + return; + } + throw new RenderViolationException("Cannot call 'EndText' without a previous call to 'BeginText'"); + } + + public void Clear() + { + Clear(areaRect); + } + + public void Clear(Rectangle clearArea) + { + UnsafeClear(Util.toTagRECT(clearArea)); + } + + public void DrawPortalImage(int portalFile, Rectangle destinationArea) + { + UnsafeDrawPortalImage(portalFile, Util.toTagRECT(destinationArea)); + } + + public void DrawPortalImage(int portalFile, int alpha, Rectangle srcArea, Rectangle destinationArea) + { + UnsafeDrawPortalImage(portalFile, alpha, Util.toTagRECT(srcArea), Util.toTagRECT(destinationArea)); + } + + public void DrawPortalImage(int portalFile, Rectangle srcArea, Rectangle destinationArea) + { + UnsafeDrawPortalImage(portalFile, 255, Util.toTagRECT(srcArea), Util.toTagRECT(destinationArea)); + } + + public void TilePortalImage(int portalFile, Rectangle destinationArea) + { + UnsafeTilePortalImage(portalFile, Util.toTagRECT(destinationArea)); + } + + public void TilePortalImage(int portalFile, Rectangle srcArea, Rectangle destinationArea) + { + UnsafeTilePortalImage(portalFile, Util.toTagRECT(srcArea), Util.toTagRECT(destinationArea)); + } + + public void DrawImage(Image image, Rectangle destinationRegion) + { + DrawImage(image, destinationRegion, Color.Cyan.ToArgb()); + } + + public void DrawImage(Image image, Rectangle destinationRegion, Color colorKey) + { + DrawImage(image, destinationRegion, colorKey.ToArgb()); + } + + public void DrawImage(Image image, Rectangle destinationRegion, int colorKey) + { + if (image == null) + { + throw new ArgumentNullException("image"); + } + MemoryStream memoryStream = new MemoryStream(); + image.Save(memoryStream, ImageFormat.Bmp); + byte[] buffer = memoryStream.GetBuffer(); + IntPtr zero = IntPtr.Zero; + int num = buffer.Length; + zero = Marshal.AllocCoTaskMem(num); + try + { + Marshal.Copy(buffer, 0, zero, num); + if (zero != IntPtr.Zero) + { + UnsafeDrawImage(zero, num, Util.toTagRECT(destinationRegion), colorKey); + } + } + finally + { + Marshal.FreeCoTaskMem(zero); + memoryStream.Dispose(); + } + } + + public void Fill(Color color) + { + Fill(areaRect, color); + } + + public void Fill(Rectangle fillArea, Color color) + { + Fill(fillArea, color.ToArgb()); + } + + public void Fill(Rectangle fillArea, int color) + { + UnsafeFill(Util.toTagRECT(fillArea), color); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeBeginText(string fontName, int pixelHeight, int weight, bool italic) + { + if (inRender && !inText) + { + myTarget.BeginText(fontName, pixelHeight, weight, italic); + inText = true; + return; + } + if (inRender && inText) + { + throw new RenderViolationException("Cannot call 'BeginText' when already rendering text"); + } + throw new RenderViolationException("Cannot call 'BeginText' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeWriteText(tagRECT region, int color, int format, string text) + { + if (inRender && inText) + { + myTarget.WriteText(ref region, color, format, text); + return; + } + throw new RenderViolationException("Cannot call 'WriteText' outside of a BeginText/EndText block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeClear(tagRECT clearArea) + { + if (!inRender) + { + myTarget.Clear(ref clearArea); + return; + } + throw new RenderViolationException("MUST call 'Clear' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeDrawPortalImage(int portalFile, tagRECT destinationArea) + { + if (inRender) + { + myTarget.DrawPortalImage(portalFile, ref destinationArea); + return; + } + throw new RenderViolationException("Cannot call 'DrawPortalImage' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeDrawPortalImage(int portalFile, int alpha, tagRECT srcArea, tagRECT destinationArea) + { + if (inRender) + { + myTarget.DrawPortalImageEx(portalFile, alpha, ref srcArea, ref destinationArea); + return; + } + throw new RenderViolationException("Cannot call 'DrawPortalImageEx' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeTilePortalImage(int portalFile, tagRECT destinationArea) + { + if (inRender) + { + myTarget.TilePortalImage(portalFile, ref destinationArea); + return; + } + throw new RenderViolationException("Cannot call 'TilePortalImage' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeTilePortalImage(int portalFile, tagRECT srcArea, tagRECT destinationArea) + { + if (inRender) + { + myTarget.TilePortalImageEx(portalFile, ref srcArea, ref destinationArea); + return; + } + throw new RenderViolationException("Cannot call 'TilePortalImageEx' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeDrawImage(IntPtr buffer, int size, tagRECT destinationRegion, int colorKey) + { + if (inRender) + { + myTarget.DrawImage((int)buffer, size, ref destinationRegion, colorKey); + return; + } + throw new RenderViolationException("Cannot call 'DrawImage' outside of a BeginRender/EndRender block"); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeFill(tagRECT fillArea, int color) + { + if (!inRender) + { + myTarget.Fill(ref fillArea, color); + return; + } + throw new RenderViolationException("MUST call 'Fill' outside of a BeginRender/EndRender block"); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public void UnsafeSetSurface(object pSurface) + { + myTarget.SetSurface(pSurface); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myTarget != null) + { + Marshal.ReleaseComObject(myTarget); + } + myTarget = null; + isDisposed = true; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/IControlWrapper.cs b/Unused/Decal.Adapter.Wrappers/IControlWrapper.cs new file mode 100644 index 0000000..4f6f80a --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/IControlWrapper.cs @@ -0,0 +1,22 @@ +using System.ComponentModel; + +namespace Decal.Adapter.Wrappers; + +public interface IControlWrapper +{ + [EditorBrowsable(EditorBrowsableState.Never)] + object Underlying { get; } + + int Id { get; } + + int ChildCount { get; } + + [EditorBrowsable(EditorBrowsableState.Never)] + void Initialize(object control); + + [EditorBrowsable(EditorBrowsableState.Never)] + object ChildById(int id); + + [EditorBrowsable(EditorBrowsableState.Never)] + object ChildByIndex(int index); +} diff --git a/Unused/Decal.Adapter.Wrappers/IIndexedProvider.cs b/Unused/Decal.Adapter.Wrappers/IIndexedProvider.cs new file mode 100644 index 0000000..1508b88 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/IIndexedProvider.cs @@ -0,0 +1,12 @@ +using System.Collections; + +namespace Decal.Adapter.Wrappers; + +public interface IIndexedProvider +{ + object GetIndexedObject(IndexType index, int item); + + IEnumerator GetEnumerator(IndexType index); + + int Count(IndexType index); +} diff --git a/Unused/Decal.Adapter.Wrappers/IIndexedValueProvider.cs b/Unused/Decal.Adapter.Wrappers/IIndexedValueProvider.cs new file mode 100644 index 0000000..3be3502 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/IIndexedValueProvider.cs @@ -0,0 +1,6 @@ +namespace Decal.Adapter.Wrappers; + +internal interface IIndexedValueProvider +{ + int GetIndexedObject(hookIndexType index, int item); +} diff --git a/Unused/Decal.Adapter.Wrappers/IViewHandler.cs b/Unused/Decal.Adapter.Wrappers/IViewHandler.cs new file mode 100644 index 0000000..946a986 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/IViewHandler.cs @@ -0,0 +1,14 @@ +using System.Reflection; + +namespace Decal.Adapter.Wrappers; + +public interface IViewHandler +{ + ViewWrapper DefaultView { get; } + + BindingFlags BindingFlags { get; } + + void LoadView(string name, string resource); + + ViewWrapper GetView(string name); +} diff --git a/Unused/Decal.Adapter.Wrappers/IndexedCollection.cs b/Unused/Decal.Adapter.Wrappers/IndexedCollection.cs new file mode 100644 index 0000000..f2fc147 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/IndexedCollection.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Globalization; + +namespace Decal.Adapter.Wrappers; + +public sealed class IndexedCollection : MarshalByRefObject, IEnumerable, IEnumerable where InternalIndexType : struct, IConvertible where IndexType : struct, IConvertible +{ + private InternalIndexType myDataType; + + private IIndexedProvider myWrap; + + public RType this[IndexType index] => (RType)myWrap.GetIndexedObject(myDataType, index.ToInt32(CultureInfo.InvariantCulture)); + + public int Count => myWrap.Count(myDataType); + + internal IndexedCollection(IIndexedProvider wrap, InternalIndexType data) + { + myDataType = data; + myWrap = wrap; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return (IEnumerator)myWrap.GetEnumerator(myDataType); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return myWrap.GetEnumerator(myDataType); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ListColumn.cs b/Unused/Decal.Adapter.Wrappers/ListColumn.cs new file mode 100644 index 0000000..7938f4e --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ListColumn.cs @@ -0,0 +1,56 @@ +using System.Drawing; +using Decal.Adapter.Support; + +namespace Decal.Adapter.Wrappers; + +public class ListColumn +{ + private ListWrapper myList; + + private int rowIndex; + + private int colIndex; + + public object this[int subVal] + { + get + { + return myList.get_Data(rowIndex, colIndex, subVal); + } + set + { + myList.set_Data(rowIndex, colIndex, subVal, ref value); + } + } + + public Color Color + { + get + { + return Util.ColorFromBGR(myList.get_Color(rowIndex, colIndex)); + } + set + { + myList.set_Color(rowIndex, colIndex, Util.ColorToBGR(value)); + } + } + + public int Width + { + get + { + return myList.get_ColWidth(colIndex); + } + set + { + myList.set_ColWidth(colIndex, value); + } + } + + internal ListColumn(ListWrapper list, int row, int col) + { + myList = list; + rowIndex = row; + colIndex = col; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ListRow.cs b/Unused/Decal.Adapter.Wrappers/ListRow.cs new file mode 100644 index 0000000..ca0d118 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ListRow.cs @@ -0,0 +1,29 @@ +namespace Decal.Adapter.Wrappers; + +public class ListRow +{ + private ListWrapper myList; + + private int rowIndex; + + private int colCount; + + public ListColumn this[int column] + { + get + { + if (column >= 0 && column < colCount) + { + return new ListColumn(myList, rowIndex, column); + } + return null; + } + } + + internal ListRow(ListWrapper list, int row) + { + myList = list; + rowIndex = row; + colCount = myList.ColCount; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ListWrapper.cs b/Unused/Decal.Adapter.Wrappers/ListWrapper.cs new file mode 100644 index 0000000..c93ad19 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ListWrapper.cs @@ -0,0 +1,194 @@ +using System; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class ListWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + private EventHandler evtSelect; + + public ListRow this[int row] + { + get + { + if (row >= 0 && row < base.Control.Count) + { + return new ListRow(this, row); + } + return null; + } + } + + public bool AutoScroll + { + get + { + return base.Control.AutoScroll; + } + set + { + base.Control.AutoScroll = value; + } + } + + public int RowEstimate + { + set + { + base.Control.RowEstimate = value; + } + } + + public int ScrollPosition + { + get + { + return base.Control.ScrollPosition; + } + set + { + base.Control.ScrollPosition = value; + } + } + + public int RowCount => base.Control.Count; + + public int ColCount => base.Control.CountCols; + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Selected + { + add + { + if (evtSelect == null) + { + base.Control.Change += SelectEvent; + } + evtSelect = (EventHandler)Delegate.Combine(evtSelect, value); + } + remove + { + evtSelect = (EventHandler)Delegate.Remove(evtSelect, value); + if (evtSelect == null) + { + base.Control.Change -= SelectEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtSelect != null) + { + evtSelect = (EventHandler)Delegate.Remove(evtSelect, evtSelect); + base.Control.Change -= SelectEvent; + } + } + base.Dispose(disposing); + } + + internal int AddRow() + { + return base.Control.AddRow(); + } + + internal object get_Data(int row, int col, int subVal) + { + return base.Control.get_Data(col, row, subVal); + } + + internal void set_Data(int row, int col, int subVal, ref object val) + { + base.Control.set_Data(col, row, subVal, ref val); + } + + internal int get_Color(int row, int col) + { + return base.Control.get_Color(col, row); + } + + internal void set_Color(int row, int col, int color) + { + base.Control.set_Color(col, row, color); + } + + internal int get_ColWidth(int col) + { + return base.Control.get_ColumnWidth(col); + } + + internal void set_ColWidth(int col, int width) + { + base.Control.set_ColumnWidth(col, width); + } + + public ListRow Add() + { + return new ListRow(this, AddRow()); + } + + public ListRow Insert(int row) + { + base.Control.InsertRow(row); + return new ListRow(this, row); + } + + public void JumpToPosition(int row) + { + base.Control.JumpToPosition(row); + } + + public void Clear() + { + base.Control.Clear(); + } + + public void Delete(int index) + { + base.Control.DeleteRow(index); + } + + private void SelectEvent(int ID, int Col, int Row) + { + if (evtSelect != null) + { + evtSelect(new ListColumn(this, Row, Col), new ListSelectEventArgs(ID, Row, Col)); + } + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/LoginEventArgs.cs b/Unused/Decal.Adapter.Wrappers/LoginEventArgs.cs new file mode 100644 index 0000000..c8551e5 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/LoginEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class LoginEventArgs : EventArgs +{ + private int myId; + + public int Id => myId; + + internal LoginEventArgs(int Id) + { + myId = Id; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/LogoffEventArgs.cs b/Unused/Decal.Adapter.Wrappers/LogoffEventArgs.cs new file mode 100644 index 0000000..9afd010 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/LogoffEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class LogoffEventArgs : EventArgs +{ + private LogoffEventType myType; + + public LogoffEventType Type => myType; + + internal LogoffEventArgs(LogoffEventType type) + { + myType = type; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/LogoffEventType.cs b/Unused/Decal.Adapter.Wrappers/LogoffEventType.cs new file mode 100644 index 0000000..b976453 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/LogoffEventType.cs @@ -0,0 +1,10 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum LogoffEventType +{ + Requested, + Authorized +} diff --git a/Unused/Decal.Adapter.Wrappers/LongValueKey.cs b/Unused/Decal.Adapter.Wrappers/LongValueKey.cs new file mode 100644 index 0000000..502fdca --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/LongValueKey.cs @@ -0,0 +1,108 @@ +namespace Decal.Adapter.Wrappers; + +public enum LongValueKey +{ + Type = 218103808, + Icon = 218103809, + Container = 218103810, + Landblock = 218103811, + ItemSlots = 218103812, + PackSlots = 218103813, + StackCount = 218103814, + StackMax = 218103815, + AssociatedSpell = 218103816, + SlotLegacy = 218103817, + Wielder = 218103818, + WieldingSlot = 218103819, + Monarch = 218103820, + Coverage = 218103821, + EquipableSlots = 218103822, + EquipType = 218103823, + IconOutline = 218103824, + MissileType = 218103825, + UsageMask = 218103826, + HouseOwner = 218103827, + HookMask = 218103828, + HookType = 218103829, + Model = 218103830, + Flags = 218103831, + CreateFlags1 = 218103832, + CreateFlags2 = 218103833, + Category = 218103834, + Behavior = 218103835, + MagicDef = 218103836, + SpecialProps = 218103837, + SpellCount = 218103838, + WeapSpeed = 218103839, + EquipSkill = 218103840, + DamageType = 218103841, + MaxDamage = 218103842, + Unknown10 = 218103843, + Unknown100000 = 218103844, + Unknown800000 = 218103845, + Unknown8000000 = 218103846, + PhysicsDataFlags = 218103847, + ActiveSpellCount = 218103848, + IconOverlay = 218103849, + IconUnderlay = 218103850, + Species = 2, + Burden = 5, + EquippedSlots = 10, + RareId = 17, + Value = 19, + TotalValue = 20, + SkillCreditsAvail = 24, + CreatureLevel = 25, + RestrictedToToD = 26, + ArmorLevel = 28, + Rank = 30, + Bonded = 33, + NumberFollowers = 35, + Unenchantable = 36, + LockpickDifficulty = 38, + Deaths = 43, + WandElemDmgType = 45, + MinLevelRestrict = 86, + MaxLevelRestrict = 87, + LockpickSkillBonus = 88, + AffectsVitalId = 89, + AffectsVitalAmt = 90, + HealKitSkillBonus = 90, + UsesTotal = 91, + UsesRemaining = 92, + DateOfBirth = 98, + Workmanship = 105, + Spellcraft = 106, + CurrentMana = 107, + MaximumMana = 108, + LoreRequirement = 109, + RankRequirement = 110, + PortalRestrictions = 111, + Gender = 113, + Attuned = 114, + SkillLevelReq = 115, + ManaCost = 117, + Age = 125, + XPForVPReduction = 129, + Material = 131, + WieldReqType = 158, + WieldReqAttribute = 159, + WieldReqValue = 160, + SlayerSpecies = 166, + NumberItemsSalvagedFrom = 170, + NumberTimesTinkered = 171, + DescriptionFormat = 172, + PagesUsed = 174, + PagesTotal = 175, + ActivationReqSkillId = 176, + GemSettingQty = 177, + GemSettingType = 178, + Imbued = 179, + Heritage = 188, + FishingSkill = 192, + KeysHeld = 193, + ElementalDmgBonus = 204, + CleaveType = 263, + ArmorSet = 265, + Slot = 231735296 +} diff --git a/Unused/Decal.Adapter.Wrappers/MoveObjectEventArgs.cs b/Unused/Decal.Adapter.Wrappers/MoveObjectEventArgs.cs new file mode 100644 index 0000000..35ea2f3 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/MoveObjectEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class MoveObjectEventArgs : EventArgs +{ + private WorldObject myMovedObject; + + public WorldObject Moved => myMovedObject; + + internal MoveObjectEventArgs(WorldObject movedObject) + { + myMovedObject = movedObject; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/NetServiceHost.cs b/Unused/Decal.Adapter.Wrappers/NetServiceHost.cs new file mode 100644 index 0000000..ae3916a --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/NetServiceHost.cs @@ -0,0 +1,43 @@ +using System; +using System.ComponentModel; +using Decal.Interop.Net; + +namespace Decal.Adapter.Wrappers; + +public sealed class NetServiceHost : HostBase +{ + private NetService myService; + + [EditorBrowsable(EditorBrowsableState.Never)] + public NetService Underlying => myService; + + public DecalWrapper Decal + { + get + { + if (base.MyDecal == null) + { + base.MyDecal = new DecalWrapper(myService.Decal); + } + return base.MyDecal; + } + } + + public HooksWrapper Actions => CoreManager.Current.Actions; + + internal NetServiceHost(NetService svc) + { + myService = svc; + base.MyDecal = new DecalWrapper(myService.Decal); + } + + public object GetComFilter(string progId) + { + return ((INetService)myService).get_FilterVB(progId); + } + + public object GetComFilter(Guid clsid, Guid riid) + { + return ((INetService)myService).get_Filter(ref clsid, ref riid); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/NotebookWrapper.cs b/Unused/Decal.Adapter.Wrappers/NotebookWrapper.cs new file mode 100644 index 0000000..e507033 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/NotebookWrapper.cs @@ -0,0 +1,117 @@ +using System; +using Decal.Interop.Controls; +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +public class NotebookWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + private EventHandler evtChange; + + private PageTextIndexer myPageIndex; + + public int ActiveTab + { + get + { + return base.Control.ActiveTab; + } + set + { + base.Control.ActiveTab = value; + } + } + + public PageTextIndexer PageText => myPageIndex; + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Change + { + add + { + if (evtChange == null) + { + base.Control.Change += ChangeEvent; + } + evtChange = (EventHandler)Delegate.Combine(evtChange, value); + } + remove + { + evtChange = (EventHandler)Delegate.Remove(evtChange, value); + if (evtChange == null) + { + base.Control.Change -= ChangeEvent; + } + } + } + + public override void Initialize(object control) + { + base.Initialize(control); + myPageIndex = new PageTextIndexer(base.Control); + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtChange != null) + { + evtChange = (EventHandler)Delegate.Remove(evtChange, evtChange); + base.Control.Change -= ChangeEvent; + } + if (myPageIndex != null) + { + myPageIndex.Dispose(); + } + } + base.Dispose(disposing); + } + + public void AddPage(string text, IControl control) + { + base.Control.AddPage(text, control); + } + + private void ChangeEvent(int ID, int Index) + { + if (evtChange != null) + { + evtChange(this, new IndexChangeEventArgs(ID, Index)); + } + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ObjectClass.cs b/Unused/Decal.Adapter.Wrappers/ObjectClass.cs new file mode 100644 index 0000000..f87c6a4 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ObjectClass.cs @@ -0,0 +1,49 @@ +namespace Decal.Adapter.Wrappers; + +public enum ObjectClass +{ + Unknown, + MeleeWeapon, + Armor, + Clothing, + Jewelry, + Monster, + Food, + Money, + Misc, + MissileWeapon, + Container, + Gem, + SpellComponent, + Key, + Portal, + TradeNote, + ManaStone, + Plant, + BaseCooking, + BaseAlchemy, + BaseFletching, + CraftedCooking, + CraftedAlchemy, + CraftedFletching, + Player, + Vendor, + Door, + Corpse, + Lifestone, + HealingKit, + Lockpick, + WandStaffOrb, + Bundle, + Book, + Journal, + Sign, + Housing, + Npc, + Foci, + Salvage, + Ust, + Services, + Scroll, + NumObjectClasses +} diff --git a/Unused/Decal.Adapter.Wrappers/PageTextIndexer.cs b/Unused/Decal.Adapter.Wrappers/PageTextIndexer.cs new file mode 100644 index 0000000..fef8159 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/PageTextIndexer.cs @@ -0,0 +1,31 @@ +using System; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public sealed class PageTextIndexer : IDisposable +{ + private NotebookClass myControl; + + public string this[int index] + { + get + { + return myControl.get_PageText(index); + } + set + { + myControl.set_PageText(index, value); + } + } + + internal PageTextIndexer(NotebookClass control) + { + myControl = control; + } + + public void Dispose() + { + myControl = null; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/PlayerModifyEventType.cs b/Unused/Decal.Adapter.Wrappers/PlayerModifyEventType.cs new file mode 100644 index 0000000..ff5eb5e --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/PlayerModifyEventType.cs @@ -0,0 +1,14 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum PlayerModifyEventType +{ + Skill, + Attribute, + Vital, + Statistic, + Allegiance, + Augmentation +} diff --git a/Unused/Decal.Adapter.Wrappers/PlayerXPEventType.cs b/Unused/Decal.Adapter.Wrappers/PlayerXPEventType.cs new file mode 100644 index 0000000..6418f1e --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/PlayerXPEventType.cs @@ -0,0 +1,10 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum PlayerXPEventType +{ + Total, + Unassigned +} diff --git a/Unused/Decal.Adapter.Wrappers/PluginHost.cs b/Unused/Decal.Adapter.Wrappers/PluginHost.cs new file mode 100644 index 0000000..82b8ca9 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/PluginHost.cs @@ -0,0 +1,202 @@ +using System; +using System.ComponentModel; +using System.IO; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Xml; +using Decal.Interop.Core; +using Decal.Interop.Inject; +using Decal.Interop.Render; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public sealed class PluginHost : HostBase +{ + private IPluginSite2 mySite; + + private IPluginSite myOldSite; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public IPluginSite2 Underlying => mySite; + + /// + /// Wrapped Decal OM + /// + public DecalWrapper Decal + { + get + { + if (base.MyDecal == null) + { + base.MyDecal = new DecalWrapper(mySite.Decal); + } + return base.MyDecal; + } + } + + /// + /// Wrapped version of the ACHooks interface + /// + public HooksWrapper Actions => CoreManager.Current.Actions; + + /// + /// Wrapped version of the DecalRenderService + /// + public RenderServiceWrapper Render + { + get + { + if (base.MyRender == null) + { + base.MyRender = new RenderServiceWrapper((RenderService)GetObject("services\\DecalRender.RenderService")); + } + return base.MyRender; + } + } + + internal PluginHost(PluginSite2 pSite) + { + mySite = pSite; + base.MyDecal = new DecalWrapper(mySite.Decal); + myOldSite = (IPluginSite)mySite.PluginSite; + } + + protected override void Dispose(bool disposing) + { + try + { + _ = base.IsDisposed; + if (myOldSite != null) + { + Marshal.ReleaseComObject(myOldSite); + myOldSite = null; + } + if (mySite != null) + { + Marshal.ReleaseComObject(mySite); + mySite = null; + } + } + finally + { + base.Dispose(disposing); + } + } + + /// + /// Function to get a COM object by path from Decal. + /// + /// The decal services path to resolve the COM object + /// instance of the object requested + public object GetObject(string path) + { + return mySite.get_Object(path); + } + + /// + /// Get Mapped Keyboard Key + /// + /// Name to retrive mapping for. + /// Mapped Key + public int GetKeyboardMapping(string name) + { + return myOldSite.QueryKeyboardMap(name); + } + + /// + /// Initializes an already exisint viewhandler (plugins) + /// + /// the handler to init + internal static void LoadViewHandler(IViewHandler handler) + { + if (ViewWrapper.ScanViews(handler)) + { + ViewWrapper.ScanControls(handler); + ViewWrapper.ScanReferences(handler); + } + } + + /// + /// Load a view handler of the specified type + /// + /// type of handler to load + /// the new handler + public ViewHandler LoadViewHandler(Type handlerType) + { + ViewHandler obj = (ViewHandler)Activator.CreateInstance(handlerType, this); + LoadViewHandler(obj); + obj.LoadComplete(); + return obj; + } + + /// + /// Load a view in the current assembly using the specified resource + /// + /// path of the embedded view xml resource + /// the new view + public ViewWrapper LoadViewResource(string resourcePath) + { + Assembly callingAssembly = Assembly.GetCallingAssembly(); + return LoadViewResource(resourcePath, callingAssembly); + } + + /// + /// Load a view in the specified assembly using the specified resource + /// + /// path of the embedded view xml resource + /// assembly containing the resource + /// the new view + public ViewWrapper LoadViewResource(string resourcePath, Assembly resourceAssembly) + { + if (null == resourceAssembly) + { + throw new ArgumentNullException("resourceAssembly"); + } + Stream manifestResourceStream = resourceAssembly.GetManifestResourceStream(resourcePath); + XmlDocument xmlDocument = new XmlDocument(); + xmlDocument.Load(manifestResourceStream); + return LoadView(xmlDocument.OuterXml); + } + + /// + /// Load a view from the specified XML element + /// + /// XmlElement containing the view schema + /// the new view + public ViewWrapper LoadView(XmlElement viewSchema) + { + if (viewSchema == null) + { + throw new ArgumentNullException("viewSchema"); + } + return LoadView(viewSchema.OuterXml); + } + + /// + /// Load a view from the specified XML string + /// + /// string containing the view schema + /// the new view + public ViewWrapper LoadView(string viewSchema) + { + View view = myOldSite.LoadView(viewSchema); + if (view != null) + { + return new ViewWrapper(view); + } + return null; + } + + /// + /// Get a COM based filter object. + /// (Similar to GetObject, but requires only ProgID instead of full path) + /// + /// + /// + public object ComFilter(string progId) + { + return mySite.get_Object("services\\DecalNet.NetService\\" + progId); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/PortalEventType.cs b/Unused/Decal.Adapter.Wrappers/PortalEventType.cs new file mode 100644 index 0000000..ded6cfe --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/PortalEventType.cs @@ -0,0 +1,10 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum PortalEventType +{ + EnterPortal, + ExitPortal +} diff --git a/Unused/Decal.Adapter.Wrappers/ProgressWrapper.cs b/Unused/Decal.Adapter.Wrappers/ProgressWrapper.cs new file mode 100644 index 0000000..b7b7e44 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ProgressWrapper.cs @@ -0,0 +1,211 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class ProgressWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + private string alignment; + + private Color borderColor; + + private int borderWidth; + + private bool drawText; + + private Color faceColor; + + private Color fillColor; + + private int maxValue; + + private string preText; + + private string postText; + + private Color textColor; + + public string Alignment + { + get + { + return alignment; + } + set + { + alignment = value; + base.Control.Alignment = value; + } + } + + public Color BorderColor + { + get + { + return borderColor; + } + set + { + borderColor = value; + base.Control.BorderColor = Util.ColorToBGR(value); + } + } + + public int BorderWidth + { + get + { + return borderWidth; + } + set + { + borderWidth = value; + base.Control.BorderWidth = value; + } + } + + public bool DrawText + { + get + { + return drawText; + } + set + { + drawText = value; + base.Control.DecalDrawText = value; + } + } + + public Color FaceColor + { + get + { + return faceColor; + } + set + { + faceColor = value; + base.Control.FaceColor = Util.ColorToBGR(value); + } + } + + public Color FillColor + { + get + { + return fillColor; + } + set + { + fillColor = value; + base.Control.FillColor = Util.ColorToBGR(value); + } + } + + public int MaxValue + { + get + { + return maxValue; + } + set + { + maxValue = value; + base.Control.MaxValue = value; + } + } + + public string PostText + { + get + { + return postText; + } + set + { + postText = value; + base.Control.PostText = value; + } + } + + public string PreText + { + get + { + return preText; + } + set + { + preText = value; + base.Control.PreText = value; + } + } + + public Color TextColor + { + get + { + return textColor; + } + set + { + textColor = value; + base.Control.TextColor = Util.ColorToBGR(value); + } + } + + public int Value + { + get + { + return base.Control.Value; + } + set + { + base.Control.Value = value; + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing && evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + base.Dispose(disposing); + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/PushButtonWrapper.cs b/Unused/Decal.Adapter.Wrappers/PushButtonWrapper.cs new file mode 100644 index 0000000..04861c6 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/PushButtonWrapper.cs @@ -0,0 +1,228 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class PushButtonWrapper : ControlWrapperBase +{ + private EventHandler evtClick; + + private EventHandler evtCancel; + + private EventHandler evtDestroy; + + private EventHandler evtHit; + + private EventHandler evtUnhit; + + public Color FaceColor + { + get + { + return Util.ColorFromBGR(base.Control.FaceColor); + } + set + { + base.Control.FaceColor = Util.ColorToBGR(value); + } + } + + public Color TextColor + { + get + { + return Util.ColorFromBGR(base.Control.TextColor); + } + set + { + base.Control.TextColor = Util.ColorToBGR(value); + } + } + + public string Text + { + get + { + return base.Control.Text; + } + set + { + base.Control.Text = value; + } + } + + public event EventHandler Click + { + add + { + if (evtClick == null) + { + base.Control.Accepted += ClickEvent; + } + evtClick = (EventHandler)Delegate.Combine(evtClick, value); + } + remove + { + evtClick = (EventHandler)Delegate.Remove(evtClick, value); + if (evtClick == null) + { + base.Control.Accepted -= ClickEvent; + } + } + } + + public event EventHandler Canceled + { + add + { + if (evtCancel == null) + { + base.Control.Canceled += CanceledEvent; + } + evtCancel = (EventHandler)Delegate.Combine(evtCancel, value); + } + remove + { + evtCancel = (EventHandler)Delegate.Remove(evtCancel, value); + if (evtCancel == null) + { + base.Control.Canceled -= CanceledEvent; + } + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Hit + { + add + { + if (evtHit == null) + { + base.Control.Hit += HitEvent; + } + evtHit = (EventHandler)Delegate.Combine(evtHit, value); + } + remove + { + evtHit = (EventHandler)Delegate.Remove(evtHit, value); + if (evtHit == null) + { + base.Control.Hit -= HitEvent; + } + } + } + + public event EventHandler Unhit + { + add + { + if (evtUnhit == null) + { + base.Control.Unhit += UnhitEvent; + } + evtUnhit = (EventHandler)Delegate.Combine(evtUnhit, value); + } + remove + { + evtUnhit = (EventHandler)Delegate.Remove(evtUnhit, value); + if (evtUnhit == null) + { + base.Control.Unhit -= UnhitEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtClick != null) + { + evtClick = (EventHandler)Delegate.Remove(evtClick, evtClick); + base.Control.Accepted -= ClickEvent; + } + if (evtCancel != null) + { + evtCancel = (EventHandler)Delegate.Remove(evtCancel, evtCancel); + base.Control.Canceled -= CanceledEvent; + } + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtHit != null) + { + evtHit = (EventHandler)Delegate.Remove(evtHit, evtHit); + base.Control.Hit -= HitEvent; + } + if (evtUnhit != null) + { + evtUnhit = (EventHandler)Delegate.Remove(evtUnhit, evtUnhit); + base.Control.Unhit -= UnhitEvent; + } + } + base.Dispose(disposing); + } + + private void ClickEvent(int ID) + { + if (evtClick != null) + { + evtClick(this, new ControlEventArgs(ID)); + } + } + + private void UnhitEvent(int ID) + { + if (evtUnhit != null) + { + evtUnhit(this, new ControlEventArgs(ID)); + } + } + + private void HitEvent(int ID) + { + if (evtHit != null) + { + evtHit(this, new ControlEventArgs(ID)); + } + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } + + private void CanceledEvent(int ID) + { + if (evtCancel != null) + { + evtCancel(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ReleaseObjectEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ReleaseObjectEventArgs.cs new file mode 100644 index 0000000..ef9f8f9 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ReleaseObjectEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ReleaseObjectEventArgs : EventArgs +{ + private WorldObject mWO; + + public WorldObject Released => mWO; + + internal ReleaseObjectEventArgs(WorldObject releasedObject) + { + mWO = releasedObject; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/RenderServiceWrapper.cs b/Unused/Decal.Adapter.Wrappers/RenderServiceWrapper.cs new file mode 100644 index 0000000..bf764c8 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/RenderServiceWrapper.cs @@ -0,0 +1,149 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Runtime.InteropServices; +using Decal.Adapter.Support; +using Decal.Interop.Core; +using Decal.Interop.Inject; +using Decal.Interop.Render; + +namespace Decal.Adapter.Wrappers; + +/// +/// RenderServiceWrapper is a wrapper for RenderService +/// +[CLSCompliant(true)] +public class RenderServiceWrapper : MarshalByRefObject, IDisposable +{ + private RenderService internalRender; + + private bool isDisposed; + + private EventHandler myDeviceLost; + + [EditorBrowsable(EditorBrowsableState.Never)] + public object UnsafeDevice => internalRender.Device; + + internal event EventHandler DeviceLost + { + add + { + myDeviceLost = (EventHandler)Delegate.Combine(myDeviceLost, value); + } + remove + { + myDeviceLost = (EventHandler)Delegate.Combine(myDeviceLost, value); + } + } + + internal RenderServiceWrapper(RenderService render) + { + internalRender = render; + internalRender.DeviceLost += internalRender_DeviceLost; + } + + ~RenderServiceWrapper() + { + Dispose(disposing: false); + } + + private void internalRender_DeviceLost() + { + if (myDeviceLost != null) + { + myDeviceLost(this, new EventArgs()); + } + } + + private void myHUD_Disposing(object sender, EventArgs e) + { + if (sender is Hud hud) + { + RemoveHud(hud); + hud.Disposing -= myHUD_Disposing; + } + } + + /// + /// Create a new Background object to be used as a background in HUDS + /// + /// The rectangle to use for the size of the background + /// Newly created and wrapped RenderService.HUDBackground + public Background CreateBackground(Rectangle region) + { + return UnsafeCreateBackground(Util.toTagRECT(region)); + } + + /// + /// Create a new HUD. New huds need to be made visible before they render. + /// + /// Size and location of where the HUD should be rendered + /// Newly created and wrapped RenderService.HUDView + public Hud CreateHud(Rectangle region) + { + return UnsafeCreateHud(Util.toTagRECT(region)); + } + + /// + /// Remove a HUD from the render pipeline + /// + /// HUD To remove + public void RemoveHud(Hud hud) + { + if (hud == null) + { + throw new ArgumentNullException("hud"); + } + internalRender.RemoveHUD(hud.Underlying); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Background UnsafeCreateBackground(tagRECT pRegion) + { + return new Background(internalRender.CreateBackground(ref pRegion)); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Hud UnsafeCreateHud(tagRECT pRegion) + { + Hud hud = new Hud(internalRender.CreateHUD(ref pRegion)); + hud.Disposing += myHUD_Disposing; + return hud; + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Background EncapsulateBackground(tagPOINT coordinates, object surface) + { + return new Background(internalRender.EncapsulateBackground(ref coordinates, surface)); + } + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Hud EncapsulateHud(tagPOINT coordinates, object surface) + { + return new Hud(internalRender.EncapsulateHUD(ref coordinates, surface)); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed && disposing) + { + internalRender.DeviceLost -= internalRender_DeviceLost; + } + if (internalRender != null) + { + Marshal.ReleaseComObject(internalRender); + } + internalRender = null; + isDisposed = true; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ResetTradeEventArgs.cs b/Unused/Decal.Adapter.Wrappers/ResetTradeEventArgs.cs new file mode 100644 index 0000000..129f73b --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ResetTradeEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class ResetTradeEventArgs : EventArgs +{ + private int mTraderId; + + public int TraderId => mTraderId; + + internal ResetTradeEventArgs(int TraderId) + { + mTraderId = TraderId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/SettingsEventArgs.cs b/Unused/Decal.Adapter.Wrappers/SettingsEventArgs.cs new file mode 100644 index 0000000..81b115c --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/SettingsEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class SettingsEventArgs : EventArgs +{ + private int mySetting; + + public int Setting => mySetting; + + internal SettingsEventArgs(int Setting) + { + mySetting = Setting; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/SkillInfoWrapper.cs b/Unused/Decal.Adapter.Wrappers/SkillInfoWrapper.cs new file mode 100644 index 0000000..b292a03 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/SkillInfoWrapper.cs @@ -0,0 +1,91 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class SkillInfoWrapper : MarshalByRefObject, IDisposable +{ + private SkillInfo mySkillInfo; + + private TrainingType myTraining; + + private bool isDisposed; + + public int Base => mySkillInfo.Base; + + public int Bonus => mySkillInfo.Bonus; + + public int Buffed => mySkillInfo.Buffed; + + public int Current => mySkillInfo.Current; + + public int XP => mySkillInfo.Exp; + + public string Formula => mySkillInfo.Formula; + + public int Increment => mySkillInfo.Increment; + + public bool Known => mySkillInfo.Known; + + public string Name => mySkillInfo.Name; + + public string ShortName => mySkillInfo.ShortName; + + public TrainingType Training => myTraining; + + internal SkillInfoWrapper(SkillInfo info) + { + mySkillInfo = info; + switch (info.Training) + { + case eTrainingType.eTrainUnusable: + myTraining = TrainingType.Unusable; + break; + case eTrainingType.eTrainUntrained: + myTraining = TrainingType.Untrained; + break; + case eTrainingType.eTrainTrained: + myTraining = TrainingType.Trained; + break; + case eTrainingType.eTrainSpecialized: + myTraining = TrainingType.Specialized; + break; + default: + myTraining = TrainingType.Unusable; + break; + } + } + + ~SkillInfoWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (mySkillInfo != null) + { + Marshal.ReleaseComObject(mySkillInfo); + } + isDisposed = true; + } + + protected void EnforceDisposedOnce() + { + if (isDisposed) + { + throw new ObjectDisposedException("SkillInfoWrapper"); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/SkillType.cs b/Unused/Decal.Adapter.Wrappers/SkillType.cs new file mode 100644 index 0000000..820eeff --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/SkillType.cs @@ -0,0 +1,86 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum SkillType +{ + CurrentMeleeDefense = 6, + CurrentMissileDefense = 7, + CurrentArcaneLore = 14, + CurrentMagicDefense = 15, + CurrentManaConversion = 16, + CurrentItemTinkering = 18, + CurrentAssessPerson = 19, + CurrentDeception = 20, + CurrentHealing = 21, + CurrentJump = 22, + CurrentLockpick = 23, + CurrentRun = 24, + CurrentAssessCreature = 27, + CurrentWeaponTinkering = 28, + CurrentArmorTinkering = 29, + CurrentMagicItemTinkering = 30, + CurrentCreatureEnchantment = 31, + CurrentItemEnchantment = 32, + CurrentLifeMagic = 33, + CurrentWarMagic = 34, + CurrentLeadership = 35, + CurrentLoyalty = 36, + CurrentFletchingSkill = 37, + CurrentAlchemySkill = 38, + CurrentCookingSkill = 39, + CurrentSkillSalvaging = 40, + CurrentTwoHandedCombat = 41, + CurrentGearcraft = 42, + CurrentVoidMagic = 43, + CurrentHeavyWeapons = 44, + CurrentLightWeapons = 45, + CurrentFinesseWeapons = 46, + CurrentMissileWeapons = 47, + CurrentShield = 48, + CurrentDualWield = 49, + CurrentRecklessness = 50, + CurrentSneakAttack = 51, + CurrentDirtyFighting = 52, + CurrentSummoning = 54, + BaseMeleeDefense = 56, + BaseMissileDefense = 57, + BaseArcaneLore = 64, + BaseMagicDefense = 65, + BaseManaConversion = 66, + BaseItemTinkering = 68, + BaseAssessPerson = 69, + BaseDeception = 70, + BaseHealing = 71, + BaseJump = 72, + BaseLockpick = 73, + BaseRun = 74, + BaseAssessCreature = 77, + BaseWeaponTinkering = 78, + BaseArmorTinkering = 79, + BaseMagicItemTinkering = 80, + BaseCreatureEnchantment = 81, + BaseItemEnchantment = 82, + BaseLifeMagic = 83, + BaseWarMagic = 84, + BaseLeadership = 85, + BaseLoyalty = 86, + BaseFletchingSkill = 87, + BaseAlchemySkill = 88, + BaseCookingSkill = 89, + BaseSkillSalvaging = 90, + BaseTwoHandedCombat = 91, + BaseGearcraft = 92, + BaseVoidMagic = 93, + BaseHeavyWeapons = 94, + BaseLightWeapons = 95, + BaseFinesseWeapons = 96, + BaseMissileWeapons = 97, + BaseShield = 98, + BaseDualWield = 99, + BaseRecklessness = 100, + BaseSneakAttack = 101, + BaseDirtyFighting = 102, + BaseSummoning = 104 +} diff --git a/Unused/Decal.Adapter.Wrappers/SliderWrapper.cs b/Unused/Decal.Adapter.Wrappers/SliderWrapper.cs new file mode 100644 index 0000000..1c48f30 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/SliderWrapper.cs @@ -0,0 +1,151 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class SliderWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + private EventHandler evtChange; + + public int Maximum + { + get + { + return base.Control.Maximum; + } + set + { + base.Control.Maximum = value; + } + } + + public int Minimum + { + get + { + return base.Control.Minimum; + } + set + { + base.Control.Minimum = value; + } + } + + [Obsolete("Use Position")] + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public int SliderPostition + { + get + { + return base.Control.SliderPosition; + } + set + { + base.Control.SliderPosition = value; + } + } + + public int Position + { + get + { + return base.Control.SliderPosition; + } + set + { + base.Control.SliderPosition = value; + } + } + + public Color TextColor + { + get + { + return Util.ColorFromBGR(base.Control.TextColor); + } + set + { + base.Control.TextColor = Util.ColorToBGR(value); + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Change + { + add + { + if (evtChange == null) + { + base.Control.Change += ChangeEvent; + } + evtChange = (EventHandler)Delegate.Combine(evtChange, value); + } + remove + { + evtChange = (EventHandler)Delegate.Remove(evtChange, value); + if (evtChange == null) + { + base.Control.Change -= ChangeEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtChange != null) + { + evtChange = (EventHandler)Delegate.Remove(evtChange, evtChange); + base.Control.Change -= ChangeEvent; + } + } + base.Dispose(disposing); + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } + + private void ChangeEvent(int ID, int Index) + { + if (evtChange != null) + { + evtChange(this, new IndexChangeEventArgs(ID, Index)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/SpellCastEventArgs.cs b/Unused/Decal.Adapter.Wrappers/SpellCastEventArgs.cs new file mode 100644 index 0000000..69eb040 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/SpellCastEventArgs.cs @@ -0,0 +1,35 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class SpellCastEventArgs : EventArgs +{ + private CastEventType mtype; + + private int mSpellId; + + private int mTargetId; + + public int SpellId => mSpellId; + + public int TargetId => mTargetId; + + public CastEventType EventType + { + get + { + return mtype; + } + set + { + mtype = value; + } + } + + internal SpellCastEventArgs(CastEventType type, int spellId, int targetId) + { + mtype = type; + mSpellId = spellId; + mTargetId = targetId; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/SpellbookEventArgs.cs b/Unused/Decal.Adapter.Wrappers/SpellbookEventArgs.cs new file mode 100644 index 0000000..25b9926 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/SpellbookEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class SpellbookEventArgs : EventArgs +{ + private AddRemoveEventType myType; + + private int mySpell; + + public AddRemoveEventType Type => myType; + + public int Spell => mySpell; + + internal SpellbookEventArgs(AddRemoveEventType type, int spell) + { + myType = type; + mySpell = spell; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/StaticWrapper.cs b/Unused/Decal.Adapter.Wrappers/StaticWrapper.cs new file mode 100644 index 0000000..126df88 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/StaticWrapper.cs @@ -0,0 +1,73 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class StaticWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + public string Text + { + get + { + return base.Control.Text; + } + set + { + base.Control.Text = value; + } + } + + public Color TextColor + { + get + { + return Util.ColorFromBGR(base.Control.TextColor); + } + set + { + base.Control.TextColor = Util.ColorToBGR(value); + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing && evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + base.Dispose(disposing); + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/StatusMessageEventArgs.cs b/Unused/Decal.Adapter.Wrappers/StatusMessageEventArgs.cs new file mode 100644 index 0000000..b3cd119 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/StatusMessageEventArgs.cs @@ -0,0 +1,20 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +public class StatusMessageEventArgs : EventArgs +{ + private int myType; + + private string myText; + + public int Type => myType; + + public string Text => myText; + + internal StatusMessageEventArgs(int Type, string Text) + { + myType = Type; + myText = Text; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/StringValueKey.cs b/Unused/Decal.Adapter.Wrappers/StringValueKey.cs new file mode 100644 index 0000000..548e09e --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/StringValueKey.cs @@ -0,0 +1,22 @@ +namespace Decal.Adapter.Wrappers; + +public enum StringValueKey +{ + SecondaryName = 184549376, + Name = 1, + Title = 5, + Inscription = 7, + InscribedBy = 8, + FellowshipName = 10, + UsageInstructions = 14, + SimpleDescription = 15, + FullDescription = 16, + MonarchName = 21, + OnlyActivatedBy = 25, + Patron = 35, + PortalDestination = 38, + LastTinkeredBy = 39, + ImbuedBy = 40, + DateBorn = 43, + MonarchyTitle = 47 +} diff --git a/Unused/Decal.Adapter.Wrappers/TextBoxWrapper.cs b/Unused/Decal.Adapter.Wrappers/TextBoxWrapper.cs new file mode 100644 index 0000000..9056799 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/TextBoxWrapper.cs @@ -0,0 +1,220 @@ +using System; +using System.Drawing; +using Decal.Adapter.Support; +using Decal.Interop.Controls; + +namespace Decal.Adapter.Wrappers; + +public class TextBoxWrapper : ControlWrapperBase +{ + private EventHandler evtDestroy; + + private EventHandler evtBegin; + + private EventHandler evtChange; + + private EventHandler evtEnd; + + public int Caret + { + get + { + return base.Control.Caret; + } + set + { + base.Control.Caret = value; + } + } + + public string SelectedText + { + get + { + return base.Control.SelectedText; + } + set + { + base.Control.SelectedText = value; + } + } + + public string Text + { + get + { + return base.Control.Text; + } + set + { + base.Control.Text = value; + } + } + + public Color TextColor + { + get + { + return Util.ColorFromBGR(base.Control.TextColor); + } + set + { + base.Control.TextColor = Util.ColorToBGR(value); + } + } + + public event EventHandler Destroy + { + add + { + if (evtDestroy == null) + { + base.Control.Destroy += DestroyEvent; + } + evtDestroy = (EventHandler)Delegate.Combine(evtDestroy, value); + } + remove + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, value); + if (evtDestroy == null) + { + base.Control.Destroy -= DestroyEvent; + } + } + } + + public event EventHandler Begin + { + add + { + if (evtBegin == null) + { + base.Control.Begin += BeginEvent; + } + evtBegin = (EventHandler)Delegate.Combine(evtBegin, value); + } + remove + { + evtBegin = (EventHandler)Delegate.Remove(evtBegin, value); + if (evtBegin == null) + { + base.Control.Begin -= BeginEvent; + } + } + } + + public event EventHandler Change + { + add + { + if (evtChange == null) + { + base.Control.Change += ChangeEvent; + } + evtChange = (EventHandler)Delegate.Combine(evtChange, value); + } + remove + { + evtChange = (EventHandler)Delegate.Remove(evtChange, value); + if (evtChange == null) + { + base.Control.Change -= ChangeEvent; + } + } + } + + public event EventHandler End + { + add + { + if (evtEnd == null) + { + base.Control.End += EndEvent; + } + evtEnd = (EventHandler)Delegate.Combine(evtEnd, value); + } + remove + { + evtEnd = (EventHandler)Delegate.Remove(evtEnd, value); + if (evtEnd == null) + { + base.Control.End -= EndEvent; + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + if (evtBegin != null) + { + evtBegin = (EventHandler)Delegate.Remove(evtBegin, evtBegin); + base.Control.Begin -= BeginEvent; + } + if (evtDestroy != null) + { + evtDestroy = (EventHandler)Delegate.Remove(evtDestroy, evtDestroy); + base.Control.Destroy -= DestroyEvent; + } + if (evtChange != null) + { + evtChange = (EventHandler)Delegate.Remove(evtChange, evtChange); + base.Control.Change -= ChangeEvent; + } + if (evtEnd != null) + { + evtEnd = (EventHandler)Delegate.Remove(evtEnd, evtEnd); + base.Control.End -= EndEvent; + } + } + base.Dispose(disposing); + } + + public void Capture() + { + base.Control.Capture(); + } + + public void Select(int start, int end) + { + base.Control.Select(start, end); + } + + public void SetMargins(int x, int y) + { + base.Control.SetMargins(x, y); + } + + private void DestroyEvent(int ID) + { + if (evtDestroy != null) + { + evtDestroy(this, new ControlEventArgs(ID)); + } + } + + private void BeginEvent(int ID) + { + if (evtBegin != null) + { + evtBegin(this, new ControlEventArgs(ID)); + } + } + + private void ChangeEvent(int ID, string text) + { + if (evtChange != null) + { + evtChange(this, new TextBoxChangeEventArgs(ID, text)); + } + } + + private void EndEvent(int ID, bool success) + { + if (evtEnd != null) + { + evtEnd(this, new TextBoxEndEventArgs(ID, success)); + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/TrainingType.cs b/Unused/Decal.Adapter.Wrappers/TrainingType.cs new file mode 100644 index 0000000..0cf9913 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/TrainingType.cs @@ -0,0 +1,12 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum TrainingType +{ + Unusable, + Untrained, + Trained, + Specialized +} diff --git a/Unused/Decal.Adapter.Wrappers/UIElementType.cs b/Unused/Decal.Adapter.Wrappers/UIElementType.cs new file mode 100644 index 0000000..16d0c2d --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/UIElementType.cs @@ -0,0 +1,23 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum UIElementType +{ + Smartbox = 268436634, + Chat = 268436993, + FloatChat1 = 268436741, + FloatChat2 = 268436750, + FloatChat3 = 268436751, + FloatChat4 = 268436752, + Examination = 268436983, + Vitals = 268436986, + EnvPack = 268436989, + Panels = 268436991, + TBar = 268436995, + Indicators = 268437009, + ProgressBar = 268437011, + Combat = 268437173, + Radar = 268437202 +} diff --git a/Unused/Decal.Adapter.Wrappers/Vector3Object.cs b/Unused/Decal.Adapter.Wrappers/Vector3Object.cs new file mode 100644 index 0000000..cba34a9 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/Vector3Object.cs @@ -0,0 +1,74 @@ +namespace Decal.Adapter.Wrappers; + +public class Vector3Object +{ + private double mX; + + private double mY; + + private double mZ; + + public double X => mX; + + public double Y => mY; + + public double Z => mZ; + + public Vector3Object(double x, double y, double z) + { + mX = x; + mY = y; + mZ = z; + } + + public override string ToString() + { + return "{X = " + mX + ", Y = " + mY + ", Z = " + mZ + "}"; + } + + public override bool Equals(object obj) + { + if (obj is Vector3Object) + { + Vector3Object vector3Object = (Vector3Object)obj; + if (mX == vector3Object.mX && mY == vector3Object.mY) + { + return mZ == vector3Object.mZ; + } + return false; + } + return false; + } + + public bool Equals(Vector3Object obj) + { + if (obj == null) + { + return false; + } + if (mX == obj.mX && mY == obj.mY) + { + return mZ == obj.mZ; + } + return false; + } + + public override int GetHashCode() + { + return mX.GetHashCode() ^ mY.GetHashCode() ^ mZ.GetHashCode(); + } + + public static bool operator ==(Vector3Object a, Vector3Object b) + { + if (object.Equals(a, null)) + { + return object.Equals(b, null); + } + return a.Equals(b); + } + + public static bool operator !=(Vector3Object a, Vector3Object b) + { + return !(a == b); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/Vector4Object.cs b/Unused/Decal.Adapter.Wrappers/Vector4Object.cs new file mode 100644 index 0000000..bcc2b67 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/Vector4Object.cs @@ -0,0 +1,79 @@ +namespace Decal.Adapter.Wrappers; + +public class Vector4Object +{ + private double mW; + + private double mX; + + private double mY; + + private double mZ; + + public double W => mW; + + public double X => mX; + + public double Y => mY; + + public double Z => mZ; + + public Vector4Object(double w, double x, double y, double z) + { + mW = w; + mX = x; + mY = y; + mZ = z; + } + + public override string ToString() + { + return "{W = " + mW + ", X = " + mX + ", Y = " + mY + ", Z = " + mZ + "}"; + } + + public override bool Equals(object obj) + { + if (obj is Vector4Object) + { + Vector4Object vector4Object = (Vector4Object)obj; + if (mW == vector4Object.mW && mX == vector4Object.mX && mY == vector4Object.mY) + { + return mZ == vector4Object.mZ; + } + return false; + } + return false; + } + + public bool Equals(Vector4Object obj) + { + if (obj == null) + { + return false; + } + if (mW == obj.mW && mX == obj.mX && mY == obj.mY) + { + return mZ == obj.mZ; + } + return false; + } + + public override int GetHashCode() + { + return mW.GetHashCode() ^ mX.GetHashCode() ^ mY.GetHashCode() ^ mZ.GetHashCode(); + } + + public static bool operator ==(Vector4Object a, Vector4Object b) + { + if (object.Equals(a, null)) + { + return object.Equals(b, null); + } + return a.Equals(b); + } + + public static bool operator !=(Vector4Object a, Vector4Object b) + { + return !(a == b); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/Vendor.cs b/Unused/Decal.Adapter.Wrappers/Vendor.cs new file mode 100644 index 0000000..f8bf175 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/Vendor.cs @@ -0,0 +1,234 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +public class Vendor : GenericDisposableWrapper, IEnumerable, IEnumerable +{ + public class VendorEnumerator : IEnumerator, IDisposable, IEnumerator + { + private Vendor vendor; + + private WorldObject current; + + public WorldObject Current + { + get + { + if (current == null) + { + MoveNext(); + } + return current; + } + } + + object IEnumerator.Current + { + get + { + if (current == null) + { + MoveNext(); + } + return current; + } + } + + internal VendorEnumerator(Vendor vendor) + { + this.vendor = vendor; + } + + ~VendorEnumerator() + { + Dispose(userCalled: false); + } + + public void Dispose() + { + Dispose(userCalled: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool userCalled) + { + if (vendor != null) + { + Reset(); + vendor = null; + } + } + + public bool MoveNext() + { + Decal.Interop.Filters.WorldObject ppObject = null; + bool num = vendor.Wrapped.Next(ref ppObject); + if (num && ppObject != null) + { + current = vendor.GetCachedObject(ppObject); + } + return num; + } + + public void Reset() + { + vendor.Wrapped.Reset(); + } + } + + private WorldFilter wf; + + private DisposableObjectDictionary objectCache; + + private IEnumerator oldstyleenumerator; + + /// + /// The indentifier for this merchant + /// + public int MerchantId => base.Wrapped.MerchantID; + + /// + /// The maximum value of an item this vendor will purchase + /// + public int MaxValue => base.Wrapped.BuyValue; + + /// + /// The rate at which this vendor sells items + /// + public float SellRate => base.Wrapped.SellRate; + + /// + /// The rate at which this vendor buys items + /// + public float BuyRate => base.Wrapped.BuyRate; + + /// + /// The item categories that this vendor buys + /// + public int Categories => base.Wrapped.BuyCategories; + + /// + /// Returns the number of items in the collection + /// + public int Count => base.Wrapped.Count; + + /// + /// Returns the number of items represented by the collection, taking into account stacks of items. + /// + public int Quantity => base.Wrapped.Quantity; + + public WorldObject First + { + get + { + using IEnumerator enumerator = GetEnumerator(); + return enumerator.Current; + } + } + + [Obsolete("Use enumerators")] + [EditorBrowsable(EditorBrowsableState.Never)] + public WorldObject Current + { + get + { + if (oldstyleenumerator == null) + { + oldstyleenumerator = GetEnumerator(); + } + return oldstyleenumerator.Current; + } + } + + public WorldObject this[int id] + { + get + { + WorldObject value = null; + if (!objectCache.TryGetValue(id, out value)) + { + Decal.Interop.Filters.WorldObject byID = base.Wrapped.GetByID(id); + if (byID != null) + { + value = new WorldObject(byID); + objectCache.Add(value.Id, value); + } + } + return value; + } + } + + public Vendor(WorldFilter wf, Decal.Interop.Filters.Vendor obj) + : base(obj) + { + this.wf = wf; + objectCache = new DisposableObjectDictionary("Id"); + } + + protected override void Dispose(bool userCalled) + { + if (oldstyleenumerator != null) + { + oldstyleenumerator.Dispose(); + oldstyleenumerator = null; + } + objectCache.Clear(); + base.Dispose(userCalled); + } + + internal WorldObject GetCachedObject(Decal.Interop.Filters.WorldObject iwo) + { + WorldObject value = null; + if (!objectCache.TryGetValue(iwo.GUID, out value)) + { + value = new WorldObject(iwo); + objectCache.Add(value.Id, value); + } + return value; + } + + /// + /// Apply a filter to this collection to limit what it returns + /// + /// filter object + public void SetFilter(WorldObjectCollectionFilter filter) + { + filter?.ApplyFilter(base.Wrapped); + } + + [Obsolete("Use enumerators")] + [EditorBrowsable(EditorBrowsableState.Never)] + public bool MoveNext() + { + if (oldstyleenumerator == null) + { + oldstyleenumerator = GetEnumerator(); + } + return oldstyleenumerator.MoveNext(); + } + + [Obsolete("Use enumerators")] + [EditorBrowsable(EditorBrowsableState.Never)] + public void Reset() + { + if (oldstyleenumerator == null) + { + oldstyleenumerator = GetEnumerator(); + } + oldstyleenumerator.Reset(); + } + + public IEnumerator GetEnumerator() + { + return new VendorEnumerator(this); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return new VendorEnumerator(this); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ViewControls.cs b/Unused/Decal.Adapter.Wrappers/ViewControls.cs new file mode 100644 index 0000000..58965a4 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ViewControls.cs @@ -0,0 +1,72 @@ +using System; +using System.Collections.Generic; +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class ViewControls : MarshalByRefObject, IDisposable +{ + private ViewWrapper myParent; + + private Dictionary myControls; + + private bool isDisposed; + + [CLSCompliant(false)] + public IControlWrapper this[string controlName] + { + get + { + if (myControls.ContainsKey(controlName)) + { + return myControls[controlName]; + } + IControlWrapper controlWrapper = ControlRegistry.CreateInstance(myParent[controlName]); + myControls.Add(controlName, controlWrapper); + return controlWrapper; + } + set + { + if (value == null) + { + throw new ArgumentNullException("value"); + } + myControls[controlName] = value; + myParent[controlName] = value.Underlying as IControl; + } + } + + internal ViewControls(ViewWrapper parent) + { + myParent = parent; + myControls = new Dictionary(); + } + + ~ViewControls() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool disposing) + { + if (!isDisposed && disposing && myParent != null) + { + foreach (IControlWrapper value in myControls.Values) + { + if (value is IDisposable disposable) + { + disposable.Dispose(); + } + } + myParent = null; + } + isDisposed = true; + } +} diff --git a/Unused/Decal.Adapter.Wrappers/ViewWrapper.cs b/Unused/Decal.Adapter.Wrappers/ViewWrapper.cs new file mode 100644 index 0000000..3be7c27 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/ViewWrapper.cs @@ -0,0 +1,279 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Decal.Adapter.Support; +using Decal.Interop.Core; +using Decal.Interop.Inject; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public class ViewWrapper : MarshalByRefObject, IDisposable +{ + private View myView; + + private ViewControls myControls; + + private bool isDisposed; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public View Underlying => myView; + + public bool Activated + { + get + { + return myView.Activated; + } + set + { + myView.Activated = value; + } + } + + public int Alpha + { + get + { + return myView.Alpha; + } + set + { + myView.Alpha = value; + } + } + + public string Title + { + get + { + return myView.Title; + } + set + { + myView.Title = value; + } + } + + public bool Transparent + { + get + { + return myView.Transparent; + } + set + { + myView.Transparent = value; + } + } + + [CLSCompliant(false)] + public IControl this[string controlName] + { + get + { + return ((IView)myView).get_Control(controlName); + } + set + { + ((IView)myView).set_Control(controlName, value); + } + } + + public ViewControls Controls => myControls; + + public Rectangle Position + { + get + { + return Util.toRectangle(myView.Position); + } + set + { + tagRECT pVal = Util.toTagRECT(value); + myView.Position = ref pVal; + } + } + + internal ViewWrapper(View vw) + { + myView = vw; + myControls = new ViewControls(this); + } + + ~ViewWrapper() + { + Dispose(disposing: false); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool disposing) + { + if (!isDisposed) + { + } + if (myView != null) + { + myControls.Dispose(); + Marshal.ReleaseComObject(myView); + myView = null; + } + isDisposed = true; + } + + public void Activate() + { + myView.Activate(); + } + + public void Alert() + { + myView.Alert(); + } + + public void Deactivate() + { + myView.Deactivate(); + } + + [CLSCompliant(false)] + public int LoadControl(Layer parent, int id, object xmlSource) + { + return myView.LoadControl(parent, id, xmlSource); + } + + public void LoadSchema(string xmlSchema) + { + myView.LoadSchema(xmlSchema); + } + + public void SetIcon(int icon, object iconLibrary) + { + myView.SetIcon(icon, iconLibrary); + } + + /// + /// Reads the class's view attributes and loads the requested views + /// + /// handler to scan + /// True when views are created, False otherwise + internal static bool ScanViews(IViewHandler handler) + { + Type type = handler.GetType(); + bool result = false; + object[] customAttributes = type.GetCustomAttributes(typeof(ViewAttribute), inherit: false); + foreach (object obj in customAttributes) + { + try + { + ViewAttribute viewAttribute = (ViewAttribute)obj; + handler.LoadView(viewAttribute.ViewName, viewAttribute.Resource); + result = true; + } + catch (Exception ex) + { + Util.WriteLine("ScanViews Exception: " + ex.Message); + } + } + return result; + } + + /// + /// Reads the class for ControlEvents and hooks them up + /// + /// handler to scan + internal static void ScanControls(IViewHandler handler) + { + MethodInfo[] methods = handler.GetType().GetMethods(handler.BindingFlags); + foreach (MethodInfo methodInfo in methods) + { + object[] customAttributes = methodInfo.GetCustomAttributes(typeof(ControlEventAttribute), inherit: false); + foreach (object obj in customAttributes) + { + try + { + ControlEventAttribute controlEventAttribute = (ControlEventAttribute)obj; + IControlWrapper controlWrapper = handler.GetView(controlEventAttribute.ViewName).Controls[controlEventAttribute.Control]; + EventInfo eventInfo = controlWrapper.GetType().GetEvent(controlEventAttribute.EventName); + eventInfo.AddEventHandler(controlWrapper, Delegate.CreateDelegate(eventInfo.EventHandlerType, handler, methodInfo.Name)); + } + catch (Exception ex) + { + Util.WriteLine("ScanControls Exception: " + ex.Message); + } + } + } + } + + /// + /// Reads the class for ControlReferences and adds them + /// + /// handler to scan + internal static void ScanReferences(IViewHandler handler) + { + Type type = handler.GetType(); + Type typeFromHandle = typeof(AccessedThroughPropertyAttribute); + Type typeFromHandle2 = typeof(ControlReferenceAttribute); + Type typeFromHandle3 = typeof(ControlReferenceArrayAttribute); + FieldInfo[] fields = type.GetFields(handler.BindingFlags); + foreach (FieldInfo fieldInfo in fields) + { + try + { + IControlWrapper controlWrapper = null; + if (!fieldInfo.FieldType.IsArray && Attribute.IsDefined(fieldInfo, typeFromHandle2)) + { + ControlReferenceAttribute controlReferenceAttribute = (ControlReferenceAttribute)Attribute.GetCustomAttribute(fieldInfo, typeFromHandle2); + controlWrapper = handler.GetView(controlReferenceAttribute.ViewName).Controls[controlReferenceAttribute.Control]; + if (!(controlWrapper.GetType() != fieldInfo.FieldType)) + { + object value = Convert.ChangeType(controlWrapper, fieldInfo.FieldType); + if (Attribute.IsDefined(fieldInfo, typeFromHandle)) + { + AccessedThroughPropertyAttribute accessedThroughPropertyAttribute = (AccessedThroughPropertyAttribute)Attribute.GetCustomAttribute(fieldInfo, typeFromHandle); + type.GetProperty(accessedThroughPropertyAttribute.PropertyName, handler.BindingFlags).SetValue(handler, value, null); + } + else + { + fieldInfo.SetValue(handler, value); + } + } + } + else + { + if (!Attribute.IsDefined(fieldInfo, typeFromHandle3)) + { + continue; + } + ControlReferenceArrayAttribute controlReferenceArrayAttribute = (ControlReferenceArrayAttribute)Attribute.GetCustomAttribute(fieldInfo, typeFromHandle3); + ViewWrapper view = handler.GetView(controlReferenceArrayAttribute.ViewName); + Type elementType = fieldInfo.FieldType.GetElementType(); + Array array = Array.CreateInstance(elementType, controlReferenceArrayAttribute.Controls.Count); + for (int j = 0; j < controlReferenceArrayAttribute.Controls.Count; j++) + { + controlWrapper = view.Controls[controlReferenceArrayAttribute.Controls[j]]; + if (elementType.IsAssignableFrom(controlWrapper.GetType())) + { + array.SetValue(controlWrapper, j); + } + } + fieldInfo.SetValue(handler, array); + continue; + } + } + catch (Exception ex) + { + Util.WriteLine("ScanReferences Exception: " + ex.Message); + } + } + } +} diff --git a/Unused/Decal.Adapter.Wrappers/VitalType.cs b/Unused/Decal.Adapter.Wrappers/VitalType.cs new file mode 100644 index 0000000..e80b5ff --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/VitalType.cs @@ -0,0 +1,17 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +[CLSCompliant(true)] +public enum VitalType +{ + MaximumHealth = 1, + CurrentHealth, + MaximumStamina, + CurrentStamina, + MaximumMana, + CurrentMana, + BaseHealth, + BaseStamina, + BaseMana +} diff --git a/Unused/Decal.Adapter.Wrappers/WorldChangeType.cs b/Unused/Decal.Adapter.Wrappers/WorldChangeType.cs new file mode 100644 index 0000000..0af486d --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/WorldChangeType.cs @@ -0,0 +1,10 @@ +namespace Decal.Adapter.Wrappers; + +public enum WorldChangeType +{ + SizeChange, + StorageChange, + IdentReceived, + VendorIdentReceived, + ManaChange +} diff --git a/Unused/Decal.Adapter.Wrappers/WorldFilter.cs b/Unused/Decal.Adapter.Wrappers/WorldFilter.cs new file mode 100644 index 0000000..2f62df7 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/WorldFilter.cs @@ -0,0 +1,531 @@ +using System; +using Decal.Adapter.Support; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +public class WorldFilter : GenericDisposableWrapper +{ + private DisposableObjectDictionary worldObjectCache; + + private EventHandler mAcceptTrade; + + private EventHandler mAddTradeItem; + + private EventHandler mApproachVendor; + + private EventHandler mChangeObject; + + private EventHandler mCreateObject; + + private EventHandler mDeclineTrade; + + private EventHandler mEndTrade; + + private EventHandler mEnterTrade; + + private EventHandler mFailToAddTradeItem; + + private EventHandler mFailToCompleteTrade; + + private EventHandler mMoveObject; + + private EventHandler mReleaseDone; + + private EventHandler mReleaseObject; + + private EventHandler mResetTrade; + + public WorldObject this[int guid] => GetCachedWorldObject(guid); + + /// + /// Returns the currently open vendor object. You **MUST** dispose this object when finished with it. + /// + public Vendor OpenVendor + { + get + { + Decal.Interop.Filters.Vendor vendor = base.Wrapped.Vendor; + if (vendor != null) + { + return new Vendor(this, vendor); + } + return null; + } + } + + [CLSCompliant(false)] + public event EventHandler AcceptTrade + { + add + { + mAcceptTrade = (EventHandler)Delegate.Combine(mAcceptTrade, value); + } + remove + { + mAcceptTrade = (EventHandler)Delegate.Remove(mAcceptTrade, value); + } + } + + [CLSCompliant(false)] + public event EventHandler AddTradeItem + { + add + { + mAddTradeItem = (EventHandler)Delegate.Combine(mAddTradeItem, value); + } + remove + { + mAddTradeItem = (EventHandler)Delegate.Remove(mAddTradeItem, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ApproachVendor + { + add + { + mApproachVendor = (EventHandler)Delegate.Combine(mApproachVendor, value); + } + remove + { + mApproachVendor = (EventHandler)Delegate.Remove(mApproachVendor, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChangeObject + { + add + { + mChangeObject = (EventHandler)Delegate.Combine(mChangeObject, value); + } + remove + { + mChangeObject = (EventHandler)Delegate.Remove(mChangeObject, value); + } + } + + [CLSCompliant(false)] + public event EventHandler CreateObject + { + add + { + mCreateObject = (EventHandler)Delegate.Combine(mCreateObject, value); + } + remove + { + mCreateObject = (EventHandler)Delegate.Remove(mCreateObject, value); + } + } + + [CLSCompliant(false)] + public event EventHandler DeclineTrade + { + add + { + mDeclineTrade = (EventHandler)Delegate.Combine(mDeclineTrade, value); + } + remove + { + mDeclineTrade = (EventHandler)Delegate.Remove(mDeclineTrade, value); + } + } + + [CLSCompliant(false)] + public event EventHandler EndTrade + { + add + { + mEndTrade = (EventHandler)Delegate.Combine(mEndTrade, value); + } + remove + { + mEndTrade = (EventHandler)Delegate.Remove(mEndTrade, value); + } + } + + [CLSCompliant(false)] + public event EventHandler EnterTrade + { + add + { + mEnterTrade = (EventHandler)Delegate.Combine(mEnterTrade, value); + } + remove + { + mEnterTrade = (EventHandler)Delegate.Remove(mEnterTrade, value); + } + } + + [CLSCompliant(false)] + public event EventHandler FailToAddTradeItem + { + add + { + mFailToAddTradeItem = (EventHandler)Delegate.Combine(mFailToAddTradeItem, value); + } + remove + { + mFailToAddTradeItem = (EventHandler)Delegate.Remove(mFailToAddTradeItem, value); + } + } + + [CLSCompliant(false)] + public event EventHandler FailToCompleteTrade + { + add + { + mFailToCompleteTrade = (EventHandler)Delegate.Combine(mFailToCompleteTrade, value); + } + remove + { + mFailToCompleteTrade = (EventHandler)Delegate.Remove(mFailToCompleteTrade, value); + } + } + + [CLSCompliant(false)] + public event EventHandler MoveObject + { + add + { + mMoveObject = (EventHandler)Delegate.Combine(mMoveObject, value); + } + remove + { + mMoveObject = (EventHandler)Delegate.Remove(mMoveObject, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ReleaseDone + { + add + { + mReleaseDone = (EventHandler)Delegate.Combine(mReleaseDone, value); + } + remove + { + mReleaseDone = (EventHandler)Delegate.Remove(mReleaseDone, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ReleaseObject + { + add + { + mReleaseObject = (EventHandler)Delegate.Combine(mReleaseObject, value); + } + remove + { + mReleaseObject = (EventHandler)Delegate.Remove(mReleaseObject, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ResetTrade + { + add + { + mResetTrade = (EventHandler)Delegate.Combine(mResetTrade, value); + } + remove + { + mResetTrade = (EventHandler)Delegate.Remove(mResetTrade, value); + } + } + + public WorldFilter(World obj) + : base(obj) + { + worldObjectCache = new DisposableObjectDictionary("Id"); + base.Wrapped.AcceptTrade += myWF_AcceptTrade; + base.Wrapped.AddTradeItem += myWF_AddTradeItem; + base.Wrapped.ApproachVendor += myWF_ApproachVendor; + base.Wrapped.ChangeObject += myWF_ChangeObject; + base.Wrapped.CreateObject += myWF_CreateObject; + base.Wrapped.DeclineTrade += myWF_DeclineTrade; + base.Wrapped.EndTrade += myWF_EndTrade; + base.Wrapped.EnterTrade += myWF_EnterTrade; + base.Wrapped.FailToAddTradeItem += myWF_FailToAddTradeItem; + base.Wrapped.FailToCompleteTrade += myWF_FailToCompleteTrade; + base.Wrapped.MoveObject += myWF_MoveObject; + base.Wrapped.ReleaseDone += myWF_ReleaseDone; + base.Wrapped.ReleaseObject += myWF_ReleaseObject; + base.Wrapped.ResetTrade += myWF_ResetTrade; + CoreManager.Current.PluginTermComplete += corePluginTermComplete; + } + + protected override void Dispose(bool userCalled) + { + if (userCalled && base.Wrapped != null) + { + ClearCache(); + base.Wrapped.AcceptTrade -= myWF_AcceptTrade; + base.Wrapped.AddTradeItem -= myWF_AddTradeItem; + base.Wrapped.ApproachVendor -= myWF_ApproachVendor; + base.Wrapped.ChangeObject -= myWF_ChangeObject; + base.Wrapped.CreateObject -= myWF_CreateObject; + base.Wrapped.DeclineTrade -= myWF_DeclineTrade; + base.Wrapped.EndTrade -= myWF_EndTrade; + base.Wrapped.EnterTrade -= myWF_EnterTrade; + base.Wrapped.FailToAddTradeItem -= myWF_FailToAddTradeItem; + base.Wrapped.FailToCompleteTrade -= myWF_FailToCompleteTrade; + base.Wrapped.MoveObject -= myWF_MoveObject; + base.Wrapped.ReleaseDone -= myWF_ReleaseDone; + base.Wrapped.ReleaseObject -= myWF_ReleaseObject; + base.Wrapped.ResetTrade -= myWF_ResetTrade; + CoreManager.Current.PluginTermComplete -= corePluginTermComplete; + worldObjectCache.Dispose(); + } + base.Dispose(userCalled); + } + + private void ClearCache() + { + worldObjectCache.Clear(); + } + + private void corePluginTermComplete(object sender, EventArgs e) + { + ClearCache(); + } + + private void myWF_AcceptTrade(int TargetID) + { + Util.SafeFireEvent(this, mAcceptTrade, new AcceptTradeEventArgs(TargetID)); + } + + private void myWF_AddTradeItem(int ItemId, int SideId) + { + Util.SafeFireEvent(this, mAddTradeItem, new AddTradeItemEventArgs(ItemId, SideId)); + } + + private void myWF_ApproachVendor(int MerchantId) + { + Vendor openVendor = OpenVendor; + Util.SafeFireEvent(this, mApproachVendor, new ApproachVendorEventArgs(MerchantId, openVendor)); + openVendor.Dispose(); + } + + private void myWF_ChangeObject(Decal.Interop.Filters.WorldObject pObject, Decal.Interop.Filters.WorldChangeType Change) + { + WorldObject worldObject = null; + if (Change != Decal.Interop.Filters.WorldChangeType.wevtVendorIdentReceived) + { + worldObject = GetCachedWorldObject(pObject); + Util.SafeFireEvent(this, mChangeObject, new ChangeObjectEventArgs(worldObject, Change)); + return; + } + using Vendor vendor = OpenVendor; + worldObject = vendor.GetCachedObject(pObject); + Util.SafeFireEvent(this, mChangeObject, new ChangeObjectEventArgs(worldObject, Change)); + } + + private void myWF_CreateObject(Decal.Interop.Filters.WorldObject pObject) + { + WorldObject cachedWorldObject = GetCachedWorldObject(pObject); + Util.SafeFireEvent(this, mCreateObject, new CreateObjectEventArgs(cachedWorldObject)); + } + + private void myWF_DeclineTrade(int TraderId) + { + Util.SafeFireEvent(this, mDeclineTrade, new DeclineTradeEventArgs(TraderId)); + } + + private void myWF_EndTrade(int ReasonId) + { + Util.SafeFireEvent(this, mEndTrade, new EndTradeEventArgs(ReasonId)); + } + + private void myWF_EnterTrade(int TraderId, int TradeeId) + { + Util.SafeFireEvent(this, mEnterTrade, new EnterTradeEventArgs(TraderId, TradeeId)); + } + + private void myWF_FailToAddTradeItem(int ItemId, int ReasonId) + { + Util.SafeFireEvent(this, mFailToAddTradeItem, new FailToAddTradeItemEventArgs(ItemId, ReasonId)); + } + + private void myWF_FailToCompleteTrade() + { + Util.SafeFireEvent(this, mFailToCompleteTrade, new EventArgs()); + } + + private void myWF_MoveObject(Decal.Interop.Filters.WorldObject pObject) + { + WorldObject cachedWorldObject = GetCachedWorldObject(pObject); + Util.SafeFireEvent(this, mMoveObject, new MoveObjectEventArgs(cachedWorldObject)); + } + + private void myWF_ReleaseDone() + { + Util.SafeFireEvent(this, mReleaseDone, new EventArgs()); + } + + private void myWF_ReleaseObject(Decal.Interop.Filters.WorldObject pObject) + { + if (pObject != null) + { + WorldObject cachedWorldObject = GetCachedWorldObject(pObject); + Util.SafeFireEvent(this, mReleaseObject, new ReleaseObjectEventArgs(cachedWorldObject)); + cachedWorldObject.Dispose(); + } + } + + private void myWF_ResetTrade(int TraderId) + { + Util.SafeFireEvent(this, mResetTrade, new ResetTradeEventArgs(TraderId)); + } + + internal WorldObject GetCachedWorldObject(Decal.Interop.Filters.WorldObject iwo) + { + WorldObject value = null; + if (!worldObjectCache.TryGetValue(iwo.GUID, out value)) + { + value = new WorldObject(iwo); + worldObjectCache.Add(value.Id, value); + } + return value; + } + + internal WorldObject GetCachedWorldObject(int id) + { + WorldObject value = null; + if (!worldObjectCache.TryGetValue(id, out value)) + { + Decal.Interop.Filters.WorldObject worldObject = base.Wrapped[id]; + if (worldObject != null) + { + value = new WorldObject(worldObject); + worldObjectCache.Add(value.Id, value); + } + } + return value; + } + + /// + /// Returns the 2D distance between two items + /// + /// Id of the first item + /// Id of the second item + /// The distance between the items + public double Distance(int id1, int id2) + { + return Distance(id1, id2, use3d: false); + } + + /// + /// Returns the distance between two items + /// + /// Id of the first item + /// Id of the second item + /// Whether or not height is taken into account + /// The distance between the items + public double Distance(int id1, int id2, bool use3d) + { + if (use3d) + { + return base.Wrapped.Distance3D(id1, id2); + } + return base.Wrapped.Distance2D(id1, id2); + } + + private WorldObjectCollection wrapIterator(WorldIterator wi) + { + if (wi != null) + { + return new WorldObjectCollection(this, wi); + } + return null; + } + + /// + /// Gets all of the items in the player's inventory. + /// + /// WorldObjectCollection containing the items in the character's inventory + public WorldObjectCollection GetInventory() + { + return wrapIterator(base.Wrapped.Inventory); + } + + /// + /// Gets all of the items known to WorldFilter. + /// + /// WorldObjectCollection containing all of the items in the world + public WorldObjectCollection GetAll() + { + return wrapIterator(base.Wrapped.All); + } + + /// + /// Gets all of the items known to WorldFilter that don't have a container. + /// + /// WorldObjectCollection containing all of the items on the landscape + public WorldObjectCollection GetLandscape() + { + return wrapIterator(base.Wrapped.Landscape); + } + + /// + /// Gets all of the items in the given container. + /// + /// Id of the container + /// WorldObjectCollection containing the items in the container + public WorldObjectCollection GetByContainer(int container) + { + return wrapIterator(((IWorld)base.Wrapped).get_ByContainer(container)); + } + + /// + /// Gets all of the items with the specified category. + /// + /// Category + /// WorldObjectCollection containing the items in the category + public WorldObjectCollection GetByCategory(int category) + { + return wrapIterator(((IWorld)base.Wrapped).get_ByCategory(category)); + } + + /// + /// Gets all of the items that have the specified name. + /// + /// Name of the items + /// WorldObjectCollection containing the items with the name + public WorldObjectCollection GetByName(string name) + { + return wrapIterator(((IWorld)base.Wrapped).get_ByName(name)); + } + + /// + /// Gets all of the items with names that contain the specified string. + /// + /// Partial name of items + /// WorldObjectCollection containing the items with the name part + public WorldObjectCollection GetByNameSubstring(string name) + { + return wrapIterator(((IWorld)base.Wrapped).get_ByNameSubstring(name)); + } + + /// + /// Gets all of the items in the object class + /// + /// class of the objects + /// WorldObjectCollection containing the items in the class + public WorldObjectCollection GetByObjectClass(ObjectClass objClass) + { + return wrapIterator(((IWorld)base.Wrapped).get_ByObjectClass((eObjectClass)objClass)); + } + + /// + /// Gets the items owned by the specified character + /// + /// Id of the owning character + /// WorldObjectCollection containing the items owned by the character + public WorldObjectCollection GetByOwner(int owner) + { + return wrapIterator(((IWorld)base.Wrapped).get_ByOwner(owner)); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/WorldObject.cs b/Unused/Decal.Adapter.Wrappers/WorldObject.cs new file mode 100644 index 0000000..c473215 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/WorldObject.cs @@ -0,0 +1,407 @@ +using System.Collections.Generic; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines an object in the world +/// +public class WorldObject : GenericDisposableWrapper +{ + /// + /// Gets the number of active spells on this object. + /// + public int ActiveSpellCount => Values(LongValueKey.ActiveSpellCount); + + /// + /// Gets the number of spells that this object casts. + /// + public int SpellCount => Values(LongValueKey.SpellCount); + + public int Behavior => base.Wrapped.Behavior; + + public int Category => base.Wrapped.Category; + + public int Container => base.Wrapped.Container; + + public int GameDataFlags1 => base.Wrapped.GameDataFlags1; + + public int Id => base.Wrapped.GUID; + + public bool HasIdData => base.Wrapped.HasIdData; + + public int Icon => base.Wrapped.Icon; + + public int LastIdTime => base.Wrapped.LastIdTime; + + public string Name => base.Wrapped.Name; + + public ObjectClass ObjectClass => (ObjectClass)base.Wrapped.ObjectClass; + + public int PhysicsDataFlags => base.Wrapped.PhysicsDataFlags; + + public int Type => base.Wrapped.Type; + + public List BoolKeys + { + get + { + List list = new List(); + int num = 0; + for (int num2 = base.Wrapped.EnumBoolKey(0); num2 != -1; num2 = base.Wrapped.EnumBoolKey(num)) + { + list.Add(num2); + num++; + } + if (base.Wrapped.Bools((Decal.Interop.Filters.BoolValueKey)(-1))) + { + list.Add(-1); + } + return list; + } + } + + public List LongKeys + { + get + { + List list = new List(); + int num = 0; + for (int num2 = base.Wrapped.EnumLongKey(0); num2 != -1; num2 = base.Wrapped.EnumLongKey(num)) + { + list.Add(num2); + num++; + } + if (base.Wrapped.Longs((Decal.Interop.Filters.LongValueKey)(-1), -1) != -1) + { + list.Add(-1); + } + return list; + } + } + + public List DoubleKeys + { + get + { + List list = new List(); + int num = 0; + for (int num2 = base.Wrapped.EnumDoubleKey(0); num2 != -1; num2 = base.Wrapped.EnumDoubleKey(num)) + { + list.Add(num2); + num++; + } + if (base.Wrapped.Doubles((Decal.Interop.Filters.DoubleValueKey)(-1), -1.0) != -1.0) + { + list.Add(-1); + } + return list; + } + } + + public List StringKeys + { + get + { + List list = new List(); + int num = 0; + for (int num2 = base.Wrapped.EnumStringKey(0); num2 != -1; num2 = base.Wrapped.EnumStringKey(num)) + { + list.Add(num2); + num++; + } + if (!base.Wrapped.Strings((Decal.Interop.Filters.StringValueKey)(-1), "-1").Equals("-1")) + { + list.Add(-1); + } + return list; + } + } + + public WorldObject(Decal.Interop.Filters.WorldObject obj) + : base(obj) + { + } + + /// + /// Gets the spell ID of one of the active spells on this object. + /// + /// The index in the list of active spells. + /// The spell ID. + public int ActiveSpell(int index) + { + return base.Wrapped.ActiveSpell(index); + } + + /// + /// Determines whether this object has the specified property. + /// + /// The property to check. + /// true if this object has the specified property. + public bool Exists(BoolValueKey index) + { + bool pValue; + return base.Wrapped.BoolExists((Decal.Interop.Filters.BoolValueKey)index, out pValue); + } + + /// + /// Determines whether this object has the specified property. + /// + /// The property to check. + /// true if this object has the specified property. + public bool Exists(DoubleValueKey index) + { + double pValue; + return base.Wrapped.DoubleExists((Decal.Interop.Filters.DoubleValueKey)index, out pValue); + } + + /// + /// Determines whether this object has the specified property. + /// + /// The property to check. + /// true if this object has the specified property. + public bool Exists(LongValueKey index) + { + int pValue; + return base.Wrapped.LongExists((Decal.Interop.Filters.LongValueKey)index, out pValue); + } + + /// + /// Determines whether this object has the specified property. + /// + /// The property to check. + /// true if this object has the specified property. + public bool Exists(StringValueKey index) + { + string pValue; + return base.Wrapped.StringExists((Decal.Interop.Filters.StringValueKey)index, out pValue); + } + + /// + /// Gets the value of the specified property, if it exists. + /// + /// The property to get. + /// Set to the value of the property, if it exists. + /// true if this object has the specified property. + public bool Exists(BoolValueKey index, out bool pValue) + { + return base.Wrapped.BoolExists((Decal.Interop.Filters.BoolValueKey)index, out pValue); + } + + /// + /// Gets the value of the specified property, if it exists. + /// + /// The property to get. + /// Set to the value of the property, if it exists. + /// true if this object has the specified property. + public bool Exists(DoubleValueKey index, out double pValue) + { + return base.Wrapped.DoubleExists((Decal.Interop.Filters.DoubleValueKey)index, out pValue); + } + + /// + /// Gets the value of the specified property, if it exists. + /// + /// The property to get. + /// Set to the value of the property, if it exists. + /// true if this object has the specified property. + public bool Exists(LongValueKey index, out int pValue) + { + return base.Wrapped.LongExists((Decal.Interop.Filters.LongValueKey)index, out pValue); + } + + /// + /// Gets the value of the specified property, if it exists. + /// + /// The property to get. + /// Set to the value of the property, if it exists. + /// true if this object has the specified property. + public bool Exists(StringValueKey index, out string pValue) + { + return base.Wrapped.StringExists((Decal.Interop.Filters.StringValueKey)index, out pValue); + } + + /// + /// Gets the value of the specified property, or false if this + /// object doesn't have the property. + /// + /// The property to get. + /// The property's value. + public bool Values(BoolValueKey index) + { + return Values(index, defaultValue: false); + } + + /// + /// Gets the value of the specified property, or 0.0 if this + /// object doesn't have the property. + /// + /// The property to get. + /// The property's value. + public double Values(DoubleValueKey index) + { + return Values(index, 0.0); + } + + /// + /// Gets the value of the specified property, or 0 if this + /// object doesn't have the property. + /// + /// The property to get. + /// The property's value. + public int Values(LongValueKey index) + { + return index switch + { + LongValueKey.Slot => Values(index, -1), + LongValueKey.SlotLegacy => Values(index, 0), + _ => Values(index, 0), + }; + } + + /// + /// Gets the value of the specified property, or "" if this + /// object doesn't have the property. + /// + /// The property to get. + /// The property's value. + public string Values(StringValueKey index) + { + return Values(index, string.Empty); + } + + /// + /// Gets the value of the specified property, or defaultValue + /// if this object doesn't have the property. + /// + /// The property to get. + /// The value to return if this object + /// doesn't have the property. + /// The property's value. + public bool Values(BoolValueKey index, bool defaultValue) + { + return base.Wrapped.Bools((Decal.Interop.Filters.BoolValueKey)index, defaultValue); + } + + /// + /// Gets the value of the specified property, or defaultValue + /// if this object doesn't have the property. + /// + /// The property to get. + /// The value to return if this object + /// doesn't have the property. + /// The property's value. + public double Values(DoubleValueKey index, double defaultValue) + { + return base.Wrapped.Doubles((Decal.Interop.Filters.DoubleValueKey)index, defaultValue); + } + + /// + /// Gets the value of the specified property, or defaultValue + /// if this object doesn't have the property. + /// + /// The property to get. + /// The value to return if this object + /// doesn't have the property. + /// The property's value. + public int Values(LongValueKey index, int defaultValue) + { + return base.Wrapped.Longs((Decal.Interop.Filters.LongValueKey)index, defaultValue); + } + + /// + /// Gets the value of the specified property, or defaultValue + /// if this object doesn't have the property. + /// + /// The property to get. + /// The value to return if this object + /// doesn't have the property. + /// The property's value. + public string Values(StringValueKey index, string defaultValue) + { + return base.Wrapped.Strings((Decal.Interop.Filters.StringValueKey)index, defaultValue); + } + + /// + /// Gets the coordinates of this object, or null if this + /// object doesn't have coordinates (if it's in a container, etc.) + /// + /// The coordinates of this object, or null if this + /// object doesn't have coordinates. + public CoordsObject Coordinates() + { + double NorthSouth = 0.0; + double EastWest = 0.0; + if (base.Wrapped.Coordinates(ref NorthSouth, ref EastWest)) + { + return new CoordsObject(NorthSouth, EastWest); + } + return null; + } + + /// + /// Gets this object's current offset in its landblock, or null + /// if this object doesn't have an offset (if it's in a container, etc.) + /// + /// The offset of this object, or null if this object + /// doesn't have an offset. + public Vector3Object Offset() + { + double x = 0.0; + double y = 0.0; + double z = 0.0; + if (base.Wrapped.Offset(out x, out y, out z)) + { + return new Vector3Object(x, y, z); + } + return null; + } + + /// + /// Gets a quaternion representing the orientation of this object, or + /// null if this object doesn't have an orientation (if it's in + /// a container, etc.) + /// + /// The orientation of this object, or null if this + /// object doesn't have an orientation. + public Vector4Object Orientation() + { + double w = 0.0; + double x = 0.0; + double y = 0.0; + double z = 0.0; + if (base.Wrapped.Orientation(out w, out x, out y, out z)) + { + return new Vector4Object(w, x, y, z); + } + return null; + } + + /// + /// Gets the raw coordinates of this object, or null if this + /// object doesn't have coordinates (if it's in a container, etc.) + /// + /// The raw coordinates of this object, or null if this + /// object doesn't have coordinates. + public Vector3Object RawCoordinates() + { + double pX = 0.0; + double pY = 0.0; + double pZ = 0.0; + if (base.Wrapped.RawCoordinates(ref pX, ref pY, ref pZ)) + { + return new Vector3Object(pX, pY, pZ); + } + return null; + } + + /// + /// Gets the spell ID of one of the spells that this object casts. + /// + /// The index in the list of spells. + /// The spell ID. + public int Spell(int index) + { + return base.Wrapped.Spell(index); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/WorldObjectCollection.cs b/Unused/Decal.Adapter.Wrappers/WorldObjectCollection.cs new file mode 100644 index 0000000..7d45a69 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/WorldObjectCollection.cs @@ -0,0 +1,167 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +/// +/// Defines a collection of WorldObjects +/// +public class WorldObjectCollection : GenericDisposableWrapper, IEnumerable, IEnumerable +{ + public class Iterator : IEnumerator, IDisposable, IEnumerator + { + private WorldObjectCollection collection; + + private WorldObject current; + + public WorldObject Current + { + get + { + if (current == null) + { + MoveNext(); + } + return current; + } + } + + object IEnumerator.Current + { + get + { + if (current == null) + { + MoveNext(); + } + return current; + } + } + + internal Iterator(WorldObjectCollection collection) + { + this.collection = collection; + Reset(); + } + + public void Dispose() + { + collection = null; + } + + public bool MoveNext() + { + Decal.Interop.Filters.WorldObject ppObject = null; + bool num = collection.Wrapped.Next(ref ppObject); + if (num && ppObject != null) + { + current = collection.wf.GetCachedWorldObject(ppObject); + } + return num; + } + + public void Reset() + { + collection.Wrapped.Reset(); + } + } + + private WorldObject current; + + private WorldFilter wf; + + private IEnumerator myEnum; + + /// + /// Returns the number of items in the collection + /// + public int Count => base.Wrapped.Count; + + /// + /// Returns the number of items represented by the collection, taking into account stacks of items. + /// + public int Quantity => base.Wrapped.Quantity; + + public WorldObject First + { + get + { + using IEnumerator enumerator = GetEnumerator(); + return enumerator.Current; + } + } + + [Obsolete("Use Enumerators")] + [EditorBrowsable(EditorBrowsableState.Never)] + public WorldObject Current + { + get + { + if (myEnum == null) + { + myEnum = GetEnumerator(); + } + return myEnum.Current; + } + } + + internal WorldObjectCollection(WorldFilter wf, WorldIterator obj) + : base(obj) + { + this.wf = wf; + } + + /// + /// Apply a filter to this collection to limit what it returns + /// + /// filter object + public void SetFilter(WorldObjectCollectionFilter filter) + { + filter?.ApplyFilter(base.Wrapped); + } + + protected override void Dispose(bool userCalled) + { + if (myEnum != null) + { + myEnum.Dispose(); + myEnum = null; + } + base.Dispose(userCalled); + } + + [Obsolete("Use Enumerators")] + [EditorBrowsable(EditorBrowsableState.Never)] + public bool MoveNext() + { + if (myEnum == null) + { + myEnum = GetEnumerator(); + } + return myEnum.MoveNext(); + } + + [Obsolete("Use Enumerators")] + [EditorBrowsable(EditorBrowsableState.Never)] + public void Reset() + { + if (myEnum != null) + { + myEnum.Dispose(); + myEnum = null; + } + } + + public IEnumerator GetEnumerator() + { + return new Iterator(this); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return new Iterator(this); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/WorldObjectCollectionFilter.cs b/Unused/Decal.Adapter.Wrappers/WorldObjectCollectionFilter.cs new file mode 100644 index 0000000..d95fef3 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/WorldObjectCollectionFilter.cs @@ -0,0 +1,14 @@ +using System; +using Decal.Interop.Filters; + +namespace Decal.Adapter.Wrappers; + +public abstract class WorldObjectCollectionFilter +{ + internal abstract void ApplyFilter(WorldIterator wi); + + internal virtual void ApplyFilter(Decal.Interop.Filters.Vendor ven) + { + throw new NotImplementedException("This method has not beed implemented"); + } +} diff --git a/Unused/Decal.Adapter.Wrappers/WriteTextFormats.cs b/Unused/Decal.Adapter.Wrappers/WriteTextFormats.cs new file mode 100644 index 0000000..65ac219 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/WriteTextFormats.cs @@ -0,0 +1,25 @@ +using System; + +namespace Decal.Adapter.Wrappers; + +/// +/// Formats to use when writing text to HUDs +/// +[Flags] +[CLSCompliant(true)] +public enum WriteTextFormats +{ + Bottom = 8, + Center = 1, + ExpandTabs = 0x40, + NoClip = 0x100, + /// + /// Implies Top and Left + /// + None = 0, + Right = 2, + RightToLeftReading = 0x20000, + SingleLine = 0x20, + VerticalCenter = 4, + WordBreak = 0x10 +} diff --git a/Unused/Decal.Adapter.Wrappers/hookIndexType.cs b/Unused/Decal.Adapter.Wrappers/hookIndexType.cs new file mode 100644 index 0000000..816e945 --- /dev/null +++ b/Unused/Decal.Adapter.Wrappers/hookIndexType.cs @@ -0,0 +1,18 @@ +namespace Decal.Adapter.Wrappers; + +internal enum hookIndexType +{ + Attribute, + AttributeClicks, + AttributeStart, + AttributeTotalXP, + Skill, + SkillClicks, + SkillFreePoints, + SkillTotalXP, + SkillTrainLevel, + Vital, + VitalClicks, + VitalTotalXP, + Misc +} diff --git a/Unused/Decal.Adapter/BaseEventAttribute.cs b/Unused/Decal.Adapter/BaseEventAttribute.cs new file mode 100644 index 0000000..2df09ae --- /dev/null +++ b/Unused/Decal.Adapter/BaseEventAttribute.cs @@ -0,0 +1,26 @@ +using System; + +namespace Decal.Adapter; + +[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] +public sealed class BaseEventAttribute : Attribute +{ + private string eventName; + + private string baseFilter; + + public string EventName => eventName; + + public string FilterName => baseFilter; + + public BaseEventAttribute(string eventName) + : this(eventName, string.Empty) + { + } + + public BaseEventAttribute(string eventName, string baseFilter) + { + this.eventName = eventName; + this.baseFilter = baseFilter; + } +} diff --git a/Unused/Decal.Adapter/COMHResultException.cs b/Unused/Decal.Adapter/COMHResultException.cs new file mode 100644 index 0000000..2e99428 --- /dev/null +++ b/Unused/Decal.Adapter/COMHResultException.cs @@ -0,0 +1,11 @@ +using System.Runtime.InteropServices; + +namespace Decal.Adapter; + +internal class COMHResultException : COMException +{ + internal COMHResultException(HResults hResult) + { + base.HResult = (int)hResult; + } +} diff --git a/Unused/Decal.Adapter/ChatClickInterceptEventArgs.cs b/Unused/Decal.Adapter/ChatClickInterceptEventArgs.cs new file mode 100644 index 0000000..89a7c71 --- /dev/null +++ b/Unused/Decal.Adapter/ChatClickInterceptEventArgs.cs @@ -0,0 +1,19 @@ +namespace Decal.Adapter; + +public class ChatClickInterceptEventArgs : EatableEventArgs +{ + private string myText; + + private int myId; + + public string Text => myText; + + public int Id => myId; + + internal ChatClickInterceptEventArgs(string text, int id, bool eat) + : base(eat) + { + myText = text; + myId = id; + } +} diff --git a/Unused/Decal.Adapter/ChatParserInterceptEventArgs.cs b/Unused/Decal.Adapter/ChatParserInterceptEventArgs.cs new file mode 100644 index 0000000..a9cae2d --- /dev/null +++ b/Unused/Decal.Adapter/ChatParserInterceptEventArgs.cs @@ -0,0 +1,14 @@ +namespace Decal.Adapter; + +public class ChatParserInterceptEventArgs : EatableEventArgs +{ + private string myText; + + public string Text => myText; + + internal ChatParserInterceptEventArgs(string text, bool eat) + : base(eat) + { + myText = text; + } +} diff --git a/Unused/Decal.Adapter/ChatTextInterceptEventArgs.cs b/Unused/Decal.Adapter/ChatTextInterceptEventArgs.cs new file mode 100644 index 0000000..4fc66df --- /dev/null +++ b/Unused/Decal.Adapter/ChatTextInterceptEventArgs.cs @@ -0,0 +1,24 @@ +namespace Decal.Adapter; + +public class ChatTextInterceptEventArgs : EatableEventArgs +{ + private string myText; + + private int myColor; + + private int myTarget; + + public string Text => myText; + + public int Color => myColor; + + public int Target => myTarget; + + internal ChatTextInterceptEventArgs(string text, int color, int target, bool eat) + : base(eat) + { + myText = text; + myColor = color; + myTarget = target; + } +} diff --git a/Unused/Decal.Adapter/CheckBoxChangeEventArgs.cs b/Unused/Decal.Adapter/CheckBoxChangeEventArgs.cs new file mode 100644 index 0000000..5ade8ba --- /dev/null +++ b/Unused/Decal.Adapter/CheckBoxChangeEventArgs.cs @@ -0,0 +1,14 @@ +namespace Decal.Adapter; + +public class CheckBoxChangeEventArgs : ControlEventArgs +{ + private bool check; + + public bool Checked => check; + + internal CheckBoxChangeEventArgs(int ID, bool Check) + : base(ID) + { + check = Check; + } +} diff --git a/Unused/Decal.Adapter/ContainerOpenedEventArgs.cs b/Unused/Decal.Adapter/ContainerOpenedEventArgs.cs new file mode 100644 index 0000000..aa6f8c7 --- /dev/null +++ b/Unused/Decal.Adapter/ContainerOpenedEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter; + +public class ContainerOpenedEventArgs : EventArgs +{ + private int myItemGUID; + + public int ItemGuid => myItemGUID; + + internal ContainerOpenedEventArgs(int itemGUID) + { + myItemGUID = itemGUID; + } +} diff --git a/Unused/Decal.Adapter/ControlEventArgs.cs b/Unused/Decal.Adapter/ControlEventArgs.cs new file mode 100644 index 0000000..8a0c816 --- /dev/null +++ b/Unused/Decal.Adapter/ControlEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter; + +public class ControlEventArgs : EventArgs +{ + private int id; + + public int Id => id; + + internal ControlEventArgs(int ID) + { + id = ID; + } +} diff --git a/Unused/Decal.Adapter/ControlEventAttribute.cs b/Unused/Decal.Adapter/ControlEventAttribute.cs new file mode 100644 index 0000000..e99b2f5 --- /dev/null +++ b/Unused/Decal.Adapter/ControlEventAttribute.cs @@ -0,0 +1,35 @@ +using System; + +namespace Decal.Adapter; + +/// +/// ControlEvent AutoWireup +/// +[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] +public sealed class ControlEventAttribute : ViewBaseAttribute +{ + private string myControl; + + private string myEventName; + + /// + /// Control Name + /// + public string Control => myControl; + + /// + /// Event to Wire + /// + public string EventName => myEventName; + + /// + /// Constructs the ControlEvent + /// + /// Control Name + /// Event to Wire + public ControlEventAttribute(string control, string eventName) + { + myControl = control; + myEventName = eventName; + } +} diff --git a/Unused/Decal.Adapter/ControlReferenceArrayAttribute.cs b/Unused/Decal.Adapter/ControlReferenceArrayAttribute.cs new file mode 100644 index 0000000..e13133c --- /dev/null +++ b/Unused/Decal.Adapter/ControlReferenceArrayAttribute.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.ObjectModel; + +namespace Decal.Adapter; + +/// +/// ControlReferenceArray AutoWireup +/// +[AttributeUsage(AttributeTargets.Field)] +public sealed class ControlReferenceArrayAttribute : ViewBaseAttribute +{ + private Collection myControls; + + /// + /// Control collection + /// + public Collection Controls => myControls; + + /// + /// Constructs a new ControlReference array + /// + /// Names of the controls to put in the array + public ControlReferenceArrayAttribute(params string[] controls) + { + myControls = new Collection(controls); + } +} diff --git a/Unused/Decal.Adapter/ControlReferenceAttribute.cs b/Unused/Decal.Adapter/ControlReferenceAttribute.cs new file mode 100644 index 0000000..0edaff4 --- /dev/null +++ b/Unused/Decal.Adapter/ControlReferenceAttribute.cs @@ -0,0 +1,26 @@ +using System; + +namespace Decal.Adapter; + +/// +/// ControlReference AutoWireup +/// +[AttributeUsage(AttributeTargets.Field)] +public sealed class ControlReferenceAttribute : ViewBaseAttribute +{ + private string myControl; + + /// + /// The Control Name + /// + public string Control => myControl; + + /// + /// Construct a new ControlReference + /// + /// Control to reference + public ControlReferenceAttribute(string control) + { + myControl = control; + } +} diff --git a/Unused/Decal.Adapter/CoreManager.cs b/Unused/Decal.Adapter/CoreManager.cs new file mode 100644 index 0000000..9f49621 --- /dev/null +++ b/Unused/Decal.Adapter/CoreManager.cs @@ -0,0 +1,987 @@ +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.IO; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Threading; +using Decal.Adapter.IDQueue; +using Decal.Adapter.Messages; +using Decal.Adapter.Support; +using Decal.Adapter.Wrappers; +using Decal.Interop.Core; +using Decal.Interop.D3DService; +using Decal.Interop.DHS; +using Decal.Interop.Filters; +using Decal.Interop.Inject; +using Decal.Interop.Render; +using Microsoft.Win32; + +namespace Decal.Adapter; + +/// +/// Lifetime Service required for the .NET Surrogate to function. +/// +[CLSCompliant(true)] +public sealed class CoreManager : MarshalByRefObject +{ + private struct sAssemblyPreloadData + { + public string AssemblyName; + + public string Path; + } + + private static bool myServiceRunning; + + private static CoreManager myService; + + private DecalCoreClass myDecal; + + private ACHooksClass myHooks; + + private PluginSite mySitev1; + + private DecalWrapper myWrappedDecal; + + private HooksWrapper myWrappedHooks; + + private global::Decal.Adapter.Wrappers.HotkeySystem myDHS; + + private CharacterFilter myCharacterFilter; + + private WorldFilter myWorldFilter; + + private global::Decal.Adapter.Wrappers.EchoFilter2 myEchoFilter; + + private D3DService myD3DService; + + private RenderServiceWrapper myRenderService; + + private FairIDQueue myIDQueue; + + private Collection myPaths = new Collection(); + + private Dictionary> myAssemblies = new Dictionary>(); + + private int myAssemblyPreloadCounter = 1; + + private bool myAssemblyPreloadStarted; + + private Dictionary myFilters = new Dictionary(); + + private Dictionary myNamedFilters = new Dictionary(); + + private Dictionary myServices = new Dictionary(); + + private Dictionary myNamedServices = new Dictionary(); + + private Dictionary myPlugins = new Dictionary(); + + private EventHandler myItemSelected; + + private EventHandler myItemDestroyed; + + private EventHandler myChatParserIntercept; + + private EventHandler myRegionChange3D; + + private EventHandler myChatTextIntercept; + + private EventHandler myStatusTextIntercept; + + private EventHandler myMessageProcessed; + + private EventHandler myContainerOpened; + + private EventHandler myChatClickIntercept; + + private EventHandler myWindowMessage; + + private EventHandler myFilterInitComplete; + + private EventHandler myServiceInitComplete; + + private EventHandler myPluginInitComplete; + + private EventHandler myFilterTermComplete; + + private EventHandler myServiceTermComplete; + + private EventHandler myPluginTermComplete; + + private EventHandler myRender_PreUI; + + private EventHandler myExtensionMessage; + + private AppDomain myPluginDomain; + + private AppDomain myDomain; + + /// + /// Returns if the service was initialized by Decal. + /// + public static bool ServiceRunning => myServiceRunning; + + /// + /// Returns the Singleton instance of the Service + /// (Initializes if necessary) + /// + public static CoreManager Current + { + get + { + if (myService == null) + { + myService = new CoreManager(); + } + return myService; + } + } + + /// + /// Tracing level for Decal.Adapter, and all loaded plugins. + /// + public static int TracingLevel => Util.TraceLevel; + + /// + /// FileService (Decal.FileService) + /// + public FilterBase FileService => Filter("Decal.FileService"); + + /// + /// Decal Hotkey System + /// + public global::Decal.Adapter.Wrappers.HotkeySystem HotkeySystem => myDHS; + + /// + /// Character Filter + /// + [CLSCompliant(false)] + public CharacterFilter CharacterFilter => myCharacterFilter; + + [CLSCompliant(false)] + public WorldFilter WorldFilter => myWorldFilter; + + /// + /// Direct3D Service + /// + [CLSCompliant(false)] + public global::Decal.Adapter.Wrappers.EchoFilter2 EchoFilter => myEchoFilter; + + [CLSCompliant(false)] + public D3DService D3DService => myD3DService; + + [CLSCompliant(false)] + public HooksWrapper Actions => myWrappedHooks; + + [CLSCompliant(false)] + public DecalWrapper Decal => myWrappedDecal; + + public RenderServiceWrapper RenderService => myRenderService; + + public FairIDQueue IDQueue => myIDQueue; + + internal AppDomain PluginDomain => myDomain; + + [CLSCompliant(false)] + public event EventHandler ItemSelected + { + add + { + myItemSelected = (EventHandler)Delegate.Combine(myItemSelected, value); + } + remove + { + myItemSelected = (EventHandler)Delegate.Remove(myItemSelected, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ItemDestroyed + { + add + { + myItemDestroyed = (EventHandler)Delegate.Combine(myItemDestroyed, value); + } + remove + { + myItemDestroyed = (EventHandler)Delegate.Remove(myItemDestroyed, value); + } + } + + [CLSCompliant(false)] + public event EventHandler CommandLineText + { + add + { + myChatParserIntercept = (EventHandler)Delegate.Combine(myChatParserIntercept, value); + } + remove + { + myChatParserIntercept = (EventHandler)Delegate.Remove(myChatParserIntercept, value); + } + } + + [CLSCompliant(false)] + public event EventHandler StatusBoxMessage + { + add + { + myStatusTextIntercept = (EventHandler)Delegate.Combine(myStatusTextIntercept, value); + } + remove + { + myStatusTextIntercept = (EventHandler)Delegate.Remove(myStatusTextIntercept, value); + } + } + + [CLSCompliant(false)] + public event EventHandler RegionChange3D + { + add + { + myRegionChange3D = (EventHandler)Delegate.Combine(myRegionChange3D, value); + } + remove + { + myRegionChange3D = (EventHandler)Delegate.Remove(myRegionChange3D, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChatBoxMessage + { + add + { + myChatTextIntercept = (EventHandler)Delegate.Combine(myChatTextIntercept, value); + } + remove + { + myChatTextIntercept = (EventHandler)Delegate.Remove(myChatTextIntercept, value); + } + } + + [CLSCompliant(false)] + public event EventHandler MessageProcessed + { + add + { + myMessageProcessed = (EventHandler)Delegate.Combine(myMessageProcessed, value); + } + remove + { + myMessageProcessed = (EventHandler)Delegate.Remove(myMessageProcessed, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ContainerOpened + { + add + { + myContainerOpened = (EventHandler)Delegate.Combine(myContainerOpened, value); + } + remove + { + myContainerOpened = (EventHandler)Delegate.Remove(myContainerOpened, value); + } + } + + [CLSCompliant(false)] + public event EventHandler ChatNameClicked + { + add + { + myChatClickIntercept = (EventHandler)Delegate.Combine(myChatClickIntercept, value); + } + remove + { + myChatClickIntercept = (EventHandler)Delegate.Remove(myChatClickIntercept, value); + } + } + + public event EventHandler FilterInitComplete + { + add + { + myFilterInitComplete = (EventHandler)Delegate.Combine(myFilterInitComplete, value); + } + remove + { + myFilterInitComplete = (EventHandler)Delegate.Remove(myFilterInitComplete, value); + } + } + + public event EventHandler ServiceInitComplete + { + add + { + myServiceInitComplete = (EventHandler)Delegate.Combine(myServiceInitComplete, value); + } + remove + { + myServiceInitComplete = (EventHandler)Delegate.Remove(myServiceInitComplete, value); + } + } + + public event EventHandler PluginInitComplete + { + add + { + myPluginInitComplete = (EventHandler)Delegate.Combine(myPluginInitComplete, value); + } + remove + { + myPluginInitComplete = (EventHandler)Delegate.Remove(myPluginInitComplete, value); + } + } + + public event EventHandler FilterTermComplete + { + add + { + myFilterTermComplete = (EventHandler)Delegate.Combine(myFilterTermComplete, value); + } + remove + { + myFilterTermComplete = (EventHandler)Delegate.Remove(myFilterTermComplete, value); + } + } + + public event EventHandler ServiceTermComplete + { + add + { + myServiceTermComplete = (EventHandler)Delegate.Combine(myServiceTermComplete, value); + } + remove + { + myServiceTermComplete = (EventHandler)Delegate.Remove(myServiceTermComplete, value); + } + } + + public event EventHandler PluginTermComplete + { + add + { + myPluginTermComplete = (EventHandler)Delegate.Combine(myPluginTermComplete, value); + } + remove + { + myPluginTermComplete = (EventHandler)Delegate.Remove(myPluginTermComplete, value); + } + } + + public event EventHandler RenderFrame + { + add + { + myRender_PreUI = (EventHandler)Delegate.Combine(myRender_PreUI, value); + } + remove + { + myRender_PreUI = (EventHandler)Delegate.Remove(myRender_PreUI, value); + } + } + + [CLSCompliant(false)] + public event EventHandler WindowMessage + { + add + { + myWindowMessage = (EventHandler)Delegate.Combine(myWindowMessage, value); + } + remove + { + myWindowMessage = (EventHandler)Delegate.Remove(myWindowMessage, value); + } + } + + internal event EventHandler ExtensionMessage + { + add + { + myExtensionMessage = (EventHandler)Delegate.Combine(myExtensionMessage, value); + } + remove + { + myExtensionMessage = (EventHandler)Delegate.Remove(myExtensionMessage, value); + } + } + + private CoreManager() + { + AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; + string location = System.Reflection.Assembly.GetExecutingAssembly().Location; + AddAssemblyPath(Path.GetDirectoryName(location)); + myDomain = AppDomain.CurrentDomain; + Util.InitializeTracing("HKEY_LOCAL_MACHINE\\Software\\Decal\\Decal.Adapter", "Tracing", 0); + } + + private Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) + { + AppDomain appDomain = (AppDomain)sender; + Assembly[] assemblies = appDomain.GetAssemblies(); + string text = appDomain.ApplyPolicy(args.Name); + if (string.IsNullOrEmpty(text)) + { + text = args.Name; + } + Assembly[] array = assemblies; + foreach (Assembly assembly in array) + { + if (assembly.FullName == text) + { + return assembly; + } + } + if (!appDomain.IsDefaultAppDomain()) + { + assemblies = myDomain.GetAssemblies(); + array = assemblies; + foreach (Assembly assembly2 in array) + { + if (assembly2.FullName == text) + { + AssemblyName name = assembly2.GetName(copiedName: false); + return appDomain.Load(name); + } + } + } + string text2 = ((text.IndexOf(",") <= 0) ? text : text.Substring(0, text.IndexOf(","))); + if (!string.IsNullOrEmpty(text2)) + { + text2 = text2.ToLowerInvariant(); + if (string.IsNullOrEmpty(Path.GetExtension(text2))) + { + text2 += ".dll"; + } + foreach (string myPath in myPaths) + { + if (File.Exists(Path.Combine(myPath, text2))) + { + AssemblyName assemblyName = new AssemblyName(); + assemblyName.CodeBase = Path.Combine(myPath, text2); + return appDomain.Load(assemblyName); + } + } + } + Util.WriteLine("Assembly resolve failed for assembly:" + args.Name); + return null; + } + + private void AddAssemblyPath(string path) + { + string item = path.ToLowerInvariant(); + if (!myPaths.Contains(item)) + { + myPaths.Add(item); + } + } + + private void myDecal_InitializeComplete(eDecalComponentType myComponent) + { + Util.WriteLine("InitializeComplete for: " + myComponent); + switch (myComponent) + { + case eDecalComponentType.eService: + Message.Initialize(Path.Combine((string)Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Decal\\Agent", "AgentPath", ""), "messages.xml")); + if (myWrappedDecal != null) + { + try + { + if (myWrappedDecal.GetObject("services\\D3DService.Service") is CService obj) + { + myD3DService = new D3DService(obj); + } + if (myWrappedDecal.GetObject("services\\DecalRender.RenderService") is RenderService render) + { + myRenderService = new RenderServiceWrapper(render); + } + object obj2 = myWrappedDecal.GetObject("services\\DecalPlugins.InjectService\\site", DecalWrapper.IID_IUNKNOWN); + mySitev1 = obj2 as PluginSite; + } + catch (Exception ex) + { + Util.WriteLine("Unable to get service reference: " + ex.Message); + } + } + else + { + Util.WriteLine("Not getting services, we don't have a Decal object to call GetObject on."); + } + try + { + myIDQueue = new FairIDQueue(); + } + catch (Exception ex2) + { + Util.WriteLine("Service initialization exception: " + ex2.Message); + } + Util.SafeFireEvent(this, myServiceInitComplete, new EventArgs()); + break; + case eDecalComponentType.eNetworkFilter: + if (myWrappedDecal != null) + { + try + { + if (myWrappedDecal.GetObject("services\\DecalNet.NetService\\DecalFilters.World") is World obj3) + { + myWorldFilter = new WorldFilter(obj3); + } + if (myWrappedDecal.GetObject("services\\DecalNet.NetService\\DecalFilters.CharacterStats") is CharacterStats obj4) + { + myCharacterFilter = new CharacterFilter(obj4); + } + if (myWrappedDecal.GetObject("services\\DecalNet.NetService\\DecalFilters.EchoFilter2") is global::Decal.Interop.Filters.EchoFilter2 obj5) + { + myEchoFilter = new global::Decal.Adapter.Wrappers.EchoFilter2(obj5); + } + } + catch (Exception ex3) + { + Util.WriteLine("Unable to get filter reference: " + ex3.Message); + } + } + else + { + Util.WriteLine("Not getting filters, we don't have a Decal object to call GetObject on."); + } + Util.SafeFireEvent(this, myFilterInitComplete, new EventArgs()); + DecrementAssemblyPreloadLockCounter(); + break; + case eDecalComponentType.ePlugin: + if (myWrappedDecal.GetObject("plugins\\DHS.HotkeySystem") is global::Decal.Interop.DHS.HotkeySystem hks) + { + myDHS = new global::Decal.Adapter.Wrappers.HotkeySystem(hks); + } + myIDQueue.Start(); + Util.SafeFireEvent(this, myPluginInitComplete, new EventArgs()); + break; + } + } + + private void myDecal_TerminateComplete(eDecalComponentType myComponent) + { + Util.WriteLine("TerminateComplete for: " + myComponent); + switch (myComponent) + { + case eDecalComponentType.eService: + if (myD3DService != null) + { + myD3DService.Dispose(); + myD3DService = null; + } + if (myRenderService != null) + { + myRenderService.Dispose(); + myRenderService = null; + } + if (mySitev1 != null) + { + Marshal.ReleaseComObject(mySitev1); + } + myServices.Clear(); + myNamedServices.Clear(); + Util.SafeFireEvent(this, myServiceTermComplete, new EventArgs()); + break; + case eDecalComponentType.eNetworkFilter: + if (myWorldFilter != null) + { + myWorldFilter.Dispose(); + myWorldFilter = null; + } + if (myCharacterFilter != null) + { + myCharacterFilter.Dispose(); + myCharacterFilter = null; + } + if (myEchoFilter != null) + { + myEchoFilter.Dispose(); + myEchoFilter = null; + } + myFilters.Clear(); + myNamedFilters.Clear(); + Util.SafeFireEvent(this, myFilterTermComplete, new EventArgs()); + break; + case eDecalComponentType.ePlugin: + myIDQueue.Stop(); + if (myDHS != null) + { + myDHS.Dispose(); + myDHS = null; + } + myPlugins.Clear(); + if (myPluginDomain != null) + { + lock (myAssemblies) + { + if (myAssemblies.ContainsKey(myPluginDomain)) + { + myAssemblies[myPluginDomain].Clear(); + myAssemblies.Remove(myPluginDomain); + } + AppDomain.Unload(myPluginDomain); + myPluginDomain = null; + } + } + Util.SafeFireEvent(this, myPluginTermComplete, new EventArgs()); + break; + } + } + + private void myHooks_ObjectSelected(int lGUID) + { + Util.SafeFireEvent(this, myItemSelected, new ItemSelectedEventArgs(lGUID)); + } + + private void myHooks_ObjectDestroyed(int lGUID) + { + Util.SafeFireEvent(this, myItemDestroyed, new ItemDestroyedEventArgs(lGUID)); + } + + private void myHooks_AC3DRegionChanged(int left, int top, int right, int bottom) + { + Util.SafeFireEvent(this, myRegionChange3D, new RegionChange3DEventArgs(left, top, right, bottom)); + } + + private void myHooks_ChatParserIntercept(string bstrText, ref bool bEat) + { + Util.SafeFireEvent(this, myChatParserIntercept, new ChatParserInterceptEventArgs(bstrText, bEat), ref bEat); + } + + private void myHooks_StatusTextIntercept(string bstrText, ref bool bEat) + { + Util.SafeFireEvent(this, myStatusTextIntercept, new StatusTextInterceptEventArgs(bstrText, bEat), ref bEat); + } + + private void myHooks_ChatTextIntercept(string bstrText, int lColor, int target, ref bool bEat) + { + Util.SafeFireEvent(this, myChatTextIntercept, new ChatTextInterceptEventArgs(bstrText, lColor, target, bEat), ref bEat); + } + + private void myHooks_MessageProcessed(int pbData, int dwSize) + { + if (myMessageProcessed != null) + { + MessageProcessedEventArgs args = new MessageProcessedEventArgs(pbData, dwSize); + Util.SafeFireEvent(this, myMessageProcessed, args); + } + } + + private void myHooks_ContainerOpened(int lGUID) + { + Util.SafeFireEvent(this, myContainerOpened, new ContainerOpenedEventArgs(lGUID)); + } + + private void myHooks_ChatClickIntercept(string bstrText, int id, ref bool bEat) + { + Util.SafeFireEvent(this, myChatClickIntercept, new ChatClickInterceptEventArgs(bstrText, id, bEat), ref bEat); + } + + private void myHooks_RenderPreUI() + { + Util.SafeFireEvent(this, myRender_PreUI, new EventArgs()); + } + + internal bool FireWindowMessage(int HWND, short uMsg, int wParam, int lParam) + { + bool eaten = false; + WindowMessageEventArgs args = new WindowMessageEventArgs(HWND, uMsg, wParam, lParam); + Util.SafeFireEvent(this, myWindowMessage, args, ref eaten); + return eaten; + } + + internal void FireExtensionMessage(object sender, AdapterMessageEventArgs args) + { + args.CanAddHandlers = true; + Util.SafeFireEvent(this, myExtensionMessage, args); + args.CanAddHandlers = false; + } + + public FilterBase Filter(string filterName) + { + try + { + if (myNamedFilters.ContainsKey(filterName)) + { + return myNamedFilters[filterName]; + } + Type type = Type.GetType(filterName); + if (null != type && myFilters.ContainsKey(type)) + { + return myFilters[type]; + } + } + catch (Exception) + { + } + return null; + } + + public T Filter() where T : FilterBase + { + try + { + if (myFilters.ContainsKey(typeof(T))) + { + return (T)myFilters[typeof(T)]; + } + } + catch (Exception) + { + } + return null; + } + + public ServiceBase Service(string serviceName) + { + try + { + if (myNamedServices.ContainsKey(serviceName)) + { + return myNamedServices[serviceName]; + } + Type type = Type.GetType(serviceName); + if (null != type && myServices.ContainsKey(type)) + { + return myServices[type]; + } + } + catch (Exception) + { + } + return null; + } + + public T Service() where T : ServiceBase + { + try + { + if (myServices.ContainsKey(typeof(T))) + { + return (T)myServices[typeof(T)]; + } + } + catch (Exception) + { + } + return null; + } + + /// + /// Get Mapped Keyboard Key + /// + /// Name to retrive mapping for. + /// Mapped Key + public int QueryKeyBoardMap(string name) + { + int result = 0; + if (mySitev1 != null) + { + result = mySitev1.QueryKeyboardMap(name); + } + return result; + } + + internal void AddFilter(FilterBase newFilter) + { + AddFilter(newFilter.ReferenceName, newFilter); + } + + internal void AddFilter(string filterName, FilterBase newFilter) + { + myFilters.Add(newFilter.GetType(), newFilter); + myNamedFilters.Add(filterName, newFilter); + } + + internal void AddService(ServiceBase newService) + { + AddService(newService.ReferenceName, newService); + } + + internal void AddService(string serviceName, ServiceBase newService) + { + myServices.Add(newService.GetType(), newService); + myNamedServices.Add(serviceName, newService); + } + + internal void AddPlugin(PluginBase newPlugin) + { + AddPlugin(newPlugin.ReferenceName, newPlugin); + } + + internal void AddPlugin(string pluginName, PluginBase newPlugin) + { + myPlugins.Add(pluginName, newPlugin); + } + + /// + /// Load the Assembly requested, first checking our internal cache + /// + /// Assembly name to load + /// Path to the assembly + /// Loaded Assembly, from cache if already loaded + internal Assembly Assembly(string name, string path) + { + return Assembly(name, path, AppDomain.CurrentDomain); + } + + internal Assembly Assembly(string name, string path, AppDomain useDomain) + { + lock (myAssemblies) + { + string text = name.ToLowerInvariant(); + useDomain = myDomain; + Dictionary dictionary; + if (myAssemblies.ContainsKey(useDomain)) + { + dictionary = myAssemblies[useDomain]; + } + else + { + myAssemblies.Add(useDomain, new Dictionary()); + dictionary = myAssemblies[useDomain]; + } + if (dictionary.ContainsKey(text)) + { + return dictionary[text]; + } + AddAssemblyPath(path); + Assembly assembly = System.Reflection.Assembly.LoadFrom(Path.Combine(path, text)); + dictionary.Add(text, assembly); + return assembly; + } + } + + internal void Initialize(DecalCore pDecal) + { + Util.WriteLine("Decal.Adapter Lifetime-service Initialize Begun"); + myServiceRunning = true; + Util.Write("Get Decal.. "); + myDecal = (DecalCoreClass)pDecal; + myWrappedDecal = new DecalWrapper(myDecal); + Util.WriteLine("Sink Decal Events.. "); + myDecal.InitializeComplete += myDecal_InitializeComplete; + myDecal.TerminateComplete += myDecal_TerminateComplete; + Util.Write("Get Hooks.. "); + myHooks = (ACHooksClass)myDecal.Hooks; + myWrappedHooks = new HooksWrapper(myHooks); + Util.WriteLine("Sink Hooks Events.. "); + myHooks.ChatTextIntercept += myHooks_ChatTextIntercept; + myHooks.StatusTextIntercept += myHooks_StatusTextIntercept; + myHooks.ChatParserIntercept += myHooks_ChatParserIntercept; + myHooks.AC3DRegionChanged += myHooks_AC3DRegionChanged; + myHooks.ObjectSelected += myHooks_ObjectSelected; + myHooks.ObjectDestroyed += myHooks_ObjectDestroyed; + myHooks.MessageProcessed += myHooks_MessageProcessed; + myHooks.ContainerOpened += myHooks_ContainerOpened; + myHooks.ChatClickIntercept += myHooks_ChatClickIntercept; + myHooks.RenderPreUI += myHooks_RenderPreUI; + Util.WriteLine("Decal.Adapter Lifetime-service Initiliazed"); + } + + internal void Terminate() + { + myDecal.InitializeComplete -= myDecal_InitializeComplete; + myDecal.TerminateComplete -= myDecal_TerminateComplete; + myHooks.ChatTextIntercept -= myHooks_ChatTextIntercept; + myHooks.StatusTextIntercept -= myHooks_StatusTextIntercept; + myHooks.ChatParserIntercept -= myHooks_ChatParserIntercept; + myHooks.AC3DRegionChanged -= myHooks_AC3DRegionChanged; + myHooks.ObjectSelected -= myHooks_ObjectSelected; + myHooks.ObjectDestroyed -= myHooks_ObjectDestroyed; + myHooks.MessageProcessed -= myHooks_MessageProcessed; + myHooks.ContainerOpened -= myHooks_ContainerOpened; + myHooks.ChatClickIntercept -= myHooks_ChatClickIntercept; + myHooks.RenderPreUI -= myHooks_RenderPreUI; + myWrappedDecal.Dispose(); + myWrappedDecal = null; + Marshal.ReleaseComObject(myDecal); + myDecal = null; + myHooks = null; + myWrappedHooks.Dispose(); + myWrappedHooks = null; + myService = null; + myServiceRunning = false; + } + + public void IncrementAssemblyPreloadLockCounter() + { + myAssemblyPreloadCounter++; + } + + public void DecrementAssemblyPreloadLockCounter() + { + myAssemblyPreloadCounter--; + if (myAssemblyPreloadCounter < 0) + { + myAssemblyPreloadCounter = 0; + } + if (myAssemblyPreloadCounter != 0 || myAssemblyPreloadStarted) + { + return; + } + myAssemblyPreloadStarted = true; + List list = new List(); + Guid clsidAdvance = Guid.Empty; + Guid guid = new Guid("{71A69713-6593-47EC-0002-0000000DECA1}"); + DecalEnum decalEnum = ((IDecalCore)Decal.Underlying).get_Configuration("Plugins", ref clsidAdvance); + try + { + while (true) + { + decalEnum.Next(); + if (!decalEnum.Enabled || decalEnum.SurrogateClass != guid) + { + continue; + } + try + { + if (decalEnum.Restricted) + { + continue; + } + } + catch + { + continue; + } + list.Add(new sAssemblyPreloadData + { + AssemblyName = (string)((IDecalEnum)decalEnum).get_Property("Assembly"), + Path = (string)((IDecalEnum)decalEnum).get_Property("Path") + }); + } + } + catch + { + } + finally + { + Marshal.ReleaseComObject(decalEnum); + } + ThreadPool.QueueUserWorkItem(AssemblyPreloadThreadProc, list); + } + + internal void AssemblyPreloadThreadProc(object data) + { + if (!(data is List list)) + { + return; + } + foreach (sAssemblyPreloadData item in list) + { + try + { + Util.WriteLine("Preloading plugin assembly {0}, {1}", item.AssemblyName, item.Path); + Assembly(item.AssemblyName, item.Path, AppDomain.CurrentDomain); + } + catch + { + } + } + } +} diff --git a/Unused/Decal.Adapter/DecalExtensionType.cs b/Unused/Decal.Adapter/DecalExtensionType.cs new file mode 100644 index 0000000..77524bb --- /dev/null +++ b/Unused/Decal.Adapter/DecalExtensionType.cs @@ -0,0 +1,17 @@ +using System; + +namespace Decal.Adapter; + +/// +/// +/// +[CLSCompliant(true)] +public enum DecalExtensionType +{ + Surrogate, + Service, + InputAction, + FileFilter, + NetworkFilter, + Plugin +} diff --git a/Unused/Decal.Adapter/DirectoryProxy.cs b/Unused/Decal.Adapter/DirectoryProxy.cs new file mode 100644 index 0000000..2b78563 --- /dev/null +++ b/Unused/Decal.Adapter/DirectoryProxy.cs @@ -0,0 +1,12 @@ +using System; +using Decal.Interop.Core; + +namespace Decal.Adapter; + +public sealed class DirectoryProxy : MarshalByRefObject, IDecalDirectory +{ + public object Lookup(string strName) + { + throw new NotImplementedException("The method or operation is not implemented."); + } +} diff --git a/Unused/Decal.Adapter/DirectoryResolveEventArgs.cs b/Unused/Decal.Adapter/DirectoryResolveEventArgs.cs new file mode 100644 index 0000000..b89759c --- /dev/null +++ b/Unused/Decal.Adapter/DirectoryResolveEventArgs.cs @@ -0,0 +1,29 @@ +using System; + +namespace Decal.Adapter; + +public class DirectoryResolveEventArgs : EventArgs +{ + private string myPath; + + private object myResult; + + public string Path => myPath; + + public object Result + { + get + { + return myResult; + } + set + { + myResult = value; + } + } + + internal DirectoryResolveEventArgs(string path) + { + myPath = path; + } +} diff --git a/Unused/Decal.Adapter/DisposableByRefObject.cs b/Unused/Decal.Adapter/DisposableByRefObject.cs new file mode 100644 index 0000000..f2a6434 --- /dev/null +++ b/Unused/Decal.Adapter/DisposableByRefObject.cs @@ -0,0 +1,60 @@ +using System; + +namespace Decal.Adapter; + +public class DisposableByRefObject : MarshalByRefObject, IDisposable +{ + private bool isDisposed; + + private EventHandler myDisposing; + + public event EventHandler Disposing + { + add + { + myDisposing = (EventHandler)Delegate.Combine(myDisposing, value); + } + remove + { + myDisposing = (EventHandler)Delegate.Remove(myDisposing, value); + } + } + + internal DisposableByRefObject() + { + } + + ~DisposableByRefObject() + { + Dispose(userCalled: false); + } + + public void Dispose() + { + Dispose(userCalled: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool userCalled) + { + if (!isDisposed && userCalled && myDisposing != null) + { + try + { + myDisposing(this, new EventArgs()); + } + catch + { + } + } + isDisposed = true; + } + + protected void EnforceDisposedOnce() + { + if (isDisposed) + { + throw new ObjectDisposedException(GetType().ToString()); + } + } +} diff --git a/Unused/Decal.Adapter/DisposableObjectDictionary.cs b/Unused/Decal.Adapter/DisposableObjectDictionary.cs new file mode 100644 index 0000000..b4385e2 --- /dev/null +++ b/Unused/Decal.Adapter/DisposableObjectDictionary.cs @@ -0,0 +1,123 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using Decal.Adapter.Support; + +namespace Decal.Adapter; + +public class DisposableObjectDictionary : DisposableByRefObject, IDictionary, ICollection>, IEnumerable>, IEnumerable where T : DisposableByRefObject +{ + private Dictionary items = new Dictionary(); + + private PropertyInfo keyProperty; + + public ICollection Keys => items.Keys; + + public ICollection Values => items.Values; + + public T this[K key] + { + get + { + return items[key]; + } + set + { + items[key] = value; + } + } + + public int Count => ((ICollection>)items).Count; + + public bool IsReadOnly => ((ICollection>)items).IsReadOnly; + + public DisposableObjectDictionary(string keyPropertyName) + { + keyProperty = typeof(T).GetProperty(keyPropertyName, BindingFlags.Instance | BindingFlags.Public); + } + + protected override void Dispose(bool userCalled) + { + if (userCalled) + { + Clear(); + } + base.Dispose(userCalled); + } + + private void value_Disposing(object sender, EventArgs e) + { + K key = (K)keyProperty.GetValue(sender, null); + ((T)sender).Disposing -= value_Disposing; + items.Remove(key); + } + + public void Add(K key, T value) + { + items.Add(key, value); + value.Disposing += value_Disposing; + } + + public bool ContainsKey(K key) + { + return items.ContainsKey(key); + } + + public bool Remove(K key) + { + return items.Remove(key); + } + + public bool TryGetValue(K key, out T value) + { + return items.TryGetValue(key, out value); + } + + public void Add(KeyValuePair item) + { + items.Add(item.Key, item.Value); + } + + public void Clear() + { + foreach (T value in items.Values) + { + try + { + value.Disposing -= value_Disposing; + value.Dispose(); + } + catch (Exception ex) + { + Util.WriteLine("GDW_Clear: Exception: {0}", ex.Message); + } + } + items.Clear(); + } + + public bool Contains(KeyValuePair item) + { + return ((ICollection>)items).Contains(item); + } + + public void CopyTo(KeyValuePair[] array, int arrayIndex) + { + ((ICollection>)items).CopyTo(array, arrayIndex); + } + + public bool Remove(KeyValuePair item) + { + return ((ICollection>)items).Remove(item); + } + + public IEnumerator> GetEnumerator() + { + return ((IEnumerable>)items).GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return ((IEnumerable)items).GetEnumerator(); + } +} diff --git a/Unused/Decal.Adapter/EatableEventArgs.cs b/Unused/Decal.Adapter/EatableEventArgs.cs new file mode 100644 index 0000000..df50cca --- /dev/null +++ b/Unused/Decal.Adapter/EatableEventArgs.cs @@ -0,0 +1,25 @@ +using System; + +namespace Decal.Adapter; + +public class EatableEventArgs : EventArgs +{ + private bool myEat; + + public bool Eat + { + get + { + return myEat; + } + set + { + myEat = value; + } + } + + internal EatableEventArgs(bool eat) + { + myEat = eat; + } +} diff --git a/Unused/Decal.Adapter/Extension.cs b/Unused/Decal.Adapter/Extension.cs new file mode 100644 index 0000000..259e4c9 --- /dev/null +++ b/Unused/Decal.Adapter/Extension.cs @@ -0,0 +1,249 @@ +using System; +using Decal.Adapter.Messages; + +namespace Decal.Adapter; + +/// +/// +/// +[CLSCompliant(true)] +public abstract class Extension : MarshalByRefObject +{ + private DecalExtensionType myExtensionType; + + private CoreManager myLifetime; + + private string myPath; + + private EventHandler directoryResolve; + + public DecalExtensionType ExtensionType => myExtensionType; + + public string Path + { + get + { + return myPath; + } + internal set + { + myPath = value; + } + } + + protected CoreManager Core + { + get + { + if (myLifetime == null) + { + myLifetime = CoreManager.Current; + } + return myLifetime; + } + } + + public virtual object ComOM => null; + + public virtual string ReferenceName => GetType().FullName; + + [CLSCompliant(false)] + protected event EventHandler DirectoryResolve + { + add + { + directoryResolve = (EventHandler)Delegate.Combine(directoryResolve, value); + } + remove + { + directoryResolve = (EventHandler)Delegate.Remove(directoryResolve, value); + } + } + + [CLSCompliant(false)] + protected event EventHandler WindowMessage + { + add + { + Core.WindowMessage += value; + } + remove + { + Core.WindowMessage -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler ChatNameClicked + { + add + { + Core.ChatNameClicked += value; + } + remove + { + Core.ChatNameClicked -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler MessageProcessed + { + add + { + Core.MessageProcessed += value; + } + remove + { + Core.MessageProcessed -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler RegionChange3D + { + add + { + Core.RegionChange3D += value; + } + remove + { + Core.RegionChange3D -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler ChatBoxMessage + { + add + { + Core.ChatBoxMessage += value; + } + remove + { + Core.ChatBoxMessage -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler ItemSelected + { + add + { + Core.ItemSelected += value; + } + remove + { + Core.ItemSelected -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler ItemDestroyed + { + add + { + Core.ItemDestroyed += value; + } + remove + { + Core.ItemDestroyed -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler CommandLineText + { + add + { + Core.CommandLineText += value; + } + remove + { + Core.CommandLineText -= value; + } + } + + [CLSCompliant(false)] + protected event EventHandler ContainerOpened + { + add + { + Core.ContainerOpened += value; + } + remove + { + Core.ContainerOpened -= value; + } + } + + protected event EventHandler AdapterMessage + { + add + { + Core.ExtensionMessage += value; + } + remove + { + Core.ExtensionMessage -= value; + } + } + + internal Extension(DecalExtensionType type) + { + myExtensionType = type; + } + + internal void standardEvent(ExtensionEvents evtToFire) + { + switch (evtToFire) + { + case ExtensionEvents.Startup: + Startup(); + break; + case ExtensionEvents.Shutdown: + Shutdown(); + break; + case ExtensionEvents.InternalWireup: + Wireup(); + break; + case ExtensionEvents.InternalUnwire: + UnWire(); + break; + } + } + + internal object ResolvePath(string path) + { + DirectoryResolveEventArgs e = new DirectoryResolveEventArgs(path); + if (directoryResolve != null) + { + try + { + directoryResolve(this, e); + return e.Result; + } + catch + { + } + } + return null; + } + + internal virtual void Wireup() + { + } + + internal virtual void UnWire() + { + } + + protected abstract void Startup(); + + protected abstract void Shutdown(); + + protected void SendAdapterMessage(AdapterMessageEventArgs args) + { + Core.FireExtensionMessage(this, args); + } +} diff --git a/Unused/Decal.Adapter/ExtensionEvents.cs b/Unused/Decal.Adapter/ExtensionEvents.cs new file mode 100644 index 0000000..0f1ba48 --- /dev/null +++ b/Unused/Decal.Adapter/ExtensionEvents.cs @@ -0,0 +1,12 @@ +namespace Decal.Adapter; + +/// +/// Sorts of events to be fired by the PluginProxy +/// +internal enum ExtensionEvents +{ + InternalWireup, + InternalUnwire, + Startup, + Shutdown +} diff --git a/Unused/Decal.Adapter/FilterBase.cs b/Unused/Decal.Adapter/FilterBase.cs new file mode 100644 index 0000000..93f3ad1 --- /dev/null +++ b/Unused/Decal.Adapter/FilterBase.cs @@ -0,0 +1,46 @@ +using System; +using Decal.Adapter.Wrappers; + +namespace Decal.Adapter; + +[CLSCompliant(true)] +public abstract class FilterBase : Extension +{ + private NetServiceHost myHost; + + [CLSCompliant(false)] + protected NetServiceHost Host => myHost; + + [CLSCompliant(false)] + protected event EventHandler ServerDispatch; + + [CLSCompliant(false)] + protected event EventHandler ClientDispatch; + + protected FilterBase() + : base(DecalExtensionType.NetworkFilter) + { + } + + /// + /// Used for internal wiring up of base-class variables. + /// Called by FilterProxy + /// + /// Host (pluginsite) object + internal void SetHost(NetServiceHost newHost) + { + myHost = newHost; + } + + internal void fireNetwork(Message newMsg, bool Server) + { + if (Server && this.ServerDispatch != null) + { + this.ServerDispatch(this, new NetworkMessageEventArgs(newMsg)); + } + else if (!Server && this.ClientDispatch != null) + { + this.ClientDispatch(this, new NetworkMessageEventArgs(newMsg)); + } + } +} diff --git a/Unused/Decal.Adapter/FilterProxy.cs b/Unused/Decal.Adapter/FilterProxy.cs new file mode 100644 index 0000000..d32b850 --- /dev/null +++ b/Unused/Decal.Adapter/FilterProxy.cs @@ -0,0 +1,51 @@ +using Decal.Adapter.NetParser; +using Decal.Adapter.Wrappers; +using Decal.Interop.Core; +using Decal.Interop.Net; + +namespace Decal.Adapter; + +public sealed class FilterProxy : INetworkFilter2, IDecalDirectory +{ + private NetServiceHost myService; + + private FilterBase myFilter; + + internal FilterProxy(FilterBase toWrap) + { + myFilter = toWrap; + } + + void INetworkFilter2.DispatchClient(IMessage2 msg) + { + Message message = null; + message = ((!(msg is MessageWrapper messageWrapper)) ? new Message(msg, MessageDirection.Inbound) : messageWrapper.Wrapped); + myFilter.fireNetwork(message, Server: false); + } + + void INetworkFilter2.DispatchServer(IMessage2 msg) + { + Message message = null; + message = ((!(msg is MessageWrapper messageWrapper)) ? new Message(msg, MessageDirection.Inbound) : messageWrapper.Wrapped); + myFilter.fireNetwork(message, Server: true); + } + + void INetworkFilter2.Initialize(NetService pService) + { + myService = new NetServiceHost(pService); + myFilter.SetHost(myService); + myFilter.standardEvent(ExtensionEvents.InternalWireup); + myFilter.standardEvent(ExtensionEvents.Startup); + } + + void INetworkFilter2.Terminate() + { + myFilter.standardEvent(ExtensionEvents.Shutdown); + myService.Dispose(); + } + + object IDecalDirectory.Lookup(string strName) + { + return myFilter.ResolvePath(strName); + } +} diff --git a/Unused/Decal.Adapter/FriendlyNameAttribute.cs b/Unused/Decal.Adapter/FriendlyNameAttribute.cs new file mode 100644 index 0000000..d9811f1 --- /dev/null +++ b/Unused/Decal.Adapter/FriendlyNameAttribute.cs @@ -0,0 +1,16 @@ +using System; + +namespace Decal.Adapter; + +[AttributeUsage(AttributeTargets.Class)] +public sealed class FriendlyNameAttribute : Attribute +{ + private string myName; + + public string Name => myName; + + public FriendlyNameAttribute(string name) + { + myName = name; + } +} diff --git a/Unused/Decal.Adapter/GenericDisposableWrapper.cs b/Unused/Decal.Adapter/GenericDisposableWrapper.cs new file mode 100644 index 0000000..0d64f34 --- /dev/null +++ b/Unused/Decal.Adapter/GenericDisposableWrapper.cs @@ -0,0 +1,32 @@ +using System; +using System.ComponentModel; +using System.Runtime.InteropServices; + +namespace Decal.Adapter; + +public class GenericDisposableWrapper : DisposableByRefObject where T : class +{ + private T myObj; + + [CLSCompliant(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public T Underlying => myObj; + + [CLSCompliant(false)] + protected T Wrapped => myObj; + + internal GenericDisposableWrapper(T obj) + { + myObj = obj; + } + + protected override void Dispose(bool userCalled) + { + EnforceDisposedOnce(); + base.Dispose(userCalled); + if (myObj != null) + { + Marshal.ReleaseComObject(myObj); + } + } +} diff --git a/Unused/Decal.Adapter/HResults.cs b/Unused/Decal.Adapter/HResults.cs new file mode 100644 index 0000000..51c4e42 --- /dev/null +++ b/Unused/Decal.Adapter/HResults.cs @@ -0,0 +1,9 @@ +namespace Decal.Adapter; + +internal enum HResults +{ + E_FAIL = -2147483640, + E_NOINTERFACE = -2147483644, + S_FAIL = -1, + S_OK = 0 +} diff --git a/Unused/Decal.Adapter/IAdapterSurrogate.cs b/Unused/Decal.Adapter/IAdapterSurrogate.cs new file mode 100644 index 0000000..514d28c --- /dev/null +++ b/Unused/Decal.Adapter/IAdapterSurrogate.cs @@ -0,0 +1,41 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Decal.Interop.Core; + +namespace Decal.Adapter; + +[ComImport] +[InterfaceType(1)] +[Guid("DA98635C-A312-463B-A746-2CF62AF7413A")] +internal interface IAdapterSurrogate +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + IntPtr CreateInstance([MarshalAs(UnmanagedType.Interface)] DecalEnum pInitData, ref Guid riid); + + [DispId(1610678273)] + string Version + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void SetEnum([MarshalAs(UnmanagedType.Interface)] DecalEnum pInitData); + + [DispId(1610678275)] + bool FileExists + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678276)] + string FilePath + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } +} diff --git a/Unused/Decal.Adapter/IndexChangeEventArgs.cs b/Unused/Decal.Adapter/IndexChangeEventArgs.cs new file mode 100644 index 0000000..de27188 --- /dev/null +++ b/Unused/Decal.Adapter/IndexChangeEventArgs.cs @@ -0,0 +1,14 @@ +namespace Decal.Adapter; + +public class IndexChangeEventArgs : ControlEventArgs +{ + private int index; + + public int Index => index; + + internal IndexChangeEventArgs(int ID, int Index) + : base(ID) + { + index = Index; + } +} diff --git a/Unused/Decal.Adapter/ItemDestroyedEventArgs.cs b/Unused/Decal.Adapter/ItemDestroyedEventArgs.cs new file mode 100644 index 0000000..a71d844 --- /dev/null +++ b/Unused/Decal.Adapter/ItemDestroyedEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter; + +public class ItemDestroyedEventArgs : EventArgs +{ + private int myItemGUID; + + public int ItemGuid => myItemGUID; + + internal ItemDestroyedEventArgs(int itemGUID) + { + myItemGUID = itemGUID; + } +} diff --git a/Unused/Decal.Adapter/ItemSelectedEventArgs.cs b/Unused/Decal.Adapter/ItemSelectedEventArgs.cs new file mode 100644 index 0000000..ce0fa4b --- /dev/null +++ b/Unused/Decal.Adapter/ItemSelectedEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter; + +public class ItemSelectedEventArgs : EventArgs +{ + private int myItemGUID; + + public int ItemGuid => myItemGUID; + + internal ItemSelectedEventArgs(int itemGUID) + { + myItemGUID = itemGUID; + } +} diff --git a/Unused/Decal.Adapter/LifetimeProxy.cs b/Unused/Decal.Adapter/LifetimeProxy.cs new file mode 100644 index 0000000..4258eb2 --- /dev/null +++ b/Unused/Decal.Adapter/LifetimeProxy.cs @@ -0,0 +1,72 @@ +using System; +using System.Runtime.InteropServices; +using Decal.Adapter.Support; +using Decal.Interop.Core; +using Microsoft.Win32; + +namespace Decal.Adapter; + +[ComVisible(true)] +[ComDefaultInterface(typeof(IDecalService))] +[ClassInterface(ClassInterfaceType.None)] +[ProgId("DecalAdapter.Lifetime")] +[Guid("71A69713-6593-47EC-0001-0000000DECA1")] +public sealed class LifetimeProxy : MarshalByRefObject, IDecalService, IDecalDirectory, IDecalWindowsMessageSink +{ + private CoreManager myLifetime; + + public LifetimeProxy() + { + Util.WriteLine("Lifetime Proxy retrieving Lifetime manager"); + myLifetime = CoreManager.Current; + Util.WriteLine("Lifetime Proxy ctor complete"); + } + + [ComRegisterFunction] + internal static void SelfRegister(Type t) + { + RegistryKey registryKey = Registry.LocalMachine.CreateSubKey("Software\\Decal\\Services").CreateSubKey("{71A69713-6593-47EC-0001-0000000DECA1}"); + registryKey.SetValue("", "Decal .NET Lifetime Service", RegistryValueKind.String); + registryKey.SetValue("Enabled", true, RegistryValueKind.DWord); + RegistryKey registryKey2 = Registry.LocalMachine.CreateSubKey("Software\\Decal\\Surrogates").CreateSubKey("{71A69713-6593-47EC-0002-0000000DECA1}"); + registryKey2.SetValue("", "Decal.Adapter Surrogate", RegistryValueKind.String); + registryKey2.SetValue("Enabled", true, RegistryValueKind.DWord); + } + + [ComUnregisterFunction] + internal static void UnRegister(Type t) + { + } + + void IDecalService.AfterPlugins() + { + } + + void IDecalService.BeforePlugins() + { + } + + void IDecalService.Initialize(DecalCore pDecal) + { + if (!RuntimePolicyHelper.LegacyV2RuntimeEnabledSuccessfully) + { + Util.WriteLine("Can't load v2 mixed-mode"); + } + myLifetime.Initialize(pDecal); + } + + void IDecalService.Terminate() + { + myLifetime.Terminate(); + } + + object IDecalDirectory.Lookup(string strName) + { + return null; + } + + bool IDecalWindowsMessageSink.WindowMessage(int HWND, short uMsg, int wParam, int lParam) + { + return myLifetime.FireWindowMessage(HWND, uMsg, wParam, lParam); + } +} diff --git a/Unused/Decal.Adapter/ListSelectEventArgs.cs b/Unused/Decal.Adapter/ListSelectEventArgs.cs new file mode 100644 index 0000000..e37f477 --- /dev/null +++ b/Unused/Decal.Adapter/ListSelectEventArgs.cs @@ -0,0 +1,19 @@ +namespace Decal.Adapter; + +public class ListSelectEventArgs : ControlEventArgs +{ + private int row; + + private int col; + + public int Row => row; + + public int Column => col; + + internal ListSelectEventArgs(int ID, int Row, int Column) + : base(ID) + { + row = Row; + col = Column; + } +} diff --git a/Unused/Decal.Adapter/Message.cs b/Unused/Decal.Adapter/Message.cs new file mode 100644 index 0000000..8b4bdfc --- /dev/null +++ b/Unused/Decal.Adapter/Message.cs @@ -0,0 +1,509 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Xml; +using Decal.Adapter.NetParser; +using Decal.Interop.Net; + +namespace Decal.Adapter; + +/// +/// Protocol Message Data +/// +public class Message : MessageStruct +{ + private static Dictionary mRecv; + + private static Dictionary mSend; + + private static Dictionary mTypes; + + private int mType; + + internal MessageStruct mStruct; + + /// + /// Message Type + /// + public int Type => mType; + + /// + /// Returns the number of fields (or vector length) + /// + public override int Count => mStruct.Count; + + /// + /// Returns the specified field data + /// + /// Field index + /// Field value + public override object this[int index] => mStruct[index]; + + /// + /// Returns the specified field data + /// + /// Field name + /// Field value + public override object this[string name] => mStruct[name]; + + /// + /// Returns the raw bytes for this field + /// + public override byte[] RawData => mStruct.RawData; + + /// + /// Returns the next object in the (parent) vector + /// + public override object Next => mStruct.Next; + + /// + /// Returns the parent field + /// + public override MessageStruct Parent => mStruct.Parent; + + internal Message() + { + } + + internal Message(IMessage2 msg, MessageDirection dir) + { + mType = BitConverter.ToInt32(msg.RawData, 0); + mStruct = new MessageStruct(msg.RawData, 4, GetParser(mType, dir)); + } + + internal Message(byte[] Data, MemberParser Parser) + { + mType = BitConverter.ToInt32(Data, 0); + mStruct = new MessageStruct(Data, 4, Parser); + } + + internal Message(Message Source) + { + mType = Source.mType; + mStruct = Source.mStruct; + } + + internal static MemberParser GetParser(int type, MessageDirection dir) + { + MemberParser result = null; + switch (dir) + { + case MessageDirection.Inbound: + if (mRecv.ContainsKey(type)) + { + result = mRecv[type]; + } + break; + case MessageDirection.Outbound: + if (mSend.ContainsKey(type)) + { + result = mSend[type]; + } + break; + } + return result; + } + + /// + /// Return the field name for the specified index + /// + /// Field index + /// Name of the field + public override string Name(int index) + { + return mStruct.Name(index); + } + + /// + /// Returns the passed in value? + /// + /// + /// + public override string Name(string memberName) + { + return mStruct.Name(memberName); + } + + /// + /// Returns the specified child structure + /// + /// Field index + /// MessageStruct for the specified field + public override MessageStruct Struct(int index) + { + return mStruct.Struct(index); + } + + /// + /// Returns the specified child structure + /// + /// Field name + /// MessageStruct for the specified field + public override MessageStruct Struct(string name) + { + return mStruct.Struct(name); + } + + /// + /// Returns the specified field value + /// + /// Type of the field + /// Field index + /// Field value cast to the specified FieldType + public override FieldType Value(int index) + { + return mStruct.Value(index); + } + + /// + /// Returns the specified field value + /// + /// Type of the field + /// Field name + /// Field value cast to the specified FieldType + public override FieldType Value(string name) + { + return mStruct.Value(name); + } + + /// + /// Returns the raw bytes of the specified field + /// + /// Field index + /// Raw field value + public override byte[] RawValue(int index) + { + return mStruct.RawValue(index); + } + + /// + /// Returns the raw bytes of the specified field + /// + /// Field name + /// Raw field value + public override byte[] RawValue(string name) + { + return mStruct.RawValue(name); + } + + internal static void Initialize(string xmlFile) + { + mRecv = new Dictionary(); + mSend = new Dictionary(); + mTypes = new Dictionary(); + XmlDocument xmlDocument = new XmlDocument(); + xmlDocument.Load(xmlFile); + foreach (XmlNode item in xmlDocument.SelectNodes("/schema/datatypes/type")) + { + ParseType(item, xmlDocument); + } + foreach (XmlNode item2 in xmlDocument.SelectNodes("/schema/messages/message")) + { + ParseMessage(item2, xmlDocument); + } + } + + private static void ParseType(XmlNode node, XmlDocument doc) + { + XmlAttribute xmlAttribute = node.Attributes["name"]; + if (xmlAttribute == null) + { + return; + } + string value = xmlAttribute.Value; + if (mTypes.ContainsKey(value)) + { + return; + } + MemberParser memberParser = new MemberParser(); + mTypes.Add(value, memberParser); + xmlAttribute = node.Attributes["primitive"]; + if (xmlAttribute != null && string.Compare(xmlAttribute.Value, "true", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + if (string.Compare(value, "BYTE", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.BYTE; + } + else if (string.Compare(value, "WORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.WORD; + } + else if (string.Compare(value, "PackedWORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.PackedWORD; + } + else if (string.Compare(value, "DWORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.DWORD; + } + else if (string.Compare(value, "PackedDWORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.PackedDWORD; + } + else if (string.Compare(value, "QWORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.QWORD; + } + else if (string.Compare(value, "float", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.@float; + } + else if (string.Compare(value, "double", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.@double; + } + else if (string.Compare(value, "String", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.String; + } + else if (string.Compare(value, "WString", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser.MemberType = MemberParserType.WString; + } + } + else + { + memberParser.MemberType = MemberParserType.Struct; + memberParser.Child = ParseStruct(node.ChildNodes, doc); + } + } + + private static void ParseMessage(XmlNode node, XmlDocument doc) + { + XmlAttribute xmlAttribute = node.Attributes["type"]; + if (xmlAttribute == null) + { + return; + } + string text = xmlAttribute.Value; + if (text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) + { + text = text.Substring(2); + } + int key = int.Parse(text, NumberStyles.HexNumber); + bool flag = true; + bool flag2 = false; + xmlAttribute = node.Attributes["direction"]; + if (xmlAttribute != null) + { + if (string.Compare(xmlAttribute.Value, "outbound", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + flag = false; + flag2 = true; + } + else if (string.Compare(xmlAttribute.Value, "both", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + flag2 = true; + } + } + if ((flag && !mRecv.ContainsKey(key)) || (flag2 && !mSend.ContainsKey(key))) + { + MemberParser value = ParseStruct(node.ChildNodes, doc); + if (flag && !mRecv.ContainsKey(key)) + { + mRecv.Add(key, value); + } + if (flag2 && !mSend.ContainsKey(key)) + { + mSend.Add(key, value); + } + } + } + + private static MemberParser ParseStruct(XmlNodeList nodes, XmlDocument doc) + { + MemberParser memberParser = new MemberParser(); + MemberParser memberParser2 = memberParser; + int count = nodes.Count; + for (int i = 0; i < count; i++) + { + XmlNode xmlNode = nodes[i]; + if (xmlNode.NodeType != XmlNodeType.Element) + { + continue; + } + string name = xmlNode.Name; + if (string.Compare(name, "field", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + XmlAttribute xmlAttribute = xmlNode.Attributes["type"]; + if (xmlAttribute != null) + { + string value = xmlAttribute.Value; + if (!mTypes.ContainsKey(value)) + { + ParseType(doc.SelectSingleNode("/schema/datatypes/type[@name='" + value + "']"), doc); + } + memberParser2.Next = new MemberParser(mTypes[value]); + memberParser2 = memberParser2.Next; + memberParser2.MemberName = xmlNode.Attributes["name"].Value; + } + } + else if (string.Compare(name, "maskmap", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + XmlAttribute xmlAttribute = xmlNode.Attributes["xor"]; + long conditionXor = 0L; + string value; + if (xmlAttribute != null) + { + value = xmlAttribute.Value; + if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) + { + value = value.Substring(2); + } + conditionXor = long.Parse(value, NumberStyles.HexNumber); + } + value = xmlNode.Attributes["name"].Value; + memberParser2.Next = ParseMaskMap(xmlNode.ChildNodes, doc); + while (memberParser2.Next != null) + { + memberParser2 = memberParser2.Next; + memberParser2.Condition = MemberParserCondition.NE; + memberParser2.ConditionResult = 0L; + memberParser2.ConditionField = value; + memberParser2.ConditionXor = conditionXor; + } + } + else if (string.Compare(name, "switch", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + string value = xmlNode.Attributes["name"].Value; + XmlAttribute xmlAttribute = xmlNode.Attributes["mask"]; + long conditionXor = -1L; + if (xmlAttribute != null) + { + value = xmlAttribute.Value; + if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) + { + value = value.Substring(2); + } + conditionXor = long.Parse(value, NumberStyles.HexNumber); + } + memberParser2.Next = ParseSwitch(xmlNode.ChildNodes, doc); + while (memberParser2.Next != null) + { + memberParser2 = memberParser2.Next; + memberParser2.Condition = MemberParserCondition.EQ; + memberParser2.ConditionField = value; + memberParser2.ConditionAnd = conditionXor; + } + } + else if (string.Compare(name, "vector", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser2.Next = new MemberParser(); + memberParser2 = memberParser2.Next; + memberParser2.MemberType = MemberParserType.Vector; + memberParser2.MemberName = xmlNode.Attributes["name"].Value; + memberParser2.LengthField = xmlNode.Attributes["length"].Value; + XmlAttribute xmlAttribute = xmlNode.Attributes["mask"]; + long conditionXor = -1L; + if (xmlAttribute != null) + { + string value = xmlAttribute.Value; + if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) + { + value = value.Substring(2); + } + conditionXor = long.Parse(value, NumberStyles.HexNumber); + } + memberParser2.LengthMask = conditionXor; + xmlAttribute = xmlNode.Attributes["skip"]; + int num = 0; + if (xmlAttribute != null) + { + string value = xmlAttribute.Value; + if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) + { + value = value.Substring(2); + } + num = int.Parse(value, NumberStyles.HexNumber); + } + memberParser2.LengthDelta = -num; + memberParser2.Child = ParseStruct(xmlNode.ChildNodes, doc); + } + else if (string.Compare(name, "align", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + string value = xmlNode.Attributes["type"].Value; + if (string.Compare(value, "WORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser2.PostAlignment = 2; + } + else if (string.Compare(value, "DWORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser2.PostAlignment = 4; + } + else if (string.Compare(value, "QWORD", ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + memberParser2.PostAlignment = 8; + } + } + } + if (memberParser.PostAlignment != 0 && memberParser.Next != null) + { + memberParser.Next.PreAlignment = memberParser.PostAlignment; + } + return memberParser.Next; + } + + private static MemberParser ParseMaskMap(XmlNodeList nodes, XmlDocument doc) + { + MemberParser memberParser = new MemberParser(); + MemberParser memberParser2 = memberParser; + int count = nodes.Count; + for (int i = 0; i < count; i++) + { + XmlNode xmlNode = nodes[i]; + if (xmlNode.NodeType != XmlNodeType.Element || string.Compare(xmlNode.Name, "mask", ignoreCase: true, CultureInfo.InvariantCulture) != 0) + { + continue; + } + long conditionAnd = 0L; + XmlAttribute xmlAttribute = xmlNode.Attributes["value"]; + if (xmlAttribute != null) + { + string text = xmlAttribute.Value; + if (text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) + { + text = text.Substring(2); + } + conditionAnd = long.Parse(text, NumberStyles.HexNumber); + } + memberParser2.Next = new MemberParser(); + memberParser2 = memberParser2.Next; + memberParser2.MemberType = MemberParserType.Case; + memberParser2.ConditionAnd = conditionAnd; + memberParser2.Child = ParseStruct(xmlNode.ChildNodes, doc); + } + return memberParser.Next; + } + + private static MemberParser ParseSwitch(XmlNodeList nodes, XmlDocument doc) + { + MemberParser memberParser = new MemberParser(); + MemberParser memberParser2 = memberParser; + int count = nodes.Count; + for (int i = 0; i < count; i++) + { + XmlNode xmlNode = nodes[i]; + if (xmlNode.NodeType != XmlNodeType.Element || string.Compare(xmlNode.Name, "case", ignoreCase: true, CultureInfo.InvariantCulture) != 0) + { + continue; + } + long conditionResult = 0L; + XmlAttribute xmlAttribute = xmlNode.Attributes["value"]; + if (xmlAttribute != null) + { + string text = xmlAttribute.Value; + if (text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) + { + text = text.Substring(2); + } + conditionResult = long.Parse(text, NumberStyles.HexNumber); + } + memberParser2.Next = new MemberParser(); + memberParser2 = memberParser2.Next; + memberParser2.MemberType = MemberParserType.Case; + memberParser2.ConditionResult = conditionResult; + memberParser2.Child = ParseStruct(xmlNode.ChildNodes, doc); + } + return memberParser.Next; + } +} diff --git a/Unused/Decal.Adapter/MessageDirection.cs b/Unused/Decal.Adapter/MessageDirection.cs new file mode 100644 index 0000000..e0f90fe --- /dev/null +++ b/Unused/Decal.Adapter/MessageDirection.cs @@ -0,0 +1,16 @@ +namespace Decal.Adapter; + +/// +/// Message Direction +/// +public enum MessageDirection +{ + /// + /// Server to Client message + /// + Inbound, + /// + /// Client to Server message + /// + Outbound +} diff --git a/Unused/Decal.Adapter/MessageProcessedEventArgs.cs b/Unused/Decal.Adapter/MessageProcessedEventArgs.cs new file mode 100644 index 0000000..ffa1ad8 --- /dev/null +++ b/Unused/Decal.Adapter/MessageProcessedEventArgs.cs @@ -0,0 +1,31 @@ +using System; +using System.Runtime.InteropServices; + +namespace Decal.Adapter; + +public class MessageProcessedEventArgs : EventArgs +{ + private Message myMessage; + + private int myData; + + private int mySize; + + public Message Message => myMessage; + + public int Data => myData; + + public int Size => mySize; + + internal MessageProcessedEventArgs(int pbData, int dwSize) + { + if (pbData != 0 && dwSize != 0) + { + byte[] array = (byte[])Array.CreateInstance(typeof(byte), dwSize); + Marshal.Copy(new IntPtr(pbData), array, 0, dwSize); + myMessage = new Message(array, Message.GetParser(BitConverter.ToInt32(array, 0), MessageDirection.Inbound)); + } + myData = pbData; + mySize = dwSize; + } +} diff --git a/Unused/Decal.Adapter/MessageStruct.cs b/Unused/Decal.Adapter/MessageStruct.cs new file mode 100644 index 0000000..cb844f2 --- /dev/null +++ b/Unused/Decal.Adapter/MessageStruct.cs @@ -0,0 +1,676 @@ +using System; +using System.Globalization; +using System.Text; +using Decal.Adapter.NetParser; +using Decal.Adapter.Support; + +namespace Decal.Adapter; + +/// +/// Represents Message data +/// +public class MessageStruct : MarshalByRefObject +{ + internal struct MessageField + { + internal string Name; + + internal MemberParserType Type; + + internal object Value; + + internal int Offset; + + internal int Length; + } + + internal byte[] mData; + + internal int mOffset; + + internal int mLength; + + internal MemberParser mParser; + + internal MessageStruct mParent; + + internal int mIndex; + + internal bool mParsed; + + internal int mCount; + + internal MessageField[] mFields; + + /// + /// Returns the number of fields (or vector length) + /// + public virtual int Count + { + get + { + if (!mParsed) + { + Parse(); + } + return mCount; + } + } + + /// + /// Returns the specified field data + /// + /// Field index + /// Field value + public virtual object this[int index] + { + get + { + if (!mParsed) + { + Parse(); + } + if (index >= 0 && index < mCount) + { + return mFields[index].Value; + } + return null; + } + } + + /// + /// Returns the specified field data + /// + /// Field name + /// Field value + public virtual object this[string name] + { + get + { + if (!mParsed) + { + Parse(); + } + int num = IndexFromName(name); + if (num >= 0 && num < mCount) + { + return mFields[num].Value; + } + return null; + } + } + + /// + /// Returns the raw bytes for this field + /// + public virtual byte[] RawData + { + get + { + if (mParent != null) + { + return mParent.RawValue(mIndex); + } + byte[] array = (byte[])Array.CreateInstance(typeof(byte), mData.Length); + Buffer.BlockCopy(mData, 0, array, 0, mData.Length); + return array; + } + } + + /// + /// Returns the next object in the (parent) vector + /// + public virtual object Next + { + get + { + if (mParent == null) + { + return null; + } + return mParent[mIndex + 1]; + } + } + + /// + /// Returns the parent field + /// + public virtual MessageStruct Parent => mParent; + + internal MessageStruct() + { + } + + internal MessageStruct(byte[] Data, int Offset, MemberParser Parser) + { + mData = (byte[])Array.CreateInstance(typeof(byte), Data.Length); + Buffer.BlockCopy(Data, 0, mData, 0, mData.Length); + mOffset = Offset; + mParser = Parser; + mCount = -1; + } + + internal MessageStruct(byte[] Data, int Offset, MemberParser Parser, MessageStruct Parent, int Index) + { + mData = Data; + mOffset = Offset; + mParser = Parser; + mParent = Parent; + mIndex = Index; + mCount = -1; + } + + internal MessageStruct(byte[] Data, int Offset, MemberParser Parser, int Length, MessageStruct Parent, int Index) + { + mData = Data; + mOffset = Offset; + mParser = Parser; + mParent = Parent; + mIndex = Index; + mCount = Length; + } + + internal int ObjectToIndex(object vIndex) + { + string text = vIndex as string; + int num = -1; + num = (string.IsNullOrEmpty(text) ? Util.UnboxTo(vIndex) : IndexFromName(text)); + if (num >= 0 && num < mCount) + { + return num; + } + return -1; + } + + /// + /// Return the field name for the specified index + /// + /// Field index + /// Name of the field + public virtual string Name(int index) + { + if (!mParsed) + { + Parse(); + } + if (index >= 0 && index < mCount) + { + return mFields[index].Name; + } + return null; + } + + /// + /// Returns the passed in value? + /// + /// + /// + public virtual string Name(string memberName) + { + if (!mParsed) + { + Parse(); + } + int num = IndexFromName(memberName); + if (num >= 0 && num < mCount) + { + return mFields[num].Name; + } + return null; + } + + /// + /// Returns the specified child structure + /// + /// Field index + /// MessageStruct for the specified field + public virtual MessageStruct Struct(int index) + { + if (!mParsed) + { + Parse(); + } + if (index >= 0 && index < mCount) + { + MemberParserType type = mFields[index].Type; + if (type == MemberParserType.Struct || type == MemberParserType.Vector) + { + return mFields[index].Value as MessageStruct; + } + } + return null; + } + + /// + /// Returns the specified child structure + /// + /// Field name + /// MessageStruct for the specified field + public virtual MessageStruct Struct(string name) + { + if (!mParsed) + { + Parse(); + } + int num = IndexFromName(name); + if (num >= 0 && num < mCount) + { + MemberParserType type = mFields[num].Type; + if (type == MemberParserType.Struct || type == MemberParserType.Vector) + { + return mFields[num].Value as MessageStruct; + } + } + return null; + } + + /// + /// Returns the specified field value + /// + /// Type of the field + /// Field index + /// Field value cast to the specified FieldType + public virtual FieldType Value(int index) + { + if (!mParsed) + { + Parse(); + } + if (index >= 0 && index < mCount) + { + return Util.UnboxTo(mFields[index].Value); + } + return default(FieldType); + } + + /// + /// Returns the specified field value + /// + /// Type of the field + /// Field name + /// Field value cast to the specified FieldType + public virtual FieldType Value(string name) + { + if (!mParsed) + { + Parse(); + } + int num = IndexFromName(name); + if (num >= 0 && num < mCount) + { + return Util.UnboxTo(mFields[num].Value); + } + return default(FieldType); + } + + /// + /// Returns the raw bytes of the specified field + /// + /// Field index + /// Raw field value + public virtual byte[] RawValue(int index) + { + if (!mParsed) + { + Parse(); + } + if (index >= 0 && index < mCount) + { + int length = mFields[index].Length; + byte[] array = (byte[])Array.CreateInstance(typeof(byte), length); + Buffer.BlockCopy(mData, mFields[index].Offset, array, 0, length); + return array; + } + return null; + } + + /// + /// Returns the raw bytes of the specified field + /// + /// Field name + /// Raw field value + public virtual byte[] RawValue(string name) + { + if (!mParsed) + { + Parse(); + } + int num = IndexFromName(name); + if (num >= 0 && num < mCount) + { + int length = mFields[num].Length; + byte[] array = (byte[])Array.CreateInstance(typeof(byte), length); + Buffer.BlockCopy(mData, mFields[num].Offset, array, 0, length); + return array; + } + return null; + } + + internal int IndexFromName(string Name) + { + int num = mCount; + for (int i = 0; i < num; i++) + { + if (string.Compare(Name, mFields[i].Name, ignoreCase: true, CultureInfo.InvariantCulture) == 0) + { + return i; + } + } + return -1; + } + + internal void Parse() + { + if (mCount == -1) + { + ParseStruct(); + } + else + { + ParseVector(); + } + } + + internal void ParseStruct() + { + int length = ParseCounter(mParser); + mFields = (MessageField[])Array.CreateInstance(typeof(MessageField), length); + mParsed = true; + int ByteIndex = mOffset; + mCount = 0; + ParseHelper(mParser, ref mCount, ref ByteIndex); + mLength = ByteIndex - mOffset; + MessageField[] sourceArray = mFields; + mFields = (MessageField[])Array.CreateInstance(typeof(MessageField), mCount); + Array.Copy(sourceArray, mFields, mCount); + } + + internal void ParseVector() + { + int num = mCount; + mFields = (MessageField[])Array.CreateInstance(typeof(MessageField), num); + mParsed = true; + int num2 = mOffset; + for (int i = 0; i < num; i++) + { + mFields[i].Name = i.ToString(); + mFields[i].Offset = num2; + mFields[i].Type = MemberParserType.Struct; + MessageStruct messageStruct = new MessageStruct(mData, num2, mParser, this, i); + messageStruct.ParseStruct(); + mFields[i].Value = messageStruct; + mFields[i].Length = messageStruct.mLength; + num2 += messageStruct.mLength; + } + mLength = num2 - mOffset; + } + + internal int ParseCounter(MemberParser Parser) + { + int num = 0; + while (Parser != null) + { + num = ((Parser.MemberType != MemberParserType.Case) ? (num + 1) : (num + ParseCounter(Parser.Child))); + Parser = Parser.Next; + } + return num; + } + + internal void ParseHelper(MemberParser Parser, ref int FieldIndex, ref int ByteIndex) + { + Encoding encoding = Encoding.GetEncoding(1252); + while (Parser != null) + { + if (Parser.PreAlignment != 0) + { + int num = ByteIndex % Parser.PreAlignment; + if (num != 0) + { + ByteIndex += Parser.PreAlignment - num; + } + } + bool flag = Parser.Condition == MemberParserCondition.None; + if (!flag) + { + MessageStruct messageStruct = this; + object obj; + do + { + obj = messageStruct[Parser.ConditionField]; + if (obj != null) + { + break; + } + messageStruct = messageStruct.mParent; + } + while (messageStruct != null); + if (obj != null) + { + long num2 = 0L; + Type type = obj.GetType(); + if (type.Equals(typeof(int))) + { + num2 = Convert.ToInt64(obj); + num2 &= 0xFFFFFFFFu; + } + else if (type.Equals(typeof(short))) + { + num2 = Convert.ToInt64(obj); + num2 &= 0xFFFF; + } + else if (type.Equals(typeof(byte))) + { + num2 = Convert.ToInt64(obj); + num2 &= 0xFF; + } + else if (type.Equals(typeof(long))) + { + num2 = Convert.ToInt64(obj); + } + num2 ^= Parser.ConditionXor; + num2 &= Parser.ConditionAnd; + switch (Parser.Condition) + { + case MemberParserCondition.EQ: + flag = num2 == Parser.ConditionResult; + break; + case MemberParserCondition.NE: + flag = num2 != Parser.ConditionResult; + break; + case MemberParserCondition.GE: + flag = num2 >= Parser.ConditionResult; + break; + case MemberParserCondition.GT: + flag = num2 > Parser.ConditionResult; + break; + case MemberParserCondition.LE: + flag = num2 <= Parser.ConditionResult; + break; + case MemberParserCondition.LT: + flag = num2 < Parser.ConditionResult; + break; + } + } + } + if (flag) + { + mFields[FieldIndex].Name = Parser.MemberName; + mFields[FieldIndex].Offset = ByteIndex; + mFields[FieldIndex].Type = Parser.MemberType; + switch (Parser.MemberType) + { + case MemberParserType.BYTE: + mFields[FieldIndex].Value = mData[ByteIndex++]; + break; + case MemberParserType.WORD: + mFields[FieldIndex].Value = BitConverter.ToInt16(mData, ByteIndex); + ByteIndex += 2; + break; + case MemberParserType.PackedWORD: + { + int num6 = mData[ByteIndex++]; + if ((num6 & 0x80) != 0) + { + num6 = ((num6 & 0x7F) << 8) | mData[ByteIndex++]; + } + mFields[FieldIndex].Value = num6; + break; + } + case MemberParserType.DWORD: + mFields[FieldIndex].Value = BitConverter.ToInt32(mData, ByteIndex); + ByteIndex += 4; + break; + case MemberParserType.PackedDWORD: + { + int num6 = BitConverter.ToInt16(mData, ByteIndex); + ByteIndex += 2; + if ((num6 & 0x8000) != 0) + { + num6 = ((num6 & 0x7FFF) << 16) | (BitConverter.ToInt16(mData, ByteIndex) & 0xFFFF); + ByteIndex += 2; + } + mFields[FieldIndex].Value = num6; + break; + } + case MemberParserType.QWORD: + mFields[FieldIndex].Value = BitConverter.ToInt64(mData, ByteIndex); + ByteIndex += 8; + break; + case MemberParserType.@float: + mFields[FieldIndex].Value = BitConverter.ToSingle(mData, ByteIndex); + ByteIndex += 4; + break; + case MemberParserType.@double: + mFields[FieldIndex].Value = BitConverter.ToDouble(mData, ByteIndex); + ByteIndex += 8; + break; + case MemberParserType.String: + { + int num6 = BitConverter.ToInt16(mData, ByteIndex); + ByteIndex += 2; + if (num6 == -1) + { + num6 = BitConverter.ToInt32(mData, ByteIndex); + ByteIndex += 4; + } + StringBuilder stringBuilder = new StringBuilder(num6); + for (int j = 0; j < num6; j++) + { + stringBuilder.Append(encoding.GetChars(mData, ByteIndex++, 1)); + } + mFields[FieldIndex].Value = stringBuilder.ToString(); + ByteIndex = (ByteIndex + 3) & -4; + break; + } + case MemberParserType.WString: + { + int num6 = mData[ByteIndex++]; + if ((num6 & 0x80) != 0) + { + num6 = ((num6 & 0x7F) << 8) | mData[ByteIndex++]; + } + StringBuilder stringBuilder = new StringBuilder(num6); + for (int i = 0; i < num6; i++) + { + stringBuilder.Append(BitConverter.ToChar(mData, ByteIndex)); + ByteIndex += 2; + } + mFields[FieldIndex].Value = stringBuilder.ToString(); + break; + } + case MemberParserType.Struct: + { + MessageStruct messageStruct = new MessageStruct(mData, ByteIndex, Parser.Child, this, FieldIndex); + messageStruct.ParseStruct(); + ByteIndex += messageStruct.mLength; + mFields[FieldIndex].Value = messageStruct; + break; + } + case MemberParserType.Vector: + { + MessageStruct messageStruct = this; + object obj; + do + { + obj = messageStruct[Parser.LengthField]; + if (obj != null) + { + break; + } + messageStruct = messageStruct.mParent; + } + while (messageStruct != null); + long num4 = 0L; + if (obj != null) + { + Type type2 = obj.GetType(); + if (type2.Equals(typeof(int))) + { + num4 = Convert.ToInt64(obj); + num4 &= 0xFFFFFFFFu; + } + else if (type2.Equals(typeof(short))) + { + num4 = Convert.ToInt64(obj); + num4 &= 0xFFFF; + } + else if (type2.Equals(typeof(byte))) + { + num4 = Convert.ToInt64(obj); + num4 &= 0xFF; + } + else if (type2.Equals(typeof(long))) + { + num4 = Convert.ToInt64(obj); + } + } + long num5 = Parser.LengthMask; + num4 &= num5; + if (num5 != 0L) + { + while ((num5 & 1) == 0L) + { + num4 >>= 1; + num5 >>= 1; + } + } + messageStruct = new MessageStruct(mData, ByteIndex, Parser.Child, (int)num4 + Parser.LengthDelta, this, FieldIndex); + messageStruct.ParseVector(); + ByteIndex += messageStruct.mLength; + mFields[FieldIndex].Value = messageStruct; + break; + } + case MemberParserType.Case: + { + int num3 = FieldIndex; + ParseHelper(Parser.Child, ref FieldIndex, ref ByteIndex); + if (FieldIndex > num3) + { + FieldIndex--; + } + break; + } + } + mFields[FieldIndex].Length = ByteIndex - mFields[FieldIndex].Offset; + } + if (Parser.PostAlignment != 0) + { + int num7 = ByteIndex % Parser.PostAlignment; + if (num7 != 0) + { + num7 = Parser.PostAlignment - num7; + ByteIndex += num7; + if (flag) + { + mFields[FieldIndex].Length += num7; + } + } + } + if (flag) + { + FieldIndex++; + } + Parser = Parser.Next; + } + } +} diff --git a/Unused/Decal.Adapter/NetworkMessageEventArgs.cs b/Unused/Decal.Adapter/NetworkMessageEventArgs.cs new file mode 100644 index 0000000..4a202c3 --- /dev/null +++ b/Unused/Decal.Adapter/NetworkMessageEventArgs.cs @@ -0,0 +1,15 @@ +using System; + +namespace Decal.Adapter; + +public class NetworkMessageEventArgs : EventArgs +{ + private Message myMsg; + + public Message Message => myMsg; + + internal NetworkMessageEventArgs(Message msg) + { + myMsg = msg; + } +} diff --git a/Unused/Decal.Adapter/PluginBase.cs b/Unused/Decal.Adapter/PluginBase.cs new file mode 100644 index 0000000..bdf5366 --- /dev/null +++ b/Unused/Decal.Adapter/PluginBase.cs @@ -0,0 +1,226 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using Decal.Adapter.Wrappers; + +namespace Decal.Adapter; + +/// +/// Base class used to create Decal Plugins +/// +[CLSCompliant(true)] +public abstract class PluginBase : Extension, IViewHandler +{ + private PluginHost myHost; + + private EventHandler myGraphicsReset; + + private BindingFlags myBindingFlags; + + private Dictionary myViews; + + /// + /// Wrapper Object to the Host. + /// Similar to IPluginSite + /// + protected PluginHost Host => myHost; + + /// + /// The Default view + /// + public ViewWrapper DefaultView => myViews["Default"]; + + /// + /// BindingFlags for internal scanning + /// + public BindingFlags BindingFlags => myBindingFlags; + + [CLSCompliant(false)] + protected event EventHandler ServerDispatch + { + add + { + if (base.Core.EchoFilter != null) + { + base.Core.EchoFilter.ServerDispatch += value; + } + } + remove + { + if (base.Core.EchoFilter != null) + { + base.Core.EchoFilter.ServerDispatch -= value; + } + } + } + + [CLSCompliant(false)] + protected event EventHandler ClientDispatch + { + add + { + if (base.Core.EchoFilter != null) + { + base.Core.EchoFilter.ClientDispatch += value; + } + } + remove + { + if (base.Core.EchoFilter != null) + { + base.Core.EchoFilter.ClientDispatch -= value; + } + } + } + + protected event EventHandler GraphicsReset + { + add + { + myGraphicsReset = (EventHandler)Delegate.Combine(myGraphicsReset, value); + if (myHost != null) + { + myHost.Render.DeviceLost += value; + } + } + remove + { + myGraphicsReset = (EventHandler)Delegate.Remove(myGraphicsReset, value); + if (myHost != null) + { + myHost.Render.DeviceLost -= value; + } + } + } + + /// + /// Default Constructor for the Base class. Should be called by all decendants. + /// + protected PluginBase() + : base(DecalExtensionType.Plugin) + { + myBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; + } + + /// + /// Called by the base class to Wire Up events. + /// + internal override void Wireup() + { + if (myGraphicsReset != null) + { + Host.Render.DeviceLost += myGraphicsReset; + } + scanBaseEvents(connect: true); + myViews = new Dictionary(); + PluginHost.LoadViewHandler(this); + } + + /// + /// Called by the base class to Unwire events + /// + internal override void UnWire() + { + if (myGraphicsReset != null) + { + Host.Render.DeviceLost -= myGraphicsReset; + } + scanBaseEvents(connect: false); + foreach (ViewWrapper value in myViews.Values) + { + value.Dispose(); + } + myViews.Clear(); + } + + /// + /// Used for internal wiring up of base-class variables. + /// Called by PluginProxy + /// + /// Host (pluginsite) object + internal void SetHost(PluginHost newHost) + { + myHost = newHost; + } + + private void scanBaseEvents(bool connect) + { + Type type = GetType(); + Type type2 = base.Core.GetType(); + if (!Attribute.IsDefined(type, typeof(WireUpBaseEventsAttribute))) + { + return; + } + MethodInfo[] methods = type.GetMethods(BindingFlags); + foreach (MethodInfo methodInfo in methods) + { + if (!Attribute.IsDefined(methodInfo, typeof(BaseEventAttribute))) + { + continue; + } + Attribute[] customAttributes = Attribute.GetCustomAttributes(methodInfo, typeof(BaseEventAttribute)); + for (int j = 0; j < customAttributes.Length; j++) + { + BaseEventAttribute baseEventAttribute = (BaseEventAttribute)customAttributes[j]; + object obj; + Type type3; + if (baseEventAttribute.FilterName == string.Empty) + { + obj = this; + type3 = type; + } + else + { + PropertyInfo property = type2.GetProperty(baseEventAttribute.FilterName, BindingFlags.Instance | BindingFlags.Public); + if (property == null) + { + continue; + } + obj = property.GetValue(base.Core, null); + type3 = obj.GetType(); + } + EventInfo eventInfo = null; + while ((eventInfo = type3.GetEvent(baseEventAttribute.EventName, BindingFlags)) == null && type3 == type) + { + type3 = type2; + obj = base.Core; + } + if (!(eventInfo == null)) + { + if (connect) + { + eventInfo.GetAddMethod(nonPublic: true).Invoke(obj, new object[1] { Delegate.CreateDelegate(eventInfo.EventHandlerType, this, methodInfo.Name) }); + } + else + { + eventInfo.GetRemoveMethod(nonPublic: true).Invoke(obj, new object[1] { Delegate.CreateDelegate(eventInfo.EventHandlerType, this, methodInfo.Name) }); + } + } + } + } + } + + /// + /// Loads a new view into the internal list (should only be called internally) + /// + /// view name + /// resource path + public void LoadView(string name, string resource) + { + myViews.Add(name, Host.LoadViewResource(resource, GetType().Assembly)); + } + + /// + /// Retrieves a view from the internal list + /// + /// view name + /// the specified view or null + public ViewWrapper GetView(string name) + { + if (myViews.TryGetValue(name, out var value)) + { + return value; + } + return null; + } +} diff --git a/Unused/Decal.Adapter/PluginProxy.cs b/Unused/Decal.Adapter/PluginProxy.cs new file mode 100644 index 0000000..b0e79a4 --- /dev/null +++ b/Unused/Decal.Adapter/PluginProxy.cs @@ -0,0 +1,71 @@ +using System; +using Decal.Adapter.Support; +using Decal.Adapter.Wrappers; +using Decal.Interop.Core; + +namespace Decal.Adapter; + +/// +/// +/// +public sealed class PluginProxy : IPlugin2, IDecalDirectory +{ + private PluginHost mySite; + + private PluginBase myWrapped; + + internal PluginProxy(PluginBase toWrap) + { + myWrapped = toWrap; + } + + void IPlugin2.Initialize(PluginSite2 Site) + { + mySite = new PluginHost(Site); + myWrapped.SetHost(mySite); + try + { + myWrapped.standardEvent(ExtensionEvents.InternalWireup); + } + catch (Exception ex) + { + Util.WriteLine("InternalWireup Exception: " + ex.Message); + } + try + { + myWrapped.standardEvent(ExtensionEvents.Startup); + } + catch (Exception ex2) + { + Util.WriteLine("Startup Exception: " + ex2.Message); + } + } + + void IPlugin2.Terminate() + { + try + { + myWrapped.standardEvent(ExtensionEvents.Shutdown); + } + catch (Exception ex) + { + Util.WriteLine("Shutdown Exception: " + ex.Message); + } + try + { + myWrapped.standardEvent(ExtensionEvents.InternalUnwire); + } + catch (Exception ex2) + { + Util.WriteLine("InternalUnwire Exception: " + ex2.Message); + } + mySite.Dispose(); + mySite = null; + myWrapped = null; + } + + object IDecalDirectory.Lookup(string strName) + { + return myWrapped.ResolvePath(strName); + } +} diff --git a/Unused/Decal.Adapter/RegionChange3DEventArgs.cs b/Unused/Decal.Adapter/RegionChange3DEventArgs.cs new file mode 100644 index 0000000..a3ff29a --- /dev/null +++ b/Unused/Decal.Adapter/RegionChange3DEventArgs.cs @@ -0,0 +1,33 @@ +using System; +using System.Drawing; + +namespace Decal.Adapter; + +public class RegionChange3DEventArgs : EventArgs +{ + private int myLeft; + + private int myRight; + + private int myTop; + + private int myBottom; + + public int Left => myLeft; + + public int Right => myRight; + + public int Top => myTop; + + public int Bottom => myBottom; + + public Rectangle Rect => new Rectangle(myLeft, myTop, myRight - myLeft, myBottom - myTop); + + internal RegionChange3DEventArgs(int left, int top, int right, int bottom) + { + myLeft = left; + myTop = top; + myRight = right; + myBottom = bottom; + } +} diff --git a/Unused/Decal.Adapter/RenderViolationException.cs b/Unused/Decal.Adapter/RenderViolationException.cs new file mode 100644 index 0000000..d2fd6e8 --- /dev/null +++ b/Unused/Decal.Adapter/RenderViolationException.cs @@ -0,0 +1,11 @@ +using System; + +namespace Decal.Adapter; + +internal class RenderViolationException : Exception +{ + internal RenderViolationException(string message) + : base(message) + { + } +} diff --git a/Unused/Decal.Adapter/RuntimePolicyHelper.cs b/Unused/Decal.Adapter/RuntimePolicyHelper.cs new file mode 100644 index 0000000..f38780c --- /dev/null +++ b/Unused/Decal.Adapter/RuntimePolicyHelper.cs @@ -0,0 +1,53 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Decal.Adapter; + +internal static class RuntimePolicyHelper +{ + [ComImport] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + [Guid("BD39D1D2-BA2F-486A-89B0-B4B0CB466891")] + private interface ICLRRuntimeInfo + { + void xGetVersionString(); + + void xGetRuntimeDirectory(); + + void xIsLoaded(); + + void xIsLoadable(); + + void xLoadErrorString(); + + void xLoadLibrary(); + + void xGetProcAddress(); + + void xGetInterface(); + + void xSetDefaultStartupFlags(); + + void xGetDefaultStartupFlags(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void BindAsLegacyV2Runtime(); + } + + public static bool LegacyV2RuntimeEnabledSuccessfully { get; private set; } + + static RuntimePolicyHelper() + { + ICLRRuntimeInfo iCLRRuntimeInfo = (ICLRRuntimeInfo)RuntimeEnvironment.GetRuntimeInterfaceAsObject(Guid.Empty, typeof(ICLRRuntimeInfo).GUID); + try + { + iCLRRuntimeInfo.BindAsLegacyV2Runtime(); + LegacyV2RuntimeEnabledSuccessfully = true; + } + catch (COMException) + { + LegacyV2RuntimeEnabledSuccessfully = false; + } + } +} diff --git a/Unused/Decal.Adapter/ServiceBase.cs b/Unused/Decal.Adapter/ServiceBase.cs new file mode 100644 index 0000000..65c6f65 --- /dev/null +++ b/Unused/Decal.Adapter/ServiceBase.cs @@ -0,0 +1,36 @@ +namespace Decal.Adapter; + +public abstract class ServiceBase : Extension +{ + internal enum ServiceEventType + { + BeforePlugins, + AfterPluigins + } + + public ServiceBase() + : base(DecalExtensionType.Service) + { + } + + internal void ServiceEvent(ServiceEventType evt) + { + switch (evt) + { + case ServiceEventType.BeforePlugins: + OnBeforePlugins(); + break; + case ServiceEventType.AfterPluigins: + OnAfterPlugins(); + break; + } + } + + protected virtual void OnBeforePlugins() + { + } + + protected virtual void OnAfterPlugins() + { + } +} diff --git a/Unused/Decal.Adapter/ServiceProxy.cs b/Unused/Decal.Adapter/ServiceProxy.cs new file mode 100644 index 0000000..9cf7d0a --- /dev/null +++ b/Unused/Decal.Adapter/ServiceProxy.cs @@ -0,0 +1,38 @@ +using Decal.Interop.Core; + +namespace Decal.Adapter; + +public sealed class ServiceProxy : IDecalService, IDecalDirectory +{ + private ServiceBase wrapped; + + internal ServiceProxy(ServiceBase toWrap) + { + wrapped = toWrap; + } + + void IDecalService.AfterPlugins() + { + wrapped.ServiceEvent(ServiceBase.ServiceEventType.AfterPluigins); + } + + void IDecalService.BeforePlugins() + { + wrapped.ServiceEvent(ServiceBase.ServiceEventType.BeforePlugins); + } + + void IDecalService.Initialize(DecalCore pDecal) + { + wrapped.standardEvent(ExtensionEvents.Startup); + } + + void IDecalService.Terminate() + { + wrapped.standardEvent(ExtensionEvents.Shutdown); + } + + object IDecalDirectory.Lookup(string strName) + { + return wrapped.ResolvePath(strName); + } +} diff --git a/Unused/Decal.Adapter/StatusTextInterceptEventArgs.cs b/Unused/Decal.Adapter/StatusTextInterceptEventArgs.cs new file mode 100644 index 0000000..9265cbc --- /dev/null +++ b/Unused/Decal.Adapter/StatusTextInterceptEventArgs.cs @@ -0,0 +1,12 @@ +namespace Decal.Adapter; + +public class StatusTextInterceptEventArgs : EatableEventArgs +{ + public string Text { get; protected set; } + + internal StatusTextInterceptEventArgs(string text, bool eat) + : base(eat) + { + Text = text; + } +} diff --git a/Unused/Decal.Adapter/Surrogate.cs b/Unused/Decal.Adapter/Surrogate.cs new file mode 100644 index 0000000..63ab31d --- /dev/null +++ b/Unused/Decal.Adapter/Surrogate.cs @@ -0,0 +1,266 @@ +using System; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Reflection; +using System.Runtime.InteropServices; +using Decal.Adapter.Support; +using Decal.Interop.Core; +using Decal.Interop.Net; +using Microsoft.Win32; + +namespace Decal.Adapter; + +/// +/// +/// +[ComVisible(true)] +[ClassInterface(ClassInterfaceType.None)] +[ComDefaultInterface(typeof(IAdapterSurrogate))] +[ProgId("DecalAdapter.Surrogate")] +[Guid("71A69713-6593-47EC-0002-0000000DECA1")] +public sealed class Surrogate : MarshalByRefObject, IAdapterSurrogate, IDecalFileSurrogate +{ + private string myAssemblyName; + + private string myPath; + + private string myTypeName; + + string IAdapterSurrogate.Version + { + get + { + CoreManager current = CoreManager.Current; + if (current == null) + { + current = CoreManager.Current; + } + if (File.Exists(Path.Combine(myPath, myAssemblyName))) + { + return FileVersionInfo.GetVersionInfo(Path.Combine(myPath, myAssemblyName)).FileVersion; + } + return ""; + } + } + + bool IAdapterSurrogate.FileExists => File.Exists(Path.Combine(myPath, myAssemblyName)); + + string IAdapterSurrogate.FilePath => Path.Combine(myPath, myAssemblyName); + + string IDecalFileSurrogate.Description => "Decal.Adapter Extension"; + + string IDecalFileSurrogate.Extension => "dll"; + + IntPtr IAdapterSurrogate.CreateInstance(DecalEnum pInitData, ref Guid riid) + { + if (CoreManager.ServiceRunning) + { + CoreManager current = CoreManager.Current; + try + { + myTypeName = (string)((IDecalEnum)pInitData).get_Property("Object"); + myAssemblyName = (string)((IDecalEnum)pInitData).get_Property("Assembly"); + myPath = (string)((IDecalEnum)pInitData).get_Property("Path"); + Assembly assembly = ((!(pInitData.Group == "Plugins")) ? current.Assembly(myAssemblyName, myPath) : current.Assembly(myAssemblyName, myPath, current.PluginDomain)); + Type type = assembly.GetType(myTypeName); + if (null == type) + { + throw new COMHResultException(HResults.E_FAIL); + } + IntPtr ppv; + if (type.IsSubclassOf(typeof(Extension))) + { + Extension extension = ((!type.IsSubclassOf(typeof(PluginBase))) ? ((Extension)Activator.CreateInstance(type, null)) : ((Extension)current.PluginDomain.CreateInstanceFromAndUnwrap(Path.Combine(myPath, myAssemblyName), myTypeName))); + extension.Path = myPath; + object obj = null; + switch (extension.ExtensionType) + { + case DecalExtensionType.Service: + if (extension is ServiceBase serviceBase) + { + current.AddService(serviceBase); + obj = new ServiceProxy(serviceBase); + } + break; + case DecalExtensionType.NetworkFilter: + if (extension is FilterBase filterBase) + { + current.AddFilter(filterBase); + obj = new FilterProxy(filterBase); + } + break; + case DecalExtensionType.Plugin: + if (extension is PluginBase pluginBase) + { + current.AddPlugin(pluginBase); + obj = new PluginProxy(pluginBase); + } + break; + } + IntPtr pUnk = ((obj == null) ? Marshal.GetIUnknownForObject(extension) : Marshal.GetIUnknownForObject(obj)); + int num = Marshal.QueryInterface(pUnk, ref riid, out ppv); + Marshal.Release(pUnk); + if (num < 0) + { + throw new Exception(); + } + return ppv; + } + object o = Activator.CreateInstance(type, null); + if (!type.IsSubclassOf(typeof(INetworkFilter))) + { + type.IsSubclassOf(typeof(INetworkFilter2)); + } + IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(o); + Marshal.QueryInterface(iUnknownForObject, ref riid, out ppv); + Marshal.Release(iUnknownForObject); + return ppv; + } + catch + { + throw new COMHResultException(HResults.E_FAIL); + } + finally + { + Marshal.ReleaseComObject(pInitData); + } + } + Marshal.ReleaseComObject(pInitData); + throw new COMHResultException(HResults.E_FAIL); + } + + void IAdapterSurrogate.SetEnum(DecalEnum pInitData) + { + try + { + myTypeName = (string)((IDecalEnum)pInitData).get_Property("Object"); + myAssemblyName = (string)((IDecalEnum)pInitData).get_Property("Assembly"); + myPath = (string)((IDecalEnum)pInitData).get_Property("Path"); + Marshal.ReleaseComObject(pInitData); + } + catch (COMException) + { + } + } + + void IDecalFileSurrogate.Register(string Filename) + { + bool flag = false; + int num = 0; + int num2 = 0; + try + { + if (File.Exists(Filename)) + { + Assembly assembly = Assembly.LoadFile(Filename); + string text = ""; + if (Attribute.IsDefined(assembly, typeof(GuidAttribute))) + { + text = ((GuidAttribute)Attribute.GetCustomAttribute(assembly, typeof(GuidAttribute))).Value.ToUpper(CultureInfo.InvariantCulture); + } + Type[] types; + try + { + types = assembly.GetTypes(); + } + catch (ReflectionTypeLoadException ex) + { + types = ex.Types; + } + Type[] array = types; + foreach (Type type in array) + { + if (null == type || !type.IsPublic) + { + continue; + } + int num3 = 0; + if (!type.IsSubclassOf(typeof(Extension))) + { + continue; + } + string directoryName = Path.GetDirectoryName(Filename); + string fileName = Path.GetFileName(Filename); + string value = ""; + string value2 = "{71A69713-6593-47EC-0002-0000000DECA1}"; + string text2 = ""; + if (type.IsSubclassOf(typeof(PluginBase))) + { + text2 = "Plugins"; + num++; + num3 = num; + } + else + { + if (!type.IsSubclassOf(typeof(FilterBase))) + { + continue; + } + text2 = "NetworkFilters"; + num2++; + num3 = num2; + } + if (Attribute.IsDefined(type, typeof(FriendlyNameAttribute))) + { + value = ((FriendlyNameAttribute)Attribute.GetCustomAttribute(type, typeof(FriendlyNameAttribute))).Name; + } + string text3 = type.Namespace.ToString() + "." + type.Name.ToString(); + string text4 = ""; + if (Attribute.IsDefined(type, typeof(GuidAttribute))) + { + text4 = ((GuidAttribute)Attribute.GetCustomAttribute(type, typeof(GuidAttribute))).Value.ToString(); + } + else if (!string.IsNullOrEmpty(text) && num3 == 1) + { + text4 = text; + } + else if (!string.IsNullOrEmpty(text)) + { + byte[] array2 = new Guid(text).ToByteArray(); + array2[15] = (byte)(array2[15] ^ num3); + text4 = new Guid(array2).ToString(); + } + else + { + text4 = Guid.NewGuid().ToString(); + } + text4 = text4.ToUpper(CultureInfo.InvariantCulture); + string subkey = string.Format("SOFTWARE\\Decal\\{0}\\{1}", text2, "{" + text4 + "}"); + Util.WriteLine("Registering Decal.Adapter extension (Type:" + type.ToString() + ")"); + Util.WriteLine("Assembly Directory: " + directoryName); + Util.WriteLine("Assembly File: " + fileName); + Util.WriteLine("Assembly Object: " + text3); + Util.WriteLine("Extension Registry CLSID: " + text4); + RegistryKey registryKey = Registry.LocalMachine.CreateSubKey(subkey); + if (registryKey != null) + { + registryKey.SetValue("Enabled", 0, RegistryValueKind.DWord); + registryKey.SetValue("Assembly", fileName, RegistryValueKind.String); + registryKey.SetValue("Path", directoryName, RegistryValueKind.String); + registryKey.SetValue("Object", text3, RegistryValueKind.String); + registryKey.SetValue("Surrogate", value2, RegistryValueKind.String); + if (!string.IsNullOrEmpty(value)) + { + registryKey.SetValue("", value, RegistryValueKind.String); + } + else + { + registryKey.SetValue("", text3, RegistryValueKind.String); + } + flag = true; + } + } + } + } + catch (Exception ex2) + { + Util.WriteLine("Exception registering plugin: " + ex2.ToString()); + throw new COMHResultException(HResults.E_FAIL); + } + if (!flag) + { + throw new COMHResultException(HResults.E_FAIL); + } + } +} diff --git a/Unused/Decal.Adapter/TextBoxChangeEventArgs.cs b/Unused/Decal.Adapter/TextBoxChangeEventArgs.cs new file mode 100644 index 0000000..d1c97b8 --- /dev/null +++ b/Unused/Decal.Adapter/TextBoxChangeEventArgs.cs @@ -0,0 +1,14 @@ +namespace Decal.Adapter; + +public class TextBoxChangeEventArgs : ControlEventArgs +{ + private string text; + + public string Text => text; + + internal TextBoxChangeEventArgs(int ID, string text) + : base(ID) + { + this.text = text; + } +} diff --git a/Unused/Decal.Adapter/TextBoxEndEventArgs.cs b/Unused/Decal.Adapter/TextBoxEndEventArgs.cs new file mode 100644 index 0000000..c4a6e72 --- /dev/null +++ b/Unused/Decal.Adapter/TextBoxEndEventArgs.cs @@ -0,0 +1,14 @@ +namespace Decal.Adapter; + +public class TextBoxEndEventArgs : ControlEventArgs +{ + private bool success; + + public bool Success => success; + + internal TextBoxEndEventArgs(int ID, bool success) + : base(ID) + { + this.success = success; + } +} diff --git a/Unused/Decal.Adapter/ViewAttribute.cs b/Unused/Decal.Adapter/ViewAttribute.cs new file mode 100644 index 0000000..5c186ae --- /dev/null +++ b/Unused/Decal.Adapter/ViewAttribute.cs @@ -0,0 +1,26 @@ +using System; + +namespace Decal.Adapter; + +/// +/// Defines a plugin view +/// +[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] +public sealed class ViewAttribute : ViewBaseAttribute +{ + private string myResource; + + /// + /// The resource to load + /// + public string Resource => myResource; + + /// + /// Constructs a new view from the specified resource + /// + /// Embedded resource path + public ViewAttribute(string resource) + { + myResource = resource; + } +} diff --git a/Unused/Decal.Adapter/ViewBaseAttribute.cs b/Unused/Decal.Adapter/ViewBaseAttribute.cs new file mode 100644 index 0000000..9696fe6 --- /dev/null +++ b/Unused/Decal.Adapter/ViewBaseAttribute.cs @@ -0,0 +1,28 @@ +using System; + +namespace Decal.Adapter; + +public abstract class ViewBaseAttribute : Attribute +{ + private string myName; + + /// + /// Name named attribute + /// + public string ViewName + { + get + { + return myName; + } + set + { + myName = value; + } + } + + protected ViewBaseAttribute() + { + myName = "Default"; + } +} diff --git a/Unused/Decal.Adapter/ViewHandler.cs b/Unused/Decal.Adapter/ViewHandler.cs new file mode 100644 index 0000000..036cb26 --- /dev/null +++ b/Unused/Decal.Adapter/ViewHandler.cs @@ -0,0 +1,76 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using Decal.Adapter.Wrappers; + +namespace Decal.Adapter; + +[CLSCompliant(true)] +public class ViewHandler : IViewHandler, IDisposable +{ + private Dictionary myViews; + + private BindingFlags myBindingFlags; + + private PluginHost myHost; + + private bool isDisposed; + + protected bool IsDisposed => isDisposed; + + protected PluginHost Host => myHost; + + public ViewWrapper DefaultView => myViews["Default"]; + + public BindingFlags BindingFlags => myBindingFlags; + + public ViewHandler(PluginHost host) + { + myBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; + myViews = new Dictionary(); + myHost = host; + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing && myViews != null) + { + foreach (ViewWrapper value in myViews.Values) + { + value.Dispose(); + } + myViews.Clear(); + myViews = null; + } + isDisposed = true; + } + + internal void LoadComplete() + { + OnLoad(); + } + + protected virtual void OnLoad() + { + } + + public void LoadView(string name, string resource) + { + myViews.Add(name, Host.LoadViewResource(resource, GetType().Assembly)); + } + + public ViewWrapper GetView(string name) + { + if (myViews.TryGetValue(name, out var value)) + { + return value; + } + return null; + } +} diff --git a/Unused/Decal.Adapter/WindowMessageEventArgs.cs b/Unused/Decal.Adapter/WindowMessageEventArgs.cs new file mode 100644 index 0000000..7a8112b --- /dev/null +++ b/Unused/Decal.Adapter/WindowMessageEventArgs.cs @@ -0,0 +1,29 @@ +namespace Decal.Adapter; + +public class WindowMessageEventArgs : EatableEventArgs +{ + private int myHwnd; + + private short myMsg; + + private int mywParam; + + private int mylParam; + + public int Hwnd => myHwnd; + + public short Msg => myMsg; + + public int WParam => mywParam; + + public int LParam => mylParam; + + internal WindowMessageEventArgs(int hwnd, short uMsg, int wParam, int lParam) + : base(eat: false) + { + myHwnd = hwnd; + myMsg = uMsg; + mywParam = wParam; + mylParam = lParam; + } +} diff --git a/Unused/Decal.Adapter/WireUpBaseEventsAttribute.cs b/Unused/Decal.Adapter/WireUpBaseEventsAttribute.cs new file mode 100644 index 0000000..98151f4 --- /dev/null +++ b/Unused/Decal.Adapter/WireUpBaseEventsAttribute.cs @@ -0,0 +1,8 @@ +using System; + +namespace Decal.Adapter; + +[AttributeUsage(AttributeTargets.Class)] +public sealed class WireUpBaseEventsAttribute : Attribute +{ +} diff --git a/Unused/Decal.Adapter/WireUpControlEventsAttribute.cs b/Unused/Decal.Adapter/WireUpControlEventsAttribute.cs new file mode 100644 index 0000000..49e954b --- /dev/null +++ b/Unused/Decal.Adapter/WireUpControlEventsAttribute.cs @@ -0,0 +1,8 @@ +using System; + +namespace Decal.Adapter; + +[AttributeUsage(AttributeTargets.Class)] +public sealed class WireUpControlEventsAttribute : Attribute +{ +} diff --git a/Unused/Decal.Interop.Core/ACHooks.cs b/Unused/Decal.Interop.Core/ACHooks.cs new file mode 100644 index 0000000..f85556e --- /dev/null +++ b/Unused/Decal.Interop.Core/ACHooks.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("93FD982E-D1CE-46C3-9428-532ACCDA06CE")] +[CoClass(typeof(ACHooksClass))] +public interface ACHooks : IACHooks, IACHooksEvents_Event +{ +} diff --git a/Unused/Decal.Interop.Core/ACHooksClass.cs b/Unused/Decal.Interop.Core/ACHooksClass.cs new file mode 100644 index 0000000..b2cb9a7 --- /dev/null +++ b/Unused/Decal.Interop.Core/ACHooksClass.cs @@ -0,0 +1,586 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("CB8875CD-ABC2-42AD-8175-8908706EED37")] +[ComSourceInterfaces("Decal.Interop.Core.IACHooksEvents\0\0")] +[TypeLibType(2)] +[SuppressUnmanagedCodeSecurity] +[ClassInterface(0)] +public class ACHooksClass : IACHooks, ACHooks, IACHooksEvents_Event +{ + [DispId(1610743810)] + public virtual extern int HooksAvail + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743810)] + get; + } + + [DispId(1610743811)] + public virtual extern bool HooksAvailEx + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743811)] + get; + } + + [DispId(1610743818)] + public virtual extern int CurrentSelection + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743818)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743818)] + [param: In] + set; + } + + [DispId(1610743820)] + public virtual extern int PreviousSelection + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743820)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743820)] + [param: In] + set; + } + + [DispId(1610743822)] + public virtual extern int SelectedStackCount + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743822)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743822)] + [param: In] + set; + } + + [DispId(1610743824)] + public virtual extern int MaxSelectedStackCount + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743824)] + get; + } + + [DispId(1610743826)] + public virtual extern tagRECT AC3DRegionRect + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743826)] + get; + } + + [DispId(1610743827)] + public virtual extern IntPtr AC3DRegionRectPtr + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743827)] + get; + } + + [DispId(1610743828)] + public virtual extern tagRECT ACWindowRect + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743828)] + get; + } + + [DispId(1610743829)] + public virtual extern bool ChatState + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743829)] + get; + } + + [DispId(1610743830)] + public virtual extern int BusyState + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743830)] + get; + } + + [DispId(1610743831)] + public virtual extern int BusyStateID + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743831)] + get; + } + + [DispId(1610743832)] + public virtual extern int PointerState + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743832)] + get; + } + + [DispId(1610743833)] + public virtual extern int VendorID + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743833)] + get; + } + + [DispId(1610743840)] + public virtual extern int CombatMode + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743840)] + get; + } + + [DispId(1610743844)] + public virtual extern int CommandInterpreter + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743844)] + get; + } + + [DispId(1610743858)] + public virtual extern double HeadingDegrees + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743858)] + get; + } + + [DispId(1610743859)] + public virtual extern double HeadingRadians + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743859)] + get; + } + + [DispId(1610743860)] + public virtual extern int Landcell + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743860)] + get; + } + + [DispId(1610743861)] + public virtual extern double LocationX + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743861)] + get; + } + + [DispId(1610743862)] + public virtual extern double LocationY + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743862)] + get; + } + + [DispId(1610743863)] + public virtual extern double LocationZ + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743863)] + get; + } + + [DispId(1610743864)] + public virtual extern eTrainLevel SkillTrainLevel + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743864)] + get; + } + + [DispId(1610743865)] + public virtual extern int SkillTotalXP + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743865)] + get; + } + + [DispId(1610743866)] + public virtual extern int SkillFreePoints + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743866)] + get; + } + + [DispId(1610743867)] + public virtual extern int SkillClicks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743867)] + get; + } + + [DispId(1610743868)] + public virtual extern int AttributeTotalXP + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743868)] + get; + } + + [DispId(1610743869)] + public virtual extern int AttributeClicks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743869)] + get; + } + + [DispId(1610743870)] + public virtual extern int AttributeStart + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743870)] + get; + } + + [DispId(1610743871)] + public virtual extern int VitalTotalXP + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743871)] + get; + } + + [DispId(1610743872)] + public virtual extern int VitalClicks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743872)] + get; + } + + [DispId(1610743873)] + public virtual extern int Vital + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743873)] + get; + } + + [DispId(1610743874)] + public virtual extern int Attribute + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743874)] + get; + } + + [DispId(1610743875)] + public virtual extern int Skill + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743875)] + get; + } + + [DispId(1610743876)] + public virtual extern int Misc + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743876)] + get; + } + + [DispId(1610743888)] + public virtual extern int OpenedContainer + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743888)] + get; + } + + [DispId(1610743894)] + public virtual extern int CallerRefInstanceInternal + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743894)] + [param: In] + set; + } + + public virtual extern event IACHooksEvents_ObjectDestroyedEventHandler ObjectDestroyed; + + public virtual extern event IACHooksEvents_ChatTextInterceptEventHandler ChatTextIntercept; + + public virtual extern event IACHooksEvents_ChatParserInterceptEventHandler ChatParserIntercept; + + public virtual extern event IACHooksEvents_StatusTextInterceptEventHandler StatusTextIntercept; + + public virtual extern event IACHooksEvents_ObjectSelectedEventHandler ObjectSelected; + + public virtual extern event IACHooksEvents_MessageProcessedEventHandler MessageProcessed; + + public virtual extern event IACHooksEvents_AC3DRegionChangedEventHandler AC3DRegionChanged; + + public virtual extern event IACHooksEvents_ContainerOpenedEventHandler ContainerOpened; + + public virtual extern event IACHooksEvents_ChatClickInterceptEventHandler ChatClickIntercept; + + public virtual extern event IACHooksEvents_RenderPreUIEventHandler RenderPreUI; + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743808)] + [TypeLibFunc(64)] + public virtual extern void SetIDFilter([In][MarshalAs(UnmanagedType.Interface)] IIdentifyFilter pIDFilter); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743809)] + [TypeLibFunc(64)] + public virtual extern void SetDecal([In][MarshalAs(UnmanagedType.IUnknown)] object pDecal); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743812)] + public virtual extern void AddChatText([In][MarshalAs(UnmanagedType.BStr)] string szText, int lColor, int lTarget); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743813)] + public virtual extern void AddChatTextRaw([In][MarshalAs(UnmanagedType.BStr)] string szText, int lColor, int lTarget); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743814)] + public virtual extern void AddStatusText([In][MarshalAs(UnmanagedType.BStr)] string Text); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743815)] + public virtual extern void InvokeChatParser([In][MarshalAs(UnmanagedType.BStr)] string Text); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743816)] + public virtual extern void SetIdleTime([In] double dIdleTimeout); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743817)] + public virtual extern void Logout(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743825)] + public virtual extern void SetCursorPosition([In] int lX, int lY); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743834)] + public virtual extern void VendorBuyListAdd([In] int lID, int lAmount); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743835)] + public virtual extern void VendorBuyListClear(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743836)] + public virtual extern void VendorBuyAll(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743837)] + public virtual extern void VendorSellListAdd([In] int lID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743838)] + public virtual extern void VendorSellListClear(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743839)] + public virtual extern void VendorSellAll(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743841)] + public virtual extern void SetCombatMode([In] int pVal); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743842)] + public virtual extern void SetAutorun([In] bool bOnOff); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743843)] + public virtual extern bool FaceHeading([In] float fHeading, [In] bool bUnknown); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743845)] + public virtual extern void SelectItem([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743846)] + public virtual extern void GiveItem([In] int lObject, int lDestination); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743847)] + public virtual extern void ApplyItem([In] int UseThis, int OnThis); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743848)] + public virtual extern void UseItem([In] int lObjectID, int lUseState); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743849)] + public virtual extern void UseItemRaw([In] int lObjectID, int lUseState, int lUseMethod); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743850)] + public virtual extern void MoveItem([In] int lObjectID, int lPackID, int lSlot, bool bStack); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743851)] + public virtual extern void MoveItemEx([In] int lObjectID, int lDestinationID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743852)] + public virtual extern void MoveItemExRaw([In] int lObject, int lDestination, int lMoveFlags); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743853)] + public virtual extern void DropItem([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743854)] + public virtual extern void CastSpell([In] int lSpellID, int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743855)] + public virtual extern bool IsValidObject([In] int lGUID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743856)] + public virtual extern int GetWeenieObjectPtr([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743857)] + public virtual extern int GetPhysicsObjectPtr([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743877)] + public virtual extern void RequestID([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743878)] + public virtual extern void IDQueueAdd([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743879)] + public virtual extern void SpellTabAdd([In] int lTab, int lIndex, int lSpellID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743880)] + public virtual extern void SpellTabDelete([In] int lTab, int lSpellID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743881)] + public virtual extern void TradeAdd([In] int ItemID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743882)] + public virtual extern void TradeAccept(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743883)] + public virtual extern void TradeDecline(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743884)] + public virtual extern void TradeReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743885)] + public virtual extern void TradeEnd(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743886)] + public virtual extern void SalvagePanelAdd([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743887)] + public virtual extern void SalvagePanelSalvage(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743889)] + public virtual extern void AddSkillExp([In] eSkill SkillID, int lExperience); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743890)] + public virtual extern void AddAttributeExp([In] eAttribute AttribID, int lExperience); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743891)] + public virtual extern void AddVitalExp([In] eVital VitalID, int lExperience); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743892)] + public virtual extern int SmartboxPtr(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743893)] + public virtual extern float ObjectHeight([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743895)] + public virtual extern void AutoWieldRaw([In] int lObjectID, int SlotID, int Explicit, int NotExplicit, int zeroVal1, int zeroVal2); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743896)] + public virtual extern void AutoWield([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743897)] + public virtual extern void AutoWieldEx([In] int lObjectID, int SlotID, int Explicit, int NotExplicit); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743898)] + public virtual extern void FellowshipRecruit([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743899)] + public virtual extern void FellowshipGrantLeader([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743900)] + public virtual extern void FellowshipSetOpen([In] bool IsOpen); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743901)] + public virtual extern void FellowshipQuit(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743902)] + public virtual extern void FellowshipDisband(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743903)] + public virtual extern void FellowshipDismiss([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743904)] + public virtual extern void UIElementMove([In] int lUIElementType, int X, int Y); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743905)] + public virtual extern void UIElementResize([In] int lUIElementType, int Width, int Height); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743906)] + public virtual extern int UIElementLookup([In] int lUIElementType); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743907)] + public virtual extern tagRECT UIElementRegionRect([In] int lUIElementType); +} diff --git a/Unused/Decal.Interop.Core/ActiveXSurrogate.cs b/Unused/Decal.Interop.Core/ActiveXSurrogate.cs new file mode 100644 index 0000000..01da5bf --- /dev/null +++ b/Unused/Decal.Interop.Core/ActiveXSurrogate.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("E182005F-6A67-48B5-A50F-464340105330")] +[CoClass(typeof(ActiveXSurrogateClass))] +public interface ActiveXSurrogate : IDecalFileSurrogate +{ +} diff --git a/Unused/Decal.Interop.Core/ActiveXSurrogateClass.cs b/Unused/Decal.Interop.Core/ActiveXSurrogateClass.cs new file mode 100644 index 0000000..d35772d --- /dev/null +++ b/Unused/Decal.Interop.Core/ActiveXSurrogateClass.cs @@ -0,0 +1,38 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[TypeLibType(2)] +[SuppressUnmanagedCodeSecurity] +[ClassInterface(0)] +[Guid("7559F22F-C56F-4621-AE08-9C354D799D4B")] +public class ActiveXSurrogateClass : IDecalFileSurrogate, ActiveXSurrogate, IDecalUninstall +{ + [DispId(1610678273)] + public virtual extern string Extension + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678274)] + public virtual extern string Description + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Register([MarshalAs(UnmanagedType.BStr)] string Filename); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Prepare([MarshalAs(UnmanagedType.Interface)] DecalEnum pEnum); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Uninstall(); +} diff --git a/Unused/Decal.Interop.Core/DecalCore.cs b/Unused/Decal.Interop.Core/DecalCore.cs new file mode 100644 index 0000000..76afbb0 --- /dev/null +++ b/Unused/Decal.Interop.Core/DecalCore.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[CoClass(typeof(DecalCoreClass))] +[Guid("A38715BB-91E7-4C66-95F9-363096F29760")] +public interface DecalCore : IDecalCore, IDecalEvents_Event +{ +} diff --git a/Unused/Decal.Interop.Core/DecalCoreClass.cs b/Unused/Decal.Interop.Core/DecalCoreClass.cs new file mode 100644 index 0000000..6c3efba --- /dev/null +++ b/Unused/Decal.Interop.Core/DecalCoreClass.cs @@ -0,0 +1,135 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("4557D5A1-00DB-48F6-ACB3-4FEF30E2F358")] +[ComSourceInterfaces("Decal.Interop.Core.IDecalEvents\0\0")] +[TypeLibType(2)] +[SuppressUnmanagedCodeSecurity] +[ClassInterface(0)] +public class DecalCoreClass : IDecalCore, DecalCore, IDecalEvents_Event +{ + [DispId(1610678274)] + public virtual extern int HWND + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + set; + } + + [DispId(1610678276)] + public virtual extern bool Focus + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678282)] + public virtual extern object Object + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [DispId(1610678284)] + public virtual extern DecalEnum Configuration + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [DispId(1610678286)] + public virtual extern object Plugin + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [DispId(1610678287)] + public virtual extern object Service + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [DispId(1610678292)] + public virtual extern ACHooks Hooks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [DispId(1610678297)] + public virtual extern bool PluginsRunning + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + public virtual extern event IDecalEvents_InitializeCompleteEventHandler InitializeComplete; + + public virtual extern event IDecalEvents_TerminateCompleteEventHandler TerminateComplete; + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void InitGraphics([MarshalAs(UnmanagedType.IUnknown)] object pD3DDevice); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + public virtual extern object GetD3DDevice(ref Guid riid); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void SendWM(int HWND, short uMsg, int wParam, int lParam, ref bool pbEat); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void GetScreenSize(out int pWidth, out int pHeight); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + public virtual extern string MapPath([MarshalAs(UnmanagedType.BStr)] string pPath); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void StartPlugins(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void StopPlugins(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void StartServices(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void StopServices(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Render2D(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Render3D(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void PreReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void PostReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void StartFilters(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void StopFilters(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern bool KillBitCheckByGUID([In][MarshalAs(UnmanagedType.BStr)] string bstrGuid, [MarshalAs(UnmanagedType.BStr)] string bstrVersion); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern bool KillBitCheckByProgID([In][MarshalAs(UnmanagedType.BStr)] string bstProgID, [MarshalAs(UnmanagedType.BStr)] string bstrVersion); +} diff --git a/Unused/Decal.Interop.Core/DecalEnum.cs b/Unused/Decal.Interop.Core/DecalEnum.cs new file mode 100644 index 0000000..35d85c1 --- /dev/null +++ b/Unused/Decal.Interop.Core/DecalEnum.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[CoClass(typeof(DecalEnumClass))] +[Guid("FFA32A7A-EFAF-484A-B358-8802DBBAB0EC")] +public interface DecalEnum : IDecalEnum +{ +} diff --git a/Unused/Decal.Interop.Core/DecalEnumClass.cs b/Unused/Decal.Interop.Core/DecalEnumClass.cs new file mode 100644 index 0000000..389a125 --- /dev/null +++ b/Unused/Decal.Interop.Core/DecalEnumClass.cs @@ -0,0 +1,112 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[ClassInterface(0)] +[Guid("6DE65A82-C451-46E6-A82D-92137BE851AD")] +[SuppressUnmanagedCodeSecurity] +public class DecalEnumClass : IDecalEnum, DecalEnum +{ + [DispId(1610678272)] + public virtual extern string FriendlyName + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678273)] + public virtual extern Guid ComClass + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678274)] + public virtual extern bool Enabled + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [param: In] + set; + } + + [DispId(1610678276)] + public virtual extern bool Restricted + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678279)] + public virtual extern Guid SurrogateClass + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678280)] + public virtual extern string ResourcePath + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678281)] + public virtual extern object Property + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Struct)] + get; + } + + [DispId(1610678282)] + public virtual extern string Group + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678285)] + public virtual extern string Version + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678286)] + public virtual extern bool FileExists + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678287)] + public virtual extern string FilePath + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + public virtual extern object CreateInstance(ref Guid riid); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Next(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Skip([In] ref Guid clsid); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void MoveBefore(ref Guid clsidBefore); +} diff --git a/Unused/Decal.Interop.Core/DecalRes.cs b/Unused/Decal.Interop.Core/DecalRes.cs new file mode 100644 index 0000000..f48f819 --- /dev/null +++ b/Unused/Decal.Interop.Core/DecalRes.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("A074F83A-32AB-46FC-9E4E-7E9DAFCD5D18")] +[CoClass(typeof(DecalResClass))] +public interface DecalRes : IDecalRes +{ +} diff --git a/Unused/Decal.Interop.Core/DecalResClass.cs b/Unused/Decal.Interop.Core/DecalResClass.cs new file mode 100644 index 0000000..ba5ee7a --- /dev/null +++ b/Unused/Decal.Interop.Core/DecalResClass.cs @@ -0,0 +1,12 @@ +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[ClassInterface(0)] +[Guid("EA7BE91B-C98A-4138-8985-E22364BE8207")] +[SuppressUnmanagedCodeSecurity] +public class DecalResClass : IDecalRes, DecalRes +{ +} diff --git a/Unused/Decal.Interop.Core/IACHooks.cs b/Unused/Decal.Interop.Core/IACHooks.cs new file mode 100644 index 0000000..521c760 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooks.cs @@ -0,0 +1,565 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("93FD982E-D1CE-46C3-9428-532ACCDA06CE")] +[TypeLibType(4160)] +[SuppressUnmanagedCodeSecurity] +[ComConversionLoss] +public interface IACHooks +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [TypeLibFunc(64)] + [DispId(1610743808)] + void SetIDFilter([In][MarshalAs(UnmanagedType.Interface)] IIdentifyFilter pIDFilter); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743809)] + [TypeLibFunc(64)] + void SetDecal([In][MarshalAs(UnmanagedType.IUnknown)] object pDecal); + + [DispId(1610743810)] + int HooksAvail + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743810)] + get; + } + + [DispId(1610743811)] + bool HooksAvailEx + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743811)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743812)] + void AddChatText([In][MarshalAs(UnmanagedType.BStr)] string szText, int lColor, int lTarget); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743813)] + void AddChatTextRaw([In][MarshalAs(UnmanagedType.BStr)] string szText, int lColor, int lTarget); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743814)] + void AddStatusText([In][MarshalAs(UnmanagedType.BStr)] string Text); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743815)] + void InvokeChatParser([In][MarshalAs(UnmanagedType.BStr)] string Text); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743816)] + void SetIdleTime([In] double dIdleTimeout); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743817)] + void Logout(); + + [DispId(1610743818)] + int CurrentSelection + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743818)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743818)] + [param: In] + set; + } + + [DispId(1610743820)] + int PreviousSelection + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743820)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743820)] + [param: In] + set; + } + + [DispId(1610743822)] + int SelectedStackCount + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743822)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743822)] + [param: In] + set; + } + + [DispId(1610743824)] + int MaxSelectedStackCount + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743824)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743825)] + void SetCursorPosition([In] int lX, int lY); + + [DispId(1610743826)] + tagRECT AC3DRegionRect + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743826)] + get; + } + + [DispId(1610743827)] + IntPtr AC3DRegionRectPtr + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743827)] + get; + } + + [DispId(1610743828)] + tagRECT ACWindowRect + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743828)] + get; + } + + [DispId(1610743829)] + bool ChatState + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743829)] + get; + } + + [DispId(1610743830)] + int BusyState + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743830)] + get; + } + + [DispId(1610743831)] + int BusyStateID + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743831)] + get; + } + + [DispId(1610743832)] + int PointerState + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743832)] + get; + } + + [DispId(1610743833)] + int VendorID + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743833)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743834)] + void VendorBuyListAdd([In] int lID, int lAmount); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743835)] + void VendorBuyListClear(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743836)] + void VendorBuyAll(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743837)] + void VendorSellListAdd([In] int lID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743838)] + void VendorSellListClear(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743839)] + void VendorSellAll(); + + [DispId(1610743840)] + int CombatMode + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743840)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743841)] + void SetCombatMode([In] int pVal); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743842)] + void SetAutorun([In] bool bOnOff); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743843)] + bool FaceHeading([In] float fHeading, [In] bool bUnknown); + + [DispId(1610743844)] + int CommandInterpreter + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743844)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743845)] + void SelectItem([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743846)] + void GiveItem([In] int lObject, int lDestination); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743847)] + void ApplyItem([In] int UseThis, int OnThis); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743848)] + void UseItem([In] int lObjectID, int lUseState); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743849)] + void UseItemRaw([In] int lObjectID, int lUseState, int lUseMethod); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743850)] + void MoveItem([In] int lObjectID, int lPackID, int lSlot, bool bStack); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743851)] + void MoveItemEx([In] int lObjectID, int lDestinationID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743852)] + void MoveItemExRaw([In] int lObject, int lDestination, int lMoveFlags); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743853)] + void DropItem([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743854)] + void CastSpell([In] int lSpellID, int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743855)] + bool IsValidObject([In] int lGUID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743856)] + int GetWeenieObjectPtr([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743857)] + int GetPhysicsObjectPtr([In] int lObjectID); + + [DispId(1610743858)] + double HeadingDegrees + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743858)] + get; + } + + [DispId(1610743859)] + double HeadingRadians + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743859)] + get; + } + + [DispId(1610743860)] + int Landcell + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743860)] + get; + } + + [DispId(1610743861)] + double LocationX + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743861)] + get; + } + + [DispId(1610743862)] + double LocationY + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743862)] + get; + } + + [DispId(1610743863)] + double LocationZ + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743863)] + get; + } + + [DispId(1610743864)] + eTrainLevel SkillTrainLevel + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743864)] + get; + } + + [DispId(1610743865)] + int SkillTotalXP + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743865)] + get; + } + + [DispId(1610743866)] + int SkillFreePoints + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743866)] + get; + } + + [DispId(1610743867)] + int SkillClicks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743867)] + get; + } + + [DispId(1610743868)] + int AttributeTotalXP + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743868)] + get; + } + + [DispId(1610743869)] + int AttributeClicks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743869)] + get; + } + + [DispId(1610743870)] + int AttributeStart + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743870)] + get; + } + + [DispId(1610743871)] + int VitalTotalXP + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743871)] + get; + } + + [DispId(1610743872)] + int VitalClicks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743872)] + get; + } + + [DispId(1610743873)] + int Vital + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743873)] + get; + } + + [DispId(1610743874)] + int Attribute + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743874)] + get; + } + + [DispId(1610743875)] + int Skill + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743875)] + get; + } + + [DispId(1610743876)] + int Misc + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743876)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743877)] + void RequestID([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743878)] + void IDQueueAdd([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743879)] + void SpellTabAdd([In] int lTab, int lIndex, int lSpellID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743880)] + void SpellTabDelete([In] int lTab, int lSpellID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743881)] + void TradeAdd([In] int ItemID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743882)] + void TradeAccept(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743883)] + void TradeDecline(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743884)] + void TradeReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743885)] + void TradeEnd(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743886)] + void SalvagePanelAdd([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743887)] + void SalvagePanelSalvage(); + + [DispId(1610743888)] + int OpenedContainer + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743888)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743889)] + void AddSkillExp([In] eSkill SkillID, int lExperience); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743890)] + void AddAttributeExp([In] eAttribute AttribID, int lExperience); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743891)] + void AddVitalExp([In] eVital VitalID, int lExperience); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743892)] + int SmartboxPtr(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743893)] + float ObjectHeight([In] int lObjectID); + + [DispId(1610743894)] + int CallerRefInstanceInternal + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743894)] + [param: In] + set; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743895)] + void AutoWieldRaw([In] int lObjectID, int SlotID, int Explicit, int NotExplicit, int zeroVal1, int zeroVal2); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743896)] + void AutoWield([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743897)] + void AutoWieldEx([In] int lObjectID, int SlotID, int Explicit, int NotExplicit); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743898)] + void FellowshipRecruit([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743899)] + void FellowshipGrantLeader([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743900)] + void FellowshipSetOpen([In] bool IsOpen); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743901)] + void FellowshipQuit(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743902)] + void FellowshipDisband(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743903)] + void FellowshipDismiss([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743904)] + void UIElementMove([In] int lUIElementType, int X, int Y); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743905)] + void UIElementResize([In] int lUIElementType, int Width, int Height); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743906)] + int UIElementLookup([In] int lUIElementType); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1610743907)] + tagRECT UIElementRegionRect([In] int lUIElementType); +} diff --git a/Unused/Decal.Interop.Core/IACHooksEvents.cs b/Unused/Decal.Interop.Core/IACHooksEvents.cs new file mode 100644 index 0000000..1b5fea4 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents.cs @@ -0,0 +1,53 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[InterfaceType(2)] +[SuppressUnmanagedCodeSecurity] +[Guid("EB282FE5-7170-4A37-A26E-92AF36385D2C")] +[TypeLibType(4096)] +public interface IACHooksEvents +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1)] + void ObjectDestroyed([In] int lGUID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(2)] + void ChatTextIntercept([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In] int lColor, [In] int lTarget, [In][Out] ref bool bEat); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(3)] + void ChatParserIntercept([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In][Out] ref bool bEat); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(4)] + void StatusTextIntercept([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In][Out] ref bool bEat); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(5)] + void ObjectSelected([In] int lGUID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(6)] + void MessageProcessed([In] int pbData, [In] int dwSize); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(7)] + void AC3DRegionChanged([In] int left, [In] int top, int right, [In] int bottom); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(8)] + void ContainerOpened([In] int lGUID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(9)] + void ChatClickIntercept([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In] int lID, [In][Out] ref bool bEat); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(10)] + void RenderPreUI(); +} diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_AC3DRegionChangedEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_AC3DRegionChangedEventHandler.cs new file mode 100644 index 0000000..ab8a5da --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_AC3DRegionChangedEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +public delegate void IACHooksEvents_AC3DRegionChangedEventHandler([In] int left, [In] int top, int right, [In] int bottom); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_ChatClickInterceptEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_ChatClickInterceptEventHandler.cs new file mode 100644 index 0000000..cf40e7a --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_ChatClickInterceptEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +public delegate void IACHooksEvents_ChatClickInterceptEventHandler([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In] int lID, [In][Out] ref bool bEat); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_ChatParserInterceptEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_ChatParserInterceptEventHandler.cs new file mode 100644 index 0000000..02aea65 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_ChatParserInterceptEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +public delegate void IACHooksEvents_ChatParserInterceptEventHandler([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In][Out] ref bool bEat); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_ChatTextInterceptEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_ChatTextInterceptEventHandler.cs new file mode 100644 index 0000000..b2bb0dd --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_ChatTextInterceptEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +public delegate void IACHooksEvents_ChatTextInterceptEventHandler([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In] int lColor, [In] int lTarget, [In][Out] ref bool bEat); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_ContainerOpenedEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_ContainerOpenedEventHandler.cs new file mode 100644 index 0000000..f8ade23 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_ContainerOpenedEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +public delegate void IACHooksEvents_ContainerOpenedEventHandler([In] int lGUID); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_Event.cs b/Unused/Decal.Interop.Core/IACHooksEvents_Event.cs new file mode 100644 index 0000000..ba37c71 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_Event.cs @@ -0,0 +1,29 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +[ComEventInterface(typeof(IACHooksEvents_0000), typeof(IACHooksEvents_EventProvider_0000))] +public interface IACHooksEvents_Event +{ + event IACHooksEvents_ObjectDestroyedEventHandler ObjectDestroyed; + + event IACHooksEvents_ChatTextInterceptEventHandler ChatTextIntercept; + + event IACHooksEvents_ChatParserInterceptEventHandler ChatParserIntercept; + + event IACHooksEvents_StatusTextInterceptEventHandler StatusTextIntercept; + + event IACHooksEvents_ObjectSelectedEventHandler ObjectSelected; + + event IACHooksEvents_MessageProcessedEventHandler MessageProcessed; + + event IACHooksEvents_AC3DRegionChangedEventHandler AC3DRegionChanged; + + event IACHooksEvents_ContainerOpenedEventHandler ContainerOpened; + + event IACHooksEvents_ChatClickInterceptEventHandler ChatClickIntercept; + + event IACHooksEvents_RenderPreUIEventHandler RenderPreUI; +} diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_EventProvider.cs b/Unused/Decal.Interop.Core/IACHooksEvents_EventProvider.cs new file mode 100644 index 0000000..09cd650 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_EventProvider.cs @@ -0,0 +1,778 @@ +using System; +using System.Collections; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using System.Threading; + +namespace Decal.Interop.Core; + +internal sealed class IACHooksEvents_EventProvider : IACHooksEvents_Event, IDisposable +{ + private IConnectionPointContainer m_ConnectionPointContainer; + + private ArrayList m_aEventSinkHelpers; + + private IConnectionPoint m_ConnectionPoint; + + private void Init() + { + IConnectionPoint ppCP = null; + Guid riid = new Guid(new byte[16] + { + 229, 47, 40, 235, 112, 113, 55, 74, 162, 110, + 146, 175, 54, 56, 93, 44 + }); + m_ConnectionPointContainer.FindConnectionPoint(ref riid, out ppCP); + m_ConnectionPoint = ppCP; + m_aEventSinkHelpers = new ArrayList(); + } + + public void add_ObjectDestroyed(IACHooksEvents_ObjectDestroyedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_ObjectDestroyedDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_ObjectDestroyed(IACHooksEvents_ObjectDestroyedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_ObjectDestroyedDelegate != null && ((iACHooksEvents_SinkHelper.m_ObjectDestroyedDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_ChatTextIntercept(IACHooksEvents_ChatTextInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_ChatTextInterceptDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_ChatTextIntercept(IACHooksEvents_ChatTextInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_ChatTextInterceptDelegate != null && ((iACHooksEvents_SinkHelper.m_ChatTextInterceptDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_ChatParserIntercept(IACHooksEvents_ChatParserInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_ChatParserInterceptDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_ChatParserIntercept(IACHooksEvents_ChatParserInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_ChatParserInterceptDelegate != null && ((iACHooksEvents_SinkHelper.m_ChatParserInterceptDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_StatusTextIntercept(IACHooksEvents_StatusTextInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_StatusTextInterceptDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_StatusTextIntercept(IACHooksEvents_StatusTextInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_StatusTextInterceptDelegate != null && ((iACHooksEvents_SinkHelper.m_StatusTextInterceptDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_ObjectSelected(IACHooksEvents_ObjectSelectedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_ObjectSelectedDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_ObjectSelected(IACHooksEvents_ObjectSelectedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_ObjectSelectedDelegate != null && ((iACHooksEvents_SinkHelper.m_ObjectSelectedDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_MessageProcessed(IACHooksEvents_MessageProcessedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_MessageProcessedDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_MessageProcessed(IACHooksEvents_MessageProcessedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_MessageProcessedDelegate != null && ((iACHooksEvents_SinkHelper.m_MessageProcessedDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_AC3DRegionChanged(IACHooksEvents_AC3DRegionChangedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_AC3DRegionChangedDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_AC3DRegionChanged(IACHooksEvents_AC3DRegionChangedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_AC3DRegionChangedDelegate != null && ((iACHooksEvents_SinkHelper.m_AC3DRegionChangedDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_ContainerOpened(IACHooksEvents_ContainerOpenedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_ContainerOpenedDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_ContainerOpened(IACHooksEvents_ContainerOpenedEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_ContainerOpenedDelegate != null && ((iACHooksEvents_SinkHelper.m_ContainerOpenedDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_ChatClickIntercept(IACHooksEvents_ChatClickInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_ChatClickInterceptDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_ChatClickIntercept(IACHooksEvents_ChatClickInterceptEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_ChatClickInterceptDelegate != null && ((iACHooksEvents_SinkHelper.m_ChatClickInterceptDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_RenderPreUI(IACHooksEvents_RenderPreUIEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = new IACHooksEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(iACHooksEvents_SinkHelper, out pdwCookie); + iACHooksEvents_SinkHelper.m_dwCookie = pdwCookie; + iACHooksEvents_SinkHelper.m_RenderPreUIDelegate = P_0; + m_aEventSinkHelpers.Add(iACHooksEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_RenderPreUI(IACHooksEvents_RenderPreUIEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (iACHooksEvents_SinkHelper.m_RenderPreUIDelegate != null && ((iACHooksEvents_SinkHelper.m_RenderPreUIDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public IACHooksEvents_EventProvider(object P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + m_ConnectionPointContainer = (IConnectionPointContainer)P_0; + } + + public void Finalize() + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 < count) + { + do + { + IACHooksEvents_SinkHelper iACHooksEvents_SinkHelper = (IACHooksEvents_SinkHelper)m_aEventSinkHelpers[num]; + m_ConnectionPoint.Unadvise(iACHooksEvents_SinkHelper.m_dwCookie); + num++; + } + while (num < count); + } + Marshal.ReleaseComObject(m_ConnectionPoint); + } + catch (Exception) + { + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void Dispose() + { + //Error decoding local variables: Signature type sequence must have at least one element. + Finalize(); + GC.SuppressFinalize(this); + } +} diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_MessageProcessedEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_MessageProcessedEventHandler.cs new file mode 100644 index 0000000..f86de75 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_MessageProcessedEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +public delegate void IACHooksEvents_MessageProcessedEventHandler([In] int pbData, [In] int dwSize); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_ObjectDestroyedEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_ObjectDestroyedEventHandler.cs new file mode 100644 index 0000000..6074c65 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_ObjectDestroyedEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +public delegate void IACHooksEvents_ObjectDestroyedEventHandler([In] int lGUID); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_ObjectSelectedEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_ObjectSelectedEventHandler.cs new file mode 100644 index 0000000..b92dcc9 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_ObjectSelectedEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +public delegate void IACHooksEvents_ObjectSelectedEventHandler([In] int lGUID); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_RenderPreUIEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_RenderPreUIEventHandler.cs new file mode 100644 index 0000000..2358371 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_RenderPreUIEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +public delegate void IACHooksEvents_RenderPreUIEventHandler(); diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_SinkHelper.cs b/Unused/Decal.Interop.Core/IACHooksEvents_SinkHelper.cs new file mode 100644 index 0000000..0c978e8 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_SinkHelper.cs @@ -0,0 +1,136 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(TypeLibTypeFlags.FHidden)] +[ClassInterface(ClassInterfaceType.None)] +public sealed class IACHooksEvents_SinkHelper : IACHooksEvents +{ + public IACHooksEvents_ObjectDestroyedEventHandler m_ObjectDestroyedDelegate; + + public IACHooksEvents_ChatTextInterceptEventHandler m_ChatTextInterceptDelegate; + + public IACHooksEvents_ChatParserInterceptEventHandler m_ChatParserInterceptDelegate; + + public IACHooksEvents_StatusTextInterceptEventHandler m_StatusTextInterceptDelegate; + + public IACHooksEvents_ObjectSelectedEventHandler m_ObjectSelectedDelegate; + + public IACHooksEvents_MessageProcessedEventHandler m_MessageProcessedDelegate; + + public IACHooksEvents_AC3DRegionChangedEventHandler m_AC3DRegionChangedDelegate; + + public IACHooksEvents_ContainerOpenedEventHandler m_ContainerOpenedDelegate; + + public IACHooksEvents_ChatClickInterceptEventHandler m_ChatClickInterceptDelegate; + + public IACHooksEvents_RenderPreUIEventHandler m_RenderPreUIDelegate; + + public int m_dwCookie; + + public void ObjectDestroyed(int P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_ObjectDestroyedDelegate != null) + { + m_ObjectDestroyedDelegate(P_0); + } + } + + public void ChatTextIntercept(string P_0, int P_1, int P_2, ref bool P_3) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_ChatTextInterceptDelegate != null) + { + m_ChatTextInterceptDelegate(P_0, P_1, P_2, ref P_3); + } + } + + public void ChatParserIntercept(string P_0, ref bool P_1) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_ChatParserInterceptDelegate != null) + { + m_ChatParserInterceptDelegate(P_0, ref P_1); + } + } + + public void StatusTextIntercept(string P_0, ref bool P_1) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_StatusTextInterceptDelegate != null) + { + m_StatusTextInterceptDelegate(P_0, ref P_1); + } + } + + public void ObjectSelected(int P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_ObjectSelectedDelegate != null) + { + m_ObjectSelectedDelegate(P_0); + } + } + + public void MessageProcessed(int P_0, int P_1) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_MessageProcessedDelegate != null) + { + m_MessageProcessedDelegate(P_0, P_1); + } + } + + public void AC3DRegionChanged(int P_0, int P_1, int P_2, int P_3) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_AC3DRegionChangedDelegate != null) + { + m_AC3DRegionChangedDelegate(P_0, P_1, P_2, P_3); + } + } + + public void ContainerOpened(int P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_ContainerOpenedDelegate != null) + { + m_ContainerOpenedDelegate(P_0); + } + } + + public void ChatClickIntercept(string P_0, int P_1, ref bool P_2) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_ChatClickInterceptDelegate != null) + { + m_ChatClickInterceptDelegate(P_0, P_1, ref P_2); + } + } + + public void RenderPreUI() + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_RenderPreUIDelegate != null) + { + m_RenderPreUIDelegate(); + } + } + + internal IACHooksEvents_SinkHelper() + { + //Error decoding local variables: Signature type sequence must have at least one element. + m_dwCookie = 0; + m_ObjectDestroyedDelegate = null; + m_ChatTextInterceptDelegate = null; + m_ChatParserInterceptDelegate = null; + m_StatusTextInterceptDelegate = null; + m_ObjectSelectedDelegate = null; + m_MessageProcessedDelegate = null; + m_AC3DRegionChangedDelegate = null; + m_ContainerOpenedDelegate = null; + m_ChatClickInterceptDelegate = null; + m_RenderPreUIDelegate = null; + } +} diff --git a/Unused/Decal.Interop.Core/IACHooksEvents_StatusTextInterceptEventHandler.cs b/Unused/Decal.Interop.Core/IACHooksEvents_StatusTextInterceptEventHandler.cs new file mode 100644 index 0000000..b7892a7 --- /dev/null +++ b/Unused/Decal.Interop.Core/IACHooksEvents_StatusTextInterceptEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +public delegate void IACHooksEvents_StatusTextInterceptEventHandler([In][MarshalAs(UnmanagedType.BStr)] string bstrText, [In][Out] ref bool bEat); diff --git a/Unused/Decal.Interop.Core/IDecalCore.cs b/Unused/Decal.Interop.Core/IDecalCore.cs new file mode 100644 index 0000000..9119350 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalCore.cs @@ -0,0 +1,130 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[TypeLibType(256)] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +[Guid("A38715BB-91E7-4C66-95F9-363096F29760")] +public interface IDecalCore +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void InitGraphics([MarshalAs(UnmanagedType.IUnknown)] object pD3DDevice); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + object GetD3DDevice(ref Guid riid); + + [DispId(1610678274)] + int HWND + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + set; + } + + [DispId(1610678276)] + bool Focus + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void SendWM(int HWND, short uMsg, int wParam, int lParam, ref bool pbEat); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void GetScreenSize(out int pWidth, out int pHeight); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + string MapPath([MarshalAs(UnmanagedType.BStr)] string pPath); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void StartPlugins(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void StopPlugins(); + + [DispId(1610678282)] + object Object + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void StartServices(); + + [DispId(1610678284)] + DecalEnum Configuration + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void StopServices(); + + [DispId(1610678286)] + object Plugin + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [DispId(1610678287)] + object Service + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Render2D(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Render3D(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void PreReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void PostReset(); + + [DispId(1610678292)] + ACHooks Hooks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void StartFilters(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void StopFilters(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + bool KillBitCheckByGUID([In][MarshalAs(UnmanagedType.BStr)] string bstrGuid, [MarshalAs(UnmanagedType.BStr)] string bstrVersion); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + bool KillBitCheckByProgID([In][MarshalAs(UnmanagedType.BStr)] string bstProgID, [MarshalAs(UnmanagedType.BStr)] string bstrVersion); + + [DispId(1610678297)] + bool PluginsRunning + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } +} diff --git a/Unused/Decal.Interop.Core/IDecalDirectory.cs b/Unused/Decal.Interop.Core/IDecalDirectory.cs new file mode 100644 index 0000000..fe9d7fa --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalDirectory.cs @@ -0,0 +1,16 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("5DBD2180-4B88-440E-9706-E6159A39D014")] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +public interface IDecalDirectory +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + object Lookup([MarshalAs(UnmanagedType.BStr)] string strName); +} diff --git a/Unused/Decal.Interop.Core/IDecalEnum.cs b/Unused/Decal.Interop.Core/IDecalEnum.cs new file mode 100644 index 0000000..de2a310 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEnum.cs @@ -0,0 +1,112 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("FFA32A7A-EFAF-484A-B358-8802DBBAB0EC")] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +public interface IDecalEnum +{ + [DispId(1610678272)] + string FriendlyName + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678273)] + Guid ComClass + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678274)] + bool Enabled + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [param: In] + set; + } + + [DispId(1610678276)] + bool Restricted + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + object CreateInstance(ref Guid riid); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Next(); + + [DispId(1610678279)] + Guid SurrogateClass + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678280)] + string ResourcePath + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678281)] + object Property + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Struct)] + get; + } + + [DispId(1610678282)] + string Group + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Skip([In] ref Guid clsid); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void MoveBefore(ref Guid clsidBefore); + + [DispId(1610678285)] + string Version + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678286)] + bool FileExists + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678287)] + string FilePath + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } +} diff --git a/Unused/Decal.Interop.Core/IDecalEvents.cs b/Unused/Decal.Interop.Core/IDecalEvents.cs new file mode 100644 index 0000000..ab263b8 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEvents.cs @@ -0,0 +1,21 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[TypeLibType(4096)] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(2)] +[Guid("A362F526-8203-4A77-9E37-361130924D28")] +public interface IDecalEvents +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(1)] + void InitializeComplete([In] eDecalComponentType Type); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [DispId(2)] + void TerminateComplete([In] eDecalComponentType Type); +} diff --git a/Unused/Decal.Interop.Core/IDecalEvents_Event.cs b/Unused/Decal.Interop.Core/IDecalEvents_Event.cs new file mode 100644 index 0000000..7156957 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEvents_Event.cs @@ -0,0 +1,13 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +[ComEventInterface(typeof(IDecalEvents_0000), typeof(IDecalEvents_EventProvider_0000))] +public interface IDecalEvents_Event +{ + event IDecalEvents_InitializeCompleteEventHandler InitializeComplete; + + event IDecalEvents_TerminateCompleteEventHandler TerminateComplete; +} diff --git a/Unused/Decal.Interop.Core/IDecalEvents_EventProvider.cs b/Unused/Decal.Interop.Core/IDecalEvents_EventProvider.cs new file mode 100644 index 0000000..10e71e9 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEvents_EventProvider.cs @@ -0,0 +1,218 @@ +using System; +using System.Collections; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using System.Threading; + +namespace Decal.Interop.Core; + +internal sealed class IDecalEvents_EventProvider : IDecalEvents_Event, IDisposable +{ + private IConnectionPointContainer m_ConnectionPointContainer; + + private ArrayList m_aEventSinkHelpers; + + private IConnectionPoint m_ConnectionPoint; + + private void Init() + { + IConnectionPoint ppCP = null; + Guid riid = new Guid(new byte[16] + { + 38, 245, 98, 163, 3, 130, 119, 74, 158, 55, + 54, 17, 48, 146, 77, 40 + }); + m_ConnectionPointContainer.FindConnectionPoint(ref riid, out ppCP); + m_ConnectionPoint = ppCP; + m_aEventSinkHelpers = new ArrayList(); + } + + public void add_InitializeComplete(IDecalEvents_InitializeCompleteEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IDecalEvents_SinkHelper decalEvents_SinkHelper = new IDecalEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(decalEvents_SinkHelper, out pdwCookie); + decalEvents_SinkHelper.m_dwCookie = pdwCookie; + decalEvents_SinkHelper.m_InitializeCompleteDelegate = P_0; + m_aEventSinkHelpers.Add(decalEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_InitializeComplete(IDecalEvents_InitializeCompleteEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IDecalEvents_SinkHelper decalEvents_SinkHelper = (IDecalEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (decalEvents_SinkHelper.m_InitializeCompleteDelegate != null && ((decalEvents_SinkHelper.m_InitializeCompleteDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(decalEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void add_TerminateComplete(IDecalEvents_TerminateCompleteEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + Init(); + } + IDecalEvents_SinkHelper decalEvents_SinkHelper = new IDecalEvents_SinkHelper(); + int pdwCookie = 0; + m_ConnectionPoint.Advise(decalEvents_SinkHelper, out pdwCookie); + decalEvents_SinkHelper.m_dwCookie = pdwCookie; + decalEvents_SinkHelper.m_TerminateCompleteDelegate = P_0; + m_aEventSinkHelpers.Add(decalEvents_SinkHelper); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void remove_TerminateComplete(IDecalEvents_TerminateCompleteEventHandler P_0) + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_aEventSinkHelpers == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 >= count) + { + return; + } + do + { + IDecalEvents_SinkHelper decalEvents_SinkHelper = (IDecalEvents_SinkHelper)m_aEventSinkHelpers[num]; + if (decalEvents_SinkHelper.m_TerminateCompleteDelegate != null && ((decalEvents_SinkHelper.m_TerminateCompleteDelegate.Equals(P_0) ? 1u : 0u) & 0xFFu) != 0) + { + m_aEventSinkHelpers.RemoveAt(num); + m_ConnectionPoint.Unadvise(decalEvents_SinkHelper.m_dwCookie); + if (count <= 1) + { + Marshal.ReleaseComObject(m_ConnectionPoint); + m_ConnectionPoint = null; + m_aEventSinkHelpers = null; + } + break; + } + num++; + } + while (num < count); + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public IDecalEvents_EventProvider(object P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + m_ConnectionPointContainer = (IConnectionPointContainer)P_0; + } + + public void Finalize() + { + bool lockTaken = default(bool); + try + { + Monitor.Enter(this, ref lockTaken); + if (m_ConnectionPoint == null) + { + return; + } + int count = m_aEventSinkHelpers.Count; + int num = 0; + if (0 < count) + { + do + { + IDecalEvents_SinkHelper decalEvents_SinkHelper = (IDecalEvents_SinkHelper)m_aEventSinkHelpers[num]; + m_ConnectionPoint.Unadvise(decalEvents_SinkHelper.m_dwCookie); + num++; + } + while (num < count); + } + Marshal.ReleaseComObject(m_ConnectionPoint); + } + catch (Exception) + { + } + finally + { + if (lockTaken) + { + Monitor.Exit(this); + } + } + } + + public void Dispose() + { + //Error decoding local variables: Signature type sequence must have at least one element. + Finalize(); + GC.SuppressFinalize(this); + } +} diff --git a/Unused/Decal.Interop.Core/IDecalEvents_InitializeCompleteEventHandler.cs b/Unused/Decal.Interop.Core/IDecalEvents_InitializeCompleteEventHandler.cs new file mode 100644 index 0000000..23b2d22 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEvents_InitializeCompleteEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(16)] +[ComVisible(false)] +public delegate void IDecalEvents_InitializeCompleteEventHandler([In] eDecalComponentType Type); diff --git a/Unused/Decal.Interop.Core/IDecalEvents_SinkHelper.cs b/Unused/Decal.Interop.Core/IDecalEvents_SinkHelper.cs new file mode 100644 index 0000000..7005988 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEvents_SinkHelper.cs @@ -0,0 +1,40 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[TypeLibType(TypeLibTypeFlags.FHidden)] +[ClassInterface(ClassInterfaceType.None)] +public sealed class IDecalEvents_SinkHelper : IDecalEvents +{ + public IDecalEvents_InitializeCompleteEventHandler m_InitializeCompleteDelegate; + + public IDecalEvents_TerminateCompleteEventHandler m_TerminateCompleteDelegate; + + public int m_dwCookie; + + public void InitializeComplete(eDecalComponentType P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_InitializeCompleteDelegate != null) + { + m_InitializeCompleteDelegate(P_0); + } + } + + public void TerminateComplete(eDecalComponentType P_0) + { + //Error decoding local variables: Signature type sequence must have at least one element. + if (m_TerminateCompleteDelegate != null) + { + m_TerminateCompleteDelegate(P_0); + } + } + + internal IDecalEvents_SinkHelper() + { + //Error decoding local variables: Signature type sequence must have at least one element. + m_dwCookie = 0; + m_InitializeCompleteDelegate = null; + m_TerminateCompleteDelegate = null; + } +} diff --git a/Unused/Decal.Interop.Core/IDecalEvents_TerminateCompleteEventHandler.cs b/Unused/Decal.Interop.Core/IDecalEvents_TerminateCompleteEventHandler.cs new file mode 100644 index 0000000..96d54c5 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalEvents_TerminateCompleteEventHandler.cs @@ -0,0 +1,7 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComVisible(false)] +[TypeLibType(16)] +public delegate void IDecalEvents_TerminateCompleteEventHandler([In] eDecalComponentType Type); diff --git a/Unused/Decal.Interop.Core/IDecalFileSurrogate.cs b/Unused/Decal.Interop.Core/IDecalFileSurrogate.cs new file mode 100644 index 0000000..1648756 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalFileSurrogate.cs @@ -0,0 +1,31 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[InterfaceType(1)] +[SuppressUnmanagedCodeSecurity] +[Guid("E182005F-6A67-48B5-A50F-464340105330")] +public interface IDecalFileSurrogate +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Register([MarshalAs(UnmanagedType.BStr)] string Filename); + + [DispId(1610678273)] + string Extension + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [DispId(1610678274)] + string Description + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } +} diff --git a/Unused/Decal.Interop.Core/IDecalRender.cs b/Unused/Decal.Interop.Core/IDecalRender.cs new file mode 100644 index 0000000..9fc4a86 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalRender.cs @@ -0,0 +1,30 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("B66985FA-8CB0-48E5-A2A9-7B232D609B9C")] +[InterfaceType(1)] +[SuppressUnmanagedCodeSecurity] +public interface IDecalRender +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Render2D(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Render3D(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void PreReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void PostReset(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void ChangeHWND(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void ChangeDirectX(); +} diff --git a/Unused/Decal.Interop.Core/IDecalRes.cs b/Unused/Decal.Interop.Core/IDecalRes.cs new file mode 100644 index 0000000..b82a507 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalRes.cs @@ -0,0 +1,12 @@ +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("A074F83A-32AB-46FC-9E4E-7E9DAFCD5D18")] +[TypeLibType(4160)] +[SuppressUnmanagedCodeSecurity] +public interface IDecalRes +{ +} diff --git a/Unused/Decal.Interop.Core/IDecalService.cs b/Unused/Decal.Interop.Core/IDecalService.cs new file mode 100644 index 0000000..8646fbe --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalService.cs @@ -0,0 +1,24 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[SuppressUnmanagedCodeSecurity] +[Guid("0F95468D-5071-4E28-A223-D83FDFED99E2")] +[InterfaceType(1)] +public interface IDecalService +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Initialize([MarshalAs(UnmanagedType.Interface)] DecalCore pDecal); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void BeforePlugins(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void AfterPlugins(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Terminate(); +} diff --git a/Unused/Decal.Interop.Core/IDecalSurrogate.cs b/Unused/Decal.Interop.Core/IDecalSurrogate.cs new file mode 100644 index 0000000..ae6424d --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalSurrogate.cs @@ -0,0 +1,43 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[SuppressUnmanagedCodeSecurity] +[Guid("DA98635C-A312-463B-A746-2CF62AF7413A")] +[InterfaceType(1)] +public interface IDecalSurrogate +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + object CreateInstance([MarshalAs(UnmanagedType.Interface)] DecalEnum pInitData, ref Guid riid); + + [DispId(1610678273)] + string Version + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void SetEnum([MarshalAs(UnmanagedType.Interface)] DecalEnum pInitData); + + [DispId(1610678275)] + bool FileExists + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + get; + } + + [DispId(1610678276)] + string FilePath + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.BStr)] + get; + } +} diff --git a/Unused/Decal.Interop.Core/IDecalUninstall.cs b/Unused/Decal.Interop.Core/IDecalUninstall.cs new file mode 100644 index 0000000..4e489e5 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalUninstall.cs @@ -0,0 +1,18 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[SuppressUnmanagedCodeSecurity] +[Guid("6A188D19-EC3D-409D-8190-7975FEEE2081")] +[InterfaceType(1)] +public interface IDecalUninstall +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Prepare([MarshalAs(UnmanagedType.Interface)] DecalEnum pEnum); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Uninstall(); +} diff --git a/Unused/Decal.Interop.Core/IDecalWindowsMessageSink.cs b/Unused/Decal.Interop.Core/IDecalWindowsMessageSink.cs new file mode 100644 index 0000000..947bc59 --- /dev/null +++ b/Unused/Decal.Interop.Core/IDecalWindowsMessageSink.cs @@ -0,0 +1,15 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("49D496B1-A97B-4545-8968-C4DDEBE04526")] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +public interface IDecalWindowsMessageSink +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + bool WindowMessage(int HWND, short uMsg, int wParam, int lParam); +} diff --git a/Unused/Decal.Interop.Core/IIdentifyFilter.cs b/Unused/Decal.Interop.Core/IIdentifyFilter.cs new file mode 100644 index 0000000..8da67c3 --- /dev/null +++ b/Unused/Decal.Interop.Core/IIdentifyFilter.cs @@ -0,0 +1,18 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +[Guid("256DF70B-0B87-45E4-96EE-043E2254CC95")] +public interface IIdentifyFilter +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void AddToQueue([In] int lObjectID); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void ShortcircuitID([In] int lObjectID); +} diff --git a/Unused/Decal.Interop.Core/IInjectService.cs b/Unused/Decal.Interop.Core/IInjectService.cs new file mode 100644 index 0000000..5a6aab2 --- /dev/null +++ b/Unused/Decal.Interop.Core/IInjectService.cs @@ -0,0 +1,23 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("47761792-2520-4802-8548-5CA580697614")] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +public interface IInjectService +{ + [DispId(1)] + object Site + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void InitPlugin([MarshalAs(UnmanagedType.IUnknown)] object pUnk); +} diff --git a/Unused/Decal.Interop.Core/IPlugin2.cs b/Unused/Decal.Interop.Core/IPlugin2.cs new file mode 100644 index 0000000..3f36555 --- /dev/null +++ b/Unused/Decal.Interop.Core/IPlugin2.cs @@ -0,0 +1,18 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("DFFED96D-C0B3-45CC-9B19-A95AFEEDA612")] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +public interface IPlugin2 +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Initialize([MarshalAs(UnmanagedType.Interface)] PluginSite2 Site); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Terminate(); +} diff --git a/Unused/Decal.Interop.Core/IPluginSite2.cs b/Unused/Decal.Interop.Core/IPluginSite2.cs new file mode 100644 index 0000000..9182e8b --- /dev/null +++ b/Unused/Decal.Interop.Core/IPluginSite2.cs @@ -0,0 +1,50 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[SuppressUnmanagedCodeSecurity] +[InterfaceType(1)] +[Guid("FF37AF34-3CAE-4235-9D85-6EE6976903D6")] +public interface IPluginSite2 +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void Unload(); + + [DispId(1610678273)] + object Object + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IDispatch)] + get; + } + + [DispId(1610678274)] + DecalCore Decal + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [DispId(1610678275)] + ACHooks Hooks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [DispId(1610678276)] + object PluginSite + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + void RegisterSinks([In][MarshalAs(UnmanagedType.IUnknown)] object pPlugin); +} diff --git a/Unused/Decal.Interop.Core/PluginSite2.cs b/Unused/Decal.Interop.Core/PluginSite2.cs new file mode 100644 index 0000000..48f09ec --- /dev/null +++ b/Unused/Decal.Interop.Core/PluginSite2.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("FF37AF34-3CAE-4235-9D85-6EE6976903D6")] +[CoClass(typeof(PluginSite2Class))] +public interface PluginSite2 : IPluginSite2 +{ +} diff --git a/Unused/Decal.Interop.Core/PluginSite2Class.cs b/Unused/Decal.Interop.Core/PluginSite2Class.cs new file mode 100644 index 0000000..2a2427c --- /dev/null +++ b/Unused/Decal.Interop.Core/PluginSite2Class.cs @@ -0,0 +1,50 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[SuppressUnmanagedCodeSecurity] +[ClassInterface(0)] +[Guid("E2284FC7-17E5-4846-ADAB-07953273C5FB")] +public class PluginSite2Class : IPluginSite2, PluginSite2 +{ + [DispId(1610678273)] + public virtual extern object Object + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IDispatch)] + get; + } + + [DispId(1610678274)] + public virtual extern DecalCore Decal + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [DispId(1610678275)] + public virtual extern ACHooks Hooks + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.Interface)] + get; + } + + [DispId(1610678276)] + public virtual extern object PluginSite + { + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + [return: MarshalAs(UnmanagedType.IUnknown)] + get; + } + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Unload(); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void RegisterSinks([In][MarshalAs(UnmanagedType.IUnknown)] object pPlugin); +} diff --git a/Unused/Decal.Interop.Core/SurrogateRemove.cs b/Unused/Decal.Interop.Core/SurrogateRemove.cs new file mode 100644 index 0000000..1b61854 --- /dev/null +++ b/Unused/Decal.Interop.Core/SurrogateRemove.cs @@ -0,0 +1,10 @@ +using System.Runtime.InteropServices; + +namespace Decal.Interop.Core; + +[ComImport] +[CoClass(typeof(SurrogateRemoveClass))] +[Guid("6A188D19-EC3D-409D-8190-7975FEEE2081")] +public interface SurrogateRemove : IDecalUninstall +{ +} diff --git a/Unused/Decal.Interop.Core/SurrogateRemoveClass.cs b/Unused/Decal.Interop.Core/SurrogateRemoveClass.cs new file mode 100644 index 0000000..7a7dfe2 --- /dev/null +++ b/Unused/Decal.Interop.Core/SurrogateRemoveClass.cs @@ -0,0 +1,19 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[ComImport] +[Guid("144FBF76-E7FB-4B41-AE19-6B5AB0E0A89B")] +[SuppressUnmanagedCodeSecurity] +[ClassInterface(0)] +[TypeLibType(2)] +public class SurrogateRemoveClass : IDecalUninstall, SurrogateRemove +{ + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Prepare([MarshalAs(UnmanagedType.Interface)] DecalEnum pEnum); + + [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)] + public virtual extern void Uninstall(); +} diff --git a/Unused/Decal.Interop.Core/eAttribute.cs b/Unused/Decal.Interop.Core/eAttribute.cs new file mode 100644 index 0000000..6e97e81 --- /dev/null +++ b/Unused/Decal.Interop.Core/eAttribute.cs @@ -0,0 +1,21 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eAttribute +{ + eCurrentStrength = 1, + eCurrentEndurance = 2, + eCurrentQuickness = 3, + eCurrentCoordination = 4, + eCurrentFocus = 5, + eCurrentSelf = 6, + eBaseStrength = 7, + eBaseEndurance = 8, + eBaseQuickness = 9, + eBaseCoordination = 10, + eBaseFocus = 11, + eBaseSelf = 12, + eAttribute_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eAvailableHooks.cs b/Unused/Decal.Interop.Core/eAvailableHooks.cs new file mode 100644 index 0000000..10872ba --- /dev/null +++ b/Unused/Decal.Interop.Core/eAvailableHooks.cs @@ -0,0 +1,36 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eAvailableHooks +{ + ePrevSelect = 1, + eCurrentSelect = 2, + eCastSpell = 8, + eMoveItem = 16, + eSelectItem = 32, + eUseItem = 64, + eCombatMode = 128, + eChatState = 256, + eStackCount = 1024, + eMaxStackCount = 2048, + eVendorID = 4096, + eBusyState = 8192, + eBusyStateID = 16384, + ePointerState = 32768, + eMoveItemEx = 65536, + ePosition = 131072, + eFaceHeading = 262144, + eAC3DRegion = 524288, + eObjectDestroyed = 2097152, + eSendTell = 4194304, + eSetAutorun = 8388608, + eSetCombatMode = 33554432, + eGetMiscInt = 67108864, + eGetMiscInt64 = 134217728, + eGetAttribute = 268435456, + eGetSkill = 536870912, + eGetVital = 1073741824, + eHooksAvailEx = int.MinValue +} diff --git a/Unused/Decal.Interop.Core/eAvailableHooksEx.cs b/Unused/Decal.Interop.Core/eAvailableHooksEx.cs new file mode 100644 index 0000000..4b2d552 --- /dev/null +++ b/Unused/Decal.Interop.Core/eAvailableHooksEx.cs @@ -0,0 +1,32 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eAvailableHooksEx +{ + eLogout = 0, + eColorEx = 1, + eSkillInfo = 2, + eAttributeInfo = 3, + eVitalInfo = 4, + eIsValidObject = 5, + eOnSelectItemEvent = 6, + eRequestID = 7, + eIDQueueAdd = 8, + eSendMessageByMask = 9, + eUseItemRaw = 10, + eSetIdleTime = 11, + eGiveItem = 12, + eMoveItemExRaw = 13, + eSpellTabAdd = 14, + eSpellTabDelete = 15, + eTradeAdd = 16, + eTradeAccept = 17, + eTradeDecline = 18, + eTradeReset = 19, + eTradeClose = 20, + eSalvagePanelAdd = 21, + eSalvagePanelSalvage = 22, + eAvailableHooksEx_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eChatColors.cs b/Unused/Decal.Interop.Core/eChatColors.cs new file mode 100644 index 0000000..16def6e --- /dev/null +++ b/Unused/Decal.Interop.Core/eChatColors.cs @@ -0,0 +1,31 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eChatColors +{ + SystemGreen, + Green, + White, + BrightYellow, + DullYellow, + Purple, + Red, + DarkBlue, + BrightPeach, + Peach, + BrightYellow2, + DullYellow2, + Grey, + Cyan, + LightBlue, + Red2, + Green2, + DarkBlue2, + Green3, + Green4, + Purple2, + Red3, + LightRed +} diff --git a/Unused/Decal.Interop.Core/eDecalComponentType.cs b/Unused/Decal.Interop.Core/eDecalComponentType.cs new file mode 100644 index 0000000..cfd72b3 --- /dev/null +++ b/Unused/Decal.Interop.Core/eDecalComponentType.cs @@ -0,0 +1,12 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eDecalComponentType +{ + ePlugin = 1, + eService = 2, + eNetworkFilter = 3, + eComponentType_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eInt64Types.cs b/Unused/Decal.Interop.Core/eInt64Types.cs new file mode 100644 index 0000000..0f2379c --- /dev/null +++ b/Unused/Decal.Interop.Core/eInt64Types.cs @@ -0,0 +1,11 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eInt64Types +{ + eTotalExperience = 1, + eUnassignedExperience = 2, + eInt64Types_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eIntTypes.cs b/Unused/Decal.Interop.Core/eIntTypes.cs new file mode 100644 index 0000000..5088183 --- /dev/null +++ b/Unused/Decal.Interop.Core/eIntTypes.cs @@ -0,0 +1,9 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eIntTypes +{ + eIntTypes_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eSkill.cs b/Unused/Decal.Interop.Core/eSkill.cs new file mode 100644 index 0000000..69e4bc3 --- /dev/null +++ b/Unused/Decal.Interop.Core/eSkill.cs @@ -0,0 +1,87 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eSkill +{ + eCurrentMeleeDefense = 6, + eCurrentMissileDefense = 7, + eCurrentArcaneLore = 14, + eCurrentMagicDefense = 15, + eCurrentManaConversion = 16, + eCurrentItemTinkering = 18, + eCurrentAssessPerson = 19, + eCurrentDeception = 20, + eCurrentHealing = 21, + eCurrentJump = 22, + eCurrentLockpick = 23, + eCurrentRun = 24, + eCurrentAssessCreature = 27, + eCurrentWeaponTinkering = 28, + eCurrentArmorTinkering = 29, + eCurrentMagicItemTinkering = 30, + eCurrentCreatureEnchantment = 31, + eCurrentItemEnchantment = 32, + eCurrentLifeMagic = 33, + eCurrentWarMagic = 34, + eCurrentLeadership = 35, + eCurrentLoyalty = 36, + eCurrentFletchingSkill = 37, + eCurrentAlchemySkill = 38, + eCurrentCookingSkill = 39, + eCurrentSkillSalvaging = 40, + eCurrentTwoHandedCombat = 41, + eCurrentGearcraft = 42, + eCurrentVoidMagic = 43, + eCurrentHeavyWeapons = 44, + eCurrentLightWeapons = 45, + eCurrentFinesseWeapons = 46, + eCurrentMissileWeapons = 47, + eCurrentShield = 48, + eCurrentDualWield = 49, + eCurrentRecklessness = 50, + eCurrentSneakAttack = 51, + eCurrentDirtyFighting = 52, + eCurrentSummoning = 54, + eBaseMeleeDefense = 56, + eBaseMissileDefense = 57, + eBaseArcaneLore = 64, + eBaseMagicDefense = 65, + eBaseManaConversion = 66, + eBaseItemTinkering = 68, + eBaseAssessPerson = 69, + eBaseDeception = 70, + eBaseHealing = 71, + eBaseJump = 72, + eBaseLockpick = 73, + eBaseRun = 74, + eBaseAssessCreature = 77, + eBaseWeaponTinkering = 78, + eBaseArmorTinkering = 79, + eBaseMagicItemTinkering = 80, + eBaseCreatureEnchantment = 81, + eBaseItemEnchantment = 82, + eBaseLifeMagic = 83, + eBaseWarMagic = 84, + eBaseLeadership = 85, + eBaseLoyalty = 86, + eBaseFletchingSkill = 87, + eBaseAlchemySkill = 88, + eBaseCookingSkill = 89, + eBaseSkillSalvaging = 90, + eBaseTwoHandedCombat = 91, + eBaseGearcraft = 92, + eBaseVoidMagic = 93, + eBaseHeavyWeapons = 94, + eBaseLightWeapons = 95, + eBaseFinesseWeapons = 96, + eBaseMissileWeapons = 97, + eBaseShield = 98, + eBaseDualWield = 99, + eBaseRecklessness = 100, + eBaseSneakAttack = 101, + eBaseDirtyFighting = 102, + eBaseSummoning = 104, + eSkill_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eTrainLevel.cs b/Unused/Decal.Interop.Core/eTrainLevel.cs new file mode 100644 index 0000000..603ce4f --- /dev/null +++ b/Unused/Decal.Interop.Core/eTrainLevel.cs @@ -0,0 +1,12 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eTrainLevel +{ + eUntrained = 1, + eTrained = 2, + eSpecialized = 3, + eTrainLevel_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/eUIElementType.cs b/Unused/Decal.Interop.Core/eUIElementType.cs new file mode 100644 index 0000000..c628c1e --- /dev/null +++ b/Unused/Decal.Interop.Core/eUIElementType.cs @@ -0,0 +1,24 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eUIElementType +{ + Smartbox = 268436634, + Chat = 268436993, + FloatChat1 = 268436741, + FloatChat2 = 268436750, + FloatChat3 = 268436751, + FloatChat4 = 268436752, + Examination = 268436983, + Vitals = 268436986, + EnvPack = 268436989, + Panels = 268436991, + TBar = 268436995, + Indicators = 268437009, + ProgressBar = 268437011, + Combat = 268437173, + Radar = 268437202, + SideBySideVitals = 268437205 +} diff --git a/Unused/Decal.Interop.Core/eVital.cs b/Unused/Decal.Interop.Core/eVital.cs new file mode 100644 index 0000000..d83e63a --- /dev/null +++ b/Unused/Decal.Interop.Core/eVital.cs @@ -0,0 +1,18 @@ +using System.Security; + +namespace Decal.Interop.Core; + +[SuppressUnmanagedCodeSecurity] +public enum eVital +{ + eMaximumHealth = 1, + eCurrentHealth = 2, + eMaximumStamina = 3, + eCurrentStamina = 4, + eMaximumMana = 5, + eCurrentMana = 6, + eBaseHealth = 7, + eBaseStamina = 8, + eBaseMana = 9, + eVital_DWORD = int.MaxValue +} diff --git a/Unused/Decal.Interop.Core/tagRECT.cs b/Unused/Decal.Interop.Core/tagRECT.cs new file mode 100644 index 0000000..773c5e8 --- /dev/null +++ b/Unused/Decal.Interop.Core/tagRECT.cs @@ -0,0 +1,17 @@ +using System.Runtime.InteropServices; +using System.Security; + +namespace Decal.Interop.Core; + +[StructLayout(LayoutKind.Sequential, Pack = 4)] +[SuppressUnmanagedCodeSecurity] +public struct tagRECT +{ + public int left; + + public int top; + + public int right; + + public int bottom; +} diff --git a/dereth.png b/dereth.png new file mode 100644 index 0000000..4722941 Binary files /dev/null and b/dereth.png differ diff --git a/flagtracker/index.lua b/flagtracker/index.lua new file mode 100644 index 0000000..f1db671 --- /dev/null +++ b/flagtracker/index.lua @@ -0,0 +1,1455 @@ +local im = require("imgui") +local ubviews = require("utilitybelt.views") +local Quests = require("quests") +local imgui = im.ImGui +local version = "1.8.1" +local currentHUDPosition = nil +local defaultHUDposition = Vector2.new(500,100) +local iconVectorSize = Vector2.new(16,16) +local characterTypeSelf = nil +local textures = {} + +--[[ + TODO / POTENTIAL WORK LIST + - Clean Up / Speed Up Code + - Add Damage Colors To Weapon Types + - Tracking for Biting Strike / Crushing Blow / Armor Cleaving + - Better Tooltips +]]-- + +-- Cached Data for Performance +local CachedData = { + LuminanceFlagged = false, + FactionBits = nil, + SkillTrainingMagicItemTinkering = SkillTrainingType.Untrained, + SkillTrainingItemTinkering = SkillTrainingType.Untrained, + SkillTrainingArmorTinkering = SkillTrainingType.Untrained, + SkillTrainingWeaponTinkering = SkillTrainingType.Untrained, + AugInnateFamily = 0, + AugResistanceFamily = 0, + InventoryCountAsheronsBenediction = 0, + LastUpdatedTime = os.clock() +} + +-- LUA Table for Color Codes +local Colors = { + Red = Vector4.new(1, 0, 0, 1), + SoftRed = Vector4.new(1, 0.5, 0.5, 1), + Orange = Vector4.new(1, 0.7, 0.4, 1), + SoftOrange = Vector4.new(1, 0.7, 0.2, 1), + Yellow = Vector4.new(1, 1, 0, 1), + SoftYellow = Vector4.new(1, 1, 0.5, 1), + Green = Vector4.new(0, 1, 0, 1), + SoftGreen = Vector4.new(0.3, 1, 0.3, 1), + SofterGreen = Vector4.new(0.5, 1, 0.5, 1), + LightBlue = Vector4.new(0.3, 0.6, 1, 1), + SoftBlue = Vector4.new(0.5, 0.7, 1, 1), + SoftPurple = Vector4.new(0.8, 0.5, 1, 1), + BrightPurple = Vector4.new(0.8, 0.3, 1, 1), + + White = Vector4.new(1, 1, 1, 1), + LightGray = Vector4.new(0.7, 0.7, 0.7, 1), + DarkGray = Vector4.new(0.6, 0.6, 0.6, 1) +} + +-- Holds Script-Wide Settings +local Settings = { + showLuminance = true, + showRecallSpells = true, + showSociety=true, + showFacHub=false, + showQuests=false, + showFlags=true, + hideUnacquiredWeapons=false, + hideMissingCantrips=false, + hideResistanceCleavingWeapons=true, + hideNonEssentialCreatureSlayers=true +} + +-- Different Character Types (Returned by GetCharacterType) +local CharacterType = { + Unknown = 0, + Melee = 1, + Archer = 2, + WarMage = 3, + VoidMage = 4 +} + +-- Quest Info Type (Used In Character Flags) +local QuestInfoType = { + SolveCount = 1, + ReadyCheck = 2, + StampCheck = 3 +} + +-- Quest Type (Used For Society Quests) +local QuestType = { + Other = 0, + KillTask = 1, + CollectItem = 2, + QuestTag = 3, + MultiQuestTag = 4 +} + +-- Maps Numeric Value to CreatureType +local MapCreatureType = { + [0] = CreatureType.Invalid, + [1] = CreatureType.Olthoi, + [2] = CreatureType.Banderling, + [3] = CreatureType.Drudge, + [4] = CreatureType.Mosswart, + [5] = CreatureType.Lugian, + [6] = CreatureType.Tumerok, + [7] = CreatureType.Mite, + [8] = CreatureType.Tusker, + [9] = CreatureType.PhyntosWasp, + [10] = CreatureType.Rat, + [11] = CreatureType.Auroch, + [12] = CreatureType.Cow, + [13] = CreatureType.Golem, + [14] = CreatureType.Undead, + [15] = CreatureType.Gromnie, + [16] = CreatureType.Reedshark, + [17] = CreatureType.Armoredillo, + [18] = CreatureType.Fae, + [19] = CreatureType.Virindi, + [20] = CreatureType.Wisp, + [21] = CreatureType.Knathtead, + [22] = CreatureType.Shadow, + [23] = CreatureType.Mattekar, + [24] = CreatureType.Mumiyah, + [25] = CreatureType.Rabbit, + [26] = CreatureType.Sclavus, + [27] = CreatureType.ShallowsShark, + [28] = CreatureType.Monouga, + [29] = CreatureType.Zefir, + [30] = CreatureType.Skeleton, + [31] = CreatureType.Human, + [32] = CreatureType.Shreth, + [33] = CreatureType.Chittick, + [34] = CreatureType.Moarsman, + [35] = CreatureType.OlthoiLarvae, + [36] = CreatureType.Slithis, + [37] = CreatureType.Deru, + [38] = CreatureType.FireElemental, + [39] = CreatureType.Snowman, + [40] = CreatureType.Unknown, + [41] = CreatureType.Bunny, + [42] = CreatureType.LightningElemental, + [43] = CreatureType.Rockslide, + [44] = CreatureType.Grievver, + [45] = CreatureType.Niffis, + [46] = CreatureType.Ursuin, + [47] = CreatureType.Crystal, + [48] = CreatureType.HollowMinion, + [49] = CreatureType.Scarecrow, + [50] = CreatureType.Idol, + [51] = CreatureType.Empyrean, + [52] = CreatureType.Hopeslayer, + [53] = CreatureType.Doll, + [54] = CreatureType.Marionette, + [55] = CreatureType.Carenzi, + [56] = CreatureType.Siraluun, + [57] = CreatureType.AunTumerok, + [58] = CreatureType.HeaTumerok, + [59] = CreatureType.Simulacrum, + [60] = CreatureType.AcidElemental, + [61] = CreatureType.FrostElemental, + [62] = CreatureType.Elemental, + [63] = CreatureType.Statue, + [64] = CreatureType.Wall, + [65] = CreatureType.AlteredHuman, + [66] = CreatureType.Device, + [67] = CreatureType.Harbinger, + [68] = CreatureType.DarkSarcophagus, + [69] = CreatureType.Chicken, + [70] = CreatureType.GotrokLugian, + [71] = CreatureType.Margul, + [72] = CreatureType.BleachedRabbit, + [73] = CreatureType.NastyRabbit, + [74] = CreatureType.GrimacingRabbit, + [75] = CreatureType.Burun, + [76] = CreatureType.Target, + [77] = CreatureType.Ghost, + [78] = CreatureType.Fiun, + [79] = CreatureType.Eater, + [80] = CreatureType.Penguin, + [81] = CreatureType.Ruschk, + [82] = CreatureType.Thrungus, + [83] = CreatureType.ViamontianKnight, + [84] = CreatureType.Remoran, + [85] = CreatureType.Swarm, + [86] = CreatureType.Moar, + [87] = CreatureType.EnchantedArms, + [88] = CreatureType.Sleech, + [89] = CreatureType.Mukkir, + [90] = CreatureType.Merwart, + [91] = CreatureType.Food, + [92] = CreatureType.ParadoxOlthoi, + [93] = CreatureType.Harvest, + [94] = CreatureType.Energy, + [95] = CreatureType.Apparition, + [96] = CreatureType.Aerbax, + [97] = CreatureType.Touched, + [98] = CreatureType.BlightedMoarsman, + [99] = CreatureType.GearKnight, + [100] = CreatureType.Gurog, + [101] = CreatureType.Anekshay +} + +-- Skill Replacement for Cantrips That Have Different Names Than Their Skill +local MapSkillCantripReplacements = { + [SkillId.MagicDefense] = "MagicResistance", + [SkillId.MeleeDefense] = "Invulnerability", + [SkillId.MissileDefense] = "Impgrenability", + [SkillId.MissleWeapons] = "MissileWeapon", + [SkillId.HeavyWeapons] = "HeavyWeapon", + [SkillId.LightWeapons] = "LightWeapon", + [SkillId.FinesseWeapons] = "FinesseWeapon" +} + +-- Color Map for Cantrip Levels +local MapCantripColors = { + ["N/A"] = Colors.LightGray, + ["Minor"] = Colors.White, + ["Moderate"] = Colors.SoftGreen, + ["Major"] = Colors.LightBlue, + ["Epic"] = Colors.BrightPurple, + ["Legendary"] = Colors.SoftOrange +} + +-- Rank Map for Societies +local MapSocietyRibbons = { + -- 1 = Min Ribbons + -- 2 = Max Ribbons + -- 3 = Ribbons Per Day + ["Initiate"] = {min = 1, max = 95, perday = 50}, + ["Adept"] = {min = 101, max = 295, perday = 100}, + ["Knight"] = {min = 301, max = 595, perday = 150}, + ["Lord"] = {min = 601, max = 995, perday = 200}, + ["Master"] = {min = 1001, max = 9999, perday = 250} +} + +-- State Tracking for Tree Nodes +local TreeOpenStates = { + ["Stat Augs"] = false, + ["Resistance Augs"] = false +} + +-- Tree Layout for Augmentation Tab +local TabAugmentations = { + -- 1 = Augmentation Name + -- 2 = Augmentation Int ID + -- 3 = Augmentation Times Repeatable + -- 4 = NPC Trainer + -- 5 = NPC Trainer Location + ["Death Augs"] = { + {name = "Keep Items", id = IntId.AugmentationLessDeathItemLoss, repeatable = 3, trainer = "Rohula bint Ludun", location = "Ayan Baqur"}, + {name = "Keep Spells", id = IntId.AugmentationSpellsRemainPastDeath, repeatable = 1, trainer = "Erik Festus", location = "Ayan Baqur"} + }, + ["Skill Augs"] = { + {name = "+5 All Skills", id = IntId.AugmentationJackOfAllTrades, repeatable = 1, trainer = "Arianna the Adept", location = "Bandit Castle"}, + {name = "+10 Melee Skills", id = IntId.AugmentationSkilledMelee, repeatable = 1, trainer = "Carlito Gallo", location = "Silyun"}, + {name = "+10 Magic Skills", id = IntId.AugmentationSkilledMagic, repeatable = 1, trainer = "Rahina bint Zalanis", location = "Zaikhal"}, + {name = "+10 Missile Skills", id = IntId.AugmentationSkilledMissile, repeatable = 1, trainer = "Kilaf", location = "Zaikhal"} + }, + ["Rating Augs"] = { + {name = "25%% Crit Protection", id = IntId.AugmentationCriticalDefense, repeatable = 1, trainer = "Piersanti Linante", location = "Sanamar"}, + {name = "1%% Critical Chance", id = IntId.AugmentationCriticalExpertise, repeatable = 1, trainer = "Anfram Mellow", location = "Ayan Baqur"}, + {name = "3%% Critical Damage", id = IntId.AugmentationCriticalPower, repeatable = 1, trainer = "Alishia bint Aldan", location = "Ayan Baqur"}, + {name = "3%% Damage Rating", id = IntId.AugmentationDamageBonus, repeatable = 1, trainer = "Neela Nashua", location = "Bandit Castle"}, + {name = "3%% Damage Reduction", id = IntId.AugmentationDamageReduction, repeatable = 1, trainer = "Emily Yarow", location = "Cragstone"} + }, + ["Burden / Pack Augs"] = { + {name = "Extra Carrying Capacity", id = IntId.AugmentationIncreasedCarryingCapacity, repeatable = 5, trainer = "Husoon", location = "Zaikhal"}, + {name = "Extra Pack Slot", id = IntId.AugmentationExtraPackSlot, repeatable = 1, trainer = "Dumida bint Ruminre", location = "Zaikhal"}, + {name = "Infused War Magic", id = IntId.AugmentationInfusedWarMagic, repeatable = 1, trainer = "Raphel Detante", location = "Silyun"}, + {name = "Infused Void Magic", id = IntId.AugmentationInfusedVoidMagic, repeatable = 1, trainer = "Morathe", location = "Candeth Keep"}, + {name = "Infused Creature Magic", id = IntId.AugmentationInfusedCreatureMagic, repeatable = 1, trainer = "Gustuv Lansdown", location = "Cragstone"}, + {name = "Infused Life Magic", id = IntId.AugmentationInfusedLifeMagic, repeatable = 1, trainer = "Akemi Fei", location = "Hebian-To"}, + {name = "Infused Item Magic", id = IntId.AugmentationInfusedItemMagic, repeatable = 1, trainer = "Gan Fo", location = "Hebian-To"} + }, + ["Misc Augs"] = { + {name = "10%% Health Increase", id = nil, repeatable = 1, trainer = "Donatello Linante", location = "Silyun"}, + {name = "Increased Spell Duration", id = IntId.AugmentationIncreasedSpellDuration, repeatable = 5, trainer = "Nawamara Ujio", location = "Mayoi"}, + {name = "Faster HP Regen", id = IntId.AugmentationFasterRegen, repeatable = 2, trainer = "Alison Dulane", location = "Bandit Castle"}, + {name = "5%% Experience Increase", id = IntId.AugmentationBonusXp, repeatable = 1, trainer = "Rickard Dumalia", location = "Silyun"} + }, + ["Salvage Augs"] = { + {name = "Specialized Weapon Tinkering", id = IntId.AugmentationSpecializeWeaponTinkering, repeatable = 1, trainer = "Lenor Turk", location = "Cragstone"}, + {name = "Specialized Armor Tinkering", id = IntId.AugmentationSpecializeArmorTinkering, repeatable = 1, trainer = "Joshun Felden", location = "Cragstone"}, + {name = "Specialized Item Tinkering", id = IntId.AugmentationSpecializeItemTinkering, repeatable = 1, trainer = "Brienne Carlus", location = "Cragstone"}, + --{"Specialized GearCraft",IntId.AugmentationSpecializeGearcraft,1,"Alex Brummel","Cragstone"}, + {name = "Specialized Magic Item Tinkering", id = IntId.AugmentationSpecializeMagicItemTinkering, repeatable = 1, trainer = "Burrell Sammrun", location = "Cragstone"}, + {name = "Specialized Salvaging", id = IntId.AugmentationSpecializeSalvaging, repeatable = 1, trainer = "Robert Crow", location = "Cragstone"}, + {name = "25%% More Salvage", id = IntId.AugmentationBonusSalvage, repeatable = 4, trainer = "Kris Cennis", location = "Cragstone"}, + {name = "5%% Imbue Chance", id = IntId.AugmentationBonusImbueChance, repeatable = 1, trainer = "Lug", location = "Oolutanga's Refuge"} + }, + ["Stat Augs"] = { + {name = "All Stats", id = IntId.AugmentationInnateFamily, repeatable = 10}, + {name = "Strength", id = IntId.AugmentationInnateStrength, repeatable = 10, trainer = "Fiun Luunere", location = "Fiun Outpost"}, + {name = "Endurance", id = IntId.AugmentationInnateEndurance, repeatable = 10, trainer = "Fiun Ruun", location = "Fiun Outpost"}, + {name = "Coordination", id = IntId.AugmentationInnateCoordination, repeatable = 10, trainer = "Fiun Bayaas", location = "Fiun Outpost"}, + {name = "Quickness", id = IntId.AugmentationInnateQuickness, repeatable = 10, trainer = "Fiun Riish", location = "Fiun Outpost"}, + {name = "Focus", id = IntId.AugmentationInnateFocus, repeatable = 10, trainer = "Fiun Vasherr", location = "Fiun Outpost"}, + {name = "Self", id = IntId.AugmentationInnateSelf, repeatable = 10, trainer = "Fiun Noress", location = "Fiun Outpost"} + }, + ["Resistance Augs"] = { + {name = "All Resistances", id = IntId.AugmentationResistanceFamily, repeatable = 2}, + {name = "Blunt", id = IntId.AugmentationResistanceBlunt, repeatable = 2, trainer = "Nawamara Dia", location = "Hebian-To"}, + {name = "Pierce", id = IntId.AugmentationResistancePierce, repeatable = 2, trainer = "Kyujo Rujen", location = "Hebian-To"}, + {name = "Slashing", id = IntId.AugmentationResistanceSlash, repeatable = 2, trainer = "Ilin Wis", location = "Hebian-To"}, + {name = "Fire", id = IntId.AugmentationResistanceFire, repeatable = 2, trainer = "Rikshen Ri", location = "Hebian-To"}, + {name = "Frost", id = IntId.AugmentationResistanceFrost, repeatable = 2, trainer = "Lu Bao", location = "Hebian-To"}, + {name = "Acid", id = IntId.AugmentationResistanceAcid, repeatable = 2, trainer = "Shujio Milao", location = "Hebian-To"}, + {name = "Lightning", id = IntId.AugmentationResistanceLightning, repeatable = 2, trainer = "Enli Yuo", location = "Hebian-To"} + } +} + +-- Tree Layout for Luminance Auras +local TabLuminanceAuras = { + -- 1 = Luminance Aura Name + -- 2 = Luminance Aura IntID + -- 3 = Luminance Aura Cap + -- 4 (Seer Auras Only) = Luminance Aura QuestFlag + ["Nalicana Auras"] = { + {"+1 Aetheria Proc Rating",IntId.LumAugSurgeChanceRating,5}, + {"+1 Damage Reduction Rating",IntId.LumAugDamageReductionRating,5}, + {"+1 Crit Reduction Rating",IntId.LumAugCritReductionRating,5}, + {"+1 Damage Rating",IntId.LumAugDamageRating,5}, + {"+1 Crit Damage Rating",IntId.LumAugCritDamageRating,5}, + {"+1 Heal Rating",IntId.LumAugHealingRating,5}, + {"+1 Equipment Mana Rating",IntId.LumAugItemManaUsage,5}, + {"+1 Mana Stone Rating",IntId.LumAugItemManaGain,5}, + {"+1 Crafting Skills",IntId.LumAugSkilledCraft,5}, + {"+1 All Skills",IntId.LumAugAllSkills,10}, + }, + ["Seer Auras"] = { + {"(Ka'hiri) +2 Specialized Skills",IntId.LumAugSkilledSpec,5,"LoyalToKahiri"}, + {"(Ka'hiri) +1 Damage Rating",IntId.LumAugDamageRating,5,"LoyalToKahiri"}, + {"(Shade of Lady Adja) +2 Specialized Skills",IntId.LumAugSkilledSpec,5,"LoyalToShadeOfLadyAdja"}, + {"(Shade of Lady Adja) +1 Damage Reduction Rating",IntId.LumAugDamageReductionRating,5,"LoyalToShadeOfLadyAdja"}, + {"(Liam of Gelid) +1 Damage Rating",IntId.LumAugDamageRating,5,"LoyalToLiamOfGelid"}, + {"(Liam of Gelid) +1 Crit Damage Rating",IntId.LumAugCritDamageRating,5,"LoyalToLiamOfGelid"}, + {"(Lord Tyragar) +1 Crit Reduction Rating",IntId.LumAugCritReductionRating,5,"LoyalToLordTyragar"}, + {"(Lord Tyragar) +1 Damage Reduction Rating",IntId.LumAugDamageReductionRating,5,"LoyalToLordTyragar"}, + } +} + +-- Tree Layout for Recall Spells +local TabRecallSpells = { + -- 1 = Spell Name + -- 2 = Spell ID + {"Recall the Sanctuary",2023}, + {"Aerlinthe Recall",2041}, + {"Mount Lethe Recall",2813}, + {"Recall Aphus Lassel",2931}, + {"Ulgrim's Recall",2941}, + {"Recall to the Singularity Caul",2943}, + {"Glenden Wood Recall",3865}, + {"Bur Recall",4084}, + {"Call of the Mhoire Forge",4128}, + {"Paradox-touched Olthoi Infested Area Recall",4198}, + {"Colosseum Recall",4213}, + {"Return to the Keep",4214}, + {"Gear Knight Invasion Area Camp Recall",5330}, + {"Lost City of Neftet Recall",5541}, + {"Rynthid Recall",6150}, + {"Viridian Rise Recall",6321}, + {"Viridian Rise Great Tree Recall",6322} +} + +-- Tree Layout for Character Flags +local TabCharacterFlags = { + -- 1 = Flag Name + -- 2 = Quest Flag + -- 3 = Quest Info Type + ["Additional Skill Credits"] = { + {"+1 Skill Lum Aura","lumaugskillquest",QuestInfoType.SolveCount}, + {"+1 Skill Aun Ralirea","arantahkill1",QuestInfoType.SolveCount}, + {"+1 Skill Chasing Oswald","oswaldmanualcompleted",QuestInfoType.SolveCount}, + }, + ["Aetheria"] = { + {"Blue Aetheria (75)","efulcentermanafieldused",QuestInfoType.StampCheck}, + {"Yellow Aetheria (150)","efmlcentermanafieldused",QuestInfoType.StampCheck}, + {"Red Aetheria (225)","efllcentermanafieldused",QuestInfoType.StampCheck}, + }, + ["Augmentation Gems"] = { + {"Sir Bellas","augmentationblankgemacquired",QuestInfoType.ReadyCheck}, + {"Gladiator Diemos Token","pickedupmarkerboss10x",QuestInfoType.ReadyCheck}, + {"100K Luminance Gem","blankaugluminancetimer_0511",QuestInfoType.ReadyCheck}, + }, + ["Other Flags"] = { + {"Candeth Keep Treehouse","strongholdbuildercomplete",QuestInfoType.StampCheck}, + {"Bur Flag (Portal)","burflagged(permanent)",QuestInfoType.StampCheck}, + {"Singularity Caul","virindiisland",QuestInfoType.StampCheck}, + {"Vissidal Island","vissflagcomplete",QuestInfoType.StampCheck}, + {"Dark Isle","darkisleflagged",QuestInfoType.StampCheck}, + {"Luminance Flag","oracleluminancerewardsaccess_1110",QuestInfoType.StampCheck}, + {"Diemos Access","golemstonediemosgiven",QuestInfoType.StampCheck} + } +} + +-- Tree Layout for Society Quests +local TabSocietyQuests = { + -- 1 = Quest Name + -- 2 = Quest Start Tag + -- 3 = Quest End Tag + -- 4 = Quest Type + -- Other Fields (Dependent on QuestType) + -- QuestType.CollectItem + -- 5 = Item To Collect + -- 6 = # Items to Collect + -- QuestType.QuestTag + -- 5 = "Ready For Turn In" Quest Tag + -- 6 = "Quest Started" Item + -- QuestType.MultiQuestTag + -- 5 = Additional Quest Tags To Complete (x/cap) + ["Initiate"] = { + {"GK: Parts x10","","GearknightPartsCollectionWait_0513",QuestType.CollectItem,"Pile of Gearknight Parts",10}, + {"GK: Phalanx Kill x10","GearknightInvasionPhalanxKilltask_0513","GearknightInvasionPhalanxKillWait_0513",QuestType.KillTask}, + {"GK: Mana Siphon","","GearknightInvasionHighSiphonWait_1009",QuestType.QuestTag,"GearknightInvasionHighSiphonStart_1009","Unstable Mana Stone"}, + {"GY: Skeleton Jaw x8","TaskGrave1JawCollectStarted","TaskGrave1JawCollectWait",QuestType.CollectItem,"Pyre Skeleton Jaw",8}, + {"GY: Wight Sorcerer Kill x12","TaskGrave1WightMageKilltask","TaskGrave1WightMageWait",QuestType.KillTask}, + {"GY: Shambling Archivist Kill","TaskGrave1BossKillStarted","TaskGrave1BossKillWait",QuestType.KillTask}, + {"DI: Vaeshok Kill","TaskDIRuschkBossKillTask","TaskDIRuschkBossKillTaskWait",QuestType.KillTask}, + {"DI: Deliver Remoran Fin","","TaskDIDeliveryWait",QuestType.QuestTag,"TaskDIDelivery","Altered Dark Remoran Fin"} + }, + ["Adept"] = { + {"DI: Black Coral x10","TaskDIBlackCoralStarted","TaskDIBlackCoralComplete",QuestType.CollectItem,"Black Coral",10}, + {"DI: Crystal of Perception","TaskDIScoutStarted","TaskDIScoutComplete",QuestType.Other}, + {"DI: Battle Reports x10","TaskDIReportStarted","TaskDIReportWait",QuestType.CollectItem,"Falatacot Battle Report",10}, + {"GY: Supplies to Massilor","","TaskGrave2FedExWait",QuestType.QuestTag,"TaskGrave2FedExDelivered","Supplies for Massilor"}, + {"GY: Stone Tracing","TaskGrave2WallCarvingStarted","TaskGrave2WallCarvingWait",QuestType.CollectItem,"Imprinted Archaeologist's Paper",1} + }, + ["Knight"] = { + {"FI: Blessed Moarsman Kill x50","TaskFreebooterMoarsmanKilltask","TaskFreebooterMoarsmanKilltaskWait",QuestType.KillTask}, + {"FI: Bandit Mana Boss Kill","TaskFreebooterBanditBossKill","TaskFreebooterBanditBossKillWait",QuestType.KillTask}, + {"FI: Glowing Jungle Lily x20","TaskFreebooterJungleLilyStarted","TaskFreebooterJungleLilyComplete",QuestType.CollectItem,"Glowing Jungle Lily",20}, + {"FI: Glowing Moar Gland x30","TaskFreebooterMoarGlandStarted","TaskFreebooterMoarGlandComplete",QuestType.CollectItem,"Glowing Moar Gland",30}, + {"FI: Killer Phyntos Wasp Kill x50","KillTaskPhyntosKiller1109","KillTaskPhyntosKillerWait1109",QuestType.KillTask}, + {"FI: Mana-Infused Jungle Flower x20","TaskFreebooterJungleFlowerStarted","TaskFreebooterJungleFlowerComplete",QuestType.CollectItem,"Mana-Infused Jungle Flower",20}, + {"FI: Phyntos Larva Kill x20","KillTaskPhyntosLarvae1109","KillTaskPhyntosLarvaeWait1109",QuestType.KillTask}, + {"FI: Phyntos Honey x10","","PhyntosHoneyComplete1109",QuestType.CollectItem,"Phyntos Honey",10}, + {"FI: Hive Queen Kill","","KillPhyntosQueenPickup1109",QuestType.CollectItem,"Phyntos Queen's Abdomen",1}, + {"FI: Phyntos Hive Splinters x10","","PhyntosHiveComplete1109",QuestType.CollectItem,"Hive Splinter",10} + }, + ["Lord"] = { + {"MC: Artifact Collection","TaskMoarsmenArtifactsStarted","TaskMoarsmenArtifactsWait",QuestType.Other}, + {"MC: Coral Tower Destroyer","TaskCoralTowersStarted","TaskCoralTowersWait",QuestType.MultiQuestTag,{"CoralTowerBlackDead","CoralTowerBlueDead","CoralTowerGreenDead","CoralTowerRedDead","CoralTowerWhiteDead"}}, + {"MC: High Priest of T'thuun Kill","KillTaskMoarsmanHighPriestStarted","KillTaskMoarsmanHighPriestWait",QuestType.MultiQuestTag,{"HighPriestAcolyteDead","HighPriestFirstDead","HighPriestSecondDead","HighPriestThirdDead"}}, + {"MC: Magshuth Moarsman Kill x20","KilltaskMagshuthMoarsman","KilltaskMagshuthMoarsmanWait",QuestType.KillTask}, + {"MC: Shoguth Moarsman Kill x40","KilltaskShoguthMoarsman","KilltaskShoguthMoarsmanWait",QuestType.KillTask}, + {"MC: Moguth Moarsman Kill x60","KilltaskMoguthMoarsman","KilltaskMoguthMoarsmanWait",QuestType.KillTask}, + {"MC: Moarsman Spawning Pools","TaskSpawnPoolsStarted","TaskSpawnPoolsWait",QuestType.MultiQuestTag,{"BroodMotherZeroDead","BroodMotherOneDead","BroodMotherTwoDead","BroodMotherThreeDead"}}, + {"MC: Palm Fort Defended","","PalmFortDefended1209",QuestType.Other}, + {"MC: Supply Saboteur","","SuppliesTurnedIn1209",QuestType.Other} + } +} + +-- Tree Layout for Facility Hub Quests +local TabFacilityHubQuests = { + -- 1 = Fac Hub Quest Name + -- 2 = Completion Quest Tag + -- 3 = Starting Quest Tag (if different than normal syntax) + ["Level 10"] = { + {"Glenden Wood","fachubglendenwood"}, + {"Folthid Estate","fachubfolthid"}, + {"Mosswart Camp","fachubmosswartcamp"} + }, + ["Level 15"] = { + {"Green Mire Grave","fachubgreenmiregrave"}, + {"Colier","fachubcolier"}, + {"Halls of Helm","fachubhallsofhelm"} + }, + ["Level 20"] = { + {"Dangerous Cave","fachubdangerouscatacombs"}, + {"Trothyr's Rest","fachubtrothyrsrest"}, + {"Hunter's Leap","fachubhuntersleap"} + }, + ["Level 25"] = { + {"Fledgemaster's Camp","fachubfledgemasterscamp"}, + {"Eastham Portals","fachubeastham","fachubeasthamportals_flag"}, + {"Catacombs of the Forgotten","fachubcatacombs"} + }, + ["Level 30"] = { + {"Mountain Sewer","fachubmountainsewer"}, + {"Mite Maze","fachubmitemaze"}, + {"Haunted Mansion","fachubhauntedmansion"} + }, + ["Level 35"] = { + {"Suntik","fachubsuntik"}, + {"Banderling Camp","fachubbanderlingcamp"}, + {"Skeleton Fort","fachubskeletonfort"} + }, + ["Level 40"] = { + {"Bellig Tower","fachubbellig"}, + {"Castle of Baron Nuvillus","fachubcastle"}, + {"Dryreach","fachubdryreach"} + }, + ["Level 45"] = { + {"Blackmire","fachubblackmire"} + } +} + +-- Tree Layout for Cantrip Tracker +local TabCantrips = { + ["Specialized Skills"] = {}, + ["Trained Skills"] = {}, + ["Attributes"] = { + ["Strength"] = { value = "N/A", color = Colors.White, spellIcon = SpellId.StrengthSelf8, iconBackground = 0x060013F9}, + ["Endurance"] = { value = "N/A", color = Colors.White, spellIcon = SpellId.EnduranceSelf8, iconBackground = 0x060013F9}, + ["Coordination"] = { value = "N/A", color = Colors.White, spellIcon = SpellId.CoordinationSelf8, iconBackground = 0x060013F9}, + ["Quickness"] = { value = "N/A", color = Colors.White, spellIcon = SpellId.QuicknessSelf8, iconBackground = 0x060013F9}, + ["Focus"] = { value = "N/A", color = Colors.White, spellIcon = SpellId.FocusSelf8, iconBackground = 0x060013F9}, + ["Willpower"] = { value = "N/A", color = Colors.White, spellIcon = SpellId.WillpowerSelf8, iconBackground = 0x060013F9} + }, + ["Protection Auras"] = { + ["Armor"] = { value = "N/A", color = Colors.DarkGray, spellIcon = SpellId.ArmorSelf8}, -- Light Gray + ["Bludgeoning Ward"] = { value = "N/A", color = Colors.LightGray, spellIcon = SpellId.BludgeonProtectionSelf8}, -- Soft Gray + ["Piercing Ward"] = { value = "N/A", color = Colors.SoftYellow, spellIcon = SpellId.PiercingProtectionSelf8}, -- Pastel Yellow + ["Slashing Ward"] = { value = "N/A", color = Colors.Orange, spellIcon = SpellId.BladeProtectionSelf8}, -- Pastel Orange + ["Flame Ward"] = { value = "N/A", color = Colors.SoftRed, spellIcon = SpellId.FireProtectionSelf8}, -- Soft Red + ["Frost Ward"] = { value = "N/A", color = Colors.SoftBlue, spellIcon = SpellId.ColdProtectionSelf8}, -- Pastel Blue + ["Acid Ward"] = { value = "N/A", color = Colors.SofterGreen, spellIcon = SpellId.AcidProtectionSelf8}, -- Soft Green + ["Storm Ward"] = { value = "N/A", color = Colors.SoftPurple, spellIcon = SpellId.LightningProtectionSelf8} -- Pastel Purple + } +} + +-- Tree Layout for Weapons Tab +local TabWeapons = { + ["Creature Slayer"] = { + ["Tumerok"] = {IntId.SlayerCreatureType, CreatureType.Tumerok, true, {}}, + ["Olthoi"] = {IntId.SlayerCreatureType, CreatureType.Olthoi, true, {}}, + ["Ghost"] = {IntId.SlayerCreatureType, CreatureType.Ghost, true, {}}, + ["Human"] = {IntId.SlayerCreatureType, CreatureType.Human, true, {}}, + ["Elemental"] = {IntId.SlayerCreatureType, CreatureType.Elemental, false, {}}, + ["FireElemental"] = {IntId.SlayerCreatureType, CreatureType.FireElemental, false, {}}, + ["FrostElemental"] = {IntId.SlayerCreatureType, CreatureType.FrostElemental, false, {}}, + ["AcidElemental"] = {IntId.SlayerCreatureType, CreatureType.AcidElemental, false, {}}, + ["LightningElemental"] = {IntId.SlayerCreatureType, CreatureType.LightningElemental, false, {}}, + ["Shadow"] = {IntId.SlayerCreatureType, CreatureType.Shadow, true, {}}, + ["Virindi"] = {IntId.SlayerCreatureType, CreatureType.Virindi, true, {}}, + ["Anekshay"] = {IntId.SlayerCreatureType, CreatureType.Anekshay, true, {}}, + ["Burun"] = {IntId.SlayerCreatureType, CreatureType.Burun, false, {}}, + ["Mukkir"] = {IntId.SlayerCreatureType, CreatureType.Mukkir, true, {}}, + ["Skeleton"] = {IntId.SlayerCreatureType, CreatureType.Skeleton, true, {}}, + ["Undead"] = {IntId.SlayerCreatureType, CreatureType.Undead, true, {}}, + }, + ["Rending / Resistance Cleaving"] = { + ["Critical Strike"] = {IntId.ImbuedEffect, 1, true,{}}, + ["Crippling Blow"] = {IntId.ImbuedEffect, 2, true,{}}, + ["Armor Rending"] = {IntId.ImbuedEffect, 4, true,{},{CharacterType.WarMage,CharacterType.VoidMage}}, + ["Slash Rending"] = {IntId.ImbuedEffect, 8, true,{},{CharacterType.VoidMage}}, + ["Pierce Rending"] = {IntId.ImbuedEffect, 16, true,{},{CharacterType.VoidMage}}, + ["Bludgeon Rending"] = {IntId.ImbuedEffect, 32, true,{},{CharacterType.VoidMage}}, + ["Cold Rending"] = {IntId.ImbuedEffect, 128, true,{},{CharacterType.VoidMage}}, + ["Fire Rending"] = {IntId.ImbuedEffect, 512, true,{},{CharacterType.VoidMage}}, + ["Acid Rending"] = {IntId.ImbuedEffect, 64, true,{},{CharacterType.VoidMage}}, + ["Electric Rending"] = {IntId.ImbuedEffect, 256, true,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Slash "] = {IntId.ResistanceModifierType, 1, false,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Pierce"] = {IntId.ResistanceModifierType, 2, false,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Bludgeon"] = {IntId.ResistanceModifierType, 4, false,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Cold"] = {IntId.ResistanceModifierType, 8, false,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Fire"] = {IntId.ResistanceModifierType, 16, false,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Acid"] = {IntId.ResistanceModifierType, 32, false,{},{CharacterType.VoidMage}}, + ["Resistance Cleaving: Electric"] = {IntId.ResistanceModifierType, 64, false,{},{CharacterType.VoidMage}} + } +} + +-- Returns the Type of Character of the Player +local function GetCharacterType() + --- @type Character + local char = game.Character + if char == nil then return CharacterType.Unknown end + local weenie = char.Weenie + if weenie == nil then return CharacterType.Unknown end + if weenie.Skills[SkillId.VoidMagic].Training == SkillTrainingType.Specialized then return CharacterType.VoidMage end + if weenie.Skills[SkillId.WarMagic].Training == SkillTrainingType.Specialized then return CharacterType.WarMage end + if weenie.Skills[SkillId.WarMagic].Training == SkillTrainingType.Trained then return CharacterType.WarMage end + if weenie.Skills[SkillId.MissleWeapons].Training == SkillTrainingType.Specialized then return CharacterType.Archer end + if weenie.Skills[SkillId.HeavyWeapons].Training == SkillTrainingType.Specialized + or weenie.Skills[SkillId.LightWeapons].Training == SkillTrainingType.Specialized + or weenie.Skills[SkillId.FinesseWeapons].Training == SkillTrainingType.Specialized + or weenie.Skills[SkillId.TwoHandedCombat].Training == SkillTrainingType.Specialized then return CharacterType.Melee end + return CharacterType.Unknown +end + +-- Texture Caching +local function GetOrCreateTexture(iconID) + if iconID == nil then + iconID = 0x06005CE6 + end + local preloadedTexture = textures[iconID] + if not preloadedTexture then + local texture = ubviews.Huds.GetIconTexture(iconID) + if texture then + textures[iconID] = texture + return texture + end + else + return preloadedTexture + end +end + +-- Refresh and Populate Cantrips +local function RefreshCantrips() + characterTypeSelf = GetCharacterType() + for id, sk in pairs(game.Character.Weenie.Skills) do + local skillName = MapSkillCantripReplacements[id] + if skillName == nil then + skillName = tostring(id) + end + if sk.Training == SkillTrainingType.Specialized then + TabCantrips["Specialized Skills"][skillName] = {value = "N/A", color = Colors.White, icon = sk.Dat.IconId} + elseif sk.Training == SkillTrainingType.Trained then + TabCantrips["Trained Skills"][skillName] = {value = "N/A", color = Colors.White, icon = sk.Dat.IconId} + end + end + for ward, _ in pairs(TabCantrips["Protection Auras"]) do + TabCantrips["Protection Auras"][ward].value = "N/A" + end + for attr, _ in pairs(TabCantrips["Attributes"]) do + TabCantrips["Attributes"][attr].value = "N/A" + end + for _, e in ipairs(game.Character.ActiveEnchantments()) do + --- @type Enchantment + local ench = e + --- @type Spell + local spell = game.Character.SpellBook.Get(ench.SpellId) + if spell then + for type, _ in pairs(MapCantripColors) do + for ward, _ in pairs(TabCantrips["Protection Auras"]) do + local matchstring = type .. " " .. ward + if spell.Name == matchstring then + TabCantrips["Protection Auras"][ward].value = type + end + end + for skill, _ in pairs(TabCantrips["Specialized Skills"]) do + local matchstring = type .. skill + if string.find(spell.Name:gsub("%s+",""),matchstring) then + TabCantrips["Specialized Skills"][skill].value = type + end + end + for skill, _ in pairs(TabCantrips["Trained Skills"]) do + local matchstring = type .. skill + if string.find(spell.Name:gsub("%s+",""),matchstring) then + TabCantrips["Trained Skills"][skill].value = type + end + end + for attribute, _ in pairs(TabCantrips["Attributes"]) do + local matchstring = type .. attribute + if string.find(spell.Name:gsub("%s+",""),matchstring) then + TabCantrips["Attributes"][attribute].value = type + end + end + end + end + end +end + +-- Function Which Takes a WorldObject and Populates Weapons If It's a Tracked Weapon +---@param wobject WorldObject +local function CategorizeWeapon(wobject) + for _, types in pairs(TabWeapons) do + for _, values in pairs(types) do + local weaponIntIDCheck = values[1] + local weaponIntIDExpectedResult = values[2] + if weaponIntIDCheck == IntId.CreatureType then + weaponIntIDExpectedResult = MapCreatureType[weaponIntIDExpectedResult] + end + local weaponIntIDResult = wobject.IntValues[weaponIntIDCheck] + if weaponIntIDResult == weaponIntIDExpectedResult then + table.insert(values[4],wobject.Id) + end + end + end +end + +-- Takes an Inventory and Categorizes Weapons From It, Calling Appraisals if Needed +local function RefreshWeaponsFromInventory(inventory) + for _, v in ipairs(inventory) do + if v.ObjectClass == ObjectClass.MeleeWeapon + or v.ObjectClass == ObjectClass.MissileWeapon + or v.ObjectClass == ObjectClass.WandStaffOrb then + if v.HasAppraisalData then + CategorizeWeapon(v) + else + v.Appraise(nil,function (res) + CategorizeWeapon(game.World.Get(res.ObjectId)) + end) + end + end + end +end + +-- Refresh and Populate Weapons Using Above Function +local function RefreshWeapons() + characterTypeSelf = GetCharacterType() + for _, types in pairs(TabWeapons) do + for _, values in pairs(types) do + -- Reset Table That Holds Player Weapons + values[4] = {} + end + end + RefreshWeaponsFromInventory(game.Character.Equipment) + RefreshWeaponsFromInventory(game.Character.Inventory) +end + +-- Update Cached Data +local function UpdateCachedData() + CachedData.LuminanceFlagged = Quests:HasQuestFlag("oracleluminancerewardsaccess_1110") + CachedData.FactionBits = game.Character.Weenie.IntValues[IntId.Faction1Bits] + CachedData.SkillTrainingMagicItemTinkering = game.Character.Weenie.Skills[SkillId.MagicItemTinkering].Training + CachedData.SkillTrainingItemTinkering = game.Character.Weenie.Skills[SkillId.ItemTinkering].Training + CachedData.SkillTrainingWeaponTinkering = game.Character.Weenie.Skills[SkillId.WeaponTinkering].Training + CachedData.SkillTrainingArmorTinkering = game.Character.Weenie.Skills[SkillId.ArmorTinkering].Training + CachedData.InventoryCountAsheronsBenediction = game.Character.GetInventoryCount("Asheron's Lesser Benediction") + CachedData.AugInnateFamily = game.Character.Weenie.Value(IntId.AugmentationInnateFamily) + CachedData.AugResistanceFamily = game.Character.Weenie.Value(IntId.AugmentationResistanceFamily) + CachedData.LastUpdatedTime = os.clock() +end + +print("[LUA]: Loading FlagTracker v"..version) + +local hud = ubviews.Huds.CreateHud("FlagTracker v"..version,0x06005A8A) +hud.ShowInBar = true +hud.WindowSettings = im.ImGuiWindowFlags.AlwaysAutoResize + +hud.OnRender.Add(function() + local char = game.Character.Weenie + if char == nil then return end + if os.clock() - CachedData.LastUpdatedTime >= 3 then + UpdateCachedData() + end + if imgui.BeginTabBar("Flag Tracker Bar") then + + -- Augmentations Tab + if imgui.BeginTabItem("Augs") then + for category, augList in pairs(TabAugmentations) do + imgui.Separator() + imgui.SetNextItemOpen(TreeOpenStates[category] == nil or TreeOpenStates[category]) + TreeOpenStates[category] = imgui.TreeNode(category) + if TreeOpenStates[category] then + -- Create a new table for this category + local numColumns = 2 + if imgui.BeginTable("Augmentations_" .. category, numColumns * 2) then + imgui.TableSetupColumn("Aug 1", im.ImGuiTableColumnFlags.WidthStretch, 200) + imgui.TableSetupColumn("Aug 1 Points", im.ImGuiTableColumnFlags.WidthStretch, 35) + imgui.TableSetupColumn("Aug 2", im.ImGuiTableColumnFlags.WidthStretch, 200) + imgui.TableSetupColumn("Aug 2 Points", im.ImGuiTableColumnFlags.WidthStretch, 35) + + local currentColumnIndex = 0 + + for _, augInfo in ipairs(augList) do + local prefix = augInfo.name + local augID = augInfo.id + local cap = augInfo.repeatable + local npc = augInfo.trainer + local town = augInfo.location + local value = 0 + if augID == nil then + value = CachedData.InventoryCountAsheronsBenediction + else + value = char.Value(augID) + end + + local skip = (category == "Stat Augs" and CachedData.AugInnateFamily == 10 and value == 0) + or (category == "Resistance Augs" and CachedData.AugResistanceFamily == 2 and value == 0) + or (augID == IntId.AugmentationSpecializeMagicItemTinkering and CachedData.SkillTrainingMagicItemTinkering == SkillTrainingType.Untrained) + or (augID == IntId.AugmentationSpecializeWeaponTinkering and CachedData.SkillTrainingWeaponTinkering == SkillTrainingType.Untrained) + or (augID == IntId.AugmentationSpecializeArmorTinkering and CachedData.SkillTrainingArmorTinkering == SkillTrainingType.Untrained) + or (augID == IntId.AugmentationSpecializeItemTinkering and CachedData.SkillTrainingItemTinkering == SkillTrainingType.Untrained) + + if not skip then + local color = Colors.Yellow + if value >= cap then + color = Colors.Green + elseif value == 0 then + color = Colors.Red + end + + if currentColumnIndex == 0 then + imgui.TableNextRow() + end + + imgui.TableSetColumnIndex(currentColumnIndex) + imgui.TextColored(color, prefix) + + if imgui.IsItemHovered() and npc and town then + imgui.SetTooltip(string.format("NPC: %s\nTown: %s", npc, town)) + end + + if imgui.IsItemClicked() and npc then + local npcObject = game.World.GetNearest(npc, DistanceType.T3D) + if npcObject then + game.Actions.ObjectSelect(npcObject.Id) + end + end + + currentColumnIndex = (currentColumnIndex + 1) % (numColumns * 2) + imgui.TableSetColumnIndex(currentColumnIndex) + imgui.TextColored(color, value .. "/" .. cap) + currentColumnIndex = (currentColumnIndex + 1) % (numColumns * 2) + end + end + imgui.EndTable() + end + imgui.TreePop() + end + end + + imgui.EndTabItem() + end + + -- Luminance Auras Tab + if CachedData.LuminanceFlagged and imgui.BeginTabItem("Lum") then + for category, auraList in pairs(TabLuminanceAuras) do + imgui.SeparatorText(category) + if imgui.BeginTable("Luminance Auras_"..category, 2) then + imgui.TableSetupColumn("Lum Aura",im.ImGuiTableColumnFlags.WidthStretch,200) + imgui.TableSetupColumn("Lum Aura Points",im.ImGuiTableColumnFlags.WidthStretch,35) + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + local seerAuraCount = 0 + for _, auraInfo in ipairs(auraList) do + local value = char.Value(auraInfo[2]) or 0 + local prefix = auraInfo[1] + local cap = auraInfo[3] + local color = Colors.Yellow + local skip = false + + if value >= cap and category == "Nalicana Auras" then + value = cap + elseif category == "Seer Auras" and auraInfo[2] ~= IntId.LumAugSkilledSpec then + value = math.max(0,value-5) + end + + if category == "Seer Auras" then + local flag = string.lower(auraInfo[4]) + skip = not Quests:HasQuestFlag(flag) + end + + if not skip then + seerAuraCount = seerAuraCount + 1 + if value >= cap then + color = Colors.Green + elseif value == 0 then + color = Colors.Red + end + + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.TextColored(color, prefix) + imgui.TableSetColumnIndex(1) + imgui.TextColored(color, value .. "/" .. cap) + end + end + if seerAuraCount == 0 then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.TextColored(Colors.Red, "No Seer Auras") + end + imgui.EndTable() + end + end + imgui.EndTabItem() + end + + -- Recall Spells Tab + if imgui.BeginTabItem("Recalls") then + if imgui.BeginTable("Recall Spells",2) then + imgui.TableSetupColumn("Recall Spell",im.ImGuiTableColumnFlags.WidthStretch,128) + imgui.TableSetupColumn("Status",im.ImGuiTableColumnFlags.WidthStretch,32) + imgui.TableHeadersRow() + for _,recallInfo in ipairs(TabRecallSpells) do + local spellName = recallInfo[1] + local spellID = recallInfo[2] + local spellKnown = game.Character.SpellBook.IsKnown(spellID) + local color = Colors.Red + local status = "Unknown" + if spellKnown then + color = Colors.Green + status = "Known" + end + imgui.TableNextRow() + imgui.TableNextColumn() + imgui.Image(GetOrCreateTexture(game.Character.SpellBook.Get(spellID).Icon).TexturePtr,iconVectorSize) + imgui.SameLine() + imgui.TextColored(color,spellName) + imgui.TableNextColumn() + imgui.TextColored(color,status) + end + imgui.EndTable() + end + imgui.EndTabItem() + end + + -- Society Tab + if CachedData.FactionBits ~= nil + and CachedData.FactionBits ~= 0 + and imgui.BeginTabItem("Society") then + if imgui.Button("Refresh Quests") then + Quests:Refresh() + end + local factionbits = CachedData.FactionBits + local factionscore = 0 + local nextfactionrankscore = 0 + local society = "" + local societyrank = "" + local maxribbonsperday = 0 + -- Determine Which Society + if factionbits == 1 then + society = "Celestial Hand" + factionscore = char.IntValues[IntId.SocietyRankCelhan] + elseif factionbits == 2 then + society = "Edlrytch Web" + factionscore = char.IntValues[IntId.SocietyRankEldweb] + elseif factionbits == 4 then + society = "Radiant Blood" + factionscore = char.IntValues[IntId.SocietyRankRadblo] + end + -- Determine Society Rank + for isocietyrank, thresholds in pairs(MapSocietyRibbons) do + local lowerT = thresholds.min + local upperT = thresholds.max + if factionscore >= lowerT and factionscore <= upperT then + societyrank = isocietyrank + nextfactionrankscore = upperT + maxribbonsperday = thresholds.perday + end + end + imgui.SeparatorText(society.." - "..societyrank) + if imgui.BeginTable("SocietyInfo",2) then + imgui.TableSetupColumn("Label",im.ImGuiTableColumnFlags.WidthStretch,90) + imgui.TableSetupColumn("Value",im.ImGuiTableColumnFlags.WidthStretch,32) + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.Text("Ribbons for Next Rank") + imgui.TableSetColumnIndex(1) + local stringFactionScore + if nextfactionrankscore == 9999 then + stringFactionScore = "Max" + else + stringFactionScore = tostring(factionscore).."/"..tostring(nextfactionrankscore) + end + imgui.TextColored(Colors.Green,stringFactionScore) + ---@type Quest + local quest = Quests.Dictionary["societyribbonsperdaycounter"] + if quest then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.Text("Ribbons per Day (Counter)") + imgui.TableSetColumnIndex(1) + imgui.TextColored(Colors.Green,tostring(quest.solves).."/"..tostring(maxribbonsperday)) + end + ---@type Quest + local quest = Quests.Dictionary["societyribbonsperdaytimer"] + if quest then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.Text("Ribbons per Day (Timer)") + imgui.TableSetColumnIndex(1) + local questColor = Colors.Red + local questStatus = Quests:GetTimeUntilExpire(quest) + if questStatus == "Ready" then + questColor = Colors.Green + end + imgui.TextColored(questColor,questStatus) + end + ---@type Quest + local quest = Quests.Dictionary["societyarmorwritwait"] + if quest then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.Text("Society Armor Writ") + imgui.TableSetColumnIndex(1) + local questColor = Colors.Red + local questStatus = Quests:GetTimeUntilExpire(quest) + if questStatus == "Ready" then + questColor = Colors.Green + end + imgui.TextColored(questColor,questStatus) + end + ---@type Quest + local quest = Quests.Dictionary["societymasterstipendcollectiontimer"] + if quest then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.Text("Society Master Stipend") + imgui.TableSetColumnIndex(1) + local questColor = Colors.Red + local questStatus = Quests:GetTimeUntilExpire(quest) + if questStatus == "Ready" then + questColor = Colors.Green + end + imgui.TextColored(questColor,questStatus) + end + imgui.EndTable() + end + for isocietyrank, questList in pairs(TabSocietyQuests) do + local thresholds = MapSocietyRibbons[isocietyrank] + local lowerT = thresholds.min + if factionscore >= lowerT then + imgui.Separator() + if imgui.TreeNode(isocietyrank.." Quests") then + if imgui.BeginTable("SocietyInfo",2) then + imgui.TableSetupColumn("Quest1",im.ImGuiTableColumnFlags.WidthStretch,90) + imgui.TableSetupColumn("Status1",im.ImGuiTableColumnFlags.WidthStretch,32) + for socquest in questList do + local socquestName = socquest[1] + local socquestStart = string.lower(socquest[2]) + local socquestEnd = string.lower(socquest[3]) + local questType = socquest[4] + local questColor = Colors.Yellow + local questString = "Ready" + imgui.TableNextRow() + ---@type Quest + local questStart = Quests.Dictionary[socquestStart] + ---@type Quest + local questEnd = Quests.Dictionary[socquestEnd] + if questType == QuestType.QuestTag and Quests:IsQuestAvailable(socquestEnd) then + local tag = string.lower(socquest[5]) + ---@type Quest + local completeQuest = Quests.Dictionary[tag] + if completeQuest then + questColor = Colors.Green + questString = "Complete" + else + local startItem = socquest[6] + if game.Character.GetInventoryCount(startItem) > 0 then + questString = "Started" + end + end + elseif questType == QuestType.MultiQuestTag and Quests:IsQuestAvailable(socquestEnd) and Quests:HasQuestFlag(socquestStart) then + local tags = socquest[5] + local completeCount = 0 + for _, tag in pairs(tags) do + if Quests:HasQuestFlag(string.lower(tag)) then + completeCount = completeCount + 1 + end + end + if completeCount >= #tags then + questColor = Colors.Green + questString = "Complete ("..completeCount.."/"..#tags..")" + else + questString = "Started ("..completeCount.."/"..#tags..")" + end + elseif questType == QuestType.CollectItem and Quests:IsQuestAvailable(socquestEnd) then + local questItem = socquest[5] + local questItemCount = socquest[6] + local collectedCount = game.Character.GetInventoryCount(questItem) + questString = "Started ("..collectedCount..")" + if collectedCount >= questItemCount then + questColor = Colors.Green + questString = "Complete ("..collectedCount..")" + end + elseif questStart then + if questType == QuestType.KillTask then + questString = "Started ("..questStart.solves..")" + if questStart.solves == questStart.maxsolves then + questColor = Colors.Green + questString = "Complete ("..questStart.solves..")" + end + elseif questType == QuestType.Other then + questString = "Started" + elseif questType == QuestType.CollectItem then + local questItem = socquest[5] + local questItemCount = socquest[6] + local collectedCount = game.Character.GetInventoryCount(questItem) + questString = "Started ("..collectedCount..")" + if collectedCount >= questItemCount then + questColor = Colors.Green + questString = "Complete ("..collectedCount..")" + end + end + elseif questEnd then + questString = Quests:GetTimeUntilExpire(questEnd) + if questString == "Ready" then + questColor = Colors.Yellow + else + questColor = Colors.Red + end + end + imgui.TableSetColumnIndex(0) + imgui.TextColored(questColor,socquestName) + imgui.TableSetColumnIndex(1) + imgui.TextColored(questColor,questString) + end + imgui.EndTable() + end + imgui.TreePop() + end + end + end + imgui.EndTabItem() + end + + -- Fachub Tab + if Settings.showFacHub and imgui.BeginTabItem("FacHub") then + if imgui.Button("Refresh Quests") then + Quests:Refresh() + end + imgui.TextDisabled("[F] = Flagged / [X] = Completed / [U] = Unknown") + for minLevel, fhquests in pairs(TabFacilityHubQuests) do + --imgui.SeparatorText(minLevel.." Quests") + imgui.Separator() + if imgui.TreeNode(minLevel.." Quests") then + local columnIndex = 0 + if imgui.BeginTable(minLevel.." Quests",6) then + imgui.TableSetupColumn(minLevel.." Quest1",im.ImGuiTableColumnFlags.WidthStretch) + imgui.TableSetupColumn(minLevel.." Quest2",im.ImGuiTableColumnFlags.WidthStretch) + imgui.TableSetupColumn(minLevel.." Quest3",im.ImGuiTableColumnFlags.WidthStretch) + for _, fhquest in pairs(fhquests) do + local fhquestName = fhquest[1] + local fhquestCompleted = fhquest[2] + local fhquestStarted = fhquest[3] + if not fhquestStarted then + fhquestStarted = fhquestCompleted.."portal_flag" + end + if columnIndex == 0 then + imgui.TableNextRow() + end + local stringFHCompleted + local colorQuest + if Quests:HasQuestFlag(fhquestCompleted) then + stringFHCompleted = "X" + colorQuest = Colors.Green + elseif Quests:HasQuestFlag(fhquestStarted) then + stringFHCompleted = "F" + colorQuest = Colors.Yellow + else + stringFHCompleted = "U" + colorQuest = Colors.Red + end + imgui.TableSetColumnIndex(columnIndex) + imgui.TextColored(colorQuest,"["..stringFHCompleted.."] "..fhquestName) + columnIndex = columnIndex + 1 + if columnIndex >= 3 then + columnIndex = 0 + end + end + imgui.EndTable() + end + imgui.TreePop() + end + end + imgui.EndTabItem() + end + + -- Character Flags Tab + if imgui.BeginTabItem("Flags") then + if imgui.Button("Refresh Quests") then + Quests:Refresh() + end + for category, flagInfo in pairs(TabCharacterFlags) do + imgui.Separator() + imgui.SetNextItemOpen(TreeOpenStates[category] == nil or TreeOpenStates[category]) + TreeOpenStates[category] = imgui.TreeNode(category) + if TreeOpenStates[category] then + if imgui.BeginTable("Character Flags_"..category, 2) then + imgui.TableSetupColumn("Flag 1",im.ImGuiTableColumnFlags.WidthStretch,128) + imgui.TableSetupColumn("Flag 1 Points",im.ImGuiTableColumnFlags.WidthStretch,64) + for _, flag in ipairs(flagInfo) do + local prefix = flag[1] + local queststamp = flag[2] + local questinfotype = flag[3] + ---@type Quest + local quest = Quests.Dictionary[queststamp] + local color = Colors.Red + local completionString = "Unknown" + if questinfotype == QuestInfoType.SolveCount then + if quest ~= nil then + if quest.solves >= quest.maxsolves then + color = Colors.Green + elseif quest.solves == 0 then + color = Colors.Red + end + completionString = tostring(quest.solves) .. "/" .. tostring(quest.maxsolves) + else + color = Colors.Red + completionString = "None" + end + elseif questinfotype == QuestInfoType.StampCheck then + if Quests:HasQuestFlag(queststamp) then + color = Colors.Green + completionString = "Yes" + else + color = Colors.Red + completionString = "No" + end + elseif questinfotype == QuestInfoType.ReadyCheck then + if Quests:IsQuestAvailable(queststamp) then + color = Colors.Yellow + completionString = "Ready" + else completionString = Quests:GetTimeUntilExpire(quest) + end + end + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.TextColored(color, prefix) + imgui.TableSetColumnIndex(1) + imgui.TextColored(color, completionString) + end + imgui.EndTable() + end + imgui.TreePop() + end + end + imgui.EndTabItem() + end + + -- Cantrips Tab + if imgui.BeginTabItem("Cantrips") then + if imgui.Button("Refresh") then + RefreshCantrips() + end + for cantripgroup, cantrips in pairs(TabCantrips) do + imgui.Separator() + imgui.SetNextItemOpen(TreeOpenStates[cantripgroup] == nil or TreeOpenStates[cantripgroup]) + TreeOpenStates[cantripgroup] = imgui.TreeNode(cantripgroup) + if TreeOpenStates[cantripgroup] then + if imgui.BeginTable(cantripgroup,2) then + imgui.TableSetupColumn(cantripgroup,im.ImGuiTableColumnFlags.WidthStretch,64) + imgui.TableSetupColumn("Status",im.ImGuiTableColumnFlags.WidthStretch,32) + for effect, info in pairs(cantrips) do + if not (info.value == "N/A" and Settings.hideMissingCantrips) then + local iconID = info.icon + local iconBackgroundID = info.iconBackground + local spellIcon = info.spellIcon + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + if iconBackgroundID then + --- @type ManagedTexture + local icon = GetOrCreateTexture(iconBackgroundID) + if icon then + local pos = imgui.GetCursorScreenPos() + imgui.Image(icon.TexturePtr,iconVectorSize) + imgui.SetCursorScreenPos(pos) + end + end + if iconID then + --- @type ManagedTexture + local icon = GetOrCreateTexture(iconID) + if icon then + imgui.Image(icon.TexturePtr,iconVectorSize) + end + imgui.SameLine() + end + if spellIcon then + local spell = game.Character.SpellBook.Get(spellIcon.ToNumber()) + if spell then + --- @type ManagedTexture + local icon = GetOrCreateTexture(spell.Icon) + if icon then + imgui.Image(icon.TexturePtr,iconVectorSize) + end + imgui.SameLine() + end + end + imgui.TextColored(info.color, effect) + imgui.TableSetColumnIndex(1) + imgui.TextColored(MapCantripColors[info.value], info.value) + end + end + imgui.EndTable() + end + imgui.TreePop() + end + end + imgui.EndTabItem() + end + + -- Weapons Tab + if imgui.BeginTabItem("Weapons") then + if imgui.Button("Refresh") then + RefreshWeapons() + end + -- TODO: Merge Slayers / Resistance Cleaving + -- TODO: Color Weapons Based On Damage Type + for cat, types in pairs(TabWeapons) do + imgui.Separator() + imgui.SetNextItemOpen(TreeOpenStates[cat] == nil or TreeOpenStates[cat]) + TreeOpenStates[cat] = imgui.TreeNode(cat) + if TreeOpenStates[cat] then + if imgui.BeginTable(cat,2) then + imgui.TableSetupColumn(cat,im.ImGuiTableColumnFlags.WidthStretch,16) + imgui.TableSetupColumn("Weapon Name",im.ImGuiTableColumnFlags.WidthStretch,32) + -- TODO: Do We Need Separate Tracking For Slayers Which Are Non-Essential (Rares/Etc?) + for type, values in pairs(types) do + local essential = values[3] + local myWeapons = values[4] + local skipCharacterTypes = values[5] + local skip = ((cat == "Rending / Resistance Cleaving") and (not essential) and Settings.hideResistanceCleavingWeapons) + or ((cat == "Creature Slayer") and (not essential) and Settings.hideNonEssentialCreatureSlayers) + if skipCharacterTypes then + for _, ctype in ipairs(skipCharacterTypes) do + if characterTypeSelf == ctype then + skip = true + end + end + end + if not skip then + if #myWeapons > 0 then + for _, weaponID in ipairs(myWeapons) do + --- @type WorldObject + local weapon = game.World.Get(weaponID) + if weapon then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.TextColored(Colors.Green,type) + imgui.TableSetColumnIndex(1) + local pos = imgui.GetCursorScreenPos() + local icon = GetOrCreateTexture(weapon.DataValues[DataId.Icon]) + local iconUnderlayID = weapon.DataValues[DataId.IconUnderlay] + if not iconUnderlayID then + iconUnderlayID = 0x060011CB + end + local iconUnderlayTexture = GetOrCreateTexture(iconUnderlayID) + local iconOverlay = GetOrCreateTexture(weapon.DataValues[DataId.IconOverlay]) + imgui.Image(iconUnderlayTexture.TexturePtr,iconVectorSize) + imgui.SetCursorScreenPos(pos) + imgui.Image(icon.TexturePtr,iconVectorSize) + imgui.SetCursorScreenPos(pos) + imgui.Image(iconOverlay.TexturePtr,iconVectorSize) + if imgui.IsItemClicked() then + game.Actions.ObjectSelect(weapon.Id) + end + imgui.SameLine() + imgui.TextColored(Colors.Green,weapon.Name) + if imgui.IsItemClicked() then + game.Actions.ObjectSelect(weapon.Id) + end + end + end + elseif not Settings.hideUnacquiredWeapons then + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.TextColored(Colors.White,type) + imgui.TableSetColumnIndex(1) + imgui.TextColored(Colors.LightGray,"No Weapon Found") + end + end + end + imgui.EndTable() + end + imgui.TreePop() + end + end + imgui.EndTabItem() + end + + -- General Quests Tab + if Settings.showQuests and imgui.BeginTabItem("Quests") then + if imgui.Button("Refresh Quests") then + Quests:Refresh() + end + -- Quests Table + if imgui.BeginTable("Quests", 6, im.ImGuiTableFlags.ScrollY + im.ImGuiTableFlags.Sortable) then + imgui.TableSetupColumn("Quest", im.ImGuiTableColumnFlags.WidthFixed, 256) + imgui.TableSetupColumn("Solves", im.ImGuiTableColumnFlags.WidthFixed, 64) + imgui.TableSetupColumn("Completed", im.ImGuiTableColumnFlags.WidthFixed, 128) + imgui.TableSetupColumn("Max", im.ImGuiTableColumnFlags.WidthFixed, 64) + imgui.TableSetupColumn("Delta", im.ImGuiTableColumnFlags.WidthFixed, 64) + imgui.TableSetupColumn("Expire", im.ImGuiTableColumnFlags.WidthFixed, 128) + imgui.TableSetupScrollFreeze(0, 1) + imgui.TableHeadersRow() + + -- Handle sorting + local sort_specs = imgui.TableGetSortSpecs() + if sort_specs and sort_specs.SpecsDirty then + table.sort(Quests.List,function(a,b) + local sortcol = sort_specs.Specs.ColumnIndex + 1 + local sortasc = sort_specs.Specs.SortDirection == im.ImGuiSortDirection.Ascending + if a and b then + local valA = Quests:GetFieldByID(a,sortcol) + local valB = Quests:GetFieldByID(b,sortcol) + if valA and valB then + if tonumber(valA) and tonumber(valB) then + ---@diagnostic disable-next-line + valA = tonumber(valA) + ---@diagnostic disable-next-line + valB = tonumber(valB) + end + if sortasc then + return valA < valB + else + return valB < valA + end + end + return true + end + return true + end) + sort_specs.SpecsDirty = false -- Mark as sorted + end + + -- Populate table + for _, quest in ipairs(Quests.List) do + local color = Colors.Red + if Quests:IsQuestMaxSolved(quest.id) then + color = Colors.Yellow + elseif Quests:IsQuestAvailable(quest.id) then + color = Colors.Green + end + imgui.TableNextRow() + imgui.TableSetColumnIndex(0) + imgui.TextColored(color, quest.id) -- Quest Name + if imgui.IsItemHovered() and Quests.Description then + imgui.SetTooltip(Quests.Description) + end + imgui.TableSetColumnIndex(1) + imgui.TextColored(color, quest.solves) -- Solves + imgui.TableSetColumnIndex(2) + imgui.TextColored(color, Quests:FormatTimeStamp(quest.timestamp)) -- Timestamp + imgui.TableSetColumnIndex(3) + imgui.TextColored(color, quest.maxsolves) -- MaxSolves + imgui.TableSetColumnIndex(4) + imgui.TextColored(color, quest.delta) -- Delta + imgui.TableSetColumnIndex(5) + imgui.TextColored(color, Quests:GetTimeUntilExpire(quest)) -- Expired + end + + imgui.EndTable() + end + imgui.EndTabItem() + end + + -- Settings Tab + if imgui.BeginTabItem("Settings") then + imgui.SeparatorText("Tab Visibility") + if imgui.Checkbox("Show Fac Hub",Settings.showFacHub) then + Settings.showFacHub = not Settings.showFacHub + end + if imgui.Checkbox("Show Quests",Settings.showQuests) then + Settings.showQuests = not Settings.showQuests + end + if imgui.Checkbox("Hide Unacquired Weapons",Settings.hideUnacquiredWeapons) then + Settings.hideUnacquiredWeapons = not Settings.hideUnacquiredWeapons + end + if imgui.Checkbox("Hide Resistance Cleaving Weapons",Settings.hideResistanceCleavingWeapons) then + Settings.hideResistanceCleavingWeapons = not Settings.hideResistanceCleavingWeapons + end + if imgui.Checkbox("Hide Non-Essential Slayer Weapons",Settings.hideNonEssentialCreatureSlayers) then + Settings.hideNonEssentialCreatureSlayers = not Settings.hideNonEssentialCreatureSlayers + end + if imgui.Checkbox("Hide Missing Cantrips",Settings.hideMissingCantrips) then + Settings.hideMissingCantrips = not Settings.hideMissingCantrips + end + imgui.EndTabItem() + end + + imgui.EndTabBar() + end + + if currentHUDPosition == nil then + imgui.SetWindowPos(defaultHUDposition) + currentHUDPosition = imgui.GetWindowPos() + end +end) + +hud.Visible = true + +Quests:Refresh() +RefreshCantrips() +RefreshWeapons() \ No newline at end of file diff --git a/flagtracker/quests.lua b/flagtracker/quests.lua new file mode 100644 index 0000000..24b2ad4 --- /dev/null +++ b/flagtracker/quests.lua @@ -0,0 +1,110 @@ +local libQuest = { + List = {}, + Dictionary = {} +} + +---@class Quest: Object +---@field id number +---@field solves number +---@field timestamp number +---@field description string +---@field maxsolves number +---@field delta number +---@field expiretime number + +local function OnChatText(evt) + local taskname, solves, timestamp, description, maxsolves, delta = string.match(evt.Message, "([%w%s%(%)-]+) %- (%d+) solves %((%d+)%)\"([^\"]+)\" (%-?%d+) (%d+)") + if taskname and solves and timestamp and description and maxsolves and delta then + table.insert(libQuest.List, {id=taskname,solves=solves,timestamp=timestamp,description=description,maxsolves=maxsolves,delta=delta,expiretime=timestamp+delta}) + libQuest.Dictionary[taskname] = {id=taskname,solves=solves,timestamp=timestamp,description=description,maxsolves=maxsolves,delta=delta,expiretime=timestamp+delta} + end +end + +function libQuest:Clear() + self.List = {} + self.Dictionary = {} +end + +function libQuest:Refresh() + self:Clear() + game.OnTick.Once(function (evt) + game.World.OnChatText.Add(OnChatText) + sleep(100) + game.Actions.InvokeChat("/myquests") + sleep(3000) + game.World.OnChatText.Remove(OnChatText) + end) +end + +function libQuest:IsQuestAvailable(queststamp) + local quest = self.Dictionary[queststamp] + if quest == nil then return true end + return quest.expiretime < os.time() +end + +function libQuest:IsQuestMaxSolved(queststamp) + local quest = self.Dictionary[queststamp] + if quest == nil then return false end + if tonumber(quest.maxsolves) == tonumber(quest.solves) then return true end + return false +end + +function libQuest:HasQuestFlag(queststamp) + local quest = self.Dictionary[queststamp] + return quest ~= nil +end + +function libQuest:GetFieldByID(quest, id) + local fields = { + quest.id, + quest.solves, + quest.timestamp, + quest.maxsolves, + quest.delta, + quest.expiretime + } + return fields[id] or quest.id +end + +function libQuest:FormatTimeStamp(time) + return tostring(os.date("%m/%d/%Y %H:%M:%S", time)) +end + +function libQuest:FormatSeconds(seconds) + if seconds <= 0 then + return "0s" + end + local days = math.floor(seconds / 86400) + seconds = seconds % 86400 + local hours = math.floor(seconds / 3600) + seconds = seconds % 3600 + local minutes = math.floor(seconds / 60) + seconds = math.floor(seconds % 60) + + local result = "" + if days > 0 then + result = result .. days .. "d " + end + if hours > 0 then + result = result .. hours .. "h " + end + if minutes > 0 then + result = result .. minutes .. "m " + end + if seconds > 0 or result == "" then + result = result .. seconds .. "s" + end + + return result:match("^%s*(.-)%s*$") -- Trim any trailing space +end + +function libQuest:GetTimeUntilExpire(quest) + if quest == nil then return "Unknown" end + local expireTime = self:FormatSeconds(quest.expiretime - os.time()) + if expireTime == "0s" then + return "Ready" + end + return expireTime +end + +return libQuest \ No newline at end of file diff --git a/highres_colorCorrect.png b/highres_colorCorrect.png new file mode 100644 index 0000000..a349505 Binary files /dev/null and b/highres_colorCorrect.png differ