class InputReceiver():
def __init__(self):
self.oP = OutPipe("InputReceiver", 0)
self.cR = ConfigReader(GAME_PATH + "controls")
self.sE = ScriptExecuter()
self.eI = EngineInterface(objectMode=False)
self.keyboard = self.eI.getKeyboard()
self.mouse = self.eI.getMouse()
self.tH = TypingHandler(self.keyboard)
self.pairs = {}
self.responses = {}
self.oldKeyboard = self.keyboard.events
self.oldMouse = self.mouse.events
self.sE.addContext("Input", self)
self.sE.execute(INPUT_PATH + "csp")
self.sE.execute(INPUT_PATH + "input")
self.keyEvents = []
self.readControls()
self.locked = False
self.xsens = 50
self.ysens = 50
self.inverted = 0
self.predict = False
self.recent = {}
self.oP("Initialized.")
def addEvent(self, event):
if not event in self.recent.keys():
self.keyEvents.append(["INPUT", "COMMAND", event])
if not type(event) == type(tuple()):
self.recent[event] = time.time()
if self.predict:
self.callClientSidePrediction(event)
def callClientSidePrediction(self, event):
if not type(event) == type(tuple()):
if hasattr(self, "csp_" + event):
getattr(self, "csp_" + event)()
else:
if hasattr(self, "csp_look"):
getattr(self, "csp_look")(event)
def readControls(self):
keys = self.cR.getAllOptions("CONTROLS")
for key in keys:
keyString = self.cR.get("CONTROLS", key)
keyCode = self.eI.getKeyCode(keyString)
try:
self.pairs[keyCode] = getattr(self, key)
self.oP("Read in key response %s successfully." % key)
except:
self.oP("Failed to read in key response %s successfully." %
key)
def checkControls(self):
for keyCode in self.pairs.keys():
if keyCode in self.keyboard.events and not self.locked:
if self.keyboard.events[keyCode] == self.eI.l.KX_INPUT_ACTIVE:
self.callCommand("KEYBOARD", keyCode)
elif self.keyboard.events[
keyCode] == self.eI.l.KX_INPUT_JUST_ACTIVATED:
self.callCommand("KEYBOARD", keyCode)
elif self.keyboard.events[
keyCode] == self.eI.l.KX_INPUT_JUST_RELEASED:
self.callCommand("KEYBOARD", keyCode)
elif keyCode in self.mouse.events:
if self.mouse.events[keyCode] == self.eI.l.KX_INPUT_ACTIVE:
self.callCommand("MOUSE", keyCode)
elif self.mouse.events[
keyCode] == self.eI.l.KX_INPUT_JUST_ACTIVATED:
self.callCommand("MOUSE", keyCode)
elif self.mouse.events[
keyCode] == self.eI.l.KX_INPUT_JUST_RELEASED:
self.callCommand("MOUSE", keyCode)
self.oldKeyboard = self.keyboard.events
self.oldMouse = self.mouse.events
#Handle the "recent" spam blocker
keys = self.recent.keys()
for key in keys:
if abs(self.recent[key] - time.time()) > 0.1:
del self.recent[key]
break
if self.locked:
self.tH.process()
def callCommand(self, mode, keyCode):
if mode == "KEYBOARD":
state = self.getState(self.keyboard.events[keyCode],
self.oldKeyboard[keyCode])
elif mode == "MOUSE":
state = self.getState(self.mouse.events[keyCode],
self.oldMouse[keyCode])
consumed = False
if state == "DEACTIVATE" and keyCode in [
self.eI.e.LEFTMOUSE, self.eI.e.RIGHTMOUSE
]:
consumed = self.checkInterfaceClick(keyCode, self.mouse.position)
if not consumed and not keyCode in [
self.eI.e.MOUSEX, self.eI.e.MOUSEY
]:
self.pairs[keyCode](state)
elif keyCode in [self.eI.e.MOUSEX, self.eI.e.MOUSEY]:
pos = self.mouse.position
self.pairs[keyCode](pos)
def checkInterfaceClick(self, keyCode, pos):
return self.eI.getGlobal("client").inputClick(keyCode, pos)
def getState(self, newstate, oldstate):
if newstate == self.eI.l.KX_INPUT_ACTIVE:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "ACTIVE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "ACTIVATE"
if newstate == self.eI.l.KX_INPUT_NONE:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "INACTIVE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "DEACTIVATE"
if newstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "ACTIVATE"
if newstate == self.eI.l.KX_INPUT_JUST_RELEASED:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "DEACTIVATE"
class Launcher():
def __init__(self):
#Remove engine log
try:
os.remove(ENGINE_PATH + "engine_log" + TEXT_EXT)
except:
pass
#Remove net logs
try:
for i in os.listdir(NET_PATH):
os.remove(NET_PATH + i)
except:
pass
#Create net path
try:
os.mkdir(NET_PATH)
except:
pass
self.oP = OutPipe("Launcher", 0)
for line in self.getSystemInfo():
self.oP(line)
self.cR = ConfigReader(ENGINE_PATH + "engine")
self.sE = ScriptExecuter()
self.eI = EngineInterface()
self.eI.preLoad()
self.eI.preLoadEpi()
#Sloppy, removes the blacker that covers up starting glitches
self.eI.getOverlayScene().objects["BlackScreen"].endObject()
self.sound = SoundEngine()
self.sound.preLoadAudio()
self.s = None
self.c = None
self.output = True
self.oP("Initialized.")
def enableShader(self, index, text):
self.oP("Activating shader pass #%i" % index)
controller = bge.logic.getCurrentController()
filterActuator = controller.actuators["filter"]
filterActuator.mode = bge.logic.RAS_2DFILTER_CUSTOMFILTER
filterActuator.passNumber = index
filterActuator.shaderText = text
controller.activate(filterActuator)
controller.deactivate(filterActuator)
def disableShader(self, index):
self.oP("Deactivating shader pass #%i" % index)
controller = bge.logic.getCurrentController()
filterActuator = controller.actuators["filter"]
filterActuator.mode = bge.logic.RAS_2DFILTER_DISABLED
filterActuator.passNumber = index
controller.activate(filterActuator)
controller.deactivate(filterActuator)
def bootSystem(self):
self.output = int(self.cR.get("LAUNCHER", "la_output"))
dedicated = int(self.cR.get("LAUNCHER", "la_dedicated"))
if dedicated:
lobby = int(self.cR.get("LAUNCHER", "la_dedicated_fast"))
self.bootServer()
self.s.configure("sv_game", lobby)
self.s.configure("sv_dedicated", 1)
else:
self.bootClient()
def getSystemInfo(self):
f = open(ENGINE_PATH + "system" + TEXT_EXT, "r")
try:
data = eval(f.read())
return [
"EpiEngine v%.2f" % data["version"],
"Built for BGE %.2f" % data["targetVersion"],
"Running %s %.2f" % (data["game"], data["gameVersion"]),
"Built %s" % data["date"],
]
except:
return "EpiEngine launching."
f.close()
def bootClient(self):
self.c = Client()
#self.sE.addContext("Client", self.c)
#self.sE.execute(bootScript)
for option in self.cR.getAllOptions("CLIENT"):
self.c.configure(option, self.cR.get("CLIENT", option))
def bootServer(self):
#bootScript = self.cR.get("SERVER", "sv_startscript")
#addr = self.cR.get("SERVER", "sv_addr")
#port = self.cR.get("SERVER", "sv_port")
self.s = Server()
#self.sE.addContext("Server", self.s)
#self.sE.execute(bootScript)
#
#self.s.configure("sv_addr", addr)
#self.s.configure("sv_port", int(port))
for option in self.cR.getAllOptions("SERVER"):
self.s.configure(option, self.cR.get("SERVER", option))
def configureServer(self, level, gamemode):
if self.s:
self.s.configure("level", level)
self.s.configure("gamemode", gamemode)
def loop(self):
self.sound.loop()
try:
if hasattr(self.c, "loop"):
self.c.loop()
except:
self.oP("Failure in client loop: %s" %
str(traceback.format_exc()))
try:
if hasattr(self.s, "loop"):
self.s.loop()
except:
self.oP("Failure in server loop: %s" %
str(traceback.format_exc()))
def pushConsoleCommand(self, command):
if hasattr(self, "s") and self.s:
self.s.pushConsoleCommand(command)
if hasattr(self, "c") and self.c:
self.c.pushConsoleCommand(command)
