THIS IS AN EARLY EXPERIMENTAL VERSION AND LIKELY CONTAINS BUGS. USE AT YOUR OWN DISCRETION.
Currently, it should only be used for smaller projects.
Documentation can be found in the 'Create Event' of obj_PersistentManager.

-------------------------
HTML5 DEMO
...
.gmz Example Project DOWNLOAD ** Open using GameMaker's 'Import' menu.
...
obj_PersistentManager.object.gmx DOWNLOAD ** Right-Click -> Save Link As **
-------------------------

PersistGMS provides a foundation for custom room persistence in GameMaker. It is designed to be easy to use. Simply add the objects you want to remain persistent for each room to a list contained in obj_PersistentManager. For now, only the x/y values of persistent objects are recorded, but this can easily be extended to suit specific needs.

Feel free to check out the example project, or download and directly import obj_PersistentManager.object.gmx into your own project. There is no need to download additional scripts or .dll files.

Designed to work across all target platforms (Windows, Mac, Linux, iOS, Android, HTML5).
Feel free to report any bugs or design issues you face.

Persistent Action!

Puzzles for the win!

For February's OneGameAMonth entry, I decided to dedicate my time on finishing up a project I started over a year and a half ago. 1GAM has become a great facilitator in helping me stay motivated and simply get things done.

Sync Labs originally started from a small puzzle game I completed called Spawner for a Game Jam I participated in almost 2 years ago. Ever since that time, I have been meaning to extend the idea and create something more complete.

Sync Labs is currently available on:

Web HTML5 ->Play Now
Android Google Play-> Full Version - Free Lite Version
Kindle Fire -> Amazon
iOS -> iTunes

[Game Description]
Welcome to Sync Labs, a place infamous for clone experimentation and questionable ethics.

As Subject 227, an oddly cheery blob, you must skillfully complete the many tests prepared for you and the clones designed to copy your every move. Success will demand perfect collaboration in activating all sync pads placed throughout each lab.

In the experiments, you will find boulders, moving platforms, brain-reversing devices, teleporters and more!

Sound easy? Think again!

Features:
- Unique puzzle experience
- 45 levels across 5 sectors
- 8-bit inspired graphics based on NES palette
- Interactive environments

Its a bit hectic

I recently finished my first entry, Battle Blocks, for One Game a Month. At one point, it seemed that I wouldn't be able to finish before the end of January, but applying a lot of KISS solved that problem. I am looking forward to working on another game for February. I still have to play with some ideas. Again, it will need to be something simple.

I must note that the community around 1GAM has been great. There is lots of activity, especially on Twitter, where many people are sharing and supporting one another. It will be interesting to see the result of this whole experiment by the end of the year!

Anyhow, here is some info for Battle Blocks:

HTML5 Version -> Play Now
Android Versions -> Google Play or Direct Download
iOS Version -> iTunes

Description:
They are coming!
The four sided foes have gathered their numbers and are ready to strike!
How long can you survive the perpetual onslaught of merciless blocks?

As the last surviving triangle, you must shoot wave after wave of incoming squares as they attempt to reinforce their numbers and conquer the screen.
Collect power ups to assist you in fighting back the enemy and to obtain the top score.

Features colorful graphics, rad music and fast paced combat!
Now, doesn't that sound great? I know, I know... its awesome+1!

Tween with Ease! *sigh*

Download: TweenGMS v0.88

HTML5 Example Demo

TweenGMS is an automated tweening system for GameMaker:Studio. It can be used for easing character/camera movements, fades, rotations, animations, and much more.

This system is still relatively new and may contain a few bugs. Feel free to report any issues you have with TweenGMS or to leave feedback on how it could be made better.

You can also check out TweenGMS in action with Battle Blocks / Sync Labs / Candy Crash.

[Features]
- No DLL required. (Uses GEX)
- Easy setup and management of numerous tweens
- Works across all target modules (Windows, Mac, iOS, Android, HTML5, Linux)
- Persistent tweens for persistent objects
- Optimized code supplying fast performance
- Ability to assign tweens to designated groups for increased control

[Example Code]
// ** Create Event ** //
// Create automated tween references
tween_x = TweenCreate(id);
tween_y = TweenCreate(id);

// Ease instance's x/y position from (0, 0) to (640, 480) over 60 steps
TweenPlayOnce(tween_x, x__, 0, 640, 60, EASE_IN_OUT_QUAD);
TweenPlayOnce(tween_y, y__, 0, 480, 60, EASE_IN_OUT_QUAD);

// Pause active automated tween
TweenPause(tween_x);

// Stop active automated tween
TweenStop(tween_y);

// Resume paused automated tween
TweenResume(tween_x);

