Simplifing FixAng function

.env.example

@@ -0,0 +1,23 @@
+# === GRAPHIC OPTIONS ===
+
+# - RENDERING OPTIONS - 
+RAYCASTER_FOV=90 # Field Of View in degrees (°) Keep between 60 and 110 for better rendering  
+RAYCASTER_NUM_RAYS=200 # Resolution (the lower, the faster)
+RAYCASTER_MAX_DISTANCE=500 # For distance shading, 
+
+# - MINIMAP -
+MAP_MINIMAP_SIZE=12
+MAP_MINIMAP_OPACITY=210 # range from 0 to 255
+
+# === CONTROLS ===
+
+# KEY BINDS
+KEY_FORWARD=z
+KEY_LEFT=q
+KEY_BACKWARD=s
+KEY_RIGHT=d
+
+# === DEV OPTIONS ===
+
+# LOGGER
+LOG_LEVEL=INFO

.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+temp/
+*.log
+env
+.env

LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
 Copyright (c) 2020 8KSpaceInvader
+Copyright (c) 2025 MxPerrot
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,21 +1,49 @@
-# A Python raycasting engine made in openGL
-This ia a simple python raycasting engine made in python.
+# Raycaster2
+
+This is a python raycasting game based on 8KSpaceInvader's  [pythonRaycaster](https://github.com/ARYANTECH123/pythonRaycaster)
+
+I've transformed it using OOP to make a multiplayer server/client based game.
+
+I'm not yet sure what to do as game content, anything is possible from there, i'm thinking of a co-op maze game.
+
+# Installation
+
 To run it, you must have Python3 and PyOpenGL.
 
 Python can be installed from the [website](python.org)
 
 To install PyOpenGL, you can go to the [documentaion](http://pyopengl.sourceforge.net/documentation/index.html)
 
-Once both are ready and configured, download or clone `ray.py` and use `python ray.py` to run it.
 
-## Running the code
-Once the program starts, you'll  see 2 views : A 2D map with the player and all the rays, and a 3d, raycasted projection. Use WASD to move, and Q to teleport.
+# Running the game
+
+Once both are ready and configured, download or clone the project and run the server (`python3 server_network.py`) and then a client (`python3 main.py`).
+
+Once the program starts, you'll  see 2 views : A 2D map with the player, and a 3d, raycasted projection.
 
-## Playing with the code
+Use ZQSD to move (I'm using a french azerty keyboard, sorry, I'll later use automatic detection of key layout and/or easy keybindings ui).
 
-The algorithm, though it may appear complex, is actually really simple and fast, and hence was used on many classic games like Wolfenstien 3D, to great effect on the limited hardware of the time. If you want to learn more about the algorithm, [this guide is a excellant starting point](https://permadi.com/1996/05/ray-casting-tutorial-1/#INTRODUCTION).
+You can run as many clients as you wish. Other clients will render on the minimap as a green dot.
 
-In order to change the map, simploy edit the 64 element long `world` list. it is formatted so thet a `0` is a space and a `1` is a block.
+## About Raycasting
+
+The algorithm, though it may appear complex, is actually really simple and fast, and hence was used on many classic games like Wolfenstien 3D, to great effect on the limited hardware of the time.
+
+It consists of shooting rays from the camera until they intersect an object; and then draw a vertical line on the screen depending on the distance reached by the ray. This results
+
+If you want to learn more about the algorithm, [this guide is a excellent starting point](https://permadi.com/1996/05/ray-casting-tutorial-1/#INTRODUCTION).
+
+## Future additions
+
+You can see planned additions in the [TODO](./TODO) file.
+Currently I plan on making
+- UI for map management/edition and key bindings
+- Map generation (maybe mazelik/terrainlike)
+- Game mechanics (not yet determined)
+- Improve graphics
+  - Use texture mapping
 
 ## Screenshots
-[img](https://github.com/ARYANTECH123/pythonRaycaster/blob/main/image.png)
+![8kSpaceInvader's old version](https://github.com/ARYANTECH123/pythonRaycaster/blob/main/image.png)
+
+![My version (IMAGE TO COME)]()

TODO

@@ -0,0 +1,2 @@
+[ ] Use texture mapping
+[ ] Multiplayer: render other players

logger/CustomFormatter.py

@@ -0,0 +1,64 @@
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from dotenv import load_dotenv
+import os
+import datetime
+
+load_dotenv()
+
+LOG_LEVEL = os.getenv('LOG_LEVEL','INFO')
+LOG_FOLDER = os.path.join(os.getcwd(), "logs")
+os.makedirs(LOG_FOLDER, exist_ok=True)
+
+class CustomFormatter(logging.Formatter):
+    cyan = "\x1b[36;20m"
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+
+    FORMATS = {
+        logging.DEBUG: cyan + format + reset,
+        logging.INFO: grey + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+def get_logger(name: str, level=logging.INFO):
+    logger = logging.getLogger(name)
+    if not logger.handlers:  # Avoid duplicate handlers
+
+        # Console handler (with colors)
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(CustomFormatter())
+        logger.addHandler(console_handler)
+
+        # Get today's date in ISO 8601 format (YYYY-MM-DD)
+        date_str = datetime.date.today().isoformat()
+        log_file_path = os.path.join(LOG_FOLDER, f"{date_str}.log")
+
+        # File handler with daily rotation (even if we don't auto-rotate here, keeps it flexible)
+        file_handler = TimedRotatingFileHandler(
+            log_file_path,
+            when="midnight",   # Rotate at midnight
+            interval=1,
+            backupCount=7,     # Keep last 7 logs (optional)
+            encoding='utf-8'
+        )
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+        logger.setLevel(level)
+
+    return logger

logger/__init__.py

@@ -0,0 +1 @@
+from .CustomFormatter import get_logger

main.py

@@ -0,0 +1,161 @@
+###############################################################################
+#                                   IMPORTS                                   #
+###############################################################################
+#from alive_progress import alive_bar
+from logger import get_logger
+from raycaster import Map, Player, Renderer
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from OpenGL.GLUT import *
+from multiplayer import ClientNetwork
+import time
+import threading
+from dotenv import load_dotenv
+import os
+
+
+###############################################################################
+#                                  CONSTANTS                                  #
+###############################################################################
+
+log = get_logger(__name__)
+
+log.info("imports successful")
+
+load_dotenv()
+
+log.info("environment loaded")
+
+def get_env_int(key, default):
+    try:
+        return int(os.getenv(key, default))
+    except ValueError:
+        return default
+
+def get_env_str(key, default):
+    return os.getenv(key, default) # is str by default
+
+FOV = get_env_int("RAYCASTER_FOV", 80)
+NUM_RAYS = get_env_int("RAYCASTER_NUM_RAYS",120)
+MAX_DISTANCE = get_env_int("RAYCASTER_MAX_DISTANCE",500)
+KEY_FORWARD = get_env_str("KEY_FORWARD",'w')
+KEY_LEFT = get_env_str("KEY_LEFT",'a')
+KEY_BACKWARD = get_env_str("KEY_BACKWARD",'s')
+KEY_RIGHT = get_env_str("KEY_RIGHT",'d')
+MAP_MINIMAP_SIZE = get_env_int("MAP_MINIMAP_SIZE",4)
+MAP_MINIMAP_OPACITY = get_env_int("MAP_MINIMAP_OPACITY",128)
+
+
+###############################################################################
+#                                INITIALIZATION                               #
+###############################################################################
+
+# === NETWORK INITIALIZATION ===
+network = ClientNetwork()  # Connects to server at localhost:5555 by default
+
+# === GAME INITIALIZATION ===
+# Wait for map data
+log.info("Waiting for map...")
+while network.map_data is None:
+    continue
+log.info("Received map")
+
+map_info = network.map_data
+map_obj = Map(map_info['grid'], map_info['mapX'], map_info['mapY'], map_info['mapS'], map_info["colorMap"], map_info["spawnpoint"])
+
+# You can adjust keybindings per client instance
+key_bindings = {'FORWARD': KEY_FORWARD, 'BACKWARD': KEY_BACKWARD, 'LEFT': KEY_LEFT, 'RIGHT': KEY_RIGHT}
+player = Player(map_info["spawnpoint"][0], map_info["spawnpoint"][1], 90, key_bindings, map_obj)
+
+renderer = Renderer(map_obj=map_obj, fov=FOV, num_rays=NUM_RAYS, max_distance=MAX_DISTANCE, minimap_size=MAP_MINIMAP_SIZE, minimap_opacity=MAP_MINIMAP_OPACITY)  # Local player only for now
+
+last_time = time.time()
+
+
+# === GLUT INITIALIZATION ===
+glutInit()
+glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
+glutInitWindowSize(1024, 512)
+glutCreateWindow(b"Networked Raycaster Client")
+
+glEnable(GL_BLEND)
+glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+glutReshapeFunc(renderer.reshape) 
+
+
+# === INPUT HANDLERS ===
+def keyboard_down(key, x, y):
+    try:
+        key_char = key.decode().lower()
+        if key_char in player.key_bindings.values():
+            player.keys_pressed.add(key_char)
+    except UnicodeDecodeError:
+        pass
+
+def keyboard_up(key, x, y):
+    try:
+        key_char = key.decode().lower()
+        if key_char in player.keys_pressed:
+            player.keys_pressed.remove(key_char)
+    except UnicodeDecodeError:
+        pass
+
+
+# === DISPLAY FUNCTION ===
+def display():
+    if not network.running:
+        log.warning("Server disconnected. Exiting client.")
+        os._exit(0)  # Force exit immediately (no need to keep GLUT running)
+
+    global last_time
+    current_time = time.time()
+    delta_time = current_time - last_time
+    last_time = current_time
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+    # Move local player
+    player.move(delta_time)
+
+    # Send local player update to server
+    network.send_player_update(player.px, player.py, player.pa)
+
+    # Draw local scene
+    renderer.draw_scene(player)
+
+    # Draw remote players (optional, if desired)
+    for remote_id, remote_data in network.players_state.items():
+        # Skip rendering ourself
+        if remote_id == str(network.my_id):  # IDs are string keys after JSON
+            continue
+        px = int(remote_data['px'])
+        py = int(remote_data['py'])
+        pa = int(remote_data['pa'])
+        renderer.draw_minimap_player((px,py,pa))
+
+    glutSwapBuffers()
+
+    log.debug(f"Rendering players_state: {network.players_state}")
+
+
+# === GLUT INITIALIZATION PART 2 ===
+
+glClearColor(0.3, 0.3, 0.3, 0)
+gluOrtho2D(0, 1024, 512, 0)
+
+glutKeyboardFunc(keyboard_down)
+glutKeyboardUpFunc(keyboard_up)
+
+glutDisplayFunc(display)
+glutIdleFunc(display)
+
+# === CLEANUP ===
+def on_close():
+    network.close()
+
+import atexit
+atexit.register(on_close)
+
+# === MAIN LOOP ===
+glutMainLoop()