def __init__(self, map_name):
# Local copy of Player
self._players = {}
self._map = Map(map_name)
self._player_height = 20
self._player_width = 10
self._player_color = 'red'
def _create_game(self, num_of_players, clients):
start_positions = {2: [], 3: [], 4: []}
for key, arr in start_positions.items():
arr.extend([int(i * (MAP_W / key)) for i in range(key)])
game_map = Map(MAP_W, MAP_H, True)
game = {
'clients': [],
'positions': start_positions[num_of_players],
'positions_y': [],
'mutex': Lock(),
'num_of_players': num_of_players,
'collision_map': game_map.collision_noise,
'health': [100 for x in range(num_of_players)],
'last_explode_time': 0.0,
'map': game_map,
'clock': 0.0,
'finished': False,
'turn': 0
}
for client in clients:
game['clients'].append(client)
join_game_req = {
'action':
REQUEST.JOIN_GAME,
'map':
zlib.compress(bson.dumps({'data': game['collision_map']}), 7),
'tank_id':
clients.index(client),
'start_x':
start_positions[num_of_players]
}
client.send(bson.dumps(join_game_req))
game['map'].create_map(game['collision_map'])
client_invalid_request = False
for client in clients:
data = client.recv()
if data['action'] != REQUEST.JOIN_GAME:
client_invalid_request = True
for pos_x in game['positions']:
game['positions_y'].append(game['map'].get_height(pos_x))
if client_invalid_request:
for client in clients:
self.clients_lock.acquire()
self.clients.remove(client)
self.clients_lock.release()
client.close()
return
self.games.append(game)
for x in range(num_of_players):
self.game_players[clients[x]] = self.games[len(self.games) - 1]
self._send_change_turn_req(game)
def parse_map(json_object: dict) -> Map:
res = Map()
m = json_object["map"]
MapLoader.parse_nodes(res, m["nodes"])
MapLoader.parse_paths(res, m["paths"])
return res
def __init__(self,interface, socket_to_server):
self.isharvest = False
self.isfighting = False
self.spells = Spells(interface)
self.map = Map(interface)
self.interface = interface
self.socket_to_server = socket_to_server
self.deplacement = Deplacement(self.socket_to_server)
self.entity = None
def main():
game_map = Map(15, 15)
while True:
game_map.draw()
game_map.next_move()
c = raw_input()
if c == "x":
break
def loadLevel(self, file):
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( False )
if file in self.loaded_maps:
self.current_map = self.loaded_maps[file]
self.current_map.reset()
else:
self.current_map = Map(file, self.screen, self)
self.loaded_maps[file] = self.current_map
self.current_map.intialize()
def _load_map(self, screen):
"""
Load the map
:param screen: pygame.Screen object
"""
# Wait for map to be loaded on blind and sent here
while not self.server.map:
self.server.listen()
map_path = self.server.map
# Load the map
self.map = Map(self, screen, map_path, self.server.map_timer)
self.map.draw_static_sprites()
super(GameGuide, self)._load_map(screen)
def _load_map(self, screen):
"""
Search for the map in the ./map/map_order.xml file and load it in the game.
Then we send the map to the guide
:param screen: .Screen object
"""
if not self.map_path:
map_name = self.search_map()
self.map_path = "../map/%s" % map_name
self.client.send_new_map(self.map_path, self.get_map_timer())
# Load the map
self.map = Map(self,
screen,
self.map_path,
self.get_map_timer(),
blind=True)
self.map.draw_static_sprites()
super(GameBlind, self)._load_map(screen)
def __init__(self):
SCREEN_WIDTH, SCREEN_HEIGHT = 96, 54
VIEW_WIDTH, VIEW_HEIGHT = 70, 36
self.gamestate = Gamestates.PLAYER_ROUND
self.map = Map(96, 54)
xo, yo = self.map.generate_map(6, 10, 30)
# Systems
self.input = InputHandler()
self.camera = CameraSystem(xo, yo, VIEW_WIDTH, VIEW_HEIGHT, 2)
self.window = GameWindow(SCREEN_WIDTH, SCREEN_HEIGHT, VIEW_WIDTH,
VIEW_HEIGHT)
self.render = RenderSystem(self.window.map_con)
self.ai = RandomAI()
self.fov = FOVSystem()
self.movement = BasicMovementSystem()
self.cmd = CommandHandler(self)
self.update_observers()
self.current_control_index = 0
def load_in_to_class(self):
'''
DataFrame:
'''
self.dataSource = {}
connection = dataSource.Database().get_connection()
cursor = connection.cursor(dictionary=True)
try:
cursor.execute('SELECT * FROM maps;')
data = cursor.fetchall()
for result in data:
try:
mapData = Map(
result['id'],
result['date'],
result['width'],
result['heigth'],
result['key'],
result['places'],
result['mapData'],
result['cells'],
result['monsters'],
result['mappos'],
result['numgroup'],
result['fixSize'],
result['minSize'],
result['maxSize'],
result['cases'],
result['forbidden'],
)
self.dataSource[result['id']] = mapData
except Exception as Error:
self.log.warning(
'maps_data.py - maps:{} can\'t be loaded'.format(
str(result['id'])))
self.log.warning(Error)
except Exception as Error:
self.log.warning('map_data.py - Can\'t load table accounts')
self.log.warning(str(Error))
finally:
cursor.close()
connection.close()
def connect(self):
# Try until the connection is up
connected = False
while not connected:
try:
requests.get(self._url)
connected = True
except:
pass
print(f'Connected to {self._url}')
# Kick all other players
#self.post('kick_all')
response_json = self.post('add_player')
# return {'rez': 'success', 'map_name': self._map.map_name, 'new_name': player_name}
self._name = response_json['new_name']
self._map = Map(response_json['map_name'])
print(f'Name is {self._name}')
print(f'Playing on map {self._map.map_name}')
def handle(self, max_lat, max_lng, seed, points, hill_noise, heights_map_width,
*args, **options):
if seed is None:
seed = int(random.random() * 10000)
print('seed = %s' % seed)
map_obj = Map(seed, [
generators.points.RelaxedPoints(points_number=points).generate,
generators.graph.VoronoiGraph().generate,
generators.graph.VoronoiGraph().imporove_corners,
generators.land.SimplexIsland().generate,
generators.elevation.FromCoast().generate,
generators.rivers.RandomRiver().generate,
generators.biomes.Moisture().generate,
generators.regions.HexGrid().generate,
exports.ModelExporter(
Biome, River, Region, City, max_lat=max_lat, max_lng=max_lng).export,
exports.GeoTiffExporter(max_lat, max_lng, heights_map_width, hill_noise).export,
# renderers.RegionRenderer().render,
])
map_obj.generate()
def __init__(self):
self.runDisplay = Display("mapaReducido.tmx")
self.win = self.runDisplay.displayWindow
self.map = Map(self.runDisplay.map.gameMap.tilewidth,
self.runDisplay.map.gameMap.tileheight,
self.runDisplay.map.walkableTiles,
self.runDisplay.map.zones)
self.peoples = [
Worker(5, 2, self.map),
Worker(10, 4, self.map),
Worker(6, 4, self.map),
Worker(1, 4, self.map),
Customer(36, 2, self.map),
Customer(37, 2, self.map),
Customer(36, 3, self.map)
]
#self.peoples = [Worker(5,2,self.map)]
self.tasks = deque([])
self.objects = deque([])
self.tasks_doing = deque([])
def __init__(self):
super(MapLoaderHandler, self).__init__()
self.map = Map()
def get_map_test_1():
locations = generate_random_sample(CIDADES_ALAGOAS,
**COORDINATES_MAP_TEST_1)
return Map(locations, **COORDINATES_MAP_TEST_1)
#! -*- coding: utf-8 -*-
'''
Created on Jan 25, 2018
@author: Jesús Molina
'''
from tittleScreen.tittleScreen import TittleScreen
from map.map import Map
if __name__ == '__main__':
tittle = TittleScreen()
tittle.startScreen()
myMap = Map()
myMap.generateMap()
from terrain.terrain_type import * from characters.soldier import Soldier from characters.jedi import Jedi from characters.clan import Clan from army.army import Army from map.map import Map from map.field import * from characters.character_type import CharacterType from army.army_deploy import ArmyDeploy m = Map(400, 400) m.assign_type(TerrainType.FOREST) # print(m) deploy = ArmyDeploy.DOWN_DIAGONAL rsize = 5000 bsize = 1000 a = Army(Clan.BLUE) a.army_type = CharacterType.T_REX # a.deploy = ArmyDeploy.HORIZONTAL a.deploy = deploy a.createArmy(bsize) b = Army(Clan.RED) b.army_type = CharacterType.JEDI_KNIGHT b.deploy = deploy b.createArmy(rsize) launch(m, a, b)
def load_map(self, map_file):
self.game.map = game_map = Map(map_settings=map_file)
self.game.pathfinder = Pathfinder(game_map)
from terrain.terrain_type import * from characters.soldier import Soldier from characters.jedi import Jedi from characters.clan import Clan from army.army import Army from map.map import Map from map.field import * from characters.character_type import CharacterType from army.army_deploy import ArmyDeploy m = Map(500, 500) m.assign_type(TerrainType.FOREST) # print(m) deploy = ArmyDeploy.SQUARE sizeBlue = 1000 sizeRed = 1000 a = Army(Clan.BLUE) a.army_type = CharacterType.SOLDIER # a.deploy = ArmyDeploy.HORIZONTAL a.deploy = deploy a.createArmy(sizeBlue) b = Army(Clan.RED) b.army_type = CharacterType.JEDI_KNIGHT b.deploy = deploy b.createArmy(sizeRed) launch(m, a, b)
