def testPolylineSerialize(self):
map = Map()
map.open(os.path.join(self.testdatadir, "00map.ini"))
streets = map.getLayerByName("00_Streets")
streets.open("r")
cell = streets.getCell(1)
street = cell.getCellElements()[0]
expected = getCellElementRawData(streets, 1, 0)
actual = street.serialize(cell)
if actual != expected:
print "Expected:", dump(expected)
print "Actual: ", dump(actual)
outstreet = CellElementPolyline(streets)
outstreet.deSerialize(cell, actual)
self.assertEqual(street,outstreet)
self.assertEqual(len(actual), len(expected))
self.assertEqual(actual, expected)
class Game(object):
def __init__(self):
self.TITLE = "TEST (by zeeisl)"
self.WIDTH = 800
self.HEIGHT = 600
self.controller = Controller()
# game things
self.char = Player("res//hero.png")
self.map = Map()
self.char1 = Character("res//hero.png", 100, 100, 32, 32)
def key_input(self, event):
self.controller.getButtonStates(event)
self.char.key_input(event)
def update(self, delta):
self.map.update()
self.char.update(self.char1)
self.char1.update()
def render(self, screen):
self.map.render(screen)
self.char.render(screen)
self.char1.render(screen)
def newTak(): name = getValue(request, "name", None) uid = getValue(request, "userid", None) lat = getValue(request, "lat", None) lng = getValue(request, "lng", None) if not ( name and lat and lng and uid): return json_response(code=400) mapid = getValue(request, "mapid", None) map = None if uid is not None: user = Account.get_by_id(int(uid)) if user is None: return json_response(code=400) if mapid is not None: map = Map.get_by_id(int(mapid)) if map is None: map = Map(creator=user.name,creatorId=int(uid),name='Untitled',adminIds=[int(uid)]) key = map.put() mapid = key.id() account = Account.get_by_id(int(uid)) account.adminMaps.append(int(mapid)) account.put() tak = Tak(lng=lng,lat=lat, creator=user.name, name=name,mapId=int(mapid),creatorId=int(uid)) key = tak.put() map.takIds.append(key.integer_id()) map.put(); return json_success(tak.Get())
def main():
# initialize map
map = Map()
player = AIPlayer(map)
map.setPlayer(player)
map.mapLoop() # map's main loop event
class ActionPhase:
"""
Handling the Action Phase of the game
"""
def __init__(self, screen, player_list):
self.player_list = player_list
self.map = Map(player_list, size=3)
self.map.create_map()
self.map.draw_tiles(screen)
self.map.draw_hex_positions(screen)
# Make sure initiative order is up to date
agenda_order = []
for player in player_list:
player.update_initiative_order()
agenda_order.append(player.get_initiative_order())
# Reorganizing the player iteration in initiative (absolute bloodbath)
iterable = self.player_list.sprites()
player_list = pygame.sprite.Group()
for i in np.argsort(agenda_order):
player_list.add(iterable[i])
# iterable[i].remove(self.player_list) # the sprite is in two groups i dont know what that means
self.player_list = player_list
self.player_list_cycle = cycle(self.player_list)
self.current_player = next(self.player_list_cycle)
self.turn_controller = TurnController(
current_player=self.current_player)
self.user_interface = UserInterface(current_player=self.current_player)
def move_to_next_player(self):
self.current_player = next(self.player_list_cycle)
self.user_interface.change_main_color(self.current_player.color)
def handle_event(self, screen, event):
pass
def update(self, screen):
# Updating MAP on hover
for tile in self.map.tiles:
r_hex = tile.image.get_rect(topleft=tile.pos)
if r_hex.collidepoint(pygame.mouse.get_pos()):
tile.update(pos=tile.pos, image=tile.image, color=BLACK)
else:
tile.update(pos=tile.pos, image=tile.image, color=WHITE)
self.map.tiles.draw(screen)
self.map.draw_players(screen)
self.draw_units(screen)
self.map.draw_hex_positions(screen)
self.user_interface.draw(screen)
def erase(self, screen):
pass
def draw_units(self, screen):
for this_player in self.player_list:
this_player.draw_units(screen)
def setNewInput(self, inp: str):
self.pfEnd()
self.running = False
self.started = False
self.finished = False
self.states = deque()
self.paths = []
self.currentStateIndex = -1
self.map = Map(inp)
def main():
map = Map()
try:
map.get_random_map(MAPS_PATH)
except MapError as e:
print("Map error:", e)
exit(FAILURE) # TODO: Handle multiple map loading retries etc...
core = Core(map)
core.run()
class OpenAnt(QApplication):
def __init__(self):
QApplication.__init__(self, sys.argv)
# Set the default background color to a darker grey.
self.setPalette(QPalette(self.palette().button().color(), QColor(192, 192, 192)))
self.window = MainWindow()
self.window.show()
self.window.start()
self.window.setWindowTitle('OpenAnt')
# Game timer, used in the gameloop FPS calculations.
self.game_timer = QTime()
self.game_timer.start()
# Draw map, set view to ground.
self.map = Map()
Globals.view = self.map.generateMap()
self.map.spawnAnts()
# Start the main loop.
self.gameLoop()
def gameLoop(self):
TICKS_PER_SECOND = 20
SKIP_TICKS = 1000 / TICKS_PER_SECOND
MAX_FRAMESKIP = 5
next_game_tick = self.getTickCount()
Globals.game_is_running = True
while Globals.game_is_running:
loops = 0
while self.getTickCount() > next_game_tick and loops < MAX_FRAMESKIP:
self.updateGame()
next_game_tick += SKIP_TICKS
loops += 1
interpolation = float(self.getTickCount() + SKIP_TICKS - next_game_tick) / float(SKIP_TICKS)
self.updateDisplay(interpolation)
def updateDisplay(self, interpolation):
#lerp away
if not 'nolerp' in sys.argv:
if self.map.yellowAnt.moving:
self.map.yellowAnt.lerpMoveSimple(interpolation)
Globals.glwidget.updateGL()
self.processEvents() # Let Qt process its events.
def getTickCount(self):
return self.game_timer.elapsed()
def updateGame(self):
self.map.update()
def run(self):
current_dir = os.path.dirname(os.path.abspath(__file__))
image_path = os.path.join(current_dir, "car.png")
car_image = pygame.image.load(image_path)
scale = 40
car = Car(6 * scale, 5 * scale, angle=70)
map = Map(scale)
agent = Agent()
while not self.exit:
# print(car.position, car.angle)
# Event queue
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.exit = True
# Logic
car.update()
# print("Car angle: ", car.angle)
# Drawing
self.screen.fill((0, 0, 0))
map.draw(self.screen, [0, 255, 0])
# draw inside
distance_vec = []
distance_point_tuples = car.calculate_distances(map)
for distance, point in distance_point_tuples:
print(f"Distance: {distance}")
distance_vec.append(distance)
if distance < 10:
# COLISION!
car = Car(6 * scale, 5 * scale)
pygame.draw.circle(self.screen, [255, 0, 0],
[int(el) for el in point], 5)
rotated = pygame.transform.rotate(car_image, car.angle)
rect = rotated.get_rect()
self.screen.blit(rotated,
car.position - (rect.width / 2, rect.height / 2))
pygame.display.flip()
# User input
pressed = pygame.key.get_pressed()
choice = agent.get_choice(np.array(distance_vec).reshape(1, -1))
if choice == 1:
car.angle = (car.angle - 2) % 360
elif choice == 0:
car.angle = (car.angle + 2) % 360
self.clock.tick(self.ticks)
pygame.quit()
def testSimple(self):
map = Map(MapDirectory(self.testdatadir), maptype=MapTypeImage)
map.open('r')
poigroup = map.getPOIGroup()
poigroup.open('r')
f = poigroup.getFeatureByIndex(0)
aux = f.getAuxAsDict(poigroup)
print f, aux
def main():
print ("Main called")
c1 = Coordinate(0,0,0)
c2 = Coordinate(10,10,10)
m = Map()
print ("begin mapping")
carl = m.map_1D_space(c1,c2,5)
print ("endin mapping")
for index, item in enumerate(carl):
print (''+str(index)+' '+str(item.coordinate.x)+' '+str(item.coordinate.y)+' '+str(item.coordinate.z))
def __init__(self):
global PIXEL
pygame.init()
self.__map = Map()
self.__dim = self.__map.getDimensions
self.__canvas = pygame.display.set_mode(
[self.__dim[0] * PIXEL, self.__dim[1] * PIXEL])
self.__beings = list()
self.__reloj = pygame.time.Clock()
pygame.display.set_caption('Artificial Intelligence')
def testSimple(self):
map = Map(MapDirectory(self.testdatadir), maptype=MapTypeImage)
map.open("r")
poigroup = map.getPOIGroup()
poigroup.open("r")
f = poigroup.getFeatureByIndex(0)
aux = f.getAuxAsDict(poigroup)
print f, aux
def buttonGenerateCircle(self):
self.contenueVille = self.nbreVille.get()
#Map creation
self.actualMap = Map(int(self.contenueVille,base=10),500,0)
tab = self.actualMap.creatMapCircle()
self.canvas.delete("all")
self.canvas.create_rectangle(0, 0, 500, 500, fill='dark slate grey')
for i in range(len(tab)):
self.placePoint(tab[i][0],tab[i][1])
def setup(self):
## Создаем карту
self.game_map = Map(1000, 1000, 1000, 1000, self)
self.mul = Multiplayer(self.game_map)
## Создаем игрока
self.game_map.spawnPlayer("player.png", self.nickname, 50)
self.calc_thread = Thread(target=self.game_map.update)
self.gui_thread = Thread(target=self.GUI)
self.calc_thread.start()
self.gui_thread.start()
def corners_from_bounds(p1, p2, sides, center, radius, width, depth):
corner_vectors = []
lines = []
for i in range(0, sides):
v1 = vg.point_along_circle(center, radius, sides, i, Map(align_to_cells=True, width=width, depth=depth, p1=p1, p2=p2))
v2 = vg.point_along_circle(center, radius, sides, i+1, Map(align_to_cells=True, width=width, depth=depth, p1=p1, p2=p2))
corner_vectors.append(v1)
lines.append((v1, v2))
return corner_vectors, lines
def __init__(self, zones, options=Map()):
self.style = options.style
self.buildings = []
self.zones = []
for part in zones:
self.zones.append(part)
p1 = vg.up(part.p1, 1)
p2 = vg.up(part.p2, 1)
p1, p2 = vg.rectangle_inner(p1, p2, 1)
self.buildings.append(Building(False, Map(p1=p1, p2=p2)))
def mutationDynamique(Map,tabBestPath):
average = 0
minimum = Map.pathLength(tabBestPath[0])
for i in tabBestPath:
average += Map.pathLength(i)
average = average/len(tabBestPath)
p = (1 - ((average - minimum)/minimum))**5
return p
def main():
contam = [[0, 5, 0], [1, 2, 3]]
map1 = Map(contam)
r1 = Robot("bob", 3, 300)
r1.set_base(0, 2)
map1.add_base(0, 2)
r1.find_goal(map1)
print(repr(r1))
r1.find_goal(map1)
print(map1)
print(r1.is_contaminated_spots_left(map1))
class Scene_Level(Scene):
def __init__(self, game):
Scene.__init__(self, game)
def init(self):
self.scrollablePosition = [0, 0]
self.scrollableSize = [480, 240]
self.map = Map(self.game, 'map.tmx')
self.game.map = self.map
self.scrollableLayer = ScrollableLayer(self.game,
self.scrollablePosition,
self.scrollableSize, [0, 0],
self.map.size)
self.game.scrollableLayer = self.scrollableLayer
self.units = []
self.units.append(Unit(self.game, [96, 64]))
self.units.append(Unit(self.game, [96, 96]))
self.units.append(Unit(self.game, [96, 128]))
self.units.append(Unit(self.game, [96, 160]))
self.ui = UI(self.game)
def endTurn(self):
for unit in self.units:
unit.endTurn()
def update(self, deltaTime, events):
scrollSpeed = 32 * deltaTime
keys = pygame.key.get_pressed()
if keys[pygame.K_UP] or self.game.cursor.bounds['top']:
self.scrollableLayer.changeOffsetBy([0, 1 * scrollSpeed])
if keys[pygame.K_DOWN] or self.game.cursor.bounds['bottom']:
self.scrollableLayer.changeOffsetBy([0, -1 * scrollSpeed])
if keys[pygame.K_LEFT] or self.game.cursor.bounds['left']:
self.scrollableLayer.changeOffsetBy([1 * scrollSpeed, 0])
if keys[pygame.K_RIGHT] or self.game.cursor.bounds['right']:
self.scrollableLayer.changeOffsetBy([-1 * scrollSpeed, 0])
for event in events:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.endTurn()
self.map.update(deltaTime, events)
for unit in self.units:
unit.update(deltaTime, events)
self.scrollableLayer.update(deltaTime, events)
self.ui.update(deltaTime, events)
def draw(self, screen):
self.map.draw(self.scrollableLayer.virtualSurface)
for unit in self.units:
unit.draw(self.scrollableLayer.virtualSurface)
self.scrollableLayer.draw(screen)
self.ui.draw(screen)
def init():
variables.append(
Map(var="roof_triangular_sloped",
choices=[-2, -1, -.5, -.25, 0, 0, 0, .25, .5, 1, 2]))
variables.append(Map(var="roof_triangular_stairs", choices=[True, False]))
variables.append(
Map(var="roof_triangular_end_cap_out", choices=[0, 1, 2, 2, 3]))
variables.append(
Map(var="roof_triangular_overhang", choices=[0, 0, 0, 1, 2]))
variables.append(Map(var="roof_triangular_chop_pct",
choices=[0])) # , 0, 0, 0, 0, .1, .2, .3, .4, .5]))
def test_25_Colours(self):
inp = Map("images/25colours.ppm")
# Currently being run with your solution... But this
# will be replaced with a call to mine.
findPath(inp, all_colour_speed)
# Outputs both the path and gradient along it.
# Uncomment these out if you want to use them
inp.outputPath()
def map_print(temp_map: Map, id):
keys = temp_map.getKeys()
values = temp_map.getValues()
release_parser.messages.append(("Displaying Map " + str(id)))
for i in range(0, keys.size()):
key = keys.get(i)
value = values.get(i)
release_parser.messages.append((str(key) + ', ' + str(value)))
return
def main():
graph = read_stations(FILE_NAME)
map = Map(graph)
start = get_user_selection(
graph, prompt="Please enter the name of your starting station:")
end = get_user_selection(
graph, prompt="Please enter the name of your ending station:")
p = map.get_path(start, end)
print_itinerary(p)
def terminalVersion():
"""
Game in terminal.
"""
# --- New game or load a save
choice = askQuestion("Menu:", ["New game", "Load game"])
if choice == 0:
# New game
objMap = Map(listMap("%s%smap%s" % (rootDir, os.sep, os.sep)))
# Select difficulty
difficulty = askQuestion("Select the difficulty:", [
"Easy: slow ghost.", "Medium: slow ghost, mode predator ON.",
"Hard: fast ghost, mode predator ON.",
"Nightmare: fast ghost, mode boosted predator ON, 1 life, no bonus life.",
"Doom: run."
])
setDifficulty(difficulty)
elif choice == 1:
# Load game
objMap = Map(listMap("%s%ssave%s" % (rootDir, os.sep, os.sep)))
# --- Initiate threads and the wx app
lock = threading.Lock()
queue = Queue.Queue(5)
objApp = wx.PySimpleApp()
objUI = UI(1, "Thread-UI", queue, lock, UAG.PacmanDelay)
objCatcher = UICatcher(2, "Thread-UICatcher", objApp, objUI)
objGhostAI = GhostAI(3, "Thread-Ghost", queue, lock, UAG.GhostSpeed,
len(objMap.dGhostSpawns))
lThreads = [objUI, objCatcher, objGhostAI]
print "[PacmanGame] Initiate threads"
for t in lThreads:
print "\t%s" % t.threadName
t.start()
# --- Initiate game
game = PacmanGame(objMap,
queue,
lock,
UAG.PacmanDelay,
objUI=objUI,
objGhostAI=objGhostAI)
game.run()
# --- Wait for all threads to terminate before leaving
print "[PacmanGame] Wait all threads before leaving"
for t in lThreads:
print "\t%s" % t.threadName
t.join()
def __init__(self,
particles: int,
rows: int,
columns: int,
sick_proportion: float = 0.05,
movement_type=MovementType.FREE,
cure=True):
self.map = Map(columns, rows)
self.map.remove_wall()
if movement_type != MovementType.HALF:
self.particles: List[Person] = [
Person(random.randint(1, rows),
random.randint(1, columns),
healthy=True,
impact_radius=2,
disease_impat_probability=0.6,
disease_cure_expected_days=20,
probability_of_curing=0.8,
movement_type=movement_type,
cure=cure) for x in range(particles)
]
else:
print('movement is half')
self.particles: List[Person] = [
Person(random.randint(1, rows),
random.randint(1, columns),
healthy=True,
impact_radius=2,
disease_impat_probability=0.6,
disease_cure_expected_days=20,
probability_of_curing=0.8,
movement_type=MovementType.FREE,
cure=cure) for x in range(particles // 2)
] + [
Person(random.randint(1, rows),
random.randint(1, columns),
healthy=True,
impact_radius=2,
disease_impat_probability=0.6,
disease_cure_expected_days=20,
probability_of_curing=0.8,
movement_type=MovementType.STILL,
cure=cure) for x in range(particles // 2)
]
sick_count = ceil(len(self.particles) * sick_proportion)
print('sick count', sick_count)
for i in range(sick_count):
particle = random.choice(self.particles)
particle.set_sick()
def __init__(self):
self.map = Map()
# スタート時のprinceの位置座標の取得
prince_location = [(room.x, room.y) for floor_y in self.map.floor
for room in floor_y if room.prince]
self.prince_location_x = prince_location[0][0]
self.prince_location_y = prince_location[0][1]
# スタート時のroomObjの参照
self.room = self.map.room(self.prince_location_x,
self.prince_location_y)
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.MAP_WIDTH = Map().width
self.MAP_HEIGHT = Map().height
self.image = self.__loadImage()
self.rect = self.image.get_rect()
self.rect.centerx = random.randrange(self.MAP_WIDTH - self.rect.width)
self.rect.centery = random.randrange(-100, -40)
self.speedy = random.randrange(1, 7)
self.speedx = random.randrange(-3, 3)
class Player:
def __init__(self, connection, mapSize, encode):
self.connection = connection
self.map = Map(mapSize)
self.enemyMap = Map(mapSize)
self.score = 0
self.encode = encode
def __str__(self):
string = ""
string += "Seu status:\n"
string += "Score: %d\n" % (self.score)
string += "Seu mapa:\t\t\t\t\tMapa adversário:"
ownMap = str(self.map).split('\n')
enemyMap = str(self.enemyMap).split('\n')
for i in range(len(ownMap)):
string += ownMap[i] + "\t\t\t\t" + enemyMap[i] + "\n"
return string
def sendMessage(self, message):
time.sleep(0.05)
self.connection.sendall(bytes(message, self.encode))
def receiveMessage(self):
return self.connection.recv(64).decode(self.encode)
def place(self, lin, col):
return self.map.place(lin, col)
def fire(self, lin, col):
return self.map.fire(lin, col)
def updateEnemyMap(self, lin, col, char):
self.enemyMap.updateMap(lin, col, char)
def printMap(self):
return self.map.__str__()
def getMap(self):
return self.map
def getEnemyMap(self):
return self.enemyMap
def updateScore(self):
self.score += 1
def getScore(self):
return self.score
def closeConnection(self):
self.connection.close()
class Room:
def __init__(self, window):
self.window = window
self.objects = {"M": [], "G": [], "D": [], "I": [], "C": []}
self.monster_count = random.randint(0, 3)
self.item_count = random.randint(0, 2)
self.actual_map = Map()
self.actual_stage = 0
def loading_map(self):
self.objects = {"M": [], "G": [], "D": [], "I": [], "C": []}
self.actual_map.random_map()
# Rendering the map
for key, line in enumerate(self.actual_map.tile):
for key1, letter in enumerate(line):
if letter == "G":
new_wall = Wall(self.window)
new_wall.hit_box[0] = new_wall.hit_box[0] * key1
new_wall.hit_box[1] = new_wall.hit_box[1] * key
self.objects[letter].append(new_wall)
elif letter == "M":
new_monster = Monster(self.window)
if self.actual_stage == 5:
new_monster.set_to_boss()
new_monster.hit_box[0] = new_monster.hit_box[0] * key1
new_monster.hit_box[1] = new_monster.hit_box[1] * key
self.objects[letter].append(new_monster)
elif letter == "I":
new_item = random.choice(
[HealthPotion(self.window),
ManaPotion(self.window)])
new_item.hit_box[0] = new_item.hit_box[0] * key1
new_item.hit_box[1] = new_item.hit_box[1] * key
self.objects[letter].append(new_item)
elif letter == "D":
new_door = Door(self.window)
new_door.hit_box[0] = new_door.hit_box[0] * key1
new_door.hit_box[1] = new_door.hit_box[1] * key
self.objects[letter].append(new_door)
elif letter == "C":
new_button = Button(self.window)
new_button.hit_box[0] = new_button.hit_box[0] * key1
new_button.hit_box[1] = new_button.hit_box[1] * key
self.objects[letter].append(new_button)
self.render()
def render(self):
for obj in self.objects.values():
for obj1 in obj:
obj1.render()
def testCategories(self):
map = Map(MapDirectory(self.testdatadir), maptype=MapTypeImage)
map.open('a')
poigroup = map.getPOIGroup()
poigroup.open('a')
catman = poigroup.getCategoryManager()
print catman.getCategories()
poigroup.close()
def reset(self):
self.world_ = Map(self.width_, self.length_, self.n_apples_,
self.render_)
self.snake_x0_ = 1 + np.random.randint(self.length_ - 2)
self.snake_y0_ = 1 + np.random.randint(self.width_ - 2)
self.direction_ = direction(np.random.randint(4))
self.snake_ = Snake(self.snake_x0_, self.snake_y0_, self.direction_)
self.world_.update(self.snake_)
self.score_ = 0
s = State(self.snake_, self.world_)
s_array = np.concatenate((s.to_array(), [self.snake_.length_],
directionToArray(self.snake_.direction_)))
return s_array
def loadData(self):
if self.isATest:
self.map = Map(self, "../Maps/testMap.txt")
else:
biggerMapPlanList = [
"../Maps/24x24Maps/map1.txt", "../Maps/24x24Maps/map2.txt"
]
smallerMapPlanList = ["../Maps/16x16Maps/map1.txt"]
if settings.mapIsBig:
self.mapPlan = random.choice(biggerMapPlanList)
else:
self.mapPlan = random.choice(smallerMapPlanList)
self.map = Map(self, self.mapPlan)
def __init__(self):
self.pathCalcComplete = 0
self.isMowerPlaced = 0
self.isStationPlaced = 0
self.state = 0
self.bladesOn = 0
self.mowOffset = 30
self.posX = 0
self.posY = 0
self.stationPosX = 0
self.stationPosY = 0
self.lawn = Map(self.mowOffset)
self.path = Pathfinder()
def testCategories(self):
map = Map(MapDirectory(self.testdatadir), maptype=MapTypeImage)
map.open("a")
poigroup = map.getPOIGroup()
poigroup.open("a")
catman = poigroup.getCategoryManager()
print catman.getCategories()
poigroup.close()
def api_taks(id=-1):
if request.method == 'GET':
map = Map.get_by_id(id)
if map is None:
return json_success({})
else:
return json_success(map.Get())
if request.method == 'DELETE':
map = Map.get_by_id(id)
if map is None:
return json_response(code=400, message="Map does not exist")
map.Delete()
return json_response(code=200,message="Success")
def api_taks(id=-1):
if request.method == 'GET':
map = Map.get_by_id(id)
if map is None:
return json_success({})
else:
return json_success(map.Get())
if request.method == 'DELETE':
map = Map.get_by_id(id)
if map is None:
return json_response(code=400, message="Map does not exist")
map.Delete()
return json_response(code=200, message="Success")
def decorate_roof(obj, options=Map()):
settings = options.options
if not settings.roof:
return obj
material = Blocks.match(settings.roof_material)
if material:
obj.material = material
if str.startswith(settings.roof, "pointy"):
height = settings.roof_pointy_multiplier * options.radius
pointy = V3(options.center.x,
options.center.y + options.height + height,
options.center.z)
for i, vec in enumerate(options.corner_vectors):
roof_line = vg.getLine(vec.x, vec.y + 1, vec.z, pointy.x,
pointy.y + 1, pointy.z)
obj.points_edges += roof_line
if not settings.roof == "pointy_lines":
next_roof_point = options.corner_vectors[(i + 1) % len(
options.corner_vectors)]
# Triangle to pointy face
triangle_face = [vec, pointy, next_roof_point]
roof_face = vg.unique_points(
vg.getFace([V3(v.x, v.y + 1, v.z) for v in triangle_face]))
obj.points = obj.points.union(roof_face)
elif str.startswith(settings.roof, "triangular"):
obj.decorations.append("roof_triangular")
elif str.startswith(settings.roof, "battlement"):
height = settings.roof_battlement_height or 1
spacing = settings.roof_battlement_space or 2
for i, vec in enumerate(options.corner_vectors):
next_roof_point = options.corner_vectors[(i + 1) % len(
options.corner_vectors)]
# TODO: Add X,Z outward from center as option
roof_line = vg.getLine(vec.x, vec.y + height, vec.z,
next_roof_point.x,
next_roof_point.y + height,
next_roof_point.z)
obj.points = obj.points.union(
vg.points_spaced(roof_line, Map(every=spacing)))
elif str.startswith(settings.roof, "shape"):
obj.decorations.append("roof_floating_shape")
return obj
class Game(object):
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((800, 608))
self.StartGame()
def StartGame(self):
self.done = False
self.map = Map("Map.txt")
self.map.Load()
self.player = Player(4 * 32, 3 * 32, (400, 304))
self.starttime = time.time()
self.lasttime = time.time()
def GameLoop(self):
while not self.done:
self.starttime = time.time()
self.screen.fill((0, 0, 0))
events = pygame.event.get()
## setup something to do when quests are done
self.done = self.player.done
# events list
for e in events:
if e.type == pygame.QUIT:
self.done = True
if e.type == pygame.KEYDOWN:
if (e.key == pygame.K_RIGHT):
self.player.Movex(32)
if (e.key == pygame.K_LEFT):
self.player.Movex(-32)
if (e.key == pygame.K_DOWN):
self.player.Movey(32)
if (e.key == pygame.K_UP):
self.player.Movey(-32)
self.map.CheckHit(self.player)
self.map.Update(self.starttime - self.lasttime)
self.player.Update(self.starttime - self.lasttime)
## not done
self.map.Render(self.screen,
(400 - self.player.x, 304 - self.player.y))
self.player.Render(self.screen)
# Update Screen
pygame.display.flip()
self.lasttime = self.starttime
def EndGame(self):
pygame.display.quit()
def loadMap(self, filename):
with open(filename, "r") as map_file:
parts = map_file.readline().split(",")
width = int(parts[0])
height = int(parts[1])
m = Map(width, height)
r = 0
for line in map_file:
row = [TileTypes()[t] for t in line.strip('\n').split(",")]
m.set_row(r, row)
r = r + 1
return m
def api_map():
if request.method == 'POST':
userName = request.args.get("username","")
mapName = request.args.get("mapname","")
userId = request.args.get("userId","")
userId = str(userId.encode('utf-8').decode('ascii', 'ignore'))
uid = int(userId)
ownMap =Map(creator=userName,creatorId=uid,name=mapName)
key = ownMap.put()
return json_success({"mapId":key.integer_id()})
if request.method == 'GET':
id = request.args.get("id","")
ownMap = Map.get_by_id(int(id))
return json_success({"creator":ownMap.creator,"name":ownMap.name,"creatorId":ownMap.creatorId,"id":int(id)})
def __init__(self): pygame.init() #self.screen = pygame.display.set_mode((1024, 768), pygame.FULLSCREEN) self.screen = pygame.display.set_mode(bounds) self.clock = pygame.time.Clock() self.state = JOIN mapRect = pygame.Rect(0, 0, bounds[0], bounds[1]) self.map = Map(mapRect) self.quit = False UDP_IP = "0.0.0.0" UDP_PORT = 5005 self.sock = socket.socket(socket.AF_INET, # Internet socket.SOCK_DGRAM) # UDP self.sock.settimeout(.1) self.sock.bind((UDP_IP, UDP_PORT)) pygame.mouse.set_visible(False) self.joinPage = JoinPage(bounds) self.mutex = Lock() t = Thread(target = Game.netThread, args = (self,)) t.start() self.countDown()
def favorite_mapsForUser(userid = -1): if userid <= 0: return json_response(code=400) user = Account.get_by_id(userid) if user is None: return json_response(code=400) if request.method == 'GET': # done # GET: returns json array of information about user's map objects return json_success(user.getFavorites()) mapid = getValue(request, "mapid", "") if not mapid: return json_response(code=400) map = Map.get_by_id(int(mapid)) if map is None: return json_response(code=400) if request.method == 'POST': if not map.key.integer_id() in user.favoriteMaps: user.favoriteMaps.append(map.key.integer_id()) user.put() return json_response(code=200) if request.method == 'DELETE': if map.key.integer_id() in user.favoriteMaps: user.favoriteMaps.remove(map.key.integer_id()) user.put() return json_response(code=200)
def __init__(self, mapdict):
self.mapdef = mapdict
self.cellmap = Map(mapdict)
self.gemgos = []
for gemgo in MGO.GEMGOTYPES:
self.gemgos += gemgo.place(self.cellmap)
def mapData(mapid = -1):
if mapid <= 0:
return json_response(code=400)
map = Map.get_by_id(mapid)
if map is None:
return json_response(code=400)
if request.method == 'GET': # done
# returns json map info
return json_success(map.Get())
if request.method == 'DELETE': #todo
# DELETE: used to delete a map object and all associated tak objects, parameters: none
map.Delete()
return json_response(code=200,message="Success")
if request.method == 'PUT': #todo
#PUT: used to update map in database, parameters: (any map parameter)
# return json map object
newName = request.args.get("name","")
newIsPublic = request.args.get("isPublic","")
newOwner = request.args.get("owner","")
map.Put(newName=newName,newIsPublic=newIsPublic,newOwner=newOwner)
return json_response(code=200,message="Success")
def __init__(self):
self.map = Map()
self.numUnits = 1
self.numPlayers = 1
self.playerIndex = -1
self.turn = 1
self.players = []
def __init__(self, host, port, name):
"""
Initialize a client for interacting with the game.
host -- The hostname of the server to connect
(e.g. "example.com")
port -- The port to connect on (e.g. 6969)
name -- Unique name of the client connecting
"""
self.host = host
self.port = port
self.name = name
self.sock = None
self.token = ""
self.resources = 0
self.ships = []
self.my_map = Map(100, 100)
self.attack_report = []
self.strat = BomberStrategy(0,0,100,100)
self.defense = RunOnDetection(self.ships)
self.enemypdf = EnemyPDF()
self.danger_grid = DangerGrid()
self.last_scan = (0,0)
self.last_special = None
self.attack_queue = []
self.burst_queue = []
# data for replay attacks
self.replay_rate = 0.03
self.replay_stack = ReplayStack(10)
self.replay_check_list = []
def run(self):
newMap = None
if self.fileName:
try:
newMap = Map.readFromFile(self.fileName)
except Exception as e:
self.mapGenerationFailed.emit(e)
return
else:
try:
newMap = Map.generateCNN(self.citiesCount, self.connectionsCount)
except Exception as e:
self.mapGenerationFailed.emit(e)
return
self.mapGenerated.emit(newMap)
def download_map(self, filename):
"""
Download a map.
@param filename Name of the map.
@return Map object on success, None on error.
"""
# [0]filename, [1]title, [2]filesize, [3]map_data
map_data = self.database.do_query(Procedures.get_map(), filename);
map = Map(self.reporter);
try:
if not map.read_map(map_data[0][3]):
raise Exception, "Unknown corruption error." % filename;
except Exception, e:
self.report("Map file %s is corrupted (%s). Discarding." % (filename, str(e)));
Log.quick_log("The map %s is corrupted: %s." % (filename, str(e)));
return None;
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.trans = None # Per mantenir l'estructura del fitxer de transport en memoria
self.stOrigen = None
self.stDesti = None
self.a = None
self.cami = None
self.ui = uic.loadUi('transPublic.ui')
#Preparem el Frame del mapa i el posem al form
self.mF = Map(self,None)
lay = QtGui.QGridLayout()
lay.addWidget(self.mF)
self.ui.mapGruopBox.setLayout(lay)
self.connect(self.ui.menuOpen, QtCore.SIGNAL("activated()"), self.openFile)
self.connect(self.ui.cbOrigen, QtCore.SIGNAL("activated(QString)"), self.cbOrigen_changed)
self.connect(self.ui.cbDesti, QtCore.SIGNAL("activated(QString)"), self.cbDesti_changed)
self.connect(self.ui.pbCalcula, QtCore.SIGNAL("clicked()"), self.calcula)
self.ui.show()
def __init__(self):
#GLOBAL CONSTS
self.GAME_WIDTH = 600
self.GAME_HEIGHT = 500
self.clock = pygame.time.Clock()
self.frame = 0
self.logicFrame = 0
self.mouseX = 0
self.mouseY = 0
self.cameraX = int(self.GAME_WIDTH / 2)
self.cameraY = int(self.GAME_HEIGHT / 2)
self.running = True
self.debug = True
self.map = Map(self)
self.heldKeys = dict()
self.checkedKeys = dict()
self.root = pygame.display.set_mode((self.GAME_WIDTH, self.GAME_HEIGHT), pygame.DOUBLEBUF)
self.player = Player(self)
self._keySetup()
#temp
self.map.mapArray[0][0].addEntity(self.player)
self.player.x = 100
self.player.y = 100
while self.running:
self.displayLoop()
self.quit()
def maps(): userMaps = getMaps(session['userId']) listOfMaps = [] for mapId in userMaps: logging.info(mapId) aMap = Map.get_by_id(mapId) listOfMaps.append(aMap.to_dict()) return json_success(listOfMaps)
def taks(mapId=-1, str=''):
if mapId == -1:
return redirect('/app')
map = Map.get_by_id(mapId)
if map is None:
return redirect('/app')
taks = map.to_dict()['taks']
return render_template('view_taks.html',taks = taks, mapName=map.name, mapid=map.key.integer_id(), id=int(session['userId']))
def load_map(self, map_url):
real_url = os.path.join("..", "assets", "world", map_url)
self.map = Map(real_url, self.text_box)
if self.map.starting_location:
self.player.teleport(self.map.starting_location)
self.view = pygame.Surface(self.map.map_size)
self.cam_offset_x = self.player.sprite_rect.left
self.cam_offset_y = self.player.sprite_rect.top
def generate_map(size, obstacle_rate = 0.4): map_matrix = Map() map_matrix.set_size(size) map_matrix.set_obstacle_rate(obstacle_rate) map_matrix.generate_map() return map_matrix
def _update_map(self, m):
if m.name is None:
# Data is not yet loaded
return
m.layers.get()
sp = HorizontalPanel(Size=('100%', '100%'))
sidebar = Sidebar()
sidebar.setLayersCollection(m.layers)
sp.add(sidebar)
sp.setCellWidth(sidebar, '25%')
map_ = Map(Size=('100%', '100%'))
map_.set_map(m)
sp.add(map_)
self.setWidget(sp)
def init(self):
"""Método para iniciar o jogo completo"""
#inicia a janela 'invisível'
self.screen = pygame.display.set_mode((1,1),NOFRAME,32)
#cria uma instancia para o mapa
self.map = Map(self.screen)
pygame.display.set_icon(self.map._getGraf('!'))
#cria personagem
self.person = Character(self.map,self.screen)
#incia mapa self.fase
self.mapInit()
#Comeca o jogo
self.screen = self.update()
#laço principal do jogo
while True:
for event in pygame.event.get():
if event.type == QUIT:
self.exit()
if event.type == KEYDOWN:
#movimentos do personagem
if event.key == K_UP: #cima
self.win,s = self.person.up()
self.pushPilha(s)
elif event.key == K_DOWN: #baixo
self.win,s = self.person.down()
self.pushPilha(s)
elif event.key == K_LEFT: #esquerda
self.win,s = self.person.left()
self.pushPilha(s)
elif event.key == K_RIGHT: #direita
self.win,s = self.person.right()
self.pushPilha(s)
elif event.key == K_w: #ganha
self.win = True
elif event.key == K_r: #reincia o mapa
self.mapInit()
self.screen = self.update()
elif event.key == K_z and pygame.key.get_mods() & KMOD_CTRL: #ctrl + z
self.desfazer()
self.screen = self.update()
pygame.display.flip()
if self.win:
self.fase = (self.fase+1) % 16
self.mapInit()
self.screen = self.update()
def create_score_array(self, terrain_map, height, width):
score_array = [None] * (height * width)
# Set scores of non traversable tiles to NON_TRAVERSABLE_SCORE
for x in range(width):
for y in range(height):
p = Point(x, y)
ndx = Map.point_to_index(p, width, height)
t_tile = terrain_map.map[ndx]
if not t_tile.is_traversable():
score_array[ndx] = ScoreTile(NON_TRAVERSABLE_SCORE, [])
return score_array
class GameScene(Scene):
def _start(self):
self.map = Map("firstMap.map")
self.map.start(self.display)
def _draw(self, dt):
self.display.fill((255,255,255))
self.map.draw()
def _event(self, event):
self.map.event(event)
def _update(self, dt):
self.map.update(dt)
#Класс редактора карт
def get_all_traversable_states(self):
states = []
for x in range(self.width):
for y in range(self.height):
pnt = Point(x, y)
ndx = Map.point_to_index(pnt, self.width, self.height)
terrain = self.map[ndx]
if terrain.is_traversable():
for dir in Directions:
state = State(pnt, dir)
states.append(state)
return states
