def make_unit(name: str, pos: int, off_board: bool) -> Unit:
"""Template function to construct a unit"""
return Unit(name, 'troopers', pos, Strategy.CHARGE, [
make_piece("Sergent {}".format(generate_name()), True, False),
make_piece("Gunner {}".format(generate_name()), False, True)] + [
make_piece("Guardsman {}".format(generate_name()), False, False) for i in range(8)],
{'infantry'}, off_board)
def generate_name(race):
race = race.lower()
if race == "half-elf":
race = "elf" if roll.parse("d2") == 1 else "human"
elif "orc" in race:
race = "orc" if roll.parse("d2") == 1 else "human"
elif race == "tiefling" and roll.parse("d2") == 2:
race = "human"
if roll.parse("d4") < 4:
return names.generate_name(race) + " " + names.generate_name(race)
return names.generate_name(race)
def main():
coloredlogs.install(level=logging.INFO, show_hostname=False)
publisher = zmq_context.socket(zmq.PUB)
publisher.bind('tcp://0.0.0.0:8888')
poller = zmq.Poller()
poller.register(publisher, zmq.POLLOUT)
logger.info("listening on tcp://0.0.0.0:8888")
MAX = 200
index = 0
while True:
if index > MAX:
url = 'stop'
else:
url = generate_name()
index += 1
try:
socks = dict(poller.poll(0.3))
if publisher in socks and socks[publisher] == zmq.POLLOUT:
logger.info("sending data %s", url)
publisher.send(b" ".join([b'status', bytes(url)]))
if url == 'stop':
break
else:
time.sleep(.13)
except KeyboardInterrupt:
publisher.close()
zmq_context.term()
raise SystemExit
def __init__(self, clustersize):
self.name = generate_name()
self.pos = (random.randrange(clustersize), random.randrange(clustersize))
while Star.all_ and min(self.distance(s) for s in Star.all_) < 40:
self.pos = (random.randrange(clustersize), random.randrange(clustersize))
self.mass = lograndom(0.7, 1.4)
self.color = usecolorstring(
(self.mass - 0.7) / 0.7, [(0, 128, 255), (255, 255, 255), (255, 255, 0), (255, 0, 0)]
)
self.planets = [Planet(self, i) for i in range(3)]
Star.all_.append(self)
def generate_npc(race, gender, level, show_stats):
global active_location
if race.lower() not in constants.ALLOWED_RACES:
click.echo("'%s' is not an allowed race" % race)
return
# Check gender
if gender.lower() not in constants.ALLOWED_GENDERS:
click.echo("'%s' is not an allowed gender" % gender)
return
# Build name
first, last = names.generate_name(race, gender)
click.echo("\n\n\n-------------------------------------------")
click.echo(click.style("{f} {l}\n".format(f=first, l=last), fg="magenta"))
click.echo(click.style("PERSONALITY : ", fg="yellow", bold=True) + "nothing")
click.echo(click.style("IDEAL : ", fg="yellow", bold=True) + "nothing")
click.echo(click.style("BOND : ", fg="yellow", bold=True) + "nothing")
click.echo(click.style("FLAW : ", fg="yellow", bold=True) + "nothing")
click.echo("-------------------------------------------\n\n\n")
should_we_save = click.confirm("Save NPC?", default=False)
# Check location
if not active_location:
active_location = click.prompt("No location set. Where are you?", type=str)
if should_we_save:
fieldnames = ['first_name', 'last_name', 'race', 'gender', 'location']
file_name = 'characters.csv'
# Check that file exist and has headers
if not os.path.isfile(file_name):
with open(file_name, 'wb') as check:
writer = csv.DictWriter(check, fieldnames=fieldnames)
writer.writeheader()
# Write to file
with open(file_name, 'a') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writerow({
'first_name': first,
'last_name': last,
'race': race.lower(),
'gender': gender.lower(),
'location': active_location
})
def sample_suburb(min_sa1s=1, max_sa1s=16):
n_sa1s = numpy.random.randint(min_sa1s, max_sa1s + 1)
sa1s = [sample_sa1() for _ in range(n_sa1s)]
# Aggregate SA1s into a suburb.
d = dict(
id=numpy.random.randint(50000, 1000000),
name=names.generate_name(),
)
meanable = 'religious', 'unemployment', 'rental_rate', 'median_rent', 'income'
for m in meanable:
d[m] = numpy.nanmean([c[m] for c in sa1s])
d['income_level'] = int(round(numpy.nanmean([c['income_level'] for c in sa1s])))
d['population'] = int(numpy.nansum([c['population'] for c in sa1s]))
d['zoning'] = {k: 0 for k in 'RCIPWU'}
d['businesses'] = list(numpy.mean([c['businesses']
for c in sa1s], axis=0))
for c in sa1s:
for z in d['zoning']:
d['zoning'][z] += c['zoning'].get(z, 0) / len(sa1s)
d['areas'] = sa1s
return d
def __init__(self, parent, index):
self.parent = parent
self.index = index
self.mass = lograndom(10 ** -2, 70) * 10 ** index
self.distance = lograndom(0.03, 0.3) * 10 ** index
self.metals = OrderedDict((m, random.random() ** 3) for m in metals())
self.solvents = OrderedDict((s, random.random() ** 3) for s in solvents())
self.dispsize = (log_to_rel(self.mass, 10 ** -2, 7000) + 0.1) * 20
self.dispdist = log_to_rel(self.distance, 0.03, 300) * 300 + 100
self.color = usecolorstring(log_to_rel(self.mass, 10 ** -2, 7000), [(127, 127, 127), (255, 255, 127)])
self.structures = [Structure(self) for _ in range(5)]
self.name = generate_name()
self.owner = None
self.storage = Counter(self.solvents.keys())
self.storage.update(self.metals.keys())
self.population = 0
self.temperature_max = 300 / self.distance / self.parent.mass
self.temperature_min = self.temperature_max * 0.8
self.pressure = self.mass ** 1 / 3
self.active_solvent = find_solvent(self.temperature_max, self.pressure)
self.buildable = self.active_solvent is not None
self.autofire = True
self.counter = 0
self.pos = self.decide_pos()
def directory_name(generator=random):
'''
Generates a random directory name, which is an alphanumeric string of
length 1 to 32, selected from a bell curve
'''
return names.generate_name(32, generator)
def application(environ, start_response):
ctype = 'text/plain'
name = None
if environ['REQUEST_METHOD'] == 'POST' and environ.get('CONTENT_LENGTH', 0):
ctype = "image/jpeg"
# Get rid of headers.
stream = environ['wsgi.input']
while len(stream.readline().strip()):
pass
# Save as temporary file
fp = tempfile.NamedTemporaryFile()
fp.write(stream.read())
with tempfile.TemporaryDirectory() as d:
name = names.generate_name() + ".jpg"
tmp_name = d + name
# Now call ImageMagick
os.system("convert {0} -gravity center -crop 582x328+0+0 - | "
"convert - {1}/watermark.png -gravity southeast "
"-composite {2}".format(fp.name,
environ["OPENSHIFT_REPO_DIR"],
tmp_name))
with open(tmp_name, 'rb') as out_fp:
response_body = out_fp.read()
elif environ['PATH_INFO'] == '/juice':
response_body = ['%s: %s' % (key, value)
for key, value in sorted(environ.items())]
response_body = '\n'.join(response_body)
else:
ctype = 'text/html'
response_body = '''
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content="Deges">
<title>Hitler was pretty OK I guess.</title>
<!-- https://i.imgur.com/jIxVqZA.jpg -->
</head>
<body style="background-color: black; color: black">
<form action="/juice" method="post" enctype="multipart/form-data">
<input type="file" name="pic" accept="image/*">
<input type="submit">
</form>
<img src="http://pospolitost.sk/potoo.jpeg" style="position: absolute; right: 20%; bottom: 0px">
</body>
</html>
'''
if ctype.startswith('text'):
response_body = response_body.encode('utf-8')
status = '200 OK'
response_headers = [('Content-Type', ctype),
('Content-Length', str(len(response_body)))]
if name:
response_headers.append(('Content-Disposition',
"attachment; filename=\"{0}\"".format(name)))
start_response(status, response_headers)
return [response_body]
def do_name(self, string):
name = names.generate_name(string)
while len(name) < 3:
name = names.generate_name(string)
print name
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import zmq
import time
from names import generate_name
port = "5560"
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.connect("tcp://localhost:%s" % port)
server_id = generate_name()
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN | zmq.POLLOUT)
colors = {
'bold': '\033[1m',
'red': '\033[31m',
'yellow': '\033[33m',
'green': '\033[32m',
'blue': '\033[34m',
'magenta': '\033[35m',
'cyan': '\033[36m',
'white': '\033[37m',
'normal': '\033[0m',
}
from __future__ import unicode_literals
import zmq
import time
import random
from names import generate_name
context = zmq.Context()
port = "5559"
print "Connecting to server..."
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:{}".format(port))
client_id = generate_name()
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN | zmq.POLLOUT)
colors = {
'bold': '\033[1m',
'red': '\033[31m',
'yellow': '\033[33m',
'green': '\033[32m',
'blue': '\033[34m',
'magenta': '\033[35m',
'cyan': '\033[36m',
'white': '\033[37m',
'normal': '\033[0m',
}
def register(ws_subject: WSSubject, i):
name = generate_name()
return Player(i, name,
ws_subject,
START_SIZE, copy(START_POS))
def directory_name(generator=random):
'''
Generates a random directory name, which is an alphanumeric string of
length 1 to 32, selected from a bell curve
'''
return names.generate_name(32, generator)
def name():
return jsonify({'names': [generate_name() for x in range(10)]})
import time
import zmq
from names import generate_name
# FRB prefix so it won't clash with auto generated variables of docker compose
queue_host = os.environ.get("FRB_QUEUE_HOST", "localhost")
port = os.environ.get("FRB_SERVER_PORT", "5560")
context = zmq.Context()
socket = context.socket(zmq.REP)
connection = "tcp://{}:{}".format(queue_host, port)
print 'connection', connection, queue_host, port
socket.connect(connection)
server_id = generate_name()
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN | zmq.POLLOUT)
colors = {
'bold': '\033[1m',
'red': '\033[31m',
'yellow': '\033[33m',
'green': '\033[32m',
'blue': '\033[34m',
'magenta': '\033[35m',
'cyan': '\033[36m',
'white': '\033[37m',
'normal': '\033[0m',
}
