bug socket linux windows Résolu/Fermé

Question

Bonjour,

Je suis en train de créer un jeu en ligne via le module socket.

Quand je lance le serveur et 2 clients depuis mon ordinateur windows ça marche.

Mais quand je lance n'importe quel programme (serveur ou client) depuis mon ordinateur linux, l'application ne marche pas (erreur -> json decode error ou aucune erreur et le programme attend)

Voici mon code:

server.py

import socket
import threading
import json
import random

class Server:
    def __init__(self, addr, port):
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server.bind((addr, port))
        self.CARTES = (0, 1)
        self.GEARS = (0, 1)
        self.ok_message = "OK!"
        self.nope_message = "NOPE!"
        self.DECO = "DECO!"
        self.games = {}
        self.names = {}
        self.map_ok = {}
        self.map = {}
        self.gear_ok = {}
        self.gear = {}
        
    def start(self):
        self.server.listen()
        while True:
            conn, _ = self.server.accept()
            threading.Thread(target=self.handle_client, daemon=True, args=(conn, )).start()
    
    @staticmethod
    def recv(conn):
        inf = conn.recv(1024).decode()
        print(inf)
        try:
            return json.loads(inf)[0]
        except json.decoder.JSONDecodeError:
            return json.loads(repr([inf, ]))
    
    @staticmethod
    def send(conn, msg):
        conn.send(json.dumps([msg,]).encode())
    
    def handle_client(self, conn):
        # get username
        while True:
            username = self.recv(conn)
            if username in self.names.values():
                self.send(conn, self.nope_message)
            else:
                self.send(conn, self.ok_message)
                self.names[conn] = username
                break
            
        # get type_game
        type_game = self.recv(conn)
        if not self.games.get(type_game, False):
            self.games[type_game] = [conn, ]
        else:
            self.games[type_game].append(conn)
            
        # get game
        while True:
            id_game = len(self.games[type_game])
            while len(self.games[type_game]) < 2:
                pass
            if id_game == 1:
                opp = self.games[type_game][id_game]
                break
            elif id_game == 2:
                opp = self.games[type_game][id_game - 2]
                break
        self.send(conn, self.ok_message)
        self.recv(opp)
        self.games[type_game].pop(self.games[type_game].index(conn))
        self.send(conn, [id_game, self.names[opp]])
        
        # get map
        carte = None
        while carte not in self.CARTES:
            carte = self.recv(conn)
            if carte in self.CARTES:
                self.send(conn, self.ok_message)
                self.map[conn] = carte
                break
            else:
                self.send(conn, self.nope_message)
        
        if id_game == 1:
            if self.map_ok.get((conn, opp)) is None:
                self.map_ok[(conn, opp)] = [True, False]
            else:
                self.map_ok[(conn, opp)] = [True, True]
            while not all(self.map_ok[(conn, opp)]):
                pass
            carte = random.choice([self.map[conn], self.map[opp]])
            self.send(conn, carte)
            self.send(opp, carte)
        else:
            if self.map_ok.get((opp, conn)) is None:
                self.map_ok[(opp, conn)] = [True, False]
            else:
                self.map_ok[(opp, conn)] = [True, True]   
                     
        # gear
        print("GETTING GEAR")
        gear = None
        while gear not in self.GEARS:
            gear = self.recv(conn)
            ok = True
            for g in gear:
                if g not in self.GEARS:
                    ok = False
                    break
            if ok:
                self.send(conn, self.ok_message)
                self.gear[conn] = gear
                break
            else:
                self.send(conn, self.nope_message)
        
        if id_game == 1:
            if self.gear_ok.get((conn, opp)) is None:
                self.gear_ok[(conn, opp)] = [True, False]
            else:
                self.gear_ok[(conn, opp)] = [True, True]
            while not all(self.gear_ok[(conn, opp)]):
                pass
            print(self.gear[opp], self.gear[conn])
            self.send(conn, self.gear[opp])
            self.send(opp, self.gear[conn])
        else:
            if self.gear_ok.get((opp, conn)) is None:
                self.gear_ok[(opp, conn)] = [True, False]
            else:
                self.gear_ok[(opp, conn)] = [True, True]
        
        # game
        while True:
            msg = self.recv(opp)
            self.send(conn, msg)

