GameManager¶

class labpyproject.apps.labpyrinthe.bus.game_manager.GameManager(type_app, game_path)[source]¶

Bases : labpyproject.core.app.app_components.BUSINESSComp

Manager principal du jeu, supportant les rôles standalone, client ou serveur.

Utilise par composition une instance de LabManager (utilisant elle même d’autres managers/helpers par composition).

Note

Prototype fonctionnel. Classe trop lourde (> 3000 lignes), à reconcevoir de façon plus générique dans une version de production.

Plan du code source :

A- Tâches : NET & GUI
    A.1- Réception tâches GUI
    A.2- Réception tâches NET
    A.3- Envoi vers GUI et NET
    A.4- Unicité des requêtes
B- Phases de l'application
    B.1- Phase initiale
    B.2- Phases Partie
        B.2.1- PARTIE_INIT
        B.2.2- PARTIE_CHOSEN
        B.2.3- PARTIE_CREATED
        B.2.4- PARTIE_STARTED
        B.2.5- PARTIE_ENDED
    B.3- Phases jeu (coups)
        B.3.1- Loop Master
        B.3.2- Utilitaires Master
        B.3.3- Méthodes Slave
        B.3.4- Application d'un coup
        B.3.5- Evénéments de jeu
    B.4- Interruptions
C- Connection/ids des joueurs
    C.1- Gestion des uids des joueurs
    C.2- Connection(s) client(s)
    C.3- Structure de suivi des clients
D- Contrôle de cohérence (client/serveur)
    D.1- Cohérence (serveur)
    D.2- Cohérence (client)
E- Gestion des choix utilisateurs
    E.1- Mécanique générale
    E.2- Saisie adresse serveur
    E.3- Choix partie
    E.4- Démarrer la partie
    E.5- Commande de jeu
F- Affichages (GUI)
    F.1- Affichages non suivis
    F.2- Affichages suivis (carte)
        F.2.1- Mécanique générique
        F.2.2- Affichages avec callback
    F.3- Statut de publication (carte)
G- Création d'une partie
H- Gestion des couleurs associées aux joueurs

Constructeur

Paramètres

type_app – AppTypes.APP_SERVER (serveur), AppTypes.APP_CLIENT (client) ou AppTypes.APP_STANDALONE
game_path – racine du jeu

Attributes Summary

`ASK_GOTO_MENU`	[gui -> bus] demande de retour au menu
`ASK_QUIT_APP`	[gui -> bus] demande à quitter le jeu
`BUILD_LAB`	[svr-> clt] publication intégrale de la carte
`BUILD_LAB_DONE`	[clt -> svr] indique que la publication de la carte est achevée
`CHECK_CHANGELOG_KEY`	[clt -> svr] retourne la clef de vérification de synchro de la carte
`CHOOSE_GAME`	[svr-> clt] choix du jeu
`CONTENT_ANIM_PIXEL`	[type de contenu] animation de déplacement fine
`CONTENT_BOT_DEAD`	[type de contenu] mort d’un joueur
`CONTENT_GAMBLE_CTX`	[type de contenu] contexte du coup
`CONTENT_HELP`	[type de contenu] aide
`CONTENT_MESSAGE`	[type de contenu] message
`CONTENT_PARTIE_SERVER`	[type de contenu] résumé du coup (svr)
`CONTENT_PLAYER_STATUS`	[type de contenu] statut d’un joueur
`CONTENT_PUBLISHED`	[gui -> bus] indique que l’affichage demandé a été effectué
`CONTENT_TYPE_PARTIE`	[type de contenu] infos partie
`ENTER_CMD`	[svr-> clt] demande une action de jeu
`ENTER_NET_ADDRESS`	[bus -> gui] demande de saisie de l’adresse du serveur
`GAME_CHOICE`	[clt -> svr] retourne le jeu choisi
`GAME_MODE_DEMO`	mode de jeu auto (démo)
`GAME_MODE_PARTIE`	mode de jeu interactif (partie)
`GET_FULL_LAB`	[clt -> svr] demande de resynchro de la carte
`INITIAL_PHASIS`	phase globale d’initialisation
`LABHELPER_SURCHARGED`	[bus -> gui] modification des chars de parsing, affichage et commande
`NET_INFOS`	[bus -> gui] infos réseau génériques
`PARTIE_CHOSEN`	phase partie choisie
`PARTIE_CREATED`	phase partie crée
`PARTIE_ENDED`	phase partie terminée
`PARTIE_INIT`	phase partie init
`PARTIE_STARTED`	phase partie démarrée
`PING_DELAY`	durée d’attente avant vérification des connections clients
`PLAY_CMD`	[svr-> clt] application d’une action de jeu
`PUBLISH_CARTE`	[type de contenu] publication complète de la carte
`QUEUE_CMD`	[clt -> svr] empile une action (non implémenté)
`REORDER_BOTS`	[svr-> clt] modification de l’ordre des joueurs
`RESET_QUEUE`	[clt -> svr] efface les actions empilées (non implémenté)
`SET_APPTYPE`	[bus -> gui] définition du type d’application
`SET_UID`	[svr-> clt] affectation uid client
`SHOW_MESSAGE`	[svr-> clt] affichage d’un message
`SHOW_TXT_CARTE`	[type de contenu] affichage carte txt dans écran de preload
`SHUTDOWN`	phase globale d’arrêt
`START_GAME`	[svr-> clt] démarrage du jeu
`SYNC_LAB_CODES`	[svr] codes commandes réservés aux clients synchronisés
`UNCONFIRMED_CODES`	code de commande sans accusé de réception
`UPDATE_BOTS`	[svr-> clt] mise à jour des joueurs
`UPDATE_CARTE`	[type de contenu] publication partielle de la carte
`UPDATE_GAMBLE_CONTEXT`	[svr-> clt] mise à jour du contexte du coup
`UPDATE_PLAYER_STATUS`	[svr-> clt] mise à jour du statut d’un joueur
`UPDATE_XTRAS`	[svr-> clt] mise à jour mines et bonus

