v1.0.0: Rebirth of the Arcade

Release Notes: Pong Reloaded v1.0.0

---

🚀 Overview

Welcome to the official v1.0.0 release of Pong Reloaded! This release marks a significant milestone, transforming the classic retro game into a modern, highly optimized, and feature-rich arcade experience built with C++20 and Raylib 5.0.

Developed as an educational student project for the Helios Additional Activity initiative at the Technical University of Cluj-Napoca (UTCN), this release brings robust performance, premium customization, and complete portability to Windows.

---

🎮 Key Features & Enhancements

📦 1. Zero-Dependency Standalone Portability

• PE Resource Embedding: All graphical textures, audio files, and system fonts are compiled directly into the executable binary (pong-reloaded.exe) using a custom Windows resource file (resources.rc).
• Zero Missing Assets: You can copy, rename, or move the single executable anywhere on your PC without worrying about broken paths or missing resource folders.

🛠️ 2. Integrated Developer Console (F7)

• Live Engine Diagnostics: Pressing F7 toggles a native Windows console overlay showing real-time engine state transitions, gameplay events, and performance logs.
• Custom Logger (DevLog): Refined logging system with distinct message types to simplify troubleshooting and debugging during runtime.

🤖 3. Gameplay Modes & Custom Lobby

• Dynamic AI Opponent: Play solo against an adaptive CPU opponent with three difficulty levels (Easy, Normal, and Hard).
• Multiplayer Lobby: Local 1v1 couch-co-op featuring an interactive matchmaking screen where both players must toggle their "Ready" state (W and Up Arrow) before the game begins.
• Visual Theme Engine: Customize your matches with custom background skins (Galaxy, Trap, Default), paddle designs, and ball textures.

⚙️ 4. Premium Settings Panel

• Resolution Control: Selectable screen sizes ranging from standard windowed configurations to dynamic Fullscreen.
• Framerate Configuration: Toggle targets between 60 FPS, 144 FPS, or VSync.
• Custom Scoring Limits: Set matches to finish at 5, 11, 15, or 21 points.

---

🛠️ Technical Improvements & Code Quality

• C++20 & Raylib 5.0: Leveraged modern language standard updates and the latest Raylib graphics pipeline.
• Global Variables Clean-up: Decoupled and refactored state variables, centralizing state management.
• Dynamic Icon Loader: Incorporated a high-resolution .ico resource mapped directly to the Win32 window class.
• CI/CD Automation: Updated and refined MSBuild configuration workflow (.github/workflows/msbuild.yml) for automated compiler validation on Windows platforms.

---

💾 Quick Install Guide

1. Download pong-reloaded.exe from the assets section below.
2. Double-click the file to launch the game instantly.
3. Use the following keyboard layout to navigate and play:

Player 1 (Left)	Player 2 (Right)	Action	Key
W / S	Up / Down	Move Paddle	—
W	Up	Toggle Ready (Lobby)	—
—	—	Pause / Resume	P
—	—	Reset / Game Over	Space
—	—	Dev Console	F7

---

v0.9.1 - Almost v1

Pong Reloaded — v0.9.1-alpha Release Notes

This release marks a significant milestone in Pong Reloaded's progression toward v1.0. This update introduces a
highly requested asset custom theme engine, multi-themed asset variations, visual layout refinements, and a substantial
codebase architecture cleanup to ensure optimized resource usage.

---

🎨 New Features & Customization

We have implemented a Premium Settings & Theme Engine, giving players full control over the aesthetic layout of the
match. All newly introduced graphical assets are compiled directly into the binary's resource section (.rc) using
Windows PE resources, preserving the game's strict zero-dependency, standalone portability.

• 🌌 Visual Space Themes: Switch seamlessly between three court backgrounds: Default, Galaxy, and Trap.

• 🍌 Ball Customization: Five unique selectable ball skins are now available:

• Default

• Banana Ball (featuring an exclusive custom hit audio variant)

• Beach Ball

• Cloudy Ball

• Simple Ball

• 🏓 Paddle Textures: Customize your on-screen paddles with four distinct visual modes: Default, Cloudy, CPU
  Style, and Human Style.

• 🔧 Version & HUD Display: Added a persistent version watermark (v0.9.1) to the main menu screen alongside
  integrated telemetry hooks.

---

🛠️ Codebase Cleanup & Optimization

Under the hood, this update focuses heavily on refactoring the application architecture for structural safety and
performance.

• Global Scope Refactoring: Transitioned loose global color arrays (Green, Dark_Green, etc.) and developer log
  buffers (logHistory, logMutex) to proper extern declarations within main.h to minimize memory overhead and
  linking collision.
• Dynamic Asset Loading: Implemented a unified ReloadTexture(int resourceId) routine across both Ball and
  Paddle classes to safely unload previous textures from VRAM before allocating new ones.
