PuzzleInstance

java.lang.Object
- java.util.Observable
- - cusack.hcg.model.PuzzleInstance

All Implemented Interfaces:

DrawableGraphProblem, java.util.Observer

Direct Known Subclasses:

ColorsInstance, GraphInstance, LightsInstance, MultiDesignsInstance, PebbleInstance, PortalLordInstance, PowerGraphInstance, WeightedInstance
```
public abstract class PuzzleInstance
extends java.util.Observable
implements java.util.Observer, DrawableGraphProblem
```
This class is a generic type of game model that holds all the relevant data for a specific game. This class interacts with the two history classes through event triggers and listeners as well as the jTableView and controller classes.

Author:

Jeff Largent, Ryan Alfuth, modified by Chuck Cusack, January-Feb, 2010., modified by Daniel Simpson Summer 2011.

Constructor Summary

Constructors
Constructor and Description

PuzzleInstance()
Default constructor.

Constructors
Constructor and Description
`PuzzleInstance()` Default constructor.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDoppelganger(Vertex ganger, java.awt.Point p, int num, boolean connectDoppelToGanger)`
`void`	`addGraph(java.awt.Point p, Graph g)`
`void`	`addGraphWithData(java.awt.Point p, GraphWithData g)`
`void`	`addToSelected(java.util.ArrayList<Vertex> verts)`
`boolean`	`addToSelected(Vertex v)`
`void`	`addVertex(java.awt.Point coordinates)`
`boolean`	`canRedo()`
`boolean`	`canUndo()`
`void`	`checkAndHandlePuzzleCompletion()` Checks if the game is completed, if it is start a timer to show the game completed dialog when it goes off.
`void`	`clearAllSelections()` Clears the currently selected vertex by setting it to null.
`void`	`clearHistory()` This method clears both histories completely so that no events remain in them: both stacks are cleared
`void`	`clearTutorial()`
`int`	`computeGlobalPoints()`
`void`	`connectAllSelectedVertices()` This method creates a clique between all the selected vertices, where each vertex that is select is connected to each other vertex in the group.
`void`	`connectToSelected(Vertex vert)`
`void`	`convertMovesToTutorial()`
`abstract PuzzleInstance`	`copyPuzzle()` Make a copy of this object, but not exactly! IMPORTANT: This copy should make a copy so that the copy's initial settings are set to this objects current settings.
`PuzzleInstance`	`copyPuzzleSoItHasInitialStateTheSameAsMyCurrentState()` Copies the puzzle so that it has an initial state that is the same as this puzzle's current state.
`boolean`	`copyRequested()`
`void`	`copySelected()` This method creates a copy of the currently selected vertices, edges and all, and stores this copy in a list for further use.
`Vertex`	`createNewVertexForPuzzle(java.awt.Point p)`
`java.lang.String`	`currentPuzzleDataToString()` A wrapper for encodePuzzleData that prepends the encoding character for the current problem type.
`void`	`deleteSelected()` This method deletes all the selected vertices from the graph after disconnecting them.
`void`	`disableHistory()` This method stops the gross history from recording any events that occur.
`void`	`disconnectFromSelected(Vertex vert)`
`void`	`disconnectSelected()` This method disconnects all the selected vertices from each other on the graph.
`void`	`doNotRecordGraphEvents()` Set recordGraphEvents to false.
`void`	`enableHistory()` This method causes the game class to allow the gross history to start recording events again.
`void`	`endGame()`
`void`	`forceRedo()` Redo the last move that was undone.
`java.lang.String`	`getAttemptName()`
`int`	`getBasePoints()`
`java.lang.String`	`getCurrentAnnotation()`
`java.lang.String`	`getCurrentMoveOverview()`
`Event<?>`	`getCurrentUndoableEvent()`
`VertexData`	`getData(Vertex v)` Calls getData(v) on the graph.
`abstract VertexData`	`getDefaultVertexDataObject()`
`java.lang.String`	`getDescription()` Get the description of this PuzzleInstance.
`int`	`getDiameter()` This method returns the diameter of the graph of the Puzzle.
`int`	`getDifficultyLevel()`
`java.lang.String`	`getEdgeDataClassName()`
`java.lang.String`	`getEditHelpClassName()`
`java.lang.String`	`getEditorClassName()`
`java.lang.String`	`getFamilyName()`
`Vertex`	`getFirstSelected()` This method gets the first vertex that is in the list of all selected vertices.
`int`	`getFirstTimeBonus()`
`java.lang.String`	`getGameName()` Return the name from the problems column in the DB.
`int`	`getGlobalBest()` This method returns the global best for the current puzzle.
`GraphWithData`	`getGraph()` Returns the GraphWithData that is associated with this game.
`java.lang.String`	`getHelpClassName()`
`int`	`getHighScoreBonus()`
`int`	`getImprovementBonus()`
`java.lang.String`	`getInstanceClassName()`
`java.util.ArrayList<Vertex>`	`getInterestingTutorialVertices()`
`int`	`getMaximumXCoordinate()`
`int`	`getMaximumYCoordinate()`
`java.lang.String`	`getMessage()`
`int`	`getMinimumSelectedXCoordinate()`
`int`	`getMinimumSelectedYCoordinate()`
`int`	`getMinimumXCoordinate()`
`int`	`getMinimumYCoordinate()`
`Solution.Mode`	`getMode()`
`int`	`getNumberOfEdges()`
`int`	`getNumberOfMoves()`
`int`	`getNumberOfVertices()` This method returns the total number of vertices that are on the graph.
`int`	`getNumberSelected()` This method returns the size of the list of selected vertices, indicating the number that have been selected.
`int`	`getOldHighScore()`
`int`	`getPersonalBest()` This method returns the user's personal best for the current puzzle.
`java.lang.String`	`getPlayClassName()`
`abstract java.lang.String`	`getProcessedSolution()`
`int`	`getPuzzleID()` This method just returns the game id.
`java.lang.String`	`getPuzzleInstanceName()`
`java.lang.String`	`getPuzzleName()` This method returns the name of the current puzzle or null if the puzzle has no name (the puzzle is newly created).
`abstract int`	`getScore()` Return the current score of the active game.
`java.util.ArrayList<Vertex>`	`getSelectedVertices()`
`Solution`	`getSolution()` Returns a solution WITHOUT the UserID properly set necessarily.
`java.lang.String`	`getSolutionAsString()`
`int`	`getSolutionID()`
`java.lang.String`	`getThemeClassName()`
`long`	`getTimeTaken()` Returns the time that it took to complete the algorithm/puzzle.
`Event<?>`	`getTopOfUndoStack()`
`abstract PuzzleInstance`	`getTryItInstanceForUseOnPlayScreen()` What kind of puzzle should the TryIt button produce? Return null if Try it is not applicable
`TutorialData`	`getTutorialData()`
`int`	`getUserID()`
`int`	`getVertexIndex(Vertex v)` Get the index of a given vertex
`java.util.ArrayList<Vertex>`	`getVertices()` This method returns a list of all vertices that currently make up the graph.
`Puzzle.VisibilityType`	`getVisibility()`
`java.util.ArrayList<Vertex>`	`getVisibleSources()`
`void`	`goToNextEvent()`
`boolean`	`grossHistoryDeleteLastEvent()`
`Event<?>`	`grossHistoryGetLastAddedEvent()`
`Event<?>`	`grossHistoryGetNextEvent()`
`int`	`grossHistoryGetNextEventIndex()`
`boolean`	`grossHistoryIsSaved()`
`boolean`	`grossHistoryIteratorAtBeginning()`
`boolean`	`grossHistoryIteratorAtEnd()`
`Event<?>`	`grossHistoryNext()`
`Event<?>`	`grossHistoryPrevious()`
`void`	`grossHistorySetSaved(boolean saved)`
`int`	`grossHistorySize()`
`void`	`grossHistoryToBeginning()`
`void`	`grossHistoryToEnd()`
`java.lang.String`	`initialPuzzleDataToString()` This method is similar to encodeData except that it returns the data as it was in the beginning.
`abstract boolean`	`isCurrentStateValidSolution()` Each instance needs to determine when the solution is valid.
`abstract boolean`	`isEventForThisPuzzleType(Event<?> e)` Return true iff this event is of type T.
`boolean`	`isFinishable()`
`boolean`	`isInReplayOrEditTutorialMode()`
`boolean`	`isLocked()` This method sets whether or not the game is locked.
`boolean`	`isLowerScoreBetter()`
`boolean`	`isPlayable()`
`boolean`	`isSaved()` Returns whether or not the game has been saved.
`boolean`	`isShowIndices()`
`abstract boolean`	`isSolutionRefinable()` For optimization problems, for instance, this will return true.
`boolean`	`isSpecialCopyOK()`
`boolean`	`isTutorial()` Check if the current problem is a tutorial puzzle.
`boolean`	`isValidToTranslationSelection(java.awt.Point change)`
`boolean`	`isVisibleSource(Vertex visibleSource)`
`void`	`makeCurrentStateInitialState()` set the current state of the graph to its initial state.
`void`	`moveGraphEnded(java.awt.Point p)` Tells the game that the series of moves is over.
`void`	`moveSelectedVerticesEnded(java.awt.Point p)` Tells the game that the series of moves is over.
`void`	`moveStarted(java.awt.Point p)` Tell the game that a series of moves has started.
`void`	`pasteAndConnectCopyOfSelected(int x, int y)` Paste the subgrapgh corresponding to the copiedList, adding an edge between the corresponding vertices in the original list and the new copy.
`void`	`pasteCopyOfSelected(int x, int y)` This method "pastes" the list of copies vertices onto the graph.
`void`	`performEvents(java.util.ArrayList<Event<?>> eventList)`
`void`	`performEvents(java.lang.String events)` Take in a string, break it up, and parse it so that it can determine what kind of events were originally fired.
`boolean`	`performTutorialEvents()`
`void`	`reallySetLocked(boolean flag)` This is needed to lock in Edit mode when there is a tutorial.
`void`	`recordGraphEvents()` Set recordGraphEvents to true.
`void`	`redo()` Allows redoing of events that are "no longer on undo queue" (They are there but hidden).
`void`	`removeFromSelected(java.util.ArrayList<Vertex> toClear)` If the vertices in the list are in the list "selection" they will be deselected.
`void`	`removeFromSelected(Vertex v)` Removes the vertex from the selected list.
`void`	`resetVerticesToInitialLocations()` Reset the vertices to their initial locations.
`void`	`restart()` Causes the game to be started over for the user by reseting all the information to the initial configuration.
`void`	`runAlgorithms()` Notifies the listeners that this algorithm should be run by supplying them with a ClickCheckButtonEvent.
`void`	`runuTryIt()`
`void`	`selectAll()`
`void`	`sendAlgorithmResult(boolean r)`
`void`	`sendMeaninglessEvent()`
`void`	`setAttemptName(java.lang.String attemptName)`
`boolean`	`setData(Vertex v, VertexData vd)` Callse setData(v, vd) on the graph
`void`	`setDefaultData(Vertex vert)`
`void`	`setDescription(java.lang.String description)` Set the description of this PuzzleInstance.
`void`	`setFinishable(boolean isLockable)`
`void`	`setGlobalBest(int global)` This method sets the global best for the current puzzle.
`void`	`setGraph(Graph graph)` This method sets the graph for this PuzzleInstance.
`void`	`setInReplayOrEditTutorialMode(boolean inReplayMode)` Set the mode.
`void`	`setLocked(boolean flag)` This method checks to see whether or not the game is locked, meaning that the user is forbbiden from interacting with it.
`void`	`setMessage(java.lang.String message)`
`void`	`setMode(Solution.Mode mode)`
`void`	`setPersonalBest(int pers)` This method sets the players personal best score.
`void`	`setPlayable(boolean isPlayable)` Set the puzzle to playable.
`void`	`setPuzzle(Puzzle dbPuzzle)` This method sets the game name and game id from the passed in game object.
`void`	`setPuzzleID(int gameID)`
`void`	`setPuzzleName(java.lang.String puzzleName)`
`void`	`setSaved(boolean saved)` Sets whether or not this game has been saved.
`void`	`setShowIndices(boolean showIndices)`
`void`	`setSolutionData(java.lang.String data)` Set the solution data to the given string.
`void`	`setSolutionID(int solutionID)`
`void`	`setSolutionInformation(Solution solution)` This method sets the solution data, such as the time taken by the user, and the previous score set by the user during their last play through.
`void`	`setUserID(int userID)`
`void`	`setVisibleSources(java.util.ArrayList<Vertex> visibleSource)`
`void`	`startTimer()` This method both initializes the timer and causes it to start when it is called.
`void`	`stopTimer()` This method causes the timer to stop if it has been initialized.
`void`	`stringToPuzzleData(java.lang.String configuration)` This method parses the parameter string into the game details.
`void`	`submit()` Notifies the listeners that the submit button has been clicked.
`void`	`toggleSelected(Vertex v)`
`abstract boolean`	`tryItResultsAreBinding()` Return true only if Try It mode, using the type from getTryItInstance, will produce a result that is AWLAYS valid for the puzzle type.
`void`	`tutorialModeEnabled(boolean b)` Set isTutorial to the given boolean.
`void`	`undo()` Undo the last RecordableEvent.
`abstract java.lang.String`	`uniqueIdentifier(Vertex v)` Return a string that represents the data related to the given Vertex in a way that is different if the data is different.
`void`	`update(java.util.Observable o, java.lang.Object arg)`
`abstract void`	`updateStateBasedOnAlgorithmResult(java.lang.String algorithmResult)` Updates the algorithm's state based on the algorithm result.
`void`	`updateTimeTaken()` Sets timeTaken to the current time - start time.
`abstract boolean`	`usesAlgorithms()` If the game related to this problem requires running algorithms, this should return true.

Methods inherited from class java.util.Observable
addObserver, countObservers, deleteObserver, deleteObservers, hasChanged, notifyObservers, notifyObservers

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

- Constructor Detail
  - PuzzleInstance
```
public PuzzleInstance()
```
    Default constructor. Takes no parameters.
- Method Detail
  - isCurrentStateValidSolution
```
public abstract boolean isCurrentStateValidSolution()
```
    Each instance needs to determine when the solution is valid.
    
    Returns:
    
    true if the current state is a valid solution.
  - usesAlgorithms
```
public abstract boolean usesAlgorithms()
```
    If the game related to this problem requires running algorithms, this should return true. In addition there must be a class in the game package called FooAlgorithmRunner.
    
    Returns:
    
    true if this problem requires running algorithms.
  - updateStateBasedOnAlgorithmResult
```
public abstract void updateStateBasedOnAlgorithmResult(java.lang.String algorithmResult)
```
    Updates the algorithm's state based on the algorithm result. (This is mostly for Confound It and Optimize It, but it may be useful for other things.)
    
    Parameters:
    
    algorithmResult - a boolean that describes the result of the algorithm.
  - isSolutionRefinable
```
public abstract boolean isSolutionRefinable()
```
    For optimization problems, for instance, this will return true. For decision problems, this will generally return false.
    
    Returns:
    
    true if the solution can be defined.
  - getTryItInstanceForUseOnPlayScreen
```
public abstract PuzzleInstance getTryItInstanceForUseOnPlayScreen()
```
    What kind of puzzle should the TryIt button produce? Return null if Try it is not applicable
    
    Returns:
    
    a subclass of PuzzleInstance that the TryIt button should produce.
  - tryItResultsAreBinding
```
public abstract boolean tryItResultsAreBinding()
```
    Return true only if Try It mode, using the type from getTryItInstance, will produce a result that is AWLAYS valid for the puzzle type. For instance, in Optimize it, valid is solvable, and if in Try It the player shows it is solvable, then it is correct. On the other hand Confound It is not binding because if you play it and don't find it solvable, that doesn't mean anything.
  - isEventForThisPuzzleType
```
public abstract boolean isEventForThisPuzzleType(Event<?> e)
```
    Return true iff this event is of type T. Stupid method that is necessary because Java is dumb. One would like to ask 'if(x instanceof T)', but since Java throws away Generics at runtime, it doesn't know what T is, so you can't ask this. This is an important method because (I think) that this is the only thing that ensure the right sort of objects are placed on history and the wrong ones aren't. Since the UndoRedoHistory is not properly parameterized (don't get me started on how much I hate Generics in Java) I think this method is the only thing that makes sure that if an RecordableEvent calls its performEvent method, that the PuzzleInstance object passed in is the correct one (for instance, a PebbleInstance must be passed if movePebbles is called since otherwise the program will crash). This may only be used in one place, but it is still necessary. CAC, Feb 2010.
    
    Parameters:
    
    e -
    
    Returns:
  - copyPuzzle
```
public abstract PuzzleInstance copyPuzzle()
```
    Make a copy of this object, but not exactly! IMPORTANT: This copy should make a copy so that the copy's initial settings are set to this objects current settings. This can probably just call the copy constructor defined in the subclass. This method should simply call the copy constructor for the puzzle.
    
    Returns:
  - getScore
```
public abstract int getScore()
```
    Return the current score of the active game. For many games this will simply be: return getNumberMoves(); For others it will be something else.
    
    Returns:
  - getProcessedSolution
```
public abstract java.lang.String getProcessedSolution()
```
  - getDefaultVertexDataObject
```
public abstract VertexData getDefaultVertexDataObject()
```
  - uniqueIdentifier
```
public abstract java.lang.String uniqueIdentifier(Vertex v)
```
    Return a string that represents the data related to the given Vertex in a way that is different if the data is different. e.g. if the only data is number of pebbles, it can just return the number of pebbles as a string. If there is no real data, returning an empty string is acceptable.
    
    Returns:
  - copyPuzzleSoItHasInitialStateTheSameAsMyCurrentState
```
public PuzzleInstance copyPuzzleSoItHasInitialStateTheSameAsMyCurrentState()
```
    Copies the puzzle so that it has an initial state that is the same as this puzzle's current state.
    
    Returns:
    
    the a copy of this puzzle.
  - restart
```
public void restart()
```
    Causes the game to be started over for the user by reseting all the information to the initial configuration.
  - getGameName
```
public java.lang.String getGameName()
```
    Return the name from the problems column in the DB.
    
    Returns:
    
    the name from the problems column in the DB.
  - getData
```
public VertexData getData(Vertex v)
```
    Calls getData(v) on the graph.
    
    Parameters:
    
    v -
    
    Returns:
    
    See Also:
    
    GraphWithData.getData(cusack.hcg.graph.Vertex)
  - setData
```
public boolean setData(Vertex v,
                       VertexData vd)
