Thinker

java.lang.Object
- org.cell2d.Thinker<T,U,V>

Type Parameters:

T - The type of CellGame that uses this Thinker's GameStates

U - The type of GameState that uses this Thinker

V - The type of SubThinker that can be assigned to this Thinker

Direct Known Subclasses:

GameState, SubThinker
```
public abstract class Thinker<T extends CellGame,U extends GameState<T,U,V>,V extends SubThinker<T,U,V>>
extends java.lang.Object
```
A Thinker is a collection of methods that contributes to the mechanics of a GameState to which it is assigned. A Thinker can be a GameState itself, in which case it is considered assigned to itself. It can also be a SubThinker that can be assigned to another Thinker, in which case it is considered assigned to a GameState if it is assigned to another Thinker that is itself assigned to the GameState.

A Thinker's assigned GameState will keep track of time for the Thinker, thus allowing the Thinker to take its own time-dependent actions, while the GameState is active. A Thinker's time factor represents the average number of discrete time units the Thinker will experience each frame while assigned to an active GameState. If its time factor is negative, as it is by default, a Thinker will use a time factor of one fracunit (if it is a GameState) or share the time factor of the Thinker to which it is assigned (if it is a SubThinker). If a Thinker is assigned to an inactive GameState or none at all, time will not pass for it.

A Thinker has timers that can perform Events after a certain number of time units. Timers have integer values, with a positive value x indicating that the Event will be performed in x time units, a negative value indicating that the timer is not running, and a value of 0 indicating that either the Event was performed, or the value was deliberately set to 0, this time unit. Each time unit, a Thinker decreases its non-negative timers' values by 1 and performs the Events whose timers have reached 0. Each frame, each Thinker experiences all of its time units immediately before its assigned SubThinkers experience any of theirs.

A Thinker has frameActions() that it takes exactly once each frame, after all Thinkers have experienced all of their time units for that frame. It also has an EventGroup of frame Events that it performs once each frame immediately after it takes its frameActions(). Both taking frameActions() and performing frame Events count as time-dependent actions, and thus a Thinker will only do them when assigned to an active GameState.

SubThinkers may be assigned to one Thinker each. Because a Thinker's internal list of SubThinkers cannot be modified while it is being iterated over, the actual addition or removal of a SubThinker to or from a Thinker is delayed until any and all iterations over its SubThinkers, such as the periods during which its SubThinkers perform their timer Events, have been completed. Multiple delayed instructions may be successfully given to Thinkers regarding the same SubThinker without having to wait until all iterations have finished.

Constructor Summary

Constructors
Constructor and Description

Thinker(java.lang.Class<T> gameClass, java.lang.Class<U> stateClass, java.lang.Class<V> subThinkerClass)
Constructs a Thinker.

Constructors
Constructor and Description
`Thinker(java.lang.Class<T> gameClass, java.lang.Class<U> stateClass, java.lang.Class<V> subThinkerClass)` Constructs a Thinker.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addSubThinker(V subThinker)` Adds the specified SubThinker to this Thinker if it is not already assigned to a Thinker, and if doing so would not create a loop of assignments in which SubThinkers are directly or indirectly assigned to themselves.
`void`	`addSubThinkerActions(T game, U state, V subThinker)` Actions for this Thinker to take immediately after adding a SubThinker to itself, before the added SubThinker takes its addedActions().
`void`	`clearLineages()` Removes from their super-Thinkers all of the SubThinkers that are directly or indirectly assigned to this Thinker.
`void`	`clearSubThinkers()` Removes from this Thinker all of the SubThinkers that are currently assigned to it.
`void`	`frameActions(T game, U state)` Actions for this Thinker to take once each frame.
`abstract long`	`getEffectiveTimeFactor()` Returns this Thinker's effective time factor; that is, the average number of time units it experiences every frame.
`EventGroup<T,U>`	`getFrameEvents()` Returns the EventGroup of this Thinker's frame Events.
`abstract T`	`getGame()` Returns the CellGame of the GameState to which this Thinker is assigned, or null if it is not assigned to a GameState.
`java.lang.Class<T>`	`getGameClass()` Returns the Class object representing the type of CellGame that uses this Thinker's GameStates.
`abstract U`	`getGameState()` Returns the GameState to which this Thinker is assigned, or null if it is not assigned to one.
`int`	`getNumSubThinkers()` Returns the number of SubThinkers that are assigned to this Thinker.
`java.lang.Class<U>`	`getStateClass()` Returns the Class object representing the type of GameState that uses this Thinker.
`java.lang.Class<V>`	`getSubThinkerClass()` Returns the Class object representing the type of SubThinker that can be assigned to this Thinker.
`long`	`getTimeFactor()` Returns this Thinker's time factor.
`int`	`getTimerValue(Event<T,U> event)` Returns the current value of this Thinker's timer for the specified Event.
`boolean`	`iteratingThroughSubThinkers()` Returns whether any Iterators over this Thinker's list of SubThinkers are in progress.
`boolean`	`removeLineage(V subThinker)` Removes from their super-Thinkers all of the SubThinkers that are directly or indirectly assigned to this Thinker, and are either assigned to or assignees of the specified SubThinker.
`boolean`	`removeSubThinker(V subThinker)` Removes the specified SubThinker from this Thinker if it is currently assigned to it.
`void`	`removeSubThinkerActions(T game, U state, V subThinker)` Actions for this Thinker to take immediately before removing a SubThinker from itself, after the soon-to-be-removed SubThinker takes its removedActions().
`void`	`setTimeFactor(long timeFactor)` Sets this Thinker's time factor to the specified value.
`void`	`setTimerValue(Event<T,U> event, int value)` Sets the value of this Thinker's timer for the specified Event to the specified value.
`SafeIterator<V>`	`subThinkerIterator()` Returns a new SafeIterator over this Thinker's list of SubThinkers.

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

- Constructor Detail
  - Thinker
```
public Thinker(java.lang.Class<T> gameClass,
               java.lang.Class<U> stateClass,
               java.lang.Class<V> subThinkerClass)
