def __init__(self, color): self.drone = Drone('/' + color) self.color = color drone = self.drone self.modes = { "idle": Mode(drone), "follow": FollowGesture(drone), "land": TakeoffLand(drone), "takeoff": TakeoffLand(drone, takeoff=True), "north": Move(drone, 0), "east": Move(drone, 3 * math.pi / 2), "south": Move(drone, math.pi), "west": Move(drone, math.pi / 2), "stop": Move(drone, 0), "forward": Move(drone, 0, relative=True), "duck": Move(drone, 0, -1), "jump": Move(drone, 0, 1), "analyze": Photo(drone) } self.look_modes = { "look": Turn(drone), "right": Turn(drone, -1), "left": Turn(drone, 1) } self.look_direction = 0 self.current_mode_pub = rospy.Publisher("/" + color + "_current_mode", String, queue_size=10) self.look_mode_pub = rospy.Publisher("/" + color + "_look_mode", String, queue_size=10) self.current_mode = self.modes["idle"] self.look_mode = self.modes["idle"] print('Drone ' + color + ' initialized')
def __init__( self, nplayers=2, onmove=0, systems=None, stash=None, alive=None, # list of player statuses, None for not yet created ): self.nplayers = nplayers self.onmove = onmove if systems is None: systems = [] alive = [None] * nplayers self.systems = systems if stash is None: stash = Stash(nplayers + 1) for sys in systems: for m in sys.markers: stash.request(m) for s in sys.ships: stash.request(s.piece) self.stash = stash if alive is None: # This assumes that players with no home have been eliminated alive = [False] * nplayers for sys in systems: if not sys.home is None: alive[sys.home] = True self.alive = alive # This turn will be built one event as a time self.curTurn = Turn(self)
def _turn1(self): """ get the Turn object for the first turn Returns ------- Turn """ return Turn(self.params, self.turn1_ang)
def __is_stalemate(self): stale = [] for i in range(0,8): for j in range(0,8): if isinstance(self.board[i][j], Piece) and self.board[i][j].colour == self.current_player: for sq in self.board[i][j].available_moves(self.board, i, j): stale.append(Turn(self.game.ruleset, self.board, self.game.log, self.game.player_1, self.game.player_2).ruleset.check_if_move_into_check(self.board, i, j, sq[0], sq[1]) == 'invalid move') return all(stale)
def __init__(self, name, height, width, max_number_players, end_type=False, length_to_win=3): self.name = name self.width = width self.height = height self.grid = [[0 for i in range(self.width)] for j in range(self.height)] self.max_number_players = max_number_players self.length_to_win = length_to_win # Instantiate a dummy turn object self.turn = Turn()
def firstTurn(self): for player in self.players: self.playerDict[player.name] = player self.playerStates[player.name] = PlayerState(player, self) self.round = 1 self.currentPlayer = self.players.pop(0) self.firstPlayer = self.currentPlayer self.log.append("Round 1") self.currentTurn = Turn(self.currentPlayer, self.players, self.round, self.log, self)
def nextTurn(self): self.currentTurn.cleanupPhase() if self.supply.gameOver(): self.log.append("The Game is Over!!") self.determineWinner() self.players.append(self.currentPlayer) self.currentPlayer = self.players.pop(0) if self.currentPlayer == self.firstPlayer: self.round += 1 self.log.append("Round %d" % (self.round)) self.currentTurn = Turn(self.currentPlayer, self.players, self.round, self.log, self)
def drive_to(bot, target: Vec3) -> Turn: """ Find the most naive turn to get to the target position """ car = bot.info.my_car turns = Turn.all(car) # Find best turn delta_n = normalize(target - car.pos) turn, _ = argmax(turns, lambda turn: dot(turn.dir, delta_n)) return turn
def run(self): # Preflop self.globalPot += Turn(self.players, self.board, self.smallBlind, self.bigBlind).run() self.emptyPlayersPots() self.dealBoardCard(3) # Flop self.globalPot += Turn(self.players, self.board, self.smallBlind, self.bigBlind).run() self.emptyPlayersPots() self.dealBoardCard(1) #Turn self.globalPot += Turn(self.players, self.board, self.smallBlind, self.bigBlind).run() self.emptyPlayersPots() self.dealBoardCard(1) #River self.globalPot += Turn(self.players, self.board, self.smallBlind, self.bigBlind).run() self.emptyPlayersPots()
def play(self): last_action = None self.end_seat = self.filtered_seats[-1] self.align_seat_deques() while True: seat = self.filtered_seats[0] turn = Turn( self.seats, self.filtered_seats, self.cards, self.current_bet, last_action, ) action = turn.play() if action: last_action = action self.resolve_action(seat, action) if len(self.filtered_seats) == 1: self.LOGGER.debug("Player {} wins".format( self.filtered_seats[0].index)) self.move_all_bets_to_pots() return list(self.filtered_seats) if seat is self.end_seat: # bets have been called self.move_all_bets_to_pots() return [ seat for seat in self.remaining_seats if seat in self.filtered_seats ] self.filtered_seats.rotate(-1) self.align_seat_deques()
def next_turn(self): print("Turn: {}. Active Player: {}".format( self.turn_count, str(self._active_player.color))) current_turn = Turn(self._active_player, self.board) # DOMOVE: self.board.move_piece(current_turn) self.turn_list.append(current_turn) # Switch player if not current_turn.extra_turn: if self._active_player is self.player1: self._active_player = self.player2 else: self._active_player = self.player1 # And increment the turn_count self.turn_count += 1
def play(self): explain_rules() answer_guessed = False while not self.did_win() and not self.strikes.limit_reached(): utils.clear_screen() utils.print_header("Turn {}".format(str(self.turn_number))) turn = Turn(self.answer, self.guessed_letters, self.strikes) if self.answer.equals(turn.guess): answer_guessed = True break self.guessed_letters.append(turn.guess) if turn.guess not in self.answer.lower(): self.strikes.add(turn.guess) self.turn_number += 1 self.end_game(answer_guessed) return self.play_again()
def newTurn(self, timeout): ''' Create turn and select not last playing team. return back the turn object pointer. ''' for t in self.teams: if t.wasLastPlaying() == False: break if t.wasLastPlaying(): raise Exception('Error in teams switching') #TODO: start team play turn = Turn(self, t, timeout) self.currentTurn = turn return self.currentTurn
def smart_drive_to(bot, target: Vec3) -> Turn: """ Find a turn that will get us to the target position and avoid creating short line segments """ car = bot.info.my_car speed = min(2295, norm(car.vel) * 1.4) next_turn_pos = car.pos if bot.can_turn( ) else car.pos + car.forward * speed * bot.time_till_turn() line_seg_min_len = speed * TURN_COOLDOWN # local.x: how far in front of my car # local.y: how far to the left of my car # local.z: how far above my car delta_local = dot(target - next_turn_pos, car.rot) SOME_SMALL_VALUE = 20 if delta_local.x < 0: delta_local.x = -delta_local.x if SOME_SMALL_VALUE < delta_local.x < line_seg_min_len: # Turning now results in a miss later return Turn.no_turn(car) else: return drive_to(bot, target)
def main(): players = {} numberOfPlayers = 0 while numberOfPlayers < 1 or numberOfPlayers > 5: try: numberOfPlayers = int(input("How many players (1-5)? ")) except ValueError: print("Pick a number between 1-5.") i = 1 while i <= numberOfPlayers: players[i] = Player(i) i += 1 # Run a turn n = 1 while True: newPlayers = playerRefresh(players, n) if newPlayers: Turn(newPlayers) n += 1 else: break
def move(direction, seconds): """generic move method""" if direction in ['forward', 'backward']: exec_move = Move() if direction == 'forward': exec_move.forward(seconds) else: exec_move.backward(seconds) result = 'done move' elif direction in ['left', 'right']: exec_move = Turn() if direction == 'left': exec_move.left(seconds) else: exec_move.right(seconds) result = 'done turn' else: result = '{0} is no valid direction, choose between forward, backward, left, right.'.format( direction) return jsonify({ 'result': result, 'direction': direction, 'seconds': seconds })
def play_turn(self, player): new_turn = Turn(player, self.board, self.rules, self.ui) result = new_turn.play_turn() self.moves_left[player.color] = result
class State: def __init__(self, data): self.nouns = data.nouns self.rooms = data.rooms self.vars = data.vars self.messages = data.messages self.lexicon = data.lexicon self.current_room = next(room for room in self.rooms.itervalues() if room.is_start) self.current_room.visit() # junction lists self.locations = set() self.tags = set() for noun in self.nouns.itervalues(): self.locations |= set((noun, self.locations_by_id(lid)) for lid in noun.initial_locs) self.tags |= set((noun, tag) for tag in noun.initial_tags) for room in self.rooms.itervalues(): self.tags |= set((room, tag) for tag in room.initial_tags) self.current_turn = None def start_turn(self, command): """Create a new turn object with the given command.""" self.current_turn = Turn(command) def command_matches(self, control_str): """Check if the number of terms in the given control string is equal to or less than the number of words in current turn's command, and each term is a wildcard, a synonymous word, or a piped list of words where at least one is synonymous.""" control_terms = [cterm for cterm in control_str.lower().split() if cterm not in ('a', 'an', 'the')] return (len(control_terms) <= len(self.current_turn.words) and all(cterm == '*' or any(self.lexicon.words_match(cword, self.current_turn.words[i]) for cword in cterm.split('|')) for i, cterm in enumerate(control_terms))) def sub_words(self, phrase): return self.current_turn.sub_words(phrase) if self.current_turn is not None else phrase def locations_by_id(self, lid): """Return the noun or room with the given ID.""" return (lid if lid in ('INVENTORY', 'WORN') else self.nouns.get(lid) or self.rooms.get(lid)) def entities_by_tag(self, *tags): """Return a list of rooms or nouns with at least one of the given tags.""" return set(entity for entity, tag in self.tags if tag in tags) def nouns_by_tag(self, *tags): """Return a list of nouns with at least one of the given tags.""" return self.entities_by_tag(*tags) & set(self.nouns.itervalues()) def rooms_by_tag(self, *tags): """Return a list of rooms with at least one of the given tags.""" return self.entities_by_tag(*tags) & set(self.rooms.itervalues()) def nouns_by_word(self, *words): """Return a list of nouns that match any of the given words.""" return set(noun for noun in self.nouns.itervalues() if set(words) & noun.words) def nouns_by_input_word(self, wordnum): """Return a list of nouns matching the input word at the given index.""" try: return self.nouns_by_word(self.current_turn.words[wordnum - 1]) except IndexError: return set() def nouns_at_loc(self, *locs): """Return all nouns at any of the given locations.""" return set(noun for noun, loc in self.locations if loc in locs) def noun_locs(self, *nouns): """Return all nouns or rooms containing any of the given nouns.""" return set(loc for noun, loc in self.locations if noun in nouns) def add_noun(self, noun, *locs): """Add the given noun to all the given locations.""" self.locations |= set((noun, loc) for loc in locs) def remove_noun(self, noun, *locs): """Remove the given noun from all the given locations.""" self.locations -= set((noun, loc) for loc in locs) def move_noun(self, noun, *locs): """Replace the given noun's current locations with the given ones.""" self.clear_noun_locs(noun) self.add_noun(noun, *locs) def clear_noun_locs(self, *nouns): """Remove the given nouns from all locations.""" self.locations -= set((noun, loc) for noun, loc in self.locations if noun in nouns) def add_tag(self, tag, *entities): """Add the tag to all given entities.""" self.tags |= set((entity, tag) for entity in entities) def remove_tag(self, tag, *entities): """Remove the tag from all given entities.""" self.tags -= set((entity, tag) for entity in entities)
def find_turns(topic, turn_section): #This is the regular expression to find the turn of a topic #This is the regular expression to find out the user and date of a turn author_reg = '\[\[User(\s*talk)*:(?P<name>.*?)\|(?P<alias>.*?)\]\]' author_reg_c = re.compile(author_reg) user_date_reg = '\[\[User(\s*talk)*:(?P<name>.*?)'\ '\|(?P<alias>.*?)\]\]'\ '[\s\|]*(\(*\[\[.*\]\]\)*)*\s*'\ '(?P<date>[a-zA-Z0-9i/,:\-\s]+)?' user_date_reg_c= re.compile(user_date_reg) #try to different turn indent from list indent list_reg = '[:\*#;\d]+' list_reg_c = re.compile(list_reg) #this indicate turn indent as a discussion thread thread_reg = ':+' thread_reg_c = re.compile(thread_reg) #Find the potential turn list based on line break #The turn list returned mightnot be the actual one, because #some authors add linebreak in their messages #we may need to combine a few contiguous turns to form a #complete turn #We know a turn is complete if we see user information at the #end, or if the next candidate starts with ":", a wiki markup #indicating indent and follow up thread # turn_text_pre = '' turn_finish = True turn_list = turn_section.split('\n') for turn_text in turn_list: #pdb.set_trace() turn_text = turn_text.strip() if len(turn_text) == 0: continue user = user_date_reg_c.search(turn_text) if user is not None: if turn_text.startswith(':'): if list_reg_c.match(turn_text) is None: if not turn_finish: turn = Turn(turn_text_pre.strip()) topic.add_turn(turn) turn_text_pre = '' turn_finish = True if not turn_finish: turn_text = turn_text_pre + '\n' + turn_text #if there are multiple matching, we take th e last one #pdb.set_trace() users = user_date_reg_c.finditer(turn_text) for match in users: date_str = match.group('date') author = match.group('name') date = None if date_str is not None: date = str_to_datetime(date_str) if date is not None: turn = Turn(turn_text.strip(), author,date) else: turn = Turn(turn_text.strip(), author) topic.add_turn(turn) turn_text_pre = '' turn_finish = True else: # a normal paragraph add it to previous one if not turn_text.startswith(':'): turn_text_pre = turn_text_pre+ '\n' + turn_text turn_finish = False else: # check if it is just a list if list_reg_c.match(turn_text) is not None: turn_text_pre = turn_text_pre + '\n' + turn_text turn_finish = False # this is a new turn else: #check if there is a previous unfinished turn if not turn_finish: turn = Turn(turn_text_pre.strip()) topic.add_turn(turn) #start the new turn turn_text_pre = turn_text else: #this is another section of a previous turn turn_text_pre = turn_text turn_finish = False if not turn_finish and len(turn_text_pre)> 0: topic.add_turn(Turn(turn_text_pre.strip())) # build parent-child relationship # turns in a topic is added in time order # after previous processing # some user use list mark up to indicate followup turns = topic.turns parent_stack = [] for turn in turns: turn_text = turn.text indent = list_reg_c.match(turn_text) #pdb.set_trace() if indent is None: # start of a new thread if len(parent_stack) > 0: del parent_stack[:] parent_stack.append(turn) else: indent_str = indent.group() level = len(indent_str) # intended level #pdb.set_trace() current = len(parent_stack)-1 # current level if current < 0: # this is the first turn parent_stack.append(turn) continue if level > current: parent = parent_stack[current] parent.add_sub(turn) turn.add_parent(parent) parent_stack.append(turn) # continue #if level == current: #same level,maybe a reply of previous one # pop the old one # parent_stack.pop() # parent = parent_stack[current] # parent.add_sub(turn) # turn.add_parent(parent) # parent_stack.append(turn) else: # this is a reply of previous turn diff = current - level + 1 for counter in range(diff): parent_stack.pop() parent = parent_stack[len(parent_stack)-1] parent.add_sub(turn) turn.add_parent(parent) parent_stack.append(turn)
def __fight(self): print(f'Um {self.npc.name} apareceu! Prepare-se!') printWSleep() while self.player.alive and self.npc.alive: self.turns += 1 Turn(self.player, self.npc)
def right(seconds): """right method""" turn_rgt = Turn() turn_rgt.right(seconds) return jsonify({'result': "done", 'direction': '', 'drive_time': seconds})
def pickTurn(self): """ Yields the turn for the proper player """ while True: for player in self.players: yield Turn(player, self)
help='How long must the car drive', type=int, default=1) PARSER.add_argument('--speed', help='How fast must the car drive', type=int, default=1) ARGS = PARSER.parse_args() # LOGLEVEL = ARGS.loglevel DIRECTION = ARGS.direction DIRECTION = -1 # backward DRIVE_TIME = ARGS.seconds WAIT_TIME = ARGS.speed / float(1000) # set log level if ARGS.verbose: logging.getLogger().setLevel(logging.DEBUG) AMOVE = Move() AMOVE.drive_time = 2 AMOVE.run() ATURN = Turn() ATURN.drive_time = 2 ATURN.direction = -1 ATURN.run() AMOVE = Move() AMOVE.wait_time = 5 AMOVE.run()
class Boardgame: piece_marker_dict = {0: " "} max_number_players = 0 players = [] type = "" # Options: "2048-like" or "tic-tac-toe-like" length_to_win = 0 def __init__(self, name, height, width, max_number_players, end_type=False, length_to_win=3): self.name = name self.width = width self.height = height self.grid = [[0 for i in range(self.width)] for j in range(self.height)] self.max_number_players = max_number_players self.length_to_win = length_to_win # Instantiate a dummy turn object self.turn = Turn() def update_available_markers(self): # First, get all markers available_markers = list(self.piece_marker_dict.values()) # Remove the empty space as an available marker available_markers.remove(' ') # Then, search for markers being used by a player for player in self.players: # Remove not available markers in list if player.marker in available_markers: available_markers.remove(player.marker) return available_markers def g2048_init(self): g2048_add_new_tile(self.grid) g2048_add_new_tile(self.grid) def tic_tac_toe_init(self): selected_marker = "" for player in self.players: print("Associate player {} with which marker?".format(player.name)) available_markers = self.update_available_markers() ask_marker = True while ask_marker: print("Available markers: {}".format(available_markers)) selected_marker = input() if selected_marker not in available_markers: print("Invalid marker! Try again") else: ask_marker = False player.marker = selected_marker def g2048_after_execution(self, grid_altered): # Procedures object made just to access the methods that test the game over condition procedures_obj = Procedures() # If the grid was altered, add a new random tile if grid_altered: g2048_add_new_tile(self.grid) # Verify if it's game over game_over = procedures_obj.g2048_is_game_over(self.grid) max_value = get_grid_tile_max(self.grid) if max_value == 2048: print("Congratulations! You have a winning configuration!") return game_over def tic_tac_toe_after_execution(self, grid_altered): game_over = False if grid_altered: game_over, winner_marker, number = tic_tac_toe_victory( self.grid, self.length_to_win) if game_over: winner = self.players[0] for player in self.players: if player.marker == self.piece_marker_dict[winner_marker]: winner = player print("{} has won the game!".format(winner.name)) return game_over def init_game(self): if self.type == "2048-like": self.g2048_init() elif self.type == "tic-tac-toe-like": self.tic_tac_toe_init() def run_game(self): # Add players in the game for i in range(self.max_number_players): print("Player {} name: ".format(i + 1)) new_player = Player(input()) self.players.append(new_player) if i + 1 < self.max_number_players: print("Do you want to add more players? (You can add {} more)". format(self.max_number_players - (i + 1))) print("1: Yes") print("2: No") option = input() if option == "2": break # Start procedure: # Put the first player in the list as their turn self.turn.player = self.players[0] # Run init_game() to load starting situation self.init_game() # Create game loop turn_index = 0 # Variable to keep track of each player's turn grid_altered = True # Variable that tells if the grid was altered after an action game_over = False while not game_over: # Game loop # Print the grid print( grid_to_string_with_size_and_theme(self.grid, self.piece_marker_dict, len(self.grid))) # Announce the player's turn, and their available actions self.turn.list_actions() # Ask the player which action he/she will perform self.turn.ask_action() # Execute action action_result = self.turn.execute_action() # Check if result is valid if action_result is not None: # If it is, check whether the updated grid is different from the old one if not equal_grids(self.grid, action_result): # Update grid self.grid = action_result grid_altered = True else: grid_altered = False else: # Else, the user has put an invalid input (an input that is not equal to any action) print("Wrong input! Try again") continue # Do things after execution (like verify movement) if self.type == "2048-like": game_over = self.g2048_after_execution(grid_altered) elif self.type == "tic-tac-toe-like": game_over = self.tic_tac_toe_after_execution(grid_altered) if not game_over: # Change turn: turn_index += 1 if turn_index == len(self.players): turn_index = 0 self.turn.player = self.players[turn_index] # Print the grid one more time to show the game over grid print( grid_to_string_with_size_and_theme(self.grid, self.piece_marker_dict, len(self.grid))) print("Game Over !")
class HWState: def __init__( self, nplayers=2, onmove=0, systems=None, stash=None, alive=None, # list of player statuses, None for not yet created ): self.nplayers = nplayers self.onmove = onmove if systems is None: systems = [] alive = [None] * nplayers self.systems = systems if stash is None: stash = Stash(nplayers + 1) for sys in systems: for m in sys.markers: stash.request(m) for s in sys.ships: stash.request(s.piece) self.stash = stash if alive is None: # This assumes that players with no home have been eliminated alive = [False] * nplayers for sys in systems: if not sys.home is None: alive[sys.home] = True self.alive = alive # This turn will be built one event as a time self.curTurn = Turn(self) def deepCopy(self): systems = [s.deepCopy() for s in self.systems] stash = self.stash.deepCopy() alive = list(self.alive) return HWState(self.nplayers, self.onmove, systems, stash, alive) def creationOver(self): return self.alive.count(None) == 0 def addSystem(self, system): self.systems.append(system) def removeSystem(self, system): self.systems.pop(self.systems.index(system)) def findHome(self, player): for sys in self.systems: if sys.home == player: return sys # Player's home is missing return None def cancelTurn(self): self.curTurn.undoAll() def addEvent(self, e): # Event should be a Creation, Action, Catastrophe, or Pass # Fade and Elimination events are checked for and triggered here self.curTurn.addEvent(e) try: e.enact(self) except Exception as ex: # Signal the turn that the event is cancelled # This affects the turn's understanding of whether a sacrifice is occurring try: self.curTurn.undoLast() except: print( 'A problem occurred while resetting the turn. This could be a serious problem.' ) print(str(ex)) raise ex # Check for Fades (but not for home systems) sys = e.getThreatenedSystem() if (not sys is None) and (sys.home is None) and sys.isVoid(): fade = sys.getFade() self.curTurn.addEvent(fade) fade.enact(self) def finishTurn(self): # Checks for home system fades and eliminations if not self.curTurn.isCompleted(): self.cancelTurn() raise TurnNotOverException( 'Turn is not complete. Did you forget to pass an unwanted sacrifice action?' ) # Check for elimination # TODO this is better for huge numbers of players, but slower otherwise # for player in self.curTurn.getThreatenedPlayers() for player in range(self.nplayers): # Check if player has been eliminated if self.alive[player] != True: # Player is either already known to be dead or hasn't created a home continue # Player is believed to be alive but may have just been eliminated home = self.findHome(player) abandoned = not home.hasPresence(player) voided = home.isVoid() if abandoned or voided: # Player has been eliminated elim = event.Elimination(player, self.onmove) self.curTurn.addEvent(elim) elim.enact(self) if voided: fade = home.getFade() self.curTurn.addEvent(fade) fade.enact(self) def startNewTurn(self): if self.isEnd(): raise Exception('State is at endpoint.') self.advanceOnmove() self.curTurn = Turn(self) def advanceOnmove(self, d=1): # set d=-1 to get previous player self.onmove = self.getNextPlayer(d) def getNextPlayer(self, d=1): # set d=-1 to get previous player i = (self.onmove + d) % self.nplayers # TODO if current player is somehow dead, this is an endless loop while self.alive[i] == False: i = (i + d) % self.nplayers return i def getScores(self): if not self.isEnd(): raise Exception('Game is not over.') if self.alive.count(True) == 0: return [1 / self.nplayers] * self.nplayers scores = [0] * self.nplayers scores[self.alive.index(True)] = 1 return scores def saveTuple(self): # Returns a tuple appropriate for saving the game # Systems are not sorted, so not appropriate for comparing states # Includes system names stuples = [s.saveTuple() for s in self.systems] return (self.onmove, tuple(self.alive), tuple(stuples)) def tuplify(self): # Does not include system names, but systems are sorted # Appropriate for comparing states if not self.tupled is None: return self.tupled stuples = [s.tuplify() for s in self.systems] stuples.sort() self.tupled = (self.onmove, tuple(self.alive), tuple(stuples)) return self.tupled def __hash__(self): return self.calcHash() def calcHash(self): return hash(self.tuplify()) def isEnd(self): # TODO implement other win conditions if not self.creationOver(): return False return self.alive.count(True) <= 1 def __eq__(self, other): return self.tuplify() == other.tuplify() def __str__(self): divider = '/' * 30 movestr = 'Player %s to move' % self.onmove stashStr = str(self.stash) sysStr = ('\n%s\n' % divideSysStr).join([str(s) for s in self.systems]) return '%s\n%s\n%s\n%s\n%s' % (divider, movestr, stashStr, sysStr, divider) def buildStr(self): return '<{}>;\n{}'.format( self.onmove, ';\n'.join([sys.buildStr(self.nplayers) for sys in self.systems])) def getConnections(self, sys): # Return a list of systems connected to sys INCLUDING DISCOVERIES # TODO remember connections so this doesn't have to keep getting called connects = [] # Existing systems for s in self.systems: if s.connectsTo(sys): connects.append(s) # Discoveries for size in piece.sizes: for m in sys.markers: if m.size == size: break else: # Inner loop exited normally, discoveries may have this size for c in colors: if self.stash.isAvailable(c, size): p = piece.Piece(size, c) connects.append(System([p])) return connects
def left(seconds): """left method""" turn_lft = Turn() turn_lft.left(seconds) return jsonify({'result': "done", 'direction': '', 'drive_time': seconds})
def setUp(self): self.a_turn = Turn(1, Player("maruko"), Card(Suit.CLUB, Rank.ACE))
class GameService(Service): __model__ = Game __schema__ = GameSchema() __schema_many__ = GameSchema(many=True) turn = Turn() def get_open_games(self): result = self.__model__.query.filter(Game.status == 'starting').all() response = self.__schema_many__.dump(result) return response.data def create_game(self, request, player): data = {'status': 'starting'} game = Game(**data) game.hosting = player db.session.add(game) self.__create_deck(game) self.__create_board(game) db.session.commit() result = self.__schema__.dump(game) return jsonify(result.data) def join_game(self, game, player): if not game: return "Game does not exist" if game.joining: return "Already Full" if game.hosting == player: return "Cannot Join your own game" game.joining = player game.status = "In Progress" game.turn = game.hosting self.__add_join_to_board(game) self.__initial_deal(game) self.__add_end_spaces(game) db.session.commit() return 'Join %d' % game.id def __create_deck(self, game): card_types = ['UL', 'U', 'UR', 'DR', 'D', 'DL'] deck = [] for x in xrange(0, 72): value = x % 6 card = dict(position=x, value=card_types[value], game=game) result = Card(**card) db.session.add(result) color = [''] for x in xrange(0, 12): direction = x % 6 card = dict(position=72 + x, value='P', direction=card_types[direction], game=game, color=direction, points=0) result = Card(**card) db.session.add(result) db.session.commit() # Kind of hacky, can be made better by calling all the cards in a game at once, # update in objects, then commit to the database for x in range(0, 84): switch = random.randint(0, 83) card1 = Card.query.filter_by(position=x).filter_by( game=game).first() card2 = Card.query.filter_by(position=switch).filter_by( game=game).first() card1.position = switch card2.position = x db.session.commit() def __create_board(self, game): for x in xrange(-5, 6): for y in xrange(-4, 5): if abs(y - x) < 5: space = BoardSpace(x_loc=x, y_loc=y, game=game) db.session.add(space) def __add_join_to_board(self, game): space1 = BoardSpace.get(-3, 1, game) space2 = BoardSpace.get(-4, -2, game) space3 = BoardSpace.get(-3, -4, game) Meeple.add_meeple(game, game.joining, space1) Meeple.add_meeple(game, game.joining, space2) Meeple.add_meeple(game, game.joining, space3) space4 = BoardSpace.get(3, -1, game) space5 = BoardSpace.get(4, 2, game) space6 = BoardSpace.get(3, 4, game) Meeple.add_meeple(game, game.hosting, space4) Meeple.add_meeple(game, game.hosting, space5) Meeple.add_meeple(game, game.hosting, space6) def __add_end_spaces(self, game): space1 = BoardSpace.get(5, 1, game) space2 = BoardSpace.get(5, 2, game) space3 = BoardSpace.get(5, 3, game) space4 = BoardSpace.get(5, 4, game) space1.player = game.joining space2.player = game.joining space3.player = game.joining space4.player = game.joining space5 = BoardSpace.get(-5, -1, game) space6 = BoardSpace.get(-5, -2, game) space7 = BoardSpace.get(-5, -3, game) space8 = BoardSpace.get(-5, -4, game) space5.player = game.hosting space6.player = game.hosting space7.player = game.hosting space8.player = game.hosting def __initial_deal(self, game): deck = game.deck.order_by(Card.position) for x in range(0, 14): if x % 2 == 0: deck[x].player = game.hosting else: deck[x].player = game.joining
#Start Battle! battle = Battle(pokemon1, pokemon2) def ask_command(pokemon): command = None while not command: # DO ATTACK -> attack 0 tmp_command = input("what should " + pokemon.name + " do?").split(" ") if len(tmp_command) == 2: try: if tmp_command[0] == DO_ATTACK and 0 <= int(tmp_command[1]): command = Command({DO_ATTACK: int(tmp_command[1])}) except Exception: pass return command while not battle.is_finished(): #First ask for command command1 = ask_command(pokemon1) command2 = ask_command(pokemon2) turn = Turn() turn.command1 = command1 turn.command2 = command2 if turn.can_start(): #Execute turn battle.execute_turn(turn) battle.print_current_status()
class Game(object): def __init__(self, playerList, sets): self.log = [] allCards = [] for Set in sets: allCards.extend(Set) gameCards = sample(allCards,10) ## gets 10 random cards from inluded sets numOfPlayers = len(playerList) self.supply = BaseSupply(gameCards,numOfPlayers) #print self.supply self.players = [Player(name,self.supply) for name in playerList] shuffle(self.players) self.playerDict = dict() self.playerStates = dict() for player in self.players: self.playerDict[player.name] = player self.playerStates[player.name]= PlayerState(player,self) self.firstTurn() def firstTurn(self): for player in self.players: self.playerDict[player.name] = player self.playerStates[player.name] = PlayerState(player, self) self.round = 1 self.currentPlayer = self.players.pop(0) self.firstPlayer = self.currentPlayer self.log.append("Round 1") self.currentTurn = Turn(self.currentPlayer, self.players, self.round, self.log, self) def nextTurn(self): self.currentTurn.cleanupPhase() if self.supply.gameOver(): self.log.append("The Game is Over!!") self.determineWinner() self.players.append(self.currentPlayer) self.currentPlayer = self.players.pop(0) if self.currentPlayer == self.firstPlayer: self.round += 1 self.log.append("Round %d" % (self.round)) self.currentTurn = Turn(self.currentPlayer, self.players, self.round, self.log, self) def determineWinner(self): winner = (None, 0) for player in self.players: vp = player.numOfVictoryPoints() if vp > winner[1]: winner = ([player], vp) elif vp == winner[1]: if winner[0]: winner = (winner[1].append(player),winner[1]) else: winner = ([player], vp) winners = '' for player in winner[0]: if player == winner[0][-1]: winners += player else: winners += player + " and " self.log.append("%s Just won with %d Victory Points" % (winners, winner[1])) for player in self.players: if player not in winner[0]: self.log.append("%s scored %d Victory Points" % (player.name, player.numOfVictoryPoints()))
def add_turn(self, player, card): turn = Turn(self.turn_number_generator + 1, player, card) # TODO: log the alternative? if not any(existing_turn == turn for existing_turn in self.turns): self.turn_number_generator += 1 self.turns.append(turn)
def startNewTurn(self): if self.isEnd(): raise Exception('State is at endpoint.') self.advanceOnmove() self.curTurn = Turn(self)
def _turn2(self): """ The second turn will be used from the rear end! """ return Turn(self.params, self.turn2_ang)
action="store_true") PARSER.add_argument( '--direction', help='Set to 1 for clockwise and -1 for anti-clockwise', type=int, default=1) PARSER.add_argument( '--seconds', help='How long must the car drive', type=int, default=1) PARSER.add_argument( '--speed', help='How fast must the car drive', type=int, default=1) ARGS = PARSER.parse_args() # LOGLEVEL = ARGS.loglevel DIRECTION = ARGS.direction DIRECTION = -1 # backward DRIVE_TIME = ARGS.seconds WAIT_TIME = ARGS.speed / float(1000) # set log level if ARGS.verbose: logging.getLogger().setLevel(logging.DEBUG) AMOVE = Move() AMOVE.drive_time = 2 AMOVE.run() ATURN = Turn() ATURN.drive_time = 2 ATURN.direction = -1 ATURN.run() AMOVE = Move() AMOVE.wait_time = 5 AMOVE.run()
def game(): scorecard = Scorecard() while "empty" in scorecard.values.values(): turn = Turn() turn.take_turn() scorecard.show_scorecard() while True: choice = raw_input("What would you like to take?") if choice == "quit": return if choice == "1s" and scorecard.values["1's"] != 'empty': print "You have already taken 1's" continue if choice == "1s": scorecard.take_1s(turn.dice_values) break if choice == "2s" and scorecard.values["2's"] != 'empty': print "You have already taken 2's" continue elif choice == "2s": scorecard.take_2s(turn.dice_values) break if choice == "3s" and scorecard.values["3's"] != 'empty': print "You have already taken 3's" continue elif choice == "3s": scorecard.take_3s(turn.dice_values) break if choice == "4s" and scorecard.values["4's"] != 'empty': print "You have already taken 4's" continue elif choice == "4s": scorecard.take_4s(turn.dice_values) break if choice == "5s" and scorecard.values["5's"] != 'empty': print "You have already taken 5's" continue elif choice == "5s": scorecard.take_5s(turn.dice_values) break if choice == "6s" and scorecard.values["6's"] != 'empty': print "You have already taken 6's" continue elif choice == "6s": scorecard.take_6s(turn.dice_values) break if choice == "3 of a kind" and scorecard.values[ "3 of a kind"] != 'empty': print "You have already taken 3 of a kind" continue elif choice == "3 of a kind": number = raw_input("Which number?") number = int(number) if turn.dice_values.count(number) < 3: print "You don't have 3 of that number" decision = raw_input( "Do you still want to take 3 of a kind, [y/n]?") if decision == "n": continue else: scorecard.no_three_of_a_kind() break else: scorecard.three_of_kind(turn.dice_values, number) break if choice == "4 of a kind" and scorecard.values[ "4 of a kind"] != 'empty': print "You have already taken 4 of a kind" continue elif choice == "4 of a kind": number = raw_input("Which number?") number = int(number) if turn.dice_values.count(number) < 4: print "You don't have 4 of that number" decision = raw_input( "Do you still want to take 4 of a kind, [y/n]?") if decision == "n": continue else: scorecard.no_four_of_a_kind() break else: scorecard.four_of_kind(turn.dice_values, number) break if choice == "low run" and scorecard.values["low run"] != 'empty': print "You have already taken low run" continue elif choice == "low run": scorecard.low_run(turn.dice_values) break if choice == "low run" and collections.Counter( turn.dice_values) == collections.Counter([1, 2, 4, 5, 3]): scorecard.low_run(turn.dice_values) break elif choice == "low run" and collections.Counter( turn.dice_values) != collections.Counter([2, 3, 4, 5, 1]): scorecard.no_low_run(turn.dice_values) break if choice == "high run" and scorecard.values["high run"] != 'empty': print "You have already taken high run" continue if choice == "high run" and collections.Counter( turn.dice_values) == collections.Counter([2, 3, 4, 5, 6]): scorecard.high_run(turn.dice_values) break elif choice == "high run" and collections.Counter( turn.dice_values) != collections.Counter([2, 3, 4, 5, 6]): scorecard.no_high_run(turn.dice_values) break if choice == "full house" and scorecard.values[ "full house"] != 'empty': print "You have already taken full house" continue if choice == "full house": countvalues = collections.Counter(turn.dice_values) if countvalues.values() == [2, 3] or countvalues.values() == [ 3, 2 ] or countvalues.values() == [5]: scorecard.full_house(turn.dice_values) break else: scorecard.no_full_house() break if choice == "sum" and scorecard.values["sum"] != 'empty': print "You have already taken sum" continue elif choice == "sum": scorecard.sum_of(turn.dice_values) break if choice == "yahtzee" and scorecard.values["yahtzee"] != 'empty': print "You have already taken yahtzee" continue elif choice == "yahtzee" and collections.Counter( turn.dice_values) == collections.Counter([6, 6, 6, 6, 6]): scorecard.yahtzee(turn.dice_values) break elif choice == "yahtzee" and collections.Counter( turn.dice_values) != collections.Counter([6, 6, 6, 6, 6]): scorecard.noyahtzee(turn.dice_values) break scorecard.show_scorecard() print "End of Game. Your final score is %s" % scorecard.total_score()
def do_turn(self, game, turns): turn = Turn(game, turns) return turn.do_turn()
def start_turn(self, command): """Create a new turn object with the given command.""" self.current_turn = Turn(command)