You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
189 lines
5.1 KiB
189 lines
5.1 KiB
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
/// <summary>
|
|
/// Base class all logic blocks are derived from
|
|
/// </summary>
|
|
[System.Serializable]
|
|
public abstract class LogicBlock : ScriptableObject
|
|
{
|
|
|
|
#region Inspector Fields
|
|
[SerializeField]
|
|
[Header("UI Settings")]
|
|
[Tooltip("Color which will identify this element")]
|
|
public Color Color;
|
|
|
|
[SerializeField]
|
|
[Tooltip("Name which will appear in the UI")]
|
|
protected string _DisplayName;
|
|
|
|
[SerializeField]
|
|
[Header("Base Settings")]
|
|
[Tooltip("Wait until this block is resolved before moving to next")]
|
|
public bool WaitUntilFinished = false;
|
|
|
|
[SerializeField]
|
|
[Tooltip("Amount of times to run this Block before moving to next")]
|
|
protected int RepeatAmount = 1;
|
|
|
|
#endregion Inspector Fields
|
|
|
|
#region ReadOnly Variables
|
|
public string DisplayName { get { return (string.IsNullOrEmpty(_DisplayName)) ? name : _DisplayName; } }
|
|
#endregion
|
|
|
|
#region private variables
|
|
|
|
/// <summary>
|
|
/// Amount of times this block has run
|
|
/// </summary>
|
|
protected int RepeatCount = 0;
|
|
|
|
#endregion private variables
|
|
|
|
#region Class Functions
|
|
/// <summary>
|
|
/// Runs the block
|
|
/// </summary>
|
|
/// <param name="player">Player which will be affected by the block</param>
|
|
/// <returns>returns true if block is finished</returns>
|
|
public virtual bool Run(Character player, float animationTime)
|
|
{
|
|
RepeatCount++;
|
|
BlockLogic(player, animationTime);
|
|
|
|
return isFinished();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the amount of space this logic block takes up
|
|
/// </summary>
|
|
/// <returns>Int which controlls how much space this takes up</returns>
|
|
public virtual int Size()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Where derived callses should implement the logic for their classes
|
|
/// </summary>
|
|
/// <param name="player">Player which will be affected by the block</param>
|
|
/// <returns>returns true if block is finished</returns>
|
|
protected abstract void BlockLogic(Character player, float animationTime);
|
|
|
|
/// <summary>
|
|
/// Returns the block that the character will endUp on after they use this logic element
|
|
/// </summary>
|
|
/// <param name="startBlock">block character is on</param>
|
|
/// <param name="transform">transform function will be based off</param>
|
|
/// <param name="layerMask">layers to ignore</param>
|
|
/// <returns>block which character will finish on after performing this function </returns>
|
|
public abstract Block GetEndBlock(Block startBlock, Transform transform, LayerMask layerMask);
|
|
|
|
/// <summary>
|
|
/// Resets the block to be ready to used again
|
|
/// </summary>
|
|
public virtual void Reset()
|
|
{
|
|
RepeatCount = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// False if this block needs to be run again
|
|
/// </summary>
|
|
/// <returns>bool false if block needs to be run again</returns>
|
|
public virtual bool isFinished()
|
|
{
|
|
return (RepeatCount == RepeatAmount);
|
|
}
|
|
|
|
|
|
#region Serialisation Functions
|
|
/// <summary>
|
|
/// Copies data from BlockToken to this Block
|
|
/// </summary>
|
|
/// <param name="token">Token to Copy</param>
|
|
public virtual void CopyToken(BlockToken token)
|
|
{
|
|
Color = token.Color;
|
|
_DisplayName = token._DisplayName;
|
|
WaitUntilFinished = token.WaitUntilFinished;
|
|
RepeatAmount = token.RepeatAmount;
|
|
name = token.ObjectName;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies Block data to supplied token, if token is null creates new token
|
|
/// </summary>
|
|
/// <param name="token">token to copy data to</param>
|
|
/// <returns></returns>
|
|
public virtual BlockToken ToToken(BlockToken token = null)
|
|
{
|
|
if (token == null)
|
|
token = new BlockToken(this);
|
|
token.Color = Color;
|
|
token._DisplayName = _DisplayName;
|
|
token.WaitUntilFinished = WaitUntilFinished;
|
|
token.RepeatAmount = RepeatAmount;
|
|
token.ObjectName = name;
|
|
|
|
return token;
|
|
}
|
|
#endregion Serialisation Functions
|
|
|
|
|
|
public override bool Equals(object other)
|
|
{
|
|
if (Object.ReferenceEquals(null, other))
|
|
return false;
|
|
|
|
if (Object.ReferenceEquals(other.GetType(), other))
|
|
return false;
|
|
|
|
LogicBlock otherLogic = other as LogicBlock;
|
|
return !Object.ReferenceEquals(null, otherLogic)
|
|
&& int.Equals(RepeatCount, otherLogic.RepeatCount);
|
|
}
|
|
|
|
public virtual void OnDoubleClick()
|
|
{
|
|
|
|
}
|
|
|
|
#endregion Class Functions
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class BlockToken
|
|
{
|
|
|
|
public System.Type blockType;
|
|
|
|
public Color Color;
|
|
|
|
public string _DisplayName;
|
|
|
|
public string ObjectName;
|
|
|
|
public bool WaitUntilFinished;
|
|
|
|
public int RepeatAmount;
|
|
|
|
public BlockToken(LogicBlock block)
|
|
{
|
|
blockType = block.GetType();
|
|
}
|
|
|
|
public LogicBlock ToLogicBlock()
|
|
{
|
|
|
|
LogicBlock retVal = (LogicBlock)ScriptableObject.CreateInstance(blockType);
|
|
Debug.Log("type: " + retVal.GetType());
|
|
retVal.CopyToken(this);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
}
|