def concurrent_sim(base_opts,
small_opts,
user_opts,
sim_opts,
geometry,
cli_args,
queue,
seed,
name=""):
"""Run one concurrent instance of a simulation. All printing is done to a
named file instead of stdout to avoid nonsensical cluttering by multiple
threads."""
# redirect stdout
filename = name if name != "" else "pid_{}.txt".format(os.getpid())
sys.stdout = open(filename, mode="w")
# precompute random values (for performance)
# must be done for each process
np.random.seed(seed)
rf.init_shadowing(sim_opts, geometry)
max_possible_dails = sim_opts.num_users * sim_opts.iterations
rf.init_call_probabilities(max_possible_dails, sim_opts.call_rate)
# set up simulation
base_station = twr.Tower(base_opts)
small_cell = twr.Tower(small_opts)
users = usr.init_users(sim_opts.num_users, user_opts)
# simulate normally
stats = simulate(base_station, small_cell, users, geometry, sim_opts,
cli_args)
# save statistics
queue.put(stats)
def initialize():
t1 = tower.Tower(1)
t2 = tower.Tower(2)
t3 = tower.Tower(3)
for disk in range(5, 0, -1):
t1.loadDisk(disk)
return t1, t2, t3
def __init__(self, gameDisplay):
self.gameDisplay = gameDisplay
self.towers = [
tower.Tower(gameDisplay, 150, 400, (255, 0, 0)),
tower.Tower(gameDisplay, 400, 400, (0, 255, 0)),
tower.Tower(gameDisplay, 650, 400, (0, 0, 255))
]
firstTower = self.towers[0]
firstTower.addDisc(disc.Disc(150, (125, 125, 125)))
firstTower.addDisc(disc.Disc(100, (125, 125, 0)))
firstTower.addDisc(disc.Disc(50, (125, 0, 0)))
def __init__(self):
print("in toh.init")
towerA = tower.Tower("1", referenceX, 'YELLOW')
towerA.addDisc(discFactory.DiscFactory(referenceX).getLarge())
towerA.addDisc(discFactory.DiscFactory(referenceX).getMedium())
towerA.addDisc(discFactory.DiscFactory(referenceX).getSmall())
self.towers = [
towerA,
tower.Tower("2", referenceX, 'MAGENTA'),
tower.Tower("3", referenceX, 'CYAN')
]
self.moveCount = 0
def update(self, board, cash):
pressed, pos = pygame.mouse.get_pressed(), pygame.mouse.get_pos()
keys = pygame.key.get_pressed()
#Drawing the selection of towers
for j in range(4):
for i in range(2):
if 660+i*100 <= pos[0] <= 660+i*100+60 and 150+j*70 <= pos[1] <= 150+j*70+60 and pressed[0] == 1:
self.selected = i+j*2+1
self.cooldown = 20
#Displays costs of certain towers
if self.selected != 0:
gameDisplay.blit(font_20.render(str(self.names[self.selected-1]), True, (0, 0, 0)), (
740-int(font_20.size(str(self.names[self.selected-1]))[0]/2), 425))
gameDisplay.blit(font_20.render("Cost: " + str(self.Costs[self.selected-1]), True, (0, 0, 0)), (690, 450))
#Buying a new tower
if self.cooldown <= 0 and self.selected != 0 and 0 <= pos[0] <= 640 and 0 <= pos[1] <= 480 and pressed[0] == 1:
if board[int(pos[1]/40)][int(pos[0]/40)] == 0 and cash >= self.Costs[self.selected-1]:
board[int(pos[1]/40)][int(pos[0]/40)] = tower.Tower(int(pos[0]/40)*40+5, int(pos[1]/40)*40+5, self.selected)
board[int(pos[1]/40)][int(pos[0]/40)].selected = True
cash -= self.Costs[self.selected-1]
self.bought = 1
if keys[303] != 1 and keys[304] != 1:
self.selected = 0
else:
self.cooldown -= 1
if keys[303] != 1 and keys[304] != 1 and self.bought != 0:
self.selected = 0
self.bought = 0
return board, cash
def test_format(self):
t = tower.Tower()
d3 = tower.Disk(3)
d5 = tower.Disk(5)
t.add(d5)
t.add(d3)
f = t.vertical_format(6, 3)
self.assertEqual(f, [" ", "[ 3 ] ", "[ 5 ] "])
def setUp(self):
self.color = (0, 0, 255)
self.position = (15, 25)
self.dimension = (80, 90)
self.attack_radius = 10
self.cost = 60
self.DISPLAYSURF = pygame.Surface([150, 160])
self.t = tower.Tower(self.color, self.position, self.dimension,
self.cost, self.DISPLAYSURF)
def test_init(self, mock_pygame_draw_circle):
self.t = tower.Tower(self.color, self.position, self.dimension,
self.cost, self.DISPLAYSURF)
self.assertEqual(self.t.DISPLAYSURF, self.DISPLAYSURF)
self.assertEqual(self.t.image.get_width(), 80)
self.assertEqual(self.t.image.get_height(), 90)
self.assertEqual(self.t.image.get_at((5, 5)), (0, 0, 255, 255))
self.assertEqual(self.t.rect.centerx, 15)
self.assertEqual(self.t.rect.centery, 25)
def test_something(self):
t = tower.Tower()
self.assertTrue(t.empty())
d = tower.Disk(3)
t.add(d)
self.assertFalse(t.empty())
d5 = tower.Disk(5)
self.assertRaises(Exception, t.add, d5)
self.assertFalse(t.empty())
def test_oksize(self):
t = tower.Tower()
self.assertTrue(t.empty())
d5 = tower.Disk(5)
t.add(d5)
self.assertFalse(t.empty())
d3 = tower.Disk(3)
t.add(d3)
self.assertFalse(t.empty())
self.assertEqual(t.top(), d3)
self.assertEqual(t.pop(), d3)
self.assertEqual(t.pop(), d5)
def generate_field():
held_positions = []
towers = []
for i in range(5):
pos = random.randint(0, 49)
while pos in held_positions:
pos = random.randint(0, 49)
held_positions.append(pos)
fp = random.randint(3, 8)
lr = random.randint(0, 2)
t = tower.Tower(pos, fp, lr)
towers.append(t)
field = Field(towers)
return field
def game_loop(load):
"""Main Function"""
width, height = 16, 12
Board = setup_Board([[0]*width for _ in range(height)])
Lives, Cash = 100, 750
selection = Selection()
score = 0
startButton = Start()
Images = load_images("Images")
abilityCooldown = False
settings = Settings()
cooldown = 100
#Generating each of the waves
wave = 1
#Loading your save file
if load:
file = open("SaveFile/saveFile.txt", "r")
data = file.readline().split("#")
if len(data) >= 197:
count = 0
#Loading all the tiles
for j, row in enumerate(Board):
for i, tile in enumerate(row):
if data[count] == "2":
count += 1
#Loading all variables for a tower
Board[j][i] = tower.Tower(i*40+5, j*40+5, int(data[count]))
Board[j][i].pops = int(data[count+1])
Board[j][i].score = int(data[count+2])
Board[j][i].pierce = int(data[count+3])
Board[j][i].damage = int(data[count+4])
Board[j][i].speed = float(data[count+5])
Board[j][i].shotAmount = int(data[count+6])
Board[j][i].size = int(data[count+7])
Board[j][i].path = int(data[count+8])
Board[j][i].seeking = data[count+9] == "True"
Board[j][i].bulletSpeed = float(data[count+10])
Board[j][i].camo = data[count+11] == "True"
Board[j][i].dead = data[count+12] == "True"
Board[j][i].fireDamage = int(data[count+13])
Board[j][i].fireLength = float(data[count+14])
Board[j][i].fireLasting = float(data[count+15])
Board[j][i].Permaslow = data[count+16] == "True"
Board[j][i].slowAmount = float(data[count+17])
Board[j][i].ExplodeTime = float(data[count+18])
Board[j][i].bombRange = float(data[count+19])
Board[j][i].crateValue = int(data[count+20])
Board[j][i].autoCollect = data[count+21] == "True"
Board[j][i].expireTime = int(data[count+22])
Board[j][i].glaiveCount = int(data[count+23])
Board[j][i].glaiveSpeed = float(data[count+24])
Board[j][i].glaiveRings = int(data[count+25])
Board[j][i].selected = False
Board[j][i].value = int(data[count+26])
Board[j][i].range = float(data[count+27])
count += 28
#Loads all upgrades
for h, item in enumerate(Board[j][i].upgrades):
for g, subItem in enumerate(item):
Board[j][i].upgrades[h][g] = int(data[count])
count += 1
Board[j][i].currentUpgrade = [int(data[count]), int(data[count+1])]
count += 2
for item in Board[j][i].ability:
Board[j][i].ability.append([data[count], int(data[count+1]), int(data[count+2]), int(data[count+3])])
count += 4
else:
Board[j][i] = int(data[count])
count += 1
Cash = int(data[count])
Lives = int(data[count+1])
settings.autoPlay.switch = data[count+3] == "True"
score = int(data[count+2])
wave = int(data[count+4])
count += 5
else:
print("Invalid Save File")
#Generating the monsters
Monsters = waves.genEnemies(wave, Images)
game_run = True
while game_run:
#Grabbing mouse cordinates
pos = pygame.mouse.get_pos()
gameDisplay.fill((130,90,50))
#Drawing the background
for j, row in enumerate(Board):
for i, tile in enumerate(row):
if Board[j][i] == 0:
Color = (0, 150, 0)
elif Board[j][i] == 1:
Color = (210, 180, 140)
else:
Color = (0, 150, 0)
pygame.draw.rect(gameDisplay, Color, (i*40,j*40,40,40), 0)
pygame.draw.rect(gameDisplay, (0, 150, 0), (i*40, j*40, 40, 40), 1)
#Updating all monsters on the board:
for monster in Monsters:
if monster[1] > 0:
monster[1] -= 1*startButton.speed
else:
if monster[0].dead:
Monsters.pop(Monsters.index(monster))
else:
Lives = monster[0].update(Lives, startButton.speed, gameDisplay)
if monster[0].duplicate:
monster[0].duplicate = False
tempMonster = [monsters.Monster(5,wave,monster[0].camo, Images),monster[1]-30]
tempMonster[0].x, tempMonster[0].y = monster[0].x, monster[0].y
tempMonster[0].step = monster[0].step
tempMonster[0].cooldown = 5
tempMonster[0].hit = monster[0].hit
tempMonster[0].fire = monster[0].fire
tempMonster[0].speedModifier = monster[0].speedModifier
Monsters.append(tempMonster)
if len(monster[0].addMonster) != 0:
for i, mons in enumerate(monster[0].addMonster):
tempMonster = [monsters.Monster(mons,wave,monster[0].camo, Images),monster[1]-30*(i+1)]
tempMonster[0].x, tempMonster[0].y = monster[0].x, monster[0].y
tempMonster[0].step = monster[0].step
tempMonster[0].cooldown = 5
tempMonster[0].hit = monster[0].hit
tempMonster[0].fire = monster[0].fire
tempMonster[0].speedModifier = monster[0].speedModifier
Monsters.append(tempMonster)
monster[0].addMonster = []
if len(Monsters) == 0:
#Starting the new wave
Cash += 100+wave+1
wave += 1
Monsters = waves.genEnemies(wave, Images)
if not settings.autoPlay.switch:
startButton.speed = 0
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
tile.Projectiles = []
#Saving after a wave ends
data = ""
for j, row in enumerate(Board):
for i, tile in enumerate(row):
stop = False
try:
tile = int(tile)
except Exception:
data += "2" + "#"
for item in [tile.rank, tile.pops, tile.score, tile.pierce, tile.damage, tile.speed, tile.shotAmount, tile.size, tile.path, tile.seeking,
tile.bulletSpeed, tile.camo, tile.dead, tile.fireDamage, tile.fireLength, tile.fireLasting, tile.Permaslow, tile.slowAmount,
tile.ExplodeTime, tile.bombRange, tile.crateValue, tile.autoCollect, tile.expireTime, tile.glaiveCount, tile.glaiveSpeed,
tile.glaiveRings, tile.value, tile.range]:
data += str(item) + "#"
for item in tile.upgrades:
for subItem in item:
data += str(subItem) + "#"
for item in tile.currentUpgrade:
data += str(item) + "#"
for ability in tile.ability:
for item in ability:
data += str(item) + "#"
stop = True
if not stop:
data += str(tile) + "#"
data += str(Cash) + "#"
data += str(Lives) + "#"
data += str(score) + "#"
data += str(settings.autoPlay.switch) + "#"
data += str(wave) + "#"
file = open("SaveFile/saveFile.txt", "w")
file.write(data)
#Making the selection bar
pygame.draw.rect(gameDisplay, (130, 90, 50), (640, 0, 200, 580), 0)
ColorBoard = [[(200, 0, 0), (0, 0, 200)], [(200, 200, 0), (0, 200, 200)], [(100, 100, 100), (0, 200, 0)], [(200, 200, 200), (100, 150, 200)]]
for j in range(4):
for i in range(2):
pygame.draw.rect(gameDisplay, (140, 90, 40), (660+i*100, 150+j*70, 60, 60), 0)
pygame.draw.rect(gameDisplay, (210, 180, 140), (660+i*100, 150+j*70, 60, 60), 3)
if (j != 1 or i != 0) and (j != 0 or i != 1) and (j != 1 or i != 1):
pygame.draw.rect(gameDisplay, ColorBoard[j][i], (660+i*100+10, 150+j*70+10, 40, 40), 0)
elif j == 0 and i == 1:
gameDisplay.blit(pygame.transform.scale(Images["NinjaBase"], (30, 30)), (660+i*100+15, 150+j*70+20))
gameDisplay.blit(pygame.transform.scale(Images["NinjaGun"], (30, 40)), (660+i*100+15, 150+j*70+5))
elif j == 1 and i == 1:
gameDisplay.blit(pygame.transform.scale(Images["IceTower"], (30, 30)), (660+i*100+15, 150+j*70+20))
else:
gameDisplay.blit(pygame.transform.scale(Images["Flamethrower"], (40, 60)), (660+i*100+10, 150+j*70))
#Drawing Lives/Cash
gameDisplay.blit(pygame.transform.scale(Images["Heart"], (20, 20)), (660, 60))
gameDisplay.blit(pygame.transform.scale(Images["InstantMoney"], (20, 20)), (660, 20))
gameDisplay.blit(font_20.render(str(Cash), True, (0, 0, 0)), (690, 16))
gameDisplay.blit(font_20.render(str(Lives), True, (0, 0, 0)), (690, 56))
gameDisplay.blit(font_20.render("Wave: " + str(wave), True, (0, 0, 0)), (660, 96))
if Lives <= 0:
game_run = False
#Event handler
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
#Drawing all towers:
stop = False
pos, pressed = pygame.mouse.get_pos(), pygame.mouse.get_pressed()
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
tile.update(Monsters, startButton.speed, Cash, Board, Images, gameDisplay)
if tile.x <= pos[0] <= tile.x + tile.width and tile.y <= pos[1] <= tile.y + tile.height and pressed[0] == True:
for h, k in enumerate(Board):
for l, s in enumerate(k):
try:
s = int(s)
except Exception:
s.selected = False
tile.selected = True
stop = True
Cash += tile.cash
#Checking to see whether something was bought today
if tile.cash < 0 or not (0 <= pos[0] <= 640 and 0 <= pos[1] <= 480):
stop = True
tile.cash = 0
score += tile.score
tile.score = 0
if tile.dead == True:
Board[j][i] = 0
if stop == False and pressed[0] == True:
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
tile.selected = False
Board, Cash = selection.update(Board, Cash)
#The start button
startButton.update()
#Updates the settings
gameDisplay.blit(font_15.render("Settings", True, (0, 0, 0)), (565, 490))
settings.update()
#Updating all crates so their drawn on a higher level then towers
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
if tile.rank == 6:
for crate in tile.Crates:
crate.update(startButton.speed, gameDisplay)
if crate.expireTime <= 0:
tile.Crates.pop(tile.Crates.index(crate))
if crate.collected:
Cash += crate.value
tile.Crates.pop(tile.Crates.index(crate))
elif tile.rank == 7:
for glaive in tile.Glaives:
glaive.update(startButton.speed, gameDisplay)
#Abilities
Abilities = []
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
for ability in tile.ability:
#Checks for all ready abilities
if ability[1] == 0:
Abilities.append(ability[0])
elif ability[1] == -1:
pass
else:
ability[1] -= 1
if len(Abilities) != 0:
alreadyUsed = {}
for ability in Abilities:
if ability not in alreadyUsed.keys():
alreadyUsed[ability] = 1
else:
alreadyUsed[ability] += 1
count = 0
for k, v in alreadyUsed.items():
pygame.draw.rect(gameDisplay, (210, 180, 140), (10+55*count, 430, 40, 40), 0)
pygame.draw.rect(gameDisplay, (180, 140, 80), (10+55*count, 430, 40, 40), 2)
if k == "Bullet Time":
pygame.draw.rect(gameDisplay, (255,215,0), (20+55*count, 435, 15, 10), 0)
pygame.draw.circle(gameDisplay, (255, 215, 0), (35+55*count, 440), 5, 0)
pygame.draw.circle(gameDisplay, (255, 255, 255), (25+55*count, 458), 10, 0)
pygame.draw.circle(gameDisplay, (0, 0, 0), (25+55*count, 458), 11, 1)
pygame.draw.line(gameDisplay, (0, 0, 0), (25+55*count, 458), (25+55*count, 450), 2)
pygame.draw.line(gameDisplay, (0, 0, 0), (25+55*count, 458), (20+55*count, 455), 2)
elif k == "Forest Fire":
gameDisplay.blit(pygame.transform.scale(Images["ForestFire"],(20,30)),(20+55*count,435))
elif k == "The Arctic":
gameDisplay.blit(pygame.transform.scale(Images["TheArctic"],(100,30)),(-20+55*count,435))
elif k == "Smoke Bomb":
gameDisplay.blit(pygame.transform.scale(Images["SmokeBomb"],(50,50)),(55*count,425))
elif k == "Instant Money":
gameDisplay.blit(pygame.transform.scale(Images["InstantMoney"],(30,30)),(15+55*count,435))
elif k == "Complete Reform":
gameDisplay.blit(pygame.transform.scale(Images["CompleteReform"],(30,30)),(15+55*count,435))
elif k == "Unleash Havoc":
gameDisplay.blit(pygame.transform.scale(Images["UnleashHavoc"],(30,30)),(15+55*count,435))
gameDisplay.blit(font_20.render(str(v), True, (0, 0, 0)), (40+55*count, 450))
stop = False
if 10+55*count <= pos[0] <= 10+55*count+40 and 430 <= pos[1] <= 470 and pressed[0] == 1:
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
for ability in tile.ability:
stop2 = False
for a in tile.effects:
if a[0] == ability[0]:
stop2 = True
if not stop and ability[0] == k and not stop2 and not abilityCooldown:
abilityCooldown = True
stop = True
ability[1] = ability[2] + 0
tile.effects.append([k,ability[3],False])
count += 1
if pressed[0] == 0:
abilityCooldown = False
#Drawing range of selected tower
for j, row in enumerate(Board):
for i, tile in enumerate(row):
try:
tile = int(tile)
except Exception:
if tile.selected:
pygame.draw.circle(gameDisplay, (0, 0, 0, 125), (tile.x+int(tile.width/2), tile.y+int(tile.height/2)),int(tile.range), 2)
pygame.display.flip()
fpsClock.tick(fps)
print("Score: " + str(score))
def __init__(self, num_disks):
self.num_of_disks = num_disks
self.num_of_moves = 0
self.towers = [tower.Tower('A'), tower.Tower('B'), tower.Tower('C')]
for i in range(num_disks, 0, -1):
self.towers[0].append(disk.Disk(i))
# cost += 2*abs(goalPeg[i] - expectedDisc)
isInOrder = isInOrder and (goalPeg[i] == expectedDisc)
if not isInOrder:
cost += 2 + abs(goalPeg[i] - expectedDisc)
for thisPeg in self.tower.pegs:
if not thisPeg == goalPeg:
for i in range(0, len(thisPeg)):
for j in range(i, len(thisPeg)):
dP = thisPeg[i] - thisPeg[j]
if dP > 0:
cost += dP
cost += 1
#print(1)
self.heuristic = cost
#print(cost)
'''
def FN(self):
#print(self.heuristic + self.depth)
return self.heuristic + self.depth
nodeState(None, tower.Tower([[2, 3, 1, 0], [], []]), False)
def gamemapScr(self):
"""
Descr: gameMapScr contains events for creating the Game Screen
Params: self
Returns: none """
while self.gamemap_Scr:
self.interface() #Creates the game menu screen
mousepos = (pygame.mouse.get_pos())
mousepos_change = (pygame.mouse.get_rel())
# Game loss and return to the endpage
if self.health == 0:
self.emptyOut()
return self.endpageScr()
elif self.wavenum == 11:
self.emptyOut()
return self.winpageScr()
for event in pygame.event.get():
# quit
if event.type == pygame.QUIT:
return pygame.quit()
# Move tower and lose money
elif event.type == MOUSEBUTTONDOWN:
if self.towerRect.collidepoint(pygame.mouse.get_pos()):
if self.money >= tower.Tower(mousepos).cost:
self.tower.append(tower.Tower(mousepos))
self.sprites.add(self.tower)
self.tower[-1].ablemove = True
elif self.wave_start_button.collidepoint(mousepos):
if self.inWave == False:
self.inWave = True
self.wavenum += 1
num = 0
invadernum = ((self.wavenum * 3) + 5)
elif event.type == MOUSEMOTION and self.tower != []:
if self.tower[-1].ablemove == True:
self.tower[-1].image = pygame.image.load(
'assets/' + 'tower2.png').convert_alpha()
self.tower[-1].followmouse(mousepos_change)
elif event.type == MOUSEBUTTONUP and self.tower != []:
if not (self.p.isGrass(self.tower[-1])):
self.sprites.remove(self.tower[-1])
self.tower.remove(self.tower[-1])
elif self.tower[-1].ablemove == True:
self.tower[-1].image = self.towerimg
self.money -= self.tower[-1].cost
self.tower[-1].ablemove = False
#INVADERS IN WAVE
if self.inWave == True:
if num < invadernum:
slime = invader.Invader("slime1.png", (20, 80))
self.invader.append(slime)
self.sprites.add(self.invader)
num += 1
elif num == invadernum:
self.inWave = False
#INVADER MOVEMENT
for monsters in self.invader:
direction = monsters.path()
monsters.move(direction)
# Make the invader Gif pictures
if monsters.whichimage == 3:
monsters.whichimage = 1
elif monsters.whichimage != 3:
monsters.whichimage += 1
if monsters.whichimage == 1:
monsters.image = self.invaderimage1
if monsters.whichimage == 2:
monsters.image = self.invaderimage2
if monsters.whichimage == 3:
monsters.image = self.invaderimage3
#Health Decreasing when Invade reach castle
if monsters.rect == (680, 110, 20, 20):
self.health -= 1
self.sprites.remove(monsters)
self.invader.remove(monsters)
#Invaders in Tower Range get Shot
for defenders in self.tower:
for monsters in self.invader:
if defenders.inRange(monsters.rect.x, monsters.rect.y):
ammo = bullet.Bullet((defenders.rect.center))
self.bullets.append(ammo)
self.sprites.add(self.bullets)
break
#Bullet MOVEMENT
for shoot in self.bullets:
#Bullets Move to Invader Location
shoot.to_invader(monsters.rect.center)
if pygame.sprite.collide_rect(shoot, monsters):
monsters.health -= 25
self.sprites.remove(shoot)
self.bullets.remove(shoot)
#Monster Killed By Bullets
if monsters.health == 0:
self.money += 5
self.sprites.remove(monsters)
self.invader.remove(monsters)
# upload the image
self.interface()
self.sprites.draw(self.mainscreen)
pygame.display.flip()
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
#Set the background colour
background = WHITE
#Create a basic font
basicFont = pygame.font.SysFont(None, 48)
#Setup the game clock object
clock = pygame.time.Clock()
#Set the loop boolean and default dt
running = True
dt = 0
##Game Related Stuff##
#Create the sprite groups to be used
tower1 = tower.Tower((100, 100))
while(running):
#Event management
for event in pygame.event.get():
if event.type == QUIT:
running = False
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
#Logic stuff
tower1.update(dt)
#Rendering stuff
errprint("please use a non-insane simulation time")
sys.exit(1)
sim_opts.set_duration(args.sim_time[0])
if args.distance != -1:
if not cfg.valid_distance(args.distance[0]):
errprint("please use a valid distance")
sys.exit(1)
geometry.road_end = args.distance[0]
# seed rng
seed = int(time.time()) if args.seed == -1 else args.seed[0]
sim_opts.seed = seed
np.random.seed(seed)
# set up simulation
base_station = twr.Tower(base_opts)
small_cell = twr.Tower(small_opts)
users = usr.init_users(sim_opts.num_users, user_opts)
# pre compute random values (for performance)
rf.init_shadowing(sim_opts, geometry)
max_possible_dails = sim_opts.num_users * sim_opts.iterations
rf.init_call_probabilities(max_possible_dails, sim_opts.call_rate)
if args.multithread:
# run simulation concurrently
print("multi threading activated")
sim.multi_sim(base_opts, small_opts, user_opts, sim_opts, geometry, args,
5)
exit(0)
else:
def city_handler(self, event):
"""event handler of city"""
#moves between menu items
if event.type == KEYDOWN and event.key == K_UP: #moves the cursor up
self.cursor_se.play()
self.city.menu -= 1
if self.city.menu < 0:
self.city.menu = MENU_MAX
if self.city.menu == 2 and self.party.house == 0:
self.city.menu -= 1
elif event.type == KEYDOWN and event.key == K_DOWN:
self.cursor_se.play()
self.city.menu += 1
if self.city.menu > MENU_MAX:
self.city.menu = 0
if self.city.menu == 2 and self.party.house == 0:
self.city.menu += 1
#move to each menu item
if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_z
or event.key == K_RETURN):
self.select_se.play()
self.city.music = 0
if self.city.menu == City.BAR:
self.game_state = BAR
self.city = None
self.bar = bar.Bar()
elif self.city.menu == City.INN:
self.game_state = INN
self.city = None
self.inn = inn.Inn()
elif self.city.menu == City.HOUSE:
self.game_state = HOUSE
self.city = None
self.house = house.House()
elif self.city.menu == City.SHOP:
if len(self.party.member) == 0:
#if it cannot be selected, continue music
self.city.music = 1
else:
self.game_state = SHOP
self.city = None
self.shop = shop.Shop(self)
elif self.city.menu == City.TEMPLE:
if len(self.party.member) == 0:
self.city.music = 1
else:
self.game_state = TEMPLE
self.city = None
self.temple = temple.Temple()
elif self.city.menu == City.CASTLE:
self.game_state = CASTLE
self.city = None
self.castle = castle.Castle()
elif self.city.menu == City.TOWER:
self.game_state = TOWER
self.city = None
self.tower = tower.Tower()
elif event.type == KEYDOWN and event.key == K_x:
self.game_state = MENU
self.city = None
self.menu = menu.Menu()
def main():
pygame.init()
screen = pygame.display.set_mode((600, 600))
pygame.display.set_caption("Tower Defense")
#Invader
print("Testing one Invader----------------------")
test_invader = invader.Invader("slime.png", (0, 100)) #Creates object
#############################################
print("Positioning test for Invader----------------")
#############################################
print("Standard LEFT test for Invader----------------")
test_invader.move("right")
assert test_invader.rect == (30, 100, 20, 20)
print("Zero Input LEFT test for Invader----------------")
test_invader.move("up")
assert test_invader.rect == (30, 70, 20, 20)
print("Standard UP test for Invader----------------")
test_invader.move("down")
assert test_invader.rect == (30, 100, 20, 20)
print("Zero Input UP test for Invader----------------")
test_invader.move("left")
assert test_invader.rect == (0, 100, 20, 20)
#############################################
print("Direction test for Invader----------------")
#############################################
print("Standard First Path")
direction = test_invader.getDirection(path.Path())
assert direction == "right"
#Tower
print("Testing one Tower ----------------------")
test_tower = tower.Tower((0, 0)) #Creates object
############################################
print("Testing positioning of tower icon ----------------------")
#############################################
print("Following x change----------")
test_tower.followmouse((2, 0))
assert test_tower.rect == (2, 0, 50, 50)
print("Following y change----------")
test_tower.followmouse((0, 5))
assert test_tower.rect == (2, 5, 50, 50)
print("Following both x and y change---------")
test_tower.followmouse((3, 5))
assert test_tower.rect == (5, 10, 50, 50)
############################################
print("Invader in Range ----------------------")
#############################################
print("Invader in Range---------")
range = test_tower.inRange(4, 8)
assert range == True
print("Invader NOT in Range---------")
notrange = test_tower.inRange(500, 200)
assert notrange == False
#Path
print("Testing Path --------------------------")
test_path = path.Path() #Creates object
############################################
print("Getting Path ----------------------")
#############################################
print("Coordinates of First Path-------")
coordinates = test_path.getPathXY(1)
assert coordinates == (0, 50)
print("Coordinates of First Path-------")
pathnum = test_path.getNextPath(test_invader)
assert pathnum == 2
def __init__(self, color):
self.color = color
self.towers = [tower.Tower(self.color)] * 100
self.walls = [wall.Wall(self.color)] * 100
from flask import Flask
from flask_restful import Resource, Api, reqparse
import tower
tower = tower.Tower()
class Heater(Resource):
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('value', type=float)
args = parser.parse_args()
print(args)
temp = args['value']
tower.heater.setTemperature(float(temp))
return {}, 200
def get(self):
temp = tower.heater.getTemperature()
return {"value": temp[0], "targetValue": temp[1]}, 200
class Extruder(Resource):
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('value')
args = parser.parse_args()
speed = args['value']