Methods Summary

`NET_send_status`(exobj)	Le composant réseau informe de son état de connection.
`NET_signal_error`(exobj)	Le composant réseau informe d’une erreur de connection.
`NET_signal_send_error`(exobj)	Le composant réseau signale un envoi en erreur.
`affiche_aide`()	Affichage / masquage aide.
`affiche_animation_pixel`(case, coords1, …)	Animation de déplacement fine (pixel)
`affiche_gamble_context`()	Transmet à l’interface le contexte du coup à venir
`affiche_message`(txt)	Affichage d’un message contextuel
`affiche_partie_infos_for_server`()	Transmet à l’interface des infos sur la partie
`apply_gamble`(uid, dictcmd, consequences)	Traitement local d’un coup à jouer
`ask_user_choice`(params)	Etape 1 : envoie la demande de choix à l’utilisateur ciblé.
`check_user_choice`(obj)	Etape 2 : vérifie la validité du choix utilisateur
`client_confirm_lab_resync`()	A l’issue de la publication complète du labyrinthe le client envoie un message de confirmation au serveur.
`client_send_changelog_key`()	Le client envoie au serveur sa clef de changelog pour contrôle de cohérence.
`configure_labyrinthe`()	Configure les caractères :
`create_changelog_key`()	Crée une clef pour le contrôle de cohérence
`create_gui_order_number`()	Génère un identifiant d’ordre d’affichage (maj carte)
`discard_publication_status`()	Invalide le statut de publication de la GUI
`dispatch_NETInfos`(dictargs)	Transmet à l’interface les infos réseau pour publication
`dispatch_type_partie`()	Affichage du type de partie et du niveau.
`end_partie`(winner)	Arrêt de la partie en cours
`fire_game_event`(code[, dictargs, uid, suffix])	Interface d’envoi de messages avec code de commande sur le réseau.
`game_loop`()	Gestion des coups (master)
`get_player_by_uid`(uid)	Retourne le LabPlayer d’uid passé en paramètre
`get_publication_status`()	Retourne le statut de publication
`goto_menu`()	L’utilisateur veut retourner au menu, en quittant la partie éventuellement en cours.
`handleTask`()	Méthode générique de dépilement de tâche.
`handle_GUI_info`(exobj)	La GUI envoie une information
`handle_NET_info`(exobj)	Le composant réseau envoie une information.
`handle_NET_request`(exobj)	Le composant réseau transmet une requête reçue.
`handle_global_choice`(exobj)	Prend en charge une éventuelle commande globale (afficher aide, quitter), retourne un booleen indiquant si l’on doit interrompre le process éventuel d’attente de choix pré existant.
`handle_gui_order_callback`(dictargs)	Applique l’éventuel callback d’affichage suivi.
`handle_returned_choice`(exobj)	La GUI retourne le choix utilisateur en réponse à ASK_USER_CHOICE.
`handle_simple_consequences`(uid, …)	Prise en charge des conséquences simples
`handle_user_choice`(obj)	Etape 3 : traite un choix utilisateur valide
`handle_user_command`(exobj)	La GUI envoie une commande utilisateur spontannée.
`init_before_gamble`(uid, coup, totalcoups)	Transmission du contexte du prochain coup (synchro interface(s))
`init_changelogs`()	Ré initialise les logs avant modification du lablevel.
`init_game`()	Appelée par l’application lorsque tous les composants ont été initialisés.
`init_gui_order_system`()	Initialise la gestion du suivi d’ordres d’affichages
`init_partie`()	Initialisation d’une partie, appelée à la fin de l’initialisation de l’AppManager.
`init_step_changelogs`()	Ré initialise les logs d’étape avant modification du lablevel.
`is_master`()	Indique si le manager de jeu est maitre (server, standalone) ou esclave (client).
`is_object_connected`()	Retourne un boolean indiquant l’état de connection.
`lock_NET_tasks`()	Met en attente le traitement des tâches réseau entrantes.
`manage_creation_loop`()	Méthode appelée par handleTask si self.check_creation == True, vérifie l’état de publication initial des clients.
`manage_game_loop`()	Méthode appelée par handleTask si self.partie_started == True, dédiée à la gestion des coups (master)
`master_closing_gamble`()	Pré finalisation du coup par le master.
`on_GUI_Ready`(exobj)	L’interface indique qu’elle est prête à réagir.
`on_bonus_win`(uid, casebonus)	Appelée lorsque le robot d’uid passe sur une case bonus
`on_content_published`(dictargs)	Confirmation par la GUI de la dernière demande d’affichage de contenu.
`on_first_action_done`(uid, dictcmd, consequences)	Callback appelé lorsque la première action a été effectuée (animation de déplacement, ajout de case)
`on_gamble_closed`()	Le coup est intégralement traité.
`on_gamble_defined`(uid, cmd, dictcmd, …)	Prise en charge master du coup venant d’être défini
`on_gamble_played`()	Le coup a été traité graphiquement
`on_game_choice_made`(dictargs)	Appelée lorsque le premier joueur a choisit le niveau.
`on_partie_created`()	Appelée lorsque le modèle (lablevel) a été généré.
`on_player_connection_status_changed`(uid)	Appelée lorsque le statut de connection du client change de valeur.
`on_player_status_changed`(uid)	Mise à jour du statut du joueur
`on_player_status_updated_by_master`(dictargs)	Mise à jour du statut du joueur : sdynchro graphique de la zone commande.
`on_player_vitesse_change`(uid, val)	Le joueur d’uid, uid vient de gagner un bonus
`on_queue_cmd_added`(dictargs)	Le joueur d’uid uid a envoyé une nouvelle cmd (action)
`ping_connections`([uid])	Envoie au composant réseau un ordre de vérification des connections
`play_animation_move`(case, coords1, coords2, …)	Joue une animation de mouvement (robot ou grenade).
`play_explosion_scenario`(uid, dictcmd, …)	Prend en charge une explosion
`player_connected`(uid)	Un joueur distant vient d’obtenir son uid de la part du serveur.
`player_joignable`(uid)	Indique que la connexion bilatérale avec le client est établie.
`publish_carte`(callback, *args)	Envoie une commande d’affichage complet de la carte à la GUI
`quit_game`()	L’utilisateur veut quitter le jeu.
`re_initialise`()	Ré initialisation complète avant la création d’une partie.
`ready_for_NET_tasks`()	Indique si l’objet peut prendre en charge une tâche réseau.
`register_gui_order_callback`(gui_order, clb, …)	Enregistre un callback à appeler lorsque la GUI confirmera l’affichage de l’ordre n° gui_order.
`register_my_uid`(uid)	Contexte client connecté : le serveur distant vient d’affecter l’uid.
`reset_cmd_queue`(uid)	Efface les commandes pré enregistrées par le joueur
`run_animation_cases`(dictanim)	Applique les étapes de transformation de l’animation case à case
`sendGuiCmd`(exobj)	Interface d’envoi d’un message à la GUI
`sendNetworkContent`(msg, confirmrecept[, uid])	Interface d’envoi de contenu sur le réseau
`sendNetworkMessage`(msg[, uid])	Envoie un message aux clients
`server_check_clients_lab_resync`()	Vérifie que les clients identifiés dans self._sync_clients_dict comme non synchronisés aient renvoyé le code GameManager.BUILD_LAB_DONE
`server_check_players_XTras_keys`()	Contrôle de cohérence des clients après mise à jour des XTras.
`server_check_players_changelog_keys`(callback)	Méthode générique de contrôle de cohérence des clients.
`server_check_players_gamble_keys`()	Contrôle de cohérence des clients après application du coup.
`server_register_client_changelog_key`(dictargs)	Enregistrement de la clef de cohérence du client
`server_register_client_lab_resync`(dictargs)	Réception de la confirmation par un client de la resynchro du labyrinthe.
`set_bot_killed`(robot[, affiche, callback, …])	Elimination d’un robot.
`show_carte_txt_in_preload`()	Affichage de la carte txt dans l’écran de preload de partie
`start_animation_cases`(case, listcoords, …)	Lance une animation suivie case à case
`start_game_loop`()	Démarre la boucle de gestion de la partie (master)
`start_partie`()	Démarre la partie une fois la carte choisie et les joueurs enregistrés
`stop_game_loop`()	Stop la boucle de gestion de la partie (master)
`unlock_NET_tasks`()	Ré active le traitement des tâches réseau.
`update_carte`(callback, *args)	Mise à jour partielle de la carte.
`update_players_labyrinthe`(case[, listuid, …])	Synchro du labyrinthe des clients distants

