def shoot(self):
target = self.pos + self.last_dir
ents = engine.metagrid.get_entities(target.x, target.y)
log('found %s' % ents)
if not LAYER_BLOCKS in ents:
FireBall(pos=target, dir=self.last_dir)
def shoot(self):
target = self.pos + self.last_dir
ents = engine.metagrid.get_entities(target.x, target.y)
log('found %s' % ents)
if not LAYER_BLOCKS in ents:
FireBall(pos=target,dir=self.last_dir)
def add_entity(self, new_guy, moving=False):
if hasattr(new_guy, "pos") and (new_guy.pos):
self.metagrid.add_entity(new_guy, moving)
else:
if not isinstance(new_guy, Updater):
log("Why add %s, a ghost that does not update?" % new_guy)
self.ghosts[new_guy.id] = new_guy
def spawn_dude(self, dude=None):
if not dude:
log ('spawning dude for %s' % self)
dude = Player()
self.dude = dude
self.dude.owner = self
self.dude.on_die = self.handle_player_die
self.inform_player_of_dude()
def spawn_dude(self, dude=None):
if not dude:
log('spawning dude for %s' % self)
dude = Player()
self.dude = dude
self.dude.owner = self
self.dude.on_die = self.handle_player_die
self.inform_player_of_dude()
def remove_entity(self, ent):
if ent.layer in self.entities:
other = self.entities.pop(ent.layer)
return True
log('%s was not in %s' % (ent, self.entities))
from entity import NoSuchEntity
import pdb
pdb.set_trace()
raise NoSuchEntity('No such entity %s at' % (ent))
def get_cell(self, x, y):
x, y = self.wrap_coords(x, y)
g_x = (x / GRID_SIZE) * GRID_SIZE
g_y = (y / GRID_SIZE) * GRID_SIZE
#log("%d,%d converted to %d,%d" % (x,y, g_x, g_y))
if not (g_x, g_y) in self.cells:
log("FATAL: unknown metagrid cell %d,%d" % (g_x, g_y))
log('cells are: %s ' % self.cells)
sys.exit()
else:
res = self.cells[(g_x, g_y)]
return res
def use(self):
target_pos = self.pos + self.last_dir
dudes = engine.get_entities(target_pos.x,target_pos.y)
move = False
if self.carrying:
smasher = self.carrying
for layer in [LAYER_BLOCKS,
LAYER_GROUND_DETAIL,
LAYER_GROUND]:
if layer in dudes:
if smasher.can_smash(dudes[layer]):
log('%s can smash %s' % (smasher, dudes[layer]))
self.carrying = None
smasher.smash(dudes[layer])
break
return
#not carrying anything
#check for an item to act on
neighbors = engine.metagrid.get_neighbors(self.pos)
#see if you're looking at a water square
if self.last_dir in neighbors:
dudes = neighbors[self.last_dir]
if not LAYER_BLOCKS in dudes and\
dudes[LAYER_GROUND].terrain_type == 'water':
WaterDrop(pos=self.pos+self.last_dir)
return
if self.last_dir in neighbors:
dudes = neighbors[self.last_dir]
for layer in [LAYER_BLOCKS,
LAYER_GROUND_DETAIL,
LAYER_GROUND]:
if layer in dudes:
other_guy = dudes[layer]
if isinstance(other_guy, Carryable):
self.carry_item(other_guy)
elif isinstance(other_guy, Consumable):
self.consume(other_guy)
other_guy.die(self)
else:
Air(self.pos).smash(other_guy)
#once we've encounterd an object, we're done
break
def on_message(self, message):
msg = json.loads(message)
if 'dir' in msg:
self.dir = DIRS[msg['dir']]
elif 'act' in msg:
self.act = msg['act']
elif 'name' in msg:
self.name = msg['name']
if self.name in clients_by_name:
log('We know this client: ' + self.name)
client = clients_by_name[self.name]
log('client has dude %s' % client.dude)
self.spawn_dude(client.dude)
client.die(self)
clients_by_name[self.name] = self
else:
clients_by_name[self.name] = self
self.spawn_dude(Player())
def on_message(self, message):
msg = json.loads(message)
if 'dir' in msg:
self.dir = DIRS[msg['dir']]
elif 'act' in msg:
self.act = msg['act']
elif 'name' in msg:
self.name = msg['name']
if self.name in clients_by_name:
log ('We know this client: ' +self.name)
client = clients_by_name[self.name]
log ('client has dude %s' % client.dude)
self.spawn_dude(client.dude)
client.die(self)
clients_by_name[self.name] = self
else:
clients_by_name[self.name] = self
self.spawn_dude(Player())
def __init__(self, **kwargs):
pos = kwargs.get('pos') or None
dist = kwargs.get('dist') or None
if not pos or not dist:
log('FireRing needs position and distance')
return
def circle_visitor(x, y):
ents = engine.metagrid.get_entities(x, y)
if LAYER_BLOCKS in ents:
dude = ents[LAYER_BLOCKS]
if isinstance(ents, Flammable):
Fire.burn(self, other)
return
else:
FirePuff(pos=vector2(x, y))
engine.metagrid.visit_circle(pos.x, pos.y, dist, circle_visitor)
def use(self):
target_pos = self.pos + self.last_dir
dudes = engine.get_entities(target_pos.x, target_pos.y)
move = False
if self.carrying:
smasher = self.carrying
for layer in [LAYER_BLOCKS, LAYER_GROUND_DETAIL, LAYER_GROUND]:
if layer in dudes:
if smasher.can_smash(dudes[layer]):
log('%s can smash %s' % (smasher, dudes[layer]))
self.carrying = None
smasher.smash(dudes[layer])
break
return
#not carrying anything
#check for an item to act on
neighbors = engine.metagrid.get_neighbors(self.pos)
#see if you're looking at a water square
if self.last_dir in neighbors:
dudes = neighbors[self.last_dir]
if not LAYER_BLOCKS in dudes and\
dudes[LAYER_GROUND].terrain_type == 'water':
WaterDrop(pos=self.pos + self.last_dir)
return
if self.last_dir in neighbors:
dudes = neighbors[self.last_dir]
for layer in [LAYER_BLOCKS, LAYER_GROUND_DETAIL, LAYER_GROUND]:
if layer in dudes:
other_guy = dudes[layer]
if isinstance(other_guy, Carryable):
self.carry_item(other_guy)
elif isinstance(other_guy, Consumable):
self.consume(other_guy)
other_guy.die(self)
else:
Air(self.pos).smash(other_guy)
#once we've encounterd an object, we're done
break
def __init__(self, **kwargs):
pos = kwargs.get('pos') or None
dist = kwargs.get('dist') or None
if not pos or not dist :
log('FireRing needs position and distance')
return
def circle_visitor(x,y):
ents = engine.metagrid.get_entities(x,y)
if LAYER_BLOCKS in ents:
dude = ents[LAYER_BLOCKS]
if isinstance(ents, Flammable):
Fire.burn(self,other)
return
else:
FirePuff(pos=vector2(x,y))
engine.metagrid.visit_circle(pos.x, pos.y,
dist, circle_visitor)
def get_real_item(item):
if isinstance(item, unicode):
return str(item)
if isinstance(item, dict):
if "_type" in item:
if item["_type"] == "vector2":
return vector2(item["vec"][0], item["vec"][1])
if item["_type"] == "ent":
log("making entity wrapper.")
return PersistedWrapper(item["ent_id"])
elif item["_type"] == "dict":
res = {}
for kvp in item["pairs"]:
res[get_real_item(kvp[0])] = get_real_item(kvp[1])
return res
return item
def build_world(self):
generate = True
if generate:
log("Generating world.")
if USE_DATASTORE:
self.datastore.entities.remove()
for x in range(METAGRID_SIZE):
for y in range(METAGRID_SIZE):
g_x = x * GRID_SIZE
g_y = y * GRID_SIZE
# log('new metacell at %d, %d' % (g_x, g_y))
cell = self.metagrid.add_cell(g_x, g_y)
if generate and self.game:
self.game.new_metagrid_cell(cell)
if generate:
if self.game != None:
self.game.build_world()
self.save_world(save_terrain=True)
else:
log("Loading world")
entities = self.datastore.entities.find()
for ent in entities:
ent_dict = {}
for var in ent:
ent_dict[str(var)] = ent[var]
guy = entity_class_registry[ent["__class__"]](**ent_dict)
log("Load complete")
def save_world(self, save_terrain=False):
if not USE_DATASTORE:
return
log("saving world..")
for cell in self.metagrid.cells:
self.metagrid.cells[cell].persist()
if save_terrain:
self.metagrid.cells[cell].persist_terrain()
log("saving ghosts.")
for ghost in self.ghosts:
log("persisting %s" % self.ghosts[ghost])
self.ghosts[ghost].persist(self.datastore)
log("saving complete.")
def __init__(self, **kwargs):
"Creating a new client."
log('Creating a new client object')
self.updates = 0
self.dir = ZERO_VECTOR
self.watching = {}
self.act = None
self.bomb = None
self.bomb_cooldown = 0
self.name = random.choice([
"Chumpalicious", "Nooborama", "Wussomatic", "Llamatastic",
"Failarious"
])
self.death_count = 0
self.kill_count = 0
self.disconnected = False
self.dude = None
Entity.__init__(self)
engine.client_manager.add_client(self)
self.name = kwargs.get('name') or self.id
log("%s joined the game" % self)
clients_by_name[self.name] = self
def __init__(self, **kwargs):
"Creating a new client."
log ('Creating a new client object')
self.updates = 0
self.dir = ZERO_VECTOR
self.watching = {}
self.act = None
self.bomb = None
self.bomb_cooldown = 0
self.name = random.choice([ "Chumpalicious",
"Nooborama",
"Wussomatic",
"Llamatastic",
"Failarious"])
self.death_count = 0
self.kill_count = 0
self.disconnected = False
self.dude = None
Entity.__init__(self)
engine.client_manager.add_client(self)
self.name = kwargs.get('name') or self.id
log ("%s joined the game" % self)
clients_by_name[self.name] = self
def build_world(self):
#add some water
log ('building world: adding water')
num_cells = (METAGRID_SIZE*GRID_SIZE)**2
num_water_cells = int(num_cells*0.05/float(METAGRID_SIZE**2))
for c in range(num_water_cells):
x = random.choice(range(GRID_SIZE*METAGRID_SIZE))
y = random.choice(range(GRID_SIZE*METAGRID_SIZE))
engine.get_entities(x,y)[LAYER_GROUND].to_water()
#now add some trees and fruit
num_bomb_cells = num_cells*2/(GRID_SIZE*GRID_SIZE)
log('building world: adding %d bombs' % num_bomb_cells)
choices = {
Sheep: GRID_SIZE*0.4,
FirePuff : GRID_SIZE*0.4,
Coal : GRID_SIZE*0.7,
Tree : GRID_SIZE*0.75,
Wolf : GRID_SIZE*0.3,
Stone: GRID_SIZE*0.3,
}
for choice in [Tree] * 4 + \
[Coal] * 2 + \
[Stone] * 3 + \
[Sheep] * 2:
x = random.choice(range(GRID_SIZE*METAGRID_SIZE))
y = random.choice(range(GRID_SIZE*METAGRID_SIZE))
def get_dudes():
x = random.choice(range(GRID_SIZE*METAGRID_SIZE))
y = random.choice(range(GRID_SIZE*METAGRID_SIZE))
return engine.metagrid.get_entities(x,y)
dudes = get_dudes()
while dudes[LAYER_GROUND].terrain_type == 'water':
dudes = get_dudes()
log ('got a dude')
dudes[LAYER_GROUND].start_forest(choice, choices[choice])
def __init__(self, application, request):
tornado.websocket.WebSocketHandler.__init__(self, application, request)
"""sets up the socket sender"""
log('New client connected: %s' % self.request)
engine.game = game
engine.build_world()
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
"login_url": "/login",
"xsrf_cookies": True,
}
application = tornado.web.Application(
[(r"/", MainHandler), (r"/js/([A-z|0-9]+).js", JSHandler),
(r'/ws', SocketConnectionHandler, {}),
(r'/images/([A-z]+).png', ImageHandler)], **settings)
if __name__ == "__main__":
log("Starting Tornado web server on port 8000!")
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8000)
main_loop = tornado.ioloop.IOLoop.instance()
scheduler = tornado.ioloop.PeriodicCallback(game.update,
TICK_PERIOD,
io_loop=main_loop)
scheduler2 = tornado.ioloop.PeriodicCallback(engine.save_world,
TICK_PERIOD * 100,
io_loop=main_loop)
scheduler.start()
scheduler2.start()
log("Server started, entering main loop.")
main_loop.start()
def __init__(self, application, request):
tornado.websocket.WebSocketHandler.__init__(self, application, request)
"""sets up the socket sender"""
log ('New client connected: %s' % self.request)
def send_deltas(self):
if not self.dude:
return
#check to make sure the guy can see what's around him
old_watching = {}
for cell_pos in self.watching:
old_watching[cell_pos] = True
#we need to know how the set of what this guy's watching
#has changed
newly_watched = {}
still_watching = {}
now_watching = {}
no_longer_watching = {}
for dir in ALL_DIRS + [ZERO_VECTOR]:
cell = self.get_neighbor(dir)
if not cell:
log('No cell for direction %s' % dir)
import pdb
pdb.set_trace()
if not cell.get_pos() in old_watching:
newly_watched[cell] = cell.get_pos()
now_watching[cell] = cell.get_pos()
for cell_pos in old_watching:
cell = engine.metagrid.get_cell(cell_pos.x, cell_pos.y)
if not cell in now_watching:
no_longer_watching[cell] = True
else:
still_watching[cell] = True
params = (len(now_watching), len(newly_watched), len(still_watching),
len(no_longer_watching))
#do some sanity checks
for cell in newly_watched:
if cell in still_watching:
log("%s was in newly AND still watched!" % cell)
if cell in no_longer_watching:
log("%s was in newly AND no longer watched!" % cell)
for cell in still_watching:
if cell in no_longer_watching:
log("%s was in still and no longer watching!" % cell)
#now go through each of these sells and send them
#the appropriate message
for cell in newly_watched:
#log('now watching %s' % cell)
if cell and cell.current_state:
self.send(cell.current_state)
for cell in still_watching:
if cell and cell.last_delta and self.delta_matters(
cell.last_delta):
#log('sending delta for %s' % cell)
self.send(cell.last_delta)
for cell in no_longer_watching:
#log ('no longer watching %s' % cell)
if cell and cell.drop_message:
self.send(cell.drop_message)
self.watching = {}
for cell in now_watching:
self.watching[cell.get_pos()] = True
def send_deltas(self):
if not self.dude:
return
#check to make sure the guy can see what's around him
old_watching = {}
for cell_pos in self.watching:
old_watching[cell_pos] = True
#we need to know how the set of what this guy's watching
#has changed
newly_watched = {}
still_watching = {}
now_watching = {}
no_longer_watching = {}
for dir in ALL_DIRS + [ZERO_VECTOR]:
cell = self.get_neighbor(dir)
if not cell:
log ('No cell for direction %s' % dir)
import pdb
pdb.set_trace()
if not cell.get_pos() in old_watching:
newly_watched[cell] = cell.get_pos()
now_watching[cell] = cell.get_pos()
for cell_pos in old_watching:
cell = engine.metagrid.get_cell(cell_pos.x, cell_pos.y)
if not cell in now_watching:
no_longer_watching[cell] = True
else:
still_watching[cell] = True
params = (len(now_watching), len(newly_watched),
len(still_watching), len(no_longer_watching))
#do some sanity checks
for cell in newly_watched:
if cell in still_watching:
log("%s was in newly AND still watched!" %
cell)
if cell in no_longer_watching:
log("%s was in newly AND no longer watched!" %
cell)
for cell in still_watching:
if cell in no_longer_watching:
log("%s was in still and no longer watching!" % cell)
#now go through each of these sells and send them
#the appropriate message
for cell in newly_watched:
#log('now watching %s' % cell)
if cell and cell.current_state:
self.send(cell.current_state)
for cell in still_watching:
if cell and cell.last_delta and self.delta_matters(cell.last_delta):
#log('sending delta for %s' % cell)
self.send(cell.last_delta)
for cell in no_longer_watching:
#log ('no longer watching %s' % cell)
if cell and cell.drop_message:
self.send(cell.drop_message)
self.watching = {}
for cell in now_watching:
self.watching[cell.get_pos()] = True
engine.build_world()
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
"login_url": "/login",
"xsrf_cookies": True,
}
application = tornado.web.Application(
[ (r"/", MainHandler),
(r"/js/([A-z|0-9]+).js", JSHandler),
(r'/ws', SocketConnectionHandler, { }),
(r'/images/([A-z]+).png', ImageHandler)
], **settings)
if __name__ == "__main__":
log("Starting Tornado web server on port 8000!")
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8000)
main_loop = tornado.ioloop.IOLoop.instance();
scheduler = tornado.ioloop.PeriodicCallback(game.update, TICK_PERIOD, io_loop = main_loop)
scheduler2 = tornado.ioloop.PeriodicCallback(engine.save_world, TICK_PERIOD*100, io_loop = main_loop)
scheduler.start()
scheduler2.start()
log("Server started, entering main loop.")
main_loop.start()
