DefaultMapModel (Gridarta)

java.lang.Object
- net.sf.gridarta.model.mapmodel.DefaultMapModel<G,A,R>

All Implemented Interfaces:

java.io.Serializable, java.lang.Iterable<MapSquare<G,A,R>>, MapModel<G,A,R>
```
public class DefaultMapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
extends java.lang.Object
implements MapModel<G,A,R>
```
Implementation of MapModel that covers the similarities between crossfire and daimonin. The transaction system is not implemented in a way that supports overriding its method for change. Therefore all methods belonging to the transaction system are final.

See Also:

class MapModel for a documentation of the transaction system., Serialized Form

Constructor Summary

Constructors
Constructor and Description
`DefaultMapModel(@NotNull AutojoinLists<G,A,R> autojoinLists, A mapArchObject, @NotNull ArchetypeChooserModel<G,A,R> archetypeChooserModel, @NotNull GameObjectFactory<G,A,R> gameObjectFactory, @NotNull GameObjectMatchers gameObjectMatchers, @NotNull InsertionMode topmostInsertionMode)` Creates a new instance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addActiveEditType(int editType)` Add edit type to the bitmask of active types.
`void`	`addGameObjectToMap(G gameObject, @NotNull java.awt.Point pos, @NotNull InsertionMode insertionMode)` Add a gameObject to the map.
`void`	`addMapModelListener(@NotNull MapModelListener<G,A,R> listener)` Register a map listener.
`void`	`addMapTransactionListener(@NotNull MapTransactionListener<G,A,R> listener)` Registers a map transaction listener.
`void`	`addObjectListToMap(@NotNull java.lang.Iterable<G> objects)` Adds a list of `GameObjects` to this map.
`void`	`beginGameObjectChange(G gameObject)` Method to notify the model that a game object is about to change.
`void`	`beginSquareChange(@NotNull MapSquare<G,A,R> mapSquare)` Method to notify the model that a map square is about to change.
`void`	`beginTransaction(@NotNull java.lang.String name)` Starts a new transaction.
`void`	`clearMap()` Clears this map completely.
`void`	`endAllTransactions()` Ends all transaction.
`void`	`endGameObjectChange(G gameObject)` Method to notify the model that a game object was changed.
`void`	`endSquareChange(@NotNull MapSquare<G,A,R> mapSquare)` Method to notify the model that a map square was changed.
`void`	`endTransaction()` End a transaction.
`void`	`endTransaction(boolean fireEvent)` End a transaction.
`void`	`facesReloaded()` Will be called whenever the archetype faces have been reloaded.
`@NotNull java.util.List<G>`	`getAllGameObjects()` Returns all game objects.
`@NotNull ErrorCollector<G,A,R>`	`getErrors()` Gets the errors in this map.
`A`	`getMapArchObject()` Returns the Map Arch Object with the meta information about the map.
`@Nullable MapFile`	`getMapFile()` Returns the map file.
`@NotNull MapFile`	`getMapFile(@NotNull MapPath mapPath)` Returns the map file for a map that can be reached by following a `MapPath` from this map.
`@NotNull MapSquare<G,A,R>`	`getMapSquare(@NotNull java.awt.Point pos)` Get the square at a specified location.
`int`	`getTransactionDepth()` Get the transaction depth, which is the number of `MapModel.beginTransaction(String)` invocations without matching `MapModel.endTransaction()` invocations.
`G`	`insertArchToMap(@NotNull BaseObject<G,A,R,?> templateBaseObject, G nextGameObject, @NotNull java.awt.Point pos, boolean join)` Insert a game object to the map at a specified position.
`G`	`insertBaseObject(@NotNull BaseObject<G,A,R,?> baseObject, @NotNull java.awt.Point pos, boolean allowMany, boolean join, @NotNull InsertionMode insertionMode)` Inserts a `BaseObject` to a map.
`boolean`	`isAnyTransactionActive()` Returns whether a transaction is currently active.
`boolean`	`isAreaEmpty(int left, int top, int width, int height)` Checks whether an area of a map is completely empty.
`boolean`	`isEmpty()` Returns whether the map is empty.
`boolean`	`isModified()` Return whether the map has been modified from the on-disk state.
`boolean`	`isMultiArchFittingToMap(@NotNull Archetype<G,A,R> archetype, @NotNull java.awt.Point pos, boolean allowDouble)` Checks whether a GameObject (multi-arch) would still fit on this map.
`java.util.Iterator<MapSquare<G,A,R>>`	`iterator()`
`void`	`mapClosed()` This function must be called if this instance is freed.
`void`	`moveEnv(G gameObject, @NotNull java.awt.Point pos, G nextGameObject)` Moves a `GameObject` to its environment.
`void`	`moveInv(G gameObject, @NotNull GameObject<G,A,R> prevGameObject)` Moves a `GameObject` to the inventory of another game object.
`void`	`nextPoint(java.awt.Point point, int direction)` Moves the given point forward or backward one map square.
`void`	`prependMapModelListener(@NotNull MapModelListener<G,A,R> listener)` Register a map listener and call it before all other listeners.
`void`	`removeGameObject(G gameObject, boolean join)` Delete an existing `GameObject` from the map.
`void`	`removeMapModelListener(@NotNull MapModelListener<G,A,R> listener)` Unregister a map listener.
`void`	`removeMapTransactionListener(@NotNull MapTransactionListener<G,A,R> listener)` Unregisters a map transaction listener.
`void`	`resetModified()` Resets the modified flag to false.
`void`	`setErrors(@NotNull ErrorCollector<G,A,R> errors)` Sets the errors in this map.
`void`	`setMapFile(@Nullable MapFile mapFile)` Sets the map file.
`void`	`transientGameObjectChange(G gameObject)` Method to notify the model that a game object was changed but need not be restored by undo/redo.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - DefaultMapModel
```
public DefaultMapModel(@NotNull
                       @NotNull AutojoinLists<G,A,R> autojoinLists,
                       @NotNull
                       A mapArchObject,
                       @NotNull
                       @NotNull ArchetypeChooserModel<G,A,R> archetypeChooserModel,
                       @NotNull
                       @NotNull GameObjectFactory<G,A,R> gameObjectFactory,
                       @NotNull
                       @NotNull GameObjectMatchers gameObjectMatchers,
                       @NotNull
                       @NotNull InsertionMode topmostInsertionMode)
