Make StackColors in Unity – Finish Line (Lesson 9)

In this lesson on how to create StackColor in Unity, we will show you how to create the finish line and the stack launch mechanic.

PlayerControllerStackColor.cs

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

public class PlayerControllerStackColor : MonoBehaviour
{
    [SerializeField] Color myColor;
    [SerializeField] Renderer[] myRends;

    [SerializeField] bool isPlaying;
    [SerializeField] float forwardSpeed;
    Rigidbody myRB;

    [SerializeField] float lerpSpeed;

    Transform parentPickup;
    [SerializeField] Transform stackPosition;

    bool atEnd;
    [SerializeField] float forwardForce;
    [SerializeField] float forceAdder;
    [SerializeField] float forceReducer;

    public static Action<float> Kick;


    // Start is called before the first frame update
    void Start()
    {
        SetColor(myColor);

        myRB = GetComponent<Rigidbody>();
    }

    // Update is called once per frame
    void Update()
    {
        if(isPlaying)
        {
            MoveForward();
        }

        if (atEnd)
        {
            forwardForce -= forceReducer * Time.deltaTime;
            if (forwardForce < 0)
                forwardForce = 0;
        }

        if (Input.GetMouseButtonDown(0))
        {
            if (atEnd)
            {
                forwardForce += forceAdder;
            }
        }
        if (Input.GetMouseButton(0))
        {
            if (atEnd)
                return;

            if(isPlaying == false)
            {
                isPlaying = true;
            }
            MoveSideways();
        }
        

        
    }

    void SetColor(Color colorIn)
    {
        myColor = colorIn;
        for(int i = 0; i <myRends.Length; i++)
        {
            myRends[i].material.SetColor("_Color", myColor);
        }
    }


    void MoveForward()
    {
        myRB.velocity = Vector3.forward * forwardSpeed;
    }

    void MoveSideways()
    {
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        if(Physics.Raycast(ray, out hit, 100))
        {
            transform.position = Vector3.Lerp(transform.position, new Vector3(hit.point.x, transform.position.y, transform.position.z), lerpSpeed *Time.deltaTime);
        }
    }

    private void OnTriggerExit(Collider other)
    {
        if (other.tag == "ColorWall")
        {
            SetColor(other.GetComponent<ColorWall>().GetColor());
        }
    }

    private void OnTriggerEnter(Collider other)
    {
        if(other.tag == "FinishingLineStart")
        {
            atEnd = true;
        }
        if(other.tag == "FinishingLineEnd")
        {
            myRB.velocity = Vector3.zero;
            isPlaying = false;
            Debug.Log(forwardForce + " forward force");
            LaunchStack();
        }

        if (atEnd)
            return;
        
        Debug.Log(other.tag);
        if(other.tag == "Pickup")
        {
            Transform otherTransform = other.transform.parent;
            if (myColor == otherTransform.GetComponent<PickupStackColor>().GetColor())
            {
                GameControllerStackColor.instance.UpdateScore(otherTransform.GetComponent<PickupStackColor>().value);
            }
            else
            {
                GameControllerStackColor.instance.UpdateScore(otherTransform.GetComponent<PickupStackColor>().value * -1);
                Destroy(other.gameObject);
                if(parentPickup != null)
                {
                    if(parentPickup.childCount > 1)
                    {
                        parentPickup.position -= Vector3.up * parentPickup.GetChild(parentPickup.childCount - 1).localScale.y;
                        Destroy(parentPickup.GetChild(parentPickup.childCount - 1).gameObject);
                    }
                    else
                    {
                        Destroy(parentPickup.gameObject);
                    }
                }
                return;
            }

            Rigidbody otherRB = otherTransform.GetComponent<Rigidbody>();
            otherRB.isKinematic = true;
            other.enabled = false;
            if(parentPickup == null)
            {
                parentPickup = otherTransform;
                parentPickup.position = stackPosition.position;
                parentPickup.parent = stackPosition;
            }
            else
            {
                parentPickup.position += Vector3.up * (otherTransform.localScale.y);
                otherTransform.position = stackPosition.position;
                otherTransform.parent = parentPickup;
            }
        }
    }

    void LaunchStack()
    {
        Camera.main.GetComponent<CameraStackColor>().SetTarget(parentPickup);
        Kick(forwardForce);
        
        
    }
}

PickupStackColor.cs

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

public class PickupStackColor : MonoBehaviour
{
    public int value;
    [SerializeField] Color pickUpColor;
    [SerializeField] Rigidbody pickUpRB;
    [SerializeField] Collider pickUpCollider;


