Bienvenue sur IndexError.

Ici vous pouvez poser des questions sur Python et le Framework Django.

Mais aussi sur les technos front comme React, Angular, Typescript et Javascript en général.

Consultez la FAQ pour améliorer vos chances d'avoir des réponses à vos questions.

Librairie python de game logic pour des jeux sur un quadrillage 2D

+2 votes

Est-ce qu'il existe une librairie python permettant des opérations de base sur des quadrillage en 2D ? (Par exemple, pour implémenter des game logic de jeux de plateaux)

L'origine de mon besoin, c'est le site codingame. Plusieurs jeux et challenges y sont proposés, dont beaucoup sur des plateaux en 2D (carrés ou hexagones), il faut coder un bot qui va jouer tout seul, s'opposer aux autres bots, etc.

Et au passage, cette librairie permettrait de créer des jeux de plateaux, de prototyper rapidement des concepts de jeux, etc.

Idéalement, il faudrait que cette librairie soit assez simple, et pas trop dépendante d'autres librairies. Comprendre : si je copie-colle tout le code de la lib dans codingame, il faut que ça marche.

Ça ressemblerait à quelque chose de ce genre :

import aboard

class MyTile(aboard.Tile):

    def __init__(self):
        self.data = ''

    # override d'une fonction existante
    def draw_on_board(self):
        if self.data:
            return self.data
        else:
            if (self.x+self.y) % 2:
                return '.'
            else:
                return '-'

# Initialisation du plateau de jeu
board = aboard.Board(
    width=8, height=7,
    tile=MyTile,
    adj_rule=aboard.no_diagonal,
    tilespacing_x=1, tilespacing_y=0)

print(board.draw())

- . - . - . - .
. - . - . - . -
- . - . - . - .
. - . - . - . -
- . - . - . - .
. - . - . - . -
- . - . - . - .


# Dessin de lignes
iter_lines = board.lines(
    ((3, 1), (6, 4), (1, 5), (3, 1), ),
    adj_rule=aboard.diagonal)

for tile in iter_lines:
    tile.data = 'A'

print(board.draw())

- . - . - . - .
. - . A . - . -
- . A . A . - .
. - A - . A . -
- A - . A A A .
. A A A . - . -
- . - . - . - .


# Propagation (option "pot de peinture" dans Paint)
for dist, tile in board.enum_propagate(
    (3, 3),
    can_propagate=lambda tile: not tile.data):

    tile.data = str(dist)

print(board.draw())

- . - . - . - .
. - . A . - . -
- . A 1 A . - .
. - A 0 1 A . -
- A 2 1 A A A .
. A A A . - . -
- . - . - . - .


# Pathfinding
for tile in board.path(
    (3, 6),
    (5, 1),
    shortest=True,
    any_path=True,
    can_propagate=lambda tile: tile.data in ('', 'A')):

    tile.data = 'Z'

print(board.draw())

- . - . - . - .
. - . A . Z . -
- . A 1 A Z - .
. - A 0 1 Z . -
- A 2 1 Z Z A .
. A A Z Z - . -
- . - Z - . - .

Et évidemment, il y aurait plein d'autres fonctionnalités :

  • objets déplaçables sur le board (comme des pions),
  • objets prenant la place de plusieurs tiles,
  • pattern-matching (pour détecter des pions alignés), etc.

Est-ce que ça existe déjà ? Si oui, ou ça ?

Est-ce que des lib comme numpy permettrait ce genre de traitement ?

demandé 25-Jul par recher (380 points)
edité 28-Jul par recher

tout ce qui concerne le devgame sous python est susceptible de m intéresser,

penses a moi quand tu auras quelque chose de testable

1 Réponse

+1 vote

tu peux jeter un coup d'oeil ici, ça peux partiellement faire avancer ton projet:
https://www.mapeditor.org/

une bonne ressource :
https://www.redblobgames.com/grids/hexagons/implementation.html#dynamic-typing

aussi:
https://github.com/mklauber/pygame-hex-grid

répondu 26-Jul par buffalo974 (2,690 points)

Bon, il n'y a rien qui me soit immédiatement exploitable pour codingame. Je vais sûrement finir par me faire ma propre lib.

Mais merci quand même, car il y a des ressources intéressantes. Je ne connaissait pas redblobgames, c'est une mine d'or !

...