Code: Alles auswählen
..........
..........
..........
..........
..........
Code: Alles auswählen
..........
...X......
..........
.....O....
..........
Code: Alles auswählen
..........
...X......
..........
.....O....
..........
Enter Command-> O down
Code: Alles auswählen
..........
...X......
..........
..........
.....O....
Enter Command->
Code: Alles auswählen
from math import sqrt
class Hexfeld(object):
"""
Diese Klasse beschreibt ein Hexfeld, dass auf dem Spielbrett dargestellt
werden kann.
"""
length = 20
# Array mit den Randpunkten des Hexfeldes beginnend mit
# dem Punkt (x0,y0) in der linken oberen Eche.
pts = [0,0,length,0,length*3.0/2.0, length*sqrt(3)/2.0,length,
length*sqrt(3),0,length*sqrt(3),-length/2.0,length*sqrt(3)/2.0]
def __init__(self, spielbrett, xpos, ypos, zeile, feldnr, color="green"):
""" Konstrukor der Klasse Hexfeld """
self.spielbrett = spielbrett
self.xpos = xpos #: X-Koordinate links oben
self.ypos = ypos #: Y-Koordinate links oben
self.zeile = zeile
self.feldnr = feldnr
self.color = color #: Farbe des Feldes bzw. die ID
self.printInfo()
self.__pts = [] + self.pts
for k in range(0, len(self.__pts), 2):
self.__pts[k] += self.xpos
self.__pts[k+1] += self.ypos
def draw(self):
""" Methode zum Zeichnen des aktuellen Hexfeldes """
self.spielbrett.create_polygon(self.__pts, outline="black",fill=self.color)
def printInfo(self):
""" Methode zum anzeiden der Attribute dieses Hexfeldes """
print "xpos : ", self.xpos
print "ypos : ", self.ypos
print "Farbe : ", self.color
print "Zeile : ", self.zeile
print "FeldNr. : ", self.feldnr
Code: Alles auswählen
import Tkinter as tk
from Hexfeld import Hexfeld
from random import choice
from math import sqrt
class Spielbrett(tk.Canvas):
""" Klasse, die das Spielbrett darstellt. Wir erben von Canvas,
um bequem zeichnen zu koennen. """
def __init__(self, window):
""" Konstruktor """
tk.Canvas.__init__(self, window, width=1024, height=768)
self.pack()
self.hexList = []
self.initHexfelder()
def drawHexfield(self):
""" Methode zum Zeichnen der Hexfelder """
for h in self.hexList:
h.draw()
def initHexfelder(self):
""" Methode zum initialisieren der Hexfelder (Aufbau wie vorher !) """
ungerade_spalten = 2
gerade_spalten = 1
spielfeld = 2
farbe = ("green","green","green","green","green","green",
"brown","green","blue","green")
#Vorbelegung der Spalten/Zeilen
xpos = xorg = 20
ypos = yorg = 10
xoffset = Hexfeld.length*1.5
yoffset = sqrt(3)*Hexfeld.length;
#Platziere den zweidimensionalen Sechseck-Array
for i in range(spielfeld):
if i%2 == 0:
for x in range(ungerade_spalten):
self.hexList.append(Hexfeld(self,xpos,ypos,i+1,x+1,choice(farbe)))
xpos = xpos + (xoffset * 2)
xpos = xorg + xoffset
ypos = ypos + yoffset / 2
else :
for x in range(gerade_spalten):
self.hexList.append(Hexfeld(self,xpos,ypos,i+1,x+1,choice(farbe)))
xpos = xpos + (xoffset *2)
xpos = xorg
ypos = ypos + yoffset / 2
Code: Alles auswählen
import Tkinter as tk
from Spielbrett import Spielbrett
def main():
print("Test des Hexfeldes")
window = tk.Tk()
# Instanz des Spielbrettes erzeugen
s = Spielbrett(window)
# ... und die Hexfelder zeichnen
s.drawHexfield()
window.mainloop()
if __name__ == "__main__":
main()
Code: Alles auswählen
class Map(object):
def __init__(self, width, height):
pass
def __getitem__(self, coordinates):
pass
def __setitem__(self, coordinates, tile):
pass
def neighbour_coordinates(self, coordinates):
passCode: Alles auswählen
class Tile(object):
def __init__(self, name):
self.name = name
DESERT = Tile('Desert')
WOODS = Tile('Woods')
class Map(object):
DIRECTION_DELTAS = [(0, -1), (1, 0), (0, 1), (-1, 0)]
def __init__(self, width, height, tile=DESERT):
self.tiles = [[tile] * width for dummy in xrange(height)]
def __getitem__(self, coordinates):
x, y = coordinates
return self.tiles[y][x]
def __setitem__(self, coordinates, tile):
x, y = coordinates
self.tiles[y][x] = tile
def neighbour_coordinates(self, coordinates):
x, y = coordinates
for delta_x, delta_y in self.DIRECTION_DELTAS:
new_x = x + delta_x
new_y = y + delta_y
if 0 <= new_x < self.width and 0 <= new_y < self.height:
yield new_x, new_y
def main():
game_map = Map(10, 10)
game_map[2, 4] = WOODS
for x, y in [(2, 4), (3, 2)]:
print game_map[x, y].name
print list(game_map.neighbour_coordinates((1, 1)))Code: Alles auswählen
def __init__(self, width, height, tile=DESERT):
self.tiles = [[tile] * width for dummy in xrange(height)]
self.width = width
self.height = height
Code: Alles auswählen
@property
def width(self):
return len(self.tiles[0])
@property
def height(self):
return len(self.tiles)
Code: Alles auswählen
def main():
game_map = Map(10, 10)
def __init__(self, width, height, tile=DESERT):
self.tiles = [[tile] * width for dummy in xrange(height)] Code: Alles auswählen
game_map = Map(10, 10) Code: Alles auswählen
self.tiles = [[tile] * width for dummy in xrange(height)] Nein, das sind weder Getter noch Setter - dies wären Funktionen die man selbst schreibt um auf Werte zuzugreifen. So etwas ist eher in Java üblich, in Python würde man einfachen Attributzugriff nutzen und, wenn man die Werte prüfen/errechnen muss dann Properties die eine Art (transparente) Getter/Setter sind (am besten liest du selbst mal dazu nach, denn es scheint mir etwas Sinnfrei zu sein, Beispiele auszudenken, wenn es im Internet schon genug gibt).wuf hat geschrieben:Die magischen Methoden __getitem__ und __setitem__ sind neu für mich. Gehe ich richtig in der Annahme diese beiden Methoden (scheinbar als 'geter' und 'seter' bekannt) dürfen nur einmal in einer Klasse vorkommen und zwar aus dem Grund weil sie ohne Methode-Bezeichnung aufgerufen werden
Code: Alles auswählen
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#~ Skriptname programm_logic_01_01.py (20.07.2008)
class Tile(object):
"""Klasse:Spielfeld"""
def __init__(self, name):
"""Konstruktor für die Klasse"""
self.name = name
#~~ Spielfeld-Instanzen
DESERT = Tile('Desert')
WOODS = Tile('Woods')
class Map(object):
"""Klasse:Spielkarte"""
#~~ Konstante für die Abfrage der Nachbarfelder
DIRECTION_DELTAS = [(0, -1), (1, 0), (0, 1), (-1, 0)]
#~~ Gibt die Anzahl x-Felder (Spalten) zurück
@property
def width(self):
return len(self.tiles[0])
#~~ Gibt die Anzahl y-Felder (Reihen) zurück
@property
def height(self):
return len(self.tiles)
def __init__(self, width, height, tile=DESERT):
"""Konstruktor für die Klasse"""
#~~ Erzeugt eine Feldobjekt-Liste mit der
# Anzahl 'width' * 'height' Feldobjekten
self.tiles = [[tile] * width for dummy in xrange(height)]
def __getitem__(self, coordinates):
"""Adressiert das Feldobjekt"""
x, y = coordinates
return self.tiles[y][x]
def __setitem__(self, coordinates, tile):
"""Setzt den Feldtyp"""
x, y = coordinates
self.tiles[y][x] = tile
def neighbour_coordinates(self, coordinates):
"""Ermittelt die Koordinaten der Nachbarfelder"""
x, y = coordinates
for delta_x, delta_y in self.DIRECTION_DELTAS:
new_x = x + delta_x
new_y = y + delta_y
if 0 <= new_x < self.width and 0 <= new_y < self.height:
yield new_x, new_y
def main():
#~~ Erstellt ein Spielfeld mit 10 * 10 Feldobjekten (default-Feldyp = 'Desert'
SPALTEN = COLUMNS = 10
REIHEN = ROWS = 10
#~~Erstellt eine Instanz der Spielfeld-Klasse (Map)
game_map = Map(SPALTEN, REIHEN)
print 'Anzahl Spalten',game_map.width
print 'Anzahl Reihen',game_map.height
#~~ Ändert den Feldtyp des Feld auf Koordinate x=2,y=4
# in ein Feldtyp 'Wood' um
game_map[2, 4] = WOODS
#~~ Test: Abfrage des Feldtyp-Namens der Felder auf Koordinate:
# a) x=2,y=4 ('Wood')
# b) x=3,y=2 ('Desert')
for x, y in [(2, 4), (3, 2)]:
print game_map[x, y].name
print 'Nachbar-Koordinate',list(game_map.neighbour_coordinates((1, 1)))
#~~ Gibt die Koordinaten der Nachbarfelder des
# Testfeldes auf Koordinate x=1,y=1 zurück.
#
# Testfeld X x=1,y=1
# Nachbarfeld a x=1,y=0
# Nachbarfeld b x=0,y=1
# Nachbarfeld c x=1,y=2
# Nachbarfeld d x=2,y=1
#
# 0 1 2 3 - x
# ------------------
# 0 | | a | | |
# ------------------
# 1 | b | X | d | |
# ------------------
# 2 | | c | | |
# ------------------
# 3 | | | | |
# ------------------
# x | | | | |
main()Code: Alles auswählen
self.tiles = [[tile] * width for dummy in xrange(height)]
Code: Alles auswählen
self.tiles = [[Tile('Desert') for x in xrange(width)] for y in xrange(height)]