smart-bow-infrared/Assets/ShotSimulator/Scripts/TrainHandle/Customize/CustomizeTrainHandle.cs

using LitJson;
using ShotSimulator.Target;
using ShotSimulator.Tool;
using ShotSimulator.Train.Info;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using Random = UnityEngine.Random;

namespace ShotSimulator.Train
{
    public class CustomizeTrainHandle : BaseTrainHandle
    {
        private int maxTargetNum = 3;

        private List<TimeTask> generateTargetTimeTasks = new List<TimeTask>();

        private double score;
        private double totalHitNum;
        private double totalTargetNum;
        private double missHitNum;

        private List<SphereShotTarget> curTargets = new List<SphereShotTarget>();

        private List<Vector3> configPositions = new List<Vector3>();

#if UNITY_EDITOR || UNITY_STANDALONE
        private readonly string configJsonPath = @"D:\ShotSimulatorCustomizeTrainConfig.json";
#elif UNITY_ANDROID
        private readonly string configJsonPath = @"/storage/emulated/0/ShotSimulatorCustomizeTrainConfig.json";
#else
        private readonly string configJsonPath = "";
#endif
        public CustomizeTrainHandle(BaseTrainCallBack callBack, BaseTrainInfo info, DifficultyType difficultyType) : base(callBack, info, difficultyType)
        {
            SetShotTargetInteractiveEvent(ShotTargetInteractiveType.OnClick, OnShottedTargetEvent);

        }

        #region Train
        private void InitConfig()
        {
            JsonData data = FileTool.ReadJson(configJsonPath);
            for (int i = 0; i < data.Count; i++)
            {
                JsonData value = data[i];
                float x = Convert.ToSingle(value["x"].ToString());
                float y = Convert.ToSingle(value["y"].ToString());
                float z = Convert.ToSingle(value["z"].ToString());
                configPositions.Add(new Vector3(x, y, z));
            }
        }
        protected override void ResetTrain()
        {
            ResetTarget();

            for (int i = 0; i < generateTargetTimeTasks.Count; i++)
            {
                TimerSystem.GetInstance().RemoveTimeTask(generateTargetTimeTasks[i]);
            }
            generateTargetTimeTasks.Clear();
            configPositions.Clear();
            score = 0;
            totalHitNum = 0;
            totalTargetNum = 0;
            missHitNum = 0;
        }
        public override void StartTrain()
        {
            base.StartTrain();
            ResetTrain();
            InitConfig();
            InitShotTargets();
        }

        public override void PauseTrain()
        {
            base.PauseTrain();

            foreach (var timer in generateTargetTimeTasks)
            {
                timer.pause = true;
            }
        }

        public override void ContinueTrain()
        {
            base.ContinueTrain();

            foreach (var timer in generateTargetTimeTasks)
            {
                timer.pause = false;
            }
        }

        public override void CalculateTrainResult()
        {
            score = totalHitNum * 2;
            SetResultMetricsDataValue(MetricsType.Score, score);
            SetResultMetricsDataValue(MetricsType.Precision, Math.Round(totalHitNum / (totalHitNum + missHitNum), 2));
            SetResultMetricsDataValue(MetricsType.TimeToKill, Math.Round(TrainInfo.duration / totalHitNum, 2));
            SetResultMetricsDataValue(MetricsType.Kill_Sec, Math.Round(totalHitNum / TrainInfo.duration, 2));
            SetResultMetricsDataValue(MetricsType.Target, totalTargetNum);
            SetResultMetricsDataValue(MetricsType.KillTotal, totalHitNum);
        }
        #endregion

        #region ShootTarget
        private void OnShottedTargetEvent(BaseShotTarget target)
        {
            if (target != null)
            {
                totalHitNum++;
                DestroyShootTarget(target as SphereShotTarget);
                generateTargetTimeTasks.Add(TimerSystem.GetInstance().AddTimeTask(GenerateShotTarget, 0.5f));
            }
            else
            {
                missHitNum++;
            }
        }
        #endregion
        private void InitShotTargets()
        {
            int num = configPositions.Count - curTargets.Count;
            for (int i = 0; i < num; i++)
            {
                GenerateShotTarget();
            }
        }

        private void GenerateShotTarget()
        {
            GameObject obj = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/SphereTarget"));
            SphereShotTarget target = obj.GetComponent<SphereShotTarget>();
            target.IsRunning = true;
            target.onClickCanChangeColor = false;
            target.onHoveringCanChangeColor = false;
            target.defaultColor = Color.green;
            target.Init(1, ReduceHealthTriggerType.OnClick, false, ReduceHealthType.Per, MotionType.None, GetPosition());
            curTargets.Add(target);
            totalTargetNum++;
        }

        private Vector3 GetPosition()
        {
            for (int i = 0; i < configPositions.Count; i++)
            {
                if (!CurrentTargetsIsPos(configPositions[i]))
                {
                    return configPositions[i];
                }
            }
            return Vector3.zero;
        }

        private bool CurrentTargetsIsPos(Vector3 pos)
        {
            for (int i = 0; i < curTargets.Count; i++)
            {
                if (curTargets[i].transform.position == pos)
                {
                    return true;
                }
            }
            return false;
        }

        private void DestroyShootTarget(SphereShotTarget target)
        {
            if (target != null)
            {
                curTargets.Remove(target);
                target.IsRunning = false;
                GameObject.Destroy(target.gameObject);
            }
        }

        private void ResetTarget()
        {
            for (int i = 0; i < curTargets.Count; i++)
            {
                curTargets[i].IsRunning = false;
                GameObject.Destroy(curTargets[i].gameObject);
            }
            curTargets.Clear();
        }
    }
}