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 leader, follower # This is global so quit() can access them.
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)
# Create shared data.
leaderData = sharedData()
followerData = sharedData()
# Create robot thread objects, each need to use a different port number since they both will open a socket.
robotPort = args.myPort
leader = Leader("Team Leader", args.myIP, robotPort, args.serverIP, args.serverPort, leaderData, followerData)
robotPort += 1
follower = Follower("Team Follower", args.myIP, robotPort, args.serverIP, args.serverPort, followerData, leaderData)
# Start threads. This will call the run() method.
leader.start()
follower.start()
# Wait for leader and follower to both end
while leader.isAlive() or follower.isAlive():
time.sleep(1)
# Both threads have returned. Print stats and exit.
for bot in (leader, follower):
log("=====================================")
log("=== " + bot.name)
log("=====================================")
log(bot.botSocket.getStats())
exit()
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():
global bots, botsMax, botsInDivision, serverMax
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-robots', metavar='dir', dest='robotsDir', type=str,
required=True, help='Directory containing only robots to use in tournaments. Must be exactly one level under netbots base dir and given relative to netbots base dir (eg. myrobots).')
parser.add_argument('-output', metavar='dir', dest='outputDir', type=str,
required=True, help='Full directory path to send output. Directory should exist and be empty. (eg. /tmp/tournament.2020-50-02-11:37:23)')
parser.add_argument('-copy', dest='copy', action='store_true', default=False, help='Copy robots dir to output dir.')
parser.add_argument('-md5sum', dest='md5sum', action='store_true', default=False, help='Print MD5sum for each robot.')
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()
outputDir = args.outputDir
robotsDir = args.robotsDir
setLogLevel(args.debug, args.verbose)
if os.path.isdir(outputDir):
log("Using existing output directory: " + outputDir)
else:
os.mkdir(outputDir)
log("Created output directory: " + outputDir)
setLogFile(os.path.join(outputDir,"output.txt"))
resultsfilename = os.path.join(outputDir,"results.txt")
# pick random ports for robots. These port numbers will be assigned to a robot for the entire tournament.
ports = random.sample(range(20100,20199), botsMax)
# Read robot filenames and assign port.
bots = {}
for file in os.listdir(robotsDir):
if os.path.isfile(os.path.join(robotsDir, file)) and not file.startswith('.'):
try:
port = ports.pop()
except:
log("Only " + botsMax + " robots can be in robots dir.","FAILURE")
quit()
log("Adding bot " + file + " at port " + str(port))
bots['127.0.0.1:' + str(port)] = {'port': port, 'file': file}
if args.md5sum:
p = subprocess.Popen(["md5sum",os.path.join(robotsDir, file)], stdout=subprocess.PIPE, stderr=sys.stdout.buffer)
log("md5sum " + p.stdout.read().decode("utf-8").rstrip())
if len(bots) % botsInDivision != 0:
log("Number of bots does not divide evenly into divisions, len(bots) % botsInDivision must equal 0: " + \
f" {len(bots)} % {botsInDivision} == {len(bots) % botsInDivision}","FAILURE")
quit()
if args.copy:
p = subprocess.Popen(["cp", "-r", robotsDir, os.path.join(outputDir, "robots")], stdout=subprocess.PIPE, stderr=sys.stdout.buffer)
log("Robots copied to " + os.path.join(outputDir, "robots") + p.stdout.read().decode("utf-8").rstrip())
divisionsTotal = int(len(bots) / botsInDivision)
log(f"Creating {divisionsTotal} divisions with {botsInDivision} bots in each.")
# Put robots randomly into divisionsTotal divisions, botsInDivision robots in each.
# divisions contains only keys to the bots dict.
divisions = []
for i in range(divisionsTotal):
divisions.append([])
next = 0
for k in bots.keys():
divisions[next % divisionsTotal].append(k)
next += 1
maxRound = divisionsTotal*2-1 # first round is 0 so "maxRound = 7" would run 8 rounds.
log(f"Max rounds set to {maxRound+1}.")
round = -1
lastRoundResult = ""
while round < maxRound and lastRoundResult != str(divisions):
round += 1
lastRoundResult = str(divisions)
log("R" + str(round) + ": Starting Round")
roundDir = os.path.join(outputDir,"round-" + str(round))
os.mkdir(roundDir)
# Run Cross Divisions if there is more than one division
# and this is not the first round (0).
# This is how robots move between divisions.
if divisionsTotal > 1 and round != 0:
# top 2 robots in first division and last 2 robots in last division do not move
# Put remaining bots into cross divisions to see if they move between divisions
# !!! ASSUMES botsInDivition == 4
crossDivisions = []
for divisionNumber in range(divisionsTotal-1):
crossDivisions.append([
divisions[divisionNumber][2],
divisions[divisionNumber][3],
divisions[divisionNumber+1][0],
divisions[divisionNumber+1][1]
])
serverPort = 20000
for divisionNumber in range(divisionsTotal-1):
# if serverMax server threads are already running then wait for one to finish
while threading.active_count() - 1 == serverMax:
time.sleep(1)
# Start running a new division
divisionDir = os.path.join(roundDir, "crossdivision-" + str(divisionNumber) + "x" + str(divisionNumber+1))
divisionName = "R" + str(round) + "D" + str(divisionNumber) + "x" + str(divisionNumber+1)
t = threading.Thread(target=rundivision,
args=(bots, divisionName, divisionDir, robotsDir, crossDivisions[divisionNumber], serverPort),
daemon=True)
t.start()
serverPort += 1
# Wait for all threads to finish.
while threading.active_count() > 1:
time.sleep(1)
for b in range(divisionsTotal-1):
# !!! ASSUMES botsInDivition == 4
# Put top 2 robots from second chance divisions into upper divisions
divisions[b][2] = crossDivisions[b][0]
divisions[b][3] = crossDivisions[b][1]
# Put bottom 2 robots from second chance divisions into lower divisions
divisions[b+1][0] = crossDivisions[b][2]
divisions[b+1][1] = crossDivisions[b][3]
# Run each division and put robots in division in order of points.
serverPort = 20000
for divisionNumber in range(divisionsTotal):
# if serverMax server threads are already running then wait for one to finish
while threading.active_count() - 1 == serverMax:
time.sleep(1)
# Start running a new division
divisionDir = os.path.join(roundDir, "division-" + str(divisionNumber))
divisionName = "R" + str(round) + "D" + str(divisionNumber)
t = threading.Thread(target=rundivision,
args=(bots, divisionName, divisionDir, robotsDir, divisions[divisionNumber], serverPort),
daemon=True)
t.start()
serverPort += 1
# Wait for all threads to finish.
while threading.active_count() > 1:
time.sleep(1)
# Output Results
output = "\n" + \
" RESULTS AFTER " + str(round+1) + " ROUNDS" + \
"\n\n" + \
" ---- Score ----- ------ Wins ------- --------- CanonFired ----------\n" + \
" Name Points % Count AvgHealth Count AvgDamage TotDamage MS% IP:Port\n" + \
" ------------------------------------------------------------------------------------------------------------------\n"
for divisionNumber in range(divisionsTotal):
output += "DIVISION " + str(divisionNumber)
roundoutput = os.path.join(roundDir, "division-" + str(divisionNumber), "server.output.txt")
p = subprocess.Popen(["grep", "-m1", "-A", str(botsInDivision), "\------------------", roundoutput], stdout=subprocess.PIPE, stderr=sys.stdout.buffer)
tmp = p.stdout.read().decode("utf-8")
output += re.sub(r'---*','',tmp)
output += "\n"
with open(resultsfilename,"a+") as f:
f.write(output)
log("R" + str(round) + ": Results written to " + resultsfilename)
log("R" + str(round) + ": Completed Round")
if round == maxRound:
log(f"Quiting because max rounds ({maxRound + 1}) completed.")
if lastRoundResult == str(divisions):
log("Quiting because no change in results of last two rounds.")
quit()
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)