```
    Creates a new instance.
    
    Parameters:
    
    autojoinLists - the autojoin lists instance to use
    
    mapArchObject - the map arch object to associate with this model
    
    archetypeChooserModel - the archetype chooser control
    
    gameObjectFactory - the game object factory for creating game objects
    
    gameObjectMatchers - the game object matchers to use
    
    topmostInsertionMode - the "topmost" insertion mode
- Method Detail
  - mapClosed
```
public void mapClosed()
```
    Description copied from interface: MapModel
    
    This function must be called if this instance is freed.
    
    Specified by:
    
    mapClosed in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
  - getMapArchObject
```
@NotNull
public A getMapArchObject()
```
    Description copied from interface: MapModel
    
    Returns the Map Arch Object with the meta information about the map.
    
    Specified by:
    
    getMapArchObject in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    the map arch object with the meta information about the map
  - iterator
```
public java.util.Iterator<MapSquare<G,A,R>> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<MapSquare<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>>
  - getMapSquare
```
@NotNull
public @NotNull MapSquare<G,A,R> getMapSquare(@NotNull
                                                       @NotNull java.awt.Point pos)
```
    Description copied from interface: MapModel
    
    Get the square at a specified location.
    
    Specified by:
    
    getMapSquare in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    pos - location to get square at
    
    Returns:
    
    square at p
  - addObjectListToMap
```
public void addObjectListToMap(@NotNull
                               @NotNull java.lang.Iterable<G> objects)
```
    Description copied from interface: MapModel
    
    Adds a list of GameObjects to this map.
    
    Specified by:
    
    addObjectListToMap in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    objects - the game objects to add
  - clearMap
