def test_player_sink_an_opponent_ship():
player1 = Player(1)
player2 = Player(2)
player1.add_opponent(player2)
player2.board.place_ship(player2.ships[0], 2, 2)
assert player1.take_turn(2, 2, 2)['sunk'] == False
assert player1.take_turn(2, 3, 2)['sunk'] == True
def test_player_take_turn_miss():
player1 = Player(1)
player2 = Player(2)
player1.add_opponent(player2)
player2.board.place_ship(player2.ships[0], 2, 2)
assert player2.ships[0].length == 2
player1.take_turn(2, 4, 2)
assert player2.ships[0].length == 2
def test_player_have_i_won():
player1 = Player(1)
player2 = Player(2)
player2.ships.pop()
player2.ships.pop()
player1.add_opponent(player2)
player2.board.place_ship(player2.ships[0], 2, 2)
assert player1.take_turn(2, 2, 2)['winner'] == False
assert player1.take_turn(2, 3, 2)['winner'] == True
def __init__(self):
app_builder = ApplicationWindow.builder
app_builder.add_from_file("gui.glade")
app_builder.connect_signals(Player())
_switch_status = app_builder.get_object('switch_status')
if Player().is_server_active():
_switch_status.set_active(True)
window = app_builder.get_object("mainWindow")
window.show_all()
def main():
signal.signal(signal.SIGINT, signal_handler)
_log = Logger('play_test', Level.INFO)
try:
_log.info('executing player tests...')
_player = Player(Level.INFO)
_player.play(Sound.BLIP)
time.sleep(3.0)
_player.play(Sound.ALARM)
time.sleep(3.0)
_log.info('test complete.')
except KeyboardInterrupt:
_log.warning('Ctrl-C caught: complete.')
except Exception as e:
_log.error('error in test: {}'.format(e))
traceback.print_exc(file=sys.stdout)
sys.exit(1)
finally:
sys.exit(0)
def _configure_default_features(self):
'''
Import dependencies and configure default features.
'''
self._log.warning('configure default features...')
from lib.button import Button
self._log.info('configuring button...')
self._ros._button = Button(self._ros._config,
self._ros.get_message_queue(),
self._ros._mutex)
from lib.bumpers import Bumpers
self._log.info('configuring bumpers...')
self._ros._bumpers = Bumpers(self._ros._config,
self._ros.get_message_queue(), None,
Level.INFO)
from lib.infrareds import Infrareds
self._log.info('configuring infrared trio...')
self._ros._infrareds = Infrareds(self._ros._config,
self._ros.get_message_queue(),
Level.INFO)
from lib.player import Sound, Player
self._log.info('configuring player...')
self._ros._player = Player(Level.INFO)
self._log.warning('default features ready.')
def setup_game(self):
player1_letter = input(
"What letter would Player 1 like to user? (X or O)?: ").upper()
if player1_letter not in ['X', 'O']:
#NOTE the player won't see this as is
print(
'Invalid input! Automatically selecting X for Player 1 and O for Player 2'
)
player1_letter = 'X'
player2_letter = 'O'
else:
print('Assigned %s to Player 1' % player1_letter)
player2_letter = 'O' if player1_letter == 'X' else 'X'
print('Assigned %s to Player 2' % player2_letter)
self.p1 = Player('Player 1', player1_letter, self.size)
self.p2 = Player('Player 2', player2_letter, self.size)
def test_player_incoming_miss():
player1 = Player(1)
assert player1.incoming(2, 2) == {
'hit': False,
'sunk': False,
'winner': False
}
def setUp(self):
card_one = Card("Heart", "5", 5)
card_two = Card("Diamond", "Jack",11)
card_three = Card("Spade", "7", 7)
card_four = Card("Spade", "Ace", 14)
cards = [card_one, card_two, card_three, card_four]
self.deck = Deck(cards)
self.player1 = Player("John", self.deck)
card_five = Card("Heart", "8", 8)
card_six = Card("Diamond", "Jack",11)
card_seven = Card("Spade", "3", 3)
card_eight = Card("Club", "Queen", 12)
cards2 = [card_five, card_six, card_seven, card_eight]
self.deck2 = Deck(cards2)
self.player2 = Player("John", self.deck2)
self.turn = Turn(self.player1, self.player2)
def reset(self):
self.level = 1
self.xp = 1
self.hp = 10
self.max_hp = 10
self.attack = 1
self.prev_level = 1
self.high_score_current = self.score_display.score_read()
self.player = Player(self.hp, self.attack, self.max_hp,
self.display_width, self.display_height,
self.health_bar, pygame)
self.crashed = False
self.enemies = []
self.point = 0
self.xp_new = 100
self.enemy_spawn_time = 5
self.multiplier = 1
self.items = []
for count in range(0, 5):
test_enemy = Enemy(random.randint(0, self.display_width),
random.randint(0, self.display_height),
self.health_bar, pygame, self.multiplier)
self.enemies.append(test_enemy)
self.add_enemy()
def initialize_players(self):
if self.lan_mode and len(self.players) < self.play_num:
self.master.master.after(1000, self.initialize_players)
else:
# Play num in joined mode is 0
for i in range(self.play_num):
pl = Player(self.players[i])
pl.draw_letters(self.bag)
self.players.append(pl)
# If the game is against a computer, no need for the second
# iteration because its class is different
if self.comp_mode:
self.opponent = AIOpponent()
self.opponent.draw_letters(self.bag)
self.players.append(self.opponent)
break
# Deletes the name strings
del self.players[:self.play_num]
if self.lan_mode:
self.queue.put(self.players)
self.init_turn()
def __init__(self):
"""
Initiates a Game object with the necessary features
"""
self.dealer = Dealer(self) # The dealer
self.player = Player(
self
) # The players: eventually change this to a list of players to allow for more than one
def on_scene_enter(self):
#glEnable(GL_POINT_SMOOTH)
#glEnable(GL_TEXTURE_2D)
self.player = Player()
self.players = [self.player]
self.dynamic.append(self.player)
self.last_lead = self.player.position = self.campos = self.cam_spline.get_point(0)
clock.schedule(self.update)
def setUp(self):
card_one = Card("Heart", "5", 5)
card_two = Card("Diamond", "Jack", 11)
card_three = Card("Spade", "7", 7)
card_four = Card("Spade", "Ace", 14)
cards = [card_one, card_two, card_three, card_four]
self.deck = Deck(cards)
self.player = Player("John", self.deck)
def test_player_incoming_hit():
player1 = Player(1)
player1.board.place_ship(player1.ships[0], 2, 2)
assert player1.incoming(2, 2) == {
'hit': True,
'sunk': False,
'winner': False
}
def test_player_updates_play_state(self):
player = Player()
# assert default player state
assert player.in_game is True
# assert we can set player to inactive
player.in_game = False
# assert that the player state has changed
assert player.in_game is False
def __init__(self, is_prod=False):
pygame.init()
inf = pygame.display.Info()
pygame.mouse.set_visible(False)
flags = pygame.FULLSCREEN if is_prod else pygame.RESIZABLE
window = pygame.display.set_mode([inf.current_w, inf.current_h], flags)
self.player = Player()
self.text = MirrorText('', window)
self.is_running = False
def startGame(self):
self.player = Player()
self.enemies = []
self.amountOfEnemies = 0
self.spawnEnemy()
self.clock = pygame.time.Clock()
self.timer = 0
self.enemyTimer = 0
self.timeUntilEnemySpawns = 2000
self.gameState = "GAME"
def new_player(session, game_id):
game = get_game(session, game_id)
num = len(get_players(session, game_id))
new_player = Player(game_id=game_id, player_id=num)
print(new_player.__dict__)
session.add(new_player)
session.flush()
pid = new_player.player_id
game.ac += 1
session.commit()
return pid
def __init__(self, pnames):
"""
:param pnames: An Array. Name of the players as Strings
"""
self.board = Board()
self.players = tuple([Player(pn, self.board, self) for pn in pnames])
self.plookup = {p.getId(): p for p in self.players}
self.lastRoll = None
self.p = None
self.getFirstPlayer()
self.state = 0
def __init__(self):
deck = Deck.shuffle()
self.trump = deck[-1]
hand1 = deck[:HAND_SIZE]
deck = deck[HAND_SIZE:]
hand2 = deck[:HAND_SIZE]
self.deck = deck[HAND_SIZE:]
self.ai = AIPlayer(self, hand1)
self.player = Player(self, hand2)
self.set_first_turn()
def main(self):
pygame.init()
self.DISPLAYSURF = pygame.display.set_mode(
(WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption('Hello World!')
self.playerImg = pygame.image.load('./pics/player.png')
self.appleImg = pygame.image.load('./pics/apple.png')
self.player = Player()
self.apple = Apple()
self.score = 0
self.clock = pygame.time.Clock()
# Text
self.font = pygame.font.Font('freesansbold.ttf', 16)
self.text = self.font.render('Score: ' + str(self.score), True, white,
black)
self.textRect = self.text.get_rect()
self.textRect.x = 1200
self.textRect.y = 700
while True:
# Event Handler
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.player.moveLeft()
if event.key == pygame.K_UP:
self.player.moveUp()
if event.key == pygame.K_DOWN:
self.player.moveDown()
if event.key == pygame.K_RIGHT:
self.player.moveRight()
if event.key == pygame.K_ESCAPE:
self.die()
if event.type == QUIT:
self.die()
self.player.update()
self.checkCollision()
self.draw()
pygame.display.update()
time.sleep(50.0 / 1000.0)
def main():
signal.signal(signal.SIGINT, signal_handler)
try:
print('all_tests :' + Fore.CYAN +
' INFO : executing tests...' + Style.RESET_ALL)
_player = Player(Level.INFO)
subprocess.call("ads_test.py", shell=True)
_player.play(Sound.BLIP)
subprocess.call("batterycheck_test.py", shell=True)
_player.play(Sound.BLIP)
subprocess.call("rgbmatrix_test.py", shell=True)
_player.play(Sound.BLIP)
subprocess.call("button_test.py", shell=True)
_player.play(Sound.ALARM)
subprocess.call("bumpers_test.py", shell=True)
_player.play(Sound.ALARM)
subprocess.call("infrareds_test.py", shell=True)
_player.play(Sound.ALARM)
subprocess.call("scanner_test.py", shell=True)
_player.play(Sound.ALARM)
# _player.play(Sound.ALARM)
# subprocess.call("motors_test.py", shell=True)
time.sleep(5.0)
print('all_tests :' + Fore.CYAN + ' INFO : test complete.' +
Style.RESET_ALL)
except KeyboardInterrupt:
print('all_tests :' + Fore.RED + Style.BRIGHT +
' INFO : Ctrl-C caught: complete.' + Style.RESET_ALL)
except Exception as e:
print('all_tests :' + Fore.RED + Style.BRIGHT +
' ERROR : error in test: {}'.format(e) + Style.RESET_ALL)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
finally:
sys.exit(0)
def main():
signal.signal(signal.SIGINT, signal_handler)
_log = Logger("scanner", Level.INFO)
_log.info(Fore.CYAN + Style.BRIGHT + ' INFO : starting test...')
_log.info(Fore.YELLOW + Style.BRIGHT + ' INFO : Press Ctrl+C to exit.')
try:
_i2c_scanner = I2CScanner(Level.WARN)
_addresses = _i2c_scanner.getAddresses()
hexAddresses = _i2c_scanner.getHexAddresses()
_addrDict = dict(list(map(lambda x, y:(x,y), _addresses, hexAddresses)))
for i in range(len(_addresses)):
_log.debug(Fore.BLACK + Style.DIM + 'found device at address: {}'.format(hexAddresses[i]))
vl53l1x_available = ( 0x29 in _addresses )
ultraborg_available = ( 0x36 in _addresses )
if not vl53l1x_available:
raise OSError('VL53L1X hardware dependency not available.')
elif not ultraborg_available:
raise OSError('UltraBorg hardware dependency not available.')
_log.info('starting scan...')
_player = Player(Level.INFO)
_loader = ConfigLoader(Level.INFO)
filename = 'config.yaml'
_config = _loader.configure(filename)
_lidar = Lidar(_config, _player, Level.INFO)
_lidar.enable()
values = _lidar.scan()
_angle_at_min = values[0]
_min_mm = values[1]
_angle_at_max = values[2]
_max_mm = values[3]
_log.info(Fore.CYAN + Style.BRIGHT + 'min. distance at {:>5.2f}°:\t{}mm'.format(_angle_at_min, _min_mm))
_log.info(Fore.CYAN + Style.BRIGHT + 'max. distance at {:>5.2f}°:\t{}mm'.format(_angle_at_max, _max_mm))
time.sleep(1.0)
_lidar.close()
_log.info(Fore.CYAN + Style.BRIGHT + 'test complete.')
except Exception:
_log.info(traceback.format_exc())
sys.exit(1)
def train():
env = Environment()
player = Player()
for episode in range(2):
env.start()
while True:
actions = player.act(env.state)
reverd = env.apply(actions)
player.learn(reverd)
if env.done:
break
return
def __init__(self):
pygame.init()
self.display_width = 790
self.display_height = 740
self.level = 1
self.xp = 1
self.hp = 10
self.max_hp = 10
self.attack = 1
self.talent_point = 0
self.prev_level = 1
self.name = "test name"
self.score_display = ScoreScreen()
self.high_score_current = self.score_display.score_read()
self.is_paused = False
pygame.display.set_caption('Taemasu v0.1')
self.health_bar = pygame.image.load('lib/img/healthbar.png')
self.player = Player(self.hp, self.attack, self.max_hp,
self.display_width, self.display_height,
self.health_bar, pygame)
self.game_display = pygame.display.set_mode((1200, 1200))
self.white = (255, 255, 255)
self.clock = pygame.time.Clock()
self.crashed = False
self.game_display.fill(self.white)
self.enemies = []
self.sword = pygame.image.load('lib/img/sword.png')
self.map = Map('maptest.txt', self.display_width, self.display_height,
pygame)
pygame.font.init() # you have to call this at the start,
# if you want to use this module.
self.myfont = pygame.font.SysFont('Comic Sans MS', 30)
self.point = 0
self.xp_new = 100
self.background = pygame.image.load('lib/img/background4.png')
self.enemy_spawn_time = 2
self.multiplier = 1
self.start = True
self.items = []
self.exiting = False
for count in range(0, 5):
test_enemy = Enemy(random.randint(0, self.display_width),
random.randint(0, self.display_height),
self.health_bar, pygame, self.multiplier)
self.enemies.append(test_enemy)
self.add_enemy()
def _get_name_from_user(self):
"""Run the code to get the user's desired character/save name."""
self.ENTER_CHARACTER_NAME.display()
if self.game.keys.text_input: # Only allow the user to continue with a name entered.
if self.game.keys.enter or self.game.keys.numpad_enter:
self.game.keys.stop_text_input()
if self.game.mouse.is_in(553, 404, 727, 442):
self.CONTINUE_BUTTON_FLARED.display()
if self.game.mouse.left:
self.game.keys.stop_text_input()
Text(self.game.keys.text_input, Font.SUNNI, Color.BLACK,
(370, 338)).display()
if not self.game.keys.receiving_text_input:
self.game.player = Player(self.game, self.game.keys.text_input)
character_name_text = f"Character name: {self.game.player.name}"
self.player_name_text = Text(character_name_text, Font.DEFAULT,
Color.MILD_BLUE, (10, 10))
def getTeam(team = None,verbose = True):
teams = ['ari','atl','bal','buf','car','chi','cin','cle','dal', 'den', 'det', 'gb', 'hou', 'ind','jax','kc', 'lac', 'lar', 'lv','mia','min','ne','no','nyg','nyj','phi','pit','sea','sf','tb','ten','was']
gotTeam = False
if team == None:
team = ""
while (not gotTeam):
try:
team = input("Enter a team abbreviation\n")
team = team.lower()
if team == 'q' or team == '^C':
raise Exception('q')
elif team not in teams:
raise Exception('bad')
else:
gotTeam = True
except Exception as e:
if str(e) == 'q':
sys.exit(0)
else:
print("Invalid team name")
team = team.upper()
filename = 'data/py_objects/'+team+'.json'
data = []
with open(filename) as json_file:
data = json.load(json_file)
players = []
for d in data:
p = Player(d)
players.append(p)
teamName = team
team = Team(teamName, players)
if verbose:
team.printStats()
team.printLineup()
return team
def __init__(self, game_map, screen):
"""
Maze grid, from Grid class which import external file.
"""
self.maze_grid = copy.deepcopy(game_map.grid)
self.screen = screen
self.guardian = Guardian(game_map)
self.player = Player(game_map)
self.needle = Item(game_map, self.guardian)
self.tube = Item(game_map, self.guardian)
self.ether = Item(game_map, self.guardian)
self.bag = Bag()
self.objects_list = [
game_map, self.player, self.guardian, self.needle, self.tube,
self.ether, self.bag
]
self.item_1 = (6, 21)
self.item_2 = (8, 21)
self.item_3 = (10, 21)
self.bag_items = [self.item_1, self.item_2, self.item_3]
self.floor = None
self.wall = None
self.macgyver = None
self.guard = None
self.exit_tile = None
self.exit_open = None
self.needle_img = None
self.tube_img = None
self.ether_img = None
self.empty_bag = None
self.item_bag = None
self.seringue_img = None
self.splash1 = None
self.splash2 = None
self.splash3 = None
self.rip = None
self.bag_font = None
self.text_full = None
self._running = True
self.list_guardian_animation = []
def on_scene_enter(self):
clock.schedule(self.update)
self.player = Player()
self.players = [self.player]
self.generate_level()
# set up collision detection
self.coll_detector = collision.CollisionDetector()
# collisions between:
# flock-player, player-bullets, player-objstacles, bulltets-obstacles, bullets-flock
#self.coll_detector.register_once(self, group_name1, group_name2, group1, group2, coll_strategy, type_tuple, func):
self.coll_detector.register_group('player', self.players)
self.coll_detector.register_group('flocks', self.flocks)
self.coll_detector.register_group('obstacles', self.obstacles)
self.coll_detector.register_group('enemies', self.enemies)
self.coll_detector.register_group('bullets', self.bullets)
self.coll_detector.register_pair('player', 'flocks', PlayerFlockCollisionStrategy(self))
self.coll_detector.register_pair('player', 'bullets', PlayerBulletsCollisionStrategy(self))
self.coll_detector.register_pair('player', 'obstacles', PlayerObstaclesCollisionStrategy(self))
self.coll_detector.register_pair('bullets', 'obstacles', BulletsObstaclesCollisionStrategy(self))
self.coll_detector.register_pair('flocks', 'bullets', FlockBulletsCollisionStrategy(self))
#self.coll_detector.register_once('player', 'flocks', self.players, self.flocks, PlayerFlockCollisionStrategy(self), tuple(), None):
# enemy
#scene, fire_rate, position, orientation)
self.enemies.append( Enemy(self, 1, Vec3(300, 10), Vec3(0, 1) * 100.0) )
self.enemies.append( Enemy(self, 0.1, Vec3(10, 200), Vec3(1, -0.1) * 300.0) )
self.enemies.append( Enemy(self, 1, Vec3(500, 10), Vec3(0, 1) * 200) )
p = Polygon()
p.add_vertex(400, 400)
p.add_vertex(550, 400)
p.add_vertex(550, 420)
p.add_vertex(400, 450)
self.obstacles.append(p)
