Sorry your browser is not supported!

// for example if you had 10 tiles and used undo on them all
for(int i = 10; i > 0; --i)
{
    // logic here to re do the tiles
}
// this way it would be putting them back in reverse order if you get me!! Again I could be wrong but it seems logical in my head lol

// Project: Yoda - Test 
// Created: 2016-01-09

// set window properties
SetWindowTitle( "Yoda - Test" )
//Keep Track of how many tiles are on screen//
//Tile# is to keep track of the tile you are currently placing on screen//
//It must be defined as an integer because you are using it to keep track of an array//
//Im weird and like to use # at the end of all my variables//
Tile# as Integer
Tile# = 0
//MaxTile# is used to keep track of the max # of tiles you have placed on the screen//
//So you can redo there positions and not excede the array data that has been stored//
MaxTile# = 0
//////////////////////////////////////////////

//Create a type to store your tiles data//
Type Data
	SpriteID as Integer
	XPos# as Float
	YPos# as Float
	//This would be for storing your image ids so you know what image to assign the sprite.
	//We are not using any images right now so it will not be used.
	//I am also not going to get into changing the tiles image to be displayed on the pointer.
	//We are just using a blank white sprite for now.
	ImageID as Integer
	EndType
	/////////////////////////////////////////////////////////////////////////////////////////
	
	//Create your Data Type as an Array//
	Global Sprite As Data[1000]
	/////////////////////////////////////



// set display properties//
SetDisPlayAspect(-1)
//////////////////////////

//Create the display sprite to be positioned on Pointer X / Y
PointerImage = CreateSprite(0)
SetSPriteSize(PointerImage,4,-1)
//////////////////////////////////////////////////////////////