```
public void clearMap()
```
    Description copied from interface: MapModel
    
    Clears this map completely. After invoking this method, no objects will remain on this map.
    
    Specified by:
    
    clearMap in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: MapModel
    
    Returns whether the map is empty.
    
    Specified by:
    
    isEmpty in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    true if the map is empty, or false if the map is not empty
  - addMapModelListener
```
public void addMapModelListener(@NotNull
                                @NotNull MapModelListener<G,A,R> listener)
```
    Description copied from interface: MapModel
    
    Register a map listener.
    
    Specified by:
    
    addMapModelListener in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    listener - the listener to register
  - prependMapModelListener
```
public void prependMapModelListener(@NotNull
                                    @NotNull MapModelListener<G,A,R> listener)
```
    Description copied from interface: MapModel
    
    Register a map listener and call it before all other listeners.
    
    Specified by:
    
    prependMapModelListener in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    listener - the listener to register
  - removeMapModelListener
```
public void removeMapModelListener(@NotNull
                                   @NotNull MapModelListener<G,A,R> listener)
```
    Description copied from interface: MapModel
    
    Unregister a map listener.
    
    Specified by:
    
    removeMapModelListener in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    listener - the listener to unregister
  - addMapTransactionListener
```
public void addMapTransactionListener(@NotNull
                                      @NotNull MapTransactionListener<G,A,R> listener)
```
    Description copied from interface: MapModel
    
    Registers a map transaction listener.
    
    Specified by:
    
    addMapTransactionListener in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    listener - the the listener to register
  - removeMapTransactionListener
```
public void removeMapTransactionListener(@NotNull
                                         @NotNull MapTransactionListener<G,A,R> listener)
```
    Description copied from interface: MapModel
    
    Unregisters a map transaction listener.
    
    Specified by:
    
    removeMapTransactionListener in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    listener - the listener to unregister
  - beginSquareChange
```
public void beginSquareChange(@NotNull
                              @NotNull MapSquare<G,A,R> mapSquare)
```
    Description copied from interface: MapModel
    
    Method to notify the model that a map square is about to change.
    
    Specified by:
    
    beginSquareChange in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    mapSquare - the map square that is about to change
  - endSquareChange
```
public void endSquareChange(@NotNull
                            @NotNull MapSquare<G,A,R> mapSquare)
```
    Description copied from interface: MapModel
    
    Method to notify the model that a map square was changed. A change to a square is atomic if MapModel.getTransactionDepth() returns 0, otherwise it is transactional. The model then notifies the registered listeners of the changes.
    
    Specified by:
    
    endSquareChange in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    mapSquare - the map square that has changed
  - beginGameObjectChange
```
public void beginGameObjectChange(@NotNull
                                  G gameObject)
```
    Description copied from interface: MapModel
    
    Method to notify the model that a game object is about to change.
    
    Specified by:
    
    beginGameObjectChange in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the game object that is about to change
  - endGameObjectChange
```
public void endGameObjectChange(@NotNull
                                G gameObject)
```
    Description copied from interface: MapModel
    
    Method to notify the model that a game object was changed. A change to a game object is atomic if MapModel.getTransactionDepth() returns 0, otherwise it is transactional. The model then notifies the registered listeners of the changes.
    
    Specified by:
    
    endGameObjectChange in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the game object that has changed
  - transientGameObjectChange
```
public void transientGameObjectChange(@NotNull
                                      G gameObject)
```
    Description copied from interface: MapModel
    
    Method to notify the model that a game object was changed but need not be restored by undo/redo. A change to a game object is atomic if MapModel.getTransactionDepth() returns 0, otherwise it is transactional. The model then notifies the registered listeners of the changes.
    
    Specified by:
    
    transientGameObjectChange in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the game object that has changed
  - beginTransaction
```
public void beginTransaction(@NotNull
                             @NotNull java.lang.String name)
```
    Description copied from interface: MapModel
    
    Starts a new transaction. Transactions may be nested. Transactions serve the purpose of firing events to the views when more changes are known to come before the view is really required to update. Each invocation of this function requires its own invocation of MapModel.endTransaction().
    A transaction has a name. The name of the outermost transaction is used as a String presented to the user for undoing the operation enclosed by that transaction.
    Beginning a nested transaction is a cheap operation.
    
    Specified by:
    
    beginTransaction in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    name - the name of the transaction
    
    See Also:
    
    MapModel.endTransaction(), MapModel.endTransaction(boolean), MapModel.endAllTransactions(), MapModel.getTransactionDepth(), MapModel.isAnyTransactionActive()
  - endTransaction
