void Update()
{
if (curState == RollState.None)
{
return;
}
allTime += Time.deltaTime;
//先进入加速阶段
if (curState == RollState.SpeedUp)
{
factor = allTime / accelerateTime;
factor = factor > 1 ? 1 : factor;
RollPanel.Rotate(new Vector3(0, 0, -1) * factor * MaxSpeed * Time.deltaTime, Space.Self);
}
//当旋转时间大于等于了加速段的时间就开始进行减速
if (allTime >= speedUpTime && curState == RollState.SpeedUp)
{
curState = RollState.SpeedDown;
tempAngle = GetTempAngle();
Debug.Log("tempAngle:" + tempAngle);
}
if (curState == RollState.SpeedDown)
{
//通过差值运算实现旋转到指定角度（球型插值无法实现大于360°的计算）
tempAngle = Mathf.Lerp(tempAngle, endAngle, Time.deltaTime * k);
RollPanel.rotation = Quaternion.Euler(0, 0, tempAngle);
//RollPanel.eulerAngles = new Vector3(0, 0, tempAngle);
//旋转结束
if (Mathf.Abs(tempAngle - endAngle) <= 1)
{
curState = RollState.None;
ResultUI.SetActive(true);
}
}
}
private void DoRolldown()
{
if (AllowRollUp && RollUpState == RollState.FullyUp)
{
RollUpState = NextRollUpState;
RollupTimer.Start();
}
}
private void DoRollup()
{
if (AllowRollUp && CanRollUp && RollUpState == RollState.FullyDown)
{
RollUpState = NextRollUpState;
RollupTimer.Start();
}
}
public override void Update()
{
if (controller.IsTrackerAppear)
{
controller.RightEyeBehaviour.FollowTarget(controller.TargetBehaviour.transform.position, MOVE_TIME);
controller.LeftEyeBehaviour.FollowTarget(controller.TargetBehaviour.transform.position, MOVE_TIME);
}
else
{
RollState rollState = new RollState(stateMgr, controller);
stateMgr.SwitchTo(rollState);
}
}
/// <summary>
/// 开始旋转转盘
/// </summary>
public void StartTurnWheel()
{
if (curState != RollState.None)
{
return;
}
allTime = 0;
tempAngle = 0;
rollID = GetRandomID();
Debug.Log("rollID: " + rollID);
endAngle = (-1) * rollID * 60;
curState = RollState.SpeedUp;
}
public void PrepareRoll()
{
if (State != RollState.Scoring)
{
return;
}
if (RerollsLeft <= 0)
{
return;
}
if (Rolling.Count == 0)
{
Rolling = Dice.GetRange(0, Dice.Count);
}
State = RollState.Preparing;
_currentCupPos = CupPos;
_cupShakeCooldown = _cupLerpSpeed;
RerollsLeft--;
var boxSize = new vec3(1.2f / 2);
List <BoundingBox> boxes = new List <BoundingBox>();
Random r = new Random();
for (int i = 0; i < Rolling.Count; i++)
{
BoundingBox box;
vec3 pos;
quat q;
do
{
q = quat.Identity.Rotated(((float)r.NextDouble() * 360).AsRad(), vec3.UnitX)
.Rotated(((float)r.NextDouble() * 360).AsRad(), vec3.UnitY)
.Rotated(((float)r.NextDouble() * 360).AsRad(), vec3.UnitZ)
.NormalizedSafe;
pos = ((vec3.UnitY * _cupSpreadDist) * q);
box = new BoundingBox(pos - boxSize, pos + boxSize);
} while (boxes.Exists(b => b.Intersects(box)));
Transform t = Transform.Identity;
t.Translation = CupPos + pos;
t.Orientation = q;
Rolling[i].Lerp(t, _cupLerpSpeed);
Rolling[i].CastShadow = true;
_cupOffset[Rolling[i]] = pos;
boxes.Add(box);
}
OnPrepareRoll?.Invoke();
}
protected override void InitAllState()
{
IdleState = new IdleState(this);
RunState = new RunState(this);
unarmedAttack_0State = new UnarmedAttack_0State(this);
unarmedAttack_1State = new UnarmedAttack_1State(this);
unarmedAttack_2State = new UnarmedAttack_2State(this);
unarmedAttack_3State = new UnarmedAttack_3State(this);
unarmedRollState = new RollState(this);
unarmedInjuredState = new InjuredState(this);
axeAttack_0State = new AxeAttack_0State(this);
axeAttack_1State = new AxeAttack_1State(this);
axeAttack_2State = new AxeAttack_2State(this);
switchState = new SwitchState(this);
CurrentState = IdleState;
}
//Dodge Rolling controller method
void Roll(float h, float v)
{
switch (rollState)
{
case RollState.Ready:
//buttonpress
if (Input.GetAxis("Roll") > 0)
{
animator.SetBool("Rolling", true);
savedVel = rigid.velocity;
actionSpeed = 800f;
rigid.velocity += new Vector2(h, v).normalized *actionSpeed *Time.deltaTime;
//set sate to rolling
rollState = RollState.Rolling;
}
break;
//If Currently Rolling
case RollState.Rolling:
rollTimer += Time.deltaTime * 3;
if (rollTimer >= maxRoll)
{
rollTimer = maxRoll;
rigid.velocity = savedVel;
rollState = RollState.Cooldown;
}
break;
//Rolling Cooldown timer
case RollState.Cooldown:
animator.SetBool("Rolling", false);
rollTimer -= Time.deltaTime;
if (rollTimer <= 0)
{
rollTimer = 0;
rollState = RollState.Ready;
}
break;
}
}
public void Roll()
{
if (State != RollState.Preparing)
{
return;
}
State = RollState.Rolling;
var momentum = _lastShakeMomentum;
var shakeSpeed = _shakeRotSpeed + (_lastShakeMomentum.Length + 1);
var rotAxis = (_shakeRotAxis * vec3.UnitY).NormalizedSafe;
foreach (var d in Rolling)
{
d.EnablePhysics();
d.RigidBody.Impulse(momentum);
d.RigidBody.AngularVelocity += (d.Transform.Orientation * rotAxis).NormalizedSafe * shakeSpeed;
}
}
public int ThrowFor(StatName stat, RollState rollState = RollState.Normal)
{
var ll = _mods[stat] + getProf(_owner.Level);
var offset = ll >= 0 ? "+" + ll.ToString() :ll.ToString();
var roll = Dice.RollDice($"1d20{offset}");
if (rollState == RollState.Normal)
{
return(roll);
}
else if (rollState == RollState.Advantage)
{
var second = Dice.RollDice($"1d20{offset}");
return(Math.Max(roll, second));
}
else
{
var second = Dice.RollDice($"1d20{offset}");
return(Math.Min(roll, second));
}
}
private void Start()
{
anim = GetComponent <Animator>();
cc = GetComponent <CharacterController>();
AttackDecision = GetComponent <AttackDetectionTwo>();
gamePanel = GameObject.Find("Canvas").transform.GetChild(0).GetComponent <GamePanel>();
IdleState idle = new IdleState(1, this);
RunState Runing = new RunState(2, this);
RollState Rolling = new RollState(3, this);
AttackState attack = new AttackState(4, this);
SwitchWeaponsState switchWeapons = new SwitchWeaponsState(5, this);
GetHitAndDeath getHitAndDeath = new GetHitAndDeath(6, this);
ForceState force = new ForceState(7, this);
machine = new StateMachine(idle);
machine.AddState(Runing);
machine.AddState(Rolling);
machine.AddState(attack);
machine.AddState(switchWeapons);
machine.AddState(getHitAndDeath);
machine.AddState(force);
}
public override void Roll(int x, int z)
{
base.Roll(x, z);
currentState = new RollState(details);
currentState.Roll(x, z);
}
void RestRollPanel()
{
RollPanel.rotation = new Quaternion(0, 0, 0, 0);
curState = RollState.None;
}
private void RollupTimer_Tick(object sender, EventArgs e)
{
if (AllowRollUp)
{
if (RollDelayCounter < RollDelayCounterMax)
{
RollDelayCounter++;
}
else if (RollDelayCounter == RollDelayCounterMax)
{
RollDelayCounter++;
RollConfirmed = ConfirmRoll();
if (!RollConfirmed)
{
RollDelayCounter = 0;
}
RollCounter = 0;
}
else if (RollConfirmed)
{
if (RollUpState == RollState.FullyDown || RollUpState == RollState.FullyUp)
{
RollDelayCounter = 0;
RollCounter = 0;
RollupTimer.Stop();
}
else
{
RollCounter++;
if (RollUpState == RollState.RollingDown)
{
Height += 10;
if (RollCounter == RollCounterMax)
{
RollUpState = RollState.FullyDown;
NextRollUpState = RollState.RollingUp;
RollDelayCounter = 0;
}
}
else if (CanRollUp)
{
Height -= 10;
if (RollCounter == RollCounterMax)
{
RollUpState = RollState.FullyUp;
NextRollUpState = RollState.RollingDown;
RollDelayCounter = 0;
}
}
else
{
Console.WriteLine("----------> Can't Roll Up!!");
}
}
if (RollCounter > RollCounterMax)
{
RollUpState = RollState.FullyDown;
Height = 60;
NextRollUpState = RollState.RollingUp;
RollDelayCounter = 0;
}
}
}
}
public void Update(Time deltaTime, bool useMouse = true)
{
if (Dice.Count <= 0)
{
return;
}
switch (State)
{
case RollState.Preparing:
if (_cupShakeCooldown > 0)
{
_cupShakeCooldown -= deltaTime.DeltaF; return;
}
var shakeSpeed = _shakeRotSpeed + (_shaking ? (_lastShakeMomentum.Length + 1) : 0);
foreach (var r in Rolling)
{
r.Transform.Orientation = r.Transform.Orientation.Rotated(shakeSpeed * deltaTime.DeltaF, _shakeRotAxis * vec3.UnitY);
}
_shakeRotAxis = _shakeRotAxis.Rotated(shakeSpeed / 3 * deltaTime.DeltaF, vec3.UnitZ);
if (!_shaking)
{
return;
}
var v2 = (Program.InputManager.MousePosition - _shakeCenter) / _maxShakeDist;
var signs = new vec2(Math.Sign(v2.x), Math.Sign(v2.y));
v2 = signs * v2;
v2 = _maxShakeMove * new vec2(signs.x * _shakeCurve[v2.x <= 1 ? v2.x : 1], signs.y * _shakeCurve[v2.y <= 1 ? v2.y : 1]);
_currentCupPos = CupPos + new vec3(v2.x, 0, v2.y);
v2 = new vec2(Program.InputManager.MousePosition - _lastShakePos) * _shakeScale;
_lastShakeMomentum = new vec3(v2.x, 0, v2.y) / deltaTime.DeltaF;
_lastShakePos = Program.InputManager.MousePosition;
foreach (var d in Rolling)
{
d.Transform.Translation = _currentCupPos + _cupOffset[d];
}
break;
case RollState.Rolling:
if (!Rolling.Exists(d => !d.RigidBody.Sleeping))
{
MoveDiceToCamera();
State = RollState.Scoring;
if (Rolling.Count == Dice.Count || RerollsLeft <= 0)
{
Rolling.Clear(); UpdateOutliners();
}
OnRolled?.Invoke(Rolled);
}
break;
case RollState.Scoring:
if (useMouse)
{
UpdateOutliners();
}
break;
}
}
public void respawn()
{
alive = true;
pos = respawnPoint;
//stop moving
moveSpeed = 0;
sideSpeed = 0;
//face the right direction
direction = Vector3.Forward;
rot.Y = 0;
//reset turning
currentTurnSpeed = 0;
tilt = 0;
//reset barrel roll
rollState = RollState.not;
rollCooldown = 0;
roll = 0;
//reset uturn
inUTurn = false;
totaluTurn = 0;
pos.Y = 4.5f;
uTurnYaw = 0;
rot.X = 0;
shipHealth.reset();
game.camera.reset();
}
void updateBarrelRoll()
{
if (!game.camera.endGame && !game.minigame.active)
{
if ((Keyboard.GetState().IsKeyDown(Keys.Q) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X < -0.3f) && rollCooldown <= 0)
{
rollCooldown = 30;
rollRecoverTime = MathHelper.PiOver2;
if (roll < 0 && rollState == RollState.rolling)
targetRoll = 0;
else
targetRoll = MathHelper.Pi * 2;
rollState = RollState.rolling;
rollDir = RollDir.left;
}
if ((Keyboard.GetState().IsKeyDown(Keys.E) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X > 0.3f) && rollCooldown <= 0)
{
rollCooldown = 30;
rollRecoverTime = MathHelper.PiOver2;
if (roll > 0 && rollState == RollState.rolling)
targetRoll = 0;
else
targetRoll = -MathHelper.Pi * 2;
rollState = RollState.rolling;
rollDir = RollDir.right;
}
}
if (rollState == RollState.rolling) //todo - treat sideways movement like forwards with lerping
{
if (rollCooldown > 0)
rollCooldown -= 60 * Utilities.deltaTime;
if (rollDir == RollDir.left)
{
sideSpeed = MathHelper.Lerp(sideSpeed, 15, Utilities.deltaTime*5);
roll += MathHelper.Pi * Utilities.deltaTime * 4 * (sideSpeed/15);
if (roll > targetRoll)// && rollCooldown >= 10)
{
rollCooldown = 0;
roll = 0;
rollState = RollState.recovering;
}
}
else
{
sideSpeed = MathHelper.Lerp(sideSpeed, -15, Utilities.deltaTime * 5);
roll += MathHelper.Pi * Utilities.deltaTime * 4 * (sideSpeed / 15);
if (roll < targetRoll)// && rollCooldown >= 10)
{
rollCooldown = 0;
roll = 0;
rollState = RollState.recovering;
}
}
}
else
{
sideSpeed = MathHelper.Lerp(sideSpeed, 0, Utilities.deltaTime * 8);
}
if(rollState == RollState.recovering)
{
if(rollDir == RollDir.left)
roll = (float)((Math.Cos(rollRecoverTime) - 1) * 0.5f) * -MathHelper.Pi * Utilities.deltaTime * 8;
if (rollDir == RollDir.right)
roll = (float)((Math.Cos(rollRecoverTime) - 1) * 0.5f) * MathHelper.Pi * Utilities.deltaTime * 8;
// roll = (float)((Math.Cos(rollRecoverTime) - 1) * 0.5f) * MathHelper.PiOver4*0.65f;
rollRecoverTime += MathHelper.Pi * 3.5f * Utilities.deltaTime;
if(rollRecoverTime >= MathHelper.Pi*2)
{
rollState = RollState.not;
roll = 0;
rollRecoverTime = MathHelper.PiOver2;
}
}
frameDiff.X += Vector3.Cross(Vector3.Up, direction).X * sideSpeed * Utilities.deltaTime;
frameDiff.Z += Vector3.Cross(Vector3.Up, direction).Z * sideSpeed * Utilities.deltaTime;
rot.Z += roll;
}
private void MakeFSM()
{
NormalIdleState normalIdle = new NormalIdleState(this.transform);
normalIdle.AddTransition(Transition.NormalIdleTSTurnR, StateID.TurnR); //
normalIdle.AddTransition(Transition.NormalIdleTSTurnL, StateID.TurnL); //
normalIdle.AddTransition(Transition.NormalIdleTSNormalMove, StateID.NormalMove); //
normalIdle.AddTransition(Transition.NormalIdleTSFightIdle, StateID.FightIdle); //
normalIdle.AddTransition(Transition.NormalIdleTSSprint, StateID.Sprint); //
normalIdle.AddTransition(Transition.NormalIdleTSCoverR, StateID.CoverR); //
normalIdle.AddTransition(Transition.NormalIdleTSCoverL, StateID.CoverL); //
normalIdle.AddTransition(Transition.NormalIdleTSCoverHiR, StateID.CoverHiR);
normalIdle.AddTransition(Transition.NormalIdleTSCoverHiL, StateID.CoverHiL);
normalIdle.AddTransition(Transition.NormalIdleTSPickUp, StateID.PickUp); //
normalIdle.AddTransition(Transition.NormalIdleTSOpenDoor, StateID.OpenDoor); //
normalIdle.AddTransition(Transition.NormalIdleTSUsePad, StateID.UsePad); //
TurnRState turnR = new TurnRState(this.transform);
turnR.AddTransition(Transition.TurnRTSTurnL, StateID.TurnL);
turnR.AddTransition(Transition.TurnRTSNormalIdle, StateID.NormalIdle);
turnR.AddTransition(Transition.TurnRTSNormalMove, StateID.NormalMove);
TurnLState turnL = new TurnLState(this.transform);
turnL.AddTransition(Transition.TurnLTSNormalIdle, StateID.NormalIdle);
turnL.AddTransition(Transition.TurnLTSNormalMove, StateID.NormalMove);
FightIdleState fightIdle = new FightIdleState(this.transform);
fightIdle.AddTransition(Transition.FightIdleTSFightMove, StateID.FightMove); //
fightIdle.AddTransition(Transition.FightIdleTSNormalMove, StateID.NormalMove); //
fightIdle.AddTransition(Transition.FightIdleTSNormalIdle, StateID.NormalIdle); //
NormalMoveState normalMove = new NormalMoveState(this.transform);
normalMove.AddTransition(Transition.NormalMoveTSFightMove, StateID.FightMove); //
normalMove.AddTransition(Transition.NormalMoveTSNormalIdle, StateID.NormalIdle); //
normalMove.AddTransition(Transition.NormalMoveTSSprint, StateID.Sprint); //
normalMove.AddTransition(Transition.NormalMoveTSRoll, StateID.Roll); //
normalMove.AddTransition(Transition.NormalMoveTSCoverR, StateID.CoverR); //
normalMove.AddTransition(Transition.NormalMoveTSCoverL, StateID.CoverL); //
normalMove.AddTransition(Transition.NormalMoveTSCoverHiR, StateID.CoverHiR);
normalMove.AddTransition(Transition.NormalMoveTSCoverHiL, StateID.CoverHiL);
normalMove.AddTransition(Transition.NormalMoveTSOpenDoor, StateID.OpenDoor); //
normalMove.AddTransition(Transition.NormalMoveTSUsePad, StateID.UsePad); //
FightMoveState fightMove = new FightMoveState(this.transform);
fightMove.AddTransition(Transition.FightMoveTSFightIdle, StateID.FightIdle); //
fightMove.AddTransition(Transition.FightMoveTSNormalMove, StateID.NormalMove); //
RollState roll = new RollState(this.transform);
roll.AddTransition(Transition.RollTSNormalIdle, StateID.NormalIdle); //
roll.AddTransition(Transition.RollTSNormalMove, StateID.NormalMove); //
SprintState sprint = new SprintState(this.transform);
sprint.AddTransition(Transition.SprintTSNormalIdle, StateID.NormalIdle); //
sprint.AddTransition(Transition.SprintTSNormalMove, StateID.NormalMove); //
sprint.AddTransition(Transition.SprintTSCoverR, StateID.CoverR); //
sprint.AddTransition(Transition.SprintTSCoverL, StateID.CoverL); //
sprint.AddTransition(Transition.SprintTSRoll, StateID.Roll); //
sprint.AddTransition(Transition.SprintTSCoverHiR, StateID.CoverHiR);
sprint.AddTransition(Transition.SprintTSCoverHiL, StateID.CoverHiL);
sprint.AddTransition(Transition.SprintTSOpenDoor, StateID.OpenDoor); //
sprint.AddTransition(Transition.SprintTSUsePad, StateID.UsePad); //
CoverJumpState coverJump = new CoverJumpState(this.transform);
coverJump.AddTransition(Transition.CoverJumpTSNormalIdle, StateID.NormalIdle);//
CoverRState coverR = new CoverRState(this.transform);
coverR.AddTransition(Transition.CoverRTSCoverL, StateID.CoverL); //
coverR.AddTransition(Transition.CoverRTSRoll, StateID.Roll); //
coverR.AddTransition(Transition.CoverRTSNormalMove, StateID.NormalMove); //
coverR.AddTransition(Transition.CoverRTSCoverJump, StateID.CoverJump); //
coverR.AddTransition(Transition.CoverRTSCoverLoRShootIdle, StateID.CoverLoRShootIdle); //
coverR.AddTransition(Transition.CoverRTSCoverRReload, StateID.CoverRReload); //
coverR.AddTransition(Transition.CoverRTSNormalIdle, StateID.NormalIdle); //
CoverLoRShootIdleState coverLoRShootIdle = new CoverLoRShootIdleState(this.transform);
coverLoRShootIdle.AddTransition(Transition.CoverLoRShootIdleTSCoverLoRShootBeforeDown, StateID.CoverLoRShootBeforeDown); //
coverLoRShootIdle.AddTransition(Transition.CoverLoRShootIdleTSFightIdle, StateID.FightIdle); //
coverLoRShootIdle.AddTransition(Transition.CoverLoRShootIdleTSCoverR, StateID.CoverR); //
CoverLoRShootBeforeDownState coverLoRShootBeforeDown = new CoverLoRShootBeforeDownState(this.transform);
coverLoRShootBeforeDown.AddTransition(Transition.CoverLoRShootBeforeDownTSCoverR, StateID.CoverR); //
coverLoRShootBeforeDown.AddTransition(Transition.CoverLoRShootBeforeDownTSCoverLoRShootIdle, StateID.CoverLoRShootIdle); //
coverLoRShootBeforeDown.AddTransition(Transition.CoverLoRShootBeforeDownTSNormalIdle, StateID.NormalIdle); //
CoverLState coverL = new CoverLState(this.transform);
coverL.AddTransition(Transition.CoverLTSCoverR, StateID.CoverR); //
coverL.AddTransition(Transition.CoverLTSRoll, StateID.Roll); //
coverL.AddTransition(Transition.CoverLTSNormalMove, StateID.NormalMove); //
coverL.AddTransition(Transition.CoverLTSCoverJump, StateID.CoverJump); //
coverL.AddTransition(Transition.CoverLTSCoverLoLShootIdle, StateID.CoverLoLShootIdle); //
coverL.AddTransition(Transition.CoverLTSCoverLReload, StateID.CoverLReload); //
coverL.AddTransition(Transition.CoverLTSNormalIdle, StateID.NormalIdle); //
CoverLoLShootIdleState coverLoLShootIdle = new CoverLoLShootIdleState(this.transform);
coverLoLShootIdle.AddTransition(Transition.CoverLoLShootIdleTSCoverLoLShootBeforeDown, StateID.CoverLoLShootBeforeDown); //
coverLoLShootIdle.AddTransition(Transition.CoverLoLShootIdleTSFightIdle, StateID.FightIdle); //
coverLoLShootIdle.AddTransition(Transition.CoverLoLShootIdleTSCoverL, StateID.CoverL); //
CoverLoLShootBeforeDownState coverLoLShootBeforeDown = new CoverLoLShootBeforeDownState(this.transform);
coverLoLShootBeforeDown.AddTransition(Transition.CoverLoLShootBeforeDownTSCoverL, StateID.CoverL); //
coverLoLShootBeforeDown.AddTransition(Transition.CoverLoLShootBeforeDownTSCoverLoLShootIdle, StateID.CoverLoLShootIdle); //
coverLoLShootBeforeDown.AddTransition(Transition.CoverLoLShootBeforeDownTSNormalIdle, StateID.NormalIdle); //
CoverHiRState coverHiR = new CoverHiRState(this.transform);
coverHiR.AddTransition(Transition.CoverHiRTSCoverHiL, StateID.CoverHiL);
coverHiR.AddTransition(Transition.CoverHiRTSNormalMove, StateID.NormalMove);
coverHiR.AddTransition(Transition.CoverHiRTSCoverHiRightIdle, StateID.CoverHiRightIdle);
coverHiR.AddTransition(Transition.CoverHiRTSNormalIdle, StateID.NormalIdle);
CoverHiRightIdleState coverHiRightIdle = new CoverHiRightIdleState(this.transform);
coverHiRightIdle.AddTransition(Transition.CoverHiRightIdleTSCoverHiR, StateID.CoverHiR);
coverHiRightIdle.AddTransition(Transition.CoverHiRightIdleTSRoll, StateID.Roll);
coverHiRightIdle.AddTransition(Transition.CoverHiRightIdleTSCoverHiRShootIdle, StateID.CoverHiRShootIdle);
coverHiRightIdle.AddTransition(Transition.CoverHiRightIdleTSNormalIdle, StateID.NormalIdle);
CoverHiRShootIdleState coverHiRShootIdle = new CoverHiRShootIdleState(this.transform);
coverHiRShootIdle.AddTransition(Transition.CoverHiRShootIdleTSCoverHiRShootBeforeDown, StateID.CoverHiRShootBeforeDown);
coverHiRShootIdle.AddTransition(Transition.CoverHiRShootIdleTSCoverHiRightIdle, StateID.CoverHiRightIdle);
coverHiRShootIdle.AddTransition(Transition.CoverHiRShootIdleTSFightIdle, StateID.FightIdle);
CoverHiRShootBeforeDownState coverHiRShootBeforeDown = new CoverHiRShootBeforeDownState(this.transform);
coverHiRShootBeforeDown.AddTransition(Transition.CoverHiRShootBeforeDownTSCoverHiRightIdle, StateID.CoverHiRightIdle);
coverHiRShootBeforeDown.AddTransition(Transition.CoverHiRShootBeforeDownTSCoverHiRShootIdle, StateID.CoverHiRShootIdle);
coverHiRShootBeforeDown.AddTransition(Transition.CoverHiRShootBeforeDownTSNormalIdle, StateID.NormalIdle);
CoverHiLState coverHiL = new CoverHiLState(this.transform);
coverHiL.AddTransition(Transition.CoverHiLTSCoverHiR, StateID.CoverHiR);
coverHiL.AddTransition(Transition.CoverHiLTSNormalMove, StateID.NormalMove);
coverHiL.AddTransition(Transition.CoverHiLTSCoverHiLeftIdle, StateID.CoverHiLeftIdle);
coverHiL.AddTransition(Transition.CoverHiLTSNormalIdle, StateID.NormalIdle);
CoverHiLeftIdleState coverHiLeftIdle = new CoverHiLeftIdleState(this.transform);
coverHiLeftIdle.AddTransition(Transition.CoverHiLeftIdleTSCoverHiL, StateID.CoverHiL);
coverHiLeftIdle.AddTransition(Transition.CoverHiLeftIdleTSRoll, StateID.Roll);
coverHiLeftIdle.AddTransition(Transition.CoverHiLeftIdleTSCoverHiLShootIdle, StateID.CoverHiLShootIdle);
coverHiLeftIdle.AddTransition(Transition.CoverHiLeftIdleTSNormalIdle, StateID.NormalIdle);
CoverHiLShootIdleState coverHiLShootIdle = new CoverHiLShootIdleState(this.transform);
coverHiLShootIdle.AddTransition(Transition.CoverHiLShootIdleTSCoverHiLShootBeforeDown, StateID.CoverHiLShootBeforeDown);
coverHiLShootIdle.AddTransition(Transition.CoverHiLShootIdleTSCoverHiLeftIdle, StateID.CoverHiLeftIdle);
coverHiLShootIdle.AddTransition(Transition.CoverHiRShootIdleTSFightIdle, StateID.FightIdle);
CoverHiLShootBeforeDownState coverHiLShootBeforeDown = new CoverHiLShootBeforeDownState(this.transform);
coverHiLShootBeforeDown.AddTransition(Transition.CoverHiLShootBeforeDownTSCoverHiLeftIdle, StateID.CoverHiLeftIdle);
coverHiLShootBeforeDown.AddTransition(Transition.CoverHiLShootBeforeDownTSCoverHiLShootIdle, StateID.CoverHiLShootIdle);
coverHiLShootBeforeDown.AddTransition(Transition.CoverHiLShootBeforeDownTSNormalIdle, StateID.NormalIdle);
CoverRReloadState coverRReloadState = new CoverRReloadState(this.transform);
coverRReloadState.AddTransition(Transition.CoverRReloadTSCoverR, StateID.CoverR);//
CoverLReloadState coverLReloadState = new CoverLReloadState(this.transform);
coverLReloadState.AddTransition(Transition.CoverLReloadTSCoverL, StateID.CoverL);//
PickUpState pickUpState = new PickUpState(this.transform);
pickUpState.AddTransition(Transition.PickUpTSNormalIdle, StateID.NormalIdle);//
OpenDoorState openDoorState = new OpenDoorState(this.transform);
openDoorState.AddTransition(Transition.OpenDoorTSNormalIdle, StateID.NormalIdle);//
UsePadState usePadState = new UsePadState(this.transform);
usePadState.AddTransition(Transition.UsePadTSNormalIdle, StateID.NormalIdle);//
fsm = new FSMSystem();
fsm.AddState(normalIdle);
fsm.AddState(normalMove);
fsm.AddState(roll);
fsm.AddState(sprint);
fsm.AddState(fightIdle);
fsm.AddState(fightMove);
fsm.AddState(coverR);
fsm.AddState(coverL);
fsm.AddState(coverJump);
fsm.AddState(turnR);
fsm.AddState(turnL);
fsm.AddState(coverHiR);
fsm.AddState(coverHiL);
fsm.AddState(coverHiRightIdle);
fsm.AddState(coverHiLeftIdle);
fsm.AddState(coverHiRShootIdle);
fsm.AddState(coverHiRShootBeforeDown);
fsm.AddState(coverHiLShootIdle);
fsm.AddState(coverHiLShootBeforeDown);
fsm.AddState(coverLoRShootIdle);
fsm.AddState(coverLoRShootBeforeDown);
fsm.AddState(coverLoLShootIdle);
fsm.AddState(coverLoLShootBeforeDown);
fsm.AddState(coverRReloadState);
fsm.AddState(coverLReloadState);
fsm.AddState(pickUpState);
fsm.AddState(openDoorState);
fsm.AddState(usePadState);
}
