def __init__(self):
self.sm = SoundManager()
self.qm = QuartzManager()
# self.am = Arduino()
self.am = QuartzScoreManager()
self.bm = BuzzManager()
self.pm = PerguntasManager()
self.cm = ConsoleManager()
self.scores = [0, 0, 0, 0]
self.player_button_pool = []
def __init__(self):
self.dir_perguntas = '/Users/joaop/Dropbox/quiz/data/2008/'
self.perguntas = self.get_nivel_perguntas()
self.n_cascatas = 6
self.start_sockets()
self.check_cascata()
self.buzz = BuzzManager()
self.sound = SoundManager()
print "%d perguntas carregadas." %(len(self.perguntas), )
print
class GameController():
"""GameController for Quizz Show"""
def __init__(self):
self.sm = SoundManager()
self.qm = QuartzManager()
# self.am = Arduino()
self.am = QuartzScoreManager()
self.bm = BuzzManager()
self.pm = PerguntasManager()
self.cm = ConsoleManager()
self.scores = [0, 0, 0, 0]
self.player_button_pool = []
def begin(self):
"""Game Begin"""
n = self.cm.ask_int("Qual o grupo de perguntas?")
self.perguntas = self.pm.perguntas_grupo( n )
for x in self.perguntas.perguntas():
self.cm.printc( "%d: %s %s" % x)
idx = 0
print self.scores
idx = self.cm.ask_int("Iniciar em que pergunta (0)?")
pergunta = self.perguntas.get_pergunta( idx )
if idx > 0:
cur_score = self.cm.ask("Current score - (0,0,0,0): ")
if len(cur_score) > 4:
self.scores = [int(x) for x in cur_score.split(",")]
print self.scores
while pergunta:
self.ask_pergunta( pergunta )
pergunta = self.perguntas.get_next()
self.am.lights_off()
def show_scores(self):
s = []
i = 1
for score in self.scores:
if score == 1 :
plural = ""
else :
plural = "s"
s.append("Equipa %d - %d ponto%s" % (i, score, plural))
i += 1
self.qm.multiplas(s)
def ask_pergunta(self, pergunta):
self.cm.clear()
self.am.lights_off()
self.qm.pontuacao( self.scores )
print self.scores
self.qm.multiplas(" ")
self.cm.printc( "%s: %s" % (pergunta.ordem, pergunta.pergunta) )
self.qm.perguntar(" Codebits Quiz Show ")
# Show scores only if any team has already scored.
if [x for x in self.scores if x > 0]:
self.show_scores()
ret = self.cm.ask_options("Enviar (S/N)?", ("S", "N"))
if ret == "N": return
self.bm.clear_button_poll()
self.qm.multiplas(" ")
player= self.timer_red_buzz(pergunta)
if player != None:
ret = self.cm.ask_options("Red Buzz %s right? (S/N/(R)etry)" % player, ("S", "N", "I") )
self.qm.perguntar(pergunta.pergunta)
if ret == "S":
time.sleep(5)
self.scores[player-1] += (2 * pergunta.multiplicador )
self.qm.pontuacao( self.scores )
return
if ret == "R":
return self.ask_pergunta(pergunta)
self.cm.ask_options("Enviar Multiplas? (S)", ("S") )
self.timer_multiplas( pergunta, player )
def timer_multiplas(self, pergunta, player=None, t=30):
"""controls clock and checks for multiple choice
events from the buzz"""
if player != None:
player = int(player)
self.am.lights_off()
self.bm.clear_button_poll()
self.clear_player_button_pool()
self.cm.printc(" ")
self.cm.printc("Waiting for Multiplas.")
self.qm.multiplas( [x[0] for x in pergunta.multiplas] )
playersStatus = self.am.get_players_from_int(0)
playerHasResponded = []
if player:
print "Ignoring %d" %(player,)
playerHasResponded.append( player )
self.am.set_player_wrong( player )
try:
while t >= 0:
self.qm.relogio( "0:%.2d" % (t,) )
t -= 1
if len(playerHasResponded) == 4:
self.qm.relogio(" ")
break
for x in range(10):
time.sleep(0.1)
ev = self.bm.poll(True)
# No red buttons, nor the player who failed.
if ev:
if ev.color == "RED" or ev.player in playerHasResponded:
continue
print ev.multi
if pergunta.options[ev.multi][1] == True:
self.sm.play( ev.player )
self.am.set_player_right( ev.player )
self.scores[ev.player-1] += (1 * pergunta.multiplicador)
self.qm.pontuacao( self.scores )
print ev.player
else:
pergunta.add_wrong_player(ev.multi, ev.player)
self.sm.playError()
self.am.set_player_wrong( ev.player )
playersStatus[ev.player - 1][1] = True
print "FAIL"
print ev.player
playerHasResponded.append(ev.player)
except KeyboardInterrupt:
self.qm.relogio(" ")
# Timeout. No one pressed the Buzz.
if t < 1:
self.sm.playTimeOut()
self.cm.ask_options(" Mostrar resposta certa? (S)", ["S"])
self.show_correct_answer(pergunta.options)
self.cm.ask_options("Continuar? (S)", ["S"])
def show_correct_answer(self, options):
l = []
for x in options:
if x[1] == True: l.append(x[0])
else:
l_str = ''
for p in x[2]:
l_str += "(%s) " %(p)
if len(l_str) > 2:
l_str = "X " + l_str
l_str += " %s" %(x[0])
l.append (l_str)
else:
l.append( " ")
self.qm.multiplas( l )
def timer_red_buzz(self, pergunta, t=20, has_been_asked=False):
"""controls clock and checks for buzz events
t is the start time for countdown."""
# Watch for events during the timer and during the time that the presenter
# is reading the question.
if has_been_asked == True:
self.qm.multiplas(" ")
self.qm.perguntar( pergunta.pergunta )
else:
self.clear_player_button_pool()
self.bm.clear_button_poll()
self.qm.perguntar("Podes responder com o botao vermelho.")
if pergunta.multiplicador > 1:
self.qm.multiplas(["Score Multiplier active: %dx" %(pergunta.multiplicador), "Straight answer is worth %d points." % (pergunta.multiplicador*2), "", ""])
self.cm.printc(" ")
self.cm.printc(pergunta.resposta )
self.cm.printc("Waiting RED Buzz.")
try:
someone_answered = False
while t > 0:
if has_been_asked == True:
t -= 1
self.qm.relogio( "0:%.2d" % (t,) )
else:
self.qm.relogio(" ")
for x in range(10):
time.sleep(0.1)
if self.bm.mobile:
ev = self.bm.mobile.poll()
if ev and ev[1] == 1:
if has_been_asked == False:
raise KeyboardInterrupt
ev = self.bm.poll(True)
if ev and ev.color == "RED":
print "GOT %d" % (ev.player,)
self.show_player_buttons(ev)
self.qm.relogio(" ")
someone_answered = True
# Clear all other button requests
# if there's more than one close player,
# show them all.
for x in range (20):
time.sleep(0.1)
ev = self.bm.poll(False)
while ev:
if ev and ev.pressed:
self.show_player_buttons(ev)
ev = self.bm.poll(False)
# Return who won.
return self.player_button_pool[3]
except KeyboardInterrupt:
self.qm.relogio(" ")
if has_been_asked == False:
if someone_answered == True:
return self.player_button_pool[3]
return self.timer_red_buzz( pergunta, 20, True)
# Timeout. No one pressed the Buzz.
self.sm.playTimeOut()
self.cm.ask_options("Timeout. Continuar? (S)", ["S"])
return None
def clear_player_button_pool(self):
self.player_button_pool = [{},[], 0,-1]
def show_player_buttons(self, ev):
"""Show buttons pressed in order"""
bp = self.player_button_pool
if ev.player not in bp[0]:
player_str = "TEAM %d" % ev.player
# Print timestamp against first player
if bp[2]:
player_str += " (%.3f seg)" % ((ev.timestamp + (float(random.randint(1,10)) / 1000)) - bp[2])
else:
self.am.set_player_light(ev.player)
bp[2] = ev.timestamp
bp[0][ev.player] = True
bp[3] = ev.player
bp[1].append(player_str)
for x in bp[1]:
print x
self.qm.multiplas( bp[1] )
self.sm.play( ev.player )
self.player_button_pool = bp
class Broadcast():
def __init__(self):
self.dir_perguntas = '/Users/joaop/Dropbox/quiz/data/2008/'
self.perguntas = self.get_nivel_perguntas()
self.n_cascatas = 6
self.start_sockets()
self.check_cascata()
self.buzz = BuzzManager()
self.sound = SoundManager()
print "%d perguntas carregadas." %(len(self.perguntas), )
print
def start(self):
self.ask("Iniciar cascata? ")
self.pergunta_actual = 0
self.perguntar_cascata()
def perguntar_cascata(self):
pergunta_actual = self.pergunta_actual
pergunta = self.perguntas[pergunta_actual]
c_info = self.cascata_info()
os.system('clear')
print "Pergunta #%d" %(pergunta_actual +1)
print c_info
print
print len(pergunta[1])
print
ask = self.ask(pergunta[1] + "\n\n \t'ok' - enviar pergunta - \n\t's' ou 'a', per. Seguinte/Snterior, \n\t'r' - Reescrever pergunta, \n\t'm' Saltar de pergunta\n\n")
if ask == 'r':
pergunta[1] = self.ask("Texto da pergunta? ")
if ask == 'ok':
self.perguntar(pergunta[1])
self.status( c_info )
self.counterOne()
print "\n\n\nRelogio acabou para pergunta directa\n\n\
n"
ask = self.ask("Avancar para opcoes multiplas? (s/N)")
if ask == 's':
self.counterMultiple()
self.pergunta_actual = self.pergunta_actual + 1
try:
raw_input("Carregar em Enter para avancar nas perguntas.\n")
except KeyboardInterrupt:
pass
elif ask == 's':
self.pergunta_actual = self.pergunta_actual +1
elif ask == 'a':
self.pergunta_actual = self.pergunta_actual -1
if ask == 'm':
self.pergunta_actual = int(self.ask("Numero da Pergunta?"))
return self.perguntar_cascata()
def cascata_info(self):
pergunta_actual = self.pergunta_actual
self.set_cascata_status(pergunta_actual)
print self.n_equipas
print self.equipa_actual
return ("%da Cascata %s, Equipa #%d") % \
(self.cascata_count, self.tipo_cascata, self.n_equipas[self.equipa_actual] )
def set_cascata_status(self, n):
pergunta_actual = n
equipas = self.equipas
tipos_cascatas = ['Ascendente', 'Descendente']
self.numero_cascata = pergunta_actual / equipas
self.equipa_actual = pergunta_actual % equipas
self.tipo_cascata = tipos_cascatas[ self.numero_cascata % 2]
self.cascata_count = ((pergunta_actual/equipas)+2)/2
def ask_equipas(self):
n_equipas = self.ask("Numeros das %d equipas do Nivel? " % (self.equipas))
n_equipas = [int(x) for x in re.split(',\s*', n_equipas)]
if len(n_equipas) != self.equipas:
print "Numero errado de equipas. %d, precisamos de %d." \
% (len(n_equipas), self.equipas)
return self.ask_equipas()
return n_equipas
# Criar valores para a cascata, com base no nivel e numero de perguntas.
def check_cascata(self):
self.numero_perguntas = len(self.perguntas)
niveis = [0,15,10,6]
self.equipas = niveis[self.nivel]
if self.nivel == 1:
self.n_equipas = [x+1 for x in range(self.equipas)]
else:
self.n_equipas = self.ask_equipas()
numero_perguntas = self.equipas * 6
print "Nivel %d tem %d perguntas, %d equipas" \
% (self.nivel, numero_perguntas, self.equipas)
if numero_perguntas != self.numero_perguntas:
print "Numero errado de Perguntas!"
sys.exit(0)
def start_sockets(self):
broadcast_host = '127.0.0.1'
self.sPergunta = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sRelogio = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sMultiplas = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sPergunta.connect((broadcast_host, 50000))
self.sRelogio.connect((broadcast_host, 51000))
self.sMultiplas.connect((broadcast_host, 52000))
def get_nivel_perguntas(self):
self.nivel = int(self.ask("Nivel da Cascata? "))
ficheiro = "%s/final_nivel%d.txt" % (self.dir_perguntas, self.nivel)
try:
os.stat(ficheiro)
return self.get_perguntas(ficheiro)
except OSError:
print "%s nao existe" %(ficheiro,)
return self.get_nivel_perguntas()
def get_perguntas(self, ficheiro):
cread = csv.reader(open(ficheiro, "rb"), dialect="excel")
perguntas = []
for row in cread:
if len(row) < 4 : continue
perguntas.append([row[0], row[1]])
return perguntas
def ask(self,texto):
return raw_input(texto)
def utf32encode(self, s):
s = s.encode('utf-16be')
ret = ''
i= 0
while i < len(s):
ret += '\0\0' + s[i:i+2]
i += 2
return ret
def display(self, socket, string):
socket.send(self.utf32encode(string))
def perguntar(self, texto):
self.display(self.sPergunta, texto)
def relogio(self, texto):
self.display(self.sRelogio, texto)
def status(self, texto):
self.display(self.sMultiplas, texto)
def clear(self):
self.perguntar(" ")
self.relogio(" ")
self.status(" ")
def showPlayerButtons(self, ev):
"""Show buttons pressed in order"""
bp = self.player_button_pool
if ev.player not in bp[0]:
player_str = "JOGADOR %d" % ev.player
# Print timestamp against first player
if bp[2]:
player_str += " (%.3f seg)" % (ev.timestamp - bp[2])
else:
arduino.write( str(ev.player) )
bp[2] = ev.timestamp
bp[1].append(player_str)
self.status( "|".join(bp[1]) )
self.sound.play( ev.player )
self.player_button_pool = bp
def counterOne(self, t=5):
self.player_button_pool = [{},[], 0]
# Make sure event poll is empty
while self.buzz.poll(False): pass
try:
while t >= 0:
t -= 1
self.relogio( "Directa 0:%.2d" % (t,))
for x in range(10):
time.sleep(0.1)
ev = self.buzz.poll(True)
if ev and ev.color == "RED":
self.showPlayerButtons(ev)
self.relogio(" ")
# Clear all other button requests
# if there's more than one close player,
# show them all.
for x in range (15):
time.sleep(0.1)
ev = self.buzz.poll(False)
while ev:
if ev and ev.pressed:
self.showPlayerButtons(ev)
ev = self.buzz.poll(False)
# clean remaining calls
return
for x in range(10):
self.relogio( "TEMPO!!!")
time.sleep(0.25)
self.relogio(" ")
except KeyboardInterrupt:
self.relogio(" ")
