public override void CheckExitTransition()
{
if (forceExit)
{
CharacterStateController.EnqueueTransition <NormalMovement>();
}
}
private void OnTriggerStay2D(Collider2D collision)
{
if (collision.isTrigger)
{
return;
}
if (!collision.attachedRigidbody)
{
return;
}
/// only marked objects can interact
var _controller = collision.attachedRigidbody.GetComponent <CharacterStateController>();
if (!_controller)
{
return;
}
if (controller && _controller.GetInput().IsInputUp(4) && tPull.IsReadyRestart())
{
controller = null;
}
else if (!controller && _controller.GetInput().IsInputDown(4) && tPull.IsReadyRestart())
{
controller = _controller;
}
}
public PlayerState(Player player, CharacterStateController stateController, PlayerData playerData, string animBoolName)
{
this.player = player;
this.stateController = stateController;
this.playerData = playerData;
this.animBoolName = animBoolName;
}
public Character(CharacterPawn pawn, IInputSource inputSource, CharacterStatus status, CharacterStateController stateController, CharacterStateController weaponStateController, int teamId, CharacterInfo info)
{
Status = status;
Health = new FloatReactiveProperty(Status.MaxHealth.Value);
Pawn = pawn;
InputSource = inputSource;
StateController = stateController;
WeaponStateController = weaponStateController;
TeamId = teamId;
Info = info;
Inventory = new BasicInventory(this);
pawn.SetCharacter(this);
StateController.Initialize(this);
WeaponStateController.Initialize(this);
var inputSourceDisposable = inputSource as IDisposable;
if (inputSourceDisposable != null)
{
_compositeDisposable.Add(inputSourceDisposable);
}
Observable.EveryUpdate().Subscribe(OnUpdate).AddTo(_compositeDisposable);
status.MoveSpeed.Subscribe(UpdatePawnSpeed).AddTo(_compositeDisposable);
Health.Subscribe(OnHealthChange); //.AddTo( _compositeDisposable );
Instances.Add(this);
Status.ModifierCalculator.Changed += OnModifiersChange;
}
public override void CharacterMove(Vector2 movement)
{
float moveX = movement.x;
float moveY = movement.y;
if (Mathf.Abs(moveX) > 0 && Mathf.Abs(moveY) > 0)
{
if (GlobalVariables.IsHorizontalMovingFirst)
{
movement = new Vector3(moveX, 0, 0);
}
else
{
movement = new Vector3(0, moveY, 0);
}
}
else if (Mathf.Abs(moveX) > 0)
{
movement = new Vector3(moveX, 0, 0);
}
else if (Mathf.Abs(moveY) > 0)
{
movement = new Vector3(0, moveY, 0);
}
else
{
Rb.velocity = Vector3.zero;
CharacterStateController.SetParams(ISMOVING, false);
return;
}
movement *= BasicMovingSpeed;
Rb.AddForce(movement);
CharacterStateController.SetParams(ISMOVING, true);
}
private void FixedUpdate()
{
if (!controller)
{
return;
}
var otherBody = controller.GetBody();
Vector2 toOther = (Vector2)transform.position - otherBody.position;
if (toOther.sqrMagnitude < distance * distance)
{
return;
}
if (toOther.sqrMagnitude > breakDistance * breakDistance)
{
controller = null;
return;
}
body.AddForceAtPosition(toOther * -forceDistanceRatioMy, transform.position);
otherBody.AddForce(toOther * forceDistanceRatioOther);
otherBody.velocity = otherBody.velocity * otherSlow;
}
// NOTE: This function is called at runtime and edit time. Keep that in mind when setting the values of properties.
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
CharacterStateController trackBinding = playerData as CharacterStateController;
if (!trackBinding)
{
return;
}
int inputCount = playable.GetInputCount();
for (int i = 0; i < inputCount; i++)
{
float inputWeight = playable.GetInputWeight(i);
ScriptPlayable <ResetEnemyRadarBehaviour> inputPlayable = (ScriptPlayable <ResetEnemyRadarBehaviour>)playable.GetInput(i);
ResetEnemyRadarBehaviour input = inputPlayable.GetBehaviour();
if (inputWeight > 0.5f && !input.radarReset)
{
GameObject enemyClose;
enemyClose = trackBinding.m_CharacterController.CharacterTransform.Find("EnemyClose").gameObject;
for (int j = 0; j < enemyClose.GetComponent <EnemyClose>().pointers.Count; j++)
{
GameObject.Destroy(enemyClose.GetComponent <EnemyClose>().pointers[j]);
}
enemyClose.GetComponent <EnemyClose>().pointers.Clear();
enemyClose.SetActive(false);
input.radarReset = true;
}
// Use the above variables to process each frame of this playable.
}
}
public override void CheckExitTransition()
{
if (CharacterActions.jetPack.value)
{
CharacterStateController.EnqueueTransition <JetPack>();
}
else if (CharacterActions.dash.Started)
{
CharacterStateController.EnqueueTransition <Dash>();
}
else if (CharacterActor.Triggers.Count != 0)
{
CharacterStateController.EnqueueTransition <LadderClimbing>();
CharacterStateController.EnqueueTransition <RopeClimbing>();
}
else if (!CharacterActor.IsGrounded)
{
if (!CharacterActions.crouch.value)
{
CharacterStateController.EnqueueTransition <WallSlide>();
}
CharacterStateController.EnqueueTransition <LedgeHanging>();
}
}
public void Move(CharacterStateController controller)
{
// Move inputs
controller.m_CharacterController.moveInput = Input.GetAxis(controller.m_CharacterController.inputMapping.LeftHorizontal);
// Movements
if (controller.m_CharacterController.moveInput >= controller.m_CharacterController.m_CharStats.joypadDeathZone)// Move right if "x" axis is over 0.2
{
controller.m_CharacterController.rb.velocity = new Vector2(controller.m_CharacterController.m_CharStats.speed, controller.m_CharacterController.rb.velocity.y);
}
else if (controller.m_CharacterController.moveInput <= -controller.m_CharacterController.m_CharStats.joypadDeathZone) // Move left if "x" axis is lower -0.2
{
controller.m_CharacterController.rb.velocity = new Vector2(-controller.m_CharacterController.m_CharStats.speed, controller.m_CharacterController.rb.velocity.y);
}
else
{
controller.m_CharacterController.rb.velocity = new Vector2(0, controller.m_CharacterController.rb.velocity.y);
}
// Flip the player direction
if (!controller.m_CharacterController.facingRight && controller.m_CharacterController.moveInput < 0)
{
controller.m_CharacterController.PlayerFlip();
}
else if (controller.m_CharacterController.facingRight && controller.m_CharacterController.moveInput > 0)
{
controller.m_CharacterController.PlayerFlip();
}
}
public Character( StatExpressionsInfo statExpressions, CharacterPlanetPawn pawn, IInputSource inputSource, CharacterStatus status, CharacterStateController stateController, CharacterStateController weaponStateController, int teamId, CharacterInfo info )
{
this.statExpressions = statExpressions;
this.status = status;
this.health = new IntReactiveProperty( this.status.maxHealth.Value );
this.pawn = pawn;
this.inputSource = inputSource;
this.stateController = stateController;
this.weaponStateController = weaponStateController;
this.teamId = teamId;
this.info = info;
this.inventory = new BasicInventory( this );
pawn.SetCharacter( this );
this.stateController.Initialize( this );
this.weaponStateController.Initialize( this );
var inputSourceDisposable = inputSource as IDisposable;
if ( inputSourceDisposable != null ) {
_compositeDisposable.Add( inputSourceDisposable );
}
Observable.EveryUpdate().Subscribe( OnUpdate ).AddTo( _compositeDisposable );
status.moveSpeed.Subscribe( UpdatePawnSpeed ).AddTo( _compositeDisposable );
health.Subscribe( OnHealthChange );//.AddTo( _compositeDisposable );
instances.Add( this );
}
public override void CheckExitTransition()
{
if (!currentRope.IsInRange(ReferencePosition) || CharacterActions.jump.Started)
{
CharacterStateController.EnqueueTransition <NormalMovement>();
}
}
public override void CheckExitTransition()
{
if (CharacterActions.jetPack.value)
{
CharacterStateController.EnqueueTransition <JetPack>();
}
else if (CharacterActions.dash.Started)
{
CharacterStateController.EnqueueTransition <Dash>();
}
else if (CharacterActor.Triggers.Count != 0)
{
if (CharacterActions.interact.Started)
{
CharacterStateController.EnqueueTransition <LadderClimbing>();
}
// else
// {
// // WIP
// // CharacterStateController.EnqueueTransition<RopeClimbing>();
// // CharacterStateController.EnqueueTransition<Swimming>();
// }
}
else if (!CharacterActor.IsGrounded)
{
CharacterStateController.EnqueueTransition <LedgeHanging>();
}
}
public override void Initialize(CharacterStateController stateController)
{
base.Initialize(stateController);
stateController.character.Health
.Where(_ => _ / (float)stateController.character.Status.MaxHealth.Value <= typedInfo.threshold)
.Subscribe(OnHealthBelowThreshold);
}
public void Death(CharacterStateController controller)
{
if (GMController.instance.gameStart)
{
//Call the Respawn method
controller.m_CharacterController.PlayerRespawn(GMController.instance.playerInfo[controller.m_CharacterController.playerNumber].PlayerSpawnPoint);
}
}
private void Awake()
{
StateController = new CharacterStateController();
PlayerIdle = new PlayerIdleState(this, StateController, playerData, "idle");
PlayerMove = new PlayerMoveState(this, StateController, playerData, "moving");
PlayerHide = new PlayerHideState(this, StateController, playerData, "hiding");
}
public override void Initialize(CharacterStateController stateController)
{
base.Initialize(stateController);
var emCharacter = character as EMCharacter;
emCharacter.DestinationSet += OnDestinationSet;
}
private void Start()
{
if (!particle)
{
particle = ParticleTypeController.instance.particles[particleId];
}
character = GetComponentInParent <CharacterStateController>();
}
protected override void Awake()
{
base.Awake();
navMeshPath = new NavMeshPath();
stateController = this.GetComponentInBranch <CharacterActor, CharacterStateController>();
stateController.MovementReferenceMode = MovementReferenceMode.World;
}
// OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
controller = animator.GetComponent <CharacterStateController>();
if (controller)
{
controller.SetCurrentAnimatorBehaviour(this);
controller.GetState(skillId).OnAnimationBeggin(stateInfo);
}
}
public override void Initialize( CharacterStateController stateController )
{
base.Initialize( stateController );
this.approachState = stateController.states.OfType<ApproachTargetStateInfo.State>().First();
this.attackState = stateController.states.OfType<AttackStateInfo.State>().First();
stateController.character.inputSource.targets.OfType<object, Character>().Subscribe( OnCharacterClicked );
}
void Awake()
{
refrence = this;
timer_healthRegen = new Timer(1f);
InitStatsDictionary();
respawning = false;
health = 20;
coins = 10000000;
}
public override bool Decide(CharacterStateController controller)
{
if (Input.GetButtonDown(controller.m_CharacterController.inputMapping.dodgeInput) && !controller.m_CharacterController.isInDash)
{
return(true);
}
else
{
return(false);
}
}
public void DoubleJump(CharacterStateController controller)
{
// Jump Input
if (Input.GetButtonDown(controller.m_CharacterController.inputMapping.jumpInput) &&
controller.m_CharacterController.extraJumps > 0)
{
controller.m_CharacterController.extraJumps--;
controller.m_CharacterController.rb.velocity = Vector2.up * controller.m_CharacterController.m_CharStats.jump;
GMController.instance.TensionThresholdCheck(GMController.instance.tensionStats.actionsPoints); // add tension points for action
}
}
public void Jump(CharacterStateController controller)
{
controller.m_CharacterController.extraJumps = controller.m_CharacterController.m_CharStats.extraJumpValue;
// Jump Input
if (Input.GetButtonDown(controller.m_CharacterController.inputMapping.jumpInput))
{
//Debug.Log(GMController.instance.playerInfo[controller.m_CharacterController.playerNumber].ControllerIndex);
controller.m_CharacterController.rb.velocity = Vector2.up * controller.m_CharacterController.m_CharStats.jump;
GMController.instance.TensionThresholdCheck(GMController.instance.tensionStats.actionsPoints); // add tension points for action
}
}
public void OpenDoor(CharacterStateController controller)
{
if (Input.GetButtonDown(controller.m_CharacterController.inputMapping.interactInput) &&
controller.m_CharacterController.canExit)
{
GMController.instance.gameEnded = true;
GMController.instance.gameStart = false;
GMController.instance.canResultCR = false;
Time.timeScale = 0;
}
}
public override bool Decide(CharacterStateController controller)
{
if (!controller.m_CharacterController.isInDash)
{
return(true);
}
else
{
return(false);
}
}
public override bool Decide(CharacterStateController controller)
{
if (GMController.instance.GetGameStatus() && GMController.instance.gameStart)
{
return(true);
}
else
{
return(false);
}
}
public override bool Decide(CharacterStateController controller)
{
if (controller.m_CharacterController.isGrounded && controller.m_CharacterController.isAlive)
{
return(true);
}
else
{
return(false);
}
}
void Start()
{
controller = GetComponentInParent <CharacterStateController>();
renders = GetComponentsInChildren <SpriteRenderer>();
if (viewfinder)
{
distanceViewfinder = (viewfinder.transform.position - transform.position).magnitude;
rendersViewFinder = viewfinder.GetComponentsInChildren <SpriteRenderer>();
}
}
private void OnCollisionEnter(Collision other)
{
if (other.gameObject.tag.Equals(GlobalVariables.TagEnemy))
{
if (!CharacterStateController.GetCurrentStateName().Equals("BonusMoving"))
{
CharacterStateController.SetParams(ISDEAD, true);
CharacterStateController.SetParams(ISMOVING, false);
CharacterDead();
}
}
}
public override void ExitBehaviour(float dt, CharacterState toState)
{
forceExit = false;
CharacterActor.IsKinematic = false;
CharacterStateController.UseRootMotion = false;
CharacterActor.AlwaysNotGrounded = false;
currentLadder = null;
CharacterStateController.ResetIKWeights();
CharacterActor.Velocity = Vector3.zero;
}
public override void CheckExitTransition()
{
if (isDone)
{
if (OnDashEnd != null)
{
OnDashEnd(dashDirection);
}
CharacterStateController.EnqueueTransition <NormalMovement>();
}
}
public override void Initialize( CharacterStateController stateController )
{
base.Initialize( stateController );
states = stateController.states.Where( where => where.info == info ).ToArray();
//foreach ( var each in states ) {
// each.Initialize( stateController );
//}
stateController.character.inputSource.targets.Subscribe( OnTargetChange );
}
public CharacterStateController GetStateController()
{
var result = new CharacterStateController {
debug = isDebug,
updateAnimation = updateAnimation,
states = entries.Select( _ => _.stateInfo.GetState() ).ToArray(),
};
foreach ( var each in result.states ) {
var transitionEntry = entries[result.states.IndexOf( each )];
each.SetTransitionStates( result.states
.EquiZip( transitionEntry.transitionMask, ( a, b ) => new { item1 = a, item2 = b } )
.Where( _ => _.item2 && _.item1 != each )
.Select( _ => _.item1 ) );
}
return result;
}
public override void Initialize( CharacterStateController stateController )
{
base.Initialize( stateController );
stateController.character.inputSource.targets.OfType<object, ItemView>().Subscribe( SetTarget );
}
public virtual void Initialize( CharacterStateController stateController )
{
this.stateController = stateController;
}