• Header Sanitation: Cleaned up unused dependency headers within main.h and structured layout groups cleanly
  inside the Visual Studio project filters file (pong-reloaded.vcxproj.filters).
• Expanded Settings Navigation: The Settings layout options have expanded from 6 rows to 9 rows to support the new
  theme selection lines, bound safely with automated loop-around line wrapping logic.

---

🎮 Controls Quick-Reference

Context	Action / Key	Player 1 (Left Paddle)	Player 2 / CPU (Right Paddle)
Menu Navigation	Up / Down	—	Arrow Up / Arrow Down
Menu Confirm	Enter	—	Enter
Lobby Ready Toggle	Ready State	W	Arrow Up
Gameplay Movement	Up / Down	W / S	Arrow Up / Arrow Down
Gameplay Actions	Pause / Resume	—	P
Gameplay Actions	Force Reset	—	Spacebar
Developer Tools	Toggle Dev Console	—	F7

---

📦 Building From Source

To compile the standalone binary locally, ensure you are on a Windows platform with Visual Studio 2022 ("Desktop
development with C++" workload installed) and Raylib 5.0 configured.

git clone https://github.com/Dr20Ervin/Pong-Reloaded.git
cd Pong-Reloaded

1. Open pong-reloaded.sln inside Visual Studio.
2. Set your build configuration layout to Release / x64.
3. Compile the solution to output the optimized, self-contained pong-reloaded.exe.

Icon update & pre-compiled executable

New release v0.8.2

Standalone, pre-compiled executable binary (Pong.Reloaded.exe) is attached below for direct playback on Windows!Standalone, pre-compiled executable binary (Pong.Reloaded.exe) is attached below for direct playback on Windows!

Commits Included: 3 commits

• b7954e4: Add Windows console toggle functionality with F7 key

• fac5b95: Add custom logging system and improve state logging. Refactor main.cpp

• 6c8fa69: Update application icon and add dynamic icon loading

---

Detailed Breakdown

Application Icon Customization (6c8fa69)

• Asset Relocation & Refresh: Swapped out the old baseline icon.ico from the project root and replaced it with a polished, updated version tracking into the assets/icon.ico path.

• Dynamic Resource Mapping: Refactored resources.rc to target the clean asset subdirectory route instead of the bare root workspace layout.

• Native Window Handle Interception (src/resource_loader.cpp): Created a platform-specific helper method, SetWindowIconFromResource(int id), inside the resource suite.

• Grabs the native Win32 window reference handle (HWND) from Raylib's container.

• Applies the compiled binary icon resources directly to the operating system's process window parameters (WM_SETICON) via SendMessageA mapping.

v0.8

Summary of Changes

Transitioned the game from loading asset files directly from disk paths to a robust Windows resource-embedding system (.rc), packaging all textures, audio, and application icons directly into the executable.

---

Detailed Breakdown

1. Resource Architecture & Asset Embedding

• Added Window Resource Script (resources.rc): Created to map resource IDs to physical asset paths for compiling directly into the binary.

• Asset Resource Mapping (include/resource.h): Created a new header defining unique resource IDs (RCDATA) for the application icon, all game textures, and audio effects:

• IDI_ICON1 (100)

• Textures: IDR_TEX_BASIC_SPACE, IDR_TEX_WALLS, IDR_TEX_LINE, IDR_TEX_BALL, IDR_TEX_PADDLE, IDR_TEX_PADDLE2

• Audio: IDR_SND_PADDLE_HIT, IDR_SND_WALL_HIT, IDR_SND_SCORE, IDR_SND_BANANA

• Added Executable Icons: Bundled icon.ico and icon.jpg directly into the project root and build pipeline.

2. Backend Engine & Asset Loading

• Created Memory Resource Loader (src/resource_loader.cpp):
• Implemented Win32 API interactions (FindResource, LoadResource, LockResource) to access embedded binary data safely.
• Resolved Win32 and Raylib naming collisions (e.g., Rectangle, CloseWindow, PlaySound, ShowCursor) using explicit #define aliasing and #undef guards.
• Added LoadTextureFromResource(int id): Extracts PNG data from executable memory using Raylib's LoadImageFromMemory.
• Added LoadSoundFromResource(int id): Extracts OGG audio data from memory using Raylib's LoadWaveFromMemory.

3. Refactoring Game Entities (src/main.cpp, include/game.h)

• Updated Constructors: Modified Paddle and Ball signatures to accept integer textureId resource definitions instead of std::string texturePath strings.
• Refactored Initializations: Updated ctx loading routines in main.cpp to use the new memory-based functions instead of standard disk-bound LoadTexture and LoadSound calls.

4. Game Rules & Gameplay Tweaks (src/game.cpp)

• Scoring Boundary Adjustment: Adjusted the right-side scoring threshold check for Player 2. The ball position trigger padding was modified from screen_width - 20.0f to screen_width - 30.0f.
• Visual Guarding: Added explicit background rendering routines for the boundary walls to prevent transparent edge-bleeding issues.

5. Build Pipeline Updates (pong-reloaded.vcxproj & Filters)

• Integrated src/resource_loader.cpp and include/resource.h into the Visual Studio solution compilation groups.
• Added <ResourceCompile Include="resources.rc"/> step to automatically build and link binary resources on project compilation.

v0.6.1

Release v0.6.1-alpha: VRAM-Cached Textures, Custom Constructors & Core State Mapping

Welcome to the second alpha milestone of Pong Reloaded! Building on our previous OOP architectural foundation for the UTCN - ETTI Helios initiative, this version addresses critical components of our roadmap. We have migrated from basic procedural geometric primitives to a modern, VRAM-cached asset pipeline and expanded our runtime pipeline configuration.

🛠️ What's New in v0.6.1-alpha

1. VRAM-Cached Asset Pipelines (Issue #3)

• Direct GPU Texture Mapping: Completely replaced plain mathematical shape rasterization with proper hardware-accelerated asset textures using Raylib’s 2D texture pipeline.
• Component Texturing: * The Ball class dynamically switches from integer-casted raw circles to rendering basic_ball_5.png.
• The Paddle and CpuPaddle classes now load and map dedicated .png graphical variations (basic_paddle.png, basic_paddle_2.png).
• The playing field environment utilizes explicit assets (basic_space.png for court segments, walls.png for border structures, and line.png for center court strip rendering).

2. OOP Enhancements & Parameterized Constructors

• Resource-Linked Lifecycles: Introduced custom, overloaded object constructors managing both geometric data and path strings seamlessly at structural instantiation.
• RAII-Compliant Deallocation: Explicitly declared custom class destructors across physical game objects (Paddle, Ball) to cleanly unmap hardware context blocks via UnloadTexture() once execution loops terminate.

3. Gameplay State Machines & Core Menu Cascades

• Dynamic Menu Triggers: Wired the internal GameState state machine directly to option metrics generated by user input blocks. Selecting singleplayer paths cleanly routes through the new DifficultySelect routine before loading the runtime space.
• Real-Time Context Adjustments: Modified the configuration stack to update baseline metrics dynamically. Setting difficulty states alters the processing steps of the CpuPaddle tracking module, binding variable tracking tolerances (CPU_SPEED_EASY, CPU_SPEED_NORMAL, CPU_SPEED_HARD) based on execution data.

📋 Active Development Roadmap (v0.7 – v1.0)

With asset pipelines stabilized, development shifts toward input systems and UI refinement:

• Issue #1: Local Multiplayer Input Decoupling — Re-architecting input processing lines inside game.cpp to map distinct keys (e.g., W/S vs. default Arrow controls), completely decoupling player boundaries from the internal AI execution loops.
• Issue #2: Audio Integration — Bootstrapping Raylib's native hardware multimedia hooks (InitAudioDevice) to mix and dispatch immediate audio responses on collision flags and goal limits.
• Issue #4: UI Menu Multi-Tier Expansion — Extending the settings cascade layout to manipulate audio configurations and mid-game engine variables on the fly.

v0.5

Release v0.5.0-alpha: Architecture Overhaul & Local Assets

Welcome to the first alpha release of Pong Reloaded! This milestone updates our foundational codebase from single-file procedural scripts into a structured, scalable Object-Oriented Programming (OOP) hierarchy.

This build fulfills the core academic and execution benchmarks for the UTCN - ETTI Helios Additional_activity initiative.

🛠️ What's New in v0.5

• OOP Inheritance Model: Integrated a virtual base GameObject class branching out into explicit Paddle, Ball, and custom derived CpuPaddle classes.
• State Machine Pipeline: Replaced rigid block logic with a dedicated GameState engine supporting an interactive MainMenu, runtime Playing environments, and seamless application shutdowns (GameOver).
• Dynamic AI Opponent: Implemented a polymorphic CpuPaddle tracking routine equipped with internal state metrics mapping to Difficulty enum parameters (Easy, Normal, Hard).
• Optimized Build Configurations: Cleaned up linker environments, tying essential native dependencies directly to raylib.lib and the Windows multimedia kernel (winmm.lib).

📋 Active Development Roadmap (v0.6 – v1.0)

We are actively tracking the upcoming system milestones via GitHub Issues:

1. Issue #1: Local Multiplayer — Transition inputs to dynamic key mappings (W/S vs. Arrows) to decouple players from the AI thread.
2. Issue #2: Audio Integration — Bootstrapping Raylib's multimedia layer (InitAudioDevice) to support hardware-mixed .wav collision and scoring alerts.
3. Issue #3: Textures & Sprites — Swapping raster-rendered primitive bounding boxes for proper VRAM-cached 2D .png asset textures.
4. Issue #4: UI Expansion — Building out secondary graphical option cascades for real-time difficulty switching.