protected override void OnUpdate()
{
for (int i = 0; i < FollowEntities.Length; i++)
{
Transform trans = FollowEntities.Transforms[i];
FollowComponent fc = FollowEntities.FollowComponents[i];
VelocityComponent vc = FollowEntities.VelocityComponents[i];
Vector3 direction = trans.InverseTransformDirection(fc.followTrans.position - trans.position);
if (direction.magnitude < fc.stopDistance)
{
vc.inputX = Mathf.Lerp(vc.inputX, 0, Time.deltaTime * 3);
vc.inputY = Mathf.Lerp(vc.inputY, 0, Time.deltaTime * 3);
}
else
{
direction.Normalize();
vc.inputX = Mathf.Lerp(vc.inputX, direction.x, Time.deltaTime * 3);
vc.inputY = Mathf.Lerp(vc.inputY, direction.z, Time.deltaTime * 3);
}
}
for (int i = 0; i < LookAtEntities.Length; i++)
{
Transform trans = LookAtEntities.Transforms[i];
LookAtComponent lookAt = LookAtEntities.LookAtComponents[i];
HeadingComponent heading = LookAtEntities.HeadingComponents[i];
Vector3 direction = lookAt.lookTrans.position - trans.position;
trans.rotation = Quaternion.Lerp(trans.rotation, Quaternion.LookRotation(direction), Time.deltaTime * heading.angularSpeed);
}
}
void applyAcceleration(Entity e, float deltaTime)
{
AccelerationComponent acceleration = e.acceleration;
VelocityComponent velocity = e.velocity;
acceleration.x = getAcceleration(acceleration.x, acceleration.frictionX, deltaTime);
acceleration.y = getAcceleration(acceleration.y, acceleration.frictionY, deltaTime);
velocity.vel += new Vector2(acceleration.x * deltaTime, acceleration.y * deltaTime);
if (acceleration.stopNearZero) // todo
{
int count = 0;
if (Mathf.Abs(velocity.vel.x) < EPSILON)
{
velocity.vel.x = 0.0f;
count++;
}
if (Mathf.Abs(velocity.vel.y) < EPSILON)
{
velocity.vel.y = 0.0f;
count++;
}
if (count == 2)
{
e.RemoveAcceleration();
}
}
}
public RocketEntity(GameEntity rocketE)
{
FirePower = rocketE.firePower;
Health = rocketE.health;
Position = rocketE.position;
Velocity = rocketE.velocity;
}
public override void Process(Entity entity)
{
VelocityComponent velocityComponent = entity.GetComponent <VelocityComponent>();
PositionComponent positionComponent = entity.GetComponent <PositionComponent>();
positionComponent.Position += velocityComponent.Velocity * (float)DeltaTime.TotalSeconds;
float speed = velocityComponent.Velocity.Length();
if (speed > 0f)
{
float newSpeed = speed - velocityComponent.Friction * (float)DeltaTime.TotalSeconds;
float ratio = newSpeed / speed;
if (ratio < 0f)
{
ratio = 0f;
}
velocityComponent.Velocity *= ratio;
speed = newSpeed;
}
if (speed > velocityComponent.MaxSpeed)
{
velocityComponent.Velocity *= velocityComponent.MaxSpeed / speed;
}
}
//You must have an Update.
public override void Update(float deltaTime)
{
foreach (Entity e in getApplicableEntities())
{
PushableComponent pushComp = ( PushableComponent )e.getComponent(GlobalVars.PUSHABLE_COMPONENT_NAME);
if (!pushComp.dontSlow && !pushComp.wasPushedLastFrame)
{
VelocityComponent velComp = ( VelocityComponent )e.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
if (Math.Abs(velComp.x) > slowRate)
{
if (velComp.x < 0)
{
velComp.x += slowRate;
}
else
{
velComp.x -= slowRate;
}
}
else if (velComp.x != 0)
{
velComp.x = 0;
}
}
if (pushComp.wasPushedLastFrame)
{
pushComp.wasPushedLastFrame = false;
}
}
}
public void Update(float deltaTime)
{
foreach (Entity entity in _entities)
{
PositionComponent positionComponent = (PositionComponent)entity.GetComponentOfType(typeof(PositionComponent));
VelocityComponent velocityComponent = (VelocityComponent)entity.GetComponentOfType(typeof(VelocityComponent));
positionComponent.position += velocityComponent.velocity * deltaTime;
// Windows collision tweak
if (positionComponent.position.X < 0)
{
positionComponent.position.X = 0;
velocityComponent.velocity.X = 0;
}
if (positionComponent.position.Y < 0)
{
positionComponent.position.Y = 0;
velocityComponent.velocity.Y = 0;
}
if (positionComponent.position.X > _gameEngine.GetDisplayWindow().GetForm().Width - 50)
{
positionComponent.position.X = _gameEngine.GetDisplayWindow().GetForm().Width - 50;
velocityComponent.velocity.X = 0;
}
if (positionComponent.position.Y > _gameEngine.GetDisplayWindow().GetForm().Height - 50)
{
positionComponent.position.X = _gameEngine.GetDisplayWindow().GetForm().Height - 50;
velocityComponent.velocity.Y = 0;
}
positionComponent.orientation += velocityComponent.angularVelocity * deltaTime;
}
}
public override void _Ready()
{
AddToGroup(GROUP);
_moveStateMachine.AddState(MoveState.GROUNDED, MoveStateGrounded);
_moveStateMachine.AddState(MoveState.AIRBORNE, MoveStateAirborne);
_moveStateMachine.AddState(MoveState.DASH, MoveStateDash);
_moveStateMachine.AddState(MoveState.SLIDE, MoveStateSlide);
_moveStateMachine.AddState(MoveState.WALL, MoveStateWall);
_moveStateMachine.AddLeaveState(MoveState.WALL, LeaveMoveStateWall);
_moveStateMachine.AddLeaveState(MoveState.GROUNDED, LeaveMoveStateGrounded);
_moveStateMachine.AddLeaveState(MoveState.AIRBORNE, LeaveMoveStateAirborne);
_moveStateMachine.AddLeaveState(MoveState.DASH, LeaveMoveStateDash);
_moveStateMachine.SetInitialState(MoveState.GROUNDED);
_animatedSprite = GetNode <AnimatedSprite>("AnimatedSprite");
_velocityComponent = this.GetFirstNodeOfType <VelocityComponent>();
_healthComponent = this.GetFirstNodeOfType <HealthComponent>();
_animationPlayer = GetNode <AnimationPlayer>("AnimationPlayer");
_flipSprite = GetNode <Sprite>("FlipSprite");
_flipTween = GetNode <Tween>("FlipTween");
_walkParticles = GetNode <Particles2D>("WalkParticles");
_dashParticles = GetNode <Particles2D>("DashParticles");
var weaponSocket = this.GetFirstNodeOfType <WeaponSocketComponent>();
weaponSocket.EquipWeapon((GD.Load("res://scenes/GameObject/Combat/GrenadeLauncher.tscn") as PackedScene).Instance() as Weapon);
weaponSocket = GetNode <WeaponSocketComponent>("WeaponSocketComponent2");
weaponSocket.EquipWeapon((GD.Load("res://scenes/GameObject/Combat/PlayerWeapon.tscn") as PackedScene).Instance() as Weapon);
_flipTween.Connect("tween_all_completed", this, nameof(OnFlipTweenCompleted));
_healthComponent?.Connect(nameof(HealthComponent.HealthChanged), this, nameof(OnHealthChanged));
}
//--------------------------HANDLE DIRECTION CHANGE--------------------------
private void checkForDirectionChange(Entity e)
{
SmushComponent smushComp = ( SmushComponent )e.getComponent(GlobalVars.SMUSH_COMPONENT_NAME);
VelocityComponent velComp = ( VelocityComponent )e.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
float stopBuffer = 0.01f;
if (smushComp.getFallSpeed().X != 0 && Math.Abs(velComp.x) < stopBuffer)
{
if (smushComp.isFalling())
{
startLowerWait(e);
}
else if (smushComp.isRising())
{
startUpperWait(e);
}
}
if (smushComp.getFallSpeed().Y != 0 && Math.Abs(velComp.y) < stopBuffer)
{
if (smushComp.isFalling())
{
startLowerWait(e);
}
else if (smushComp.isRising())
{
startUpperWait(e);
}
}
}
public void fireItem(Entity e, DirectionalComponent dir)
{
TimedShooterComponent timedShooterComp = ( TimedShooterComponent )e.getComponent(GlobalVars.TIMED_SHOOTER_COMPONENT_NAME);
PositionComponent posComp = (PositionComponent)e.getComponent(GlobalVars.POSITION_COMPONENT_NAME);
ShooterBullet bullet = new ShooterBullet(level, level.rand.Next(Int32.MinValue, Int32.MaxValue), posComp.x, posComp.y, dir.getDir(), timedShooterComp.state);
VelocityComponent bulletVel = ( VelocityComponent )bullet.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
float bulletSpeed = 160.0f;
if (dir.isUp())
{
bulletVel.setVelocity(0, -bulletSpeed);
}
else if (dir.isRight())
{
bulletVel.setVelocity(bulletSpeed, 0);
}
else if (dir.isDown())
{
bulletVel.setVelocity(0, bulletSpeed);
}
else if (dir.isLeft())
{
bulletVel.setVelocity(-bulletSpeed, 0);
}
level.addEntity(bullet);
}
public void finishGrapple(Entity grapple)
{
if (!level.getPlayer().hasComponent(GlobalVars.PLAYER_INPUT_COMPONENT_NAME))
{
PlayerInputComponent plInComp = ( PlayerInputComponent )level.getPlayer().addComponent(new PlayerInputComponent(level.getPlayer()));
plInComp.passedAirjumps = 0;
}
if (!level.getPlayer().hasComponent(GlobalVars.GRAVITY_COMPONENT_NAME))
{
level.getPlayer().addComponent(new GravityComponent(0, GlobalVars.STANDARD_GRAVITY));
}
if (stopPlayer)
{
VelocityComponent velComp = ( VelocityComponent )level.getPlayer().getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
velComp.x = 0;
velComp.y = 0;
stopPlayer = false;
}
if (level.curGrap == grapple)
{
level.curGrap = null;
}
level.removeEntity(grapple);
return;
}
public override void Update(float deltaTime)
{
if (!hasRunOnce)
{
level.getInputSystem().addKey(glideKey);
//level.getInputSystem().addKey(blockSpawnKey);
level.getInputSystem().addKey(speedyKey);
level.getInputSystem().addKey(cycleDownPowerupKey);
//level.getInputSystem().addKey(cycleUpPowerupKey);
level.getInputSystem().addKey(equippedPowerupKey);
level.getInputSystem().addKey(bounceKey);
hasRunOnce = true;
}
if (glideActive)
{
VelocityComponent velComp = (VelocityComponent)this.level.getPlayer().getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
if (velComp.y > maxVelocity)
{
velComp.setVelocity(velComp.x, maxVelocity);
}
glideTimer = glideTimer - deltaTime;
if (glideTimer < 0.0f)
{
GravityComponent gravComp = (GravityComponent)this.level.getPlayer().getComponent(GlobalVars.GRAVITY_COMPONENT_NAME);
gravComp.setGravity(gravComp.x, GlobalVars.STANDARD_GRAVITY);
glideActive = false;
glideTimer = glideDuration;
}
}
if (speedyTimer > 0)
{
if (level.getPlayer() == null)
{
return;
}
speedyTimer -= deltaTime;
if (!level.getPlayer().hasComponent(GlobalVars.VELOCITY_COMPONENT_NAME))
{
return;
}
VelocityComponent velComp = (VelocityComponent)this.level.getPlayer().getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
if (speedyTimer <= 0 || Math.Abs(velComp.x) < GlobalVars.SPEEDY_SPEED)
{
velComp.setVelocity(0, velComp.y);
speedyTimer = -1;
speedyActive = false;
if (!level.getPlayer().hasComponent(GlobalVars.PLAYER_INPUT_COMPONENT_NAME))
{
level.getPlayer().addComponent(new PlayerInputComponent(level.getPlayer()));
}
}
}
checkForInput();
}
//Start Rising
private void startRise(Entity e)
{
SmushComponent smushComp = ( SmushComponent )e.getComponent(GlobalVars.SMUSH_COMPONENT_NAME);
VelocityComponent velComp = ( VelocityComponent )e.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
startRise(velComp, smushComp);
}
//--------------------------------------------------------------------------------
//------------------------------------- Actions ----------------------------------
public void playerJump(PositionComponent posComp, VelocityComponent velComp, PlayerInputComponent pelInComp)
{
//If it's landed on something, jump
float checkY = posComp.y + (posComp.height / 2) + GlobalVars.MIN_TILE_SIZE / 2;
//float buffer = 2;
if (pelInComp.passedAirjumps < GlobalVars.numAirJumps)
{
velComp.setVelocity(velComp.x, pelInComp.jumpStrength);
pelInComp.passedAirjumps++;
pelInComp.justJumped = true;
}
/*
* if ( level.getCollisionSystem().findObjectsBetweenPoints( posComp.x - posComp.width / 2 + buffer, checkY, posComp.x + posComp.width / 2 - buffer, checkY ).Count > 0 ) {
* velComp.setVelocity( velComp.x, pelInComp.jumpStrength );
* pelInComp.passedAirjumps = 0;
* } else {
* if ( pelInComp.passedAirjumps < GlobalVars.numAirJumps ) {
* velComp.setVelocity( velComp.x, pelInComp.jumpStrength );
* pelInComp.passedAirjumps++;
* }
* }
* */
}
public static Entity NewBasePlayer(String model, int gamePadIndex, Vector3 transformPos, Texture2D texture, String typeName)
{
Entity player = EntityFactory.NewEntity(typeName);
TransformComponent transformComponent = new TransformComponent(player, transformPos);
ModelComponent modelComponent = new ModelComponent(player, AssetManager.Instance.GetContent <Model>(model));
VelocityComponent velocityComponent = new VelocityComponent(player);
CollisionComponent collisionComponent = new CollisionComponent(player, new BoxVolume(EntityFactory.CreateBoundingBox(modelComponent.Model)));
PlayerComponent playerComponent = new PlayerComponent(player);
FrictionComponent frictionComponent = new FrictionComponent(player);
TextureComponent textureComponent = new TextureComponent(player, texture);
GravityComponent gravityComponent = new GravityComponent(player);
EffectComponent effectComponent = new EffectComponent(player, AssetManager.Instance.GetContent <Effect>("Shading"));
ComponentManager.Instance.AddComponentToEntity(player, modelComponent);
ComponentManager.Instance.AddComponentToEntity(player, transformComponent);
ComponentManager.Instance.AddComponentToEntity(player, velocityComponent);
ComponentManager.Instance.AddComponentToEntity(player, collisionComponent, typeof(CollisionComponent));
ComponentManager.Instance.AddComponentToEntity(player, playerComponent);
ComponentManager.Instance.AddComponentToEntity(player, frictionComponent);
ComponentManager.Instance.AddComponentToEntity(player, textureComponent);
ComponentManager.Instance.AddComponentToEntity(player, gravityComponent);
ComponentManager.Instance.AddComponentToEntity(player, effectComponent);
TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
TransformHelper.SetBoundingBoxPos(collisionComponent, transformComponent);
//TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
//TransformHelper.SetInitialBoundingSpherePos(collisionComponent, transformComponent);
return(player);
}
/// <summary>
///
/// </summary>
/// <param name="Id"></param>
/// <param name="gameTime"></param>
private void KeyBoardMove(int Id, GameTime gameTime)
{
KeyBoardComponent kbc = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(Id);
PositionComponent p = ComponentManager.Instance.GetEntityComponent <PositionComponent>(Id);
PlayerComponent pc = ComponentManager.Instance.GetEntityComponent <PlayerComponent>(Id);
VelocityComponent v = ComponentManager.Instance.GetEntityComponent <VelocityComponent>(Id);
DirectionComponent dc = ComponentManager.Instance.GetEntityComponent <DirectionComponent>(Id);
JumpComponent jump = ComponentManager.Instance.GetEntityComponent <JumpComponent>(Id);
p.prevPosition = p.position;
if (dc != null && v != null)
{
v.velocity.X = sideMovement * (int)dc.directio;
}
if (p != null && v != null && kbc != null && jump != null && dc != null)
{
if (kbc.state[ActionsEnum.Jump] == ButtonStates.Pressed && !pc.isFalling)
{
if (dc.directio == Direction.Still)
{
dc.directio = dc.preDir;
}
if (v.velocity.Y > -jump.maxJumpHeight)
{
v.velocity.Y -= jump.jumpHeight;
ComponentManager.Instance.AddComponentToEntity(Id, new SoundEffectComponent("jump"));
}
}
v.velocity.Y += gravity * (float)gameTime.ElapsedGameTime.TotalSeconds;
p.position += v.velocity * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
}
void IECSSystem.Execute(ECSEngine engine, ECSEntity[] entities)
{
for (int i = 0; i < entities.Length; i++)
{
ECSEntity entity = entities[i];
PositionComponent pc = engine.GetComponent <PositionComponent>(entity);
VelocityComponent vc = engine.GetComponent <VelocityComponent>(entity);
if (Input.IsKeyPressed(KeyCode.W))
{
pc.Position.Y -= vc.Velocity.Y * Time.DeltaTime;
}
if (Input.IsKeyPressed(KeyCode.S))
{
pc.Position.Y += vc.Velocity.Y * Time.DeltaTime;
}
if (Input.IsKeyPressed(KeyCode.A))
{
pc.Position.X -= vc.Velocity.X * Time.DeltaTime;
}
if (Input.IsKeyPressed(KeyCode.D))
{
pc.Position.X += vc.Velocity.X * Time.DeltaTime;
}
engine.SetComponent <PositionComponent>(entity, pc);
}
}
public void update(GameTime gameTime)
{
List <int> entitys = ComponentManager.Instance.GetAllEntitiesWithComponentType <HealthComponent>();
if (entitys != null)
{
if (deathList.Count == 0)
{
foreach (var en in entitys)
{
deathList.Add(en);
}
}
foreach (var entity in entitys)
{
HealthComponent hc = ComponentManager.Instance.GetEntityComponent <HealthComponent>(entity);
if (hc.health <= 0 && !hc.isDead)
{
CollisionComponent cc = ComponentManager.Instance.GetEntityComponent <CollisionComponent>(entity);
ComponentManager.Instance.RemoveComponentFromEntity(entity, cc);
VelocityComponent vc = ComponentManager.Instance.GetEntityComponent <VelocityComponent>(entity);
ComponentManager.Instance.RemoveComponentFromEntity(entity, vc);
hc.isDead = true;
if (deathList.Count != 1)
{
deathList.Remove(entity);
}
}
}
}
}
/// <summary>
/// Check if networkinputcomponent's parameters are true and do actions on remote player
/// </summary>
/// <param name="gameTime"></param>
/// <param name="playerEntity"></param>
private void ParseNetworkInput(GameTime gameTime, Entity playerEntity)
{
NetworkInputComponent networkInputComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <NetworkInputComponent>(playerEntity);
VelocityComponent velocityComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <VelocityComponent>(playerEntity);
TransformComponent transformComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <TransformComponent>(playerEntity);
GravityComponent gravityComponent = ComponentManager.Instance.ConcurrentGetComponentOfEntity <GravityComponent>(playerEntity);
if (networkInputComponent.MoveForward)
{
PlayerActions.AcceleratePlayerForwards(gameTime, velocityComponent);
}
if (networkInputComponent.MoveLeft)
{
PlayerActions.AcceleratePlayerLeftwards(gameTime, velocityComponent);
}
if (networkInputComponent.MoveRight)
{
PlayerActions.AcceleratePlayerRightwards(gameTime, velocityComponent);
}
if (networkInputComponent.Jump)
{
PlayerActions.PlayerJump(gameTime, velocityComponent);
}
if (networkInputComponent.MoveBackward)
{
PlayerActions.AcceleratePlayerBackwards(gameTime, velocityComponent);
}
}
public void endRightHorizontalMove(PositionComponent posComp, VelocityComponent velComp)
{
if (velComp.x > 0)
{
velComp.setVelocity(0, velComp.y);
}
}
public void endLowerMove(PositionComponent posComp, VelocityComponent velComp)
{
if (velComp.y > 0)
{
velComp.setVelocity(velComp.x, 0);
}
}
/// <summary>
/// Accelerates the player backward until it reaches maximum running speed
/// </summary>
/// <param name="velocityComponent"></param>
public static void AcceleratePlayerBackwards(GameTime gameTime, VelocityComponent velocityComponent)
{
if (velocityComponent.Velocity.Z > -playerMaxRunningSpeed)
{
velocityComponent.Velocity.Z = Math.Max(velocityComponent.Velocity.Z - playerForwardAcceleration, -playerForwardAcceleration);
}
}
//-----------------------------------------------------------------------------
//----------------------------------- Input -----------------------------------
public void checkForInput(PositionComponent posComp, VelocityComponent velComp, VisionInputComponent visInComp)
{
if (level.getInputSystem().myKeys[GlobalVars.KEY_JUMP].down)
{
beginMoveUp(posComp, velComp, visInComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_DOWN].down)
{
beginMoveDown(posComp, velComp, visInComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_LEFT].down)
{
beginMoveLeft(posComp, velComp, visInComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_RIGHT].down)
{
beginMoveRight(posComp, velComp, visInComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_JUMP].up)
{
endUpperMove(posComp, velComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_DOWN].up)
{
endLowerMove(posComp, velComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_RIGHT].up)
{
endRightHorizontalMove(posComp, velComp);
}
if (level.getInputSystem().myKeys[GlobalVars.KEY_LEFT].up)
{
endLeftHorizontalMove(posComp, velComp);
}
}
//Returns whether or not movement has been blocked by a collision
public bool manageMovementColliderCheck(PositionComponent posComp, float newX, float newY, bool moveToContactH, bool moveToContactV)
{
VelocityComponent velComp = ( VelocityComponent )posComp.myEntity.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
//List of all collisions caused by potential move
List <Entity> collisions = level.getCollisionSystem().checkForCollision(posComp.myEntity, newX, newY, posComp.width, posComp.height);
bool movementBlocked = false;
//Perform all collisions
if (collisions.Count > 0 && !(level is CreationLevel))
{
foreach (Entity e in collisions)
{
if (!(e.hasComponent(GlobalVars.COLLIDER_COMPONENT_NAME)))
{
continue;
}
//Handle the collision. handleCollision(...) will return true if it should stop the movement.
if (colHandler.handleCollision(posComp.myEntity, e))
{
movementBlocked = true;
stopMovementAfterCollision(e, posComp, velComp, newX, newY, moveToContactH, moveToContactV);
}
}
}
return(movementBlocked);
}
/// <summary>
/// Creates an new Player with Controlls
/// </summary>
/// <param name="pixlePer"> True if pixelPerfect shall be used </param>
/// <param name="GamePade"> True if GamePad the player uses a gamepad </param>
/// <param name="PadJump"> Key binding to gamePad </param>
/// <param name="Jump"> key binding to keybord </param>
/// <param name="position"> Player start Position </param>
/// <param name="name"> The name off the player</param>
/// <param name="dir"> The players starting direction</param>
/// <param name="index"> Playerindex For GamePad </param>
/// <returns></returns>
public int CreatePlayer(bool pixlePer, bool GamePade, Buttons PadJump, Keys Jump, Vector2 position, string name, Direction dir, PlayerIndex index, Color colour)
{
SpriteEffects flip;
GamePadComponent gam;
KeyBoardComponent kcb;
int id = ComponentManager.Instance.CreateID();
if (dir == Direction.Left)
{
flip = SpriteEffects.FlipHorizontally;
}
else
{
flip = SpriteEffects.None;
}
if (GamePade == true)
{
gam = new GamePadComponent(index);
gam.gamepadActions.Add(ActionsEnum.Jump, PadJump);
ComponentManager.Instance.AddComponentToEntity(id, gam);
}
else
{
kcb = new KeyBoardComponent();
kcb.keyBoardActions.Add(ActionsEnum.Jump, Jump);
ComponentManager.Instance.AddComponentToEntity(id, kcb);
}
DirectionComponent dc = new DirectionComponent(dir);
DrawableComponent comp = new DrawableComponent(Game.Instance.GetContent <Texture2D>("Pic/kanin1"), flip);
PositionComponent pos = new PositionComponent(position);
VelocityComponent vel = new VelocityComponent(new Vector2(200F, 0), 50F);
JumpComponent jump = new JumpComponent(300F, 200F);
CollisionRectangleComponent CRC = new CollisionRectangleComponent(new Rectangle((int)pos.position.X, (int)pos.position.Y, comp.texture.Width, comp.texture.Height));
CollisionComponent CC = new CollisionComponent(pixlePer);
PlayerComponent pc = new PlayerComponent(name);
DrawableTextComponent dtc = new DrawableTextComponent(name, Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/TestFont"));
HUDComponent hudc = new HUDComponent(Game.Instance.GetContent <Texture2D>("Pic/PowerUp"), new Vector2(pos.position.X, pos.position.Y));
HUDComponent hudc2 = new HUDComponent(Game.Instance.GetContent <Texture2D>("Pic/PowerUp"), Vector2.One);
HealthComponent hc = new HealthComponent(3, false);
//AnimationComponent ani = new AnimationComponent(100, 114, comp.texture.Width, comp.texture.Height, 0.2);
comp.colour = colour;
ComponentManager.Instance.AddComponentToEntity(id, vel);
ComponentManager.Instance.AddComponentToEntity(id, comp);
ComponentManager.Instance.AddComponentToEntity(id, pos);
ComponentManager.Instance.AddComponentToEntity(id, CRC);
ComponentManager.Instance.AddComponentToEntity(id, CC);
ComponentManager.Instance.AddComponentToEntity(id, pc);
ComponentManager.Instance.AddComponentToEntity(id, dtc);
ComponentManager.Instance.AddComponentToEntity(id, hudc);
ComponentManager.Instance.AddComponentToEntity(id, hc);
//ComponentManager.Instance.AddComponentToEntity(id, ani);
ComponentManager.Instance.AddComponentToEntity(id, dc);
ComponentManager.Instance.AddComponentToEntity(id, jump);
return(id);
}
public void stopRight(PositionComponent posComp, VelocityComponent velComp)
{
level.getMovementSystem().changeX(posComp, level.levelWidth - posComp.width / 2, true);
if (velComp.x > 0)
{
velComp.setVelocity(0, velComp.y);
}
}
public override void Process(Entity entity)
{
ForceComponent forceComponent = entity.GetComponent <ForceComponent>();
VelocityComponent velocityComponent = entity.GetComponent <VelocityComponent>();
velocityComponent.Velocity += forceComponent.Force / forceComponent.Mass;
forceComponent.Force = Vector2.Zero;
}
//Start Lower Waiting
private void startLowerWait(Entity e)
{
SmushComponent smushComp = ( SmushComponent )e.getComponent(GlobalVars.SMUSH_COMPONENT_NAME);
VelocityComponent velComp = ( VelocityComponent )e.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
TimerComponent timerComp = ( TimerComponent )e.getComponent(GlobalVars.TIMER_COMPONENT_NAME);
startLowerWait(velComp, smushComp, timerComp, e);
}
public void stopDown(PositionComponent posComp, VelocityComponent velComp)
{
level.getMovementSystem().changeY(posComp, level.levelHeight - posComp.height / 2, true);
if (velComp.y > 0)
{
velComp.setVelocity(velComp.x, 0);
}
}
/// <summary>
/// Accelerates the player to the right until it reaches maximum strafeing speed
/// </summary>
/// <param name="velocityComponent"></param>
public static void AcceleratePlayerRightwards(GameTime gameTime, VelocityComponent velocityComponent)
{
if (velocityComponent.Velocity.X > -playerMaxStrafeSpeed)
{
//velocityComponent.Velocity.X -= playerStrafeAcceleration * (float)gameTime.ElapsedGameTime.TotalSeconds;
velocityComponent.Velocity.X = Math.Max(velocityComponent.Velocity.X - playerStrafeAcceleration, -playerStrafeAcceleration);
}
}
/// <summary>
/// Accelerates the player forward until it reaches maximum running speed
/// </summary>
/// <param name="velocityComponent"></param>
public static void AcceleratePlayerForwards(GameTime gameTime, VelocityComponent velocityComponent)
{
if (velocityComponent.Velocity.Z < playerMaxRunningSpeed)
{
//velocityComponent.Velocity.Z += playerForwardAcceleration * (float)gameTime.ElapsedGameTime.TotalSeconds;
velocityComponent.Velocity.Z = Math.Min(velocityComponent.Velocity.Z + playerForwardAcceleration, playerForwardAcceleration);
}
}
Vector2 getDesiredPosition(VelocityComponent velocity, PositionComponent position)
{
Vector2 positionOffset = velocity.vel;
positionOffset *= -1.0f;
positionOffset.Normalize();
positionOffset *= LEADER_BEHIND_DIST;
return position.pos + positionOffset;
}
Vector2 arrivalSteeringForce(PositionComponent position, VelocityComponent velocity, float speed, Vector2 desiredPosition, float slowingRadius)
{
Vector2 desiredVelocity = new Vector2((desiredPosition.x - position.pos.x), (desiredPosition.y - position.pos.y));
float distance = desiredVelocity.magnitude;
desiredVelocity.Normalize();
desiredVelocity *= speed;
if (distance < slowingRadius) {
desiredVelocity *= (distance / slowingRadius);
}
return desiredVelocity - velocity.vel;
}
public MoveAction(float expiration, int priority, Entity entity, Vector2 goal)
: base(expiration, priority)
{
_entity = entity;
_goal = goal;
ComponentMapper<PositionComponent> positionMapper = new ComponentMapper<PositionComponent>(Director.SharedDirector.EntityWorld);
_position = positionMapper.Get(entity);
ComponentMapper<VelocityComponent> velocityMapper = new ComponentMapper<VelocityComponent>(Director.SharedDirector.EntityWorld);
_velocity = velocityMapper.Get(entity);
}
public static Manifold overlapAABB(Rectangle a, VelocityComponent velocityA, Rectangle b, VelocityComponent velocityB)
{
Manifold manifold = new Manifold();
manifold.a = a;
manifold.b = b;
// vectrom from a to b
Vector2 normal = new Vector2(b.X - a.X, b.Y - a.Y);
//calculate half extents along x axis for each object
float a_extent = (a.Width - a.X) / 2;
float b_extent = (b.Width - b.X) / 2;
//calculate overlap on x axis
var x_overlap = a_extent + b_extent - Math.Abs(normal.X);
// SAT test on x axis
if (x_overlap > 0)
{
a_extent = (a.Height - a.X) / 2;
b_extent = (b.Height - b.X) / 2;
//calculate overlap on y axes
var y_overlap = a_extent + b_extent - Math.Abs(normal.Y);
// SAT test on y axis
if (y_overlap > 0)
{
// Find out which axis is axis of least penetration
if (x_overlap < y_overlap)
{
// point towards b knowing that dist points from a to b
if (normal.X < 0)
{
manifold.normal = new Vector2(-1, 0);
}
else
{
manifold.normal = new Vector2(1, 0);
}
manifold.penetration = x_overlap;
return manifold;
}
else
{
// Point toward B knowing that dist points from A to B
if (normal.Y < 0)
{
manifold.normal = new Vector2(0, -1);
}
else
{
manifold.normal = new Vector2(0, 1);
}
manifold.penetration = y_overlap;
return manifold;
}
}
}
return new Manifold();
}
public static void UpdateAABBPlayerCollision(PlayingState playingState)
{
IEnumerable<Guid> playerEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Player) == ComponentMasks.Player).Select(x => x.ID);
IEnumerable<Guid> levelObjectEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.LevelObjects) == ComponentMasks.LevelObjects).Select(x => x.ID);
//create aa non velocity component for our level objects
VelocityComponent levelObjectVelocityComponent = new VelocityComponent();
levelObjectVelocityComponent.xVelocity = 0f;
levelObjectVelocityComponent.yVelocity = 0f;
foreach (Guid playerid in playerEntities)
{
AABBComponent playerAABBComponent = playingState.AABBComponents[playerid];
VelocityComponent playerVelocityComponent = playingState.VelocityComponents[playerid];
foreach (Guid lobjectid in levelObjectEntities)
{
AABBComponent levelAABBComponent = playingState.AABBComponents[lobjectid];
Manifold manifold = overlapAABB(playerAABBComponent.BoundedBox, playerVelocityComponent, levelAABBComponent.BoundedBox, levelObjectVelocityComponent);
if (manifold.a != null)
{
resolveCollision(playerAABBComponent.BoundedBox, playerVelocityComponent, levelAABBComponent.BoundedBox, levelObjectVelocityComponent, manifold, playingState, playerid);
}
}
}
}
void setVelocity(VelocityComponent velocity, PositionComponent actual, PositionComponent desired)
{
//velocity.x = (desired.x - actual.x) * 2.0f;
}
public static void resolveCollision(Rectangle a, VelocityComponent velocityA, Rectangle b, VelocityComponent velocityB, Manifold m, PlayingState playingState, Guid aid, Guid? bid = null)
{
// calculate relative velocity
Vector2 rv = new Vector2(velocityB.xVelocity - velocityA.xVelocity, velocityB.yVelocity - velocityA.yVelocity);
//calculate relative velocity in terms of normal direction
var velAlongNormal = DotProduct(rv, m.normal);
//do not resolve if velocities are seperating
if (velAlongNormal > 0)
{
return;
}
//calculate restitution
var e = Math.Min(restitution, restitution);
//calculate impulse scaler
var j = -(1 + e) * velAlongNormal;
j /= invmass + invmass;
// Apply impulse
Vector2 _impulse = new Vector2(m.normal.X * j, m.normal.Y * j);
velocityA.xVelocity -= (invmass * _impulse.X);
velocityA.yVelocity -= (invmass * _impulse.Y);
velocityB.xVelocity += (invmass * _impulse.X);
velocityB.yVelocity += (invmass * _impulse.Y);
playingState.VelocityComponents[aid] = velocityA;
if (bid != null)
{
playingState.VelocityComponents[(Guid)bid] = velocityB;
}
//float percent = .8f;
//float slop = .01f;
//var c = Math.Max(m.penetration - slop, 0) / (invmass + invmass) * percent * m.normal;
//there is like some position shit that should go here but i dont know what
}
