504 lines
12 KiB
C#
504 lines
12 KiB
C#
using System.Collections.Generic;
|
|
using BitStrap;
|
|
using UnityEngine;
|
|
|
|
public class SpinningMethodController : MonoBehaviour
|
|
{
|
|
public enum SpinningMethod
|
|
{
|
|
NONE = 0,
|
|
STRAIGHT_SLOW = 1,
|
|
STRAIGHT = 2,
|
|
STRAIGHT_FAST = 3,
|
|
LIFT_DROP = 4,
|
|
STOP_GO = 5,
|
|
TWITCHING = 6
|
|
}
|
|
|
|
public enum SpinningState
|
|
{
|
|
MOVE_SLOW = 0,
|
|
MOVE_MEDIUM = 1,
|
|
MOVE_FAST = 2,
|
|
JERK = 3,
|
|
GROUND = 4,
|
|
IDLE = 5
|
|
}
|
|
|
|
[HideInInspector]
|
|
public Bait bait;
|
|
|
|
[HideInInspector]
|
|
public FishingFloat fishingFloat;
|
|
|
|
[HideInInspector]
|
|
public FishingHands fishingHands;
|
|
|
|
[ReadOnly]
|
|
public SpinningMethod currentSpinningMethod;
|
|
|
|
[ReadOnly]
|
|
public int currentSpinningLevel = 1;
|
|
|
|
[ReadOnly]
|
|
public SpinningState currentSpinningState = SpinningState.IDLE;
|
|
|
|
[ReadOnly]
|
|
public List<SpinningState> spinningStates = new List<SpinningState>();
|
|
|
|
[ReadOnly]
|
|
public List<int> spinningStatesLevel = new List<int>();
|
|
|
|
[ReadOnly]
|
|
public SpinningState currentSpinningEvent = SpinningState.IDLE;
|
|
|
|
[ReadOnly]
|
|
public float stateCheckTimer;
|
|
|
|
[ReadOnly]
|
|
public float noMethodTimer;
|
|
|
|
private const float noMethodDelay = 18f;
|
|
|
|
public int rememberedStates = 40;
|
|
|
|
public Vector3 levelThresholds = new Vector3(5f, 10f, 15f);
|
|
|
|
public Vector3 levelThresholdsTwitching = new Vector3(10f, 20f, 30f);
|
|
|
|
public Vector3 levelThresholdsStopGo = new Vector3(20f, 40f, 60f);
|
|
|
|
public float[] levelMultipliers = new float[3] { 1f, 1.15f, 1.3f };
|
|
|
|
public float stateCheckDelay = 0.5f;
|
|
|
|
[ReadOnly]
|
|
public int fishCatchMethodLevel;
|
|
|
|
private void Start()
|
|
{
|
|
stateCheckTimer = stateCheckDelay;
|
|
for (int i = 0; i < rememberedStates; i++)
|
|
{
|
|
spinningStates.Add(SpinningState.IDLE);
|
|
}
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (fishingHands == null || fishingHands != fishingHands.fishingPlayer.currentHands || fishingHands.isFloatRig || fishingHands.isGroundRig || !fishingHands.ThrowObjectOnWater() || fishingHands.fishingPlayer.IsSomethingOnBait())
|
|
{
|
|
return;
|
|
}
|
|
stateCheckTimer -= Time.deltaTime;
|
|
if (stateCheckTimer <= 0f)
|
|
{
|
|
stateCheckTimer = stateCheckDelay;
|
|
AddSpinningState(currentSpinningEvent, Random.Range(1, 4));
|
|
currentSpinningEvent = SpinningState.IDLE;
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.NONE && !GameController.Instance.iceLevel)
|
|
{
|
|
noMethodTimer -= Time.deltaTime;
|
|
if (noMethodTimer <= 0f)
|
|
{
|
|
HUDManager.Instance.ShowMessage(Utilities.GetTranslation("HUD_MESSAGE/NO_LURING_METHOD"));
|
|
noMethodTimer = 18f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
noMethodTimer = 18f;
|
|
}
|
|
}
|
|
|
|
public void SpinningStateEvent(SpinningState state)
|
|
{
|
|
if (currentSpinningEvent != SpinningState.GROUND || state != SpinningState.GROUND)
|
|
{
|
|
}
|
|
switch (state)
|
|
{
|
|
case SpinningState.MOVE_SLOW:
|
|
currentSpinningEvent = SpinningState.MOVE_SLOW;
|
|
break;
|
|
case SpinningState.MOVE_MEDIUM:
|
|
currentSpinningEvent = SpinningState.MOVE_MEDIUM;
|
|
break;
|
|
case SpinningState.MOVE_FAST:
|
|
currentSpinningEvent = SpinningState.MOVE_FAST;
|
|
break;
|
|
case SpinningState.JERK:
|
|
{
|
|
for (int i = 0; i < 1; i++)
|
|
{
|
|
if (spinningStates[i] == SpinningState.JERK)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
currentSpinningEvent = SpinningState.IDLE;
|
|
stateCheckTimer = stateCheckDelay;
|
|
AddSpinningState(SpinningState.JERK, 1);
|
|
break;
|
|
}
|
|
case SpinningState.GROUND:
|
|
currentSpinningEvent = SpinningState.GROUND;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void AddSpinningState(SpinningState state, int level)
|
|
{
|
|
for (int num = rememberedStates - 1; num >= 0; num--)
|
|
{
|
|
if (num >= 1)
|
|
{
|
|
spinningStates[num] = spinningStates[num - 1];
|
|
}
|
|
else
|
|
{
|
|
spinningStates[num] = state;
|
|
}
|
|
}
|
|
CheckSpinningMethod();
|
|
}
|
|
|
|
public void CheckSpinningMethod()
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
currentSpinningLevel = 0;
|
|
if (currentSpinningMethod == SpinningMethod.NONE && spinningStates[0] == SpinningState.MOVE_SLOW)
|
|
{
|
|
for (int i = 0; i < rememberedStates; i++)
|
|
{
|
|
if (spinningStates[i] != SpinningState.MOVE_SLOW)
|
|
{
|
|
if ((float)i < levelThresholds.x)
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
}
|
|
break;
|
|
}
|
|
currentSpinningLevel = i;
|
|
currentSpinningMethod = SpinningMethod.STRAIGHT_SLOW;
|
|
}
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.NONE && spinningStates[0] == SpinningState.MOVE_MEDIUM)
|
|
{
|
|
for (int j = 0; j < rememberedStates; j++)
|
|
{
|
|
if (spinningStates[j] != SpinningState.MOVE_MEDIUM)
|
|
{
|
|
if ((float)j < levelThresholds.x)
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
}
|
|
break;
|
|
}
|
|
currentSpinningLevel = j;
|
|
currentSpinningMethod = SpinningMethod.STRAIGHT;
|
|
}
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.NONE && spinningStates[0] == SpinningState.MOVE_FAST)
|
|
{
|
|
for (int k = 0; k < rememberedStates; k++)
|
|
{
|
|
if (spinningStates[k] != SpinningState.MOVE_FAST)
|
|
{
|
|
if ((float)k < levelThresholds.x)
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
}
|
|
break;
|
|
}
|
|
currentSpinningLevel = k;
|
|
currentSpinningMethod = SpinningMethod.STRAIGHT_FAST;
|
|
}
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.NONE && (spinningStates[0] == SpinningState.JERK || IsMoving(spinningStates[0])))
|
|
{
|
|
int num = 0;
|
|
bool flag = false;
|
|
Vector2 vector = new Vector2(2f, 5f);
|
|
bool flag2 = false;
|
|
for (int l = 0; (float)l <= vector.y + 1f; l++)
|
|
{
|
|
if (spinningStates[l] == SpinningState.JERK)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
}
|
|
if (flag2)
|
|
{
|
|
bool flag3 = IsMoving(spinningStates[0]);
|
|
if (flag3)
|
|
{
|
|
num = 1;
|
|
}
|
|
for (int m = 1; m < rememberedStates; m++)
|
|
{
|
|
if (!IsMoving(spinningStates[m]) && spinningStates[m] != SpinningState.JERK)
|
|
{
|
|
flag = true;
|
|
}
|
|
else if (IsMoving(spinningStates[m]))
|
|
{
|
|
num++;
|
|
if ((float)num > vector.y)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else if (spinningStates[m] == SpinningState.JERK)
|
|
{
|
|
if ((float)num < vector.x && !flag3)
|
|
{
|
|
flag = true;
|
|
}
|
|
num = 0;
|
|
flag3 = false;
|
|
}
|
|
if (flag)
|
|
{
|
|
if ((float)m < levelThresholdsTwitching.x)
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
}
|
|
break;
|
|
}
|
|
currentSpinningLevel = m;
|
|
currentSpinningMethod = SpinningMethod.LIFT_DROP;
|
|
}
|
|
}
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.NONE && (spinningStates[0] == SpinningState.GROUND || IsMovingOrIdle(spinningStates[0])))
|
|
{
|
|
bool flag4 = false;
|
|
int num2 = 0;
|
|
Vector2 vector2 = new Vector2(1f, 10f);
|
|
int num3 = 0;
|
|
Vector2 vector3 = new Vector2(1f, 5f);
|
|
bool flag5 = false;
|
|
for (int n = 0; (float)n <= vector2.y + 1f; n++)
|
|
{
|
|
if (spinningStates[n] == SpinningState.GROUND)
|
|
{
|
|
flag5 = true;
|
|
}
|
|
}
|
|
if (flag5)
|
|
{
|
|
if (IsMovingOrIdle(spinningStates[0]))
|
|
{
|
|
num2 = 1;
|
|
}
|
|
for (int num4 = 1; num4 < rememberedStates; num4++)
|
|
{
|
|
if (!IsMovingOrIdle(spinningStates[num4]) && spinningStates[num4] != SpinningState.GROUND)
|
|
{
|
|
flag4 = true;
|
|
}
|
|
else if (IsMovingOrIdle(spinningStates[num4]))
|
|
{
|
|
num3 = 0;
|
|
num2++;
|
|
if ((float)num2 > vector2.y)
|
|
{
|
|
flag4 = true;
|
|
}
|
|
}
|
|
else if (spinningStates[num4] == SpinningState.GROUND)
|
|
{
|
|
num2 = 0;
|
|
num3++;
|
|
if ((float)num3 > vector3.y)
|
|
{
|
|
flag4 = true;
|
|
}
|
|
bool flag6 = false;
|
|
}
|
|
if (flag4)
|
|
{
|
|
if ((float)num4 < levelThresholdsStopGo.x)
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
}
|
|
break;
|
|
}
|
|
currentSpinningLevel = num4;
|
|
currentSpinningMethod = SpinningMethod.STOP_GO;
|
|
}
|
|
}
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.NONE && (spinningStates[0] == SpinningState.JERK || spinningStates[0] == SpinningState.IDLE))
|
|
{
|
|
int num5 = 0;
|
|
bool flag7 = false;
|
|
Vector2 vector4 = new Vector2(2f, 5f);
|
|
bool flag8 = false;
|
|
for (int num6 = 0; (float)num6 <= vector4.y + 1f; num6++)
|
|
{
|
|
if (spinningStates[num6] == SpinningState.JERK)
|
|
{
|
|
flag8 = true;
|
|
}
|
|
}
|
|
if (flag8)
|
|
{
|
|
bool flag9 = spinningStates[0] == SpinningState.IDLE;
|
|
if (flag9)
|
|
{
|
|
num5 = 1;
|
|
}
|
|
for (int num7 = 1; num7 < rememberedStates; num7++)
|
|
{
|
|
if (spinningStates[num7] != SpinningState.IDLE && spinningStates[num7] != SpinningState.JERK)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
else if (spinningStates[num7] == SpinningState.IDLE)
|
|
{
|
|
num5++;
|
|
if ((float)num5 > vector4.y)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
}
|
|
else if (spinningStates[num7] == SpinningState.JERK)
|
|
{
|
|
if ((float)num5 < vector4.x && !flag9)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
num5 = 0;
|
|
flag9 = false;
|
|
}
|
|
if (flag7)
|
|
{
|
|
if ((float)num7 < levelThresholdsTwitching.x)
|
|
{
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
}
|
|
break;
|
|
}
|
|
currentSpinningLevel = num7;
|
|
currentSpinningMethod = SpinningMethod.TWITCHING;
|
|
}
|
|
}
|
|
}
|
|
if (currentSpinningMethod == SpinningMethod.STRAIGHT || currentSpinningMethod == SpinningMethod.STRAIGHT_FAST || currentSpinningMethod == SpinningMethod.STRAIGHT_SLOW)
|
|
{
|
|
if ((float)currentSpinningLevel >= levelThresholds.z)
|
|
{
|
|
currentSpinningLevel = 3;
|
|
}
|
|
else if ((float)currentSpinningLevel >= levelThresholds.y)
|
|
{
|
|
currentSpinningLevel = 2;
|
|
}
|
|
else
|
|
{
|
|
currentSpinningLevel = 1;
|
|
}
|
|
}
|
|
else if (currentSpinningMethod == SpinningMethod.LIFT_DROP || currentSpinningMethod == SpinningMethod.TWITCHING)
|
|
{
|
|
if ((float)currentSpinningLevel >= levelThresholdsTwitching.z)
|
|
{
|
|
currentSpinningLevel = 3;
|
|
}
|
|
else if ((float)currentSpinningLevel >= levelThresholdsTwitching.y)
|
|
{
|
|
currentSpinningLevel = 2;
|
|
}
|
|
else
|
|
{
|
|
currentSpinningLevel = 1;
|
|
}
|
|
}
|
|
else if (currentSpinningMethod == SpinningMethod.STOP_GO)
|
|
{
|
|
if ((float)currentSpinningLevel >= levelThresholdsStopGo.z)
|
|
{
|
|
currentSpinningLevel = 3;
|
|
}
|
|
else if ((float)currentSpinningLevel >= levelThresholdsStopGo.y)
|
|
{
|
|
currentSpinningLevel = 2;
|
|
}
|
|
else
|
|
{
|
|
currentSpinningLevel = 1;
|
|
}
|
|
}
|
|
if (!GameController.Instance.iceLevel)
|
|
{
|
|
fishingHands.fishingPlayer.gameController.hudManager.hudFishing.UpdateSpinningMethod(currentSpinningMethod, currentSpinningLevel);
|
|
}
|
|
if ((bool)jkmStatistic.Instance)
|
|
{
|
|
jkmStatistic.Instance.spinnigMethod.text = currentSpinningMethod.ToString() + " " + currentSpinningLevel;
|
|
}
|
|
}
|
|
|
|
public float GetLevelMultiplier()
|
|
{
|
|
return levelMultipliers[currentSpinningLevel - 1];
|
|
}
|
|
|
|
public bool IsMoving(SpinningState state)
|
|
{
|
|
return state == SpinningState.MOVE_SLOW || state == SpinningState.MOVE_MEDIUM || state == SpinningState.MOVE_FAST;
|
|
}
|
|
|
|
public bool IsMovingOrIdle(SpinningState state)
|
|
{
|
|
return state == SpinningState.MOVE_SLOW || state == SpinningState.MOVE_MEDIUM || state == SpinningState.MOVE_FAST || state == SpinningState.IDLE;
|
|
}
|
|
|
|
public bool IsMovingOrJerking(SpinningState state)
|
|
{
|
|
return state == SpinningState.MOVE_SLOW || state == SpinningState.MOVE_MEDIUM || state == SpinningState.MOVE_FAST || state == SpinningState.JERK || state == SpinningState.IDLE;
|
|
}
|
|
|
|
public void FishCatchBait()
|
|
{
|
|
fishCatchMethodLevel = currentSpinningLevel;
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
for (int i = 0; i < spinningStates.Count; i++)
|
|
{
|
|
spinningStates[i] = SpinningState.IDLE;
|
|
}
|
|
currentSpinningEvent = SpinningState.IDLE;
|
|
currentSpinningMethod = SpinningMethod.NONE;
|
|
currentSpinningLevel = 1;
|
|
fishingHands.fishingPlayer.gameController.hudManager.hudFishing.UpdateSpinningMethod(currentSpinningMethod, currentSpinningLevel);
|
|
noMethodTimer = 18f;
|
|
}
|
|
|
|
public static string GetSpinningMethodName(SpinningMethod spinningMethod)
|
|
{
|
|
switch (spinningMethod)
|
|
{
|
|
case SpinningMethod.LIFT_DROP:
|
|
return Utilities.GetTranslation("HUD/SPINNING_LIFT_DROP");
|
|
case SpinningMethod.STOP_GO:
|
|
return Utilities.GetTranslation("HUD/SPINNING_STOP_GO");
|
|
case SpinningMethod.STRAIGHT:
|
|
return Utilities.GetTranslation("HUD/SPINNING_STRAIGHT");
|
|
case SpinningMethod.STRAIGHT_SLOW:
|
|
return Utilities.GetTranslation("HUD/SPINNING_STRAIGHT_SLOW");
|
|
case SpinningMethod.STRAIGHT_FAST:
|
|
return Utilities.GetTranslation("HUD/SPINNING_STRAIGHT_FAST");
|
|
case SpinningMethod.TWITCHING:
|
|
return Utilities.GetTranslation("HUD/SPINNING_TWITCHING");
|
|
default:
|
|
return "None";
|
|
}
|
|
}
|
|
}
|