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