if __name__ == "__main__":
    server = Server("localhost", 5070)
    server.start()

game.py

from networking import Client
import game

import pygame

def test(addr, port):
    x = y = x2 = y2 = 100
    j_moi = pygame.Surface((50, 50))
    j_moi.fill((255, 0, 0))
    
    j_opp = pygame.Surface((50, 50))
    j_opp.fill((0, 0, 255))
    clock = pygame.time.Clock()    
    
    aff_win = True
    run = True
    with Client(addr, port) as client:
        # get some info
        name = input("Entrer un nom d'utilisateur: ")
        while not client.get_username(name):
            print("nom deja utilise!")
            name = input("Entrer un nom d'utilisateur: ")
        
        moi_aff = game.Afficher((0, 0), name, (0, 0, 0), 30)

id_game, opp = client.get_game("!PUBLIC")
        print("id_game:", id_game)
        print("opp:", opp)
        opp_aff = game.Afficher((0, 0), opp, (0, 0, 0), 30)
        
        while True:
            carte_inp = input("Entrer une carte: ")
            try:
                carte_inp = int(carte_inp) - 1
            except ValueError:
                print("Entrer le nombre de la carte!")
                continue
            carte = client.get_map(carte_inp)
            if carte is not None:
                break
            print("map n'existe pas!")
        
        print("carte:", carte)
        
        # gear
        while True:
            gear = []
            for i in range(game.GEAR_LEN):
                while True:
                    inp = input("Entrer gear "+str(i + 1)+": ")
                    try:
                        inp = int(inp) - 1
                        break
                    except ValueError:
                        print("Veuillez entrer le nombre du gear que vous voulez utiliser!")
                gear.append(inp)
            gear_opp = client.get_gear(gear)
            if gear_opp is not None:
                break
            print("gear n'existe pas!")