    private void OnEnable()
    {
        PlayerControllerStackColor.Kick += MyKick;
    }

    private void MyKick(float forceSent)
    {
        transform.parent = null;
        pickUpCollider.enabled = true;
        pickUpRB.isKinematic = false;
        pickUpRB.AddForce(new Vector3(0, 200, forceSent));
    }

    private void OnDisable()
    {
        PlayerControllerStackColor.Kick -= MyKick;
    }

    // Start is called before the first frame update
    void Start()
    {
        Renderer rend = transform.GetChild(0).GetComponent<Renderer>();
        rend.material.SetColor("_Color", pickUpColor);
    }

    public Color GetColor()
    {
        return pickUpColor;
    }

    
}

using Photon.Chat;
using Photon.Pun;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class PhotonChatManager : MonoBehaviour, IChatClientListener
{
    #region Setup

    [SerializeField] GameObject joinChatButton;
    ChatClient chatClient;
    bool isConnected;
    [SerializeField] string username;

    public void UsernameOnValueChange(string valueIn)
    {
        username = valueIn;
    }

    public void ChatConnectOnClick()
    {
        isConnected = true;
        chatClient = new ChatClient(this);
        //chatClient.ChatRegion = "US";
        chatClient.Connect(PhotonNetwork.PhotonServerSettings.AppSettings.AppIdChat, PhotonNetwork.AppVersion, new AuthenticationValues(username));
        Debug.Log("Connenting");
    }

    #endregion Setup

    #region General

    [SerializeField] GameObject chatPanel;
    string privateReceiver = "";
    string currentChat;
    [SerializeField] InputField chatField;
    [SerializeField] Text chatDisplay;

    // Start is called before the first frame update
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {
        if (isConnected)
        {
            chatClient.Service();
        }

        if (chatField.text != "" && Input.GetKey(KeyCode.Return))
        {
            SubmitPublicChatOnClick();
            SubmitPrivateChatOnClick();
        }
    }

    #endregion General

    #region PublicChat

    public void SubmitPublicChatOnClick()
    {
        if (privateReceiver == "")
        {
            chatClient.PublishMessage("RegionChannel", currentChat);
            chatField.text = "";
            currentChat = "";
        }
    }

    public void TypeChatOnValueChange(string valueIn)
    {
        currentChat = valueIn;
    }

    #endregion PublicChat

    #region PrivateChat

    public void ReceiverOnValueChange(string valueIn)
    {
        privateReceiver = valueIn;
    }

    public void SubmitPrivateChatOnClick()
    {
        if (privateReceiver != "")
        {
            chatClient.SendPrivateMessage(privateReceiver, currentChat);
            chatField.text = "";
            currentChat = "";
        }
    }

    #endregion PrivateChat

    #region Callbacks

    public void DebugReturn(DebugLevel level, string message)
    {
        //throw new System.NotImplementedException();
    }

    public void OnChatStateChange(ChatState state)
    {
        if(state == ChatState.Uninitialized)
        {
            isConnected = false;
            joinChatButton.SetActive(true);
            chatPanel.SetActive(false);
        }
    }

    public void OnConnected()
    {
        Debug.Log("Connected");
        joinChatButton.SetActive(false);
        chatClient.Subscribe(new string[] { "RegionChannel" });
    }

    public void OnDisconnected()
    {
        isConnected = false;
        joinChatButton.SetActive(true);
        chatPanel.SetActive(false);
    }

    public void OnGetMessages(string channelName, string[] senders, object[] messages)
    {
        string msgs = "";
        for (int i = 0; i < senders.Length; i++)
        {
            msgs = string.Format("{0}: {1}", senders[i], messages[i]);

            chatDisplay.text += "\n" + msgs;

            Debug.Log(msgs);
        }

    }

    public void OnPrivateMessage(string sender, object message, string channelName)
    {
        string msgs = "";

        msgs = string.Format("(Private) {0}: {1}", sender, message);

        chatDisplay.text += "\n " + msgs;

        Debug.Log(msgs);
        
    }

    public void OnStatusUpdate(string user, int status, bool gotMessage, object message)
    {
        throw new System.NotImplementedException();
    }

    public void OnSubscribed(string[] channels, bool[] results)
    {
        chatPanel.SetActive(true);
    }

    public void OnUnsubscribed(string[] channels)
    {
        throw new System.NotImplementedException();
    }

    public void OnUserSubscribed(string channel, string user)
    {
        throw new System.NotImplementedException();
    }

    public void OnUserUnsubscribed(string channel, string user)
    {
        throw new System.NotImplementedException();
    }

    #endregion Callbacks
}