def start_game(self):
"""
"""
old = events.RootEventSource().remove_all_listeners()
events.RootEventSource().clear()
# revert players to player type
for idx, player in enumerate(config.players):
player.revert_to_type(self.spinners[idx + 1].get_current_value())
# 1 dice per land, minimum
for land in config.world.get_lands():
land.set_num_dice(1)
# additional dices per player
num_dice = len(config.world.get_lands()) * 2
player_num_dice = num_dice / len(config.players) + 1
print "starting game"
chat = gui.ChatModul("your_nick")
networkreplacement.NetworkReplacement()
# new start the game
g = game.Game(chat)
eventtypes.post_start_game(g)
g.run()
events.RootEventSource().remove_all_listeners()
events.RootEventSource().clear()
self.rand_lands()
self.setup_map()
events.RootEventSource().set_all_listeners(old)
def notify(self, subject):
"""
"""
## print "notify from: ", subject, " value: ", subject.get_current_value()
if subject == self.spinners[0]:
if len(self.spinners) - 1 > subject.get_current_value():
spinner = self.spinners.pop()
spinner.remove_observer(self)
events.RootEventSource().remove_listener(spinner)
self.texts.pop()
config.players.pop()
self.rand_lands()
elif len(self.spinners) - 1 < subject.get_current_value():
# add new spinner for player
xpos, ypos = self.spinners[-1].position
spinner = gui.Spinner(self.font, (xpos, ypos + 30))
for item in self.items:
spinner.add(item)
events.RootEventSource().add_listener(spinner)
self.spinners.append(spinner)
self.texts.append(gui.Text("Player "+str(len(self.spinners)-1)+\
": ", self.font, (xpos - 100, ypos + 30)))
config.players.append(Player(len(self.spinners) - 1))
self.rand_lands()
def on_keydown(self, event):
"""
Decides what do to with a keypress.
special meanings have these keys:
enter, left, right, home, end, backspace, delete
"""
if event.type != pygame.KEYDOWN:
print "textentry got wrong event:", event
else:
if event.key == pygame.K_RETURN:
self.on_enter()
elif event.key == pygame.K_RIGHT:
self.move_caret()
elif event.key == pygame.K_LEFT:
self.move_caret(-1)
elif event.key == pygame.K_HOME:
self.move_caret('home')
elif event.key == pygame.K_END:
self.move_caret('end')
elif event.key == pygame.K_BACKSPACE:
self.backspace_char()
elif event.key == pygame.K_DELETE:
self.delete_char()
else:
if event.unicode != u'':
if len(self.text) < self.max:
self.text = self.text[:self.caretpos]+ event.unicode+ \
self.text[self.caretpos:]
self.caretpos += 1
self.render()
### debug
if __name__ == '__main__' and event.key == pygame.K_ESCAPE:
events.RootEventSource().stop()
def __init__(self):
"""
"""
events.EventEnabled.__init__(self)
# data
self.players = config.players
self.world = config.world
self.current_player = None
self.state = 0 # 0=not started, 1=playing, 2=ended
# events
self.reg_event_func(eventtypes.ATTACKRESULT, self.on_attackresult)
## self.reg_event_func(eventtypes.ENDTURN, self.on_endturn)
self.reg_event_func(eventtypes.NEWTURN, self.on_newturn)
self.reg_event_func(eventtypes.PLAYERDEAD, self.on_playerdead)
self.reg_event_func(eventtypes.PLAYERWIN, self.on_playerwin)
self.reg_event_func(eventtypes.STARTGAME, self.on_startgame)
self.reg_event_func(eventtypes.ENDGAME, self.on_endgame)
self.reg_event_func(eventtypes.DROPDICE, self.on_dropdice)
self.reg_event_func(eventtypes.SELECTRESULT, self.on_selectresult)
self.reg_event_func(eventtypes.CONNINTERRUPT,
self.on_connectioninterrupt)
self.reg_event_func(eventtypes.PLAYERRECONN, self.on_playerreconnect)
print self.get_eventtypes()
# register it directly to source
events.RootEventSource().add_listener(self, prio=1)
def main():
# simulate the state after Multivote or Singleoptions
# init pygame and screen
pygame.init()
pygame.display.set_caption('Dice Wars')
logo = pygame.image.load(os.path.join('data', 'images', 'logo32x32.png'))
pygame.display.set_icon(logo)
pygame.display.set_mode((800, 600)) #, pygame.FULLSCREEN)
## # creade world
## oddlocator = pygame.image.load(os.path.join('data', 'images', 'oddLocator.PNG')).convert()
## evenlocator = pygame.image.load(os.path.join('data', 'images', 'evenLocator.PNG')).convert()
## grid = grids.HexagonGrid((30, 27), oddlocator, evenlocator,(100,10))
## config.world = MapGenerator()
## config.world.create(grid, diceland.DiceLandFactory(config.world), percent_grid_fill=0.8)
options = Singleoptions()
events.RootEventSource().add_listener(options)
events.RootEventSource().set_blocking(True)
options.run()
def on_keydown(self, event):
"""
Decides what do to with a keypress.
"""
if event.type != pygame.KEYDOWN:
print "textentry got wrong event:", event
else:
self.render()
### debug
if __name__ == '__main__' and event.key == pygame.K_ESCAPE:
events.RootEventSource().stop()
def on_keydown(self, event):
"""
Decides what do to with a keypress.
special meanings have these keys:
enter, left, right, home, end, backspace, delete
"""
if event.type != pygame.KEYDOWN:
print "textentry got wrong event:", event
else:
self.render()
### debug
if __name__=='__main__' and event.key == pygame.K_ESCAPE:
events.RootEventSource().stop()
def __init__(self, gamestate):
"""
"""
events.EventEnabled.__init__(self)
self.state = gamestate
self.selection = None
self.reg_event_func(ENDTURN, self.on_endturn)
self.reg_event_func(SELECT, self.on_select)
self.reg_event_func(STARTGAME, self.on_startgame)
self.reg_event_func(CONNINTERRUPT, self.on_connectioninterrupt)
self.reg_event_func(DROPDICE, self.on_drop_dice)
events.RootEventSource().add_listener(self)
def __init__(self):
"""
"""
events.EventEnabled.__init__(self)
self.eliza = eliza.eliza()
self.reg_event_func(eventtypes.CHATMSG, self.on_chatmsg)
self.reg_event_func(eventtypes.ELIZATIMER, self.on_timer)
events.RootEventSource().add_listener(self)
self.nick = "Darth: "
eventtypes.post_chatmsg(self, self.nick + "Do it.")
self.messages = []
def run(self):
"""
"""
screen = pygame.display.get_surface()
screen.fill((0, 0, 0))
while self._running:
events.RootEventSource().update()
for button in self.buttons:
screen.blit(button.image, button.position)
for spinner in self.spinners:
screen.blit(spinner.image, spinner.position)
for text in self.texts:
screen.blit(text.image, text.position)
screen.blit(self._preview, (20, 20))
pygame.display.flip()
screen.fill((0, 0, 0))
def __init__(self, chat):
"""
"""
events.EventEnabled.__init__(self)
self.gamestate = GameState()
self.game_logic = GameLogic(self.gamestate)
self.graphics = Graphics()
self.event_source = events.RootEventSource()
self.event_source.set_blocking(False)
self.chat = chat
self._running = True
self.reg_event_func(pygame.QUIT, self.on_quit)
self.reg_event_func(pygame.KEYDOWN, self.on_key)
self.event_source.add_listener(self)
self.clock = pygame.time.Clock()
def __init__(self, nickname, lines=5, width=600):
"""
"""
self.dirty = True
events.EventDispatcher.__init__(self)
font = pygame.font.Font(None, 22)
self.text_entry = textentry.TextEntry(nickname, font, width)
self.scroll_text = scrolltext.ScrollText(font, lines, width)
self.image = pygame.Surface((width+10, self.text_entry.size[1]+\
self.scroll_text.size[1]+15)).convert()
self.image.fill((255, 255, 255))
self.on_afterevent(1)
# event stuff
self.add_listener(self.text_entry)
self.add_listener(self.scroll_text)
events.RootEventSource().add_listener(self)
def __init__(self, player_id):
"""
id should be a unique id.
"""
events.EventEnabled.__init__(self)
self._lands = []
self._player_id = player_id
self.dead = False
self._myturn = False
self._implementation = None
## self.revert_to_type(HUMAN)
# register event functions
# TODO: perhaps this should be done when entering
# Multigame or Singlegame
self.reg_event_func(eventtypes.NEWTURN, self.on_newturn)
# register at a dispatcher, here source
events.RootEventSource().add_listener(self)
def __init__(self):
"""
"""
events.EventEnabled.__init__(self)
self.screen = pygame.display.get_surface()
self.world = config.world
self.player_color = {}
# color for each player (actually an index)
idx = 0
print ">>>>>>>>>Graphics:", config.players
for player in config.players:
self.player_color[player] = idx
idx += 1
# load tiles
dir_path = join_path('data', 'images')
tile_names = ['hexDGruen.PNG','hexGelb.PNG','hexHGruen.PNG', \
'hexOrange.PNG','hexRosa.PNG','hexRot.PNG', \
'hexTuerkis.PNG','hexViolette.PNG','hexSchwarz.PNG']
self.tiles = []
for name in tile_names:
path = join_path(dir_path, name)
img = pygame.image.load(path).convert()
img.set_colorkey((0x80, 0x00, 0x80))
self.tiles.append(img)
# generate map image with borders
self.map_img = None
self.generate_borders()
random.shuffle(self.tiles[:-1])
if len(self.tiles) != len(self.player_color):
print "num tiles:", len(self.tiles), "num player:", len(
self.player_color)
self.current = None
## self.reg_event_func(eventtypes.ATTACKRESULT, self.on_attack_result)
self.reg_event_func(eventtypes.NEWTURN, self.on_newturn)
events.RootEventSource().add_listener(self)
pygame.time.set_timer(eventtypes.ELIZATIMER, 0)
msg = self.messages.pop(0)
resp = self.eliza.respond(msg)
resp = self.nick + resp
eventtypes.post_chatmsg(self, resp)
if len(self.messages) > 0:
self.set_timer()
def set_timer(self):
"""
"""
interval = random.randint(1500, 10000)
print interval
pygame.time.set_timer(eventtypes.ELIZATIMER, interval)
if __name__ == '__main__':
import pygame
import gui
pygame.init()
screen = pygame.display.set_mode((800, 600))
chat = gui.ChatModul("nickname", 10)
NetworkReplacement()
pygame.key.set_repeat(500, 30)
while 1:
screen.fill((0, 0, 0))
events.RootEventSource().update()
screen.blit(chat.image, (0, 0))
pygame.display.flip()
xpos = self.font.size(self.text[:self.caretpos])[0] + 2
pygame.draw.line(self.image, (255, 255, 255, 255), (xpos, 2), \
(xpos, self.image.get_height()-2), 1)
else:
pygame.draw.line(self.image, (255, 255, 255), (3, 2), \
(3, self.image.get_height()-2), 1)
pygame.draw.rect(self.image, (100, 100, 100), self.text_field_rect, 2)
def update(self):
"""
Actually not needed. (only need if this module is run as a script)
"""
# only need if this module is run as a script
if __name__ == '__main__':
print self.text, len(self.text), self.caretpos
screen = pygame.display.get_surface()
screen.fill((0, 0, 0))
screen.blit(self.image, (100, 100))
pygame.display.flip()
if __name__ == '__main__':
pygame.init()
pygame.key.set_repeat(500, 30)
pygame.display.set_mode((800, 600))
t = TextEntry("supernick:", pygame.font.Font(None, 22))
events.RootEventSource().add_listener(t)
print t.parent
events.RootEventSource().set_blocking(True)
events.RootEventSource().run(t.update)
def __init__(self):
"""
"""
events.EventEnabled.__init__(self)
font = pygame.font.Font(None, 25)
self.font = font
# create gui elements
self.buttons = []
self.buttons.append(
gui.Button(font, "randomize map", (50, 350), self.rand_map))
self.buttons.append(
gui.Button(font, "randomize regions", (200, 350), self.rand_lands))
self.buttons.append(gui.Button(font, "exit", (500, 350), self.quit))
self.buttons.append(
gui.Button(font, "start", (600, 350), self.start_game))
self.spinners = []
self.texts = []
# number of players
xpos = 500
ypos = 30
self.texts.append(gui.Text("number of Players: ", font, (xpos, ypos)))
spinner = gui.Spinner(font, (xpos + 180, ypos), False)
for num in range(2, 9):
spinner.add(gui.Item(str(num), num))
spinner.register_observer(self)
self.spinners.append(spinner)
# player config
self.items = []
self.items.append(gui.Item("human", player.HUMAN))
self.items.append(gui.Item("passive AI", player.AI_PASSIVE))
self.items.append(gui.Item("expander AI", player.AI_DUMB))
self.items.append(gui.Item("AI 1", player.AI_1))
self.items.append(gui.Item("none", None))
for num in range(2):
ypos += 30
spinner = gui.Spinner(font, (xpos + 100, ypos))
if num == 2:
self.items.insert(0, self.items.pop(-1))
for item in self.items:
spinner.add(item)
## spinner.register_observer(self)
self.spinners.append(spinner)
self.texts.append(gui.text.Text("Player "+str(num+1)+": ", font, \
(xpos, ypos)))
self.texts.append(gui.text.Text( \
"Quick instructions", font, (10, 460)))
self.texts.append(gui.text.Text( \
"Right click to end turn, Left click to select regions", font, \
(10, 500)))
self.texts.append(gui.text.Text( \
"You have to first select any of your regions with more than 1 dice on it, then you can attack an", font, (10, 530)))
self.texts.append(gui.text.Text( \
"adjacent region of different colour/player" , font, (10, 560)))
# data
self._running = True
self._preview = pygame.Surface((0, 0))
self._preview.fill((255, 255, 255))
# events
self.reg_event_func(pygame.KEYDOWN, self.on_keydown)
self.reg_event_func(pygame.QUIT, self.quit)
for spinner in self.spinners:
events.RootEventSource().add_listener(spinner)
for button in self.buttons:
events.RootEventSource().add_listener(button)
self.setup_map()