Tank Game Server Project

A multiplayer tank game server implementation using ProudNet networking library, providing both C# and C++ versions with cross-platform support.

📋 Table of Contents

Prerequisites
Project Structure
Development Notes
Getting Started
1. C# Server Implementation
2. C# Client Implementation
3. C++ Server Implementation (Optional)
4. Multiplayer Movement Testing
5. Fire and Messaging Testing
Troubleshooting

Prerequisites

Before building this project, you must have the ProudNet folder installed at the same level as the tank_server project folder.

Required Directory Structure

project_root/
├── tank_server/          # This project
│   ├── Common/
│   ├── Server/
│   ├── Client/
│   └── Server_CPP/
└── ProudNet/            # Required: Files from ProudNet installation
    ├── doc/             # ProudNet documentation
    ├── include/         # ProudNet header files
    ├── lib/             # ProudNet library files
    ├── Sample/          # ProudNet sample projects
    └── util/            # ProudNet utilities

ProudNet Installation

Download and install ProudNet from the official website
Ensure the ProudNet folder contains the following subdirectories:
- doc/ - Documentation files
- include/ - Header files for C++ development
- lib/ - Library files for both .NET and C++
- Sample/ - Example projects
- util/ - Utility tools and license authentication

Project Structure

📁 Common

Contains shared resources used by both server and client implementations.

Contents:

PIDL files - Protocol Interface Definition Language files that define RMI (Remote Method Invocation) functions
Batch files - Scripts for compiling PIDL files into C# and C++ stub/proxy classes
Vars.cs/Vars.h - Shared configuration variables (server port, protocol version, etc.)

Key Files:

Tank.PIDL - Tank game protocol definitions
CompilePIDL_cs.bat - PIDL compilation script (C#)
CompilePIDL_cpp.bat - PIDL compilation script (C++)
Vars.cs - C# configuration
Vars.h - C++ configuration

🖥️ Server

C# implementation of the tank game server.

Features:

Real-time multiplayer tank game server
Tank movement, firing, and health management
Player connection/disconnection handling
P2P group management for efficient networking
Server console commands (damage, heal, respawn, status)
Windows/.NET compatible

Key Files:

TankServer.cs - Main server implementation
TankServer.csproj - .NET project file
build.bat - Build script with DLL copying

🎮 Client

C# console-based client for the tank game.

Features:

Console interface for tank game client
Tank movement and firing controls
Real-time communication with server
P2P messaging support
Windows/.NET compatible

Key Files:

TankClient.cs - Main client implementation
TankClient.csproj - .NET project file
build.bat - Build script with DLL copying

🐧 Server_CPP

C++ implementation of the tank game server with Linux support.

Features:

Cross-platform tank game server (Windows/Linux)
Docker containerization support
CMake build system
Same game logic as C# version
Linux production deployment ready

Key Files:

src/TankServer.cpp - Main C++ server implementation
CMakeLists.txt - CMake configuration
Dockerfile - Docker container configuration
docker-compose.yml - Docker Compose setup
run.bat - Windows execution script

Build Options:

Windows: Visual Studio with CMake
Linux: GCC with CMake
Docker: Containerized deployment

Development Notes

C# version requires .NET 9.0
C++ version requires C++17 standard
Both versions share the same protocol definitions via PIDL files
Docker deployment supports automatic ProudNet library detection and copying

Getting Started

Prerequisites

Copy ProudNet files from your ProudNet installation location to create a ProudNet/ directory at the same level as tank_server/
Verify that ProudNet/util/PIDL.exe exists for protocol compilation

1. C# Server Implementation

Step 1: Understanding the Protocol Definition (Tank.PIDL)

The Tank.PIDL file defines the communication protocol between server and client:

// Tank.PIDL - Protocol Interface Definition Language
global Tank 2000 // Client-Server and Server-Client RMI, first message ID = 2000
{
    // Client to Server functions
    SendMove([in] float posX, [in] float posY, [in] float direction);
    SendFire([in] int shooterId, [in] float direction, [in] float launchForce, ...);
    SendTankType([in] int tankType);
    
    // Server to Client functions  
    OnPlayerJoined([in] int clientId, [in] float posX, [in] float posY, [in] int tankType);
    OnTankPositionUpdated([in] int clientId, [in] float posX, [in] float posY, [in] float direction);
    OnSpawnBullet([in] int clientId, [in] int shooterId, ...);
    // ... more RMI functions
}

This PIDL file defines:

RMI functions sent from Client to Server (SendMove, SendFire, etc.)
RMI functions sent from Server to Client (OnPlayerJoined, OnTankPositionUpdated, etc.)
P2P messaging for direct client communication

Step 2: Generate C# Stub and Proxy Classes

Run the PIDL compiler to generate C# networking code:

cd tank_server/Common
CompilePIDL_cs.bat

Expected Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Common [master +5 ~14 -15 !]> .\CompilePIDL_cs.bat 
PIDL compile complete!
Press any key to continue . . .

This script will:

Execute ProudNet/util/PIDL.exe -cs Tank.PIDL -outdir ../Server
Execute ProudNet/util/PIDL.exe -cs Tank.PIDL -outdir ../Client
Generate files in both Server and Client directories:
- Tank_stub.cs - Handles incoming RMI calls
- Tank_proxy.cs - Sends outgoing RMI calls
- Tank_common.cs - Common definitions and constants

Step 3: Build the Server

Navigate to the Server directory and build:

cd tank_server/Server
build.bat

Expected Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server [master +15 ~13 -15 !]> ./build.bat
========================================
Tank Server Build Script
========================================
Build configuration: Debug
Building Tank Server...
Restore complete (0.2s)
  TankServer succeeded (1.8s) → bin\Debug\net9.0\TankServer.dll

Build succeeded in 2.3s
Build completed successfully!
Using build output path: bin\Debug\net9.0
Build output directory exists: bin\Debug\net9.0
ProudNet DotNet directory exists: ..\..\ProudNet\lib\DotNet
ProudNet x64 directory exists: ..\..\ProudNet\lib\DotNet\x64
========================================
Copying ProudNet DLLs...
========================================
Copying libcrypto-3-x64.dll...
        1 file(s) copied.
Copying libssl-3-x64.dll...
        1 file(s) copied.
Copying ProudDotNetClient.dll...
        1 file(s) copied.
Copying ProudDotNetClient.pdb...
        1 file(s) copied.
Copying ProudDotNetServer.dll...
        1 file(s) copied.
Copying ProudDotNetServer.pdb...
        1 file(s) copied.
Copying ProudNetClient.dll...
        1 file(s) copied.
Copying ProudNetClientPlugin.dll...
        1 file(s) copied.
Copying ProudNetServer.dll...
        1 file(s) copied.
Copying ProudNetServerPlugin.dll...
        1 file(s) copied.
Copying ProudNetServerPlugin.pdb...
        1 file(s) copied.
========================================
Build and DLL copy completed!
========================================

Output directory: bin\Debug\net9.0
You can now run the Tank Server executable.

Press any key to continue . . .

The build script will:

Compile the C# project using dotnet build --configuration Debug
Copy required ProudNet DLLs to the output directory:
- ProudDotNetServer.dll, ProudDotNetClient.dll
- ProudNetServer.dll, ProudNetServerPlugin.dll
- libcrypto-3-x64.dll, libssl-3-x64.dll

Step 4: Run the Server

cd tank_server/Server/bin/Debug/net9.0
TankServer.exe

Expected Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server [master +5 ~14 -15 !]> .\bin\Debug\net9.0\TankServer.exe      
Tank Server started on port 33334
Server is running. Commands:
status: Show connected clients
health [id]: Show tank health (all or specific ID)
damage id amount: Apply damage to a tank
heal id amount: Heal a tank
respawn id x y: Respawn a tank at position (x,y)
q: Quit server
Client 3 connected
New tank created for client 3 with tank type -1 and health 100/100
Not enough clients to create P2P group (need at least 2)

The server will:

Start listening on port 33334
Display connection status and game events
Accept commands: status, health, damage, heal, respawn, q (quit)

2. C# Client Implementation

Step 1: Shared Protocol Understanding

The client uses the same Tank.PIDL file as the server, ensuring perfect protocol compatibility:

Same RMI definitions: Both server and client understand identical function signatures
Shared stub/proxy classes: The CompilePIDL_cs.bat script generates identical networking code for both projects
Protocol synchronization: Any changes to Tank.PIDL automatically update both server and client when recompiled

This approach guarantees that:

Server and client always use compatible network protocols
RMI function calls are type-safe and validated at compile time
Network message format is consistent between both applications

Step 2: Build the Client

Navigate to the Client directory and build:

cd tank_server/Client  
build.bat

Expected Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Client [master +5 ~14 -15 !]> .\build.bat
========================================
Tank Client Build Script
========================================
Build configuration: Debug
Building Tank Client...
Restore complete (0.3s)
  TankClient succeeded (0.2s) → bin\Debug\net9.0\TankClient.dll

Build succeeded in 0.8s
Build completed successfully!
Using build output path: bin\Debug\net9.0
Build output directory exists: bin\Debug\net9.0
ProudNet DotNet directory exists: ..\..\ProudNet\lib\DotNet
ProudNet x64 directory exists: ..\..\ProudNet\lib\DotNet\x64
========================================
Copying ProudNet DLLs...
========================================
Copying libcrypto-3-x64.dll...
        1 file(s) copied.
Copying libssl-3-x64.dll...
        1 file(s) copied.
Copying ProudDotNetClient.dll...
        1 file(s) copied.
Copying ProudDotNetClient.pdb...
        1 file(s) copied.
Copying ProudDotNetServer.dll...
        1 file(s) copied.
Copying ProudNetClient.dll...
        1 file(s) copied.
Copying ProudNetClientPlugin.dll...
        1 file(s) copied.
Copying ProudNetServer.dll...
        1 file(s) copied.
========================================
Build and DLL copy completed!
========================================

Output directory: bin\Debug\net9.0
You can now run the Tank Client executable.

Press any key to continue . . .

The client build script performs the same operations as the server:

Compiles the C# project using dotnet build --configuration Debug
Copies the same ProudNet DLLs to ensure runtime compatibility
Uses the generated stub/proxy classes from the PIDL compilation

Step 3: Run the Client

cd tank_server/Client/bin/Debug/net9.0
TankClient.exe

Expected Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Client [master +6 ~14 -15 !]> .\bin\Debug\net9.0\TankClient.exe
Connecting to server...
Commands:
move x y dir : Move tank to position (x,y) with direction dir
fire dir [force] : Fire in direction dir with optional force (default 25.0)
tank n       : Select tank type (0-3)
health h [max]: Update tank health to h with optional max health
destroy [id] : Send tank destroyed event (id of destroyer, default 0 = environment)
spawn x y dir type health: Spawn/respawn tank
msg text     : Send P2P message to other clients
history      : Show message history
status       : Show P2P connection status
auto         : Toggle auto movement
q            : Quit
Connected to server. My ID: 3

🔍 Check Server Connection:

When the client successfully connects, you should also see a connection message on the server console:

Server Console Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server [master +5 ~14 -15 !]> .\bin\Debug\net9.0\TankServer.exe
Tank Server started on port 33334
Server is running. Commands:
status: Show connected clients
health [id]: Show tank health (all or specific ID)
damage id amount: Apply damage to a tank
heal id amount: Heal a tank
respawn id x y: Respawn a tank at position (x,y)
q: Quit server
Client 3 connected
New tank created for client 3 with tank type -1 and health 100/100
Not enough clients to create P2P group (need at least 2)

📝 Server Log Explanation:

Client 3 connected - A new client has successfully connected and been assigned ID 3
New tank created for client 3 with tank type -1 and health 100/100 - Server creates a tank object for the new client:
- Tank type -1 means no tank type selected yet
- Initial health is set to 100/100 (current/maximum)
Not enough clients to create P2P group (need at least 2) - P2P group creation requires at least 2 clients for peer-to-peer communication

💡 To test P2P functionality:

Run a second client in another terminal to see:

Second Client Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Client [master +5 ~14 -15 !]> .\bin\Debug\net9.0\TankClient.exe          
Connecting to server...                                                                                                                                                                                                                             
Commands:                                                                                                                                                                                                                                           
move x y dir : Move tank to position (x,y) with direction dir                                                                                                                                                                                       
fire dir [force] : Fire in direction dir with optional force (default 25.0)
tank n       : Select tank type (0-3)
health h [max]: Update tank health to h with optional max health
destroy [id] : Send tank destroyed event (id of destroyer, default 0 = environment)
spawn x y dir type health: Spawn/respawn tank
msg text     : Send P2P message to other clients
history      : Show message history
status       : Show P2P connection status
auto         : Toggle auto movement
q            : Quit
Connected to server. My ID: 4
P2P: Member 4 joined group 5
P2P: Member 3 joined group 5
P2P: Added member 3 to group member list
OnPlayerJoined: Tank 3 joined at (12.939716,28.795837) with tank type -1
OnTankHealthUpdated: Tank 3 health: 100/100
P2P: Received group info, Group ID: 5

Updated Server Console Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server [master +5 ~14 -15 !]> .\bin\Debug\net9.0\TankServer.exe
Tank Server started on port 33334
Server is running. Commands:
status: Show connected clients
health [id]: Show tank health (all or specific ID)
damage id amount: Apply damage to a tank
heal id amount: Heal a tank
respawn id x y: Respawn a tank at position (x,y)
q: Quit server
Client 3 connected
New tank created for client 3 with tank type -1 and health 100/100
Not enough clients to create P2P group (need at least 2)
Client 4 connected
New tank created for client 4 with tank type -1 and health 100/100
Sending existing player info to new client: ID=3, Type=-1, Health=100/100
Notifying existing client 3 about new player: ID=4, Type=-1, Health=100/100
P2P group created with 2 members, Group ID: 5
Sent P2P group info to client 3: P2P_GROUP_INFO:5
Sent P2P group info to client 4: P2P_GROUP_INFO:5

📝 Multi-Client Connection Analysis:

When the second client connects:

Client 4 connects - Server assigns new ID and creates tank object
Player synchronization - Server exchanges player information:
- Sends existing player info (Client 3) to the new client (Client 4)
- Notifies existing client (Client 3) about the new player (Client 4)
P2P group creation - Now that there are 2+ clients:
- Server creates P2P group with ID 5
- Both clients receive P2P group information
- Clients can now communicate directly via P2P messaging

Client-side P2P events:

P2P: Member X joined group Y - P2P group membership notifications
OnPlayerJoined: Tank 3 joined at (x,y) - Receives info about existing players
OnTankHealthUpdated: Tank 3 health: 100/100 - Receives health status of other tanks
P2P: Received group info, Group ID: 5 - Confirms P2P group setup

🎮 Now you can test multiplayer features:

Use msg hello in one client to send P2P messages to others
Use move x y dir to see position updates across clients
Use fire dir to test projectile synchronization

3. C++ Server Implementation (Optional)

The C++ server implementation provides the exact same functionality as the C# server, offering cross-platform support and containerized deployment options. This is an optional advanced implementation that demonstrates ProudNet's multi-language capabilities.

Protocol Compatibility

Since both C# and C++ servers use the same Tank.PIDL file, they are fully compatible:

Same RMI functions: Identical network protocol definitions
Client compatibility: C# clients can connect to either C# or C++ servers seamlessly
Feature parity: Movement, firing, P2P messaging, and all game mechanics work identically

Key Advantages of C++ Implementation

Cross-platform support: Runs on Windows, Linux, and containerized environments
Performance optimization: Native C++ performance for high-load scenarios
Production deployment: Docker containerization for scalable server infrastructure
Linux compatibility: Deploy on Ubuntu/Linux servers without .NET dependencies

Step 1: Generate C++ Stub and Proxy Classes

First, generate the C++ networking code from the PIDL file:

cd tank_server/Common
CompilePIDL_cpp.bat

Expected Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Common [master +5 ~14 -15 !]> .\CompilePIDL_cpp.bat
[INFO] Generating C++ files from Tank.PIDL...
[INFO] PIDL C++ compilation complete!
[INFO] Generated files in ..\Server_CPP\include directory.
Press any key to continue . . .

This will generate C++ stub/proxy classes in the Server_CPP/include/ directory:

Tank_stub.cpp/.h - Handles incoming RMI calls
Tank_proxy.cpp/.h - Sends outgoing RMI calls
Tank_common.cpp/.h - Common definitions and constants

Step 2: Build the C++ Server (Windows)

Prerequisites for Windows Build

Before building the C++ server, ensure you have the following components installed:

Required Software:

Visual Studio 2022 (Community/Professional/Enterprise)
- Also supports VS 2019, 2017, 2015
CMake 3.10 or higher
Windows SDK 10.0 (latest version recommended)

Required Visual Studio Components:

When installing Visual Studio, make sure to include these workloads and components:

Desktop development with C++ workload
MSVC v143 - VS 2022 C++ x64/x86 build tools (latest)
Windows 11 SDK (or Windows 10 SDK)
ATL for v143 build tools (x86 & x64) - Required for ProudNet linking
CMake tools for C++
Git for Windows (optional, for version control)

Important Note about ATL:

The Active Template Library (ATL) is essential for ProudNet linking on Windows. In CMakeLists.txt, you can see it's explicitly linked:

target_link_libraries(TankGameServer
    # ... other libraries ...
    atls       # ATL library addition
)

Build Process

Navigate to the Server_CPP directory and build using the provided script:

cd tank_server/Server_CPP
build.bat

Expected Build Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server_CPP [master +5 ~14 -15 !]> .\build.bat
[INFO] =========================================
[INFO] Starting TankGameServer C++ Build...
[INFO] =========================================
[INFO] Detecting Visual Studio installation...
[INFO] Visual Studio 2022 Community found
[INFO] Setting up VS2022 environment...
**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.14.0
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
[vcvarsall.bat] Environment initialized for: 'x64'
[INFO] Using Visual Studio 2022 with generator: NMake Makefiles
[INFO] ProudNet Path: C:\Users\wayne\Documents\proud_tank\ProudNet
[INFO] Build Type: Release
[INFO] Using: Visual Studio 2022 with NMake Makefiles
[INFO] Checking and generating PIDL files...
[INFO] Compiling PIDL files...
[INFO] Generating C++ files from Tank.PIDL...
[INFO] PIDL C++ compilation complete
[INFO] Generated files in ..\Server_CPP\include directory.
Press any key to continue . . .
[INFO] Creating build directory...
[INFO] Removing existing build directory...
[INFO] Configuring CMake...
[INFO] Using NMake Makefiles generator
-- The C compiler identification is MSVC 19.44.35207.1
-- The CXX compiler identification is MSVC 19.44.35207.1
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working C compiler: C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/bin/Hostx64/x64/cl.exe - skipped
-- Detecting C compile features
-- Detecting C compile features - done
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/MSVC/14.44.35207/bin/Hostx64/x64/cl.exe - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Building on Windows - Using OpenSSL and CURL from ProudNet
-- System check: Windows
-- Current working directory: C:/Users/wayne/Documents/proud_tank/tank_server/Server_CPP
-- Build type: Release
-- ProudNet Path: C:\Users\wayne\Documents\proud_tank\ProudNet
-- Operating System: Windows
-- Using Visual Studio version from command line: 2022
-- Found Visual Studio installation: C:/Program Files/Microsoft Visual Studio/2022/Community
-- Visual Studio Path: C:/Program Files/Microsoft Visual Studio/2022/Community
-- Using Release Library Path: C:\Users\wayne\Documents\proud_tank\ProudNet/lib/x64/v140/Release
-- Configuring done
-- Generating done
-- Build files have been written to: C:/Users/wayne/Documents/proud_tank/tank_server/Server_CPP/build
[INFO] Building project...
[ 33%] Building CXX object CMakeFiles/TankGameServer.dir/src/TankServer.cpp.obj
TankServer.cpp
[ 66%] Building CXX object CMakeFiles/TankGameServer.dir/C_/Users/wayne/Documents/proud_tank/tank_server/Common/Vars.cpp.obj
Vars.cpp
[100%] Linking CXX executable TankServer.exe
[100%] Built target TankGameServer
[INFO] Build successful
[INFO] Executable: C:\Users\wayne\Documents\proud_tank\tank_server\Server_CPP\build\Release\TankGameServer.exe
[INFO] Copying required DLL files...
[INFO] =========================================
[INFO] Build completed
[INFO] Executable: C:\Users\wayne\Documents\proud_tank\tank_server\Server_CPP\build\TankServer.exe
[INFO] =========================================
Press any key to continue . . .

Build Process Analysis:

Visual Studio Detection: Automatically detects VS 2022 Community installation
Environment Setup: Initializes VS 2022 Developer Command Prompt with x64 tools
PIDL Compilation: Automatically generates C++ stub/proxy classes
CMake Configuration: Uses NMake Makefiles generator for MSVC compiler
Compilation: Builds TankServer.cpp and Vars.cpp with C++17 standard
Linking: Links with ProudNet libraries, Windows system libraries, and ATL
DLL Copying: Copies required ProudNet DLLs to executable directory

The build script will:

Detect Visual Studio installation automatically (2015-2022)
Set up build environment with vcvarsall.bat
Generate PIDL files automatically before CMake configuration
Create build directory and configure CMake with NMake Makefiles
Compile C++ source files with MSVC compiler
Link with ProudNet libraries and Windows system libraries:
- ProudNetServer.lib, ProudNetClient.lib
- ws2_32 (Windows Sockets), winmm (Multimedia), iphlpapi (IP Helper)
- atls (Active Template Library)
Copy required ProudNet DLLs to output directory

Step 3: Run the C++ Server (Windows)

cd tank_server/Server_CPP
run.bat

Expected Server Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server_CPP [master +5 ~14 -15 !]> .\run.bat
[INFO] Starting TankGameServer C++ Server...
[INFO] Found executable at build\TankServer.exe (NMake build
[INFO] Server is starting. Press 'q' to quit.
[INFO] Running: C:\Users\wayne\Documents\proud_tank\tank_server\Server_CPP\build\TankServer.exe
========== Tank Server Started ==========
TCP Server listening on 0.0.0.0:33334
WebSocket Server listening on 0.0.0.0:33335/ws
Ready to accept connections from all network interfaces
==========================================
Server is running. Commands:
status: Show connected clients
health [id]: Show tank health (all or specific ID)
damage id amount: Apply damage to a tank
heal id amount: Heal a tank
respawn id x y: Respawn a tank at position (x,y)
q: Quit server

Server Startup Analysis:

Executable Detection: run.bat automatically locates the built executable
Network Binding: Server binds to all network interfaces (0.0.0.0)
- TCP Server: Port 33334 for game connections
- WebSocket Server: Port 33335/ws for web client support
Command Interface: Same server commands as C# version
Ready State: Server is ready to accept client connections

Step 4: C# Client Compatibility Test

🔄 Protocol Compatibility Verification:

The C++ server is fully compatible with the existing C# clients. You can connect the same C# clients from Step 2 to this C++ server without any modifications.

Connect C# Client to C++ Server:

# In another terminal, run the C# client
cd tank_server/Client/bin/Debug/net9.0
TankClient.exe

C++ Server Console Log (Client Connection):

Client 3 connected from 127.0.0.1:52341
New tank created for client 3 with tank type -1 and health 100/100
Not enough clients to create P2P group (need at least 2)

Server Log Analysis:

Identical Client Processing: C++ server handles client connections exactly like C# server
Same Tank Creation: Creates tank objects with identical initial state (health 100/100, type -1)
Player Synchronization: Exchanges player information between clients identically
P2P Group Management: Creates P2P groups with same logic and group ID assignment
Protocol Compatibility: All RMI functions and message formats work seamlessly

✅ Complete Functional Parity:

All movement, firing, and messaging commands work identically
P2P group creation and management function the same
Server commands (status, health, damage, heal, respawn) work identically
Client connection handling and state management are identical
Tank creation, health tracking, and game logic are exactly the same

🎯 This demonstrates that the C++ server is a complete drop-in replacement for the C# server with 100% protocol compatibility.

Step 5: Docker Deployment (Linux/Ubuntu)

The C++ server can be deployed as a Docker container on Ubuntu 24.04 for production environments.

Prerequisites for Docker Deployment

Docker Desktop (Windows) or Docker Engine (Linux)
Docker Compose for orchestration

Windows Docker Setup

If running on Windows, ensure Docker is configured for Linux containers:

Install Docker Desktop from the official website
Switch to Linux containers:
- Right-click Docker Desktop system tray icon
- Select "Switch to Linux containers..."
- Wait for Docker to restart in Linux container mode

ProudNet License Configuration (Optional)

By default, the server runs in 50 CCU limitation mode without a license key. For production deployment with unlimited concurrent users, you can configure a ProudNet license:

Step 1: License Key Setup

Edit the tank_server/licensekey.txt file:

# Default content (50 CCU limitation): Replace with your actual ProudNet license key:
PUT_YOUR_PROUDNET_LICENSE_KEY_HERE

Step 2: License Verification

The Docker build process automatically detects and applies the license:

With License: Unlimited CCU, full ProudNet features
Without License: 50 CCU limitation, development mode

Expected Docker Output with License:

tank-server-1  | License key found: /app/licensekey.txt
tank-server-1  | ProudNet license validation successful
tank-server-1  | Starting server with full license (unlimited CCU)

Expected Docker Output without License (Default):

tank-server-1  | License key file not found: /app/licensekey.txt
tank-server-1  | Building without ProudNet license.
tank-server-1  | Starting server without license (50 CCU limitation mode).

🔑 License Benefits:

Increased CCU: Higher concurrent connection limits based on license type
Production Features: Full ProudNet server capabilities
Technical Support: Access to ProudNet technical support
Performance Optimization: Enhanced server performance features

Docker Deployment Commands

cd tank_server/Server_CPP
docker-compose up

Expected Docker Output:

C:\Users\wayne\Documents\proud_tank\tank_server\Server_CPP [master +5 ~14 -15 !]> docker-compose up
Compose can now delegate builds to bake for better performance.
 To do so, set COMPOSE_BAKE=true.
[+] Building 2.3s (22/22)                                                                                                                                 docker:desktop-linux 
[+] Building 2.3s (22/23)                                                                                                                                 docker:desktop-linux 
[+] Building 2.3s (23/23) FINISHED                                                                                                                        docker:desktop-linux 
 => [tank-server internal] load build definition from Dockerfile                                                                                                          0.0s 
 => => transferring dockerfile: 6.39kB                                                                                                                                    0.0s 
 => [tank-server internal] load metadata for docker.io/library/ubuntu:24.04                                                                                               1.9s 
 => [tank-server auth] library/ubuntu:pull token for registry-1.docker.io                                                                                                 0.0s 
 => [tank-server internal] load .dockerignore                                                                                                                             0.0s 
 => => transferring context: 2B                                                                                                                                           0.0s 
 => [tank-server  1/16] FROM docker.io/library/ubuntu:24.04@sha256:6015f66923d7afbc53558d7ccffd325d43b4e249f41a6e93eef074c9505d2233                                       0.0s 
 => [tank-server internal] load build context                                                                                                                             0.1s
 => => transferring context: 106.41kB                                                                                                                                     0.0s
 => CACHED [tank-server  2/16] RUN apt-get update && apt-get install -y     build-essential     cmake     git     libssl-dev     libssl3     libcurl4-openssl-dev     tz  0.0s
 => CACHED [tank-server  3/16] WORKDIR /app                                                                                                                               0.0s
 => CACHED [tank-server  4/16] COPY tank_server/Server_CPP/src /app/src/                                                                                                  0.0s
 => CACHED [tank-server  5/16] COPY tank_server/Server_CPP/include /app/include/                                                                                          0.0s
 => CACHED [tank-server  6/16] COPY tank_server/Server_CPP/CMakeLists.txt /app/CMakeLists.txt                                                                             0.0s
 => CACHED [tank-server  7/16] COPY tank_server/Common/Vars.cpp /app/Common/Vars.cpp                                                                                      0.0s
 => CACHED [tank-server  8/16] COPY tank_server/Common/Vars.h /app/Common/Vars.h                                                                                          0.0s
 => CACHED [tank-server  9/16] COPY ProudNet/include /app/ProudNet/include/                                                                                               0.0s
 => CACHED [tank-server 10/16] COPY ProudNet/lib/x86_x64-linux /app/ProudNet/lib/x86_x64-linux/                                                                           0.0s
 => CACHED [tank-server 11/16] COPY ProudNet/util/PNLicenseAuth /app/ProudNet/util/                                                                                       0.0s 
 => CACHED [tank-server 12/16] RUN if [ -f "tank_server/licensekey.txt" ] &&     [ "$(cat tank_server/licensekey.txt)" != "PUT_YOUR_PROUDNET_LICENSE_KEY_HERE" ]; then    0.0s 
 => CACHED [tank-server 13/16] RUN chmod +x /app/ProudNet/util/PNLicenseAuth &&     echo "System information:" &&     uname -a &&     echo "Current directory:" &&     p  0.0s 
 => CACHED [tank-server 14/16] RUN echo "Copied file structure:" &&     ls -la /app &&     echo "Common directory:" &&     ls -la /app/Common/ || echo "Failed to copy C  0.0s 
 => CACHED [tank-server 15/16] RUN echo '#!/bin/bash \necho "Server build starting..." \n\ncheck_file() { \n  if [ ! -f "$1" ]; then \n    echo "File not found: $1" \n   0.0s
 => CACHED [tank-server 16/16] RUN chmod +x /app/start.sh                                                                                                                 0.0s
 => [tank-server] exporting to image                                                                                                                                      0.0s 
 => => exporting layers                                                                                                                                                   0.0s 
 => => writing image sha256:cf987b1363c26bf89aa7ced6c0eca898573679bc92001c3aedee2ff1fe7c649e                                                                              0.0s 
 => => naming to docker.io/library/server_cpp-tank-server                                                                                                                 0.0s 
 => [tank-server] resolving provenance for metadata file                                                                                                                  0.0s 
[+] Running 2/2
 ✔ tank-server                         Built                                                                                                                              0.0s 
 ✔ Container server_cpp-tank-server-1  Created                                                                                                                            0.0s 
Attaching to tank-server-1
tank-server-1  | Server build starting...
tank-server-1  | File found: /app/Common/Vars.cpp
tank-server-1  | File found: /app/Common/Vars.h                                                                                                                                
tank-server-1  | Directory found: /app/ProudNet/lib/x86_64-linux                                                                                                              
tank-server-1  | ProudNet license check in progress...                                                                                                                         
tank-server-1  | License file information:                                                                                                                                     
tank-server-1  | total 18560                                                                                                                                                   
tank-server-1  | drwxr-xr-x 1 root root     4096 Jun  2 15:03 .
tank-server-1  | drwxr-xr-x 1 root root     4096 Jun  2 15:03 ..                                                                                                               
tank-server-1  | -rwxr-xr-x 1 root root 18987960 May 20 23:14 PNLicenseAuth                                                                                                    
tank-server-1  | License key file not found: /app/licensekey.txt                                                                                                               
tank-server-1  | Building without ProudNet license.                                                                                                                            
tank-server-1  | ODBC driver information:                                                                                                                                      
tank-server-1  | /app/start.sh: line 72: odbcinst: command not found                                                                                                           
tank-server-1  | Could not get ODBC information.
tank-server-1  | -- OpenSSL found: /usr/include
tank-server-1  | -- OpenSSL libraries: /usr/lib/x86_64-linux-gnu/libssl.so;/usr/lib/x86_64-linux-gnu/libcrypto.so
tank-server-1  | -- OpenSSL version: 3.0.13                                                                                                                                    
tank-server-1  | -- CURL found: /usr/include/x86_64-linux-gnu                                                                                                                  
tank-server-1  | -- CURL libraries: /usr/lib/x86_64-linux-gnu/libcurl.so
tank-server-1  | -- CURL version: 8.5.0                                                                                                                                        
tank-server-1  | -- System check: Linux                                                                                                                                        
tank-server-1  | -- Current working directory: /app                                                                                                                            
tank-server-1  | -- Build type:                                                                                                                                                
tank-server-1  | -- ProudNet Path: /app/ProudNet                                                                                                                               
tank-server-1  | -- Operating System: Linux
tank-server-1  | -- Library path check: /app/ProudNet/lib/x86_64-linux                                                                                                        
tank-server-1  | -- Found Linux ProudNet library: /app/ProudNet/lib/x86_64-linux                                                                                              
tank-server-1  | -- Library file list: /app/ProudNet/lib/x86_64-linux/Debug;/app/ProudNet/lib/x86_64-linux/Release                                                           
tank-server-1  | -- Found ODBC library: /usr/lib/x86_64-linux-gnu/libodbc.so                                                                                                   
tank-server-1  | -- Found ODBCINST library: /usr/lib/x86_64-linux-gnu/libodbcinst.so
tank-server-1  | -- Linking OpenSSL libraries: /usr/lib/x86_64-linux-gnu/libssl.so;/usr/lib/x86_64-linux-gnu/libcrypto.so                                                      
tank-server-1  | -- Linking CURL library: /usr/lib/x86_64-linux-gnu/libcurl.so                                                                                                 
tank-server-1  | -- Configuring done (0.1s)                                                                                                                                    
tank-server-1  | -- Generating done (0.0s)                                                                                                                                     
tank-server-1  | -- Build files have been written to: /app/build                                                                                                               
tank-server-1  | [100%] Built target TankGameServer
tank-server-1  | Build completed, attempting to start server...
tank-server-1  | Starting server without license (50 CCU limitation mode).                                                                                                     
tank-server-1  | No NIC binding though multiple NIC detected##Process=/app/build                                                                                               
tank-server-1  | ========== Tank Server Started ==========
tank-server-1  | TCP Server listening on 0.0.0.0:33334                                                                                                                         
tank-server-1  | WebSocket Server listening on 0.0.0.0:33335/ws                                                                                                                
tank-server-1  | Ready to accept connections from all network interfaces                                                                                                       
tank-server-1  | ==========================================                                                                                                                    
tank-server-1  | Server is running. Commands:                                                                                                                                  
tank-server-1  | status: Show connected clients                                                                                                                                
tank-server-1  | health [id]: Show tank health (all or specific ID)
tank-server-1  | damage id amount: Apply damage to a tank                                                                                                                      
tank-server-1  | heal id amount: Heal a tank                                                                                                                                   
tank-server-1  | respawn id x y: Respawn a tank at position (x,y)                                                                                                              
tank-server-1  | q: Quit server

Docker Build Process Analysis:

Multi-stage Build: Uses Ubuntu 24.04 base image with cached build layers
Dependencies Installation: Installs build-essential, cmake, OpenSSL, CURL development libraries
File Structure Copy: Copies source files, ProudNet libraries, and build configuration
License Detection: Checks for ProudNet license key (falls back to 50 CCU limitation mode)
Library Detection: Automatically finds and links system libraries:
- OpenSSL 3.0.13: SSL/TLS support
- CURL 8.5.0: HTTP client support
- ODBC: Database connectivity support
CMake Configuration: Configures build with Linux-specific ProudNet libraries
Compilation: Successfully builds TankGameServer executable
Server Startup: Starts in 50 CCU limitation mode (no license key provided)

📋 Docker Container Details:

Base image: Ubuntu 24.04 LTS
Multi-stage build: Optimized container size
Port exposure: 33334-33335 mapped to host ports
ProudNet libraries: Automatically copied and linked
Production ready: Minimal runtime dependencies

Docker Container Management

View running containers:

docker ps

Expected Output:

CONTAINER ID   IMAGE                    COMMAND                   CREATED       STATUS         PORTS                                  NAMES
dd96172cd51d   server_cpp-tank-server   "/bin/bash /app/star…"   2 hours ago   Up 7 seconds   0.0.0.0:33334-33335->33334-33335/tcp   server_cpp-tank-server-1

View server logs:

docker logs server_cpp-tank-server-1

Stop the server:

docker-compose down

Step 6: Cross-Platform Client Testing

🌐 Test C# Client → C++ Docker Server:

The C# client can connect to the dockerized C++ server running on Ubuntu:

# In another terminal, run the C# client
cd tank_server/Client/bin/Debug/net9.0
TankClient.exe

Expected Client Connection:

Connected to server. My ID: 3

Expected Docker Server Log:

tank-server-cpp  | Client 3 connected from 172.17.0.1:52341
tank-server-cpp  | New tank created for client 3 with tank type -1 and health 100/100

Key Benefits of C++ Implementation:

🚀 Performance:

Native C++ performance for high-CCU scenarios
Optimized memory management and networking
Suitable for production game servers

🐧 Cross-Platform:

Windows development with Visual Studio/CMake
Linux deployment with Docker containers
Ubuntu 24.04 LTS for stable production environment

📦 Containerization:

Dockerized deployment for cloud platforms
Scalable infrastructure with container orchestration
Isolated runtime environment with minimal dependencies

🔄 Protocol Compatibility:

100% compatible with C# clients
Same PIDL protocol definitions
Seamless migration between C# and C++ servers

WebSocket Integration

🌐 Additional WebSocket Server (Port 33335):

The C++ server implementation includes an additional WebSocket server that runs alongside the main TCP server:

TCP Server: Port 33334 (for desktop C# clients)
WebSocket Server: Port 33335/ws (for Unity WebGL clients)

🎮 Unity WebGL Client Support:

This WebSocket functionality is specifically designed for Unity tank clients that will be built as WebGL applications:

Web Browser Gaming: Unity WebGL clients can connect directly through web browsers
Same Game Protocol: Uses identical Tank.PIDL RMI functions over WebSocket transport
Cross-Platform Multiplayer: Desktop clients (TCP) and web clients (WebSocket) can play together in the same game sessions
No Installation Required: Players can join games instantly through any modern web browser

Connection Example:

ws://localhost:33335/ws  // Local development
ws://your-server.com:33335/ws  // Production deployment

This dual-protocol architecture enables seamless integration between traditional desktop applications and modern web-based gaming platforms.

4. Multiplayer Movement Testing

This section demonstrates a real-world scenario where two clients connect simultaneously and test tank movement functionality.

Test Scenario

Client 1 (ID=3): Uses move 1 1 0 command to move to position (1,1) with direction 0 degrees
Client 2 (ID=4): Uses move 2 2 90 command to move to position (2,2) with direction 90 degrees

Client 1 (ID=3) Console Log:

Connected to server. My ID: 3
move 1 1 0
Status: Tank ID=3, Position=(1,1), Type=0, Health=100/100
OnPlayerJoined: Tank 4 joined at (64.18131,34.385406) with tank type -1
P2P: Member 3 joined group 5
P2P: Member 4 joined group 5
P2P: Added member 4 to group member list
OnTankHealthUpdated: Tank 4 health: 100/100
P2P: Received group info, Group ID: 5
>>> OTHER TANK 4 MOVED TO (2,2) dir=90

Client 1 Log Analysis:

Self Movement Processing: After executing move 1 1 0 command, own tank status is updated
New Player Detection: Receives OnPlayerJoined event when Client 4 connects to server
P2P Group Formation: P2P group (ID: 5) is created when 2+ clients are connected
Other Tank Movement Notification: Receives Client 4's movement in real-time and displays it

Client 2 (ID=4) Console Log:

Connected to server. My ID: 4
P2P: Member 4 joined group 5
P2P: Member 3 joined group 5
P2P: Added member 3 to group member list
OnPlayerJoined: Tank 3 joined at (1,1) with tank type -1
OnTankHealthUpdated: Tank 3 health: 100/100
P2P: Received group info, Group ID: 5
move 2 2 90
Status: Tank ID=4, Position=(2,2), Type=0, Health=100/100

Client 2 Log Analysis:

Server Connection: Successfully connected to server and assigned ID 4
P2P Group Participation: Joins P2P group 5 together with existing Client 3
Existing Player Info Reception: Receives tank information (position, health) of already connected Client 3
Self Movement Execution: Uses move 2 2 90 command to move tank to position (2,2) with 90-degree direction

Server Console Log:

New tank created for client 4 with tank type -1 and health 100/100
Sending existing player info to new client: ID=3, Type=-1, Health=100/100
Notifying existing client 3 about new player: ID=4, Type=-1, Health=100/100
P2P group created with 2 members, Group ID: 5
Sent P2P group info to client 3: P2P_GROUP_INFO:5
Sent P2P group info to client 4: P2P_GROUP_INFO:5
SendMove from client 4: pos=(2,2), direction=90

Server Log Analysis:

New Client Processing: Creates new tank object for Client 4 (initial health 100/100)
Player Information Synchronization:
- Sends existing player (ID=3) information to new client (ID=4)
- Notifies existing client (ID=3) about new player (ID=4)
P2P Group Management: Creates P2P group (ID: 5) when 2+ clients are present and distributes group information
Movement Command Processing: Receives and processes Client 4's SendMove RMI call

Core Multiplayer Features Verification:

🔄 Real-time Synchronization:

Movement from one client is immediately propagated to all other clients
Server manages state centrally and broadcasts to all clients

🌐 P2P Networking:

P2P group is automatically formed when 2+ clients are connected
Direct client-to-client communication improves network efficiency

📊 State Management:

Position, direction, and health of each tank are synchronized across all clients
Newly connected clients automatically receive existing game state

🎮 Game Logic:

Tank type, position, and direction are accurately transmitted and displayed
Each player's actions are reflected in real-time in the multiplayer environment

5. Fire and Messaging Testing

In addition to movement, clients can test projectile firing and P2P messaging functionality.

Extended Test Commands

Fire Command: fire 180 10 - Fire projectile in direction 180 degrees with force 10
Message Command: msg hi - Send P2P message "hi" to other connected clients

Client 1 (ID=3) Fire and Message Commands:

fire 180 10
Fire request sent: direction=180, force=10, position=(1, 1, 1)
Status: Tank ID=3, Position=(1,1), Type=0, Health=100/100
msg hi
P2P message sent via server: hi
Status: Tank ID=3, Position=(1,1), Type=0, Health=100/100

Client 1 Command Analysis:

Fire Command Execution: fire 180 10 sends projectile with 180-degree direction and force value 10
Fire Confirmation: Client receives confirmation with firing position and parameters
Message Command Execution: msg hi sends P2P message to all connected clients
Message Confirmation: Client receives confirmation that message was sent via server relay

Client 2 (ID=4) Receiving Fire and Message Events:

OnSpawnBullet: Tank 3 fired from (1,1) dir=180, force=10
Fire position: (1, 1, 1), shooter ID=3
P2P Message from Client ID 3 (relayed): hi

Client 2 Reception Analysis:

Bullet Spawn Event: Receives OnSpawnBullet RMI call with firing tank's position and projectile parameters
Fire Details: Gets complete information about shooter ID, position, direction, and force
P2P Message Reception: Receives the P2P message from Client 3 relayed through the server

Key Multiplayer Communication Features:

🔫 Projectile System:

Fire commands are synchronized across all clients in real-time
Each client receives complete projectile information (position, direction, force, shooter ID)
Projectile spawn events are properly broadcast to maintain game state consistency

💬 P2P Messaging:

Messages are sent through server relay to ensure delivery
All connected clients receive messages from any sender
Message source identification (sender Client ID) is preserved
Reliable message delivery through ProudNet's P2P infrastructure

🔄 Event Broadcasting:

All game actions (movement, firing, messaging) are immediately propagated
Consistent game state maintained across all connected clients
Real-time multiplayer interaction without noticeable delays

Troubleshooting

Build errors: Ensure ProudNet DLLs are in the correct paths
Connection failed: Check if server is running and firewall settings
PIDL compilation errors: Verify ProudNet/util/PIDL.exe exists and is accessible
Runtime exceptions: Confirm all ProudNet DLLs are copied to output directories