[Update Notes]
- Major update to shared_Tweener object -->> **REPLACE PREVIOUS VERSION**
* Faster
* More stable
* Fixed potential memory leaks
* STRONGER!

- Added Simple Tween Functions
*TweenSimpleMove()
*TweenSimpleScale()
*TweenSimpleFade()
*... etc ...

- Deactivated instances now retain their automated tween.
*Tween is automatically paused when instance is deactivated.
*Tween is automatically resumed when instance is activated.

- Not advised, but shared_Tweener can now be safely deactivated.(Will stop all tweens from running)
*Make sure to use --> instance_activate_object(shared_Tweener) <-- if you use mass deactivation functions.

- Changed included property setters x__Rounded/y__Rounded to x__int/y__int, respectively.

- Cut down TweenSetOnBoundary() to 2 scripts. Now use TArgs() to pass arguments.

* TweenSetOnBoundary()
* First version takes a single script constant.
* TweenSetOnBoundary(tween, KillPlayer);

* TweenSetOnBoundaryArgs() --> TArgs() utility script must be included to use this function
* Second version takes a script constant AND uses TArgs() utility script to pass arguments.
* TweenSetOnBoundaryArgs(tween, SuperMessageScript, TArgs("Your score is ", myScore));

- TweenSetVariableSetter() has been changed to TweenSetProperty()

- TweenGetVariableSetter() has been changed to TweenGetProperty()

If you feel so inclined, you may support TweenGMS by giving funds through PayPal to stephen@8bitwarrior.com

Description:
It is Halloween night!
Well past your bedtime, you have landed the biggest score of candy ever. However, on your way back home, you have tripped and spilled your candy all over. Already high on too much sugar, your imagination goes wild as you find yourself caught in a monster mash.

You must recover as much candy as you can before you are overcome by your wild fears of ghosts, ghouls, vampire bats and spooky graveyards.

Features:
Local Scoreboard
Solid Touch Controls
Fun Challenging Atmosphere
A Kid in a Ninja Costume!
Pumpkins and Jack-o'-lanterns!

HTML5 Version
Play Now

Available for Android devices via
Google Play
Amazon.com
Direct APK download

Available for iOS devices via
iTunes

Available for Windows via
Direct Download

Available for Mac via
Direct Download

I just finished the more refined version with GameMaker:Studio for Android devices. I can't say enough about how much easier GameMaker makes things for development. I also hope to have Drop Cube submitted to iOS devices in short order.

Available on Google Play:
Paid Version / Free Version

Game Description:

Drop Cube will put your reflexes and steady hand to the test. Utilize refined tilt controls to dodge obstacles as you free fall increasingly faster towards terminal velocity.

Choosing the safer route will keep you in action longer, but greater risk garnishes greater reward. Find out how your skills stack up with Drop Cube!

Features:
- Responsive Tilt Controls
- Local Scoreboard
- Risk Based Scoring
- No Splash Screens!
- Retro Themed Music

To the book's credit, I never felt like it was swamping me with too much information at once. It stayed reasonably comfortable to follow along with and had me never feeling completely lost. But again, the general topics covered seemed to jump around with little warning, at times feeling like a wild ride through someone's last minute check list. I had a difficult time anticipating where the instructions were going to inevitably lead me, and it offered myself only a slight sense of being an active participator in its exercises.

An example to help relate the book's textual inconsistency is revealed by the fact that quiz questions are given at the end of the first two chapters but fail to appear in the following chapters. This may seem trivial, but it is an odd pattern to begin with and to suddenly drop. And just so everyone knows, I love quiz questions at the end of a chapter! :D

I wish the book spent less time on how to use third party plugins and more time going through real world examples of how to achieve varied control styles or game mechanics tailored for iOS devices. I believe it could have benefited from including such a topic as raycasting, something which I considered vital for my own projects, as the iOS version of Unity does not recognize user input on game objects like the PC or Mac version. For example, the OnMouseDown() callback is not recognized on game objects for iOS, thus requiring raycasting to be used inorder to directly interact with objects when touched.

I found too many subjects just briefly touched upon. Some chapters have a sense of being incomplete and not following through with teaching the functionality promised in the book's advertisement. I wouldn't be so bothered by this fact if the book didn't advertise itself with overhyped expectations.

Being somewhat of an experienced Unity user, I was satisfied with some useful morsels of information which I gleaned from this book, but I am glad that I have the experience already behind me to fill in the blanks that I felt were missing on some subjects.

If you are a fledgling beginner with Unity and iPhone development, this book might be okay to start with. Despite its shortcomings, I still found myself able to get through it quite easily and learn some new things along the way. But, don't expect it to make you a whiz or even leave you with a well rounded knowledge of Unity basics. Expect further books, tutorials, and hands on experience to fill in the other basic concepts you will need to know along your adventures.

Book's official site

FINAL VERDICT: 5/10

