Gridarta Editor
SelectedSquareActionsTest.java
Go to the documentation of this file.
1 /*
2  * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
3  * Copyright (C) 2000-2015 The Gridarta Developers.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19 
20 package net.sf.gridarta.action;
21 
22 import java.awt.Point;
23 import java.io.File;
24 import net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareModel;
25 import net.sf.gridarta.model.archetype.DuplicateArchetypeException;
26 import net.sf.gridarta.model.archetype.TestArchetype;
27 import net.sf.gridarta.model.gameobject.TestGameObject;
28 import net.sf.gridarta.model.maparchobject.TestMapArchObject;
29 import net.sf.gridarta.model.mapcontrol.MapControl;
30 import net.sf.gridarta.model.mapcontrol.TestMapControlCreator;
31 import net.sf.gridarta.model.mapmodel.MapFile;
32 import net.sf.gridarta.model.mapmodel.MapModel;
33 import net.sf.gridarta.model.mapmodel.MapSquare;
34 import net.sf.gridarta.model.mapmodel.TestMapModelHelper;
35 import net.sf.gridarta.utils.Size2D;
36 import org.junit.Assert;
37 import org.junit.Test;
38 
43 public class SelectedSquareActionsTest {
44 
48  private static final MapFile MAP_FILE1 = new MapFile(new File("a"));
49 
53  private static final String MAP_NAME1 = "name1";
54 
60  @Test
61  public void testDoMoveSquareTopSingle() throws DuplicateArchetypeException {
62  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
63  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
64  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
65  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
66  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareTopAction = new MoveSquareTopAction<>(selectedSquareModel, null);
67 
68  final Point point = new Point(0, 0);
69  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
70  mapModel.beginTransaction("TEST");
71  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
72  final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
73  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
74 
75  TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
76 
77  // empty selection => nothing to move
78  Assert.assertFalse(moveSquareTopAction.doAction(false));
79  Assert.assertFalse(moveSquareTopAction.doAction(true));
80 
81  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
82  selectedSquareModel.setSelectedGameObject(ob2);
83 
84  // [ob2, ob1] => ob2 can move
85  Assert.assertTrue(moveSquareTopAction.doAction(false));
86  Assert.assertTrue(moveSquareTopAction.doAction(true));
87  TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
88 
89  // [ob1, ob2] => ob2 cannot move
90  Assert.assertFalse(moveSquareTopAction.doAction(false));
91  Assert.assertFalse(moveSquareTopAction.doAction(true));
92  TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
93  }
94 
100  @Test
101  public void testDoMoveSquareTopMulti() throws DuplicateArchetypeException {
102  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
103  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
104  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
105  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
106  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareTopAction = new MoveSquareTopAction<>(selectedSquareModel, null);
107 
108  final Point pointHead = new Point(0, 0);
109  final Point pointTail = new Point(1, 0);
110  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
111  mapModel.beginTransaction("TEST");
112  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
113  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
114  final TestGameObject ob1Head = mapModelHelper.insertFloor(mapModel, pointHead);
115  final TestGameObject ob1Tail = mapModelHelper.insertFloor(mapModel, pointTail);
116  final TestGameObject ob2Head = mapModelHelper.insertMob21(mapModel, pointHead);
117  final TestGameObject ob2Tail = ob2Head.getMultiNext();
118 
119  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
120  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
121 
122  // empty selection => nothing to move
123  Assert.assertFalse(moveSquareTopAction.doAction(false));
124  Assert.assertFalse(moveSquareTopAction.doAction(true));
125 
126  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
127  selectedSquareModel.setSelectedGameObject(ob1Head);
128 
129  // [ob1, ob2] => ob1 can move
130  Assert.assertTrue(moveSquareTopAction.doAction(false));
131  Assert.assertTrue(moveSquareTopAction.doAction(true));
132  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
133  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
134 
135  // [ob2, ob1] => ob1 cannot move
136  Assert.assertFalse(moveSquareTopAction.doAction(false));
137  Assert.assertFalse(moveSquareTopAction.doAction(true));
138  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
139  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
140 
141  selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
142  selectedSquareModel.setSelectedGameObject(ob1Tail);
143 
144  // [ob1, ob2] => ob1 can move // XXX: this probably should be changed: moving tail parts is not sensible
145  Assert.assertTrue(moveSquareTopAction.doAction(false));
146  Assert.assertTrue(moveSquareTopAction.doAction(true));
147  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
148  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
149 
150  // [ob2, ob1] => ob1 cannot move
151  Assert.assertFalse(moveSquareTopAction.doAction(false));
152  Assert.assertFalse(moveSquareTopAction.doAction(true));
153  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
154  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
155  }
156 
162  @Test
163  public void testDoMoveSquareUpSingle() throws DuplicateArchetypeException {
164  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
165  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
166  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
167  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
168  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareUpAction = new MoveSquareUpAction<>(selectedSquareModel, null);
169 
170  final Point point = new Point(0, 0);
171  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
172  mapModel.beginTransaction("TEST");
173  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
174  final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
175  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
176 
177  TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
178 
179  // empty selection => nothing to move
180  Assert.assertFalse(moveSquareUpAction.doAction(false));
181  Assert.assertFalse(moveSquareUpAction.doAction(true));
182 
183  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
184  selectedSquareModel.setSelectedGameObject(ob2);
185 
186  // [ob2, ob1] => ob2 can move
187  Assert.assertTrue(moveSquareUpAction.doAction(false));
188  Assert.assertTrue(moveSquareUpAction.doAction(true));
189  TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
190 
191  // [ob1, ob2] => ob2 cannot move
192  Assert.assertFalse(moveSquareUpAction.doAction(false));
193  Assert.assertFalse(moveSquareUpAction.doAction(true));
194  TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
195  }
196 
202  @Test
203  public void testDoMoveSquareUpMulti() throws DuplicateArchetypeException {
204  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
205  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
206  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
207  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
208  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareUpAction = new MoveSquareUpAction<>(selectedSquareModel, null);
209 
210  final Point pointHead = new Point(0, 0);
211  final Point pointTail = new Point(1, 0);
212  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
213  mapModel.beginTransaction("TEST");
214  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
215  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
216  final TestGameObject ob2Head = mapModelHelper.insertFloor(mapModel, pointHead);
217  final TestGameObject ob2Tail = mapModelHelper.insertFloor(mapModel, pointTail);
218  final TestGameObject ob1Head = mapModelHelper.insertMob21(mapModel, pointHead);
219  final TestGameObject ob1Tail = ob1Head.getMultiNext();
220 
221  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
222  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
223 
224  // empty selection => nothing to move
225  Assert.assertFalse(moveSquareUpAction.doAction(false));
226  Assert.assertFalse(moveSquareUpAction.doAction(true));
227 
228  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
229  selectedSquareModel.setSelectedGameObject(ob2Head);
230 
231  // [ob2, ob1] => ob2 can move
232  Assert.assertTrue(moveSquareUpAction.doAction(false));
233  Assert.assertTrue(moveSquareUpAction.doAction(true));
234  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
235  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
236 
237  // [ob1, ob2] => ob2 cannot move
238  Assert.assertFalse(moveSquareUpAction.doAction(false));
239  Assert.assertFalse(moveSquareUpAction.doAction(true));
240  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
241  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
242 
243  selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
244  selectedSquareModel.setSelectedGameObject(ob2Tail);
245 
246  // [ob2, ob1] => ob2 can move // XXX: this probably should be changed: moving tail parts is not sensible
247  Assert.assertTrue(moveSquareUpAction.doAction(false));
248  Assert.assertTrue(moveSquareUpAction.doAction(true));
249  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
250  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
251 
252  // [ob1, ob2] => ob2 cannot move
253  Assert.assertFalse(moveSquareUpAction.doAction(false));
254  Assert.assertFalse(moveSquareUpAction.doAction(true));
255  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
256  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
257  }
258 
264  @Test
265  public void testDoMoveSquareDownSingle() throws DuplicateArchetypeException {
266  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
267  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
268  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
269  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
270  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareDownAction = new MoveSquareDownAction<>(selectedSquareModel, null);
271 
272  final Point point = new Point(0, 0);
273  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
274  mapModel.beginTransaction("TEST");
275  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
276  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
277  final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
278 
279  TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
280 
281  // empty selection => nothing to move
282  Assert.assertFalse(moveSquareDownAction.doAction(false));
283  Assert.assertFalse(moveSquareDownAction.doAction(true));
284 
285  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
286  selectedSquareModel.setSelectedGameObject(ob2);
287 
288  // [ob1, ob2] => ob2 can move
289  Assert.assertTrue(moveSquareDownAction.doAction(false));
290  Assert.assertTrue(moveSquareDownAction.doAction(true));
291  TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
292 
293  // [ob2, ob1] => ob2 cannot move
294  Assert.assertFalse(moveSquareDownAction.doAction(false));
295  Assert.assertFalse(moveSquareDownAction.doAction(true));
296  TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
297  }
298 
304  @Test
305  public void testDoMoveSquareDownMulti() throws DuplicateArchetypeException {
306  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
307  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
308  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
309  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
310  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareDownAction = new MoveSquareDownAction<>(selectedSquareModel, null);
311 
312  final Point pointHead = new Point(0, 0);
313  final Point pointTail = new Point(1, 0);
314  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
315  mapModel.beginTransaction("TEST");
316  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
317  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
318  final TestGameObject ob1Head = mapModelHelper.insertMob21(mapModel, pointHead);
319  final TestGameObject ob1Tail = ob1Head.getMultiNext();
320  final TestGameObject ob2Head = mapModelHelper.insertFloor(mapModel, pointHead);
321  final TestGameObject ob2Tail = mapModelHelper.insertFloor(mapModel, pointTail);
322 
323  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
324  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
325 
326  // empty selection => nothing to move
327  Assert.assertFalse(moveSquareDownAction.doAction(false));
328  Assert.assertFalse(moveSquareDownAction.doAction(true));
329 
330  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
331  selectedSquareModel.setSelectedGameObject(ob2Head);
332 
333  // [ob2, ob1] => ob2 can move
334  Assert.assertTrue(moveSquareDownAction.doAction(false));
335  Assert.assertTrue(moveSquareDownAction.doAction(true));
336  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
337  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
338 
339  // [ob1, ob2] => ob2 cannot move
340  Assert.assertFalse(moveSquareDownAction.doAction(false));
341  Assert.assertFalse(moveSquareDownAction.doAction(true));
342  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
343  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
344 
345  selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
346  selectedSquareModel.setSelectedGameObject(ob2Tail);
347 
348  // [ob2, ob1] => ob2 can move // XXX: this probably should be changed: moving tail parts is not sensible
349  Assert.assertTrue(moveSquareDownAction.doAction(false));
350  Assert.assertTrue(moveSquareDownAction.doAction(true));
351  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
352  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
353 
354  // [ob1, ob2] => ob2 cannot move
355  Assert.assertFalse(moveSquareDownAction.doAction(false));
356  Assert.assertFalse(moveSquareDownAction.doAction(true));
357  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
358  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
359  }
360 
366  @Test
367  public void testDoMoveSquareBottomSingle() throws DuplicateArchetypeException {
368  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
369  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
370  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
371  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
372  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareBottomAction = new MoveSquareBottomAction<>(selectedSquareModel, null);
373 
374  final Point point = new Point(0, 0);
375  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
376  mapModel.beginTransaction("TEST");
377  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
378  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
379  final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
380 
381  TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
382 
383  // empty selection => nothing to move
384  Assert.assertFalse(moveSquareBottomAction.doAction(false));
385  Assert.assertFalse(moveSquareBottomAction.doAction(true));
386 
387  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
388  selectedSquareModel.setSelectedGameObject(ob2);
389 
390  // [ob1, ob2] => ob2 can move
391  Assert.assertTrue(moveSquareBottomAction.doAction(false));
392  Assert.assertTrue(moveSquareBottomAction.doAction(true));
393  TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
394 
395  // [ob2, ob1] => ob2 cannot move
396  Assert.assertFalse(moveSquareBottomAction.doAction(false));
397  Assert.assertFalse(moveSquareBottomAction.doAction(true));
398  TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
399  }
400 
406  @Test
407  public void testDoMoveSquareBottomMulti() throws DuplicateArchetypeException {
408  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
409  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
410  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
411  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
412  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareBottomAction = new MoveSquareBottomAction<>(selectedSquareModel, null);
413 
414  final Point pointHead = new Point(0, 0);
415  final Point pointTail = new Point(1, 0);
416  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
417  mapModel.beginTransaction("TEST");
418  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
419  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
420  final TestGameObject ob1Head = mapModelHelper.insertMob21(mapModel, pointHead);
421  final TestGameObject ob1Tail = ob1Head.getMultiNext();
422  final TestGameObject ob2Head = mapModelHelper.insertFloor(mapModel, pointHead);
423  final TestGameObject ob2Tail = mapModelHelper.insertFloor(mapModel, pointTail);
424 
425  TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
426  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
427 
428  // empty selection => nothing to move
429  Assert.assertFalse(moveSquareBottomAction.doAction(false));
430  Assert.assertFalse(moveSquareBottomAction.doAction(true));
431 
432  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
433  selectedSquareModel.setSelectedGameObject(ob2Head);
434 
435  // [ob2, ob1] => ob2 can move
436  Assert.assertTrue(moveSquareBottomAction.doAction(false));
437  Assert.assertTrue(moveSquareBottomAction.doAction(true));
438  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
439  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
440 
441  // [ob1, ob2] => ob2 cannot move
442  Assert.assertFalse(moveSquareBottomAction.doAction(false));
443  Assert.assertFalse(moveSquareBottomAction.doAction(true));
444  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
445  TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
446 
447  selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
448  selectedSquareModel.setSelectedGameObject(ob2Tail);
449 
450  // [ob2, ob1] => ob2 can move // XXX: this probably should be changed: moving tail parts is not sensible
451  Assert.assertTrue(moveSquareBottomAction.doAction(false));
452  Assert.assertTrue(moveSquareBottomAction.doAction(true));
453  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
454  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
455 
456  // [ob1, ob2] => ob2 cannot move
457  Assert.assertFalse(moveSquareBottomAction.doAction(false));
458  Assert.assertFalse(moveSquareBottomAction.doAction(true));
459  TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
460  TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
461  }
462 
468  @Test
469  public void testDoMoveSquareEnvSingle1() throws DuplicateArchetypeException {
470  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
471  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
472  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
473  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
474  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
475 
476  final Point point = new Point(0, 0);
477  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
478  mapModel.beginTransaction("TEST");
479  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
480  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
481 
482  TestMapModelHelper.checkContents(mapSquare, ob1);
483 
484  // empty selection => nothing to move
485  Assert.assertFalse(moveSquareEnvAction.doAction(false));
486  Assert.assertFalse(moveSquareEnvAction.doAction(true));
487 
488  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
489  selectedSquareModel.setSelectedGameObject(ob1);
490 
491  // [ob1] => ob1 cannot move
492  Assert.assertFalse(moveSquareEnvAction.doAction(false));
493  Assert.assertFalse(moveSquareEnvAction.doAction(true));
494  TestMapModelHelper.checkContents(mapSquare, ob1);
495  }
496 
502  @Test
503  public void testDoMoveSquareEnvSingle2() throws DuplicateArchetypeException {
504  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
505  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
506  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
507  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
508  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
509 
510  final Point point = new Point(0, 0);
511  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
512  mapModel.beginTransaction("TEST");
513  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
514  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
515  final TestGameObject ob2 = mapModelHelper.insertExit(mapModel, point);
516  final TestGameObject ob3 = mapModelHelper.insertExit(mapModel, point);
517  final TestGameObject ob4 = mapModelHelper.insertExit(ob2);
518 
519  TestMapModelHelper.checkContents(mapSquare, ob1, ob2, ob3);
520  TestMapModelHelper.checkContents(ob2, ob4);
521 
522  // empty selection => nothing to move
523  Assert.assertFalse(moveSquareEnvAction.doAction(false));
524  Assert.assertFalse(moveSquareEnvAction.doAction(true));
525 
526  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
527  selectedSquareModel.setSelectedGameObject(ob4);
528 
529  // ob4 can move
530  Assert.assertTrue(moveSquareEnvAction.doAction(false));
531  Assert.assertTrue(moveSquareEnvAction.doAction(true));
532  TestMapModelHelper.checkContents(mapSquare, ob1, ob4, ob2, ob3);
533  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
534  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
535 
536  // ob4 cannot move
537  Assert.assertFalse(moveSquareEnvAction.doAction(false));
538  Assert.assertFalse(moveSquareEnvAction.doAction(true));
539  TestMapModelHelper.checkContents(mapSquare, ob1, ob4, ob2, ob3);
540  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
541  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
542  }
543 
549  @Test
550  public void testDoMoveSquareEnvSingle3() throws DuplicateArchetypeException {
551  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
552  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
553  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
554  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
555  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
556 
557  final Point point = new Point(0, 0);
558  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
559  mapModel.beginTransaction("TEST");
560  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
561  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
562  final TestGameObject ob2 = mapModelHelper.insertExit(ob1);
563  final TestGameObject ob3 = mapModelHelper.insertExit(ob2);
564  final TestGameObject ob4 = mapModelHelper.insertExit(ob2);
565  final TestGameObject ob5 = mapModelHelper.insertExit(ob2);
566 
567  TestMapModelHelper.checkContents(mapSquare, ob1);
568  TestMapModelHelper.checkContents(ob1, ob2);
569  TestMapModelHelper.checkContents(ob2, ob3, ob4, ob5);
570 
571  // empty selection => nothing to move
572  Assert.assertFalse(moveSquareEnvAction.doAction(false));
573  Assert.assertFalse(moveSquareEnvAction.doAction(true));
574 
575  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
576  selectedSquareModel.setSelectedGameObject(ob4);
577 
578  // ob4 can move
579  Assert.assertTrue(moveSquareEnvAction.doAction(false));
580  Assert.assertTrue(moveSquareEnvAction.doAction(true));
581  TestMapModelHelper.checkContents(mapSquare, ob1);
582  TestMapModelHelper.checkContents(ob1, ob4, ob2);
583  TestMapModelHelper.checkContents(ob2, ob3, ob5);
584  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
585  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
586 
587  // ob4 can move
588  Assert.assertTrue(moveSquareEnvAction.doAction(false));
589  Assert.assertTrue(moveSquareEnvAction.doAction(true));
590  TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
591  TestMapModelHelper.checkContents(ob1, ob2);
592  TestMapModelHelper.checkContents(ob2, ob3, ob5);
593  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
594  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
595 
596  // ob4 cannot move
597  Assert.assertFalse(moveSquareEnvAction.doAction(false));
598  Assert.assertFalse(moveSquareEnvAction.doAction(true));
599  TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
600  TestMapModelHelper.checkContents(ob1, ob2);
601  TestMapModelHelper.checkContents(ob2, ob3, ob5);
602  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
603  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
604  }
605 
611  @Test
612  public void testDoMoveSquareEnvMulti3() throws DuplicateArchetypeException {
613  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
614  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
615  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
616  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
617  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
618 
619  final Point point = new Point(0, 0);
620  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
621  mapModel.beginTransaction("TEST");
622  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(point);
623  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(new Point(1, 0));
624  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
625  final TestGameObject ob2 = mapModelHelper.insertExit(ob1);
626  final TestGameObject ob3 = mapModelHelper.insertExit(ob2);
627  final TestGameObject ob4Head = mapModelHelper.insertMob21(ob2);
628  final TestGameObject ob5 = mapModelHelper.insertExit(ob2);
629 
630  TestMapModelHelper.checkContents(mapSquareHead, ob1);
631  TestMapModelHelper.checkContents(ob1, ob2);
632  TestMapModelHelper.checkContents(ob2, ob3, ob4Head, ob5);
633  TestMapModelHelper.checkContents(mapSquareTail);
634 
635  // empty selection => nothing to move
636  Assert.assertFalse(moveSquareEnvAction.doAction(false));
637  Assert.assertFalse(moveSquareEnvAction.doAction(true));
638 
639  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
640  selectedSquareModel.setSelectedGameObject(ob4Head);
641 
642  // ob4Head can move
643  Assert.assertTrue(moveSquareEnvAction.doAction(false));
644  Assert.assertTrue(moveSquareEnvAction.doAction(true));
645  TestMapModelHelper.checkContents(mapSquareHead, ob1);
646  TestMapModelHelper.checkContents(ob1, ob4Head, ob2);
647  final TestGameObject ob4Tail1 = ob4Head.getMultiNext();
648  Assert.assertNull(ob4Tail1);
649  TestMapModelHelper.checkContents(ob2, ob3, ob5);
650  TestMapModelHelper.checkContents(mapSquareTail);
651  Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
652  Assert.assertEquals(ob4Head, selectedSquareModel.getSelectedGameObject());
653 
654  // ob4Head can move
655  Assert.assertTrue(moveSquareEnvAction.doAction(false));
656  Assert.assertTrue(moveSquareEnvAction.doAction(true));
657  TestMapModelHelper.checkContents(mapSquareHead, ob4Head, ob1);
658  TestMapModelHelper.checkContents(ob1, ob2);
659  TestMapModelHelper.checkContents(ob2, ob3, ob5);
660  final TestGameObject ob4Tail2 = ob4Head.getMultiNext();
661  Assert.assertNotNull(ob4Tail2);
662  TestMapModelHelper.checkContents(mapSquareTail, ob4Tail2);
663  Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
664  Assert.assertEquals(ob4Head, selectedSquareModel.getSelectedGameObject());
665 
666  // ob4Head cannot move
667  Assert.assertFalse(moveSquareEnvAction.doAction(false));
668  Assert.assertFalse(moveSquareEnvAction.doAction(true));
669  TestMapModelHelper.checkContents(mapSquareHead, ob4Head, ob1);
670  TestMapModelHelper.checkContents(ob1, ob2);
671  TestMapModelHelper.checkContents(ob2, ob3, ob5);
672  Assert.assertEquals(ob4Tail2, ob4Head.getMultiNext());
673  TestMapModelHelper.checkContents(mapSquareTail, ob4Tail2);
674  Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
675  Assert.assertEquals(ob4Head, selectedSquareModel.getSelectedGameObject());
676  }
677 
683  @Test
684  public void testDoMoveSquareEnvMulti4() throws DuplicateArchetypeException {
685  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
686  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
687  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
688  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
689  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
690 
691  final Point point = new Point(0, 0);
692  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
693  mapModel.beginTransaction("TEST");
694  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(point);
695  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
696  final TestGameObject ob2Head = mapModelHelper.insertMob21(ob1);
697 
698  TestMapModelHelper.checkContents(mapSquareHead, ob1);
699  TestMapModelHelper.checkContents(ob1, ob2Head);
700 
701  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
702  selectedSquareModel.setSelectedGameObject(ob2Head);
703 
704  // ob2Head cannot move: would not fit into map
705  Assert.assertFalse(moveSquareEnvAction.doAction(false));
706  Assert.assertFalse(moveSquareEnvAction.doAction(true));
707  TestMapModelHelper.checkContents(mapSquareHead, ob1);
708  TestMapModelHelper.checkContents(ob1, ob2Head);
709  Assert.assertNull(ob2Head.getMultiNext());
710  }
711 
717  @Test
718  public void testDoMoveSquareInvSingle1() throws DuplicateArchetypeException {
719  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
720  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
721  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
722  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
723  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareInvAction = new MoveSquareInvAction<>(selectedSquareModel, null);
724 
725  final Point point = new Point(0, 0);
726  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
727  mapModel.beginTransaction("TEST");
728  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
729  final TestGameObject ob4 = mapModelHelper.insertExit(mapModel, point);
730  final TestGameObject ob3 = mapModelHelper.insertExit(mapModel, point);
731  final TestGameObject ob2 = mapModelHelper.insertExit(mapModel, point);
732  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
733 
734  TestMapModelHelper.checkContents(mapSquare, ob4, ob3, ob2, ob1);
735 
736  // empty selection => nothing to move
737  Assert.assertFalse(moveSquareInvAction.doAction(false));
738  Assert.assertFalse(moveSquareInvAction.doAction(true));
739 
740  // select ob3
741  selectedSquareModel.setSelectedMapSquare(mapSquare, null);
742  selectedSquareModel.setSelectedGameObject(ob3);
743 
744  // ob3 can move
745  Assert.assertTrue(moveSquareInvAction.doAction(false));
746  Assert.assertTrue(moveSquareInvAction.doAction(true));
747  TestMapModelHelper.checkContents(mapSquare, ob4, ob2, ob1);
748  TestMapModelHelper.checkContents(ob2, ob3);
749  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
750  Assert.assertEquals(ob3, selectedSquareModel.getSelectedGameObject());
751 
752  // ob3 cannot move
753  Assert.assertFalse(moveSquareInvAction.doAction(false));
754  Assert.assertFalse(moveSquareInvAction.doAction(true));
755  TestMapModelHelper.checkContents(mapSquare, ob4, ob2, ob1);
756  TestMapModelHelper.checkContents(ob2, ob3);
757  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
758  Assert.assertEquals(ob3, selectedSquareModel.getSelectedGameObject());
759 
760  // select ob2
761  selectedSquareModel.setSelectedGameObject(ob2);
762 
763  // ob2 can move
764  Assert.assertTrue(moveSquareInvAction.doAction(false));
765  Assert.assertTrue(moveSquareInvAction.doAction(true));
766  TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
767  TestMapModelHelper.checkContents(ob1, ob2);
768  TestMapModelHelper.checkContents(ob2, ob3);
769  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
770  Assert.assertEquals(ob2, selectedSquareModel.getSelectedGameObject());
771 
772  // ob2 cannot move
773  Assert.assertFalse(moveSquareInvAction.doAction(false));
774  Assert.assertFalse(moveSquareInvAction.doAction(true));
775  TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
776  TestMapModelHelper.checkContents(ob1, ob2);
777  TestMapModelHelper.checkContents(ob2, ob3);
778  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
779  Assert.assertEquals(ob2, selectedSquareModel.getSelectedGameObject());
780 
781  // select ob4
782  selectedSquareModel.setSelectedGameObject(ob4);
783 
784  // ob4 can move
785  Assert.assertTrue(moveSquareInvAction.doAction(false));
786  Assert.assertTrue(moveSquareInvAction.doAction(true));
787  TestMapModelHelper.checkContents(mapSquare, ob1);
788  TestMapModelHelper.checkContents(ob1, ob4, ob2);
789  TestMapModelHelper.checkContents(ob2, ob3);
790  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
791  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
792 
793  // ob4 can move
794  Assert.assertTrue(moveSquareInvAction.doAction(false));
795  Assert.assertTrue(moveSquareInvAction.doAction(true));
796  TestMapModelHelper.checkContents(mapSquare, ob1);
797  TestMapModelHelper.checkContents(ob1, ob2);
798  TestMapModelHelper.checkContents(ob2, ob4, ob3);
799  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
800  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
801 
802  // ob4 can move
803  Assert.assertTrue(moveSquareInvAction.doAction(false));
804  Assert.assertTrue(moveSquareInvAction.doAction(true));
805  TestMapModelHelper.checkContents(mapSquare, ob1);
806  TestMapModelHelper.checkContents(ob1, ob2);
807  TestMapModelHelper.checkContents(ob2, ob3);
808  TestMapModelHelper.checkContents(ob3, ob4);
809  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
810  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
811 
812  // ob4 cannot move
813  Assert.assertFalse(moveSquareInvAction.doAction(false));
814  Assert.assertFalse(moveSquareInvAction.doAction(true));
815  TestMapModelHelper.checkContents(mapSquare, ob1);
816  TestMapModelHelper.checkContents(ob1, ob2);
817  TestMapModelHelper.checkContents(ob2, ob3);
818  TestMapModelHelper.checkContents(ob3, ob4);
819  Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
820  Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
821  }
822 
828  @Test
829  public void testDoMoveSquareInvMulti1() throws DuplicateArchetypeException {
830  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
831  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
832  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
833  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
834  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareInvAction = new MoveSquareInvAction<>(selectedSquareModel, null);
835 
836  final Point point = new Point(0, 0);
837  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
838  mapModel.beginTransaction("TEST");
839  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(point);
840  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(new Point(1, 0));
841  final TestGameObject ob3Head = mapModelHelper.insertMob21(mapModel, point);
842  final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
843  final TestGameObject ob2 = mapModelHelper.insertExit(ob1);
844 
845  final TestGameObject ob3Tail = ob3Head.getMultiNext();
846  Assert.assertNotNull(ob3Tail);
847  TestMapModelHelper.checkContents(mapSquareHead, ob3Head, ob1);
848  TestMapModelHelper.checkContents(mapSquareTail, ob3Tail);
849  TestMapModelHelper.checkContents(ob1, ob2);
850 
851  // empty selection => nothing to move
852  Assert.assertFalse(moveSquareInvAction.doAction(false));
853  Assert.assertFalse(moveSquareInvAction.doAction(true));
854 
855  // select ob3Head
856  selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
857  selectedSquareModel.setSelectedGameObject(ob3Head);
858 
859  // ob3Head can move; ob3Tail is removed
860  Assert.assertTrue(moveSquareInvAction.doAction(false));
861  Assert.assertTrue(moveSquareInvAction.doAction(true));
862  TestMapModelHelper.checkContents(mapSquareHead, ob1);
863  TestMapModelHelper.checkContents(mapSquareTail);
864  TestMapModelHelper.checkContents(ob1, ob3Head, ob2);
865  Assert.assertNull(ob3Head.getMultiNext());
866  Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
867  Assert.assertEquals(ob3Head, selectedSquareModel.getSelectedGameObject());
868 
869  // ob3Head can move
870  Assert.assertTrue(moveSquareInvAction.doAction(false));
871  Assert.assertTrue(moveSquareInvAction.doAction(true));
872  TestMapModelHelper.checkContents(mapSquareHead, ob1);
873  TestMapModelHelper.checkContents(mapSquareTail);
874  TestMapModelHelper.checkContents(ob1, ob2);
875  TestMapModelHelper.checkContents(ob2, ob3Head);
876  Assert.assertNull(ob3Head.getMultiNext());
877  Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
878  Assert.assertEquals(ob3Head, selectedSquareModel.getSelectedGameObject());
879 
880  // ob3Head cannot move
881  Assert.assertFalse(moveSquareInvAction.doAction(false));
882  Assert.assertFalse(moveSquareInvAction.doAction(true));
883  TestMapModelHelper.checkContents(mapSquareHead, ob1);
884  TestMapModelHelper.checkContents(mapSquareTail);
885  TestMapModelHelper.checkContents(ob1, ob2);
886  TestMapModelHelper.checkContents(ob2, ob3Head);
887  Assert.assertNull(ob3Head.getMultiNext());
888  Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
889  Assert.assertEquals(ob3Head, selectedSquareModel.getSelectedGameObject());
890  }
891 
897  @Test
898  public void testDoMoveSquareInvIntoHead1() throws DuplicateArchetypeException {
899  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
900  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
901  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(3, 1));
902  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
903  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareInvAction = new MoveSquareInvAction<>(selectedSquareModel, null);
904 
905  final Point point0 = new Point(0, 0);
906  final Point point1 = new Point(1, 0);
907  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
908  mapModel.beginTransaction("TEST");
909  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare0 = mapModel.getMapSquare(point0);
910  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare1 = mapModel.getMapSquare(point1);
911  final TestGameObject ob2 = mapModelHelper.insertMob21(mapModel, point1);
912  final TestGameObject ob1 = mapModelHelper.insertMob21(mapModel, point0);
913 
914  TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21,mob21b|mob21b");
915 
916  // select ob2
917  selectedSquareModel.setSelectedMapSquare(mapSquare1, null);
918  selectedSquareModel.setSelectedGameObject(ob2);
919 
920  // move ob2 into ob1
921  Assert.assertTrue(moveSquareInvAction.doAction(true));
922 
923  TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21b|");
924  TestMapModelHelper.checkContents(mapSquare0, ob1);
925  final TestGameObject ob1Tail = ob1.getMultiNext();
926  Assert.assertNotNull(ob1Tail);
927  TestMapModelHelper.checkContents(mapSquare1, ob1Tail);
928  TestMapModelHelper.checkContents(ob1, ob2);
929  }
930 
935  @Test
936  public void testMoveTailPart() throws DuplicateArchetypeException {
937  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
938  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
939  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
940  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
941  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareTopAction = new MoveSquareTopAction<>(selectedSquareModel, null);
942  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareUpAction = new MoveSquareUpAction<>(selectedSquareModel, null);
943  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareDownAction = new MoveSquareDownAction<>(selectedSquareModel, null);
944  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareBottomAction = new MoveSquareBottomAction<>(selectedSquareModel, null);
945  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareInvAction = new MoveSquareInvAction<>(selectedSquareModel, null);
946  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
947 
948  final Point pointHead = new Point(0, 0);
949  final Point pointTail = new Point(1, 0);
950  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
951  mapModel.beginTransaction("TEST");
952  final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
953  mapModelHelper.insertExit(mapModel, pointHead);
954  mapModelHelper.insertExit(mapModel, pointTail);
955  final TestGameObject ob2Head = mapModelHelper.insertMob21(mapModel, pointHead);
956  mapModelHelper.insertExit(mapModel, pointHead);
957  mapModelHelper.insertExit(mapModel, pointTail);
958 
959  TestMapModelHelper.checkMapContents(mapModel, "exit,mob21,exit|exit,mob21b,exit");
960 
961  // select ob2Tail
962  selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
963  selectedSquareModel.setSelectedGameObject(ob2Head.getMultiNext());
964 
965  // ob2Tail cannot move
966  Assert.assertFalse(moveSquareTopAction.doAction(false));
967  Assert.assertFalse(moveSquareUpAction.doAction(false));
968  Assert.assertFalse(moveSquareDownAction.doAction(false));
969  Assert.assertFalse(moveSquareBottomAction.doAction(false));
970  Assert.assertFalse(moveSquareInvAction.doAction(false));
971  Assert.assertFalse(moveSquareEnvAction.doAction(false));
972  }
973 
979  @Test
980  public void testMoveEnvIntoSelectedMapSquare() throws DuplicateArchetypeException {
981  final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
982  final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
983  final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(3, 1));
984  final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<>();
985  final AbstractMoveSquareAction<TestGameObject, TestMapArchObject, TestArchetype> moveSquareEnvAction = new MoveSquareEnvAction<>(selectedSquareModel, null);
986 
987  final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
988  mapModel.beginTransaction("TEST");
989  final TestGameObject ob1 = mapModelHelper.insertMob21(mapModel, new Point(0, 0));
990  final TestGameObject ob2 = mapModelHelper.insertMob21(ob1);
991 
992  TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21b|");
993 
994  // select ob2 in (1,0)
995  selectedSquareModel.setSelectedMapSquare(mapModel.getMapSquare(new Point(1, 0)), null);
996  selectedSquareModel.setSelectedGameObject(ob2);
997 
998  // move ob2 into (1,0)
999  Assert.assertTrue(moveSquareEnvAction.doAction(true));
1000 
1001  TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21,mob21b|mob21b");
1002  }
1003 
1004 }
net.sf.gridarta.action.SelectedSquareActionsTest
Regression tests for AbstractMoveSquareAction implementations.
Definition: SelectedSquareActionsTest.java:43
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareUpSingle
void testDoMoveSquareUpSingle()
Checks that MoveSquareUpAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:163
net.sf.gridarta.action.MoveSquareInvAction.doAction
boolean doAction(final boolean performAction, @Nullable final G gameObject)
Definition: MoveSquareInvAction.java:58
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareBottomSingle
void testDoMoveSquareBottomSingle()
Checks that MoveSquareBottomAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:367
net.sf.gridarta.model.mapmodel.MapModel
A MapModel reflects the data of a map.
Definition: MapModel.java:75
net.sf.gridarta.gui
Graphical User Interface of Gridarta.
net.sf.gridarta.action.SelectedSquareActionsTest.testMoveEnvIntoSelectedMapSquare
void testMoveEnvIntoSelectedMapSquare()
Checks that MoveSquareEnvAction inserts into selected map square.
Definition: SelectedSquareActionsTest.java:980
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareInvSingle1
void testDoMoveSquareInvSingle1()
Checks that MoveSquareInvAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:718
net.sf.gridarta.action.MoveSquareTopAction.doAction
boolean doAction(final boolean performAction, @Nullable final G gameObject)
Definition: MoveSquareTopAction.java:58
net.sf.gridarta.model.mapmodel.TestMapModelHelper
Helper class for creating MapModel instances for regression tests.
Definition: TestMapModelHelper.java:45
net.sf.gridarta.action.MoveSquareBottomAction.doAction
boolean doAction(final boolean performAction, @Nullable final G gameObject)
Definition: MoveSquareBottomAction.java:58
net.sf.gridarta.model.mapcontrol.TestMapControlCreator
Helper class for creating MapControl instances for regression tests.
Definition: TestMapControlCreator.java:68
net.sf.gridarta.action.MoveSquareUpAction.doAction
boolean doAction(final boolean performAction, @Nullable final G gameObject)
Definition: MoveSquareUpAction.java:58
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareDownSingle
void testDoMoveSquareDownSingle()
Checks that MoveSquareDownAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:265
net.sf.gridarta.model.maparchobject.TestMapArchObject
A MapArchObject implementation for testing purposes.
Definition: TestMapArchObject.java:28
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareInvMulti1
void testDoMoveSquareInvMulti1()
Checks that MoveSquareInvAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:829
net.sf.gridarta.model.mapcontrol.MapControl.getMapModel
MapModel< G, A, R > getMapModel()
Returns the map model.
net.sf.gridarta.model.mapmodel.TestMapModelHelper.checkContents
static void checkContents(@NotNull final Iterable< TestGameObject > mapSquare, @NotNull final BaseObject<?, ?, ?, ?>... gameObjects)
Checks that a MapSquare contains the given game objects.
Definition: TestMapModelHelper.java:277
net.sf.gridarta.model.mapmodel.TestMapModelHelper.insertFloor
TestGameObject insertFloor(@NotNull final MapModel< TestGameObject, TestMapArchObject, TestArchetype > mapModel, @NotNull final Point point)
Inserts a floorArchetype game object into a map model.
Definition: TestMapModelHelper.java:135
net.sf.gridarta
Base package of all Gridarta classes.
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareEnvSingle3
void testDoMoveSquareEnvSingle3()
Checks that MoveSquareEnvAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:550
net.sf.gridarta.action.MoveSquareDownAction
An net.sf.gridarta.utils.EditorAction that moves the selected game object in the SelectedSquareModel ...
Definition: MoveSquareDownAction.java:38
net.sf.gridarta.action.AbstractMoveSquareAction
Abstract base class for actions that move the selected game object in the SelectedSquareModel.
Definition: AbstractMoveSquareAction.java:47
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareEnvSingle2
void testDoMoveSquareEnvSingle2()
Checks that MoveSquareEnvAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:503
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareDownMulti
void testDoMoveSquareDownMulti()
Checks that MoveSquareDownAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:305
net.sf.gridarta.model.archetype.DuplicateArchetypeException
An Exception indicating that an Archetype name is not unique.
Definition: DuplicateArchetypeException.java:29
net.sf.gridarta.action.MoveSquareDownAction.doAction
boolean doAction(final boolean performAction, @Nullable final G gameObject)
Definition: MoveSquareDownAction.java:58
net.sf.gridarta.model.mapmodel.MapModel.getMapSquare
MapSquare< G, A, R > getMapSquare(@NotNull Point pos)
Get the square at a specified location.
net.sf.gridarta.model.gameobject
GameObjects are the objects based on Archetypes found on maps.
Definition: AbstractGameObject.java:20
net.sf.gridarta.model.mapmodel.TestMapModelHelper.checkMapContents
static void checkMapContents(@NotNull final MapModel< TestGameObject, TestMapArchObject, TestArchetype > mapModel, @NotNull final String... lines)
Checks for expected MapModel&#39;s contents.
Definition: TestMapModelHelper.java:230
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareUpMulti
void testDoMoveSquareUpMulti()
Checks that MoveSquareUpAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:203
net.sf.gridarta.action.SelectedSquareActionsTest.MAP_FILE1
static final MapFile MAP_FILE1
The first map file.
Definition: SelectedSquareActionsTest.java:48
net.sf.gridarta.gui.panel.selectedsquare
Displays the contents of the currently selected map square.
Definition: CellRenderer.java:20
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareEnvMulti3
void testDoMoveSquareEnvMulti3()
Checks that MoveSquareEnvAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:612
net.sf.gridarta.model.mapcontrol.TestMapControlCreator.newMapModelCreator
TestMapModelHelper newMapModelCreator()
Creates a new TestMapModelHelper instance.
Definition: TestMapControlCreator.java:165
net.sf.gridarta.model.mapmodel.TestMapModelHelper.insertMob21
TestGameObject insertMob21(@NotNull final MapModel< TestGameObject, TestMapArchObject, TestArchetype > mapModel, @NotNull final Point point)
Inserts a mob21Archetype game object into a map model.
Definition: TestMapModelHelper.java:157
net.sf.gridarta.model.mapmodel.TestMapModelHelper.insertExit
TestGameObject insertExit(@NotNull final MapModel< TestGameObject, TestMapArchObject, TestArchetype > mapModel, @NotNull final Point point)
Inserts an exitArchetype game object into a map model.
Definition: TestMapModelHelper.java:146
net.sf.gridarta.action.MoveSquareBottomAction
An net.sf.gridarta.utils.EditorAction that moves the selected game object in the SelectedSquareModel ...
Definition: MoveSquareBottomAction.java:38
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareTopMulti
void testDoMoveSquareTopMulti()
Checks that MoveSquareTopAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:101
net.sf.gridarta.model.mapcontrol.MapControl
Currently nothing more than a marker interface for unification.
Definition: MapControl.java:35
net.sf.gridarta.action.SelectedSquareActionsTest.MAP_NAME1
static final String MAP_NAME1
The first map name.
Definition: SelectedSquareActionsTest.java:53
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareInvIntoHead1
void testDoMoveSquareInvIntoHead1()
Checks that MoveSquareInvAction always inserts into the head-part.
Definition: SelectedSquareActionsTest.java:898
net.sf.gridarta.action.MoveSquareUpAction
An net.sf.gridarta.utils.EditorAction that moves the selected game object in the SelectedSquareModel ...
Definition: MoveSquareUpAction.java:38
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareTopSingle
void testDoMoveSquareTopSingle()
Checks that MoveSquareTopAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:61
net.sf.gridarta.action.MoveSquareTopAction
An net.sf.gridarta.utils.EditorAction that moves the selected game object in the SelectedSquareModel ...
Definition: MoveSquareTopAction.java:38
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareEnvMulti4
void testDoMoveSquareEnvMulti4()
Checks that MoveSquareEnvAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:684
net.sf.gridarta.model.archetype.TestArchetype
An Archetype implementation for testing purposes.
Definition: TestArchetype.java:30
net.sf.gridarta.action.MoveSquareEnvAction
An net.sf.gridarta.utils.EditorAction that moves the selected game object in the SelectedSquareModel ...
Definition: MoveSquareEnvAction.java:39
net.sf.gridarta.action.MoveSquareInvAction
An net.sf.gridarta.utils.EditorAction that moves the selected game object in the SelectedSquareModel ...
Definition: MoveSquareInvAction.java:38
net.sf.gridarta.model.gameobject.TestGameObject
A GameObject implementation for testing purposes.
Definition: TestGameObject.java:34
net.sf.gridarta.model.mapmodel.MapModel.beginTransaction
void beginTransaction(@NotNull String name)
Starts a new transaction.
net.sf.gridarta.gui.panel.selectedsquare.SelectedSquareModel
The model component of the selected square control.
Definition: SelectedSquareModel.java:34
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareBottomMulti
void testDoMoveSquareBottomMulti()
Checks that MoveSquareBottomAction does work for multi-square game objects.
Definition: SelectedSquareActionsTest.java:407
net.sf.gridarta.action.SelectedSquareActionsTest.testMoveTailPart
void testMoveTailPart()
Checks that tail parts cannot be moved.
Definition: SelectedSquareActionsTest.java:936
net.sf.gridarta.model.mapmodel.MapFile
The location of a map file with a map directory.
Definition: MapFile.java:31
net.sf.gridarta.action.SelectedSquareActionsTest.testDoMoveSquareEnvSingle1
void testDoMoveSquareEnvSingle1()
Checks that MoveSquareEnvAction does work for single-square game objects.
Definition: SelectedSquareActionsTest.java:469
net.sf.gridarta.utils.Size2D
The class Size2D represents a 2d rectangular area.
Definition: Size2D.java:30
net.sf.gridarta.model.mapcontrol.TestMapControlCreator.newMapControl
MapControl< TestGameObject, TestMapArchObject, TestArchetype > newMapControl(@Nullable final MapFile mapFile, @NotNull final String mapName, @NotNull final Size2D mapSize)
Creates a new map control.
Definition: TestMapControlCreator.java:176