def MergeChars(a, b):
global LetterToSet
if a == b:
return a
try:
sa = LetterToSet[a.upper()]
except:
die.Die("Bad letter in primer '%c'" % a)
try:
sb = LetterToSet[b.upper()]
except:
die.Die("Bad letter in primer '%c'" % b)
Set = sa
for x in sb:
if x not in Set:
Set += x
for x in LetterToSet.keys():
Set2 = LetterToSet[x]
if len(Set2) != len(Set):
continue
Found = True
for y in Set:
if y not in Set2:
Found = False
if Found:
return x
die.Die("MergeChars(%c,%c) failed" % (a, b))
def setUp(self):
self.testLStreetObj = CalcLittelStreet("testBlub")
self.newDice = [
die.Die(3),
die.Die(2),
die.Die(4),
die.Die(1),
die.Die(3)
]
def GetLevelName(Path, Level, Default=""):
Fields = Path.split(',')
for Field in Fields:
if len(Field) < 2 or Field[1] != ':':
die.Die("Invalid path '%s'" % Path)
if Field[0] == Level:
s = Field[2:]
n = s.find('(')
if n > 0:
return s[:n]
return s
if Default == "":
die.Die("GetLevelName, '%c:' not found in path '%s'" % (Level, Path))
return Default
def test_invalid_max_roll(self):
"""A Dice created with an invalid max_roll will set max_roll to the
default value.
"""
d = die.Die(-1)
self.assertEqual(d.max_roll, die.DEF_MAX)
d = die.Die('sdfsd')
self.assertEqual(d.max_roll, die.DEF_MAX)
d = die.Die(True)
self.assertEqual(d.max_roll, die.DEF_MAX)
d = die.Die(0.7)
self.assertEqual(d.max_roll, die.DEF_MAX)
def test_invalid_offset(self):
"""A Dice created with an invalid offset will set offset to the
default value.
"""
d = die.Die(2, offset=-1)
self.assertEqual(d.offset, die.DEF_OFFSET)
d = die.Die(2, offset='sdfsdf')
self.assertEqual(d.offset, die.DEF_OFFSET)
d = die.Die(2, offset='False')
self.assertEqual(d.offset, die.DEF_OFFSET)
d = die.Die(2)
self.assertEqual(d.offset, die.DEF_OFFSET)
def run_die():
"""运行投掷骰子"""
# 实例话Die
die1 = die.Die()
die2 = die.Die(10)
# 生成两个骰子的组合结果
tow_results = to_results(die1, die2)
# 生成两个骰子的频率
tow_frequencies = to_frequency(tow_results)
# 生成结果的交集组合，其中没有重复的，并排序
tow_results_sides = sorted(set(tow_results))
# 显示图表
show_die(tow_results_sides, tow_frequencies)
webbrowser.open_new_tab("http://localhost:63342/Demo/"
"pygal_demo/die_visual.svg")
def GetPctIdFromLabel(Label):
Fields = Label.split(";")
for Field in Fields:
if Field.startswith("pctid="):
PctId = int(Field[6:])
return PctId
die.Die("pctid= not found in >" + Label)
def test_incorrectConstructionZero():
sides = 0
D0 = die.Die(sides)
notExist = False
if not D0:
notExist = True
assert True == notExist
def test_text_init(self):
"Test the Die object creation from text"
# 1. Create Die object from text
myobj = die.Die(text=EXAMPLE_TEXT)
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 3)
self.assertEqual(myobj.rolled, 0)
self.assertEqual(myobj.sides, 100)
self.assertEqual(myobj.last, 0)
# 3. Check methods
self.assertEqual(myobj.roll(), 1)
self.assertEqual(myobj.rolled, 1)
self.assertEqual(myobj.last, 1)
self.assertEqual(myobj.roll(), 2)
self.assertEqual(myobj.rolled, 2)
self.assertEqual(myobj.last, 2)
myobj.last = 99
self.assertEqual(myobj.last, 99)
self.assertEqual(myobj.roll(), 100)
self.assertEqual(myobj.rolled, 3)
self.assertEqual(myobj.last, 100)
self.assertEqual(myobj.roll(), 1)
self.assertEqual(myobj.rolled, 4)
self.assertEqual(myobj.last, 1)
def test_incorrectConstructionNegative():
sides = -10
Dminus = die.Die(sides)
notExist = False
if not Dminus:
notExist = True
assert True == notExist
def MatchLetter(a, b):
if b == 'A' or b == 'C' or b == 'G' or b == 'T':
return a == b
elif b == 'S':
return a == 'C' or a == 'G'
elif b == 'Y':
return a == 'T' or a == 'C'
elif b == 'K':
return a == 'G' or a == 'T'
elif b == 'V':
return a == 'A' or a == 'C' or a == 'G'
elif b == 'H':
return a == 'A' or a == 'C' or a == 'T'
elif b == 'D':
return a == 'A' or a == 'G' or a == 'T'
elif b == 'B':
return a == 'C' or a == 'G' or a == 'T'
elif b == 'X' or b == 'N':
return a == 'G' or a == 'A' or a == 'T' or a == 'C'
elif b == 'R':
return a == 'A' or a == 'G'
elif b == 'M':
return a == 'A' or a == 'C'
elif b == 'H':
return a == 'A' or a == 'C' or a == 'T'
elif b == 'W':
return a == 'A' or a == 'T'
else:
die.Die("Bad letter in primer '%c'" % b)
return 0
def test_incorrectConstructionEmpty():
sides = ""
D = die.Die(sides)
notExist = False
if not D:
notExist = True
assert True == notExist
def GetLKRFromLabel(Label):
Fields = Label.split(";")
for Field in Fields:
if Field.startswith("lkr="):
assert len(Field) == 5
return Field[4]
die.Die("lkr= not found in >" + Label)
def GetTaxFromLabel(Label):
Fields = Label.split(";")
for Field in Fields:
if Field.startswith("tax="):
Tax = Field[4:]
return Tax
die.Die("tax= not found in label >" + Label)
def run_away(char: character.Character, victim: enemy.Child):
"""Decide if the player will take damage when running away.
A die is rolled to decide chance of damage, the higher the number of sides the lower the chance of damage.
Default chance of damage is 1 in 4 or 25%. If a one is rolled the player will take 1 to 4 points of damage.
PARAM: An instance belonging to the class 'Character' and an instance belonging the the class 'Child'.
PRECONDITION: The parameters must be an instance belonging to the class 'Character' and the class 'Child'.
POSTCONDITION: Either the player escapes unharmed or the player will take 1 to 4 points of damage.
RETURN: N/A
"""
print(
'\nYou walk away, the thought of killing a child was too much for you. But in her fear the child attempts to '
'attack you!')
damage_die = die.Die(10)
chance_of_damage = damage_die.roll_die()
if chance_of_damage == 1:
victim.escape_attack(char)
# Enemy attacks character. Escape damage range from 1 - 4
print("You have escaped, but have taken " +
str(victim.get_escape_damage()) +
" points of damage in the process. You now have " +
str(char.get_health()) + " health points remaining.")
else:
print(
"You have escaped unscathed, the child runs off into the darkness."
)
def test_incorrectConstructionNonNumber():
sides = "a"
Da = die.Die(sides)
notExist = False
if not Da:
notExist = True
assert True == notExist
def GetPredScore(Path, LevelChar):
n = Path.find(LevelChar + ":")
if n < 0:
return -1.0
s = Path[n + 2:]
m = s.find("(")
# if not s[m+1].isdigit():
# s = s[m+1:]
# m = s.find("(")
if m <= 0:
die.Die("Missing score %c: in %s" % (LevelChar, Path))
s = s[m + 1:]
m = s.find(")")
if m <= 0:
die.Die("Missing ) for level %c: in %s" % (LevelChar, Path))
s = s[:m]
return float(s)
def ParsePred(Pred):
Fields = Pred.split("(")
n = len(Fields)
if n == 1:
die.Die("Missing score in %s" % Pred)
Name = Fields[0]
s = Fields[n - 1]
if s.endswith(';'):
s = s.replace(";", "")
assert s.endswith(')')
ss = s[:-1]
try:
Score = float(ss)
except:
die.Die("utax2.ParsePred, bad pred '%s'" % Pred)
return Name, Score
def test_remove_die(self):
"""
"""
size = len(die.DICE)
d = die.Die(21, name='Test')
self.assertEqual(len(die.DICE), size + 1)
die.remove(d)
self.assertEqual(len(die.DICE), size)
def GetDictFromLabel(Label):
Tax = GetTaxFromLabel(Label)
Names = Tax.split(',')
Dict = {}
for Name in Names:
if len(Name) <= 2 or Name[1] != ':':
die.Die("GetDictFromLabel(%s)" % Label)
Dict[Name[0]] = Name
return Dict
def GetNameFromLabel(Label, Level):
Tax = GetTaxFromLabel(Label)
Names = Tax.split(',')
for Name in Names:
if len(Name) <= 2 or Name[1] != ':':
die.Die("Invalid name '%s' in label >%s" % (Name, Label))
if Name[0] == Level:
return Name
return ""
def SplitLevelIsTrue(SplitLevelChar, TestLevelChar):
if len(SplitLevelChar) != 1 or len(TestLevelChar) != 1:
die.Die("SplitLevelIsTrue(Split=%s, Test=%s)" %
(SplitLevelChar, TestLevelChar))
Splitn = LevelChars.find(SplitLevelChar)
Testn = LevelChars.find(TestLevelChar)
assert Splitn >= 0
assert Testn >= 0
return Testn <= Splitn
def test_fields():
# test initialization
d4 = die.Die(n_sides=4)
# test fields
assert d4.n_sides == 4
assert d4.state is None
r = d4.roll()
assert d4.state == r
def GetPred(PredStr, LevelChar):
Fields = PredStr.split(',')
for Field in Fields:
if len(Field) < 2 or Field[1] != ':':
die.Die("Invalid predstr '%s'" % PredStr)
if Field[0] == LevelChar:
if not Field.endswith(')') and not Field.endswith(");"):
die.Die("Pred must end with ) '%s'" % Field)
m = Field.rfind("(")
if m <= 0:
die.Die("Missing ( in '%s'" % (PredStr))
Name = Field[0:m]
s = Field[m + 1:]
m = s.find(")")
if m <= 0:
die.Die("Missing ) for level %c: in %s" % (LevelChar, PredStr))
s = s[:m]
Score = float(s)
return Name, Score
return "*", -1.0
def GetNameFromTaxStr(Tax, Level):
if Tax == "":
return ""
Names = Tax.split(',')
for Name in Names:
if len(Name) <= 2 or Name[1] != ':':
die.Die("GetNameFromTaxStr(" + Tax + ", " + Level +
"), bad name '" + Name + "'")
if Name[0] == Level:
return Name
return ""
def test_empty_init(self):
"Test the default Die creation"
# 1. Create default Die object
myobj = die.Die()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
self.assertEqual(myobj.rolled, 0)
self.assertEqual(myobj.sides, 100)
self.assertEqual(myobj.last, 0)
def test_roll():
# Initialize
d4 = die.Die(n_sides=4)
d6 = die.Die(n_sides=6)
d4_rolls = [0, 0, 0, 0]
d6_rolls = [0, 0, 0, 0, 0, 0]
# Check that roll is never out of die range
for _ in range(4000):
r = d4.roll()
assert (r >= 1 and r <= 4)
d4_rolls[r - 1] += 1
for _ in range(6000):
r = d6.roll()
assert (r >= 1 and r <= 6)
d6_rolls[r - 1] += 1
# Check that rolls are reasonably weighted
assert (all(x > 250 for x in d4_rolls + d6_rolls))
def chance_of_engagement(char):
"""Decide if an enemy encounter will take place.
A die is rolled to decide chance of encounter, the higher the number of sides the lower the chance of encounter.
The default chance of battle is 1 in 10 or 10%. If a one is rolled an enemy engagement will occur. If there is no
enemy, regenerate health by one.
PARAM: An instance belonging to the class 'Character'.
PRECONDITION: The parameter must be an instance belonging to the class 'Character'.
POSTCONDITION: An enemy encounter will take place or player health regenerates by one.
RETURN: N/A
"""
engagement_die = die.Die(10)
engagement_chance = engagement_die.roll_die()
if engagement_chance == 1:
fight_or_run(char)
# Enemy engages and player gets to choose
else:
char.regenerate_one_health()
def LevelCharToName(c):
if c == 's':
return "Species"
elif c == 'g':
return "Genus"
elif c == 'f':
return "Family"
elif c == 'c':
return "Class"
elif c == 'o':
return "Order"
elif c == 'p':
return "Phylum"
elif c == 'd':
return "Domain"
elif c == 'k':
return "Kingdom"
die.Die("Unknown level " + c)
def __init__(self, text=None, part2=False):
# 1. Set the initial values
self.part2 = part2
self.text = text
self.track = list(range(TRACK_BEG, TRACK_END + 1))
self.players = []
self.die = None
if part2:
self.goal = GOAL_TWO
else:
self.goal = GOAL_ONE
self.times = TIMES
# 2. Process text (if any)
if text is not None and len(text) > 0:
for line in text:
self.players.append(player.Player(text=line, part2=part2))
self.die = die.Die(part2=part2)
