Memory Windows Kids Education Game | Unity Complete Project for Android And iOS

Introduction:

Welcome to the comprehensive tutorial on how to use the Memory Windows Kids Education Game | Unity Complete Project for Android and iOS! This tutorial is designed to guide you through the process of creating a engaging and educational mobile game for kids, targeting Android and iOS platforms, using Unity as the development engine.

The Memory Windows Kids Education Game is an interactive learning experience that combines the classic memory game concept with educational content, ensuring that kids have fun while learning. The game targets children aged 4-8 years old, who are learning basic shapes and colors. The game involves matching identical shapes and colors, promoting cognitive development and improving memory skills.

As we walk through this tutorial, we will cover the step-by-step process of using the Unity Complete Project package to develop the game. You will learn how to:

1. Set up the Unity project and add the game assets.
2. Configure the game settings, including graphics, audio, and controls.
3. Implement the game logic using Unity's scripting language.
4. Test and iterate the game to ensure high-quality performance.
5. Deploy the game on Android and iOS platforms.

Let's get started!

Tutorial:

Step 1: Setting up the Unity Project

1. Go to the Unity Hub website (<https://unity3d.com/get-unity >) and download the latest version of Unity Hub (Unity Hub is a user-friendly application that allows you to manage multiple versions of Unity).
2. Install Unity Hub on your computer. Once installed, open it and click on the "+" button to create a new project.
3. Give your project a name and choose a location to store it. Select "Unity" as the project template and "3D" as the game type (although our game is primarily 2D, setting it to 3D won't affect the result).
4. Choose your Unity version and select a license type (personal, educational, or commercial, depending on your needs).

Step 2: Adding Game Assets

1. In the Unity Project window, navigate to Assets > Import Package and select the Samples folder from the ZIP file provided with the Complete Project package.
2. Select the Prefabs folder and import it into your project. These prefabs contain the 3D models and objects used in the game.

Step 3: Configuring Game Settings

1. In the Project Settings window (Edit > Project Settings or press Ctrl + Shift + P on Windows or Cmd + Shift + P on Mac), navigate to Graphics.
2. Change the Graphics Resolution to 1080 x 1920 or a resolution of your preference.
3. Set Quality to Balanced or High for better graphics rendering.
4. Navigate to Audio and select a suitable audio format. For this tutorial, use the default MP3 format.

Step 4: Implementing Game Logic

1. In the Unity Editor, navigate to Assets > Scripts and create a new C# script.
2. Name the script MemoryGameController. Double-click on the file to open it in MonoDevelop or Visual Studio, and add the following code:

using UnityEngine;
using UnityEngine.EventSystems;

public class MemoryGameController : MonoBehaviour
{
    public GameObject[] cells;
    public int gridWidth = 3;
    public int gridHeight = 3;
    public string[] shapesAndColors = new string[6] { "GreenSquare", "RedSquare", "BlueTriangle", "YellowTriangle", "GreenCircle", "BlueCircle" };
    private int[,] grid = new int[gridWidth, gridHeight];
    private int correctMatches = 0;

    private void Start()
    {
        // Initialize the grid and set random shapes and colors
        for (int i = 0; i < gridWidth; i++)
        {
            for (int j = 0; j < gridHeight; j++)
            {
                int num = Random.Range(0, shapesAndColors.Length);
                grid[i, j] = num;
            }
        }
        ShuffleGrid();
    }

    private void ShuffleGrid()
    {
        // Perform a Fisher-Yates shuffle algorithm to randomize the cell order
        for (int i = 0; i < grid.Length; i++)
        {
            int j = Random.Range(0, grid.Length - i);
            int temp = grid[j, 0];
            grid[j, 0] = grid[i, 0];
            grid[i, 0] = temp;
        }
    }

    private void OnMouseDown()
    {
        // Check if two cells are clicked simultaneously (used for multi-touch Android devices)
        if (Input.touchCount > 1)
        {
            Vector3 pos1 = RaycastToCell();
            Vector3 pos2 = RaycastToCell(1);
            if (pos1!= Vector3.zero && pos2!= Vector3.zero)
            {
                int cell1 = getCellIndex(pos1.x, pos1.y);
                int cell2 = getCellIndex(pos2.x, pos2.y);
                if (isCorrectMatch(cell1, cell2))
                {
                    // Update the display to show the correct combination
                    updateDisplayCells(cell1, cell2);
                    correctMatches += 2;
                }
                else
                {
                    // Update the display to show the incorrect combination
                    updateDisplayCells(cell1, cell2, true);
                }
            }
        }
    }

    private Vector3 RaycastToCell()
    {
        return RaycastToCell(0);
    }

    private Vector3 RaycastToCell(int touchIndex = 0)
    {
        Touch touch = Input.touches[touchIndex];
        RaycastHit hit;
        if (Physics.Raycast(camera.transform.position, camera.transform.forward, out hit))
        {
            Vector3 hitPos = hit.collider.transform.position;
            GameObject hitObject = hit.collider.gameObject;
            if (hitObject.CompareTag("Cells"))
            {
                Cell cell = hitObject.GetComponent<Cell>();
                return hitPos;
            }
            return Vector3.zero;
        }
        return Vector3.zero;
    }

    private int getCellIndex(float x, float y)
    {
        // Calculate the cell's index based on its grid position
        int pos = (int)(Mathf.Round(x / (CELL_WIDTH + CELL_SPACING)) + Mathf.Round(y / (CELL_HEIGHT + CELL_SPACING)) * gridWidth);
        if (pos >= 0 && pos < gridLength)
        {
            return pos;
        }
        return -1;
    }

    private bool isCorrectMatch(int cell1, int cell2)
    {
        // Compare the shapes and colors for the two cells
        return grid[cell1] == grid[cell2] &&!isMatchExist(cell1, cell2);
    }

    private bool isMatchExist(int cell1, int cell2)
    {
        // Check if a combination of cells already exists as a match
        if (cell1 < cell2)
        {
            return getMatchCountAtCell(cell1) == 2 || getMatchCountAtCell(cell2) == 2;
        }
        else if (cell2 < getCellIndex(0.5f, 1.5f))
        {
            return getMatchCountAtCell(cell1) == 2 && getMatchCountAtCell(cell2) == 2;
        }
        return false;
    }

    private int getMatchCountAtCell(int pos)
    {
        int count = 0;
        for (int j = 0; j < gridHeight; j++)
        {
            for (int i = 0; i < gridWidth; i++)
            {
                if (pos == i + j * gridWidth && grid[pos] == grid[i + j * gridWidth] &&!isMatchExist(i, j))
                {
                    count++;
                }
            }
        }
        return count;
    }

    private void updateDisplayCells(int cell1, int cell2, bool flash = false)
    {
        // Update the visibility of the cells to either show the correct combination (no flash) or incorrectly matched cells (flash)

        // Code to fade out and fade in, you can add or subtract layers for more customization or change colors.
        fadeOut(cell1);
        fadeOut(cell2);

        // Wait for few seconds to let the user see the incorrect combination.
        Invoke("fadeIn", FLASH_TIME);

        // The flash duration should be few seconds to let the users understand what is going on.
        if (correctMatches == gridLength &&!flash)
        {
            // The game was won.
            Invoke("gameWon", FLASH_TIME);
        }
    }

    private void fadeOut(int cell)
    {
        // Fade out the cell, adjust this based on your requirements.
        GameAnalytics.sendEvent("CardFlipped", cell);

        // Fade out implementation goes here.
    }

    private void fadeIn()
    {
        // Flash or fade in implementation based on your game's appearance.
    }

    public void gameWon()
    {
        // Code after winning the game, alert or send analytics based on your requirements.
    }

    private void OnGui()
    {
        int i = 0, j = 0, x = 0;
        foreach (GameObject go in cells)
        {
            if (j * gridWidth + i <= gridLength)
            {
                Rect rect = Rect(x, j * CELLS_HEIGHT + CELLS_SPACING, CELLS_WIDTH, CELLS_HEIGHT);
                GUI.DrawRegion(rect, new Color(getCellColor(i, j)));

                if (Input.touches.Length > 0 && GUI.Button(rect, go.GetComponent<Cell>().shape)
                {
                    OnCellClicked(i, j);

                }
            }
        }
    }

    int getCellColor(int col, int row)
    {
        // Function used to return the color (color for each cell when displayed in the grid,
        // or you might need a function for every single cell, but there should be a pattern),
        // it is mainly for your game's looks and functionality.
    }
}

1. Create a new Material for the cell. Right-click in the Assets folder and select Material. Name it DefaultMaterial.
2. Modify the DefaultMaterial by adding a Textrue property. Choose a texture that matches your game's theme.
3. Create a new prefab for the cell. Create a new GameObject (right-click in the Hierarchy panel and select GameObject) and set its Material property to the DefaultMaterial.

Step 5: Implementing UI and Interaction

1. In the OnGui function, create a grid for the cells. Iterate over the cells array using nested loops and draw the cells using GUI.Button. When a cell is clicked, call the OnCellClicked method.

Step 6: Testing and Iterating

1. Run the game on a test device or simulator to test for any errors or issues.

Step 7: Deploying the Game on Android and iOS

1. Export the Unity game as an Android APK:

   • Go to the Unity menu and select "File" > "Build Settings" > "Android"
   • Choose the devices and platforms you want to support
   • Generate the APK file
   • Transfer the APK to a device or emulator
2. Export the Unity game as an iOS APK:
   • Go to the Unity menu and select "File" > "Build Settings" > "iPhone"
   • Choose the devices and platforms you want to support
   • Generate the IPA file

Congratulations! You have completed the tutorial on how to use the Memory Windows Kids Education Game | Unity Complete Project for Android and iOS.