def __init__(self, host="localhost", port=5001, name="client"):
self.name = name
self.cManager = QueuedConnectionManager()
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
self.readerCallbacks = []
taskMgr = Task.TaskManager()
# how long until we give up trying to reach the server?
timeout_in_miliseconds = 3000 # 3 seconds
self.myConnection = self.cManager.openTCPClientConnection(
host, port, timeout_in_miliseconds)
if not self.myConnection:
print("{}: Failed to connect to server!".format(self.name))
return
self.cReader.addConnection(
self.myConnection) # receive messages from server
taskMgr.add(self.tskReaderPolling, "Poll the connection reader", -40)
print("{}: Successfully connected to server {} at {}!".format(
self.name, port, host))
def __init__(self):
self.loadDefaultConfig()
self.loadLocalConfig()
if ConfigVariableBool("want-pstats", False):
PStatClient.connect()
# Set up some global objects
self.globalClock = ClockObject.getGlobalClock()
# We will manually manage the clock
self.globalClock.setMode(ClockObject.MSlave)
builtins.globalClock = self.globalClock
self.vfs = VirtualFileSystem.getGlobalPtr()
# For tasks that run every application frame
self.taskMgr = TaskManagerGlobal.taskMgr
builtins.taskMgr = self.taskMgr
# For tasks that run every simulation tick
self.simTaskMgr = Task.TaskManager()
self.simTaskMgr.mgr = AsyncTaskManager("sim")
builtins.simTaskmgr = self.simTaskMgr
self.eventMgr = EventManagerGlobal.eventMgr
builtins.eventMgr = self.eventMgr
self.messenger = MessengerGlobal.messenger
builtins.messenger = self.messenger
self.loader = Loader(self)
builtins.loader = self.loader
builtins.base = self
# What is the current frame number?
self.frameCount = 0
# Time at beginning of current frame
self.frameTime = self.globalClock.getRealTime()
# How long did the last frame take.
self.deltaTime = 0
#
# Variables pertaining to simulation ticks.
#
self.prevRemainder = 0
self.remainder = 0
# What is the current overall simulation tick?
self.tickCount = 0
# How many ticks are we going to run this frame?
self.totalTicksThisFrame = 0
# How many ticks have we run so far this frame?
self.currentTicksThisFrame = 0
# What tick are we currently on this frame?
self.currentFrameTick = 0
# How many simulations ticks are we running per-second?
self.ticksPerSec = 60
self.intervalPerTick = 1.0 / self.ticksPerSec
def __init__(self, host="localhost", port=5001):
taskMgr = Task.TaskManager()
self.cManager = QueuedConnectionManager()
self.cListener = QueuedConnectionListener(self.cManager, 0)
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
self.activeConnections = [] # We'll want to keep track of these later
self.readerCallbacks = []
backlog = 1000 #If we ignore 1,000 connection attempts, something is wrong!
self.tcpSocket = self.cManager.openTCPServerRendezvous(port, backlog)
self.cListener.addConnection(self.tcpSocket)
taskMgr.add(self.tskListenerPolling, "Poll the connection listener",
-39)
taskMgr.add(self.tskReaderPolling, "Poll the connection reader", -40)
print("started server! ({} at {})".format(port, host))
def __init__(self, host="localhost", port=5001, name="client or server"):
self.name = name
self.port = port
self.host = host
self.cManager = QueuedConnectionManager()
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
self.connections = [
] # list of connections, contains 1 item for client, multiple for server
self.readerCallback = None # will be called when a new message arrives
self.writerCallback = None # will be called when a message needs to be constructed
self.taskMgr = Task.TaskManager()
self.taskMgr.add(self.tskReaderPolling, "Poll the connection reader",
-40)
self.taskMgr.add(self.tskWriterPolling, "Send data package", -39)
rbtmnp[1] = robotball.showcn(base, bcndict)
rbtmnp[0].reparentTo(base.render)
motioncounter[0] += 1
else:
motioncounter[0] = 0
return task.done
return task.again
def updatesection(numikmsmpactive, motioncounter, robot, robotmesh, robotball, task):
# if base.inputmgr.keyMap['space']:
if counter[0] < len(numikmsmpactive):
path = numikmsmpactive[counter[0]]
base.inputmgr.keyMap['space'] = False
# taskMgr.remove('updateshow')
if not taskMgr.hasTaskNamed("updateshow"):
taskMgr.doMethodLater(0.1, updateshow, "updateshow",
extraArgs=[rbtmnp, motioncounter, robot, path, armname, robotmesh, robotball],
appendTask=True)
counter[0] += 1
else:
counter[0] = 0
return task.again
taskMgr = Task.TaskManager()
taskMgr.add(updatesection, "updatesection",
extraArgs=[newpath, motioncounter, nxtrobot, robotmesh, robotball],
appendTask=True)
base.run()
host = config["server"]["host"]
# start server and clients
server = TestServer( port=port, host=host )
client1 = TestClient(port=port, host=host, name="Henk" )
client2 = TestClient(port=port, host=host, name="Bert" )
# run test
# TODO(vicdie): run server and clients in separate threads,
# move Task.TaskManager().step() stuff
print("======= Server->Client =======")
tStart = time.time()
tLastHearbeat = tStart
while time.time() < tStart + 10:
Task.TaskManager().step() # perform a step as often as possible
if tLastHearbeat + 1 < time.time():
server.heartbeat()
tLastHearbeat = time.time()
print("======= Client->Server =======")
tStart = time.time()
tLastHearbeat = tStart
while time.time() < tStart + 10:
Task.TaskManager().step() # perform a step as often as possible
if tLastHearbeat + 1 < time.time():
client1.SendMessage()
client2.SendMessage()
tLastHearbeat = time.time()
