Tag: code

This is the approach that I have made so far in the code that I have written. Based on the results in unity, I can see 4 white pieces on one end and 4 black pieces on the opposite end. When I try to move the pieces, it moves diagonally once. When I try to move the second piece it goes back to the original settings.
What I am trying to do here is that I want to set up 4 white pieces on one end and 1 black piece on the opposite end and to move them diagonally.
The code is given below:-

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class GC : MonoBehaviour
{
(Tooltip(“The number of squares wide”))
public int width = 10;
(Tooltip(“The number of squares deep”))
public int depth = 10;
(Tooltip(“The prefab for the light board tile”))
public GameObject tileLightPrefab;
(Tooltip(“The prefab for the dark board tile”))
public GameObject tileDarkPrefab;
(Tooltip(“The prefab for the light playing piece”))
public GameObject pieceLightPrefab;
(Tooltip(“The prefab for the dark playing piece”))
public GameObject pieceDarkPrefab;
(Tooltip(“Any string put in messagetext.text will appear the the left of the screen”))
public Text messageText;
(Tooltip(“Reference to the camera to be used in determining the mouse position”))
public Camera cam;

// The following is used if you wish to have mouse input
private Vector2 mousePos;   // Can be used to hold the mouse screen position 
private Vector3 mouse3DPos; // Can be used to hold the mouse position on the ground (ignore y axis)
                            // To get the mouse position use the following code in the update method
                            //    mousePos = Input.mousePosition;//gets mouse postion
                            //    // Convert mouse screen position to a position on the ground
                            //    mouse3DPos = cam.ScreenToWorldPoint(new Vector3(mousePos.x, mousePos.y, cam.transform.position.y));

public const int NumberOfPieces = 8;   // A constant used to hold the number of pieces created


GameObject() Piece = new GameObject(NumberOfPieces);     // This array will hold all the playing pieces
Vector3() Target = new Vector3(NumberOfPieces);       // This array will hold the target for each playing piece

GameObject() PiecePrefab = new GameObject(2);   // Used to hold the piece prefabs for easier selection

public float Speed = 10f;   // Speed to move peice in m/s
int Movethepiece = 0;        // Used as index to piece array to indicate piece to be moved    
public float PieceHeight = 0.1f; // The height the pieces should be placed above the tiles

public enum GameState { Begin, Player1, Player2, End };
public GameState gameState;
public bool isGameInitialised = false;
public Vector3 gizmoPosition = Vector3.zero;

// Start is called before the first frame update
void Start()
{
    InitialiseBoard(width, depth);  // Call method to create the playing board
    messageText.text = "";  // Any string assigned to this will appear on the left of the screen 

    PiecePrefab(0) = pieceDarkPrefab;  // Put the pieces prefabs into an array to be able to use the index
    PiecePrefab(1) = pieceLightPrefab;   //  to select a light or dark piece.
    //piece.clear();
    int i = 0;
    while ( i < NumberOfPieces)    // While Loop to initialise the playing pieces
    {
        Target(i) = new Vector3(i, PieceHeight, 0); // Target holds the initial piece position
        Piece(i) = Instantiate(PiecePrefab(i % 2), Target(i), Quaternion.identity);   // Create a new playing piece
        i++;
    }
    
}
void InitialGame()
{
    for (int i = 0; i < NumberOfPieces; i++)    // Loop to initialise the playing pieces
    {
        Target(i) = new Vector3(i, PieceHeight, 9 - (i % 2 * 9)); // Target holds the initial piece position
        Piece(i).transform.position = Target(i);
    }
    Target(1) = new Vector3(1f, PieceHeight, 1f);
    Piece(1).transform.position = Target(1);
    isGameInitialised = true;
} 

// Method:  InitialiseBoard
// Input:   int width - the width of the board in number of tiles
//          int depth - the depth of the board in number of tiles
// Output:  none
// Description:
//      Creates a draughts or checkers board of size given by the inputs.
//      It assumes that the first tile is at position 0,0 and that the tile are 1x1 in size.
private void InitialiseBoard(int width, int depth)
{
    for (int x = 0; x < width; x++)  // Loop through each row of the board
    {                               // x indicates the width position of tile
        for (int z = 0; z < depth; z++) // Loop through each column of the board
        {                               // z indicates the depth position of tile
            // By adding x and z we get a number that alternates between odd and even.
            // Taking the modulus'%' of 2 (i.e. dividing by 2 and taking the remainder)
            // we get a remainder of 0 or 1. We can now check if the number is even by comparing with 0.
            // This allows us to select the light or dark coloured tile to create.
            if ((x + z) % 2 == 0)     // Select light or dark coloured tile. 
            {
                // Create new instance of Light Tile
                Instantiate(tileLightPrefab, new Vector3(x, 0, z), Quaternion.Euler(0f, 0f, 0f));
            }
            else
            {
                // Create new instance of Dark Tile
                Instantiate(tileDarkPrefab, new Vector3(x, 0, z), Quaternion.Euler(0f, 0f, 0f));
            }
        }
    }
}

// Update is called once per frame
void Update()
{
    switch (gameState)
    {
        case GameState.Begin:
            Begin();
            break;
        case GameState.Player1:
            MovePiece();
            break;
        case GameState.Player2:
            MovePiece();
            break;
        case GameState.End:
            break;

    }
    //MovePiece();
}
void Begin()
{
    if (!isGameInitialised)
    {
        InitialGame();
    }
    messageText.text = "Wolf and Sheep GamenInstructions:-nPress Spacebar Enter to startnPieces move diagonal onlynLight piece only move forwardn Dark piece move back and forth";
   
    if (Input.GetKeyDown(KeyCode.Space))
    {
        gameState = GameState.Player1;
    }
}

void MovePiece()
{
    Vector3 tempTarget;

    if (Input.GetKeyDown(KeyCode.Space))    // Check for space bar to change piece to be moved
    {
        Movethepiece++;  // Space bar used to increment the piece to be moved
        if (Movethepiece >= Piece.Length)  // check that the piece to moved is valid, i.e. not greater that the pieces available
        {
            Movethepiece = 0;    // If not valid then wrap around to zero.
        }

    }
    if (gameState == GameState.Player1)
    {
        messageText.text = "Player 1n";
    }
    else
    {
        messageText.text = "Player 2n";
    }
    messageText.text = "Piece To Move: " + Movethepiece.ToString();  // Tell the play which piece is to be moved.

    tempTarget = Target(Movethepiece);
    if (Input.GetKeyDown(KeyCode.W))
    {
        if (tempTarget.z < (width - 1))
        {
            tempTarget.z += 1;
            tempTarget.x += 1;
            if (gameState == GameState.Player1)
            {
                gameState = GameState.Player2;
            }
            else
            {
                gameState = GameState.Begin;
                isGameInitialised = false;
            }
        }

    }
    
    if (Input.GetKeyDown(KeyCode.S))
    {
        if (tempTarget.z > 0)
        {
            tempTarget.z -= 1;
            tempTarget.x -= 1;
            if (gameState == GameState.Player1)
            {
                gameState = GameState.Player2;
            }
            else
            {
                gameState = GameState.Begin;
                isGameInitialised = false;
            }
        }

    }
    Target(Movethepiece) = tempTarget;

    Vector3 position = Piece(Movethepiece).transform.position;
    if (position != tempTarget)
    {
        if (position.z != tempTarget.z)
        {
            if (position.z < tempTarget.z)
            {
                position.z += Speed * Time.deltaTime;   // Look up LERP
                if (position.z > tempTarget.z)
                {
                    position.z = tempTarget.z;
                }
            }
            else
            {
                position.z -= Speed * Time.deltaTime;
                if (position.z < tempTarget.z)
                {
                    position.z = tempTarget.z;
                }
            }
        }
    }
    Piece(Movethepiece).transform.position = position;
    if (!IsTileOccupied(tempTarget))
    {
        Target(Movethepiece) = tempTarget;
    }

    if (Piece(Movethepiece).transform.position != Target(Movethepiece))
    {
        Piece(Movethepiece).transform.position = Vector3.Lerp(Piece(Movethepiece).transform.position, Target(Movethepiece), Speed * Time.deltaTime);
    }
    ShowSelection(Piece(Movethepiece).transform.position);

}
    public void ShowSelection(Vector3 position)
    {
    gizmoPosition = position;
    }
    public void OnDrawGizmos()
    {
    Gizmos.color = Color.green;
    Gizmos.DrawSphere(gizmoPosition, 0.25f);
    }

    public float MoveAxis(float targetAxis, float currentAxis)
    {
    if (currentAxis < targetAxis)
    {
        currentAxis += Speed * Time.deltaTime;   // Look up LERP
        if (currentAxis > targetAxis)
        {
            currentAxis = targetAxis;
        }
    }
    else
    {
        currentAxis -= Speed * Time.deltaTime;
        if (currentAxis < targetAxis)
        {
            currentAxis = targetAxis;
        }
    }
    return currentAxis;

    }

    bool IsTileOccupied(Vector3 targetTile)
    {
    bool isTileOccupied = false;
    for (int i = 0; i < Target.Length; i++)
    {
        if (Target(i) == targetTile)
        {
            isTileOccupied = true;
        }
    }

    return isTileOccupied;
    }

}