do

	MouseX# = GetPointerX()
	MouseY# = GetPointerY()
	
	//Set the tile on the pointer location//
	SetSpritePosition(PointerImage,MouseX#,MouseY#)
	
	
	//When the mosue is pressed create our sprite and store the data in our Sprite Type. //
	If GetPointerPressed()
		Tile# = Tile# + 1
		MaxTile# = MaxTile# + 1
        Sprite[Tile#].SpriteID = CreateSprite(0)
        SetSpriteSize(Sprite[Tile#].SpriteID ,4,-1)
        SetSpritePosition(Sprite[Tile#].SpriteID ,MouseX#,MouseY#)
        
        //The Sprite ID was stored when the sprite was created. Also positiononed on the screen//
        //Here is where the Xpos / Ypos positions will be stored in our type. To read / Write later//
        //It is also stored here so we can redo for future purposes//
        //If you were using diff type images you would also store the image id here//
        Sprite[Tile#].Xpos# = MouseX#
         Sprite[Tile#].Ypos# = MouseY#

        endif
        
        
        //This is where you delete / undo the sprite you have created with the (Z key)//
        //The reason we only erase the spriteid is because. When it is created again. It will just be written over.//
        //There for by not erasing it we have it stored to recreate with a redo function//
        If GetRawKeyPressed(90) = 1 and Tile# > 0			
			DeleteSprite(Sprite[Tile#].SpriteID)
			Tile# = Tile# - 1
			endif
			
			
			//This is where you can redo the sprite positions with the (R Key)//
			//You need to add 1 to the Tile# to create the new sprite. So you are not writing over already used data//
			//Create the sprite / position it at the old X and Y positions that is stored in your Sprite Data Type//			
		If GetRawkeyPressed(82) = 1 and Tile# <= MaxTile# - 1
			Tile# = Tile# + 1			
			Sprite[Tile#].SpriteID = CreateSprite(0)
			SetSpriteSize(Sprite[Tile#].SpriteID,4,-1)
			SetSpritePosition(Sprite[Tile#].SpriteID,Sprite[Tile#].Xpos#,Sprite[Tile#].Ypos#)
			endif
		
			
			
   

    Print( ScreenFPS() )
    Sync()
loop

// This file is for undoing and redoing actions in the editor

// First set up a type which will store the data
Type undoData
	actionType as integer
	
	tileID as integer
	tileX as integer
	tileY as integer
	tileType as integer
	lastX as integer
	lastY as integer
EndType

// Create the undo and redo list
Global UndoStack as undoData[]
Global RedoStack as undoData[]
Global copyData as undoData

// Define some constants
#Constant TILE_PLACED = 1
#Constant TILE_DELETED = 2


// Add the last performed action to the Undo Stack
Function AddToUndoStack(actionType as integer)
	// Create a local undo object
	local undo as undoData
	
	// Store the action type
	undo.actionType = actionType
	
	// Store the id#
	undo.tileID = copyData.tileID
	
	// store the position
	undo.tileX = copyData.tileX
	undo.tileY = copyData.tileY
	undo.tileType = copyData.tileType
	undo.lastX = copyData.lastX
	undo.lastY = copyData.lastY
	
	// insert object into undo stack
	UndoStack.insert(undo)
EndFunction

// Add the last undone action to the Redo Stack
Function AddToRedoStack()
	// create a local redo object
	local Redo as undoData
	
	// Get the last action that was performed
	i = UndoStack.length
	
	// copy the values from the undo stack
	Redo.actionType = UndoStack[i].actionType
	Redo.tileID = UndoStack[i].tileID
	Redo.tileType = UndoStack[i].tileType
	Redo.tileX = UndoStack[i].tileX
	Redo.tileY = UndoStack[i].tileY
	Redo.lastX = UndoStack[i].lastX
	Redo.lastY = UndoStack[i].lastY
	
	// insert into redo stack
	RedoStack.insert(Redo)
EndFunction

// Undo function
Function Undo()
	// First determine what the last action taken was
	i = UndoStack.length

	// undo the last action
	Select UndoStack[i].actionType
		Case TILE_PLACED:
			// delete the sprite
			DeleteSprite(UndoStack[i].tileID)
		
			// Clear the map tileExists flag at this point
			map[UndoStack[i].lastX, UndoStack[i].lastY].tileExists = 0
			
		EndCase
		
		Case TILE_DELETED:
			// Recreate the sprite
			img = UndoStack[i].tileType
			map[UndoStack[i].lastX, UndoStack[i].lastY].tileExists = 1
			map[UndoStack[i].lastX, UndoStack[i].lastY].tileID = CreateSprite(img)
			SetSpritePosition(map[UndoStack[i].lastX, UndoStack[i].lastY].tileID, UndoStack[i].tileX, UndoStack[i].tileY)
		EndCase
	EndSelect
	
	// Copy over to the redo stack
	AddToRedoStack()
	
	// Delete this element of the array
	UndoStack.remove(i)
EndFunction

// Redo Function
Function Redo()
	// determine what to do 
	i = RedoStack.length

	Select RedoStack[i].actionType
		Case TILE_PLACED:
			// recreate the sprite
			img = RedoStack[i].tileType
			map[RedoStack[i].lastX, RedoStack[i].lastY].tileExists = 1
			map[RedoStack[i].lastX, RedoStack[i].lastY].tileID = CreateSprite(img)
			SetSpritePosition(map[RedoStack[i].lastX,RedoStack[i].lastY].tileID, RedoStack[i].tileX, RedoStack[i].tileY)			
		EndCase
		
		Case TILE_DELETED:
			// delete the sprite
			DeleteSprite(RedoStack[i].tileID)
		
			// Clear the map tileExists flag at this point
			map[RedoStack[i].lastX, RedoStack[i].lastY].tileExists = 0
			Print("Am I Gone?")
		EndCase
	EndSelect
	
	// Copy this info over to our copyData object
	copyData.actionType = RedoStack[i].actionType
	copyData.tileID = map[RedoStack[i].lastX, RedoStack[i].lastY].tileID
	copyData.tileX = map[RedoStack[i].lastX, RedoStack[i].lastY].tileX
	copyData.tileY = map[RedoStack[i].lastX, RedoStack[i].lastY].tileY
	copyData.tileType = map[RedoStack[i].lastX, RedoStack[i].lastY].tileType
	copyData.lastX = RedoStack[i].lastX
	copyData.lastY = RedoStack[i].lastY
	
	// Add to the undo stack
	AddToUndoStack(copyData.actionType)
		
	// Delete this element of the array
	RedoStack.remove(i)
EndFunction

Function NewAction()
	// Delete any elements in the redo list
	If RedoStack.length > -1 
		RedoStack.length = -1
	EndIf
EndFunction