void Awake()
{
m_PlayerMovementComponentToDisplay = Utils.FindComponentMatchingWithTag <PlayerMovementComponent>(m_Target.ToString());
m_PlayerAttackComponentToDisplay = Utils.FindComponentMatchingWithTag <PlayerAttackComponent>(m_Target.ToString());
m_PlayerInfoComponentToDisplay = Utils.FindComponentMatchingWithTag <PlayerInfoComponent>(m_Target.ToString());
m_DebugSettings = ScenesConfig.GetDebugSettings();
m_GameInputList.SetActive(m_DebugSettings.m_DisplayInputsInfo);
m_TriggeredInputs = new List <List <GameInput> >(m_GameInputList.transform.childCount);
m_GameInputsImage = new List <List <Image> >(m_GameInputList.transform.childCount);
for (int i = 0; i < m_GameInputList.transform.childCount; i++)
{
List <Image> gameInputImageList = new List <Image>();
Transform gameInputs = m_GameInputList.transform.GetChild(i);
for (int j = 0; j < gameInputs.childCount; j++)
{
Image gameInputImage = gameInputs.GetChild(j).GetComponent <Image>();
gameInputImage.sprite = null;
gameInputImage.enabled = false;
gameInputImageList.Add(gameInputImage);
}
m_GameInputsImage.Add(gameInputImageList);
}
#if !UNITY_EDITOR
m_TextInputs.enabled = false;
m_TextToDisplayInputs.enabled = false;
m_TextInputsAttack.enabled = false;
m_TextToDisplayInputsAttack.enabled = false;
m_TextAttacks.enabled = false;
m_TextToDisplayAttacks.enabled = false;
#endif
}
public override void Update()
{
player = WatchedComponents.FirstOrDefault(c => c is PlayerMovementComponent) as PlayerMovementComponent;
if (AnyDisabled && (player?.OnGround ?? false))
{
foreach (EnergyRefillComponent refill in WatchedComponents.OfType <EnergyRefillComponent>())
{
if (refill.Enabled)
{
continue;
}
refill.Enabled = true;
Renderable renderable = refill.Owner.GetComponent <Renderable>();
if (renderable != null && renderable.Sprites.Count >= 1)
{
renderable.Sprites[0].Source = new Rectangle(0, 0, 16, 16);
}
AnimationComponent animatable = refill.Owner.GetComponent <AnimationComponent>();
if (animatable != null && animatable.Animations.Count >= 1 && animatable.Animations[0].SpriteIndex == 0)
{
AnimatedSprite animation = animatable.Animations[0];
animation.Loop = true;
animation.CurrentFrame = 0;
animation.LoopFrame = 5;
animation.FrameProgress = 0;
animation.FrameDuration = 8;
animation.FrameCount = 9;
animation.Frame = new Rectangle(128, 0, 16, 16);
animation.Step = new Vector2D(-16, 0);
}
}
AnyDisabled = false;
}
}
public PlayerProximityGuardSubComponent(PlayerHealthComponent healthComponent, PlayerMovementComponent movementComponent, Animator anim) : base(healthComponent.gameObject)
{
m_PlayerHealthComponent = healthComponent;
m_PlayerStunInfoSubComponent = m_PlayerHealthComponent.GetStunInfoSubComponent();
m_PlayerMovementComponent = movementComponent;
m_Animator = anim;
Utils.GetPlayerEventManager(m_Owner).StartListening(EPlayerEvent.ProximityBox, OnProximityBoxEvent);
}
void HandleMovementInput(PlayerMovementComponent move)
{
InputSingleton input = InputSingleton.GetLocalInputComponent();
if (input != null)
{
switch (move.State)
{
case MovementState.Idle:
if (input.IsInputActivated())
{
if (input.Jump)
{
ChangeXZVelocityByInput(move, input.InputAxis);
move.EnterState(MovementState.Jump);
}
else if (input.InputAxis != Vector3.zero)
{
ChangeXZVelocityByInput(move, input.InputAxis);
move.EnterState(MovementState.Move);
}
}
break;
case MovementState.Move:
if (input.IsInputActivated())
{
if (input.Jump)
{
ChangeXZVelocityByInput(move, input.InputAxis);
move.EnterState(MovementState.Jump);
}
else
{
ChangeXZVelocityByInput(move, input.InputAxis);
}
}
else
{
move.EnterState(MovementState.Idle);
}
break;
case MovementState.Jump:
ChangeXZVelocityByInput(move, input.InputAxis);
if (move.cc.isGrounded && move.velocity.y < 0)
{
move.EnterState(MovementState.Idle);
}
break;
default:
Debug.LogError("HandleMovementInput: Uncaught movement system state");
break;
}
}
}
// 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)
{
PlayerMovementComponent playerMovementComp = animator.GetComponentInParent <PlayerMovementComponent>();
if (playerMovementComp != null)
{
playerMovementComp.ChangePlayerStance(m_PlayerStance, m_JumpPhase);
}
}
// Use this for initialization
void Start()
{
loopsComponent = GetComponent <LoopsComponent> ();
mainLevelManager = FindObjectOfType <LevelManager> ();
spriteRendered = GetComponent <SpriteRenderer> ();
healthComponent = GetComponent <HealthComponent> ();
effectsManager = GetComponent <EffectsManagerComponent>();
movement = GetComponent <PlayerMovementComponent>();
}
private void Awake()
{
startPosition = transform.localPosition;
startRotation = transform.rotation;
movComp = GetComponent <PlayerMovementComponent>();
rb = GetComponent <Rigidbody>();
anim = GetComponent <Animator>();
audioSource = GetComponent <AudioSource>();
}
public void LockMovement()
{
PlayerMovementComponent pmc = GetComponent <PlayerMovementComponent>();
if (!pmc.Locked)
{
pmc.Destiny = 0;
pmc.Lock();
}
}
public virtual void OnInit(PlayerAttackComponent playerAttackComponent, PlayerAttack attack)
{
m_Owner = playerAttackComponent.gameObject;
m_Attack = attack;
m_Animator = playerAttackComponent.m_Animator;
m_MovementComponent = playerAttackComponent.m_MovementComponent;
m_AttackComponent = playerAttackComponent;
m_InfoComponent = playerAttackComponent.m_InfoComponent;
m_AudioManager = playerAttackComponent.m_AudioManager;
}
void HandleLocalMovement()
{
PlayerMovementComponent move = PlayerMovementComponent.GetLocalMovementComponent();
if (move && move.isMine)
{
HandleMovementInput(move);
MoveObjectByVelocity(move);
}
}
public override void Update()
{
foreach (PlayerAnimation player in WatchedComponents)
{
Physical physical = player.Owner.Components.Get <Physical>();
PlayerMovementComponent movement = player.Owner.Components.Get <PlayerMovementComponent>();
PlayerOrientation orientation = player.Owner.Components.Get <PlayerOrientation>();
PulseAbility pulse = player.Owner.Components.Get <PulseAbility>();
if (physical == null || movement == null || orientation == null)
{
continue;
}
if (pulse != null && pulse.EnergyMeter == 0)
{
player.WooferBlinkingTime += Owner.DeltaTime;
if (player.WooferBlinkingTime >= 0.75)
{
player.WooferBlinkingTime -= 0.75;
}
}
else
{
player.WooferBlinkingTime = 0;
}
if (!movement.OnGround || Math.Abs(physical.Velocity.X) <= 1e-2)
{
player.WalkAnimationProgress = 0;
}
else if (Math.Abs(physical.Velocity.X) > 1e-2)
{
//Console.WriteLine("frames: " + ((int)(Owner.DeltaTime/Owner.FixedDeltaTime)));
if (orientation.Unit.X == 0 || orientation.Unit.X / Math.Abs(orientation.Unit.X) == physical.Velocity.X / Math.Abs(physical.Velocity.X))
{
player.WalkAnimationProgress++;
}
else
{
player.WalkAnimationProgress--;
}
int frameDuration = 8;
int animationFrames = 6;
if (player.WalkAnimationProgress >= animationFrames * frameDuration)
{
player.WalkAnimationProgress = 0;
}
else if (player.WalkAnimationProgress <= 0)
{
player.WalkAnimationProgress = animationFrames * frameDuration - 1;
}
}
}
}
public PlayerCharacter() : base()
{
controller = new PlayerCombatHandler(this);
input = new PlayerInputComponent();
Movement = new PlayerMovementComponent(this);
SetToTile(TileMapManager.Instance.CurrentMap.GetTile((int)TileMapManager.Instance.CurrentMap.mapSize.x / 2, (int)TileMapManager.Instance.CurrentMap.mapSize.y / 2));
Stats.GetHealth().Initialise(this);
//Stats.GetHealth().
CameraController.instance.target = Graphics.entity.transform;
//IEntity.isSelected = true;
}
public void Setup(IMap map, GameManager.PlayerCallbacks callbacks)
{
movementComponent = GetComponent <PlayerMovementComponent>();
controller = new MovementController(map,
new DepthFirst(),
callbacks,
SingletonProvider.MainCombatManager,
movementComponent);
previousPosition = controller.GridPosition;
movementComponent.SetPosition(previousPosition);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
if (Parent)
{
var data = new PlayerMovementComponent
{
Speed = MovementSpeed
};
dstManager.AddComponentData(entity, data);
}
dstManager.AddComponent(entity, typeof(PlayerInputComponent));
}
//Must have: add self to static, and remove on disable
void Awake()
{
RegisterToList();
pv = GetComponent <PhotonView>();
cc = GetComponent <CharacterController>();
if (pv.isMine)
{
isMine = true;
myMovement = this;
}
velocity = Vector3.zero;
State = MovementState.Idle;
}
public override void OnAddedToScene()
{
base.OnAddedToScene();
var coneTexture = Scene.Content.LoadTexture(ContentPaths.Scoop_Cone);
coneDecal = Scene.AddEntity(new SpriteEntity(coneTexture, Constants.RenderLayer_Truck, 0.5f));
coneDecal.ToggleVisible(defaultVisible);
coneSpring = coneDecal.AddComponent(new EntitySpringComponent(this, weaponMountOffset, 5));
shootFX = Scene.AddEntity(new AnimatedEntity());
AddFXAnimation();
shootFX.ToggleVisible(defaultVisible);
playerMove = weaponComponent.GetComponent <PlayerMovementComponent>();
}
public void Reset()
{
FramesBeingUsed = framesRunning;
currentFrame = 0;
jumpCount = 0;
touchingGround = true;
keepMoving = true;
kickBall = kickingBall = finishedEnding = happyEnding = sadEnding = false;
PlayerMovementComponent pmc = GetComponent <PlayerMovementComponent>();
pmc.Unlock();
Position = Vector3.Zero;
pmc.Destiny = Position.X;
pmc.Origin = Position.X;
}
void MoveObjectByVelocity(PlayerMovementComponent move)
{
Vector3 velocityClamp = move.velocity;
velocityClamp.y = 0;
if (velocityClamp.magnitude > move.speedOnGround)
{
velocityClamp = Vector3.ClampMagnitude(velocityClamp, move.speedOnGround);
}
move.velocity.x = velocityClamp.x;
move.velocity.z = velocityClamp.z;
move.velocity.y -= move.gravity * Time.deltaTime;
move.cc.Move(move.velocity * Time.deltaTime);
move.velocity = move.cc.velocity;
}
void ChangeXZVelocityByInput(PlayerMovementComponent move, Vector3 input)
{
switch (move.State)
{
case MovementState.Jump:
AddVectorXZ(ref move.velocity, input * move.accelerationInAir * Time.deltaTime);
break;
case MovementState.Move:
ChangeVectorXZ(ref move.velocity, input * move.speedOnGround);
break;
default:
ChangeVectorXZ(ref move.velocity, Vector3.zero);
break;;
}
}
public override void OnAddedToScene()
{
base.OnAddedToScene();
var mainScene = (Scene as MainScene);
truck = mainScene.truck;
playerWeapon = truck.GetComponent <PlayerWeaponComponent>();
playerWeapon.OnWeaponCycle += UpdateWeaponIcons;
playerMove = truck.GetComponent <PlayerMovementComponent>();
playerHealth = truck.GetComponent <HealthComponent>();
playerHealth.OnHealthChanged += (h) => UpdateHealth(h);
playerAmmo = truck.GetComponent <AmmoComponent>();
playerAmmo.OnAmmoChanged += a => UpdateAmmo(a);
playerState = truck.GetComponent <PlayerStateMachine>();
SetUpUI();
}
private void Start()
{
movement = GetComponent <PlayerMovementComponent>();
UIHealthText.text = health.ToString("R");
}
public override void Render <TSurface, TSource>(ScreenRenderer <TSurface, TSource> r)
{
foreach (PlayerAnimation player in WatchedComponents)
{
Renderable renderable = player.Owner.Components.Get <Renderable>();
Vector2D[] srcOffsets = new Vector2D[5];
srcOffsets[Legs] = new Vector2D(0, Origins[Legs]);
srcOffsets[Torso] = new Vector2D(0, Origins[Torso]);
srcOffsets[Head] = new Vector2D(0, Origins[Head]);
srcOffsets[Woofer] = new Vector2D(0, Origins[Woofer]);
srcOffsets[Arms] = new Vector2D(0, Origins[Arms]);
Vector2D[] destOffsets = new Vector2D[5];
destOffsets[Legs] = destOffsets[Torso] = destOffsets[Head] = destOffsets[Woofer] = destOffsets[Arms] = Vector2D.Empty;
if (!player.Initialized)
{
renderable.Sprites = new List <Sprite>()
{
new Sprite(player.SpritesheetName, Destination, new Rectangle(srcOffsets[Legs], 32, 32)),
new Sprite(player.SpritesheetName, Destination, new Rectangle(srcOffsets[Torso], 32, 32)),
new Sprite(player.SpritesheetName, Destination, new Rectangle(srcOffsets[Head], 32, 32)),
new Sprite("woofer", Destination, new Rectangle(srcOffsets[Woofer], 0, 0)),
new Sprite(player.SpritesheetName, Destination, new Rectangle(srcOffsets[Arms], 32, 32))
};
player.Initialized = true;
}
Physical physical = player.Owner.Components.Get <Physical>();
PlayerMovementComponent movement = player.Owner.Components.Get <PlayerMovementComponent>();
PlayerOrientation orientation = player.Owner.Components.Get <PlayerOrientation>();
if (physical == null || movement == null || orientation == null)
{
continue;
}
PulseAbility pulse = player.Owner.Components.Get <PulseAbility>();
bool handsFree = pulse == null;
if (orientation.Unit.X > 0 || player.LastLookedRight)
{
for (int i = Legs; i <= Arms; i++)
{
srcOffsets[i] += OrientationOffset;
}
}
bool forceLook = handsFree && !movement.OnGround;
if (orientation.Unit.Y >= Math.Sin(Math.PI / 9))
{
if (!forceLook)
{
srcOffsets[Head].X += 32;
}
srcOffsets[Woofer].X += 32;
if (!handsFree)
{
srcOffsets[Arms].X += 32;
}
if (orientation.Unit.Y >= Math.Sin(2 * Math.PI / 6))
{
srcOffsets[Woofer].X += 32;
if (!handsFree)
{
srcOffsets[Arms].X += 32;
}
}
}
else if (orientation.Unit.Y <= Math.Sin(-Math.PI / 9))
{
if (!forceLook)
{
srcOffsets[Head].X += 64;
}
srcOffsets[Woofer].X += 96;
if (!handsFree)
{
srcOffsets[Arms].X += 96;
}
if (orientation.Unit.Y <= Math.Sin(-2 * Math.PI / 6))
{
srcOffsets[Woofer].X += 32;
destOffsets[Woofer] += new Vector2D(0, -3); //Offset woofer down since it goes out of the spritesheet grid
if (!handsFree)
{
srcOffsets[Arms].X += 32;
}
}
}
if (forceLook)
{
srcOffsets[Head].X += physical.Velocity.Y <= 0 ? 64 : 32;
}
if (orientation.Unit.X != 0)
{
player.LastLookedRight = orientation.Unit.X > 0;
}
if (pulse != null)
{
srcOffsets[Woofer].Y = 256;
srcOffsets[Woofer].Y -= 32 * Math.Round(pulse.EnergyMeter / 20);
if (pulse.EnergyMeter == 0 && player.WooferBlinkingTime >= 0.375)
{
srcOffsets[Woofer].Y += 32;
}
}
if (handsFree)
{
srcOffsets[Arms].Y += 32;
}
if (!movement.OnGround || Math.Abs(physical.Velocity.X) <= 1e-2) /*player.WalkAnimationProgress = 0;*/ } {
// Start is called before the first frame update
void Start()
{
movementComponent = gameObject.GetComponent <PlayerMovementComponent>();
}
