Sorry your browser is not supported!

[Serializable]
class PlayerData
{
    // These variables contain the position and rotation of our player
    public Vector3 pos;
    public Quaternion rot;

    // These variables contain the current score and lives
    public int score;
    public int lives;
    public int health;
    public int ammoCount;
    public int coinCount;
    public int carrotCount;

    // player's current level
    public string currentLevel;

    // Player's power ups
    public bool hasSwagger;
    public bool hasCarrotLauncher;
    public bool hasSuperJump;
    public bool hasDoubleSpeed;
}

    void SaveGame(string slot)
    {
        // first create a binary formatter and file stream
        BinaryFormatter bf = new BinaryFormatter();
        FileStream file = File.Create(Application.persistentDataPath + "/" + slot + "/save.jrg");

        // find the gameobject
        jackRabbit = GameObject.FindWithTag("Player");

        // now get the position and rotation of jackRabbit
        player.pos = jackRabbit.transform.position;
        player.rot = jackRabbit.transform.rotation;

        // now save it all!
        bf.Serialize(file, player);
        file.Close();
    }

/* ------------------------------------------------------------------------- */
static void
text_generate_mesh(struct context_t* context, struct text_t* text)
{
	const wchar_t* iterator;
	GLfloat dist_between_chars;
	GLfloat space_dist;
	GLfloat x, y;
	INDEX_DATA_TYPE base_index;

	/* start base index at 0 */
	base_index = 0;

	/* distance between characters */
	dist_between_chars = 3.0f / (GLfloat)window_width();
	space_dist = 20.0f / (GLfloat)window_width();

	/*
	 * If text is centered, figure out total width and set x coordinate
	 * accordingly. Otherwise just use x and y values passed in. */
	if(text->is_centered)
	{
		x = 0;
		for(iterator = text->string; *iterator; ++iterator)
		{
			struct char_info_t* info;

			/* the space character requires some extra attention */
			if(wcsncmp(iterator, L" ", 1) == 0)
			{
				x += space_dist;
				continue;
			}

			/* lookup character info */
			info = (struct char_info_t*)bstv_find(&text->group->char_info, (uint32_t)*iterator);
			if(!info)
			{
				char buffer[sizeof(wchar_t)+1];
				memcpy(buffer, iterator, sizeof(wchar_t));
				buffer[sizeof(wchar_t)] = '\0';
				llog(LOG_ERROR, context->game, PLUGIN_NAME, "Failed to look up character: \"%s\"", buffer);
				continue;
			}

			/* advance */
			x += info->width + dist_between_chars;
		}

		/* x is now the total width of the string in GL screen space. */
		x = text->pos.x - (x / 2.0f);
		y = text->pos.y;
	}
	else
	{
		x = text->pos.x;
		y = text->pos.y;
	}

	/* generate new vertices and insert into text vertex buffer */
	for(iterator = text->string; *iterator; ++iterator)
	{
		struct char_info_t* info;
		struct vertex_quad_t* vertex;

		/* the space character requires some extra attention */
		if(wcsncmp(iterator, L" ", 1) == 0)
		{
			x += space_dist;
			continue;
		}

		/* lookup character info */
		info = (struct char_info_t*)bstv_find(&text->group->char_info, (uint32_t)*iterator);
		if(!info)
		{
			char buffer[sizeof(wchar_t)+1];
			memcpy(buffer, iterator, sizeof(wchar_t));
			buffer[sizeof(wchar_t)] = '\0';
			llog(LOG_ERROR, context->game, PLUGIN_NAME, "Failed to look up character: \"%s\"", buffer);
			continue;
		}

		/* top left vertex */
		vertex = (struct vertex_quad_t*)ordered_vector_push_emplace(&text->vertex_buffer);
		vertex->position[0]  = x;
		vertex->position[1]  = y - info->bearing_y;
		vertex->tex_coord[0] = info->uv_left;
		vertex->tex_coord[1] = info->uv_top;

		/* top right vertex */
		vertex = (struct vertex_quad_t*)ordered_vector_push_emplace(&text->vertex_buffer);
		vertex->position[0]  = x + info->width;
		vertex->position[1]  = y - info->bearing_y;
		vertex->tex_coord[0] = info->uv_left + info->uv_width;
		vertex->tex_coord[1] = info->uv_top;

		/* bottom left vertex */
		vertex = (struct vertex_quad_t*)ordered_vector_push_emplace(&text->vertex_buffer);
		vertex->position[0]  = x;
		vertex->position[1]  = y - info->bearing_y - info->height;
		vertex->tex_coord[0] = info->uv_left;
		vertex->tex_coord[1] = info->uv_top + info->uv_height;

		/* bottom right vertex */
		vertex = (struct vertex_quad_t*)ordered_vector_push_emplace(&text->vertex_buffer);
		vertex->position[0]  = x + info->width;
		vertex->position[1]  = y - info->bearing_y - info->height;
		vertex->tex_coord[0] = info->uv_left + info->uv_width;
		vertex->tex_coord[1] = info->uv_top + info->uv_height;

		/* generate indices */
		*(INDEX_DATA_TYPE*)ordered_vector_push_emplace(&text->index_buffer) = base_index + 0;
		*(INDEX_DATA_TYPE*)ordered_vector_push_emplace(&text->index_buffer) = base_index + 2;
		*(INDEX_DATA_TYPE*)ordered_vector_push_emplace(&text->index_buffer) = base_index + 1;
		*(INDEX_DATA_TYPE*)ordered_vector_push_emplace(&text->index_buffer) = base_index + 1;
		*(INDEX_DATA_TYPE*)ordered_vector_push_emplace(&text->index_buffer) = base_index + 2;
		*(INDEX_DATA_TYPE*)ordered_vector_push_emplace(&text->index_buffer) = base_index + 3;

		x += info->width + dist_between_chars;
		base_index += 4;
	}

	/* let text group about mesh update */
	text_group_inform_updated_text_object(text->group);
}