```
    Constructs a Thinker.
    
    Parameters:
    
    gameClass - The Class object representing the type of CellGame that uses this Thinker's GameStates
    
    stateClass - The Class object representing the type of GameState that uses this Thinker
    
    subThinkerClass - The Class object representing the type of SubThinker that can be assigned to this Thinker
- Method Detail
  - getGameClass
```
public final java.lang.Class<T> getGameClass()
```
    Returns the Class object representing the type of CellGame that uses this Thinker's GameStates.
    
    Returns:
    
    The Class object representing the type of CellGame that uses this Thinker's GameStates
  - getStateClass
```
public final java.lang.Class<U> getStateClass()
```
    Returns the Class object representing the type of GameState that uses this Thinker.
    
    Returns:
    
    The Class object representing the type of GameState that uses this Thinker
  - getSubThinkerClass
```
public final java.lang.Class<V> getSubThinkerClass()
```
    Returns the Class object representing the type of SubThinker that can be assigned to this Thinker.
    
    Returns:
    
    The Class object representing the type of SubThinker that can be assigned to this Thinker
  - getGame
```
public abstract T getGame()
```
    Returns the CellGame of the GameState to which this Thinker is assigned, or null if it is not assigned to a GameState.
    
    Returns:
    
    This Thinker's GameState's CellGame
  - getGameState
```
public abstract U getGameState()
```
    Returns the GameState to which this Thinker is assigned, or null if it is not assigned to one.
    
    Returns:
    
    The GameState to which this Thinker is assigned
  - getTimeFactor
```
public final long getTimeFactor()
```
    Returns this Thinker's time factor.
    
    Returns:
    
    This Thinker's time factor
  - getEffectiveTimeFactor
```
public abstract long getEffectiveTimeFactor()
```
    Returns this Thinker's effective time factor; that is, the average number of time units it experiences every frame. If it is not assigned to a GameState, this will be 0.
    
    Returns:
    
    This Thinker's effective time factor
  - setTimeFactor
```
public final void setTimeFactor(long timeFactor)
```
    Sets this Thinker's time factor to the specified value.
    
    Parameters:
    
    timeFactor - The new time factor
  - getTimerValue
```
public final int getTimerValue(Event<T,U> event)
```
    Returns the current value of this Thinker's timer for the specified Event.
    
    Parameters:
    
    event - The Event whose timer value should be returned
    
    Returns:
    
    The current value of the timer for the specified Event
  - setTimerValue
```
public final void setTimerValue(Event<T,U> event,
                                int value)
```
    Sets the value of this Thinker's timer for the specified Event to the specified value.
    
    Parameters:
    
    event - The Event whose timer value should be set
    
    value - The new value of the specified Event's timer
  - frameActions
```
public void frameActions(T game,
                         U state)