print("gear opp:", gear_opp)
        
        # game
        pygame.init()
        screen = pygame.display.set_mode((game.width, game.height))
        pygame.display.set_caption(name)
        
        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
                    aff_win = False
                    break
            if not run:
                break
            key = pygame.key.get_pressed()
            if key[pygame.K_UP]:
                y -= game.base_J_DEP[0]
            if key[pygame.K_DOWN]:
                y += game.base_J_DEP[0]
            if key[pygame.K_LEFT]:
                x -= game.base_J_DEP[0]
            if key[pygame.K_RIGHT]:
                x += game.base_J_DEP[0]
            
            info = client.dialogue([x, y])
            if len(info) == 1:
                if info == client.DECO:
                    print("L'ADVERSAIRE C'EST DÉCONNECTER!!!!!")
                    run = False
            elif len(info) == 2:
                x2, y2 = info
                
            moi_aff.update(x=x + moi_aff.surface.get_width()//2, y=y - moi_aff.surface.get_height())
            opp_aff.update(x=x2 + opp_aff.surface.get_width()//2, y=y2 - opp_aff.surface.get_height())

screen.fill((255, 255, 255))
            screen.blit(j_moi, (x, y))
            screen.blit(j_opp, (x2, y2))
            moi_aff.draw(screen)
            opp_aff.draw(screen)
            pygame.display.update()
            clock.tick(60)

if __name__ == "__main__":
    addr = input("Entrer l'address: ")
    while True:
        port = input("Entrer le port: ")
        try:
            port = int(port)
            break
        except ValueError:
            print("Veuillez entrer un nombre entier pour le port.")
    test(addr, port)

dossier networking:

__init__.py

from .client import *

client.py

import socket
import json

class Client:
    def __init__(self, addr, port):
        self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.client.connect((addr, port))
        self.DECO = "DECO!"
        self.ok_message = "OK!"
        self.nope_message = "NOPE!"
        
    def send(self, msg):
        print("sending:", msg)
        self.client.send(json.dumps([msg]).encode())
        
    def recv(self):
        infos = self.client.recv(1024).decode()
        print(infos)
        return json.loads(self.client.recv(1024).decode())[0]

def dialogue(self, msg):
        self.send(msg)
        return self.recv()
    
    def __enter__(self):
        return self
        
    def __exit__(self, *_):
        self.send(self.DECO)
        
    def get_game(self, msg):
        self.dialogue(msg)
        return self.dialogue(self.ok_message)
    
    def get_username(self, msg):
        return self.dialogue(msg) == self.ok_message
    
    def get_map(self, msg):
        self.send(msg)
        if self.recv() == self.ok_message:
            return self.recv()
        
    def get_gear(self, msg):
        self.send(msg)
        if self.recv() == self.ok_message:
            return self.recv()

le dossier game:

__init__.py

from .sprite import Sprite
from .afficher import Afficher
from .get_path import path, separator
from .data import *

sprite.py

import pygame

class Sprite:
    __list = []

@classmethod
    def get_list(cls):
        return cls.__list

def __init__(self, coord: (int, int), surface: pygame.Surface):
        self.alive = True
        self.show = True
        self.x, self.y = coord
        self.surface = surface
        self.mask = pygame.mask.from_surface(self.surface)
        self.__list.append(self)
        self.nb = len(self.__list)
        self.nom = "Sprite{}".format(self.nb)

def draw(self, screen: pygame.Surface):
        if self.alive and self.show:
            screen.blit(self.surface, (self.x, self.y))

def is_coliding(self, m):
        if m == "all":
            check = self.__list
            check.remove(self)
        elif type(m) == tuple or type(m) == list or m is None:
            check = m
            if m == () or m == [] or m is None:
                return
        elif hasattr(m, "mask") and hasattr(m, "x") and hasattr(m, "y"):
            check = (m,)
        else:
            raise (ValueError("parameter m is not valid, please enter "all" "
                              "or a Mask or a tuple/list of Mask: not a {}".format(type(m))))
        res = []
        for sprite in check:
            if self.mask.overlap_mask(sprite.mask, (sprite.x - self.x, sprite.y - self.y)).count() != 0:
                try:
                    if sprite.alive:
                        res.append(sprite)
                except AttributeError:
                    res.append(sprite)
        return res

def __str__(self):
        return self.nom

def __repr__(self):
        return "{}->x:{},y:{}".format(self.nom, self.x, self.y)

def check_alive(self):
        if not self.alive:
            self.__list.remove(self)

def update(self):
        self.check_alive()

afficher.py

from .sprite import Sprite
from .get_path import path
import pygame

class Afficher(Sprite):
    def __init__(self, coord, texte, color, taille):
        police = pygame.font.Font(path+"arial_narrow_7.ttf", taille)
        texte_surface = police.render(texte, True,
                                      pygame.Color(color))
        super().__init__(coord, texte_surface)
        self.texte = texte
        self.taille = taille
        self.color = color
        self.nom = "Afficher{}".format(self.nb)

def update(self, texte=None, x=None, y=None):
        if texte is not None:
            police = pygame.font.Font(path+"arial_narrow_7.ttf", self.taille)
            self.surface = police.render(texte, True,
                                         pygame.Color(self.color))
        if x is not None:
            self.x = x
        if y is not None:
            self.y = y
        self.check_alive()

get_path.py

import os
import sys
separator = "/" if sys.platform == "linux" else "\"

path = __file__.split(separator)
path = path[:-1]
_ = ""
for p in path:
    _ += p + (separator)
path = _

data.py

import pygame

from .get_path import path
from .mur import Mur

pygame.init()
width, height = pygame.display.Info().current_w - 70, pygame.display.Info().current_h - 70

maps = [{"mur": [Mur(0, -100, width, 100), Mur(width, 0, 100, height), Mur(0, height, width, 100),
                 Mur(-100, 0, 100, height), Mur(-100, 0, 100, height),
                 Mur(width // 7, height // 3.3, 30, width // 4.5),
                 Mur(width // 7 * 6, height // 3.3, 30, width // 4.5),
                 Mur(width // 2 - 15, 0, 30, height // 6 + 10),
                 Mur(width // 2 - 15, height // 6 * 5, 30, height // 6 + 10)]}, ]

GEAR_LEN = 8
WH_PLAYER = 100
WH_TIR = 10

base_J_DEP = (10, 3)
base_J_VIE = 100

base_TIR_DEP = (15, 3)
base_TIR_DEGAT = 3

base_background = pygame.image.load(path + "space.png")
base_background = pygame.transform.scale(base_background, (width, height))

base_j1_image = pygame.image.load(path + "wizard_bleu.png")
base_j1_image = pygame.transform.scale(base_j1_image, (WH_PLAYER, WH_PLAYER))
base_j1_image.set_colorkey((255, 255, 255))

base_j1_image_wand = pygame.image.load(path + "wand_bleu.png")
base_j1_image_wand = pygame.transform.scale(base_j1_image_wand, (WH_PLAYER, WH_PLAYER))
base_j1_image_wand.set_colorkey((255, 255, 255))

base_j2_image = pygame.image.load(path + "wizard_rouge.png")
base_j2_image = pygame.transform.scale(base_j2_image, (WH_PLAYER, WH_PLAYER))
base_j2_image.set_colorkey((255, 255, 255))

base_j2_image_wand = pygame.image.load(path + "wand_rouge.png")
base_j2_image_wand = pygame.transform.scale(base_j2_image_wand, (WH_PLAYER, WH_PLAYER))
base_j2_image_wand.set_colorkey((255, 255, 255))

base_j1_image_tir = pygame.Surface((WH_TIR, WH_TIR))
base_j1_image_tir.fill((0, 0, 255))

base_j2_image_tir = pygame.Surface((WH_TIR, WH_TIR))
base_j2_image_tir.fill((255, 0, 0))

(-> jeu pas fini)

(pour ce qui veulent tester le jeu pour m'aider il faut aller télécharger la police arial narrow7.ttf.

Je pense que les erreurs viennent de socket.

J'ai essayé cette commande (sur linux) lorsque je cherchais une solution:

sysctl -w net.ipv4.tcp_timestamps=0

Rien n'a changé. Si vous n'avez pas tout compris, posez des questions et merci de m'aider à résoudre mon problème,

Flayme

Flayme · Answer

correction:

Ça ne marche pas seulement avec le "ngrok" que j'utilise

mamiemando · Answer

Bonjour,

Merci quand tu partages de préciser dans la cellule de code le langage de programmation (python).

Autant que possible, évite de mettre tout ton programme pour parler d'un problème précis. Il faut plutôt construire un exemple minimal qui met en évidence le problème, nous expliquer comment tu le lances, le comportement observé et le comportement attendu. Ici une grande partie du code partagé n'a vraisemblablement rien à avoir avec ton problème.

Vu que le projet est volumineux et contient des ressources qui ne sont pas du code (polices, images...) il vaudrait mieux mettre ton projet par exemple sur github et nous donner l'adresse du dépôt. Car là, il manque des fichiers pour tester ton code.

Je te propose de repartir sur cet exemple relativement minimal qui montre comment écrire en pygame un jeu multijoueur ou chaque joueur peut depuis sont client déplacer un carré qui lui est propre et voir le carré des autres joueurs.

Bonne chance

troplu · Answer

Salut, si tu souhaites avoir de l'aide afin d'identifier ce qui cloche, fais un zip de ton application que tu hébergeras quelque part afin que l'on ait pas à copier/coller chacun de tes codes dans chaque fichier, et surtout que l'on a juste à lancer ton programme pour pouvoir le déboguer, et si possible réduire au minimum ton script, il n'y a certainement pas besoin de tout ces fichiers, essaie d'identifier celui où cela bogue, client, serveur, et json, pas besoin de pygame et tous ces packages.

Sinon, comme d'habitude, des prints, des exceptions pour comprndre où ton programme plante. Déjà je vois un ÉNORME problème, c'est que tu as un fichier game, et un package game, nomme les différemment ! Même si ça fonctionne en l'état.

Bon courage.

Flayme · Answer

Pour corriger mon bug, j'ai encadré tout mes messages avec un caractère: "^" ce qui permet de savoir exactement ou commence et ou finit le message pour ne pas avoir d'interférence. Avant cela, il faut vérifier si le caractère est dans le message pour éviter les problèmes.

Je ne sais pas comment on fait pour marquer résolu ma question, donc si un modérateur pouvait le faire pour moi ce serait gentil.

Merci quand même d'avoir essayer de m'aider

Au revoir

Flayme

Bug socket linux windows

4 réponses