def __init__(self):
# Set up our middleware which will handle messages from the client.
middleware = ControllerMiddleware(game_server=self)
# Our "middleware" will populate this dictionary with legal directional
# events from the client when they are received.
self.network_events = {"left": False,
"right": False,
"up": False,
"down": False}
# Create a Neteria server instance and start listening.
self.server = NeteriaServer(middleware)
self.server.listen()
# Set up and configure PyGame.
pygame.init()
self.screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Neteria Server")
self.clock = pygame.time.Clock()
# Create a player sprite that we can move around.
self.sprite = pygame.image.load("assets/player.png").convert_alpha()
self.sprite_position = [(self.screen.get_width() / 2) - self.sprite.get_width() / 2,
(self.screen.get_height() / 2) - self.sprite.get_height() / 2]
def __init__(self, game):
self.game = game
self.network_events = []
self.listening = False
self.interfaces = {}
# Handle users without networking support
if not networking:
self.server = DummyNetworking()
return
self.server = NeteriaServer(Controller(self))
def __init__(self, game, server_name=None):
self.game = game
if not server_name:
self.server_name = "Default Tuxemon Server"
else:
self.server_name = server_name
self.network_events = []
self.listening = False
self.interfaces = {}
self.ips = []
# Handle users without networking support.
if not networking:
self.server = DummyNetworking()
return
self.server = NeteriaServer(Multiplayer(self), server_port=40081, server_name=self.server_name)
def __init__(self, caption):
self.screen = pg.display.get_surface()
self.caption = caption
self.done = False
self.clock = pg.time.Clock()
self.fps = 60.0
self.show_fps = True
self.current_time = 0.0
self.keys = pg.key.get_pressed()
self.key_events = []
self.state_dict = {}
self.state_name = None
self.state = None
if NeteriaServer and Controller:
self.network_events = []
self.server = NeteriaServer(Controller(self))
self.server.listen()
else:
self.server = None
# Set up our game's configuration from the prepare module.
from core import prepare
self.imports = {
"prepare": prepare,
"ai": ai,
"rumble": rumble,
"db": db,
"monster": monster,
"player": player,
"item": item,
"map": maps,
"pyganim": pyganim
}
self.config = prepare.CONFIG
# Set up our game's event engine which executes actions based on
# conditions defined in map files.
self.event_engine = event.EventEngine()
self.event_conditions = {}
self.event_actions = {}
self.event_persist = {}
# Set up a variable that will keep track of currently playing music.
self.current_music = {"status": "stopped", "song": None}
# Keep track of animations that we will play.
self.animations = {}
# Create these Pygame event objects to simulate KEYDOWN and KEYUP
# events for all the directional keys
self.keyboard_events = {}
self.keyboard_events["KEYDOWN"] = {}
self.keyboard_events["KEYDOWN"]["up"] = pg.event.Event(
pg.KEYDOWN, {
'scancode': 111,
'key': 273,
'unicode': u'',
'mod': 4096
})
self.keyboard_events["KEYDOWN"]["down"] = pg.event.Event(
pg.KEYDOWN, {
'scancode': 116,
'key': 274,
'unicode': u'',
'mod': 4096
})
self.keyboard_events["KEYDOWN"]["left"] = pg.event.Event(
pg.KEYDOWN, {
'scancode': 113,
'key': 276,
'unicode': u'',
'mod': 4096
})
self.keyboard_events["KEYDOWN"]["right"] = pg.event.Event(
pg.KEYDOWN, {
'scancode': 114,
'key': 275,
'unicode': u'',
'mod': 4096
})
self.keyboard_events["KEYDOWN"]["enter"] = pg.event.Event(
pg.KEYDOWN, {
'scancode': 36,
'key': 13,
'unicode': u'\r',
'mod': 4096
})
self.keyboard_events["KEYDOWN"]["escape"] = pg.event.Event(
pg.KEYDOWN, {
'scancode': 9,
'key': 27,
'unicode': u'\x1b',
'mod': 4096
})
self.keyboard_events["KEYUP"] = {}
self.keyboard_events["KEYUP"]["up"] = pg.event.Event(
pg.KEYUP, {
'scancode': 111,
'key': 273,
'mod': 4096
})
self.keyboard_events["KEYUP"]["down"] = pg.event.Event(
pg.KEYUP, {
'scancode': 116,
'key': 274,
'mod': 4096
})
self.keyboard_events["KEYUP"]["left"] = pg.event.Event(
pg.KEYUP, {
'scancode': 113,
'key': 276,
'mod': 4096
})
self.keyboard_events["KEYUP"]["right"] = pg.event.Event(
pg.KEYUP, {
'scancode': 114,
'key': 275,
'mod': 4096
})
self.keyboard_events["KEYUP"]["enter"] = pg.event.Event(
pg.KEYUP, {
'scancode': 36,
'key': 13,
'mod': 4096
})
self.keyboard_events["KEYUP"]["escape"] = pg.event.Event(
pg.KEYUP, {
'scancode': 9,
'key': 27,
'mod': 4096
})
# Set up the command line. This provides a full python shell for
# troubleshooting. You can view and manipulate any variables in
# the game.
self.exit = False # Allow exit from the CLI
if self.config.cli:
self.cli = cli.CommandLine(self)
# Controller overlay
if self.config.controller_overlay == "1":
self.controller = controller.Controller(self)
self.controller.load()
# Keep track of what buttons have been pressed when the overlay
# controller is enabled.
self.overlay_pressed = {
"up": False,
"down": False,
"left": False,
"right": False,
"a": False,
"b": False
}
# Set up rumble support for gamepads
self.rumble_manager = rumble.RumbleManager()
self.rumble = self.rumble_manager.rumbler
def run(self):
server = NeteriaServer(EchoMiddleware())
server.listen()
while(True):
time.sleep(1)
#!/usr/bin/python
import logging
import sys
import time
from neteria.server import NeteriaServer
from neteria.tools import _Middleware
# Create a middleware object that will echo events. "event_execute" is
# executed for every legal event message.
class EchoMiddleware(_Middleware):
def event_legal(self, cuuid, euuid, event_data):
return True
def event_execute(self, cuuid, euuid, event_data):
print event_data
# Create a client instance.
server = NeteriaServer(EchoMiddleware())
server.listen()
print "Server started. Press CTRL+C to quit."
while True:
time.sleep(1)