```
public void endTransaction()
```
    Description copied from interface: MapModel
    
    End a transaction. Invoking this method will reduce the transaction depth by only 1.
    Ending a nested operation is a cheap operation. Ending a transaction without changes also is a cheap operation.
    If the last transaction is ended, the changes are committed.
    Same as endTransaction(false).
    
    Specified by:
    
    endTransaction in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    See Also:
    
    MapModel.beginTransaction(String), MapModel.endTransaction(boolean), MapModel.endAllTransactions(), MapModel.getTransactionDepth(), MapModel.isAnyTransactionActive()
  - endTransaction
```
public void endTransaction(boolean fireEvent)
```
    Description copied from interface: MapModel
    
    End a transaction. Invoking this method will reduce the transaction depth by only 1.
    Ending a nested operation is a cheap operation. Ending a transaction without changes also is a cheap operation.
    If the last transaction is ended, the changes are committed.
    An example where setting fireEvent to true is useful even though the outermost transaction is not ended is when during painting the UI should be updated though painting is not finished.
    
    Specified by:
    
    endTransaction in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    fireEvent - true if an event should be fired even in case this doesn't end the outermost transaction.
    
    See Also:
    
    MapModel.beginTransaction(String), MapModel.endTransaction(), MapModel.endAllTransactions(), MapModel.getTransactionDepth(), MapModel.isAnyTransactionActive()
  - endAllTransactions
```
public void endAllTransactions()
```
    Description copied from interface: MapModel
    
    Ends all transaction. Invoking this method will reduce set the transaction depth to 0. You shouldn't invoke this method regularly. It is meant as a fallback in high level methods / exception handlers to prevent errors from causing unclosed transactions.
    
    Specified by:
    
    endAllTransactions in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    See Also:
    
    MapModel.beginTransaction(String), MapModel.endTransaction(), MapModel.endTransaction(boolean), MapModel.getTransactionDepth(), MapModel.isAnyTransactionActive()
  - getTransactionDepth
```
public int getTransactionDepth()
```
    Description copied from interface: MapModel
    
    Get the transaction depth, which is the number of MapModel.beginTransaction(String) invocations without matching MapModel.endTransaction() invocations. A transaction depth of 0 means there is no ongoing transaction.
    
    Specified by:
    
    getTransactionDepth in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    transaction depth
    
    See Also:
    
    MapModel.beginTransaction(String), MapModel.endTransaction(), MapModel.endTransaction(boolean), MapModel.endAllTransactions(), MapModel.isAnyTransactionActive()
  - isAnyTransactionActive
```
public boolean isAnyTransactionActive()
```
    Description copied from interface: MapModel
    
    Returns whether a transaction is currently active. This method will return true if and only if MapModel.getTransactionDepth() returns a value greater than zero.
    
    Specified by:
    
    isAnyTransactionActive in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    true if there's a transaction going on, otherwise false.
    
    See Also:
    
    MapModel.beginTransaction(String), MapModel.endTransaction(), MapModel.endTransaction(boolean), MapModel.endAllTransactions(), MapModel.getTransactionDepth()
  - removeGameObject
```
public void removeGameObject(@NotNull
                             G gameObject,
                             boolean join)
```
    Description copied from interface: MapModel
    
    Delete an existing GameObject from the map.
    
    Specified by:
    
    removeGameObject in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the game object to remove
    
    join - if set, auto-joining is supported
  - isMultiArchFittingToMap
```
public boolean isMultiArchFittingToMap(@NotNull
                                       @NotNull Archetype<G,A,R> archetype,
                                       @NotNull
                                       @NotNull java.awt.Point pos,
                                       boolean allowDouble)
```
    Description copied from interface: MapModel
    
    Checks whether a GameObject (multi-arch) would still fit on this map.
    
    Specified by:
    
    isMultiArchFittingToMap in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    archetype - the archetype to check
    
    pos - position of multi-square head
    
    allowDouble - whether overlapping multi-square arches should be allowed (check is done using the archetype name)
    
    Returns:
    
    whether the multi-arch would still fit on this map
  - setErrors