Attributes Documentation

ASK_GOTO_MENU = 'ASK_GOTO_MENU'¶: [gui -> bus] demande de retour au menu

ASK_QUIT_APP = 'ASK_QUIT_APP'¶: [gui -> bus] demande à quitter le jeu

BUILD_LAB = 'BUILD_LAB'¶: [svr-> clt] publication intégrale de la carte

BUILD_LAB_DONE = 'BUILD_LAB_DONE'¶: [clt -> svr] indique que la publication de la carte est achevée

CHECK_CHANGELOG_KEY = 'CHECK_CHANGELOG_KEY'¶: [clt -> svr] retourne la clef de vérification de synchro de la carte

CHOOSE_GAME = 'CHOOSE_GAME'¶: [svr-> clt] choix du jeu

CONTENT_ANIM_PIXEL = 'CONTENT_ANIM_PIXEL'¶: [type de contenu] animation de déplacement fine

CONTENT_BOT_DEAD = 'CONTENT_BOT_DEAD'¶: [type de contenu] mort d’un joueur

CONTENT_GAMBLE_CTX = 'CONTENT_GAMBLE_CTX'¶: [type de contenu] contexte du coup

CONTENT_HELP = 'CONTENT_HELP'¶: [type de contenu] aide

CONTENT_MESSAGE = 'CONTENT_MESSAGE'¶: [type de contenu] message