using UnityEngine;
using System;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

public class StateMachine : MonoBehaviour
{
    // first create a new player object
    PlayerData player = new PlayerData();

    // set up our instance variable
    private static StateMachine instance;

    // start the statemachine if one doesn't exist already
    public static StateMachine Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new GameObject("StateMachine").AddComponent<StateMachine>();
            }

            return instance;
        }
    }

    /* -----------------------------------------------------------
     * The following methods save, load, or create a new game
     * depending on what the player has clicked on from the 
     * main menu
     * ---------------------------------------------------------- */
    void NewGame() // Starts a new game instance!
    {
        // first set up default values for the player object
        player.score = 0;
        player.health = 100;
        player.lives = 3;
        player.ammoCount = 0;
        player.coinCount = 0;
        player.carrotCount = 0;
        player.hasCarrotLauncher = false;
        player.hasSwagger = false;
        player.hasSuperJump = false;
        player.hasDoubleSpeed = false;
        player.currentLevel = "demo";

    }

    void SaveGame(string slot) // This save's the player's current progress
    {
        // first create a binary formatter and file stream
        BinaryFormatter bf = new BinaryFormatter();
        string fileName = Application.persistentDataPath + "/" + slot + "/" + slot + ".jrg";
        FileStream file = File.Create(fileName);

        // now save it all!
        bf.Serialize(file, player);
        file.Close();
    }

    void LoadGame(string slot) // Load a previous instance of the game into memory
    {
        string fileName = Application.persistentDataPath + "/" + slot + "/" + slot + ".jrg";
        if (File.Exists(fileName))
        {
            BinaryFormatter bf = new BinaryFormatter();
            FileStream file = File.Open(fileName, FileMode.Open);

            // now cast the data back into the player object
            PlayerData player = (PlayerData)bf.Deserialize(file);
            file.Close();
        }
    }

    /* -----------------------------------------------------------
     * These methods get and set the properties of the player
     * 
     * --------------------------------------------------------- */

    // Health
    void SetHealth(int amount)
    {
        player.health += amount;
    }

    int GetHealth()
    {
        return player.health;
    }

    // Lives
    void SetLives(int amount)
    {
        player.lives += amount;
    }

    int GetLives()
    {
        return player.lives;
    }

    // Ammo
    void SetAmmo(int amount)
    {
        player.ammoCount += amount;
    }

    int GetAmmo()
    {
        return player.ammoCount;
    }

    // Coins
    void SetCoins(int amount)
    {
        player.coinCount += amount;
    }

    int GetCoins()
    {
        return player.coinCount;
    }

    // Carrots
    void SetCarrots(int amount)
    {
        player.carrotCount += amount;
    }

    int GetCarrots()
    {
        return player.carrotCount;
    }

    // Score
    void SetScore(int amount)
    {
        player.score += amount;
    }

    int GetScore()
    {
        return player.score;
    }

    // Swagger
    void SetSwagger(bool state)
    {
        player.hasSwagger = state;
    }

    bool GetSwagger()
    {
        return player.hasSwagger;
    }

    // Double Speed
    void SetDoubleSpeed(bool state)
    {
        player.hasDoubleSpeed = state;
    }

    bool GetDoubleSpeed()
    {
        return player.hasDoubleSpeed;
    }

    // Super jump
    void SetSuperJump(bool state)
    {
        player.hasSuperJump = state;
    }

    bool GetSuperJump()
    {
        return player.hasSuperJump;
    }

    // Carrot Launcher
    void SetCarrotLauncher(bool state)
    {
        player.hasCarrotLauncher = state;
    }

    bool GetCarrotLauncher()
    {
        return player.hasCarrotLauncher;
    }
}

// This is the class that contains all of the data for our player
[Serializable]
class PlayerData
{
    // These variables contain the position and rotation of our player
    public Vector3 pos;
    public Quaternion rot;

    // These variables contain the current score and lives
    public int score;
    public int lives;
    public int health;
    public int ammoCount;
    public int coinCount;
    public int carrotCount;

    // player's current level
    public string currentLevel;

    // Player's power ups
    public bool hasSwagger;
    public bool hasCarrotLauncher;
    public bool hasSuperJump;
    public bool hasDoubleSpeed;
}