介绍
水波荡漾的特效
鱼有多种运动轨迹
每隔一段时间自动收集金币
可以切换不同的炮台
升级后有不同的特效
捕捉到普通鱼类有金币特效
捕捉到大金鱼后有特效
playerprefs存档读档
制作水波特效
新建一个面板Plane
新建一个材质球，设置为Legacy Shaders/Particles/Additive
添加脚本：
using UnityEngine;
public class Ef_WaterWave : MonoBehaviour
{
public Texture[] textures; // 存储多个纹理的数组
private Material material; // 存储材质的变量
private int index = 0; // 纹理索引
void Start()
{
// 获取当前对象上的MeshRenderer组件，并将其材质赋值给material变量
material = GetComponent<MeshRenderer>().material;
// 每隔0.1秒调用ChangeTexture方法
InvokeRepeating("ChangeTexture", 0, 0.1f);
}
void ChangeTexture()
{
// 将当前纹理数组textures中的纹理赋值给材质的mainTexture属性
material.mainTexture = textures[index];
// 更新纹理索引，当索引超过纹理数组长度时，将索引重置为0
index = (index + 1) % textures.Length;
}
}
制作多种ui
制作不同种类鱼的动画
鱼的多种移动效果
鱼儿可以直着走、弯着走
using UnityEngine; // 引入UnityEngine命名空间
using System.Collections; // 引入System.Collections命名空间
public class FishMaker : MonoBehaviour // 定义一个名为FishMaker的类并继承MonoBehaviour
{
public Transform fishHolder; // 定义一个Transform类型的公共变量fishHolder，用于存储生成的鱼
public Transform[] genPositions; // 定义一个Transform数组类型的公共变量genPositions，用于存储生成鱼的位置
public GameObject[] fishPrefabs; // 定义一个GameObject数组类型的公共变量fishPrefabs，用于存储不同种类的鱼的预制体
public float fishGenWaitTime = 0.5f; // 定义一个公共浮点型变量fishGenWaitTime，用于控制生成鱼的时间间隔
public float waveGenWaitTime = 0.3f; // 定义一个公共浮点型变量waveGenWaitTime，用于控制每次生成鱼的时间间隔
void Start() // Start方法，用于在游戏开始时执行初始化逻辑
{
InvokeRepeating("MakeFishes", 0, waveGenWaitTime); // 重复调用MakeFishes方法，0表示不延迟，waveGenWaitTime表示每次调用之间的时间间隔
}
void MakeFishes() // MakeFishes方法，用于生成鱼
{
int genPosIndex = Random.Range(0, genPositions.Length); // 随机生成一个0到genPositions.Length-1之间的整数，作为生成鱼的位置的索引
int fishPreIndex = Random.Range(0, fishPrefabs.Length); // 随机生成一个0到fishPrefabs.Length-1之间的整数，作为生成鱼的预制体的索引
int maxNum = fishPrefabs[fishPreIndex].GetComponent<FishAttr>().maxNum; // 获取生成鱼预制体的FishAttr组件中的最大数量
int maxSpeed = fishPrefabs[fishPreIndex].GetComponent<FishAttr>().maxSpeed; // 获取生成鱼预制体的FishAttr组件中的最大速度
int num = Random.Range((maxNum / 2) + 1, maxNum); // 随机生成一个最大数量的一半到最大数量之间的整数，作为生成鱼的数量
int speed = Random.Range(maxSpeed / 2, maxSpeed); // 随机生成一个最大速度的一半到最大速度之间的整数，作为生成鱼的速度
int moveType = Random.Range(0, 2); // 随机生成一个0或1，0表示直走，1表示转弯
int angOffset; // 定义一个整型变量angOffset，表示直走时的倾斜角
int angSpeed; // 定义一个整型变量angSpeed，表示转弯时的角速度
if (moveType == 0) // 如果moveType等于0，表示生成直走的鱼
{
angOffset = Random.Range(-22, 22); // 随机生成一个-22到22之间的整数，表示直走的倾斜角
StartCoroutine(GenStraightFish(genPosIndex, fishPreIndex, num, speed, angOffset)); // 使用协程生成直走的鱼
}
else // 如果moveType等于1，表示生成转弯的鱼
{
if (Random.Range(0, 2) == 0) // 随机生成一个0或1，表示是否取负的角速度
{
angSpeed = Random.Range(-15, -9); // 随机生成一个-15到-9之间的整数，作为角速度
}
else
{
angSpeed = Random.Range(9, 15); // 随机生成一个9到15之间的整数，作为角速度
}
StartCoroutine(GenTrunFish(genPosIndex, fishPreIndex, num, speed, angSpeed)); // 使用协程生成转弯的鱼
}
}
IEnumerator GenStraightFish(int genPosIndex,int fishPreIndex,int num,int speed,int angOffset) // 生成直走的鱼的协程
{
for (int i = 0; i < num; i++) // 循环生成指定数量的鱼
{
GameObject fish = Instantiate(fishPrefabs[fishPreIndex]); // 生成鱼的实例
fish.transform.SetParent(fishHolder, false); // 设置鱼的父物体为fishHolder
fish.transform.localPosition = genPositions[genPosIndex].localPosition; // 设置鱼的初始位置为指定的生成位置的本地位置
fish.transform.localRotation = genPositions[genPosIndex].localRotation; // 设置鱼的初始角度为指定的生成位置的本地角度
fish.transform.Rotate(0, 0, angOffset); // 将鱼绕z轴旋转指定的倾斜角
fish.GetComponent<SpriteRenderer>().sortingOrder += i; // 设置鱼的渲染层级
fish.AddComponent<Ef_AutoMove>().speed = speed; // 添加Ef_AutoMove组件，并设置移动速度
yield return new WaitForSeconds(fishGenWaitTime); // 等待指定的时间后再生成下一条鱼
}
}
IEnumerator GenTrunFish(int genPosIndex, int fishPreIndex, int num, int speed, int angSpeed) // 生成转弯的鱼的协程
{
for (int i = 0; i < num; i++) // 循环生成指定数量的鱼
{
GameObject fish = Instantiate(fishPrefabs[fishPreIndex]); // 生成鱼的实例
fish.transform.SetParent(fishHolder, false); // 设置鱼的父物体为fishHolder
fish.transform.localPosition = genPositions[genPosIndex].localPosition; // 设置鱼的初始位置为指定的生成位置的本地位置
fish.transform.localRotation = genPositions[genPosIndex].localRotation; // 设置鱼的初始角度为指定的生成位置的本地角度
fish.GetComponent<SpriteRenderer>().sortingOrder += i; // 设置鱼的渲染层级
fish.AddComponent<Ef_AutoMove>().speed = speed; // 添加Ef_AutoMove组件，并设置移动速度
fish.AddComponent<Ef_AutoRotate>().speed = angSpeed; // 添加Ef_AutoRotate组件，并设置旋转速度
yield return new WaitForSeconds(fishGenWaitTime); // 等待指定的时间后再生成下一条鱼
}
}
}
using UnityEngine;
public class Ef_AutoRotate : MonoBehaviour
{
public float speed = 10f;
void Update()
{
transform.Rotate(Vector3.forward, speed * Time.deltaTime);
}
}
using UnityEngine;
public class Ef_AutoMove : MonoBehaviour
{
public float speed = 1f;
public Vector3 dir = Vector3.right;
void Update()
{
transform.Translate(dir * speed * Time.deltaTime);
}
}
制作鱼的生成点
这段代码主要实现了生成不同类型的鱼，并让它们在屏幕上游动。
函数功能简介：
- Start()：在游戏开始时调用，通过InvokeRepeating函数定时调用MakeFishes函数生成鱼。
- MakeFishes()：随机生成不同种类的鱼，并根据鱼的属性生成不同运动轨迹的鱼。
- GenStraightFish()：生成直走的鱼，每生成一条鱼就等待一定时间，然后再生成下一条鱼。
- GenTrunFish()：生成转弯的鱼，每生成一条鱼就等待一定时间，然后再生成下一条鱼。
变量功能简介：
- fishHolder：存放生成的鱼的父物体。
- genPositions：存放生成鱼的位置的数组。
- fishPrefabs：存放不同种类鱼的预制体的数组。
- fishGenWaitTime：生成鱼的间隔时间。
- waveGenWaitTime：生成不同类型鱼的间隔时间。
using UnityEngine;
using System.Collections;
public class FishMaker : MonoBehaviour
{
public Transform fishHolder; // 鱼的父物体
public Transform[] genPositions; // 生成鱼的位置数组
public GameObject[] fishPrefabs; // 鱼的预制体数组
public float fishGenWaitTime = 0.5f; // 生成鱼的等待时间
public float waveGenWaitTime = 0.3f; // 波次生成的等待时间
void Start()
{
InvokeRepeating("MakeFishes", 0, waveGenWaitTime); // 开始重复调用MakeFishes方法
}
void MakeFishes()
{
int genPosIndex = Random.Range(0, genPositions.Length); // 随机生成位置的索引
int fishPreIndex = Random.Range(0, fishPrefabs.Length); // 随机鱼的预制体的索引
int maxNum = fishPrefabs[fishPreIndex].GetComponent<FishAttr>().maxNum; // 获取最大数量
int maxSpeed = fishPrefabs[fishPreIndex].GetComponent<FishAttr>().maxSpeed; // 获取最大速度
int num = Random.Range((maxNum / 2) + 1, maxNum); // 随机生成数量
int speed = Random.Range(maxSpeed / 2, maxSpeed); // 随机生成速度
int moveType = Random.Range(0, 2); // 随机生成移动类型，0：直走；1：转弯
int angOffset; // 仅直走生效，直走的倾斜角
int angSpeed; // 仅转弯生效，转弯的角速度
if (moveType == 0)
{
angOffset = Random.Range(-22, 22); // 随机生成倾斜角
StartCoroutine(GenStraightFish(genPosIndex, fishPreIndex, num, speed, angOffset)); // 开始生成直走的鱼
}
else
{
if (Random.Range(0, 2) == 0) // 是否取负的角速度
{
angSpeed = Random.Range(-15, -9); // 随机生成负的角速度
}
else
{
angSpeed = Random.Range(9, 15); // 随机生成正的角速度
}
StartCoroutine(GenTrunFish(genPosIndex, fishPreIndex, num, speed, angSpeed)); // 开始生成转弯的鱼
}
}
IEnumerator GenStraightFish(int genPosIndex, int fishPreIndex, int num, int speed, int angOffset)
{
for (int i = 0; i < num; i++)
{
GameObject fish = Instantiate(fishPrefabs[fishPreIndex]); // 实例化鱼的预制体
fish.transform.SetParent(fishHolder, false); // 设置鱼的父物体
fish.transform.localPosition = genPositions[genPosIndex].localPosition; // 设置鱼的本地位置
fish.transform.localRotation = genPositions[genPosIndex].localRotation; // 设置鱼的本地旋转
fish.transform.Rotate(0, 0, angOffset); // 对鱼进行倾斜角旋转
fish.GetComponent<SpriteRenderer>().sortingOrder += i; // 设置鱼的渲染层级
fish.AddComponent<Ef_AutoMove>().speed = speed; // 添加自动移动组件并设置速度
yield return new WaitForSeconds(fishGenWaitTime); // 等待一段时间后继续生成下一条鱼
}
}
IEnumerator GenTrunFish(int genPosIndex, int fishPreIndex, int num, int speed, int angSpeed)
{
for (int i = 0; i < num; i++)
{
GameObject fish = Instantiate(fishPrefabs[fishPreIndex]); // 实例化鱼的预制体
fish.transform.SetParent(fishHolder, false); // 设置鱼的父物体
fish.transform.localPosition = genPositions[genPosIndex].localPosition; // 设置鱼的本地位置
fish.transform.localRotation = genPositions[genPosIndex].localRotation; // 设置鱼的本地旋转
fish.GetComponent<SpriteRenderer>().sortingOrder += i; // 设置鱼的渲染层级
fish.AddComponent<Ef_AutoMove>().speed = speed; // 添加自动移动组件并设置速度
fish.AddComponent<Ef_AutoRotate>().speed = angSpeed; // 添加自动旋转组件并设置角速度
yield return new WaitForSeconds(fishGenWaitTime); // 等待一段时间后继续生成下一条鱼
}
}
}
多种炮台
多种炮台，点击按钮进行升级
多种子弹
升级后，子弹也会升级，伤害更高。
多种网
升级后，渔网的大小和形状也会升级，范围更大、消失时间更长
游戏控制器
游戏控制器（GameController）的脚本，负责管理游戏的各种逻辑和UI元素。
该脚本的功能和作用如下：
声明了GameController的单例模式，提供对唯一实例的访问。
声明了一系列用于显示UI的文本、按钮和滑动条等元素。
定义了一些游戏的变量，如等级（lv）、经验值（exp）、金币（gold）、倒计时等等。
声明了一些用于显示游戏背景、特效和子弹的元素，如背景图片（bgImage）、特效（fireEffect、changeEffect等）、子弹对象数组等。
在Awake函数中初始化GameController的实例。
在Start函数中读取之前保存的游戏数据，并更新UI的显示。
在Update函数中更新游戏逻辑，包括切换子弹的花费、开火、更新UI、切换背景等。
定义了ChangeBg函数，用于根据当前等级切换游戏背景。
定义了UpdateUI函数，用于更新游戏UI的显示，包括倒计时、金币、等级等。
定义了Fire函数，用于处理开火逻辑，生成子弹并扣除金币。
定义了ChangeBulletCost函数，用于根据鼠标滚轮的输入切换子弹花费。
定义了一些按钮的回调函数，如OnButtonPDown和OnButtonMDown，用于切换子弹花费。
定义了OnBigCountdownButtonDown函数，用于处理大倒计时按钮的点击事件。
定义了GoldNotEnough协程函数，用于在金币不足时显示提示信息。
该脚本是一个游戏控制器，负责管理游戏的逻辑、UI和各种元素的显示和交互。它处理了游戏中的等级、经验、金币、倒计时、背景切换、开火等功能，并提供了与UI元素交互的回调函数。
using System.Collections;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
public class GameController : MonoBehaviour
{
private static GameController _instance;
public static GameController Instance
{
get
{
return _instance;
}
}
// UI 元素的引用
public Text oneShootCostText; // 显示一次射击的花费
public Text goldText; // 显示金币数量
public Text lvText; // 显示等级
public Text lvNameText; // 显示等级名称
public Text smallCountdownText; // 显示小倒计时
public Text bigCountdownText; // 显示大倒计时
public Button bigCountdownButton; // 大倒计时按钮
public Button backButton; // 返回按钮
public Button settingButton; // 设置按钮
public Slider expSlider; // 经验条
// 游戏状态变量
public int lv = 0; // 等级
public int exp = 0; // 经验值
public int gold = 500; // 金币数量
public const int bigCountdown = 240; // 大倒计时常量
public const int smallCountdown = 60; // 小倒计时常量
public float bigTimer = bigCountdown; // 大倒计时计时器
public float smallTimer = smallCountdown; // 小倒计时计时器
public Color goldColor; // 金币的颜色
public int bgIndex = 0; // 背景索引
// 引用的游戏对象和精灵数组
public Image bgImage; // 背景图像
public GameObject lvUpTips; // 升级提示
public GameObject seaWaveEffect; // 海浪特效
public GameObject fireEffect; // 开火特效
public GameObject changeEffect; // 切换特效
public GameObject lvEffect; // 升级特效
public GameObject goldEffect; // 金币特效
public Transform bulletHolder; // 子弹容器
public Sprite[] bgSprites; // 背景精灵数组
public GameObject[] gunGos; // 枪支游戏对象数组
public GameObject[] bullet1Gos; // 炮弹1游戏对象数组
public GameObject[] bullet2Gos; // 炮弹2游戏对象数组
public GameObject[] bullet3Gos; // 炮弹3游戏对象数组
public GameObject[] bullet4Gos; // 炮弹4游戏对象数组
public GameObject[] bullet5Gos; // 炮弹5游戏对象数组
// 使用的是第几档的炮弹
private int costIndex = 0;
// 每一炮所需的金币数和造成的伤害值
private int[] oneShootCosts = {
5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 };
private string[] lvName = {
"新手", "入门", "钢铁", "青铜", "白银", "黄金", "白金", "钻石", "大师", "宗师" };
void Awake()
{
// 单例模式
_instance = this;
}
void Start()
{
// 从 PlayerPrefs 中获取存储的数据
gold = PlayerPrefs.GetInt("gold", gold);
lv = PlayerPrefs.GetInt("lv", lv);
exp = PlayerPrefs.GetInt("exp", exp);
smallTimer = PlayerPrefs.GetFloat("scd", smallCountdown);
bigTimer = PlayerPrefs.GetFloat("bcd", bigCountdown);
UpdateUI();
}
void Update()
{
// 更新各种状态和 UI
ChangeBulletCost();
Fire();
UpdateUI();
ChangeBg();
}
// 改变背景
void ChangeBg()
{
if (bgIndex != lv / 20)
{
// 根据等级计算背景索引
bgIndex = lv / 20;
AudioManager.Instance.PlayEffectSound(AudioManager.Instance.seaWaveClip);
Instantiate(seaWaveEffect);
if (bgIndex >= 3)
{
bgImage.sprite = bgSprites[3];
}
else
{
bgImage.sprite = bgSprites[bgIndex];
}
}
}
// 更新 UI
void UpdateUI()
{
bigTimer -= Time.deltaTime;
smallTimer -= Time.deltaTime;
if (smallTimer <= 0)
{
smallTimer = smallCountdown;
gold += 50;
}
if (bigTimer <= 0 && bigCountdownButton.gameObject.activeSelf == false)
{
bigCountdownText.gameObject.SetActive(false);
bigCountdownButton.gameObject.SetActive(true);
}
// 经验等级换算公式：升级所需经验=1000+200*当前等级
while (exp >= 1000 + 200 * lv)
{
exp = exp - (1000 + 200 * lv);
lv++;
lvUpTips.SetActive(true);
lvUpTips.transform.Find("Text").GetComponent<Text>().text = lv.ToString();
StartCoroutine(lvUpTips.GetComponent<Ef_HideSelf>().HideSelf(0.6f));
AudioManager.Instance.PlayEffectSound(AudioManager.Instance.lvUpClip);
Instantiate(lvEffect);
}
goldText.text = "$" + gold;
lvText.text = lv.ToString();
if ((lv / 10) <= 9)
{
lvNameText.text = lvName[lv / 10];
}
else
{
lvNameText.text = lvName[9];
}
smallCountdownText.text = " " + (int)smallTimer / 10 + " " + (int)smallTimer % 10;
bigCountdownText.text = (int)bigTimer + "s";
expSlider.value = ((float)exp) / (1000 + 200 * lv);
}
// 开火
void Fire()
{
GameObject[] useBullets = bullet5Gos;
int bulletIndex;
if (Input.GetMouseButtonDown(0) && EventSystem.current.IsPointerOverGameObject() == false)
{
if (gold - oneShootCosts[costIndex] >= 0)
{
switch (costIndex / 4)
{
case 0: useBullets = bullet1Gos; break;
case 1: useBullets = bullet2Gos; break;
case 2: useBullets = bullet3Gos; break;
case 3: useBullets = bullet4Gos; break;
case 4: useBullets = bullet5Gos; break;
}
bulletIndex = (lv % 10 >= 9) ? 9 : lv % 10;
gold -= oneShootCosts[costIndex];
AudioManager.Instance.PlayEffectSound(AudioManager.Instance.fireClip);
Instantiate(fireEffect);
GameObject bullet = Instantiate(useBullets[bulletIndex]);
bullet.transform.SetParent(bulletHolder, false);
bullet.transform.position = gunGos[costIndex / 4].transform.Find("FirePos").transform.position;
bullet.transform.rotation = gunGos[costIndex / 4].transform.Find("FirePos").transform.rotation;
bullet.GetComponent<BulletAttr>().damage = oneShootCosts[costIndex];
bullet.AddComponent<Ef_AutoMove>().dir = Vector3.up;
bullet.GetComponent<Ef_AutoMove>().speed = bullet.GetComponent<BulletAttr>().speed;
}
else
{
StartCoroutine(GoldNotEnough());
}
}
}
// 切换炮弹花费
void ChangeBulletCost()
{
if (Input.GetAxis("Mouse ScrollWheel") < 0)
{
OnButtonMDown();
}
if (Input.GetAxis("Mouse ScrollWheel") > 0)
{
OnButtonPDown();
}
}
// 点击 "+" 按钮
public void OnButtonPDown()
{
gunGos[costIndex / 4].SetActive(false);
costIndex++;
AudioManager.Instance.PlayEffectSound(AudioManager.Instance.changeClip);
Instantiate(changeEffect);
costIndex = (costIndex > oneShootCosts.Length - 1) ? 0 : costIndex;
gunGos[costIndex / 4].SetActive(true);
oneShootCostText.text = "$" + oneShootCosts[costIndex];
}
// 点击 "-" 按钮
public void OnButtonMDown()
{
gunGos[costIndex / 4].SetActive(false);
costIndex--;
AudioManager.Instance.PlayEffectSound(AudioManager.Instance.changeClip);
Instantiate(changeEffect);
costIndex = (costIndex < 0) ? oneShootCosts.Length - 1 : costIndex;
gunGos[costIndex / 4].SetActive(true);
oneShootCostText.text = "$" + oneShootCosts[costIndex];
}
// 点击大倒计时按钮
public void OnBigCountdownButtonDown()
{
gold += 500;
AudioManager.Instance.PlayEffectSound(AudioManager.Instance.rewardClip);
Instantiate(goldEffect);
bigCountdownButton.gameObject.SetActive(false);
bigCountdownText.gameObject.SetActive(true);
bigTimer = bigCountdown;
}
// 金币不足时的协程
IEnumerator GoldNotEnough()
{
goldText.color = goldColor;
goldText.color = Color.red;
yield return new WaitForSeconds(0.5f);
goldText.color = goldColor;
}
}
声音控制器
Awake(): 在对象被创建时调用，用于初始化音频管理器。它设置音频管理器的实例，并从PlayerPrefs中获取静音状态，并根据静音状态设置音频的播放状态。
SwitchMuteState(bool isOn): 切换静音状态的方法。根据传入的参数 isOn 来确定是否要静音。它会反转静音状态，并调用 DoMute() 方法以应用变更。
DoMute(): 根据静音状态来控制背景音乐的播放和暂停。如果静音，背景音乐会暂停播放；如果非静音，背景音乐会开始播放。
PlayEffectSound(AudioClip clip): 播放音效的方法。根据当前的静音状态，判断是否播放音效。如果非静音，会在世界坐标原点（Vector3.zero）处播放传入的音效剪辑。
using UnityEngine;
public class AudioManager : MonoBehaviour
{
private static AudioManager _instance;
public static AudioManager Instance
{
get
{
return _instance;
}
}
private bool isMute = false;
public bool IsMute
{
get
{
return isMute;
}
}
public AudioSource bgmAudioSource; // 背景音频源
public AudioClip seaWaveClip; // 海浪音频剪辑
public AudioClip goldClip; // 金币音频剪辑
public AudioClip rewardClip; // 奖励音频剪辑
public AudioClip fireClip; // 发射音频剪辑
public AudioClip changeClip; // 切换音频剪辑
public AudioClip lvUpClip; // 升级音频剪辑
void Awake()
{
_instance = this;
isMute = (PlayerPrefs.GetInt("mute", 0) == 0) ? false : true; // 从PlayerPrefs中获取静音状态
DoMute();
}
public void SwitchMuteState(bool isOn)
{
isMute = !isOn; // 切换静音状态
DoMute();
}
void DoMute()
{
if (isMute)
{
bgmAudioSource.Pause(); // 静音时暂停背景音乐
}
else
{
bgmAudioSource.Play(); // 恢复播放背景音乐
}
}
public void PlayEffectSound(AudioClip clip)
{
if (!isMute)
{
AudioSource.PlayClipAtPoint(clip, Vector3.zero); // 在世界坐标原点播放音效
}
}
}
游戏存档
Start(): 在对象启动时调用，用于初始化主场景的UI。它设置静音开关的初始状态，根据音频管理器的静音状态来确定切换按钮的选中状态。
SwitchMute(bool isOn): 切换静音状态的方法。根据传入的参数 isOn 来确定是否要静音。它调用音频管理器的 SwitchMuteState() 方法来切换静音状态。
OnBackButtonDown(): 返回按钮按下时调用的方法。它保存当前游戏状态（包括金币、等级、计时器、经验和静音状态）到 PlayerPrefs 中，并加载场景索引为 0 的场景。
OnSettingButtonDown(): 设置按钮按下时调用的方法。它激活设置面板，使其可见。
OnCloseButtonDown(): 关闭按钮按下时调用的方法。它隐藏设置面板，使其不可见。
using UnityEngine;
using UnityEngine.UI;
public class MainSceneUI : MonoBehaviour
{
public Toggle muteToogle; // 静音切换开关
public GameObject settingPanel; // 设置面板
void Start()
{
muteToogle.isOn = !AudioManager.Instance.IsMute; // 设置静音开关的初始状态为音频管理器的静音状态的相反值
}
public void SwitchMute(bool isOn)
{
AudioManager.Instance.SwitchMuteState(isOn); // 切换静音状态
}
public void OnBackButtonDown()
{
// 保存当前游戏状态到PlayerPrefs
PlayerPrefs.SetInt("gold", GameController.Instance.gold);
PlayerPrefs.SetInt("lv", GameController.Instance.lv);
PlayerPrefs.SetFloat("scd", GameController.Instance.smallTimer);
PlayerPrefs.SetFloat("bcd", GameController.Instance.bigTimer);
PlayerPrefs.SetInt("exp", GameController.Instance.exp);
int temp = (AudioManager.Instance.IsMute == false) ? 0 : 1;
PlayerPrefs.SetInt("mute", temp);
// 加载场景索引为0的场景
UnityEngine.SceneManagement.SceneManager.LoadScene(0);
}
public void OnSettingButtonDown()
{
settingPanel.SetActive(true); // 激活设置面板，使其可见
}
public void OnCloseButtonDown()
{
settingPanel.SetActive(false); // 关闭设置面板，使其不可见
}
}
游戏开始
using UnityEngine;
using UnityEngine.SceneManagement;
public class StartSceneUI : MonoBehaviour
{
public void NewGame()
{
// 删除已保存的游戏状态
PlayerPrefs.DeleteKey("gold");
PlayerPrefs.DeleteKey("lv");
PlayerPrefs.DeleteKey("exp");
PlayerPrefs.DeleteKey("scd");
PlayerPrefs.DeleteKey("bcd");
// 加载场景索引为1的场景（新游戏场景）
SceneManager.LoadScene(1);
}
public void OldGame()
{
// 加载场景索引为1的场景（继续游戏场景）
SceneManager.LoadScene(1);
}
public void OnCloseButton()
{
// 关闭应用程序
Application.Quit();
}
}