CONTENT_PARTIE_SERVER = 'CONTENT_PARTIE_SERVER'¶: [type de contenu] résumé du coup (svr)

CONTENT_PLAYER_STATUS = 'CONTENT_PLAYER_STATUS'¶: [type de contenu] statut d’un joueur

CONTENT_PUBLISHED = 'CONTENT_PUBLISHED'¶: [gui -> bus] indique que l’affichage demandé a été effectué

CONTENT_TYPE_PARTIE = 'CONTENT_TYPE_PARTIE'¶: [type de contenu] infos partie

ENTER_CMD = 'ENTER_CMD'¶: [svr-> clt] demande une action de jeu

ENTER_NET_ADDRESS = 'ENTER_NET_ADDRESS'¶: [bus -> gui] demande de saisie de l’adresse du serveur

GAME_CHOICE = 'GAME_CHOICE'¶: [clt -> svr] retourne le jeu choisi

GAME_MODE_DEMO = 'GAME_MODE_DEMO'¶: mode de jeu auto (démo)

GAME_MODE_PARTIE = 'GAME_MODE_PARTIE'¶: mode de jeu interactif (partie)

GET_FULL_LAB = 'GET_FULL_LAB'¶: [clt -> svr] demande de resynchro de la carte

INITIAL_PHASIS = 'INITIAL_PHASIS'¶: phase globale d’initialisation

