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()
