def PersonalityTraits1000(method, num=3):
results = []
if method == "1000words":
results = PersonalityTraits1000Tab.useRepeatedly(num, unique=True)
elif method == "100words":
results = PersonalityTraits100Tab.useRepeatedly(num, unique=True)
else:
return 'Method is not supported. Supported methods are: 1000words and 100words.'
if request.query.format == '' or request.query.format == 'html':
return formatting.html(results)
elif request.query.format == 'htmlText':
return '<pre>' + formatting.text(results) + '</pre>'
elif request.query.format == 'json':
#return json.dumps(results, default=lambda o: o.__dict__,
# sort_keys=True, indent=4)
return Rpggen.toJson(results)
elif request.query.format == 'jsonHtml':
return '<pre>' + Rpggen.toJson(results) + '</pre>'
elif request.query.format == 'text':
return formatting.text(results)
else:
return (
'Unknown format query variable.'
' Right now, only "text", "html", "htmlText, and "htmlPage" is supported.'
)
def test_uniqueList3(self):
tab = Table("test1", ['one','two','three','four'], unique=True)
res1 = Rpggen.finduse('test1')
self.assertEqual(res1,'two')
tab.clear()
res2 = Rpggen.finduse('test1')
self.assertEqual(res2,'two')
def doMusteringOut(self, character):
# CE31
# Calculate pension
if character.rank > 4:
character.money['pension'] = 2000 * character.rank
character.history.append('Got a pension of %d' %
character.money['pension'])
# Calculate number of benefits
benefitCount = character.terms
if character.rank >= 4:
benefitCount = character.rank - 2
# Divide between cash and material
cashBenefits = 0
materialBenefits = 0
if benefitCount < 3:
cashBenefits = benefitCount
elif 3 <= benefitCount:
cashBenefits = 2
materialBenefits = benefitCount - 2
character.history.append(
'Ended up with %d cash and %d material benefits' %
(cashBenefits, materialBenefits))
for num in range(cashBenefits):
benefit = Rpggen.finduse('CashBenefits')
character.money['bank'] += Traveller.str2cr(benefit)
character.history.append(benefit)
for num in range(materialBenefits):
benefit = Rpggen.finduse('MaterialBenefits')
if benefit.startswith('+'):
character.changeStr(benefit)
else:
character.possessions.append(benefit)
character.history.append(benefit)
def __init__(self):
super().__init__()
Rpggen.clear()
try:
Rpggen.load("Setting.rpggen")
except:
print('Warning: could not find data file Setting.rpggen.')
print(sys.exc_info()[1])
def reload():
global table
global tableFormat
if tableFormat == 'json':
Rpggen.load(sys.argv[1])
table = Rpggen.find(sys.argv[2])
else:
table = Rpggen.loadLt(sys.argv[2])
return 'Reloaded the %s data file.' % sys.argv[1]
def test_createDict3(self):
tab = Table("test1", {'roll': '2d2', '2':'two', '3-4': 'threefour'})
res1 = Rpggen.finduse('test1')
self.assertEqual(res1,'threefour')
res2 = Rpggen.finduse('test1')
self.assertEqual(res2,'threefour')
values = tab.results()
values.sort()
self.assertEqual(values,['threefour','two'])
def test_createDict(self):
tab = Table("test1", {'1':'one','2': 'two'})
res1 = Rpggen.finduse('test1')
self.assertEqual(res1,'two')
res2 = Rpggen.finduse('test1')
self.assertEqual(res2,'two')
values = tab.results()
values.sort()
self.assertEqual(values,['one','two'])
def test_createList(self):
tab = Table("test1", ['one','two','three','four'])
res1 = Rpggen.finduse('test1')
self.assertEqual(res1,'two')
res2 = Rpggen.finduse('test1')
self.assertEqual(res2,'two')
values = tab.results()
values.sort()
self.assertEqual(values,['four','one','three','two'])
def test_uniqueFull(self):
tab = Table("test8", ['one','two','three','four'], unique=True)
res1 = Rpggen.finduse('test8')
self.assertEqual(res1,'two')
res2 = Rpggen.finduse('test8')
self.assertEqual(res2,'one')
res3 = Rpggen.finduse('test8')
self.assertEqual(res3,'three')
res4 = Rpggen.finduse('test8')
self.assertEqual(res4,'four')
def test_uniqueFull2(self):
tab = Table("test8", ['one','two','three','four'], unique=True)
res1 = Rpggen.finduse('test8')
self.assertEqual(res1,'two')
res2 = Rpggen.finduse('test8')
self.assertEqual(res2,'one')
res3 = Rpggen.finduse('test8')
self.assertEqual(res3,'three')
res4 = Rpggen.finduse('test8')
self.assertEqual(res4,'four')
# Expect/want the exception here
self.assertRaises(ValueError,tab.use)
def roll(cls, target=None, dm=None, dice=None, debug=False):
if debug:
print('roll(%s, %s, %s)' % (dice, target, dm))
got = Rpggen.roll("2d6")
if dice is not None:
if type(dice) == int:
got = Rpggen.roll(str(dice) + "d6")
if type(dice) == str:
got = Rpggen.roll(dice)
if debug:
logging.debug('raw roll %d' % got)
dmValue = 0
if dm is not None:
if type(dm) == int:
got = got + dm
if type(dm) == str:
dmMatch = re.search(r"^([+-]?)([0123456789]+)$", dm)
dmDir = dmMatch.group(1)
if dmDir is None: dmDir = '+'
dmValue = int(dmMatch.group(2))
if dmDir == '+':
got = got + dmValue
elif dmDir == '-':
got = got - dmValue
if target is None:
#print('returning %d' % got)
return got
targetMatch = re.search(r"^([0123456789]+)([+-]?)$", target)
#print(targetMatch)
if targetMatch is None:
raise ValueError(
'In Traveller.roll(), target of %s matched noting' % target)
targetNum = int(targetMatch.group(1))
targetCmp = targetMatch.group(2)
if debug:
print('%s %d %d' % (targetCmp, got, targetNum))
if targetCmp is None:
return got == targetNum
elif targetCmp == '+':
return got >= targetNum
elif targetCmp == '-':
return got <= targetNum
else:
raise ValueError('In roll(), target string (%s) is malformed.' %
target)
def createRandomlyTopdown(self):
'''Very simple random character creator.
'''
self.history.append('--> Using Topdown randomly')
self.createUpToCareer()
self.terms = Rpggen.roll('1d7')
self.age = 18 + self.terms * 4
self.lastCareer = 'Corporate Repo'
if self.terms == 1:
numSkills = 3
elif self.terms == 2:
numSkills = 5
else:
numSkills = (self.terms - 1) * 2 + Rpggen.roll('2d2')
for nSkill in range(numSkills):
skillLevel = Rpggen.roll('1d4-1')
skillName = Rpggen.finduse("skills")
self.skills.append(Attribute(skillName, skillLevel))
def youngthug():
yt = YoungThug()
yt.generate()
if request.query.format == '' or request.query.format == 'html':
return yt.html()
elif request.query.format == 'htmlText':
return yt.htmlText()
elif request.query.format == 'text':
return yt.strSmall()
elif request.query.format == 'htmlPage':
return yt.htmlPage()
elif request.query.format == 'json':
return Rpggen.toJson(yt)
elif request.query.format == 'jsonHtml':
return '<pre>' + Rpggen.toJson(yt) + '</pre>'
else:
return (
'Unknown format query variable.'
' Right now, only "text", "html", and "htmlPage" is supported.')
def createUpToCareer(self):
self.history.append('Birth')
self.name = GetFromWeb.get('names')
self.lastCareer = "No Career"
self.terms = 0
self.age = 18
self.str = Rpggen.roll('2d6')
self.dex = Rpggen.roll('2d6')
self.end = Rpggen.roll('2d6')
self.int = Rpggen.roll('2d6')
self.edu = Rpggen.roll('2d6')
self.soc = Rpggen.roll('2d6')
def doOneTerm(self, character, debug=False):
'''Adds one term to a character.
Returns None if the career continues, or a string if the career
ends, the string stating why the career ends.
'''
if debug:
print('entering doOneTerm')
character.history.append('Starting a new term.')
if character.terms == 7:
result = 'Aged out of career.'
character.history.append(result)
return result
if not character.checkStr(self.config['survival']):
result = 'Did not survive.'
character.history.append(result)
return result
character.terms += 1
character.age += 4
# TODO use funciton here
which = self.whichAdvantage.use()
adv = Rpggen.finduse(which)
character.changeStr(adv)
print('rank %d' % character.rank)
if character.rank == 0:
print('foo')
if character.checkStr(self.config['commission']):
character.history.append('Was commissioned')
character.rank = 1
newSkill = self.config['Skills'][character.rank - 1]
if newSkill is not None:
character.changeStr(newSkill)
else:
if character.checkStr(self.config['advancement']):
character.history.append('Advanced in rank.')
character.rank += 1
newSkill = self.config['Skills'][character.rank - 1]
if newSkill is not None:
character.changeStr(newSkill)
if self.roll('reenlistment'):
return 'Could not reenlist.'
return None
def equipmentTableOrDefault(self, weapon, default=None):
'''Note that this function assumes a table with name 'WeaponsX' for each skill with a
specialization of X. If oneis not found, then default is used, and if default is not
set, then the specialization is used as a possetion. (Which actually works better than
you would expect.)
'''
if default is None:
default = weapon
tableName = 'Weapons'+weapon
try:
equipment = Rpggen.finduse(tableName)
if equipment is None or equipment == '':
logging.warning('Using equipment table %s returned None or "".' % tableName)
else:
self.equipment.append(equipment)
except:
logging.warning('Table %s not found, but should have been in Settings.rpggen.' %
tableName)
logging.warning(sys.exc_info()[1])
self.equipment.append(default+' Weapon')
def createUpToCareer(self):
'''Creates a character up to their first career.
Just roll up basic attributes.
'''
self.history.append('Birth')
self.name = GetFromWeb.get('names')
self.lastCareer = "No Career"
self.terms = 0
self.age = 18
self.str = Rpggen.roll('2d6')
self.dex = Rpggen.roll('2d6')
self.end = Rpggen.roll('2d6')
self.int = Rpggen.roll('2d6')
self.edu = Rpggen.roll('2d6')
self.soc = Rpggen.roll('2d6')
self.history.append('At 18 has: %s' % self.strUpp())
def doBasicTraining(self, character):
# TODO put in seperate function
character.history.append('In basic training')
which = self.whichAdvantage.use()
adv = Rpggen.finduse(which)
character.changeStr(adv)
@route('/yt')
def youngthug():
yt = YoungThug()
yt.generate()
if request.query.format == '' or request.query.format == 'html':
return yt.html()
elif request.query.format == 'htmlText':
return yt.htmlText()
elif request.query.format == 'text':
return yt.strSmall()
elif request.query.format == 'htmlPage':
return yt.htmlPage()
elif request.query.format == 'json':
return Rpggen.toJson(yt)
elif request.query.format == 'jsonHtml':
return '<pre>' + Rpggen.toJson(yt) + '</pre>'
else:
return (
'Unknown format query variable.'
' Right now, only "text", "html", and "htmlPage" is supported.')
rpggen = Rpggen()
PersonalityTraits100Tab = Rpggen.loadLt("PersonalityTraits100.lt")
PersonalityTraits1000Tab = Rpggen.loadLt("PersonalityTraits.lt")
if development:
# bottle.debug(True)
run(host='localhost', port=1188, reloader=True, debug=False)
else:
# bottle.run(server='paste')
application = default_app()
def test_3(self):
result = Rpggen.roll('2d6+1')
self.assertEqual(result, 5)
class Traveller():
majorRaces = ['Vlandi', 'Solomani', 'Vargr', 'Aslan']
minorRaces = ['Hhakr', 'Vegan']
races = majorRaces + minorRaces
customziations = {}
Rpggen.setCustomization('d66support', True)
@classmethod
def digit2char(cls, num):
"""This function takes a number (usually one digit) and converts it to
a hex digit (0-F). Letters are upper case.
TODO: make it work for non-standard digit conversion
"""
return hex(num)[2].upper()
@classmethod
def dm(cls, num):
"""
"""
return 0
@classmethod
def iscr(cls, str):
try:
match = re.search(r"^(\$|[Cc][Rr] ?)?([0123456789]+)$", str)
result = int(match.group(2))
return True
except:
return False
@classmethod
def str2cr(cls, str):
match = re.search(r"^(\$|[Cc][Rr] ?)?([0123456789]+)$", str)
return int(match.group(2))
# Since traveller implies 2d6 most of the time, the default string passed is the
# target, not the dice roll, and the dice modifier comes second.
@classmethod
def roll(cls, target=None, dm=None, dice=None, debug=False):
if debug:
print('roll(%s, %s, %s)' % (dice, target, dm))
got = Rpggen.roll("2d6")
if dice is not None:
if type(dice) == int:
got = Rpggen.roll(str(dice) + "d6")
if type(dice) == str:
got = Rpggen.roll(dice)
if debug:
logging.debug('raw roll %d' % got)
dmValue = 0
if dm is not None:
if type(dm) == int:
got = got + dm
if type(dm) == str:
dmMatch = re.search(r"^([+-]?)([0123456789]+)$", dm)
dmDir = dmMatch.group(1)
if dmDir is None: dmDir = '+'
dmValue = int(dmMatch.group(2))
if dmDir == '+':
got = got + dmValue
elif dmDir == '-':
got = got - dmValue
if target is None:
#print('returning %d' % got)
return got
targetMatch = re.search(r"^([0123456789]+)([+-]?)$", target)
#print(targetMatch)
if targetMatch is None:
raise ValueError(
'In Traveller.roll(), target of %s matched noting' % target)
targetNum = int(targetMatch.group(1))
targetCmp = targetMatch.group(2)
if debug:
print('%s %d %d' % (targetCmp, got, targetNum))
if targetCmp is None:
return got == targetNum
elif targetCmp == '+':
return got >= targetNum
elif targetCmp == '-':
return got <= targetNum
else:
raise ValueError('In roll(), target string (%s) is malformed.' %
target)
def setAllCustomizations(self, customizations):
'''Sets all customizations by replacing whatever is there with those listed
in the argument. Previous customizations are lost, even if their is non-standard
similar customization in the argument.
'''
self.customziations = customizations
def setCustomization(self, name, value):
'''Sets one customization. Either changes the value, if it already exists,
or creates it new, with the given value.
'''
self.customziations[name] = value
def getCustomization(self, name, default=None):
'''Returns the customization value, or the second argument, if that
customization is not set, or None if the second argument is empty.
'''
if customizations is None:
return default
try:
result = self.customizations[name]
return result
except KeyError:
return default
def test_13(self):
result = Rpggen.roll('2d10+1')
self.assertEqual(result, 7)
def test_12(self):
result = Rpggen.roll('2d10')
self.assertEqual(result, 6)
def test_1(self):
result = Rpggen.roll('1d6')
self.assertEqual(result, 3)
def test_5(self):
result = Rpggen.roll('d6')
self.assertEqual(result, 2)
def test_4(self):
result = Rpggen.roll('2d6-1')
self.assertEqual(result, 3)
def test_14(self):
result = Rpggen.roll('2d10-1')
self.assertEqual(result, 5)
def test_15(self):
result = Rpggen.roll('d10')
self.assertEqual(result, 3)
def test_11(self):
result = Rpggen.roll('1d10')
self.assertEqual(result, 2)
def test_2(self):
result = Rpggen.roll('2d6')
self.assertEqual(result, 4)