```
    Callse setData(v, vd) on the graph
    
    Parameters:
    
    v -
    
    vd -
    
    Returns:
    
    See Also:
    
    GraphWithData.setData(cusack.hcg.graph.Vertex, cusack.hcg.graph.VertexData)
  - setDefaultData
```
public void setDefaultData(Vertex vert)
```
    Parameters:
    
    vert - the vertex for which we will set data
    
    See Also:
    
    GraphWithData.setDefaultData(cusack.hcg.graph.Vertex)
  - setGraph
```
public void setGraph(Graph graph)
```
    This method sets the graph for this PuzzleInstance. It will initialize any game data as well.
    
    Parameters:
    
    dbGraph - The database graph that holds the necessary information
  - setPuzzle
```
public void setPuzzle(Puzzle dbPuzzle)
```
    This method sets the game name and game id from the passed in game object. setUpGraph should be called BEFORE this method so there is a graph.
    
    Parameters:
    
    dbPuzzle - The game object that is passed in that holds the necessary information
  - initialPuzzleDataToString
```
public final java.lang.String initialPuzzleDataToString()
```
    This method is similar to encodeData except that it returns the data as it was in the beginning. If moves have been made, this will still return the same thing. To get the current state of the puzzle instead, call encodePuzzleData.
    
    Returns:
    
    the encoded string
  - currentPuzzleDataToString
```
public final java.lang.String currentPuzzleDataToString()
```
    A wrapper for encodePuzzleData that prepends the encoding character for the current problem type.
    
    Returns:
    
    the encoded string
  - makeCurrentStateInitialState
```
public void makeCurrentStateInitialState()
```
    set the current state of the graph to its initial state.
  - stringToPuzzleData
```
public final void stringToPuzzleData(java.lang.String configuration)
```
    This method parses the parameter string into the game details. This method takes care of ensuring the encoding is correct by looking at the first character, and then passing off the rest of the job to decodeData(), which is implemented by the subclasses.
    
    Parameters:
    
    configuration - the string that will be encoded into this puzzle data.
  - setSolutionInformation
```
public void setSolutionInformation(Solution solution)
```
    This method sets the solution data, such as the time taken by the user, and the previous score set by the user during their last play through.
    
    Parameters:
    
    solution - The database class that holds the necessary information
  - setSolutionData
```
public void setSolutionData(java.lang.String data)
```
    Set the solution data to the given string.
    
    Parameters:
    
    data - the data to set
  - resetVerticesToInitialLocations
```
public void resetVerticesToInitialLocations()
```
    Reset the vertices to their initial locations.
  - clearHistory
```
public void clearHistory()
```
    This method clears both histories completely so that no events remain in them: both stacks are cleared
  - disableHistory
```
public void disableHistory()
```
    This method stops the gross history from recording any events that occur.
  - enableHistory
```
public void enableHistory()
```
    This method causes the game class to allow the gross history to start recording events again.
  - getNumberOfMoves
```
public int getNumberOfMoves()
```
    Returns:
    
    the number of moves in grossHistory.
  - getDiameter
```
public int getDiameter()
```
    This method returns the diameter of the graph of the Puzzle.
    
    Returns:
    
    The diameter of the graph.
  - getNumberOfVertices
```
public int getNumberOfVertices()
```
    This method returns the total number of vertices that are on the graph.
    
    Specified by:
    
    getNumberOfVertices in interface DrawableGraphProblem
    
    Returns:
    
    The number of vertices on the graph
  - getNumberOfEdges
```
public int getNumberOfEdges()
```
    Specified by:
    
    getNumberOfEdges in interface DrawableGraphProblem
    
    Returns:
    
    the number of edges on the graph.
  - getVertices
```
public java.util.ArrayList<Vertex> getVertices()
```
    This method returns a list of all vertices that currently make up the graph.
    
    Specified by:
    
    getVertices in interface DrawableGraphProblem
    
    Returns:
    
    The list of vertices that are on the graph
  - getVertexIndex
```
public int getVertexIndex(Vertex v)
```
    Get the index of a given vertex
    
    Specified by:
    
    getVertexIndex in interface DrawableGraphProblem
    
    Parameters:
    
    v - the vertex
    
    Returns:
    
    the index of the vertex.
  - canUndo
```
public boolean canUndo()
```
    Returns:
    
    true if the history has undo capability.
  - canRedo
```
public boolean canRedo()
```
    Returns:
    
    true if the history has redo capability.
  - undo
```
public void undo()
```
    Undo the last RecordableEvent.
  - forceRedo
```
public void forceRedo()
```
    Redo the last move that was undone.
  - redo
```
public void redo()
```
    Allows redoing of events that are "no longer on undo queue" (They are there but hidden).
  - createNewVertexForPuzzle
```
public Vertex createNewVertexForPuzzle(java.awt.Point p)
```
  - addVertex
```
public void addVertex(java.awt.Point coordinates)
```
  - addGraphWithData
```
public void addGraphWithData(java.awt.Point p,
                             GraphWithData g)
