V3.4.1 整理script位置

Assets/Script/GameScript/Character.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 772abe5dcba09d147adebd1e32dd12fc
+guid: 860d67fa6b1173e4f8c8f84a289c7cfd
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/Script/GameScript/SideChannel.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 904366f9a1b2c0644bb656ed4643ca4a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/PlayMode.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 32d99ab4ab44caa4a9f6cf0055fb52b4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/TargetContainer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0fe001d5fdb52fa4f94525807abd47d4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/UI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c066499bb6961e844a1a4f1b3d5f2879
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/UI/StartMenuProbabilityPanel.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+public class StartMenuProbabilityPanel : MonoBehaviour
+{
+    public GameObject singleTargetLevelProbabilityPanel;
+    public GameObject startSceneData;
+    private SceneBlocksSet scenePrefabSet;
+
+    public List<TargetLevelProbabilityPanel> targetLevelProbabilityPanel = new List<TargetLevelProbabilityPanel>();
+
+    private void Start()
+    {
+        scenePrefabSet = startSceneData.GetComponent<StartSeneData>().scenePrefabSet;
+        for (int i = 0; i < scenePrefabSet.targetLevels.Length; i++)
+        {
+            Targets nowTarget = scenePrefabSet.targets[i];
+            targetLevelProbabilityPanel.Add(Instantiate(singleTargetLevelProbabilityPanel, transform).GetComponent<TargetLevelProbabilityPanel>());
+            targetLevelProbabilityPanel[i].IntializePanels(scenePrefabSet.GetLevelNumber(nowTarget), nowTarget.ToString());
+        }
+    }
+}

Assets/Script/UI/StartMenuProbabilityPanel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0195eb0e734c7e747bb7f8b669c80fe5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/UI/TargetLevelProbabilityPanel.cs

