def generate_real_traffic(self, filename, sw_list=None): # sw_list: senders
# real pcap/pkl -> syn traffic
self.traffic = traffic.Traffic()
if filename.find('.pcap') != -1:
real_traffic = traffic.Traffic(filename)
elif filename.find('.pkl') != -1:
real_traffic = element.de_serialize(filename)
else:
raise NameError('Error. Not a valid input file format. Return')
return
real_pkts = real_traffic.pkts
syn_pkts = self.traffic_mapping(real_pkts, sw_list)
self.traffic.add_pkts(syn_pkts)
return
def main():
pygame.init()
gamedisplay = pygame.display.set_mode((840, 650))
print("#testing driver car model#")
test_driver = driver.Driver(0, 0)
print("#right input test#")
test_driver.moveRight()
assert test_driver.x == 5
print('#zero input test#')
assert test_driver.x == 5
print('#left input test#')
test_driver.moveLeft()
assert test_driver.x == 0
print("#testing traffic model#")
test_traffic = traffic.Traffic(0)
print('#speedup test#')
oldspeed = test_traffic.randomspeed
test_traffic.speedup()
assert test_traffic.randomspeed > oldspeed
print('#slowdown test#')
oldspeed = test_traffic.randomspeed
test_traffic.slowdown()
assert test_traffic.randomspeed < oldspeed
print('#reset test#')
test_traffic.reset()
assert test_traffic.y >= -2000 and test_traffic.y <= -500
print('#drive test#')
test_traffic.drive()
assert test_traffic.y >= -2000 and test_traffic.y <= -500
print('#testing gameSetup model#')
test_gameSetup = gameSetup.GameSetup()
print('#game screen test#')
test_gameSetup.setup()
assert test_gameSetup.display_width == 840
print('#testing background model#')
test_background = background.Background()
print('#testing reset#')
test_background.reset()
assert test_background.y == -650
print('#testing speedup#')
test_background.speedup()
assert test_background.speed <= 5
print('#testing slowdown#')
test_background.slowdown()
assert test_background.speed >= 2
def generate_random_traffic(self, traffic_mat, total, burst_max=1, exp=1, pktsize=1500):
self.traffic = traffic.Traffic()
pkts = []
cdf_mat = element.pdf2cdf(traffic_mat)
for _ in range(total):
[src, dst] = element.sample(cdf_mat)
pkts += traffic.synflow2pkt(src, dst, burst_max, exp, pktsize)
self.traffic.add_pkts(pkts)
return 0
def generate_sample_traffic(self, dup=1):
self.traffic = traffic.Traffic()
pkts = []
flow_set = [[i, j] for i in range(self.switch_num)
for j in range(self.switch_num)]
for flow in flow_set:
pkts += traffic.synflow2pkt(flow[0], flow[1], dup=dup)
self.traffic.add_pkts(pkts)
return 0
def __init__(self, date_report):
super().__init__()
self.bar = progressbar.ProgressBar()
self.date_report = date_report
self.tp = telephony.Telephony()
self.ct = calltouch.Calltouch()
self.ads = ads.Ads()
self.tr = traffic.Traffic()
self.er = email_report.EmailReport()
self.pl = plot_ly.Plotly()
self.cb = callbacks.CallBacks()
self.bar.update(5)
def __init__(self):
#Run the game window setup
self.game = gameSetup.GameSetup()
self.game.setup()
#Initialize all needed objects
self.gamedisplay = self.game.gamedisplay
self.drivercar = driver.Driver(500, 400)
self.background = background.Background()
self.mainmenu = mainMenuLoop.TitleScreen(self.gamedisplay)
self.crashmenu = crashMenuLoop.CrashMenuLoop(self.gamedisplay)
self.lane1 = traffic.Traffic(110)
self.lane2 = traffic.Traffic(230)
self.lane3 = traffic.Traffic(370)
self.lane4 = traffic.Traffic(500)
self.slowfont = pygame.font.SysFont("monospace", 30)
self.scorefont = pygame.font.SysFont("monospace", 20)
self.dodged = 0
pygame.mixer.music.load("assets/race_music.mp3")
#Group the lane objects together
self.lanegroup = pygame.sprite.Group(self.lane1, self.lane2,
self.lane3, self.lane4)
def __init__(self, topo, soft_labels=None, regions=None):
self.topo = topo
self.switch_num = len(topo)
self.switches = []
for label in range(self.switch_num):
self.switches.append(switch.Switch(label))
self.soft_labels = soft_labels
if soft_labels is None:
self.soft_labels = []
for label in self.soft_labels:
self.switches[label].set_sw_type(setting.TYPE_SOFTWARE)
self.controller = controller.Controller(topo, soft_labels, regions)
self.traffic = traffic.Traffic()
def pre_pcap(pcap_filelist, pkl_file, max_flownum=None, json_file=None):
print('serialize {} into {}'.format(pcap_filelist, pkl_file))
t = traffic.Traffic()
for pcap_file in pcap_filelist:
print('processing {}...'.format(pcap_file))
pkts = traffic.pcap2pkts(pcap_file)
t.add_pkts(pkts)
flownum = t.flownum[-1]
print('flow number: {}'.format(flownum))
if max_flownum is not None and flownum > max_flownum:
break
t.serialize(pkl_file)
print('target flow number: {}; real flow number: {}'.format(max_flownum, t.flownum[-1]))
print('total number of packets: {}'.format(len(t.pkts)))
if json_file is not None:
t.print_traffic_data(json_file)
return
def getTraffic(self):
traffic_time = str(traffic.Traffic())
traffic_time = float(traffic_time)
if traffic_time <= 4.3:
#print(str(traffic_time))
print("NO TRAFFIC") #0 - 4 minutes
microbit.MicrobitControl().noTraffic()
elif traffic_time <= 9.3:
print("Traffic Building") #5 - 9 minutes
microbit.MicrobitControl().trafficBuilding()
elif traffic_time <= 14.3:
print("Traffic Pretty Bad") #10 - 14 minutes
microbit.MicrobitControl().trafficBad()
elif traffic_time <= 19.3:
print("Traffic Awful") #15 - 19Minutes
microbit.MicrobitControl().trafficAwful()
elif traffic_time > 19.3:
print("Traffic Really Very Awful") #20+ minutes
microbit.MicrobitControl().worstTraffic()
def pre_classbench_trace():
print('generating classbench trace...')
with open(setting.CB_TRACE, 'r') as f:
lines = f.readlines()
lines = [l.rstrip('\n').split('\t') for l in lines]
tf = traffic.Traffic()
pkts = []
for l in lines:
srcip = element.int2ip(int(l[0]))
dstip = element.int2ip(int(l[1]))
srcport = int(l[2])
dstport = int(l[3])
protocol = int(l[4])
p = traffic.Packet((srcip, dstip, srcport, dstport, protocol))
# modify src and dst
p.src = 0
p.dst = 2
pkts.append(p)
tf.add_pkts(pkts)
element.serialize(tf, setting.CB_TRACE_PKL)
return
def setVeiculosHardmode(self):
if (self.veiculos_hardmode is False):
self.veiculos_hardmode = True
self.quantidadeVeiculos = AI_CONFIG._L3_quantidade_veiculos_dificil
for count in range(0, gameControl.quantidadeVeiculos):
traffic_s.add(traffic.Traffic())
def main(id='001'):
agentePontosGanho = AI_INSTANCES.Agente_Interativo(
AI_CONFIG._L3_PARAMETRO_pontos, 'gte', gameControl.setVeiculosHardmode)
agenteTempoGasto = AI_INSTANCES.Agente_Interativo(
AI_CONFIG._L3_PARAMETRO_tempogasto, 'gte',
gameControl.setExtraTimeHardmode)
agenteChamadasAtendidas = AI_INSTANCES.Agente_Interativo(
AI_CONFIG._L3_PARAMETRO_chamadas_atentidas, 'gte',
gameControl.setPontosHardmode)
agenteParadas = AI_INSTANCES.Agente_Interativo(
AI_CONFIG._L3_PARAMETRO_paradas, 'gte', gameControl.setPontosHardmode)
agenteEscrita = AI_INSTANCES.Agente_de_Escrita('./logs/' + id + '.txt', id,
3)
agenteEscrita.escreveLog(['NOVOJOGO', str(0)])
totalChamadasAtendidas = 0
totalParadas = 0
running = True
# generate tiles
for tile_num in range(0, len(maps.map_tile)):
maps.map_files.append(load_image(maps.map_tile[tile_num], False))
for x in range(0, 10):
for y in range(0, 10):
map_s.add(
maps.Map(maps.map_1[x][y], x * 1000, y * 1000,
maps.map_1_rot[x][y]))
# load tracks
tracks.initialize()
# load finish
target_s.add(target)
# load direction
pointer_s.add(pointer)
# load alerts
timer_alert_s.add(time_alert)
bound_alert_s.add(bound_alert)
celular_s.add(celular_alert)
stop_s.add(stop_alert)
menu_alert_s.add(info)
# load traffic
traffic.initialize(CENTER_W, CENTER_H)
for count in range(0, gameControl.quantidadeVeiculos):
traffic_s.add(traffic.Traffic())
player_s.add(car)
cam.set_pos(car.x, car.y)
end = False
while running:
# Render loop.
# Check for menu/reset, (keyup event - trigger ONCE)
keys = pygame.key.get_pressed()
for event in pygame.event.get():
if event.type == pygame.KEYUP:
if keys[K_m]:
if (info.visibility == True):
info.visibility = False
else:
info.visibility = True
if (keys[K_p]):
end = False
car.reset()
target.reset()
if (keys[K_q]):
agenteEscrita.escreveLog(['SAIU', '-'])
pygame.quit()
sys.exit(0)
if (keys[K_z]): # atende ligacao
celular_alert.atender = True
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
from source.menu import Menu as menu2
aux = menu2()
aux.main_menu()
running = False
agenteEscrita.escreveLog(['SAIU', '-'])
break
# Check for key input. (KEYDOWN, trigger often)
if (target.timeleft > 0):
if keys[K_LEFT]:
car.steerleft()
if keys[K_RIGHT]:
car.steerright()
if keys[K_UP]:
car.accelerate()
else:
car.soften()
if keys[K_DOWN]:
car.deaccelerate()
cam.set_pos(car.x, car.y)
# Show text data.
text_fps = font.render('', 1, (224, 16, 16))
textpos_fps = text_fps.get_rect(centery=25, centerx=60)
text_score = font.render('Pontuacao: ' + str(target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=45, centerx=60)
text_timer = font.render(
'Tempo: ' + str(int((target.timeleft / 60) / 60)) + ":" +
str(int((target.timeleft / 60) % 60)), 1, (224, 16, 16))
textpos_timer = text_fps.get_rect(centery=65, centerx=60)
# Render Scene.
screen.blit(background, (0, 0))
# cam.set_pos(car.x, car.y)
map_s.update(cam.x, cam.y)
map_s.draw(screen)
# Conditional renders/effects
car.grass(screen.get_at(((int(CENTER_W - 5), int(CENTER_H - 5)))).g)
tracks_s = []
if car.tracks:
tracks_s.add(
tracks.Track(cam.x + CENTER_W, cam.y + CENTER_H, car.dir))
# Just render..
tracks_s.update(cam.x, cam.y)
tracks_s.draw(screen)
player_s.update(cam.x, cam.y)
player_s.draw(screen)
traffic_s.update(cam.x, cam.y)
traffic_s.draw(screen)
target_s.update(cam.x, cam.y)
target_s.draw(screen)
pointer_s.update(car.x + CENTER_W, car.y + CENTER_H, target.x,
target.y)
pointer_s.draw(screen)
# stop_alert.updateTimer(time.time())
# Conditional renders.
if (bounds.breaking(car.x + CENTER_W, car.y + CENTER_H) == True):
bound_alert_s.update()
bound_alert_s.draw(screen)
if (target.timeleft == 0):
timer_alert_s.draw(screen)
car.speed = 0
text_score = font.render('Pontuacao Final: ' + str(target.score),
1, (224, 16, 16))
textpos_score = text_fps.get_rect(centery=CENTER_H,
centerx=CENTER_W - 100)
if end is False:
end = True
gameControl.extraTimeValue = AI_CONFIG._L3_tempo_extra_facil
gameControl.quantidadeVeiculos = AI_CONFIG._L3_quantidade_veiculos_facil
gameControl.pontosChamadaAtendida = AI_CONFIG._L3_ponto_atender_facil
gameControl.pontosPararCarro = AI_CONFIG._L3_ponto_parar_facil
agenteEscrita.escreveLog(['TERMINOU', str(target.score)])
celular_alert.grass(
screen.get_at(((int(CENTER_W - 5), int(CENTER_H - 5)))).g,
car.speed)
if (target.totalTime > 300 and int(
(target.totalTime / 60) % 60) % 20 == 0):
celular_alert.visibility = True
celular_alert.startTimer()
if (celular_alert.tocando):
celular_alert.chron.run()
if (target.timeleft > 0 and celular_alert.visibility is True
and celular_alert.tocando is True):
celular_s.draw(screen)
keys = pygame.key.get_pressed()
if (keys[K_c] and car.speed > 0.4):
celular_alert.visibility = False
celular_alert.tocando = False
target.score -= 70
agenteEscrita.escreveLog(['ATENDEUERRADO', -70])
if (celular_alert.visibility is True
and celular_alert.tocando is True and keys[K_c]
and car.speed <= 0.4):
celular_alert.visibility = False
celular_alert.tocando = False
target.score += gameControl.pontosChamadaAtendida
agenteEscrita.escreveLog(['ATENDEU', 200])
agenteChamadasAtendidas.analizaEntrada(totalChamadasAtendidas)
if (not celular_alert.cel_time()):
celular_alert.visibility = False
celular_alert.tocando = False
target.score -= 100
agenteEscrita.escreveLog(['NAOATENDEU', -100])
stop_alert.stop_car(car.speed)
if (target.totalTime != 0 and int(
(target.totalTime / 60) % 60) % 15 == 0 and car.speed >= 0.1):
stop_alert.visibility = True
if (target.timeleft > 0 and stop_alert.visibility is True):
stop_s.draw(screen)
if (car.speed < 0.1):
target.score += 200
stop_alert.visibility = False
agenteEscrita.escreveLog(['PAROU', 200])
agenteParadas.analizaEntrada(totalParadas)
else:
target.score -= 1
if (info.visibility == True):
menu_alert_s.draw(screen)
# Blit Blit..
pygame.draw.rect(screen, (216, 216, 216), [40, 30, 200, 55])
screen.blit(text_fps, textpos_fps)
screen.blit(text_score, textpos_score)
screen.blit(text_timer, textpos_timer)
pygame.display.flip()
# Check collision!!!
if pygame.sprite.spritecollide(car, traffic_s, False):
car.impact()
target.car_crash()
target.score -= 5
agenteEscrita.escreveLog(['BATIDA', '-5'])
if pygame.sprite.spritecollide(car, target_s, True):
target.claim_flag(gameControl.extraTimeValue)
target.score += 50
target.generate_finish()
target_s.add(target)
agenteEscrita.escreveLog(
['TEMPOEXTRA', gameControl.extraTimeValue])
agentePontosGanho.analizaEntrada(target.score)
agenteTempoGasto.analizaEntrada(target.totalTime)
clock.tick(64)
# cria semaforo
# Enter the mainloop.
# main()
# pygame.quit()
# sys.exit(0)
def main():
clock = pygame.time.Clock()
running = True
font = pygame.font.Font(None, 24)
car = player.Player()
cam = camera.Camera()
target = gamemode.Final()
bound_alert = bounds.Alert()
time_alert = timeout.Alerta()
info = menu.Alerta()
# se crea un sprite con los grupos
game_main_sprite = pygame.sprite.Group()
map_s = pygame.sprite.Group()
player_s = pygame.sprite.Group()
traffic_s = pygame.sprite.Group()
target_s = pygame.sprite.Group()
pointer_s = pygame.sprite.Group()
timer_alerta_s = pygame.sprite.Group()
bound_alert_s = pygame.sprite.Group()
menu_alerta_s = pygame.sprite.Group()
balas = pygame.sprite.Group()
#Generar tiles
for tile_num in range(0, len(maps.map_tile)):
maps.map_files.append(load_image(maps.map_tile[tile_num], False))
for x in range(0, 10):
for y in range(0, 10):
map_s.add(
maps.Map(maps.map_1[x][y], x * 1000, y * 1000,
maps.map_1_rot[x][y]))
#Se carga el final del juego
game_main_sprite.add(target)
target_s.add(target)
#Se cargan las alertas
timer_alerta_s.add(time_alert)
bound_alert_s.add(bound_alert)
menu_alerta_s.add(info)
#Carga Trafico
traffic.initialize(Centro_W, Centro_H)
for count in range(0, Cantidad_trafico):
game_main_sprite.add(traffic.Traffic())
traffic_s.add(traffic.Traffic())
game_main_sprite.add(car)
player_s.add(car)
cam.set_pos(car.x, car.y)
while running:
for event in pygame.event.get():
if event.type == pygame.KEYUP:
if (keys[K_m]):
if (info.visibilidad == True):
info.visibilidad = False
else:
info.visibilidad = True
if (keys[K_p]):
car.reset()
target.reset()
if (keys[K_q]):
pygame.quit()
sys.exit(0)
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
running = False
break
#Check for key input. (KEYDOWN, trigger often)
keys = pygame.key.get_pressed()
if (target.timeleft > 0):
if keys[K_LEFT]:
car.dirigir_izquierda()
if keys[K_RIGHT]:
car.dirigir_derecha()
if keys[K_UP]:
car.accelerate()
else:
car.soften()
if keys[K_DOWN]:
car.deaccelerate()
if keys[K_SPACE]:
#Crear objeto bala
bala = player.DisparoCarro()
bala.rect.x = car.rect.x
bala.rect.y = car.rect.y
bala.dir = car.dir
bala.image = pygame.transform.rotate(bala.image, bala.dir)
game_main_sprite.add(bala)
balas.add(bala)
cam.set_pos(car.x, car.y)
text_fps = font.render('FPS: ' + str(int(clock.get_fps())), 1,
(224, 16, 16))
textpos_fps = text_fps.get_rect(centery=25, centerx=60)
text_score = font.render('Score: ' + str(target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=45, centerx=60)
text_timer = font.render(
'Timer: ' + str(int((target.timeleft / 30) / 60)) + ":" +
str(int((target.timeleft / 60) % 60)), 1, (224, 16, 16))
textpos_timer = text_fps.get_rect(centery=65, centerx=60)
screen.blit(background, (0, 0))
cam.set_pos(car.x, car.y)
map_s.update(cam.x, cam.y)
map_s.draw(screen)
player_s.update()
player_s.draw(screen)
traffic_s.update(cam.x, cam.y)
traffic_s.draw(screen)
target_s.update(cam.x, cam.y)
target_s.draw(screen)
pointer_s.update(car.x + Centro_W, car.y + Centro_H, target.x,
target.y)
pointer_s.draw(screen)
balas.update()
balas.draw(screen)
if (bounds.breaking(car.x + Centro_W, car.y + Centro_H) == True):
bound_alert_s.update()
bound_alert_s.draw(screen)
if (target.timeleft == 0):
timer_alerta_s.draw(screen)
car.speed = 0
text_score = font.render('Puntaje Final: ' + str(target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=Centro_H + 56,
centerx=Centro_W - 20)
if (info.visibilidad == True):
menu_alerta_s.draw(screen)
screen.blit(text_score, textpos_score)
screen.blit(text_timer, textpos_timer)
pygame.display.flip()
#Colosiones
if pygame.sprite.spritecollide(car, traffic_s, False):
car.impact()
target.colision_carro()
if pygame.sprite.spritecollide(car, target_s, True):
target.Bandera()
target.generar_final()
target_s.add(target)
clock.tick(200)
def getTraffic(self):
return traffic.Traffic()
def main():
#initialize objects.
clock = pygame.time.Clock()
running = True
font = pygame.font.Font(None, 32)
car = player.Player()
cam = camera.Camera()
target = gamemode.Finish()
bound_alert = bounds.Alert()
time_alert = timeout.Alert()
celular_alert = leis_transito.CelularAlert()
stop_alert = leis_transito.StopAlert()
info = menu.Alert()
pointer = direction.Tracker(int(CENTER_W * 2), int(CENTER_H * 2))
#create sprite groups.
map_s = pygame.sprite.Group()
player_s = pygame.sprite.Group()
celular_s = pygame.sprite.Group()
stop_s = pygame.sprite.Group()
traffic_s = pygame.sprite.Group()
tracks_s = pygame.sprite.Group()
target_s = pygame.sprite.Group()
pointer_s = pygame.sprite.Group()
timer_alert_s = pygame.sprite.Group()
bound_alert_s = pygame.sprite.Group()
menu_alert_s = pygame.sprite.Group()
#generate tiles
for tile_num in range(0, len(maps.map_tile)):
maps.map_files.append(load_image(maps.map_tile[tile_num], False))
for x in range(0, 10):
for y in range(0, 10):
map_s.add(
maps.Map(maps.map_1[x][y], x * 1000, y * 1000,
maps.map_1_rot[x][y]))
#load tracks
tracks.initialize()
#load finish
target_s.add(target)
#load direction
pointer_s.add(pointer)
#load alerts
timer_alert_s.add(time_alert)
bound_alert_s.add(bound_alert)
celular_s.add(celular_alert)
stop_s.add(stop_alert)
menu_alert_s.add(info)
#load traffic
traffic.initialize(CENTER_W, CENTER_H)
for count in range(0, TRAFFIC_COUNT):
traffic_s.add(traffic.Traffic())
player_s.add(car)
cam.set_pos(car.x, car.y)
while running:
#Render loop.
#Check for menu/reset, (keyup event - trigger ONCE)
for event in pygame.event.get():
if event.type == pygame.KEYUP:
if keys[K_m]:
if (info.visibility == True):
info.visibility = False
else:
info.visibility = True
if (keys[K_p]):
car.reset()
target.reset()
if (keys[K_q]):
pygame.quit()
sys.exit(0)
if (keys[K_z]): # atende ligacao
celular_alert.atender = True
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
from source.menu import Menu as menu2
aux = menu2()
aux.main_menu()
running = False
break
#Check for key input. (KEYDOWN, trigger often)
keys = pygame.key.get_pressed()
if (target.timeleft > 0):
if keys[K_LEFT]:
car.steerleft()
if keys[K_RIGHT]:
car.steerright()
if keys[K_UP]:
car.accelerate()
else:
car.soften()
if keys[K_DOWN]:
car.deaccelerate()
cam.set_pos(car.x, car.y)
#Show text data.
text_fps = font.render('', 1, (224, 16, 16))
textpos_fps = text_fps.get_rect(centery=25, centerx=60)
text_score = font.render('Pontuacao: ' + str(target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=45, centerx=60)
text_timer = font.render(
'Tempo: ' + str(int((target.timeleft / 60) / 60)) + ":" +
str(int((target.timeleft / 60) % 60)), 1, (224, 16, 16))
textpos_timer = text_fps.get_rect(centery=65, centerx=60)
#Render Scene.
screen.blit(background, (0, 0))
#cam.set_pos(car.x, car.y)
map_s.update(cam.x, cam.y)
map_s.draw(screen)
#Conditional renders/effects
car.grass(screen.get_at(((int(CENTER_W - 5), int(CENTER_H - 5)))).g)
if car.tracks:
tracks_s.add(
tracks.Track(cam.x + CENTER_W, cam.y + CENTER_H, car.dir))
#Just render..
tracks_s.update(cam.x, cam.y)
tracks_s.draw(screen)
player_s.update(cam.x, cam.y)
player_s.draw(screen)
traffic_s.update(cam.x, cam.y)
traffic_s.draw(screen)
target_s.update(cam.x, cam.y)
target_s.draw(screen)
pointer_s.update(car.x + CENTER_W, car.y + CENTER_H, target.x,
target.y)
pointer_s.draw(screen)
# stop_alert.updateTimer(time.time())
#Conditional renders.
if (bounds.breaking(car.x + CENTER_W, car.y + CENTER_H) == True):
bound_alert_s.update()
bound_alert_s.draw(screen)
if (target.timeleft == 0):
timer_alert_s.draw(screen)
car.speed = 0
text_score = font.render('Pontuacao Final: ' + str(target.score),
1, (224, 16, 16))
textpos_score = text_fps.get_rect(centery=CENTER_H + 56,
centerx=CENTER_W - 20)
celular_alert.grass(
screen.get_at(((int(CENTER_W - 5), int(CENTER_H - 5)))).g,
car.speed)
if (int((target.timeleft / 60) % 60) % 20 == 0):
celular_alert.visibility = True
if (target.timeleft > 0 and celular_alert.visibility is True):
celular_s.draw(screen)
keys = pygame.key.get_pressed()
celular_alert.startTimer()
if (keys[K_c] and car.speed > 0.4):
target.score -= 15
celular_alert.visibility = False
if (keys[K_c] and car.speed <= 0.4):
target.score += 200
celular_alert.visibility = False
if (not celular_alert.cel_time()):
target.score -= 100
celular_alert.visibility = False
stop_alert.stop_car(car.speed)
if (int((target.timeleft / 60) % 60) % 15 == 0 and car.speed >= 0.1):
stop_alert.visibility = True
if (target.timeleft > 0 and stop_alert.visibility is True):
stop_s.draw(screen)
if (car.speed < 0.1):
target.score += 200
stop_alert.visibility = False
else:
target.score -= 1
if (info.visibility == True):
menu_alert_s.draw(screen)
#Blit Blit..
pygame.draw.rect(screen, (216, 216, 216), [40, 30, 200, 55])
screen.blit(text_fps, textpos_fps)
screen.blit(text_score, textpos_score)
screen.blit(text_timer, textpos_timer)
pygame.display.flip()
#Check collision!!!
if pygame.sprite.spritecollide(car, traffic_s, False):
car.impact()
target.car_crash()
target.score -= 5
if pygame.sprite.spritecollide(car, target_s, True):
target.claim_flag()
target.score += 150
target.generate_finish()
target_s.add(target)
clock.tick(64)
def main():
# initialize objects.
clock = pygame.time.Clock()
running = True
font = pygame.font.Font(None, 24)
car = player.Player()
cam = camera.Camera()
target = gamemode.Finish()
bound_alert = boundary.Alert()
time_alert = timeout.Alert()
info = menu.Alert()
pointer = direction.Tracker(int(CENTER_W * 2), int(CENTER_H * 2))
# create sprite groups.
map_s = pygame.sprite.Group()
player_s = pygame.sprite.Group()
traffic_s = pygame.sprite.Group()
tracks_s = pygame.sprite.Group()
target_s = pygame.sprite.Group()
pointer_s = pygame.sprite.Group()
timer_alert_s = pygame.sprite.Group()
bound_alert_s = pygame.sprite.Group()
menu_alert_s = pygame.sprite.Group()
# generate tiles
for tile_num in range(0, len(maps.map_tile)):
maps.map_files.append(load_image(maps.map_tile[tile_num], False))
for x in range(0, 10):
for y in range(0, 10):
map_s.add(maps.Map(maps.map_1[x][y], x * 1000, y * 1000, maps.map_1_rot[x][y]))
# load tracks
tracks.initialize()
# load finish
target_s.add(target)
# load direction
pointer_s.add(pointer)
# load alerts
timer_alert_s.add(time_alert)
bound_alert_s.add(bound_alert)
menu_alert_s.add(info)
# load traffic
traffic.initialize(CENTER_W, CENTER_H)
for count in range(0, TRAFFIC_COUNT):
traffic_s.add(traffic.Traffic())
player_s.add(car)
cam.set_pos(car.x, car.y)
while running:
# Check for key input. (KEYDOWN, trigger often)
keys = pygame.key.get_pressed()
# Render loop.
# Check for menu/reset, (keyup event - trigger ONCE)
for event in pygame.event.get():
if event.type == pygame.KEYUP:
if keys[K_m]:
if (info.visibility == True):
info.visibility = False
if (keys[K_p]):
car.reset()
target.reset()
if (keys[K_q]):
pygame.quit()
sys.exit(0)
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
running = False
break
if (target.timeleft > 0):
if keys[K_c]:
car.steerleft()
if keys[K_b]:
car.steerright()
if keys[K_UP]:
car.accelerate()
else:
car.soften()
if keys[K_DOWN]:
car.deaccelerate()
if keys[K_RIGHT]:
car.breakk()
cam.set_pos(car.x, car.y)
# Show text data.
text_fps = font.render('FPS: ' + str(int(clock.get_fps())), 1, (224, 16, 16))
textpos_fps = text_fps.get_rect(centery=25, centerx=60)
text_score = font.render('Score: ' + str(target.score), 1, (224, 16, 16))
textpos_score = text_fps.get_rect(centery=45, centerx=60)
text_timer = font.render(
'Timer: ' + str(int((target.timeleft /1000) / 1000)) + ":" + str(int((target.timeleft / 1500) % 300)), 6,
(224, 16, 16))
textpos_timer = text_fps.get_rect(centery=65, centerx=60)
# Render Scene.
screen.blit(background, (0, 0))
# cam.set_pos(car.x, car.y)
map_s.update(cam.x, cam.y)
map_s.draw(screen)
# Conditional renders/effects
car.grass(screen.get_at(((int(CENTER_W - 5), int(CENTER_H - 5)))).g)
if (car.tracks):
tracks_s.add(tracks.Track(cam.x + CENTER_W, cam.y + CENTER_H, car.dir))
# Just render..
tracks_s.update(cam.x, cam.y)
tracks_s.draw(screen)
player_s.update(cam.x, cam.y)
player_s.draw(screen)
traffic_s.update(cam.x, cam.y)
traffic_s.draw(screen)
target_s.update(cam.x, cam.y)
target_s.draw(screen)
pointer_s.update(car.x + CENTER_W, car.y + CENTER_H, target.x, target.y)
pointer_s.draw(screen)
# Conditional renders.
if (boundary.breaking(car.x + CENTER_W, car.y + CENTER_H) == True):
bound_alert_s.update()
bound_alert_s.draw(screen)
if (target.timeleft == 0):
timer_alert_s.draw(screen)
car.speed = 0
text_score = font.render('Final Score: ' + str(target.score), 1, (224, 16, 16))
textpos_score = text_fps.get_rect(centery=CENTER_H + 56, centerx=CENTER_W - 20)
if (info.visibility == True):
menu_alert_s.draw(screen)
# Blit Blit..
screen.blit(text_fps, textpos_fps)
screen.blit(text_score, textpos_score)
screen.blit(text_timer, textpos_timer)
pygame.display.flip()
# Check collision!!!
if pygame.sprite.spritecollide(car, traffic_s, False):
car.impact()
target.car_crash()
if pygame.sprite.spritecollide(car, target_s, True):
target.claim_flag()
target.generate_finish()
target_s.add(target)
clock.tick(64)
def run(self):
# generate tiles
for tile_num in range(0, len(maps.map_tile)):
maps.map_files.append(load_image(maps.map_tile[tile_num], False))
for x in range(0, 10):
for y in range(0, 10):
self.map_s.add(
maps.Map(maps.map_1[x][y], x * 1000, y * 1000,
maps.map_1_rot[x][y]))
# load tracks
tracks.initialize()
# load finish
self.target_s.add(self.target)
# load direction
self.pointer_s.add(self.pointer)
# load alerts
self.timer_alert_s.add(self.time_alert)
self.bound_alert_s.add(self.bound_alert)
self.celular_s.add(self.celular_alert)
self.stop_s.add(self.stop_alert)
self.menu_alert_s.add(self.info)
# load traffic
traffic.initialize(CENTER_W, CENTER_H)
for count in range(0, self.quantidadeVeiculos):
self.traffic_s.add(traffic.Traffic())
self.player_s.add(self.car)
self.cam.set_pos(self.car.x, self.car.y)
while self.running:
# Render loop.
# Check for menu/reset, (keyup event - trigger ONCE)
for event in pygame.event.get():
if event.type == pygame.KEYUP:
if keys[K_m]:
if (self.info.visibility == True):
self.info.visibility = False
else:
self.info.visibility = True
if (keys[K_p]):
self.car.reset()
self.target.reset()
if (keys[K_q]):
pygame.quit()
sys.exit(0)
if (keys[K_z]): # atende ligacao
self.celular_alert.atender = True
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
from source.menu import Menu as menu2
aux = menu2()
aux.main_menu()
running = False
break
# Check for key input. (KEYDOWN, trigger often)
keys = pygame.key.get_pressed()
if (self.target.timeleft > 0):
if keys[K_LEFT]:
self.car.steerleft()
if keys[K_RIGHT]:
self.car.steerright()
if keys[K_UP]:
self.car.accelerate()
else:
self.car.soften()
if keys[K_DOWN]:
self.car.deaccelerate()
self.cam.set_pos(self.car.x, self.car.y)
# Show text data.
text_fps = self.font.render('', 1, (224, 16, 16))
textpos_fps = text_fps.get_rect(centery=25, centerx=60)
text_score = self.font.render(
'Pontuacao: ' + str(self.target.score), 1, (224, 16, 16))
textpos_score = text_fps.get_rect(centery=45, centerx=60)
text_timer = self.font.render(
'Tempo: ' + str(int((self.target.timeleft / 60) / 60)) + ":" +
str(int((self.target.timeleft / 60) % 60)), 1, (224, 16, 16))
textpos_timer = text_fps.get_rect(centery=65, centerx=60)
# Render Scene.
self.screen.blit(self.background, (0, 0))
# cam.set_pos(car.x, car.y)
self.map_s.update(self.cam.x, self.cam.y)
self.map_s.draw(self.screen)
# Conditional renders/effects
self.car.grass(
self.screen.get_at(
((int(self.CENTER_W - 5), int(self.CENTER_H - 5)))).g)
if self.car.tracks:
self.tracks_s.add(
tracks.Track(self.cam.x + self.CENTER_W,
self.cam.y + self.CENTER_H, self.car.dir))
# Just render..
self.tracks_s.update(self.cam.x, self.cam.y)
self.tracks_s.draw(self.screen)
self.player_s.update(self.cam.x, self.cam.y)
self.player_s.draw(self.screen)
self.traffic_s.update(self.cam.x, self.cam.y)
self.traffic_s.draw(self.screen)
self.target_s.update(self.cam.x, self.cam.y)
self.target_s.draw(self.screen)
self.pointer_s.update(self.car.x + self.CENTER_W,
self.car.y + self.CENTER_H, self.target.x,
self.target.y)
self.pointer_s.draw(self.screen)
# stop_alert.updateTimer(time.time())
# Conditional renders.
if (bounds.breaking(self.car.x + self.CENTER_W,
self.car.y + self.CENTER_H) == True):
self.bound_alert_s.update()
self.bound_alert_s.draw(self.screen)
if (self.target.timeleft == 0):
self.timer_alert_s.draw(self.screen)
self.car.speed = 0
text_score = self.font.render(
'Pontuacao Final: ' + str(self.target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=self.CENTER_H + 56,
centerx=self.CENTER_W - 20)
self.celular_alert.grass(
self.screen.get_at(
((int(self.CENTER_W - 5), int(self.CENTER_H - 5)))).g,
self.car.speed)
if (int((self.target.timeleft / 60) % 60) % 20 == 0):
self.celular_alert.visibility = True
self.celular_alert.startTimer()
if (self.celular_alert.tocando):
self.celular_alert.chron.run()
if (self.target.timeleft > 0
and self.celular_alert.visibility is True):
self.celular_s.draw(self.screen)
keys = pygame.key.get_pressed()
if (keys[K_c] and self.car.speed > 0.4):
self.target.score -= 50
self.celular_alert.tocando = False
self.celular_alert.visibility = False
if (keys[K_c] and self.car.speed <= 0.4):
self.target.score += 200
self.celular_alert.tocando = False
self.celular_alert.visibility = False
if (not self.celular_alert.cel_time()):
self.target.score -= 100
self.celular_alert.tocando = False
self.celular_alert.visibility = False
self.stop_alert.stop_car(self.car.speed)
if (int((self.target.timeleft / 60) % 60) % 15 == 0
and self.car.speed >= 0.1):
self.stop_alert.visibility = True
if (self.target.timeleft > 0
and self.stop_alert.visibility is True):
self.stop_s.draw(self.screen)
if (self.car.speed < 0.1):
self.target.score += 200
self.stop_alert.visibility = False
else:
self.target.score -= 1
if (self.info.visibility == True):
self.menu_alert_s.draw(self.screen)
# Blit Blit..
pygame.draw.rect(self.screen, (216, 216, 216), [40, 30, 200, 55])
self.screen.blit(text_fps, textpos_fps)
self.screen.blit(text_score, textpos_score)
self.screen.blit(text_timer, textpos_timer)
pygame.display.flip()
# Check collision!!!
if pygame.sprite.spritecollide(self.car, self.traffic_s, False):
self.car.impact()
self.target.car_crash()
self.target.score -= 5
if pygame.sprite.spritecollide(self.car, self.target_s, True):
self.target.claim_flag()
self.target.score += 50
self.target.generate_finish()
self.target_s.add(self.target)
self.clock.tick(64)
# cria semaforo
# initialization
pygame.init()
print pygame.display.Info().current_w
print pygame.display.Info().current_h
'''
screen = pygame.display.set_mode((pygame.display.Info().current_w,
pygame.display.Info().current_h),
pygame.FULLSCREEN)
'''
self.screen = pygame.display.set_mode((1024, 768), pygame.FULLSCREEN)
pygame.display.set_caption('Race of Math.')
pygame.mouse.set_visible(True)
self.font = pygame.font.Font(None, 24)
# CENTER_W = int(1024 / 2)
# CENTER_H = int(768 / 2)
'''
CENTER_W = int(pygame.display.Info().current_w /2)
CENTER_H = int(pygame.display.Info().current_h /2)
'''
# new background surface
self.background = pygame.Surface(self.screen.get_size())
self.background = self.background.convert_alpha()
self.background.fill((26, 26, 26))
import streamlit as st
import sys
import numpy as np
import traffic
import config as cn
import tools
tr = traffic.Traffic('Info Datensatz')
title_placeholder = st.sidebar.empty()
st.sidebar.markdown('<small> MobEx.bs version: {}</small>'.format(
traffic.__version__),
unsafe_allow_html=True)
tr.traffic_type = st.sidebar.selectbox(
'Verkehrsart',
index=0,
options=list(cn.traffic_type_dic.keys()),
format_func=lambda x: cn.traffic_type_dic[x])
title_placeholder.markdown(
f'# {cn.logo_dic[tr.traffic_type]} <span style="color:steelblue">Mobility Explorer BS</span>',
unsafe_allow_html=True)
menu = st.sidebar.radio(label='', index=0, options=cn.menu_list)
print(menu)
if menu == 'Info Datensatz':
tr.show_dataset_info()
tr.show_about_box()
elif menu == 'Statistik':
tr.result_type = menu
tr.show_sidebar_controls()
tr.show_results()
def main():
#database
record_switch = False
text_rank = []
textpos_rank = []
#start music
pygame.mixer.music.load('./media/background.wav')
pygame.mixer.music.play(-1)
#initialize objects.
clock = pygame.time.Clock()
running = True
font = pygame.font.Font(None, 32)
car = player.Player()
cam = camera.Camera()
target = gamemode.Finish()
item = []
traffics = []
bound_alert = bounds.Alert()
time_alert = timeout.Alert()
info = menu.Alert()
pointer = direction.Tracker(int(CENTER_W * 2), int(CENTER_H * 2))
#create sprite groups.
map_s = pygame.sprite.Group()
player_s = pygame.sprite.Group()
traffic_s = pygame.sprite.Group()
tracks_s = pygame.sprite.Group()
target_s = pygame.sprite.Group()
item_s = pygame.sprite.Group()
pointer_s = pygame.sprite.Group()
timer_alert_s = pygame.sprite.Group()
bound_alert_s = pygame.sprite.Group()
menu_alert_s = pygame.sprite.Group()
#generate tiles 기본 맵 초원
for tile_num in range(0, len(maps.map_tile[0])):
maps.map_files.append(load_image(maps.map_tile[0][tile_num], False))
for x in range(0, 10):
for y in range(0, 10):
map_s.add(
maps.Map(maps.map_1[x][y], x * 1000, y * 1000,
maps.map_1_rot[x][y]))
#load tracks
tracks.initialize()
#load finish
target_s.add(target)
#load items
items.initialize()
for count in range(0, ITEM_COUNT):
item.append(items.Items())
item_s.add(item[count])
#load direction
pointer_s.add(pointer)
#load alerts
timer_alert_s.add(time_alert)
bound_alert_s.add(bound_alert)
menu_alert_s.add(info)
#load traffic
traffic.initialize(CENTER_W, CENTER_H)
for count in range(0, TRAFFIC_COUNT):
traffics.append(traffic.Traffic())
traffic_s.add(traffics[count])
player_s.add(car)
cam.set_pos(car.x, car.y)
while running:
#Render loop.
#Check for menu/reset, (keyup event - trigger ONCE)
for event in pygame.event.get():
if event.type == pygame.KEYUP:
if keys[K_m]:
if (info.visibility == True):
info.visibility = False
else:
info.visibility = True
if info.visibility == True:
if (keys[K_p]):
car.reset()
target.reset()
for i in range(0, ITEM_COUNT):
item[i].reset
record_switch = False
if (keys[K_q]):
pygame.quit()
sys.exit(0)
if (keys[K_1]):
change_map(map_s, maps, 0)
car.reset()
target.reset()
for i in range(0, ITEM_COUNT):
item[i].reset
if (keys[K_2]):
change_map(map_s, maps, 1)
car.reset()
target.reset()
for i in range(0, ITEM_COUNT):
item[i].reset
if (keys[K_3]):
change_map(map_s, maps, 2)
car.reset()
target.reset()
for i in range(0, ITEM_COUNT):
item[i].reset
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
running = False
break
#Check for key input. (KEYDOWN, trigger often)
keys = pygame.key.get_pressed()
if (target.timeleft > 0):
if keys[K_LEFT]:
car.steerleft()
if keys[K_RIGHT]:
car.steerright()
if keys[K_UP]:
car.accelerate()
else:
car.soften()
if keys[K_DOWN]:
car.deaccelerate()
cam.set_pos(car.x, car.y)
#Show text data.
text_fps = font.render('FPS: ' + str(int(clock.get_fps())), 1,
(224, 16, 16))
textpos_fps = text_fps.get_rect(centery=175, centerx=260)
text_score = font.render('Score: ' + str(target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=205, centerx=260)
text_timer = font.render(
'Timer: ' + str(int((target.timeleft / 60) / 60)) + ":" +
str(int((target.timeleft / 60) % 60)), 1, (224, 16, 16))
textpos_timer = text_fps.get_rect(centery=235, centerx=260)
text_red_ball = font.render(
'Red Ball: ' + str(int(car.red_timer / 64)), 1, (224, 16, 16))
textpos_red_ball = text_fps.get_rect(centery=265, centerx=260)
text_blue_ball = font.render(
'Blue Ball: ' + str(int(car.blue_timer / 64)), 1, (224, 16, 16))
textpos_blue_ball = text_fps.get_rect(centery=295, centerx=260)
text_green_ball = font.render(
'Green Ball: ' + str(int(car.green_timer / 64)), 1, (224, 16, 16))
textpos_green_ball = text_fps.get_rect(centery=325, centerx=260)
text_ranking = font.render('TOP 5 Ranking', 1, (16, 224, 16))
textpos_ranking = text_fps.get_rect(centery=CENTER_H,
centerx=CENTER_W - 20)
text_boundtimer = font.render(
'Game over After ' + str(int(bound_alert.timeleft / 64)) +
' Second.', 1, (224, 16, 16))
textpos_boundtimer = text_fps.get_rect(centery=CENTER_H + 30,
centerx=CENTER_W - 100)
#Render Scene.
screen.blit(background, (0, 0))
#cam.set_pos(car.x, car.y)
map_s.update(cam.x, cam.y)
map_s.draw(screen)
#Conditional renders/effects
car.grass(screen.get_at(((int(CENTER_W - 5), int(CENTER_H - 5)))).g)
if (car.tracks):
tracks_s.add(
tracks.Track(cam.x + CENTER_W, cam.y + CENTER_H, car.dir))
#Just render..
tracks_s.update(cam.x, cam.y)
tracks_s.draw(screen)
player_s.update(cam.x, cam.y)
player_s.draw(screen)
traffic_s.update(cam.x, cam.y)
traffic_s.draw(screen)
target_s.update(cam.x, cam.y)
target_s.draw(screen)
item_s.update(cam.x, cam.y)
item_s.draw(screen)
pointer_s.update(car.x + CENTER_W, car.y + CENTER_H, target.x,
target.y)
pointer_s.draw(screen)
#Conditional renders.
if (bounds.breaking(car.x + CENTER_W, car.y + CENTER_H) == True):
bound_alert_s.update()
bound_alert_s.draw(screen)
bound_alert.update()
screen.blit(text_boundtimer, textpos_boundtimer)
if (bound_alert.timeleft == 0):
target.timeleft = 0
else:
bound_alert.timeleft = 640
if (target.timeleft == 0):
timer_alert_s.draw(screen)
car.speed = 0
text_score = font.render('Your Score: ' + str(target.score), 1,
(224, 16, 16))
textpos_score = text_fps.get_rect(centery=CENTER_H - 56,
centerx=CENTER_W - 20)
if record_switch == False:
cur.execute("SELECT * From rank ORDER BY Point DESC")
dataList = []
dataList = cur.fetchall()
rank = 0
if len(dataList) == 0:
cur.execute("INSERT INTO rank VALUES(?,?)",
(1, target.score))
elif len(dataList) < 5:
for i in dataList:
if i[1] < target.score:
rank = i[0]
break
if rank != 0:
cur.execute(
"UPDATE rank SET Rank=Rank+1 WHERE Point < %d" %
(target.score))
cur.execute("INSERT INTO rank VALUES(?,?)",
(rank, target.score))
else:
cur.execute("INSERT INTO rank VALUES(?,?)",
(len(dataList) + 1, target.score))
elif len(dataList) >= 5:
for i in dataList:
if i[1] < target.score:
rank = i[0]
break
if rank != 0:
cur.execute(
"UPDATE rank SET Rank=Rank+1 WHERE Point<%d" %
(target.score))
cur.execute("INSERT INTO rank VALUES(?,?)",
(rank, target.score))
cur.execute("DELETE FROM rank WHERE Rank > 5")
con.commit()
cur.execute("SELECT * From rank ORDER BY Rank ASC")
dataList = cur.fetchall()
cnt = 0
text_rank.clear()
textpos_rank.clear()
for i in dataList:
cnt = cnt + 1
text_rank.append(
font.render(
str(i[0]) + '. ' + str(i[1]), 1, (16, 224, 16)))
textpos_rank.append(
text_fps.get_rect(centery=CENTER_H + 25 + cnt * 25,
centerx=CENTER_W - 20))
record_switch = True
if (info.visibility == True):
menu_alert_s.draw(screen)
#Blit Blit..
screen.blit(text_fps, textpos_fps)
screen.blit(text_score, textpos_score)
screen.blit(text_timer, textpos_timer)
screen.blit(text_red_ball, textpos_red_ball)
screen.blit(text_blue_ball, textpos_blue_ball)
screen.blit(text_green_ball, textpos_green_ball)
if record_switch == True:
screen.blit(text_ranking, textpos_ranking)
for i in range(0, cnt):
screen.blit(text_rank[i], textpos_rank[i])
pygame.display.flip()
#Check collision!!!
#traffic 과의 충돌 확인. 블루볼 먹었을 시에는 충돌 없음
for i in range(0, TRAFFIC_COUNT):
if traffics[i].collision_check(car) == True:
if car.blue_ball == True:
pygame.mixer.Sound.play(point_sound)
traffics[i].respawn()
else:
car.impact()
target.car_crash()
if pygame.sprite.spritecollide(car, target_s, True):
pygame.mixer.Sound.play(point_sound)
target.claim_flag()
target.generate_finish()
target_s.add(target)
for i in range(0, ITEM_COUNT):
if item[i].collision_check(car) == True:
pygame.mixer.Sound.play(point_sound)
car.get_item(item[i].color)
item[i].generate_items()
item_s.add(item[i])
clock.tick(64)