LABHELPER_SURCHARGED = 'LABHELPER_SURCHARGED'¶: [bus -> gui] modification des chars de parsing, affichage et commande

NET_INFOS = 'NET_INFOS'¶: [bus -> gui] infos réseau génériques

PARTIE_CHOSEN = 'PARTIE_CHOSEN'¶: phase partie choisie

PARTIE_CREATED = 'PARTIE_CREATED'¶: phase partie crée

PARTIE_ENDED = 'PARTIE_ENDED'¶: phase partie terminée

PARTIE_INIT = 'PARTIE_INIT'¶: phase partie init

PARTIE_STARTED = 'PARTIE_STARTED'¶: phase partie démarrée

PING_DELAY = 4¶: durée d’attente avant vérification des connections clients

PLAY_CMD = 'PLAY_CMD'¶: [svr-> clt] application d’une action de jeu

PUBLISH_CARTE = 'PUBLISH_CARTE'¶: [type de contenu] publication complète de la carte

QUEUE_CMD = 'QUEUE_CMD'¶: [clt -> svr] empile une action (non implémenté)

REORDER_BOTS = 'REORDER_BOTS'¶: [svr-> clt] modification de l’ordre des joueurs

RESET_QUEUE = 'RESET_QUEUE'¶: [clt -> svr] efface les actions empilées (non implémenté)

SET_APPTYPE = 'SET_APPTYPE'¶: [bus -> gui] définition du type d’application

SET_UID = 'SET_UID'¶: [svr-> clt] affectation uid client

SHOW_MESSAGE = 'SHOW_MESSAGE'¶: [svr-> clt] affichage d’un message

SHOW_TXT_CARTE = 'SHOW_TXT_CARTE'¶: [type de contenu] affichage carte txt dans écran de preload

SHUTDOWN = 'SHUTDOWN'¶: phase globale d’arrêt

START_GAME = 'START_GAME'¶: [svr-> clt] démarrage du jeu

SYNC_LAB_CODES = ['UPDATE_GAMBLE_CONTEXT', 'PLAY_CMD', 'UPDATE_XTRAS']¶: [svr] codes commandes réservés aux clients synchronisés

UNCONFIRMED_CODES = ['SHOW_MESSAGE']¶: code de commande sans accusé de réception

UPDATE_BOTS = 'UPDATE_BOTS'¶: [svr-> clt] mise à jour des joueurs

UPDATE_CARTE = 'UPDATE_CARTE'¶: [type de contenu] publication partielle de la carte

UPDATE_GAMBLE_CONTEXT = 'UPDATE_GAMBLE_CONTEXT'¶: [svr-> clt] mise à jour du contexte du coup

UPDATE_PLAYER_STATUS = 'UPDATE_PLAYER_STATUS'¶: [svr-> clt] mise à jour du statut d’un joueur

UPDATE_XTRAS = 'UPDATE_XTRAS'¶: [svr-> clt] mise à jour mines et bonus

Methods Documentation

NET_send_status(exobj)[source]¶

Le composant réseau informe de son état de connection.

exobj.dictargs={« connection_status »:, « netcode »:NETExchangeObject.NET_STATUS, « msg »:}

avec connection_status ayant pour valeur :

STATUS_SHUTDOWN = « STATUS_SHUTDOWN » # arrêt définiif
STATUS_DISCONNECTED = « STATUS_DISCONNECTED » # arrêt temporaire
STATUS_ERROR_CONNECTION = « STATUS_ERROR_CONNECTION » # erreur
STATUS_UNDEFINED = « STATUS_UNDEFINED » # probablement en erreur
STATUS_CONNECTED = « STATUS_CONNECTED » # active
STATUS_REJECTED = « STATUS_REJECTED » # connection refusée

Rq : V1 ne concerne que la connection principale au serveur.

NET_signal_error(exobj)[source]¶

Le composant réseau informe d’une erreur de connection.

Remarques :

