001    /*
002     * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
003     * Copyright (C) 2000-2011 The Gridarta Developers.
004     *
005     * This program is free software; you can redistribute it and/or modify
006     * it under the terms of the GNU General Public License as published by
007     * the Free Software Foundation; either version 2 of the License, or
008     * (at your option) any later version.
009     *
010     * This program is distributed in the hope that it will be useful,
011     * but WITHOUT ANY WARRANTY; without even the implied warranty of
012     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
013     * GNU General Public License for more details.
014     *
015     * You should have received a copy of the GNU General Public License along
016     * with this program; if not, write to the Free Software Foundation, Inc.,
017     * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
018     */
019    
020    package net.sf.gridarta.gui.panel.selectedsquare;
021    
022    import java.awt.Point;
023    import java.io.File;
024    import net.sf.gridarta.model.archetype.DuplicateArchetypeException;
025    import net.sf.gridarta.model.archetype.TestArchetype;
026    import net.sf.gridarta.model.gameobject.TestGameObject;
027    import net.sf.gridarta.model.maparchobject.TestMapArchObject;
028    import net.sf.gridarta.model.mapcontrol.MapControl;
029    import net.sf.gridarta.model.mapcontrol.TestMapControlCreator;
030    import net.sf.gridarta.model.mapmodel.CannotInsertGameObjectException;
031    import net.sf.gridarta.model.mapmodel.MapModel;
032    import net.sf.gridarta.model.mapmodel.MapSquare;
033    import net.sf.gridarta.model.mapmodel.TestMapModelHelper;
034    import net.sf.gridarta.utils.Size2D;
035    import org.junit.Assert;
036    import org.junit.Test;
037    
038    /**
039     * Regression tests for {@link SelectedSquareActions}.
040     * @author Andreas Kirschbaum
041     */
042    public class SelectedSquareActionsTest {
043    
044        /**
045         * The first map file.
046         */
047        private static final File MAP_FILE1 = new File("a");
048    
049        /**
050         * The first map name.
051         */
052        private static final String MAP_NAME1 = "name1";
053    
054        /**
055         * Checks that {@link SelectedSquareActions#doMoveSquareTop(boolean)} does
056         * work for single-square game objects.
057         * @throws CannotInsertGameObjectException if the test fails
058         * @throws DuplicateArchetypeException if the test fails
059         */
060        @Test
061        public void testDoMoveSquareTopSingle() throws CannotInsertGameObjectException, DuplicateArchetypeException {
062            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
063            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
064            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
065            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
066            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
067    
068            final Point point = new Point(0, 0);
069            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
070            mapModel.beginTransaction("TEST");
071            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
072            final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
073            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
074    
075            TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
076    
077            // empty selection => nothing to move
078            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(false));
079            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(true));
080    
081            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
082            selectedSquareModel.setSelectedGameObject(ob2);
083    
084            // [ob2, ob1] => ob2 can move
085            Assert.assertTrue(selectedSquareActions.doMoveSquareTop(false));
086            Assert.assertTrue(selectedSquareActions.doMoveSquareTop(true));
087            TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
088    
089            // [ob1, ob2] => ob2 cannot move
090            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(false));
091            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(true));
092            TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
093        }
094    
095        /**
096         * Checks that {@link SelectedSquareActions#doMoveSquareTop(boolean)} does
097         * work for multi-square game objects.
098         * @throws CannotInsertGameObjectException if the test fails
099         * @throws DuplicateArchetypeException if the test fails
100         */
101        @Test
102        public void testDoMoveSquareTopMulti() throws CannotInsertGameObjectException, DuplicateArchetypeException {
103            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
104            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
105            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
106            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
107            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
108    
109            final Point pointHead = new Point(0, 0);
110            final Point pointTail = new Point(1, 0);
111            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
112            mapModel.beginTransaction("TEST");
113            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
114            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
115            final TestGameObject ob1Head = mapModelHelper.insertFloor(mapModel, pointHead);
116            final TestGameObject ob1Tail = mapModelHelper.insertFloor(mapModel, pointTail);
117            final TestGameObject ob2Head = mapModelHelper.insertMob21(mapModel, pointHead);
118            final TestGameObject ob2Tail = ob2Head.getMultiNext();
119    
120            TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
121            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
122    
123            // empty selection => nothing to move
124            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(false));
125            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(true));
126    
127            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
128            selectedSquareModel.setSelectedGameObject(ob1Head);
129    
130            // [ob1, ob2] => ob1 can move
131            Assert.assertTrue(selectedSquareActions.doMoveSquareTop(false));
132            Assert.assertTrue(selectedSquareActions.doMoveSquareTop(true));
133            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
134            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
135    
136            // [ob2, ob1] => ob1 cannot move
137            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(false));
138            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(true));
139            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
140            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
141    
142            selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
143            selectedSquareModel.setSelectedGameObject(ob1Tail);
144    
145            // [ob1, ob2] => ob1 can move // XXX: this probably should be changed: moving tail parts is not sensible
146            Assert.assertTrue(selectedSquareActions.doMoveSquareTop(false));
147            Assert.assertTrue(selectedSquareActions.doMoveSquareTop(true));
148            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
149            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
150    
151            // [ob2, ob1] => ob1 cannot move
152            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(false));
153            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(true));
154            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
155            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
156        }
157    
158        /**
159         * Checks that {@link SelectedSquareActions#doMoveSquareUp(boolean)} does
160         * work for single-square game objects.
161         * @throws CannotInsertGameObjectException if the test fails
162         * @throws DuplicateArchetypeException if the test fails
163         */
164        @Test
165        public void testDoMoveSquareUpSingle() throws CannotInsertGameObjectException, DuplicateArchetypeException {
166            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
167            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
168            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
169            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
170            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
171    
172            final Point point = new Point(0, 0);
173            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
174            mapModel.beginTransaction("TEST");
175            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
176            final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
177            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
178    
179            TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
180    
181            // empty selection => nothing to move
182            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(false));
183            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(true));
184    
185            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
186            selectedSquareModel.setSelectedGameObject(ob2);
187    
188            // [ob2, ob1] => ob2 can move
189            Assert.assertTrue(selectedSquareActions.doMoveSquareUp(false));
190            Assert.assertTrue(selectedSquareActions.doMoveSquareUp(true));
191            TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
192    
193            // [ob1, ob2] => ob2 cannot move
194            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(false));
195            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(true));
196            TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
197        }
198    
199        /**
200         * Checks that {@link SelectedSquareActions#doMoveSquareUp(boolean)} does
201         * work for multi-square game objects.
202         * @throws CannotInsertGameObjectException if the test fails
203         * @throws DuplicateArchetypeException if the test fails
204         */
205        @Test
206        public void testDoMoveSquareUpMulti() throws CannotInsertGameObjectException, 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<TestGameObject, TestMapArchObject, TestArchetype>();
211            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
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(selectedSquareActions.doMoveSquareUp(false));
229            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(true));
230    
231            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
232            selectedSquareModel.setSelectedGameObject(ob2Head);
233    
234            // [ob2, ob1] => ob2 can move
235            Assert.assertTrue(selectedSquareActions.doMoveSquareUp(false));
236            Assert.assertTrue(selectedSquareActions.doMoveSquareUp(true));
237            TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
238            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
239    
240            // [ob1, ob2] => ob2 cannot move
241            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(false));
242            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(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(selectedSquareActions.doMoveSquareUp(false));
251            Assert.assertTrue(selectedSquareActions.doMoveSquareUp(true));
252            TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
253            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
254    
255            // [ob1, ob2] => ob2 cannot move
256            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(false));
257            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(true));
258            TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
259            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
260        }
261    
262        /**
263         * Checks that {@link SelectedSquareActions#doMoveSquareDown(boolean)} does
264         * work for single-square game objects.
265         * @throws CannotInsertGameObjectException if the test fails
266         * @throws DuplicateArchetypeException if the test fails
267         */
268        @Test
269        public void testDoMoveSquareDownSingle() throws CannotInsertGameObjectException, DuplicateArchetypeException {
270            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
271            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
272            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
273            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
274            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
275    
276            final Point point = new Point(0, 0);
277            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
278            mapModel.beginTransaction("TEST");
279            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
280            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
281            final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
282    
283            TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
284    
285            // empty selection => nothing to move
286            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(false));
287            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(true));
288    
289            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
290            selectedSquareModel.setSelectedGameObject(ob2);
291    
292            // [ob1, ob2] => ob2 can move
293            Assert.assertTrue(selectedSquareActions.doMoveSquareDown(false));
294            Assert.assertTrue(selectedSquareActions.doMoveSquareDown(true));
295            TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
296    
297            // [ob2, ob1] => ob2 cannot move
298            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(false));
299            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(true));
300            TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
301        }
302    
303        /**
304         * Checks that {@link SelectedSquareActions#doMoveSquareDown(boolean)} does
305         * work for multi-square game objects.
306         * @throws CannotInsertGameObjectException if the test fails
307         * @throws DuplicateArchetypeException if the test fails
308         */
309        @Test
310        public void testDoMoveSquareDownMulti() throws CannotInsertGameObjectException, DuplicateArchetypeException {
311            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
312            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
313            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
314            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
315            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
316    
317            final Point pointHead = new Point(0, 0);
318            final Point pointTail = new Point(1, 0);
319            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
320            mapModel.beginTransaction("TEST");
321            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
322            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
323            final TestGameObject ob1Head = mapModelHelper.insertMob21(mapModel, pointHead);
324            final TestGameObject ob1Tail = ob1Head.getMultiNext();
325            final TestGameObject ob2Head = mapModelHelper.insertFloor(mapModel, pointHead);
326            final TestGameObject ob2Tail = mapModelHelper.insertFloor(mapModel, pointTail);
327    
328            TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
329            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
330    
331            // empty selection => nothing to move
332            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(false));
333            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(true));
334    
335            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
336            selectedSquareModel.setSelectedGameObject(ob2Head);
337    
338            // [ob2, ob1] => ob2 can move
339            Assert.assertTrue(selectedSquareActions.doMoveSquareDown(false));
340            Assert.assertTrue(selectedSquareActions.doMoveSquareDown(true));
341            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
342            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
343    
344            // [ob1, ob2] => ob2 cannot move
345            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(false));
346            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(true));
347            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
348            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
349    
350            selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
351            selectedSquareModel.setSelectedGameObject(ob2Tail);
352    
353            // [ob2, ob1] => ob2 can move // XXX: this probably should be changed: moving tail parts is not sensible
354            Assert.assertTrue(selectedSquareActions.doMoveSquareDown(false));
355            Assert.assertTrue(selectedSquareActions.doMoveSquareDown(true));
356            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
357            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
358    
359            // [ob1, ob2] => ob2 cannot move
360            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(false));
361            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(true));
362            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
363            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
364        }
365    
366        /**
367         * Checks that {@link SelectedSquareActions#doMoveSquareBottom(boolean)}
368         * does work for single-square game objects.
369         * @throws CannotInsertGameObjectException if the test fails
370         * @throws DuplicateArchetypeException if the test fails
371         */
372        @Test
373        public void testDoMoveSquareBottomSingle() throws CannotInsertGameObjectException, DuplicateArchetypeException {
374            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
375            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
376            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
377            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
378            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
379    
380            final Point point = new Point(0, 0);
381            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
382            mapModel.beginTransaction("TEST");
383            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
384            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
385            final TestGameObject ob2 = mapModelHelper.insertFloor(mapModel, point);
386    
387            TestMapModelHelper.checkContents(mapSquare, ob1, ob2);
388    
389            // empty selection => nothing to move
390            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(false));
391            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(true));
392    
393            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
394            selectedSquareModel.setSelectedGameObject(ob2);
395    
396            // [ob1, ob2] => ob2 can move
397            Assert.assertTrue(selectedSquareActions.doMoveSquareBottom(false));
398            Assert.assertTrue(selectedSquareActions.doMoveSquareBottom(true));
399            TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
400    
401            // [ob2, ob1] => ob2 cannot move
402            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(false));
403            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(true));
404            TestMapModelHelper.checkContents(mapSquare, ob2, ob1);
405        }
406    
407        /**
408         * Checks that {@link SelectedSquareActions#doMoveSquareBottom(boolean)}
409         * does work for multi-square game objects.
410         * @throws CannotInsertGameObjectException if the test fails
411         * @throws DuplicateArchetypeException if the test fails
412         */
413        @Test
414        public void testDoMoveSquareBottomMulti() throws CannotInsertGameObjectException, DuplicateArchetypeException {
415            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
416            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
417            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
418            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
419            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
420    
421            final Point pointHead = new Point(0, 0);
422            final Point pointTail = new Point(1, 0);
423            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
424            mapModel.beginTransaction("TEST");
425            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(pointHead);
426            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
427            final TestGameObject ob1Head = mapModelHelper.insertMob21(mapModel, pointHead);
428            final TestGameObject ob1Tail = ob1Head.getMultiNext();
429            final TestGameObject ob2Head = mapModelHelper.insertFloor(mapModel, pointHead);
430            final TestGameObject ob2Tail = mapModelHelper.insertFloor(mapModel, pointTail);
431    
432            TestMapModelHelper.checkContents(mapSquareHead, ob1Head, ob2Head);
433            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
434    
435            // empty selection => nothing to move
436            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(false));
437            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(true));
438    
439            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
440            selectedSquareModel.setSelectedGameObject(ob2Head);
441    
442            // [ob2, ob1] => ob2 can move
443            Assert.assertTrue(selectedSquareActions.doMoveSquareBottom(false));
444            Assert.assertTrue(selectedSquareActions.doMoveSquareBottom(true));
445            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
446            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
447    
448            // [ob1, ob2] => ob2 cannot move
449            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(false));
450            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(true));
451            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
452            TestMapModelHelper.checkContents(mapSquareTail, ob1Tail, ob2Tail);
453    
454            selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
455            selectedSquareModel.setSelectedGameObject(ob2Tail);
456    
457            // [ob2, ob1] => ob2 can move // XXX: this probably should be changed: moving tail parts is not sensible
458            Assert.assertTrue(selectedSquareActions.doMoveSquareBottom(false));
459            Assert.assertTrue(selectedSquareActions.doMoveSquareBottom(true));
460            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
461            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
462    
463            // [ob1, ob2] => ob2 cannot move
464            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(false));
465            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(true));
466            TestMapModelHelper.checkContents(mapSquareHead, ob2Head, ob1Head);
467            TestMapModelHelper.checkContents(mapSquareTail, ob2Tail, ob1Tail);
468        }
469    
470        /**
471         * Checks that {@link SelectedSquareActions#doMoveSquareEnv(boolean)} does
472         * work for single-square game objects.
473         * @throws CannotInsertGameObjectException if the test fails
474         * @throws DuplicateArchetypeException if the test fails
475         */
476        @Test
477        public void testDoMoveSquareEnvSingle1() throws CannotInsertGameObjectException, DuplicateArchetypeException {
478            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
479            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
480            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
481            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
482            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
483    
484            final Point point = new Point(0, 0);
485            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
486            mapModel.beginTransaction("TEST");
487            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
488            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
489    
490            TestMapModelHelper.checkContents(mapSquare, ob1);
491    
492            // empty selection => nothing to move
493            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
494            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
495    
496            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
497            selectedSquareModel.setSelectedGameObject(ob1);
498    
499            // [ob1] => ob1 cannot move
500            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
501            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
502            TestMapModelHelper.checkContents(mapSquare, ob1);
503        }
504    
505        /**
506         * Checks that {@link SelectedSquareActions#doMoveSquareEnv(boolean)} does
507         * work for single-square game objects.
508         * @throws CannotInsertGameObjectException if the test fails
509         * @throws DuplicateArchetypeException if the test fails
510         */
511        @Test
512        public void testDoMoveSquareEnvSingle2() throws CannotInsertGameObjectException, DuplicateArchetypeException {
513            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
514            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
515            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
516            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
517            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
518    
519            final Point point = new Point(0, 0);
520            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
521            mapModel.beginTransaction("TEST");
522            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
523            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
524            final TestGameObject ob2 = mapModelHelper.insertExit(mapModel, point);
525            final TestGameObject ob3 = mapModelHelper.insertExit(mapModel, point);
526            final TestGameObject ob4 = mapModelHelper.insertExit(ob2);
527    
528            TestMapModelHelper.checkContents(mapSquare, ob1, ob2, ob3);
529            TestMapModelHelper.checkContents(ob2, ob4);
530    
531            // empty selection => nothing to move
532            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
533            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
534    
535            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
536            selectedSquareModel.setSelectedGameObject(ob4);
537    
538            // ob4 can move
539            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(false));
540            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(true));
541            TestMapModelHelper.checkContents(mapSquare, ob1, ob4, ob2, ob3);
542            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
543            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
544    
545            // ob4 cannot move
546            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
547            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
548            TestMapModelHelper.checkContents(mapSquare, ob1, ob4, ob2, ob3);
549            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
550            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
551        }
552    
553        /**
554         * Checks that {@link SelectedSquareActions#doMoveSquareEnv(boolean)} does
555         * work for single-square game objects.
556         * @throws CannotInsertGameObjectException if the test fails
557         * @throws DuplicateArchetypeException if the test fails
558         */
559        @Test
560        public void testDoMoveSquareEnvSingle3() throws CannotInsertGameObjectException, DuplicateArchetypeException {
561            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
562            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
563            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
564            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
565            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
566    
567            final Point point = new Point(0, 0);
568            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
569            mapModel.beginTransaction("TEST");
570            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
571            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
572            final TestGameObject ob2 = mapModelHelper.insertExit(ob1);
573            final TestGameObject ob3 = mapModelHelper.insertExit(ob2);
574            final TestGameObject ob4 = mapModelHelper.insertExit(ob2);
575            final TestGameObject ob5 = mapModelHelper.insertExit(ob2);
576    
577            TestMapModelHelper.checkContents(mapSquare, ob1);
578            TestMapModelHelper.checkContents(ob1, ob2);
579            TestMapModelHelper.checkContents(ob2, ob3, ob4, ob5);
580    
581            // empty selection => nothing to move
582            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
583            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
584    
585            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
586            selectedSquareModel.setSelectedGameObject(ob4);
587    
588            // ob4 can move
589            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(false));
590            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(true));
591            TestMapModelHelper.checkContents(mapSquare, ob1);
592            TestMapModelHelper.checkContents(ob1, ob4, ob2);
593            TestMapModelHelper.checkContents(ob2, ob3, ob5);
594            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
595            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
596    
597            // ob4 can move
598            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(false));
599            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(true));
600            TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
601            TestMapModelHelper.checkContents(ob1, ob2);
602            TestMapModelHelper.checkContents(ob2, ob3, ob5);
603            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
604            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
605    
606            // ob4 cannot move
607            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
608            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
609            TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
610            TestMapModelHelper.checkContents(ob1, ob2);
611            TestMapModelHelper.checkContents(ob2, ob3, ob5);
612            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
613            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
614        }
615    
616        /**
617         * Checks that {@link SelectedSquareActions#doMoveSquareEnv(boolean)} does
618         * work for multi-square game objects.
619         * @throws CannotInsertGameObjectException if the test fails
620         * @throws DuplicateArchetypeException if the test fails
621         */
622        @Test
623        public void testDoMoveSquareEnvMulti3() throws CannotInsertGameObjectException, DuplicateArchetypeException {
624            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
625            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
626            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
627            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
628            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
629    
630            final Point point = new Point(0, 0);
631            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
632            mapModel.beginTransaction("TEST");
633            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(point);
634            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(new Point(1, 0));
635            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
636            final TestGameObject ob2 = mapModelHelper.insertExit(ob1);
637            final TestGameObject ob3 = mapModelHelper.insertExit(ob2);
638            final TestGameObject ob4Head = mapModelHelper.insertMob21(ob2);
639            final TestGameObject ob5 = mapModelHelper.insertExit(ob2);
640    
641            TestMapModelHelper.checkContents(mapSquareHead, ob1);
642            TestMapModelHelper.checkContents(ob1, ob2);
643            TestMapModelHelper.checkContents(ob2, ob3, ob4Head, ob5);
644            TestMapModelHelper.checkContents(mapSquareTail);
645    
646            // empty selection => nothing to move
647            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
648            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
649    
650            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
651            selectedSquareModel.setSelectedGameObject(ob4Head);
652    
653            // ob4Head can move
654            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(false));
655            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(true));
656            TestMapModelHelper.checkContents(mapSquareHead, ob1);
657            TestMapModelHelper.checkContents(ob1, ob4Head, ob2);
658            final TestGameObject ob4Tail1 = ob4Head.getMultiNext();
659            Assert.assertNull(ob4Tail1);
660            TestMapModelHelper.checkContents(ob2, ob3, ob5);
661            TestMapModelHelper.checkContents(mapSquareTail);
662            Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
663            Assert.assertEquals(ob4Head, selectedSquareModel.getSelectedGameObject());
664    
665            // ob4Head can move
666            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(false));
667            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(true));
668            TestMapModelHelper.checkContents(mapSquareHead, ob4Head, ob1);
669            TestMapModelHelper.checkContents(ob1, ob2);
670            TestMapModelHelper.checkContents(ob2, ob3, ob5);
671            final TestGameObject ob4Tail2 = ob4Head.getMultiNext();
672            Assert.assertNotNull(ob4Tail2);
673            TestMapModelHelper.checkContents(mapSquareTail, ob4Tail2);
674            Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
675            Assert.assertEquals(ob4Head, selectedSquareModel.getSelectedGameObject());
676    
677            // ob4Head cannot move
678            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
679            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
680            TestMapModelHelper.checkContents(mapSquareHead, ob4Head, ob1);
681            TestMapModelHelper.checkContents(ob1, ob2);
682            TestMapModelHelper.checkContents(ob2, ob3, ob5);
683            Assert.assertEquals(ob4Tail2, ob4Head.getMultiNext());
684            TestMapModelHelper.checkContents(mapSquareTail, ob4Tail2);
685            Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
686            Assert.assertEquals(ob4Head, selectedSquareModel.getSelectedGameObject());
687        }
688    
689        /**
690         * Checks that {@link SelectedSquareActions#doMoveSquareEnv(boolean)} does
691         * work for multi-square game objects.
692         * @throws CannotInsertGameObjectException if the test fails
693         * @throws DuplicateArchetypeException if the test fails
694         */
695        @Test
696        public void testDoMoveSquareEnvMulti4() throws CannotInsertGameObjectException, DuplicateArchetypeException {
697            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
698            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
699            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
700            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
701            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
702    
703            final Point point = new Point(0, 0);
704            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
705            mapModel.beginTransaction("TEST");
706            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(point);
707            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
708            final TestGameObject ob2Head = mapModelHelper.insertMob21(ob1);
709    
710            TestMapModelHelper.checkContents(mapSquareHead, ob1);
711            TestMapModelHelper.checkContents(ob1, ob2Head);
712    
713            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
714            selectedSquareModel.setSelectedGameObject(ob2Head);
715    
716            // ob2Head cannot move: would not fit into map
717            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
718            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(true));
719            TestMapModelHelper.checkContents(mapSquareHead, ob1);
720            TestMapModelHelper.checkContents(ob1, ob2Head);
721            Assert.assertNull(ob2Head.getMultiNext());
722        }
723    
724        /**
725         * Checks that {@link SelectedSquareActions#doMoveSquareInv(boolean)} does
726         * work for single-square game objects.
727         * @throws CannotInsertGameObjectException if the test fails
728         * @throws DuplicateArchetypeException if the test fails
729         */
730        @Test
731        public void testDoMoveSquareInvSingle1() throws CannotInsertGameObjectException, DuplicateArchetypeException {
732            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
733            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
734            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(1, 1));
735            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
736            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
737    
738            final Point point = new Point(0, 0);
739            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
740            mapModel.beginTransaction("TEST");
741            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare = mapModel.getMapSquare(point);
742            final TestGameObject ob4 = mapModelHelper.insertExit(mapModel, point);
743            final TestGameObject ob3 = mapModelHelper.insertExit(mapModel, point);
744            final TestGameObject ob2 = mapModelHelper.insertExit(mapModel, point);
745            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
746    
747            TestMapModelHelper.checkContents(mapSquare, ob4, ob3, ob2, ob1);
748    
749            // empty selection => nothing to move
750            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
751            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(true));
752    
753            // select ob3
754            selectedSquareModel.setSelectedMapSquare(mapSquare, null);
755            selectedSquareModel.setSelectedGameObject(ob3);
756    
757            // ob3 can move
758            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
759            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(true));
760            TestMapModelHelper.checkContents(mapSquare, ob4, ob2, ob1);
761            TestMapModelHelper.checkContents(ob2, ob3);
762            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
763            Assert.assertEquals(ob3, selectedSquareModel.getSelectedGameObject());
764    
765            // ob3 cannot move
766            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
767            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(true));
768            TestMapModelHelper.checkContents(mapSquare, ob4, ob2, ob1);
769            TestMapModelHelper.checkContents(ob2, ob3);
770            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
771            Assert.assertEquals(ob3, selectedSquareModel.getSelectedGameObject());
772    
773            // select ob2
774            selectedSquareModel.setSelectedGameObject(ob2);
775    
776            // ob2 can move
777            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
778            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(true));
779            TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
780            TestMapModelHelper.checkContents(ob1, ob2);
781            TestMapModelHelper.checkContents(ob2, ob3);
782            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
783            Assert.assertEquals(ob2, selectedSquareModel.getSelectedGameObject());
784    
785            // ob2 cannot move
786            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
787            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(true));
788            TestMapModelHelper.checkContents(mapSquare, ob4, ob1);
789            TestMapModelHelper.checkContents(ob1, ob2);
790            TestMapModelHelper.checkContents(ob2, ob3);
791            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
792            Assert.assertEquals(ob2, selectedSquareModel.getSelectedGameObject());
793    
794            // select ob4
795            selectedSquareModel.setSelectedGameObject(ob4);
796    
797            // ob4 can move
798            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
799            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(true));
800            TestMapModelHelper.checkContents(mapSquare, ob1);
801            TestMapModelHelper.checkContents(ob1, ob4, ob2);
802            TestMapModelHelper.checkContents(ob2, ob3);
803            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
804            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
805    
806            // ob4 can move
807            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
808            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(true));
809            TestMapModelHelper.checkContents(mapSquare, ob1);
810            TestMapModelHelper.checkContents(ob1, ob2);
811            TestMapModelHelper.checkContents(ob2, ob4, ob3);
812            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
813            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
814    
815            // ob4 can move
816            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
817            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(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            // ob4 cannot move
826            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
827            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(true));
828            TestMapModelHelper.checkContents(mapSquare, ob1);
829            TestMapModelHelper.checkContents(ob1, ob2);
830            TestMapModelHelper.checkContents(ob2, ob3);
831            TestMapModelHelper.checkContents(ob3, ob4);
832            Assert.assertEquals(mapSquare, selectedSquareModel.getSelectedMapSquare());
833            Assert.assertEquals(ob4, selectedSquareModel.getSelectedGameObject());
834        }
835    
836        /**
837         * Checks that {@link SelectedSquareActions#doMoveSquareInv(boolean)} does
838         * work for multi-square game objects.
839         * @throws CannotInsertGameObjectException if the test fails
840         * @throws DuplicateArchetypeException if the test fails
841         */
842        @Test
843        public void testDoMoveSquareInvMulti1() throws CannotInsertGameObjectException, DuplicateArchetypeException {
844            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
845            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
846            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
847            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
848            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
849    
850            final Point point = new Point(0, 0);
851            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
852            mapModel.beginTransaction("TEST");
853            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareHead = mapModel.getMapSquare(point);
854            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(new Point(1, 0));
855            final TestGameObject ob3Head = mapModelHelper.insertMob21(mapModel, point);
856            final TestGameObject ob1 = mapModelHelper.insertExit(mapModel, point);
857            final TestGameObject ob2 = mapModelHelper.insertExit(ob1);
858    
859            final TestGameObject ob3Tail = ob3Head.getMultiNext();
860            Assert.assertNotNull(ob3Tail);
861            TestMapModelHelper.checkContents(mapSquareHead, ob3Head, ob1);
862            TestMapModelHelper.checkContents(mapSquareTail, ob3Tail);
863            TestMapModelHelper.checkContents(ob1, ob2);
864    
865            // empty selection => nothing to move
866            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
867            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(true));
868    
869            // select ob3Head
870            selectedSquareModel.setSelectedMapSquare(mapSquareHead, null);
871            selectedSquareModel.setSelectedGameObject(ob3Head);
872    
873            // ob3Head can move; ob3Tail is removed
874            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
875            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(true));
876            TestMapModelHelper.checkContents(mapSquareHead, ob1);
877            TestMapModelHelper.checkContents(mapSquareTail);
878            TestMapModelHelper.checkContents(ob1, ob3Head, ob2);
879            Assert.assertNull(ob3Head.getMultiNext());
880            Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
881            Assert.assertEquals(ob3Head, selectedSquareModel.getSelectedGameObject());
882    
883            // ob3Head can move
884            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(false));
885            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(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            // ob3Head cannot move
895            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
896            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(true));
897            TestMapModelHelper.checkContents(mapSquareHead, ob1);
898            TestMapModelHelper.checkContents(mapSquareTail);
899            TestMapModelHelper.checkContents(ob1, ob2);
900            TestMapModelHelper.checkContents(ob2, ob3Head);
901            Assert.assertNull(ob3Head.getMultiNext());
902            Assert.assertEquals(mapSquareHead, selectedSquareModel.getSelectedMapSquare());
903            Assert.assertEquals(ob3Head, selectedSquareModel.getSelectedGameObject());
904        }
905    
906        /**
907         * Checks that {@link SelectedSquareActions#doMoveSquareInv(boolean)} always
908         * inserts into the head-part.
909         * @throws CannotInsertGameObjectException if the test fails
910         * @throws DuplicateArchetypeException if the test fails
911         */
912        @Test
913        public void testDoMoveSquareInvIntoHead1() throws CannotInsertGameObjectException, DuplicateArchetypeException {
914            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
915            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
916            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(3, 1));
917            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
918            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
919    
920            final Point point0 = new Point(0, 0);
921            final Point point1 = new Point(1, 0);
922            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
923            mapModel.beginTransaction("TEST");
924            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare0 = mapModel.getMapSquare(point0);
925            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare1 = mapModel.getMapSquare(point1);
926            final TestGameObject ob2 = mapModelHelper.insertMob21(mapModel, point1);
927            final TestGameObject ob1 = mapModelHelper.insertMob21(mapModel, point0);
928    
929            TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21,mob21b|mob21b");
930    
931            // select ob2
932            selectedSquareModel.setSelectedMapSquare(mapSquare1, null);
933            selectedSquareModel.setSelectedGameObject(ob2);
934    
935            // move ob2 into ob1
936            Assert.assertTrue(selectedSquareActions.doMoveSquareInv(true));
937    
938            TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21b|");
939            TestMapModelHelper.checkContents(mapSquare0, ob1);
940            final TestGameObject ob1Tail = ob1.getMultiNext();
941            Assert.assertNotNull(ob1Tail);
942            TestMapModelHelper.checkContents(mapSquare1, ob1Tail);
943            TestMapModelHelper.checkContents(ob1, ob2);
944        }
945    
946        /**
947         * Checks that tail parts cannot be moved.
948         * @throws CannotInsertGameObjectException if the test fails
949         * @throws DuplicateArchetypeException if the test fails
950         */
951        @Test
952        public void testMoveTailPart() throws CannotInsertGameObjectException, DuplicateArchetypeException {
953            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
954            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
955            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(2, 1));
956            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
957            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
958    
959            final Point pointHead = new Point(0, 0);
960            final Point pointTail = new Point(1, 0);
961            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
962            mapModel.beginTransaction("TEST");
963            final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquareTail = mapModel.getMapSquare(pointTail);
964            mapModelHelper.insertExit(mapModel, pointHead);
965            mapModelHelper.insertExit(mapModel, pointTail);
966            final TestGameObject ob2Head = mapModelHelper.insertMob21(mapModel, pointHead);
967            mapModelHelper.insertExit(mapModel, pointHead);
968            mapModelHelper.insertExit(mapModel, pointTail);
969    
970            TestMapModelHelper.checkMapContents(mapModel, "exit,mob21,exit|exit,mob21b,exit");
971    
972            // select ob2Tail
973            selectedSquareModel.setSelectedMapSquare(mapSquareTail, null);
974            selectedSquareModel.setSelectedGameObject(ob2Head.getMultiNext());
975    
976            // ob2Tail cannot move
977            Assert.assertFalse(selectedSquareActions.doMoveSquareTop(false));
978            Assert.assertFalse(selectedSquareActions.doMoveSquareUp(false));
979            Assert.assertFalse(selectedSquareActions.doMoveSquareDown(false));
980            Assert.assertFalse(selectedSquareActions.doMoveSquareBottom(false));
981            Assert.assertFalse(selectedSquareActions.doMoveSquareInv(false));
982            Assert.assertFalse(selectedSquareActions.doMoveSquareEnv(false));
983        }
984    
985        /**
986         * Checks that {@link SelectedSquareActions#doMoveSquareEnv(boolean)}
987         * inserts into selected map square.
988         * @throws CannotInsertGameObjectException if the test fails
989         * @throws DuplicateArchetypeException if the test fails
990         */
991        @Test
992        public void testMoveEnvIntoSelectedMapSquare() throws CannotInsertGameObjectException, DuplicateArchetypeException {
993            final TestMapControlCreator testMapControlCreator = new TestMapControlCreator();
994            final TestMapModelHelper mapModelHelper = testMapControlCreator.newMapModelCreator();
995            final MapControl<TestGameObject, TestMapArchObject, TestArchetype> mapControl = testMapControlCreator.newMapControl(MAP_FILE1, MAP_NAME1, new Size2D(3, 1));
996            final SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareModel = new SelectedSquareModel<TestGameObject, TestMapArchObject, TestArchetype>();
997            final SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype> selectedSquareActions = new SelectedSquareActions<TestGameObject, TestMapArchObject, TestArchetype>(selectedSquareModel);
998    
999            final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapControl.getMapModel();
1000            mapModel.beginTransaction("TEST");
1001            final TestGameObject ob1 = mapModelHelper.insertMob21(mapModel, new Point(0, 0));
1002            final TestGameObject ob2 = mapModelHelper.insertMob21(ob1);
1003    
1004            TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21b|");
1005    
1006            // select ob2 in (1,0)
1007            selectedSquareModel.setSelectedMapSquare(mapModel.getMapSquare(new Point(1, 0)), null);
1008            selectedSquareModel.setSelectedGameObject(ob2);
1009    
1010            // move ob2 into (1,0)
1011            Assert.assertTrue(selectedSquareActions.doMoveSquareEnv(true));
1012    
1013            TestMapModelHelper.checkMapContents(mapModel, "mob21|mob21,mob21b|mob21b");
1014        }
1015    
1016    }