```
public void setErrors(@NotNull
                      @NotNull ErrorCollector<G,A,R> errors)
```
    Description copied from interface: MapModel
    
    Sets the errors in this map.
    
    Specified by:
    
    setErrors in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    errors - the errors
  - getErrors
```
@NotNull
public @NotNull ErrorCollector<G,A,R> getErrors()
```
    Description copied from interface: MapModel
    
    Gets the errors in this map.
    
    Specified by:
    
    getErrors in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    the errors
  - insertArchToMap
```
@Nullable
public G insertArchToMap(@NotNull
                                   @NotNull BaseObject<G,A,R,?> templateBaseObject,
                                   @Nullable
                                   G nextGameObject,
                                   @NotNull
                                   @NotNull java.awt.Point pos,
                                   boolean join)
```
    Description copied from interface: MapModel
    
    Insert a game object to the map at a specified position. This function allows either to choose from the archetypes or to insert a copy from an existing game object. It also works for container-inventory.
    
    Specified by:
    
    insertArchToMap in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    templateBaseObject - a clone copy of this game object gets inserted to the map; it can be an archetype of a game object
    
    nextGameObject - the new game object gets inserted before this; if null, the game object gets inserted at bottom
    
    pos - the map position to insert the new game object
    
    join - if set, auto-joining is supported
    
    Returns:
    
    the inserted game object, or null if an error occurred
    
    XXX:
    
    I'm too complex
  - insertBaseObject
```
@Nullable
public G insertBaseObject(@NotNull
                                    @NotNull BaseObject<G,A,R,?> baseObject,
                                    @NotNull
                                    @NotNull java.awt.Point pos,
                                    boolean allowMany,
                                    boolean join,
                                    @NotNull
                                    @NotNull InsertionMode insertionMode)
```
    Description copied from interface: MapModel
    
    Inserts a BaseObject to a map. Archetypes are instantiated, game objects are cloned. The direction of the inserted game object is set to the direction of the archetype chooser. This function allows multi-square game objects.
    
    Specified by:
    
    insertBaseObject in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    baseObject - the base object
    
    pos - the insert-location on this map
    
    allowMany - whether duplicates are allowed
    
    join - whether to auto-join the inserted game object
    
    insertionMode - the insertion mode to use
    
    Returns:
    
    the inserted game object or null if nothing was inserted
  - addGameObjectToMap
```
public void addGameObjectToMap(@NotNull
                               G gameObject,
                               @NotNull
                               @NotNull java.awt.Point pos,
                               @NotNull
                               @NotNull InsertionMode insertionMode)
```
    Description copied from interface: MapModel
    
    Add a gameObject to the map. Including multi square objects. This function allows to insert any given GameObject. Make sure that the given gameObject is a new and unlinked object.
    
    Specified by:
    
    addGameObjectToMap in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the new GameObject with set destination coordinates to be linked onto the map
    
    pos - the insert location
    
    insertionMode - the insertion mode to use
  - moveEnv
```
public void moveEnv(@NotNull
                    G gameObject,
                    @NotNull
                    @NotNull java.awt.Point pos,
                    @NotNull
                    G nextGameObject)
```
    Description copied from interface: MapModel
    
    Moves a GameObject to its environment.
    
    Specified by:
    
    moveEnv in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the game object to move
    
    pos - the insertion position
    
    nextGameObject - the next game object
  - moveInv
```
public void moveInv(@NotNull
                    G gameObject,
                    @NotNull
                    @NotNull GameObject<G,A,R> prevGameObject)
```
    Description copied from interface: MapModel
    
    Moves a GameObject to the inventory of another game object.
    
    Specified by:
    
    moveInv in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    gameObject - the game object to move
    
    prevGameObject - the previous game object
  - isAreaEmpty
