def __init__(self, random):
self.random = random
self.running = True
self.centerx = self.MAP_WIDTH // 2
self.centery = self.MAP_HEIGHT // 2
self.player_pos = [self.centerx, (int)(self.MAP_HEIGHT * .99)]
self.player_right = [self.centerx + 1, (int)(self.MAP_HEIGHT * .99)]
self.player_left = [self.centerx - 1, (int)(self.MAP_HEIGHT * .99)]
self.invaders = []
self.drops_eaten = 0
self.invaders_left = 0
self.missiles_left = 0
self.apple_pos = []
self.objects = []
self.turns = 0
self.bullets_fired = 0
self.level = 0
self.gravity_power = 1
self.bullet_speed = 3
self.invader_speed = 1
self.placed_invaders = 0
self.movement_direction = Direction.RIGHT
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 1, self.SCREEN_WIDTH - self.MSG_START, 5)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 1, self.MSG_START, 5)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Welcome to " + self.GAME_TITLE + "!!!")
self.lives = 3
self.life_lost = False
self.at_bottom = False
self.debug = False
def __init__(self, random):
self.random = random
self.running = True
self.player_y = self.MAP_HEIGHT // 2
self.player_v = 0
self.x = 0
self.pipes_passed = 0
self.pipes = []
self.msg_panel = MessagePanel(self.MSG_START,
self.MAP_HEIGHT + 1,
self.SCREEN_WIDTH - self.MSG_START,
5,
padding=PanelPadding.create(top=1,
right=1,
bottom=1))
self.status_panel = StatusPanel(0,
self.MAP_HEIGHT + 1,
self.MSG_START,
5,
padding=PanelPadding.create(top=1,
left=1,
bottom=1))
self.panels = [self.status_panel, self.msg_panel]
self.msg_panel.add("Welcome to")
self.msg_panel.add(" " + self.GAME_TITLE + "!!!")
self.msg_panel.add("Don't hit the pipes")
def __init__(self, random):
self.random = random
self.running = True
self.is_stopping = False
self.players = []
self.num_alive = 0
self.standings = []
self.turns = 0
self.level = 1
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 2,
self.SCREEN_WIDTH - self.MSG_START + 1,
4)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 2, self.MSG_START,
4)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Welcome to Game GRID!!!")
self.msg_panel.add("Stop The Corruption")
def __init__(self, random):
self.random = random
self.running = True
self.NUM_ENEMIES = 2
self.enemies = self.NUM_ENEMIES
self.USER = None
self.CORRUPTION = []
self.CORRUPTION_POSITIONS = []
self.turns = 0
self.level = 1
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 1,
self.SCREEN_WIDTH - self.MSG_START, 5)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 1, self.MSG_START,
5)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Welcome to Game GRID!!!")
self.msg_panel.add("Stop The Corruption")
self.__create_map()
def __init__(self, random):
self.random = random
self.running = True
self.colliding = False
self.saved_object = None # stores a map item we're "on top of"
self.last_move = 'w' # need this to restore objects
self.flying = 0 # set to some value and decrement (0 == on ground)
self.hp = 1
self.player_pos = [int(self.MAP_WIDTH / 2), self.MAP_HEIGHT - 4]
self.score = 0
self.objects = []
self.turns = 0
self.level = 1
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 1,
self.SCREEN_WIDTH - self.MSG_START, 5)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 1, self.MSG_START,
5)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Velkommen to Robot Backcountry Skiing!")
self.msg_panel.add("Move left and right! Don't crash!")
self.__create_map()
class SpaceInvaders(GridGame):
MAP_WIDTH = 60
MAP_HEIGHT = 25
SCREEN_WIDTH = 60
SCREEN_HEIGHT = MAP_HEIGHT + 6
MSG_START = 20
MAX_MSG_LEN = SCREEN_WIDTH - MSG_START - 1
CHAR_WIDTH = 16
CHAR_HEIGHT = 16
GAME_TITLE = "Space Invaders"
CHAR_SET = "resources/terminal16x16_gs_ro.png"
NUM_OF_INVADERS = 10
TOTAL_INVADERS = 10
MAX_TURNS = 900
score = 0
# we use these for moving the mothership easily
LEFT = -1
RIGHT = 1
mothership_direction = RIGHT
MOTHERSHIP_SPEED = 3
mothership_exists = False
MOTHERSHIP_L = chr(241)
MOTHERSHIP_C = chr(242)
MOTHERSHIP_R = chr(243)
MOTHERSHIP_POINTS = 300
INVADER0_POINTS = 50
INVADER1_POINTS = 40
INVADER2_POINTS = 30
INVADER0 = chr(244) # worth 50 points
INVADER1 = chr(245) # worth 40 points
INVADER2 = chr(246) # worth 30 points
# create a list of sprite to blit by type on redraw
INVADER_SPRITE = [INVADER0, INVADER1, INVADER2]
BARRIER_1 = chr(247)
BARRIER_2 = chr(248)
BARRIER_3 = chr(249)
BARRIER_4 = chr(250)
MISSILE = chr(251)
BULLET = chr(252)
PLAYER_L = chr(253)
PLAYER_C = chr(254)
PLAYER_R = chr(255)
EMPTY = ' '
OUT_OF_BOUNDS = chr(240)
fire_rate = 2 # the fire rate of invaders
def __init__(self, random):
self.random = random
self.running = True
self.centerx = self.MAP_WIDTH // 2
self.centery = self.MAP_HEIGHT // 2
self.player_pos = [self.centerx, (int)(self.MAP_HEIGHT * .99)]
self.player_right = [self.centerx + 1, (int)(self.MAP_HEIGHT * .99)]
self.player_left = [self.centerx - 1, (int)(self.MAP_HEIGHT * .99)]
self.invaders = []
self.drops_eaten = 0
self.invaders_left = 0
self.missiles_left = 0
self.apple_pos = []
self.objects = []
self.turns = 0
self.bullets_fired = 0
self.level = 0
self.gravity_power = 1
self.bullet_speed = 3
self.invader_speed = 1
self.placed_invaders = 0
self.movement_direction = Direction.RIGHT
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 1, self.SCREEN_WIDTH - self.MSG_START, 5)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 1, self.MSG_START, 5)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Welcome to " + self.GAME_TITLE + "!!!")
self.lives = 3
self.life_lost = False
self.at_bottom = False
self.debug = False
def init_board(self):
self.map = MapPanel(0, 0, self.MAP_WIDTH, self.MAP_HEIGHT, self.EMPTY,
border=PanelBorder.create(bottom="-"))
self.panels += [self.map]
self.map[(self.player_pos[0], self.player_pos[1])] = self.PLAYER_C
self.map[(self.player_right[0], self.player_right[1])] = self.PLAYER_R
self.map[(self.player_left[0], self.player_left[1])] = self.PLAYER_L
self.draw_level()
def start_game(self):
# This is a hack to make sure that the map array is setup before the player makes their first move.
self.player.bot_vars = self.get_vars_for_bot()
def create_new_player(self, prog):
self.player = DefaultGridPlayer(prog, self.get_move_consts())
return self.player
def draw_level(self):
if self.debug:
print("Redrawing map! turn: %d" % (self.turns))
start_barrier = 5 # we want to offset the first barrier
barrier_height = 3
barrier_width = 5
set_sb = False
self.mothership_exists = False
for w in range(0, 60):
for h in range(0, 25):
self.map[(w,h)] = self.EMPTY
for w in range(0, 60):
for h in range(0, 25):
# generating the invaders -- 5 rows of 11, alternating columns and rows
if h < 10 and w >= 20 and w <= 40:
if (w % 2 == 0) and (h % 2 == 1):
if h == 9 or h == 7:
self.invaders.append(Invader((w, h), 2))
self.map[(w, h)] = self.INVADER2
elif h == 5 or h == 3:
self.invaders.append(Invader((w, h), 1))
self.map[(w, h)] = self.INVADER1
elif h == 1:
self.invaders.append(Invader((w, h), 0))
self.map[(w, h)] = self.INVADER0
# generate the barriers
if h >= self.MAP_HEIGHT - 1 - barrier_height and h < self.MAP_HEIGHT - 1:
# it's a barrier row
if w >= start_barrier and w <= start_barrier + barrier_width: # we draw the barrier
self.map[(w, h)] = self.BARRIER_4
if w == start_barrier + barrier_width:
set_sb = True
if set_sb:
start_barrier += 12 # to achieve spacing between barriers...hopefully
set_sb = False
self.set_bottom_invaders()
def set_bottom_invaders(self):
# all_invaders = [ x for x in self.invaders ]
cols = {}
# sort all the invaders into columns
for invader in self.invaders:
pos = invader.get_pos()
if pos[0] in cols:
cols[pos[0]].append(invader)
else:
empty = []
empty.append(invader)
cols[pos[0]] = empty
# sort each column on y value descending (high y values are "lower")
for i in range(0, self.MAP_WIDTH):
if i in cols:
cols[i] = sorted(cols[i], key=lambda x: x.get_pos()[1], reverse=True)
cols[i][0].set_bottom(True)
def handle_mothership(self):
# if there is a bullet in center_positon, center_position + direction * 1, * 2, or * 3 or * 4 (the right/left requires the *4, because the offset from center position is 1), or any of those positions are out of bounds, remove the entire mothership
# move the center location over by 3.
if not self.mothership_exists:
return
old_center = self.map.get_all_pos(self.MOTHERSHIP_C).pop()[0]
redraw = True
for i in range(0, 5):
test_x = old_center + i * self.mothership_direction
if test_x < 0 or test_x >= self.MAP_WIDTH: # we fell off the map
# remove mothership
redraw = False
self.mothership_exists = False
clear_l = self.map.get_all_pos(self.MOTHERSHIP_L).pop()
clear_c = self.map.get_all_pos(self.MOTHERSHIP_C).pop()
clear_r = self.map.get_all_pos(self.MOTHERSHIP_R).pop()
self.map[clear_l] = self.EMPTY
self.map[clear_c] = self.EMPTY
self.map[clear_r] = self.EMPTY
if redraw:
new_l = (clear_l[0] + 3 * self.mothership_direction, 0)
new_c = (clear_c[0] + 3 * self.mothership_direction, 0)
new_r = (clear_r[0] + 3 * self.mothership_direction, 0)
self.map[new_l] = self.MOTHERSHIP_L
self.map[new_c] = self.MOTHERSHIP_C
self.map[new_r] = self.MOTHERSHIP_R
return
def launch_mothership(self):
if self.turns % 45 == 0: # launch mothership every 45 turns
self.mothership_exists = True
# launch the ship
# if the turns are even, we launch from right and vice versa
center_x = 1 # when launching from left we have to leave space for the left element
if self.turns % 2 == 0:
center_x = (int)(self.MAP_WIDTH * .99) - 1
self.mothership_direction = self.LEFT
# launch from right
# the top row is 0
else:
self.mothership_direction = self.RIGHT
if self.debug:
print("Launching mothership at %d (turn: %d)" % (center_x, self.turns))
position_l = (center_x - 1, 0)
position_c = (center_x, 0)
position_r = (center_x + 1, 0)
self.map[position_l] = self.MOTHERSHIP_L
self.map[position_c] = self.MOTHERSHIP_C
self.map[position_r] = self.MOTHERSHIP_R
def fire_missiles(self):
for invader in self.invaders:
if invader.get_bottom() and not invader.get_missile(): # it can fire
invader_pos = invader.get_pos()
# first we determine if the invader can fire...are there any invaders below it?
# second we determine (randomly) if the invader will fire
fire = self.random.randint(0, 30 - self.fire_rate) # hacky way of increasing fire percentage
if fire == 2: # hacky way to set it to fire at a low percentage only
missile_pos = (invader_pos[0], invader_pos[1] + self.gravity_power)
# fixed missile collision problem at the bottom
if (missile_pos[0] == self.player_pos[0] and missile_pos[1] == self.player_pos[1]) or (missile_pos[0] == self.player_left[0] and missile_pos[1] == self.player_left[1]) or (missile_pos[0] == self.player_right[0] and missile_pos[1] == self.player_right[1]):
if self.debug:
print("You lost a life!")
self.msg_panel.add(["You lost a life!"])
self.map[(self.player_pos[0], self.player_pos[1])] = self.EMPTY
self.map[(self.player_right[0], self.player_right[1])] = self.EMPTY
self.map[(self.player_left[0], self.player_left[1])] = self.EMPTY
self.lives -= 1
# reset to center
self.player_pos = [self.centerx, (int)(self.MAP_HEIGHT * .99)]
self.player_right = [self.centerx + 1, (int)(self.MAP_HEIGHT * .99)]
self.player_left = [self.centerx - 1, (int)(self.MAP_HEIGHT * .99)]
# remove all missiles
for invader in self.invaders:
invader.set_missile(False)
self.lost_life = True
self.map[(self.player_pos[0], self.player_pos[1])] = self.PLAYER_C
self.map[(self.player_left[0], self.player_left[1])] = self.PLAYER_L
self.map[(self.player_right[0], self.player_right[1])] = self.PLAYER_R
# fixed collision problem at the bottom
if missile_pos[1] < self.MAP_HEIGHT:
invader.set_missile(missile_pos)
def fire_turret(self):
# place the bullet one over the position
# can only have on bullet on the screen at once
if len(self.map.get_all_pos(self.BULLET)) == 0:
bullet_pos = (self.player_pos[0], self.player_pos[1] - 1)
if self.is_barrier(self.map[bullet_pos]):
self.map[bullet_pos] = self.decrement_barrier(self.map[bullet_pos])
elif self.map[bullet_pos] == self.MISSILE:
self.map[bullet_pos] = self.EMPTY
else:
self.map[bullet_pos] = self.BULLET
self.bullets_fired += 1
def is_barrier(self, c):
if c == self.BARRIER_1 or c == self.BARRIER_2 or c == self.BARRIER_3 or c == self.BARRIER_4:
return True
return False
def decrement_barrier(self, c):
if c == self.BARRIER_1:
return self.EMPTY
elif c == self.BARRIER_2:
return self.BARRIER_1
elif c == self.BARRIER_3:
return self.BARRIER_2
elif c == self.BARRIER_4:
return self.BARRIER_3
else:
return self.EMPTY
def move_invaders(self):
# determine if we can continue moving in the same direction (nothing will fall off the edge)
move_down = False
positions = None
if self.movement_direction == Direction.RIGHT:
# sort descending by x value
positions = sorted([x.get_pos() for x in self.invaders], key=lambda x: x[0], reverse=True)
# TODO: will this ever occur when we are not testing? Like when someone wins?
if len(positions) == 0:
return
if positions[0][0] + 1 >= self.MAP_WIDTH:
move_down = True
self.movement_direction = Direction.LEFT
elif self.movement_direction == Direction.LEFT:
positions = sorted([x.get_pos() for x in self.invaders], key=lambda x: x[0], reverse=False)
if positions[0][0] - 1 < 0:
move_down = True
self.fire_rate += 1 # every time they move down, they fire a little bit faster
self.movement_direction = Direction.RIGHT
# sort ascending by x value
if move_down:
self.move_invaders_down()
self.move_invaders() # to move one in the new direction after going down
elif not move_down:
movement = self.invader_speed
if self.movement_direction == Direction.LEFT:
movement *= -1 # go the other direction
for invader in self.invaders:
pos = invader.get_pos()
new_pos = (pos[0] + movement, pos[1])
# if not self.map[new_pos] == self.BULLET:
invader.set_pos(new_pos)
# else:
# #if its a barrier, we need to decrement it
# #if its a bullet, we need to remove it
# if self.map[new_pos] == self.BULLET:
# self.map[new_pos] == self.EMPTY
# print("collision with a bullet!")
# elif is_barrier(self.map[new_pos]):
# self.map[new_pos] = decrement_barrier(self.map[new_pos])
# self.invaders.remove(invader)
def move_invaders_down(self):
for invader in self.invaders:
pos = invader.get_pos()
new_pos = (pos[0], pos[1] + 1)
if new_pos[1] < self.MAP_HEIGHT:
# if self.map[new_pos] != self.BULLET: #it wasn't a hit
invader.set_pos(new_pos)
# else: #it was hit
# self.map[new_pos] = self.EMPTY
# self.invaders.remove(invader)
else:
self.at_bottom = True
def move_bullets(self):
# there should only be one tbh
# we need to get the list of all invader positions
invader_positions = [x.get_pos() for x in self.invaders]
missile_positions = [x.get_missile() for x in self.invaders]
# we generate a list of all the mothership positions that we will encounter
mothership_locations = []
if self.mothership_exists:
mothership_locations.append(self.map.get_all_pos(self.MOTHERSHIP_L).pop())
mothership_locations.append(self.map.get_all_pos(self.MOTHERSHIP_C).pop())
mothership_locations.append(self.map.get_all_pos(self.MOTHERSHIP_R).pop())
# we add 2 because we need to detect a collision with the left/right, as well as the center.
for pos in sorted(self.map.get_all_pos(self.BULLET), key=lambda x: x[1], reverse=False):
still_exists = True
# we iterate over all the positions that the bullet "warped" through to detect any collisions
for i in range(0, self.bullet_speed): # 0 - 1 so we clear the initial position
clear = (pos[0], pos[1] - i)
if clear[1] >= 0 and still_exists:
if clear in invader_positions:
# we need to find which invader it was and delete it
for invader in self.invaders:
if invader.get_pos() == clear:
# increment the score for the aliens
if invader.sprite == 0:
self.score += self.INVADER0_POINTS
if self.debug:
print("Hit INVADER0! (%d left)" % (len(self.invaders)))
if invader.sprite == 1:
self.score += self.INVADER1_POINTS
if self.debug:
print("Hit INVADER1! (%d left)" % (len(self.invaders)))
if invader.sprite == 2:
self.score += self.INVADER2_POINTS
if self.debug:
print("Hit INVADER2! (%d left)" % (len(self.invaders)))
self.invaders.remove(invader)
still_exists = False
self.map[clear] = self.EMPTY
self.map[pos] = self.EMPTY
elif clear in mothership_locations:
still_exists = False
# remove the mothership from map
self.map[self.map.get_all_pos(self.MOTHERSHIP_L).pop()] = self.EMPTY
self.map[self.map.get_all_pos(self.MOTHERSHIP_R).pop()] = self.EMPTY
self.map[self.map.get_all_pos(self.MOTHERSHIP_C).pop()] = self.EMPTY
self.mothership_exists = False
self.score += self.MOTHERSHIP_POINTS
elif self.map[clear] == self.MISSILE:
# we need to track downt he invader which owns this missile
for invader in self.invaders:
if invader.get_missile() == clear:
invader.set_missile(False)
self.map[pos] = self.EMPTY
self.map[clear] = self.EMPTY
still_exists = False
elif self.is_barrier(self.map[clear]):
self.map[clear] = self.decrement_barrier(self.map[clear])
self.map[pos] = self.EMPTY
still_exists = False
else:
self.map[clear] = self.EMPTY
self.map[pos] = self.EMPTY
new_pos = (pos[0], pos[1] - self.bullet_speed)
if new_pos[1] >= 0 and still_exists:
if new_pos in invader_positions:
for invader in self.invaders:
if invader.get_pos() == new_pos:
self.invaders.remove(invader)
still_exists = False
self.map[clear] = self.EMPTY
elif new_pos in missile_positions:
for invader in self.invaders:
if invader.get_missile() == new_pos:
invader.set_missile(False)
still_exists = False
self.map[new_pos] = self.EMPTY
elif self.is_barrier(self.map[new_pos]):
self.map[new_pos] = self.decrement_barrier(self.map[new_pos])
still_exists = False
if still_exists:
self.map[new_pos] = self.BULLET
self.map[clear] = self.EMPTY
# if not still_exists:
# self.map[new_pos] = self.EMPTY
def do_turn(self):
self.handle_key(self.player.move)
self.player.bot_vars = self.get_vars_for_bot()
# End of the game
if self.turns >= self.MAX_TURNS:
self.running = False
self.msg_panel.add("You are out of moves.")
if self.at_bottom:
# Not quite sure why it's not adding this message to the panel or updating the lives counter at the bottom.
# It's a UI "feature"
self.msg_panel.add(["They have invaded!"])
self.lives = 0
if self.lives == 0:
self.running = False
msg = "You lost all your lives"
self.msg_panel.add(msg)
if self.debug:
print(msg)
if self.life_lost:
self.life_lost = False
msg = "You lost a life"
self.msg_panel.add(msg)
if self.debug:
print(msg)
def handle_key(self, key):
self.turns += 1
self.map[(self.player_pos[0], self.player_pos[1])] = self.EMPTY
self.map[(self.player_right[0], self.player_right[1])] = self.EMPTY
self.map[(self.player_left[0], self.player_left[1])] = self.EMPTY
# if key == "w":
# self.player_pos[1] -= 1
# if key == "s":
# self.player_pos[1] += 1
if key == "a":
if self.player_left[0] - 1 >= 0:
self.player_pos[0] -= 1
self.player_right[0] -= 1
self.player_left[0] -= 1
if key == "d":
if self.player_right[0] + 1 < self.MAP_WIDTH:
self.player_pos[0] += 1
self.player_right[0] += 1
self.player_left[0] += 1
if key == "w":
self.fire_turret()
if key == "Q":
self.running = False
return
# move the invaders
self.move_bullets() # we do hits detection first
if len(self.invaders) == 0:
self.level += 1
if self.debug:
print("*************************************************")
print("No more invaders! New level: %d" % self.level)
print("*************************************************")
self.draw_level()
return
self.move_invaders()
self.move_missiles(self.gravity_power) # move all drops down 1
self.handle_mothership()
# collision detection
position = self.map[(self.player_pos[0], self.player_pos[1])]
position_left = self.map[(self.player_left[0], self.player_left[1])]
position_right = self.map[(self.player_right[0], self.player_right[1])]
collision = False
# if position == self.MISSILE or position == self.INVADER2 or position == self.INVADER1 or position == self.INVADER0:
# collision = True
# if position_left == self.MISSILE or position == self.INVADER2 or position == self.INVADER1 or position == self.INVADER0:
# collision = True
# if position_right == self.MISSILE or position == self.INVADER2 or position == self.INVADER1 or position == self.INVADER0:
# collision = True
# fixed collision issue at the bottom
for invader in self.invaders:
invader_pos = invader.get_pos()
if self.player_pos[0] == invader_pos[0] and self.player_pos[1] == invader_pos[1]:
collision = True
elif self.player_left[0] == invader_pos[0] and self.player_left[1] == invader_pos[1]:
collision = True
elif self.player_right[0] == invader_pos[0] and self.player_right[1] == invader_pos[1]:
collision = True
elif position == self.MISSILE or position_left == self.MISSILE or position_right == self.MISSILE:
collision = True
# fixed collision issue at the bottom
# self.msg_panel.remove("You lost a life!")
if collision:
if self.debug:
print("You lost a life!")
self.msg_panel.add(["You lost a life!"])
position = self.EMPTY # clear the position
self.lives -= 1
# reset to center
self.player_pos = [self.centerx, (int)(self.MAP_HEIGHT * .99)]
self.player_right = [self.centerx + 1, (int)(self.MAP_HEIGHT * .99)]
self.player_left = [self.centerx - 1, (int)(self.MAP_HEIGHT * .99)]
# remove all missiles
for invader in self.invaders:
invader.set_missile(False)
self.lost_life = True
self.map[(self.player_pos[0], self.player_pos[1])] = self.PLAYER_C
self.map[(self.player_left[0], self.player_left[1])] = self.PLAYER_L
self.map[(self.player_right[0], self.player_right[1])] = self.PLAYER_R
# Fire the missiles
self.fire_missiles()
self.launch_mothership()
# first we clear all the prevoius invaders
for old_invader in self.map.get_all_pos(self.INVADER2):
self.map[old_invader] = self.EMPTY
for old_invader in self.map.get_all_pos(self.INVADER1):
self.map[old_invader] = self.EMPTY
for old_invader in self.map.get_all_pos(self.INVADER0):
self.map[old_invader] = self.EMPTY
for old_missile in self.map.get_all_pos(self.MISSILE):
self.map[old_missile] = self.EMPTY
for invader in self.invaders:
self.map[invader.get_pos()] = self.INVADER_SPRITE[invader.sprite]
if invader.get_missile():
self.map[invader.get_missile()] = self.MISSILE
def move_missiles(self, gravity_power): # gravity power is the number of positions a drop will fall per turn
for invader in self.invaders:
pos = invader.get_missile()
if pos:
# drop each by gravity_power
new_pos = (pos[0], pos[1] + gravity_power)
invader.set_missile(False)
if new_pos[1] < self.MAP_HEIGHT:
if self.map[new_pos] == self.BULLET:
self.map[new_pos] = self.EMPTY
elif self.map[new_pos] == self.PLAYER_L or self.map[new_pos] == self.PLAYER_C or self.map[
new_pos] == self.PLAYER_R:
self.life_lost()
elif self.is_barrier(self.map[new_pos]):
self.map[new_pos] = self.decrement_barrier(self.map[new_pos])
else:
invader.set_missile(new_pos)
self.map[new_pos] = self.MISSILE
else: # it fell off the map
self.missiles_left -= 1
def is_running(self):
return self.running
def get_vars_for_bot(self):
bot_vars = {}
# player x location (center)
# mothership x location(center)
bonus_ship_x = -1
if self.mothership_exists:
bonus_ship_x = self.map.get_all_pos(self.MOTHERSHIP_C).pop()[0]
# for these, we send an array where 0 = y and 1 = the character (or self.EMPTY if nothing)
# we send -1 if the location is out of bounds (for the left-1 and right+1)
player_x = self.player_pos[0]
player_left_minus_one = self.EMPTY
for h in range(self.MAP_HEIGHT - 2, 0, -1):
if player_x - 2 < 0:
player_left_minus_one = self.OUT_OF_BOUNDS
elif not self.map[(player_x - 2, h)] == self.EMPTY:
player_left_minus_one = self.map[(player_x - 2, h)]
break
player_left = self.EMPTY
for h in range(self.MAP_HEIGHT - 2, 0, -1):
if not self.map[(player_x - 1, h)] == self.EMPTY:
player_left = self.map[(player_x - 1, h)]
break
player_center = self.EMPTY
for h in range(self.MAP_HEIGHT - 2, 0, -1):
if not self.map[(player_x, h)] == self.EMPTY:
player_center = self.map[(player_x, h)]
break
player_right = self.EMPTY
for h in range(self.MAP_HEIGHT - 2, 0, -1):
if not self.map[(player_x + 1, h)] == self.EMPTY:
player_right = self.map[(player_x + 1, h)]
break
player_right_plus_one = self.EMPTY
for h in range(self.MAP_HEIGHT - 2, 0, -1):
if player_x + 2 >= self.MAP_WIDTH:
player_right_plus_one = self.OUT_OF_BOUNDS
elif not self.map[(player_x + 2, h)] == self.EMPTY:
player_right_plus_one = self.map[(player_x + 2, h)]
break
bot_vars["bonus_ship_x"] = bonus_ship_x
bot_vars["player_x"] = player_x
bot_vars["player_left_minus_one"] = ord(player_left_minus_one)
bot_vars["player_left"] = ord(player_left)
bot_vars["player_center"] = ord(player_center)
bot_vars["player_right"] = ord(player_right)
bot_vars["player_right_plus_one"] = ord(player_right_plus_one)
bot_vars["map_array"] = self.get_map_array_tuple()
# TODO: pass in the map to the bot
return bot_vars
def get_map_array_tuple(self):
map_arr = []
for w in range(0, self.MAP_WIDTH):
w_arr = []
for h in range(0, self.MAP_HEIGHT):
w_arr.append(ord(self.map.p_to_char[(w, h)]))
map_arr.append(tuple(w_arr))
return tuple(map_arr)
@staticmethod
def default_prog_for_bot(language):
if language == GameLanguage.LITTLEPY:
return open(os.path.join(os.path.dirname(__file__), "resources/sample_bot.lp"), "r").read()
@staticmethod
def get_intro():
return open(os.path.join(os.path.dirname(__file__), "resources/intro.md"), "r").read()
# return "Welcome to Space Invaders"
def get_score(self):
return self.score
def draw_screen(self, frame_buffer):
# if not self.running:
# self.msg_panel += [""+str(self.drops_eaten)+" drops. Good job!"]
# Update Status
self.status_panel["Invaders"] = len(self.invaders)
self.status_panel["Lives"] = str(self.lives)
self.status_panel["Move"] = str(self.turns) + " of " + str(self.MAX_TURNS)
self.status_panel["Score"] = str(self.score)
for panel in self.panels:
panel.redraw(frame_buffer)
@staticmethod
def get_move_consts():
return ConstMapping({"west": ord("a"),
"east": ord("d"),
"fire": ord("w"),
"stay": ord("s"),
"MOTHERSHIP_L": ord(SpaceInvaders.MOTHERSHIP_L),
"MOTHERSHIP_C": ord(SpaceInvaders.MOTHERSHIP_C),
"MOTHERSHIP_R": ord(SpaceInvaders.MOTHERSHIP_R),
"INVADER_0": ord(SpaceInvaders.INVADER0),
"INVADER_1": ord(SpaceInvaders.INVADER1),
"INVADER_2": ord(SpaceInvaders.INVADER2),
"BARRIER_1": ord(SpaceInvaders.BARRIER_1),
"BARRIER_2": ord(SpaceInvaders.BARRIER_2),
"BARRIER_3": ord(SpaceInvaders.BARRIER_3),
"BARRIER_4": ord(SpaceInvaders.BARRIER_4),
"MISSILE": ord(SpaceInvaders.MISSILE),
"BULLET": ord(SpaceInvaders.BULLET),
"PLAYER_L": ord(SpaceInvaders.PLAYER_L),
"PLAYER_C": ord(SpaceInvaders.PLAYER_C),
"PLAYER_R": ord(SpaceInvaders.PLAYER_R),
"EMPTY": ord(' '),
"OUT_OF_BOUNDS": ord(SpaceInvaders.OUT_OF_BOUNDS),
"MAP_HEIGHT": SpaceInvaders.MAP_HEIGHT,
"MAP_WIDTH": SpaceInvaders.MAP_WIDTH,
})
class Tron(GridGame):
MAP_WIDTH = 40
MAP_HEIGHT = 20
SCREEN_WIDTH = MAP_WIDTH + 2 # add 2 for the borders
SCREEN_HEIGHT = MAP_HEIGHT + 6
MSG_START = 15
MAX_MSG_LEN = SCREEN_WIDTH - MSG_START - 1
CHAR_WIDTH = 16
CHAR_HEIGHT = 16
GAME_TITLE = "TRON"
CHAR_SET = "tron16x16_gs_ro.png"
GOLD_BOT = chr(240)
SLATE_BOT = chr(144)
RED_BOT = chr(153)
PURPLE_BOT = chr(160)
CYAN_BOT = chr(227)
BOT_SPRITES = [GOLD_BOT, SLATE_BOT, RED_BOT, PURPLE_BOT, CYAN_BOT]
TAKEN = 8912
OPEN = 12312
WALL = 323423
EMPTY = ' '
MULTIPLAYER = True
def __init__(self, random):
self.random = random
self.running = True
self.is_stopping = False
self.players = []
self.num_alive = 0
self.standings = []
self.turns = 0
self.level = 1
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 2,
self.SCREEN_WIDTH - self.MSG_START + 1,
4)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 2, self.MSG_START,
4)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Welcome to Game GRID!!!")
self.msg_panel.add("Stop The Corruption")
def start_game(self):
pass
def init_board(self):
self.map = MapPanel(1,
1,
self.MAP_WIDTH,
self.MAP_HEIGHT,
self.EMPTY,
border=PanelBorder.create(bottom=True,
left=True,
right=True,
top=True))
self.panels += [self.map]
def create_new_player(self, prog) -> Bike:
self.players += [self.place_bike(prog, len(self.players))]
player = self.players[-1]
self.map[player.pos()] = player.char
self.num_alive += 1
return player
def start_game(self):
self.update_player_states()
def place_bike(self, prog, bot_id):
while True:
x = self.random.randint(0, self.MAP_WIDTH - 1)
y = self.random.randint(0, self.MAP_HEIGHT - 1)
if self.map[(x, y)] == self.EMPTY:
return Bike((x, y),
self.BOT_SPRITES[bot_id % len(self.BOT_SPRITES)],
prog, self.get_move_consts())
def do_turn(self):
if self.is_stopping:
self.running = False
self.turns += 1
collision = []
self.num_alive = 0
for player in self.players:
if not player.derezzed:
if player.old is not None:
self.map[player.old] = player.prev_char
if player.x >= self.MAP_WIDTH or player.x < 0:
player.derezzed = True
elif player.y >= self.MAP_HEIGHT or player.y < 0:
player.derezzed = True
elif self.map[(player.x, player.y)] != ' ':
player.derezzed = True
else:
self.map[(player.x, player.y)] = player.char
if player.derezzed:
self.derezz(player)
self.msg_panel.add("{} was derezzed".format(player.name))
else:
self.num_alive += 1
elif player.quit:
player.quit = False
self.derezz(player)
self.msg_panel.add("{} was derezzed".format(player.name))
if self.num_alive == 1:
winning_player = [p for p in self.players if not p.derezzed][0]
self.msg_panel.add("{} Won!".format(winning_player.name))
for p in self.players:
if not p.derezzed:
self.standings += [p]
self.is_stopping = True
# if self.enemies > 0:
# self.msg_panel += ["END OF LINE"]
# else:
# self.msg_panel += ["Corruption progress has stopped Exit(0)"]
elif self.num_alive == 0:
self.msg_panel.add("No Player Won.")
self.is_stopping = True
self.update_player_states()
def derezz(self, bike):
for j in bike.path:
self.map[j] = self.EMPTY
bike.derezzed = True
self.standings += [bike]
def is_running(self):
return self.running
@staticmethod
def default_prog_for_bot(language):
if language == GameLanguage.LITTLEPY:
return open(os.path.join(os.path.dirname(__file__), "tron.lp"),
"r").read()
@staticmethod
def default_prog_for_computer():
return DumbComputer
@staticmethod
def get_intro():
return open(os.path.join(os.path.dirname(__file__), "intro.md"),
"r").read()
def get_score(self):
return Ranking(self.standings)
def draw_screen(self, frame_buffer):
# Update Status
self.status_panel["# Alive"] = str(self.num_alive)
self.status_panel["Turns"] = str(self.turns)
for panel in self.panels:
panel.redraw(frame_buffer)
def update_player_states(self):
for player in self.players:
if not player.derezzed:
player.bot_vars = self.get_vars(player)
def get_vars(self, player):
bot_vars = {
"s{}".format(i + 1): 0
for i in range(player.NUM_OF_SENSORS)
}
for i in range(len(player.sensor_coords)):
x_offset = int(player.sensor_coords[i][0])
y_offset = int(player.sensor_coords[i][1])
if player.x + x_offset >= self.MAP_WIDTH or player.x + x_offset < 0:
bot_vars["s" + str(i + 1)] = self.WALL
elif player.y + y_offset >= self.MAP_HEIGHT or player.y + y_offset < 0:
bot_vars["s" + str(i + 1)] = self.WALL
else:
if self.map[(player.x + x_offset, player.y + y_offset)] == ' ':
bot_vars["s" + str(i + 1)] = self.OPEN
else:
bot_vars["s" + str(i + 1)] = self.TAKEN
bot_vars["height"] = self.MAP_HEIGHT
bot_vars["width"] = self.MAP_WIDTH
bot_vars["map"] = self.get_map_array()
return bot_vars
def get_map_array(self):
map_array = []
for w in range(0, self.MAP_WIDTH):
width_arr = []
for h in range(0, self.MAP_HEIGHT):
if self.map[(w, h)] == ' ':
width_arr.append(self.OPEN)
else:
width_arr.append(self.TAKEN)
map_array.append(list(width_arr))
return map_array
@staticmethod
def get_move_consts():
consts = super(Tron, Tron).get_move_consts()
consts["OPEN"] = Tron.OPEN
consts["TAKEN"] = Tron.TAKEN
consts["WALL"] = Tron.WALL
return consts
@staticmethod
def get_number_of_players():
return 4
class Ski(GridGame):
MAP_WIDTH = 60
MAP_HEIGHT = 30
SCREEN_WIDTH = 60
SCREEN_HEIGHT = MAP_HEIGHT + 6
MSG_START = 20
MAX_MSG_LEN = SCREEN_WIDTH - MSG_START - 1
CHAR_WIDTH = 16
CHAR_HEIGHT = 16
GAME_TITLE = "Ski"
CHAR_SET = "terminal16x16_gs_ro.png"
NUM_OF_SENSORS = 8
SENSE_DIST = 20
LEVELUP_RESPONSES = [
"The forest seems to be getting more dense!",
"Are there more trees here or what?", "Watch out!",
"Better pay attention!"
]
ROBOT_CRASH_RESPONSES = [
"OOF!", "OWWWIE!", "THAT'S GONNA LEAVE A MARK!", "BONK!"
]
ROBOT_HEART_RESPONSES = [
"Wow, I feel a lot better!", "Shazam!", "That's the ticket!", "Yes!!!"
]
ROBOT_COIN_RESPONSES = [
"Cha-ching!", "Badabing!", "Bling! Bling!", "Wahoo!"
]
ROBOT_FLYING_RESPONSES = [
"I'm free as a bird now!", "It's a bird, it's a plane...", "Cowabunga!"
]
NUM_OF_ROCKS_START = 30
NUM_OF_TREES_START = 30
NUM_OF_SPIKES_START = 30
NUM_OF_SNOWMAN_START = 30
NUM_OF_COINS_START = 1
NUM_OF_HEARTS_START = 1
NUM_OF_JUMPS_START = 1
MAX_TURNS = 500
MAX_FLYING = 10
FLYING_POINTS = 5
COIN_POINTS = 25
HOUSE_ODDS = 500 # e.g., 1/500
PLAYER = '@'
EMPTY = '\0'
HEART = chr(3)
COIN = chr(4)
ROCK = chr(15)
SPIKE = chr(16)
SNOWMAN = chr(17)
TRACKS = chr(29)
TREE = chr(30)
JUMP = chr(31)
DEAD = chr(1)
FLY = chr(2)
CRASH = chr(8)
HOUSE = chr(9)
def __init__(self, random):
self.random = random
self.running = True
self.colliding = False
self.saved_object = None # stores a map item we're "on top of"
self.last_move = 'w' # need this to restore objects
self.flying = 0 # set to some value and decrement (0 == on ground)
self.hp = 1
self.player_pos = [int(self.MAP_WIDTH / 2), self.MAP_HEIGHT - 4]
self.score = 0
self.objects = []
self.turns = 0
self.level = 1
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 1,
self.SCREEN_WIDTH - self.MSG_START, 5)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 1, self.MSG_START,
5)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Velkommen to Robot Backcountry Skiing!")
self.msg_panel.add("Move left and right! Don't crash!")
self.__create_map()
def __create_map(self):
self.map = MapPanel(0,
0,
self.MAP_WIDTH,
self.MAP_HEIGHT + 1,
self.EMPTY,
border=PanelBorder.create(bottom="-"))
self.panels += [self.map]
self.place_objects(self.TREE, self.NUM_OF_ROCKS_START)
self.place_objects(self.ROCK, self.NUM_OF_TREES_START)
self.place_objects(self.SNOWMAN, self.NUM_OF_SNOWMAN_START)
self.place_objects(self.COIN, self.NUM_OF_COINS_START)
self.place_objects(self.HEART, self.NUM_OF_HEARTS_START)
self.place_objects(self.JUMP, self.NUM_OF_JUMPS_START)
# make a clearing for the player
for y in range(8):
for x in range(self.MAP_WIDTH):
self.map[(x, self.MAP_HEIGHT - 1 - y)] = self.EMPTY
# place decorative trees
self.map[(self.player_pos[0] + 5, self.player_pos[1])] = self.TREE
self.map[(self.player_pos[0] - 5, self.player_pos[1])] = self.TREE
# place initial hearts
self.map[(self.player_pos[0], self.player_pos[1] - 2)] = self.HEART
self.map[(self.player_pos[0], self.player_pos[1] - 3)] = self.HEART
def init_board(self):
pass
def create_new_player(self, prog):
self.player = SkiPlayer(prog, self.get_move_consts(),
self.NUM_OF_SENSORS)
# place player
self.map[(self.player_pos[0], self.player_pos[1])] = self.PLAYER
self.update_vars_for_player()
return self.player
def start_game(self):
pass
def place_objects(self, char, count, replace=False):
placed_objects = 0
while placed_objects < count:
x = self.random.randint(0, self.MAP_WIDTH - 1)
y = self.random.randint(0, self.MAP_HEIGHT - 1)
if self.map[(x, y)] == self.EMPTY:
self.map[(x, y)] = char
placed_objects += 1
elif replace:
# we can replace objects that exist
self.map[(x, y)] = char
placed_objects += 1
def make_new_row(self):
for x in range(self.MAP_WIDTH):
here = self.random.randint(0, self.MAX_TURNS)
if here <= self.turns:
which = self.random.randint(0, 2)
if which == 0:
self.map[(x, 0)] = self.ROCK
elif which == 1:
self.map[(x, 0)] = self.TREE
elif which == 2:
self.map[(x, 0)] = self.SNOWMAN
if self.random.randint(0, 100) > 33:
self.map[(self.random.randint(0,
self.MAP_WIDTH - 1), 0)] = self.HEART
if self.random.randint(0, 100) > 33:
self.map[(self.random.randint(0,
self.MAP_WIDTH - 1), 0)] = self.COIN
if self.random.randint(0, 100) > 33:
self.map[(self.random.randint(0,
self.MAP_WIDTH - 1), 0)] = self.JUMP
if self.random.randint(0, self.HOUSE_ODDS) == 1:
self.map[(self.random.randint(0,
self.MAP_WIDTH - 1), 0)] = self.HOUSE
def save_object(self, obj):
self.saved_object = obj
def restore_object_tracks(self):
# restore an object you went over or make tracks
# where should the object be restored?
y = 1 # it's always going to be behind us
x = 0 # we will set the x value accordingly
if self.last_move == 'a':
x = 1
elif self.last_move == 'd':
x = -1
elif self.last_move == 'w':
x = 0
if self.saved_object:
if self.last_move == 't':
# if the player previously teleported when on an
# obstacle, just destroy the obstacle. We can't put it
# back where it was because we don't know (x, y) for the
# player due to map shifting, and we can't draw it under
# us or we will collide with it twice!
self.msg_panel.add("Teleporting destroyed the object!")
self.saved_object = None
else:
# if the player didn't teleport, put object back
self.map[(self.player_pos[0] + x,
self.player_pos[1] + y)] = self.saved_object
self.saved_object = None
else:
if self.flying < 1:
if self.map[(self.player_pos[0] + x,
self.player_pos[1] + y)] == self.EMPTY:
self.map[(self.player_pos[0] + x,
self.player_pos[1] + y)] = self.TRACKS
def shift_map(self):
# shift all rows down
dx = int(self.MAP_WIDTH / 2) - self.player_pos[0]
self.map.shift_all((dx, 1), wrap_x=True)
self.player_pos[0] += dx
self.make_new_row()
self.restore_object_tracks()
def do_turn(self):
self.handle_key(self.player.move)
self.update_vars_for_player()
def handle_key(self, key):
if (DEBUG):
print("Move {}".format(self.player.move))
print("Key {}".format(key))
self.turns += 1
if self.flying > 0:
self.score += self.FLYING_POINTS
self.flying -= 1
self.msg_panel.add("In flight for " + str(self.flying) +
" turns...")
if self.flying == 0:
self.msg_panel.add("Back on the ground!")
else:
self.score += 1
if self.turns % 30 == 0:
self.level += 1
if (DEBUG):
print("player_pos[0] {} player_pos[1] {}".format(
self.player_pos[0], self.player_pos[1]))
self.map[(self.player_pos[0], self.player_pos[1])] = self.EMPTY
if key == "a":
self.player_pos[0] -= 1
if key == "d":
self.player_pos[0] += 1
if key == "w":
pass
if key == "t":
# horizontal-only teleporting code
self.msg_panel.add("TELEPORT! (-1 HP)")
self.hp -= 1
self.player_pos[0] = self.random.randint(0, self.MAP_WIDTH - 1)
if key == "Q":
self.running = False
return
if (DEBUG):
print("Key was: %s turn #%d" % (key, self.turns))
self.last_move = key # save last move for saved_object restoration
# shift the map
self.shift_map()
self.colliding = False # reset colliding variable
# check for various types of collisions (good and bad)
if self.map[(self.player_pos[0], self.player_pos[1])] == self.ROCK:
self.save_object(self.ROCK)
if self.flying == 0:
self.colliding = True
self.hp -= 10
self.msg_panel.add(
self.random.choice(
list(
set(self.ROBOT_CRASH_RESPONSES) -
set(self.msg_panel.get_current_messages()))))
elif self.map[(self.player_pos[0], self.player_pos[1])] == self.TREE:
self.save_object(self.TREE)
if self.flying == 0:
self.colliding = True
self.hp -= 2
self.msg_panel.add(
self.random.choice(
list(
set(self.ROBOT_CRASH_RESPONSES) -
set(self.msg_panel.get_current_messages()))))
elif self.map[(self.player_pos[0],
self.player_pos[1])] == self.SNOWMAN:
if self.flying == 0:
self.colliding = True
self.hp -= 1
self.msg_panel.add(
self.random.choice(
list(
set(self.ROBOT_CRASH_RESPONSES) -
set(self.msg_panel.get_current_messages()))))
else:
self.save_object(
self.SNOWMAN) # flying over snowmen is nondestructive
elif self.map[(self.player_pos[0], self.player_pos[1])] == self.HEART:
if self.flying == 0:
if self.hp < 10:
self.hp += 1
self.msg_panel.add(
self.random.choice(
list(
set(self.ROBOT_HEART_RESPONSES) -
set(self.msg_panel.get_current_messages()))))
else:
self.msg_panel.add("Your HP is already full!")
else:
self.save_object(self.HEART)
elif self.map[(self.player_pos[0], self.player_pos[1])] == self.HOUSE:
if self.flying == 0:
self.hp = 10
self.msg_panel.add("This cabin was very refreshing!")
else:
self.save_object(self.HOUSE)
elif self.map[(self.player_pos[0], self.player_pos[1])] == self.COIN:
if self.flying == 0:
self.score += self.COIN_POINTS
self.msg_panel.add(
self.random.choice(
list(
set(self.ROBOT_COIN_RESPONSES) -
set(self.msg_panel.get_current_messages()))))
else:
self.save_object(self.COIN)
elif self.map[(self.player_pos[0], self.player_pos[1])] == self.JUMP:
if self.flying == 0:
self.save_object(self.JUMP)
self.flying += self.random.randint(2, self.MAX_FLYING)
self.msg_panel.add(
self.random.choice(
list(
set(self.ROBOT_FLYING_RESPONSES) -
set(self.msg_panel.get_current_messages()))))
else:
self.save_object(self.JUMP)
# draw player
if self.flying < 1:
if self.colliding:
self.map[(self.player_pos[0], self.player_pos[1])] = self.CRASH
else:
self.map[(self.player_pos[0],
self.player_pos[1])] = self.PLAYER
else:
self.map[(self.player_pos[0], self.player_pos[1])] = self.FLY
# Check for game-ending state:
if self.turns >= self.MAX_TURNS:
self.running = False
elif self.hp <= 0:
self.running = False
self.map[(self.player_pos[0], self.player_pos[1])] = self.DEAD
def is_running(self):
return self.running
def get_map_array_tuple(self):
map_arr = []
for w in range(0, self.MAP_WIDTH):
w_arr = []
for h in range(0, self.MAP_HEIGHT):
w_arr.append(ord(self.map.p_to_char[(w, h)]))
map_arr.append(tuple(w_arr))
return tuple(map_arr)
def update_vars_for_player(self):
bot_vars = {
"jump_x":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.JUMP,
default=(0, 0))[0],
"jump_y":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.JUMP,
default=(0, 0))[1],
"heart_x":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.HEART,
default=(0, 0))[0],
"heart_y":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.HEART,
default=(0, 0))[1],
"coin_x":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.COIN,
default=(0, 0))[0],
"coin_y":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.COIN,
default=(0, 0))[1],
"house_x":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.HOUSE,
default=(0, 0))[0],
"house_y":
self.map.get_x_y_dist_to_foo(tuple(self.player_pos),
self.HOUSE,
default=(0, 0))[1],
"map_width":
self.MAP_WIDTH,
"map_height":
self.MAP_HEIGHT,
"hp":
0,
"flying":
0,
"s1":
0,
"s2":
0,
"s3":
0,
"s4":
0,
"s5":
0,
"s6":
0,
"s7":
0
}
# go through self.sensor_coords and retrieve the map item at the
# position relative to the player
for i in range(self.NUM_OF_SENSORS):
if (i < len(self.player.sensor_coords)):
sensor = "s" + str(i + 1)
x_offset = self.player.sensor_coords[i][0]
y_offset = self.player.sensor_coords[i][1]
bot_vars[sensor] = ord(
self.map[(self.player_pos[0] + int(x_offset),
self.player_pos[1] + int(y_offset))])
if (DEBUG):
print(
"sensor: %s - i: %d - x_off: %s y_off: %s content: %s"
% (sensor, i, x_offset, y_offset, bot_vars[sensor]))
if bot_vars[sensor] == 64:
bot_vars[sensor] = 0
bot_vars['hp'] = self.hp
bot_vars['flying'] = self.flying
bot_vars['map_array'] = self.get_map_array_tuple()
if DEBUG:
print("Printing bot_vars:")
for key in bot_vars.keys():
if key != "map_array":
print("%s ==> %s" % (key, bot_vars[key]))
else:
# sort of pretty print the map
for rownum in range(len(bot_vars['map_array'])):
print("%02d: " % (rownum), end='')
for val in bot_vars['map_array'][rownum]:
print("%02d " % (val), end='')
print("")
print(
"Note: map printed sideways for terminal readability (bottom on right)"
)
print(
"Note: robot already dead in last frame -- 2nd to last more useful!"
)
print("")
self.player.bot_vars = bot_vars
@staticmethod
def default_prog_for_bot(language):
if language == GameLanguage.LITTLEPY:
return open("bot.lp", "r").read()
@staticmethod
def get_intro():
return open("intro.md", "r").read()
@staticmethod
def get_move_consts():
return ConstMapping({
"teleport": ord("t"),
"west": ord("a"),
"east": ord("d"),
"heart": ord(Ski.HEART),
"coin": ord(Ski.COIN),
"rock": ord(Ski.ROCK),
"spikes": ord(Ski.SPIKE),
"snowman": ord(Ski.SNOWMAN),
"tracks": ord(Ski.TRACKS),
"tree": ord(Ski.TREE),
"jump": ord(Ski.JUMP),
"house": ord(Ski.HOUSE),
})
@staticmethod
def get_move_names():
names = Game.get_move_names()
names.update({ord("t"): "teleport"})
names.update({ord("d"): "east"})
names.update({ord("a"): "west"})
names.update({ord(Ski.HEART): "heart"})
names.update({ord(Ski.COIN): "coin"})
names.update({ord(Ski.ROCK): "rock"})
names.update({ord(Ski.SPIKE): "spikes"})
names.update({ord(Ski.SNOWMAN): "snowman"})
names.update({ord(Ski.TRACKS): "tracks"})
names.update({ord(Ski.TREE): "tree"})
names.update({ord(Ski.JUMP): "jump"})
names.update({ord(Ski.HOUSE): "house"})
return names
def get_score(self):
return self.score
def draw_screen(self, frame_buffer):
# End of the game
if self.turns >= self.MAX_TURNS:
self.msg_panel.add("You are out of moves.")
elif self.hp <= 0:
self.msg_panel.add("You sustained too much damage!")
if not self.running:
self.msg_panel.add("GAME 0VER: Score:" + str(self.score))
# Update Status
self.status_panel["Score"] = self.score
self.status_panel["Move"] = str(self.turns) + " of " + str(
self.MAX_TURNS)
self.status_panel["HP"] = self.HEART * self.hp
for panel in self.panels:
panel.redraw(frame_buffer)
class Tron(Game):
SCREEN_WIDTH = 60
SCREEN_HEIGHT = 50
MAP_WIDTH = 40 #TRUE DIMENSIONS
MAP_HEIGHT = 30 #TRUE DIMENSIONS
MSG_START = 30
MAX_MSG_LEN = MAP_WIDTH - MSG_START - 1
CHAR_WIDTH = 16
CHAR_HEIGHT = 16
GAME_TITLE = "TRON"
CHAR_SET = "tron16x16_gs_ro.png"
EMPTY = ' '
def __init__(self, random):
self.random = random
self.running = True
self.NUM_ENEMIES = 2
self.enemies = self.NUM_ENEMIES
self.USER = None
self.CORRUPTION = []
self.CORRUPTION_POSITIONS = []
self.turns = 0
self.level = 1
self.msg_panel = MessagePanel(self.MSG_START, self.MAP_HEIGHT + 1,
self.SCREEN_WIDTH - self.MSG_START, 5)
self.status_panel = StatusPanel(0, self.MAP_HEIGHT + 1, self.MSG_START,
5)
self.panels = [self.msg_panel, self.status_panel]
self.msg_panel.add("Welcome to Game GRID!!!")
self.msg_panel.add("Stop The Corruption")
self.__create_map()
def __create_map(self):
self.map = MapPanel(0,
0,
self.MAP_WIDTH,
self.MAP_HEIGHT + 1,
self.EMPTY,
border=PanelBorder.create(bottom=True,
left=True,
right=True,
top=True))
self.panels += [self.map]
self.place_bikes()
for i in self.CORRUPTION:
self.map[i.pos()] = i.char
self.map[self.USER.pos()] = self.USER.char
def place_bikes(self):
for i in range(0, self.NUM_ENEMIES + 1):
while True:
x = self.random.randint(self.map.x + 1, self.map.w - 1)
y = self.random.randint(self.map.y + 1, self.map.h - 1)
if self.map[(x, y)] == self.EMPTY:
if i == self.enemies:
self.USER = User((x, y), chr(239))
else:
self.CORRUPTION += [
Computer((x, y), chr(234), self.level)
]
self.CORRUPTION_POSITIONS += [(x, y)]
break
def handle_key(self, key):
self.turns += 1
if key == "w":
self.USER.move("NORTH")
if key == "s":
self.USER.move("SOUTH")
if key == "a":
self.USER.move("WEST")
if key == "d":
self.USER.move("EAST")
if key == "Q":
self.running = False
return
self.map[self.USER.old] = self.USER.prev_char
if self.USER.x == self.map.w or self.USER.x < self.map.x - 1:
self.running = False
elif self.USER.y == self.map.h or self.USER.y < self.map.y - 1:
self.running = False
elif self.map[(self.USER.x, self.USER.y)] != ' ':
self.running = False
else:
self.map[(self.USER.x, self.USER.y)] = self.USER.char
self.spread_corruption()
def spread_corruption(self):
collision = []
for i in range(0, len(self.CORRUPTION)):
cor = self.CORRUPTION[i]
if cor.derezzed == True:
continue
cor.make_move(self.map, self.map.w, self.map.h)
self.map[cor.old] = cor.prev_char
if cor.x == self.map.w or cor.x < self.map.x:
self.derezz(i)
elif cor.y == self.map.h or cor.y < self.map.y:
self.derezz(i)
elif cor.pos() in self.CORRUPTION_POSITIONS:
self.derezz(i)
self.derezz(self.CORRUPTION_POSITIONS.index(cor.pos()))
elif cor.pos() == self.USER.pos():
self.running = False #User collision, failure
elif self.map[cor.pos()] != self.EMPTY:
self.derezz(i)
else:
self.map[cor.pos()] = cor.char
self.CORRUPTION_POSITIONS[i] = cor.pos()
if self.enemies == 0:
self.running = False
def derezz(self, cor_ind):
cor = self.CORRUPTION[cor_ind]
for j in cor.derezz():
self.map[j] = self.EMPTY
cor.derezzed = True
self.enemies -= 1
def is_running(self):
return self.running
@staticmethod
def default_prog_for_bot(language):
if language == GameLanguage.LITTLEPY:
return open("apple_bot.lp", "r").read()
@staticmethod
def get_intro():
return open("intro.md", "r").read()
def get_score(self):
return self.apples_eaten
def draw_screen(self, frame_buffer):
# End of the game
if not self.running:
if self.enemies > 0:
self.msg_panel += ["END OF LINE"]
else:
self.msg_panel += ["Corruption progress has stopped Exit(0)"]
# Update Status
self.status_panel["Enemies"] = str(self.enemies) + " left"
self.status_panel["Turns"] = str(self.turns)
for panel in self.panels:
panel.redraw(frame_buffer)
def get_vars_for_bot(self):
return {}
class FlappyBird(GridGame):
MAP_WIDTH = 40
MAP_HEIGHT = 35
SCREEN_WIDTH = 40
SCREEN_HEIGHT = MAP_HEIGHT + 6
MSG_START = 20
MAX_MSG_LEN = SCREEN_WIDTH - MSG_START - 1
CHAR_WIDTH = 16
CHAR_HEIGHT = 16
GAME_TITLE = "Flappy Robot"
EMPTY = ' '
PLAYER = '@'
PIPE = chr(11 * 16 + 3) #'|'
PIPE_TOP_LEFT = chr(13 * 16 + 4)
PIPE_TOP_RIGHT = chr(11 * 16 + 14)
PIPE_BUTTOM_LEFT = chr(13 * 16 + 5)
PIPE_BUTTOM_RIGHT = chr(11 * 16 + 8)
MAP_BOTTOM = chr(12 * 16 + 4)
PLAYER_X = 2
MAX_DOWNWARD_SPEED = 4
CHAR_SET = "resources/terminal16x16_gs_ro.png"
PASSING_SOUNDS = ['Swish!', 'Whoosh!', 'Swoosh!', 'Chirp', 'Tweet']
def __init__(self, random):
self.random = random
self.running = True
self.player_y = self.MAP_HEIGHT // 2
self.player_v = 0
self.x = 0
self.pipes_passed = 0
self.pipes = []
self.msg_panel = MessagePanel(self.MSG_START,
self.MAP_HEIGHT + 1,
self.SCREEN_WIDTH - self.MSG_START,
5,
padding=PanelPadding.create(top=1,
right=1,
bottom=1))
self.status_panel = StatusPanel(0,
self.MAP_HEIGHT + 1,
self.MSG_START,
5,
padding=PanelPadding.create(top=1,
left=1,
bottom=1))
self.panels = [self.status_panel, self.msg_panel]
self.msg_panel.add("Welcome to")
self.msg_panel.add(" " + self.GAME_TITLE + "!!!")
self.msg_panel.add("Don't hit the pipes")
def init_board(self):
self.map = MapPanel(0,
0,
self.MAP_WIDTH,
self.MAP_HEIGHT,
self.EMPTY,
border=PanelBorder.create(bottom=self.MAP_BOTTOM))
self.panels.append(self.map)
def create_new_player(self, prog):
self.player = DefaultGridPlayer(prog, self.get_move_consts())
self.map[(self.PLAYER_X, self.player_y)] = self.PLAYER
self.update_vars_for_player()
return self.player
def start_game(self):
pass
def do_turn(self):
# print("doing turn")
self.handle_key(self.player.move)
self.move_pipes()
self.draw_pipe_if_needed()
self.update_vars_for_player()
def handle_key(self, key):
if key == 'Q':
self.running = False
return
self.map[(self.PLAYER_X, self.player_y)] = self.EMPTY
if key == 'w' or key == ' ':
self.player_y -= 2
self.player_v = -1
else:
self.player_y += self.player_v
self.player_v += 1 if self.player_v < self.MAX_DOWNWARD_SPEED else 0
self.x += 1
self.map.shift_all((-1, 0))
new_pos = (self.PLAYER_X, self.player_y)
if not self.map.in_bounds(new_pos) or self.map[new_pos] == self.PIPE:
self.running = False
# self.msg_panel.add("You flu into a pipe!")
else:
self.map[(self.PLAYER_X, self.player_y)] = self.PLAYER
def move_pipes(self):
num_pipes_before = len(self.pipes)
self.pipes = [pipe.shift() for pipe in self.pipes if pipe.x > 1]
num_pipes_after = len(self.pipes)
self.pipes_passed += num_pipes_before - num_pipes_after
def draw_pipe_if_needed(self):
if not self.pipes:
self.pipes.append(self.create_pipe())
self.draw_pipe(self.pipes[-1])
else:
last_pipe = self.pipes[-1]
dist_from_last_pipe = self.MAP_WIDTH - last_pipe.x
print(dist_from_last_pipe)
if dist_from_last_pipe > (20 - (self.x // 100)):
self.pipes.append(self.create_pipe())
self.draw_pipe(self.pipes[-1])
return
# print(f"space: {(20 - (self.x//25))}")
# if self.x % (20 - (self.x//100)) == 0:
# position = self.random.choice(range(10, self.MAP_HEIGHT-10))
# for i in range(self.MAP_HEIGHT):
# if abs(position-i) > 3:
# self.map[(self.MAP_WIDTH - 1, i)] = self.PIPE
# self.map[(self.MAP_WIDTH - 2, i)] = self.PIPE
def draw_pipe(self, pipe):
print(f'Drawing {pipe}')
for i in range(self.MAP_HEIGHT):
if abs(pipe.y - i) > 3:
if pipe.y - i == 4:
self.map[(pipe.x, i)] = self.PIPE_TOP_LEFT
self.map[(pipe.x + 1, i)] = self.PIPE_TOP_RIGHT
elif pipe.y - i == -4:
self.map[(pipe.x, i)] = self.PIPE_BUTTOM_LEFT
self.map[(pipe.x + 1, i)] = self.PIPE_BUTTOM_RIGHT
else:
self.map[(pipe.x, i)] = self.PIPE
self.map[(pipe.x + 1, i)] = self.PIPE
def create_pipe(self):
print('Creating pipe')
y = self.random.choice(range(10, self.MAP_HEIGHT - 10))
return Pipe(self.MAP_WIDTH - 2, y)
def update_vars_for_player(self):
bot_vars = {
"y":
self.player_y,
"next_pipe_y":
self.pipes[0].y if self.pipes else -1,
"dist_to_next_pipe":
self.pipes[0].x - self.PLAYER_X if self.pipes else 9999,
}
self.player.bot_vars = bot_vars
def is_running(self):
return self.running
def draw_screen(self, frame_buffer):
if not self.running:
self.msg_panel.add("Game Over.")
if self.pipes_passed == 0:
self.msg_panel.add("Better luck")
self.msg_panel.add(" next time :(")
else:
self.msg_panel.add(" Good job!")
self.status_panel["Meters Flown"] = self.x
self.status_panel["Pipes Passed"] = self.pipes_passed
self.status_panel["Score"] = self.get_score()
for panel in self.panels:
panel.redraw(frame_buffer)
def get_score(self):
return self.x + (self.pipes_passed * 50)
@staticmethod
def get_intro():
return open("resources/intro.md", "r").read()
@staticmethod
def default_prog_for_bot(language):
if language == GameLanguage.LITTLEPY:
return open("resources/flappy_bot.lp", "r").read()
@staticmethod
def get_move_consts():
return ConstMapping({
"flap": ord(" "),
"up": ord("w"),
"down": ord("s"),
"glide": ord("d")
})