Debian Codegraph @

tests/swig_tests/model_tests.py

raw
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 # ####################################################################
5 # Copyright (C) 2005-2019 by the FIFE team
6 # http://www.fifengine.net
7 # This file is part of FIFE.
8 #
9 # FIFE is free software; you can redistribute it and/or
10 # modify it under the terms of the GNU Lesser General Public
11 # License as published by the Free Software Foundation; either
12 # version 2.1 of the License, or (at your option) any later version.
13 #
14 # This library is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 # Lesser General Public License for more details.
18 #
19 # You should have received a copy of the GNU Lesser General Public
20 # License along with this library; if not, write to the
21 # Free Software Foundation, Inc.,
22 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 # ####################################################################
24
25 from .swig_test_utils import *
26 import math
27
28
29 class TestModel(unittest.TestCase):
30 def setUp(self):
31 self.engine = getEngine(True)
32 self.timeManager = self.engine.getTimeManager()
33 self.model = self.engine.getModel()
34
35 def tearDown(self):
36 self.engine.destroy()
37
38 # del self.timeManager
39
40 def testModel(self):
41 map1 = self.model.createMap("map001")
42 map2 = self.model.createMap("map002")
43
44 query = self.model.getMap("map001")
45 self.assertEqual(map1.getId(), query.getId())
46
47 query = self.model.getMap("map002")
48 self.assertEqual(map2.getId(), query.getId())
49
50 query = self.model.getMaps()
51 self.assertEqual(len(query), 2)
52
53 self.assertEqual(len(query), self.model.getMapCount())
54
55 self.model.deleteMap(map2)
56
57 query = self.model.getMaps()
58 self.assertEqual(len(query), 1)
59
60 self.model.createMap("map003")
61 self.model.createMap("map004")
62
63 query = self.model.getMaps()
64 self.assertEqual(len(query), 3)
65 self.assertEqual(self.model.getMapCount(), 3)
66
67 self.model.deleteMaps()
68 query = self.model.getMaps()
69 self.assertEqual(len(query), 0)
70 self.assertEqual(self.model.getMapCount(), 0)
71
72 def testMaps(self):
73 map = self.model.createMap("map005")
74
75 self.assertEqual(map.getLayerCount(), 0)
76
77 grid = self.model.getCellGrid("square")
78
79 layer1 = map.createLayer("layer001", grid)
80 layer2 = map.createLayer("layer002", grid)
81
82 self.assertEqual(layer1.getId(), "layer001")
83 self.assertEqual(layer2.getId(), "layer002")
84
85 self.assertEqual(len(map.getLayers()), 2)
86
87 self.assertEqual(map.getLayerCount(), 2)
88 map.deleteLayer(layer2)
89 self.assertEqual(map.getLayerCount(), 1)
90 map.deleteLayers()
91 self.assertEqual(map.getLayerCount(), 0)
92
93 def testLayers(self):
94 map = self.model.createMap("map006")
95
96 grid = self.model.getCellGrid("square")
97 obj1 = self.model.createObject("object001", "test_nspace")
98 obj2 = self.model.createObject("object002", "test_nspace")
99
100 self.assertEqual(obj1.getId(), "object001")
101 self.assertEqual(obj2.getId(), "object002")
102
103 layer = map.createLayer("layer003", grid)
104
105 self.assertEqual(layer.hasInstances(), 0)
106 self.assertEqual(layer.getMap().getId(), map.getId())
107
108 inst = layer.createInstance(obj1, fife.ModelCoordinate(4, 4))
109 layer.createInstance(obj2, fife.ModelCoordinate(5, 6))
110 layer.createInstance(obj2, fife.ModelCoordinate(5, 4))
111
112 # query = layer.getInstances("Name", "Goon")
113 # self.assertEqual(len(query), 2)
114 self.assertEqual(len(layer.getInstances()), 3)
115
116 # self.assertEqual(query[0].get("Name"), "Goon")
117 # p1 = fife.ModelCoordinate(4,4)
118 # print p1.x, p1.y
119 # p2 = inst.getLocation().getLayerCoordinates()
120 # print p2.x, p2.y
121 # self.assertEqual(inst.getLocation().getLayerCoordinates(), fife.ModelCoordinate(4,4))
122
123 def testObjects(self):
124 obj1 = self.model.createObject("object003", "test_nspace")
125 obj2 = self.model.createObject("object004", "test_nspace")
126 self.model.createObject("object005", "test_nspace")
127 self.model.createObject("object006", "test_nspace")
128
129 self.assertEqual(self.model.deleteObject(obj2), True)
130
131 map = self.model.createMap("map007")
132 grid = self.model.getCellGrid("square")
133 layer = map.createLayer("layer004", grid)
134
135 inst = layer.createInstance(obj1, fife.ModelCoordinate(4, 4))
136 self.assertEqual(self.model.deleteObject(obj1), False)
137 self.assertEqual(self.model.deleteObjects(), False)
138 layer.deleteInstance(inst)
139 self.assertEqual(self.model.deleteObject(obj1), True)
140 self.assertEqual(self.model.deleteObjects(), True)
141
142
143 class TestActionAngles(unittest.TestCase):
144 def setUp(self):
145 self.engine = getEngine(True)
146 self.anim0 = self.engine.getAnimationManager().create("0")
147 self.anim1 = self.engine.getAnimationManager().create("1")
148 self.anim2 = self.engine.getAnimationManager().create("2")
149 self.anim3 = self.engine.getAnimationManager().create("3")
150 self.runaction = fife.Action("action001")
151 fife.ActionVisual.create(self.runaction)
152 self.runaction.get2dGfxVisual().addAnimation(90, self.anim1)
153 self.runaction.get2dGfxVisual().addAnimation(0, self.anim0)
154 self.runaction.get2dGfxVisual().addAnimation(270, self.anim3)
155 self.runaction.get2dGfxVisual().addAnimation(180, self.anim2)
156 self.walkaction = fife.Action("action002")
157 fife.ActionVisual.create(self.walkaction)
158 self.walkaction.get2dGfxVisual().addAnimation(70, self.anim1)
159 self.walkaction.get2dGfxVisual().addAnimation(200, self.anim2)
160 self.walkaction.get2dGfxVisual().addAnimation(320, self.anim3)
161
162 def testRunAngle89(self):
163 self.assertEqual(
164 self.runaction.get2dGfxVisual().getAnimationByAngle(89).getHandle(),
165 self.anim1.getHandle())
166
167 def testRunAngle90(self):
168 self.assertEqual(
169 self.runaction.get2dGfxVisual().getAnimationByAngle(90).getHandle(),
170 self.anim1.getHandle())
171
172 def testRunAngle91(self):
173 self.assertEqual(
174 self.runaction.get2dGfxVisual().getAnimationByAngle(91).getHandle(),
175 self.anim1.getHandle())
176
177 def testRunAngle135(self):
178 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
179 135).getHandle(), self.anim1.getHandle())
180
181 def testRunAngle134(self):
182 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
183 134).getHandle(), self.anim1.getHandle())
184
185 def testRunAngle136(self):
186 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
187 136).getHandle(), self.anim2.getHandle())
188
189 def testRunAngle0(self):
190 self.assertEqual(
191 self.runaction.get2dGfxVisual().getAnimationByAngle(0).getHandle(),
192 self.anim0.getHandle())
193
194 def testRunAngle40(self):
195 self.assertEqual(
196 self.runaction.get2dGfxVisual().getAnimationByAngle(40).getHandle(),
197 self.anim0.getHandle())
198
199 def testRunAngle45(self):
200 self.assertEqual(
201 self.runaction.get2dGfxVisual().getAnimationByAngle(45).getHandle(),
202 self.anim0.getHandle())
203
204 def testRunAngle270(self):
205 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
206 270).getHandle(), self.anim3.getHandle())
207
208 def testRunAngle269(self):
209 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
210 269).getHandle(), self.anim3.getHandle())
211
212 def testRunAngle271(self):
213 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
214 271).getHandle(), self.anim3.getHandle())
215
216 def testRunAngle314(self):
217 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
218 314).getHandle(), self.anim3.getHandle())
219
220 def testRunAngle359(self):
221 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
222 359).getHandle(), self.anim0.getHandle())
223
224 def testRunAngle400(self):
225 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
226 400).getHandle(), self.anim0.getHandle())
227
228 def testRunAngle451(self):
229 self.assertEqual(self.runaction.get2dGfxVisual().getAnimationByAngle(
230 451).getHandle(), self.anim1.getHandle())
231
232 def testWalkAngle0(self):
233 self.assertEqual(
234 self.walkaction.get2dGfxVisual().getAnimationByAngle(0).getHandle(),
235 self.anim3.getHandle())
236
237 def testWalkAngle60(self):
238 self.assertEqual(self.walkaction.get2dGfxVisual().getAnimationByAngle(
239 60).getHandle(), self.anim1.getHandle())
240
241 def testWalkAngle199(self):
242 self.assertEqual(self.walkaction.get2dGfxVisual().getAnimationByAngle(
243 199).getHandle(), self.anim2.getHandle())
244
245
246 class GridTests(unittest.TestCase):
247 def _testgrid(self, grid, curpos, access, cost):
248 for k, v in list(access.items()):
249 # print(k, v)
250 self.assertEqual(grid.isAccessible(fife.ModelCoordinate(*curpos),
251 fife.ModelCoordinate(*k)), v)
252 for k, v in list(cost.items()):
253 self.assertEqual(int(
254 10000 * grid.getAdjacentCost(fife.ModelCoordinate(*curpos),
255 fife.ModelCoordinate(*k))),
256 int(10000 * v))
257
258 curpos = fife.ModelCoordinate(*curpos)
259 accessiblepts = fife.ModelCoordinateVector()
260 grid.getAccessibleCoordinates(curpos, accessiblepts)
261 costpts = [fife.ModelCoordinate(*pt) for pt in list(cost.keys())]
262 for pt in costpts:
263 self.assert_(pt in accessiblepts)
264 for pt in accessiblepts:
265 self.assert_(pt in costpts)
266
267 def testHexGrid(self):
268 self.engine = getEngine(True)
269 self.model = self.engine.getModel()
270 grid = self.model.getCellGrid("hexagonal")
271 curpos = (1, 1)
272 access = {
273 (0, 0): False,
274 (0, 1): True,
275 (0, 2): False,
276 (1, 0): True,
277 (1, 1): True,
278 (1, 2): True,
279 (2, 0): True,
280 (2, 1): True,
281 (2, 2): True,
282 }
283 cost = {
284 (0, 1): 1,
285 (1, 0): 1,
286 (1, 1): 0,
287 (1, 2): 1,
288 (2, 0): 1,
289 (2, 1): 1,
290 (2, 2): 1,
291 }
292 self._testgrid(grid, curpos, access, cost)
293
294 def testSquareGrid(self):
295 self.engine = getEngine(True)
296 self.model = self.engine.getModel()
297 grid = self.model.getCellGrid("square")
298 grid.setAllowDiagonals(False)
299 curpos = (1, 1)
300 access = {
301 (0, 0): False,
302 (0, 1): True,
303 (0, 2): False,
304 (1, 0): True,
305 (1, 1): True,
306 (1, 2): True,
307 (2, 0): False,
308 (2, 1): True,
309 (2, 2): False,
310 }
311 cost = {
312 (0, 1): 1,
313 (1, 0): 1,
314 (1, 1): 0,
315 (1, 2): 1,
316 (2, 1): 1,
317 }
318 self._testgrid(grid, curpos, access, cost)
319
320 def testDiagSquareGrid(self):
321 self.engine = getEngine(True)
322 self.model = self.engine.getModel()
323 grid = self.model.getCellGrid("square")
324 grid.setAllowDiagonals(True)
325 curpos = (1, 1)
326 access = {
327 (0, 0): True,
328 (0, 1): True,
329 (0, 2): True,
330 (1, 0): True,
331 (1, 1): True,
332 (1, 2): True,
333 (2, 0): True,
334 (2, 1): True,
335 (2, 2): True,
336 }
337 cost = {
338 (0, 0): 1.4,
339 (0, 1): 1,
340 (0, 2): 1.4,
341 (1, 0): 1,
342 (1, 1): 0,
343 (1, 2): 1,
344 (2, 0): 1.4,
345 (2, 1): 1,
346 (2, 2): 1.4,
347 }
348 self._testgrid(grid, curpos, access, cost)
349
350
351 TEST_CLASSES = [TestModel, TestActionAngles, GridTests]
352
353 if __name__ == '__main__':
354 unittest.main()