```
    Actions for this Thinker to take once each frame.
    
    Parameters:
    
    game - This Thinker's GameState's CellGame
    
    state - This Thinker's GameState
  - getFrameEvents
```
public final EventGroup<T,U> getFrameEvents()
```
    Returns the EventGroup of this Thinker's frame Events.
    
    Returns:
    
    The EventGroup of this Thinker's frame Events
  - getNumSubThinkers
```
public final int getNumSubThinkers()
```
    Returns the number of SubThinkers that are assigned to this Thinker.
    
    Returns:
    
    The number of SubThinkers that are assigned to this Thinker
  - iteratingThroughSubThinkers
```
public final boolean iteratingThroughSubThinkers()
```
    Returns whether any Iterators over this Thinker's list of SubThinkers are in progress.
    
    Returns:
    
    Whether any Iterators over this Thinker's list of SubThinkers are in progress
  - subThinkerIterator
```
public final SafeIterator<V> subThinkerIterator()
```
    Returns a new SafeIterator over this Thinker's list of SubThinkers.
    
    Returns:
    
    A new SafeIterator over this Thinker's list of SubThinkers
  - addSubThinker
```
public final boolean addSubThinker(V subThinker)
```
    Adds the specified SubThinker to this Thinker if it is not already assigned to a Thinker, and if doing so would not create a loop of assignments in which SubThinkers are directly or indirectly assigned to themselves.
    
    Parameters:
    
    subThinker - The SubThinker to be added
    
    Returns:
    
    Whether the addition occurred
  - removeSubThinker
```
public final boolean removeSubThinker(V subThinker)
```
    Removes the specified SubThinker from this Thinker if it is currently assigned to it.
    
    Parameters:
    
    subThinker - The SubThinker to be removed
    
    Returns:
    
    Whether the removal occurred
  - clearSubThinkers
```
public final void clearSubThinkers()
```
    Removes from this Thinker all of the SubThinkers that are currently assigned to it.
  - removeLineage
```
public final boolean removeLineage(V subThinker)
```
    Removes from their super-Thinkers all of the SubThinkers that are directly or indirectly assigned to this Thinker, and are either assigned to or assignees of the specified SubThinker. For instance, if a SubThinker is assigned to a SubThinker that is assigned to a SubThinker that is assigned to this Thinker, and the second SubThinker is the specified SubThinker, the first SubThinker will be removed from the second, the second from the third, and the third from this Thinker. This method is useful for Thinkers that use SubThinkers to model a hierarchy of states in which they can exist.
    
    Parameters:
    
    subThinker - The SubThinker with which the removed SubThinkers must share a lineage of assignments
    
    Returns:
    
    Whether any removals occurred
  - clearLineages
```
public final void clearLineages()
```
    Removes from their super-Thinkers all of the SubThinkers that are directly or indirectly assigned to this Thinker. For instance, if a SubThinker is assigned to a SubThinker that is assigned to this Thinker, the first SubThinker will be removed from the second, and the second will be removed from this Thinker.
  - addSubThinkerActions
```
public void addSubThinkerActions(T game,
                                 U state,
                                 V subThinker)
```
    Actions for this Thinker to take immediately after adding a SubThinker to itself, before the added SubThinker takes its addedActions().
    
    Parameters:
    
    game - This Thinker's GameState's CellGame, or null if it has no GameState
    
    state - This Thinker's GameState, or null if it has none
    
    subThinker - The SubThinker that was added
  - removeSubThinkerActions
```
public void removeSubThinkerActions(T game,
                                    U state,
                                    V subThinker)
```
    Actions for this Thinker to take immediately before removing a SubThinker from itself, after the soon-to-be-removed SubThinker takes its removedActions().
    
    Parameters:
    
    game - This Thinker's GameState's CellGame, or null if it has no GameState
    
    state - This Thinker's GameState, or null if it has none
    
    subThinker - The SubThinker that is about to be removed

Class Thinker<T extends CellGame,U extends GameState<T,U,V>,V extends SubThinker<T,U,V>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Thinker

Method Detail

getGameClass

getStateClass

getSubThinkerClass

getGame

getGameState

getTimeFactor

getEffectiveTimeFactor

setTimeFactor

getTimerValue

setTimerValue

frameActions

getFrameEvents

getNumSubThinkers

iteratingThroughSubThinkers

subThinkerIterator

addSubThinker

removeSubThinker

clearSubThinkers

removeLineage

clearLineages

addSubThinkerActions

removeSubThinkerActions