@@ -0,0 +1,268 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+public class TargetLevelProbabilityPanel : MonoBehaviour
+{
+    public GameObject singleLevelProbabilityPanel;
+    public GameObject targetTitleText;
+
+    private GameObject titleText;
+    public List<GameObject> singleLevelPanelsObjs = new List<GameObject>();
+    public List<SingleLevelProbabilityPanel> singleLevelPanels = new List<SingleLevelProbabilityPanel>();
+
+    private int panelNum = 0;
+
+    public void IntializePanels(int levelNum, string titleName)
+    {
+        // initialize target level probability panel size
+        float defaultWidth = singleLevelProbabilityPanel.GetComponent<RectTransform>().sizeDelta.x;
+        float defaultLevelHeight = singleLevelProbabilityPanel.GetComponent<RectTransform>().sizeDelta.y;
+        float titleHeight = targetTitleText.GetComponent<RectTransform>().sizeDelta.y;
+        float averageProbability = 1f / levelNum;
+        float lastLevelProbability = 1f - averageProbability * (levelNum - 1);
+        // Debug.Log("averageProbability: " + averageProbability);
+        transform.GetComponent<RectTransform>().sizeDelta = new Vector2(defaultWidth, (defaultLevelHeight * levelNum) + titleHeight);
+        // create title text
+        titleText = Instantiate(targetTitleText, transform);
+        titleText.GetComponent<TextMeshProUGUI>().text = titleName;
+        // create and initialize single level probability panels
+        for (int i = 0; i < levelNum; i++)
+        {
+            int tempIndex = i;
+            singleLevelPanelsObjs.Add(Instantiate(singleLevelProbabilityPanel, transform));
+            singleLevelPanels.Add(singleLevelPanelsObjs[i].GetComponent<SingleLevelProbabilityPanel>());
+            singleLevelPanels[i].InitializeLevelProbabilityPanel(i, i == levelNum - 1 ? lastLevelProbability : averageProbability);
+            //add onValueChanged event to slider and input field
+            singleLevelPanels[i].probabilitySlider.onValueChanged.AddListener((value) => OnProbabilityValueChange(value, tempIndex));
+            singleLevelPanels[i].inputField.onEndEdit.AddListener((value) => OnProbabilityValueChange(value, tempIndex));
+        }
+        panelNum = levelNum;
+    }
+
+    /// <summary>
+    /// Adds an event trigger entry to an event trigger.
+    /// </summary>
+    /// <param name="trigger">The event trigger object.</param>
+    /// <param name="type">The event trigger type.</param>
+    /// <param name="action">The event handler method to execute.</param>
+    private void AddEventTrigger(GameObject gameObject, EventTriggerType triggerType, System.Action<BaseEventData> action)
+    {
+        EventTrigger eventTrigger = gameObject.GetComponent<EventTrigger>();
+        if (eventTrigger == null)
+        {
+            eventTrigger = gameObject.AddComponent<EventTrigger>();
+        }
+        EventTrigger.Entry entry = new EventTrigger.Entry();
+        entry.eventID = triggerType;
+        entry.callback.AddListener(new UnityEngine.Events.UnityAction<BaseEventData>(action));
+        eventTrigger.triggers.Add(entry);
+    }
+
+    /// <summary>
+    /// On Probability Slider Value Change.Adjust other sliders' value to make sure the total value is 1.
+    /// </summary>
+    /// <param name="value">change to this value</param>
+    /// <param name="exceptedIndex">changed panel index</param>
+    private void OnProbabilityValueChange<T>(T value, int exceptedIndex)
+    {
+        float changedValue = 0f;
+        switch (value)
+        {
+            case float floatValue:
+                changedValue = floatValue;
+                break;
+            case string stringValue:
+                changedValue = float.Parse(stringValue);
+                // limit the value between 0 and 1
+                if(changedValue>1 && changedValue <=100)
+                {
+                    changedValue /= 100;
+                }else if(changedValue>100)
+                {
+                    changedValue = 1;
+                }
+                break;
+            default:
+                Debug.LogError("Invalid value type!");
+                throw new ArgumentException("Unsupported value type");
+        }
+        float newTotalValue = 0; // new total probability value without locked panel
+        int unlockedPanelNum = 0;
+        int remainCorrectionNum = panelNum;
+        float extraValue = 0; // the extra value after probability value changed
+        float maxLimitValue = 1; // the max value of unlocked panel permitted
+        float[] correctionValues = new float[panelNum];
+
+        // calculate total probability value
+        for (int i = 0; i < panelNum; i++)
+        {
+            // disable slider listener
+            singleLevelPanels[i].probabilitySlider.onValueChanged.RemoveAllListeners();
+            if (singleLevelPanels[i].UnLocked)
+            {
+                unlockedPanelNum++;
+                newTotalValue += (i == exceptedIndex ? changedValue : singleLevelPanels[i].ProbabilityValue);
+            }
+            else
+            {
+                // delete locked probability value from maxLimitValue
+                maxLimitValue -= singleLevelPanels[i].ProbabilityValue;
+            }
+        }
+        // only have one panel
+        if (panelNum == 1)
+        {
+            singleLevelPanels[exceptedIndex].SetProbability(1);
+            enableSliderListener();
+            return;
+        }
+        //only one panel is unlocked
+        if (unlockedPanelNum == 1)
+        {
+            // limit this panel value at maxLimitValue
+            singleLevelPanels[exceptedIndex].SetProbability(maxLimitValue);
+            enableSliderListener();
+            return;
+        }
+        // Calculate the average correction value
+        extraValue = newTotalValue - maxLimitValue;
+        // initialize correction value to each panel
+        correctionValues = Enumerable.Repeat(extraValue / (unlockedPanelNum - 1), panelNum).ToArray();
+        // make sure all probability value is not less than 0 and equal to 1
+        int iterationCount = 0;
+        while (remainCorrectionNum > 0)
+        {
+            iterationCount++;
+            (correctionValues, remainCorrectionNum) = reCalculateCorrectionValues(correctionValues, exceptedIndex, changedValue, extraValue, maxLimitValue);
+            // protect the infinite loop
+            if (iterationCount >= 100)
+            {
+                Debug.LogError("Infinite loop detected!");
+                break;
+            }
+        }
+
+        // applicate the value to all unlocked panels excepted the changed one
+        applyCorrectionValue(correctionValues);
+        enableSliderListener();
+    }
+
+    /// <summary>
+    /// enable all sliders' onValueChanged action listener
+    /// </summary>
+    private void enableSliderListener()
+    {
+        for (int i = 0; i < panelNum; i++)
+        {
+            int tempIndex = i;
+            singleLevelPanels[i].probabilitySlider.onValueChanged.AddListener((value) => OnProbabilityValueChange(value, tempIndex));
+        }
+    }
+
+    /// <summary>
+    /// calculate the correction value to each panel,while the total value is not equal to 1
+    /// </summary>
+    private (float[], int) reCalculateCorrectionValues(float[] correctionValues, int exceptedIndex, float value, float extraValue, float maxLimitValue)
+    {
+        // the number of panels which need to be corrected in next iteration
+        int remainCorrectionNum = 0;
+        List<int> reCorrectionIndex = new List<int>();
+        // the index of the last panel which need to be corrected in this iteration
+        int lastReCorrectionIndex = 0;
+        // another extra value after correctionValue applicate to probability value which value also less than 0
+        // this value will be added to the panel which value is bigger.
+        float underZeroExtraValueAfterCorrected = 0;
+        for (int i = 0; i < panelNum; ++i)
+        {
+            // if the panel is the changed one
+            if (i == exceptedIndex)
+            {
+                // limit the value under maxLimitValue
+                correctionValues[i] = value > maxLimitValue ? (singleLevelPanels[i].ProbabilityValue - maxLimitValue) : (singleLevelPanels[i].ProbabilityValue - value);
+                continue;
+            }
+            // if the panel is locked
+            if (singleLevelPanels[i].IsLocked)
+            {
+                correctionValues[i] = 0;
+                continue;
+            }
+            // if the panel is unlocked
+            // and the probability value is less than 0 or bigger than maxLimitValue
+            if (singleLevelPanels[i].ProbabilityValue < 0 || singleLevelPanels[i].ProbabilityValue > maxLimitValue)
+            {
+                // correct this panel value to 0 or maxLimitValue
+                correctionValues[i] = singleLevelPanels[i].ProbabilityValue;
+            }
+            // probability value will be correct to 0
+            else if (singleLevelPanels[i].ProbabilityValue == correctionValues[i])
+            {
+                // that's good keep this correction value, and add it to the extraValue
+                underZeroExtraValueAfterCorrected += correctionValues[i];
+            }
+            // probability value will be correct over the limit (bigger than maxLimitValue or less than 0)
+            else if (singleLevelPanels[i].ProbabilityValue - correctionValues[i] < 0 || singleLevelPanels[i].ProbabilityValue - correctionValues[i] > maxLimitValue)
+            {
+                // should be corrected to 0 or maxLimitValue,and add it to the extraValue
+                underZeroExtraValueAfterCorrected += singleLevelPanels[i].ProbabilityValue;
+                correctionValues[i] = singleLevelPanels[i].ProbabilityValue;
+            }
+            // left panels correction value which need to be re-corrected
+            else
+            {
+                lastReCorrectionIndex = i;
+                reCorrectionIndex.Add(i);
+            }
+        }
+        foreach (int index in reCorrectionIndex)
+        {
+            // calculate the average correction value
+            float newAverageCorrectionValue = (extraValue - underZeroExtraValueAfterCorrected) / reCorrectionIndex.Count;
+            // if the panel is the last one which need to be corrected.
+            // Avoidance of floating-point rounding error, the last panel correction value will be the extraValue minus the sum of the other panels correction value
+            if (index == lastReCorrectionIndex)
+            {
+                correctionValues[index] = extraValue - (newAverageCorrectionValue * (reCorrectionIndex.Count - 1));
+                // still out of limit after correction, correct it to 0 and activate next iteration
+                if (singleLevelPanels[index].ProbabilityValue - correctionValues[index] < 0 || singleLevelPanels[index].ProbabilityValue - correctionValues[index] > maxLimitValue)
+                {
+                    correctionValues[index] = singleLevelPanels[index].ProbabilityValue;
+                    remainCorrectionNum++;
+                }
+            }
+            else
+            {
+                correctionValues[index] = newAverageCorrectionValue;
+                // still out of limit after correction, correct it to 0 and activate next iteration
+                if (singleLevelPanels[index].ProbabilityValue - correctionValues[index] < 0 || singleLevelPanels[index].ProbabilityValue - correctionValues[index] > maxLimitValue)
+                {
+                    correctionValues[index] = singleLevelPanels[index].ProbabilityValue;
+                    remainCorrectionNum++;
+                }
+            }
+        }
+        return (correctionValues, remainCorrectionNum);
+    }
+
+    /// <summary>
+    /// applicate correction value to each panel
+    /// </summary>
+    private void applyCorrectionValue(float[] correctionValues)
+    {
+        for (int i = 0; i < panelNum; i++)
+        {
+            /*            if (singleLevelPanels[i].ProbabilityValue - correctionValues[i] < 0)
+                        {
+                            Debug.LogWarning("Probability value is less than 0");
+                            Debug.Log(i);
+                            Debug.Log(singleLevelPanels[i].ProbabilityValue);
+                            Debug.Log(correctionValues[i]);
+                        }*/
+            singleLevelPanels[i].SetProbability(singleLevelPanels[i].ProbabilityValue - correctionValues[i]);
+        }
+    }
+}

Assets/Script/UI/TargetLevelProbabilityPanel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 44de9c40b3fc56046a490c8c47631d4d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/UI/UIColorContainer.cs

@@ -0,0 +1,18 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class UIColorContainer : MonoBehaviour
+{
+    // Start is called before the first frame update
+    void Start()
+    {
+        
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        
+    }
+}

Assets/Script/UI/UIColorContainer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3fef23608d0a5d242a781d8ca28ed23b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: