Architecture du Code Source (Python)

Le code source du jeu PFE-Roguelike est structuré en plusieurs modules distincts pour garantir la maintenabilité et la clarté. Chaque module a une responsabilité unique au sein de l'application. Vous pouvez explorer le code complet sur notre dépôt GitHub.

Outils et Technologies

Module engine

Le cœur du jeu. Il gère la boucle principale, l'état du jeu, la génération de la carte et le moteur d'apprentissage par renforcement.

# Exemple simplifié de la boucle de jeu dans engine/game.py
class Game:
    def __init__(self):
        self.player = Player(...)
        self.map = Map()
        self.is_running = True

    def run(self):
        while self.is_running:
            self.handle_input()
            self.update_game_state()
            self.render()

Module entities

Définit les objets du jeu, comme le joueur, les monstres et autres PNJ. Contient leur logique de comportement et leurs attributs.

# Exemple de la classe Player dans entities/players.py
class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.health = 100
        self.inventory = []

    def move(self, dx, dy):
        # Logique de mouvement et de collision
        self.x += dx
        self.y += dy

Module database

Gère toutes les interactions avec les bases de données. Sépare la logique de connexion pour PostgreSQL (données du jeu) et MongoDB (logs).

# Exemple de connexion dans database/db_sql.py
import psycopg2

def get_player_data(player_id):
    conn = psycopg2.connect(...)
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM players WHERE id = %s", (player_id,))
    player_data = cursor.fetchone()
    cursor.close()
    conn.close()
    return player_data

Module items

Contient la définition de tous les objets que le joueur peut trouver et utiliser, comme les armes, les potions, et les équipements.

# Exemple de la classe Weapon dans items/weapon.py
from .item import Item

class Weapon(Item):
    def __init__(self, name, damage):
        super().__init__(name)
        self.damage = damage

    def use(self, target):
        target.take_damage(self.damage)

Module system

Gère la journalisation (logging), la configuration et d'autres fonctionnalités transversales qui soutiennent l'ensemble du système.

# Exemple de configuration du logger dans system/logging_setup.py
import logging

def setup_logger():
    logger = logging.getLogger('roguelike_logger')
    logger.setLevel(logging.INFO)
    handler = logging.FileHandler('game.log')
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    return logger