管理场景流和数据
面向对象
- 抽象
public class 00PTest : MonoBehaviour
{
class Animal
{
public string name;
public virtual string shout()
//virtual代表虚方法可重写，此父类方法已经被子类重写，所以在此父类方法中返回什么没有意义
{
return this.name;
}
class Cat : Animal//继承 Animal类，父类里的方法属性等 子类可以用
{
public override string shout()//override重写父类方法
{
return this.name +"，喵喵";
}
}
class Dog : Animal
{
public override string shout()
{
return this.name +"，汪汪";
}
}
void Start()
{
Cat cat1 = new Cat();
cat1.name ="咪咪"；
Debug.Log(cat1.shout());
Dog dog1 = new Dog();
dog1.name ="旺财"；
Debug.Log(dog1.shout());
}
}
public class 00PTest : MonoBehaviour
{
abstract class Animal
//abstract代表抽象类，抽象类不一定非要有抽象方法，抽象类不能用，不能new
//当需要一个类不能实例化时，用到抽象类
{
public string name;
public abstract string shout();//抽象方法没有方法体
//定义为抽象方法，所在的类必须也为抽象类，此方法需被重写才有意义
//只要有一个抽象方法 所在类必须是抽象类
class Cat : Animal//继承 Animal类，父类里的方法属性等 子类可以用
{
public override string shout()//override重写父类方法
{
return this.name +"，喵喵";
}
}
class Dog : Animal
{
public override string shout()
{
return this.name +"，汪汪";
}
}
void Start()
{
Cat cat1 = new Cat();
cat1.name ="咪咪"；
Debug.Log(cat1.shout());
Dog dog1 = new Dog();
dog1.name ="旺财"；
Debug.Log(dog1.shout());
//多态：多种形态，声明变量时使用的是父类，new变量时使用的是子类
Animal a1=new Cat();
//如果定义时用的父类定义
//a1调用的方法也只能是父类有的方法调用不出来子类Cat的自己的方法（父类没有的方法），
//当我们要实现多个子类来回切换时（需要new不同的子类），需要用父类定义，
//防止调用了子类自己独特的方法，导致出错
Debug.Log(a1.shout);//喵喵
a1=new Dog();
Debug.Log(a1.shout);//汪汪
// IList l1=new ArrayList();
// l1.Add(11);
// l1.Add(22);
}
}
- 重写和重载
重写是将父类方法重写，重载是方法相同参数不同（virtual）
- 私有变量与可见性
pubulic class Rabbit:MonoBehaviour
{
//防止被而已更改并且也能在检查器中显示
[SerializaField]//序列化 暴露私有属性到inspector中，
private Color furColor;
public static Rabbit Instance{get;};//虽然是公有变量，但其他地方只能得到不能修改
//{get;set;}外部能修改能得到 {get;private set;}只有内部能修改 外部能得到不能修改
}
public float m_ProductionSpeed = 0.5f;
public float ProductionSpeed//一旦被修改就会触发set里的内容，无论在内部还是在外部，这时会进入死循环
{//此时需要再定义一个变量值m_ProductionSpeed，赋值0.5，外部获取时将m_ProductionSpeed返回，一旦内外设置ProductionSpeed变量时即触发set更改m_ProductionSpeed值
//如果依然用ProductionSpeed进行get中的返回和set中的改值，set中的赋值操作会一直触发进入死循环
get { return m_ProductionSpeed; }
set {
if (value < 0f)//value为要赋的值
{
Debug.Log("报错");
}
else
{
m_ProductionSpeed = value;
}
}
}源码
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
// Base class for all Unit. It will handle movement order given through the UserControl script.
// It require a NavMeshAgent to navigate the scene.
[RequireComponent(typeof(NavMeshAgent))]
public abstract class Unit : MonoBehaviour,
UIMainScene.IUIInfoContent
{
public float Speed = 3;
protected NavMeshAgent m_Agent;
protected Building m_Target;
protected void Awake()
{
m_Agent = GetComponent<NavMeshAgent>();
m_Agent.speed = Speed;
m_Agent.acceleration = 999;
m_Agent.angularSpeed = 999;
}
private void Start()
{
if (MainManager.Instance != null)
{
SetColor(MainManager.Instance.TeamColor);
}
}
void SetColor(Color c)
{
var colorHandler = GetComponentInChildren<ColorHandler>();
if (colorHandler != null)
{
colorHandler.SetColor(c);
}
}
private void Update()
{
if (m_Target != null)
{
float distance = Vector3.Distance(m_Target.transform.position, transform.position);
if (distance < 2.0f)
{
m_Agent.isStopped = true;
BuildingInRange();
}
}
}
public virtual void GoTo(Building target)
{
m_Target = target;
if (m_Target != null)
{
m_Agent.SetDestination(m_Target.transform.position);
m_Agent.isStopped = false;
}
}
public virtual void GoTo(Vector3 position)
{
//we don't have a target anymore if we order to go to a random point.
m_Target = null;
m_Agent.SetDestination(position);
m_Agent.isStopped = false;
}
/// <summary>
/// Override this function to implement what should happen when in range of its target.
/// Note that this is called every frame the current target is in range, not only the first time we get in range!
/// </summary>
protected abstract void BuildingInRange();//子类可以访问，其他不可
//Implementing the IUIInfoContent interface so the UI know it should display the UI when this is clicked on.
//Implementation of all the functions are empty as default, but they are set as virtual so subclass units can
//override them to offer their own data to it.
public virtual string GetName()
{
return "Unit";
}
public virtual string GetData()
{
return "";
}
public virtual void GetContent(ref List<Building.InventoryEntry> content)
{
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
public class MainManager : MonoBehaviour
{
//单例模式 设置为静态后整个程序Instance只有一个，实现传数据，防止从Main回到Menu的时候Menu会再加载一遍，在生成一个是不对的，因为需要来回传数据
public static MainManager Instance { get; private set; }//静态变量名字首字母大写,属性
public Color TeamColor;//字段
private void Awake()//Awake-》Start->Update
{
if (Instance != null)
{//gameObject省略了this.,this.gameObject
Destroy(this.gameObject);//销毁从Main回到Menu后在一次加载Menu生成的MainManager游戏对象
return;
}
Instance = this;//游戏启动，组件等都会加载，将当前的MainManager对象赋值给Instance
DontDestroyOnLoad(gameObject);//this和gameObject不是一个对象，gameObject场景中MainManager游戏对象，而this是MainManager类对象
//MainManager将被缓存不会被销毁，为了传给Main场景
LoadColor();//不点击Load按钮无所谓，因为直接自动调用了，如果没有此句则需要运行后再点击才能取出磁盘文件的内容
}
//private void Start()
//{
// if (MainManager.Instance != null)
// {
// SetColor(MainManager.Instance.TeamColor);
// }
//}
[System.Serializable]//SaveData可被序列化
class SaveData//未加public默认为private
{//如果不用这个内部类，直接在MainManager主类前面加[System.Serializable]，
//运行后也会生成savefile.json文件，但选择了颜色但文件内的颜色值全是0，未赋值存储成功
//是因为如果是上述情况会需要新new MainManager(),和之前的MainManager（游戏运行时刚加载时编辑器帮new的）不是一个
//如果不new MainManager()，而是string json = JsonUtility.ToJson(this);将当前的MainManager类传进去，这种方法是可以将颜色值存储的，
//但如果MainManager中含有其他属性和对应的值也会一同存储进磁盘文件，而这些不一定是我们需要的，所以要创建内部类来实现
public Color TeamColor;
}
public void SaveColor()//将数据存入磁盘文件中（序列化）
{
SaveData data = new SaveData();
data.TeamColor = TeamColor;
string json = JsonUtility.ToJson(data);//将data转换成json形式（磁盘文件 文本格式就是字符串形式）
//File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);//将文件存储到C盘某目录
File.WriteAllText(Application.dataPath + "/savefile.json", json);//将文件存储到当前文件根目录某目录
//存入savefile.json文件
}
public void LoadColor()//将磁盘文件中的数据拿出（反序列化）
{
//string path = Application.persistentDataPath + "/savefile.json";
string path = Application.dataPath + "/savefile.json";
if (File.Exists(path))//如果文件存在
{
string json = File.ReadAllText(path);//读出
SaveData data = JsonUtility.FromJson<SaveData>(json);//反序列化取出数据
TeamColor = data.TeamColor;
}
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
using UnityEngine.SceneManagement;
#if UNITY_EDITOR
using UnityEditor;
#endif
// Sets the script to be executed later than all default scripts
// This is helpful for UI, since other things may need to be initialized before setting the UI
[DefaultExecutionOrder(1000)]//给其关联的游戏对象的脚本排序
public class MenuUIHandler : MonoBehaviour
{
public ColorPicker ColorPicker;
public void NewColorSelected(Color color)
{
// add code here to handle when a color is selected
MainManager.Instance.TeamColor = color;
//TeamColor不是静态变量（属性），所以不能直接用MainManager.TeamColor
}
private void Start()
{
ColorPicker.Init();
//this will call the NewColorSelected function when the color picker have a color button clicked.
ColorPicker.onColorChanged += NewColorSelected;//将NewColorSelected此函数行为赋值给ColorPicker.onColorChanged
ColorPicker.SelectColor(MainManager.Instance.TeamColor);
}
public void StartNew()
{
SceneManager.LoadScene(1);//生成设置 1 是里面的场景序号
}
public void Exit()
{
MainManager.Instance.SaveColor();
#if UNITY_EDITOR//如果是Unity编辑器
EditorApplication.ExitPlaymode();//编辑器运行环境的终止
#else//不是Unity编辑器
Application.Quit();//程序退出，适用于打包完后程序文件，再运行时会成功退出
#endif
}
public void SaveColorClicked()
{
MainManager.Instance.SaveColor();
}
public void LoadColorClicked()
{
MainManager.Instance.LoadColor();
ColorPicker.SelectColor(MainManager.Instance.TeamColor);
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ProductivityUnit : Unit
{
//定义m_CurrentPile为ResourcePile（物品堆）类型，本项目中一共有两种类型的物品堆，初值为null
private ResourcePile m_CurrentPile = null;//点中哪个物品堆
//定义资源生产速度应该提高多少
public float ProductivityMultiplier = 2;
protected override void BuildingInRange()//重写父类方法
{
//判断是否选择物品堆 防止生产速度会一直提高
if(m_CurrentPile == null)
{
ResourcePile pile = m_Target as ResourcePile;//m_Target是Building类型，看你点击的是否是那两个物品堆中的某一个，并将其赋值，每点击赋值null
if (pile != null)
{
m_CurrentPile = pile;
m_CurrentPile.ProductionSpeed *= ProductivityMultiplier;
//提高生产速度加倍
}
}
}
void ResetProductivity()//当小人离开生产速度恢复原值
{
if (m_CurrentPile != null)
{
m_CurrentPile.ProductionSpeed /= ProductivityMultiplier;
m_CurrentPile = null;
}
}
public override void GoTo(Building target)
{
ResetProductivity();//调用你的新方法 重置速度
base.GoTo(target);//调用父类中的GoTo方法
}
public override void GoTo(Vector3 position)
{
ResetProductivity();
base.GoTo(position);
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// A subclass of Building that produce resource at a constant rate.
/// </summary>
public class ResourcePile : Building
{
public ResourceItem Item;
public float m_ProductionSpeed = 0.5f;
public float ProductionSpeed//一旦被修改就会触发set里的内容，无论在内部还是在外部，这时会进入死循环
{//此时需要再定义一个变量值m_ProductionSpeed，赋值0.5，外部获取时将m_ProductionSpeed返回，一旦内外设置ProductionSpeed变量时即触发set更改m_ProductionSpeed值
//如果依然用ProductionSpeed进行get中的返回和set中的改值，set中的赋值操作会一直触发进入死循环
get { return m_ProductionSpeed; }
set {
if (value < 0f)//value为要赋的值
{
Debug.Log("报错");
}
else
{
m_ProductionSpeed = value;
}
}
}
private float m_CurrentProduction = 0.0f;
private void Update()
{
if (m_CurrentProduction > 1.0f)
{
int amountToAdd = Mathf.FloorToInt(m_CurrentProduction);
int leftOver = AddItem(Item.Id, amountToAdd);
m_CurrentProduction = m_CurrentProduction - amountToAdd + leftOver;
}
if (m_CurrentProduction < 1.0f)
{
m_CurrentProduction += m_ProductionSpeed * Time.deltaTime;
}
}
public override string GetData()
{
return $"Producing at the speed of {m_ProductionSpeed}/s";
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// Subclass of Unit that will transport resource from a Resource Pile back to Base.
/// </summary>
public class TransporterUnit : Unit
{
public int MaxAmountTransported = 1;
private Building m_CurrentTransportTarget;
private Building.InventoryEntry m_Transporting = new Building.InventoryEntry();
// We override the GoTo function to remove the current transport target, as any go to order will cancel the transport
public override void GoTo(Vector3 position)
{
base.GoTo(position);
m_CurrentTransportTarget = null;
}
protected override void BuildingInRange()
{
if (m_Target == Base.Instance)
{
//we arrive at the base, unload!
if (m_Transporting.Count > 0)
m_Target.AddItem(m_Transporting.ResourceId, m_Transporting.Count);
//we go back to the building we came from
GoTo(m_CurrentTransportTarget);
m_Transporting.Count = 0;
m_Transporting.ResourceId = "";
}
else
{
if (m_Target.Inventory.Count > 0)
{
m_Transporting.ResourceId = m_Target.Inventory[0].ResourceId;
m_Transporting.Count = m_Target.GetItem(m_Transporting.ResourceId, MaxAmountTransported);
m_CurrentTransportTarget = m_Target;
GoTo(Base.Instance);
}
}
}
//Override all the UI function to give a new name and display what it is currently transporting
public override string GetName()
{
return "Transporter";
}
public override string GetData()
{
return $"Can transport up to {MaxAmountTransported}";
}
public override void GetContent(ref List<Building.InventoryEntry> content)
{
if (m_Transporting.Count > 0)
content.Add(m_Transporting);
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// This script handle all the control code, so detecting when the users click on a unit or building and selecting those
/// If a unit is selected it will give the order to go to the clicked point or building when right clicking.
/// </summary>
public class UserControl : MonoBehaviour
{
public Camera GameCamera;
public float PanSpeed = 10.0f;
public GameObject Marker;
private Unit m_Selected = null;//声明的是Unit类
private void Start()
{
Marker.SetActive(false);
}
private void Update()
{
Vector2 move = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
GameCamera.transform.position = GameCamera.transform.position + new Vector3(move.y, 0, -move.x) * PanSpeed * Time.deltaTime;
if (Input.GetMouseButtonDown(0))
{//GameCamera.ScreenPointToRay(Input.mousePosition)鼠标点击位置与照相机之间形成一条射线，返回Ray射线类型
var ray = GameCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;//得到射线碰上的物体
if (Physics.Raycast(ray, out hit))// out hit，hit为引用，这里会给hit赋值，检测射线ray命中某个物体
{
//the collider could be children of the unit, so we make sure to check in the parent
var unit = hit.collider.GetComponentInParent<Unit>();//利用多态，找射线命中的物体，找组件Unit,从本身开始一直往上找，自己没有Unit就继续找父亲，找离它最近的有Unit的节点
m_Selected = unit;//如果找到的是继承Unit类的子类组件对象，则返回的是子类，多态
//check if the hit object have a IUIInfoContent to display in the UI
//if there is none, this will be null, so this will hid the panel if it was displayed
var uiInfo = hit.collider.GetComponentInParent<UIMainScene.IUIInfoContent>();//命中的物体找含有此接口UIMainScene.IUIInfoContent这个组件（类）取出其中的信息，因为IUIInfoContent是UIMainScene内部接口
UIMainScene.Instance.SetNewInfoContent(uiInfo);//把信息uiInfo传入
}
}
else if (m_Selected != null && Input.GetMouseButtonDown(1))
{//right click give order to the unit
var ray = GameCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
var building = hit.collider.GetComponentInParent<Building>();
if (building != null)
{
m_Selected.GoTo(building);
}
else
{
m_Selected.GoTo(hit.point);
}
}
}
MarkerHandling();
}
// Handle displaying the marker above the unit that is currently selected (or hiding it if no unit is selected)
void MarkerHandling()
{
if (m_Selected == null && Marker.activeInHierarchy)
{
Marker.SetActive(false);
Marker.transform.SetParent(null);
}
else if (m_Selected != null && Marker.transform.parent != m_Selected.transform)
{
Marker.SetActive(true);
Marker.transform.SetParent(m_Selected.transform, false);
Marker.transform.localPosition = Vector3.zero;
}
}
}
using System;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// Base class for building on the map that hold a Resource inventory and that can be interacted with by Unit.
/// This Base class handle modifying the inventory of resources.
/// </summary>
public abstract class Building : MonoBehaviour,
UIMainScene.IUIInfoContent
{
//need to be serializable for the save system, so maybe added the attribute just when doing the save system
[System.Serializable]
public class InventoryEntry
{
public string ResourceId;
public int Count;
}
[Tooltip("-1 is infinite")]
public int InventorySpace = -1;
protected List<InventoryEntry> m_Inventory = new List<InventoryEntry>();
public List<InventoryEntry> Inventory => m_Inventory;
protected int m_CurrentAmount = 0;
//return 0 if everything fit in the inventory, otherwise return the left over amount
public int AddItem(string resourceId, int amount)
{
//as we use the shortcut -1 = infinite amount, we need to actually set it to max value for computation following
int maxInventorySpace = InventorySpace == -1 ? Int32.MaxValue : InventorySpace;
if (m_CurrentAmount == maxInventorySpace)
return amount;
int found = m_Inventory.FindIndex(item => item.ResourceId == resourceId);
int addedAmount = Mathf.Min(maxInventorySpace - m_CurrentAmount, amount);
//couldn't find an entry for that resource id so we add a new one.
if (found == -1)
{
m_Inventory.Add(new InventoryEntry()
{
Count = addedAmount,
ResourceId = resourceId
});
}
else
{
m_Inventory[found].Count += addedAmount;
}
m_CurrentAmount += addedAmount;
return amount - addedAmount;
}
//return how much was actually removed, will be 0 if couldn't get any.
public int GetItem(string resourceId, int requestAmount)
{
int found = m_Inventory.FindIndex(item => item.ResourceId == resourceId);
//couldn't find an entry for that resource id so we add a new one.
if (found != -1)
{
int amount = Mathf.Min(requestAmount, m_Inventory[found].Count);
m_Inventory[found].Count -= amount;
if (m_Inventory[found].Count == 0)
{//no more of that resources, so we remove it
m_Inventory.RemoveAt(found);
}
m_CurrentAmount -= amount;
return amount;
}
return 0;
}
public virtual string GetName()
{
return gameObject.name;
}
public virtual string GetData()
{
return "";
}
public void GetContent(ref List<InventoryEntry> content)
{
content.AddRange(m_Inventory);
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// A special building that hold a static reference so it can be found by other script easily (e.g. for Unit to go back
/// to it)
/// </summary>
public class Base : Building
{
public static Base Instance { get; private set; }
private void Awake()
{
Instance = this;
}
}
UI源码
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class ContentEntry : MonoBehaviour
{
public Image Icone;
public Text Count;
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class InfoPopup : MonoBehaviour
{
public Text Name;
public Text Data;
public RectTransform ContentTransform;
public ContentEntry EntryPrefab;
public void ClearContent()
{
foreach (Transform child in ContentTransform)
{
Destroy(child.gameObject);
}
}
public void AddToContent(int count, Sprite Icone)
{
var newEntry = Instantiate(EntryPrefab, ContentTransform);
newEntry.Count.text = count.ToString();
newEntry.Icone.sprite = Icone;
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
public class UIMainScene : MonoBehaviour
{
public static UIMainScene Instance { get; private set; }
public interface IUIInfoContent//interface接口，不能new
{//接口是用来实现的，里面的方法都是抽象的，需要被子类重写来实现
//接口的主要作用是用来约束行为（方法）一个需要的方法定义一个接口，需要的类就实现它，低耦合高聚合，自顶而下
//继承属于强耦合，自底而上，很多子类有公共部分就可以抽象一个父类去继承
/*例如 c#中一个类只能继承一个父类，单继承多实现（可实现多个接口）
class Aa : SomeInterface，ISomeInterface{}//c#中，和继承没办法区分所以一般接口开头有I
interface SomeInterface{void Methhod1();void Methhod1();}
class Bb extends Cc implements SomeInterface{}//Java中
*/
string GetName();//获取Main场景中点击物体的信息
string GetData();
void GetContent(ref List<Building.InventoryEntry> content);
}
public InfoPopup InfoPopup;
public ResourceDatabase ResourceDB;
protected IUIInfoContent m_CurrentContent;
protected List<Building.InventoryEntry> m_ContentBuffer = new List<Building.InventoryEntry>();
private void Awake()
{
Instance = this;
InfoPopup.gameObject.SetActive(false);
ResourceDB.Init();
}
private void OnDestroy()
{
Instance = null;
}
private void Update()
{
if (m_CurrentContent == null)
return;
//This is not the most efficient, as we reconstruct everything every time. A more efficient way would check if
//there was some change since last time (could be made through a IsDirty function in the interface) or smarter
//update (match an entry content ta type and just update the count) but simplicity in this tutorial we do that
//every time, this won't be a bottleneck here.
InfoPopup.Data.text = m_CurrentContent.GetData();
InfoPopup.ClearContent();//先将左上角信息表清空
m_ContentBuffer.Clear();
m_CurrentContent.GetContent(ref m_ContentBuffer);
foreach (var entry in m_ContentBuffer)//取图标
{
Sprite icon = null;
if (ResourceDB != null)
icon = ResourceDB.GetItem(entry.ResourceId)?.Icone;
InfoPopup.AddToContent(entry.Count, icon);
}
}
public void SetNewInfoContent(IUIInfoContent content)//多态，传过来的是实现接口的类，把点击的物体显示的信息到左上角
{
if (content == null)//此类未实现此接口
{
InfoPopup.gameObject.SetActive(false);//左上角不显示信息
}
else
{
InfoPopup.gameObject.SetActive(true);
m_CurrentContent = content;
InfoPopup.Name.text = content.GetName();//打开的是点击物体对应组件（类）中实现接口的方法，如果没重写接口中的方法就去继承的父类（实现接口方法）实现的方法
}
}
public void BackToMenuScene()
{
SceneManager.LoadScene(0);//0为Menu场景，回到Menu场景，将Menu场景在一次加载一遍
}
}
Helpers文档
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
public class AnimatorHandler : MonoBehaviour
{
private Animator m_Animator;
private NavMeshAgent m_Agent;
// Start is called before the first frame update
void Start()
{
m_Agent = GetComponentInParent<NavMeshAgent>();
m_Animator = GetComponentInChildren<Animator>();
}
// Update is called once per frame
void Update()
{
if (m_Agent != null && m_Animator != null)
{
m_Animator.SetFloat("Speed", m_Agent.velocity.magnitude / m_Agent.speed);
}
}
}
using UnityEngine;
// Handles setting a color to a given renderer and material slot. Used to simplify coloring our Unit.
// (This can be added on the visual prefab and the Unit code can just query oif that component exists to set color)
public class ColorHandler : MonoBehaviour
{
public Renderer TintRenderer;
public int TintMaterialSlot;
public void SetColor(Color c)
{
var prop = new MaterialPropertyBlock();
prop.SetColor("_BaseColor", c);
TintRenderer.SetPropertyBlock(prop, TintMaterialSlot);
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class ColorPicker : MonoBehaviour
{
public Color[] AvailableColors;
public Button ColorButtonPrefab;
public Color SelectedColor { get; private set; }
public System.Action<Color> onColorChanged;//添加某种行为，在MenuUIHandler中添加过来的行为
List<Button> m_ColorButtons = new List<Button>();
// Start is called before the first frame update
public void Init()
{
foreach (var color in AvailableColors)//var不确定AvailableColors是什么类型用var,自己会推断
{
var newButton = Instantiate(ColorButtonPrefab, transform);//克隆出来一个新的按钮放在自己的下边
newButton.GetComponent<Image>().color = color;//按钮赋值颜色
newButton.onClick.AddListener(() =>//给按钮绑定点击事件，只有点击时才会执行里面的东西
{
SelectedColor = color;
foreach (var button in m_ColorButtons)
{
button.interactable = true;//按钮交互，当鼠标划到颜色按钮身上，颜色会加深
}
newButton.interactable = false;//点击后的按钮，关闭交互
onColorChanged.Invoke(SelectedColor);//触发NewColorSelected行为，并将SelectedColor传到NewColorSelected中
//等同于MainManager.Instance.TeamColor=SelectedColor,但上述代码是将你用的颜色给你，但具体干什么可以写在调用的函数中
});
//回调，整体生成按钮 绑定事件 赋值按钮 瞬间完成，只有点击时才会回到上面代码进入里面执行foreach
m_ColorButtons.Add(newButton);//按钮扔到按钮列表中
}
}
public void SelectColor(Color color)
{
for (int i = 0; i < AvailableColors.Length; ++i)
{
if (AvailableColors[i] == color)
{
m_ColorButtons[i].onClick.Invoke();//设置的颜色作为下一次运行时菜单默认的颜色，自动触发点击函数
}
}
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "ResourcesDatabase", menuName = "Tutorial/Resources Database")]
public class ResourceDatabase : ScriptableObject
{
public List<ResourceItem> ResourceTypes = new List<ResourceItem>();
private Dictionary<string, ResourceItem> m_Database;
public void Init()
{
m_Database = new Dictionary<string, ResourceItem>();
foreach (var resourceItem in ResourceTypes)
{
m_Database.Add(resourceItem.Id, resourceItem);
}
}
public ResourceItem GetItem(string uniqueId)
{
m_Database.TryGetValue(uniqueId, out ResourceItem type);
return type;
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "ResourceItem", menuName = "Tutorial/Resource Item")]
public class ResourceItem : ScriptableObject
{
public string Name;
public string Id;
public Sprite Icone;
}
扫一扫
903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
