def __init__(self):
self.screen = pygame.display.set_mode((setting.WIDTH, setting.HEIGHT))
self.clock = pygame.time.Clock()
self.running = True
self.state = 'start'
self.cell_width = setting.MAZE_WIDTH // setting.COLS
self.cell_height = setting.MAZE_HEIGHT // setting.ROWS
#load from environment file
self.walls = []
self.coins = []
self.powerups = []
self.turns = []
self.enemies = []
self.enemies_to_respawn = []
self.scatter_targets = []
self.e_pos = []
self.p_pos = None
self.respawn = None
self.load()
self.player = Player(self, vec(self.p_pos))
self.make_enemies()
self.current_score = 0
self.highscore = self.get_highscore()
self.level = 0
self.difficulty = 'normal'
self.map_type = 'basic'
async def roles(ctx):
summoner = cass.get_summoner(name='aresyama')
match = summoner.match_history[0]
teams = match.teams
team_1 = teams[0].participants
player_1 = Player(team_1[0].summoner.name, team_1[0].champion.name)
best_role = player_1.main_role()
await ctx.send(best_role)
def __init__(self):
self.dico_sum_position = {
key: 0
for key in list(map(str, range(1, 8)))
}
self.current_serie = ''
self.player_list = [
Player('René Caravel', 'x'),
Player('Miroslav O\'matic ', 'o')
]
def play_game(self):
P1 = Player(self.player_1_type, 1)
P2 = Player(self.player_2_type, 2)
B = Board()
player_list = [P1, P2]
turn_count = 0
error_count = 0
winner_id = ''
while turn_count < 42:
current_player = player_list[turn_count % 2]
move, piece = current_player.make_move_master(B.board_dict)
# print("You are here. This is move we got coming in: " + str(move))
if B.is_error(move) != 0:
if B.is_error(int(move)) == 1:
print('ERROR CODE 1 move not int!')
error_count += 1
# print('Error count: ' + str(error_count))
continue
if B.is_error(int(move)) == 2:
print('ERROR CODE 2 move not 1-7!')
error_count += 1
# print('Error count: ' + str(error_count))
if current_player.player_type == 'Human':
continue
else:
break
if B.is_error(int(move)) == 3:
# print('ERROR CODE 3 move off board')
error_count += 1
# print('Error count: ' + str(error_count))
continue
error_count = 0
B.board_move(move, piece)
if self.print_status == 2:
B.print_board()
if B.is_win() is True:
winner_id = (turn_count % 2) + 1
print("Game Won!!!")
break
turn_count += 1
if winner_id == '':
winner_id = 3
if self.print_status == 1 or self.print_status == 2:
print("FINAL BOARD: ")
B.print_board()
print(B.board_dict)
print('')
print(B.move_list)
return winner_id, B.board_dict
def main():
#display introductory text describing the game
introText()
#create a player object with parameters for the player's name (to be entered by player) and
player = Player(inputName())
print(
"You hop into the Ecto-1 and see the Empire State Building 10 blocks ahead of you."
)
stepsLeft = stepForward(player)
currentEnergy = player.getProtonEnergy()
if currentEnergy > 0 and stepsLeft == 0:
print(
"\nCongratulations! You have reached the Empire State Building and rescued the Ghostbusters!"
)
print("FINAL STATS FOR {}: ".format(player.getPlayerName()))
print(" Ghosts Caught: {}".format(player.getGhostsCollected()))
print(" Proton Energy: {}".format(player.getProtonEnergy()))
winnerGraphic()
if currentEnergy <= 0:
currentEnergy = 0
print("\nGAME OVER")
print(
"You and the rest of New York City have succumbed to this paranormal war. The world is doomed."
)
print("FINAL STATS FOR {}: ".format(player.getPlayerName()))
print(" Ghosts Caught: {}".format(player.getGhostsCollected()))
print(" Proton Energy: {}".format(currentEnergy))
def play(self) -> None: # game loop that handles playing the game
curPlayer = None
for playerNum in range(2):
self.players.append(Player(self.players, self.board))
self.players[playerNum].getListOfShips()
curPlayer = self.getCurPlayer()
self.takeShips()
self.changeTurn()
self.possibleTotalHits = self.getMaxHits()
outerCheck = False
while not self.someoneWon(outerCheck):
curPlayer = self.getCurPlayer()
print("{}'s Scanning Board".format(curPlayer.name))
print(curPlayer.scanningBoard)
print("{}'s Board".format(curPlayer.name))
print(curPlayer.playerBoard)
curPlayer.move(curPlayer, self.getOtherPlayer())
print(
f"{curPlayer.name}'s Scanning Board\n{curPlayer.scanningBoard}\n{curPlayer.name}'s Board\n{curPlayer.playerBoard}\n",
end='')
if (curPlayer.hitCounter == self.possibleTotalHits):
outerCheck = True
self.someoneWon(outerCheck)
continue
self.changeTurn()
self.displayTheWinner(curPlayer)
def createSprites(self):
player = Player(2, self.width, self.height) #Create player at speed 2
self.player = player
self.loadSprite(player, "player") #load player into sprite group
self.loadSprite(Number(0, self.height, self.width, 0, 100, False, 50, self.wins), "scores")
self.loadSprite(Number(0, self.height, self.width, 750, 100, False, 50, self.losses), "scores")
numbers = []
equation = self.randomEquationGen()
xpos = 250
for val in equation[0].split(" "):
numbers.append(Number(0, self.height, self.width, xpos , 325, False, 50, val))
xpos += 100
rand = random.choice([250, 425])
self.answer = Number(0, self.height, self.width, rand, 100, False, 50, str(equation[1]))
numbers.append(self.answer)
randans = str(random.randint(0, 81))
if randans == str(equation[1]):
randans = str(int(randans)+1)
if rand == 250:
numbers.append(Number(0, self.height, self.width, 425, 100, False, 50, randans))
else:
numbers.append(Number(0, self.height, self.width, 250, 100, False, 50, randans))
for num in numbers:
self.loadSprite(num, "number")
def create_players(p, bots, minimum, maximum):
""" Create and append players and bots and return list of players."""
players = []
for i in range(0, p):
n, b = get_user_info(i)
players.append(Player(n, b, "Human", minimum, maximum))
if not bot_bets:
for i in range(0, bots):
entering = True
while entering:
try:
cash = int(
raw_input(
"Enter starting cash for Bot {num} "
"(20, 50, 100, 200, 500, 1000, 2000): "
.format(num = i+1)))
if cash in [20, 50, 100, 200, 500, 1000, 2000]:
entering = False
else:
print(
"Please enter one of these: (20, 50, 100, 200, 500): "
)
except ValueError, e:
print("Enter a number please")
players.append(BotPlayer("",cash, "Bot", minimum, maximum))
def init_players(player_number):
player_list = []
for i in range(player_number):
player_list.append(Player(i))
for i, player in enumerate(player_list):
print(f"Insert name for player {i + 1}:")
player.get_player_name()
return player_list
def new(self):
"""For things that should happen once, at the start of a new game"""
# Load map from file
self.map_folder = path.join(self.game_folder, 'data/maps')
# self.map = Map(path.join(game_folder, 'map.txt'))
self.map = TiledMap(self, path.join(self.map_folder, MAP_NAME))
self.map_img = self.map.make_map()
self.map_rect = self.map_img.get_rect()
# self.paths = breadth_first_search(self.map, self
# initialize all variables and do all the setup for a new game
self.all_sprites = pg.sprite.LayeredUpdates()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
# For Loading map from tmx data
for tile_object in self.map.tmxdata.objects:
obj_center = vec(tile_object.x + tile_object.width / 2,
tile_object.y + tile_object.height / 2)
if tile_object.name == 'player':
self.player = Player(self, obj_center.x, obj_center.y)
if tile_object.name == 'zombie':
Mob(self, obj_center.x,
obj_center.y) # For EM all entities must have unique id
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
if tile_object.name in ['health', 'shotgun', 'pistol']:
Item(self, obj_center, tile_object.name)
# self.EM = AI.EntityManager()
for mob in self.mobs:
# self.EM.add_entity(mob.id) #All entities must have a unique id
mob.SM.current_state = zombie_states.Idle(self, mob)
mob.SM.global_state = zombie_states.ZombieGlobalState(self, mob)
assert self.player is not None
self.camera = Camera(self.map.width,
self.map.height) # Give camera total size of map
# Flags
self.draw_debug = False
self.paused = False
self.night = False
self.effects_sounds['level_start'].play()
def __init__(self):
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
self.clock = pygame.time.Clock()
self.running = True
self.state = 'start'
self.cell_width = MAZE_WIDTH // COLS
self.cell_height = MAZE_HEIGHT // ROWS
self.walls = []
self.coins = []
self.enemies = []
self.e_pos = []
self.p_pos = None
self.highscore = 0
self.load()
self.player = Player(self, vec(self.p_pos))
self.make_enemies()
def add_players():
""" Add players to the game """
x = int(input('How many players do you wanna add to the game? '))
num = 0
while x != num:
name = Player(input('Add a new player: '))
players.append(name.name)
num += 1
print(len(players))
def __init__(self, n, c, t, tbl_min, tbl_max,s=None, bs=None): Player.__init__(self, n, c, t, tbl_min, tbl_max) if s is not None: self._hand_strategy = s else: self._hand_strategy = BotPlayer \ .hand_strategies \ [randint(0, len(BotPlayer.hand_strategies)-1)] self._hand_strategy_name = BotPlayer \ .hand_strategy_names[self.hand_strategy-1] if bs is not None: self._bet_strategy = s else: self._bet_strategy = BotPlayer \ .bet_strategies \ [randint(0, len(BotPlayer.bet_strategies)-1)] self._bet_strategy_name = BotPlayer \ .bet_strategy_names[self.bet_strategy-1]
def __init__(self, n, c, t, tbl_min, tbl_max, s=None, bs=None):
Player.__init__(self, n, c, t, tbl_min, tbl_max)
if s is not None:
self._hand_strategy = s
else:
self._hand_strategy = BotPlayer \
.hand_strategies \
[randint(0, len(BotPlayer.hand_strategies)-1)]
self._hand_strategy_name = BotPlayer \
.hand_strategy_names[self.hand_strategy-1]
if bs is not None:
self._bet_strategy = s
else:
self._bet_strategy = BotPlayer \
.bet_strategies \
[randint(0, len(BotPlayer.bet_strategies)-1)]
self._bet_strategy_name = BotPlayer \
.bet_strategy_names[self.bet_strategy-1]
def main():
# Pretending there is some input data that
namestring = "Michael Jackson,Janice Joplin,Tina Turner,Billy Joel"
# Calling the previous function
listed_and_separated = name_sep(namestring)
# Create an empty player dictionary
player_dictionary = dict()
# Loop through all names, I chose the first names, doesn't matter
for i in range(len(listed_and_separated[0])):
# Create a player class with a temporary variable name
name = Player(listed_and_separated[0][i],listed_and_separated[1][i], i+1)
# Add the id from the current player and add it to the dictionary as a key
# and assign a Dice instance as a value, with the name of the owner.
player_dictionary[name.get_id()] = Dice(listed_and_separated[0][i])
# Loop through keys, roll their dices and print the names
# and the dices current values
for key in player_dictionary:
player_dictionary[key].roll()
print(player_dictionary[key].get_owner(),player_dictionary[key].get_sideup())
class PlayerTest(unittest.TestCase):
def setUp(self):
name = "Beata"
score = 20
lives = 2
self.player = Player(score=score, name=name, lives=lives)
def test_is_name_correct(self):
expected_name = "Beata"
msg = "Name is not set correctly"
self.assertEqual(expected_name, self.player.get_name(), msg)
def test_is_score_correct(self):
expected_score = 20
msg = "Score is not set correctly"
self.assertEqual(expected_score, self.player.get_score(), msg)
def test_is_arg_lives_correct(self):
expected_lives = 2
msg = "Lives are not set correctly"
self.assertEqual(expected_lives, self.player.get_lives(), msg)
def start_tutorial(self):
'''Plays if there is no save file'''
player_name = self.get_name()
time.sleep(2)
player_type = self.get_type()
if player_type == "Special":
player = Player(name=player_name, attack=25, sp_attack=50)
print(
"Valder: Great! You can have this Spellbook, it's about flames"
)
player.inventory.add(Item("Flame Spellbook", 50, 50))
else:
player = Player(name=player_name, attack=50, sp_attack=25)
print("Valder: Then have this Iron Sword, it will keep you safe")
player.inventory.add(Item("Iron Sword", 50, 50))
file = open("save_file.sav", "wb")
pickle.dump(player, file)
file.close()
return player
def playAdventure():
print("Welcome to Codebreakers 2018 Adventures!\n")
name = input("What is your name? ")
global player
player = Player(name)
print("\nWelcome, {}! Remember, if you ever get lost or confused during the game, all you \
have to do is input 'help' and I'll tell you your options. Got it? Good!\n\nLet's get \
started!".format(player.name))
print('\n')
print('You are standing outside of an old house. You see a old sign out front and \
the front door appears to be the only way inside.\n')
while True:
user_choice = input("\nWhat do you want to do? ")
if user_choice.lower() == 'quit':
print("Thanks for playing!")
return
choice(user_choice)
K_ESCAPE,
KEYDOWN,
QUIT,
)
#==============================================================================
# Set up the drawing window
#==============================================================================
pygame.display.init()
screen_dim = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(screen_dim, pygame.FULLSCREEN)
#DISPLAYSURF = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
screen.fill((0, 0, 0))
# Create player
player = Player("stimulus.jpg", screen_dim, GAIN)
position = player.stim_center()
stim_threshold = position[0] + THRESHOLD
# create inital stimulus
screen.blit(player.surf, position)
#-----------------------------------------------------------------------------
# on soft code of state 4
#-----------------------------------------------------------------------------
# present initial stimulus
pygame.display.flip()
#==============================================================================
# py game loop
#==============================================================================
running = True
def setUp(self):
self.player1 = Player('roie')
self.player2 = Player('itamar')
self.card_deck = CardDeck()
self.card_deck2 = CardDeck()
class TestPlayer(TestCase):
def setUp(self):
self.player1 = Player('roie')
self.player2 = Player('itamar')
self.card_deck = CardDeck()
self.card_deck2 = CardDeck()
def test__set_hand(self):
"""
checks that no duplicated card is dealt to both players
"""
self.player1._Player__set_hand(self.card_deck, 26)
self.player2._Player__set_hand(self.card_deck, 26)
self.assertTrue(len(self.player1.hand) == len(self.player2.hand))
self.assertTrue(len(self.player1.hand) == 26)
for p1_card in self.player1.hand:
self.assertNotIn(p1_card, self.player2.hand)
def test__set_hand2(self):
"""
test the condition of the deck after dealing all of it remained as it should.
"""
self.player1._Player__set_hand(self.card_deck, 26)
self.player2._Player__set_hand(self.card_deck, 26)
# deck is empty ofter dealing all of it
self.assertEqual(self.card_deck.cards_list, [])
self.player1._Player__set_hand(self.card_deck2, 0)
self.player2._Player__set_hand(self.card_deck2, 0)
# deck is left with 50 cards after dealing 2
self.assertEqual(len(self.card_deck2.cards_list), 50)
def test_get_card(self):
"""
check that get_card get a card from the given player not somewhere else
"""
self.player1._Player__set_hand(self.card_deck, 1)
p1_card = self.player1.hand[0]
# checks a card from the players hand is dealt and not a random card from somewhere else
self.assertEqual(p1_card, self.player1.get_card())
# checks the card is removed
self.assertEqual(self.player1.hand, [])
def test_get_card2(self):
"""
checks the cards got from the player are random and not the first in the deck.
the test will be on three cards, because 1 if tried with 1 card
"""
self.player2._Player__set_hand(self.card_deck, 10)
p2_hand = self.player2.hand.copy(
) # saves a copy of the first hand to compare later
cards_dealt = []
for i in range(3):
cards_dealt.append(
self.player2.get_card()) # get three cards from the player.
self.assertNotEqual(cards_dealt, p2_hand[0:3])
self.assertNotEqual(cards_dealt.reverse(), p2_hand[-3:-1])
def test_add_cards(self):
"""
checks the add_cards func can get as many cards as given.
checks 0, 1, 3
and check that no card type input is not added to the list
"""
from Card_class import Card
self.player1.add_cards(Card({"Diamonds": 1}, 1))
self.assertEqual(len(self.player1.hand), 1)
self.player1.add_cards(Card({"Harts": 3}, 3), Card({"Spades": 2}, 8),
Card({"Clubs": 4}, 11), 4, "abba", 5.2345)
self.assertEqual(len(self.player1.hand), 4)
self.assertNotIn('abba', self.player1.hand)
self.player1.add_cards()
self.assertEqual(len(self.player1.hand), 4)
if __name__ == "__main__":
# get player names
player_names = get_players()
game_over = False
# start the actual War game
while not game_over:
# create a new deck of cards and shuffle it
deck = Deck()
deck.shuffle()
# randomize which player goes first in game
random.shuffle(player_names)
player_one = Player(player_names[0])
player_two = Player(player_names[1])
# deal cards to players from the deck
while len(deck): # i.e. is not empty
player_one.get_cards(deck.deal_card())
player_two.get_cards(deck.deal_card())
# create the gaming table
table = Table(player_one.name, player_two.name)
round = 0 # counting the rounds
# game session starts here
playing = True
while playing:
round += 1
class Game:
def __init__(self):
self.logger = logging.getLogger(f"{__name__}.Game")
self.logger.debug("Initializing game object")
pg.mixer.pre_init(
44100, -16, 1,
1024) # increase sound buffer to minise lag when playing sounds
pg.init()
self.screen = pg.display.set_mode((WIDTH, HEIGHT))
pg.display.set_caption(TITLE)
self.clock = pg.time.Clock()
# pg.key.set_repeat(10, 100) # Lets you hold down a key to keep the move going
self.game_folder = path.dirname(__file__)
self.load_images()
self.load_sounds()
self.player = None
def draw_text(self, text, font_name, size, color, x, y, align="nw"):
font = pg.font.Font(font_name, size)
text_surface = font.render(text, True, color)
text_rect = text_surface.get_rect()
if align == "nw":
text_rect.topleft = (x, y)
if align == "ne":
text_rect.topright = (x, y)
if align == "sw":
text_rect.bottomleft = (x, y)
if align == "se":
text_rect.bottomright = (x, y)
if align == "n":
text_rect.midtop = (x, y)
if align == "s":
text_rect.midbottom = (x, y)
if align == "e":
text_rect.midright = (x, y)
if align == "w":
text_rect.midleft = (x, y)
if align == "center":
text_rect.center = (x, y)
self.screen.blit(text_surface, text_rect)
def load_images(self):
self.logger.debug("loading images...")
# Define game folders
image_folder = path.join(self.game_folder, 'data/images')
# Load images from files
self.title_font = path.join(image_folder, 'ZOMBIE.TTF')
self.hud_font = path.join(image_folder, 'Impacted2.0.TTF')
self.dim_screen = pg.Surface(self.screen.get_size()).convert_alpha()
self.dim_screen.fill((0, 0, 0, 180))
self.player_imgs = {}
for img in PLAYER_IMGS:
self.player_imgs[img] = pg.image.load(
path.join(image_folder, PLAYER_IMGS[img])).convert_alpha()
self.wall_img = pg.image.load(path.join(image_folder,
WALL_IMG)).convert_alpha()
self.wall_img = pg.transform.scale(self.wall_img, (TILESIZE, TILESIZE))
self.mob_img = pg.image.load(path.join(image_folder,
MOB_IMG)).convert_alpha()
self.bullet_images = {}
self.bullet_images['lg'] = pg.image.load(
path.join(image_folder, BULLET_IMG)).convert_alpha()
self.bullet_images['lg'] = pg.transform.scale(self.bullet_images['lg'],
(5, 5))
self.splat = pg.image.load(path.join(image_folder,
SPLAT)).convert_alpha()
self.splat = pg.transform.scale(self.splat, (64, 64))
self.gun_smoke = []
for img in MUZZLE_SMOKE:
self.gun_smoke.append(
pg.image.load(path.join(image_folder, img)).convert_alpha())
self.item_images = {}
for item in ITEM_IMAGES:
self.item_images[item] = pg.image.load(
path.join(image_folder, ITEM_IMAGES[item])).convert_alpha()
# Lighting
self.fog = pg.Surface((WIDTH, HEIGHT))
self.fog.fill(NIGHT_COLOUR)
self.light_mask = pg.image.load(path.join(image_folder,
LIGHT_MASK)).convert_alpha()
self.light_mask = pg.transform.scale(self.light_mask, LIGHT_RADIUS)
self.light_rect = self.light_mask.get_rect()
def load_sounds(self):
self.logger.debug("loading sounds...")
sound_folder = path.join(self.game_folder, 'data/sounds')
self.music_folder = path.join(self.game_folder, 'data/music')
# Load initial music - define user event to trigger when it ends, picked up in events()
self.SONG_END = pg.USEREVENT + 1
self.current_song = random.choice(BG_MUSIC)
pg.mixer.music.set_endevent(self.SONG_END)
pg.mixer.music.load(path.join(self.music_folder, self.current_song))
pg.mixer.music.set_volume(BG_MUSIC_LEVEL)
# Effects
self.effects_sounds = {}
for eff in EFFECTS_SOUNDS:
self.effects_sounds[eff] = pg.mixer.Sound(
path.join(sound_folder, EFFECTS_SOUNDS[eff]['file']))
self.effects_sounds[eff].set_volume(EFFECTS_SOUNDS[eff]['volume'])
# Weapons
self.weapon_sounds = {}
for weapon in WEAPON_SOUNDS:
self.weapon_sounds[weapon] = []
for sound in WEAPON_SOUNDS[weapon]:
s = pg.mixer.Sound(path.join(sound_folder, sound))
s.set_volume(GUN_SOUND_LEVEL)
self.weapon_sounds[weapon].append(s)
# Zombies
self.zombie_moan_sounds = []
for sound in ZOMBIE_MOAN_SOUNDS:
s = pg.mixer.Sound(path.join(sound_folder, sound))
s.set_volume(ZOMBIE_MOAN_LEVEL)
self.zombie_moan_sounds.append(s)
self.zombie_hit_sounds = []
for sound in ZOMBIE_HIT_SOUNDS:
s = pg.mixer.Sound(path.join(sound_folder, sound))
s.set_volume(ZOMBIE_HIT_LEVEL)
self.zombie_hit_sounds.append(s)
# Player
self.player_hit_sounds = []
for sound in PLAYER_HIT_SOUNDS:
s = pg.mixer.Sound(path.join(sound_folder, sound))
s.set_volume(PLAYER_HIT_LEVEL)
self.player_hit_sounds.append(s)
self.player_pain_sounds = []
for sound in PLAYER_PAIN_SOUNDS:
s = pg.mixer.Sound(path.join(sound_folder, sound))
s.set_volume(PLAYER_PAIN_LEVEL)
self.player_pain_sounds.append(s)
self.player_panic_sounds = []
for sound in PLAYER_PANIC_SOUNDS:
s = pg.mixer.Sound(path.join(sound_folder, sound))
s.set_volume(PLAYER_PANIC_LEVEL)
self.player_panic_sounds.append(s)
def new(self):
"""For things that should happen once, at the start of a new game"""
# Load map from file
self.map_folder = path.join(self.game_folder, 'data/maps')
# self.map = Map(path.join(game_folder, 'map.txt'))
self.map = TiledMap(self, path.join(self.map_folder, MAP_NAME))
self.map_img = self.map.make_map()
self.map_rect = self.map_img.get_rect()
# self.paths = breadth_first_search(self.map, self
# initialize all variables and do all the setup for a new game
self.all_sprites = pg.sprite.LayeredUpdates()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
# For Loading map from tmx data
for tile_object in self.map.tmxdata.objects:
obj_center = vec(tile_object.x + tile_object.width / 2,
tile_object.y + tile_object.height / 2)
if tile_object.name == 'player':
self.player = Player(self, obj_center.x, obj_center.y)
if tile_object.name == 'zombie':
Mob(self, obj_center.x,
obj_center.y) # For EM all entities must have unique id
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
if tile_object.name in ['health', 'shotgun', 'pistol']:
Item(self, obj_center, tile_object.name)
# self.EM = AI.EntityManager()
for mob in self.mobs:
# self.EM.add_entity(mob.id) #All entities must have a unique id
mob.SM.current_state = zombie_states.Idle(self, mob)
mob.SM.global_state = zombie_states.ZombieGlobalState(self, mob)
assert self.player is not None
self.camera = Camera(self.map.width,
self.map.height) # Give camera total size of map
# Flags
self.draw_debug = False
self.paused = False
self.night = False
self.effects_sounds['level_start'].play()
def run(self):
pg.mixer.music.play()
# game loop - set self.playing = False to end the game
self.playing = True
while self.playing:
self.dt = self.clock.tick(FPS) / 1000
self.events()
if not self.paused:
self.update()
self.draw()
def quit(self):
pg.quit()
sys.exit()
def update(self):
"""For things that should happen every frame"""
# update portion of the game loop
self.all_sprites.update()
self.camera.update(
self.player
) # Call camera.update - give player as target to follow
# Game over condition - No more zombies
# if len(self.mobs) == 0:
# self.playing = False
# Mobs hit player
hits = pg.sprite.spritecollide(self.player, self.mobs, False,
collide_hit_rect)
for hit in hits:
now = pg.time.get_ticks()
if now - hit.last_hit > MOB_HIT_TIMEOUT and random.random(
) < MOB_HIT_CHANCE:
hit.last_hit = now
# self.player.health -= MOB_DAMAGE
hit.vel = vec(0, 0)
random.choice(self.player_hit_sounds).play()
if self.player.health <= 0:
self.playing = False
self.player.got_hit()
self.player.pos += vec(MOB_KNOCKBACK, 0).rotate(-hits[0].rot)
# Bullets hit mobs
hits = pg.sprite.groupcollide(self.mobs, self.bullets, False, True)
for mob in hits:
# hit.health -= WEAPONS[self.player.weapon]['damage'] * len(hits[hit])
# hit.draw_health()
for bullet in hits[mob]:
mob.health -= bullet.damage
mob.vel = vec(0, 0)
# Player hits items
hits = pg.sprite.spritecollide(self.player, self.items, False)
for hit in hits:
if hit.type == 'health' and self.player.health < PLAYER_HEALTH:
hit.kill()
self.effects_sounds['health_up'].play()
self.player.add_health(HEALTH_PACK_AMOUNT)
if hit.type in WEAPONS.keys():
hit.kill()
self.player.pickup(hit.type)
# print(hit.type)
def draw_grid(self):
for x in range(0, WIDTH, TILESIZE):
pg.draw.line(self.screen, GREEN, (x, 0), (x, HEIGHT))
for y in range(0, HEIGHT, TILESIZE):
pg.draw.line(self.screen, GREEN, (0, y), (WIDTH, y))
def render_fog(self):
# draw light mask (gradient) onto fog image
self.fog.fill((NIGHT_COLOUR))
self.light_rect.center = self.camera.apply(self.player).center
self.fog.blit(self.light_mask, self.light_rect)
self.screen.blit(self.fog, (0, 0), special_flags=pg.BLEND_MULT)
def draw(self):
pg.display.set_caption("{:.2f}".format(self.clock.get_fps()))
# self.screen.fill(BGCOLOR)
self.screen.blit(self.map_img, self.camera.apply_rect(self.map_rect))
# self.draw_grid()
# self.all_sprites.draw(self.screen)
for sprite in self.all_sprites:
if isinstance(sprite, Mob):
sprite.draw_health()
self.screen.blit(
sprite.image, self.camera.apply(sprite)
) # blit all sprites to screen in location of where the camera says the sprite is
# if self.draw_debug:
# pg.draw.rect(self.screen, CYAN, self.camera.apply_rect(sprite.hit_rect), 1)
if self.night:
self.render_fog()
# DEBUG HUD
if self.draw_debug:
for wall in self.walls:
pg.draw.rect(self.screen, CYAN,
self.camera.apply_rect(wall.rect), 1)
for sprite in self.all_sprites:
if isinstance(sprite, Mob):
sprite.draw_health()
pg.draw.circle(self.screen, CYAN,
(self.camera.apply(sprite).centerx,
self.camera.apply(sprite).centery),
sprite.detect_radius, 1)
pg.draw.rect(self.screen, CYAN,
self.camera.apply_rect(sprite.hit_rect), 1)
# HUD functions
draw_player_stats(self.screen, 10, 10,
(self.player.health / PLAYER_HEALTH))
draw_player_stats(self.screen, 10, 40,
(self.player.fatigue / PLAYER_FATIGUE), BEIGE)
self.draw_text("Zombies: {}".format(len(self.mobs)),
self.hud_font,
30,
WHITE,
WIDTH - 10,
10,
align="ne")
if self.player.weapon is not None:
self.draw_text("{}:{}".format(self.player.weapon.name,
self.player.weapon.remaining_shots),
self.hud_font,
30,
WHITE,
10,
HEIGHT - 50,
align="nw")
# Paused
if self.paused:
self.screen.blit(self.dim_screen, (0, 0))
self.draw_text("Paused",
self.title_font,
105,
RED,
WIDTH / 2,
HEIGHT / 2,
align='center')
pg.display.flip()
def play_new_song(self):
next_song = random.choice(BG_MUSIC)
self.current_song = next_song
# pg.mixer.music.load(next_song)
pg.mixer.music.load(path.join(self.music_folder, next_song))
pg.mixer.music.play()
def events(self):
# catch all events here
for event in pg.event.get():
if event.type == pg.QUIT:
self.quit()
if event.type == pg.MOUSEBUTTONDOWN:
# print(event.button)
if event.button == 1:
self.player.shoot()
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
self.quit()
if event.key == pg.K_h:
self.draw_debug = not self.draw_debug
if event.key == pg.K_p:
self.paused = not self.paused
if event.key == pg.K_n:
self.night = not self.night
if event.key == pg.K_r:
self.player.reload()
if event.key == pg.K_SPACE:
self.player.cycle_weapon()
if event.key == pg.K_g:
self.player.print_inventory()
if event.type == self.SONG_END:
self.play_new_song()
def show_start_screen(self):
pass
def show_go_screen(self):
self.screen.fill(BLACK)
pg.mixer.fadeout(5000)
self.draw_text("GAME OVER",
self.title_font,
180,
RED,
WIDTH / 2,
HEIGHT / 2,
align='center')
self.draw_text("Press any key to start",
self.title_font,
75,
WHITE,
WIDTH / 2,
HEIGHT * 3 / 4,
align='center')
pg.display.flip()
self.wait_for_key()
def wait_for_key(self):
pg.event.wait() # Clears event queue
waiting = True
while waiting:
self.clock.tick(FPS)
for event in pg.event.get():
if event.type == pg.QUIT:
waiting = False
self.quit()
if event.type == pg.KEYUP:
waiting = False
def psap(participant_name, opponent_image_name_list):
"""Initialize the game screen"""
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption(screen_name)
"""Initialize clock variables"""
clock = pygame.time.Clock()
safe_period = 0
"""Initialize game phases"""
phase = 0
phase_timer = 0
start = ObjectPrint(start_message, start_message_fontsize, start_message_x,
start_message_y, screen)
practice = ObjectPrint(practice_opponent_name, practice_opponent_fontsize,
practice_opponent_x, practice_opponent_y, screen)
transition = ObjectPrint(transition_message, transition_message_fontsize,
transition_message_x, transition_message_y,
screen)
end = ObjectPrint(end_message, end_message_fontsize, end_message_x,
end_message_y, screen)
"""Initialize AI variables"""
opponent = AI()
screen_opponent_name = ObjectPrint(opponent_name, opponent_name_fontsize,
opponent_name_x, opponent_name_y,
screen)
screen_opponent_points = FlashingObject(opponent.points,
opponent_points_fontsize,
opponent_points_x,
opponent_points_y, screen)
"""Initialize Player variables"""
participant = Player()
screen_player_name = ObjectPrint(participant_name,
participant_name_fontsize,
participant_name_x, participant_name_y,
screen)
screen_player_points = FlashingObject(participant.points,
participant_points_fontsize,
participant_points_x,
participant_points_y, screen)
"""Initialize interface variables"""
screen_counter = FlashingObject(participant.count, counter_fontsize,
counter_x, counter_y, screen)
screen_choice_1 = ObjectPrint('1', indicators_fontsize, indicators_x,
indicators_y, screen)
screen_choice_2 = ObjectPrint('2', indicators_fontsize,
indicators_x + indicator_spacing,
indicators_y, screen)
screen_choice_3 = ObjectPrint('3', indicators_fontsize,
indicators_x + (2 * indicator_spacing),
indicators_y, screen)
defense_meter_label = ObjectPrint(meter_label, meter_label_fontsize,
meter_label_x, meter_label_y, screen)
choice_list = [screen_choice_1, screen_choice_2, screen_choice_3]
"""DATA OUTPUT"""
data = {'1': {}, '2': {}, '3': {}}
"""Functions"""
def game_screen_display(tic, screen_player_points, screen_opponent_points,
opponent, participant, screen_counter,
screen_choice_1, screen_choice_2, screen_choice_3,
screen_opponent_name, screen_player_name,
choice_list, opponent_image_print):
if participant_earned_animation:
screen_player_points.begin_flashing(
participant.earned_point_animation_timer, 'pos')
if participant_provoked_animation:
screen_player_points.begin_flashing(
participant.provoked_animation_timer, 'neg')
if opponent_earned_animation:
screen_opponent_points.begin_flashing(
opponent.earned_point_animation_timer, 'pos')
if opponent_provoked_animation:
screen_opponent_points.begin_flashing(
opponent.provoked_animation_timer, 'neg')
screen_player_points.flashing_check(tic)
screen_opponent_points.flashing_check(tic)
if participant_choice_dump_animation:
if participant.choice_dump_animation_timer > 0:
screen_counter.font_color = (255, 0, 0)
else:
screen_counter.font_color = (0, 0, 0)
# USE: Light up active counter.
if active_counter_animation:
for choice in choice_list:
if choice.content == participant.active_counter:
choice.font_color = (0, 255, 0
) # choose active counter color
else:
choice.font_color = (0, 0, 0)
# Display objects
if meter_print:
defense_meter_label.display_object()
if opponent_points_print:
screen_opponent_points.display_object()
if counter_print:
screen_counter.display_object()
if indicators_print:
screen_choice_1.display_object()
screen_choice_2.display_object()
screen_choice_3.display_object()
if opponent_name_print:
screen_opponent_name.display_object()
if participant_name_print:
screen_player_name.display_object()
if participant_points_print:
screen_player_points.display_object()
if opponent_image_print:
screen.blit(opponent_image, (opponent_image_x, opponent_image_y))
def get_block_quantities(number):
hundreds = number // 100
number -= (100 * hundreds)
tens = number // 10
ones = number % 10
return [hundreds, tens, ones]
def print_meters(block_list, screen, meter_x, meter_y, block_spacing_x,
block_spacing_y, hundreds_block_color, tens_block_color,
ones_block_color, block_width, block_height):
if meter_print:
for block in range(block_list[0]):
pygame.draw.rect(screen, pygame.Color(hundreds_block_color),
(meter_x + (block_spacing_x * block), meter_y,
block_width, block_height))
for block in range(block_list[1]):
pygame.draw.rect(
screen, pygame.Color(tens_block_color),
(meter_x + (block_spacing_x * block),
meter_y + block_spacing_y, block_width, block_height))
for block in range(block_list[2]):
pygame.draw.rect(
screen, pygame.Color(ones_block_color),
(meter_x + (block_spacing_x * block), meter_y +
(2 * block_spacing_y), block_width, block_height))
# ----------------------------------------------------------------------------------------------------------------------
"""Game Loop"""
running = True
while running:
tic = clock.tick(30) / 1000
screen.fill((255, 255, 255))
for event in pygame.event.get():
# ALL THE OUTPUT THING GO HERE
if event.type == pygame.QUIT:
print(phase)
running = False
# ----------------------------------------------------------------------------------------------------------------------
"""Keydown events"""
if event.type == pygame.KEYDOWN:
if phase % 2 == 0:
if event.key == pygame.K_n:
if phase < 8:
participant = Player()
opponent = AI()
screen_player_points = FlashingObject(
participant.points,
participant_points_fontsize,
participant_points_x, participant_points_y,
screen)
screen_opponent_points = FlashingObject(
opponent.points, opponent_points_fontsize,
opponent_points_x, opponent_points_y, screen)
screen_counter = FlashingObject(
participant.count, counter_fontsize, counter_x,
counter_y, screen)
phase += 1
if phase == 1:
phase_timer = practice_phase_duration
opponent.points = practice_opponent_points
else:
phase_timer = block_phase_duration
safe_period = safe_period_default
if event.key == pygame.K_ESCAPE:
data_file_name = os.path.join('Data', 'pickle', participant_name + "_" + \
str(datetime.datetime.now()).replace(" ", "_").replace(":", "_").replace(".", "_").replace("-", "_") + ".pickle")
data_file = open(data_file_name, 'ab')
pickle.dump(data, data_file)
data_file.close()
dumpDict = pickle2Dumps(data_file_name)
writer = ExcelWriter(data_file_name.replace('.pickle', '.xlsx').replace('pickle', 'excel')\
.replace(participant_name, 'Dumps_' + participant_name), engine='xlsxwriter')
for trial in dumpDict:
trialDumps = DataFrame(dumpDict[trial])
trialDumps.to_excel(writer,
sheet_name=str('dumps_trial_' +
trial))
writer.save()
pygame.display.quit()
running = False
if not phase % 2 == 0:
if event.key == pygame.K_KP1:
participant.counter_update('1')
if event.key == pygame.K_KP2:
participant.counter_update('2')
if event.key == pygame.K_KP3:
participant.counter_update('3')
# ---------------------------------------------------------------------------------------------------------------------
if phase == 0: # PHASE: start
if start_message_print:
start.display_object()
pygame.display.update()
continue
# ---------------------------------------------------------------------------------------------------------------------
if phase == 1: # PHASE: practice
phase_timer -= tic # TODO: code smell
if phase_timer <= 0: phase += 1 # TODO: code smell
participant.timekeeping(tic)
opponent.timekeeping(tic)
participant.condition_check(tic, option1_presses, option2_presses,
option3_presses,
participant_earned_animation_duration,
participant_defense_duration_mean,
participant_defense_duration_sd)
# use: participant stealing points
if participant.stole_point == 1 and len(
opponent.defense_blocks) <= 0 < opponent.points:
"""Successful point steal"""
opponent.points -= 1
opponent.provoked_animation_timer = opponent_provoked_animation_duration
participant.stole_point = 0
else:
participant.stole_point = 0
"""ObjectPrint content updates"""
screen_player_points.content = participant.points
screen_counter.content = participant.count
screen_opponent_points.content = opponent.points
print_meters(get_block_quantities(len(participant.defense_blocks)),
screen, meter_x, meter_y, block_spacing_x,
block_spacing_y, hundreds_block_color,
tens_block_color, ones_block_color, block_width,
block_height)
game_screen_display(tic,
screen_player_points,
screen_opponent_points,
opponent,
participant,
screen_counter,
screen_choice_1,
screen_choice_2,
screen_choice_3,
practice,
screen_player_name,
choice_list,
opponent_image_print=False)
pygame.display.update()
continue
# ----------------------------------------------------------------------------------------------------------------------
if phase % 2 == 0: # PHASE: transitionnn
if phase > 2:
if participant.points > 0:
data[str((int(phase / 2) -
1))]['player_points'] = participant.points
else:
data[str((int(phase / 2) - 1))]['player_points'] = 0
data[str(
(int(phase / 2) -
1))]['total_presses'] = participant.counters_data_output
data[str((int(phase / 2) -
1))]['player_provoked'] = participant.provoked_total
data[str((int(phase / 2) - 1))]['dumps'] = participant.dumps
# TODO: remove the seconds latency, add number of clicks on the dumped counter
data[str(
(int(phase / 2) -
1))]['defense_rewards'] = participant.defense_blocks_data
# CHANGED: adjustable phase num
if phase >= (num_phases * 2 + 2): # PHASE: end
if end_message_print:
end.display_object()
pygame.display.update()
continue
else:
if transition_message_print:
transition.display_object()
pygame.display.update()
continue
else: # PHASE: block
opponent_image = pygame.image.load(opponent_image_name_list[int(
(phase - 1) / 2)])
phase_timer -= tic
if phase_timer <= 0: phase += 1
if safe_period > 0:
safe_period -= tic
else:
safe_period = 0
participant.timekeeping(tic)
opponent.timekeeping(tic)
"""Participant's move"""
participant.condition_check(tic, option1_presses, option2_presses,
option3_presses,
participant_earned_animation_duration,
participant_defense_duration_mean,
participant_defense_duration_sd)
# use: participant stealing points
if participant.stole_point == 1 and len(
opponent.defense_blocks) <= 0 < opponent.points:
"""Successful point steal"""
opponent.points -= 1
opponent.provoked_animation_timer = opponent_provoked_animation_duration
participant.stole_point = 0
else:
participant.stole_point = 0
"""Opponent's move"""
# use: opponent choice
if opponent.choice_cooldown == 0:
opponent.ai_choose(opponent_aggression)
opponent.manage_choice_result(
choice1_delay_mean, choice1_delay_sd, choice2_delay_mean,
choice2_delay_sd, choice3_delay_mean, choice3_delay_sd)
opponent.manage_choice_timer(tic,
opponent_earned_animation_duration,
opponent_defense_duration_mean,
opponent_defense_duration_sd)
# use: opponent stole points
if opponent.stole_point == 1:
if safe_period <= 0:
if len(participant.defense_blocks
) <= 0 < participant.points:
participant.points -= 1
participant.provoked = 1
participant.provoked_total += 1
participant.provoked_animation_timer = participant_provoked_animation_timer
opponent.stole_point = 0
elif participant.points <= 0:
opponent.stole_point = 0
opponent.choice = 1
opponent.choice_cooldown = 1
opponent.choice_timer = choice1_delay_mean - choice1_delay_sd
else:
opponent.stole_point = 0
else:
# opponent.defense_blocks = np.append(opponent.defense_blocks, np.random.normal(opponent_defense_duration_mean, opponent_defense_duration_sd, 1))
opponent.stole_point = 0
opponent.choice = 1
opponent.choice_cooldown = 1
opponent.choice_timer = choice1_delay_mean - choice1_delay_sd
"""Data Processes"""
"""ObjectPrint content updates"""
screen_player_points.content = participant.points
screen_counter.content = participant.count
screen_opponent_points.content = opponent.points
"""Print Display"""
print_meters(get_block_quantities(len(participant.defense_blocks)),
screen, meter_x, meter_y, block_spacing_x,
block_spacing_y, hundreds_block_color,
tens_block_color, ones_block_color, block_width,
block_height)
game_screen_display(tic,
screen_player_points,
screen_opponent_points,
opponent,
participant,
screen_counter,
screen_choice_1,
screen_choice_2,
screen_choice_3,
screen_opponent_name,
screen_player_name,
choice_list,
opponent_image_print=True)
pygame.display.update()
continue
def __init__(self):
self.__window = Tk()
self.__window.title("tic tac toe")
self.__top = Frame(self.__window)
self.__middle = Frame(self.__window)
self.__bottom = Frame(self.__window)
self.__startframe = Frame(self.__window)
self.__top.pack()
self.__middle.pack()
self.__bottom.pack()
self.__startframe.pack()
self.__text1 = 'A1'
self.__text2 = 'A2'
self.__text3 = 'A3'
self.__text4 = 'A4'
self.__text5 = 'A5'
self.__text6 = 'A6'
self.__text7 = 'A7'
self.__text8 = 'A8'
self.__text9 = 'A9'
self.__text_list = [
self.__text1, self.__text2, self.__text3, self.__text4,
self.__text5, self.__text6, self.__text7, self.__text8,
self.__text9
]
self.__font = font.Font(family="Comic Sans MS", size=15,
weight='bold') #bg = "PeachPuff")
self.__x_image = PhotoImage(file='x_image.gif')
self.__o_image = PhotoImage(file='o_image.gif')
self.player = Player()
self.board = Board()
self.__button1 = Button(self.__top, text = self.__text1,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(1,self.__text1))
self.__button1.config(width=bwidth, height=bheight, bg='white')
self.__button1.pack(side='left')
self.__button2 = Button(self.__top, text = self.__text2,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(2,self.__text2))
self.__button2.config(width=bwidth, height=bheight, bg='white')
self.__button2.pack(side='left')
self.__button3 = Button(self.__top, text = self.__text3, font = self.__font, state = DISABLED, \
command=lambda: self.button_click(3,self.__text3))
self.__button3.config(width=bwidth, height=bheight, bg='white')
self.__button3.pack(side='left')
self.__button4 = Button(self.__middle, text = self.__text4,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(4,self.__text4))
self.__button4.config(width=bwidth, height=bheight, bg='white')
self.__button4.pack(side='left')
self.__button5 = Button(self.__middle, text = self.__text5,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(5,self.__text5))
self.__button5.config(width=bwidth, height=bheight, bg='white')
self.__button5.pack(side='left')
self.__button6 = Button(self.__middle, text = self.__text6,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(6,self.__text6))
self.__button6.config(width=bwidth, height=bheight, bg='white')
self.__button6.pack(side='left')
self.__button7 = Button(self.__bottom, text = self.__text7,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(7,self.__text7))
self.__button7.config(width=bwidth, height=bheight, bg='white')
self.__button7.pack(side='left')
self.__button8 = Button(self.__bottom, text = self.__text8,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(8,self.__text8))
self.__button8.config(width=bwidth, height=bheight, bg='white')
self.__button8.pack(side='left')
self.__button9 = Button(self.__bottom, text = self.__text9,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(9,self.__text9))
self.__button9.config(width=bwidth, height=bheight, bg='white')
self.__button9.pack(side='left')
self.__button_list = [
self.__button1, self.__button2, self.__button3, self.__button4,
self.__button5, self.__button6, self.__button7, self.__button8,
self.__button9
]
#Start game button
self.__start_game_text = StringVar()
self.__start_game_text.set('Start Game')
self.__start_game_button = Button(self.__startframe, text = self.__start_game_text.get(),\
command = self.start_game)
#Reset game button
self.__reset_game_text = StringVar()
self.__reset_game_text.set('Reset Game')
self.__reset_game_button = Button(self.__startframe, text = self.__reset_game_text.get(),\
command = self.reset_game)
#Graph button
self.__graph_wins_button = Button(self.__startframe,
text='Graph',
command=self.graph_wins)
#X wins labels
self.__x_win_label = Label(self.__startframe, text='X: ')
self.__num_x_wins = IntVar()
self.__num_x_wins.set(self.player.get_x_wins())
self.__x_win = Label(self.__startframe, textvariable=self.__num_x_wins)
#O wins labels
self.__num_o_wins = IntVar()
self.__num_o_wins.set(self.player.get_o_wins())
self.__o_win_label = Label(self.__startframe, text='O: ')
self.__o_win = Label(self.__startframe, textvariable=self.__num_o_wins)
#Ties labels
self.__num_ties = IntVar()
self.__num_ties.set(self.player.get_ties())
self.__num_ties_label = Label(self.__startframe, text='Tie: ')
self.__ties = Label(self.__startframe, textvariable=self.__num_ties)
#Pack start,end,graph buttons and x,o,ties labels
self.__start_game_button.pack(side='left')
self.__reset_game_button.pack(side='left')
self.__graph_wins_button.pack(side='left')
self.__x_win_label.pack(side='left')
self.__x_win.pack(side='left')
self.__o_win_label.pack(side='left')
self.__o_win.pack(side='left')
self.__num_ties_label.pack(side='left')
self.__ties.pack(side='left')
self.__window.mainloop()
class App:
def __init__(self):
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
self.clock = pygame.time.Clock()
self.running = True
self.state = 'start'
self.cell_width = MAZE_WIDTH // COLS
self.cell_height = MAZE_HEIGHT // ROWS
self.walls = []
self.coins = []
self.enemies = []
self.e_pos = []
self.p_pos = None
self.highscore = 0
self.load()
self.player = Player(self, vec(self.p_pos))
self.make_enemies()
def run(self):
while self.running:
if self.state == 'start':
self.start_events()
self.start_update()
self.start_draw()
elif self.state == 'playing':
self.playing_events()
self.playing_update()
self.playing_draw()
elif self.state == 'game over':
self.game_over_events()
self.game_over_update()
self.game_over_draw()
elif self.state == 'winner':
self.winner_events()
self.winner_update()
self.winner_draw()
else:
self.running = False
self.clock.tick(FPS)
pygame.quit()
try:
sys.exit()
except:
print("Game over, bye")
################### HELPER FUNCTIONS #####################
def draw_text(self,
words,
screen,
pos,
size,
color,
font_name,
centered=False):
font = pygame.font.SysFont(font_name, size)
text = font.render(words, False, color)
text_size = text.get_size()
if centered:
pos[0] = pos[0] - text_size[0] // 2
pos[1] = pos[1] - text_size[1] // 2
screen.blit(text, pos)
def load(self):
self.background = pygame.image.load('maze.png')
self.background = pygame.transform.scale(self.background,
(MAZE_WIDTH, MAZE_HEIGHT))
# Opening walls file
# Creating walls list with co-ords of walls
with open("walls.txt", mode='r') as file:
for yidx, line in enumerate(file):
for xidx, char in enumerate(line):
if char == "1":
self.walls.append(vec(xidx, yidx))
elif char == "C":
self.coins.append(vec(xidx, yidx))
elif char == "P":
self.p_pos = [xidx, yidx]
elif char in ["2", "3", "4", "5", "6", "7"]:
self.e_pos.append([xidx, yidx])
elif char == "B":
pygame.draw.rect(
self.background, BLACK,
(xidx * self.cell_width, yidx * self.cell_height,
self.cell_width, self.cell_height))
#print(self.walls)
# read Highscore from highscore.txt
with open("highscore.txt", mode='r') as highscore_file:
for line in highscore_file:
name, var = line.partition("=")[::2]
self.highscore = int(var)
def make_enemies(self):
for idx, pos in enumerate(self.e_pos):
self.enemies.append(Enemy(self, vec(pos), idx))
def draw_grid(self):
for x in range(WIDTH // self.cell_width):
pygame.draw.line(self.background, GREY, (x * self.cell_width, 0),
(x * self.cell_width, HEIGHT))
for x in range(HEIGHT // self.cell_height):
pygame.draw.line(self.background, GREY, (0, x * self.cell_height),
(WIDTH, x * self.cell_height))
# Shows wall as rectangles
# for wall in self.walls:
# pygame.draw.rect(self.background, (112,55,163), (wall.x*self.cell_width, wall.y*self.cell_height, self.cell_width, self.cell_width))
# for coin in self.coins:
# pygame.draw.rect(self.background, (167, 179, 34), (coin.x*self.cell_width, coin.y*self.cell_height, self.cell_width, self.cell_width))
def reset(self):
self.player.lives = 3
self.player.current_score = 0
self.player.grid_pos = vec(self.player.starting_pos)
self.player.pix_pos = self.player.get_pix_pos()
self.player.direction *= 0
for enemy in self.enemies:
enemy.grid_pos = vec(enemy.starting_pos)
enemy.pix_pos = enemy.get_pix_pos()
enemy.direction *= 0
self.coins = []
with open("walls.txt", mode='r') as file:
for yidx, line in enumerate(file):
for xidx, char in enumerate(line):
if char == 'C':
self.coins.append(vec(xidx, yidx))
self.state = "playing"
################### INIT FUNCTIONS #####################
def start_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
self.state = 'playing'
def start_update(self):
pass
def start_draw(self):
self.screen.fill(BLACK)
self.draw_text('PUSH SPACE BAR',
self.screen, [WIDTH // 2, HEIGHT // 2 - 50],
START_TEXT_SIZE, (170, 132, 58),
START_FONT,
centered=True)
self.draw_text('1 PLAYER ONLY',
self.screen, [WIDTH // 2, HEIGHT // 2 + 50],
START_TEXT_SIZE, (44, 167, 198),
START_FONT,
centered=True)
# self.draw_text('HIGH SCORE', self.screen, [4,0],
#START_TEXT_SIZE, (255, 255, 255), START_FONT)
pygame.display.update()
################### PLAYING FUNCTIONS #####################
def playing_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.player.move(vec(-1, 0))
if event.key == pygame.K_RIGHT:
self.player.move(vec(1, 0))
if event.key == pygame.K_UP:
self.player.move(vec(0, -1))
if event.key == pygame.K_DOWN:
self.player.move(vec(0, 1))
def playing_update(self):
self.player.update()
for enemy in self.enemies:
enemy.update()
for enemy in self.enemies:
if enemy.grid_pos == self.player.grid_pos:
self.remove_life()
if self.player.current_score == 287:
if self.highscore < self.player.current_score:
self.write_highscore(self.player.current_score)
self.state = "winner"
def write_highscore(self, new_highscore):
with open("highscore.txt", "a+") as highscore_file:
line = highscore_file.readline()
highscore_file.truncate(0)
self.highscore = new_highscore
highscore_file.write('highscore={}'.format(self.highscore))
highscore_file.close()
def playing_draw(self):
self.screen.fill(BLACK)
self.screen.blit(self.background,
(TOP_BOTTOM_BUFFER // 2, TOP_BOTTOM_BUFFER // 2))
self.draw_grid()
self.draw_coins()
self.draw_text('CURRENT SCORE: {}'.format(self.player.current_score),
self.screen, [70, 5], 30, WHITE, START_FONT)
self.draw_text('HIGH SCORE: {}'.format(self.highscore), self.screen,
[WIDTH // 2 + 60, 5], 30, WHITE, START_FONT)
self.player.draw()
for enemy in self.enemies:
enemy.draw()
pygame.display.update()
def remove_life(self):
self.player.lives -= 1
if self.player.lives == 0:
# if self.highscore < self.player.current_score:
# self.highscore = self.player.current_score
self.state = "game over"
else:
self.player.grid_pos = vec(self.player.starting_pos)
self.player.pix_pos = self.player.get_pix_pos()
self.player.direction *= 0
for enemy in self.enemies:
enemy.grid_pos = vec(enemy.starting_pos)
enemy.pix_pos = enemy.get_pix_pos()
enemy.direction *= 0
def draw_coins(self):
for coin in self.coins:
pygame.draw.circle(
self.screen, (124, 123, 7),
(int(coin.x * self.cell_height) + self.cell_width // 2 +
TOP_BOTTOM_BUFFER // 2, int(coin.y * self.cell_height) +
self.cell_width // 2 + TOP_BOTTOM_BUFFER // 2), 5)
################### GAME OVER FUNCTIONS #####################
def game_over_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
self.reset()
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.state = False
def game_over_update(self):
pass
def game_over_draw(self):
self.screen.fill(BLACK)
again_text = "Press SPACE bar to PLAY AGAIN"
quit_text = "Press the escape button to QUIT"
self.draw_text("GAME OVER",
self.screen, [WIDTH // 2, 100],
36,
RED,
"arial",
centered=True)
if self.highscore < self.player.current_score:
self.write_highscore(self.player.current_score)
highscore_text = "New Highscore is {}".format(self.highscore)
else:
highscore_text = "Highscore is {}".format(self.highscore)
self.draw_text(highscore_text,
self.screen, [WIDTH // 2, 150],
36,
YELLOW,
"arial",
centered=True)
self.draw_text(again_text,
self.screen, [WIDTH // 2, HEIGHT // 2],
36, (190, 190, 190),
"arial",
centered=True)
self.draw_text(quit_text,
self.screen, [WIDTH // 2, HEIGHT // 1.5],
36, (190, 190, 190),
"arial",
centered=True)
pygame.display.update()
##################### WINNER FUNCTIONS #####################
def winner_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
self.reset()
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.state = False
def winner_update(self):
pass
def winner_draw(self):
self.screen.fill(BLACK)
again_text = "Press SPACE bar to PLAY AGAIN"
quit_text = "Press the escape button to QUIT"
winner_text = "YOU ARE A WINNER WITH {} POINTS".format(
self.player.current_score)
highscore_text = "Highscore is {} points!".format(self.highscore)
self.draw_text(winner_text,
self.screen, [WIDTH // 2, 100],
36,
YELLOW,
"arial",
centered=True)
self.draw_text(highscore_text,
self.screen, [WIDTH // 2, 150],
36,
YELLOW,
"arial",
centered=True)
self.draw_text(again_text,
self.screen, [WIDTH // 2, HEIGHT // 2],
36, (190, 190, 190),
"arial",
centered=True)
self.draw_text(quit_text,
self.screen, [WIDTH // 2, HEIGHT // 1.5],
36, (190, 190, 190),
"arial",
centered=True)
pygame.display.update()
def main():
pygame.init()
winner = ""
blue_player = Player(530, 200, COWBOY_WIDTH, COWBOY_HEIGHT, LIMIT_BULLETS,
BULLET_VEL)
red_player = Player(130, 200, COWBOY_WIDTH, COWBOY_HEIGHT, LIMIT_BULLETS,
BULLET_VEL)
obsta = Obstacles(LIMIT_OBSTACLES, OBSTACLE_WIDTH, OBSTACLE_HEIGHT,
OBSTACLES_VEL, LEFT_OBSTACLES_LIMIT,
RIGHT_OBSTACLES_LIMIT, HEIGHT)
clock = pygame.time.Clock()
pygame.time.set_timer(OBSTACLE_TIME_EVENT, 800)
run = True
while run:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
pygame.quit()
if event.type == pygame.KEYDOWN and pygame.time.get_ticks() > 6000:
red_player.create_bullets(event, pygame.K_q)
blue_player.create_bullets(event, pygame.K_RCTRL, COWBOY_WIDTH)
red_player.handle_health(event, RED_HIT)
blue_player.handle_health(event, BLUE_HIT)
obsta.create_obstacles(event, OBSTACLE_TIME_EVENT)
if red_player.health <= 0:
winner = "Blue Wins!!"
if blue_player.health <= 0:
winner = "Red Wins!!"
if winner != "":
draw_win(winner)
break
keys_pressed = pygame.key.get_pressed()
red_handle_movement(keys_pressed, red_player)
blue_handle_movement(keys_pressed, blue_player)
obsta.handle_obstacles_movement()
red_player.handle_bullets_impact(blue_player, obsta, RED_HIT, BLUE_HIT,
WIDTH)
draw_screen(red_player, blue_player, obsta)
main()
def run_game(self):
# pygame config
pygame.init()
fpsClock = pygame.time.Clock()
fpsClock.tick(self.FPS)
# define keys and user interaction
from pygame.locals import (
K_ESCAPE,
KEYDOWN,
QUIT,
)
#===========================
# Set up the drawing window
pygame.display.init()
screen_dim = [self.SCREEN_WIDTH, self.SCREEN_HEIGHT]
screen = pygame.display.set_mode(screen_dim, pygame.FULLSCREEN)
#DISPLAYSURF = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
screen.fill((0, 0, 0))
# Create player
player = Player(self.STIMULUS, screen_dim, self.GAIN)
position = player.stim_center()
stim_threshold = position[0] + self.THRESHOLD
# create inital stimulus
screen.blit(player.surf, position)
#-----------------------------------------------------------------------------
# on soft code of state 1
#-----------------------------------------------------------------------------
# present initial stimulus
self.display_stim_event.wait()
pygame.display.flip()
#=========================
# py game loop
# loop is running while open loop active
data_pref = [[0, 0, 0]]
while self.run_open_loop:
# Fill the background with white
screen.fill((0, 0, 0))
screen.blit(player.surf, position)
#-------------------------------------------------------------------------
# on soft code of state 2
#-------------------------------------------------------------------------
# read rotary encoder stream
self.move_stim_event.wait()
data = rotary_encoder.read_stream()
running = True
if len(data) == 0:
continue
else:
pos_change = abs(data[0][2]) - abs(data_pref[0][2])
#print(f"data-pref: {data_pref[0][2]} data-now: {data[0][2]} n")
data_pref = data
#repositin based on changes
if data[0][2] < 0:
#player.move_left(pos_change)
position[0] -= (pos_change * self.GAIN)
if data[0][2] > 0:
#player.move_right(pos_change)
position[0] += (pos_change * self.GAIN)
# # keep on screen
# if abs(position[0]) >= stim_threshold:
# running = False
pygame.display.update()
#show stimulus after closed loop period is over until reward gieven
self.still_show_event.wait()
screen.fill((0, 0, 0))
pygame.display.flip()
fpsClock.tick(self.FPS)
pygame.quit()
print("end of game loop")
import random
import function as Fun
from player_class import Player
Cards=['A','K','Q']
players=[]
player_num=2
for i in range(player_num):
player=Player()
players.append(player)
SB=1
BB=1
while players[0].stack !=0 and player[1].stack !=0 :
players[0].stack -=SB
player[1].stack -=BB
pot=SB+BB
for i in range(player_num)
player[i-1].clear_bet()
player[i-1].clear_status()
x=random.sample(Cards,2)
players[0].hand,players[1].hand=Fun.split_list(x,1)
print("player1のハンド:"+player[0].hand+" palyer2のハンド:"+player[1].hand)
while players[0].status==1 and players.status[1]==1
players[0].action=input('player1のアクションを選択してください(0:チェック 1:ベットorレイズ 2:コール 3:フォールド ):')
while Fun.validate_action(action,player_bet,enemy_bet,player_stack)==False:
players[0].action=input('player1の正しいアクションを選択してください(0:チェック 1:ベットorレイズ 2:コール 3:フォールド ):')
from army_class import Army
from bowman_class import Bowman
from player_class import Player
from scouter_class import Scouter
from swordsman_class import Swordsman
army_red = Army("Red Army", [])
army_black = Army("Red Army", [])
player_one = Player(1000, army_red)
player_two = Player(100, army_black)
bowman_1 = Bowman("Arc smecher")
bowman_2 = Bowman("Arc mai putin smecher")
scouter_1 = Scouter("Papuci")
scouter_1.join(player_one, army_red)
bowman_1.join(player_one, army_red)
bowman_2.join(player_one, army_red)
bowman_1.say_hurray()
scouter_1.inform_army(army_red)
swordman = Swordsman("Sabie de carton")
bowman_3 = Bowman("Elastic")
swordman.say_hurray()
swordman.join(player_two, army_black)
bowman_3.join(player_two, army_black)
army_red.fight(army_black)
class tttGUI():
def __init__(self):
self.__window = Tk()
self.__window.title("tic tac toe")
self.__top = Frame(self.__window)
self.__middle = Frame(self.__window)
self.__bottom = Frame(self.__window)
self.__startframe = Frame(self.__window)
self.__top.pack()
self.__middle.pack()
self.__bottom.pack()
self.__startframe.pack()
self.__text1 = 'A1'
self.__text2 = 'A2'
self.__text3 = 'A3'
self.__text4 = 'A4'
self.__text5 = 'A5'
self.__text6 = 'A6'
self.__text7 = 'A7'
self.__text8 = 'A8'
self.__text9 = 'A9'
self.__text_list = [
self.__text1, self.__text2, self.__text3, self.__text4,
self.__text5, self.__text6, self.__text7, self.__text8,
self.__text9
]
self.__font = font.Font(family="Comic Sans MS", size=15,
weight='bold') #bg = "PeachPuff")
self.__x_image = PhotoImage(file='x_image.gif')
self.__o_image = PhotoImage(file='o_image.gif')
self.player = Player()
self.board = Board()
self.__button1 = Button(self.__top, text = self.__text1,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(1,self.__text1))
self.__button1.config(width=bwidth, height=bheight, bg='white')
self.__button1.pack(side='left')
self.__button2 = Button(self.__top, text = self.__text2,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(2,self.__text2))
self.__button2.config(width=bwidth, height=bheight, bg='white')
self.__button2.pack(side='left')
self.__button3 = Button(self.__top, text = self.__text3, font = self.__font, state = DISABLED, \
command=lambda: self.button_click(3,self.__text3))
self.__button3.config(width=bwidth, height=bheight, bg='white')
self.__button3.pack(side='left')
self.__button4 = Button(self.__middle, text = self.__text4,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(4,self.__text4))
self.__button4.config(width=bwidth, height=bheight, bg='white')
self.__button4.pack(side='left')
self.__button5 = Button(self.__middle, text = self.__text5,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(5,self.__text5))
self.__button5.config(width=bwidth, height=bheight, bg='white')
self.__button5.pack(side='left')
self.__button6 = Button(self.__middle, text = self.__text6,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(6,self.__text6))
self.__button6.config(width=bwidth, height=bheight, bg='white')
self.__button6.pack(side='left')
self.__button7 = Button(self.__bottom, text = self.__text7,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(7,self.__text7))
self.__button7.config(width=bwidth, height=bheight, bg='white')
self.__button7.pack(side='left')
self.__button8 = Button(self.__bottom, text = self.__text8,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(8,self.__text8))
self.__button8.config(width=bwidth, height=bheight, bg='white')
self.__button8.pack(side='left')
self.__button9 = Button(self.__bottom, text = self.__text9,font = self.__font, state = DISABLED, \
command=lambda: self.button_click(9,self.__text9))
self.__button9.config(width=bwidth, height=bheight, bg='white')
self.__button9.pack(side='left')
self.__button_list = [
self.__button1, self.__button2, self.__button3, self.__button4,
self.__button5, self.__button6, self.__button7, self.__button8,
self.__button9
]
#Start game button
self.__start_game_text = StringVar()
self.__start_game_text.set('Start Game')
self.__start_game_button = Button(self.__startframe, text = self.__start_game_text.get(),\
command = self.start_game)
#Reset game button
self.__reset_game_text = StringVar()
self.__reset_game_text.set('Reset Game')
self.__reset_game_button = Button(self.__startframe, text = self.__reset_game_text.get(),\
command = self.reset_game)
#Graph button
self.__graph_wins_button = Button(self.__startframe,
text='Graph',
command=self.graph_wins)
#X wins labels
self.__x_win_label = Label(self.__startframe, text='X: ')
self.__num_x_wins = IntVar()
self.__num_x_wins.set(self.player.get_x_wins())
self.__x_win = Label(self.__startframe, textvariable=self.__num_x_wins)
#O wins labels
self.__num_o_wins = IntVar()
self.__num_o_wins.set(self.player.get_o_wins())
self.__o_win_label = Label(self.__startframe, text='O: ')
self.__o_win = Label(self.__startframe, textvariable=self.__num_o_wins)
#Ties labels
self.__num_ties = IntVar()
self.__num_ties.set(self.player.get_ties())
self.__num_ties_label = Label(self.__startframe, text='Tie: ')
self.__ties = Label(self.__startframe, textvariable=self.__num_ties)
#Pack start,end,graph buttons and x,o,ties labels
self.__start_game_button.pack(side='left')
self.__reset_game_button.pack(side='left')
self.__graph_wins_button.pack(side='left')
self.__x_win_label.pack(side='left')
self.__x_win.pack(side='left')
self.__o_win_label.pack(side='left')
self.__o_win.pack(side='left')
self.__num_ties_label.pack(side='left')
self.__ties.pack(side='left')
self.__window.mainloop()
#Update the number of wins x has
#Invokes set()
def update_x_wins(self):
self.__num_x_wins.set(self.player.get_x_wins())
def update_o_wins(self):
self.__num_o_wins.set(self.player.get_o_wins())
def update_ties(self):
self.__num_ties.set(self.player.get_ties())
def start_game(self):
for button in self.__button_list:
button.config(state=NORMAL)
def reset_game(self):
i = 0
for button in self.__button_list:
button.config(state=DISABLED, text=self.__text_list[i])
i += 1
self.board.reset()
self.player.reset()
self.update_x_wins()
self.update_o_wins()
#Responsible for all button functions
def button_click(self, button_id, text):
self.player.inc_turn()
team = self.player.set_team()
if team == 'X':
self.board.add_x(button_id)
if button_id == 1:
self.__button1.config(state=DISABLED,
text=team) #image=self.__x_image)
elif button_id == 2:
self.__button2.config(state=DISABLED, text=team)
elif button_id == 3:
self.__button3.config(state=DISABLED, text=team)
elif button_id == 4:
self.__button4.config(state=DISABLED, text=team)
elif button_id == 5:
self.__button5.config(state=DISABLED, text=team)
elif button_id == 6:
self.__button6.config(state=DISABLED, text=team)
elif button_id == 7:
self.__button7.config(state=DISABLED, text=team)
elif button_id == 8:
self.__button8.config(state=DISABLED, text=team)
elif button_id == 9:
self.__button9.config(state=DISABLED, text=team)
else:
self.board.add_o(button_id)
if button_id == 1:
self.__button1.config(state=DISABLED, text=team)
elif button_id == 2:
self.__button2.config(state=DISABLED, text=team)
elif button_id == 3:
self.__button3.config(state=DISABLED, text=team)
elif button_id == 4:
self.__button4.config(state=DISABLED, text=team)
elif button_id == 5:
self.__button5.config(state=DISABLED, text=team)
elif button_id == 6:
self.__button6.config(state=DISABLED, text=team)
elif button_id == 7:
self.__button7.config(state=DISABLED, text=team)
elif button_id == 8:
self.__button8.config(state=DISABLED, text=team)
elif button_id == 9:
self.__button9.config(state=DISABLED, text=team)
if self.board.check_for_wins():
#DISABLE BUTTONS
if self.board.x_wins():
message = "X wins!"
self.player.inc_x_wins()
self.update_x_wins()
else:
message = "O wins!"
self.player.inc_o_wins()
self.update_o_wins()
messagebox.showinfo("Winner!", message)
self.reset_game()
elif (not self.board.check_for_wins()) and (self.board.full_board()):
message = "Tie!"
self.player.inc_ties()
messagebox.showinfo("No winner...", message)
self.reset_game()
self.update_ties()
def graph_wins(self):
objects = ('X', 'O', 'Ties')
y_pos = np.arange(len(objects))
x = int(self.player.get_x_wins())
o = int(self.player.get_o_wins())
ties = int(self.player.get_ties())
performance = [x, o, ties]
plt.bar(y_pos, performance, align='center', alpha=1.0)
plt.xticks(y_pos, objects)
plt.ylabel('Number of Wins')
plt.title('Number of X and O Wins')
plt.show()
def __init__(self, n, c, t, h): Player.__init__(self, n, c, t, 0, 0) self._house = h self._house_rule_name = Dealer.house_rule_names[self.house-1]