[Windows]
Part 3 Editable Project Download

[Mac]
Part 3 Editable Project Download (Slightly outdated)

If you have not already done so, I highly suggest going through parts 1 and 2 of this series first, as this lesson will be based upon their existing code.

Part 1: The Basics
Part 2: Collision Detection

Welcome to part 3 of my series on Grid Based Movement for Game Maker!
In this lesson, we are going to look at implementing character animation for our player object. There are a few ways to go about doing this with Game Maker, but today I will teach one of the techniques which I prefer and continue to use myself.

The result of this lesson should look like this: Grid Animation Example

Alright, onto the Lesson!
First, lets get ourselves some sprite strips to work with. Go ahead and download the following files to use for our lesson. You can use your own if you like, but note that you will likely need to make minor adjustments to the example code if you do so.

Sprite Strip 1
Sprite Strip 2
(Big thanks to Cody Penner for the sprites! )

For this lesson, we are going to continue where we left off from Part 2: Collision Detection. You can download the completed editable project for that lesson here: Part 2 Project Download

With our existing project from Part 2, add the new sprite strips to the Sprites folder.
The first 4 images of the sprite strip are for the standing "animations", one for each direction. Following them are the walking frames for all 4 directions containing 4 images for each animation.

Noting the placement, order and length of our images/animations within the sprite strip is important. We will be using this information to properly set up our animations for our player object. Be aware that the numerical values of the images in the strip are zero-based. This means that 0 refers to the first image, 1 to the second, 2 to the third, and so on. We can explicitly change an instance's displayed image at runtime by modifying its built in image_index variable, setting it to the appropriate offset we want, relevant to the current sprite strip. Soon, you will see how this is used to create smooth walking/standing animations for our grid based movement system.

Before doing anything else, open up the properties for obj_player and change Sprite to one of the sprites we just imported.

Within obj_player, highlight the Create Event and open the existing Execute Code action.
Below the already existing code in our action, insert the new variables we will use to support our animation system.

// ...PREVIOUS OLDER CODE

    // We will now keep track of our direction
direction = 270;
    // Used to help set standing animations
justStoppedMoving = true;

    // Initialize animation properties
animIndex = 0;         // first frame in current animation
animLength = 0;        // current animation length in frames
animSpeed = 0;         // current animation speed
animIndexRelative = 0; // relative from first frame of animation

    // Set animation length properties
animLengthStanding = 1;
animLengthWalking  = 4;

// Set animation speed properties
animSpeedStanding  = 0.0;
animSpeedWalking   = 0.2;

    // Standing animation index offsets
animIndexStandRight = 0;
animIndexStandUp    = 1;
animIndexStandLeft  = 2;
animIndexStandDown  = 3;

    // Walking animation index offsets
animIndexWalkRight = 4;
animIndexWalkUp    = 8;
animIndexWalkLeft  = 12;
animIndexWalkDown  = 16;

Because we want our character facing downward at the start, we will set direction to 270
As a refresher: right = 0, up = 90, left = 180, down = 270
We have also created a new variable justStoppedMoving which will enable us to easily manage code for when our player stops walking. This can be helpful for setting standing animations.

Following that, we have initialized some required properties to make our animation system work. animIndex, animLength, animSpeed and animIndexRelative hold the status of the active animation.
animIndex receives the value of the first frame in the animation we want to use. We can easily assign it one of the animation indexes we have created, such as animIndexWalkRight.
animLength holds the length of the current animation in frames. We will assign in the value from either animLengthStanding or animLengthWalking.
animSpeed is simply how fast our animation will animate. Make sure to keep the value relatively small. We will assign it the value held by animLengthStanding or animLengthWalking.
Finally, we initialized animIndexRelative. This variables holds the current animation's frame value relative to its starting animIndex frame. It will allows us to repeatedly cycle through and select the appropriate frames needed for each animation.

With that set up, we are now going to set up a script so that we can comfortably change the required properties needed to set up the appropriate animations we want.

In GameMaker's 'Scripts' folder, create a new script called 'SetAnimation'
Inside this script, go ahead and input the following code:

animIndex = argument0;
animLength = argument1;
animSpeed = argument2;

This script takes 3 arguments. It will be used to change our animation Index, Length, and Speed.
With that inputted, close it up and once again open the properties for obj_player.

We are now going to add the code which will make our animation system work. But we are not going to add it to the Normal Step Event. Instead, we will add an End Step Event, and place our code inside there. By placing our animation system here, we separate it from our Normal Step Event code, ensuring the intended animations are drawn after all our other updates are finished.

Inside the End Step event, add a new action -> Execute Code. Inside this code action, place the following:

image_index = animIndex + animIndexRelative;
animIndexRelative += animSpeed;

