class TestOutputQueue(unittest.TestCase): def setUp(self): self.computer = Computer() def test_queue_has_correct_values(self): self.computer.load_program([["print_mem", ["0"]], ["print_char", ["0"]]], [33]) self.computer.run_program() self.failUnlessEqual(self.computer.output_queue[0], 33) self.failUnlessEqual(self.computer.output_queue[1], "!")
class TestProgramCounter(unittest.TestCase): def setUp(self): self.computer = Computer() def test_pc_ends_with_correct_value(self): self.computer.load_program( [["load", [-1, "1"]], ["jump_if_pos", ["1", 2]], ["load", [1, "2"]], ["load", [2, "3"]]] # Should run ) self.computer.run_program() self.failUnlessEqual(self.computer.pc, 4)
class TestInputLoading(unittest.TestCase): def setUp(self): self.computer = Computer() def test_inputs_loaded(self): self.computer.load_program( [["load", [-1, "1"]], ["jump_if_pos", ["1", 2]], ["load", [1, "2"]], ["load", [2, "3"]]], # Should run [5, 4, 3, 2, 1], ) self.failUnlessEqual(self.computer.memory["0"].value, 5) self.failUnlessEqual(self.computer.memory["4"].value, 1)
def mkComputerArena(screen, x, y, id): if id.isupper(): computer = Computer(screen, x, y, radius=30) computer.count = 15 else: computer = Computer(screen, x, y, radius=15) computer.count = 5 if id == "A" or id == "B": computer.changeOwner("RED") computer.count = 10 elif id == "Y" or id == "Z": computer.changeOwner("GREEN") computer.count = 10 return computer
def get_computers(): c = [] # Lawson c.extend(Computer.many("K9", "%02d", "LWSN B160", 0, 25)) # c.extend(Computer.many("HA", "%02d", "HAAS G56", 0, 24)) # MC01-MC18 are servers return c
def __init__(self, program, inputs): super(ProgramResult, self).__init__() self.program = program self.computer = Computer() self.computer.load_program(program) self.output = None self.memory = None self.was_killed = False
def get_computers(): c = [] #Lawson c.extend(Computer.many("SAC", "%02d", "LWSN B131", 1, 13)) c.extend(Computer.many("MOORE", "%02d", "LWSN B146", 0, 24)) c.extend(Computer.many("SSLAB", "%02d", "LWSN B158", 0, 24)) #POD Lab c.append(Computer("POD0-0", "POD", "LWSN B148")) c.extend(Computer.many("POD", "1-%d", "LWSN B148", 1, 5)) c.extend(Computer.many("POD", "2-%d", "LWSN B148", 1, 5)) c.extend(Computer.many("POD", "3-%d", "LWSN B148", 1, 5)) c.extend(Computer.many("POD", "4-%d", "LWSN B148", 1, 5)) c.extend(Computer.many("POD", "5-%d", "LWSN B148", 1, 5)) #HAAS c.extend(Computer.many("BORG", "%02d", "HAAS G40", 0, 24)) c.extend(Computer.many("XINU", "%02d", "HAAS 257", 0, 21)) #MC01-MC18 are servers return c
class ProgramResult(object): """Holds a program and it's output/score""" def __init__(self, program, inputs): super(ProgramResult, self).__init__() self.program = program self.computer = Computer() self.computer.load_program(program) self.output = None self.memory = None self.was_killed = False def run_program(self): def target(): self.computer.run_program() self.was_killed = False thread = threading.Thread(target=target) thread.start() thread.join(TIMEOUT) if thread.is_alive(): self.computer.kill_program() self.was_killed = True thread.join() self.output = self.computer.output_queue self.memory = self.computer.memory
def main(): print("LET'S PLAY ROCK-PAPER-SCISSORS!!\n") name = input("What is your name? ") human = Human(name) computer = Computer() cont = "yes" # rounds while cont.lower() == "yes": human.setChoice(input("Rock, Paper, Scissors? ")) computer.makeChoice() print("The computer chose " + computer.getChoice()) # determine winner of round humanChoice = human.getChoice() compChoice = computer.getChoice() if ((humanChoice == "Paper" and compChoice == "Rock") or (humanChoice == "Rock" and compChoice == "Scissors") or (humanChoice == "Scissors" and compChoice == "Paper")): winner = human elif (humanChoice == compChoice): winner = None else: winner = computer if winner: print("The winner is " + winner.getName()) winner.addScore() else: print("Cats Game!") cont = input("Want to play another round? (yes/no)") #calculating winner if human.getScore() > computer.getScore(): winner = human loser = computer elif human.getScore() == computer.getScore(): winner = None loser = None else: winner = computer loser = human if winner: print("Thanks for playing!! " + winner.getName() + " is the winner." ) print(winner.getName() + ": " + str(winner.getScore()) + "\n" + loser.getName() + ": " + str(loser.getScore())) else: print("Thanks for playing!! Your game ended as a cats game, tied at " + str(human.getScore()))
def handle_human_players_input(self, event): if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: self.logger.info("Making Player {0}".format(self.name)) self.players.append(Human( self.name, self.avatars[self.current_number - 1], self.offsets[self.current_number - 1][0], self.offsets[self.current_number - 1][1])) self.current_number += 1 self.name = "" if self.current_number > self.player_number: self.logger.info("Creating Bots") for i in range(self.current_number, 5): self.players.append(Computer( self.name, self.avatars[i - 1], self.offsets[i - 1][0], self.offsets[i - 1][1], 50)) self.switch_scene(QueryMode(self.players)) elif event.key == pygame.K_BACKSPACE: self.name = self.name[:-1] else: key = pygame.key.name(event.key) if key in string.ascii_lowercase: self.name += key self.name = self.name.capitalize()
def single_player(self): """ single player game against the computer, with option for easy/hard mode :return: """ mode = input('Choose game mode (easy/hard): ').lower() while mode not in ['easy', 'hard']: mode = input('please enter a valid input: ') self.player1 = Computer(mode) self.player0.place_battleships() self.player1.place_battleships() while True: result = self.player0.turn(self.player1) if result == 'win': print('player 0 has won!') return result = self.player1.turn(self.player0) if result == 'win': print('player 1 has won!') return
def run_computers(phases: Tuple, code: List[int]) -> int: computers = [] for phase in phases: computer = Computer(copy(code)) computer.inputs.append(phase) computers.append(computer) i = -1 computers[0].inputs.append(0) while True: i = (i + 1) % 5 while not computers[i].done: try: computers[i].run() except OutputInterrupt: next_val = computers[i].outputs[-1] computers[(i + 1) % 5].inputs.append(next_val) continue except InputInterrupt: break if all(map(lambda comp: comp.done, computers)): break return computers[0].inputs[-1]
def __init__(self, playerCount=2, deckSize=6, comp=1): self.__deck = Deck(deckSize) self.__engineStart = deckSize self.__players = [] for i in range(comp): self.__players.append(Computer(playerCount)) for i in range(playerCount - comp): self.__players.append(Human()) if playerCount > 2: self.__largeGame = True else: self.__largeGame = False self.__passed = [False for i in range(playerCount)] self.__stacks = [[] for i in range(playerCount)] self.__playNext = [[self.__engineStart] for i in range(playerCount)] self.__currentTurn = 0 self.__engine = self.__engineStart self.__engineSet = False self.__passMessage = 'Passed.'
def testPlayWithComputer(self): print "testPlayWithComputer" with mock.patch('Computer.Computer.generatePosibleNumber', return_value='1234'): computer = Computer() # computer.setNumber("1234") goods, regulars = computer.ask("1567") # 1 good self.assertEqual(1, goods) self.assertEqual(0, regulars) goods, regulars = computer.ask("0356") # 1 regular self.assertEqual(0, goods) self.assertEqual(1, regulars) goods, regulars = computer.ask("9831") # 1 good and 1 regular self.assertEqual(1, goods) self.assertEqual(1, regulars) goods, regulars = computer.ask("1243") # 2 goods and 2 regulars self.assertEqual(2, goods) self.assertEqual(2, regulars) goods, regulars = computer.ask("1234") # 4 goods and you win! self.assertEqual(4, goods) self.assertEqual(0, regulars)
def __init__(self): self.roundNumber = 1 self.stockPile = [] self.layout = [] self.humanHand = [[], [], []] self.computerHand = [[], [], []] self.humanCapture = [[], [], []] self.computerCapture = [[], [], []] self.numComPlayers = 0 self.numHumPlayers = 0 #Initalize classes here self.s = Serialization() self.deck = Deck() self.player = Player() self.computer1 = Computer() self.computer2 = Computer() self.computer3 = Computer() self.human1 = Human() self.human2 = Human() self.human3 = Human()
def setUp(self): self.computer = Computer()
from Computer import Computer, StopReason from Point2D import Point2D with open("input.txt","r") as program_data: program = program_data.readline().strip('\n') grid = dict() startPoint = Point2D(0,0) direction = # PART 1 computer = Computer(program,[0]) output = computer.run_program() print(output[0])
''' Created on Feb 4, 2010 @author: tim for cs44 w10 ''' from State import State from Computer import Computer import sys if __name__ == '__main__': if len(sys.argv) > 1: file = sys.argv[1] try: ev = sys.argv[2] #optional to check strings individually except: pass else: print "usage: eval-c4 filenamewithstate" sys.exit(0) lines = open(file).readlines() s = State() c = Computer(s) s.decode("".join(lines)) print c.utility(s) try: print c.evaluate([ev]) except: pass
def test_input(test_input, expected): computer = Computer([3, 9, 8, 9, 10, 9, 4, 9, 99, -1, 8]) assert computer.compute(test_input) == expected
def RestartComputer(self): computer = Computer() computer.LoadProgram(self._computer.GetOriginalProgram()) self._computer = computer
def mkComputer(screen, x, y, id): if id.isupper(): if id == "Z": computer = Computer(screen, x, y, radius=60) computer.count = 150 else: computer = Computer(screen, x, y, radius=30) computer.count = 15 else: computer = Computer(screen, x, y, radius=15) computer.count = 5 if id == "a": computer.changeOwner("RED") computer.count = 10 elif id == "G": computer = Computer(screen, x, y, radius=15) computer.changeOwner("GREEN") computer.count = 10 return computer
class Simulation: """ Clase Simulación. En esta clase se controla la simulación basada en eventos. En esta clase se implementan los métodos que se debe realizar para cada evento en específico (LMC1, LMC2, LMC3, SMC1, SMC2P1, SMC2P2, SCM3) """ # Constructor def __init__(self): self.clock = 0.0 # Reloj de la simulacion self.number_of_runs = 0 # Cantidad de veces a ejecutar la simulacion self.simulation_time = 0.0 # Tiempo de simulacion por corrida self.max = 0.0 # Valor utilizado como infinito (se cambia a 4 * Tiempo de simulacion) self.x1_probability = 0.0 # Probabilidad de X1 self.x2_probability = 0.0 # Probabilidad de X2 self.x3_probability = 0.0 # Probabilidad de X3 self.distribution_list = {} # Contiene D1, D2, D3, D4, D5 y D6 self.event_list = {} # Contiene la lista de eventos para programar self.message_list = [ ] # Contiene todos los mensajes que se crean en una corrida self.processor_list = [ ] # Contiene todos los procesadores utilizados en la simulacion self.LMC1_list = [ ] # Lista ordenada de mensajes que deben llegar a la computadora 1 self.LMC2_list = [ ] # Lista ordenada de mensajes que deben llegar a la computadora 2 self.LMC3_list = [ ] # Lista ordenada de mensajes que deben llegar a la computadora 3 self.results = Results( ) # Objeto que contiene los resultados de cada corrida self.interface = Interface( ) # Instancia para utilizar la interfaz de consola self.computer_1 = None # Instancia de la Computadora 1 de la Simulación self.computer_2 = None # Instancia de la Computadora 2 de la Simulación self.computer_3 = None # Instancia de la Computadora 3 de la Simulación def run(self): """ Método de clase En este método se hace el procesamiento general de la simulación """ # Se solicitan y obtienen los datos de inicio al usuario self.get_user_input() # Se crean los eventos iniciales self.createEvents() # Se crean las computadoras y sus procesadores self.createComputers() # Comienza las iteraciones por las n simulaciones indicadas por el usuario for i in range(self.number_of_runs): # Se imprime el número de simulación self.interface.print_number_of_run(i) # Se ingresan los primeros mensajes de llegada en la computadora 2 y 3 y se programan los eventos self.message_list.append(Message(0)) self.message_list.append(Message(1)) self.event_list["LMC2"].id_message = 0 self.event_list["LMC3"].id_message = 1 self.LMC2_list.append((0, 0)) self.LMC3_list.append((1, 0)) # Se relizan de manera cíclica todos los eventos de la simulación self.do_events() # Guardar datos para calcular estadisticas self.results.add_processor_busy_time(self.processor_list) self.results.add_messages_results(self.message_list) self.results.add_last_clock_of_run(self.clock) # Imprimir estadisticas de la corrida self.print_statistics(i) # Se reinican los datos para una nueva corrida self.reset_run() # Imprimir estadisticas finales self.print_final_statistics() def get_user_input(self): """ Método de clase Se obtienen cada uno de los datos del usuario necesarios para la simulación """ # Se le solicita al usuario la cantidad de simulaciones self.number_of_runs = self.interface.ask_number_of_runs() # Se le solicita al usuario el tiempo que debe durar cada simulación self.simulation_time = self.interface.ask_simulation_time() # Se fija el valor de max o infinito en la simulación self.max = 4 * self.simulation_time # Actualiza el valor de max # Se piden los datos de cada una de las distribuciones self.set_simulation_distributions() # Se asignan las probabilidades de retorno o rechazo de un mensaje por parte de los procesadores self.x1_probability = self.interface.ask_x_probability(1) self.x2_probability = self.interface.ask_x_probability(2) self.x3_probability = self.interface.ask_x_probability(3) def set_simulation_distributions(self): """ Método de clase Se inicializan cada una de las simulaciones y sus respectivos parámetros """ # Se crea un diccionario para manejar los identificadores de cada distribución distribution_dictionary = { 1: "Direct", 2: "TLC", 3: "Uniform", 4: "Exponential", 5: "Density" } # Se realiza la solicitud de los datos de cada una de las 6 distribuciones for i in range(6): dist = Distribution() # Se pregunta cual distribución desa asignar a la distribución de la simulación: D_i option = self.interface.ask_distribution("D" + str(i + 1)) # Según la distribución señalada entonces se asígna el identificador dist.id = distribution_dictionary[option] # Se piden los parámetros que necesita la distribución elegida self.set_dist_parameters(dist) # Agrega la distribución al diccionario de distribuciones en su ubicación asociada self.distribution_list["D" + str(i + 1)] = dist def set_dist_parameters(self, dist): """ Método de clase Se inicializan los respectivos parámetros de la distribución: dist """ if (dist.id == "Direct"): # ¿Es una distribución normal directa? # Se inicializan los parámetros miu y sigma^2 parameters = self.interface.ask_normal() dist.miu = parameters[0] dist.sigma2 = parameters[1] elif (dist.id == "TLC" ): # ¿Es una distribución normal por el método de convolución? # Se inicializan los parámetros miu y sigma^2 parameters = self.interface.ask_normal() dist.miu = parameters[0] dist.sigma2 = parameters[1] elif (dist.id == "Uniform"): # ¿Es una distribución uniforme? # Se inicializan los parámetros a y b parameters = self.interface.ask_uniform() dist.a = parameters[0] dist.b = parameters[1] elif (dist.id == "Exponential"): # ¿Es una distribución exponencial? # Se inicializa el parámetro lambda parameters = self.interface.ask_exponential() dist.lambd = parameters else: # ¿Es una distribución de función de densidad? # Se inicializan los parámetros k, a y b parameters = self.interface.ask_density() dist.k = parameters[0] dist.a = parameters[1] dist.b = parameters[2] def createEvents(self): """ Método de clase Se inicializan cada unos de los eventos que son necesarios para la simulación, los que tienen max están desprogramados y los que tienen el valor de 0 están programados al momento 0 del reloj """ self.event_list["LMC1"] = (Event("LMC1", self.max)) self.event_list["LMC2"] = (Event("LMC2", 0)) self.event_list["LMC3"] = (Event("LMC3", 0)) self.event_list["SMC1"] = (Event("SMC1", self.max)) self.event_list["SMC2P1"] = (Event("SMC2P1", self.max)) self.event_list["SMC2P2"] = (Event("SMC2P2", self.max)) self.event_list["SMC3"] = (Event("SMC3", self.max)) def createComputers(self): """ Método de clase Se crean las computadoras y sus respectivos procesadores """ # Se crea la computadora 1 y se inicializa su distribución de arribos en None y su identificador en 1 self.computer_1 = Computer(1, None) # Se crea el procesador con identificador 0 y distribución de salida D6 self.computer_1.add_processor(0, self.distribution_list["D6"]) # Se agrega el procesador a la lista de procesadores self.processor_list.append(self.computer_1.processors_list[0]) # Se crea la computadora 2 y se inicializa su distribución de arribos en D1 y su identificador en 2 self.computer_2 = Computer(2, self.distribution_list["D1"]) # Se crea el procesador con identificador 1 y distribución de salida D2 self.computer_2.add_processor(1, self.distribution_list["D2"]) # Se crea el procesador con identificador 2 y distribución de salida D3 self.computer_2.add_processor(2, self.distribution_list["D3"]) # Se agrega el procesador a la lista de procesadores self.processor_list.append(self.computer_2.processors_list[0]) # Se agrega el procesador a la lista de procesadores self.processor_list.append(self.computer_2.processors_list[1]) # Se crea la computadora 3 y se inicializa su distribución de arribos en D4 y su identificador en 3 self.computer_3 = Computer(3, self.distribution_list["D4"]) # Se crea el procesador con identificador 3 y distribución de salida D5 self.computer_3.add_processor(3, self.distribution_list["D5"]) # Se agrega el procesador a la lista de procesadores self.processor_list.append(self.computer_3.processors_list[0]) def print_statistics(self, run_number): """ Método de clase Se realiza la impresión de las estádisticas correspondientes al número de corrida señalado """ # Se imprime el porcentaje de tiempo que pasó el procesador ocupado en general y con mensajes rechazados self.interface.print_percentage_processor_busy( self.results.percentage_processor_busy_time(run_number)) self.interface.print_percentage_processor_busy_rejected( self.results.percentage_processor_busy_rejected(run_number)) # Se imprime el porcentaje de mensajes rechazados self.interface.print_percentage_rejected_messages( self.results.percentage_rejected_messages(run_number)) # Se imprime el promedio de tiempo en el sistema de un mensaje self.interface.print_mean_system_time( self.results.message_mean_system(run_number)) # Se imprime el promedio de la cantidad de veces que fue devuelto un mensaje self.interface.print_mean_amount_returned( self.results.message_mean_returned(run_number)) # Se imprime el promedio de tiempo en cola en el sistema de un mensaje self.interface.print_mean_queue_time( self.results.message_mean_queue(run_number)) # Se imprime el promedio de tiempo en transmisión en el sistema de un mensaje self.interface.print_mean_transmission_time( self.results.message_mean_transmission(run_number)) # Se imprime el promedio de tiempo en procesamiento en el sistema de un mensaje self.interface.print_percentage_in_processing_time( self.results.percentage_message_processing(run_number)) def print_final_statistics(self): """ Método de clase Realiza la impresión de todas las estadísticas finales """ print( "---------------------ESTADÍSTICAS FINALES---------------------\n") # Se imprime el porcentaje de tiempo que pasó el procesador ocupado en general y con mensajes rechazados self.interface.print_percentage_processor_busy( self.results.finished_percentage_processor_busy_time()) self.interface.print_percentage_processor_busy_rejected( self.results.finished_percentage_processor_busy_rejected()) # Se imprime el porcentaje de mensajes rechazados self.interface.print_percentage_rejected_messages( self.results.finished_percentage_rejected_messages()) # Se imprime el promedio de tiempo en el sistema de un mensaje self.interface.print_mean_system_time( self.results.finished_message_mean_system()) # Se imprime el promedio de la cantidad de veces que fue devuelto un mensaje self.interface.print_mean_amount_returned( self.results.finished_message_mean_returned()) # Se imprime el promedio de tiempo en cola en el sistema de un mensaje self.interface.print_mean_queue_time( self.results.finished_message_mean_queue()) # Se imprime el promedio de tiempo en transmisión en el sistema de un mensaje self.interface.print_mean_transmission_time( self.results.finished_message_mean_transmission()) # Se imprime el promedio de tiempo en procesamiento en el sistema de un mensaje self.interface.print_percentage_in_processing_time( self.results.finished_percentage_message_processing()) # Se imprime el intervalo de confianza para el tiempo promedio en el sistema de los mensajes rechazados self.interface.print_confidence_interval_rejected( self.results.rejected_confidence_interval()) # Se imprime el intervalo de confianza para el tiempo promedio en el sistema de los mensajes enviados self.interface.print_confidence_interval_sent( self.results.sent_confidence_interval()) # Se imprime el intervalo de confianza para el tiempo promedio en el sistema de todos los mensajes self.interface.print_confidence_interval_total( self.results.total_confidence_interval()) def reset_run(self): """ Método de clase Reinicia todos los valores para poder iniciar la siguiente simulación """ # Limpia la lista de mensajes del self.message_list[:] # Limpia las listas ordenadas de mensajes por llegar a la computadora 1, 2 y 3 self.LMC1_list.clear() self.LMC2_list.clear() self.LMC3_list.clear() # Reinicia el valor inicial de todos los eventos self.event_list["LMC1"].event_time = self.max self.event_list["LMC2"].event_time = 0 self.event_list["LMC3"].event_time = 0 self.event_list["SMC1"].event_time = self.max self.event_list["SMC2P1"].event_time = self.max self.event_list["SMC2P2"].event_time = self.max self.event_list["SMC3"].event_time = self.max # Reinicia los valores de cada procesador for processor in self.processor_list: processor.busy_status = False processor.processing_time = 0.0 processor.last_registered_clock = 0.0 # Limpia las colas de mensajes self.computer_1.queued_messages.clear() self.computer_2.queued_messages.clear() self.computer_3.queued_messages.clear() def do_events(self): """ Método de clase Se realiza la ejecución correspondiente a una simulación """ # Se indica que no ha terminado la corrida de la simulación run_finished = False while (run_finished == False ): # ¿No ha acabado la corrida de la simulación? # Obtenga el mínimo de los eventos min_ocurrence_event = min( self.event_list, key=lambda x: self.event_list[x].event_time) if (min_ocurrence_event == "LMC1"): # ¿Es el evento LMC1? # Realice el evento self.do_LMC1_event() elif (min_ocurrence_event == "LMC2"): # ¿Es el evento LMC2? # Realice el evento self.do_LMC2_event() elif (min_ocurrence_event == "LMC3"): # ¿Es el evento LMC3? # Realice el evento self.do_LMC3_event() elif (min_ocurrence_event == "SMC1"): # ¿Es el evento SMC1? # Realice el evento self.do_SMC1_event() elif (min_ocurrence_event == "SMC2P1"): # ¿Es el evento SMC2P1? # Realice el evento self.do_SMC2P1_event() elif (min_ocurrence_event == "SMC2P2"): # ¿Es el evento SMC2P2? # Realice el evento self.do_SMC2P2_event() elif (min_ocurrence_event == "SMC3"): # ¿Es el evento SMC3? # Realice el evento self.do_SMC3_event() if (self.clock >= self.simulation_time): # ¿Acabo el tiempo de simulación? # indique que la simulación ya acabó run_finished = True # Actualice el tiempo de procesamiento de los procesadores que no terminaron de procesar self.update_remaining_processing_times() def update_remaining_processing_times(self): """ Método de clase Se actualizan los tiempos de procesamiento de cada uno de los procesadores que no terminaron de trabajar al final de la simulación """ # Recorra cada uno de los procesadores for processor in self.processor_list: if processor.busy_status == True: # ¿El procesador estaba trabajando cuando terminó la simulación? # Actualice su tiempo de procesamiento processor.update_processing_time(self.clock) def do_LMC1_event(self): """ Este es el método que ejecuta el evento llega mensaje a la computadora 1 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["LMC1"].event_time # Se obtiene el mensaje que está llegando a la computadora 1 event_message = self.message_list[self.event_list["LMC1"].id_message] # Se suma el tiempo de transmisión al tiempo del mensaje en el sistema y en transmisión event_message.system_time += 20.0 event_message.transmission_time += 20.0 if (self.computer_1.processors_list[0].busy_status == False ): # ¿Está el procesador libre? # Se asigna el procesador assigned_processor = self.computer_1.processors_list[0] # Se programa el evento para que el procesador seleccionado procese el mensaje self.event_list[ "SMC1"].event_time = self.clock + assigned_processor.output_distribution.calculate( ) self.event_list["SMC1"].id_message = event_message.id # Se cambia el estado del procesador a ocupado assigned_processor.busy_status = True # Se guarda el momento en el que el mensaje empezó a ser procesado event_message.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje assigned_processor.last_registered_clock = self.clock else: # Se ingresa el mensaje a la cola de la computadora self.computer_1.add_queued_message(event_message.id) # Se guarda el momento en el que el mensaje empezó a esperar en cola event_message.last_registered_clock = self.clock # Se saca de la lista ordenada de mensajes que deben llegar a la computadora 1 el mensaje que ya se procesó o puso en cola self.LMC1_list.remove((event_message.id, self.clock)) if (len(self.LMC1_list) != 0): # Se busca el próximo mensaje que tiene que llegar a la computadora 1 next_event_parameters = min( self.LMC1_list, key=lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el siguiente Evento LMC1 self.event_list["LMC1"].id_message = next_event_parameters[0] self.event_list["LMC1"].event_time = next_event_parameters[1] else: # Se desprograma el evento LMC1 self.event_list["LMC1"].event_time = self.max def do_LMC2_event(self): """ Este es el método que ejecuta el evento llega mensaje a la computadora 2 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["LMC2"].event_time # Se obtiene el mensaje que está llegando a la computadora 2 event_message = self.message_list[self.event_list["LMC2"].id_message] if (event_message.last_computer == 0): # ¿Es un mensaje nuevo? # Se asigna a la computadora 2 como la primera computadora del mensaje event_message.first_computer = 2 # Se programa el próximo mensaje nuevo que debe llegar a la computadora 2 new_message = Message(len(self.message_list)) new_message_time = self.clock + self.computer_2.input_distribution.calculate( ) self.LMC2_list.append((new_message.id, new_message_time)) self.message_list.append(new_message) else: # ¿Es un mensaje devuelto desde la computadora 1? # Se suma el tiempo de transmisión al tiempo del mensaje en el sistema y en transmisión event_message.system_time += 3.0 event_message.transmission_time += 3.0 # Se incrementa en 1 la cantidad de veces que fue retornado el mensaje event_message.amount_returned += 1 assigned_processor = None if (self.computer_2.processors_list[0].busy_status == False and self.computer_2.processors_list[1].busy_status == False): # ¿Están los dos procesadores libres? # Se calcula con probalidad 50/50 a cual procesador se le asigna el mensaje para que lo procese random_number = calculate_uniform( 0, 99 ) # Utiliza método propio de generación de aleatorios con distribución uniforme if (random_number < 50): assigned_processor = self.computer_2.processors_list[0] else: assigned_processor = self.computer_2.processors_list[1] elif (self.computer_2.processors_list[0].busy_status == False ): # ¿Está el procesador 1 libre? # Se asigna el procesador 1 assigned_processor = self.computer_2.processors_list[0] elif (self.computer_2.processors_list[1].busy_status == False ): # ¿Está el procesador 2 libre? # Se asigna el procesador 2 assigned_processor = self.computer_2.processors_list[1] # ¿Ninguno está libre? # Se mantiene: assigned_processor = None if (assigned_processor != None): # ¿Existía un procesador libre? # Se programa el evento para que el procesador seleccionado procese el mensaje event_str = "SMC2P" + str(assigned_processor.id) self.event_list[ event_str].event_time = self.clock + assigned_processor.output_distribution.calculate( ) self.event_list[event_str].id_message = event_message.id # Se cambia el estado del procesador a ocupado assigned_processor.busy_status = True # Se guarda el momento en el que el mensaje empezó a ser procesado event_message.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje assigned_processor.last_registered_clock = self.clock else: # Se ingresa el mensaje a la cola de la computadora self.computer_2.add_queued_message(event_message.id) # Se guarda el momento en el que el mensaje empezó a esperar en cola event_message.last_registered_clock = self.clock # Se saca de la lista ordenada de mensajes que deben llegar a la computadora 2 el mensaje que ya se procesó o puso en cola self.LMC2_list.remove((event_message.id, self.clock)) # Se busca el próximo mensaje que tiene que llegar a la computadora 2 next_event_parameters = min( self.LMC2_list, key=lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el siguiente Evento LMC2 self.event_list["LMC2"].id_message = next_event_parameters[0] self.event_list["LMC2"].event_time = next_event_parameters[1] def do_LMC3_event(self): """ Este es el método que ejecuta el evento llega mensaje a la computadora 3 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["LMC3"].event_time # Se obtiene el mensaje que está llegando a la computadora 3 event_message = self.message_list[self.event_list["LMC3"].id_message] if (event_message.last_computer == 0): # ¿Es un mensaje nuevo? # Se asigna a la computadora 3 como la primera computadora del mensaje event_message.first_computer = 3 # Se programa el próximo mensaje nuevo que debe llegar a la computadora 3 new_message = Message(len(self.message_list)) new_message_time = self.clock + self.computer_3.input_distribution.calculate( ) self.LMC3_list.append((new_message.id, new_message_time)) self.message_list.append(new_message) else: # ¿Es un mensaje devuelto desde la computadora 1? # Se suma el tiempo de transmisión al tiempo del mensaje en el sistema y en transmisión event_message.system_time += 3.0 event_message.transmission_time += 3.0 # Se incrementa en 1 la cantidad de veces que fue retornado el mensaje event_message.amount_returned += 1 if (self.computer_3.processors_list[0].busy_status == False ): # ¿Está el procesador libre? # Se asigna el procesador assigned_processor = self.computer_3.processors_list[0] # Se programa el evento para que el procesador seleccionado procese el mensaje self.event_list[ "SMC3"].event_time = self.clock + assigned_processor.output_distribution.calculate( ) self.event_list["SMC3"].id_message = event_message.id # Se cambia el estado del procesador a ocupado assigned_processor.busy_status = True # Se guarda el momento en el que el mensaje empezó a ser procesado event_message.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje assigned_processor.last_registered_clock = self.clock else: # Se ingresa el mensaje a la cola de la computadora self.computer_3.add_queued_message(event_message.id) # Se guarda el momento en el que el mensaje empezó a esperar en cola event_message.last_registered_clock = self.clock # Se saca de la lista ordenada de mensajes que deben llegar a la computadora 3 el mensaje que ya se procesó o puso en cola self.LMC3_list.remove((event_message.id, self.clock)) # Se busca el próximo mensaje que tiene que llegar a la computadora 3 next_event_parameters = min( self.LMC3_list, key=lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el siguiente Evento LMC2 self.event_list["LMC3"].id_message = next_event_parameters[0] self.event_list["LMC3"].event_time = next_event_parameters[1] def do_SMC1_event(self): """ Este es el método que ejecuta el evento sale mensaje de la computadora 1 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["SMC1"].event_time # Se obtiene el mensaje que debe salir de la computadora 1 event_message = self.message_list[self.event_list["SMC1"].id_message] # Se actualiza el tiempo en el sistema del mensaje event_message.update_system_time(self.clock) # Se actualiza el tiempo que duró el mensaje procesándose en la computadora 1 event_message.update_processing_time_1(self.clock) # Se actualiza el tiempo que duró procesando el mensaje la computadora 1 self.computer_1.processors_list[0].update_processing_time(self.clock) # Se toma un aleatorio de 0 a 99 para calcular la probabilidad X1 y X3 de que se devuelva el mensaje a su respectiva computadora random_number = calculate_uniform(0, 99) if (event_message.last_computer == 2 ): # ¿El mensaje viene de la computadora 2? if (random_number < self.x1_probability ): # ¿Se tiene que devolver el mensaje a la computadora 2? # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 2 el mensaje a devolver next_message_time = self.clock + 3.0 self.LMC2_list.append((event_message.id, next_message_time)) # Se busca el próximo mensaje que tiene que llegar a la computadora 2 next_event_parameters = min(self.LMC2_list, key=lambda x: x[ 1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el evento LMC2 self.event_list["LMC2"].id_message = next_event_parameters[0] self.event_list["LMC2"].event_time = next_event_parameters[1] else: # ¿El mensaje debe de enviarse? # Se realiza el envío del mensaje event_message.send() elif (event_message.last_computer == 3 ): # ¿El mensaje viene de la computadora 3? if (random_number < self.x3_probability ): # ¿Se tiene que devolver el mensaje a la computadora 3? # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 3 el mensaje a devolver next_message_time = self.clock + 3.0 self.LMC3_list.append((event_message.id, next_message_time)) # Se busca el próximo mensaje que tiene que llegar a la computadora 3 next_event_parameters = min(self.LMC3_list, key=lambda x: x[ 1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el evento LMC3 self.event_list["LMC3"].id_message = next_event_parameters[0] self.event_list["LMC3"].event_time = next_event_parameters[1] else: # ¿El mensaje debe de enviarse? # Se realiza el envío del mensaje event_message.send() # Se asigna la computadora 1 como la última en la que ha estado el mensaje event_message.last_computer = 1 if (len(self.computer_1.queued_messages) == 0 ): # ¿La cola de la computadora 1 está vacía? # Se Se cambia el estado del procesador a libre y se desprograma el evento SMC1 self.computer_1.processors_list[0].busy_status = False self.event_list["SMC1"].event_time = self.max else: # ¿La cola de la computadora 1 tiene algún mensaje? # Se toma el mensaje a ser procesado next_message_to_process_id = self.computer_1.pop_queued_message() next_message_to_process = self.message_list[ next_message_to_process_id] # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar next_message_to_process.update_queue_time(self.clock) next_message_to_process.update_system_time(self.clock) # Se programa el evento SMC1 self.event_list[ "SMC1"].event_time = self.clock + self.computer_1.processors_list[ 0].output_distribution.calculate() self.event_list["SMC1"].id_message = next_message_to_process_id # Se guarda el momento en el que el mensaje empezó a ser procesado next_message_to_process.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje self.computer_1.processors_list[ 0].last_registered_clock = self.clock def do_SMC2P1_event(self): """ Este es el método que ejecuta el evento sale mensaje del procesador 1 computadora 2 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["SMC2P1"].event_time # Se obtiene el mensaje que debe salir del procesador 1 de la computadora 2 event_message = self.message_list[self.event_list["SMC2P1"].id_message] # Se actualiza el tiempo en el sistema del mensaje event_message.update_system_time(self.clock) # Se actualiza el tiempo que duró el mensaje procesándose en el procesador 1 de la computadora 2 event_message.update_processing_time_2(self.clock) # Se actualiza el tiempo que duró procesando el mensaje el procesador 1 de la computadora 2 self.computer_2.processors_list[0].update_processing_time(self.clock) # Se asigna la computadora 2 como la última en la que ha estado el mensaje event_message.last_computer = 2 # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 1 el mensaje a enviar next_message_time = self.clock + 20.0 self.LMC1_list.append((event_message.id, next_message_time)) # Se busca el próximo mensaje que tiene que llegar a la computadora 1 next_event_parameters = min( self.LMC1_list, key=lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el evento LMC1 self.event_list["LMC1"].id_message = next_event_parameters[0] self.event_list["LMC1"].event_time = next_event_parameters[1] if (len(self.computer_2.queued_messages) == 0 ): # ¿La cola de la computadora 2 está vacía? # Se cambia el estado del procesador a libre y se desprograma el evento SMC2P1 self.computer_2.processors_list[0].busy_status = False self.event_list["SMC2P1"].event_time = self.max else: # ¿La cola de la computadora 2 tiene algún mensaje? # Se toma el mensaje a ser procesado next_message_to_process_id = self.computer_2.pop_queued_message() next_message_to_process = self.message_list[ next_message_to_process_id] # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar next_message_to_process.update_queue_time(self.clock) next_message_to_process.update_system_time(self.clock) # Se programa el evento SMC2P1 self.event_list[ "SMC2P1"].event_time = self.clock + self.computer_2.processors_list[ 0].output_distribution.calculate() self.event_list["SMC2P1"].id_message = next_message_to_process_id # Se guarda el momento en el que el mensaje empezó a ser procesado next_message_to_process.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje self.computer_2.processors_list[ 0].last_registered_clock = self.clock def do_SMC2P2_event(self): """ Este es el método que ejecuta el evento sale mensaje del procesador 2 computadora 2 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["SMC2P2"].event_time # Se obtiene el mensaje que debe salir del procesador 2 de la computadora 2 event_message = self.message_list[self.event_list["SMC2P2"].id_message] # Se actualiza el tiempo en el sistema del mensaje event_message.update_system_time(self.clock) # Se actualiza el tiempo que duró el mensaje procesándose en el procesador 2 de la computadora 2 event_message.update_processing_time_2(self.clock) # Se actualiza el tiempo que duró procesando el mensaje el procesador 2 de la computadora 2 self.computer_2.processors_list[1].update_processing_time(self.clock) # Se asigna la computadora 2 como la última en la que ha estado el mensaje event_message.last_computer = 2 # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 1 el mensaje a enviar next_message_time = self.clock + 20.0 self.LMC1_list.append((event_message.id, next_message_time)) # Se busca el próximo mensaje que tiene que llegar a la computadora 1 next_event_parameters = min( self.LMC1_list, key=lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el evento LMC1 self.event_list["LMC1"].id_message = next_event_parameters[0] self.event_list["LMC1"].event_time = next_event_parameters[1] if (len(self.computer_2.queued_messages) == 0 ): # ¿La cola de la computadora 2 está vacía? # Se cambia el estado del procesador a libre y se desprograma el evento SMC2P2 self.computer_2.processors_list[1].busy_status = False self.event_list["SMC2P2"].event_time = self.max else: # ¿La cola de la computadora 2 tiene algún mensaje? # Se toma el mensaje a ser procesado next_message_to_process_id = self.computer_2.pop_queued_message() next_message_to_process = self.message_list[ next_message_to_process_id] # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar next_message_to_process.update_queue_time(self.clock) next_message_to_process.update_system_time(self.clock) # Se programa el evento SMC2P2 self.event_list[ "SMC2P2"].event_time = self.clock + self.computer_2.processors_list[ 1].output_distribution.calculate() self.event_list["SMC2P2"].id_message = next_message_to_process_id # Se guarda el momento en el que el mensaje empezó a ser procesado next_message_to_process.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje self.computer_2.processors_list[ 1].last_registered_clock = self.clock def do_SMC3_event(self): """ Este es el método que ejecuta el evento sale mensaje de la computadora 3 """ # Se actualiza el reloj al tiempo del evento self.clock = self.event_list["SMC3"].event_time # Se obtiene el mensaje que debe salir de la computadora 3 event_message = self.message_list[self.event_list["SMC3"].id_message] # Se actualiza el tiempo en el sistema del mensaje event_message.update_system_time(self.clock) # Se actualiza el tiempo que duró el mensaje procesándose en la computadora 3 event_message.update_processing_time_3(self.clock) # Se actualiza el tiempo que duró procesando el mensaje el procesador de la computadora 3 self.computer_3.processors_list[0].update_processing_time(self.clock) # Se asigna la computadora 3 como la última en la que ha estado el mensaje event_message.last_computer = 3 # Se toma un aleatorio de 0 a 99 para calcular la probabilidad X2 de que se rechace un mensaje random_number = calculate_uniform(0, 99) if (random_number < self.x2_probability): # ¿Se debe rechazar el mensaje? # Se rechaza el mensaje event_message.reject() else: # Se envía el mensaje a la computadora 1 # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 1 next_message_time = self.clock + 20.0 self.LMC1_list.append((event_message.id, next_message_time)) # Se busca el próximo mensaje que tiene que llegar a la computadora 1 next_event_parameters = min( self.LMC1_list, key=lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia) # Se programa el evento LMC1 self.event_list["LMC1"].id_message = next_event_parameters[0] self.event_list["LMC1"].event_time = next_event_parameters[1] if (len(self.computer_3.queued_messages) == 0 ): # ¿La cola de la computadora 3 está vacía? # Se cambia el estado del procesador a libre y se desprograma el evento SMC3 self.computer_3.processors_list[0].busy_status = False self.event_list["SMC3"].event_time = self.max else: # ¿La cola de la computadora 3 tiene algún mensaje? # Se toma el mensaje a ser procesado next_message_to_process_id = self.computer_3.pop_queued_message() next_message_to_process = self.message_list[ next_message_to_process_id] # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar next_message_to_process.update_queue_time(self.clock) next_message_to_process.update_system_time(self.clock) # Se programa el evento SMC3 self.event_list[ "SMC3"].event_time = self.clock + self.computer_3.processors_list[ 0].output_distribution.calculate() self.event_list["SMC3"].id_message = next_message_to_process_id # Se guarda el momento en el que el mensaje empezó a ser procesado next_message_to_process.last_registered_clock = self.clock # Se guarda el momento en el que el procesador empezó a procesar el mensaje self.computer_3.processors_list[ 0].last_registered_clock = self.clock
class Arcade: tiles = [ lambda scr, x, y: scr.addstr(y, x * 2, ' ', curses.color_pair(1)), lambda scr, x, y: scr.addstr(y, x * 2, ' ', curses.color_pair(2)), lambda scr, x, y: scr.addstr(y, x * 2, ' ', curses.color_pair(3)), lambda scr, x, y: scr.addstr(y, x * 2, '__', curses.color_pair(4)), lambda scr, x, y: scr.addstr(y, x * 2, ' ', curses.color_pair(5)), ] def __init__(self, mem, stdscr): self.c = Computer(mem) self.screen = defaultdict(lambda: 0) self.stdscr = stdscr self.score = 0 self.paddle = 0 self.ball = 0 def run(self): running = True while(running): while(len(self.c.outputs) < 3): ret = self.c._do_instruction() if self.c.waiting_for_input: # time.sleep(0.01) if self.ball > self.paddle: i = 1 elif self.ball < self.paddle: i = -1 else: i = 0 self.c.inputs.append(i) elif not ret: running = False break if running == False: break tile = self.c.outputs.pop() y = self.c.outputs.pop() x = self.c.outputs.pop() if x == -1 and y == 0: self.score = tile self.stdscr.addstr(1, 4, f'SCORE: {self.score}', curses.color_pair(0)), else: if tile == 3: self.paddle = x elif tile == 4: self.ball = x self.draw_tile(x, y, tile) def draw_tile(self, x, y, tile): self.screen[(x, y)] = tile self.tiles[tile](self.stdscr, x + 2, y + 2) self.stdscr.refresh() def draw(self): for i in range(0, len(self.c.outputs), 3): x = self.c.outputs[i] y = self.c.outputs[i + 1] tile = self.c.outputs[i + 2] self.screen[(x, y)] = tile
class Game: def __init__(self, mode, bet, coop): self.deck = self.get_deck(shuffled=True) self.humans = [] self.computer = Computer() self.mode = mode self.ranking = [] self.coop = coop self.bet = bet def clear(self): return lambda: os.system('cls') def generate_humans(self, count, stack): humans = [] for i in range(count): msg = "Quel est votre pseudo, joueur {} ?\n".format(i + 1) name = str(input(msg)) while len(name) < 2: print("2 caractères minimum s'il vous plaît!") name = str(input(msg)) humans.append(Human(name, int(stack))) return humans # def generate_humans(self, count, stack): # humans = [] # for i in range(count): # msg = "Quel est votre pseudo, joueur {} ?\n".format(i+1) # name = str(input(msg)) # while len(name) < 2: # print("2 caractères minimum s'il vous plaît!") # name = str(input(msg)) # humans.append(Human(name, int(stack))) # return humans def get_deck(self, shuffled): deck = Deck() if shuffled: deck.shuffle() return deck def distribution(self): print(' Distribution des cartes... \n') for human in self.humans: self.distribute_to(human, 1) self.distribute_to(self.computer, 1) for human in self.humans: self.distribute_to(human, 1) if self.mode == "US": self.distribute_to(self.computer, 1, hide=True) def distribute_to(self, player, count, hide=False): for i in range(count): card = self.deck.draw() if hide: card.hide() player.hand.add_card(card) def status(self): print('===================== STATUT ===================== \n') self.computer.show_hand() print('\n') for human in self.humans: human.show_hand() human.show_stack() def set_ranking(self): players = self.humans + [self.computer] sorted(players, key=lambda player: (player.hand.score(), player.hand.is_blackjack())) ranked_players = [ player for player in players if player.hand.score() <= 21 ] unranked_players = [ player for player in players if player.hand.score() > 21 ] self.ranking = ranked_players + unranked_players def get_winners(self): ranked_players = [ player for player in self.ranking if player.hand.score() <= 21 ] one_of_the_best = max( ranked_players, key=lambda player: (player.hand.score(), player.hand.is_blackjack())) winners = [] for player in ranked_players: if player.hand.score() == one_of_the_best.hand.score( ) and player.hand.is_blackjack( ) == one_of_the_best.hand.is_blackjack(): winners.append(player) return winners def reset(self): self.ranking = [] self.deck = self.get_deck(shuffled=True) self.computer.hand.reset() for human in self.humans: human.hand.reset() def ask_action(self): msg = "Tapez 'Carte !' pour piocher, ou 'Je reste' pour passer.\n" action = input(msg) while action not in ['Carte !', 'Je reste']: action = input(msg) return action def welcome_msg(self): self.clear() print("================================================== \n") print(' Bienvenue au Black jack! \n') print("================================================== \n") def set_mode(self): msg = "À quel mode de jeu souhaitez-vous jouer? (EU/US) \n" mode = input(msg) while mode not in ['EU', 'US']: mode = input(msg) self.mode = mode def set_players_count(self): msg = "Combien de joueurs vont participer à cette partie? (1-6)\n" players_count = input(msg) while not players_count.isdigit() or int(players_count) < 1 or int( players_count) > 6: if not players_count.isdigit(): print('{} n\'est pas un nombre valide!'.format(players_count)) elif int(players_count) < 1: print('Il faut au moins un joueur pour jouer!') else: print('6 joueurs maximum autorisés!') players_count = input(msg) return int(players_count) def set_players_stack(self): msg = "Combien de jetons auront les joueurs? \n" stack = input(msg) while not stack.isnumeric() or int(stack) < 1: if not stack.isnumeric(): print('{} n\'est pas un nombre valide!'.format(stack)) elif int(stack) < 1: print('Il faut au moins un jeton par joueur pour parier!') stack = input(msg) return int(stack) def set_players_bet(self, stack): msg = "Quelle sera la mise des joueurs? ({} jeton(s) maximum!) \n".format( stack) bet = input(msg) while not bet.isnumeric() or int(bet) < 1 or int(bet) > stack: if not bet.isnumeric(): print('{} n\'est pas un nombre valide!'.format(bet)) elif int(bet) < 1: print('La mise doit être au minimum de 1 jeton!') bet = input(msg) return int(bet) def set_humans(self): players_count = self.set_players_count() stack = self.set_players_stack() self.bet = self.set_players_bet(stack) self.humans = self.generate_humans(players_count, stack) def set_coop_mode(self): msg = "Voulez vous jouer en coopération contre l'ordinateur? (y/n) \n" if len(self.humans) > 1: coop = input(msg) while coop not in ['y', 'n']: coop = input(msg) self.coop = True if coop == 'y' else False def humans_turn(self): for human in self.humans: print("================================================== \n") print("C'est au tour de {}".format(human.name)) human.show_hand() if human.hand.score() != 21: if self.ask_action() == 'Carte !': card = self.deck.draw() print("Pioche d'un {}".format(card.value)) human.hand.add_card(card) human.show_hand() while human.hand.score() < 21 and self.ask_action( ) == 'Carte !': human.hand.add_card(self.deck.draw()) human.show_hand() def computer_turn(self): is_playing = False for human in self.humans: if 0 < human.hand.score() <= 21: is_playing = True if is_playing: print("================================================== \n") print("C'est au tour de l'ordinateur") if self.mode == 'EU': self.distribute_to(self.computer, 1) elif self.mode == 'US': self.computer.hand.unhide() self.computer.show_hand() while self.computer.hand.score() < 17: card = self.deck.draw() print("Pioche d'un {}".format(card.value)) self.computer.hand.add_card(card) self.computer.show_hand() def show_winner(self): winners = self.get_winners() if len(winners) == 1: print("================================================== \n") print( " LE GAGNANT DE CE TOUR EST {} ! \n".format( winners[0].name)) print("================================================== \n") else: draw = self.computer in winners if draw: winners.remove(self.computer) joueurs = '' for player in winners: joueurs += player.name + '\n' if draw: print("================================================== \n") print(" Les joueurs :\n{} \n". format(joueurs)) print(" sont à égalité avec \n") print(" {} ! \n". format(self.computer.name)) print("================================================== \n") else: print("================================================== \n") print( " LES GAGNANTS SONT :\n{} \n" .format(joueurs)) print("================================================== \n") def humans_bet(self): print("================= MISE DES JOUEURS =============== \n") for human in self.humans: if human.stack - self.bet < 0: print( "{} ne peut pas miser, il ne lui reste plus que {} jeton(s), la mise est de {}!\n" .format(human.name, human.stack, self.bet)) print("{} est éliminé!\n".format(human.name)) self.humans.remove(human) else: human.stack -= self.bet print( "{} place sa mise de {} jeton(s) sur le tapis. ({} jeton(s) restant)" .format(human.name, self.bet, human.stack)) print("\n================================================== \n") def set_gains(self): winners = self.get_winners() print("====================== GAINS ===================== \n") if len(winners) == 1 and winners[0] == self.computer: print(" {} a remporté toutes les mises! \n".format( self.computer.name)) print("================================================== \n") return elif self.computer in winners: gains = self.bet * 1.5 winners.remove(self.computer) else: gains = self.bet * 2 if self.coop: for human in self.humans: human.stack += gains players_getting_gains = [player.name for player in self.humans] else: for winner in winners: winner.stack += gains players_getting_gains = [player.name for player in winners] print("{}".format("\n".join(players_getting_gains))) print("{} remporté {} jeton(s) {}! \n".format( "a" if len(players_getting_gains) == 1 else "ont", gains, "chacun" if len(players_getting_gains) > 1 else "")) print("================================================== \n") def game_over(self): if self.coop: for human in self.humans: if human.stack <= 0: print( "==================== GAME OVER ==================== \n" ) print( "L'ordinateur a remporté tous les jetons de chacun des joueurs! La partie est finie!" ) return True else: for human in self.humans: if human.is_out(): self.humans.remove(human) if len(self.humans) == 0: print("==================== GAME OVER ==================== \n") print( "L'ordinateur a remporté tous les jetons de chacun des joueurs! La partie est finie!" ) return True return False def initialisation(self): self.welcome_msg() # Message de bienvenue self.set_mode() # Paramétrage du mode self.set_humans() # Génération des joueurs "humains" self.set_coop_mode() # Paramétrage du style de jeu def turn(self): self.humans_bet() # Mise self.distribution() # distribution des cartes self.status() # Affichage du status self.humans_turn() # Tour des humains self.computer_turn() # Tour de l'ordinateur self.set_ranking() # Génération du classement self.show_winner() # Affichage du gagnant self.set_gains() # Répartition des gains self.reset() # Reset des mains et du jeu def run(self): self.initialisation() while not self.game_over(): self.turn()
class TestCheckMethods(unittest.TestCase): marker = "X" computer = Computer() player = Player(marker) game = Game() # Testing if the program can recognize 3 in a row in each row def test_row_check(self): case_empty = np.empty([3, 3], dtype=str) case_row1 = np.empty([3, 3], dtype=str) case_row2 = np.empty([3, 3], dtype=str) case_row3 = np.empty([3, 3], dtype=str) for i in range(3): case_row1[0,i] = self.marker case_row2[1,i] = self.marker case_row3[2,i] = self.marker self.game.set_board(case_empty) row_bool_empty = self.game.check_row(self.marker) self.assertFalse(row_bool_empty) self.game.set_board(case_row1) row_bool1 = self.game.check_row(self.marker) self.assertTrue(row_bool1) self.game.set_board(case_row1) row_bool2 = self.game.check_row(self.marker) self.assertTrue(row_bool2) self.game.set_board(case_row1) row_bool3 = self.game.check_row(self.marker) self.assertTrue(row_bool3) def test_col_check(self): case_empty = np.empty([3, 3], dtype=str) case_col1 = np.empty([3, 3], dtype=str) case_col2 = np.empty([3, 3], dtype=str) case_col3 = np.empty([3, 3], dtype=str) for i in range(3): case_col1[i,0] = self.marker case_col2[i,1] = self.marker case_col3[i,2] = self.marker self.game.set_board(case_empty) col_bool_empty = self.game.check_col(self.marker) self.assertFalse(col_bool_empty) self.game.set_board(case_col1) col_bool1 = self.game.check_col(self.marker) self.assertTrue(col_bool1) self.game.set_board(case_col2) col_bool2 = self.game.check_col(self.marker) self.assertTrue(col_bool2) self.game.set_board(case_col3) col_bool3 = self.game.check_col(self.marker) self.assertTrue(col_bool3) # Testing if method returns True for 3 in a row diagonally and False for no 3 in a row diagonally def test_diag_check(self): case_empty = np.empty([3, 3], dtype=str) case_diamatch = np.empty([3, 3], dtype=str) case_diag2 = np.empty([3, 3], dtype=str) for i in range(3): case_diamatch[i, i] = self.marker case_diag2[i, 2-i] = self.marker self.game.set_board(case_empty) diag_bool_empty = self.game.check_diag(self.marker) self.assertFalse(diag_bool_empty) self.game.set_board(case_diamatch) diag_bool1 = self.game.check_diag(self.marker) self.assertTrue(diag_bool1) self.game.set_board(case_diag2) diag_bool2 = self.game.check_diag(self.marker) self.assertTrue(diag_bool2) # Testing if method returns True for an available space and False for an unavailable space def test_check_location(self): row_test = randint(0,2) col_test = randint(0,2) case_empty = np.empty([3, 3], dtype=str) case1 = np.empty([3, 3], dtype=str) case1[row_test,col_test] = self.marker self.game.set_board(case_empty) location_bool = self.game.check_location([row_test,col_test]) self.assertTrue([row_test,col_test],case_empty) self.game.set_board(case1) location_bool = self.game.check_location([row_test,col_test]) self.assertFalse(location_bool)
def main(): pygame.init() fps_clock = pygame.time.Clock() pygame.display.set_caption('Checkers') main_board = Board() main_display = Display() spoty = 0 spotx = 0 mousex = 0 mousey = 0 mouse_clicked = False board = main_board.get_newboard() human_player = Player(Colour.WHITE.value, True) ai_player = Player(Colour.RED.value, False) computer = Computer(ai_player, human_player, Colour.RED.value) move = Move() while True: # Main game loop current_player = Player.select_player_with_turn( human_player, ai_player) main_display.update_board(board) if human_player.turn is True: # human player turn is_attacked = human_player.is_piece_attacked( board) # checks if piece is attacked main_display.check_for_quit() for event in pygame.event.get( ): # catch mouseclicks and mouse position if event.type == MOUSEMOTION: mousey, mousex = event.pos if event.type == MOUSEBUTTONUP: spoty, spotx = main_display.get_spot_clicked( board, event.pos[0], event.pos[1]) mouse_clicked = True main_display.highlight_while_hovering(board, main_display, mouse_clicked, mousey, mousex) piece = board[spoty][spotx] if isinstance( piece, Piece ) and piece.colour == human_player.colour and mouse_clicked is True: available_moves, attack = piece.get_all_available_moves(board) has_attacked = False # While loop for handling attack moves. If there's no attack available, this loop is skipped. while any(True in sublist for sublist in available_moves) and attack is True: main_display.highlight_available_moves( available_moves) # displays available attacks event = pygame.event.wait() main_display.check_for_quit() if event.type == MOUSEBUTTONUP: field_to_move_y, field_to_move_x = main_display.get_spot_clicked( board, event.pos[0], event.pos[1]) if available_moves[field_to_move_y][ field_to_move_x] is True: main_display.attack_piece_animation( board, field_to_move_y, field_to_move_x, piece.colour, spoty, spotx) piece.attack_piece(board, field_to_move_y, field_to_move_x) spoty, spotx = field_to_move_y, field_to_move_x if isinstance(piece, Pawn): piece.check_for_promotion(board) available_moves, attack = piece.get_all_available_moves( board) has_attacked = True elif has_attacked is False: break # return to piece selection # while loop for handling non attack moves while any(True in sublist for sublist in available_moves ) and not has_attacked and not is_attacked: main_display.highlight_available_moves(available_moves) event = pygame.event.wait() main_display.check_for_quit() if event.type == MOUSEBUTTONUP: # catch mouseclicks field_to_move_y, field_to_move_x = main_display.get_spot_clicked( board, event.pos[0], event.pos[1]) if available_moves[field_to_move_y][ field_to_move_x] is True: main_display.move_piece_animation( board, field_to_move_y, field_to_move_x, piece.colour, spoty, spotx) piece.make_move(board, field_to_move_y, field_to_move_x) spoty, spotx = field_to_move_y, field_to_move_x if isinstance(piece, Pawn): piece.check_for_promotion(board) # end his turn human_player.switch_turns(human_player, ai_player) mousey, mousex = event.pos available_moves = [[]] else: break # return to piece selection if has_attacked: # end his turn human_player.switch_turns(human_player, ai_player) mousey, mousex = event.pos else: # Computer turn value, best_move = computer.alpha_beta(5, True, -math.inf, math.inf, board) if best_move[4] is not None: move.attack(board, best_move[0], best_move[1], best_move[2], best_move[3], best_move[4]) main_display.draw_computer_highlight(best_move[0], best_move[1]) piece = board[best_move[0]][best_move[1]] if isinstance(piece, Pawn): piece.check_for_promotion(board) can_attack_again = piece.can_piece_attack(board) while can_attack_again is True: # can move after multi-attack, check this function value, best_move = computer.alpha_beta( 5, True, math.inf, -math.inf, board) move.attack(board, best_move[0], best_move[1], best_move[2], best_move[3], best_move[4]) main_display.draw_computer_highlight( best_move[0], best_move[1]) piece = board[best_move[0]][best_move[1]] if isinstance(piece, Pawn): piece.check_for_promotion(board) can_attack_again = piece.can_piece_attack(board) else: # non attack touple doesnt have any fifth item move.move(board, best_move[0], best_move[1], best_move[2], best_move[3]) main_display.draw_computer_highlight(best_move[0], best_move[1]) piece = board[best_move[0]][best_move[1]] if isinstance(piece, Pawn): piece.check_for_promotion(board) ai_player.switch_turns(human_player, ai_player) pygame.display.update() pygame.time.wait(300) # Redraw screen and wait a clock tick. current_player.check_for_victory(board, main_display) mouse_clicked = False pygame.display.update() fps_clock.tick()
return (position[0], position[1] - 1) if facing == 'left': return (position[0] - 1, position[1]) # 0 = black, 1 = white position = (100, 100) visited_colors = {} facing = 'up' visited = 0 img = Image.new('1', (200, 200), 0) pixels = img.load() pixels[100, 100] = 1 comp = Computer() comp.set_input(1) while not comp.finished: comp.run() if position not in visited_colors: visited += 1 visited_colors[position] = comp.output pixels[position[0], position[1]] = comp.output comp.un_halt() comp.run() # turn robpt facing = turn_robot(facing, comp.output)
class TestInstructions(unittest.TestCase): def setUp(self): self.computer = Computer() def test_load(self): self.computer.load_program([["load", [2, "1"]]]) self.computer.run_program() self.failUnless(self.computer.memory["1"].value == 2) def test_move(self): self.computer.load_program([["load", [2, "1"]], ["move", ["1", "2"]]]) self.computer.run_program() self.failUnless(self.computer.memory["2"].value == 2) def test_dec(self): self.computer.load_program([["load", [2, "1"]], ["dec", ["1"]], ["dec", ["1"]], ["dec", ["1"]]]) self.computer.run_program() self.failUnless(self.computer.memory["1"].value == -1) def test_inc(self): self.computer.load_program([["load", [2, "1"]], ["inc", ["1"]], ["inc", ["1"]], ["inc", ["1"]]]) self.computer.run_program() self.failUnless(self.computer.memory["1"].value == 5) def test_clear(self): self.computer.load_program([["load", [2, "1"]], ["clear", ["1"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, 0) def test_add(self): self.computer.load_program([["load", [2, "1"]], ["add", [1, "1", "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["2"].value, 3) self.failUnlessEqual(self.computer.memory["1"].value, 2) def test_multiply(self): self.computer.load_program([["load", [2, "1"]], ["multiply", [3, "1", "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["2"].value, 6) self.failUnlessEqual(self.computer.memory["1"].value, 2) def test_divide_no_remainder(self): self.computer.load_program([["load", [6, "1"]], ["divide", ["1", 2, "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["2"].value, 3) self.failUnlessEqual(self.computer.memory["1"].value, 6) def test_divide_with_remainder(self): self.computer.load_program([["load", [7, "1"]], ["divide", ["1", 2, "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["2"].value, 3) self.failUnlessEqual(self.computer.memory["1"].value, 7) def test_shift_left(self): self.computer.load_program([["load", [6, "1"]], ["shift_left", ["1"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, 12) def test_shift_right(self): self.computer.load_program([["load", [6, "1"]], ["shift_right", ["1"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, 3) def test_bit_or(self): self.computer.load_program([["load", [0b010101, "1"]], ["load", [0b011111, "2"]], ["bit_or", ["1", "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, 0b011111) def test_bit_and(self): self.computer.load_program([["load", [0b010101, "1"]], ["load", [0b011111, "2"]], ["bit_and", ["1", "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, 0b010101) def test_complement(self): self.computer.load_program([["load", [0b010101, "1"]], ["complement", ["1"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, ~0b010101) def test_bit_xor(self): self.computer.load_program([["load", [0b010101, "1"]], ["load", [0b011111, "2"]], ["bit_xor", ["1", "2"]]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["1"].value, 0b010101 ^ 0b011111) def test_jump(self): self.computer.load_program([["jump", [2]], ["load", [1, "2"]], ["load", [2, "3"]]]) # Should never run self.computer.run_program() self.failUnlessEqual(self.computer.memory["3"].value, 2) self.failIfEqual(self.computer.memory["2"].value, 1) def test_jump_if_neg_on_negative(self): self.computer.load_program( [["load", [-1, "1"]], ["jump_if_neg", ["1", 2]], ["load", [1, "2"]], ["load", [2, "3"]]] # Should never run ) self.computer.run_program() self.failUnlessEqual(self.computer.memory["3"].value, 2) self.failIfEqual(self.computer.memory["2"].value, 1) def test_jump_if_neg_on_positive(self): self.computer.load_program( [["load", [5, "1"]], ["jump_if_neg", ["1", 2]], ["load", [1, "2"]], ["load", [2, "3"]]] # Should run ) self.computer.run_program() self.failUnlessEqual(self.computer.memory["3"].value, 2) self.failUnlessEqual(self.computer.memory["2"].value, 1) def test_jump_if_pos_on_positive(self): self.computer.load_program( [["load", [5, "1"]], ["jump_if_pos", ["1", 2]], ["load", [1, "2"]], ["load", [2, "3"]]] # Should never run ) self.computer.run_program() self.failUnlessEqual(self.computer.memory["3"].value, 2) self.failIfEqual(self.computer.memory["2"].value, 1) def test_jump_if_pos_on_negative(self): self.computer.load_program( [["load", [-1, "1"]], ["jump_if_pos", ["1", 2]], ["load", [1, "2"]], ["load", [2, "3"]]] # Should run ) self.computer.run_program() self.failUnlessEqual(self.computer.memory["3"].value, 2) self.failUnlessEqual(self.computer.memory["2"].value, 1) def test_jump_if_eq_on_equal(self): self.computer.load_program( [ ["load", [5, "1"]], ["load", [5, "2"]], ["jump_if_eq", ["1", "2", 2]], ["load", [1, "3"]], # Should never run ["load", [2, "4"]], ] ) self.computer.run_program() self.failUnlessEqual(self.computer.memory["4"].value, 2) self.failIfEqual(self.computer.memory["3"].value, 1) def test_jump_if_eq_on_not_equal(self): self.computer.load_program( [ ["load", [5, "1"]], ["load", [4, "2"]], ["jump_if_eq", ["1", "2", 2]], ["load", [1, "3"]], # Should run ["load", [2, "4"]], ] ) self.computer.run_program() self.failUnlessEqual(self.computer.memory["4"].value, 2) self.failUnlessEqual(self.computer.memory["3"].value, 1) def test_push(self): self.computer.load_program([["load", [5, "1"]], ["push", ["1"]], ["push", [1]]]) self.computer.run_program() self.failUnlessEqual(self.computer.stack[0], 5) self.failUnlessEqual(self.computer.stack[1], 1) def test_pop_with_non_empty_stack(self): self.computer.load_program([["load", [5, "1"]], ["push", ["1"]], ["push", [1]], ["pop", "3"], ["pop", "4"]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["4"].value, 5) self.failUnlessEqual(self.computer.memory["3"].value, 1) def test_pop_with_empty_stack(self): self.computer.load_program([["pop", "3"], ["pop", "4"]]) self.computer.run_program() self.failUnlessEqual(self.computer.memory["4"].value, 0) self.failUnlessEqual(self.computer.memory["3"].value, 0)
from Computer import Computer import numpy as np from os import system, name from time import sleep og = [int(x) for x in '2,380,379,385,1008,3031,179032,381,1005,381,12,99,109,3032,1101,0,0,383,1102,1,0,382,20102,1,382,1,21002,383,1,2,21101,0,37,0,1105,1,578,4,382,4,383,204,1,1001,382,1,382,1007,382,46,381,1005,381,22,1001,383,1,383,1007,383,26,381,1005,381,18,1006,385,69,99,104,-1,104,0,4,386,3,384,1007,384,0,381,1005,381,94,107,0,384,381,1005,381,108,1106,0,161,107,1,392,381,1006,381,161,1102,1,-1,384,1106,0,119,1007,392,44,381,1006,381,161,1101,1,0,384,21001,392,0,1,21102,24,1,2,21101,0,0,3,21101,138,0,0,1106,0,549,1,392,384,392,20101,0,392,1,21101,24,0,2,21102,3,1,3,21101,0,161,0,1106,0,549,1101,0,0,384,20001,388,390,1,21001,389,0,2,21101,180,0,0,1106,0,578,1206,1,213,1208,1,2,381,1006,381,205,20001,388,390,1,21001,389,0,2,21101,0,205,0,1105,1,393,1002,390,-1,390,1102,1,1,384,20102,1,388,1,20001,389,391,2,21101,0,228,0,1105,1,578,1206,1,261,1208,1,2,381,1006,381,253,21002,388,1,1,20001,389,391,2,21102,253,1,0,1105,1,393,1002,391,-1,391,1101,0,1,384,1005,384,161,20001,388,390,1,20001,389,391,2,21101,0,279,0,1106,0,578,1206,1,316,1208,1,2,381,1006,381,304,20001,388,390,1,20001,389,391,2,21102,304,1,0,1106,0,393,1002,390,-1,390,1002,391,-1,391,1102,1,1,384,1005,384,161,21002,388,1,1,20102,1,389,2,21101,0,0,3,21102,1,338,0,1105,1,549,1,388,390,388,1,389,391,389,21002,388,1,1,21002,389,1,2,21101,0,4,3,21101,0,365,0,1105,1,549,1007,389,25,381,1005,381,75,104,-1,104,0,104,0,99,0,1,0,0,0,0,0,0,324,21,21,1,1,23,109,3,21201,-2,0,1,22101,0,-1,2,21102,0,1,3,21101,0,414,0,1106,0,549,21201,-2,0,1,22102,1,-1,2,21102,1,429,0,1106,0,601,2102,1,1,435,1,386,0,386,104,-1,104,0,4,386,1001,387,-1,387,1005,387,451,99,109,-3,2105,1,0,109,8,22202,-7,-6,-3,22201,-3,-5,-3,21202,-4,64,-2,2207,-3,-2,381,1005,381,492,21202,-2,-1,-1,22201,-3,-1,-3,2207,-3,-2,381,1006,381,481,21202,-4,8,-2,2207,-3,-2,381,1005,381,518,21202,-2,-1,-1,22201,-3,-1,-3,2207,-3,-2,381,1006,381,507,2207,-3,-4,381,1005,381,540,21202,-4,-1,-1,22201,-3,-1,-3,2207,-3,-4,381,1006,381,529,21202,-3,1,-7,109,-8,2106,0,0,109,4,1202,-2,46,566,201,-3,566,566,101,639,566,566,2101,0,-1,0,204,-3,204,-2,204,-1,109,-4,2106,0,0,109,3,1202,-1,46,594,201,-2,594,594,101,639,594,594,20102,1,0,-2,109,-3,2105,1,0,109,3,22102,26,-2,1,22201,1,-1,1,21101,601,0,2,21102,815,1,3,21101,0,1196,4,21101,0,630,0,1105,1,456,21201,1,1835,-2,109,-3,2106,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,2,0,0,2,0,2,2,0,2,0,2,2,2,2,2,2,0,0,2,0,2,2,2,2,0,2,0,0,0,2,0,0,2,0,0,0,0,0,0,0,2,0,0,1,1,0,0,2,0,0,2,2,0,2,0,0,0,0,2,2,2,0,0,0,0,0,0,2,2,2,0,0,2,0,0,2,2,0,2,2,0,0,0,0,2,2,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,0,2,2,0,0,2,0,0,2,0,0,0,0,2,0,0,2,2,2,0,0,2,2,0,2,2,2,2,0,1,1,0,2,0,0,2,2,2,2,2,0,0,2,0,0,0,2,0,0,2,0,0,0,0,0,0,0,0,0,2,0,0,2,0,2,0,0,2,0,0,0,0,0,0,0,1,1,0,2,2,0,2,2,0,2,2,0,0,2,2,0,0,0,2,0,0,2,0,0,0,2,2,2,2,2,2,0,2,0,0,0,0,0,2,0,2,0,2,2,0,0,1,1,0,2,0,2,0,2,0,2,0,0,2,0,0,0,2,2,0,0,0,0,0,2,0,0,0,0,2,0,0,0,0,0,2,0,0,0,2,0,2,2,0,2,2,0,1,1,0,2,0,2,0,0,2,0,0,2,0,0,2,2,0,0,2,2,2,0,0,2,0,0,2,2,0,0,2,0,2,0,0,0,0,0,2,2,2,0,0,2,2,0,1,1,0,2,0,0,0,2,2,2,0,2,0,0,2,0,0,0,0,2,2,2,0,0,2,0,2,0,2,2,2,2,0,0,2,0,0,0,0,2,0,0,2,2,0,0,1,1,0,2,0,0,0,2,2,2,2,0,2,2,0,0,2,0,0,0,0,0,2,2,0,2,2,2,0,2,0,0,2,2,2,2,0,2,0,2,0,0,0,0,0,0,1,1,0,2,0,0,0,2,2,2,0,2,2,0,0,0,2,0,2,2,0,2,0,0,0,0,0,2,2,0,2,2,0,2,0,2,0,0,0,2,2,0,0,0,0,0,1,1,0,2,0,0,0,2,2,2,2,0,0,0,0,2,0,0,2,0,2,0,0,0,2,0,2,2,0,2,0,2,0,0,0,2,0,0,2,0,2,0,2,0,2,0,1,1,0,0,0,0,2,0,0,0,0,0,2,0,0,0,0,2,2,0,0,0,2,0,2,0,2,2,2,2,0,0,0,0,0,0,0,2,2,2,2,2,0,0,0,0,1,1,0,0,0,0,2,0,2,2,0,0,0,0,0,2,0,0,0,2,2,0,0,2,2,2,0,0,2,2,0,2,0,0,0,0,0,0,0,0,0,2,0,2,0,0,1,1,0,0,0,2,0,0,2,0,0,0,2,2,0,2,2,2,0,2,2,2,0,0,0,2,0,2,2,0,0,2,2,0,2,2,0,2,2,2,2,0,2,2,2,0,1,1,0,0,0,2,0,0,2,0,2,0,2,2,2,0,0,0,0,0,2,0,0,2,2,2,0,2,2,0,0,2,2,0,0,2,0,2,0,2,0,2,2,0,0,0,1,1,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,2,2,2,0,0,0,0,2,0,0,2,0,0,2,0,2,0,0,2,2,0,0,2,0,0,0,0,1,1,0,2,2,2,2,2,2,2,0,2,0,0,0,0,2,0,0,2,0,0,0,0,2,2,2,0,2,0,2,0,0,2,0,0,0,0,2,2,2,2,2,2,0,0,1,1,0,2,0,0,2,0,0,0,2,0,0,0,2,2,2,0,0,2,0,0,0,2,0,2,2,2,0,0,0,2,2,0,0,0,2,2,0,0,2,2,2,0,2,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,94,84,7,6,83,20,72,3,78,13,11,21,96,9,37,43,14,37,93,70,55,53,86,83,69,6,8,95,92,4,13,65,73,23,56,5,94,21,87,34,29,67,41,80,63,65,30,50,5,82,52,16,6,91,54,6,48,64,78,92,96,46,27,31,22,53,89,86,33,82,49,46,91,51,72,34,25,6,91,65,75,83,48,60,92,87,64,69,26,64,94,70,42,10,76,96,2,38,37,84,18,55,23,85,20,88,29,12,50,11,91,13,95,70,81,89,96,70,95,84,90,36,35,81,24,5,10,55,11,41,48,95,79,63,89,90,11,91,51,13,12,9,94,68,96,8,18,38,13,93,55,43,78,94,20,10,69,47,94,5,54,58,18,87,13,56,87,82,51,57,61,41,52,16,92,88,23,88,10,23,28,30,91,96,21,64,30,26,87,14,41,58,32,59,92,88,79,66,32,87,9,2,76,4,76,56,96,20,60,33,9,58,20,1,31,45,91,15,92,70,65,7,32,29,81,50,42,83,11,97,40,42,97,78,98,69,46,55,51,17,12,15,58,81,87,97,18,73,3,7,56,79,39,70,41,90,10,35,19,24,7,8,76,75,38,24,31,33,4,29,68,77,21,6,23,95,3,89,27,4,6,11,57,19,47,65,42,51,17,86,30,85,57,31,92,47,12,26,9,1,83,11,48,25,91,37,66,57,53,98,89,10,86,77,65,31,31,17,10,34,47,43,46,77,95,23,77,90,53,19,66,48,60,91,67,30,42,94,63,37,44,40,32,50,31,53,88,72,76,34,26,63,71,13,78,30,2,25,35,37,39,79,71,91,5,17,89,50,52,53,7,64,60,53,15,62,39,43,86,18,42,93,57,81,50,32,59,59,90,29,85,18,20,78,39,73,13,91,17,64,13,18,39,14,94,56,57,68,95,10,92,91,62,40,40,15,5,33,86,53,73,65,96,92,8,12,62,22,24,95,2,28,34,27,10,16,89,49,34,46,93,58,33,5,68,62,27,16,98,62,13,19,5,11,96,25,21,10,72,16,6,23,44,80,4,95,40,33,24,28,15,13,25,97,47,43,38,34,98,54,17,29,63,48,6,24,98,34,58,13,19,15,21,10,23,63,9,67,32,21,37,1,4,54,25,91,18,9,81,52,93,22,55,98,5,87,55,46,12,7,81,95,1,44,4,32,46,29,60,95,87,25,95,59,47,11,46,16,14,42,5,98,93,7,93,52,97,2,76,11,25,8,28,5,90,71,64,98,69,78,70,17,55,87,97,90,61,39,83,94,65,58,10,82,76,26,32,83,55,1,29,72,13,13,95,78,53,38,95,81,93,82,4,76,17,24,19,34,80,26,92,20,81,82,22,51,4,25,92,50,84,5,18,77,26,56,52,69,14,83,6,34,64,2,55,43,2,58,71,79,22,72,91,70,19,79,26,1,34,72,22,44,58,97,1,30,29,31,50,9,90,64,81,48,7,85,32,32,66,96,60,17,61,72,42,35,28,97,66,86,33,35,69,88,17,84,29,16,5,27,16,96,95,97,53,94,77,59,11,41,54,21,25,77,11,94,44,40,29,26,64,56,72,61,48,64,48,88,92,75,64,43,62,17,49,22,94,63,45,32,39,95,71,89,55,72,18,58,14,48,41,54,81,14,63,57,63,67,29,90,39,54,33,62,89,6,20,42,29,39,85,52,98,18,84,5,58,22,66,77,37,35,25,14,82,14,61,57,9,32,90,5,47,96,19,28,83,90,40,62,61,48,52,80,34,77,38,30,14,40,10,36,94,53,58,69,60,5,77,89,68,52,2,36,93,14,14,60,47,17,1,86,38,52,93,46,96,29,21,78,12,80,70,68,7,53,21,34,41,56,83,4,76,75,85,64,32,41,83,77,7,3,58,87,87,53,40,21,19,72,39,48,83,91,95,59,59,79,77,55,64,47,91,73,57,63,62,80,61,56,50,39,90,32,20,89,47,33,78,55,14,90,10,60,92,87,96,42,76,39,88,20,7,77,79,83,53,91,39,42,42,72,21,60,3,71,21,64,22,14,27,30,64,95,60,76,78,98,8,60,17,21,33,74,7,55,29,49,29,72,69,84,75,32,71,29,62,51,98,79,63,59,50,92,66,89,59,87,58,28,29,47,69,83,62,67,31,67,89,82,4,71,70,31,43,20,92,88,82,46,95,34,41,97,57,17,46,98,92,64,23,65,35,95,6,34,64,59,7,47,31,20,20,90,27,60,33,45,7,18,55,58,76,35,95,55,89,4,55,10,49,57,33,70,46,88,95,44,74,3,95,4,37,12,35,20,41,66,47,31,94,8,39,65,6,23,16,34,10,13,85,72,73,68,97,62,43,9,36,53,94,32,40,59,25,33,35,13,26,16,32,95,12,23,59,31,60,85,95,53,23,20,59,78,8,91,66,93,42,84,51,51,73,90,78,55,3,22,28,20,15,21,1,38,32,56,85,3,85,82,97,45,79,10,90,84,70,33,1,42,39,56,47,41,96,15,19,71,93,59,64,24,60,87,12,95,41,68,63,80,95,42,57,61,28,15,22,45,55,3,86,7,27,39,49,9,34,13,12,2,49,65,94,39,56,88,1,70,68,54,74,35,5,80,42,59,49,77,60,80,1,11,70,18,40,23,36,45,20,37,66,40,88,85,31,69,40,17,24,18,79,63,47,47,83,39,179032'.split(',')] def get_tile(idx): if idx == 0: return " " if idx == 1: return "◻️" if idx == 2: return "⬛" if idx == 3: return "▃" if idx == 4: return "⚽" com = Computer(og, 0, 10000) idx = 0 x = 0 y = 0 code = 0 grid_size = 100 grid = [[None for y in range(26)] for x in range(46)] counter = 0 last_score = 0 ball_x = 0 block_x = 0 while not com.done: output = com.iterate(None) if output is None: print(last_score) temp_grid = np.transpose(grid) output = ""
def game(self): ''' game Method Parameters: N/A Returns: N/A Preconditions: Valid screen created (created in constructor) Postconditions: Plays battleship and awaits for the gameOver scenario to have occured then exits ''' #*****Member Variables of game*****# self.player1Board = Board() self.player1Fleet = [] #****************# self.numPlayers = self.selectPlayers() # selects the number of players # asks user for the number of ships in the game self.numShips = self.chooseNumShips() if (self.numPlayers == 1): # Computer Variables self.computerFleet = [] aiDifficulty = self.chooseAIDifficulty() self.computer = Computer(aiDifficulty) # End Computer Variables self.turn = "Player 1" self.topgrid = self.createDisplayBoard( 50, 40) # creates the top "opponent" grid self.botgrid = self.createDisplayBoard( 50, self.buffer) # creates the bottom "player" grid playerWin = "" if (self.numPlayers == 1): self.fillCoordinates("Computer Board", "Player 1 Board") # sets the UI self.placeShipPhase("Player 1", self.numShips) # places ship playerWin = self.attackPhase() elif (self.numPlayers == 2): self.player2Board = Board() self.player2Fleet = [] self.fillCoordinates("Player 2 Board", "Player 1 Board") # sets the UI # places ships for player 1 self.placeShipPhase("Player 1", self.numShips) self.fillCoordinates("Player 1 Board", "Player 2 Board") # sets the UI # places ships for player 2 self.placeShipPhase("Player 2", self.numShips) self.fillCoordinates("Player 2 Board", "Player 1 Board") self.swapBoards(self.player2Board, self.player1Board) playerWin = self.attackPhase() else: toptext = pygame.font.Font('freesansbold.ttf', 20).render("NO PLAYERS", False, (255, 255, 255)) self.screen.blit(toptext, (20, 20)) return quitGame = False while not quitGame: self.result(playerWin) # displays if you win or not for event in pygame.event.get(): self.checkQuit(event) # checks to see if you quit if event.type == pygame.KEYDOWN: # confirm placement if event.key == pygame.K_RETURN: # quits if hit enter quitGame = True
from Utils import read_input_as_list from Computer import Computer lines = read_input_as_list("inputs/2.txt") input = [int(ele) for ele in lines[0].split(",")] c = Computer(input) c.run_program() print("Part 1") print(c.temp_copy[0]) print("Part 2") for i in range(99): for j in range(99): input[1] = i input[2] = j c = Computer(input) c.run_program() if c.temp_copy[0] == 19690720: print(100 * i + j) break
from Computer import Computer comp = Computer(1) while not comp.finished: comp.un_halt() comp.run() print(comp.output)
def start_game(self): # Choose the player type for both players print('Please choose Player 1:') print('1. Human Player') print('2. Computer Player') valid = True while valid: x = input('Your choice is: ') if x == '1': self.players.append(Human(1, self.board)) print('Player 1 is a human.') valid = False elif x == '2': self.players.append(Computer(1, self.board)) print('Player 1 is a computer.') valid = False else: print('Invalid value') #Choose the type for player 2 print('Please choose Player 2:') print('1. Human Player') print('2. Computer Player') valid = True while valid: x = input('Your choice is: ') if x == '1': self.players.append(Human(2, self.board)) print('Player 1 is a human.') valid = False elif x == '2': self.players.append(Computer(2, self.board)) print('Player 1 is a computer.') valid = False else: print('Invalid value') # Start the game self.board.print_board() end = False while not end: player = self.next_player() if self.num_play <= 12: # Phase 1 x = player.next_put() else: # Phase 2 x = player.next_move() self.board.print_board() if self.num_play > 11 and self.check_win(player): end = True else: if self.board.form_mill(x, player): print('You form a mill!') player.next_remove(self.opponent(player)) self.board.print_board() if self.num_play > 12 and self.check_win(player): end = True
''' Created on Feb 4, 2010 @author: tim for cs44 w10 this takes two arguments who is going next and a file with state info ''' from State import State from Computer import Computer import sys if __name__ == '__main__': if len(sys.argv) > 1: who = sys.argv[1] file = sys.argv[2] else: print "usage: move-c4 whosmove filenamewithstate" sys.exit(0) lines = open(file).readlines() s = State() c = Computer(s) s.decode("".join(lines)) print "utility: " + str(c.utility(s)) print "move chosen " + str(c.minimaxi(s, who))
from GameField import GameField from Computer import Computer from Player import Player from termcolor import colored if __name__ == '__main__': field = GameField() computer = Computer(field) player = Player(field) playing = True while playing: playing = computer.make_a_move() if not playing: print(colored('You won! Computer lose', 'yellow')) break field.print_current_field() playing = player.make_a_move() if not playing: print(colored('You lose', 'red')) break
class Game: def __init__(self, board_size=25, cell_size=20, margin=15): #constructor of the display, dimensions ''' Display Constructor Parameters: N/A Returns: N/A Preconditions: N/A Postconditions: Creates a valid screen, computer, player board, fleet for both computer and player ''' #*****Initializes screen*****# self.board_size = board_size self.cell_size = cell_size self.margin = margin SCREEN_WIDTH = 470 self.SCREEN_WIDTH = SCREEN_WIDTH SCREEN_HEIGHT = 900 self.SCREEN_HEIGHT = SCREEN_HEIGHT screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) self.screen = screen pygame.init() pygame.font.init() self.font = pygame.font.SysFont("ComicSans", 15) # sets font pygame.display.set_caption("Battleship!") #name of window self.buffer = math.floor( self.margin / 30 + self.board_size * self.cell_size) #buffer between top and bottom grid #****************# #*****Member Variables of game*****# self.playerBoard = Board() self.playerFleet = [] self.computerFleet = [] self.computer = Computer() #contains it's own board #****************# def checkQuit(self, event): ''' checkQuit Method Parameters: event Returns: N/A Preconditions: N/A Postconditions: asuming event is exit, quits the game ''' if event.type == pygame.QUIT: pygame.quit() sys.exit() def chooseNumShips(self): ''' chooseNumShips Method Parameters: N/A Returns: number of ships in the game (1-5) Preconditions: N/A Postconditions: N/A ''' getNumShips = False titlefont = pygame.font.Font('freesansbold.ttf', 20) numShips = 0 while not getNumShips: toptext = titlefont.render( 'Please choose a number of ships (1 - 5)', False, (255, 255, 255)) self.screen.blit(toptext, (20, 20)) for event in pygame.event.get(): self.checkQuit(event) #checks if user exits if event.type == pygame.KEYDOWN: for key in range(1, 6): # if user presses key 1-5 if event.unicode == str(key): numShips = int( event.unicode ) #sets fleet size and asks for confirmation self.screen.fill(black) fleetTxt = titlefont.render( 'A fleet size of ' + str(key) + ", press enter to confirm", False, white) self.screen.blit(fleetTxt, (20, 50)) if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN and numShips != 0: #confirms that the user inputted keys getNumShips = True return (numShips) pygame.display.flip() #goes to next frame def createDisplayBoard(self, xOffset, yOffset): ''' createDisplayBoard Method Parameters: xOffset, yOffset (distance from top left corner in pixels) Returns: empty water grid that is created Preconditions: N/A Postconditions: N/A ''' BLOCK_SIZE = 40 grid = [] for y in range(9): # this is creating the top graph row = [] for x in range(9): rect = pygame.Rect(xOffset + y * BLOCK_SIZE, x * BLOCK_SIZE + yOffset, BLOCK_SIZE, BLOCK_SIZE) #creates a 9x9 rectangle grid pygame.draw.rect(self.screen, blue, rect, 1) #draws blue squares on it row.append([rect, blue]) grid.append(row) return grid def scanGridClick(self, event, grid): ''' scanGridClick Method Parameters: event, and grid you clicked on Returns: origin ([x, y], which is the corresponding square you clicked on) Preconditions: N/A Postconditions: N/A ''' x = 0 y = 0 origin = [-1, -1] for row in grid: #bot graph for item in row: rect, color = item if rect.collidepoint(event.pos): origin = [ x, y ] #sets the origin to the spot which was clicked on x = (x + 1) % 9 y = (y + 1) % 9 return origin def displayGrid(self, grid, board, displayShips): ''' displayGrid Method Parameters: grid and corresponding board. displayShips (boolean which says whether to display ships as grey or hide them) Returns: N/A Preconditions: N/A Postconditions: When frame is flipped displays a newly updated board ''' x = 0 y = 0 for row in grid: # this redraws each bot square, with the updated colors for item in row: if (not board.getTile(x, y).getTileAttacked()): if (displayShips ): # if you want to show the ships on board if (self.playerBoard.getTile( x, y).getTileItem() == "water"): item[1] = blue else: item[1] = grey else: # if you dont want to show the ships item[1] = blue elif board.getTile(x, y).getTileItem() == "water": item[1] = white else: item[1] = red rect, color = item pygame.draw.rect(self.screen, color, rect) x = (x + 1) % 9 y = (y + 1) % 9 def placeShipPhase(self, numShips): ''' placeShipPhase Method Parameters: numShips (the number of ships you want the player to place) Returns: N/A Preconditions: valid player and computer grid Postconditions: both players' boards have placed ships, players' fleets have been updated to contain the ships they placed ''' shipNames = [ Ship("dinghy", 1), Ship("gunboat", 2), Ship("submarine", 3), Ship("battleship", 4), Ship("carrier", 5) ] directions = ["up", "right", "down", "left"] dir = 0 shipPlace = 0 shipPositions = [] font = pygame.font.Font('freesansbold.ttf', 17) self.displayGrid(self.topgrid, self.computer.getBoard(), True) while not shipPlace >= numShips: text = font.render('Placing ship: ', False, white) self.screen.blit(text, (50, int(self.SCREEN_HEIGHT / 2) - 25)) rect = pygame.Rect(160, int(self.SCREEN_HEIGHT / 2) - 25, 200, 20) pygame.draw.rect(self.screen, black, rect) text = font.render(shipNames[shipPlace].getName(), False, white) self.screen.blit(text, (165, int(self.SCREEN_HEIGHT / 2) - 25)) text = font.render("click to place, enter to confirm", False, white) self.screen.blit(text, (50, int(self.SCREEN_HEIGHT / 2) - 5)) for event in pygame.event.get(): self.checkQuit(event) if event.type == pygame.MOUSEBUTTONDOWN: #if mouse clicked shipOrigin = self.scanGridClick( event, self.botgrid) #gets the square that you clicked on if shipOrigin == [-1, -1]: #if you clicked outside grid break for coordinate in shipPositions: # deletes old ship placement ****note for first ship ship positions is [] so it skips this step self.playerBoard.setTile( coordinate[0], coordinate[1], "water") # sets those spots to water shipPlaced = False while not shipPlaced: dir = ( dir + 1 ) % 4 #everytime you click on a spot increments the direction to the next available spot shipPlaced = self.playerBoard.placeShip( directions[dir], shipNames[shipPlace], shipOrigin[0], shipOrigin[1]) shipPositions = [shipOrigin] if directions[dir] == "up": for i in range(shipNames[shipPlace].getHealth()): shipPositions = shipPositions + [[ shipPositions[0][0], shipPositions[0][1] - i ]] if directions[dir] == "down": for i in range(shipNames[shipPlace].getHealth()): shipPositions = shipPositions + [[ shipPositions[0][0], shipPositions[0][1] + i ]] if directions[dir] == "right": for i in range(shipNames[shipPlace].getHealth()): shipPositions = shipPositions + [[ shipPositions[0][0] + i, shipPositions[0][1] ]] if directions[dir] == "left": for i in range(shipNames[shipPlace].getHealth()): shipPositions = shipPositions + [[ shipPositions[0][0] - i, shipPositions[0][1] ]] shipPositions.pop( 0 ) # in placing a ship, shipPositions has a duplicate of the origin spot, so pop that off elif event.type == pygame.KEYDOWN: #confirm placement if event.key == pygame.K_RETURN: if (shipPositions != []): #checks to make sure you placed a ship self.playerFleet += [shipNames[shipPlace]] shipPositions = [] shipPlace += 1 # draw all in every loop #for row in topgrid: # this redraws each top square, with the updated colors # for item in row: # rect, color = item # pygame.draw.rect(self.screen, color, rect) self.displayGrid(self.botgrid, self.playerBoard, True) # updates bottom grid to show new values pygame.display.flip() #displays the updated frame for ship in self.playerFleet: # creates computer fleet and places ship on the computer board self.computer.shipPlace(ship) self.computerFleet += [Ship(ship.getName(), ship.getHealth())] def attackPhase(self): ''' attackPhase Method Parameters: N/A Returns: playerWin (true if player wins, false if computer wins) Preconditions: valid player and computer grid and fleet with placed ships Postconditions: players take turns attacking until all the ships of one board are sunk, then exits ''' gameOver = False playerWin = True font = pygame.font.Font('freesansbold.ttf', 17) while not gameOver: rect = pygame.Rect(0, int(self.SCREEN_HEIGHT / 2 - 25), 400, 45) pygame.draw.rect(self.screen, black, rect) text = font.render("Click on top board to attack a tile", False, white) self.screen.blit(text, (50, int(self.SCREEN_HEIGHT / 2) - 25)) for event in pygame.event.get(): self.checkQuit(event) #checks to see if exited game if event.type == pygame.MOUSEBUTTONDOWN: #if clicked x, y = self.scanGridClick( event, self.topgrid) #gets where clicked on topgrid if ( x == -1 and y == -1 ): #if you clicked outside of the board exit event loop break if (self.computer.attackTile( x, y)): #attacks the computers board for ship in range( len(self.computerFleet) ): #checks to see if you hit any of the ships if self.computer.getBoard().getTile( x, y).getTileItem( ) == self.computerFleet[ship].getName( ): #compares tile name to fleet name self.computerFleet[ship].damageShip( ) # if it matches damages that ship x, y = 0, 0 newTileAttacked = False while (not newTileAttacked ): # ensures that the computer gets a new guess x, y = self.computer.shipGuess() newTileAttacked = self.playerBoard.attackTile( x, y ) #attack tile returns false if you have already attacked that tile for ship in range( len(self.playerFleet )): #if it is a hit damages corresponding ship if self.playerBoard.getTile(x, y).getTileItem( ) == self.playerFleet[ship].getName(): self.playerFleet[ship].damageShip() self.displayGrid(self.botgrid, self.playerBoard, True) #displays complete bottom grid self.displayGrid(self.topgrid, self.computer.getBoard(), False) #displays top grid with hidden ships pygame.display.flip() #updates frame gameOver = True #checks if either fleet is completely dead for ship in self.computerFleet: if (not ship.isDead()): gameOver = False if (gameOver): break gameOver = True for ship in self.playerFleet: if (not ship.isDead()): gameOver = False if (gameOver): playerWin = False # if the player fleet is dead sets playerWin to false break return playerWin # returns true if player won, false if computer won def game(self): ''' game Method Parameters: N/A Returns: N/A Preconditions: Valid screen created (created in constructor) Postconditions: Plays battleship until one person wins then waits to exit ''' self.banger() # music numShips = self.chooseNumShips( ) #asks user for the number of ships in the game self.topgrid = self.createDisplayBoard( 50, 40) #creates the top "opponent" grid self.botgrid = self.createDisplayBoard( 50, self.buffer) #creates the bottom "player" grid self.fillCoordinates() # sets the UI self.placeShipPhase(numShips) # places ship playerWin = self.attackPhase() quitGame = False while not quitGame: self.result(playerWin) #displays if you win or not for event in pygame.event.get(): self.checkQuit(event) #checks to see if you quit if event.type == pygame.KEYDOWN: #confirm placement if event.key == pygame.K_RETURN: # quits if hit enter quitGame = True def banger(self): ''' banger Method Parameters: N/A Returns: N/A Preconditions: N/A Postconditions: plays banger music ''' #pygame.mixer.init() #sound = pygame.mixer.Sound("metal.mp3") #sound.set_volume(.5) #pygame.mixer.music.load("metal.mp3") #pygame.mixer.music.play(loops=-1) #Metal by Alexander Nakarada | https://www.serpentsoundstudios.com #Music promoted by https://www.free-stock-music.com #Attribution 4.0 International (CC BY 4.0) #https://creativecommons.org/licenses/by/4.0/ def fillCoordinates(self): ''' fillCoordinates Method Parameters: N/A Returns: N/A Preconditions: N/A Postconditions: outputs GUI for player with row and column names ''' self.screen.fill(black) xCoordinates = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'] yCoordinates = ['1', '2', '3', '4', '5', '6', '7', '8', '9'] bottom = 75 left = 55 font = pygame.font.Font('freesansbold.ttf', 20) titlefont = pygame.font.Font('freesansbold.ttf', 25) toptext = titlefont.render('Opponent Board', False, (255, 255, 255)) bottext = titlefont.render('Player Board', False, (255, 255, 255)) self.screen.blit(toptext, (130, 15)) self.screen.blit(bottext, (130, 470)) #for top board Y coordinates for y in range(9): text = font.render(yCoordinates[y], True, white, black) textRect = text.get_rect() textRect.bottom = bottom textRect.right = 30 # x axis of label self.screen.blit(text, textRect) bottom = bottom + 40 # distance between characters #for top board X coordinates for x in range(9): text = font.render(xCoordinates[x], True, white, black) textRect = text.get_rect() textRect.top = 405 # y axis of label textRect.left = left self.screen.blit(text, textRect) left = left + 41 # distance between characters #for bot board Y coordinates for y in range(9): text = font.render(yCoordinates[y], True, white, black) textRect = text.get_rect() textRect.bottom = bottom + 100 # y axis of label textRect.right = 30 self.screen.blit(text, textRect) bottom = bottom + 40 # distance between characters left = 55 #reset left coordinate # for bot board X coordinates for x in range(9): text = font.render(xCoordinates[x], True, white, black) textRect = text.get_rect() textRect.top = 865 # x axis of labels textRect.left = left self.screen.blit(text, textRect) left = left + 41 # distance between characters def result(self, winner): ''' result Method Parameters: winner (who won the game (bool: true if player won, false if computer)) Returns: N/A Preconditions: game finished playing Postconditions: displays winner or loser screen ''' red = (255, 0, 0) # makes red more vibrant font = pygame.font.Font('freesansbold.ttf', 50) if winner == True: text = font.render('You Win!', True, black, red) textRect = text.get_rect() textRect.center = (int(self.SCREEN_WIDTH // 2), int(self.SCREEN_HEIGHT // 2)) self.screen.blit(text, textRect) else: text = font.render('You Lose!', True, black, red) textRect = text.get_rect() textRect.center = (int(self.SCREEN_WIDTH // 2), int(self.SCREEN_HEIGHT // 2)) self.screen.blit(text, textRect) font = pygame.font.Font('freesansbold.ttf', 20) text = font.render('Press enter to quit', True, black, red) textRect = text.get_rect() textRect.center = (int(self.SCREEN_WIDTH // 2), int(self.SCREEN_HEIGHT // 2) + 30) self.screen.blit(text, textRect) pygame.display.flip()
from Computer import Computer filename = "input.txt" with open(filename,"r") as file_in: program = file_in.readline().strip('\n') computer = Computer(program) computer.initialise_memory((12,2)) computer.run_program() print(f'Answer: {computer.memory[0]}') ''' PART 2 ''' for noun in range(1, 100): for verb in range(1, 100): # Need to reset computer memory to initial state before each run computer = Computer(program) computer.initialise_memory((noun,verb)) computer.run_program() if computer.memory[0] == 19690720: print(f"Noun = {noun}; Verb = {verb}. Answer = {100 * noun + verb}") break
''' David Hanley, Dec 2019 See: https://adventofcode.com/2019/day/5 ''' from Computer import Computer filename = "input.txt" with open(filename, "r") as file_in: program = file_in.readline().strip('\n') computer = Computer(program) computer.run_program()
def test_add_and_multiply(test_input, expected): computer = Computer(test_input) computer.compute() assert computer.memory == expected
def main(): player = Player.decide(); computer = Computer.decide(); print('The computer chose ', computer, '. You chose ', player, sep = ''); decider = Decider(computerChoice = computer, playerChoice = player); decider.decide();
class Game: board = np.empty([3, 3], dtype=str) num_player = 0 cur_player = 0 game_mode = 0 player1 = Player("X") player2 = Player("O") computer_player = Computer() def __init__(self): self.cur_player = randint(0, 1) self.game_mode = 0 def set_player_count(self, num_player): self.num_player = int(num_player) def set_player(self, num_player): self.cur_player = num_player def set_game_mode(self, game_mode): self.game_mode = game_mode # This method is to help with unit testing def set_board(self, board): self.board = board def get_player_count(self): return self.num_player def get_player(self): # Depending on the game mode the players playing are either two humans or a human and the computer if self.game_mode == 0: self.players = [self.player1, self.computer_player] else: self.players = [self.player1, self.player2] return self.players[self.cur_player] def get_cur_player(self): return self.cur_player def get_board(self): return self.board def print_board(self): print(self.board) def print_player_turn(self): if self.get_player_count() == 2: print("It's Player", self.cur_player + 1, "'s turn!") else: print("It's Your Turn!") if self.get_cur_player() == 0 else print( "It's the Computer's Turn!") # Checks all rows for 3 in a row. def check_row(self, marker): for row, i in enumerate(self.board): count = 0 for item in self.board[row]: if (item == marker): count += 1 if count == 3: return True return False # Checks all columns for 3 in a row. def check_col(self, marker): for col, i in enumerate(self.board): count = 0 column = self.board[:, col] for item in column: if (item == marker): count += 1 if count == 3: return True return False # Checks both diagonals for 3 in a row. def check_diag(self, marker): diag = np.empty([2, 3], dtype=str) for i in range(3): diag[0, i] = self.board[i, i] diag[1, i] = self.board[i, 2 - i] count1 = 0 count2 = 0 for item1, item2 in zip(diag[0], diag[1]): if item1 == marker: count1 += 1 if item2 == marker: count2 += 1 if count1 == 3 or count2 == 3: return True return False # This function uses previous checks to see if the current player has won. def check_win(self, marker): is_win = self.check_row(marker) or \ self.check_col(marker) or self.check_diag(marker) return is_win # This function checks to see if a marker can be placed at a location # Moves were not being read in correctly as integers. # Type casting fixed issue def check_location(self, location): return self.board[int(location[0]), int(location[1])] == "" # This function adds a move to the board. # Locations were not being read correctly as integers. # Type casting fixed issues. def add_move(self, location, cur_player_marker): self.board[int(location[0]), int(location[1])] = cur_player_marker def clear(self): # for windows if name == 'nt': system('cls') # for mac and linux else: system('clear')
from Computer import Computer import pygame screen_width = 45 screen_height = 30 scaling_factor = 10 pygame.init() win = pygame.display.set_mode((screen_width*scaling_factor, screen_height*scaling_factor)) screen = pygame.Surface((screen_width, screen_height)) run = True comp = Computer() block_tiles = 0 score = 0 paddle_pos = old_paddle_pos = (0, 0) ball_pos = old_ball_pos = (0, 0) output = [] while run: pygame.time.delay(50) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False comp.run() output.append(comp.output) comp.un_halt() comp.run()
# We remember the masterHostIp for using it with the "computers" later # Take care: If you want to have a network that spans multiple PCs, you need to specify the external IP here instead of localhost (127.0.0.1) masterHostIp = '127.0.0.1' __debugOut.debugOutSource("Main", __debugOut.srcComputer, __debugOut.INFO, "Initiating PhyMaster") network = PhyNetwork(baseport=10000, numberOfNodesPerRing=4, ownIdentifier="PhyMaster") __debugOut.debugOutSource("Main", __debugOut.srcComputer, __debugOut.INFO, "Initiating PhyMaster done \n") # We are initiating one computer __debugOut.debugOutSource("Main", __debugOut.srcComputer, __debugOut.INFO, "Instanciation computer 1") computer1 = Computer(ownIdentifier="A", masterHost=masterHostIp, baseport=10000, statusUpdateSeconds=10) # Get the global debug messages from the server for the graphical interface (this shall only be done for one computer) computer1.enableGlobalDebug() # Configure the delay in each layer and before sending the packet out of the computer (for debugging) computer1.debugConfigureNetworkstackDelay(sendDelay=0.2, layerDelay=0.2) __debugOut.debugOutSource("Main", __debugOut.srcComputer, __debugOut.INFO, "Instanciation computer 2") computer2 = Computer(ownIdentifier="B", masterHost=masterHostIp, baseport=10000, statusUpdateSeconds=10) computer2.debugConfigureNetworkstackDelay(sendDelay=0.2, layerDelay=0.2) # We may want to have a third computer somewhen
Bx = 0; By = 0.2; Bz = 0; return [Bx, By, Bz]; r0 = np.array([0,0,0]) v0 = np.array([0.6 * Constants.c,0,0]) m = Constants.me q = Constants.e tStart = 0 tEnd = 1e-9 dt = 1e-13 E = Field(E_Feld) B = Field(B_Feld) particle = Particle(r0, v0, m, q) comput = Computer(dt) comput.start(E, B, particle, tStart, tEnd) r = Drawer() r.DrawTrajectory(particle.getTrajectory()) #r.DrawKineticEnergy(particle.getKineticEnergy(), tStart, tEnd, dt) #r.DrawKineticEnergy(particle.getVelocities(), tStart, tEnd, dt)
from Board import Board from Game import Game from Computer import Computer from ui import UI from GUI import GUI from Settings import Settings def get_ui_from_properties(settings, game): if settings['ui'] == 'gui': window_width = int(settings['window_width']) window_height = int(settings['window_height']) window_title = settings['window_title'] return GUI(game, window_width, window_height, window_title) elif settings['ui'] == 'console': return UI(game) if __name__ == '__main__': settings = Settings("application.properties") board = Board(6, 7) computer = Computer() game = Game(board, computer) ui = get_ui_from_properties(settings, game) ui.run()
#!/usr/bin/env python from PhyNetwork import PhyNetwork from Computer import Computer import time if __name__ == '__main__': # We try to be the master first print("Initiating PhyMaster") network=PhyNetwork(baseport=10000, numberOfNodesPerRing=3) print("Initiating PhyMaster done") computer1=Computer(ownIdentifier="A", sendDestinations=["C"], masterHost='127.0.0.1', baseport=10000) #computer2=Computer(ownIdentifier="B", sendDestinations=["A"], masterHost='127.0.0.1', baseport=10000) #computer3=Computer(ownIdentifier="C", sendDestinations=["B"], masterHost='127.0.0.1', baseport=10000) #computer4=Computer(ownIdentifier="D", sendDestinations=["A","C"], masterHost='127.0.0.1', baseport=10000) #computer5=Computer(ownIdentifier="R", sendDestinations=["A","C"], masterHost='127.0.0.1', baseport=10000) time.sleep(2) computer1.initiateToken()