```
  - addGraph
```
public void addGraph(java.awt.Point p,
                     Graph g)
```
    Parameters:
    
    p - a point that represents an offset by which the subgraph will be added.
    
    g - the subgraph that will be added.
    
    See Also:
    
    Graph.addSubGraph(java.awt.Point, cusack.hcg.graph.Graph)
  - getGraph
```
public GraphWithData getGraph()
```
    Returns the GraphWithData that is associated with this game.
    
    Returns:
    
    The graph that is associated with this game
  - isTutorial
```
public boolean isTutorial()
```
    Check if the current problem is a tutorial puzzle.
    
    Specified by:
    
    isTutorial in interface DrawableGraphProblem
    
    Returns:
    
    true if isTutorial is true
  - tutorialModeEnabled
```
public void tutorialModeEnabled(boolean b)
```
    Set isTutorial to the given boolean.
    
    Parameters:
    
    b - the boolean to set isTutorial to.
  - convertMovesToTutorial
```
public void convertMovesToTutorial()
```
  - update
```
public void update(java.util.Observable o,
                   java.lang.Object arg)
```
    Specified by:
    
    update in interface java.util.Observer
  - checkAndHandlePuzzleCompletion
```
public void checkAndHandlePuzzleCompletion()
```
    Checks if the game is completed, if it is start a timer to show the game completed dialog when it goes off.
  - runAlgorithms
```
public void runAlgorithms()
```
    Notifies the listeners that this algorithm should be run by supplying them with a ClickCheckButtonEvent.
  - runuTryIt
```
public void runuTryIt()
```
  - submit
```
public void submit()
```
    Notifies the listeners that the submit button has been clicked.
  - endGame
```
public void endGame()
```
  - startTimer
```
public void startTimer()
```
    This method both initializes the timer and causes it to start when it is called.
  - stopTimer
```
public void stopTimer()
```
    This method causes the timer to stop if it has been initialized.
  - getTimeTaken
```
public long getTimeTaken()
```
    Returns the time that it took to complete the algorithm/puzzle.
    
    Returns:
    
    the total time taken
  - updateTimeTaken
```
public void updateTimeTaken()
```
    Sets timeTaken to the current time - start time.
  - recordGraphEvents
```
public void recordGraphEvents()
```
    Set recordGraphEvents to true.
  - doNotRecordGraphEvents
```
public void doNotRecordGraphEvents()
```
    Set recordGraphEvents to false.
  - getDescription
```
public java.lang.String getDescription()
```
    Get the description of this PuzzleInstance.
    
    Returns:
    
    the description of this PuzzleInstance.
  - setDescription
```
public void setDescription(java.lang.String description)
```
    Set the description of this PuzzleInstance.
    
    Parameters:
    
    description -
  - getMessage
```
public java.lang.String getMessage()
```
  - setMessage
```
public void setMessage(java.lang.String message)
```
  - isInReplayOrEditTutorialMode
```
public boolean isInReplayOrEditTutorialMode()
```
    Returns:
    
    true we are in Replay mode.
  - setInReplayOrEditTutorialMode
```
public void setInReplayOrEditTutorialMode(boolean inReplayMode)
```
    Set the mode.
    
    Parameters:
    
    inReplayMode - should be true if we are in replay mode.
  - sendMeaninglessEvent
```
public void sendMeaninglessEvent()
```
  - performEvents
```
public void performEvents(java.lang.String events)
```
    Take in a string, break it up, and parse it so that it can determine what kind of events were originally fired.
    
    Parameters:
    
    events - the string that has information about the fired events
  - performEvents
```
public void performEvents(java.util.ArrayList<Event<?>> eventList)
```
    Parameters:
    
    eventList - the list of events.
  - setLocked
```
public void setLocked(boolean flag)
```
    This method checks to see whether or not the game is locked, meaning that the user is forbbiden from interacting with it.
    
    Parameters:
    
    flag - true if locked, false otherwise
  - reallySetLocked
```
public void reallySetLocked(boolean flag)
```
    This is needed to lock in Edit mode when there is a tutorial. A quick fix. Not happy about it. CAC, 7/11
  - isLocked
```
public boolean isLocked()
```
    This method sets whether or not the game is locked.
    
    Returns:
    
    true if is it locked, false otherwise
  - isPlayable
```
public boolean isPlayable()
```
    Returns:
    
    true if this puzzle is playable.
  - setPlayable
```
public void setPlayable(boolean isPlayable)
```
    Set the puzzle to playable.
    
    Parameters:
    
    isPlayable - should be true if the puzzle is going to be playable.
  - isFinishable
```
public boolean isFinishable()
```
    Returns:
    
    true if this puzzle is finishable.
  - setFinishable
```
public void setFinishable(boolean isLockable)
```
  - isSaved
```
public boolean isSaved()
```
    Returns whether or not the game has been saved.
    
    Returns:
    
    true, if checks if is saved
  - setSaved
```
public void setSaved(boolean saved)
```
    Sets whether or not this game has been saved.
    
    Parameters:
    
    saved - the saved
  - clearAllSelections
```
public void clearAllSelections()
```
    Clears the currently selected vertex by setting it to null.
  - removeFromSelected
```
public void removeFromSelected(java.util.ArrayList<Vertex> toClear)
```
    If the vertices in the list are in the list "selection" they will be deselected.
  - removeFromSelected
```
public void removeFromSelected(Vertex v)
```
    Removes the vertex from the selected list.
  - toggleSelected
```
public void toggleSelected(Vertex v)
```
  - addToSelected
```
public void addToSelected(java.util.ArrayList<Vertex> verts)
```
  - selectAll
```
public void selectAll()
```
  - addToSelected
```
public boolean addToSelected(Vertex v)
```
  - getNumberSelected
```
public int getNumberSelected()
```
    This method returns the size of the list of selected vertices, indicating the number that have been selected.
    
    Returns:
    
    int The number of selected vertices
  - getSelectedVertices
```
public java.util.ArrayList<Vertex> getSelectedVertices()
```
  - getFirstSelected
```
public Vertex getFirstSelected()
```
    This method gets the first vertex that is in the list of all selected vertices. Usually, this method is only called if it is certain that only one vertex has been selected.
    
    Returns:
    
    The vertex that was selected
  - deleteSelected
```
public void deleteSelected()
```
    This method deletes all the selected vertices from the graph after disconnecting them.
  - disconnectSelected
```
public void disconnectSelected()
```
    This method disconnects all the selected vertices from each other on the graph.
  - connectAllSelectedVertices
```
public void connectAllSelectedVertices()
```
    This method creates a clique between all the selected vertices, where each vertex that is select is connected to each other vertex in the group.
  - connectToSelected
```
public void connectToSelected(Vertex vert)
```
  - disconnectFromSelected
```
public void disconnectFromSelected(Vertex vert)
```
  - isSpecialCopyOK
```
public boolean isSpecialCopyOK()
```
  - copyRequested
```
public boolean copyRequested()
```
  - addDoppelganger
```
public void addDoppelganger(Vertex ganger,
                            java.awt.Point p,
                            int num,
                            boolean connectDoppelToGanger)
