def main():
nodeGreen = Node(3, 5)
nodeRed = Node(6, 3)
nodeFalse = Node(4.8, 4)
nodeOut = Node(-10, -10)
nodeObs = Node(20, 12)
nodeBetw = Node(4.9, 7.8)
map = Map("P1.json")
obstacles = [[[5, 3], [7, 5], [7, 8], [4, 7]],
[[4, 8], [5, 8], [5, 9], [4, 9]]]
hitboxes = makeBoxes(obstacles)
#print("Grön")
#print(len(checkIfHitBox(nodeGreen, hitboxes)))
#rint("Röd")
#print(len(checkIfHitBox(nodeRed, hitboxes)))
#print(len(checkIfHitBox(nodeFalse, hitboxes)))
#print(isBlocked(nodeRed, obstacles, hitboxes))
#print(isBlocked(nodeFalse, obstacles, hitboxes))
#print(map.isOK(nodeFalse))
print(map.isOK(nodeOut))
print(map.isOK(nodeObs))
def __init__(self, screen, resources):
self.font = pygame.font.SysFont("Arial", 25)
self.tilemaps = {}
self.gameover = False
self.entities = []
self.genentities = Group()
self.bullets = pygame.sprite.Group()
self.resources = resources
self.won = False
pygame.mixer.music.load("assets/sounds/FragOutNCS.mp3")
pygame.mixer.music.play(-1)
#self.tilemap = TileMap("map1.csv", self.resources)
self.map = Map()
self.player, self.tilemaps, self.entities = self.map.load_map(
filename="map2.txt", resources=self.resources)
self.generate_entities()
# Set player and world for turrets; house images for houses
house_images = [
resources["h1"].image, resources["h2"].image,
resources["h3"].image, resources["h4"].image, resources["h5"].image
]
for i in range(len(self.entities)):
if isinstance(self.entities[i], Turret):
self.entities[i].set_player(self.player)
self.entities[i].set_world(self)
elif isinstance(self.entities[i], House):
self.entities[i].set_images(house_images)
self.camera = pygame.Rect(0, 0, screen.get_width(),
screen.get_height())
self.bg_surface = pygame.Surface(screen.get_size())
def render(Plot):
global screen, background
screen.fill((255, 255, 255)) #black
#screen.blit(background, (0,0))#load backgroud
#for tile in tileMap:#load map first
# screen.blit(tile.sprite, (tile.x, tile.y), tile.frame)
#for row in range(Map.MAPHEIGHT):
# for column in range(Map.MAPWIDTH):
# screen.blit(Map.tiles[Map.tilemap[row][column]], (column * Map.TILESIZE, row * Map.TILESIZE))
Map.displayMap(Plot.currentRoom(), screen)
displaySprite(Plot.currentRoom())
for entitiy in sprites: #load entities
screen.blit(entitiy.sprite, ((entitiy.x, entitiy.y)), entitiy.frame)
#IF textbox load textbox
michael.drawTextBox(screen)
michael.drawText(Plot.currentText(), screen)
#if textbox:
#print("There is a text box!")
Entities.displayArrow(screen, Plot.currentState, Plot.decision)
pygame.display.flip() #print to screen
def main(antenna, i):
"""calcule la puissance en tout point. Cette fonction utilise le multiprocessing"""
init_time = datetime.now()
pool = mp.Pool(8)
global results
MAPstyle = 1 # 1(corner) or 2(MET)
walls = Map.getWalls(MAPstyle)
wallsh = Map.getWallsH(walls)
wallsv = Map.getWallsV(walls)
precision = 1 # m^2
for x in range(200 // precision):
for y in range(110 // precision):
if [
x * precision + precision // 2,
y * precision + precision // 2
] == antenna:
a = 1
else:
pool.apply_async(calculatePower,
args=(x * precision, y * precision, wallsh,
wallsv, precision, antenna),
callback=collect_results)
pool.close()
pool.join()
end_time = datetime.now()
print("Execution time: ", (end_time - init_time))
w = str(i + 39)
with open('antenna' + w, 'wb') as f:
np.save(f, results)
f.close()
class Game:
def __init__(self, evManager):
self.evManager = evManager
#List every event for which this object listens
self.evManager.registerListener(self, [TickEvent])
self.state = GameStatePrepareEvent()
self.evManager.post(self.state)
#self.state = Game.STATE_PREPARING
self.maxPlayers = 4
self.players = [None
] * self.maxPlayers #creates a [None, None, None...]
self.addPlayer(1)
self.level = Map(self.evManager)
def addPlayer(self, playerNumber):
self.players[playerNumber] = Player(self.evManager, playerNumber)
#self.players[playerNumber] = Player(self.evManager, playerNumber, controller)
def start(self):
self.level.build()
self.state = GameStatePlayEvent(self.level)
self.evManager.post(self.state)
def notify(self, event):
if event.is_a(gameStateEvents):
self.state = event
class Slam:
MapSize = 16
TileSize = 0.25
ScanAngle = math.pi / 3
def __init__(self):
self.car = Car()
self.car.stop()
self.map = Map((self.MapSize, self.MapSize), self.TileSize)
self.pos = mul(self.map.sizeInMeters(), (0.5, ) * 2)
self.dir = 0.0
def scan(self):
self.car.pointSonic()
scans = self.car.scanSector(-self.ScanAngle, self.ScanAngle)
for ang, dist in scans:
delta = vecindir(self.dir + ang, dist)
end = add(self.pos, delta)
self.map.setLine(self.pos, end)
def turn(self, tgt):
to = sub(tgt, self.pos)
a = normalize_angle(vecdir(to) - self.dir)
self.car.turn(a)
self.dir = normalize_angle(self.dir + a)
def moveTo(self, tgt):
self.turn(tgt)
dist = vecdist(tgt, self.pos)
self.car.move(dist)
self.pos = tgt
def __init__(self):
self.display = Display()
self.map_player = Map()
self.needle = Item("needle", 4, self.map_player)
self.map_player.put_item_on_map(self.needle)
self.ether = Item("ether", 5, self.map_player)
self.map_player.put_item_on_map(self.ether)
self.tube = Item("tube", 6, self.map_player)
self.map_player.put_item_on_map(self.tube)
self.mac_gyver = Player(self.map_player)
self.display.load_wall()
self.display.load_ground()
self.display.load_player_display()
self.display.load_jailer()
self.display.load_items()
self.display.load_font()
self.display.refresh(self.map_player, self.mac_gyver)
self.display.show_inventory(self.mac_gyver)
self.items_in_game = [self.needle, self.ether, self.tube]
self.keyboard_list_movements = [
pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT
]
self.keyboard_functions = [
self.mac_gyver.move_up, self.mac_gyver.move_down,
self.mac_gyver.move_left, self.mac_gyver.move_right
]
def __init__(self):
self.car = Car()
self.car.stop()
self.map = Map((self.MapSize, self.MapSize), self.TileSize)
self.pos = mul(self.map.sizeInMeters(), (0.5, ) * 2)
self.dir = 0.0
def main():
pg.init()
global win, player, width, height
win = create_window(width, height)
running = True
while running:
start = time.time()
for event in pg.event.get():
if event.type == pg.QUIT:
running = False
if event.type == pg.VIDEORESIZE:
width, height = event.size
win = create_window(width, height)
# Send Input To Classes
for i in map.mapObjects:
i.processInput(event, pg, win, width, height)
win.fill([255, 255, 255])
# Update Classes
for i in map.mapObjects:
i.update(pg, win, width, height)
map.updateMap()
if (map.getMap() != "MENU"):
player.update(pg, win, width, height)
HUD.update(pg, win, width, height)
pg.display.update()
time.sleep(max(1.0 / 60 - (time.time() - start), 0))
class MainWindow(QMainWindow):
'''Wrapper class for...well, the game? Maybe this needs to be called the game engine then'''
def __init__(self):
'''
Only initialize critical components(like opengl) here, use start() for anything else
'''
QMainWindow.__init__(self)
Globals.glwidget = GLWidget(self)
self.setCentralWidget(Globals.glwidget)
Globals.glwidget.makeCurrent()
if Globals.musicOn:
print "Using music"
Globals.mediaobject = Phonon.MediaObject(self)
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(Globals.mediaobject, self.audioOutput)
self.map = Map() #map class
self.drawTimer = QTimer()
self.drawTimer.timeout.connect(self.drawTimerTimeout)
self.drawTimer.start(15)
def start(self):
if Globals.musicOn:
Globals.muspanel = MusPanel(self)
#draw map... set view to ground
Globals.view = self.map.generateMap()
def drawTimerTimeout(self):
self.map.update()
Globals.glwidget.updateGL()
def game_loop(game_map):
game_flag = True
gmap = Map(game_map)
lb, lo, arr, start, end = gmap.get_game_objects()
set_pos(start, start.map_pos)
set_pos(end, end.map_pos)
fish = Fish(FISH_DIR, (start.rect.centerx, start.rect.centery))
flag_fish_move = False
count = 0
while game_flag:
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_flag = False
break
if event.type == pygame.KEYDOWN:
do_key_action(gmap, arr, event)
if fish.check_status(gmap, lb, lo):
fish.move(flag_fish_move)
if not flag_fish_move and count > START_TIME:
flag_fish_move = not flag_fish_move
if not flag_fish_move:
count += 1
screen.blit(bg.image, bg.rect)
screen.blit(start.image, start.rect)
screen.blit(end.image, end.rect)
update_game(lb, lo, arr, gmap, screen)
screen.blit(fish.image, fish.rect)
screen.blit(edge.image, edge.rect)
pygame.display.flip()
clock.tick(FPS)
def __init__(self, server, color, levelPreset = "empty"):
self.server = server
self.butterflies = []
self.screen = pygame.display.get_surface()
self.backgroundImage, self.backgroundRect = loadPNG("background.png")
self.buttonSound = pygame.mixer.Sound("resources/sound/button.wav")
self.buttonSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.active = True
if levelPreset == "empty":
self.level = Map()
else:
self.level = Map(True)
self.toolbar = GameToolbar()
self.regis = Rabbit(1, "regis" , color, self.level.objectList, self.level.objectSpritesList)
self.server.accept()
self.server.send(b"connexion avec client : OK")
msg = self.server.recieve()
mapStr = self.level.getMapStr()
#MAP STRING SEND
self.server.send(struct.pack(str(len(mapStr)) + "s", mapStr))
#SERVER RABBIT COLOR SEND
self.server.send(struct.pack("iii", self.regis.color[0], self.regis.color[1], self.regis.color[2]))
#CLIENT RABBIT COLOR RECIEVE
clientCol = self.server.recieve()
clientCol = struct.unpack("iii", clientCol)
#CREATE CLIENT RABBIT
self.john = Rabbit(2, "john" , clientCol, self.level.objectList, self.level.objectSpritesList, True)
self.regis.appendRabbit(self.john)
self.john.appendRabbit(self.regis)
self.pauseMenu = PauseGameMenu()
self.deltaCarrot = 0
self.timeCarrot = random.randint(1, 4)
# for l in range(0, 6):
# while True:
# randPos = random.randint(0, 16)
# if not self.level.isInBlock(self.level.objectList[randPos].getX() + 10, self.level.objectList[randPos].getY() - 26):
# break
# butterfly = Butterfly(self.level.objectList[randPos].getX() + 10, self.level.objectList[randPos].getY() - 26, (255, 10, 100), self.level.objectList, self.level.objectSpritesList)
# self.butterflies.append(butterfly)
pygame.display.flip()
def main():
player1 = Player("Player 1")
player2 = Player("Player 2")
players = [player1, player2] # TODO: Change when number of players changes
numOfPlayers = len(players)
currentPlayer = player1.id
inf1 = Unit("infantry", 0, 5, "green", 0, 0)
cav1 = Unit("cavalry", 0, 1, "blue", 1, 1)
# Test code for Map
unitsList = []
terrainList = []
initialize_map_1(unitsList, terrainList, 15, 8)
unitsList[inf1.y][inf1.x] = inf1
unitsList[cav1.y][cav1.x] = cav1
map = Map(unitsList, terrainList)
# Main game loop
choice = " "
while choice != "exit":
displayUnits(unitsList)
map.display()
menuDisplay(players, currentPlayer)
choice = input("> ")
# Make the appropriate action
takeAction(choice, map, players, currentPlayer)
# switch to next player's turn
currentPlayer = nextTurn(currentPlayer, numOfPlayers)
def Astar(self, Point1, Point2, win, width):
moveset = []
moveset.append(Point1)
last = Point1
current = Point1
checked = 0
queue = set()
distances = []
visited = []
blacklist = []
while mp.distance(Point2, current) > 5 or Point2 == current:
distances = []
for neighbour in self.graph[f'({current[0]}, {current[1]})']:
if len(
moveset
) > 0 and neighbour != current and neighbour not in blacklist:
# print(neighbour)
distances.append(mp.distance(neighbour, Point2))
else:
distances.append(9999)
closest = self.graph[f'({current[0]}, {current[1]})'][
distances.index(min(distances))]
print(distances)
while closest in blacklist:
if all(x for x in distances if x == 9999):
blacklist.append(current)
current = visited[-1]
print(current)
visited = visited[:-1]
break
# current = closest
# break
else:
distances[distances.index(min(distances))] = 9999
closest = self.graph[f'({current[0]}, {current[1]})'][
distances.index(min(distances))]
if closest in visited and closest not in blacklist:
blacklist.append(current)
# last = current
current = closest
# pygame.time.delay(20)
# else:
visited.append(closest)
# current = closest
print(mp.distance(current, Point2))
print(blacklist)
moveset = np.append(moveset, current)
bg = pygame.image.load("map.png")
win.fill((0, 0, 0))
win.blit(bg, (0, 0))
pygame.draw.rect(win, (255, 0, 0),
(current[0], current[1], width, width))
pygame.display.update()
return moveset
def __init__(self):
"""Initialize game variables"""
self.clock = pygame.time.Clock()
self.current_map_name = "world"
self.maps = {
"world":Map('Maps/map0.txt', 'images/ProjectUtumno_full.png', screen_size),
"shop": Map('Maps/map_shop.txt', 'images/ProjectUtumno_full.png', screen_size),
"dungeon":Map('Maps/map_dungeon.txt', 'images/ProjectUtumno_full.png', screen_size),
}
self.current_map = self.maps[self.current_map_name]
self.running = False
self.window = pygame.display.set_mode(screen_size)
self.player = Player('images/star.png')
self.bg_color = (0,0,0)
self.event_manager = EventManager()
self.event_manager.addGameObject(self.player)
self.camera = Camera(self.current_map)
self.event_manager.addGameObject(self.camera)
# feel free to move this to its own method or wherever, just using for testing
for enemy in self.current_map.enemy_list.sprites():
self.event_manager.addGameObject(enemy)
self.warpCoordinates = {
"world": [(self.player.position.x,self.player.position.y)],
"shop": [(320,590),(1360,334)],
"dungeon": [(2816,1600),(1440,1525)]
}
class Jeu(Frame):
def __init__(self, parent, controller):
Frame.__init__(self, parent)
self.controller= controller
self.data = None
self.map = None
self.canvas = Canvas(self, bg = 'dark gray', height = 600, width = 800)
self.canvas.pack(padx = 10, pady = 10)
self.liste_id_obstacle=[]
self.taille = 25
self.color_obstacle = "black"
def initialisation(self):
self.data = {self.controller.client.name:{"color":"red", "position":[(1,2)]}}
self.map = Map(10,10)
self.controller.client.get_map()
def updateAffichage(self):
self.afficherObstacle()
'''
for name in self.data:
temp = self.data[name]
pos = temp["position"]
color = temp["color"]
for n in pos:
self.drawCarre(n, color, name)
'''
def set_map(self, dico):
width = dico["width"]
height = dico["height"]
numbers = dico["numbers"]
obstacles = dico["obstacles"]
self.map = Map(width, height)
for i in obstacles:
self.map.set_obstacle(i[0], i[1], True)
self.ajouterID_obstacles(numbers)
def moveID(self, pos_x, pos_y, id, taille):
x0 = pos_x * self.taille + self.taille/2.0 - taille/2.0
y0 = pos_y * self.taille + self.taille/2.0 - taille/2.0
x1 = pos_x * self.taille + taille + self.taille/2.0 - taille/2.0
y1 = pos_y * self.taille + taille + self.taille/2.0 - taille/2.0
self.canvas.coords(id, x0, y0, x1, y1)
def afficherObstacle(self):
liste_pos = self.map.getPositionObstacles()
for i in range (len(liste_pos)):
pos = liste_pos[i]
self.moveID(pos[0], pos[1], self.liste_id_obstacle[i], self.taille)
def ajouterID_obstacles(self, nombre =1):
for i in range (nombre):
self.liste_id_obstacle.append(self.canvas.create_rectangle(0, 0, self.taille, self.taille, fill = self.color_obstacle))
self.afficherObstacle()
def drawCarre(self, n, color, name):
print (n, color)
print (name)
def __init__(self, pos):
self.name = "coalFurnace"
self.pos = pos
Map.changeMap("CF", pos)
self.timer = time.time()
self.working = False
self.occupied = False
def throwItem(position,index): #Jette un objet
global throw
throw = 0
Map.addItem(position,Player.getItem(index))
descript = "Vous jetez " + Player.getItemName(index)
Player.removeItem(index)
return descript
def __init__(self, pos):
self.name = "blacksmith"
self.pos = pos
Map.changeMap("BS", pos)
self.timer = time.time()
self.working = False
self.occupied = False
def __init__(self, pos):
self.name = "smeltery"
self.pos = pos
Map.changeMap("SM", pos)
self.timer = time.time()
self.working = False
self.occupied = False
def __init__(self, pos):
self.name = "trainingCamp"
self.pos = pos
Map.changeMap("TC", pos)
self.timer = time.time()
self.working = False
self.occupied = False
def move(x1, th1, speed=1, delta=0):
settings = termios.tcgetattr(sys.stdin)
#pub = rospy.Publisher('/vesc/ackermann_cmd_mux/input/teleop', AckermannDriveStamped, queue_size=10)
rospy.init_node(
'keyop'
) # vesc/ackermann_cmd_mux/input/navigation ackermann_msgs/AckermannDriveStamped
pub = rospy.Publisher('/vesc/ackermann_cmd_mux/input/teleop',
AckermannDriveStamped,
queue_size=10)
#print(delta)
th12 = th1 * turn
if (abs(th12) >= 1): print("WARNING TURN = " + str(th12))
try:
m.move(x1 * speed * delta * 50)
#m.move(x1*speed)
msg = AckermannDriveStamped()
msg.header.stamp = rospy.Time.now()
msg.header.frame_id = "base_link"
msg.drive.speed = x1 * speed
msg.drive.acceleration = .1
msg.drive.jerk = 1
msg.drive.steering_angle = th1 * turn
msg.drive.steering_angle_velocity = 1
#print ("moving this dude " , speed, "*",x1," ",msg.drive.speed)
pub.publish(msg)
except:
print('error')
def __init__(self):
self._map = Map()
self._soldier = Task4Soldier()
self._spring = Spring()
self._monsters = [Task4Monster(i, random.randint(0,5) * 10 + 30) for i in range(1, 8)]
self._merchant = Task4Merchant()
self._game_enabled = True
def quiz(WIN, game):
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT: # If hit red cross on pygame window
break
if event.type == pygame.MOUSEBUTTONDOWN: # If any button on mouse pressed down
awnser = get_awnser(pygame.mouse.get_pos())
if isinstance(awnser, str):
if game.quiz.next_question[-1].replace("\n", "").lower() == awnser.lower():
WIN.blit(TICK, (900, 400))
pygame.display.update()
time.sleep(2)
game.quiz.get_next_question()
game.quiz.questionsAwnsered += 1
ma.main(game, WIN, game.map)
if game.quiz.questionsAwnsered == 3:
return None
else:
draw(WIN, game)
WIN.blit(CROSS, (900, 400))
pygame.display.update()
if game.firewalls == 1:
final.loser(WIN)
game.firewalls -= 1
time.sleep(2)
draw(WIN, game)
pygame.quit()
def new_game():
global player, inventory, game_msgs, game_state, dungeon_level
#create object representing the player
entity_component = Entity(5)
GameState.player = Object(0, 0, '@', 'player', libtcod.white, blocks=True, entity=entity_component)
GameState.player.level = 1
#generate map (at this point it's not drawn to the screen)
dungeon_level = 1
Map.make_map()
initialize_fov()
game_state = 'playing'
GameState.inventory = []
#create the list of game messages and their colors, starts empty
GameState.game_msgs = []
#a warm welcoming message!
GUI.message('Welcome stranger! Prepare to perish in the Tombs of the Ancient Kings.', libtcod.red)
#initial equipment: a dagger
equipment_component = Equipment(slot='right hand', power_bonus=2)
obj = Object(0, 0, '-', 'dagger', libtcod.sky, equipment=equipment_component)
GameState.inventory.append(obj)
equipment_component.equip()
obj.always_visible = True
class MainWindow(QMainWindow):
'''Wrapper class for...well, the game? Maybe this needs to be called the game engine then'''
def __init__(self):
'''
Only initialize critical components(like opengl) here, use start() for anything else
'''
QMainWindow.__init__(self)
Globals.glwidget = GLWidget(self)
self.setCentralWidget(Globals.glwidget)
Globals.glwidget.makeCurrent()
if Globals.musicOn:
print "Using music"
Globals.mediaobject = Phonon.MediaObject(self)
self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
Phonon.createPath(Globals.mediaobject, self.audioOutput)
self.map = Map() #map class
self.drawTimer = QTimer()
self.drawTimer.timeout.connect(self.drawTimerTimeout)
self.drawTimer.start(0.2)
def start(self):
if Globals.musicOn:
Globals.muspanel = MusPanel(self)
#draw map... set view to ground
Globals.view = self.map.generateMap()
def drawTimerTimeout(self):
self.map.update()
Globals.glwidget.updateGL()
def update(self):
if self.rect.y > HEIGHT * 2:
# Если Марио упал за пределы карты, в том числе из-за отключения коллизий после смерти
Map.load_level(Map.cur, Utilities,
resetscore=True) # перезагруажем уровень
hud.add_lives(-1) # Отнимаем одну жизнь
self.cur_frame = (self.cur_frame +
1) % 60 # Обновление счетчика кадров
self.update_invincibility() # Обновление счетчика неуязвимости
self.vx = max(min(self.vx, self.max_vx),
-self.max_vx) # Ограничение горизонт. скорости
self.update_flagpoled() # Проигрывание анимаций в конце уровня
self.update_coords()
if self.died: # Анимация смерти и отключение коллизий
self.image = self.frames[5]
self.jump()
return
# Взаимодействия с тайлами, врагами, флагштоком
self.check_tile_collisions()
self.check_enemies_collisions()
self.check_flagpole_collision()
self.update_blincking() # Анимация мерцания
self.sides_group.draw(screen) # Отрисовка коллизий
def __init__(self, map_file_name, bot_files):
""" Initializes the map and bikes. """
self.map = Map(map_file_name)
init_posns = self._generate_init_posns(self.map)
self.bikes = [
Bike(BIKE_1_SYMBOL, init_posns[0], bot_files[0]),
Bike(BIKE_2_SYMBOL, init_posns[1], bot_files[1])
]
self.map.set_symbol(self.bikes[0].curr_posn, self.bikes[0].symbol)
self.map.set_symbol(self.bikes[1].curr_posn, self.bikes[1].symbol)
self.game_over = False
self.turn_count = 0
# Send the initialization info to the bots.
for bike in self.bikes:
bike.bot.add_to_info_to_send(bike.symbol)
if bike.symbol == BIKE_1_SYMBOL:
enemy_symbol = BIKE_2_SYMBOL
bot_num = 0
else:
enemy_symbol = BIKE_1_SYMBOL
bot_num = 1
bike.bot.add_to_info_to_send(enemy_symbol)
bike.bot.add_to_info_to_send(
str(init_posns[bot_num].x) + " " + str(init_posns[bot_num].y))
bike.bot.add_to_info_to_send(
str(init_posns[1 - bot_num].x) + " " +
str(init_posns[1 - bot_num].y))
bike.bot.add_to_info_to_send(map_file_name)
def game_first_start():
if True:
(PlayerName, StarterName) = naming()
else:
PlayerName = "PlayerDefault"
StarterName = "Starty"
Journey_Start = time.time()
PlayerX = 2
PlayerY = 2
MapID = 1
PlayerID = random.randint(0, 9999999999)
MonsterID = 1
MonsterLvl = 1
Player = Classes.new_player(PlayerName, PlayerID, MapID, PlayerX, PlayerY,
"Up", Journey_Start)
Starter = Classes.catch_monster(Classes.new_monster(MonsterID, MonsterLvl),
Player, StarterName, 1, Journey_Start)
Player = Monster.put_monster_in_party(Starter, Player)
Field = Map.load_map(Player, (PlayerX, PlayerY), MapID)
try:
(Field, Player) = Map.set_player(Field, Player, MapID, PlayerX,
PlayerY)
except:
print("Error: Setting of Player on Map " + str(MapID) + " failed.")
sys.exit()
Saves.save_game(Field, Player)
return (Player, Field)
def LoadGame():
if not reloadGame:
loadHolder = maps.load()
maps.new_blocks = loadHolder[0]
player.rect = loadHolder[1]
objects.all_objects = loadHolder[2]
else:
maps.loadMap()
def getValueOfAction(self, loc, dir, state):
start = Map.getNextLoc(loc, dir)
if start == False:
start = loc
list_dis = []
for ghost_location in state.get('ghost_locations'):
list_dis += [float(Map.getShortestPath(start, ghost_location))]
return min(list_dis)
def game_init_screen(Field):
Map.Block_Size = Blocksize
Map.FieldSizeX = int(Screen_Height / Blocksize)
Map.FieldSizeY = int(Screen_Width / Blocksize)
MapScreen = pygame.display.set_mode((Screen_Height, Screen_Width))
Map.draw_map(MapScreen, Field)
pygame.key.set_repeat(200)
return MapScreen
def draw(self):
if not self.game_over:
background(0, 0, 0)
center_point = Point(screen_width() / 2, screen_height() / 2)
Map.draw(center_point)
update_display()
def bycicleProcess():
tag = bicycleEntry.get()
#Map.FindLocation(tag)
coord = Map.GetCoordinate(tag)
Map.GetMap(coord)
photo = PhotoImage(file="SearchMap.gif")
boganImage.configure(image=photo, width=777, height=397.5)
boganImage.image = photo
def LoadGame():
if not reloadGame:
loadHolder = maps.load()
maps.new_blocks = loadHolder[0]
player.rect = loadHolder[1]
objects.all_objects = loadHolder[2]
else:
maps.loadMap()
def __init__(self, protocol, botname):
self.protocol = protocol
self.botname = botname
protocol.addPacketHandlers({
PACKET_CHAT: self._handleChat,
PACKET_SPAWNPOSITION: self._handleSpawnPosition,
PACKET_PLAYERHEALTH: self._handlePlayerHealth,
PACKET_PLAYERPOSITION: self._handlePlayerPosition,
PACKET_PLAYERPOSITIONLOOK: self._handlePlayerPositionLook,
PACKET_MOBSPAWN: self._handleMobSpawn,
PACKET_NAMEDENTITYSPAWN: self._handleNamedEntitySpawn,
PACKET_PICKUPSPAWN: self._handlePickupSpawn,
PACKET_ENTITYMOVE: self._handleEntityMove,
PACKET_ENTITYMOVELOOK: self._handleEntityMoveLook,
PACKET_ENTITYTELEPORT: self._handleEntityTeleport,
PACKET_DESTROYENTITY: self._handleDestroyEntity,
PACKET_PRECHUNK: self._handlePreChunk,
PACKET_CHUNK: self._handleChunk,
PACKET_BLOCKCHANGE: self._handleBlockChange,
PACKET_MULTIBLOCKCHANGE: self._handleMultiBlockChange,
PACKET_SETSLOT: self._handleSetSlot,
PACKET_WINDOWOPEN: self._handleWindowOpen,
PACKET_WINDOWCLOSE: self._handleWindowClose,
PACKET_WINDOWITEMS: self._handleWindowItems,
PACKET_TRANSACTION: self._handleTransaction,
})
self.entities = {}
#redundant entity dicts for convenience
self.players = {}
self.pickups = {}
self.entityDicts = [self.entities, self.players, self.pickups]
self.spawnPos = Point(-1, -1, -1)
self.pos = Point(-1, -1, -1)
self.headY = -1
self.hp = -1
self.food = -1
self.lookTarget = None
self.map = Map()
self.inventoryHandler = InventoryHandler(self.protocol)
self.playerInventory = self.inventoryHandler.windows[0]
self.speed = 6#block/s
self.targetTick = 0.2
self.runTask = None
#self.running = False
self.commandQueue = []
def load_map(self):
# create map instance, load generated map on top on the menu
self.blit_menu = False
self.blit_map = True
self.map = Map(
self,
15) #tosses window class attributes and functions to Map class
self.map.load_tile_types()
self.map.generate()
def build_constelation(self,mol):
if mol.acteur == None :
MB.showwarning('Info','Select a molecule in the list')
return
if mol.symobs !=None:
mol.acteur.RemoveObserver(mol.symobs)
if mol.lsm!=[]:
for sm in mol.lsm:
self.gfx.renderer.RemoveActor(sm)
mol.lsm=[]
(xmin, xmax, ymin, ymax, zmin, zmax)= self.bounds
sym=open(self.symlistfile,'r')
for l in sym:
ms = l.split()
nbl = int(ms[6][1:])
if nbl not in mol.lnbsm:
continue
ang = [float(ms[0]),float(ms[1]),float(ms[2])]
tra = array([float(ms[3]),float(ms[4]),float(ms[5])])
sm=symmate() #on cree un symmate vide
sm.SetPosition(mol.acteur.GetPosition()) #on assigne la partie translationelle des pv
sm.SetOrientation(mol.acteur.GetOrientation()) #on assigne la partie rotationelle des pv
self.RotaEuler(sm.ut,ang[0],ang[1],ang[2]) #on defini la partie rotationelle de la transformation
sm.ut.Translate(tra[0],tra[1],tra[2]) #on defini la partie translationelle de la transformation
sm.SetUserTransform(sm.ut) #on assigne la transformation a notre symmate
pip = [sm.GetMatrix().GetElement(0,3),sm.GetMatrix().GetElement(1,3),sm.GetMatrix().GetElement(2,3)]#on recupere la partie translationelle de la combinaison de pv et de la transformation (ut)
if (xmin + self.mdbe < pip[0]) and (pip[0] < xmax - self.mdbe) and (ymin + self.mdbe < pip[1]) and (pip[1] < ymax - self.mdbe) and (zmin + self.mdbe < pip[2]) and (pip[2] < zmax - self.mdbe):# on test si pip est dans la boite
sm.nbsym=nbl
if mol.acteur.GetClassName()=='vtkAssembly':# dans le cas ou la molecule independante est un assembly
for i in range(mol.acteur.GetNumberOfPaths()):
tmp=vtk.vtkActor()
tmp.SetMapper(mol.acteur.GetParts().GetItemAsObject(i).GetMapper())
p=vtk.vtkProperty()
#p.SetColor(mol.acteur.GetParts().GetItemAsObject(i).GetProperty().GetColor())
p.SetColor(Map.invcolor(mol.acteur.GetParts().GetItemAsObject(i).GetProperty().GetColor()))
tmp.SetProperty(p)
if mol.mod.type=='mol':
tmp.GetProperty().SetLineWidth(4)
tmp.DragableOff()
tmp.PickableOff()
sm.AddPart(tmp)
else:#cas simple ou la mol ind est composer d un seul objet
tmp=vtk.vtkActor()
tmp.SetMapper(mol.acteur.GetMapper())
p=vtk.vtkProperty()
#p.SetColor(mol.acteur.GetParts().GetItemAsObject(i).GetProperty().GetColor())
p.SetColor(Map.invcolor(mol.acteur.GetProperty().GetColor()))
tmp.SetProperty(p)
if mol.mod.type=='mol':
tmp.GetProperty().SetLineWidth(4)
tmp.DragableOff()
tmp.PickableOff()
sm.AddPart(tmp)
mol.lsm+=[sm]# on ajoute le symmate a la liste des symmate
sym.close()
self.move_sym(mol)
def __init__ (self, search_range = 100):
bjmap = Map()
filenames = ["bjmap/road"]
bjmap.load_roads(filenames)
bjmap.stat_map_info()
bjmap.index_roads_on_grid()
bjmap.gen_road_graph()
self.traj_map = bjmap
self.search_range = search_range
#for constructing a coordinate map in meters
m_latitude = (self.traj_map.min_latitude + self.traj_map.max_latitude) / 2
self.WIDTH = map_dist(self.traj_map.min_longitude, m_latitude, self.traj_map.max_longitude, m_latitude)
m_longitude = (self.traj_map.min_longitude + self.traj_map.max_longitude) / 2
self.HEIGHT = map_dist(m_longitude, self.traj_map.min_latitude, m_longitude, self.traj_map.max_latitude)
print "Connecting..Database: shortest_path..."
self.conn_sp = psycopg2.connect(host='localhost', port='5432', database="mapmatching", user='******',password='******')
print "Connected!"
self.cursor_sp = self.conn_sp.cursor()
self.shortest_path = {}
self.initialize_sp()
self.supp = {}
def pickItem(position,index): #Ramasse un objet
global pick
pick = 0
print "add"
Player.addItem(Map.getItem(position,index))
print "describe"
descript = "Vous ramassez " + Map.getItemName(position,index)
print "remove"
Map.removeItem(position,index)
print "return"
return descript
def init(): # Defini les variables de depart
global descript, myBackground
myBackground=Background.create("background","victoire","defaite","menu")
Background.show(myBackground,"menu")
Player.setName()
Player.setHealth()
Player.setPower()
Map.generate(6)
descript = descript()
tty.setcbreak(sys.stdin.fileno())
return descript
def getInput():
options = [];
if Globals.gameState != "Load" and Globals.player.dead():
Globals.quitGame = True
else:
if(Globals.gameState == "Load"):
options.append(Selection("New Game", ["new", "new game"], "create()"))
options.append(Selection("Load Game", ["load", "load game"], "load()"))
if Globals.gameState == "Running":
options.append(Selection("Fight", ["fight", "fight something"], "testCombat()"))
options.append(Selection("Display Character",["display","display character"], "print(Globals.player)"))
if Globals.gameState == "Dungeon":
options.append(Selection("Move(N,S,E,W)",["n","north","s","south","e","east","w","west"],"Map.mapMain(valInput)"))
if Map.positionCheck() == [0,4]:
if Globals.getKey == False:
options.append(Selection("Get Key",["get","get key"],"Globals.getKey= True"))
elif Map.positionCheck() == [4,5]:
if Globals.doorUnlocked == False:
if Globals.getKey:
options.append(Selection("Unlock Door",["unlock","unlock door"],"Globals.doorUnlocked = True"))
if Map.positionCheck() == [2,4]:
options.append(Selection("Rest",["rest"],"Globals.player.rest()"))
options.append(Selection("Display Character",["display","display character"], "print(Globals.player)"))
if Globals.defeatBoss:
options.append(Selection("New Game +",["new","new game", "new game +"],"newGamePlus()"))
options.append(Selection("Cheat",["xyzzy"],"Globals.player.AP += 1000"))
if Globals.gameState == "Combat":
pass
if Globals.gameState != "Load" and Globals.gameState != "Combat":
if Globals.player.AP >= 100:
options.append(Selection("Level Up", ["level", "level up"], "level()"))
options.append(Selection("Save Game", ["save", "save game"], "save()"))
options.append(Selection("Exit Game", ["exit", "exit game"], "quitGame()"))
stroptions = "("
for i in range(0, len(options), 1):
stroptions += str(options[i])
if i < len(options)-1:
stroptions += ", "
stroptions += ")"
valid = False
selection = None
while not valid:
valInput = input("\nWhat would you like to do? " + str(stroptions) + "\n>").lower()
for sel in options:
if sel.validSel(valInput):
valid = True
selection = sel
break
exec(sel.codeToExecute)
def on_paint(self,event):
dc = wx.PaintDC(event.GetEventObject())
dc.Clear()
dc.SetPen(wx.Pen("BLACK", 4))
map = Map()
mapaArray = map.creaPoligono()
for j in range(0, len(mapaArray)):
#print mapaArray
print len(mapaArray[j].polarr)
for i in range (0,len(mapaArray[j].polarr) - 1):
dc.DrawLine(int(mapaArray[j].polarr[i].x),int(mapaArray[j].polarr[i].y), int(mapaArray[j].polarr[i + 1].x),int(mapaArray[j].polarr[i + 1].y),)
def __init__(self, levelPreset = "empty"):
self.screen = pygame.display.get_surface()
self.backgroundImage, self.backgroundRect = loadPNG("background.png")
self.blockList = [Object(type = "earth"), Object(type = "boing"), Object(type = "ice")]
self.currentBlockNumber = 0
self.currentBlock = self.blockList[self.currentBlockNumber]
self.currentSpriteBlock = pygame.sprite.RenderPlain(self.currentBlock)
self.buttonSound = pygame.mixer.Sound("resources/sound/button.wav")
self.buttonSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.grid = False
self.level = Map(True)
self.active = True
self.pauseMenu = PauseEditorMenu()
self.toolbar = EditorToolbar()
if levelPreset != "empty":
self.level.load(levelPreset)
pygame.display.flip()
def execute(server, iterator, source):
name = iterator.getString()
mapname = iterator.getString()
party = {
'name': name,
'mapname': mapname,
'map' : Map.load(mapname),
'chars': {},
'log': {},
'creator': server.sessions[source]['login'],
'players': [],
'formations': [],
}
party['players'].append(server.sessions[source]['login'])
server.parties[name] = party
server.sessions[source]['party'] = name
server.sessions[source]['player'] = len(party['players'])-1
server.readysources[name] = set()
server.updateAllPartyLists()
print server.sessions[source]['login'], "created the party", name, "using the map", mapname
server.send.PARTY_CREATED(party, source)
def __init__(self, ki=False, level=50): # Asking for 'human' I prefer before asking for dump, deadly # fast calculating machines...so, I called the member 'human'. # I called the "level" now 'ki_level' to make clear it is only # valid for computer players, not for human ones. self.human = not ki self.ki_level = level # The Player needs some counters for counting his ships # 'ship_count' which not sunk so far and a list of ships his foe # has already. This is 'foeships'. self.ship_count = 0 self.foeships = [] # Now the maps. Because the handling of maps may be difficult, # this is encapsulated in another class called 'Map'. I called # them 'ships' for the secret map the Player hold his own ships. # And 'hits' which is his open map to track the bombardments. self.ships = Map() self.hits = Map() # The player (especially the KI) needs to remember the last # turn's result. So here we hold space to save is... self.last_result = None
class Game(object):
Ranked, Unranked = range(2)
Blind, Draft, Random = range(3)
phases = 3
def __init__(self, sid, stype = Unranked, smode = Draft, spublic = False, mapsettings = (4, 4, 3) ):
self.id = sid
self.type = stype #ranked?
self.mode = smode #draft?
self.public = spublic
self.players = []
# Pending meta requests (rewind, draw, etc)
self.requests = [];
self.rosters = {}
if self.mode == self.Draft:
self.bans = {}
self.map = Map(mapsettings)
self.states = {}
self.states[(0,0)] = self.map.getState((0,0))
def __init__(self, map_file_name, bot_files):
""" Initializes the map and bikes. """
self.map = Map(map_file_name)
init_posns = self._generate_init_posns(self.map)
self.bikes = [
Bike(BIKE_1_SYMBOL, init_posns[0], bot_files[0]),
Bike(BIKE_2_SYMBOL, init_posns[1], bot_files[1]),
]
self.map.set_symbol(self.bikes[0].curr_posn, self.bikes[0].symbol)
self.map.set_symbol(self.bikes[1].curr_posn, self.bikes[1].symbol)
self.game_over = False
self.turn_count = 0
# Send the initialization info to the bots.
for bike in self.bikes:
bike.bot.add_to_info_to_send(bike.symbol)
if bike.symbol == BIKE_1_SYMBOL:
enemy_symbol = BIKE_2_SYMBOL
bot_num = 0
else:
enemy_symbol = BIKE_1_SYMBOL
bot_num = 1
bike.bot.add_to_info_to_send(enemy_symbol)
bike.bot.add_to_info_to_send(str(init_posns[bot_num].x) + " " + str(init_posns[bot_num].y))
bike.bot.add_to_info_to_send(str(init_posns[1 - bot_num].x) + " " + str(init_posns[1 - bot_num].y))
bike.bot.add_to_info_to_send(map_file_name)
def __init__(self):
self.window = pyglet.window.Window(640, 320)
self.window.set_caption("Pedometer")
self.window.set_icon(pyglet.image.load("../res/graphics/icons/020-Accessory05.png"))
self.window.on_key_press = self.keyDown
self.window.on_key_release = self.keyUp
self.window.on_draw = self.render
self.fps = pyglet.clock.ClockDisplay()
self.map = Map()
pygame.init()
pygame.mixer.music.load("../res/audio/music/001-Battle01.mid")
pygame.mixer.music.play(-1, 0.0)
self.background = pyglet.image.load("../res/graphics/battlebacks/001-Grassland01.jpg")
self.character = Character(self, 0, 0)
self.steps = 0
self.label = pyglet.text.Label("Steps: 0", font_name = "Helvetica", font_size = 12, x = 10, y = self.window.height - 10, anchor_x = "left", anchor_y = "top", bold = True)
pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA, pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
pyglet.clock.schedule_interval(self.update, 0.1 / 32)
pyglet.app.run()
def move(direction): # Deplace le joueur si possible
flee = random.randint(1,6)
if Map.isMonster(Player.getPosition()) == 0 or flee == 6:
answer = Map.check(Player.getPosition(),direction)
if answer == 0:
return "You can't go this way. Unless, of course, you can walk through walls!"
elif answer == 1 :
Player.move(direction)
Player.editTime(10)
return Map.getDescript(Player.getPosition())
else :
win()
exitGame()
else:
Player.editHealth(-1)
Player.editTime(1)
return "Votre adversaire vous attrappe par le col et frappe a l'estomac. Battez-vous que diable!"
def move(direction): # Deplace le joueur si possible
flee = random.randint(1,6)
if Map.isMonster(Player.getPosition()) == 0 or flee == 6:
answer = Map.check(Player.getPosition(),direction)
if answer == 0:
return 'Il y a un mur dans cette direction'
elif answer == 1 :
Player.move(direction)
Player.editTime(10)
return Map.getDescript(Player.getPosition())
else :
win()
exitGame()
else:
Player.editHealth(-1)
Player.editTime(1)
return "Votre adversaire vous attrappe par le col et frappe a l'estomac. Battez-vous que diable!"
def setUp(self): self.app=QApplication([]) self.dg=DummyGame() self.p1=Player(self.dg) self.p2=Player(self.dg) self.m=Map() self.m.createSquareMap(3,[self.p1, self.p2]) print "created"
def __init__(self, color):
self.butterflies = []
self.screen = pygame.display.get_surface()
self.backgroundImage, self.backgroundRect = loadPNG("background.png")
self.buttonSound = pygame.mixer.Sound("resources/sound/button.wav")
self.buttonSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.active = True
self.level = Map(True)
self.toolbar = GameToolbar()
self.client = Client('localhost')
self.client.connect()
self.client.recieve()
self.client.send(b"connexion avec serveur : OK")
#MAP STRING RECIEVE
mapStr = self.client.recieve(4096)
mapStr = struct.unpack(str(len(mapStr)) + "s", mapStr)[0]
#LOAD MAP FROM STRING
self.level.saveFromStr("tempClient", mapStr)
self.level.load("tempClient")
#CREATE CLIENT RABBIT
self.regis = Rabbit(1, "regis" , color, self.level.objectList, self.level.objectSpritesList)
#SERVER RABBIT COLOR RECIEVE
serverCol = self.client.recieve()
serverCol = struct.unpack("iii", serverCol)
#CLIENT RABBIT COLOR SEND
self.client.send(struct.pack("iii", self.regis.color[0], self.regis.color[1], self.regis.color[2]))
#CREATE SERVER RABBIT
self.john = Rabbit(2, "john" , serverCol, self.level.objectList, self.level.objectSpritesList, True)
self.regis.appendRabbit(self.john)
self.john.appendRabbit(self.regis)
self.pauseMenu = PauseGameMenu()
# for l in range(0, 6):
# while True:
# randPos = random.randint(0, 16)
# if not self.level.isInBlock(self.level.objectList[randPos].getX() + 10, self.level.objectList[randPos].getY() - 26):
# break
# butterfly = Butterfly(self.level.objectList[randPos].getX() + 10, self.level.objectList[randPos].getY() - 26, (255, 10, 100), self.level.objectList, self.level.objectSpritesList)
# self.butterflies.append(butterfly)
pygame.display.flip()
def set_map(self, dico):
width = dico["width"]
height = dico["height"]
numbers = dico["numbers"]
obstacles = dico["obstacles"]
self.map = Map(width, height)
for i in obstacles:
self.map.set_obstacle(i[0], i[1], True)
self.ajouterID_obstacles(numbers)
def __init__(self, protocol, botname):
self.protocol = protocol
self.botname = botname
protocol.addPacketHandlers({
PACKET_CHAT: self._handleChat,
PACKET_SPAWNPOSITION: self._handleSpawnPosition,
PACKET_PLAYERHEALTH: self._handlePlayerHealth,
PACKET_PLAYERPOSITION: self._handlePlayerPosition,
PACKET_PLAYERPOSITIONLOOK: self._handlePlayerPositionLook,
PACKET_MOBSPAWN: self._handleMobSpawn,
PACKET_NAMEDENTITYSPAWN: self._handleNamedEntitySpawn,
PACKET_PICKUPSPAWN: self._handlePickupSpawn,
PACKET_ENTITYMOVE: self._handleEntityMove,
PACKET_ENTITYMOVELOOK: self._handleEntityMoveLook,
PACKET_ENTITYTELEPORT: self._handleEntityTeleport,
PACKET_DESTROYENTITY: self._handleDestroyEntity,
PACKET_PRECHUNK: self._handlePreChunk,
PACKET_CHUNK: self._handleChunk,
PACKET_BLOCKCHANGE: self._handleBlockChange,
PACKET_MULTIBLOCKCHANGE: self._handleMultiBlockChange,
PACKET_SETSLOT: self._handleSetSlot,
PACKET_WINDOWOPEN: self._handleWindowOpen,
PACKET_WINDOWCLOSE: self._handleWindowClose,
PACKET_WINDOWITEMS: self._handleWindowItems,
PACKET_TRANSACTION: self._handleTransaction,
})
self.entities = {}
#redundant entity dicts for convenience
self.players = {}
self.pickups = {}
self.entityDicts = [self.entities, self.players, self.pickups]
self.spawnPos = Point(-1, -1, -1)
self.pos = Point(-1, -1, -1)
self.headY = -1
self.hp = -1
self.food = -1
self.lookTarget = None
self.map = Map()
self.inventoryHandler = InventoryHandler(self.protocol)
self.playerInventory = self.inventoryHandler.windows[0]
self.speed = 6#block/s
self.targetTick = 0.2
self.runTask = None
#self.running = False
self.commandQueue = []
def pickList(): #Renvoie la liste des objets ramassables
global items, pick
items = Map.isItem(Player.getPosition())
if items == 0:
return "Il n'y a pas d'objets dans cette zone."
elif Player.isItem() == 6:
return "Vous n'avez plus de place dans votre inventaire."
else:
pick = 1
return "Quel objet voulez-vous ramasser? (Tapez le numero correspondant) ~~~~~~~~~~~~~~~~~~~~~~~~~~ " + Map.getItemList(Player.getPosition())
def __init__(self, port = 13000, host = "localhost"): """ This function has two objects right now move will control the movement of the pibot com controls the communication. Basically the AI gets information from the sensors (Maybe thats a class aswell?) does its AI stuff, calls move to move the bot and calls com to update the laptop """ self.move = Move() self.room = Map([[0,0]]) self.com = Com(port = port, host = host)
def save():
print("Saving...")
if os.path.isfile("player.qso"):
os.remove("player.qso")
pickle.dump(Globals.player, open( "player.qso","wb"))
print("Save complete!")
if os.path.isfile("progress.qso"):
os.remove("progress.qso")
x,y = Map.positionCheck()
globalsList = [Globals.doorUnlocked, Globals.miniBoss, Globals.defeatBoss, Globals.getKey,x,y,Globals.whaleTrap,Globals.levelInit]
pickle.dump(globalsList, open( "progress.qso","wb"))
class TestPlayer(unittest.TestCase): def setUp(self): self.app=QApplication([]) self.dg=DummyGame() self.p1=Player(self.dg) self.p2=Player(self.dg) self.m=Map() self.m.createSquareMap(3,[self.p1, self.p2]) print "created" def test_unitnumber(self): i=0 for unit in self.m.units: if unit.owner == self.p1 and unit.getId() == 'tank': i=i+1 self.assertEqual(i,3) def tearDown(self): pass
def load():
print("Loading")
if os.path.isfile("player.qso"):
Globals.player = pickle.load( open( "player.qso","rb"))
global loadingFlag
loadingFlag = True
Globals.gameState = "Dungeon"
print(Globals.player.name,"loaded successfully.")
a,b = Map.positionCheck()
globalsList = pickle.load( open("progress.qso","rb"))
Globals.doorUnlocked = globalsList[0]
Globals.miniBoss = globalsList[1]
Globals.defeatBoss = globalsList[2]
Globals.getKey = globalsList[3]
Map.position = [globalsList[4],globalsList[5]]
Map.roomDesc(globalsList[4],globalsList[5])
Globals.whaleTrap = globalsList[6]
Globals.levelInit = globalsList[7]
else:
print("Player not found")
