def test10Charges(self):
"""Test for ability to add *two* group of ten charges without errors."""
shield = blazon.Field("sable")
# Currently, this looks wrong, because the annulets end up
# *on top of* the lozenges.
shield.charges.append(blazon.ChargeGroup(10, blazon.Lozenge("argent")))
shield.charges.append(blazon.ChargeGroup(10, blazon.Annulet("or")))
for charge in shield.charges:
charge.arrange()
def testInOrle(self):
shield = blazon.Field("gules")
bezants = blazon.ChargeGroup(9, blazon.Roundel("or"))
bezants.arrangement = arrangement.InOrle()
shield.charges.append(bezants)
for charge in shield.charges:
charge.arrange()
def testBogusByNumbers(self):
shield = blazon.Field("vert")
chargegroup = blazon.ChargeGroup(6, blazon.Roundel("argent"))
chargegroup.arrangement = arrangement.ByNumbers()
chargegroup.arrangement.setRows([1, 2, 3, 4])
shield.charges.append(chargegroup)
for charge in shield.charges:
self.assertRaises(blazon.ArrangementError, charge.arrange)
def test2by4(self):
shield = blazon.Field("sable")
chargegroup = blazon.ChargeGroup(8, blazon.Annulet("or"))
chargegroup.arrangement = arrangement.ByNumbers()
chargegroup.arrangement.setRows([2, 2, 2, 2])
shield.charges.append(chargegroup)
for charge in shield.charges:
charge.arrange()
def p_fullcharge_2(p):
"""fullcharge : ON A almostfullcharge charges"""
if not (len(p[4]) == 1 and isinstance(p[4][0], blazon.ChargeGroup)):
res = blazon.ChargeGroup()
res.extendCharges(p[4])
res = [res]
else:
res = p[4]
p[3].extendCharges(res)
p[0] = p[3]
def p_group_1a(p):
"group : amount GROUPS optarrange optrows OF charges"
# The same as above, just taking it to mean "areas proper each charged with"
area = blazon.BigRect()
area.tincture = blazon.Treatment("proper")
res = blazon.ChargeGroup(p[1], area)
for elt in res.charges:
elt.extendCharges(copy.deepcopy(p[6]))
res.arrangement = p[3]
if p[4]:
res.arrangement = ByNumbers(p[4])
p[0] = res
def p_charges(p):
"""charges : optand optplacement grouporcharge
| charges optand optplacement optoverall grouporcharge"""
if len(p) == 4:
if p[2]:
# ???
if isinstance(p[3], blazon.ChargeGroup):
p[3].arrangement = p[2]
gp = p[3]
else:
gp = blazon.ChargeGroup(1, p[3])
gp.arrangement = p[2]
else:
gp = p[3]
p[0] = [gp]
else:
# OK, let's try to work out this business of "consolidating"
# charges into chargegroups. Charges conjoined with "and" can join
# into a group. Charges conjoined with "between" cannot. Let's
# see if we can do this without separate lexemes for "and" and
# "between", just different values for it.
#
# We need to be able to consolidate in order to make things like
# {azure a bend argent between a fusil and a roundel or}
lastgroup = p[1][-1]
# Always make it a ChargeGroup if it isn't?
# ... unless it's a TrueOrdinary?
if p[3] or (not isinstance(p[5], blazon.ChargeGroup)
and not isinstance(p[5], blazon.TrueOrdinary)):
newthing = blazon.ChargeGroup(1, p[5])
if p[3]:
newthing.arrangement = p[3]
else:
newthing = p[5]
p[0] = p[1] + [newthing]
def p_group_1(p):
"""group : amount charge optarrange opttreatment optfimbriation optrows
| amount charge optarrange opttreatment optfimbriation optrows EACH CHARGED WITH charges"""
# I don't have to worry about handling the opttreatment. That's just in
# case the treatment was omitted in the charge before the arrangement,
# and the "missing color" code will handle it. Right?
p[0] = blazon.ChargeGroup(p[1], p[2])
if len(p) > 7:
for elt in p[0].charges:
elt.extendCharges(copy.deepcopy(p[10]))
rows = p[6]
if not p[2].tincture:
Globals.colorless.extend(p[0].charges)
# Doesn't matter if p[3] is empty; so we'll pass along an empty one.
p[0].arrangement = p[3]
if rows:
p[0].arrangement = ByNumbers(rows)
# We wind up having two different places for treatment and fimbriation,
# but that's okay. If you specify both, one wins, but GIGO after all.
p[5](p[0])
def test10Charges(self):
"""Test for ability to add a group of ten charges without errors."""
shield = blazon.Field("sable")
shield.charges.append(blazon.ChargeGroup(10, blazon.Lozenge("argent")))
for charge in shield.charges:
charge.arrange()
def __init__(self, background, color):
self.background = background
cg = blazon.ChargeGroup(3, blazon.Roundel(tincture=color))
cg.arrangement = arrangement.ByNumbers([1, 2])
self.charge = blazon.BigRect()
self.charge.addCharge(cg)
def p_group_2(p):
"""group : LP charges RP"""
p[0] = blazon.ChargeGroup()
p[0].fromarray(p[2])
def p_grouporcharge_b(p):
"""grouporcharge : charge optarrange"""
p[0] = blazon.ChargeGroup(1, p[1])
if not p[1].tincture:
Globals.colorless.append(p[0].charges[0])
p[0].arrangement = p[2]
def p_fullcharge_5(p):
"fullcharge : LP charges RP"
p[0] = blazon.ChargeGroup()
p[0].fromarray(p[2])