def template_Run(self, n, svr_do_sync, user_do_sync):
assert svr_do_sync == user_do_sync
k = MockKeyboard()
k.inputs = [1]*30+[0]*100
r = NullRenderer()
conf = GameConfig()
conf.player_size = n
conf.frames_per_sec = 32767
conf.game_length = 0.05
conf.post_game_time = 0
conf.do_sync = svr_do_sync
conf.sync_timeout = 0.1
conf.sync_rate = 100
conf.buffer_size = 64
# Try to avoid clients dying at the end of handshake.
test_tries = 40
status = 0
for i in range(0, test_tries):
s = UDPSocket()
s.Open()
s.Bind(('', 0))
svraddr = s.sock.getsockname()
ps = []
qs = []
clients = []
# Try only once here. In case of server failure and client success,
# we must re-run the test as a whole.
server_tries = 1
server_timeout = 0.5
client_tries = 1
# Send only once. To keep tests short, games run only briefly.
# If the resend happens after the game is ended, the test fails.
client_resend = 1
client_timeout = 0.5
user_conf = GameConfig()
user_conf.do_sync = user_do_sync
user_conf.sync_timeout = conf.sync_timeout * n
for i in range(0, n):
q = multiprocessing.Queue()
c = UDPClient()
p = multiprocessing.Process(target=\
UDPServerTestPickleJar_Run,
args=(client_tries, client_resend, client_timeout,
c, svraddr, r, k, user_conf, q))
p.start()
ps.append(p)
qs.append(q)
svr = UDPServer()
svr.buffer_time = 0
try:
status = svr.Run(s, False, conf, server_tries, server_timeout)
except Exception as ex:
logger.exception(ex)
status = 100 # Error in the server, stop the test
results = []
for i in range(0, n):
results.append(qs[i].get())
ps[i].join()
s.Close()
self.assertTrue(status != 100)
if status == 0:
break
self.assertTrue(status == 0)
for i in range(0, n):
self.assertTrue(results[i])
parser.add_argument('--port', type=int, default=8090, help='The port.')
parser.add_argument('-i', '--interpolate', action='store_true',
default=False, help='Enable interpolation')
parser.add_argument('-b', '--buffersize', type=int, default=64,
help='Number of records to keep.')
parser.add_argument('--tries', type=int, default=60,
help='The number of attempts to connect to the server.')
parser.add_argument('--resend', type=int, default=9,
help='The number of duplicate messages to send during handshake.')
parser.add_argument('--timeout', type=int, default=10,
help='The time allowed for each connection and handshake.')
parser.add_argument('--nosync', default=False, action='store_true',
help='Allow server to measure latency and clock.')
parser.add_argument('--synctimeout', type=int, default=3,
help='The timeout for RecvSync.')
args = parser.parse_args()
conf = GameConfig()
conf.do_interpolate = args.interpolate
conf.buffer_size = args.buffersize
conf.do_sync = not args.nosync
conf.sync_timeout = args.synctimeout
c = UDPClient()
from renderer import Renderer
r = Renderer()
# For now, nothing in server's conf affects renderer.
r.Init()
conf.ApplyRenderer(r)
if not c.Run((args.ip, args.port), r, r, conf, args.tries, args.resend,
args.timeout):
print('Timed out.')
