329 lines
9.0 KiB
C#
329 lines
9.0 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.EventSystems;
|
|
|
|
public class Utils
|
|
{
|
|
public static List<Vector3> GenerateSmoothPoints(Vector3 pStartP, Vector3 pEndP, float pDelta)
|
|
{
|
|
List<Vector3> tPointList = new List<Vector3>();
|
|
|
|
Vector3 tDir = (pEndP - pStartP).normalized;
|
|
|
|
Vector3 tNextP = pStartP;
|
|
while ((pEndP - tNextP).magnitude > pDelta)
|
|
{
|
|
tNextP = tNextP + tDir * pDelta;
|
|
tPointList.Add(tNextP);
|
|
}
|
|
|
|
return tPointList;
|
|
}
|
|
|
|
public static long DateToTimestamp(DateTime pDate)
|
|
{
|
|
DateTime tDate1970 = new DateTime(1970, 1, 1, 0, 0, 0, 0);
|
|
return (pDate.Ticks - tDate1970.Ticks) / 10000000;
|
|
}
|
|
|
|
public static DateTime TimestampToDate(long tTimestamp)
|
|
{
|
|
DateTime tDate1970 = new DateTime(1970, 1, 1, 0, 0, 0, 0);
|
|
long t = tDate1970.Ticks + tTimestamp * 10000000;
|
|
return new DateTime(t);
|
|
}
|
|
|
|
public static float GetClipLength(Animator pAnimator, string pClipName)
|
|
{
|
|
if (pAnimator == null || pAnimator.runtimeAnimatorController == null)
|
|
return 0;
|
|
|
|
AnimationClip[] tClips = pAnimator.runtimeAnimatorController.animationClips;
|
|
if (tClips == null || tClips.Length <= 0)
|
|
return 0;
|
|
|
|
AnimationClip tClip;
|
|
for (int i = 0; i < tClips.Length; i++)
|
|
{
|
|
tClip = tClips[i];
|
|
if (tClip != null && tClip.name.Equals(pClipName))
|
|
return tClip.length;
|
|
}
|
|
return 0f;
|
|
}
|
|
|
|
public static int GetRandomIndex(int pTotalCount, List<int> pMaskList)
|
|
{
|
|
List<int> tFilterList = new List<int>();
|
|
for (int i = 0; i < pTotalCount; i++)
|
|
{
|
|
if (!pMaskList.Contains(i))
|
|
tFilterList.Add(i);
|
|
}
|
|
|
|
int tRandomIndex = tFilterList[UnityEngine.Random.Range(0, tFilterList.Count)];
|
|
|
|
if (!pMaskList.Contains(tRandomIndex))
|
|
pMaskList.Add(tRandomIndex);
|
|
|
|
return tRandomIndex;
|
|
}
|
|
|
|
public static void CheckDirectory(string tRootPath, string tSubPath)
|
|
{
|
|
string tDirectoryPath = tRootPath;
|
|
string[] tFolderNames = tSubPath.Split('/');
|
|
|
|
if (tFolderNames.Length > 1)
|
|
{
|
|
for (int i = 0; i < tFolderNames.Length - 1; i++)
|
|
{
|
|
tDirectoryPath = Path.Combine(tDirectoryPath, tFolderNames[i]);
|
|
if (!Directory.Exists(tDirectoryPath))
|
|
{
|
|
Directory.CreateDirectory(tDirectoryPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static List<T> GetChildList<T>(Transform pParent)
|
|
{
|
|
List<T> tList = new List<T>();
|
|
|
|
T[] tComs = pParent.GetComponentsInChildren<T>(true);
|
|
for (int i = 0; i < tComs.Length; i++)
|
|
{
|
|
tList.Add(tComs[i]);
|
|
}
|
|
|
|
return tList;
|
|
}
|
|
|
|
public static List<T> GetChildListFirstLayer<T>(Transform pParent)
|
|
{
|
|
List<T> tList = new List<T>();
|
|
|
|
for (int i = 0; i < pParent.childCount; i++)
|
|
{
|
|
T tCom = pParent.GetChild(i).GetComponent<T>();
|
|
tList.Add(tCom);
|
|
}
|
|
|
|
return tList;
|
|
}
|
|
|
|
public static void NormalizeGameObject(GameObject pGob)
|
|
{
|
|
pGob.transform.localPosition = Vector3.zero;
|
|
pGob.transform.localRotation = Quaternion.identity;
|
|
pGob.transform.localScale = Vector3.one;
|
|
}
|
|
|
|
public static void DelayShowGameObject(GameObject pGob, float pDelay)
|
|
{
|
|
pGob.SetActive(false);
|
|
TimerManager.Instance.Schedule(() => pGob.SetActive(true), pDelay);
|
|
}
|
|
|
|
public static void DelayHideGameObject(GameObject pGob, float pDelay)
|
|
{
|
|
TimerManager.Instance.Schedule(() => pGob.SetActive(false), pDelay);
|
|
}
|
|
|
|
public static float Clamp360(float pOriginal, float pOffset = 0)
|
|
{
|
|
float tResult = pOriginal;
|
|
while (tResult < 0 + pOffset)
|
|
{
|
|
tResult += 360;
|
|
}
|
|
|
|
while (tResult > 360 + pOffset)
|
|
{
|
|
tResult -= 360;
|
|
}
|
|
|
|
return tResult;
|
|
}
|
|
|
|
public static void SetGameSpeed(float pSpeed)
|
|
{
|
|
Time.timeScale = pSpeed;
|
|
Time.fixedDeltaTime = 0.02f * Time.timeScale;
|
|
}
|
|
|
|
public static WarUnitAttr GetWarUnitAttrFromCard(BlockType pBType, int pLevel)
|
|
{
|
|
CardData tCard = GameConfig.Instance.GetCardData(GetCardID(pBType, pLevel));
|
|
|
|
WarUnitAttr tAttr = new WarUnitAttr();
|
|
|
|
tAttr.MaxHP = tCard.MaxHp / tCard.GroupNum;
|
|
tAttr.Damage = tCard.Damage / tCard.GroupNum;
|
|
|
|
tAttr.MoveSpeed = GameConfig.Instance.UnitSpeed;
|
|
|
|
tAttr.AtkType = AttackType.Far;// pBType == BlockType.Monster ? AttackType.Near : AttackType.Far;
|
|
tAttr.AtkDistance = pBType == BlockType.Monster ? 6 : 12;
|
|
|
|
return tAttr;
|
|
}
|
|
|
|
public static string GetCardID(BlockType pBType, int pLevel)
|
|
{
|
|
return pBType + "_" + pLevel.ToString("D2");
|
|
}
|
|
|
|
public static int CountDamage(int pAttackerLv, int pSuffererLv, int pDamage)
|
|
{
|
|
int tLevelDelta = Mathf.Max(pSuffererLv - pAttackerLv, 0);
|
|
float tRatio = Mathf.Max(1 - tLevelDelta * 0.08f, 0.6f);
|
|
return (int)(tRatio * pDamage);
|
|
}
|
|
|
|
public static bool IsHuman(string pCardID)
|
|
{
|
|
return pCardID.Contains("Human");
|
|
}
|
|
|
|
public static bool IsMonster(string pCardID)
|
|
{
|
|
return pCardID.Contains("Monster");
|
|
}
|
|
|
|
public static float GetHpHOffset(BlockType pBType, int pLevel)
|
|
{
|
|
float tHOffset = 4;
|
|
if (pBType == BlockType.Monster)
|
|
{
|
|
switch (pLevel)
|
|
{
|
|
case 1: tHOffset = 2f; break;
|
|
case 2: tHOffset = 2f; break;
|
|
case 3: tHOffset = 3f; break;
|
|
case 4: tHOffset = 3f; break;
|
|
case 5: tHOffset = 3.5f; break;
|
|
case 6: tHOffset = 4f; break;
|
|
case 7: tHOffset = 4.5f; break;
|
|
case 8: tHOffset = 3.5f; break;
|
|
case 9: tHOffset = 4f; break;
|
|
case 10: tHOffset = 5f; break;
|
|
}
|
|
}
|
|
else if (pBType == BlockType.Human)
|
|
{
|
|
switch (pLevel)
|
|
{
|
|
case 1: tHOffset = 2f; break;
|
|
case 2: tHOffset = 2f; break;
|
|
case 3: tHOffset = 3f; break;
|
|
case 4: tHOffset = 3f; break;
|
|
case 5: tHOffset = 3.5f; break;
|
|
case 6: tHOffset = 4f; break;
|
|
case 7: tHOffset = 4.5f; break;
|
|
case 8: tHOffset = 5f; break;
|
|
case 9: tHOffset = 5.2f; break;
|
|
case 10: tHOffset = 6f; break;
|
|
}
|
|
}
|
|
|
|
return tHOffset;
|
|
}
|
|
|
|
public static float GetHpScale(BlockType pBType, int pLevel)
|
|
{
|
|
float tScale = 1;
|
|
if (pBType == BlockType.Monster)
|
|
{
|
|
switch (pLevel)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4: tScale = 0.5f; break;
|
|
case 5:
|
|
case 6:
|
|
case 7: tScale = 0.8f; break;
|
|
case 8: tScale = 1f; break;
|
|
case 9:
|
|
case 10: tScale = 1.2f; break;
|
|
}
|
|
}
|
|
else if (pBType == BlockType.Human)
|
|
{
|
|
switch (pLevel)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5: tScale = 0.5f; break;
|
|
case 6: tScale = 0.5f; break;
|
|
case 7: tScale = 0.6f; break;
|
|
case 8: tScale = 0.7f; break;
|
|
case 9: tScale = 0.8f; break;
|
|
case 10: tScale = 1f; break;
|
|
}
|
|
}
|
|
|
|
return tScale;
|
|
}
|
|
|
|
public static float GetAtkAniLength(BlockType pBType, int pLevel)
|
|
{
|
|
float tLength = 1;
|
|
if (pBType == BlockType.Monster)
|
|
{
|
|
switch (pLevel)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3: tLength = 1.167f; break;
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7: tLength = 1f; break;
|
|
}
|
|
}
|
|
else if (pBType == BlockType.Human)
|
|
{
|
|
switch (pLevel)
|
|
{
|
|
case 1:
|
|
case 2: tLength = 1.033f; break;
|
|
case 3:
|
|
case 4: tLength = 1.333f; break;
|
|
case 5:
|
|
case 6:
|
|
case 7: tLength = 1f; break;
|
|
}
|
|
}
|
|
|
|
return tLength;
|
|
}
|
|
|
|
public static int GetBpByLv(int pLevel)
|
|
{
|
|
int tBP = 10;
|
|
|
|
switch (pLevel)
|
|
{
|
|
case 1: tBP = 10; break;
|
|
case 2: tBP = 24; break;
|
|
case 3: tBP = 56; break;
|
|
case 4: tBP = 138; break;
|
|
case 5: tBP = 332; break;
|
|
case 6: tBP = 796; break;
|
|
case 7: tBP = 1910; break;
|
|
case 8: tBP = 4586; break;
|
|
case 9: tBP = 11008; break;
|
|
case 10: tBP = 26418; break;
|
|
}
|
|
|
|
return tBP;
|
|
}
|
|
} |