def __init__(self, name, ip, port, serverip, serverport, mydata, friendsData):
threading.Thread.__init__(self)
self.name = name
self.mydata = mydata
self.friendsData = friendsData
log(name + ": Running!")
try:
botSocket = nbipc.NetBotSocket(ip, port, serverip, serverport)
self.botSocket = botSocket
joinReply = botSocket.sendRecvMessage(
{'type': 'joinRequest', 'name': name}, retries=300, delay=1, delayMultiplier=1)
self.srvConf = joinReply['conf']
except nbipc.NetBotSocketException as e:
log(name + ": Is netbot server running at" + args.serverIP + ":" + str(args.serverPort) + "?")
log(str(e), name + ": FAILURE")
quit()
log(name + ": Join server was successful. We are ready to play!")
log(name + ": " + str(self.srvConf), "VERBOSE")
def createController(ip, port, sip, sp):
d = ViewerData()
# POSSIBLE BUG (if you get triggered at the smallest "issues"):
# log level for viewer are the same as they are for the bot.
# setLogLevel(args.debug, args.verbose)
# d.srvIP = args.serverIP
# d.srvPort = args.serverPort
d.srvIP = sip
d.srvPort = sp
log("Registering with Server: " + d.srvIP + ":" + str(d.srvPort) +
" (this could take a few seconds)")
try:
d.viewerSocket = nbipc.NetBotSocket(ip, port, sip, sp)
# this step is reeeeeally slow for some reason... must investigate
reply = d.viewerSocket.sendRecvMessage({'type': 'addViewerRequest'})
d.conf = reply['conf']
log("Server Configuration: " + str(d.conf), "VERBOSE")
except Exception as e:
log(str(e), "FAILURE")
quit()
log("Server registration successful. Opening Window.")
openWindow(d)
return d
def main():
global d
d = ViewerData()
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter,
epilog="Note: pressing the space bar activates a 7 second long instant replay at the default step speed. "
+ "Live action will resume after the replay completes.")
parser.add_argument('-ip', metavar='My IP', dest='myIP', type=nbipc.argParseCheckIPFormat, nargs='?',
default='127.0.0.1', help='My IP Address')
parser.add_argument('-p', metavar='My Port', dest='myPort', type=int, nargs='?',
default=20010, help='My port number')
parser.add_argument('-sip', metavar='Server IP', dest='serverIP', type=nbipc.argParseCheckIPFormat, nargs='?',
default='127.0.0.1', help='Server IP Address')
parser.add_argument('-sp', metavar='Server Port', dest='serverPort', type=int, nargs='?',
default=20000, help='Server port number')
parser.add_argument('-randcolors', dest='randomColors', action='store_true',
default=False, help='Randomizes bot colors in viewer')
parser.add_argument('-debug', dest='debug', action='store_true',
default=False, help='Print DEBUG level log messages.')
parser.add_argument('-verbose', dest='verbose', action='store_true',
default=False, help='Print VERBOSE level log messages. Note, -debug includes -verbose.')
args = parser.parse_args()
setLogLevel(args.debug, args.verbose)
d.srvIP = args.serverIP
d.srvPort = args.serverPort
log("Registering with Server: " + d.srvIP + ":" + str(d.srvPort))
try:
d.viewerSocket = nbipc.NetBotSocket(args.myIP, args.myPort, d.srvIP, d.srvPort)
reply = d.viewerSocket.sendRecvMessage({'type': 'addViewerRequest'}, retries=60, delay=1, delayMultiplier=1)
d.conf = reply['conf']
log("Server Configuration: " + str(d.conf), "VERBOSE")
except Exception as e:
log(str(e), "FAILURE")
quit()
log("Server registration successful. Opening Window.")
if args.randomColors:
random.shuffle(d.colors)
openWindow(d)
def main():
global botSocket # This is global so quit() can print stats in botSocket
global robotName
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-ip', metavar='My IP', dest='myIP', type=nbipc.argParseCheckIPFormat, nargs='?',
default='127.0.0.1', help='My IP Address')
parser.add_argument('-p', metavar='My Port', dest='myPort', type=int, nargs='?',
default=20010, help='My port number')
parser.add_argument('-sip', metavar='Server IP', dest='serverIP', type=nbipc.argParseCheckIPFormat, nargs='?',
default='127.0.0.1', help='Server IP Address')
parser.add_argument('-sp', metavar='Server Port', dest='serverPort', type=int, nargs='?',
default=20000, help='Server port number')
parser.add_argument('-debug', dest='debug', action='store_true',
default=False, help='Print DEBUG level log messages.')
parser.add_argument('-verbose', dest='verbose', action='store_true',
default=False, help='Print VERBOSE level log messages. Note, -debug includes -verbose.')
args = parser.parse_args()
setLogLevel(args.debug, args.verbose)
try:
botSocket = nbipc.NetBotSocket(args.myIP, args.myPort, args.serverIP, args.serverPort)
joinReply = botSocket.sendRecvMessage({'type': 'joinRequest', 'name': robotName}, retries=300, delay=1, delayMultiplier=1)
except nbipc.NetBotSocketException as e:
log("Is netbot server running at" + args.serverIP + ":" + str(args.serverPort) + "?")
log(str(e), "FAILURE")
quit()
log("Join server was successful. We are ready to play!")
# the server configuration tells us all about how big the arena is and other useful stuff.
srvConf = joinReply['conf']
log(str(srvConf), "VERBOSE")
# Now we can play, but we may have to wait for a game to start.
play(botSocket, srvConf)
def main():
global d # d is global so quit() can access it.
d = SrvData()
random.seed()
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-ip', metavar='Server_IP', dest='serverIP', type=nbipc.argParseCheckIPFormat,
default='127.0.0.1', help='My IP Address')
parser.add_argument('-p', metavar='Server_Port', dest='serverPort', type=int,
default=20000, help='My port number')
parser.add_argument('-name', metavar='Server_Name', dest='serverName', type=str,
default="Netbots Server", help='Name displayed by connected viewers.')
parser.add_argument('-games', metavar='int', dest='gamesToPlay', type=int,
default=10, help='Games server will play before quiting.')
parser.add_argument('-bots', metavar='int', dest='botsInGame', type=int,
default=4, help='Number of bots required to join before game can start.')
parser.add_argument('-stepsec', metavar='sec', dest='stepSec', type=float,
default=0.05, help='How many seconds between server steps.')
parser.add_argument('-stepmax', metavar='int', dest='stepMax', type=int,
default=1000, help='Max steps in one game.')
parser.add_argument('-droprate', metavar='int', dest='dropRate', type=int,
default=11, help='Drop over nth message, best to use primes. 0 == no drop.')
parser.add_argument('-msgperstep', metavar='int', dest='botMsgsPerStep', type=int,
default=4, help='Number of msgs from a bot that server will respond to each step.')
parser.add_argument('-arenasize', dest='arenaSize', type=int, min=100, max=32767, action=Range,
default=1000, help='Size of arena.')
parser.add_argument('-botradius', metavar='int', dest='botRadius', type=int,
default=25, help='Radius of robots.')
parser.add_argument('-explradius', metavar='int', dest='explRadius', type=int,
default=75, help='Radius of explosions.')
parser.add_argument('-botmaxspeed', metavar='int', dest='botMaxSpeed', type=int,
default=5, help="Robot distance traveled per step at 100%% speed")
parser.add_argument('-botaccrate', metavar='float', dest='botAccRate', type=float,
default=2.0, help='%% robot can accelerate (or decelerate) per step')
parser.add_argument('-shellspeed', metavar='int', dest='shellSpeed', type=int,
default=40, help='Distance traveled by shell per step.')
parser.add_argument('-hitdamage', metavar='int', dest='hitDamage', type=int,
default=10, help='Damage a robot takes from hitting wall or another bot.')
parser.add_argument('-expldamage', metavar='int', dest='explDamage', type=int,
default=10, help='Damage bot takes from direct hit from shell.')
parser.add_argument('-obstacles', metavar='int', dest='obstacles', type=int,
default=0, help='How many obstacles does the arena have.')
parser.add_argument('-obstacleradius', metavar='int', dest='obstacleRadius', type=int,
default=5, help='Radius of obstacles as %% of arenaSize.')
parser.add_argument('-jamzones', metavar='int', dest='jamZones', type=int,
default=0, help='How many jam zones does the arena have.')
parser.add_argument('-allowclasses', dest='allowClasses', action='store_true',
default=False, help='Allow robots to specify a class other than default.')
parser.add_argument('-simplecollisions', dest='simpleCollisions', action='store_true',
default=False, help='Uses the simple collision system, damage taken is the same as -hitdamage')
parser.add_argument('-startperms', dest='startPermutations', action='store_true',
default=False, help='Use all permutations of each set of random start locations.')
parser.add_argument('-scanmaxdistance', metavar='int', dest='scanMaxDistance', type=int,
default=1415, help='Maximum distance a scan can detect a robot.')
parser.add_argument('-noviewers', dest='noViewers', action='store_true',
default=False, help='Do not allow viewers.')
parser.add_argument('-maxsecstojoin', metavar='int', dest='maxSecsToJoin', type=int,
default=300, help='Max seconds server will wait for all bots to join before quiting.')
parser.add_argument('-onlylastsb', dest='onlyLastSb', action='store_true',
default=False, help='Only print the scoreboard when the server quits.')
parser.add_argument('-jsonsb', metavar='filename', dest='jsonScoreboard', type=str,
default=False, help='Save json formatted server data to filename before quiting.')
parser.add_argument('-debug', dest='debug', action='store_true',
default=False, help='Print DEBUG level log messages.')
parser.add_argument('-verbose', dest='verbose', action='store_true',
default=False, help='Print VERBOSE level log messages. Note, -debug includes -verbose.')
args = parser.parse_args()
setLogLevel(args.debug, args.verbose)
d.conf['serverName'] = args.serverName
d.conf['gamesToPlay'] = args.gamesToPlay
d.conf['botsInGame'] = args.botsInGame
d.conf['stepSec'] = args.stepSec
d.conf['stepMax'] = args.stepMax
d.conf['dropRate'] = args.dropRate
d.state['dropNext'] = args.dropRate
d.conf['botMsgsPerStep'] = args.botMsgsPerStep
d.conf['arenaSize'] = args.arenaSize
d.conf['botRadius'] = args.botRadius
d.conf['explRadius'] = args.explRadius
d.conf['botMaxSpeed'] = args.botMaxSpeed
d.conf['botAccRate'] = args.botAccRate
d.conf['shellSpeed'] = args.shellSpeed
d.conf['hitDamage'] = args.hitDamage
d.conf['explDamage'] = args.explDamage
d.conf['obstacleRadius'] = args.obstacleRadius
d.conf['obstacles'] = mkObstacles(d, args.obstacles)
d.conf['jamZones'] = mkJamZones(d, args.jamZones)
d.conf['allowClasses'] = args.allowClasses
d.conf['simpleCollisions'] = args.simpleCollisions
d.conf['startPermutations'] = args.startPermutations
d.conf['scanMaxDistance'] = args.scanMaxDistance
d.conf['noViewers'] = args.noViewers
d.conf['maxSecsToJoin'] = args.maxSecsToJoin
d.state['onlyLastSb'] = args.onlyLastSb
d.state['jsonScoreboard'] = args.jsonScoreboard
mkStartLocations(d)
log("Server Name: " + d.conf['serverName'])
log("Server Version: " + d.conf['serverVersion'])
log("Argument List:" + str(sys.argv))
log("Server Configuration: " + str(d.conf), "VERBOSE")
try:
d.srvSocket = nbipc.NetBotSocket(args.serverIP, args.serverPort)
except Exception as e:
log(str(e), "FAILURE")
quit()
nextStepAt = time.perf_counter() + d.conf['stepSec']
while True:
aliveBots = 0
for src, bot in d.bots.items():
if bot['health'] != 0:
aliveBots += 1
# only count slow steps if we actually process a step this time around.
countSlowStep = False
if aliveBots > 0: # if there is an ongoing game
countSlowStep = True
step(d)
elif len(d.bots) == d.conf['botsInGame']: # if we have enough bots to start playing
if not d.state['tourStartTime']:
d.state['tourStartTime'] = time.time()
if d.conf['gamesToPlay'] != d.state['gameNumber']:
if not d.state['onlyLastSb']:
logScoreboard(d)
initGame(d)
else:
log("All games have been played.")
jsonScoreboard(d)
quit()
elif d.conf['maxSecsToJoin'] < float(time.time() - d.state['startTime']):
log("Not enough bots joined game before max seconds to join (" + str(d.conf['maxSecsToJoin']) + " secs).", "ERROR")
if len(d.bots) >= 2:
d.conf['botsInGame'] = len(d.bots)
log("Starting game with only " + str(d.conf['botsInGame']) + " bots.", "WARNING")
else:
log("Cannot start game with less than 2 bots. Exiting.", "FAILURE")
quit()
recvReplyMsgs(d)
sendToViwers(d)
ptime = time.perf_counter()
if ptime < nextStepAt:
d.state['sleepCount'] += 1
d.state['sleepTime'] += nextStepAt - ptime
while ptime < nextStepAt:
ptime = time.perf_counter()
elif countSlowStep:
d.state['longStepCount'] += 1
log("Server running slower than " + str(d.conf['stepSec']) + " sec/step.", "VERBOSE")
nextStepAt = ptime + d.conf['stepSec']
def main():
q = Queue() # mouse event queue
arenaSize = 0
mouseDown = False # whether mouse button is pressed
waiting = False # whether waiting for explosion
global botSocket # This is global so quit() can print stats in botSocket
global robotName
global upKey
global downKey
global leftKey
global rightKey
global steering
global controller
# mmmmmm closure why do I do this?
def mousePressHandler(event):
nonlocal q
nonlocal arenaSize
nonlocal mouseDown
nonlocal waiting
global controller
mousePos = {"x": 0, "y": 0}
mouseDown = True
# event.x and event.y are in canvas coordinates, which are from
# the top left corner and are in terms of the canvas size. We want
# a location within arenaSize
ratio = arenaSize / controller.canvas.winfo_width()
mousePos["x"] = event.x * ratio
# TOP left corner, remember?
mousePos["y"] = (controller.canvas.winfo_width() - event.y) * ratio
q.put({"mousePos": mousePos})
q.put({"mouseDown": True}) # put this after or weird things happen
def mouseMoveHandler(event):
nonlocal arenaSize
nonlocal mouseDown
global controller
mousePos = {"x": 0, "y": 0}
if (mouseDown):
canvasSize = controller.canvas.winfo_width()
ratio = arenaSize / canvasSize
mousePos["x"] = event.x * ratio
mousePos["y"] = (canvasSize - event.y) * ratio
q.put({"mousePos": mousePos})
def mouseReleaseHandler(event):
nonlocal mouseDown
mouseDown = False
q.put({"mouseDown": False})
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-ip',
metavar='My IP',
dest='myIP',
type=nbipc.argParseCheckIPFormat,
nargs='?',
default='127.0.0.1',
help='My IP Address')
parser.add_argument('-p',
metavar='My Port',
dest='myPort',
type=int,
nargs='?',
default=20010,
help='My port number')
parser.add_argument('-sip',
metavar='Server IP',
dest='serverIP',
type=nbipc.argParseCheckIPFormat,
nargs='?',
default='127.0.0.1',
help='Server IP Address')
parser.add_argument('-sp',
metavar='Server Port',
dest='serverPort',
type=int,
nargs='?',
default=20000,
help='Server port number')
parser.add_argument('-debug',
dest='debug',
action='store_true',
default=False,
help='Print DEBUG level log messages.')
parser.add_argument(
'-verbose',
dest='verbose',
action='store_true',
default=False,
help='Print VERBOSE level log messages. Note, -debug includes -verbose.'
)
parser.add_argument("-vp",
metavar="Viewer/Controller Port",
dest="viewerPort",
type=int,
nargs="?",
default=20018,
help="Viewer/Controller port number")
# account for movement keys
parser.add_argument("-up",
metavar="Up Key",
dest="upKey",
type=str,
nargs="?",
default="Up",
help="Up movement key")
parser.add_argument("-down",
metavar="Down Key",
dest="downKey",
type=str,
nargs="?",
default="Down",
help="Down movement key")
parser.add_argument("-left",
metavar="Left Key",
dest="leftKey",
type=str,
nargs="?",
default="Left",
help="Left movement key")
parser.add_argument("-right",
metavar="Right Key",
dest="rightKey",
type=str,
nargs="?",
default="Right",
help="Right movement key")
# determine whether should use directional movement or steering
parser.add_argument('-directional',
dest='directional',
action='store_true',
default=False,
help='Use directional movement instead of steering')
args = parser.parse_args()
setLogLevel(args.debug, args.verbose)
upKey = args.upKey
downKey = args.downKey
leftKey = args.leftKey
rightKey = args.rightKey
if (args.directional):
steering = False
try:
botSocket = nbipc.NetBotSocket(args.myIP, args.myPort, args.serverIP,
args.serverPort)
joinReply = botSocket.sendRecvMessage({
'type': 'joinRequest',
'name': robotName
})
except nbipc.NetBotSocketException as e:
log("Is netbot server running at" + args.serverIP + ":" +
str(args.serverPort) + "?")
log(str(e), "FAILURE")
quit()
log("Join server was successful. We are ready to play!")
#the server configuration tells us all about how big the arena is and other useful stuff.
srvConf = joinReply['conf']
log(str(srvConf), "VERBOSE")
# controller is a viewer that needs information: but the IP and port
# info must NOT BE THE SAME as the bot's, otherwise the server will boot us
controller = botctrl.createController(args.myIP, args.viewerPort,
args.serverIP, args.serverPort)
# Don't snitch to Ms. Wear that I didn't use proper encapsulation
controller.window.title("NetBots (Controlling " + robotName + ")")
# set key handling functions
controller.setKeyPressHandler(keyPressHandler)
controller.setKeyReleaseHandler(keyReleaseHandler)
arenaSize = srvConf["arenaSize"]
controller.setMousePressHandler(mousePressHandler)
controller.setMouseMoveHandler(mouseMoveHandler)
controller.setMouseReleaseHandler(mouseReleaseHandler)
#Now we can play, but we may have to wait for a game to start.
playThread = threading.Thread(target=play, args=(botSocket, srvConf, q))
playThread.start()
# start updating window
# use controller.window.mainloop() for a simpler click to shoot, and no dir lines
# otherwise you probably want something like:
# while(playThread.is_alive()):
# # optional: dir line should go here
# controller.window.update()
controller.window.mainloop()
# I have no idea what happens here. I think this is what you do...
playThread.join()
controller.window.destroy()
def main():
d = ViewerData()
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-ip',
metavar='My IP',
dest='myIP',
type=nbipc.argParseCheckIPFormat,
nargs='?',
default='127.0.0.1',
help='My IP Address')
parser.add_argument('-p',
metavar='My Port',
dest='myPort',
type=int,
nargs='?',
default=20010,
help='My port number')
parser.add_argument('-sip',
metavar='Server IP',
dest='serverIP',
type=nbipc.argParseCheckIPFormat,
nargs='?',
default='127.0.0.1',
help='Server IP Address')
parser.add_argument('-sp',
metavar='Server Port',
dest='serverPort',
type=int,
nargs='?',
default=20000,
help='Server port number')
parser.add_argument('-debug',
dest='debug',
action='store_true',
default=False,
help='Print DEBUG level log messages.')
parser.add_argument(
'-verbose',
dest='verbose',
action='store_true',
default=False,
help='Print VERBOSE level log messages. Note, -debug includes -verbose.'
)
args = parser.parse_args()
setLogLevel(args.debug, args.verbose)
d.srvIP = args.serverIP
d.srvPort = args.serverPort
log("Registering with Server: " + d.srvIP + ":" + str(d.srvPort))
try:
d.viewerSocket = nbipc.NetBotSocket(args.myIP, args.myPort, d.srvIP,
d.srvPort)
reply = d.viewerSocket.sendRecvMessage({'type': 'addViewerRequest'})
d.conf = reply['conf']
log("Server Configuration: " + str(d.conf), "VERBOSE")
except Exception as e:
log(str(e), "FAILURE")
quit()
log("Server registration successful. Opening Window.")
openWindow(d)