if  (animIndexRelative >= animLength)
{
    image_index = animIndex;
    animIndexRelative = 0;
}

With that code in place, the animation will always be within our set boundaries.
As long as we use the SetAnimation script, we can be certain that our animation system will function properly.

We are now going to return to the Normal Step event for obj_player and edit the existing code action.
We will start by adding a new line at the bottom of our existing code for when our character has just stopped moving.
Add the line of code where it is commented: // *** NEW CODE ***

//... OTHER CODE

if (isMoving == true)
{
    x += speedX;
    y += speedY

    moveTimer -= moveSpeed;
    if (moveTimer)
    {
        isMoving = false;
        justStoppedMoving = true; // *** NEW CODE ***
    }
}

We can now return to the top of the code action and utilize the justStoppedMoving variable to set standing animations when our player finishes walking.

    
    // Set standing animations if just stopped
if (justStoppedMoving == true)
{
    justStoppedMoving = false;

        // Set appropriate standing animations
    if (direction == 0)
        SetAnimation(animIndexStandRight, animLengthStanding, animSpeedStanding);
    else
    if (direction == 90)
        SetAnimation(animIndexStandUp, animLengthStanding, animSpeedStanding);
    else
    if (direction == 180)
        SetAnimation(animIndexStandLeft, animLengthStanding, animSpeedStanding);
    else
    if (direction == 270)
        SetAnimation(animIndexStandDown, animLengthStanding, animSpeedStanding);
}

    // ... Other Code

Based upon the character's current direction, we have effectively set the appropriate standing animation. But up until this point, we haven't written any code to change the character's direction or set a walking animation.

Just below the code we wrote, we will modify the existing code within the keyboard_key() check statements to include an updated direction. We will also set the appropriate walking animation when our player is able to move.
Go ahead and modify our existing code to include keeping track of our current direction, as well as setting the appropriate animations. Note that this code will also set an appropriate standing animation if the player is blocked and unable to move. This allows the player to allows face the direction they intend to.

if (isMoving == false)
{
         // Perform 4 direction keyboard and grid checks
         // for setting appropriate movement and animation
    if (keyboard_check(vk_right))
    {
        direction = 0; // Keep track of new direction

        if (obj_grid.cells[(x div 32) + 1, y div 32] == 0)
        {
            isMoving = true;      // Lets start moving
            moveTimer = gridSize; // Ready moveTimer for countdown
            speedX = moveSpeed;   // Set horizontal speed
            speedY = 0;           // Set vertical speed
            SetAnimation(animIndexWalkRight, animLengthWalking, animSpeedWalking);
        }
        else
        {       // Set standing anim for new direction
            SetAnimation(animIndexStandRight, animLengthStanding, animSpeedStanding);
        }
    }
    else
    if (keyboard_check(vk_up))
    {
        direction = 90;

        if (obj_grid.cells[x div 32, (y div 32) - 1] == 0)
        {
            isMoving = true;
            moveTimer = gridSize;
            speedX = 0;
            speedY = -moveSpeed;
            SetAnimation(animIndexWalkUp, animLengthWalking, animSpeedWalking);
        }
        else
        {
            SetAnimation(animIndexStandUp, animLengthStanding, animSpeedStanding);
        }
    }
    else
    if (keyboard_check(vk_left))
    {
        direction = 180;

        if (obj_grid.cells[(x div 32) -1, y div 32] == 0)
        {
            isMoving = true;
            moveTimer = gridSize;
            speedX = -moveSpeed;
            speedY = 0;
            SetAnimation(animIndexWalkLeft, animLengthWalking, animSpeedWalking);
        }
        else
        {
            SetAnimation(animIndexStandLeft, animLengthStanding, animSpeedStanding);
        }
    }
    else
    if (keyboard_check(vk_down))
    {
        direction = 270;

        if (obj_grid.cells[x div 32, (y div 32) + 1] == 0)
        {
            isMoving = true;
            moveTimer = gridSize;
            speedX = 0;
            speedY = moveSpeed;
            SetAnimation(animIndexWalkDown, animLengthWalking, animSpeedWalking);
        }
        else
        {
            SetAnimation(animIndexStandDown, animLengthStanding, animSpeedStanding);
        }
    }
    // ... OTHER CODE
}

With that code in place, we now have a functioning animation system where the character will animate according to our set parameters determined by the sprite strip.
A benefit to this animation system is that sprite strips, which share the same animation parameters, can be swapped at any time with ease! Simply change the character's sprite_index and the change will be immediately reflected, no matter what state the character is in!

If you want to have your standing animations the same as your walking animations (think Dragon Warrior/Quest), then simply change the standing properties to be the same as the walking animation properties, and you're good to go!

If you have any questions or suggestions, I would love to hear from you!
And if you're on Twitter, find me at @Nehemius