from lampost.datastore.classes import get_dbo_class
from lampost.context.resource import m_requires
from lampost.datastore.exceptions import DataError
from lampost.editor.editor import Editor, ChildrenEditor
from lampost.env.movement import Direction
from lampost.env.room import Room
from lampost.context.config import m_configured
from lampost.model.area import Area
m_requires(__name__, 'datastore', 'log', 'perm', 'dispatcher', 'edit_notify_service')
m_configured(__name__, 'root_area_id', 'default_start_room')
class AreaEditor(Editor):
def initialize(self):
super().initialize(Area)
def _pre_create(self):
if object_exists('player', self.raw['dbo_id']):
raise DataError("Area name should not match any player name.")
def _pre_delete(self, del_obj):
if del_obj.dbo_id == root_area_id:
raise DataError("Cannot delete root area.")
for room in load_object_set(Room, 'area_rooms:{}'.format(del_obj.dbo_id)):
room_clean_up(room, self.session, del_obj.dbo_id)
class RoomEditor(ChildrenEditor):
def initialize(self):
from lampost.context.resource import m_requires
from lampost.gameops.action import action_handler, ActionError
from lampost.context.config import m_configured
from lampost.lpmud.fight import Fight
from lampost.lpmud import attributes
from lampost.lpmud.combat import calc_consider
from lampost.model.entity import Entity
m_requires(__name__, 'log', 'tools', 'dispatcher')
m_configured(__name__, 'refresh_interval', 'refresh_rates')
class EntityLP(Entity):
health = 0
stamina = 0
mental = 0
action = 0
auto_fight = True
weapon = None
last_opponent = None
_refresh_pulse = None
_current_action = None
_action_target = None
_next_command = None
_action_pulse = None
def __init__(self):
super().__init__()
from lampost.context.config import m_configured
from lampost.context.resource import m_requires
from lampost.datastore.dbofield import DBOField, DBOTField
from lampost.datastore.auto import TemplateField
from lampost.lpmud.archetype import Archetype
from lampost.lpmud.attributes import fill_pools
from lampost.lpmud.entity import EntityLP
from lampost.lpmud.skill import add_skill
from lampost.model.mobile import MobileTemplate, Mobile
m_requires(__name__, 'log', 'datastore', 'dispatcher')
m_configured(__name__, 'affinities', 'attributes', 'base_attr_value')
class MobileTemplateLP(MobileTemplate):
class_id = 'mobile'
default_skills = DBOField([], 'default_skill')
def on_loaded(self):
if self.archetype:
arch = load_object(self.archetype, Archetype)
for attr_name, start_value in arch.base_attrs.items():
setattr(self.instance_cls, attr_name, start_value)
self.desc = arch.desc
else:
for attr in attributes:
setattr(self.instance_cls, attr['dbo_id'], base_attr_value * self.level)
self.enemies = affinities[self.affinity]['enemies']
def config_instance(self, mobile, owner):
if maintenance_lc:
maintenance_lc.stop()
maintenance_lc = PeriodicCallback(lambda: dispatch('maintenance'), 60 * maintenance_interval * 1000)
maintenance_lc.start()
info("Maintenance Event heartbeat started at {} minutes", maintenance_interval)
class Registration():
def __init__(self, event_type, callback, owner=None, priority=0):
self.event_type = event_type
self.callback = callback
self.owner = owner if owner else getattr(callback, '__self__', self)
self.priority = priority
def cancel(self):
pass
class PulseRegistration(Registration):
def __init__(self, freq, callback, owner=None, priority=0, repeat=True):
super().__init__('pulse_i', callback, owner, priority)
self.freq = freq
self.repeat = repeat
def cancel(self):
self.freq = 0
m_configured(__name__, 'pulse_interval', 'maintenance_interval')
from lampost.context.config import m_configured
pool_keys = []
attr_list = []
def _on_configured():
global attr_list, pool_keys
pool_keys = [(pool['dbo_id'], "base_{}".format(pool['dbo_id'])) for pool in resource_pools]
attr_list = [attr['dbo_id'] for attr in attributes]
m_configured(__name__, 'attributes', 'resource_pools')
def base_pools(entity):
for pool in resource_pools:
total = sum(getattr(entity, key) * value for key, value in pool['calc'].items())
setattr(entity, 'base_{}'.format(pool['dbo_id']), total)
def fill_pools(entity):
base_pools(entity)
for pool_id, base_pool_id in pool_keys:
setattr(entity, pool_id, getattr(entity, base_pool_id))
def restore_attrs(entity):
for attr in attr_list:
setattr(entity, attr, getattr(entity, "perm_{}".format(attr)))
import time
from datetime import datetime, timedelta
from os import urandom
from base64 import b64encode
from lampost.context.resource import m_requires, requires
from lampost.context.config import m_configured
from lampost.util.lputil import ClientError
m_requires(__name__, 'log', 'dispatcher', 'user_manager')
m_configured(__name__, 'refresh_link_interval', 'broadcast_interval', 'link_dead_prune', 'link_dead_interval',
'link_idle_refresh')
class SessionManager():
def __init__(self):
self.session_map = {}
self.player_info_map = {}
self.player_session_map = {}
def _post_init(self):
register_p(self._refresh_link_status, seconds=refresh_link_interval)
register_p(self._broadcast_status, seconds=broadcast_interval)
self.link_dead_prune = timedelta(seconds=link_dead_prune)
self.link_dead_interval = timedelta(seconds=link_dead_interval)
self.link_idle_refresh = timedelta(seconds=link_idle_refresh)
register('player_logout', self._player_logout)
def get_session(self, session_id):
return self.session_map.get(session_id)
def _on_configured():
if _web_server:
_web_server.lsp_js('config.js', "var lampost_config = {{title:'{0}', description:'{1}'}};".format(lampost_title, lampost_description))
def init(web_server):
global _web_server
_web_server = web_server
web_server.add(r'/game_connect', GameConnect)
web_server.add(r'/link', Link)
web_server.add(r'/login', Login)
web_server.add(r'/action', Action)
web_server.add(r'/register', Register)
web_server.add(r'/unregister', Unregister)
web_server.add(r'/remote_log', RemoteLog)
web_server.add(r'/messages/friend_response', FriendResponse)
web_server.add(r'/messages/delete', MessageDelete)
web_server.add(r'/settings/(.*)', Settings)
_on_configured()
m_configured(__name__, 'lampost_title', 'lampost_description')
from lampost.context.resource import m_requires
from lampost.context.config import m_configured
m_requires(__name__, 'dispatcher')
client_displays = {}
def _on_configured():
client_displays.clear()
for display in default_displays:
client_displays[display['name']] = display['value']
m_configured(__name__, 'default_displays')
def _post_init():
register('session_connect', set_displays)
def set_displays(session):
session.append({'client_config': {'default_displays': client_displays}})
m_requires(__name__, 'log', 'tools', 'dispatcher')
damage_categories = {}
def _on_configured():
global damage_categories
damage_categories = {group['dbo_id']: set() for group in damage_groups}
for damage_type in damage_types:
dbo_id, damage_group = damage_type['dbo_id'], damage_type['group']
if damage_group:
damage_categories['any'].add(dbo_id)
damage_categories[damage_group].add(dbo_id)
m_configured(__name__, 'damage_types', 'damage_groups')
CON_LEVELS = ['Insignificant', 'Trivial', 'Pesky', 'Annoying', 'Irritating', 'Bothersome', 'Troublesome',
'Evenly Matched',
'Threatening', 'Difficult', 'Intimidating', 'Imposing', 'Frightening', 'Terrifying', 'Unassailable']
CON_RANGE = int((len(CON_LEVELS) - 1) / 2)
def validate_weapon(ability, weapon_type):
if not ability.weapon_type or ability.weapon_type == 'unused':
return
if ability.weapon_type == 'unarmed':
if weapon_type:
raise ActionError("You can't do that with a weapon.")
return
from lampost.comm.broadcast import BroadcastMap
from lampost.context.config import m_configured
from lampost.context.resource import m_requires, requires
from lampost.datastore.dbofield import DBOField
from lampost.env.movement import Direction
from lampost.env.room import Room
from lampost.gameops import target_gen
from lampost.gameops.action import convert_verbs, ActionError
from lampost.model.item import BaseItem
m_requires(__name__, 'datastore', 'dispatcher')
m_configured(__name__, 'instance_preserve_hours')
instance_map = {}
class InstanceManager():
def _post_init(self):
register('maintenance', self.remove_old)
def next_instance(self):
instance_id = db_counter('instance_id')
area_instance = AreaInstance(instance_id)
instance_map[instance_id] = area_instance
return area_instance
def remove_old(self):
stale_pulse = future_pulse(instance_preserve_hours * 60 * 60)
for instance_id, instance in instance_map.copy().items():
if instance.pulse_stamp < stale_pulse and not [entity for entity in instance.entities
from lampost.comm.broadcast import Broadcast
from lampost.context.resource import m_requires
from lampost.datastore.auto import AutoField
from lampost.datastore.dbo import CoreDBO, ChildDBO
from lampost.datastore.dbofield import DBOField, DBOCField
from lampost.env.movement import Direction
from lampost.context.config import m_configured
from lampost.gameops.script import Scriptable, Shadow
from lampost.model.item import Connected
m_requires(__name__, 'log', 'dispatcher', 'datastore')
m_configured(__name__, 'room_reset_time')
def tell(listeners, msg_type, *args):
for listener in listeners:
try:
receiver = getattr(listener, msg_type)
except AttributeError:
continue
receiver(*args)
class Exit(CoreDBO):
class_id = 'exit'
target_class = None
from lampost.context.config import m_configured
from lampost.context.resource import m_requires
from lampost.util.lputil import PermError
m_requires(__name__, 'datastore')
def _on_configured():
global _rev_levels
_rev_levels = {level: name for name, level in imm_levels.items()}
m_configured(__name__, 'imm_levels', 'system_accounts', 'system_level')
def _post_init():
global immortals
immortals = get_all_hash('immortals')
immortals.update({account: system_level for account in system_accounts})
def perm_name(num_level):
return _rev_levels.get(num_level, 'player')
def update_immortal_list(player):
if player.imm_level:
set_db_hash('immortals', player.dbo_id, player.imm_level)
immortals[player.dbo_id] = player.imm_level
else:
delete_index('immortals', player.dbo_id)
try:
from lampost.server.services import ClientService
from lampost.gameops.action import make_action
from lampost.context.resource import m_requires
from lampost.context.config import m_configured
from lampost.util.lputil import timestamp
m_requires(__name__, 'dispatcher', 'datastore', 'channel_service')
m_configured(__name__, 'max_channel_history')
class Channel():
def __init__(self, channel_type, instance_id=None, general=False, aliases=()):
if instance_id == 'next':
instance_id = db_counter('channel')
make_action(self, (channel_type,) + aliases)
self.id = "{}_{}".format(channel_type, instance_id) if instance_id else channel_type
channel_service.register_channel(self.id, general)
def __call__(self, source, command, **_):
space_ix = command.find(" ")
if space_ix == -1:
return source.display_line("Say what?")
self.send_msg(source.name + ":" + command[space_ix:])
def send_msg(self, msg):
channel_service.dispatch_message(self.id, msg)
def disband(self):
channel_service.unregister_channel(self.id)
from lampost.context.config import m_configured
from lampost.datastore.dbo import KeyDBO, DBOAccess
from lampost.datastore.dbofield import DBOField, DBOLField
m_configured(__name__, 'base_attr_value', 'attributes', 'default_start_room')
class Archetype(DBOAccess, KeyDBO):
dbo_key_type = 'archetype'
dbo_set_key = 'archetypes'
name = DBOField("Unnamed")
desc = DBOField('')
base_attrs = DBOField({})
class PlayerRace(Archetype):
dbo_key_type = "race"
dbo_set_key = "races"
default_skills = DBOField([], 'default_skill')
start_room = DBOLField(dbo_class_id='room')
start_instanced = DBOField(False)
@classmethod
def new_dto(cls):
dto = super().new_dto()
dto['start_room'] = default_start_room
dto['base_attrs'] = {attr['dbo_id']: base_attr_value for attr in attributes}
return dto
import random
import string
from lampost.server.handlers import MethodHandler
from lampost.server.user import User
from lampost.context.resource import m_requires, requires
from lampost.datastore.exceptions import DataError
from lampost.context.config import m_configured
from lampost.model.player import Player
from lampost.util.encrypt import make_hash
from lampost.util.lputil import ClientError
m_requires(__name__, 'datastore', 'dispatcher', 'user_manager', 'perm', 'email_sender', 'friend_service')
m_configured(__name__, 'lampost_title')
@requires('session_manager')
class Settings(MethodHandler):
def get_account(self):
user_id = self.raw['user_id']
if self.session.user.dbo_id != user_id:
check_perm(self.player, 'admin')
return load_object(user_id, User).edit_dto
def create_account(self):
account_name = self.raw['account_name'].lower()
if get_index("ix:user:name", account_name) or object_exists('player', account_name) or\
account_name in perm.system_accounts or object_exists('area', account_name):
raise DataError("InUse: {}".format(account_name))
from lampost.comm.channel import Channel
from lampost.context.config import m_configured
from lampost.context.resource import m_requires
from lampost.env.room import Room, safe_room
from lampost.gameops.action import ActionError
from lampost.mud.action import mud_action, imm_actions
m_requires(__name__, 'log', 'datastore', 'dispatcher', 'perm', 'user_manager', 'instance_manager',
'message_service', 'friend_service')
m_configured(__name__, 'default_start_room')
_init_priority = 5000
def _post_init():
global shout_channel, imm_channel
shout_channel = Channel('shout', general=True)
imm_channel = Channel('imm')
register('player_create', _player_create)
register('player_baptise', _baptise, priority=-100)
register('imm_baptise', _imm_baptise, priority=-100)
register('missing_env', _start_env)
def _player_create(player, user):
if len(user.player_ids) == 1 and not player.imm_level:
player.imm_level = perm_level('builder')
update_immortal_list(player)
dispatch('imm_level_change', player, 0)
message_service.add_message('system', "Welcome! Your first player has been given immortal powers. Check out the 'Editor' window on the top menu.", player.dbo_id)
from lampost.datastore.dbofield import DBOField
import lampost.env.room
from lampost.gameops.action import ActionError
from lampost.context.config import m_configured
m_configured(__name__, "room_stamina", "room_action", "default_room_size")
exit_cost_map = {}
prep_multiplier = 1
def find_cost(room):
if room and room.size:
try:
return exit_cost_map[room.size]
except KeyError:
exit_cost_map[room.size] = {
"action": int(room_stamina * room.size / default_room_size),
"stamina": int(room_action * room.size / default_room_size),
}
return exit_cost_map[room.size]
class ExitLP(lampost.env.room.Exit):
class_id = "exit"
guarded = DBOField(False)
door_key = DBOField()
@property
def prep_time(self):