def pickTargetTerminator(droid,AI): targetDroids = findDroids(droid.x,droid.y,2,1-AI.playerID,AI.droids) if (len(targetDroids) > 0): for targetDroid in targetDroids: if targetDroid.variant == TURRET: return targetDroid.x,targetDroid.y for targetDroid in targetDroids: if targetDroid.variant == HANGAR: return targetDroid.x,targetDroid.y for targetDroid in targetDroids: if targetDroid.variant == HACKER: return targetDroid.x,targetDroid.y lowest = targetDroids[0] lowestrating = targetDroids[0].armor*targetDroids[0].healthLeft for targetDroid in targetDroids: if lowestrating > targetDroid.armor*targetDroid.healthLeft: lowest = targetDroid lowestrating = targetDroid.armor*targetDroid.healthLeft return lowest.x,lowest.y else: targetDroids = findDroids(droid.x,droid.y,AI.getMapHeight()+AI.getMapWidth(),1-AI.playerID,AI.droids) if (len(targetDroids) > 0): for targetDroid in targetDroids: if targetDroid.variant == HANGAR: return targetDroid.x,targetDroid.y return targetDroids[0].x,targetDroids[0].y else: #return droid.x+ 4*(-2*AI.playerID+1),droid.y return AI.getMapWidth()/2, AI.getMapHeight()/2
def get(self): try: stage = json.loads(self.request.get("stage")) aiChar = pieces["aiChar"] playerChar = pieces["playerChar"] board = Board(stage) logging.info("Stage: {}".format(stage)) logging.info("AIChar: {}".format(aiChar)) logging.info("Player Char: {}".format(playerChar)) logging.info("Turn count {}".format(len(board))) logging.info("Game Board:\n"+str(board)) over,winner = board.gameOver() output = {"over":over, "winner":winner, "aiMove":-1,} if not over: aiMove = AI.takeTurn(board, aiChar, playerChar, self.easyMode) board.makeMove(*(list(aiMove)+[aiChar])) logging.info("\n"+str(board)) output["over"], output["winner"] = board.gameOver() output["aiMove"] = ((aiMove[0]*3)+aiMove[1]) if output["over"]: AI.reshuffle() self.write(json.dumps(output)) except: self.render("bad.html")
def pickTargetRepair(droid,AI): possibleDroids = findDroids(droid.x,droid.y,4,AI.playerID,AI.droids) for targetDroid in possibleDroids: if targetDroid.armor != targetDroid.maxArmor and targetDroid.variant == TURRET: return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.armor != targetDroid.maxArmor and targetDroid.variant == TERMINATOR: return targetDroid.x,targetDroid.y #for targetDroid in possibleDroids: # if targetDroid.armor != targetDroid.maxArmor: # return targetDroid.x,targetDroid.y possibleDroids = findDroids(droid.x,droid.y,AI.getMapHeight()+AI.getMapWidth(),AI.playerID,AI.droids) for targetDroid in possibleDroids: if targetDroid.armor != targetDroid.maxArmor and targetDroid.variant == TURRET: return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.armor != targetDroid.maxArmor and targetDroid.variant == TERMINATOR: return targetDroid.x,targetDroid.y #for targetDroid in possibleDroids: # if targetDroid.armor != targetDroid.maxArmor: # return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.armor != targetDroid.maxArmor: return targetDroid.x,targetDroid.y return -1,-1
def AI_setup(module): AI.minimax('reset') response = input("Will you go first (X), or second (O)? ") assert response == 'X' or response == 'O', "Invalid input, please try again." if response == 'X': AI.AI_player, AI.minimax_dict = 2, {1: min, 2: max} else: AI.AI_player, AI.minimax_dict = 1, {1: max, 2: min}
def pickTargetClaw(droid,AI): targetDroids = findDroids(droid.x,droid.y,5,1-AI.playerID,AI.droids) if (len(targetDroids) > 0): for targetDroid in targetDroids: if targetDroid.variant == ARCHER: return targetDroid.x,targetDroid.y return targetDroids[0].x,targetDroids[0].y else: targetDroids = findDroids(droid.x,droid.y,AI.getMapHeight()+AI.getMapWidth(),1-AI.playerID,AI.droids) if (len(targetDroids) > 0): return targetDroids[0].x,targetDroids[0].y else: #return droid.x+ 4*(-2*AI.playerID+1),droid.y return AI.getMapWidth()/2, AI.getMapHeight()/2
def processCardPlay(self,screen): while self.playable(): if not self.auto and self.getNextSeat().human: card=self.getUserCard(screen) else: card=AI.chooseCard(self) self.playCard(screen,card)
def AIMove(board, type) : global moveList global outputFile global maxDepth #move = AI.decideMoveMinMax(board, maxDepth, type) move = AI.decideMoveAlphaBeta(board, maxDepth, type) boardNum = int(move[0]) pos = int(move[2]) boardRotate = move[4] rotateDir = move[5] board.addPiece(boardNum, pos, type) winCheck = board.checkWin() if (winCheck == -1) : if (rotateDir.lower() == 'l') : board.shiftLeft(int(boardRotate)) else : board.shiftRight(int(boardRotate)) moveList.append(move) outputFile.write(str(board) + "\n") outputFile.write(str(moveList) + "\n") print("AI move: " + str(move))
def play(): global white, black user_pos = int(request.args.get("id", "")) if user_pos not in white and user_pos not in black: white.append(user_pos) AI_pos = AI.play(white, black) black.append(AI_pos) return str(AI_pos) else: return "-1"
def pickTargetHacker(droid,AI): possibleDroids = findDroids(droid.x,droid.y,4,1-AI.playerID,AI.droids) for targetDroid in possibleDroids: if targetDroid.hackedTurnsLeft == 0 and targetDroid.variant == CLAW: return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.hackedTurnsLeft == 0 and targetDroid.variant == TERMINATOR: return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.hackedTurnsLeft == 0 and (targetDroid.variant != HANGAR and targetDroid.variant != WALL and targetDroid.variant != TURRET): return targetDroid.x,targetDroid.y possibleDroids = findDroids(droid.x,droid.y,AI.getMapHeight()+AI.getMapWidth(),1-AI.playerID,AI.droids) for targetDroid in possibleDroids: if targetDroid.hackedTurnsLeft == 0 and targetDroid.variant == CLAW: return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.hackedTurnsLeft == 0 and targetDroid.variant == TERMINATOR: return targetDroid.x,targetDroid.y for targetDroid in possibleDroids: if targetDroid.hackedTurnsLeft == 0 and (targetDroid.variant != HANGAR and targetDroid.variant != WALL and targetDroid.variant != TURRET): return targetDroid.x,targetDroid.y return -1,-1
def play(): global white, black user_pos = int(request.args.get('id','')) if user_pos not in white and user_pos not in black: white.append(user_pos) AI_pos = AI.play(black, white) if AI_pos < 0: black.append(-AI_pos-1) else: black.append(AI_pos) print 'B: ', black print 'W: ', white return str(AI_pos) else: return '-1024'
def pickTargetArcher(droid,AI): targetDroids = findDroids(droid.x,droid.y,5,1-AI.playerID,AI.droids) if (len(targetDroids) > 0): for targetDroid in targetDroids: if targetDroid.variant == HACKER: return targetDroid.x,targetDroid.y lowest = targetDroids[0] lowestrating = targetDroids[0].armor*targetDroids[0].healthLeft for targetDroid in targetDroids: if lowestrating > targetDroid.armor*targetDroid.healthLeft: lowest = targetDroid lowestrating = targetDroid.armor*targetDroid.healthLeft return lowest.x,lowest.y else: targetDroids = findDroids(droid.x,droid.y,AI.getMapHeight()+AI.getMapWidth(),1-AI.playerID,AI.droids) # if (len(targetDroids) > 0): # for targetDroid in targetDroids: # if (targetDroid.variant == TERMINATOR) and ((droid.owner == 0 and targetDroid.x > droid.x) or (droid.owner == 1 and targetDroid.x < droid.x)): # return targetDroid.x + 2*(2*AI.playerID-1),targetDroid.y # return AI.getMapWidth()/2, AI.getMapHeight()/2 if (len(targetDroids) > 0): return targetDroids[0].x,targetDroids[0].y else: return AI.getMapWidth()/2, AI.getMapHeight()/2
def testAI() : global maxDepth test = Board() # diagonal win configs test.addPiece(1, 1, 'w') test.addPiece(1, 5, 'b') test.addPiece(1, 2, 'w') """ test.addPiece(1, 9, 'b') test.addPiece(4, 1, 'b') test.addPiece(4, 5, 'b') test.addPiece(4, 9, 'b') test.addPiece(2, 3, 'b') test.addPiece(2, 5, 'b') test.addPiece(2, 7, 'b') test.addPiece(3, 3, 'b') test.addPiece(3, 5, 'b') test.addPiece(3, 7, 'b') """ test2 = test.copyBoard() test2.addPiece(1, 1, 'w') print(test) #print(test2) #AIMove(test, 'b') print(test) print(test.heuristicValue()) AI.decideMoveAlphaBeta(test, maxDepth, 'b') print("Done!")
def makeObstacle(obstacleChoice, position, size, image, direction = 'left'): if (obstacleChoice == 'Spikes'): return AI.spikes(position, size, image) elif (obstacleChoice == 'Log'): return AI.treeLog(position, size, image) elif (obstacleChoice == 'Giant rock'): return AI.giantRock(position, size, image, direction) elif (obstacleChoice == 'Banana peel'): return AI.bananaPeel(position, size, image) elif (obstacleChoice == 'Snake'): return AI.snake(position, size, image) elif (obstacleChoice == 'Bird'): return AI.bird(position, size, image) elif (obstacleChoice == 'Spider'): return AI.spider(position, size, image) elif (obstacleChoice == 'Mud'): return AI.mud(position, size, image) elif (obstacleChoice == 'Tidal wave'): return AI.tidalWave(position, size, image) else: return AI.Obstacle((0,0), (0,0), pygame.Surface((0, 0)))
def main(self): for i in range(len(self.citizens)): if self.citizens[i].villageRole == 'Lumberjack': if self.citizens[i].toGive == None: self.citizens[i].AI = AI.lumberJack if self.citizens[i].toGive == None: if self.citizens[i].inv.findItemAmount(6) >= 80: closeCraft = self.findClosestVillager((self.citizens[i].column,self.citizens[i].row),'Crafter') if closeCraft != None: self.citizens[i].AI = AI.give self.citizens[i].AIGoal = closeCraft self.citizens[i].toGive = 6 elif self.citizens[i].villageRole == 'Builder': if self.citizens[i].toTake == (None,None): self.citizens[i].AI = AI.builder if len(self.mustBuild) > 0: if self.citizens[i].currentBuildingProject == None: self.citizens[i].mustBuild = self.mustBuild[0] del(self.mustBuild[0]) if self.citizens[i].currentBuildingProject != None: if AI.hasResources(self.citizens[i],self.citizens[i].currentBuildingProject) == False: if self.citizens[i].requiredResources == []: blues = Blueprints.blueprintList() blue = blues.getBlueprint(self.citizens[i].currentBuildingProject) req = blue.getRequiredResources() for r in range(len(req)): if self.citizens[i].inv.findItemAmount(req[r][0]) < req[r][1]: self.citizens[i].requiredResources.append((req[r][0],req[r][1] - self.citizens[i].inv.findItemAmount(req[r][0]))) else: if self.citizens[i].toTake == (None,None): chests = self.storage for l in range(len(chests)): if len(self.citizens[i].requiredResources) > 0: if chests[l].inv.findItemAmount(self.citizens[i].requiredResources[0][0]) >= self.citizens[i].requiredResources[0][1]: self.citizens[i].toTake = (self.citizens[i].requiredResources[0][0],self.citizens[i].requiredResources[0][1]) self.citizens[i].AIGoal = chests[l] self.citizens[i].AI = AI.take del(self.citizens[i].requiredResources[0]) break elif self.citizens[i].villageRole == 'Crafter': if self.citizens[i].inv.findItemAmount(6) >= 80: self.citizens[i].crafting.craftItem(8,20) self.citizens[i].crafting.craftItem(9,1) self.citizens[i].crafting.craftItem(10,1) self.transferToNearestChest(self.citizens[i],8,40) self.transferToNearestChest(self.citizens[i],9,1) self.transferToNearestChest(self.citizens[i],10,1) self.transferToNearestChest(self.citizens[i],6,20)
def press(num): ''' Comando de los botones. Desactiva las posiciones del tablero donde se presento el movimiento. :param num: referencia a la posicion del tablero donde se presenta el movimiento. :type num: integer ''' global a global count global first button = buttonList[num] button.config(text=str(a[count%2]), state=DISABLED) AI.posJuego(num, first) count+=1 if first==False and not AI.isOver() and AI.freeSpace(): first = True press(AI.nextMove()) elif not AI.freeSpace() or AI.isOver(): colorButton(AI.poswin) info.config(text= "Fin Partida! Juego para "+a[(count-1)%2]) tkMessageBox.showinfo("FIN PARTIDA", message(first, AI.isOver())) end() else: first = False
AI_plays = input("Play with an AI player? (Y/N) ") assert AI_plays == 'Y' or AI_plays == 'N', "Invalid input, please try again." break except AssertionError as e: print(e) if AI_plays == 'Y': try_loop(AI_setup, AI) board, player = Classicboard(), 1 print(board) while board.winner is None: if AI_plays == 'Y' and player == AI.AI_player: print("\n") move = AI.minimax(board, AI.AI_player)[1] print(move[0], move[1]) board.change(move[0], move[1], plyr[AI.AI_player]) else: try_loop(prompt_for_move) if board.winner is None: print(board) player = 3 - player elif response == 'next-gen': board, player = Bigboard(), 1 print(board) try_loop(prompt_for_board)
def main(args): AI.InitAI() winner = tictactoe() printboard() print("the winner is " + winner + "\n") return 0
def SmartZoneEvent(self, direction, id, robot, chassis): if id == 1: if direction == 1: AI.SuperAI.SmartZoneEvent(self, direction, id, robot, chassis) elif id == 2: if robot > 0: if direction == 1: # if not already well-positionned : move servo motor : servoangle = self.GetMotorAngle(self.motor) if servoangle < (self.maxangle - self.delta): self.Input("Servo", 0, -self.servospeed) elif servoangle > (self.maxangle + self.delta): self.Input("Servo", 0, self.servospeed) #else: self.Input("Servo", 0, 0) elif id == 3: if robot > 0: if direction == 1: # if not already well-positionned : move servo motor : servoangle = self.GetMotorAngle(self.motor) if servoangle > (self.minangle + self.delta): self.Input("Servo", 0, self.servospeed) elif servoangle < (self.minangle - self.delta): self.Input("Servo", 0, -self.servospeed) #else: self.Input("Servo", 0, -self.servospeed) return True AI.register(OmniServo)
for trigger in self.trigger2: self.Input(trigger, 0, 1) for i in range(0, 8): yield 0 def LostComponent(self, id): # if we lose all our weapons, stop using the Engage tactic and switch to Shove if id in self.weapons: self.weapons.remove(id) if not self.weapons and not self.sweapons and not self.tweapons and not self.qweapons: self.top_speed = 100 tactic = [x for x in self.tactics if x.name == "Engage"] if len(tactic) > 0: self.tactics.remove(tactic[0]) self.tactics.append(Tactics.Shove(self)) self.tactics.append(Tactics.Charge(self)) return AI.SuperAI.LostComponent(self, id) def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) AI.register(Smashbox)
def __init__(self, world, ent_xml_data, ent_config): Actor.__init__(self, world, ent_xml_data, ent_config) self.sensor = AI.Sensor(world, self) self.maxForce = 1000 self.message_queue = []
if isLegal(i, j, turn)] initBoard() turn = b # turn indicator b or w(Black Or White), black goes first whiteCanPlay = True # if white is not stuck blackCanPlay = True # if black is not stuck # legal check playerTile = input( "Choose your chess color. Type 'b' for black and white otherwise. Black goes first: " ) playerTile = b if playerTile == 'b' else w bestNetwork = AI.loadNetworks(AI.structure, generation)[0] while whiteCanPlay or blackCanPlay: validMoves = generateValidMovesList() if len(validMoves) == 0: print() if turn == w: whiteCanPlay = False if turn == b: blackCanPlay = False else: if turn == w: whiteCanPlay = True if turn == b:
def InvertHandler(self): # fire weapon once per second (until we're upright!) while 1: for trigger in self.triggers: self.Input(trigger, 0, 1) for i in range(0, 8): yield 0 def LostComponent(self, id): # if we lose all our weapons, stop using the Engage tactic and switch to Shove if id in self.weapons: self.weapons.remove(id) if not self.weapons: self.RemoveTactic("Engage") self.tactics.append(Tactics.Shove(self)) self.tactics.append(Tactics.Charge(self)) return AI.SuperAI.LostComponent(self, id) def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) AI.register(OmniSwitch)
running_reward = None #---------define the placeholder-------- # image shape is 512,288,3 #convert shape is 64,36,1 states_batch_pl = tf.placeholder(tf.float32, shape=[None, 64, 36, 1]) actions_batch_pl = tf.placeholder(tf.float32, shape=[None, 1]) discount_rewards_batch_pl = tf.placeholder(tf.float32, shape=[None, 1]) #---------define the loss and train_op-------- gamma = 0.9 decay_rate = 0.9 #network = AI.policy_network(states_batch_pl) sampling_prob = AI.policy_network(states_batch_pl) loss = rein.cross_entropy_reward_loss(sampling_prob, actions_batch_pl, discount_rewards_batch_pl) logloss = rein.loss(logits=sampling_prob, actions=actions_batch_pl) train_op = tf.train.RMSPropOptimizer(learning_rate=0.1, decay=0.9).minimize(loss) #---------train--------- env = gym.make('FlappyBird-v0') with tf.Session() as sess: init = tf.initialize_all_variables() sess.run(init) update_batch = 70 #when times > update_batch update my weights
self.RegisterSmartZone("weapon3", 4) self.RegisterSmartZone("weapon4", 5) return bReturn def SmartZoneEvent(self, direction, id, robot, chassis): if id == 1: if direction == 1: AI.SuperAI.SmartZoneEvent(self, direction, id, robot, chassis) elif id == 2: if robot > 0: if direction == 1: self.Input("Fire1", 0, 1) elif id == 3: if robot > 0: if direction == 1: self.Input("Fire2", 0, 1) elif id == 4: if robot > 0: if direction == 1: self.Input("Fire3", 0, 1) elif id == 5: if robot > 0: if direction == 1: self.Input("Fire4", 0, 1) return True AI.register(OmniMultiZone)
import json, numpy, decimal est = 1 '''if est==1: est=2 else: est=1''' while 1: #try: import AI rawdata = AI.talk(str(input("You: ")), est) answsheet = json.load(open("answ.json")) probs = list(rawdata.values()) totalprob = 0 for i in probs: totalprob = totalprob + i for i in range(0, len(probs)): probs[i] = decimal.Decimal(probs[i]) / totalprob print(probs) print(answsheet[numpy.random.choice(list(rawdata.keys()), p=probs)]) #except Exception as E: # print(E)
def game(player1, player2): if type(player1) == Q.QLearning: if os.path.exists('./data/first_win_rate.pickle'): with open('./data/first_win_rate.pickle', 'rb') as f: win_rate = pickle.load(f) else: win_rate = [] if type(player2) == Q.QLearning: if os.path.exists('./data/first_win_rate.pickle'): with open('./data/second_win_rate.pickle', 'rb') as f: win_rate = pickle.load(f) else: win_rate = [] b = 0 w = 0 cnt = 1 board = B.Board() player = P.Player() random_ai = R.RandomAI() color = BLACK while True: for i in range(100): w = 0 b = 0 for j in range(100): board.init() while not board.is_end(): color = board.get_color() if color == BLACK: status = turn(board, player1, player2, 0) else: status = turn(board, player2, player1, 0) if status == "game-set": break # 盤面の表示 # print('after -------------->') # board.show_board() win = board.who_won() if win == BLACK: # print('black win') b += 1 elif win == WHITE: # print('white win') w += 1 if type(player1) == Q.QLearning: win_rate.append(b / 100) else: win_rate.append(w / 100) print('black {} win'.format(b)) print('white {} win'.format(w)) if type(player1) == Q.QLearning: with open('./data/first_move_4x4.pickle'.format(cnt), 'wb') as f: pickle.dump(player1, f) with open('./data/first_win_rate.pickle', 'wb') as f: pickle.dump(win_rate, f) if type(player2) == Q.QLearning: with open('./data/second_move_4x4.pickle', 'wb') as f: pickle.dump(player2, f) with open('./data/second_win_rate.pickle', 'wb') as f: pickle.dump(win_rate, f) cnt += 1
with open('./data/second_move_4x4.pickle', 'wb') as f: pickle.dump(player2, f) with open('./data/second_win_rate.pickle', 'wb') as f: pickle.dump(win_rate, f) cnt += 1 # plt.plot(win_rate) # plt.show() if __name__ == '__main__': x = 3 #int(input('先手: ナイーブ=1, ランダム=2, QL=3 > ')) if x is 1: player1 = N.NaiveAI() elif x is 2: player1 = R.RandomAI() elif x is 3: if os.path.exists('./data/first_move.pickle'): with open('./data/first_move.pickle', 'rb') as f: player1 = pickle.load(f) else: player1 = Q.QLearning(BLACK) x = 2 #int(input('後手: ナイーブ=1, ランダム=2, QL=3 > ')) if x is 1: player2 = N.NaiveAI() elif x is 2: player2 = R.RandomAI() elif x is 3: if os.path.exists('./data/second_move.pickle'): with open('./data/second_move.pickle', 'rb') as f:
child.append(tree03, 2) count = 0 for child in tree.children: for branch in child.children: tree001 = AI.Tree(1, 2, 0, 0, 100) tree002 = AI.Tree(1, 2, 0, 0, 100) tree003 = AI.Tree(1, 2, 0, 0, 100) branch.append(tree001, 0) branch.append(tree002, 1) branch.append(tree003, 2) for leaf in branch.children: leaf.value = count count += 1 finalValue = AI.minimax(tree, True) print("final value of root:", finalValue) j = [1, 2, 3, 4, 5, 6] a = j a[0] += 1 v = 4 w = v v += 1 print(v, w)
if len(targets) > 0 and self.reloadTime <= 0: try: trigger = self.triggerIterator.next() except StopIteration: self.triggerIterator = iter(self.triggers) trigger = self.triggerIterator.next() self.Input(trigger, 0, 1) self.reloadTime = self.reloadDelay return AI.SuperAI.Tick(self) def InvertHandler(self): # fire all weapons once per second (until we're upright!) while 1: for trigger in self.triggers: self.Input(trigger, 0, 1) for i in range(0, 8): yield 0 def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) AI.register(PokerPlus)
return json.dumps( brain.inst.parse_text(user_data.q, user_data.device)) class myAI(web.application): def run(self, port=8080, *middleware): func = self.wsgifunc(*middleware) return web.httpserver.runsimple(func, ('0.0.0.0', port)) if __name__ == "__main__": #app = web.application(urls, globals()) settings.SERVER_STARTTIME = datetime.now() settings.REQUESTS = 0 log.info('') log.info('') log.info('') log.info('') log.info("****************************************") log.info("*** Starting Janet v{} ***".format(VERSION)) log.info("****************************************") log.info('') log.info('') log.info("Started {}".format(settings.SERVER_STARTTIME)) AI.init() app = myAI(urls, globals()) app.run(port=8888)
def nextStep(self,text): if consts.godmode: self.myCell.lifeTimeLeft=self.myCell.lifeTime self.myCell.foodLeft=self.myCell.food if text!="Empty": consts.askingQuestion=False ##parse input self._counter+=1 ##change season if not consts.recording: if self._counter%(consts.framerate*60)==0: consts.season=(consts.season+1)%4 ##handle input inputlist=self.getInput() for item in inputlist: if (item=="Left" or item=="Right") and (("Left" in self.__kinput) or ("Right" in self.__kinput)): continue elif (item=="c" and ("c" in self.__kinput)): continue elif (item=="m" and ("m" in self.__kinput)): continue else: self.__kinput.append(item) for item in self.__kinput: if not consts.mouse_control: if item=="Left" or item=="OLeft": self.myCell.changeAngle(-1) if item=="Right" or item=="ORight": self.myCell.changeAngle(1) self.myCell.changeAngle(0) if "Up" in self.__kinput: self.myCell.move() ##handle food and life self.myCell.checkTarget() self.myCell.checkEat(self.foodList) self.myCell.consumeFood(self._counter) self.myCell.consumeLife(self._counter) self.myCell.consumeEggTime(self._counter) self.myCell.checkRIP() if self.myCell.timeToHurt!=0: self.myCell.timeToHurt-=1 input=[] for cell in self.cellList: input=AI.nextStep(self.myCell,self.cellList,self.foodList,cell) for item in input: if item=="OLeft": cell.changeAngle(-1) if item=="ORight": cell.changeAngle(1) if "Up" == item: cell.move() if "a" == item: if cell.timeToLayLeft==0 and cell.lastMother!=None: self.cellEggs.append(cell.layEgg()) cell.lastMother=None cell.target=None if "c" ==item: if cell.mode=="m": cell.mode="c" else: cell.mode="m" cell.checkEat(self.foodList) cell.consumeFood(self._counter) cell.consumeLife(self._counter) cell.consumeEggTime(self._counter) cell.checkTarget() cell.checkRIP() if cell.timeToHurt!=0: cell.timeToHurt-=1 if cell.dead: self.cellList.remove(cell) if "a" in inputlist: if self.myCell.timeToLayLeft==0 and self.myCell.lastMother!=None: self.myEggs.append(self.myCell.layEgg(True)) self.myCell.lastMother=None if "c" in inputlist: ##carnivore or mating if self.myCell.mode=='m': self.myCell.mode='c' else: self.myCell.mode='m' if "m" in inputlist: ##load/save menu self.LoadSaveMenu() ##check egg hatching for egg in self.cellEggs: egg.consumeHatch(self._counter) for egg in self.myEggs: egg.consumeHatch(self._counter) self.growCellEggs() self.growPlayerEggs() ##check for carnivore eating and mating allCells=[] noCollision=True for cell in self.cellList: allCells.append(cell) allCells.append(self.myCell) for cell in allCells: for otherCell in allCells: collision=math.sqrt(((cell.location.x-otherCell.location.x)**2)+((cell.location.y-otherCell.location.y)**2))<cell.rad+otherCell.rad if (cell.ID!=otherCell.ID) and (collision): ##not the same cell noCollision=False if cell.mode=='c': ##carnivore if otherCell.timeToHurt<=0: otherCell.timeToHurt=consts.framerate otherCell.lifeTimeLeft-=cell.strength if otherCell.lifeTimeLeft<=0: ##only eat if you killed him cell.foodLeft+=otherCell.foodLeft otherCell.lifeTimeLeft=0 otherCell.dead=True print str(cell.ID), "Ate", str(otherCell.ID) else: ##cant eat print str(cell.ID), "hurt", str(otherCell.ID), "but did not kill him." ##cell eat practicle if cell.lastCollision!=otherCell and otherCell.lastCollision!=cell: ##only if its not a false collision graphics.practicleList.append(classes.practicle(cell.location,(240,165,36),practicle_radius)) cell.lastCollision=otherCell if cell.mode=='m': ##mate if otherCell.mode=='m': ##mate too cell.lastMother=otherCell otherCell.lastMother=cell ##cell eat practicle if cell.lastCollision!=otherCell and otherCell.lastCollision!=cell: ##only if its not a false collision graphics.practicleList.append(classes.practicle(cell.location,(240,36,131),practicle_radius)) cell.lastCollision=otherCell if noCollision: ##the cell has not colided, reset the last collision cell.lastCollision=cell.ID+self._counter ##check if its phase 2 if consts.counter/consts.framerate>consts.timeUntilPhase2 and self.p2spaceLimiter.active==False: self.p2spaceLimiter.activate() self.p2spaceLimiter.grow() if self.p2spaceLimiter.active: completeCellList=[] for cell in self.cellList: completeCellList.append(cell) completeCellList.append(self.myCell) for cell in completeCellList: if not math.sqrt(((cell.location.x-self.p2spaceLimiter.loc.x)**2)+((cell.location.y-self.p2spaceLimiter.loc.y)**2))<cell.rad+self.p2spaceLimiter.radius: cell.lifeTimeLeft-=self.p2spaceLimiter.hurt graphics.practicleList.append(classes.practicle(cell.location,(255,0,0),7)) #grow more food """ 0-Summer 75% 1-Autumn 50% 2-winter 25% 3-spring 100% """ if consts.season==0: if self._counter%(consts.framerate/6)==0: self.putFood() elif consts.season==1: if self._counter%(consts.framerate/4)==0: self.putFood() elif consts.season==2: if self._counter%(consts.framerate/2)==0: self.putFood() elif consts.season==3: if self._counter%(consts.framerate/8)==0: self.putFood() consts.counter=self._counter self.__kinput=[] if self.myCell.dead: choice=None while choice!="Okay": choice = graphics.askBoard("Prompt","You have died :(\n\nYou lived " + str(consts.counter/consts.framerate)+" seconds.") pygame.event.post(pygame.event.Event(pygame.QUIT)) ##deduct practicle time if (self._counter%(consts.framerate*0.125)): for practicle in graphics.practicleList: if practicle.radius==1: graphics.practicleList.remove(practicle) else: practicle.radius-=1 import requests testdata="" if self._counter%30==0: for cell in self.cellList: #print cell.location.x #print cell.location.y testdata+=str(cell.location.x/float(consts.screenwidth)*100)+"@"+str(cell.location.y/float(consts.screenheight)*100)+"|"; r = requests.post("http://www.avuka.net/P_live.php", data={"cells":testdata})
def __init__(self): self.currentBoard = startingBoard self.ai = mai.AI(self) self.movesOutFile = None self.predictionsOutFile = None
def __init__(self): self.surface = pygame.display.set_mode(Game.SIZE) self.clock = pygame.time.Clock() self.ai=AI.ArtificialIntelligence()
def InvertHandler(self): # fire all weapons once per second (until we're upright!) while 1: for trigger in self.triggers2: self.Input(trigger, 0, 1) for i in range(0, 8): yield 0 def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) def SmartZoneEvent(self, direction, id, robot, chassis): if id == 1 and self.weapons: if robot > 0: if direction == 1: self.compinzone = 1 if chassis: self.botinzone = 1 if direction == -1: self.compinzone = 0 if chassis: self.botinzone = 0 return True AI.register(ServoClamp)
return found # WIP, convert this into array for support of more wheel sides def Throttle(self, throttle): # if we're car steering and we're not moving much, throttle up if self.bCarSteering and self.last_turn_throttle != 0: speed = self.GetSpeed() if speed > 0 and speed < self.top_speed / 3: throttle = self.last_throttle + 10 elif speed < 0 and speed > -self.top_speed / 3: throttle = self.last_throttle - 10 throttle = min(max(throttle, -100), 100) if self.bInvertible and self.IsUpsideDown(): throttle = -throttle self.set_throttle = throttle self.Input('Forward', 0, throttle) self.DebugString(0, "Throttle = " + str(int(throttle))) def Turn(self, turning): turning = min(max(turning, -100), 100) if self.bInvertible and self.IsUpsideDown(): turning = -turning self.set_turn_throttle = turning self.Input('LeftRight', 0, -turning) self.Input('LeftRight', 1, turning) self.DebugString(1, "Turning = " + str(int(turning))) AI.register(FBSFlame)
def __init__(self, parent, landed): """ Intialise the game... """ self.parent = parent self.lose = False self.score = 0 self.level = 0 if BATCH_AMOUNT > 1: self.delay = 10 #batch mode else: self.delay = 10 #ms #lookup table self.shapes = [ square_shape, t_shape, l_shape, reverse_l_shape, z_shape, s_shape, i_shape ] self.thresholds = level_thresholds(500, NO_OF_LEVELS) self.status_bar = status_bar(parent) self.status_bar.pack(side=TOP, fill=X) #print "Status bar width",self.status_bar.cget("width") print self.score self.status_bar.set( "Rows Cleared: %d\t Level: %d \t Round: %d \t Avg: %d \t Highest: %d" % (self.score / 100, self.level + 1, amount_played + 1, average, high_score / 100)) self.board = Board(parent, landed, scale=SCALE, max_x=MAXX, max_y=MAXY, offset=OFFSET) ##load in previous game if self.board.landed != None: newlanded = copy.deepcopy(self.board.landed) for key, value in self.board.landed.iteritems(): print value self.board.landed[key] = Block( self.board.add_block(key, "blue"), key).id for key, value in self.board.landed.iteritems(): print value #self.board.landed = newlanded self.board.pack(side=BOTTOM) self.parent.bind("p", self.p_callback) self.parent.bind("f", self.f_callback) self.parent.bind("<Up>", self.faster) self.parent.bind("<Down>", self.slower) #DISABLE KEY EVENT HANDLERS ---- MARK LARSEN if len(sys.argv) > 1 and sys.argv[1] == 'human': self.parent.bind("<Left>", self.left_callback) self.parent.bind("<Right>", self.right_callback) self.parent.bind("<Up>", self.up_callback) self.parent.bind("<Down>", self.down_callback) self.parent.bind("a", self.a_callback) self.parent.bind("s", self.s_callback) #MAKE AI INSTEAD self.shapes = [ square_shape, t_shape, l_shape, reverse_l_shape, z_shape, s_shape, i_shape ] self.badshapes = [fly_shape, longT_shape, square_shape] if sys.argv[1] == 'GBFS': self.ai = AI.GBFS(self) elif sys.argv[1] == 'DLBFS': self.ai = AI.DLBFS(self) elif sys.argv[1] == 'minimax1': self.ai = AI.Minimax1(self) self.ai.shapeList = self.shapes elif sys.argv[1] == 'minimax2': self.ai = AI.Minimax2(self) self.ai.shapeList = self.shapes elif sys.argv[1] == 'frankenminimax1': self.ai = AI.Minimax1(self) self.ai.shapeList = self.badshapes elif sys.argv[1] == 'frankenminimax2': self.ai = AI.Minimax2(self) self.ai.shapeList = self.badshapes self.shape = self.get_next_shape() ##MARK LARSEN, store a class variable that holds the next shape. ##since get_next_shape() actually handled the drawing for the shape too, we should make a separate method for the self.nextShape that draws the piece off to the side of the grid. Get_next_shape() draws it at the top of the grid. ##We'll also need to update this class variable in the handle_move function where the piece meets the bottom and a the next piece starts to come. self.nextShape = self.get_next_next_shape() self.board.output() self.after_id = self.parent.after(self.delay, self.move_my_shape) ##make the first move self.ai.make_and_time_move(self.board.gridList, self.shape, self.nextShape, first=True)
def reset(self): self._resetLocation() self.knowledge = AI.KnowledgeBase(self.world, self) self.health = 100 self.drop()
print("Finally, there are some action cards that lower your gluttony level") print("These actions are:") print("Exercise: -2 Laxative: -3") print("") print("Now that you know the rules, it's time to play!") print("Good luck!") print(" ") username = input("Enter your name: ") print("----------------------------------------") print(" ") #################################GAME################################# while True: player_playing_card, player_hand, player_deck = player.player_main(player_hand, player_deck) ai_playing_card, ai_hand, ai_deck = AI.ai_main(ai_hand, ai_deck) player_gluttony, ai_gluttony = gluttony.gluttony_math( ai_playing_card, player_playing_card, ai_gluttony, player_gluttony ) print("----------------------------------------") print("AI used " + str(ai_playing_card)) print(" ") print(" " + str(username) + "'s gluttony level: " + str(player_gluttony)) print(" AI's gluttony level: " + str(ai_gluttony)) print("----------------------------------------") if ai_gluttony >= 30 or len(ai_deck) <= 0: print("You win!") break
# setup a logger that logs to stdout and file logging.basicConfig(format='%(levelname)s %(asctime)s: %(message)s', filename='ai_server.log', datefmt='%Y/%m/%d %H:%M:%S', level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler()) logger = logging.getLogger("AIServer") # global ai result variable. # set by worker thread "calculate_next_move", # read by ai_retrieve requests. # initialize to something that is a valid backup input in most cases, # so eventual ai-retrieve-deadlocks can be resolved with a restart of this server. ai_result = None # global handle to actual AI Artificial = AI.AI() LastActions = [] slack_oauth = "" #insert slack oauth here #global previous_execption variable to cut down on spam previous_posted_message = "" def post_slack_errormsg(battle_state, traceback_last): #post the AI exception to slack #To use, generate a slack oauth and paste it into the slack_oauth variable global previous_posted_message if slack_oauth == "": return
def frameUpdateVR(self): if self.frameNum == 0: self.players[self.selchar]["fCam"] = True sc = self.selchar scale = 1.48 offY = -0 self.cmp.waitGetPoses(self.VRposes, None) HMD_pose = self.VRposes[openvr.k_unTrackedDeviceIndex_Hmd] mat = np.array(HMD_pose.mDeviceToAbsoluteTracking.m) self.pos = mat[:, 3] * scale self.pos[0] *= -1 self.pos[1] += -self.players[sc]["cheight"] + offY self.pos += self.players[sc]["b1"].offset[:3] self.vMat = np.array(mat[:, :3]) self.vMat = np.transpose(self.vMat) self.vMat[::2] = self.vMat[::-2] self.vMat[1:] = self.vMat[:0:-1] self.vMat[:, 1] *= -1 self.vMat[:, 2] *= -1 self.vMat = np.array(self.vMat, order='C') self.vv = self.vMat[0] if len(self.CONTROLLERS) > 0: CTR_pose = self.VRposes[self.CONTROLLERS[0]] mat = np.array(CTR_pose.mDeviceToAbsoluteTracking.m) vMat = np.array(mat[:, :3]) vMat = np.transpose(vMat) vMat[::2] = vMat[::-2] vMat[1:] = vMat[:0:-1] vMat[:, 1] *= -1 vMat[:, 2] *= -1 forward = vMat[0] d = AI.follow(forward, np.zeros(3), 1, 1, 0) if self.players[sc]["fCam"]: self.players[sc]["cr"] = d[1] vh = d[2] i = self.vrsys.getControllerState(self.CONTROLLERS[0])[1] x, y = i.rAxis[0].x, i.rAxis[0].y # Touchpad self.players[sc]["moving"] = round(y) self.players[sc]["cv"] = -3 * x if i.ulButtonPressed & 4: # Grip self.jump() if i.ulButtonPressed & 2: # Upper menu if self.frameNum & 3 == 0: self.players[sc]["fCam"] = not self.players[sc]["fCam"] if (i.ulButtonPressed > 1000) and (x * x + y * y == 0): # Trigger if self.frameNum & 7 == 0: self.tgControl() if len(self.CONTROLLERS) > 1: if self.frameNum & 1: CTRL = self.CONTROLLERS[1] CTR_pose = self.VRposes[CTRL] i = self.vrsys.getControllerState(self.CONTROLLERS[1])[1] x, y = i.rAxis[0].x, i.rAxis[0].y if (y > 0.8): self.fire("blank", vh=vh) if (x > 0.8): self.fire("red", vh=vh) if (y < -0.8): self.fire("orange", vh=vh) if (x < -0.8): self.fire("black", vh=vh) if i.ulButtonPressed & 4: self.gesture(self.selchar, 0) if i.ulButtonPressed & 2: self.gesture(self.selchar, 2) if (i.ulButtonPressed > 1000) and (x * x + y * y == 0): self.gesture(self.selchar, 3)
def runm(self): time.Clock() from os.path import dirname, join here = dirname(__file__) scr = display.set_mode((600, 560)) print(menu.__doc__) f = font.Font(join('data/FEASFBRG.ttf'), 45) f1 = font.Font(join('data/FEASFBRG.ttf'), 25) f2 = font.Font(join('data/FEASFBRG.ttf'), 15) #'data/321impact.ttf' mainmenu = f.render('ANGRY SNAKES', 1, (255, 255, 255)) r = mainmenu.get_rect() r.centerx, r.top = 300, 120 #scr.blit(image.load(join('data/bg.png')),(0,0)) if time.get_ticks()&1 else scr.fill(-1) background_main = image.load('data/bg.png').convert() scr.blit(background_main, (0, 0)) bg = scr.copy() scr.blit(mainmenu, r) display.flip() menu1 = { "menu": ['PLAY', 'ABOUT', 'EXIT'], "font1": f1, "pos": 'center', "color1": (154, 180, 61), "light": 6, "speed": 200, "lag": 20 } menu2 = { "menu": [ '1 PLAYER', '2 PLAYERS VS', '2 PLAYERS CO-OP', '2 PLAYERS NETWORK', 'BACK' ], "font1": f1, "font2": f, "pos": 'center', "color1": (154, 180, 61), "light": 5, "speed": 200, "lag": 20 } #"pos":'center',"color1":(50,100,150),"light":5,"speed":0,"font1":f1,"font2":f,"justify":0} menu3 = { "menu": ['AI-1', 'AI-2'], "pos": (50, 250), "color1": (154, 180, 61), "light": 5, "speed": 0, "font1": f1, "font2": f, "justify": 0 } menu4 = { "menu": ['BACK'], "pos": (20, 450), "color1": (154, 180, 61), "light": 5, "speed": 0, "font2": f1, "justify": 0 } menu5 = { "menu": ['SERVER', 'CLIENT'], "pos": (50, 250), "color1": (154, 180, 61), "light": 5, "speed": 0, "font1": f1, "font2": f, "justify": 0 } menus = (menu1, menu2, menu4, menu5) playlist = [menu1, menu2, menu4, menu5] resp = "re-show" while resp == "re-show": resp = menu(**menu1)[0] if resp == 'ABOUT': webbrowser.open("http://194.225.238.146/~kharazi/") display.update(scr.blit(bg, r, r)) display.update( scr.blit( f2.render('@author: vahid kharazi', 1, (200, 200, 200)), (200, 450))) display.update( scr.blit(f2.render('*****@*****.**', 1, (200, 200, 200)), (205, 470))) display.update( scr.blit(f2.render('Winter 1390', 1, (200, 200, 200)), (235, 490))) # scr.blit(background_main,(0,0)) display.update( scr.blit(f.render('***ABOUT***', 1, (255, 255, 255)), (200, 120))) resp = menu(**menu4)[0] if resp == 'BACK': scr.blit(background_main, (0, 0)) display.update( scr.blit(f.render('ANGRY SNAKES', 1, (255, 255, 255)), (185, 120))) resp = menu(**menu1)[0] if resp == 'PLAY': display.update(scr.blit(bg, r, r)) display.update( scr.blit(f.render('PLAY', 1, (255, 255, 255)), (255, 120))) resp = menu(**menu2)[0] # if resp == 'OPTION': # fileopen=open('data/option.csv') if resp == '1 PLAYER': mysnake = singleplayer.Snake() mysnake.run() if resp == '2 PLAYERS VS': mysnake = snake.Snake() mysnake.run() if resp == '2 PLAYERS CO-OP': display.update(scr.blit(bg, r, r)) display.update( scr.blit(f.render('AI', 1, (255, 255, 255)), (30, 120))) resp = menu(**menu3)[0] if resp == '2 PLAYERS NETWORK': display.update(scr.blit(bg, r, r)) display.update( scr.blit(f.render('NETWORK', 1, (255, 255, 255)), (30, 120))) resp = menu(**menu5)[0] if resp == 'BACK': scr.blit(background_main, (0, 0)) display.update( scr.blit(f.render('ANGRY SNAKES', 1, (255, 255, 255)), (185, 120))) resp = menu(**menu1)[0] if resp == 'CLIENT': import input myinput = input.input() myinput.runclient() # import clientside # myclient=clientside.Snake() # myclient.run() if resp == 'SERVER': import input myinput = input.input() myinput.runserver() # import serverside # myclient=serverside.Snake() # myclient.run() if resp == 'AI-1': fi1 = open('data/ai.txt', 'w') fi1.write('1') fi1.close() import AI mysnake = AI.Snake() mysnake.run() if resp == 'AI-2': fi2 = open('data/ai.txt', 'w') fi2.write('2') fi2.close() import AI mysnake = AI.Snake() mysnake.run()
def startGame(settings, restart, code, load, loadData): def drawInterface(): guesses = settings["guesses"] colourNo = settings["colours"] pegNo = settings["pegs"] colourList = settings["colourList"] # Draw interface frame layout #================================================ frame = GUI.Frame(gameScr, relief=GUI.RAISED, borderwidth=1, bg="white") frame.pack(fill=GUI.BOTH, expand=1) # Draw game board #================================================ hintWidth = 8 + int((pegNo + 1) / 2) * 12 gridWidth = 50 * pegNo + hintWidth cvsGrid = GUI.Canvas(frame, width=gridWidth, height=((guesses + 1) * 50 + guesses), bg="white") cvsGrid.pack(side=GUI.RIGHT) gridPegs = [] hintPegs = [] row = 0 while row < guesses + 1: gridPegs.append([]) hintPegs.append([]) col = 0 while col < pegNo: # Draw rows of pegs #================================================ xPos = 50 * col + 3 yPos = 50 * row + row + 3 gridPegs[row].append(cvsGrid.create_oval(xPos, yPos, xPos + 44, yPos + 44, fill="black")) # Draw hint pegs #================================================ if row < guesses: hintX = 50 * pegNo + 6 + int(col / 2) * 12 if col % 2 == 0: hintY = 50 * row + 15 + row else: hintY = 50 * row + 27 + row hintPegs[row].append(cvsGrid.create_oval(hintX, hintY, hintX + 8, hintY + 8, fill="black")) # Separate rows with lines #================================================ if row != 0: cvsGrid.create_line(0, yPos - 3, gridWidth, yPos - 3) col += 1 row += 1 # Draw common interface buttons #================================================ btnQuit = GUI.Button(gameScr, text="Quit Game", fg="red", command=quitGame) btnQuit.pack(side=GUI.RIGHT) btnMenu = GUI.Button(gameScr, text="Back to Menu", command=openMenu) btnMenu.pack(side=GUI.RIGHT) btnRestart = GUI.Button(gameScr, text="Restart Game", command=restartGame) btnRestart.pack(side=GUI.RIGHT) btnNew = GUI.Button(gameScr, text="New Game", command=newGame) btnNew.pack(side=GUI.RIGHT) # Draw human codebreaker buttons #================================================ if settings["mode"] == 1: for i in range(0, colourNo): btnColour = GUI.Button(frame, text=colourList[i], bg=colourList[i], width=12, height=5, command=lambda a=colourList[i]: selectPeg(a)) btnColour.pack(anchor=GUI.W) btnDel = GUI.Button(frame, text="Undo", width=12, command=undo) btnDel.pack(anchor=GUI.W) btnSave = GUI.Button(gameScr, text="Save Game", command=lambda a=settings, b=gameEnded: file.saveGame(a, b)) btnSave.pack(side=GUI.RIGHT) # Draw CPU codebreaker buttons #================================================ if settings["mode"] == 2: btnAI = GUI.Button(gameScr, text="Start AI", fg="blue", command=lambda a=settings, b=GUI, c=gameScr, d=gameEnded, e=selectPeg: AI.startAI(a, b, c, d, e)) btnAI.pack(side=GUI.RIGHT) # Set up canvas objects for manipulation #================================================ settings["grid"] = gridPegs settings["hints"] = hintPegs settings["canvas"] = cvsGrid # Resume a loaded game #================================================ if load == True: loadGrid = loadData[0] loadHints = loadData[1] for row in range(0, settings["guesses"]): for col in range(0, settings["pegs"]): settings["canvas"].itemconfig(settings["grid"][row][col], fill=loadGrid[row][col]) settings["canvas"].itemconfig(settings["hints"][row][col], fill=loadHints[row][col]) def quitGame(): if tkMessageBox.askyesno("Quit", "Are you sure you want to quit this game?"): sys.exit() def restartGame(): if not settings["AIstarted"]: if tkMessageBox.askyesno("Restart", "Are you sure you want to restart this game?"): settings["restart"] = True gameScr.destroy() else: tkMessageBox.showinfo("Start AI", "Please wait for the AI to finish guessing.") def newGame(): if not settings["AIstarted"]: if tkMessageBox.askyesno("New", "Are you sure you want to start a new game?"): gameScr.destroy() else: tkMessageBox.showinfo("Start AI", "Please wait for the AI to finish guessing.") def undo(): if not gameEnded() and not settings["col"] == 0: canvas = settings["canvas"] row = settings["row"] col = settings["col"] - 1 if col >= 0: canvas.itemconfig(settings["grid"][row][col], fill="black") settings["col"] -= 1 elif gameEnded(): tkMessageBox.showinfo("Undo", "You can't undo once the game has ended.") elif settings["col"] == 0 and settings["row"] == 0: tkMessageBox.showinfo("Undo", "There is nothing to undo!") else: tkMessageBox.showinfo("Undo", "You can't undo a finished guess, that's cheating!") def selectPeg(pegColour): canvas = settings["canvas"] if not gameEnded(): row = settings["row"] col = settings["col"] canvas.itemconfig(settings["grid"][row][col], fill=pegColour) settings["col"] += 1 if settings["col"] == settings["pegs"]: # If the row has been filled correct = checkRow() if correct == False: settings["row"] += 1 settings["col"] = 0 else: endGame(True) else: tkMessageBox.showinfo("Game Over", "You have already guessed the code.") if settings["row"] == settings["guesses"]: endGame(False) return def gameEnded(): canvas = settings["canvas"] if canvas.itemcget(settings["grid"][settings["guesses"]][0], "fill") == "black" and settings["row"] != settings["guesses"]: # If the game is still going return False else: return True def checkRow(): rowNo = settings["row"] canvas = settings["canvas"] correct = True hints = [] code = settings["code"][:] # First, check correct positions #================================================ p = 0 while p < settings["pegs"]: pegColour = canvas.itemcget(settings["grid"][rowNo][p], "fill") if pegColour == settings["code"][p]: hints.append(0) # 0 means colour is in correct position code[p] = "used" # Set the colour to used so we don't use it for hints again else: correct = False p += 1 # Next, check correct colours in wrong positions #================================================ p = 0 while p < settings["pegs"]: pegColour = canvas.itemcget(settings["grid"][rowNo][p], "fill") if pegColour in code and pegColour != settings["code"][p]: hints.append(1) # 1 means colour exists but is not in correct position i = 0 while i < settings["pegs"]: if code[i] == pegColour: code[i] = "used" break i += 1 p += 1 hints.sort() # Fill in the hint pegs #================================================ h = 0 while h < len(hints): if hints[h] == 0: canvas.itemconfig(settings["hints"][rowNo][h], fill="red") elif hints[h] == 1: canvas.itemconfig(settings["hints"][rowNo][h], fill="white") h += 1 return correct def endGame(win): canvas = settings["canvas"] code = settings["code"] p = 0 while p < settings["pegs"]: canvas.itemconfig(settings["grid"][settings["guesses"]][p], fill=code[p]) p += 1 if win == True: tkMessageBox.showinfo("Win", "Congratulations, you found the code in " + str(settings["row"] + 1) + " guesses!") else: tkMessageBox.showinfo("Lose", "Sorry, you've used all of your " + str(settings["guesses"]) + " guesses!") def openMenu(): if not settings["AIstarted"]: if tkMessageBox.askyesno("Menu", "Are you sure you want to leave this game and return to the menu?"): settings["menu"] = True gameScr.destroy() else: tkMessageBox.showinfo("Start AI", "Please wait for the AI to finish guessing.") # Set up variables #==================================================== settings["colourList"] = ["red", "green", "blue", "yellow", "purple", "orange", "pink", "white"] settings["guesses"] = 12 settings["restart"] = False settings["menu"] = False settings["AIstarted"] = False if load == False: settings["row"] = 0 settings["col"] = 0 # Draw interface #==================================================== gameScr = GUI.Tk() drawInterface() # Generate/reload the answer #==================================================== if restart == True: settings["code"] = code elif load == False: settings["code"] = AI.codeMaker(settings["pegs"], settings["colours"], settings["colourList"]) gameScr.mainloop() # Return instructions for menu when game is stopped #================================================ return (settings["restart"], settings["code"], settings["menu"])
def main(argv): """The main arguments occur. All variables are initialized and set to the respective values, whether an integer or a class definition. All mouse motion is tracked once clicked, given statements for the click event such as selecting which level of game to play, sound on/off, and exiting the game execute. Once a game is selected, the board loads with instructions for placing pieces on the board. The game starts as soon as the last piece(patrol boat) is placed on the player's board. Once a ship has been sunk, a message will display saying that respective ship has been destroyed and if the final ship is sunk, a winning message will dispaly. A new game can be started at any time using the F keys to select which level of play, turn on/off sound, or to return to the main menu as well as quit the game. All actions on the boards are set to be logged in a seperate text file for documentation and debugging. """ screen = init() print ("Drawing main menu.") title(screen) gamemode = 0 global gamedifficulty global soundon gamestarted = False spacetaken = 0 direction = 0 turn = 0 temp = 0 shipmessage ='' hit = pygame.mixer.Sound('resources\hit.ogg') miss = pygame.mixer.Sound('resources\miss.ogg') music = pygame.mixer.Sound('resources\TheLibertyBellMarch.ogg') # Continuous music music.play(loops = -1) #get current hostname enteredip = list(getIP()) while 1: mouseClicked = False for event in pygame.event.get(): pressed = pygame.key.get_pressed() # If the user clicks the x at the top of the window if event.type == pygame.QUIT: gamemode = 4 # If the user presses F1 elif pressed[pygame.K_F1]: gamemode = 1 gamestarted = False gamedifficulty = 0 # If the user presses F2 elif pressed[pygame.K_F2]: gamemode = 1 gamestarted = False gamedifficulty = 1 # If the user presses F3 elif pressed[pygame.K_F3]: gamemode = 1 gamestarted = False gamedifficulty = 2 # If the user presses F4 elif pressed[pygame.K_F4]: gamemode = 2 gamestarted = False # If the user presses F5 elif pressed[pygame.K_F5]: gamemode = 0 gamestarted = False #If the user presses F6 elif pressed[pygame.K_F6]: if (soundon == 1): pygame.mixer.pause() soundon = 0 elif (soundon == 0): pygame.mixer.unpause() soundon = 1 #If the user presses F12 elif pressed[pygame.K_F12]: gamemode = 4 # If the mouse is moved, record the current coordinates elif event.type == MOUSEMOTION: mousex, mousey = event.pos # If the mouse is clicked, say so and record the current coordinates elif event.type == MOUSEBUTTONUP: mousex, mousey = event.pos mouseClicked = True # Blanket catch for any other key press, keep this at the end! elif event.type == KEYDOWN: if event.key == K_BACKSPACE: enteredip = enteredip[0:-1] elif event.key == K_RETURN: pass elif (event.key >= 48 and event.key <= 57) or event.key == 46: enteredip.append(chr(event.key)) # If we're in gamemode 0, show the titlescreen if (gamemode == 0): gamemode = title(screen, mousex, mousey, mouseClicked) if gamemode != 0: continue # If we're in gamemode 1, show the game screen if (gamemode == 1): if not gamestarted: print ("Starting a new game") single(screen) place = 0 spacetaken = 0 turn = 0 playerboard = board() playerattackboard = board() cpuboard = board() cpuattackboard = board() comp = AI() comp.placeships(shiparray, cpuboard) gamestarted = True if (place == 0): singleinstructions(screen, 'Please place the Aircraft Carrier on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 475, 500) elif (place == 1): singleinstructions(screen, 'Please place the Battleship on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 475, 500) elif (place == 2): singleinstructions(screen, 'Please place the Submarine on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 475, 500) elif (place == 3): singleinstructions(screen, 'Please place the Destroyer on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 475, 500) elif (place == 4): singleinstructions(screen, 'Please place the Patrol Boat on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 475, 500) elif (place == 5): singleinstructions(screen, 'Please select spot on attack board to start game', 'Click to place ships down from point, hold space and click to place ships right from point', 475, 500) #else: #singleinstructions(screen, '', '', 475, 500) drawboards(playerattackboard, playerboard, screen, XMARGIN, XMARGIN2) boxx2, boxy2 = whatbox(mousex, mousey, XMARGIN2) # user places ships on board if (boxx2 != None and boxy2 != None) and mouseClicked: if (place < 5): checkplace = 0 spacepressed = pressed[pygame.K_SPACE] if not (spacepressed): hold = boxy2 if ((shiparray[place]+boxy2) < 11): if (checkplace == 0): for y in range(shiparray[place]): if ((playerboard.returnpiece(boxx2,hold)) != 0): checkplace = 1 else: hold = hold + 1 for y in range(shiparray[place]): if (checkplace == 1): break else: playerboard.setpiece(shiparray[place],boxx2,boxy2) boxy2 = boxy2 + 1 if (y == (shiparray[place]-1)): place = place + 1 elif (spacepressed): hold = boxx2 if ((shiparray[place]+boxx2) < 11): if (checkplace == 0): for x in range(shiparray[place]): if ((playerboard.returnpiece(hold,boxy2)) != 0): checkplace = 1 else: hold = hold + 1 for x in range(shiparray[place]): if (checkplace == 1): break else: playerboard.setpiece(shiparray[place],boxx2,boxy2) boxx2 = boxx2 + 1 if (x == (shiparray[place]-1)): place = place + 1 boxx, boxy = whatbox(mousex, mousey, XMARGIN) # game ready to play if (place >= 5): if (turn == 0): if (boxx != None and boxy != None) and mouseClicked: place = place + 1 temp = cpuboard.checkforhitormiss(boxx,boxy) if (temp == 9): blah = 0 else: playerattackboard.setpiece(temp,boxx,boxy) log_message('Player Move', playerattackboard.returnboard()) if (temp == 7): printstatus(screen, 'Miss') miss.play(loops = 0) else: printstatus(screen, 'Hit') hit.play(loops = 0) if (checkforwin(playerattackboard)): printstatus(screen, 'You win!') turn = -1 else: checkforshipsunk(playerattackboard, temp, screen) turn = 1 elif (turn == 1): if (gamedifficulty == 0): comp.attack(playerboard, cpuattackboard) log_message('Easy CPU Move', cpuattackboard.returnboard()) elif (gamedifficulty == 1): comp.attack2(playerboard, cpuattackboard) log_message('Harder CPU Move', cpuattackboard.returnboard()) elif (gamedifficulty == 2): comp.attack3(playerboard, cpuattackboard) log_message('Hardest CPU Move', cpuattackboard.returnboard()) if (checkforwin(cpuattackboard)): printstatus(screen, 'Computer Wins!') turn = -1 else: turn = 0 # If we're in gamemode 2, show the multiplayer screen if (gamemode == 2): option = multi(screen, "".join(enteredip), mousex, mousey, mouseClicked) if (option == 1): multi_game_init(None) ip = getIP() gamemode = 3 playernumber = 1 elif (option == 2): ip = "".join(enteredip) multi_game_init(ip) gamemode = 3 playernumber = 2 elif (option == 3): gamemode = 0 if (gamemode == 3): s = get_socket(ip) preamble = get_preamble(s) status, turn = preamble.split('.') status = int(status) turn = int(turn) boards = get_boards(s) if (status == 0): gamemode = 0 if not gamestarted: try: playernumber except NameError: print ('Something went horribly wrong... I don\'t know whose turn it is!') sys.exit(1) print ("Starting a new multiplayer game") single(screen) place = 0 spacetaken = 0 turn = 0 playerboard = board() playerattackboard = board() enemyboard = board() enemyattackboard = board() gameboards = [playerboard.returnboard(), playerattackboard.returnboard(), enemyboard.returnboard(), enemyattackboard.returnboard()] gamestarted = True if (place == 0): multiinstructions(screen, 'Please place the Aircraft Carrier on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 200, 20) elif (place == 1): multiinstructions(screen, 'Please place the Battleship on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 200, 20) elif (place == 2): multiinstructions(screen, 'Please place the Submarine on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 200, 20) elif (place == 3): multiinstructions(screen, 'Please place the Destroyer on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 200, 20) elif (place == 4): multiinstructions(screen, 'Please place the Patrol Boat on your board!', 'Click to place ships down from point, hold space and click to place ships right from point', 200, 20) boxx, boxy = whatbox(mousex, mousey, XMARGIN) boxx2, boxy2 = whatbox(mousex, mousey, XMARGIN2) # user places ships on board if (place < 5 and place >= 0): drawboards(playerattackboard, playerboard, screen, XMARGIN, XMARGIN2) if boxx2 != None and boxy2 != None and mouseClicked: checkplace = 0 spacepressed = pressed[pygame.K_SPACE] if not (spacepressed): hold = boxy2 if ((shiparray[place]+boxy2) < 11): if (checkplace == 0): for y in range(shiparray[place]): if ((playerboard.returnpiece(boxx2,hold)) != 0): checkplace = 1 else: hold = hold + 1 for y in range(shiparray[place]): if (checkplace == 1): break else: playerboard.setpiece(shiparray[place],boxx2,boxy2) boxy2 = boxy2 + 1 if (y == (shiparray[place]-1)): place = place + 1 elif (spacepressed): hold = boxx2 if ((shiparray[place]+boxx2) < 11): if (checkplace == 0): for x in range(shiparray[place]): if ((playerboard.returnpiece(hold,boxy2)) != 0): checkplace = 1 else: hold = hold + 1 for x in range(shiparray[place]): if (checkplace == 1): break else: playerboard.setpiece(shiparray[place],boxx2,boxy2) boxx2 = boxx2 + 1 if (x == (shiparray[place]-1)): place = place + 1 # game ready to play if (place > 6): if (turn == playernumber): multiinstructions(screen, 'Please select spot on attack board to start game', '', 100, 500) if (boxx != None and boxy != None) and mouseClicked: shipmessage = '' place = place + 1 temp = enemyboard.checkforhitormiss(boxx,boxy) if (temp == 9): pass else: playerattackboard.setpiece(temp,boxx,boxy) log_message('Player Move', playerattackboard.returnboard()) if (temp == 7): printstatus(screen, 'Miss') miss.play(loops = 0) else: printstatus(screen, 'Hit') hit.play(loops = 0) if (checkforwin(playerattackboard)): place = -1 else: temp_shipmessage = checkforshipsunk_multi(playerattackboard, temp, screen) if temp_shipmessage: shipmessage = temp_shipmessage gameboards = [playerboard.returnboard(), playerattackboard.returnboard(), enemyboard.returnboard(), enemyattackboard.returnboard()] send_boards(s, gameboards) else: #waiting for other player to play, don't accept clicks multiinstructions(screen, 'Please wait for your opponent to play!', shipmessage, 200, 250) if (playernumber == 1): playerboard.setboard(boards[0]) playerattackboard.setboard(boards[1]) enemyboard.setboard(boards[2]) enemyattackboard.setboard(boards[3]) else: playerboard.setboard(boards[2]) playerattackboard.setboard(boards[3]) enemyboard.setboard(boards[0]) enemyattackboard.setboard(boards[1]) drawboards_multi(playerattackboard, playerboard, screen, XMARGIN, XMARGIN2) if (place == 6): # waiting for server to signal game is started multiinstructions(screen, 'All Set!', 'Waiting for the other player to finish placing their ships...', 300, 20) if (status == 2): s.close() s = get_socket(ip) preamble = get_preamble(s) status, turn = preamble.split('.') status = int(status) turn = int(turn) boards = get_boards(s) if (playernumber == 1): playerboard.setboard(boards[0]) enemyboard.setboard(boards[2]) else: playerboard.setboard(boards[2]) enemyboard.setboard(boards[0]) place += 1 if (place == 5): multiinstructions(screen, 'All Set!', 'Waiting for the other player to finish placing their ships...', 300, 20) if (turn == playernumber): print ("Player ready", playernumber) gameboards = [playerboard.returnboard(), playerattackboard.returnboard(), enemyboard.returnboard(), enemyattackboard.returnboard()] send_boards(s, gameboards) place += 1 if (place == -1): printstatus(screen, 'You win!') s.close() # If we're in gamemode 4, we're quitting if (gamemode == 4): screen.fill(color['black']) font = pygame.font.Font('resources/alphbeta.ttf', 70) thanks = font.render("Thanks for playing!", False, color['white']) thanksRect = thanks.get_rect() thanksRect.center = (400, 300) screen.blit(thanks, thanksRect) pygame.mixer.quit() pygame.display.update() print('Quitting :[') pygame.time.wait(1500) pygame.quit() sys.exit(0) # redraw screen pygame.display.update() fpsClock.tick(60)
def makeObstacle(obstacleChoice, position, size, image, direction = 'left'): if (obstacleChoice == 'Giant rock'): return AI.soccerBall(position, size, image, direction) else: return AI.Obstacle((0,0), (0,0), pygame.Surface((0, 0)))
def useThunderDecision(self): decision = AI.useThunderAI(self.copy()) return decision
self.tactics.append(Tactics.Shove(self)) self.tactics.append(Tactics.Charge(self)) return AI.SuperAI.LostComponent(self, id) def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) def SmartZoneEvent(self, direction, id, robot, chassis): if id == 1 and self.weapons: if chassis: if direction == 1: self.botinzone = 1 if direction == -1: self.botinzone = 0 if id == 2: if robot > 0: if self.undered == 0: self.memory[0] = 0 file("adaptiveAI.txt", "w").write(str(self.memory)) self.randcheck = 0 self.undered = 1 return True AI.register(Snow)
def drawInterface(): guesses = settings["guesses"] colourNo = settings["colours"] pegNo = settings["pegs"] colourList = settings["colourList"] # Draw interface frame layout #================================================ frame = GUI.Frame(gameScr, relief=GUI.RAISED, borderwidth=1, bg="white") frame.pack(fill=GUI.BOTH, expand=1) # Draw game board #================================================ hintWidth = 8 + int((pegNo + 1) / 2) * 12 gridWidth = 50 * pegNo + hintWidth cvsGrid = GUI.Canvas(frame, width=gridWidth, height=((guesses + 1) * 50 + guesses), bg="white") cvsGrid.pack(side=GUI.RIGHT) gridPegs = [] hintPegs = [] row = 0 while row < guesses + 1: gridPegs.append([]) hintPegs.append([]) col = 0 while col < pegNo: # Draw rows of pegs #================================================ xPos = 50 * col + 3 yPos = 50 * row + row + 3 gridPegs[row].append(cvsGrid.create_oval(xPos, yPos, xPos + 44, yPos + 44, fill="black")) # Draw hint pegs #================================================ if row < guesses: hintX = 50 * pegNo + 6 + int(col / 2) * 12 if col % 2 == 0: hintY = 50 * row + 15 + row else: hintY = 50 * row + 27 + row hintPegs[row].append(cvsGrid.create_oval(hintX, hintY, hintX + 8, hintY + 8, fill="black")) # Separate rows with lines #================================================ if row != 0: cvsGrid.create_line(0, yPos - 3, gridWidth, yPos - 3) col += 1 row += 1 # Draw common interface buttons #================================================ btnQuit = GUI.Button(gameScr, text="Quit Game", fg="red", command=quitGame) btnQuit.pack(side=GUI.RIGHT) btnMenu = GUI.Button(gameScr, text="Back to Menu", command=openMenu) btnMenu.pack(side=GUI.RIGHT) btnRestart = GUI.Button(gameScr, text="Restart Game", command=restartGame) btnRestart.pack(side=GUI.RIGHT) btnNew = GUI.Button(gameScr, text="New Game", command=newGame) btnNew.pack(side=GUI.RIGHT) # Draw human codebreaker buttons #================================================ if settings["mode"] == 1: for i in range(0, colourNo): btnColour = GUI.Button(frame, text=colourList[i], bg=colourList[i], width=12, height=5, command=lambda a=colourList[i]: selectPeg(a)) btnColour.pack(anchor=GUI.W) btnDel = GUI.Button(frame, text="Undo", width=12, command=undo) btnDel.pack(anchor=GUI.W) btnSave = GUI.Button(gameScr, text="Save Game", command=lambda a=settings, b=gameEnded: file.saveGame(a, b)) btnSave.pack(side=GUI.RIGHT) # Draw CPU codebreaker buttons #================================================ if settings["mode"] == 2: btnAI = GUI.Button(gameScr, text="Start AI", fg="blue", command=lambda a=settings, b=GUI, c=gameScr, d=gameEnded, e=selectPeg: AI.startAI(a, b, c, d, e)) btnAI.pack(side=GUI.RIGHT) # Set up canvas objects for manipulation #================================================ settings["grid"] = gridPegs settings["hints"] = hintPegs settings["canvas"] = cvsGrid # Resume a loaded game #================================================ if load == True: loadGrid = loadData[0] loadHints = loadData[1] for row in range(0, settings["guesses"]): for col in range(0, settings["pegs"]): settings["canvas"].itemconfig(settings["grid"][row][col], fill=loadGrid[row][col]) settings["canvas"].itemconfig(settings["hints"][row][col], fill=loadHints[row][col])
while 1: for trigger in self.trigger2: self.Input(trigger, 0, 1) for i in range(0, 8): yield 0 def LostComponent(self, id): # if we lose all our weapons, stop using the Engage tactic and switch to Shove if id in self.weapons: self.weapons.remove(id) if not self.weapons: tactic = [x for x in self.tactics if x.name == "Engage"] if len(tactic) > 0: self.tactics.remove(tactic[0]) self.tactics.append(Tactics.Shove(self)) self.tactics.append(Tactics.Charge(self)) return AI.SuperAI.LostComponent(self, id) def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) AI.register(OmniVSpinner)
def main(twoPlayer, playComputer, White, Black): black_player = chessboard.setBlack() white_player = chessboard.setWhite() players = chessboard.Players() for sprites in black_player.sprites(): players.add(sprites) for sprites in white_player.sprites(): players.add(sprites) black_pieces = black_player.sprites() white_pieces = white_player.sprites() Pieces = black_pieces + white_pieces blackPiece = [] whitePiece = [] screen = pygame.display.set_mode((640, 640)) gridsquare = chessboard.convert(pygame.Surface((80, 80)).convert_alpha()) board = pygame.image.load('chessboard.gif').convert() board = pygame.transform.scale(board, (640, 640)) clearBoard = pygame.image.load('chessboard.gif').convert() clearBoard = pygame.transform.scale(clearBoard, (640, 640)) players.draw(board) screen.blit(board, (0, 0)) grid = [] newPiece = None for y in range(0, 640, 80): for x in range(0, 640, 80): occupied = False for piece in Pieces: if piece.xpos == x + 40 and piece.ypos == y + 40: occupied = True newPiece = piece if occupied: s = chessboard.Square(gridsquare, x, y, newPiece) #screen.blit(s.image, (x, y)) grid.append(s) else: s = chessboard.Square(gridsquare, x, y, None) #screen.blit(s.image, (x, y)) grid.append(s) pygame.display.update() checkmate = False stalemate = False turn = True whiteKing = None blackKing = None whiteCount = 0 blackCount = 0 while True: while not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() if twoPlayer: while turn and not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() turn = user.movement_whitePlayer(white_player, event, grid, whitePiece, screen, board, clearBoard, black_player, players) black_pieces = black_player.sprites() if len(black_pieces) == 1: whiteCount += 1 for black_piece in black_player: if type(black_piece) == chessboard.King: blackKing = black_piece checkmate = blackKing.checkmate(black_player, white_player, grid) stalemate = blackKing.stalemate(black_player, white_player, grid) if whiteCount == 50: stalemate = True elif len(white_pieces) == 1 and len(black_pieces) == 1: stalemate = True while not turn and not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() turn = user.movement_blackPlayer(black_player, event, grid, blackPiece, screen, board, clearBoard, white_player, players) white_pieces = white_player.sprites() if len(white_pieces) == 1: blackCount += 1 for white_piece in white_player: if type(white_piece) == chessboard.King: whiteKing = white_piece if not checkmate and not stalemate: checkmate = whiteKing.checkmate(white_player, black_player, grid) stalemate = whiteKing.stalemate(white_player, black_player, grid) if blackCount == 50: stalemate = True elif len(white_pieces) == 1 and len(black_pieces) == 1: stalemate = True elif playComputer: if White: while turn and not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() turn = user.movement_whitePlayer(white_player, event, grid, whitePiece, screen, board, clearBoard, black_player, players) black_pieces = black_player.sprites() if len(black_pieces) == 1: whiteCount += 1 for black_piece in black_player: if type(black_piece) == chessboard.King: blackKing = black_piece checkmate = blackKing.checkmate(black_player, white_player, grid) stalemate = blackKing.stalemate(black_player, white_player, grid) if whiteCount == 50: stalemate = True elif len(white_pieces) == 1 and len(black_pieces) == 1: stalemate = True if not turn and not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() turn = AI.movement_blackPlayer(black_player, event, grid, screen, board, clearBoard, white_player, players) white_pieces = white_player.sprites() if len(white_pieces) == 1: blackCount += 1 for white_piece in white_player: if type(white_piece) == chessboard.King: whiteKing = white_piece if not checkmate and not stalemate: checkmate = whiteKing.checkmate(white_player, black_player, grid) stalemate = whiteKing.stalemate(white_player, black_player, grid) if blackCount == 50: stalemate = True elif len(white_pieces) == 1 and len(black_pieces) == 1: stalemate = True #turn = True elif Black: if turn and not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() turn = AI.movement_whitePlayer(white_player, event, grid, screen, board, clearBoard, black_player, players) black_pieces = black_player.sprites() if len(black_pieces) == 1: whiteCount += 1 for black_piece in black_player: if type(black_piece) == chessboard.King: blackKing = black_piece checkmate = blackKing.checkmate(black_player, white_player, grid) stalemate = blackKing.stalemate(black_player, white_player, grid) if whiteCount == 50: stalemate = True elif len(white_pieces) == 1 and len(black_pieces) == 1: stalemate = True while not turn and not checkmate and not stalemate: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() turn = user.movement_blackPlayer(black_player, event, grid, blackPiece, screen, board, clearBoard, white_player, players) white_pieces = white_player.sprites() if len(white_pieces) == 1: blackCount += 1 for white_piece in white_player: if type(white_piece) == chessboard.King: whiteKing = white_piece if not checkmate and not stalemate: checkmate = whiteKing.checkmate(white_player, black_player, grid) stalemate = whiteKing.stalemate(white_player, black_player, grid) if blackCount == 50: stalemate = True elif len(white_pieces) == 1 and len(black_pieces) == 1: stalemate = True text = pygame.font.Font(None, 25) prompt = None if blackKing.checkmate(black_player, white_player, grid): prompt = text.render("White Won: Press Y to play again, Press N for menu", True, (0, 0, 255)) elif whiteKing.checkmate(white_player, black_player, grid): prompt = text.render("Black Won: Press Y to play again, Press N for menu", True, (0, 0, 255)) elif stalemate: prompt = text.render("Draw: Press Y to play again, Press N for menu", True, (0, 0, 255)) players.clear(board, clearBoard) players.draw(board) screen.blit(board, (0, 0)) select = False while not select: screen.blit(prompt, (0, 320)) pygame.display.update() pygame.event.pump() keys = pygame.key.get_pressed() if keys[pygame.K_y]: players.clear(board, clearBoard) players.empty() black_player = chessboard.setBlack() white_player = chessboard.setWhite() for sprites in black_player.sprites(): players.add(sprites) for sprites in white_player.sprites(): players.add(sprites) black_pieces = black_player.sprites() white_pieces = white_player.sprites() Pieces = black_pieces + white_pieces blackPiece = [] whitePiece = [] players.draw(board) screen.blit(board, (0, 0)) grid = [] newPiece = None for y in range(0, 640, 80): for x in range(0, 640, 80): occupied = False for piece in Pieces: if piece.xpos == x + 40 and piece.ypos == y + 40: occupied = True newPiece = piece if occupied: s = chessboard.Square(gridsquare, x, y, newPiece) #screen.blit(s.image, (x, y)) grid.append(s) else: s = chessboard.Square(gridsquare, x, y, None) #screen.blit(s.image, (x, y)) grid.append(s) pygame.display.update() checkmate = False stalemate = False turn = True whiteKing = None blackKing = None whiteCount = 0 blackCount = 0 select = True elif keys[pygame.K_n]: menu.main()
self.max_turn_speed = 3 def Activate(self, active): if active: if AI.SuperAI.debugging: self.debug = Gooey.Plain("watch", 0, 75, 100, 75) tbox = self.debug.addText("line0", 0, 0, 100, 15) tbox.setText("Throttle") tbox = self.debug.addText("line1", 0, 15, 100, 15) tbox.setText("Turning") tbox = self.debug.addText("line2", 0, 30, 100, 15) tbox.setText("") tbox = self.debug.addText("line3", 0, 45, 100, 15) tbox.setText("") return AI.SuperAI.Activate(self, active) def LostComponent(self, id): #print "Lost Component!" return AI.SuperAI.LostComponent(self, id) def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) AI.register(Pinner)
self.last_move = p.move(self.board, self.last_move.x, self.last_move.y) x, y = self.last_move.x, self.last_move.y bx, by = self.last_move.boardx, self.last_move.boardy self.mini[x][y] = '.' self.mark(self.board[bx][by]) print 'TURN: %d' % self.turn print self.board print '\nNext move:\n%s' % self.mini print '\n\n' #check win if self.check_win() != BLANK: print self.check_win() self.gameover = True self.winner = self.check_win() self.turn += 1 self.mini.clear() def check_win(self): return self.board.check_win() bb = big_board() bb.randomize() #bb.check_win() #print bb g = game(AI.random_bot(), AI.center_bot()) g.start_game(delay=0.1)
if self.wiggletimer >= 8: self.wiggletimer = -8 # fire everything we have as a last-ditch effort if we're still not free after 5 seconds if self.srimechtimer >= 20: self.srispintimer += 1 for trigger in self.triggers: self.Input(trigger, 0, 1) for trigger in self.trigger2: self.Input(trigger, 0, 1) if self.srispintimer < 7: self.Input("Spin1", 0, -100) self.Input("Spin2", 0, -100) if self.srispintimer >= 7: self.Input("Spin1", 0, 100) self.Input("Spin2", 0, 100) if self.srispintimer == 15: self.srispintimer = 0 else: self.srimechtimer = 0 self.srispintimer = 0 self.wiggletimer = -8 def LostComponent(self, id): # if we lose all our weapons, ignore it because ram tactics in reverse don't work well. if id in self.weapons: self.weapons.remove(id) return AI.SuperAI.LostComponent(self, id) AI.register(SwitchDirEcoOmni)
def __init__(self): # self.UsePushStart = True self.PushStartDepth = 0.5 self.Depth = 1 # self.DataTimeout = 2 self.MinProgress = 0.5 self.MinProgressSamples = 5 # self.FirstHeading = AI.OptionWithMeta(90, units=" degrees", opt_type=Bearing) self.TurnDistance = AI.OptionWithMeta( 25, docstring="Distance from wall at which to turn", units="m") self.TDError = AI.OptionWithMeta( 1, docstring="Acceptable error in distance", units="m") self.TDProportion = 5 self.TDClamp = AI.OptionWithMeta( 30, docstring="Highest speed at which to travel (pre-turning)", opt_type=MotorValue) self.TDTimeout = AI.OptionWithMeta( 0, docstring="Time to travel before giving up.", units="s") # self.SecondHeading = AI.OptionWithMeta(0, units=" degrees", opt_type=Bearing) self.SecondSpeed = AI.OptionWithMeta( 100, docstring="Speed to travel after turning", opt_type=MotorValue) self.SecondTime = AI.OptionWithMeta( 10, docstring="Time to travel, after turning", units="s") # self.ThirdHeading = AI.OptionWithMeta(180, units=" degrees", opt_type=Bearing) self.StopDistance = AI.OptionWithMeta( 2, docstring="Distance from back wall at which to finally stop.", units="m") self.SDError = AI.OptionWithMeta( 1, docstring="Acceptable error in distance.", units="m") self.SDProportion = 5 self.SDClamp = AI.OptionWithMeta( 30, docstring="Highest speed at which to travel in final section.", opt_type=MotorValue) self.SDTimeout = AI.OptionWithMeta( 0, docstring="Time to travel before giving up.", units="s")
if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) elif id == 4: self.debug.get("line4").setText(string) elif id == 5: self.debug.get("line5").setText(string) elif id == 6: self.debug.get("line6").setText(string) elif id == 7: self.debug.get("line7").setText(string) elif id == 8: self.debug.get("line8").setText(string) elif id == 9: self.debug.get("line9").setText(string) elif id == 10: self.debug.get("line10").setText(string) def ShiftConditionOk(self): #test condition to turn servo # true : turn servo, may 'restart' different counter for next test # false : condition not meet. # in this version, turn condition depends of timer. #return False self.servoCountDown -= 1 # count down if self.servoCountDown <= 0 : #Time to shift ! self.servoCountDown = self.servoTimer return True else: return False AI.register(ShiftWeapon3)
if self.GetPistonPosition(linacu) < -0.05: self.Input(self.trigger + str(n), 1, -100) self.Input(self.trigger + str(n), 0, 0) self.DebugString(7, "Descend") else: self.Input(self.trigger + str(n), 1, 0) self.DebugString(7, "Stop") n += 1 self.DebugString( 5, str(self.GetInputStatus(self.trigger, 0)) + " " + str(self.GetInputStatus(self.trigger, 1))) return bReturn def DebugString(self, id, string): if self.debug: if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) elif id == 4: self.debug.get("line4").setText(string) elif id == 5: self.debug.get("line5").setText(string) elif id == 6: self.debug.get("line6").setText(string) elif id == 7: self.debug.get("line7").setText(string) elif id == 8: self.debug.get("line8").setText(string) elif id == 9: self.debug.get("line9").setText(string) AI.register(Forklift)
if id == 0: self.debug.get("line0").setText(string) elif id == 1: self.debug.get("line1").setText(string) elif id == 2: self.debug.get("line2").setText(string) elif id == 3: self.debug.get("line3").setText(string) def SmartZoneEvent(self, direction, id, robot, chassis): if id == 1 and self.weapons: if robot > 0: if direction == 1: self.compinzone = 1 if chassis: self.botinzone = 1 if direction == -1: self.compinzone = 0 if chassis: self.botinzone = 0 elif id == 2 and not self.weapons and self.sweapons: if robot > 0: if direction == 1: self.compinzone = 1 if chassis: self.botinzone = 1 if direction == -1: self.compinzone = 0 if chassis: self.botinzone = 0 return True AI.register(SwitchWepPopup)
def runGame(MAP_NUMBER): ''' Set up initial player object. This object contains the following keys: surface: the image of the player facing: the direction the player is facing x: the left edge coordinate of the player on the window y: the top edge coordinate of the player on the window width: the width of the player image height: the height of the player image ''' # Initialize the player object p = player.Player( (HALF_WINWIDTH,HALF_WINHEIGHT), (PLAYER_WIDTH,PLAYER_HEIGHT), IMAGESDICT['player'] ) # initialize camera variables cam_x = HALF_WINWIDTH cam_y = HALF_WINHEIGHT ROCK_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['rock'], ROCK_BALL_SIZE) ROCK_IMG_SCALE_2 = pygame.transform.smoothscale(IMAGESDICT['rock2'], ROCK_BALL_SIZE) ROCK_IMG_SCALE_3 = pygame.transform.smoothscale(IMAGESDICT['rock3'], ROCK_BALL_SIZE) ROCK_IMG_SCALE_4 = pygame.transform.smoothscale(IMAGESDICT['rock4'], ROCK_BALL_SIZE) BANANA_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['banana_peel'], BANANA_PEEL_SIZE) SPIKES_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['spikes'], SPIKES_SIZE) SNAKE_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['snake'], SNAKE_SIZE) SNAKE_IMG_SCALE_2 = pygame.transform.smoothscale(IMAGESDICT['snake2'], SNAKE_SIZE_2) BIRD_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['bird'], BIRD_SIZE) BIRD_IMG_SCALE_2 = pygame.transform.smoothscale(IMAGESDICT['bird2'], BIRD_SIZE) SPIDER_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['spider'], SPIDER_SIZE) SPIDER_IMG_SCALE_2 = pygame.transform.smoothscale(IMAGESDICT['spider2'], SPIDER_SIZE) LOG_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['log'], LOG_SIZE) MUD_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['mud'], MUD_SIZE) MUD_IMG_SCALE_2 = pygame.transform.smoothscale(IMAGESDICT['mud2'], MUD_SIZE_2) TIDAL_WAVE_IMG_SCALE = pygame.transform.smoothscale(IMAGESDICT['tidalWave'], TIDAL_WAVE_SIZE) # Animations for various AI snakeAnimation = [SNAKE_IMG_SCALE, SNAKE_IMG_SCALE_2] birdAnimation = [BIRD_IMG_SCALE, BIRD_IMG_SCALE_2] spiderAnimation = [SPIDER_IMG_SCALE, SPIDER_IMG_SCALE_2] rockAnimation = [ROCK_IMG_SCALE, ROCK_IMG_SCALE_2, ROCK_IMG_SCALE_3, ROCK_IMG_SCALE_4] mudAnimation = [MUD_IMG_SCALE, MUD_IMG_SCALE_2] giantRock = AI.giantRock( ROCK_BALL_POSITION, ROCK_BALL_SIZE, ROCK_IMG_SCALE, LEFT ) # For storing our obstacles obstacleObjs = [] # obstacleObjs.append(makeObstacle('Giant rock', ROCK_BALL_POSITION, ROCK_BALL_SIZE, ROCK_IMG_SCALE)) # obstacleObjs.append(makeObstacle('Tidal wave', TIDAL_WAVE_POSITION, TIDAL_WAVE_SIZE, TIDAL_WAVE_IMG_SCALE)) ''' obstacleObjs.append(makeObstacle('Giant rock', ROCK_BALL_POSITION, ROCK_BALL_SIZE, ROCK_IMG_SCALE)) obstacleObjs.append(makeObstacle('Spikes', SPIKES_POSITION, SPIKES_SIZE, SPIKES_IMG_SCALE)) obstacleObjs.append(makeObstacle('Snake', SNAKE_POSITION, SNAKE_SIZE, SNAKE_IMG_SCALE)) obstacleObjs.append(makeObstacle('Bird', BIRD_POSITION, BIRD_SIZE, BIRD_IMG_SCALE)) obstacleObjs.append(makeObstacle('Spider', SPIDER_POSITION, SPIDER_SIZE, SPIDER_IMG_SCALE)) obstacleObjs.append(makeObstacle('Log', LOG_POSITION, LOG_SIZE, LOG_IMG_SCALE)) obstacleObjs.append(makeObstacle('Banana peel', BANANA_PEEL_POSITION, BANANA_PEEL_SIZE, BANANA_IMG_SCALE)) obstacleObjs.append(makeObstacle('Mud', MUD_POSITION, MUD_SIZE, MUD_IMG_SCALE)) ''' ballImage = pygame.transform.scale(IMAGESDICT['rock'], ROCK_BALL_SIZE) slipTimeElapsed = BANANA_PEEL_INIT_SLIP_TIME # Initialize moving variables moveLeft = False moveRight = False moveUp = False moveDown = False pygame.mixer.init() if MAP_NUMBER == 0: sprite_layers, player_sprite, player_layer, renderer = initializeLevel('ForestLevel.tmx',PLAYER_LAYER,p) pygame.mixer.music.load('Sounds/Level2.mp3') obstacleObjs.append(makeObstacle('Giant rock', ROCK_BALL_POSITION, ROCK_BALL_SIZE, ROCK_IMG_SCALE)) elif MAP_NUMBER == 1: sprite_layers, player_sprite, player_layer, renderer = initializeLevel('SandLevel.tmx',PLAYER_LAYER,p) pygame.mixer.music.load('Sounds/NeroNewLifeCut.mp3') obstacleObjs.append(makeObstacle('Tidal wave', TIDAL_WAVE_POSITION, TIDAL_WAVE_SIZE, TIDAL_WAVE_IMG_SCALE)) pygame.mixer.music.play(0) frame_count = 0 while True: # main game loop # update player sprite sprite_layers[PLAYER_LAYER].remove_sprite(player_sprite) player_sprite = p.get_sprite() sprite_layers[PLAYER_LAYER].add_sprite(player_sprite) # reset applicable variables step_x = 0 step_y = 0 # This loop will handle all of the player input events for event in pygame.event.get(): if event.type == QUIT: terminate() elif event.type == KEYDOWN: if event.key in (K_UP, K_w, K_SPACE): moveDown = False moveUp = True elif event.key in (K_DOWN, K_s): moveUp = False moveDown = True elif event.key in (K_LEFT, K_a): moveRight = False moveLeft = True elif event.key in (K_RIGHT, K_d): moveLeft = False moveRight = True elif event.type == KEYUP: # stop moving the player if event.key in (K_LEFT, K_a): moveLeft = False elif event.key in (K_RIGHT, K_d): moveRight = False elif event.key in (K_UP, K_w, K_SPACE): moveUp = False elif event.key in (K_DOWN, K_s): moveDown = False elif event.key == K_ESCAPE: terminate() ''' All the jumping and gravity is handled here. If the player is jumping we move them up, otherwise they are moving down (gravity). We can alter how quickly the player jumps by altering the moverate or jump duration. ''' if p.isJumping(): t = pygame.time.get_ticks() - jumpingStart if t > JUMPING_DURATION: p.jumping = False p.change_sprite( IMAGESDICT['jump1'] ) elif t > JUMPING_DURATION / 2: p.change_sprite( IMAGESDICT['jump4'] ) if t < JUMPING_DURATION and t > 0: step_y -= MOVERATE elif not p.isJumping(): step_y += MOVERATE # actually move the player if moveLeft: step_x -= MOVERATE if moveRight: step_x += MOVERATE if not p.isJumping(): if frame_count is 20: p.change_sprite( IMAGESDICT['run1'] ) elif frame_count is 40: p.change_sprite( IMAGESDICT['run2'] ) elif frame_count is 60: p.change_sprite( IMAGESDICT['run3'] ) elif frame_count is 80: p.change_sprite( IMAGESDICT['run4'] ) if frame_count > 80: frame_count = 0 if moveUp: if not p.isJumping() and p.isOnGround(): p.jumping = True p.onGround = False p.change_sprite( IMAGESDICT['jump2'] ) jumpingStart = pygame.time.get_ticks() step_y -= 60 if check_game_end(p,step_x,step_y,sprite_layers[DEATH_LAYER]): print 'Collided with death layer' elif check_game_end(p,step_x,step_y,sprite_layers[WIN_LAYER]): print 'Collided with win layer' elif p.get_rect().left <= (cam_x-HALF_WINWIDTH): print 'Collided with left end of screen' step_x, step_y = check_collision(p,step_x,step_y,sprite_layers[COLL_LAYER]) # Apply the steps to the player and the player rect p.x += step_x p.y += step_y player_sprite.rect.midbottom = (p.x, p.y) # Set the new camera position renderer.set_camera_position_and_size(cam_x, cam_y, WINWIDTH, WINHEIGHT) # Draw the background SCREEN.fill((0, 0, 0)) # render the map including the player for sprite_layer in sprite_layers: if sprite_layer.is_object_group: # we dont draw the object group layers # you should filter them out if not needed continue else: renderer.render_layer(SCREEN, sprite_layer) # Collision debugging # pygame.draw.rect(SCREEN, (0, 0, 0), (p.x, p.y, p.width, p.height)) # pygame.draw.rect(SCREEN, (0, 0, 0), (obstacleObjs[0].xPos, obstacleObjs[0].yPos, obstacleObjs[0].width, obstacleObjs[0].height)) # pygame.draw.rect(SCREEN, (255, 0, 255), (obstacleObjs[1].xPos, obstacleObjs[1].yPos, obstacleObjs[1].width, obstacleObjs[1].height)) obstacleChoice = random.randint(1, 4) if (cam_x % 100 == 0): if (obstacleChoice == 1): obstacleObjs.append(makeObstacle('Bird', BIRD_POSITION, BIRD_SIZE, BIRD_IMG_SCALE)) elif (obstacleChoice == 2): obstacleObjs.append(makeObstacle('Snake', SNAKE_POSITION, SNAKE_SIZE, SNAKE_IMG_SCALE)) elif (obstacleChoice == 3): obstacleObjs.append(makeObstacle('Banana peel', BANANA_PEEL_POSITION, BANANA_PEEL_SIZE, BANANA_IMG_SCALE)) else: obstacleObjs.append(makeObstacle('Spider', SPIDER_POSITION, SPIDER_SIZE, SPIDER_IMG_SCALE)) ''' We need specific drawing cases for different obstacles, since every obstacle could have different methods defined for drawing executions. This is what we do below. ''' ''' Here, we have backwards-list checking to avoid a common object deletion mistake. ''' for i in range(len(obstacleObjs) - 1, -1, -1): # Player collision checking with the obstacles. pygame.draw.rect(SCREEN, (0, 0, 0), (p.x, p.y, p.width, p.height)) # if p.isTouching(obstacleObjs[i].xPos, obstacleObjs[i].yPos, obstacleObjs[i].yPos + obstacleObjs[i].height): # soundObj = pygame.mixer.Sound('Sounds/Spikes.wav') # soundObj.play() # Collision boundary drawing (for debug) # pygame.draw.rect(SCREEN, GRAY_1, (obstacleObjs[i].xPos, obstacleObjs[i].yPos, obstacleObjs[i].width, obstacleObjs[i].height)) # Checking if a particular object is a rock. if isinstance(obstacleObjs[i], AI.giantRock): obstacleObjs[i].setSpeed(ROCK_SPEED) obstacleObjs[i].doGiantRockAction(p, floorY() - 40, ROCK_GRAVITY, WINWIDTH) # CHOPPED_ROCK = pygame.transform.rotozoom(obstacleObjs[i].image, obstacleObjs[i].giantRockRotate(ROCK_ROTATE_INCREMENT), 2.0) # CHOPPED_ROCK = pygame.transform.scale(CHOPPED_ROCK, obstacleObjs[i].image.get_size()) SCREEN.blit(rockAnimation[obstacleObjs[i].animateToNext(2, 8)], obstacleObjs[i].get_rect()) # Checking if a particular object is a banana peel. elif isinstance(obstacleObjs[i], AI.bananaPeel): obstacleObjs[i].setHoriAndVertRiseSpeeds(BANANA_PEEL_HORI_RISE_SPEED, BANANA_PEEL_VERT_RISE_SPEED) obstacleObjs[i].doBananaPeelAction(p, floorY() + 180, ROCK_GRAVITY, BANANA_PEEL_TIME_TO_RISE, WINWIDTH) obstacleObjs[i].move(-CAM_X_INCREMENT, 0) BANANA_IMG_ROT = pygame.transform.rotate(obstacleObjs[i].image, obstacleObjs[i].slipRotate(floorY(), BANANA_ROTATE_FIRST, BANANA_ROTATE_SECOND)) blit_alpha(SCREEN, BANANA_IMG_ROT, obstacleObjs[i].get_rect(), obstacleObjs[i].doFadeOutBananaPeel(BANANA_PEEL_FADE_DECREMENT)) # Has the banana peel faded to 0 after being slipped on? # (This check has been validated) if obstacleObjs[i].getBananaPeelFadeAmount() <= 0: del obstacleObjs[i] # Checking if a particular object represents the spikes # elif isinstance(obstacleObjs[i], AI.spikes): # obstacleObjs[i].spikeBump(p) # SCREEN.blit(obstacleObjs[i].image, obstacleObjs[i].get_rect()) # Checking if the object is a tree log elif isinstance(obstacleObjs[i], AI.treeLog): obstacleObjs[i].collidedHardWith(p) SCREEN.blit(obstacleObjs[i].image, obstacleObjs[i].get_rect()) # Checking if the object is a snake elif isinstance(obstacleObjs[i], AI.snake): obstacleObjs[i].setFrameRate(SNAKE_FRAME_RATE) if (obstacleObjs[i].doSnakeAction(SNAKE_SPEED)): SCREEN.blit(snakeAnimation[0], obstacleObjs[i].get_rect()) else: SCREEN.blit(snakeAnimation[1], obstacleObjs[i].get_rect()) if (obstacleObjs[i].xPos + obstacleObjs[i].width < 0): del obstacleObjs[i] # Checking if the object is a bird elif isinstance(obstacleObjs[i], AI.bird): obstacleObjs[i].setFrameRate(BIRD_FRAME_RATE) if (obstacleObjs[i].doBirdAction(BIRD_SPEED)): SCREEN.blit(birdAnimation[0], obstacleObjs[i].get_rect()) else: SCREEN.blit(birdAnimation[1], obstacleObjs[i].get_rect()) if (obstacleObjs[i].xPos + obstacleObjs[i].width < 0): del obstacleObjs[i] # Checking if the object is a spider elif isinstance(obstacleObjs[i], AI.spider): obstacleObjs[i].setFrameRate(SPIDER_FRAME_RATE) obstacleObjs[i].move(-CAM_X_INCREMENT, 0) if (obstacleObjs[i].doSpiderAction(SPIDER_SPEED)): SCREEN.blit(spiderAnimation[0], obstacleObjs[i].get_rect()) else: SCREEN.blit(spiderAnimation[1], obstacleObjs[i].get_rect()) obstacleObjs[i].setWebStringRect(obstacleObjs[i].xPos + obstacleObjs[i].width/2, obstacleObjs[i].yPos - 50, 2, 50) pygame.draw.rect(SCREEN, GRAY_1, obstacleObjs[i].getWebStringRect()) # Checking if the object represents the mud elif isinstance(obstacleObjs[i], AI.mud): obstacleObjs[i].setFrameRate(MUD_FRAME_RATE) if (obstacleObjs[i].doMudAction(MUD_FRAME_RATE)): SCREEN.blit(mudAnimation[0], obstacleObjs[i].get_rect()) else: SCREEN.blit(mudAnimation[1], obstacleObjs[i].get_rect()) # Default for drawing any other obstacles elif isinstance(obstacleObjs[i], AI.tidalWave): SCREEN.blit(obstacleObjs[i].image, obstacleObjs[i].get_rect()) cam_x += CAM_X_INCREMENT frame_count += 1 pygame.display.update() FPSCLOCK.tick()
sendmsg(channel,stats.runCommands(channel,nick,commandChar,ircmsg,ircsock,hostmask)) except: pass if Trivial.birthday(nick,BWBellairsTrue) != False: for i in Trivial.birthday(nick,BWBellairsTrue): sendmsg(channel,i) BWBellairsTrue = False if config.config.enableQuizCheat: a = QuizSolver.phraseChat(ircmsg,nick) sendmsg(channel,a) #TEMP TEST!! if ircmsg.split(" :",1)[1].startswith("bowserbot") or ircmsg.lower().split(" :",1)[1].startswith(botnick.lower()): if "aegisserver2" not in ircmsg.lower(): AI.phraseText(ircmsg.lower().split(" :",1)[1].replace('bowserbot','').replace(botnick.lower(),""),channel,nick,hostmask,ircsock,botnick) #Auto rejoin for channel in channels: if ircmsg.lower().find("kick " + channel.lower() + " " + botnick.lower()) != -1: joinchan(channel) time.sleep(1) joinchan(channel) if ircmsg.lower().find("part " + channel.lower()) != -1: joinchan(channel) time.sleep(1) joinchan(channel)