JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=50831d506671d82735f09f8baa765beeMedaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

Damits hier nicht ausstirbt.. Webgames!

 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Projekte
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
xardias
JLI Master


Alter: 37
Anmeldedatum: 28.12.2003
Beiträge: 804
Wohnort: Palo Alto, CA
Medaillen: Keine

BeitragVerfasst am: 30.10.2008, 22:25    Titel: Damits hier nicht ausstirbt.. Webgames! Antworten mit Zitat

Aloha!

http://dev-area.net:8095/ (Funktioniert momentan NICHT im IE)

Ich hab mal mal wieder mit Spieleprogrammierung angefangen. Was ihr da oben im Link seht ist ein Webgame welches über nen Python Server läuft und mittels Javascript und JSON mit dem Browser kommuniziert.
Dabei kann man gegen eine AI spielen, oder gegen einen Freund über das Internet.

Das Spiel selbst ist noch ein bischen Buggy, daran arbeite ich gerade.

Der Clou an der Sache ist.. die Spiellogik ist in eine Klasse gekapselt. Alles was sich auf einer Art Sachbrett (beliebig groß) durch setzen und verschieben von Steinen spielen lässt kann man damit in wenigen Zeilen implementieren (Hab hier noch nen halbfertiges 4-Gewinnt liegen.. 100 Zeilen Code Wink).
Die komplette Synchronisierung, die Anzeige im Client, das verwalten von Sessions, Spielen und Spielern etc übernimmt das Framework.

(Es lassen sich sogar (jedoch mit etwas mehr Aufwand) neue "Models" nutzen. Also statt eines Schachbretts kann man ein Model für Kartenspiele schreiben und eben dafür neue Spielregeln).

Ist noch alles in Aufbau, aber ich denke ich ein paar Wochen sollte die API für die Spiele stabil sein. Dann kann man das Model etwas erweitern (Neue Figuren etc) und sollte damit schon ein dicken Satz an Spielen implementieren können Wink.

Die AI lässt sich auch Spielunabhängig entwickeln so lange man sie darauf beschränkt sich mit einem Zahlenwert als Situationsbeurteilung zu beschränken. Die Spielregeln sagen der AI mehr oder weniger wie "gut" ein Spielstand für den Spieler aussieht. Damit lassen sich einfache Minmax AIs implementieren. Alles andere wird natürlich was komplexer.

Grüße,
Dennis
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
xardias
JLI Master


Alter: 37
Anmeldedatum: 28.12.2003
Beiträge: 804
Wohnort: Palo Alto, CA
Medaillen: Keine

BeitragVerfasst am: 31.10.2008, 12:36    Titel: Antworten mit Zitat

Ich habe damit gerade mal TicTacToe implementiert, da das Spiel recht kompakt ist ist der Code eigentlich sehr schön und verständlich. Lade noch auf den Server, dann kann man es auch spielen Wink

Code:

class XXORules(object):   
   """
       Regelwerk für TicTacToe. Definiert mögliche Züge,
        die Ausführung von Zügen und den Spielablauf.
   """
   
   
   def __init__(self, info):
      """
         Erstelle die sog. check listen. Eine check list enthält eine Reihe von
         Koordinaten (x, y) welche in einer Reihenfolge auf
         Zusammengehörigkeit geprüft werden sollen. Wenn die Felder einer dieser Listen
         komplett einem Spieler gehört hat dieser gewonnen. Siehe determine_winner.
      """
      
      width, height = info.board_dimensions
      
      # Prüfe eine Zeile [(0, y), (1, y), (2, y)] für jede möglichen y-Wert.
      horizontal = [[(x, y) for x in range(0, width)] for y in range(0, height)]
      
      #Prüfe eine Spalte [(x, 0), (x, 1), (x, 2)] für jede möglichen x-Wert.
      vertical = [[(x, y) for y in range(0, width)] for x in range(0, height)]
      
      #Zuletzt noch die diagonalen Möglichkeiten [ (0, 0), (1, 1), (2, 2) ] ...
      diagonal = [[(x, x) for x in range(0, width)], [(x, width-x-1) for x in range(0, width)]]
      
      # Füge Zeilen-, Spalten- und Diagonallisten zusammen
      self.check_lists = []
      for set in (horizontal, vertical, diagonal):
         self.check_lists.extend(set)
      
      
   def get_player_scores(self, model):
      """
         Wird in diesem Spiel nicht benötigt.
      """
      return dict(white=Score(), black=Score())
   
   def get_active_player(self, model):
      """
         Muss den Spieler zurückgeben von dem der nächste
         Zug erwartet wird.
      """
      return model.active_player
   
   
   def is_running(self, model):
      """
         Muss True zurückgeben so lange das Spiel noch läuft. False
         wenn es beendet ist.
      """
      # haben wir einen Gewinner? -> Spiel vorbei
      winner = self.determine_winner(model)
      if winner:
         return False
      else:
         # Kein Gewinner aber alle Felder voll? -> Spiel vorbei
         for x, y in nrange(model.board.dimensions):
            if model.board.get_field(x, y) is None:
               return True
         return False


   def start_game(self, model):
      """
         Setze den Spieler der den ersten Zug machen darf.
      """
      model.active_player = model.player["white"]
   
   
   def determine_winner(self, model):
      """
         Erkenne ob ein Spieler das Spiel gewonnen hat oder nicht.
      """
      
      def check_list(list):
         """
            Prüfe ob alle Koordinaten in der liste dem selben Spieler gehören
         """
         x, y = list[0]
         first_field = model.board.get_field(x, y)
         if not first_field:
            return None
         else:
            for x, y in list[1:]:
               field = model.board.get_field(x, y)
               if field is None or field.owner is not first_field.owner:
                  return None
            return first_field.owner
      
      # Prüfe alle listen
      # Wenn eine Liste komplett einem Spieler gehört gewinnt er das Spiel
      for list in self.check_lists:
         winner = check_list(list)
         if winner:
            return [winner]
         
      # Noch hat niemand gewonnen
      return None
      
   def check_action(self, model, action):
      """
         Darf die gegebene Aktion ausgeführt werden?
         gibt True zurück, wenn das Feld frei ist.
      """
      (x, y) = action.position
      return model.board.get_field(x, y) is None

   def get_possible_moves(self, model, player):
      """
         Liste alle möglichen Züge auf. Also alle Züge für die
         check_action True ist.
      """
      possible = []
      for (x, y) in nrange(model.board.dimensions):
         action = SetFigureAction(player, (x, y), Figure(Figure.STONE, player))
         if self.check_action(model, action):
            possible.append(action)
      return possible

   def swap_active_player(self, model):
      """
         Hilfsfunktion. Tauscht den aktuellen Spieler.
      """
      white = model.player["white"]
      black = model.player["black"]
      model.active_player = white if model.active_player is black else black

   def perform_action(self, model, action):
      """
         Führe eine Aktion aus. Also setze den Spielstein auf das Feld.
      """
      (x, y) = action.position
      model.board.fields[x][y] = Figure(action.stone, action.player)
      self.swap_active_player(model)

Sind ohne Kommentare nur 70 Zeilen code.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
DirectXer
Dark JLI'ler



Anmeldedatum: 05.02.2005
Beiträge: 1201
Wohnort: Köln
Medaillen: Keine

BeitragVerfasst am: 01.11.2008, 21:29    Titel: Antworten mit Zitat

ahja die hatteste auch im IRC gezeigt ;) da gabs auch schon n lustigen Screenshot zu nem Bug :P

Gruß DXer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
xardias
JLI Master


Alter: 37
Anmeldedatum: 28.12.2003
Beiträge: 804
Wohnort: Palo Alto, CA
Medaillen: Keine

BeitragVerfasst am: 03.11.2008, 09:35    Titel: Antworten mit Zitat

Jo daran arbeite ich noch. Die TODO Liste ist einfach noch soooo lang.. Wink
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Projekte Alle Zeiten sind GMT
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum