def setUp(self):
self.menu = Fake_menu()
self.game = Game((800, 600), 40, self.menu)
self.inputqueue = None
self.display = Mocup_display(0)
self.clock = Fake_clock()
self.set_event([(0, -40, "D"), (40, 0, "R")], 200)
def getOutOfBounds(self, border=10):
"""Gets a Struct containing Rects that are just outside the camera boundaries."""
bounds = self.getBounds()
oobleft = Game.Rect(bounds.left-border, bounds.top-border,\
border,bounds.height+border*2)
oobright = Game.Rect(bounds.right, bounds.top-border,\
border,bounds.height+border*2)
oobtop = Game.Rect(bounds.left-border, bounds.top-border,\
bounds.width+border*2, border)
oobbottom = Game.Rect(bounds.left-border, bounds.bottom,\
bounds.width+border*2, border)
l = [r.move(-Game.scroll.x, -Game.scroll.y) for r in \
oobleft, oobright, oobtop, oobbottom]
return Struct(left=l[0], right=l[1], top=l[2], bottom=l[3])
def __init__(self, width=640, height=480, fps=60, scale=1):
super(World, self).__init__(width, height, fps, scale)
# camera position (this is a basis position for all drawing)
self.camera = point.Point(0, 0)
Game.scroll = Game.camera = self.camera
# which object is the focus of the camera
self.focus = None
# how far away the camera (center of the screen) should be from the focus
self._focusLead = None
# how fast the camera should "catch up" to the focus
self._followSpeed = 1.0
# the boundaries of camera movement
self._followMin, self._followMax = None, None
# SDL uses 16-bit coordinates for drawing, so these are the maximum bounds
# Range of a 16-bit integer = -32,678 to +32,767 (or -2**15 to 2**15 - 1)
self._bounds = Game.Rect(-(1 << 15), (1 << 15) - 1, (1 << 16) - 1,
(1 << 16) - 1)
# the world's stages (game states)
self._stages = []
# the currently active stage, or None if no stage is active,
# or stages are not being used
self._activeStage = None
def __init__(self, resolution, block_size):
self.window_size = resolution
self.block_size = block_size
self.display = DrawWindow(self.window_size)
self.menu = Menu((self.window_size), Eventqueue(
self.block_size), self.display)
self.game = Game(self.window_size, self.block_size, self.menu)
def fromImage(cls, sheet, image, colors, *args, **kwargs):
"""Creates a new tilemap from an image.
@param sheet: The SpriteSheet to use when creating the TileMap.
@param image: The image to use as the basis for the TileMap.
@param colors: A dictionary mapping color values to tile indices.
Any color that is not in the colors dictionary is treated as
a blank tile (index -1). The keys in the colors dict should
be RGB or RGBA tuples.
"""
if isinstance(image, basestring):
image = Game.Image.load(image)
rows = []
pxarray = Game.PixelArray(image)
for y in xrange(image.get_height()):
thisRow = []
for x in xrange(image.get_width()):
r,g,b,a = image.unmap_rgb(pxarray[x][y])
idx = colors.get((r,g,b,a),None)
if idx is None:
idx = colors.get((r,g,b),-1)
thisRow.append(idx)
rows.append(thisRow)
return cls(sheet, rows, *args, **kwargs)
def __init__(self, *args, **kwargs):
super(Console, self).__init__(*args, **kwargs)
self.x += self.width/2
self.y += self.height/2
self.textbox = text.Text('', size=self.size)
self.textbox.background = Game.color('black')
def update(self):
"""Update the console."""
if self.textbox.dirty > 0:
rect = Game.Rect(0,max(0,self.textbox.height - self.height),
self.width,min(self.rect.height,self.textbox.rect.height))
self.pixels = self.textbox.pixels.subsurface(rect)
self.redraw()
self.textbox.dirty = 0
def __init__(self, *args, **kwargs):
# set a click handler, if we get one
if 'click' in kwargs:
self.click = kwargs['click']
# text label
# TODO: add more options?
self.text = text.Text(kwargs.get('label',''),
color=kwargs.get('labelColor',Game.color('black')),
)
# graphics
self.graphic = kwargs.get('graphic',None)
if isinstance(self.graphic, basestring):
self.graphic = Image().load(self.graphic)
# background
self.bgColor = kwargs.get('bgColor', 'gray70')
if isinstance(self.bgColor, basestring):
self.bgColor = Game.color(self.bgColor)
# border
self.border = kwargs.get('border',8)
# border color
self.borderColor = kwargs.get('borderColor', None)
# if we don't get a size, figure one out
# TODO: if we get a graphic and text, make it the bigger of the two
if 'size' not in kwargs:
if self.graphic is not None:
kwargs['size'] = self.graphic.size
elif self.text is not None:
kwargs['size'] = self.text.size
else:
kwargs['size'] = (0,0)
kwargs['size'] += (self.border,self.border)
super(Button, self).__init__(*args, **kwargs)
self.pixels = Game.Surface((self.width,self.height),Game.Constants.SRCALPHA)
self.pixels.fill(self.bgColor)
self._drawBorder()
def __init__(self, items, depth=8, bounds=None):
# the four sub trees
self.nw = self.ne = self.se = self.sw = None
# change a Group to a list
# this can be useful when using World.getEntities()
if isinstance(items, Game.Sprite.Group):
items = items.sprites()
depth -= 1
if depth == 0 or not items:
self.items = items
return
if bounds:
bounds = Game.Rect(bounds)
else:
bounds = items[0].rect
bounds = bounds.unionall([i.rect for i in items[1:]])
cx = self.cx = bounds.centerx
cy = self.cy = bounds.centery
self.items = []
nw_items = []
ne_items = []
se_items = []
sw_items = []
for item in items:
# Which of the sub-quadrants does the item overlap?
in_nw = item.rect.left <= cx and item.rect.top <= cy
in_sw = item.rect.left <= cx and item.rect.bottom >= cy
in_ne = item.rect.right >= cx and item.rect.top <= cy
in_se = item.rect.right >= cx and item.rect.bottom >= cy
# If it overlaps all 4 quadrants then insert it at the current
# depth, otherwise append it to a list to be inserted under every
# quadrant that it overlaps.
if in_nw and in_ne and in_se and in_sw:
self.items.append(item)
else:
if in_nw: nw_items.append(item)
if in_ne: ne_items.append(item)
if in_se: se_items.append(item)
if in_sw: sw_items.append(item)
# Create the sub-quadrants, recursively.
if nw_items:
self.nw = QuadTree(nw_items, depth, (bounds.left, bounds.top, cx, cy))
if ne_items:
self.ne = QuadTree(ne_items, depth, (cx, bounds.top, bounds.right, cy))
if se_items:
self.se = QuadTree(se_items, depth, (cx, cy, bounds.right, bounds.bottom))
if sw_items:
self.sw = QuadTree(sw_items, depth, (bounds.left, cy, cx, bounds.bottom))
def __init__(self, screen):
self.game = Game(screen)
self.screen = screen
self.image = image_util.load_image("mainmenu.png")
self.index = 0
self.play_rect = Rect(275,200,245,70)
self.controls_rect = Rect(275,290,245,70)
self.quit_rect = Rect(275,380,245,70)
self.credits_rect = Rect(610, 530, 180, 60)
self.controlScreen = ControlScreen(self.game)
self.creditsScreen = CreditsScreen(self.game)
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( True )
def _render_text(self):
"""This is a helper method to render text to a surface with wrapping."""
if self._autowidth:
# "autowidth" means one line, no wrapping, and the left edge
# stays in the same place
textlines = [self.text]
textheight = self.font.get_linesize()
oldleft = self.left
self.width = self.font.size(self.text)[0]
self.x = oldleft + self.width / 2.
else:
textlines = self._wrap(self.text)
textheight = len(textlines) * self.font.get_linesize()
textwidth = self.width
self.height = textheight
# fix in case we're drawing black text
if self.background is None and self.color == Game.rgb(0, 0, 0):
ALPHA = Game.Constants.SRCALPHA
else:
ALPHA = 0
surf = Game.Surface((textwidth, textheight), ALPHA)
for lineno, line in enumerate(textlines):
if self.background is not None:
r = self.font.render(line, self.antialias, self.color,
self.background)
else:
r = self.font.render(line, self.antialias, self.color)
surf.blit(r, (0, lineno * self.font.get_linesize()))
self.pixels = surf
if self.background is None:
# per-pixel alphas override colorkeys, so this line won't do anything
# if the text is black
self.pixels.set_colorkey((0, 0, 0), Game.Constants.RLEACCEL)
self.redraw()
def followBounds(self, followMin=None, followMax=None):
"""Sets the range in which the camera is allowed to move.
If both parameters, C{followMin} and C{followMax}, are None,
then the game world's extents are set to be the same as the screen.
@param followMin: The top-left corner of the game world.
@param followMax: The bottom-right corner of the game world.
"""
if followMin is None:
followMin = point.Vector(0, 0)
if followMax is None:
followMax = point.Vector(self.width, self.height)
# The minimum follow value is the top-left corner of the game world,
# and the maximum is the bottom-right. We can just use followMin as is,
# but we have to adjust followMax to take into account the size of the
# screen. We do this _after_ setting the world boundaries, though,
# because it saves typing and it might be slightly faster.
self._followMin = point.Vector(followMin)
self._followMax = point.Vector(followMax)
self._bounds = Game.Rect(followMin, self._followMax - self._followMin)
self._followMax -= (self.width, self.height)
self._doCameraFollow()
def play(self):
self.game.gameloop()
if self.game.isGameOver:
self.game = Game(self.screen)
for x in xrange(len(self.pressed)):
self.pressed[x] = True
class Tests(unittest.TestCase):
def setUp(self):
self.menu = Fake_menu()
self.game = Game((800, 600), 40, self.menu)
self.inputqueue = None
self.display = Mocup_display(0)
self.clock = Fake_clock()
self.set_event([(0, -40, "D"), (40, 0, "R")], 200)
def set_event(self, events, loops):
self.inputqueue = Mocup_eventqueue(40, loops, events)
def test_gameloop_runs_and_quits(self):
self.game.game_loop(self.display, self.inputqueue, self.clock, None)
def test_gameloop_runs_and_quits_if_snake_collides(self):
event0 = (0, -40, "D")
event1 = (-40, 0, "L")
event2 = (0, 40, "U")
event3 = (40, 0, "R")
event4 = (0, -40, "D")
events = [event0, event1, event2, event3, event4]
self.set_event(events, None)
self.game.game_loop(self.display, self.inputqueue, self.clock, None)
game_state = self.menu.return_status()
self.assertEqual(0, game_state)
def test_game_loop_monitors_the_boarders_x_axis(self):
test_status = True
event0 = [(40, 0, "L")]
self.set_event(event0, 1000)
self.game.game_loop(self.display, self.inputqueue, self.clock, None)
sprites = self.display.return_sprites()
for group in sprites:
for sprite in group:
location = sprite.rect.center
if location[0] not in range(20, 781):
test_status = False
self.assertEqual(True, test_status)
def test_game_loop_monitors_the_boarders_y_axis(self):
test_status = True
event0 = [(0, -40, "U")]
self.set_event(event0, 1000)
self.game.game_loop(self.display, self.inputqueue, self.clock, None)
sprites = self.display.return_sprites()
for group in sprites:
for sprite in group:
location = sprite.rect.center
if location[1] not in range(20, 581):
test_status = False
self.assertEqual(True, test_status)
def test_game_loop_collisions_grow_points(self):
test = False
event0 = [(-40, 0, "L")]
rewards_group = pygame.sprite.Group(Coin(), Coin(), Coin(), Coin())
i = 20
for sprite in rewards_group:
sprite.rect.center = (i, 340)
i += 40
self.display = Mocup_display(1)
self.set_event(event0, 500)
self.game.game_loop(self.display, self.inputqueue, self.clock,
rewards_group)
game_state = self.menu.return_status()
if game_state in range(4, 6):
test = True
self.assertEqual(True, test)
from random import choice
from gomoku_env import GomokuEnv
from gameloop import Game
try: # python3 compatibility
input = raw_input
except NameError:
pass
def player1_turn(state):
return choice(state.available_turns())
def player1_human_turn(state):
_ = input("Type your turn as x,y: ")
x, y = _.split(",")
x, y = int(x.strip()), int(y.strip())
return x, y
def player2_turn(state):
return choice(state.available_turns())
env = GomokuEnv(board_size=15, win_len=5)
game = Game(env, player1_turn, player2_turn)
game.loop()
from gameloop import Game
if __name__ == '__main__':
# This is the games main-function.
# This is the first function the game runs.
# In this main-function, we simply create an instance of the Game()-class.
game = Game()
class MenuScreen:
def __init__(self, screen):
self.game = Game(screen)
self.screen = screen
self.image = image_util.load_image("mainmenu.png")
self.index = 0
self.play_rect = Rect(275,200,245,70)
self.controls_rect = Rect(275,290,245,70)
self.quit_rect = Rect(275,380,245,70)
self.credits_rect = Rect(610, 530, 180, 60)
self.controlScreen = ControlScreen(self.game)
self.creditsScreen = CreditsScreen(self.game)
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( True )
def get_input(self):
self.getEvents()
self.getButtonPresses()
def getEvents(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
if self.play_rect.collidepoint(pos):
self.index = PLAY
self.draw()
self.play()
elif self.controls_rect.collidepoint(pos):
self.index = CONTROLS
self.draw()
self.controls()
elif self.quit_rect.collidepoint(pos):
self.index = QUIT
self.quit()
elif self.credits_rect.collidepoint(pos):
self.credits()
def getButtonPresses(self):
keys = pygame.key.get_pressed()
# select
if(keys[K_SPACE]):
if not self.pressed[K_SPACE]:
self.pressed[K_SPACE] = True
self.select()
else:
self.pressed[K_SPACE] = False
if(keys[K_RETURN]):
if not self.pressed[K_RETURN]:
self.pressed[K_RETURN] = True
self.select()
else:
self.pressed[K_RETURN] = False
# move
if(keys[K_UP]):
if not self.pressed[K_UP]:
self.pressed[K_UP] = True
self.up()
else:
self.pressed[K_UP] = False
if(keys[K_DOWN]):
if not self.pressed[K_DOWN]:
self.pressed[K_DOWN] = True
self.down()
else:
self.pressed[K_DOWN] = False
if(keys[K_w]):
if not self.pressed[K_w]:
self.pressed[K_w] = True
self.up()
else:
self.pressed[K_w] = False
if(keys[K_s]):
if not self.pressed[K_s]:
self.pressed[K_s] = True
self.down()
else:
self.pressed[K_s] = False
def play(self):
self.game.gameloop()
if self.game.isGameOver:
self.game = Game(self.screen)
for x in xrange(len(self.pressed)):
self.pressed[x] = True
def controls(self):
self.controlScreen.loop()
for x in xrange(len(self.pressed)):
self.pressed[x] = True
def quit(self):
sys.exit()
def credits(self):
self.creditsScreen.loop()
for x in xrange(len(self.pressed)):
self.pressed[x] = True
def up(self):
self.index -= 1
if self.index < 0:
self.index = MAX_INDEX
self.draw()
def down(self):
self.index += 1
if self.index > MAX_INDEX:
self.index = 0
self.draw()
def select(self):
if self.index is PLAY:
self.play()
elif self.index is CONTROLS:
self.controls()
elif self.index is QUIT:
self.quit()
def draw(self):
self.screen.blit(self.image, (0,0))
if self.index is PLAY:
pygame.draw.rect(self.screen, (255,255,0), self.play_rect, 5)
elif self.index is CONTROLS:
pygame.draw.rect(self.screen, (255,255,0), self.controls_rect, 5)
elif self.index is QUIT:
pygame.draw.rect(self.screen, (255,255,0), self.quit_rect, 5)
pygame.display.flip()
def loop(self):
while True:
self.draw()
self.get_input()
def getScreenRect(self):
"""Returns a Rect object containing the bounds of the screen."""
if self.screen is not None:
return self.screen.get_rect()
else:
return Game.Rect(0, 0, self.width, self.height)
