def test_constructors(self):
"""Test space constructors"""
a = space.space()
self.assertEqual(a.x, 0)
self.assertEqual(a.y, 0)
self.assertEqual(a.z, 0)
self.assertSpaceAreEqual(a, space.Uo)
a = space.space(self.x1)
self.assertEqual(a.x, self.x1)
self.assertEqual(a.y, 0)
self.assertEqual(a.z, 0)
a = space.space(self.x1, self.y1)
self.assertEqual(a.x, self.x1)
self.assertEqual(a.y, self.y1)
self.assertEqual(a.z, 0)
a = space.space(self.x1, self.y1, self.z1)
self.assertSpaceAreEqual(self.space1, a)
a = space.space(z=self.z2, x=self.x2, y=self.y2)
self.assertSpaceAreEqual(self.space2, a)
def test_subtract(self):
"""Test subtract"""
a = space.space(self.A, self.B, self.C)
b = space.space(self.A, self.B, self.C)
c = a - b
self.assertEqual(c.x, 0)
self.assertEqual(c.y, 0)
self.assertEqual(c.z, 0)
def test_space_noop_richcompare_space(self):
"""Test space >, >=, <, <= space"""
a = space.space(1, 2, 3)
b = space.space(4, 5, 5)
self.assertRaises(TypeError, lambda a, b: a > b)
self.assertRaises(TypeError, lambda a, b: a >= b)
self.assertRaises(TypeError, lambda a, b: a < b)
self.assertRaises(TypeError, lambda a, b: a <= b)
def test_add(self):
"""Test add"""
a = space.space(self.A, self.B, self.C)
b = space.space(-self.A, -self.B, -self.C)
c = a + b
self.assertEqual(0, c.x)
self.assertEqual(0, c.y)
self.assertEqual(0, c.z)
def test_copy_constructor(self):
"""Test space copy constructor"""
a = space.space(self.A, self.B, self.C)
b = space.space(a)
self.assertEqual(self.A, b.x)
self.assertEqual(self.B, b.y)
self.assertEqual(self.C, b.z)
def createSpaces(self):
for x in range(8):
List = []
for y in range(8):
List.append(space(y,x))
self.spaces.append(List)
self.spaces.reverse()
def test_xyz_assignments(self):
"""Test space xyz assignment operators"""
a = space.space()
a.x = self.p1.x
a.y = self.p1.y
a.z = self.p1.z
self.assertSpacesAreEqual(self.p1, a)
def create_map(height, width):
map = []
for row in range(height):
map.append([])
for col in range(width):
map[row].append(space(' '))
return map
def test_copy_assign_2(self):
"""Test copy assignment operator is shallow"""
a = space.space(1,2,3)
b = a
b.x = 4.0
self.assertSpacesAreEqual(a, b)
self.assertEqual(4, b.x)
def test_space_minus_space(self):
"""Test space - space"""
result = space.space(self.p1.x - self.p2.x,
self.p1.y - self.p2.y,
self.p1.z - self.p2.z)
a = self.p1 - self.p2
self.assertTrue(result == a)
def test_copy_assign_2(self):
"""Test copy assignment operator is shallow"""
a = space.space(1,2,3)
b = a
b.x(4.0)
self.assertTrue(a == b)
self.assertEqual(4, b.x())
def test_space_minus_space(self):
"""Test space - space"""
result = space.space(self.p1.x() - self.p2.x(),
self.p1.y() - self.p2.y(),
self.p1.z() - self.p2.z())
a = self.p1 - self.p2
self.assertTrue(result == a)
def test_xyz_assignments(self):
"""Test space xyz assignment operators"""
a = space.space()
a.x(self.p1.x())
a.y(self.p1.y())
a.z(self.p1.z())
self.assertTrue(self.p1 == a)
def test_space_plus_space(self):
"""Test space + space"""
result = space.space(self.p1.x() + self.p2.x(),
self.p1.y() + self.p2.y(),
self.p1.z() + self.p2.z())
a = self.p1 + self.p2
self.assertTrue(result == a)
def test_default_constructor(self):
"""Test default constructor"""
a = space.space()
self.assertEqual(0, a.x)
self.assertEqual(0, a.y)
self.assertEqual(0, a.z)
self.assertSpacesAreEqual(space.space.Uo, a)
def test_default_constructor(self):
"""Test default constructor"""
a = space.space()
self.assertEqual(0, a.x)
self.assertEqual(0, a.y)
self.assertEqual(0, a.z)
self.assertTrue(space.Uo == a)
def test_space_eq_space(self):
"""Test space == space"""
result = space.space(self.p1.x + self.p2.x,
self.p1.y + self.p2.y,
self.p1.z + self.p2.z)
a = self.p1 + self.p2
self.assertTrue(result == a)
def test_prints(self):
"""Test space print and repr"""
a = space.space(self.x2, self.y2, self.z2)
self.assertEqual(self.two_as_str, str(a))
self.assertEqual(self.two_as_repr, repr(a))
def test_space_plus_space(self):
"""Test space + space"""
result = space.space(self.p1.x + self.p2.x,
self.p1.y + self.p2.y,
self.p1.z + self.p2.z)
a = self.p1 + self.p2
self.assertSpacesAreEqual(result, a)
def test_space_minus_space(self):
"""Test space - space"""
result = space.space(self.p1.x - self.p2.x,
self.p1.y - self.p2.y,
self.p1.z - self.p2.z)
a = self.p1 - self.p2
self.assertSpacesAreEqual(result, a)
def test_unitary_minus(self):
"""Test space = -space"""
result = space.space(-self.p1.x,
-self.p1.y,
-self.p1.z)
a = -self.p1
self.assertTrue(result == a)
def test_divide(self):
"""Test divide (scale)"""
result = space.space(self.p1.x / 2.0,
self.p1.y / 2.0,
self.p1.z / 2.0)
a = self.p1 / 2.0
self.assertSpacesAreEqual(result, a)
def test_divide(self):
"""Test divide (scale)"""
result = space.space(self.p1.x / 2.0,
self.p1.y / 2.0,
self.p1.z / 2.0)
a = self.p1 / 2.0
self.assertTrue(result == a)
def test_xyz_assignments(self):
"""Test space xyz assignment operators"""
a = space.space()
a.x = self.p1.x
a.y = self.p1.y
a.z = self.p1.z
self.assertTrue(self.p1 == a)
def test_inplace_add(self):
"""Test space +="""
result = space.space(self.p1.x() + self.p2.x(),
self.p1.y() + self.p2.y(),
self.p1.z() + self.p2.z())
a = self.p1
a += self.p2
self.assertTrue(result == a)
def test_copy_assign(self):
"""Test space copy assign"""
a = space.space(self.A, self.B, self.C)
b = a
self.assertEqual(self.A, b.x)
self.assertEqual(self.B, b.y)
self.assertEqual(self.C, b.z)
def test_inplace_subtract(self):
"""Test inplace subtract"""
a = space.space(self.A, self.B, self.C)
a -= a
self.assertEqual(0, a.x)
self.assertEqual(0, a.y)
self.assertEqual(0, a.z)
def test_inplace_divide(self):
"""Test inplace divide, a.k.a. scale"""
a = space.space(self.A, self.B, self.C)
a /= 10
self.assertEqual(self.A/10, a.x)
self.assertEqual(self.B/10, a.y)
self.assertEqual(self.C/10, a.z)
def test_inplace_multiply(self):
"""Test inplace multiply
This is weird because a becomes a float since this is a dot product.
"""
a = space.space(self.A, self.B, self.C)
a *= a
self.assertAlmostEqual(self.product, a, self.places)
def test_inplace_add(self):
"""Test space +="""
result = space.space(self.p1.x + self.p2.x,
self.p1.y + self.p2.y,
self.p1.z + self.p2.z)
a = self.p1
a += self.p2
self.assertSpacesAreEqual(result, a)
def test_copy_assign_3(self):
"""Test copy assignment operator can use deep copy"""
import copy
a = space.space(1,2,3)
b = copy.deepcopy(a)
b.x = 4.0
self.assertEqual(1, a.x)
self.assertEqual(4, b.x)
def test_inplace_subtract(self):
"""Test space -="""
result = space.space(self.p1.x - self.p2.x,
self.p1.y - self.p2.y,
self.p1.z - self.p2.z)
a = self.p1
a -= self.p2
self.assertSpacesAreEqual(result, a)
def test_inplace_subtract(self):
"""Test space -="""
result = space.space(self.p1.x - self.p2.x,
self.p1.y - self.p2.y,
self.p1.z - self.p2.z)
a = self.p1
a -= self.p2
self.assertTrue(result == a)
def test_inplace_add(self):
"""Test space +="""
result = space.space(self.p1.x + self.p2.x,
self.p1.y + self.p2.y,
self.p1.z + self.p2.z)
a = self.p1
a += self.p2
self.assertTrue(result == a)
def test_divide(self):
"""Test divide, a.k.a. scale"""
a = space.space(self.A, self.B, self.C)
b = a / 10
self.assertEqual(self.A/10, b.x)
self.assertEqual(self.B/10, b.y)
self.assertEqual(self.C/10, b.z)
def test_inplace_add(self):
"""Test inplace add"""
a = space.space(self.A, self.B, self.C)
a += a
self.assertEqual(2*self.A, a.x)
self.assertEqual(2*self.B, a.y)
self.assertEqual(2*self.C, a.z)
def test_assignments(self):
"""Test space assignment operators"""
a = space.space()
a.x = self.x1
a.y = self.y1
a.z = self.z1
self.assertSpaceAreEqual(self.space1, a)
def test_accessors(self):
"""Test space accessors"""
a = space.space()
a.setX(self.A)
a.setY(-self.B)
a.setZ(self.C)
self.assertEqual(self.A, a.getX())
self.assertEqual(-self.B, a.getY())
self.assertEqual(self.C, a.getZ())
def test_properties(self):
"""Test properties"""
a = space.space()
a.x = self.A
a.y = -self.B
a.z = self.C
self.assertEqual(self.A, a.x)
self.assertEqual(-self.B, a.y)
self.assertEqual(self.C, a.z)
def test_cross_product(self):
"""Test space cross product"""
# simple axis rotation.
a = space.cross(space.Ux, space.Uy)
self.assertSpaceAreEqual(a, space.Uz)
a = space.cross(space.Uy, space.Uz)
self.assertSpaceAreEqual(a, space.Ux)
a = space.cross(space.Uz, space.Ux)
self.assertSpaceAreEqual(a, space.Uy)
# more complex
a = space.space(1, 1, 1)
b = space.space(0, 0, 0.5)
c = space.cross(a, b)
self.assertSpaceAreEqual(space.space(0.5, -0.5, 0), c)
def partition(self,S):
# According to Figure a in the article
# Front space
self.pos=[S.pos[0],S.pos[4]-self.W,S.pos[2]]
fl2=S.pos[0]+self.L
fw2=S.pos[4]-self.W
Front_space=space(S.pos[0],S.pos[1],S.pos[2],fl2,fw2,S.pos[5])
# Upper sapce
ul2=self.L+S.pos[0]
uw1=S.pos[4]-self.W
uh1=self.H+S.pos[2]
Upper_space=space(S.pos[0],uw1,uh1,ul2,S.pos[4],S.pos[5])
Upper_space.lowerBox_type=[self.boxtype]
# Right space
rl1=S.pos[0]+self.L
Right_space=space(rl1,S.pos[1],S.pos[2],S.pos[3],S.pos[4],S.pos[5])
# delete the initial space
S.delet()
Blok.AllBloks.append(self)
return
def __init__(self, height, width, players):
self.height = height
self.width = width
self.map = create_map(height, width)
self.rebels = []
self.players = players
self.bullets = []
for i in range(players):
self.rebels.append(dude(self, 1, i * 5, 10))
for i in range(self.width):
self.map[self.height - 3][i] = space('-', full=True)
def test_default_constructors(self):
"""Test space default constructors"""
a = space.space()
self.assertEqual(0, a.x)
self.assertEqual(0, a.y)
self.assertEqual(0, a.z)
a = space.space(self.A)
self.assertEqual(self.A, a.x)
self.assertEqual(0, a.y)
self.assertEqual(0, a.z)
a = space.space(self.A, self.B)
self.assertEqual(self.A, a.x)
self.assertEqual(self.B, a.y)
self.assertEqual(0, a.z)
a = space.space(self.A, self.B, self.C)
self.assertEqual(self.A, a.x)
self.assertEqual(self.B, a.y)
self.assertEqual(self.C, a.z)
def setUp(self):
self.places = 7 # almost equal places
self.zero = space.space()
self.A = 1.1
self.B = 2.2
self.C = 3.3
self.product = self.A*self.A + self.B*self.B + self.C*self.C
self.magnitude = math.sqrt(self.product)
self.a_str = '<space><x>1.1</x><y>2.2</y><z>3.3</z></space>'
def setUp(self):
"""Set up test parameters."""
self.places = 7 # almost equal places
# various types to check math operators
self.most_exception_types = (
'foo', 0, 1, -2, 3.1415, -2.7, complex(1.2, -3.4))
self.divisor_exception_types = ('foo', complex(1.2, -3.4))
# one point
self.x1 = 1
self.y1 = 2
self.z1 = 3
self.space1 = space.space(self.x1, self.y1, self.z1)
self.space1_mag = math.sqrt(self.x1*self.x1 + self.y1*self.y1 + self.z1*self.z1)
self.normal1 = space.space(self.x1/self.space1_mag,
self.y1/self.space1_mag,
self.z1/self.space1_mag)
# hardcoded strings keep this from being too circular.
self.one_as_str = '<space><x>1</x><y>2</y><z>3</z></space>'
self.one_as_repr = '(1, 2, 3)'
# another point
self.x2 = 0.123456789
self.y2 = -2.71828
self.z2 = 3.14159
self.space2 = space.space(self.x2, self.y2, self.z2)
# Note: space print precision (default) is less than in Body.
self.two_as_str = '<space><x>0.123457</x><y>-2.71828</y><z>3.14159</z></space>'
self.two_as_repr = '(0.123457, -2.71828, 3.14159)'
# sum
self.sum_space1_space2 = space.space(self.x1 + self.x2,
self.y1 + self.y2,
self.z1 + self.z2)
# difference
self.diff_space1_space2 = space.space(self.x1 - self.x2,
self.y1 - self.y2,
self.z1 - self.z2)
# dot product
self.dot_prod_space1_space2 = \
self.x1 * self.x2 + \
self.y1 * self.y2 + \
self.z1 * self.z2
self.quotient_space1_over_2 = space.space(self.x1 / 2.0,
self.y1 / 2.0,
self.z1 / 2.0)
def test_exceptions(self):
"""Test space exceptions"""
a_space = space.space()
self.assertRaises(TypeError, a_space.x, 'foo')
self.assertRaises(TypeError, a_space.y, 'foo')
self.assertRaises(TypeError, a_space.z, 'foo')
# assert exceptions on operators of different types.
if False:
# FN
self.assertRaises(TypeError, lambda a, b: a + b,
self.space1, self.space2)
for type_ in self.most_exception_types:
self.assertRaises(TypeError, lambda a, b: a + b, a_space, type_)
self.assertRaises(TypeError, lambda a, b: b + a, a_space, type_)
# TODO +=
for type_ in self.most_exception_types:
self.assertRaises(TypeError, lambda a, b: a - b, a_space, type_)
self.assertRaises(TypeError, lambda a, b: b - a, a_space, type_)
# TODO -=
for type_ in self.most_exception_types:
self.assertRaises(TypeError, lambda a, b: a * b, a_space, type_)
self.assertRaises(TypeError, lambda a, b: b * a, a_space, type_)
# TODO *=
for type_ in self.divisor_exception_types:
self.assertRaises(TypeError, lambda a, b: a / b, a_space, type_)
self.assertRaises(TypeError, lambda a, b: b / a, a_space, type_)
# TODO /=
# divide by 0
self.assertRaises(space.space_error, lambda a, b: a / b, a_space, 0)
def loading(self, Data):
#### loading hurestic ###
space.reset()
BOX.reset()
Blok.reset()
(L, W, H) = Data.contdim
S = space(0, 0, 0, L, W, H)
BOXS = []
for j in self.value:
BOXS.append(BOX(Data, j))
while len(space.remainlist) != 0 or BOX.Is_unloaded_BOX():
S = S.merge()
j = 0
while (j < Data.ntype and len(space.remainlist) != 0):
currentbox = BOXS[j]
if (currentbox.quantity > 0 and currentbox.Can_Load(Data, S)):
BBlok = currentbox.Best_Blok(S)
BBlok.partition(S)
if len(space.remainlist) != 0:
S = space.curentspace()
j = 0
else:
break
S = S.merge()
#j+=1
else:
j += 1
S.waste()
if len(space.remainlist) != 0:
S = space.curentspace()
else:
break
def test_magnitude(self):
"""Test magnitude"""
a = space.space(self.A, self.B, self.C)
self.assertAlmostEqual(self.magnitude, a.magnitude(), self.places)
def DISABLED_test_divide_zero(self):
"""Test divide by zero to raise exception"""
a = space.space(self.A, self.B, self.C)
self.assertRaises(RuntimeError, a / 0)
def test_normalized(self):
"""Test normalized"""
a = space.space(self.A, self.B, self.C)
b = a.normalized()
self.assertAlmostEqual(1.0, b.magnitude())
def test_str(self):
"""Test string representation."""
a = space.space(self.A, self.B, self.C)
self.assertEqual(self.a_str, str(a))
def remove_dude (self):
for row in range(self.y,self.y + self.height):
for col in range(self.x, self.x + self.width):
self.game.map[row][col] = space(' ')
pygame.init()
size = width, height = 1920, 1020
screen = pygame.display.set_mode(size)
icon = pygame.image.load("./hatLogo.ico")
pygame.display.set_icon(icon)
pygame.display.set_caption("Generic Property Game-opoly")
#input()
#reads in content from csv
boardArray = []
with open(root.filename, newline='') as boardFile:
boardReader = csv.reader(boardFile, delimiter=',')
for i in boardReader:
#print(i)
boardArray.append(
space.space(i[0], i[1], int(i[3]), int(i[4]), 90, colourDict[i[2]],
i))
#print(boardArray)
chanceArray = []
with open("CHANCE.csv", newline='') as chanceFile:
chanceReader = csv.reader(chanceFile, delimiter=",")
for i in chanceReader:
chanceArray.append(space.chance(i))
#print(chanceArray)
random.shuffle(chanceArray)
background = pygame.image.load("background2.png")
diceArray = [space.dice(0), space.dice(1)]
mainMenuArray = resetMenu()
def test_multiply(self):
"""Test multiply, a.k.a. dot product"""
a = space.space(self.A, self.B, self.C)
b = space.space(self.A, self.B, self.C)
c = a * b
self.assertAlmostEqual(self.product, c, self.places)