connection concernée = la connection principale client -> serveur, soit read pour le serveur et write pour le client.
l’état des autres connections est décrit dans le dict reçu par handle_NET_info.

NET_signal_send_error(exobj)[source]¶

Le composant réseau signale un envoi en erreur.

Server : ne signale que les erreurs non fatales (le client est bien connecté), l’erreur est probablement liée à un problème de décodage unicode (du à une erreur d’encodage utf8 en bytes). exob.dictargs = {« msg »:message initial, « confirmrecept »:bool, « clients »:liste non vide d’uids}

Client : signale toutes les erreurs d’envoi, quelques soient les statuts de connection du serveur et du client. exob.dictargs = {« msg »:message initial, « confirmrecept »:bool}

affiche_aide()[source]¶: Affichage / masquage aide.

affiche_animation_pixel(case, coords1, coords2, duration, callback, *args)[source]¶: Animation de déplacement fine (pixel)

affiche_gamble_context()[source]¶: Transmet à l’interface le contexte du coup à venir

affiche_message(txt)[source]¶: Affichage d’un message contextuel

affiche_partie_infos_for_server()[source]¶: Transmet à l’interface des infos sur la partie

apply_gamble(uid, dictcmd, consequences)[source]¶: Traitement local d’un coup à jouer

ask_user_choice(params)[source]¶: Etape 1 : envoie la demande de choix à l’utilisateur ciblé.

check_user_choice(obj)[source]¶

Etape 2 : vérifie la validité du choix utilisateur

Paramètres: obj – GUIExchangeObject généré à l’étape 1 ou envoyé spontanément via la GUI

client_confirm_lab_resync()[source]¶: A l’issue de la publication complète du labyrinthe le client envoie un message de confirmation au serveur.

client_send_changelog_key()[source]¶: Le client envoie au serveur sa clef de changelog pour contrôle de cohérence.

configure_labyrinthe()[source]¶

Configure les caractères :

de commande (direction, aide, quitter, création de mur et porte)
de parsing des cartes txt
d’affichage graphique des objets Labyrinthe

V1 : ces paramétrages sont gérés en dur dans cette méthode, on pourrait les charger dynamiquement dans des fichiers de config, des préférences propres aux joueurs…

create_changelog_key()[source]¶: Crée une clef pour le contrôle de cohérence

create_gui_order_number()[source]¶: Génère un identifiant d’ordre d’affichage (maj carte)

discard_publication_status()[source]¶: Invalide le statut de publication de la GUI

dispatch_NETInfos(dictargs)[source]¶: Transmet à l’interface les infos réseau pour publication

dispatch_type_partie()[source]¶: Affichage du type de partie et du niveau.

end_partie(winner)[source]¶

Arrêt de la partie en cours

Paramètres: winner – le joueur gagnant ou None

fire_game_event(code, dictargs=None, uid=None, suffix='')[source]¶

Interface d’envoi de messages avec code de commande sur le réseau.

Paramètres

code (str) – une constante statique
dictargs (dict) – paramètres
uid – id ou liste d’ids
suffix (str) – suffix de marquage de requète

game_loop()[source]¶

Gestion des coups (master)

Rq : aucune « sous boucle » dans ce code. Les traitements graphiques et les traitements métiers s’enchainent grâce à un mécanisme de callback de publication.

get_player_by_uid(uid)[source]¶: Retourne le LabPlayer d’uid passé en paramètre

get_publication_status()[source]¶: Retourne le statut de publication

goto_menu()[source]¶: L’utilisateur veut retourner au menu, en quittant la partie éventuellement en cours.

handleTask()[source]¶

Méthode générique de dépilement de tâche.

Plutôt que de créer un thread fils dédié à la boucle de gestion du jeu, on surcharge cette méthode.

handle_GUI_info(exobj)[source]¶: La GUI envoie une information

handle_NET_info(exobj)[source]¶: Le composant réseau envoie une information.

handle_NET_request(exobj)[source]¶: Le composant réseau transmet une requête reçue.

handle_global_choice(exobj)[source]¶: Prend en charge une éventuelle commande globale (afficher aide, quitter), retourne un booleen indiquant si l’on doit interrompre le process éventuel d’attente de choix pré existant.

handle_gui_order_callback(dictargs)[source]¶

