def start(self): strategies = [] strategies.extend(self.generate_random(10)) for j in range(0, 100): for strategy in strategies: strategy.score = 0 for i in range(0, 10): player = Player() player.strategy = strategy skip = True while player.play(): if not skip: moves = raw_input('Move? ') if moves == 'y': skip = True print 'Run %d score %d' % (i, player._score) strategy.score += player._score print 'Score %d' % strategy.score print 'Next strategy...' sorted_strategies = sorted(strategies, cmp=lambda x, y: cmp(x.score, y.score), reverse=True) print 'Best score: %d' % sorted_strategies[0].score print 'Second score: %d' % sorted_strategies[1].score print '\n' strategies = [sorted_strategies[0], sorted_strategies[1]] strategies.extend(self.breed(sorted_strategies[0], sorted_strategies[1], 2)) strategies.extend(self.generate_random(2)) strategies.append(self.mutate(strategies[4])) strategies.append(self.mutate(strategies[5])) print 'New Strategies...'
def createPlayer(self, name=None, word=None): if name == None: print ("Name is required") return None player = Player() player.createPlayer(name=name, word=word) self.players.append(player)
class Game: def __init__(self, strategy, doorsNumber, numDoorsWin): self.player = Player(strategy, doorsList = []) self.strategy = strategy self.doorsNumber = doorsNumber self.numDoorsWin = numDoorsWin def gamePreparing(self): for i in range(1, int(self.doorsNumber)+1): self.player.doorsList.append(Door()) for i in random.sample(self.player.doorsList, int(self.numDoorsWin)): i.status = 'win' def gameStart(self): self.player.chooseDoor() def playersDecision(self): temp = [] if self.strategy == 'changeable': for i in self.player.doorsList: if i.condition != 'opened' and i.playersChoice != 'choosed': #self.player.doorsList.remove(i) temp.append(i) self.player.doorsList = temp def isWin(self): for i in self.player.doorsList: if i.condition == 'closed' and i.playersChoice == 'choosed' and i.status == 'win': return True
def load(self): for key in itersplit(self.playerKeys, ','): player = Player(key, self) player.load() self.players.append(player) self.terrain.load(self.players)
def get_get_reponse(self, intent_request, session): data = { "card_title": "Get Request", "card_output": "Get card output", "request_name": "get", "should_end_session": False, "speech_output": "", "session_attributes": {}, } item_name = intent_request["intent"]["slots"]["Item"]["value"] session_attributes = session["attributes"] dungeon = Dungeon(session_attributes["dungeon_data"]) player = Player(session_attributes["player_data"]) pos = player.data["position"] if dungeon.item_is_available(item_name, pos): item = dungeon.take_item(item_name, pos) player.add_item(item) data["speech_output"] = "You take the " + item_name else: data["speech_output"] = "You cannot take the " + item_name session_attributes["player_data"] = player.data session_attributes["dungeon_data"] = dungeon.data data["session_attributes"] = session_attributes return data
def serve(request): p = Playlist() player = Player() doc = CGI.httpHeaders() doc += CGI.htmlHead({ 'style':['../playlist.css'] }) if request.command == "POST": form = request.form if form.has_key('addSongs'): for e in makeList(form.getvalue('song')): if e is not None: doc += addSong(p, e) elif form.has_key('addAlbums'): for e in makeList(form.getvalue('album')): if e is not None: doc += addAlbum(p, e) elif form.has_key('clear'): p.clear() elif form.has_key('clearAndStop'): p.clear() request.state.stop() player.stop() f = p.update() doc += playlistToHtml(f, p) doc += CGI.htmlTail() request.serve_string(doc)
def main(): """hack""" parser = SafeConfigParser() parser.read('config.ini') shots = parser.getint('shots', 'number_of_tryes') current_word = Word() category = current_word.random_category() user = Player() player = user.ask_for_name() con = mdb.connect('localhost', 'testuser', '1', 'hangman'); cur = con.cursor() with con: cur.execute("INSERT INTO player(player_name) VALUES('%s');" % (player)) file_name = "%s.log" % player logging.basicConfig(filename=file_name, level=logging.DEBUG, format='%(message)s') logging.info("USER:%s start the game and has %s wrong turns", player, shots ) logging.info("###### [word]:[hidden]:[guess]:[wrong_guess]:[right_guess]") word = current_word.random_word() with con: cur.execute("insert into game(currentWord) values('%s');" %(word)) print word play_fun = Game(word,player) play_fun.play()
def __init__(self, agent_filepath=""): Player.__init__(self) # Create the experience memory database if not os.path.exists(REPLAY_MEMORY_FILENAME): self.replay_memory = ReplayMemory() else: self.replay_memory = cPickle.load(open(REPLAY_MEMORY_FILENAME, 'r')) # Initialize the convolutional neural network self.network = MinecraftNet(agent_filepath) self.ae_network = FeatureNet() # Probability of selecting non-random action self.epsilon = STARTING_EPSILON # The total number of frames this agent has been trained on # through all the minibatch training self.frames_trained = 0 # Load old epsilon and frames learned values self.load() self.cnn_action_map = self.initActionMap() # The current and previous sequences of game frames and actions self.current_seq = None self.previous_seq = None self.previous_action = None # Event logging self.log = LogFile("run.log", True)
def __init__(self,gameDisplay,gameWidth,gameHeight,FPS): Player.__init__(self,gameDisplay, gameWidth, gameHeight,FPS) self.currentMotion = 0 self.currentWeapon = 1 self.x = 100 self.y = 100 self.playerSoundTime = 10
def serve(request): c = Collection() p = Playlist() player = Player() doc = CGI.httpHeaders() doc += CGI.htmlHead({"style": ["../playlist.css"]}) if request.command == "POST": form = request.form if form.has_key("addSongs"): for e in makeList(form.getvalue("song")): if e is not None: doc += addSong(p, c, e) elif form.has_key("addAlbums"): for e in makeList(form.getvalue("album")): if e is not None: doc += addAlbum(p, c, e) elif form.has_key("clear"): p.clear() elif form.has_key("clearAndStop"): p.clear() request.state.stop() player.stop() f = p.update() doc += playlistToHtml(f, p) doc += CGI.htmlTail() request.serve_string(doc)
def __init__(self, *args, **kwargs): Player.__init__(self, *args, **kwargs) self.cells = [] self.dir = 1 self.x = 40 self.y = 30 self.dead = False
class AmarokEventHandler: def __init__(self, state): self.__running = True; self.__player = Player() self.__state = state Dcop.call("player enableRandomMode false") def start(self): while self.__running: delay = 1 fd = sys.stdin.fileno() (r,w,e) = select.select( [fd], [], [], delay) for File in r: if File == fd: line = os.read(fd, 1024) self.__dispatch(line) def stop(self): self.__running = False def __dispatch(self, s): Debug.log("Event received: " + s) if s.find("engineStateChange: empty" ) >= 0: Debug.log("Playlist is empty!") if self.__state.isRunning(): Debug.log("Queuing random song") self.__player.playRandom() else: Debug.log("Not running") elif s.find("trackChange" ) >= 0: pl = Playlist() if not pl.isPlaying(): self.__player.playRandom()
def __init__(self): #Initialize all variables self.turn = 0 self.gameover = False self.numPlayers = 0 self.CONST_PLAYERCOUNT = 0 self.dealer = 0 self.players = [] self.deck = [] self.drawpile = [] self.midPile = [] self.deadPile = [] self.playerOne = Player() #playerOne.setName("Craig") assert type(self.playerOne) == type(Player()) self.playerTwo = Player() self.playerThree = Player() self.playerFour = Player() print "Name: %s" % self.playerOne.getName() self.setupGame()
class StreamPiControls: def __init__(self, btn_pwr, re_a, re_b, re_btn): self._volume = Volume() self._player = Player() self._rotary_encoder = RotaryEncoder(re_a, re_b, re_btn, self.re_callback, self.re_btn_callback) self._system = System() GPIO.setup(btn_pwr, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.add_event_detect(btn_pwr, GPIO.FALLING, callback=self.pwr_callback, bouncetime=200) def re_callback(self, direction, btn_pressed): if direction == RotaryEncoder.DIRECTION_CLOCKWISE: self._volume.volume_up() elif direction == RotaryEncoder.DIRECTION_COUNTERCLOCKWISE: self._volume.volume_down() def re_btn_callback(self): if(self._player.is_playing()): self._player.stop() else: self._player.play("http://icecast.omroep.nl/3fm-bb-mp3") def pwr_callback(self, channel): self._system.shutdown()
def create_player_dict (): """ This function populates player_dict for the players with their names as keys and their player object as values""" player_dict = {} player_file = open("passers.csv", "r") player_file.readline() punctuation = string.punctuation for line in player_file: line = line.strip() line = line.strip(punctuation) stats_list = line.split(",") full_name_str = stats_list[0] + " " + stats_list[1] playerObject = Player(stats_list[0], stats_list[1]) if full_name_str not in player_dict: player_dict[full_name_str] = [(playerObject)] else: player_dict[full_name_str].append(playerObject) # stats_list[0] first name, [1] last name, [2] position(QB), [3] team, # [4] year, [5] unimportant, [6] completions, [7] attempts, # [8] yardage, [9] touchdowns, [10] unimportant, [11] unimportant, # [12] interceptions playerObject.update(stats_list[3], stats_list[4], stats_list[6], \ stats_list[7], stats_list[8], stats_list[9], \ stats_list[12]) player_file.close() return player_dict
def main(): form = cgi.FieldStorage() c = Collection() p = Playlist() player = Player() CGI.httpHeaders() CGI.htmlHead({ 'style':['../playlist.css'] }) if os.environ['REQUEST_METHOD'] == "POST": if form.has_key('addSongs'): for e in makeList(form.getvalue('song')): if e is not None: addSong(p, c, e) elif form.has_key('addAlbums'): for e in makeList(form.getvalue('album')): if e is not None: addAlbum(p, c, e) elif form.has_key('clear'): p.clear() elif form.has_key('clearAndStop'): p.clear() player.stop() f = p.update() playlistToHtml(f, p) CGI.htmlTail()
def __init__(self): # 1) basic init pygame.init() self.size = self.width, self.height = 1200,800 self.black = 0,0,0 self.screen = pygame.display.set_mode(self.size) pygame.key.set_repeat(1,50) # 2) set up game objects self.Player1 = Player(self) #Player1 self.Player1.choosePlayer("player1.png") self.Player2 = Player(self) #Player2 self.Player2.choosePlayer("player2.png") self.laserList = [] #List of laser objects self.Victor = 0 #The winner of the game (1 or 2, or 0 if no winner yet) # This image is displayed to the user when the other player is yet to connect self.wait_image = None self.wait_rect = None # This is the scene in which the game is played on self.back_image = pygame.image.load("media/background.png") self.back_rect = self.back_image.get_rect() # Two different victory screens self.p1v_image = pygame.image.load("media/p1v.png") self.p1v_rect = self.p1v_image.get_rect() self.p2v_image = pygame.image.load("media/p2v.png") self.p2v_rect = self.p2v_image.get_rect()
def __init__(self): Player.__init__(self) self._role = "ContingencyPlanner" #役職名英名 #役職名 self._name = u"%2s 危機管理官" self._action_table = [u"", u"車/フェリー ", u"直行便 ", u"チャーター便 ", u"シャトル便 ", u"調査基地の設置 ", u"感染者の治療 ", u"知識の共有(受け取る) ", u"知識の共有(渡す) ", u"治療薬の発見 ", u"イベントカードの再利用 ", u"イベントカードの使用 "] self._reuse_ev_card = 0
class Game(object): isPlayer1Turn= True def __init__(self): self.player1 = Player("ATeam") self.player2 = Player("BTeam") def play(self): point = None while True: try: if(self.isPlayer1Turn): hit=self.player1.mygrid.check(self.player1.fleet,point) self.player2.enemygrid.update(point, hit) point = self.player1.takeAGuess() self.isPlayer1Turn = False else: hit = self.player2.mygrid.check(self.player2.fleet,point) self.player1.enemygrid.update(point, hit) point = self.player2.takeAGuess() self.isPlayer1Turn = True except GameOver: print(GameOver.value) if(self.isPlayer1Turn==True): print(self.player1.teamName+" won") else: print(self.player2.teamName+" won") break
def ServiceEntryPoint(self): lastProgressUpdate = datetime.today() player = Player() lastFile = None while (not xbmc.abortRequested): xbmc.sleep(1000) if xbmc.Player().isPlaying(): try: playTime = xbmc.Player().getTime() totalTime = xbmc.Player().getTotalTime() currentFile = xbmc.Player().getPlayingFile() addonSettings = xbmcaddon.Addon(id='service.nextup.notification') notificationtime = addonSettings.getSetting("autoPlaySeasonTime") if xbmcgui.Window(10000).getProperty("PseudoTVRunning") != "True": if (totalTime - playTime <= int(notificationtime) and (lastFile==None or lastFile!=currentFile)) and totalTime != 0: lastFile = currentFile self.logMsg("Calling autoplayback totaltime - playtime is %s" % (totalTime - playTime) , 2) player.autoPlayPlayback() self.logMsg("Netflix style autoplay succeeded.", 2) xbmc.sleep(1000) except Exception, e: self.logMsg("Exception in Playback Monitor Service: %s" % e) pass else: xbmc.sleep(5000)
def play(self, scope = None): scope = Scope(scope) scope['_USER_INDEX_'] = self.user_index assert self.scripts == [] and self.children == [] global_reporter = scope.lookup('global_reporter') if global_reporter: reporter = global_reporter.get_reporter() scope['reporter'] = reporter else: reporter = None try: if self.iteration_factory: self.before(scope) for i in range(self.iteration_count): # TODO: put _ITERATION_INDEX_ in iteration scope instead of user scope scope['_ITERATION_INDEX_'] = i iteration = self.iteration_factory.create() iteration.player = self.player Player.execute_here(self, iteration, scope) self.after(scope) else: try: for i in range(self.iteration_count): scope['_ITERATION_INDEX_'] = i self.children.append(self.player) Player.play(self, scope) finally: self.children = [] except Errors.TerminateUser, e: log.exception('User terminated because of %s' % e)
def play(self, scope = None): assert self.scripts == [] and self.children == [] self.children = [self.player] try: Player.play(self, scope) except Errors.TerminateIteration, e: log.exception('Iteration terminated because of %s' % e)
def ServiceEntryPoint(self): player = Player() monitor = xbmc.Monitor() lastFile = None while not monitor.abortRequested(): # check every 5 sec if monitor.waitForAbort(5): # Abort was requested while waiting. We should exit break if xbmc.Player().isPlaying(): try: playTime = xbmc.Player().getTime() totalTime = xbmc.Player().getTotalTime() currentFile = xbmc.Player().getPlayingFile() addonSettings = xbmcaddon.Addon(id='service.nextup.notification') notificationtime = addonSettings.getSetting("autoPlaySeasonTime") nextUpDisabled = addonSettings.getSetting("disableNextUp") == "true" if xbmcgui.Window(10000).getProperty("PseudoTVRunning") != "True" and not nextUpDisabled: if (totalTime - playTime <= int(notificationtime) and ( lastFile is None or lastFile != currentFile)) and totalTime != 0: lastFile = currentFile self.logMsg("Calling autoplayback totaltime - playtime is %s" % (totalTime - playTime), 2) player.autoPlayPlayback() self.logMsg("Netflix style autoplay succeeded.", 2) except Exception as e: self.logMsg("Exception in Playback Monitor Service: %s" % e) pass self.logMsg("======== STOP %s ========" % self.addonName, 0)
def __init__(self): self.merlin = Player(True, 'Merlin') self.percival = Player(True, 'Percival') self.vanilla = Player(True, 'Vanilla') self.morgana = Player(False, 'Morgana') self.assassin = Player(False, 'the Assassin') sortedPlayers = [self.merlin, self.percival, self.vanilla, self.morgana, self.assassin] self.players = [] while len(sortedPlayers) > 0: index = randint(0, len(sortedPlayers) - 1) player = sortedPlayers[index] del sortedPlayers[index] self.players.append(player) currentIndex = len(self.players) - 1 player.myIndex(currentIndex) if(player.getName() == 'Merlin'): self.percival.addKnown(currentIndex) if(player.getName() == 'Morgana'): self.percival.addKnown(currentIndex) self.assassin.addKnown(currentIndex) self.merlin.addKnown(currentIndex) if(player.getName() == 'the Assassin'): self.morgana.addKnown(currentIndex) self.merlin.addKnown(currentIndex) for player in self.players: print(player.getName()) self.rounds = [Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5)]
class Client: proxy = None screen = None mainView = None mapModel = None playerModel = None def __init__(self, proxy, screen): self.proxy = proxy self.screen = screen self.playerModel = Player(self.proxy) self.playerModel.initPlayer() self.mapModel = Map(self.playerModel) # create chat model chatView = ChatView(self.screen) mapView = MapView(self.screen, self.mapModel, self.playerModel) inventoryView = InventoryView(self.screen, self.playerModel) viewTuple = (chatView, mapView, inventoryView) self.mainView = MainView(viewTuple) def getMainView(self): return self.mainView
def GenerarPlayerData(self,nick): x = len(self.players) miColor = self.COLORS[x%self.TEAMS] player = Player(nick, 3, x/2, x%2, "SP_"+str(x)+"_"+miColor) player.setTeam(miColor) return player
def __init__(self): Player.__init__(self) self._role = "Dispatcher" #役職名英名 self._action_table = [u"", u"車/フェリー ", u"直行便 ", u"チャーター便 ", u"シャトル便 ", u"調査基地の設置 ", u"感染者の治療 ", u"知識の共有(受け取る) ", u"知識の共有(渡す) ", u"治療薬の発見 ", u"他プレイヤーの移動 ", u"イベントカードの使用 "] self._special_action_table = [u"", u"車/フェリー", u"直行便", u"チャーター便", u"シャトル便", u"他プレイヤーコマへの移動"] #役職名 self._name = u" 通信司令員"
def __init__(self): self.p = Player(savedPlayerJSON) #self.updatePlayer(self.p,True,0,0) if self.p.isDead(): self.p = Player("./json/newPlayerTemplate.json") self.trend = getTrend() #print self.trend self.scen = Scenario() self.scen.loadFromFile(savedScenJSON) if self.scen.finished: option = getReplies(self.p.lastID) self.followUpTweet(option) if option == 1: item = self.scen.finish1[1] exp = self.scen.finish1[2] health = self.scen.finish1[3] elif option ==2: item = self.scen.finish2[1] exp = self.scen.finish2[2] health = self.scen.finish2[3] else: item = self.scen.finish3[1] exp = self.scen.finish3[2] health = self.scen.finish3[3] self.updatePlayer(self.p,item,exp,health) tempEnviro = Environment(self.trend) tempEnviro.generateScenario(self.trend).saveScenario() self.scen = loadScenFromFile(savedScenJSON)
class BlackArturo(object): def __init__(self): self._player1 = Player('14', '7') self._player2 = Player('2', '9') @property def player1(self): return self._player1 @property def player2(self): return self._player2 def start(self): pass def get_players(self): return 2 def do_we_have_an_winner(self): if self._player1.get_points() == 21 or \ self._player2.get_points() == 21: return True return False
class AmarokEventHandler: def __init__(self, state): self.__running = True; self.__player = Player() self.__state = state def start(self): while self.__running: delay = 1 fd = sys.stdin.fileno() (r,w,e) = select.select( [fd], [], [], delay) for File in r: if File == fd: line = os.read(fd, 1024) self.__dispatch(line) def stop(self): self.__running = False def __dispatch(self, s): if s.find("engineStateChange: empty" ) >= 0: if self.__state.isRunning(): sys.stderr.write("Unknown notification: " + s + " -> ignoring\n") self.__player.playRandom() elif s.find("trackChange" ) >= 0: pl = Playlist() if not pl.isPlaying(): self.__player.playRandom() else: sys.stderr.write("Unknown notification: " + s + " -> ignoring\n")
init() # Инициализация pygame window = display.set_mode(WINDOW) # Создание окна display.set_caption("Dakota`s run") # Название окна screen = Surface(DISPLAY) # Создание видимой поверхности # Строка состояния info_string = Surface((640, 30)) # Шрифты font.init() inf_font = font.Font(None, 32) # Создание героя hero = Player(320, 1320) left = right = up = False # Создание уровня with open(LEVEL_1, 'r') as level1: level_mas = level1.read().split('\n') sprite_group = sprite.Group() sprite_group.add(hero) platforms = [] x = 0 y = 0 for row in level_mas: for col in row: if col == "1":
def start_server(self): print("Server listening.") print(HOST) while True: connection, address = self.server_socket.accept() print('[+] New connection from', str(address[0]), str(address[1])) player = Player() player.set_address(address) player.set_connection(connection) # self.players[PlayerType.Player1.value] = player message = "Welcome " + str( player.get_address()) + "\nPlease enter your name: " player.get_connection().send(message.encode()) message = player.get_connection().recv(1024).decode() if not message: print("Player may be disconnected. (while entering name)") player.get_connection().close() continue player.set_name(message) print("(", str(address[0]), str(address[1]), ") player's name is", player.get_name()) if len(self.players) >= 1: message = "At the moment the server is hosting " game_message = "" if self.game_type == GameType.TicTacToe.value: game_message = "the tic tac toe game " elif self.game_type == GameType.GuessingNumber.value: game_message = "guessing a number game " player.get_connection().send( (message + game_message + "\nIf you want to join " + self.players[PlayerType.Player1.value].get_name() + " insert " + str(self.game_type)).encode()) data = player.get_connection().recv(1024).decode() if not data: print("Lost connection - while choosing game mode") player.get_connection().close() continue game_mode_choice = int(data) if game_mode_choice == self.game_type: player.get_connection().send( ("Prepare for the match " + str(player.get_name())).encode()) self.players.append(player) else: player.get_connection().close() else: message = "Please choose a game :\n1 for Tic Tac Toe \n2 for Guess a number \n " player.get_connection().send(message.encode()) data = player.get_connection().recv(1024).decode() if not data: print("Lost connection - while choosing game mode") player.get_connection().close() #if len(self.players) > 0: # self.players.pop() continue self.game_type = int(data) player.get_connection().send( ("Prepare for the match " + str(player.get_name()) + "\nWaiting for opponents").encode()) self.players.append(player) if len(self.players) == 2: self.handle_server_state_transitions(ServerEvent.START_GAME)
def __init__(self, name): Player.__init__(self, name) self.strategy = Strategy() print(self.name + " follows the " + self.strategy.strategyName + " strategy.")
if turn == 1: turn = 2 else: turn = 1 lock.release() lock = threading.Lock() HOST = "" PORT = 6854 tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM) orig = (HOST, PORT) tcp.bind(orig) q = Queue() # loop para conectar os jogadores max 2 jogadores for i in range(1, 3): tcp.listen(1) connection, client = tcp.accept() print('Conectado por', client) if i == 1: p1 = Player("X", i) player1 = Conexoes(connection, p1) connection.send(p1.getSymbol().encode()) elif i == 2: p2 = Player("O", i) player2 = Conexoes(connection, p2) connection.send(p2.getSymbol().encode()) player1.start() player2.start()
def __init__(self, player_name, decks_used=4): self.players = [Player(player_name)] self.dealer = Dealer() self.number_of_decks = decks_used self.card_pool = CardPool(number_of_decks=decks_used) self.used_card_pool = []
class Game: def __init__(self): self.board = Board(ROWS, COLUMNS) self.gui = GUI(ROWS, COLUMNS, SIZE, self.board) self.rules = Rules() self.cursor = Cursor() self.player1 = Player(1) self.player2 = AIPlayer(2, self.rules, self.board) self.currentPlayer = self.assign_player() self.gameOver = False self.menuFlag = False def assign_player(self): a = random.randint(0, 1) if a == 0: self.gui.next_move_message(self.player1.get_id()) return self.player1 else: self.gui.next_move_message(self.player2.get_id()) return self.player2 def switch_players(self): if self.currentPlayer == self.player1: self.currentPlayer = self.player2 else: self.currentPlayer = self.player1 self.gui.next_move_message(self.currentPlayer.get_id()) def reset(self): self.menuFlag = False self.board.reset() def change_rules(self, rule): if rule == 1: self.rules = Rules() elif rule == 2: self.rules = DiagonalOnly() else: self.rules = RowsColumnsOnly() self.reset() def update_cursor(self, event): x = event.pos[0] y = event.pos[1] self.cursor.update(x, y) def mouse_motion(self): if self.gameOver is False and self.menuFlag is False: if self.gui.are_buttons_hovered(self.cursor.gety()): self.gui.buttons_hovered(self.cursor.getx()) else: self.gui.draw_gui(self.board) elif self.menuFlag: if self.gui.are_rules_hovered(self.cursor.getx(), self.cursor.gety()): self.gui.rules_hovered(self.cursor.getx(), self.cursor.gety()) else: self.gui.draw_gui(self.board) def move_made(self): if self.rules.winning_move(self.board.get_board(), self.currentPlayer.get_id(), self.board.get_columns(), self.board.get_rows()): self.gameOver = True self.gui.winning_move_message(self.currentPlayer.get_id()) elif self.board.is_full(): self.gui.draw_message() self.gameOver = True else: self.switch_players() #print(self.board.get_board()) def mouse_clicked(self): if self.gameOver is False and self.menuFlag is False: if self.gui.are_buttons_hovered(self.cursor.gety()): col = int(math.floor(self.cursor.getx() / self.gui.get_size())) if self.currentPlayer.make_move(self.board, col): self.move_made() else: self.gui.not_valid_loc_message(self.currentPlayer.get_id()) self.gui.draw_gui(self.board) elif self.menuFlag: if self.gui.are_rules_hovered(self.cursor.getx(), self.cursor.gety()): rule = self.gui.get_rule(self.cursor.getx(), self.cursor.gety()) self.change_rules(rule) self.gui.shut_rules() self.gameOver = self.menuFlag = False self.reset() if self.gui.reset_hovered(self.cursor.getx(), self.cursor.gety()): self.board.reset() self.assign_player() self.gameOver = self.menuFlag = False if self.gui.are_options_hovered(self.cursor.getx(), self.cursor.gety()): self.gui.options_hovered(self.menuFlag) self.menuFlag = not self.menuFlag self.gui.draw_gui(self.board) def start_game(self): while True: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() if self.currentPlayer.get_type() == "player": if event.type == pygame.MOUSEMOTION: self.update_cursor(event) self.mouse_motion() elif event.type == pygame.MOUSEBUTTONDOWN: self.update_cursor(event) self.mouse_clicked() elif self.currentPlayer.get_type() == "AI": if not self.gameOver and not self.menuFlag: if self.currentPlayer.make_move(self.board, 0): self.move_made() else: self.gui.not_valid_loc_message( self.currentPlayer.get_id()) self.gui.draw_gui(self.board) else: self.currentPlayer = self.player1
def main(): """ Main program """ WIDTH, HEIGHT = 800, 600 # Initialize pygame pygame.init() myfont = pygame.font.SysFont("monospace", 15) # Set screen dimensions screen = pygame.display.set_mode([WIDTH, HEIGHT]) # Create the player player = Player(50, 50) movingsprites = pygame.sprite.Group() movingsprites.add(player) # Initialize the game map levels = [] level = Level.Level1() levels.append(level) level = Level.Level2() levels.append(level) level = Level.Level3() levels.append(level) level = Level.Level4() levels.append(level) currentLevelNo = 0 currentLevel = levels[currentLevelNo] clock = pygame.time.Clock() quit = False # Main game loop to check user input while not quit: for event in pygame.event.get(): if event.type == pygame.QUIT: quit = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: player.changeSpeed(-5, 0) if event.key == pygame.K_RIGHT: player.changeSpeed(5, 0) if event.key == pygame.K_UP: player.changeSpeed(0, -5) if event.key == pygame.K_DOWN: player.changeSpeed(0, 5) if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT: player.changeSpeed(5, 0) if event.key == pygame.K_RIGHT: player.changeSpeed(-5, 0) if event.key == pygame.K_UP: player.changeSpeed(0, 5) if event.key == pygame.K_DOWN: player.changeSpeed(0, -5) # Game Logic player.move(currentLevel.wall_list, currentLevel.obsticles) if player.rect.x < -15: if currentLevelNo == 0: currentLevelNo = 3 currentLevel = levels[currentLevelNo] player.rect.x = 790 elif currentLevelNo == 3: currentLevelNo = 2 currentLevel = levels[currentLevelNo] player.rect.x = 790 player.rect.y = 285 elif currentLevelNo == 2: currentLevelNo = 1 currentLevel = levels[currentLevelNo] player.rect.x = 790 else: currentLevelNo = 0 currentLevel = levels[currentLevelNo] player.rect.x = 790 if player.rect.x > 801: if currentLevelNo == 0: currentLevelNo = 1 currentLevel = levels[currentLevelNo] player.rect.x = 0 elif currentLevelNo == 1: currentLevelNo = 2 currentLevel = levels[currentLevelNo] player.rect.x = 0 elif currentLevelNo == 2: currentLevelNo = 3 currentLevel = levels[currentLevelNo] player.rect.x = 0 player.rect.y = 425 else: currentLevelNo = 0 currentLevel = levels[currentLevelNo] player.rect.x = 0 screen.fill(BLACK) label = myfont.render("Level: %s" % (currentLevelNo + 1), 1, (255, 255, 0)) screen.blit(label, (25, 50)) movingsprites.draw(screen) currentLevel.wall_list.draw(screen) currentLevel.obsticles.draw(screen) pygame.display.flip() clock.tick(60) pygame.quit()
def turn(player_name): game_list_top = ['aces' , 'twos' , 'threes' , 'fours' , 'fives' , 'sixes'] game_list_top_values = [1,2,3,4,5,6] player = Player(player_name) dice1 = Roll() for index, item in enumerate(game_list_top): print ('-'*40) print (f'rolling for {item}') print ('-'*40) dice1.roll_dice() keep1 = dice1.keep_dice() dice1.reroll_dice(keep1) keep2 = dice1.keep_dice() roll3 = dice1.reroll_dice(keep2) dice1.forced_keep(roll3) final_roll_collection = dice1.get_kept_dice() print (f'final roll collection: {final_roll_collection}') top_score = dice1.single_values(final_roll_collection,game_list_top_values[index]) player.add_rolled(item, top_score) player.add_top_score(top_score) bottom_score = dice1.get_bottom_score(final_roll_collection) player.add_bottom_score(bottom_score) player.add_top_bonus() player.add_bottom_bonus() player.add_total_score() player.print_scoreboard() return player.get_total_score()
class MainView(View): def __init__(self): super().__init__() self.time = 0 self.last_click = -1 self.last_start = -1 self.player = Player() self.enemy = Enemy() self.dialog_box = DialogBox() self.background = load_texture(MAIN_PIC) self.sprite_manager = SpriteManager() self.set_buttons() self.sprite_manager.setup() self.enemy.setup() def set_buttons(self): for i in range(SHIPS_COUNT): button = Button(BUTTON_X, BUTTON_Y[i], BUTTON_WIDTH[i], BUTTON_HEIGHT, SHIPS_NAME[i] + '\n' + str(SHIPS_COST[i]) + '$', SHIPS_NAME[i], BUTTON_FONT_SIZE) self.button_list.append(button) self.button_list.append(self.dialog_box.supply_button) self.button_list.append(self.dialog_box.weapon_button) self.button_list.append(self.dialog_box.go_button) def on_draw(self): start_render() draw_lrwh_rectangle_textured(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, self.background) for button in self.button_list: button.draw() self.dialog_box.draw() self.sprite_manager.draw_sprites() self.player.draw() def on_update(self, delta_time): new_ship = self.enemy.on_update(delta_time, self.sprite_manager.game_state()) if new_ship is not None: self.sprite_manager.add_enemy_ship(new_ship) self.sprite_manager.update(delta_time) self.player.money_increase(self.sprite_manager.player_fight_benefit()) self.enemy.money_increase(self.sprite_manager.enemy_fight_benefit()) for i in range(SHIPS_COUNT): if self.button_list[i].pressed: self.dialog_box.curr = i self.dialog_box.update() self.update_buttons(delta_time) self.time += delta_time status = self.sprite_manager.check_end_game() if status != 0: final_view = DefeatView() if status == 1 else WinView() self.window.show_view(final_view) def clone(self, number: int): self.player.set_builder(number) fighter = self.player.clone() if self.dialog_box.weapon_button.checked: fighter = WeaponDecorator(fighter) if self.dialog_box.supply_button.checked: fighter = SupplyDecorator(fighter) if self.player.money < fighter.get_cost(): return fighter.center_x = PLAYER_LOCATION_X fighter.center_y = PLAYER_LOCATION_Y fighter.change_x = FIGHTERS_SPEED fighter.side = 'player' self.sprite_manager.add_ship(fighter) self.player.money_decrease(fighter.cost) def lock_buttons(self, button): button.locked = True self.last_click = self.time def update_buttons(self, delta_time): if self.dialog_box.supply_button.pressed and self.time > self.last_click + TIME_DELAY * delta_time: self.last_click = self.time self.dialog_box.supply_button.checked = not self.dialog_box.supply_button.checked if self.dialog_box.weapon_button.pressed and self.time > self.last_click + TIME_DELAY * delta_time: self.last_click = self.time self.dialog_box.weapon_button.checked = not self.dialog_box.weapon_button.checked if self.dialog_box.go_button.pressed and not self.dialog_box.go_button.checked: self.clone(self.dialog_box.curr) self.dialog_box.go_button.checked = True self.dialog_box.supply_button.checked = False self.dialog_box.weapon_button.checked = False self.last_start = self.time if self.time > self.last_start + BUTTON_DELAY: self.dialog_box.go_button.checked = False if SHIPS_COST[self.dialog_box.curr] > self.player.money: self.dialog_box.go_button.locked = True else: self.dialog_box.go_button.locked = False if SHIPS_COST[self.dialog_box.curr] + EXTRA_SUPPLY_COST > self.player.money or \ self.dialog_box.weapon_button.checked and \ SHIPS_COST[self.dialog_box.curr] + EXTRA_WEAPON_COST + EXTRA_SUPPLY_COST > self.player.money: self.dialog_box.supply_button.locked = True else: self.dialog_box.supply_button.locked = False if SHIPS_COST[self.dialog_box.curr] + EXTRA_WEAPON_COST > self.player.money or \ self.dialog_box.supply_button.checked and \ SHIPS_COST[self.dialog_box.curr] + EXTRA_WEAPON_COST + EXTRA_SUPPLY_COST > self.player.money: self.dialog_box.weapon_button.locked = True else: self.dialog_box.weapon_button.locked = False
#!/usr/bin/env python3 from Actions import Actions from Player import Player from Util import sendAction, recvAction from Tournament import Tournament from threading import Thread from time import sleep import asyncio import websockets tournaments = {"test": Tournament(Player("host", None))} async def handleConnection(websocket, path): global tournaments action = await recvAction(websocket) while action["type"] != Actions.JOIN_TOURNAMENT.value \ or action["tournamentId"] not in tournaments: await sendAction(websocket, Actions.INVALID_TOURNAMENT) action = await recvAction(websocket) await sendAction(websocket, Actions.ASK_NAME) nameA = await recvAction(websocket) while nameA["type"] != Actions.SET_NAME.value \ or tournaments[action["tournamentId"]].isPlayerNameTaken(nameA["name"]): await sendAction(websocket, Actions.INVALID_NAME) nameA = await recvAction(websocket) tournaments[action["tournamentId"]].addPlayer( Player(nameA["name"], websocket))
def build_full_map(r=100): my_map = Map() gradient_of_randomness = [r, r, r, r, r, r] random.shuffle(gradient_of_randomness) Player1 = Player('ai_player', my_map, gradient_of_randomness[1]) Player2 = Player('player2', my_map, gradient_of_randomness[1]) Player3 = Player('player3', my_map, gradient_of_randomness[2]) Player4 = Player('player4', my_map, 100) Player5 = Player('player5', my_map, 100) Player6 = Player('player6', my_map, 100) Player1.resetPlayerIndex() Player_list = my_map.getPlayerList() #Countries #North America alaska = Country('alaska', my_map, 1, 9, (0, 9, 5)) NWterritory = Country('NWterritory', my_map, 2, 8, (0, 9, 5)) alberta = Country('alberta', my_map, 1, 7, (0, 9, 5)) greenland = Country('greenland', my_map, 3, 8, (0, 9, 5)) ontario = Country('ontario', my_map, 2, 7, (0, 9, 5)) quebec = Country('quebec', my_map, 3, 7, (0, 9, 5)) WUS = Country('WUS', my_map, 1, 6, (0, 9, 5)) EUS = Country('EAS', my_map, 2, 6, (0, 9, 5)) central_america = Country('central_america', my_map, 1, 5, (0, 9, 5)) #NA Neighbours my_map.makeNeighbours(alaska, NWterritory) my_map.makeNeighbours(alaska, alberta) my_map.makeNeighbours(alberta, NWterritory) my_map.makeNeighbours(greenland, NWterritory) my_map.makeNeighbours(greenland, quebec) my_map.makeNeighbours(greenland, ontario) my_map.makeNeighbours(alberta, ontario) my_map.makeNeighbours(alberta, WUS) my_map.makeNeighbours(ontario, WUS) my_map.makeNeighbours(ontario, EUS) my_map.makeNeighbours(quebec, EUS) my_map.makeNeighbours(WUS, EUS) my_map.makeNeighbours(WUS, central_america) my_map.makeNeighbours(EUS, central_america) #South America venezuela = Country('venezuela', my_map, 1, 4, (1, 4, 2)) peru = Country('peru', my_map, 1, 3, (1, 4, 2)) brazil = Country('brazil', my_map, 2, 3, (1, 4, 2)) argentina = Country('argentina', my_map, 1, 2, (1, 4, 2)) my_map.makeNeighbours(central_america, venezuela) my_map.makeNeighbours(venezuela, peru) my_map.makeNeighbours(venezuela, brazil) my_map.makeNeighbours(argentina, peru) my_map.makeNeighbours(argentina, brazil) #Europe iceland = Country('iceland', my_map, 4, 8, (2, 7, 5)) scandinavia = Country('scandinavia', my_map, 5, 8, (2, 7, 5)) ukraine = Country('ukraine', my_map, 6, 7, (2, 7, 5)) GB = Country('GB', my_map, 4, 7, (2, 7, 5)) NEU = Country('NEU', my_map, 5, 7, (2, 7, 5)) WEU = Country('WEU', my_map, 4, 6, (2, 7, 5)) SEU = Country('SEU', my_map, 5, 6, (2, 7, 5)) my_map.makeNeighbours(iceland, greenland) my_map.makeNeighbours(iceland, scandinavia) my_map.makeNeighbours(iceland, GB) my_map.makeNeighbours(scandinavia, GB) my_map.makeNeighbours(scandinavia, NEU) my_map.makeNeighbours(scandinavia, ukraine) my_map.makeNeighbours(GB, NEU) my_map.makeNeighbours(GB, WEU) my_map.makeNeighbours(NEU, ukraine) my_map.makeNeighbours(NEU, WEU) my_map.makeNeighbours(NEU, SEU) my_map.makeNeighbours(ukraine, SEU) #Africa north_africa = Country('north_africa', my_map, 4, 4, (3, 6, 3)) egypt = Country('egypt', my_map, 5, 4, (3, 6, 3)) east_africa = Country('east_africa', my_map, 5, 3, (3, 6, 3)) congo = Country('congo', my_map, 4, 3, (3, 6, 3)) south_africa = Country('south_africa', my_map, 4, 2, (3, 6, 3)) madagascar = Country('madagascar', my_map, 5, 2, (3, 6, 3)) my_map.makeNeighbours(north_africa, brazil) my_map.makeNeighbours(north_africa, SEU) my_map.makeNeighbours(north_africa, WEU) my_map.makeNeighbours(egypt, SEU) my_map.makeNeighbours(north_africa, egypt) my_map.makeNeighbours(north_africa, east_africa) my_map.makeNeighbours(north_africa, congo) my_map.makeNeighbours(egypt, east_africa) my_map.makeNeighbours(east_africa, congo) my_map.makeNeighbours(east_africa, south_africa) my_map.makeNeighbours(east_africa, madagascar) my_map.makeNeighbours(congo, south_africa) my_map.makeNeighbours(south_africa, madagascar) #Asia middle_east = Country('middle_east', my_map, 6, 5, (4, 12, 7)) afghanistan = Country('afghanistan', my_map, 7, 6, (4, 12, 7)) ural = Country('ural', my_map, 7, 7, (4, 12, 7)) siberia = Country('siberia', my_map, 8, 7, (4, 12, 7)) yakutsk = Country('yakutsk', my_map, 7, 8, (4, 12, 7)) kamchatka = Country('kamchatka', my_map, 9, 9, (4, 12, 7)) india = Country('india', my_map, 7, 5, (4, 12, 7)) china = Country('china', my_map, 8, 6, (4, 12, 7)) mongolia = Country('mongolia', my_map, 9, 7, (4, 12, 7)) irkutsk = Country('irkutsk', my_map, 8, 8, (4, 12, 7)) japan = Country('japan', my_map, 9, 8, (4, 12, 7)) siam = Country('siam', my_map, 8, 5, (4, 12, 7)) my_map.makeNeighbours(middle_east, egypt) my_map.makeNeighbours(middle_east, east_africa) my_map.makeNeighbours(middle_east, SEU) my_map.makeNeighbours(middle_east, ukraine) my_map.makeNeighbours(middle_east, afghanistan) my_map.makeNeighbours(middle_east, india) my_map.makeNeighbours(afghanistan, ukraine) my_map.makeNeighbours(afghanistan, ural) my_map.makeNeighbours(afghanistan, india) my_map.makeNeighbours(afghanistan, china) my_map.makeNeighbours(ural, ukraine) my_map.makeNeighbours(ural, siberia) my_map.makeNeighbours(ural, china) my_map.makeNeighbours(siberia, yakutsk) my_map.makeNeighbours(siberia, irkutsk) my_map.makeNeighbours(siberia, mongolia) my_map.makeNeighbours(siberia, china) my_map.makeNeighbours(yakutsk, irkutsk) my_map.makeNeighbours(irkutsk, kamchatka) my_map.makeNeighbours(irkutsk, mongolia) my_map.makeNeighbours(kamchatka, alaska) my_map.makeNeighbours(kamchatka, yakutsk) my_map.makeNeighbours(kamchatka, mongolia) my_map.makeNeighbours(kamchatka, japan) my_map.makeNeighbours(mongolia, japan) my_map.makeNeighbours(mongolia, china) my_map.makeNeighbours(china, india) my_map.makeNeighbours(china, siam) my_map.makeNeighbours(india, siam) #Australia indonesia = Country('indonesia', my_map, 8, 4, (5, 4, 2)) new_guinea = Country('new_guinea', my_map, 9, 4, (5, 4, 2)) western_australia = Country('western_australia', my_map, 8, 3, (5, 4, 2)) eastern_australia = Country('eastern_australia', my_map, 9, 3, (5, 4, 2)) my_map.makeNeighbours(indonesia, siam) my_map.makeNeighbours(indonesia, western_australia) my_map.makeNeighbours(indonesia, new_guinea) my_map.makeNeighbours(western_australia, new_guinea) my_map.makeNeighbours(western_australia, eastern_australia) my_map.makeNeighbours(eastern_australia, new_guinea) """ ireland = Country('ireland', my_map,5,5,(1,2,3)) scotland = Country('scotland',my_map,7,5,(0,2,10)) wales = Country('wales',my_map,7,6,(2,2,3)) france = Country('france',my_map,6,7,(2,2,3)) england = Country('england', my_map,6,6,(0,2,10)) ni = Country('NI', my_map,5,6,(1,2,3)) """ Country_list = my_map.nodes() """ my_map.makeNeighbours(england,ireland) """ index_list = [0, 1, 2, 3, 4, 5] random.shuffle(index_list) counter = 0 while counter < len(Country_list): if counter % len(index_list) == 0: random.shuffle(index_list) Player_list[index_list[counter % len(index_list)]].addCountry( Country_list[counter]) counter += 1 #Player1.addCountry(ireland) #Player1.addCountry(ni) #Player2.addCountry(england) #Player3.addCountry(scotland) #Player3.addCountry(wales) #Player2.addCountry(france) #for node in my_map.nodes(): # node.setSoldiers(random.randint(1,6)) for i in range(28): for player in Player_list: player.place_random_soldier() return my_map
from Player import Player from AI import play from chessGP import fileToGPTree randomTree = fileToGPTree('./solutions/randomSolution.txt') stockfishTree = fileToGPTree('./solutions/stockfishSolution.txt') randomPlayer = Player('custom', randomTree.pickChessMove) stockfishPlayer = Player('custom', stockfishTree.pickChessMove) win = 0 draw = 0 loss = 0 for i in range(25): resultBoard = play(stockfishPlayer, randomPlayer) result = resultBoard.result() print(result) if result == '1-0': win += 1 elif result == '0-1': loss += 1 else: draw += 1 print("White: Stockfish, Black: Random") print(win, draw, loss) win = 0 draw = 0 loss = 0 for i in range(25): resultBoard = play(randomPlayer, stockfishPlayer) result = resultBoard.result()
from Player import Player from Enemy import Troll, Vampire, VampireKing tim = Player('Tim') ugly_troll = Troll('Urg') another_troll = Troll('Ug') first_vampire = Vampire('Dracula') print(ugly_troll) print(another_troll) print(first_vampire) first_vampire.take_damage(10) print(first_vampire) vamp_king = VampireKing('KingDracula') print(vamp_king) while vamp_king.alive: vamp_king.take_damage(12) print(vamp_king) print('*' * 40)
x = str(myString) parsed = True # we only get here if the previous line didn't throw an exception if (parsed == True): fileinput.close() except ValueError: print 'Invalid value! Please enter standard text.' break if __name__ == '__main__': print("Please enter your name") for line in fileinput.input(): validateStringInput(line) myString = str(line) player = Player(myString, 1) fileinput.close() print("How many rounds do you want to play?") for line in fileinput.input(): validateIntInput(line) game = Game(line) fileinput.close() ##test and write an order to a rfid print("Test now your Raspi and your RFID reader") nfc = NFC() ##testdata firstOrder = True amount = 5
def __init__(self, name=None): Player.__init__(self, name) self.taken_rounds = 0 self.taken_cards_pack = set() pass
def __init__(self, map): Player.__init__(self, map) self.searchAlgorithm = 0
class State: def __init__(self): self.deck = Deck() self.allcards = self.deck.all_cards self.player1 = Player(self.deck, "Player1") self.player2 = Player(self.deck, "Player2") self.used_cards = [] def deal_cards(self): first, second = self.deck.deal_cards() self.player1.set_cards(first) self.player2.set_cards(second) def test(self): self.deal_cards() main_card = self.deck.get_first_card() # for card in self.deck.deck: # print(card) card = self.player1.current_cards[0] # better_cards_in_game(card,self.used_cards,self.player1.current_cards,self.allcards, main_card) # print(main_card) # check_main_power(main_card,self.used_cards,self.player1.current_cards,self.allcards) def make_move(self): print("") def game(self): self.deal_cards() main_card = self.deck.get_first_card() first = self.player1 second = self.player2 # monte = MonteCarlo(self.player1, self.player2,1,main_card,self.deck) # monte.check_moves() while True: player1_pick = input("It's " + first.name + " turn to play,\n(Main card is " + str(main_card) + ") select number from 1 to 3,\n" + str(first.current_cards) + " \nwhich card in deck you want to play: ") card1_playing = first.throw_card(int(player1_pick)) first.card_down = card1_playing print(card1_playing) player2_pick = input("It's " + second.name + " turn to play,\n(Main card is " + str(main_card) + ") select number from 1 to 3,\n" + str(second.current_cards) + "\n which card in deck you want to play: ") card2_playing = second.throw_card(int(player2_pick)) second.card_down = card2_playing print(card2_playing) if card1_playing.color == main_card.color and card2_playing.color != main_card.color: print(first.name + " win the turn.") first.add_to_loot(card1_playing, card2_playing) print(first.count_score() + "\n\n") elif card1_playing.color != main_card.color and card2_playing.color == main_card.color: print(second.name + " win the turn.") second.add_to_loot(card1_playing, card2_playing) print(second.count_score() + "\n\n") tmp = first first = second second = tmp elif card1_playing.color == main_card.color and card2_playing.color == main_card.color: if card1_playing.power > card2_playing.power: print(first.name + " win the turn.") first.add_to_loot(card1_playing, card2_playing) print(first.count_score() + "\n\n") elif card1_playing.power < card2_playing.power: print(second.name + " win the turn.") second.add_to_loot(card1_playing, card2_playing) print(second.count_score() + "\n\n") tmp = first first = second second = tmp elif card1_playing.color != main_card.color and card2_playing.color != main_card.color: if card1_playing.color != card2_playing.color: print(first.name + " win the turn.") first.add_to_loot(card1_playing, card2_playing) print(first.count_score() + "\n\n") elif card1_playing.color == card2_playing.color: if card1_playing.power > card2_playing.power: print(first.name + " win the turn.") first.add_to_loot(card1_playing, card2_playing) print(first.count_score() + "\n\n") elif card1_playing.power < card2_playing.power: print(second.name + " win the turn.") second.add_to_loot(card1_playing, card2_playing) print(second.count_score() + "\n\n") tmp = first first = second second = tmp self.used_cards.append(card1_playing) self.used_cards.append(card2_playing) if self.deck.check_if_deck_empty() is False: card1, card2 = self.deck.deal_cards_on_turn() first.pick_up_card(card1) second.pick_up_card(card2) if second.check_hand(): break print("\n\n") print(first.name + " has collected " + first.count_score() + " points.") print(second.name + " has collected " + second.count_score() + " points.") print("\n") if first.score > second.score: print(first.name + " has won the game because he collected more points!") elif first.score < second.score: print(second.name + " has won the game because he collected more points!") else: print("Game has finished with tied score!") def check_cards(self, card1_playing, card2_playing, main_card): if card1_playing.color == main_card.color and card2_playing.color != main_card.color: return True elif card1_playing.color != main_card.color and card2_playing.color == main_card.color: return False elif card1_playing.color == main_card.color and card2_playing.color == main_card.color: if card1_playing.power > card2_playing.power: return True elif card1_playing.power < card2_playing.power: return False elif card1_playing.color != main_card.color and card2_playing.color != main_card.color: if card1_playing.color != card2_playing.color: return True elif card1_playing.color == card2_playing.color: if card1_playing.power > card2_playing.power: return True elif card1_playing.power < card2_playing.power: return False # def random_game(self, move): # self.deal_cards() # main_card = self.deck.get_first_card() # first = self.player1 # second = self.player2 # # random = move.move # while True: # # player1_pick = input("It's " + first.name + " turn to play,\n(Main card is " + str( # # main_card) + ") select number from 1 to 3,\n" # # + str(first.current_cards) + " \nwhich card in deck you want to play: ") # card1_playing = first.throw_card(int(random)) # # print(card1_playing) # # player2_pick = input("It's " + second.name + " turn to play,\n(Main card is " + str( # # main_card) + ") select number from 1 to 3,\n" # # + str(second.current_cards) + "\n which card in deck you want to play: ") # # player2_pick = randint(1, len(second.current_cards)) # # card2_playing = second.throw_card(int(player2_pick)) # print(card2_playing) # # if card1_playing.color == main_card.color and card2_playing.color != main_card.color: # print(first.name + " win the turn.") # first.add_to_loot(card1_playing, card2_playing) # print(first.count_score() + "\n\n") # # elif card1_playing.color != main_card.color and card2_playing.color == main_card.color: # print(second.name + " win the turn.") # second.add_to_loot(card1_playing, card2_playing) # print(second.count_score() + "\n\n") # # tmp = first # first = second # second = tmp # # elif card1_playing.color == main_card.color and card2_playing.color == main_card.color: # if card1_playing.power > card2_playing.power: # print(first.name + " win the turn.") # first.add_to_loot(card1_playing, card2_playing) # print(first.count_score() + "\n\n") # # elif card1_playing.power < card2_playing.power: # print(second.name + " win the turn.") # second.add_to_loot(card1_playing, card2_playing) # print(second.count_score() + "\n\n") # # tmp = first # first = second # second = tmp # # elif card1_playing.color != main_card.color and card2_playing.color != main_card.color: # if card1_playing.color != card2_playing.color: # print(first.name + " win the turn.") # first.add_to_loot(card1_playing, card2_playing) # print(first.count_score() + "\n\n") # # elif card1_playing.color == card2_playing.color: # if card1_playing.power > card2_playing.power: # print(first.name + " win the turn.") # first.add_to_loot(card1_playing, card2_playing) # print(first.count_score() + "\n\n") # # elif card1_playing.power < card2_playing.power: # print(second.name + " win the turn.") # second.add_to_loot(card1_playing, card2_playing) # print(second.count_score() + "\n\n") # # tmp = first # first = second # second = tmp # # if self.deck.check_if_deck_empty() is False: # card1, card2 = self.deck.deal_cards_on_turn() # first.pick_up_card(card1) # second.pick_up_card(card2) # if second.check_hand(): # break # # game = GameManager() # game.test() # print(game.player1.current_cards)
def __init__(self): #initializing the player player = Player() #variable to hold whether the game is over gameOver = False #here we could ask for user input for board dimensions, but a 5x5 grid seemed appropriate #all you would need to do is have #populating the neighborhood size right now it is a 5 by 5 grid, but easily modified #list comprehension is awesome! neighborhood = [[0 for y in range(5)] for x in range(5)] #variable to keep track of the number of monsters in the entire game monster_num = 0 #populating the neighborhood and getting the number of monsters in the game for i in range(len(neighborhood)): for j in range(len(neighborhood[i])): neighborhood[i][j] = House() monster_num = monster_num + neighborhood[i][j].monster_count #random start location stored as a tuple location = (random.randint(0, len(neighborhood) - 1), random.randint(0, len(neighborhood) - 1)) #printing initial message print( "----------------------------------------------------\n On the eve of Halloween, you wake up and realize that your entire neighborhood has been took over by Monsters! You must take your candy and save the neighborhood by killing each monster! Best of luck... you'll need it...\n --------------------------------------------------- " ) print("You have this much HP: " + str(player.hp)) print("And right now you are at this location: " + str(location)) playerName = input("What is your Name?") print("Welcome... Play at your own risk...") #Counting the turns of the game turnCounter = -1 #main game while gameOver != True: turnCounter = turnCounter + 1 #print information for each turn print("\n\n\n\n\n") print("Turn: " + str(turnCounter)) print("Name: " + playerName) print("HP: " + str(player.hp)) print("location: " + str(location)) print("Monsters in this house: " + str(neighborhood[location[0] - 1][location[1] - 1].monster_count)) print("All Monsters left: " + str(monster_num)) #checking gameOver Conditions if monster_num <= 0: print( "CONGRATULATIONS YOU SURVIVED AND SAVED THE NEIGHBORHOOD... At the expense of your candy go ahead and type Yay!" ) gameOver = True if player.hp < 0: print("You perished... It's not like we didn't warn you...") gameOver = True #taking in commands direction = input("Enter a Direction") #list off some help if direction == "help": print( "1. go [north,south,east,west]-- Allows you to traverse the neighborhood houses... at your own risk" ) print( "2. look around-- looks around the house you are in and examine the monsters in that house" ) print("3. look at candy-- allows you to check your inventory") print( "4. attack-- Allows you to start attacking the monsters in the house you are given, attacking a person heals you, but they are not damaged (think of them as checkpoints), so don't waste your nerd bombs on them" ) print( "5. exit-- Let's you exit the game, but do you really want to leave?" ) #quitting the game elif direction.lower() == "exit": print("How could you leave us?") print("-----------------GAME OVER--------------------------") gameOver = True #go North elif direction.lower().lstrip() == "go north": if location[0] != 0: location = (location[0] - 1, location[1]) else: print("Sorry you can't go North out of this neighborhood") #go South elif direction.lower().lstrip() == "go south": if location[0] != len(neighborhood): location = (location[0] + 1, location[1]) else: print("Sorry you can't go South out of this neighborhood") #go East elif direction.lower().lstrip() == "go east": if location[1] != len(neighborhood): location = (location[0], location[1] + 1) else: print("Sorry you can't go South out of this neighborhood") #Go West elif direction.lower().lstrip() == "go west": if location[1] != 0: location = (location[0], location[1] - 1) else: print("Sorry you can't go West out of this neighborhood") #allows you to see the monsters in the house elif direction.lower().lstrip() == "look around": counter = 0 print("You see: ") for i in neighborhood[location[0]][location[1]].monster_list: counter = counter + 1 print( str(counter) + "-" + str(i.Name) + " --HP: " + str(i.Health)) #checking inventory elif direction.lower().lstrip() == "look at candy": counter = 0 for i in player.weapons: counter = counter + 1 print( str(counter) + "-" + str(i.Name) + " --qty: " + str(i.qty)) #attacking Monsters logic elif direction.lower().lstrip() == "attack": counter = 0 #print out monster_list for conveniece :) for i in neighborhood[location[0]][location[1]].monster_list: print( str(counter) + "-" + str(i.Name) + " --" + str(i.Health)) counter = counter + 1 directed_attack = input("Which index would you like to attack") if directed_attack == exit: pass #checking valid input for the list player is supposed to enter an index in order to do a lookup #One problem here is I could not find a way to check a string being an int without casting it as an int beforehand which is a problem :( elif type(int(directed_attack)) is int and int( directed_attack) < len( neighborhood[location[0]][location[1]].monster_list ) and int(directed_attack) >= 0: counter = 0 print("\n\n\n\n\n") for i in player.weapons: print( str(counter) + "-" + str(i.Name) + " --qty: " + str(i.qty)) counter = counter + 1 #wanting to know the index of what item the player wants attackItem = input( "Enter an index for which weapon you want to use: ") if type(int(attackItem)) is int and int(attackItem) < len( player.weapons) and int( attackItem) >= 0 and player.weapons[int( attackItem)].qty > 0: #calling getAttackedBy on the monster that the player wants to attack neighborhood[location[0]][location[1]].monster_list[ int(directed_attack)].getAttackedBy( player.useItem(int(attackItem)), player.weapons[int(attackItem)].Name) #The player used a weapon, so we now have 1 less of that item player.weapons[int(attackItem)].qty = player.weapons[ int(attackItem)].qty - 1 #getting the damage appropriate for the monster damage = neighborhood[location[0]][location[ 1]].monster_list[int(directed_attack)].Attack() #changing print message depending on whether or not the monster is a person or not if neighborhood[location[0]][location[1]].monster_list[ int(directed_attack)].Name == "Person": #in case they want to get healed different message print( "The person finds you and gives you some orange juice: You feel better: +" + str(damage * -1) + " HP") else: #printing message for monster attacks print("The " + neighborhood[location[0]][location[1]]. monster_list[int(directed_attack)].Name + " Leaps towards you and attacks you for " + str(damage) + " damage") #updating player health player.hp = player.hp - damage #checking if monster dies, which then we wnat to notify the house and then that will mean that we have 1 less monster if neighborhood[location[0]][location[1]].monster_list[ int(directed_attack)].isDead(): neighborhood[location[0]][location[1]].update( int(directed_attack)) monster_num = monster_num - 1 else: print("Please enter a correct number next time") else: print( "please enter a correct number corresponding to a monster" ) else: print( "Sorry you look around and realize that you can't do that")
class Board: potArray = [] storeP1 = 0 storeP2 = 0 selectedPlayer = 1 playNum = 0 computer = Player() computerState = [] gameStates = [] @staticmethod def getPermutations(inputArray, interable): perms = list(itertools.permutations(inputArray, interable)) returnPerms = list() for permutation in perms: if len(returnPerms) > 0: keepPerm = True for perm in returnPerms: if perm == permutation: keepPerm = False break if keepPerm: returnPerms.append(permutation) else: returnPerms.append(permutation) return returnPerms def generateGameStates(self): gameStates = [] permList = [0, 0, 0, 0, 0, 0] for i in range(0, 6): comb = self.getPermutations(permList, 6) for perm in comb: gameStates.append(perm) permList[i] = 1 gameStates.append(permList) del gameStates[0] return gameStates def setCurrentComputerState(self): self.computerState = [ self.potArray[6].hasStones, self.potArray[7].hasStones, self.potArray[8].hasStones, self.potArray[9].hasStones, self.potArray[10].hasStones, self.potArray[11].hasStones ] def __init__(self, pots, computer): self.potArray = pots self.computer = computer self.gameStates = self.generateGameStates() def test(self): self.setCurrentComputerState() potIndex = self.askForIndex() return self.moveStonesAtIndex(potIndex) def player1Stones(self, index, stoneNum): length = len(self.potArray) maxIndex1 = (length - (length / 2)) lastPot = (index + stoneNum) lastCheck = 0 i = index + 1 while i <= lastPot: if i == maxIndex1: self.storeP1 += 1 if lastPot == maxIndex1: self.playNum -= 1 lastCheck = 1 # lastPot -= 1 # lastCheck = 1 if i >= length and lastCheck == 0: self.potArray[i - length].stoneNum += 1 elif lastCheck == 0: self.potArray[i].stoneNum += 1 if i == maxIndex1: lastPot -= 1 lastCheck = 0 i += 1 self.potArray[index].stoneNum = 0 def player2Stones(self, index, stoneNum): length = len(self.potArray) lastPot = (index + stoneNum) lastCheck = 0 i = index + 1 while index + 1 <= i < lastPot + 1: if i == length: self.storeP2 += 1 if lastPot == length: self.playNum -= 1 # lastPot -= 1 lastCheck = 1 if i > length: var = math.floor(i / length) * length var = int(var) self.potArray[i - var - 1].stoneNum += 1 elif lastCheck == 0: self.potArray[i].stoneNum += 1 lastCheck = 0 i += 1 self.potArray[index].stoneNum -= stoneNum def setCurrentPlayer(self): if self.playNum % 2 == 0: self.selectedPlayer = 1 else: self.selectedPlayer = 2 def moveStonesAtIndex(self, index): stone = self.potArray[index] self.checkPots() self.setCurrentPlayer() if stone.hasStones: stoneNum = stone.stoneNum self.setCurrentPlayer() if self.selectedPlayer == 1: self.player1Stones(index, stoneNum) else: self.player2Stones(index, stoneNum) self.playNum += 1 return self.checkGameOver() else: print "Pot does not contain any stones!" def askForIndex(self): if self.playNum % 2 == 0: inputIndex = input("P1 Input Index: ") if 5 < inputIndex < 12: print "Incorrect Index" return self.askForIndex() else: self.selectedPlayer = 1 return inputIndex else: self.setCurrentComputerState() if self.computer.stateMoveDictionary.values()[0] < 6: for state in self.gameStates: self.computer.stateMoveDictionary[tuple(state)] += 6 inputIndex = self.computer.stateMoveDictionary[tuple( self.computerState)] if inputIndex < 6: print "Error" print "Player 2 plays: " + str(inputIndex) self.selectedPlayer = 2 return inputIndex def checkPots(self): for pot in self.potArray: if pot.stoneNum <= 0: pot.hasStones = False else: pot.hasStones = True def checkGameOver(self): self.checkPots() if not self.potArray[0].hasStones and not self.potArray[1].hasStones and not self.potArray[2].hasStones and not \ self.potArray[3].hasStones and not self.potArray[4].hasStones and not self.potArray[5].hasStones: return 1 if not self.potArray[11].hasStones and not self.potArray[10].hasStones and not self.potArray[ 9].hasStones and not \ self.potArray[8].hasStones and not self.potArray[7].hasStones and not self.potArray[6].hasStones: return 1 return 0 def printValues(self): print "Store1 " + str(self.storeP1) print "Store2 " + str(self.storeP2) index = 0 for i in self.potArray: print "Pot" + str(index) print i.stoneNum index += 1
def __init__(self): self.deck = Deck() self.allcards = self.deck.all_cards self.player1 = Player(self.deck, "Player1") self.player2 = Player(self.deck, "Player2") self.used_cards = []
from Aimbotz import Aimbotz from Deck import Deck from Player import Player Player1 = Player() Deck1 = Deck() Aimbotz1 = Aimbotz() Resume = True Comdraw = True Playdraw = True Game = True End = False Player1.Score = 0 Aimbotz1.Score = 0 Deck1.Rawdeck = [] Deck1.initdeck() Player1.Rawdeck = [] Aimbotz1.Rawdeck = [] while Resume: Comdraw = True Playdraw = True Game = True Player1.Score = 0 Aimbotz1.Score = 0 Deck1.Rawdeck = [] Deck1.initdeck() Player1.Rawdeck = [] Aimbotz1.Rawdeck = []
#coding:UTF-8" from Bom import Bom from Player import Player from Object import Object from Board import Board if __name__ == '__main__': # main() p = [] board = Board(width=7, height=7) p.append(Player(x=1, y=1, fire=2, ID=chr(65))) # randomに p.append(Player(x=7, y=7, fire=2, ID='T')) """ p.append(Player(x=1, y=7, fire=2, ID='M')) p.append(Player(x=7, y=1, fire=2, ID='N')) p.append(Player(x=4, y=3, fire=2, ID='E')) """ board.display(p) while True: print('input direction') directions = input().strip().split() for i, player in enumerate(p): # ボム置く if '1' in directions[i]: board.putObject(player.createBom()) elif 'q' in directions[i]: break for i, player in enumerate(p): # 移動 player.move(directions[i], board.movable_range(player)) #print(board.getClassList(Bom))
from config import * from Player import Player from EnemyFactory import EnemyFactory player = Player(WIDTH / 2, HEIGHT / 2) enemy_factory = EnemyFactory() def setup(): size(WIDTH, HEIGHT) imageMode(CENTER) rectMode(CENTER) def draw(): #Setup background(0) player.controller() translate(WIDTH / 2 - player.x, HEIGHT / 2 - player.y) #Bullet for i, bullet in enumerate(BULLET_LIST): if bullet.outOfRange(): BULLET_LIST.pop(i) bullet.move() bullet.draw() #Player player.draw()
def pruebaPuntuacionVm(): from Player import Player from Dice import Dice dices = [Dice().roll() for i in range(5)] player = Player("Salvador") player.setScore("Ones", 6) player.setScore("Chance", 21) player.setScore("Fours", 16) player.setScore("Full House", 25) vmLower, vmUpper = player.getScoreCardVm(dices) print("Dices: ", dices, sep=" ") print("Lower Section: ", vmLower, sep=" ") print("Upper Section: ", vmUpper, sep=" ")
class Window(pyglet.window.Window): def __init__(self): super(Window, self).__init__(width=width, height=height, vsync=True, caption="Platformer") self.set_icon(icon1, icon2) self.CurrentLevel = 1 self.PlayerSprite = Player(playerStill.width, playerStill.height, playerStill, 0, 0) self.LoadLevel(self.CurrentLevel) pyglet.clock.schedule_interval(self.DrawScreen, 1 / 60) pyglet.clock.schedule_interval(self.UpdatePlayer, 1 / 60) self.Gravity = -1 self.AveFPS = [] def on_draw(self): pyglet.clock.tick() FPSVal = str(round(pyglet.clock.get_fps(), 2)) self.AveFPS.append(float(FPSVal)) if Extras: TotFPS = 0 for FPSValue in self.AveFPS: TotFPS += float(FPSValue) TotFPS /= len(self.AveFPS) while len(self.AveFPS) > 5000: del self.AveFPS[0] fpsDisplay = pyglet.text.Label(f"FPS: {FPSVal}", font_size=10, x=10, y=700) AveFPSDisplay = pyglet.text.Label(f"Ave FPS: {round(TotFPS, 2)}", font_size=10, x=10, y=680) fpsDisplay.draw() AveFPSDisplay.draw() def on_key_release(dt, symbol, modifiers): try: del pressedKeys[symbol] except: pass def on_key_press(dt, symbol, modifiers): global Extras if symbol == key.ESCAPE: pyglet.app.exit() if symbol == key.F3: Extras = not Extras pressedKeys[symbol] = True def UpdatePlayer(self, dt): Moved = False if key.W in pressedKeys and self.PlayerSprite.OnFloor: self.PlayerSprite.applyforce(0, 18) Moved = "W" if key.S in pressedKeys: self.PlayerSprite.applyforce(0, -0.8) Moved = "S" if key.A in pressedKeys: self.PlayerSprite.applyforce(-1, 0) Moved = "A" if key.D in pressedKeys: self.PlayerSprite.applyforce(1, 0) Moved = "D" if not (Moved): self.PlayerSprite.update(playerStill) elif Moved == "W": self.PlayerSprite.update(playerUp) elif Moved == "S": self.PlayerSprite.update(playerDown) elif Moved == "A": self.PlayerSprite.update(playerLeft) elif Moved == "D": self.PlayerSprite.update(playerRight) Collide = False for CurrentTile in self.LoadedData: if abs(CurrentTile.Pos[0] - self.PlayerSprite.Pos[0]) > 100: continue if abs(CurrentTile.Pos[1] - self.PlayerSprite.Pos[1]) > 100: continue if self.PlayerSprite.collideswith(CurrentTile): if key.W in pressedKeys: self.PlayerSprite.resetvel(CurrentTile, "UP") Collide = True if key.S in pressedKeys: self.PlayerSprite.resetvel(CurrentTile, "DOWN") Collide = True if key.A in pressedKeys: self.PlayerSprite.resetvel(CurrentTile, "LEFT") Collide = True if key.D in pressedKeys: self.PlayerSprite.resetvel(CurrentTile, "RIGHT") Collide = True if Moved == False: self.PlayerSprite.resetvel(CurrentTile) Collide = True if self.PlayerSprite.checkfloor(CurrentTile): self.PlayerSprite.resetvel(CurrentTile) Collide = True if not Collide: self.PlayerSprite.OnFloor = False if self.PlayerSprite.nextlevel(self.width): self.CurrentLevel += 1 self.LoadLevel(self.CurrentLevel) def DrawScreen(self, dt): self.clear() self.PlayerSprite.draw() for CurrentTile in self.LoadedData: CurrentTile.draw() def LoadLevel(self, num: int): Index = num - 1 self.LoadedData = [] with open("Level.Data", "r") as LevelData: LevelData = json.loads(LevelData.read()) GroundData = LevelData["levels"][Index]["Data"] for Data in GroundData: Data = Data.split(",") if Data[2] == "gr": Data[2] = groundTexture elif Data[2] == "drt": Data[2] = dirtTexture Data[0] = int(Data[0]) Data[1] = int(Data[1]) CurrentTile = Tile(Data[2].width, Data[2].height, Data[2], Data[0], Data[1], Data[3]) self.LoadedData.append(CurrentTile) StartingPos = LevelData["levels"][Index]["StartingPos"] self.PlayerSprite.movepos(StartingPos[0], StartingPos[1])
def setUp(self): TestDatabaseSetup.setUp(self) self.p1 = Player("Vladimir", Alignment.WOOD) self.p2 = Player("Estragon", Alignment.METAL) self.rock = Rock() self.gp3 = GoldPiece(3)
def addPlayer(self, playerName): self.players.append(Player(playerName))
from Game import Game from Player import Player player1 = Player(race='horde', start_gold=10, name='Grubby', number=1) player2 = Player(race='human', start_gold=10, name='a1sok', number=2) game = Game(player1, player2) player2.factory.create_unit('footman', (4, 5)) player2.factory.create_unit('footman', (4, 7)) game.run()
return text_rect if __name__ == '__main__': pygame.init() window_surface: Surface = pygame.display.set_mode(SCREEN_DIMENSION) pygame.display.set_caption(WINDOW_CAPTION) pygame.mixer.init() pygame.mixer.music.load(BGM_PATH) pygame.mixer.music.play(loops=-1) running = True ball_1 = Ball(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2) player_1 = Player(WINDOW_WIDTH / 2, WINDOW_HEIGHT - 60) # drawing screen borders left_limit_rect = Rect(10, 10, 10, 700) right_limit_rect = Rect(440, 10, 10, 700) top_limit_rect = Rect(20, 10, 420, 20) clock = pygame.time.Clock() brick_list = [] number_of_lines = 8 brick_y_position = top_limit_rect.bottom + 40 line_value = 1000 for i in range(number_of_lines): has_space = True
def on_update(self, delta_time: float): if self.drawn: player1 = Player(int(1/8 * SCREEN_WIDTH), Y_BASELINE, BOX_WIDTH, BOX_HEIGHT, 0, character='nate') player2 = Player(int(7/8 * SCREEN_WIDTH), Y_BASELINE, BOX_WIDTH, BOX_HEIGHT, 1, character='nate') fight_view = FightView(self.window, player1=player1, player2=player2) self.window.show_view(fight_view)