public void attemptRopeGrab(string levelUid, int characterId)
{
CharacterMovementComponent characterMovementComponent = _entityManager.getComponent(levelUid, characterId, ComponentType.CharacterMovement) as CharacterMovementComponent;
PhysicsComponent physicsComponent = _entityManager.getComponent(levelUid, characterId, ComponentType.Physics) as PhysicsComponent;
attemptRopeGrab(levelUid, characterId, characterMovementComponent, physicsComponent, null);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Start()
{
m_CachedCameraRaycaster = Camera.main.GetComponent <CameraRayCaster>();
m_CachedMovementComponent = GetComponent <CharacterMovementComponent>();
m_CachedWeaponComponent = GetComponent <WeaponComponent>();
m_CachedDamageComponent = GetComponent <DamageComponent>();
m_CachedDamageComponent.SetCurrentTeam(CharacterTeamEnum.CharacterTeamEnum_Player);
}
public void update(GameTime gameTime)
{
LevelSystem levelSystem = _systemManager.getSystem(SystemType.Level) as LevelSystem;
string levelUid = LevelSystem.currentLevelUid;
float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
if (levelSystem.finalized)
{
if (!_paused || _singleStep)
{
List <int> characterRenderEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.CharacterRender);
for (int i = 0; i < characterRenderEntities.Count; i++)
{
CharacterRenderComponent characterRenderComponent = _entityManager.getComponent(levelUid, characterRenderEntities[i], ComponentType.CharacterRender) as CharacterRenderComponent;
CharacterMovementComponent characterMovementComponent = _entityManager.getComponent(levelUid, characterRenderEntities[i], ComponentType.CharacterMovement) as CharacterMovementComponent;
float changeRate = 1f / _animationManager.getFPS(characterRenderComponent.character, characterRenderComponent.animation);
// Handle time
characterRenderComponent.time += dt;
if (characterRenderComponent.time >= changeRate)
{
int currentFrame = characterRenderComponent.currentFrame;
int totalFrames = _animationManager.getFrameCount(characterRenderComponent.character, characterRenderComponent.animation);
int nextFrame = currentFrame + 1;
characterRenderComponent.currentFrame = nextFrame == totalFrames ? 0 : nextFrame;
characterRenderComponent.time -= changeRate;
}
// Update animation
if (characterMovementComponent.walkLeft)
{
if (characterRenderComponent.animation != "walk_left")
{
setAnimation(characterRenderComponent, "walk_left");
}
}
else if (characterMovementComponent.walkRight)
{
if (characterRenderComponent.animation != "walk_right")
{
setAnimation(characterRenderComponent, "walk_right");
}
}
else
{
if (characterRenderComponent.animation != "idle")
{
setAnimation(characterRenderComponent, "idle");
}
}
}
}
_singleStep = false;
}
}
public override void ApplyAbilityEffect()
{
CharacterMovementComponent ownerMovementComponent = m_AbilityOwner.GetComponent <CharacterMovementComponent>();
if (ownerMovementComponent != null)
{
ownerMovementComponent.ApplyAttackSpeedModifier((m_AbilityConfig as FastAttackAbilityConfig).GetTimeActive());
}
}
public void update(GameTime gameTime)
{
if (!_paused || _singleStep)
{
if (_levelSystem.finalized)
{
string levelUid = LevelSystem.currentLevelUid;
List <int> wanderBehaviorEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.AIWanderBehavior);
List <WaypointsComponent> waypointsComponents = _entityManager.getComponents <WaypointsComponent>(levelUid, ComponentType.Waypoints);
for (int i = 0; i < wanderBehaviorEntities.Count; i++)
{
int entityId = wanderBehaviorEntities[i];
AIWanderBehaviorComponent behaviorComponent = _entityManager.getComponent(levelUid, entityId, ComponentType.AIWanderBehavior) as AIWanderBehaviorComponent;
CharacterMovementComponent movementComponent = _entityManager.getComponent(levelUid, entityId, ComponentType.CharacterMovement) as CharacterMovementComponent;
if (behaviorComponent.currentDelay > 0)
{
movementComponent.walkLeft = false;
movementComponent.walkRight = false;
behaviorComponent.currentDelay--;
}
else
{
WaypointsComponent waypointsComponent = getWaypointsComponent(behaviorComponent.waypointsUid, waypointsComponents);
if (waypointsComponent != null)
{
WorldPositionComponent worldPositionComponent = _entityManager.getComponent(levelUid, entityId, ComponentType.WorldPosition) as WorldPositionComponent;
Vector2 currentWaypoint = waypointsComponent.waypoints[behaviorComponent.currentWaypointIndex];
Vector2 relative = currentWaypoint - worldPositionComponent.position;
movementComponent.speedLimit = behaviorComponent.walkSpeed;
if (relative.X > 0.25f)
{
movementComponent.walkRight = true;
movementComponent.walkLeft = false;
}
else if (relative.X < -0.25f)
{
movementComponent.walkLeft = true;
movementComponent.walkRight = false;
}
else
{
behaviorComponent.currentWaypointIndex = _random.Next(waypointsComponent.waypoints.Count);
behaviorComponent.currentDelay = _random.Next(behaviorComponent.minDelay, behaviorComponent.maxDelay + 1);
}
}
}
}
}
}
_singleStep = false;
}
public void InfiniteDash()
{
Character[] c = FindObjectsOfType <Character>();
foreach (Character p in c)
{
CharacterMovementComponent m = p.GetComponent <CharacterMovementComponent>();
p.GetComponent <PhotonView>().RPC("NetworkDash", PhotonTargets.All, m.currentTile.position.x, m.currentTile.position.y, m._lastMoveDirection.x, m._lastMoveDirection.y, 100);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
void Start()
{
m_CachedPlayerGameObject = GameObject.FindGameObjectWithTag("Player");//Replace with static helper?
m_CachedMovementComponent = GetComponent <CharacterMovementComponent>();
m_CachedWeaponComponent = GetComponent <WeaponComponent>();
m_CachedAnimatorComponent = GetComponent <Animator>();
m_CachedDamageComponent = GetComponent <DamageComponent>();
m_CachedSpecialAbilityComponent = GetComponent <SpecialAbiltyComponent>();
m_CachedWeaponComponent.SetCurrentTarget(m_CachedPlayerGameObject);//Target will always be player
m_CurrentAIState = AIState.AIState_Idle;
m_CachedDamageComponent.SetCurrentTeam(CharacterTeamEnum.CharacterTeamEnum_AI);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
public override void ApplyAbilityEffect()
{
m_ZoneOfEffectCollisions = Physics.OverlapSphere(m_AbilityCurrentTarget.transform.position, 2f);
foreach (Collider currentCollider in m_ZoneOfEffectCollisions)
{
DamageComponent currentDamageComponent = currentCollider.gameObject.GetComponent <DamageComponent>();
CharacterMovementComponent currentMovementComponent = currentCollider.gameObject.GetComponent <CharacterMovementComponent>();
if (currentDamageComponent != null && currentMovementComponent != null)
{
if (m_AbilityOwnerDamageComponent.GetCurrentTeam() != currentDamageComponent.GetCurrentTeam())
{
AoeSlowAbilityConfig abilityConfig = m_AbilityConfig as AoeSlowAbilityConfig;
currentMovementComponent.ApplyMovementSpeedModifier(abilityConfig.GetAbilitySlowPercentage(), abilityConfig.GetAbilityDuration());
}
}
}
}
public void PostSolve(Contact contact, ContactConstraint contactConstraint)
{
string levelUid = LevelSystem.currentLevelUid;
List <int> characterEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.CharacterMovement);
int entityAId = (int)contact.FixtureA.Body.UserData;
int entityBId = (int)contact.FixtureB.Body.UserData;
CharacterMovementComponent characterMovementComponent = null;
FixedArray2 <Vector2> points;
Vector2 normal;
characterMovementComponent = (_entityManager.getComponent(levelUid, entityAId, ComponentType.CharacterMovement) ?? _entityManager.getComponent(levelUid, entityBId, ComponentType.CharacterMovement)) as CharacterMovementComponent;
if (characterMovementComponent != null)
{
if (contact.FixtureA == characterMovementComponent.feetFixture || contact.FixtureB == characterMovementComponent.feetFixture)
{
contact.GetWorldManifold(out normal, out points);
characterMovementComponent.collisionNormals.Add(normal);
//if (characterMovementComponent.allowJumpResetOnCollision)
// characterMovementComponent.alreadyJumped = false;
}
}
}
public void attemptRopeGrab(string levelUid, int characterId, CharacterMovementComponent characterMovementComponent, PhysicsComponent physicsComponent, RopeGrabComponent existingRopeGrabComponent)
{
float margin = 0.5f;
AABB region = new AABB();
RopeNode ropeNode = null;
int nodeCount = 0;
region.LowerBound = physicsComponent.body.Position - new Vector2(margin, margin);
region.UpperBound = physicsComponent.body.Position + new Vector2(margin, margin);
if (physicsComponent == null)
{
return;
}
// Query the world for a body, and check to see if it's a rope
physicsComponent.body.World.QueryAABB((fixture) =>
{
int ropeEntityId = (int)fixture.Body.UserData;
RopeComponent ropeComponent = (RopeComponent)_entityManager.getComponent(levelUid, ropeEntityId, ComponentType.Rope);
RopeGrabComponent ropeGrabComponent = null;
if (ropeComponent != null && !ropeComponent.doubleAnchor)
{
RopeNode current = ropeComponent.ropeNodeHead;
characterMovementComponent.allowRopeGrab = false;
while (current != null)
{
if (current.body == fixture.Body)
{
ropeNode = current;
break;
}
nodeCount++;
current = current.next;
}
if (existingRopeGrabComponent != null)
{
RopeComponent existingRopeComponent = (RopeComponent)_entityManager.getComponent(levelUid, existingRopeGrabComponent.ropeEntityId, ComponentType.Rope);
if (existingRopeComponent.destroyAfterRelease)
{
existingRopeComponent.timeToLive = 100;
}
_ropeSystem.releaseRope(existingRopeGrabComponent, physicsComponent.body);
_entityManager.removeComponent(levelUid, characterId, existingRopeGrabComponent);
}
ropeGrabComponent = new RopeGrabComponent(ropeEntityId, ropeNode, (float)nodeCount, ropeComponent.reverseClimbDirection);
_ropeSystem.grabRope(ropeGrabComponent, physicsComponent.body);
_entityManager.addComponent(levelUid, characterId, ropeGrabComponent);
return(false);
}
return(true);
},
ref region);
}
public void update(GameTime gameTime)
{
if (!_paused || _singleStep)
{
LevelSystem levelSystem = _systemManager.getSystem(SystemType.Level) as LevelSystem;
if (levelSystem.finalized)
{
string levelUid = LevelSystem.currentLevelUid;
List <int> characterEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.CharacterMovement);
for (int i = 0; i < characterEntities.Count; i++)
{
PhysicsComponent physicsComponent = _entityManager.getComponent(levelUid, characterEntities[i], ComponentType.Physics) as PhysicsComponent;
ParticleInfluenceComponent particleInfluenceComponent = _entityManager.getComponent(levelUid, characterEntities[i], ComponentType.ParticleInfluence) as ParticleInfluenceComponent;
CharacterMovementComponent characterMovementComponent = _entityManager.getComponent(levelUid, characterEntities[i], ComponentType.CharacterMovement) as CharacterMovementComponent;
RopeGrabComponent ropeGrabComponent = _entityManager.getComponent(levelUid, characterEntities[i], ComponentType.RopeGrab) as RopeGrabComponent;
Body body = physicsComponent.body;
float currentSpeed = body.LinearVelocity.Length();
// Handle fluid properties
characterMovementComponent.inFluid = particleInfluenceComponent.particleCount > 2;
// Handle rope grabs
if (characterMovementComponent.allowRopeGrab && characterMovementComponent.doRopeGrab)
{
attemptRopeGrab(levelUid, characterEntities[i], characterMovementComponent, physicsComponent, ropeGrabComponent);
}
// Calculate movement vector
if (characterMovementComponent.collisionNormals.Count > 0)
{
characterMovementComponent.movementUnitVector = Vector2.Zero;
for (int j = 0; j < characterMovementComponent.collisionNormals.Count; j++)
{
characterMovementComponent.movementUnitVector += characterMovementComponent.collisionNormals[j] / characterMovementComponent.collisionNormals.Count;
}
characterMovementComponent.movementUnitVector = new Vector2(characterMovementComponent.movementUnitVector.Y, -characterMovementComponent.movementUnitVector.X);
characterMovementComponent.movementUnitVector.Normalize();
}
else
{
characterMovementComponent.movementUnitVector = new Vector2(-1, 0);
}
// On surface movement
if (characterMovementComponent.onSurface)
{
if (characterMovementComponent.walkLeft || characterMovementComponent.walkRight)
{
// Adjust friction
if (body.LinearVelocity.X < -0.1f && characterMovementComponent.walkRight)
{
body.Friction = 10f;
}
else if (body.LinearVelocity.X > 0.1f && characterMovementComponent.walkLeft)
{
body.Friction = 10f;
}
else
{
body.Friction = 0.1f;
}
// Walk
if (currentSpeed <= characterMovementComponent.speedLimit)
{
Vector2 impulse = characterMovementComponent.movementUnitVector * _baseWalkMultiplier;
if (characterMovementComponent.walkRight)
{
impulse *= -1;
}
if (characterMovementComponent.inFluid)
{
impulse *= 0.5f;
}
body.ApplyLinearImpulse(ref impulse);
}
}
else
{
body.Friction = 10f;
}
}
else // In-air movement
{
if (characterMovementComponent.walkLeft || characterMovementComponent.walkRight)
{
if (ropeGrabComponent != null)
{
// Swing
Vector2 impulse = characterMovementComponent.movementUnitVector * _baseSwingMultiplier;
if (characterMovementComponent.walkRight)
{
impulse *= -1;
}
body.ApplyLinearImpulse(ref impulse);
}
else
{
// Air walk
if ((body.LinearVelocity.X < 0 && characterMovementComponent.walkRight) ||
(body.LinearVelocity.X > 0 && characterMovementComponent.walkLeft) ||
(body.LinearVelocity.X > -characterMovementComponent.speedLimit && characterMovementComponent.walkLeft) ||
(body.LinearVelocity.X < characterMovementComponent.speedLimit && characterMovementComponent.walkRight))
{
Vector2 impulse = characterMovementComponent.movementUnitVector * _baseAirWalkMultiplier;
if (characterMovementComponent.walkRight)
{
impulse *= -1;
}
body.ApplyLinearImpulse(ref impulse);
}
}
}
}
// Jump
if (characterMovementComponent.attemptJump)
{
// While holding rope
if (ropeGrabComponent != null)
{
RopeComponent ropeComponent = _entityManager.getComponent(levelUid, ropeGrabComponent.ropeEntityId, ComponentType.Rope) as RopeComponent;
Vector2 impulse = new Vector2(0, -1.2f);
if (ropeComponent != null && ropeComponent.destroyAfterRelease)
{
ropeComponent.timeToLive = 100;
}
_ropeSystem.releaseRope(ropeGrabComponent, physicsComponent.body);
_entityManager.removeComponent(levelUid, characterEntities[i], ropeGrabComponent);
ropeGrabComponent = null;
body.ApplyLinearImpulse(ref impulse);
}
if (characterMovementComponent.onSurface)
{
Vector2 impulse = new Vector2(0, -2f);
float adjustment = 0f;
// Try to limit the impulse based on the current y velocity.
// This is done to prevent jumps from contributing too much to the y velocity when
// the player is already moving upwards too fast (which results in a super-jump).
adjustment = (body.LinearVelocity.Y / 6f);
impulse.Y -= adjustment;
body.ApplyLinearImpulse(ref impulse);
characterMovementComponent.attemptJump = false;
}
}
// Swim
if (characterMovementComponent.inFluid && characterMovementComponent.swimUp)
{
Vector2 impulse = new Vector2(0, -0.25f);
body.ApplyLinearImpulse(ref impulse);
}
// Climbing
if (ropeGrabComponent != null)
{
float climbSpeed = characterMovementComponent.climbAmount * CLIMB_SPEED;
if (characterMovementComponent.climbUp)
{
_ropeSystem.moveAttachedBody(ropeGrabComponent, physicsComponent.body, climbSpeed);
}
else if (characterMovementComponent.climbDown)
{
_ropeSystem.moveAttachedBody(ropeGrabComponent, physicsComponent.body, -climbSpeed);
}
}
}
}
}
_singleStep = false;
}
public void update(GameTime gameTime)
{
if (_singleStep || !_paused)
{
LevelSystem levelSystem = _systemManager.getSystem(SystemType.Level) as LevelSystem;
if (levelSystem.finalized)
{
string levelUid = LevelSystem.currentLevelUid;
EventSystem eventSystem = _systemManager.getSystem(SystemType.Event) as EventSystem;
List <CharacterMovementComponent> movementComponents = _entityManager.getComponents <CharacterMovementComponent>(levelUid, ComponentType.CharacterMovement);
List <int> ropeGrabEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.RopeGrab);
List <int> prismaticEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.Prismatic);
List <int> physicsEntities;
for (int i = 0; i < _bodiesToRemove.Count; i++)
{
getWorld(levelUid).RemoveBody(_bodiesToRemove[i]);
}
_bodiesToRemove.Clear();
for (int i = 0; i < movementComponents.Count; i++)
{
CharacterMovementComponent movementComponent = movementComponents[i];
movementComponent.collisionNormals.Clear();
}
for (int i = 0; i < prismaticEntities.Count; i++)
{
PrismaticJointComponent prismaticJointComponent = _entityManager.getComponent(levelUid, prismaticEntities[i], ComponentType.Prismatic) as PrismaticJointComponent;
LimitState limitState = prismaticJointComponent.prismaticJoint.LimitState;
if (prismaticJointComponent.previousLimitState != limitState)
{
if (limitState == LimitState.AtLower)
{
eventSystem.postEvent(new GameEvent(GameEventType.OnLowerLimitReached, prismaticEntities[i]));
}
else if (limitState == LimitState.AtUpper)
{
//eventSystem.postEvent(new GameEvent(GameEventType.OnUpperLimitReached, prismaticEntities[i]));
}
}
prismaticJointComponent.previousLimitState = limitState;
}
getWorld(levelUid).Step(_dt);
// Handle physic entities
physicsEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.Physics);
for (int i = 0; i < physicsEntities.Count; i++)
{
PhysicsComponent physicsComponent = _entityManager.getComponent(levelUid, physicsEntities[i], ComponentType.Physics) as PhysicsComponent;
WorldPositionComponent worldPositionComponent = _entityManager.getComponent(levelUid, physicsEntities[i], ComponentType.WorldPosition) as WorldPositionComponent;
FollowMetamerComponent followMetamerComponent = _entityManager.getComponent(levelUid, physicsEntities[i], ComponentType.FollowMetamer) as FollowMetamerComponent;
// Set body position to the metamer being followed
if (followMetamerComponent != null)
{
physicsComponent.body.Position = followMetamerComponent.metamer.position;
physicsComponent.body.Rotation = followMetamerComponent.metamer.currentAngle + StasisMathHelper.halfPi;
}
// Update world position component
worldPositionComponent.position = physicsComponent.body.Position;
}
}
}
_singleStep = false;
}
// Handle player character movement
private void handleCharacterMovement(string levelUid, PhysicsComponent playerPhysicsComponent, bool inDialogue)
{
if (playerPhysicsComponent != null)
{
CharacterMovementComponent characterMovementComponent = _entityManager.getComponent(levelUid, PLAYER_ID, ComponentType.CharacterMovement) as CharacterMovementComponent;
RopeGrabComponent ropeGrabComponent = _entityManager.getComponent(levelUid, PLAYER_ID, ComponentType.RopeGrab) as RopeGrabComponent;
if (InputSystem.usingGamepad)
{
if (InputSystem.newGamepadState.ThumbSticks.Left.X < 0)
{
//characterMovementComponent.walkSpeedModifier = Math.Abs(InputSystem.newGamepadState.ThumbSticks.Left.X);
characterMovementComponent.walkLeft = true;
}
else if (InputSystem.newGamepadState.DPad.Left == ButtonState.Pressed)
{
characterMovementComponent.walkLeft = true;
}
else
{
characterMovementComponent.walkLeft = false;
}
if (InputSystem.newGamepadState.ThumbSticks.Left.X > 0)
{
//characterMovementComponent.walkSpeedModifier = InputSystem.newGamepadState.ThumbSticks.Left.X;
characterMovementComponent.walkRight = true;
}
else if (InputSystem.newGamepadState.DPad.Right == ButtonState.Pressed)
{
characterMovementComponent.walkRight = true;
}
else
{
characterMovementComponent.walkRight = false;
}
characterMovementComponent.climbAmount = 0f;
characterMovementComponent.climbDown = false;
characterMovementComponent.climbUp = false;
if (InputSystem.newGamepadState.ThumbSticks.Left.Y > 0)
{
characterMovementComponent.climbUp = true;
characterMovementComponent.climbAmount = Math.Abs(InputSystem.newGamepadState.ThumbSticks.Left.Y);
}
else if (InputSystem.newGamepadState.ThumbSticks.Left.Y < 0)
{
characterMovementComponent.climbDown = true;
characterMovementComponent.climbAmount = Math.Abs(InputSystem.newGamepadState.ThumbSticks.Left.Y);
}
characterMovementComponent.attemptJump = InputSystem.newGamepadState.Buttons.A == ButtonState.Pressed;
}
else
{
//characterMovementComponent.walkSpeedModifier = 1f;
characterMovementComponent.walkLeft = InputSystem.newKeyState.IsKeyDown(Keys.A) || InputSystem.newKeyState.IsKeyDown(Keys.Left);
characterMovementComponent.walkRight = InputSystem.newKeyState.IsKeyDown(Keys.D) || InputSystem.newKeyState.IsKeyDown(Keys.Right);
characterMovementComponent.attemptJump = InputSystem.newKeyState.IsKeyDown(Keys.Space) && InputSystem.oldKeyState.IsKeyUp(Keys.Space);
characterMovementComponent.swimUp = InputSystem.newKeyState.IsKeyDown(Keys.Space);
characterMovementComponent.climbUp = InputSystem.newKeyState.IsKeyDown(Keys.W);
characterMovementComponent.climbDown = InputSystem.newKeyState.IsKeyDown(Keys.S);
characterMovementComponent.climbAmount = 1f;
characterMovementComponent.doRopeGrab = InputSystem.newKeyState.IsKeyDown(Keys.E) && InputSystem.oldKeyState.IsKeyUp(Keys.E);
characterMovementComponent.allowRopeGrab = characterMovementComponent.allowRopeGrab ? true : (InputSystem.newKeyState.IsKeyUp(Keys.E) && InputSystem.oldKeyState.IsKeyDown(Keys.E));
}
}
}