Applique l’éventuel callback d’affichage suivi.

Rq : appelée par self.on_content_published (confirmation affichage par GUI)

handle_returned_choice(exobj)[source]¶: La GUI retourne le choix utilisateur en réponse à ASK_USER_CHOICE.

handle_simple_consequences(uid, consequences, callback)[source]¶: Prise en charge des conséquences simples

handle_user_choice(obj)[source]¶

Etape 3 : traite un choix utilisateur valide

Paramètres: obj – GUIExchangeObject généré à l’étape 1

handle_user_command(exobj)[source]¶

La GUI envoie une commande utilisateur spontannée.

avec exobj.dictargs = {« typechoix »:GameManager.QUEUE_CMD, « choix »:}

init_before_gamble(uid, coup, totalcoups)[source]¶: Transmission du contexte du prochain coup (synchro interface(s))

init_changelogs()[source]¶: Ré initialise les logs avant modification du lablevel. Logs à l’échelle du coup complet.

init_game()[source]¶: Appelée par l’application lorsque tous les composants ont été initialisés.

init_gui_order_system()[source]¶: Initialise la gestion du suivi d’ordres d’affichages

init_partie()[source]¶: Initialisation d’une partie, appelée à la fin de l’initialisation de l’AppManager.

init_step_changelogs()[source]¶: Ré initialise les logs d’étape avant modification du lablevel. Logs à l’échelle d’une étape du coup complet.

is_master()[source]¶: Indique si le manager de jeu est maitre (server, standalone) ou esclave (client).

is_object_connected()[source]¶: Retourne un boolean indiquant l’état de connection.

lock_NET_tasks()[source]¶: Met en attente le traitement des tâches réseau entrantes.

manage_creation_loop()[source]¶: Méthode appelée par handleTask si self.check_creation == True, vérifie l’état de publication initial des clients.

manage_game_loop()[source]¶: Méthode appelée par handleTask si self.partie_started == True, dédiée à la gestion des coups (master)

master_closing_gamble()[source]¶: Pré finalisation du coup par le master.

on_GUI_Ready(exobj)[source]¶: L’interface indique qu’elle est prête à réagir.

on_bonus_win(uid, casebonus)[source]¶: Appelée lorsque le robot d’uid passe sur une case bonus

on_content_published(dictargs)[source]¶: Confirmation par la GUI de la dernière demande d’affichage de contenu.

on_first_action_done(uid, dictcmd, consequences)[source]¶: Callback appelé lorsque la première action a été effectuée (animation de déplacement, ajout de case)

on_gamble_closed()[source]¶: Le coup est intégralement traité.

on_gamble_defined(uid, cmd, dictcmd, consequences)[source]¶: Prise en charge master du coup venant d’être défini

on_gamble_played()[source]¶: Le coup a été traité graphiquement

on_game_choice_made(dictargs)[source]¶

Appelée lorsque le premier joueur a choisit le niveau.

Process :

handle_user_choice est appelée lorsque le choix de partie est valide

elle appelle alors cette méthode (maj phase)

enfin elle appelle le callback define_game qui lance le process de création de la partie

Suite du process : voir on_partie_created

on_partie_created()[source]¶: Appelée lorsque le modèle (lablevel) a été généré.

on_player_connection_status_changed(uid)[source]¶: Appelée lorsque le statut de connection du client change de valeur. Rq: player.joignable est déja actualisé (handle_NET_info appelant _server_check_connections).

on_player_status_changed(uid)[source]¶: Mise à jour du statut du joueur

on_player_status_updated_by_master(dictargs)[source]¶: Mise à jour du statut du joueur : sdynchro graphique de la zone commande.

on_player_vitesse_change(uid, val)[source]¶: Le joueur d’uid, uid vient de gagner un bonus

on_queue_cmd_added(dictargs)[source]¶: Le joueur d’uid uid a envoyé une nouvelle cmd (action)

ping_connections(uid=None)[source]¶

Envoie au composant réseau un ordre de vérification des connections

Paramètres: uid – peut être un uid unique ou une liste d’uid

play_animation_move(case, coords1, coords2, duration, nbcases, callback, *args)[source]¶: Joue une animation de mouvement (robot ou grenade).

play_explosion_scenario(uid, dictcmd, consequences, scenariodict)[source]¶: Prend en charge une explosion

