Jeu d'aventure - se promener dans une pièce

Question

Je travaille sur un jeu d'aventure en Python en utilisant Pygame. Mon principal problème est de savoir comment je vais définir les limites de la pièce et faire en sorte que le personnage principal marche sans toucher une frontière à chaque fois. Malheureusement, je n'ai jamais étudié les algorithmes, donc je n'ai aucune idée sur la façon de calculer un chemin. Je sais que cette question est assez générale et difficile à répondre, mais un point dans la bonne direction serait très apprécié. Merci!

Answer 1

Je vous recommande de lire l'algorithme de recherche A* car il est couramment utilisé dans les jeux pour les problèmes de cheminement.

Si ce jeu est bidimensionnel (ou 2.5), je vous suggère d'utiliser un système de carreaux car la vérification des collisions sera plus facile. Theres beaucoup d'informations en ligne qui peuvent vous aider à démarrer avec ceux-ci.

Answer 2

Malheureusement, je n'ai jamais étudié d'algorithmes, donc je n'ai aucune idée sur la façon de calculer un chemin.

Avant de commencer à écrire des jeux, vous devez vous renseigner sur ceux-ci. Cela prend un peu plus d'effort au début, mais vous permettra d'économiser beaucoup de temps plus tard.

Answer 3

Je ne suis pas familier avec pygame, mais de nombreuses applications utilisent généralement bounding volumes pour définir le bord de certaines régions. L'idée est que lorsque votre personnage marche, vous vérifiez si le volume des caractères croise le volume d'un mur. Vous pouvez alors ajuster la vélocité ou empêcher votre personnage de bouger. Utilisez des formes différentes pour obtenir un mur lisse afin que votre personnage ne reste pas coincé sur les bords pointus.

Ces concepts peuvent être utilisés pour toute application nécessitant une détection rapide des bords et des limites.

Answer 4

Il y a deux façons simples de définir vos limites qui sont appropriées pour un tel jeu.

La méthode la plus simple consiste à diviser votre zone en une grille et à utiliser un tableau 2D pour suivre quels carrés de la grille sont passables. Habituellement, ce tableau stocke aussi les informations de votre carte, donc dans chaque position, il y a un nombre qui indique si ce carré contient de l'herbe ou un mur ou une route ou une montagne etc. (et donc quelle image afficher). Pour vous donner une image approximative:

###### 
#.# # 
# ## # 
# # 
###### 

Une méthode plus complexe qui est nécessaire si vous voulez une sorte de regard « labyrinthe », avec parois minces, est d'utiliser un tableau 2D qui indique s'il y a un mur vertical entre les carrés de la grille, et aussi s'il y a un mur horizontal entre les carrés de la grille. Une image brute (il semble un étiré en ASCII, mais nous espérons que vous aurez le point):

- - - - 
| |  | 
    - - 
|  | 
- - - - 

La prochaine chose à décider est ce que les directions de votre personnage peut se déplacer dans (haut/bas/gauche/droite est plus facile , mais les diagonales ne sont pas trop beaucoup plus difficile). Ensuite, le programme doit essentiellement «mentalement» explorer la zone, à partir de votre position actuelle, dans l'espoir de trouver la destination.

Une recherche simple qui est facile à implémenter pour le haut/bas/gauche/droite et vous trouverez le chemin le plus court, s'il y en a un, est appelée Breadth-First search. Voici quelques pseudo-code:

queue = new Queue #just a simple first-in-first-out 
queue.push(startNode) 
while not queue.empty(): 
    exploreNode = queue.pop() 
    if isWalkable(exploreNode): #this doesn't work if you use 
           #"thin walls". The check must go 
           #where the pushes are instead 

     if isTarget(exploreNode): 
      #success!!! 
     else: 
      #push all neighbours 
      queue.push(exploreNode.up) 
      queue.push(exploreNode.down) 
      queue.push(exploreNode.left) 
      queue.push(exploreNode.right) 

Cet algorithme est lent pour les grandes cartes, mais il vous habituer à des graphes recherche et les concepts pathfinding.Une fois que vous avez vérifié que cela fonctionne correctement, vous pouvez essayer de le remplacer par A * ou quelque chose de similaire, ce qui devrait donner les mêmes résultats en moins de temps!

A * et de nombreux autres algorithmes de recherche utilisent une file d'attente prioritaire au lieu d'une file d'attente FIFO. Cela leur permet d'envisager d'abord les chemins "plus probables", mais de contourner les chemins d'accès en sens inverse s'il s'avère que les chemins les plus directs sont bloqués.