```
public boolean isAreaEmpty(int left,
                           int top,
                           int width,
                           int height)
```
    Description copied from interface: MapModel
    
    Checks whether an area of a map is completely empty.
    
    Specified by:
    
    isAreaEmpty in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    left - the left border of the area
    
    top - the top border of the area
    
    width - the with of the area
    
    height - the height of the area
    
    Returns:
    
    whether the area is completely empty
  - addActiveEditType
```
public void addActiveEditType(int editType)
```
    Description copied from interface: MapModel
    
    Add edit type to the bitmask of active types. If this is a new type, it gets calculated for every arch on the map. Once it is calculated, we save that state in 'activeEditType' so we don't need to do it again.
    
    Specified by:
    
    addActiveEditType in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    editType - new edit type
  - setMapFile
```
public void setMapFile(@Nullable
                       @Nullable MapFile mapFile)
```
    Description copied from interface: MapModel
    
    Sets the map file.
    
    Specified by:
    
    setMapFile in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    mapFile - the map file or null if the map has not yet been saved
  - getMapFile
```
@Nullable
public @Nullable MapFile getMapFile()
```
    Description copied from interface: MapModel
    
    Returns the map file.
    
    Specified by:
    
    getMapFile in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    the map file or null if the map has not yet been saved
  - getMapFile
```
@NotNull
public @NotNull MapFile getMapFile(@NotNull
                                            @NotNull MapPath mapPath)
                                     throws SameMapException,
                                            UnsavedMapException
```
    Description copied from interface: MapModel
    
    Returns the map file for a map that can be reached by following a MapPath from this map.
    
    Specified by:
    
    getMapFile in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    mapPath - the map path to follow
    
    Returns:
    
    the map file
    
    Throws:
    
    SameMapException - of the destination map file is the same as this map file
    
    UnsavedMapException - if this map is not saved and therefore its map file is unknown
  - getAllGameObjects
```
@NotNull
public @NotNull java.util.List<G> getAllGameObjects()
```
    Description copied from interface: MapModel
    
    Returns all game objects. Only top-level head parts are returned; tail parts are ignored as are objects in inventories.
    
    Specified by:
    
    getAllGameObjects in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    all game objects
  - isModified
```
public boolean isModified()
```
    Description copied from interface: MapModel
    
    Return whether the map has been modified from the on-disk state.
    
    Specified by:
    
    isModified in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Returns:
    
    true if the map has been modified from the on-disk state
  - resetModified
```
public void resetModified()
```
    Description copied from interface: MapModel
    
    Resets the modified flag to false.
    
    Specified by:
    
    resetModified in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
  - facesReloaded
```
public void facesReloaded()
```
    Description copied from interface: MapModel
    
    Will be called whenever the archetype faces have been reloaded.
    
    Specified by:
    
    facesReloaded in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
  - nextPoint
```
public void nextPoint(java.awt.Point point,
                      int direction)
```
    Description copied from interface: MapModel
    
    Moves the given point forward or backward one map square.
    
    Specified by:
    
    nextPoint in interface MapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>
    
    Parameters:
    
    point - the point to start with and modify
    
    direction - the direction (-1 or +1)

Class DefaultMapModel<G extends GameObject<G,A,R>,A extends MapArchObject<A>,R extends Archetype<G,A,R>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

DefaultMapModel

Method Detail

mapClosed

getMapArchObject

iterator

getMapSquare

addObjectListToMap

clearMap

isEmpty

addMapModelListener

prependMapModelListener

removeMapModelListener

addMapTransactionListener

removeMapTransactionListener

beginSquareChange

endSquareChange

beginGameObjectChange

endGameObjectChange

transientGameObjectChange

beginTransaction

endTransaction

endTransaction

endAllTransactions

getTransactionDepth

isAnyTransactionActive

removeGameObject

isMultiArchFittingToMap

setErrors

getErrors

insertArchToMap

insertBaseObject

addGameObjectToMap

moveEnv

moveInv

isAreaEmpty

addActiveEditType

setMapFile

getMapFile

getMapFile

getAllGameObjects

isModified

resetModified

facesReloaded

nextPoint