player_connected(uid)[source]¶: Un joueur distant vient d’obtenir son uid de la part du serveur.

player_joignable(uid)[source]¶: Indique que la connexion bilatérale avec le client est établie.

publish_carte(callback, *args)[source]¶: Envoie une commande d’affichage complet de la carte à la GUI

quit_game()[source]¶: L’utilisateur veut quitter le jeu.

re_initialise()[source]¶: Ré initialisation complète avant la création d’une partie.

ready_for_NET_tasks()[source]¶: Indique si l’objet peut prendre en charge une tâche réseau.

register_gui_order_callback(gui_order, clb, *args)[source]¶: Enregistre un callback à appeler lorsque la GUI confirmera l’affichage de l’ordre n° gui_order.

register_my_uid(uid)[source]¶: Contexte client connecté : le serveur distant vient d’affecter l’uid. Contexte standalone : auto affectation.

reset_cmd_queue(uid)[source]¶: Efface les commandes pré enregistrées par le joueur

run_animation_cases(dictanim)[source]¶: Applique les étapes de transformation de l’animation case à case

sendGuiCmd(exobj)[source]¶

Interface d’envoi d’un message à la GUI

Paramètres: exobj (GUIExchangeObject) –

sendNetworkContent(msg, confirmrecept, uid=None)[source]¶

Interface d’envoi de contenu sur le réseau

Paramètres

msg (str) – contenu à envoyer
confirmrecept (bool) – avec accusé de réception?
uid – peut être un uid unique ou une liste d’uid

sendNetworkMessage(msg, uid=None)[source]¶

Envoie un message aux clients

Paramètres

msg (str) –
uid – peut être un uid unique ou une liste d’uid

server_check_clients_lab_resync()[source]¶: Vérifie que les clients identifiés dans self._sync_clients_dict comme non synchronisés aient renvoyé le code GameManager.BUILD_LAB_DONE

server_check_players_XTras_keys()[source]¶: Contrôle de cohérence des clients après mise à jour des XTras.

server_check_players_changelog_keys(callback)[source]¶

Méthode générique de contrôle de cohérence des clients. Compare self._gamble_key aux clés enregistrées dans self._sync_clients_dict, après :

l’exécution d’un coup
la mise à jour des XTras

En cas d’incohérences, le serveur resynchronise les clients le nécessitant (via le code GameManager.BUILD_LAB), la propriété self.wait_client_resync passe alors à True. Dans le cas contraire, le callback de poursuite de traitement est appelé.

Paramètres: callback (function) – callback à appeler en absence d’incohérences.

server_check_players_gamble_keys()[source]¶: Contrôle de cohérence des clients après application du coup.

server_register_client_changelog_key(dictargs)[source]¶: Enregistrement de la clef de cohérence du client

server_register_client_lab_resync(dictargs)[source]¶: Réception de la confirmation par un client de la resynchro du labyrinthe.

set_bot_killed(robot, affiche=False, callback=None, clbargs=None)[source]¶

Elimination d’un robot.

Rq : l’affichage est à revoir (« écrasé » par un update immédiat de la carte), d’où des appels avec affiche=False.

show_carte_txt_in_preload()[source]¶: Affichage de la carte txt dans l’écran de preload de partie

start_animation_cases(case, listcoords, stepduration, callback, *args)[source]¶: Lance une animation suivie case à case

start_game_loop()[source]¶: Démarre la boucle de gestion de la partie (master)

start_partie()[source]¶: Démarre la partie une fois la carte choisie et les joueurs enregistrés

stop_game_loop()[source]¶: Stop la boucle de gestion de la partie (master)

unlock_NET_tasks()[source]¶: Ré active le traitement des tâches réseau.

update_carte(callback, *args)[source]¶: Mise à jour partielle de la carte.

update_players_labyrinthe(case, listuid=None, dictargs=None)[source]¶

Synchro du labyrinthe des clients distants

Paramètres

case – parmi BUILD_LAB, UPDATE_XTRAS, UPDATE_BOTS, REORDER_BOTS
listuid – uid ou liste d’uid de joueurs concernés par l’envoi ou None (ie tous les joueurs)
dictargs – dict associé aux derniers bonus/dangers ajoutés ou à la liste de bots (cas part déconnection)