```
  - copySelected
```
public void copySelected()
```
    This method creates a copy of the currently selected vertices, edges and all, and stores this copy in a list for further use.
  - pasteCopyOfSelected
```
public void pasteCopyOfSelected(int x,
                                int y)
```
    This method "pastes" the list of copies vertices onto the graph.
  - pasteAndConnectCopyOfSelected
```
public void pasteAndConnectCopyOfSelected(int x,
                                          int y)
```
    Paste the subgrapgh corresponding to the copiedList, adding an edge between the corresponding vertices in the original list and the new copy.
  - moveStarted
```
public void moveStarted(java.awt.Point p)
```
    Tell the game that a series of moves has started. See moveEnded for more...
    
    Parameters:
    
    p -
  - moveSelectedVerticesEnded
```
public void moveSelectedVerticesEnded(java.awt.Point p)
```
    Tells the game that the series of moves is over. Now tell the graph to summarize the series of moves.
    
    Parameters:
    
    p -
  - moveGraphEnded
```
public void moveGraphEnded(java.awt.Point p)
```
    Tells the game that the series of moves is over. Now tell the graph to summarize the series of moves.
    
    Parameters:
    
    p -
  - getSolutionAsString
```
public java.lang.String getSolutionAsString()
```
  - setPersonalBest
```
public void setPersonalBest(int pers)
```
    This method sets the players personal best score.
    
    Parameters:
    
    pers - The score that will become this user's new personal best score
  - setGlobalBest
```
public void setGlobalBest(int global)
```
    This method sets the global best for the current puzzle.
    
    Parameters:
    
    global - The highest score overall for this puzzle
  - getPersonalBest
```
public int getPersonalBest()
```
    This method returns the user's personal best for the current puzzle.
    
    Returns:
    
    The best score this user has had thus far
  - getGlobalBest
```
public int getGlobalBest()
```
    This method returns the global best for the current puzzle.
    
    Returns:
    
    The global best for the current puzzle
  - getVisibility
```
public Puzzle.VisibilityType getVisibility()
```
  - getPuzzleName
```
public java.lang.String getPuzzleName()
```
    This method returns the name of the current puzzle or null if the puzzle has no name (the puzzle is newly created).
    
    Returns:
    
    The name of the puzzle or null if the puzzle has no name
  - setPuzzleName
```
public void setPuzzleName(java.lang.String puzzleName)
```
    Parameters:
    
    puzzleName - the puzzleName to set
  - getPuzzleID
```
public int getPuzzleID()
```
    This method just returns the game id.
    
    Returns:
    
    The id of the game
  - setPuzzleID
```
public void setPuzzleID(int gameID)
```
  - getAttemptName
```
public java.lang.String getAttemptName()
```
  - setAttemptName
```
public void setAttemptName(java.lang.String attemptName)
```
  - getSolutionID
```
public int getSolutionID()
```
  - setSolutionID
```
public void setSolutionID(int solutionID)
```
  - getMinimumXCoordinate
```
public int getMinimumXCoordinate()
```
  - getMaximumXCoordinate
```
public int getMaximumXCoordinate()
```
  - getMinimumYCoordinate
```
public int getMinimumYCoordinate()
```
  - getMaximumYCoordinate
```
public int getMaximumYCoordinate()
```
  - getMinimumSelectedXCoordinate
```
public int getMinimumSelectedXCoordinate()
```
  - getMinimumSelectedYCoordinate
```
public int getMinimumSelectedYCoordinate()
```
  - isValidToTranslationSelection
```
public boolean isValidToTranslationSelection(java.awt.Point change)
```
  - getSolution
```
public Solution getSolution()
```
    Returns a solution WITHOUT the UserID properly set necessarily. This is messy. Refactor? CAC, Feb 2010. Is this true? Not clear.
    
    Returns:
    
    the solution
  - getUserID
```
public int getUserID()
```
  - setUserID
```
public void setUserID(int userID)
```
  - computeGlobalPoints
```
public int computeGlobalPoints()
```
  - getTutorialData
```
public TutorialData getTutorialData()
```
    Specified by:
    
    getTutorialData in interface DrawableGraphProblem
  - clearTutorial
```
public void clearTutorial()
```
  - performTutorialEvents
```
public boolean performTutorialEvents()
```
  - getMode
```
public Solution.Mode getMode()
```
  - setMode
```
public void setMode(Solution.Mode mode)
```
  - getBasePoints
```
public int getBasePoints()
```
  - getImprovementBonus
```
public int getImprovementBonus()
```
  - getHighScoreBonus
```
public int getHighScoreBonus()
```
  - getFirstTimeBonus
```
public int getFirstTimeBonus()
```
  - getOldHighScore
```
public int getOldHighScore()
```
  - getDifficultyLevel
```
public int getDifficultyLevel()
```
  - isShowIndices
```
public boolean isShowIndices()
```
    Specified by:
    
    isShowIndices in interface DrawableGraphProblem
  - setShowIndices
```
public void setShowIndices(boolean showIndices)
```
  - getEditorClassName
```
public java.lang.String getEditorClassName()
```
  - getInstanceClassName
```
public java.lang.String getInstanceClassName()
```
  - getPlayClassName
```
public java.lang.String getPlayClassName()
```
  - getThemeClassName
```
public java.lang.String getThemeClassName()
```
  - getHelpClassName
```
public java.lang.String getHelpClassName()
```
  - getEditHelpClassName
```
public java.lang.String getEditHelpClassName()
```
  - getPuzzleInstanceName
```
public java.lang.String getPuzzleInstanceName()
```
  - getEdgeDataClassName
```
public java.lang.String getEdgeDataClassName()
```
  - getFamilyName
```
public java.lang.String getFamilyName()
```
  - getVisibleSources
```
public java.util.ArrayList<Vertex> getVisibleSources()
```
    Specified by:
    
    getVisibleSources in interface DrawableGraphProblem
  - setVisibleSources
```
public void setVisibleSources(java.util.ArrayList<Vertex> visibleSource)
```
  - isVisibleSource
```
public boolean isVisibleSource(Vertex visibleSource)
```
  - isLowerScoreBetter
```
public boolean isLowerScoreBetter()
```
  - goToNextEvent
```
public void goToNextEvent()
```
  - sendAlgorithmResult
```
public void sendAlgorithmResult(boolean r)
```
  - getCurrentAnnotation
```
public java.lang.String getCurrentAnnotation()
```
  - getCurrentMoveOverview
```
public java.lang.String getCurrentMoveOverview()
```
  - getInterestingTutorialVertices
```
public java.util.ArrayList<Vertex> getInterestingTutorialVertices()
```
  - grossHistoryIteratorAtBeginning
```
public boolean grossHistoryIteratorAtBeginning()
```
  - getTopOfUndoStack
```
public Event<?> getTopOfUndoStack()
```
  - getCurrentUndoableEvent
```
public Event<?> getCurrentUndoableEvent()
```
  - grossHistoryIteratorAtEnd
```
public boolean grossHistoryIteratorAtEnd()
```
  - grossHistoryGetNextEvent
```
public Event<?> grossHistoryGetNextEvent()
```
  - grossHistoryNext
```
public Event<?> grossHistoryNext()
```
  - grossHistoryPrevious
```
public Event<?> grossHistoryPrevious()
```
  - grossHistoryDeleteLastEvent
```
public boolean grossHistoryDeleteLastEvent()
```
  - grossHistorySize
```
public int grossHistorySize()
```
  - grossHistoryToBeginning
```
public void grossHistoryToBeginning()
```
  - grossHistoryGetLastAddedEvent
```
public Event<?> grossHistoryGetLastAddedEvent()
```
  - grossHistoryToEnd
```
public void grossHistoryToEnd()
```
  - grossHistoryGetNextEventIndex
```
public int grossHistoryGetNextEventIndex()
```
  - grossHistoryIsSaved
```
public boolean grossHistoryIsSaved()
```
  - grossHistorySetSaved
```
public void grossHistorySetSaved(boolean saved)
```

Class PuzzleInstance

Constructor Summary

Method Summary

Methods inherited from class java.util.Observable

Methods inherited from class java.lang.Object

Constructor Detail

PuzzleInstance

Method Detail

isCurrentStateValidSolution

usesAlgorithms

updateStateBasedOnAlgorithmResult

isSolutionRefinable

getTryItInstanceForUseOnPlayScreen

tryItResultsAreBinding

isEventForThisPuzzleType

copyPuzzle

getScore

getProcessedSolution

getDefaultVertexDataObject

uniqueIdentifier

copyPuzzleSoItHasInitialStateTheSameAsMyCurrentState

restart

getGameName

getData

setData

setDefaultData

setGraph

setPuzzle

initialPuzzleDataToString

currentPuzzleDataToString

makeCurrentStateInitialState

stringToPuzzleData

setSolutionInformation

setSolutionData

resetVerticesToInitialLocations

clearHistory

disableHistory

enableHistory

getNumberOfMoves

getDiameter

getNumberOfVertices

getNumberOfEdges

getVertices

getVertexIndex

canUndo

canRedo

undo

forceRedo

redo

createNewVertexForPuzzle

addVertex

addGraphWithData

addGraph

getGraph

isTutorial

tutorialModeEnabled

convertMovesToTutorial

update

checkAndHandlePuzzleCompletion

runAlgorithms

runuTryIt

submit

endGame

startTimer

stopTimer

getTimeTaken

updateTimeTaken

recordGraphEvents

doNotRecordGraphEvents

getDescription

setDescription

getMessage

setMessage

isInReplayOrEditTutorialMode

setInReplayOrEditTutorialMode

sendMeaninglessEvent

performEvents

performEvents

setLocked

reallySetLocked