private void HandleGravityInitialize(EntityUid uid, GravityComponent component, ComponentInit args)
{
// Incase there's already a generator on the grid we'll just set it now.
var gridId = Transform(component.Owner).GridUid;
if (gridId == null)
{
return;
}
GravityChangedMessage message;
foreach (var generator in EntityManager.EntityQuery <GravityGeneratorComponent>())
{
if (Transform(generator.Owner).GridUid == gridId && generator.GravityActive)
{
component.Enabled = true;
message = new GravityChangedMessage(gridId.Value, true);
RaiseLocalEvent(message);
return;
}
}
component.Enabled = false;
message = new GravityChangedMessage(gridId.Value, false);
RaiseLocalEvent(message);
}
public bool CanSwimAtCurrentLocation(bool check_head)
{
if (base.def.canSwim)
{
Vector3 position = base.transform.GetPosition();
float num = 1f;
if (!check_head)
{
num = 0.5f;
}
float y = position.y;
Vector2 size = base.transform.GetComponent <KBoxCollider2D>().size;
position.y = y + size.y * num;
int cell = Grid.PosToCell(position);
if (Grid.IsSubstantialLiquid(cell, 0.35f))
{
if (!GameComps.Gravities.Has(base.gameObject))
{
return(true);
}
GravityComponent data = GameComps.Gravities.GetData(GameComps.Gravities.GetHandle(base.gameObject));
if (data.velocity.magnitude < 2f)
{
return(true);
}
}
}
return(false);
}
/// <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 glide()
{
GravityComponent gravComp = (GravityComponent)this.level.getPlayer().getComponent(GlobalVars.GRAVITY_COMPONENT_NAME);
gravComp.setGravity(gravComp.x, (Glide_Gravity_Decrease));
glideActive = true;
}
public override void Execute(Entity entity)
{
GravityComponent gravityComponent = entity.gravityComponent;
gravityComponent.fallVelocity = entity.statsComponent.GetTotalStat(StatID.InitJumpVel);
gravityComponent.inAir = true;
}
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();
}
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);
}
/**
* X roaming
*/
// TODO: Bias based on liquid mass in right/left cells
private static void ApplyXVelocityChanges(ref GravityComponent grav, float dt)
{
Vector2 position = grav.transform.GetPosition();
Vector2 newChange = new Vector2(grav.velocity.x, grav.velocity.y);
if (Mathf.Abs(grav.velocity.x) < MIN_X_VELOCITY / 2 * dt)
{
newChange.x += RandomXVelocity() * dt;
}
grav.velocity = newChange;
}
public void DisableGravity(GravityComponent comp)
{
if (!comp.Enabled)
{
return;
}
comp.Enabled = false;
var gridId = EntityManager.GetComponent <TransformComponent>(comp.Owner).GridID;
var message = new GravityChangedMessage(gridId, false);
RaiseLocalEvent(message);
}
//Gets force magnitude between this object and other object
float CalculateGravityForce(GravityComponent otherActor)
{
//check to make sure we never divide by 0
if (Vector3.Distance(transform.position, otherActor.transform.position) == 0)
{
return(0.0f);
}
//F = Gm1m2/r2 //g=6.67408*10^-11
float F = ((6.67408e-11f) * (rb.mass) * (otherActor.GetComponent <Rigidbody>().mass))
/ (Vector3.Distance(transform.position, otherActor.transform.position));
//Debug.Log(F*1000000);
return(F * 1000000);
}
private void OnOreSizeChanged(object data)
{
Vector3 v = Vector3.zero;
HandleVector<int>.Handle handle = GameComps.Gravities.GetHandle(base.gameObject);
if (handle.IsValid())
{
GravityComponent data2 = GameComps.Gravities.GetData(handle);
v = data2.velocity;
}
RemoveFaller();
if (!KPrefabID.HasTag(GameTags.Stored))
{
AddFaller(v);
}
}
public void glide()
{
if (level.getPlayer() == null)
{
return;
}
if (!level.getPlayer().hasComponent(GlobalVars.GRAVITY_COMPONENT_NAME))
{
return;
}
GravityComponent gravComp = ( GravityComponent )this.level.getPlayer().getComponent(GlobalVars.GRAVITY_COMPONENT_NAME);
gravComp.setGravity(gravComp.x, (Glide_Gravity_Decrease));
glideActive = true;
}
public CollisionResolver(GravityComponent grav, Vector2 desiredPosition)
{
this.grav = grav;
this.currentPosition = grav.transform.position;
this.desiredPosition = desiredPosition;
bestDistance = float.PositiveInfinity;
bestPosition = currentPosition;
KCollider2D collider = grav.transform.GetComponent <KCollider2D>();
if (collider != null)
{
this.bounds = collider.bounds;
bounds.Expand(0.05f); // Apply breathing room
}
}
public static void HandleCollisionFromAbove(GameTime gameTime, Entity entity, float diff)
{
VelocityComponent velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(entity);
GravityComponent gravity = ComponentManager.Instance.GetComponentOfEntity <GravityComponent>(entity);
TransformComponent transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(entity);
//var diffY = blockY - playerY;
if (velocityComponent != null)
{
if (velocityComponent.Velocity.Y < 0)
{
// if we collide with an acceleration downwards then we want a counter force up.
velocityComponent.Velocity.Y += (Math.Abs(velocityComponent.Velocity.Y)) + (diff / 4);
}
gravity.HasJumped = false;
}
}
/**
* Reverse gravity application (floatation)
*/
private static void ApplyYVelocityChanges(ref GravityComponent grav, float dt)
{
GravityComponents.Tuning tuning = TuningData <GravityComponents.Tuning> .Get();
float yExtent = Helpers.GetYExtent(grav);
Vector2 position = (Vector2)grav.transform.GetPosition() + Vector2.up * (yExtent + 0.01f);
float distanceToSurface = Helpers.GetLiquidSurfaceDistanceAbove(position);
if (distanceToSurface != float.PositiveInfinity && distanceToSurface > 2 * yExtent)
{
Vector2 target = position + Vector2.up * distanceToSurface;
Mathf.SmoothDamp(position.y, target.y, ref grav.velocity.y, 1f, tuning.maxVelocityInLiquid, dt);
}
else if (grav.velocity.y > 0)
{
Mathf.SmoothDamp(position.y, position.y, ref grav.velocity.y, 5f, tuning.maxVelocityInLiquid, dt);
}
}
public void DisableGravity(GravityComponent comp)
{
if (!comp.Enabled)
{
return;
}
comp.Enabled = false;
var gridId = Transform(comp.Owner).GridUid;
if (gridId == null)
{
return;
}
var message = new GravityChangedMessage(gridId.Value, false);
RaiseLocalEvent(message);
}
public void RemoveGravityActor(GravityComponent actor)
{
List <GravityComponent> templist = new List <GravityComponent>();
foreach (GravityComponent gravActor in ActorsInGravityWell)
{
if (gravActor != actor)
{
templist.Add(gravActor);
}
}
ActorsInGravityWell.Clear();
foreach (GravityComponent gravActor in templist)
{
if (!ActorsInGravityWell.Contains(gravActor))
{
ActorsInGravityWell.Add(gravActor);
}
}
}
protected override void OnPrefabInit(HandleVector <int> .Handle h)
{
FallerComponent data = GetData(h);
Vector3 position = data.transform.GetPosition();
int num = Grid.PosToCell(position);
data.cellChangedCB = delegate
{
OnSolidChanged(h);
};
float num2 = 0f - GravityComponent.GetRadius(data.transform) - 0.07f;
int num3 = Grid.PosToCell(new Vector3(position.x, position.y + num2, position.z));
bool flag = Grid.IsValidCell(num3) && Grid.Solid[num3] && data.initialVelocity.sqrMagnitude == 0f;
if ((Grid.IsValidCell(num) && Grid.Solid[num]) || flag)
{
data.solidChangedCB = delegate
{
OnSolidChanged(h);
};
int height = 2;
Vector2I vector2I = Grid.CellToXY(num);
vector2I.y--;
if (vector2I.y < 0)
{
vector2I.y = 0;
height = 1;
}
else if (vector2I.y == Grid.HeightInCells - 1)
{
height = 1;
}
data.partitionerEntry = GameScenePartitioner.Instance.Add("Faller", data.transform.gameObject, vector2I.x, vector2I.y, 1, height, GameScenePartitioner.Instance.solidChangedLayer, data.solidChangedCB);
GameComps.Fallers.SetData(h, data);
}
else
{
GameComps.Fallers.SetData(h, data);
AddGravity(data.transform, data.initialVelocity);
}
}
public void EnableGravity(GravityComponent comp)
{
if (comp.Enabled)
{
return;
}
var gridId = Transform(comp.Owner).GridUid;
Dirty(comp);
if (gridId == null)
{
return;
}
comp.Enabled = true;
var message = new GravityChangedEvent(gridId.Value, true);
RaiseLocalEvent(message);
}
public void manageGlideTimer(float deltaTime)
{
if (glideActive && level.getPlayer() != null)
{
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);
if (gravComp != null)
{
gravComp.setGravity(gravComp.x, GlobalVars.STANDARD_GRAVITY);
}
glideActive = false;
glideTimer = glideDuration;
}
}
}
//Create AI Player
public static Entity NewAiPlayer(String model, Vector3 transformPos, Texture2D texture)
{
Entity player = EntityFactory.NewEntity(GameEntityFactory.AI_PLAYER);
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);
AiComponent aiComponent = new AiComponent(player);
LightComponent lightComponent = new LightComponent(player, new Vector3(0, 7, -5), Color.White.ToVector4(), 10f, Color.Blue.ToVector4(), 0.2f, Color.White.ToVector4(), 1000f);
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, aiComponent);
ComponentManager.Instance.AddComponentToEntity(player, effectComponent);
ComponentManager.Instance.AddComponentToEntity(player, lightComponent);
//TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
//TransformHelper.SetBoundingBoxPos(collisionComponent, transformComponent);
TransformHelper.SetInitialModelPos(modelComponent, transformComponent);
TransformHelper.SetBoundingBoxPos(collisionComponent, transformComponent);
return(player);
}
private void PushSourceAwayFromTarget(GameTime gameTime, Entity sourceEntity, Entity targetEntity)
{
CollisionComponent sourceCollisionComponent = ComponentManager.Instance.GetComponentOfEntity <CollisionComponent>(sourceEntity);
CollisionComponent targetCollisionComponent = ComponentManager.Instance.GetComponentOfEntity <CollisionComponent>(targetEntity);
GravityComponent sourceGravityComponent = ComponentManager.Instance.GetComponentOfEntity <GravityComponent>(sourceEntity);
TransformComponent sourceTransformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(sourceEntity);
if (sourceCollisionComponent.BoundingVolume.Center.X < targetCollisionComponent.BoundingVolume.Center.X)
{
CollisionActions.AccelerateColliderRightwards(gameTime, sourceEntity);
}
else
{
CollisionActions.AccelerateColliderLeftwards(gameTime, sourceEntity);
}
if (sourceCollisionComponent.BoundingVolume.Center.Z < targetCollisionComponent.BoundingVolume.Center.Z)
{
CollisionActions.AccelerateColliderBackwards(gameTime, sourceEntity);
}
else
{
CollisionActions.AccelerateColliderForwards(gameTime, sourceEntity);
}
}
// TODO: Check for potential bug with 1-tile width water
static void Prefix(ref GravityComponents __instance, float dt)
{
gravComponentState.Clear();
var data = __instance.GetDataList();
for (int i = 0; i < data.Count; i++)
{
GravityComponent grav = data[i];
if (!Helpers.ShouldFloat(grav.transform))
{
continue;
}
ApplyXVelocityChanges(ref grav, dt);
ApplyYVelocityChanges(ref grav, dt);
Vector3 pos = grav.transform.GetPosition();
Vector3 newPosition = (Vector2)pos + grav.velocity * dt;
// Resolve collisions
CollisionResolver resolver = new CollisionResolver(grav, newPosition);
resolver.ResolveCollisions();
// Apply the new gravity/position
newPosition = resolver.bestPosition;
newPosition.z = pos.z;
grav = resolver.grav;
grav.transform.SetPosition(newPosition);
grav.elapsedTime += dt;
gravComponentState.Add(i, grav);
data[i] = NULL_COMPONENT;
}
}
protected Point ExecuteState(GameTime gameTime, Point matrixPosition, Vector3 position, VelocityComponent aiVelocity, GravityComponent gravity, AiComponent aiComponent)
{
//Get the block at the AI's current position
var currentBlock = GetBlock(matrixPosition);
// Debug
//WriteWorld(worldMatrix);
// Get the "real" values of the next block (destination) and the players "real" position
// to make the move to the next block:
//int row = 0;
//if (matrixPosition.Y < worldMatrix.GetLength(1) - 1)
// row = matrixPosition.Y + 1;
//else
// row = matrixPosition.Y;
//var decision = ChooseBlock(worldMatrix, row);
//var destinationBlock = GetBlock(decision);
int row = 0;
if (matrixPosition.Y < worldMatrix.GetLength(1) - 1)
{
row = matrixPosition.Y + 1;
}
else
{
row = matrixPosition.Y;
}
if (targetBlockTile.Y <= matrixPosition.Y)
{
targetBlockTile = ChooseBlock(worldMatrix, row);
targetBlockPos = GetBlock(targetBlockTile);
}
// Execute the move to the next block
ExecuteMove(gameTime, currentBlock, targetBlockPos, position, aiVelocity, gravity, aiComponent);
// We look to see if the player is in the same block in the "real" world as
// in the matrix. if he is, we "wait" until the move is completed and return the same
// position, or we make the move.
// TODO: Need to fix
if (currentBlock.Z + 50 <= position.Z)
{
return(targetBlockTile);
}
else
{
return(matrixPosition);
}
}
//Gest unit vector towards desired direction
Vector3 CalculateGravityDirection(GravityComponent otherActor)
{
return(Vector3.Normalize(otherActor.transform.position - transform.position));
}
public static float GetYExtent(GravityComponent component)
{
return(Mathf.Max(0.2f, component.radius));
}
private void HandleGravityShutdown(EntityUid uid, GravityComponent component, ComponentShutdown args)
{
DisableGravity(component);
}
//You must have an Update.
//Always read in deltaTime, and only deltaTime (it's the time that's passed since the last frame)
//Use deltaTime for things like changing velocity or changing position from velocity
//This is where you do anything that you want to happen every frame.
//There is a chance that your system won't need to do anything in update. Still have it.
public override void Update(float deltaTime)
{
foreach (Entity e in getApplicableEntities())
{
PositionComponent platPos = (PositionComponent)e.getComponent(GlobalVars.POSITION_COMPONENT_NAME);
ColliderComponent platCol = (ColliderComponent)e.getComponent(GlobalVars.COLLIDER_COMPONENT_NAME);
VelocityComponent platVel = ( VelocityComponent )e.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
MovingPlatformComponent movPlatComp = ( MovingPlatformComponent )e.getComponent(GlobalVars.MOVING_PLATFORM_COMPONENT_NAME);
float mySpeed = platVel.x;
if (movPlatComp.vertical)
{
mySpeed = platVel.y;
}
//If it's been stopped for more than one frame, try changing the direction and see if it can move that way instead.
if (mySpeed == 0)
{
float newSpeed = GlobalVars.MOVING_PLATFORM_SPEED;
if (!movPlatComp.wasStoppedLastFrame)
{
newSpeed = GlobalVars.MOVING_PLATFORM_SPEED;
}
else
{
newSpeed = -GlobalVars.MOVING_PLATFORM_SPEED;
}
if (movPlatComp.vertical)
{
platVel.y = newSpeed;
}
else
{
platVel.x = newSpeed;
}
movPlatComp.wasStoppedLastFrame = true;
}
else if (movPlatComp.wasStoppedLastFrame)
{
movPlatComp.wasStoppedLastFrame = false;
}
float checkBuffer = 3;
float upperLeftX = platCol.getX(platPos) - platCol.width / 2;
float upperRightX = platCol.getX(platPos) + platCol.width / 2;
float upperY = platCol.getY(platPos) - platCol.height / 2 - checkBuffer;
System.Drawing.PointF leftPoint = new System.Drawing.PointF(upperLeftX, upperY);
System.Drawing.PointF rightPoint = new System.Drawing.PointF(upperRightX, upperY);
List <Entity> aboveEnts = level.getCollisionSystem().findObjectsBetweenPoints(leftPoint, rightPoint);
foreach (Entity otherEnt in aboveEnts)
{
if (!stoppingEntities.Contains(otherEnt.GetType()) && otherEnt.hasComponent(GlobalVars.VELOCITY_COMPONENT_NAME))
{
PositionComponent otherPos = (PositionComponent)otherEnt.getComponent(GlobalVars.POSITION_COMPONENT_NAME);
VelocityComponent otherVel = ( VelocityComponent )otherEnt.getComponent(GlobalVars.VELOCITY_COMPONENT_NAME);
ColliderComponent otherCol = ( ColliderComponent )otherEnt.getComponent(GlobalVars.COLLIDER_COMPONENT_NAME);
System.Drawing.PointF grav = new System.Drawing.PointF(0.0f, 0.0f);
if (otherEnt.hasComponent(GlobalVars.GRAVITY_COMPONENT_NAME))
{
GravityComponent otherGrav = ( GravityComponent )otherEnt.getComponent(GlobalVars.GRAVITY_COMPONENT_NAME);
grav = new System.Drawing.PointF(otherGrav.x, otherGrav.y);
}
if (movPlatComp.vertical)
{
if ((platVel.y == 0 || platVel.y <= 0 && (otherVel.y + grav.Y * deltaTime) >= platVel.y) || (platVel.y >= 0 && (otherVel.y + grav.Y * deltaTime) <= platVel.y))
{
otherVel.y = platVel.y - grav.Y * deltaTime;
}
level.getMovementSystem().changePosition(otherPos, otherCol.getX(otherPos), platCol.getY(platPos) - platCol.height / 2 - otherCol.height / 2 - 1, false, false);
}
else
{
if ((platVel.x == 0 || platVel.x <= 0 && (otherVel.x + grav.X * deltaTime) >= platVel.x) || (platVel.x >= 0 && (otherVel.x + grav.X * deltaTime) <= platVel.y))
{
otherVel.x = platVel.x - grav.X * deltaTime;
}
if (otherEnt is RunningGame.Entities.Player)
{
level.getMovementSystem().changePosition(otherPos, otherCol.getX(otherPos) + platVel.x * deltaTime, platCol.getY(platPos) - platCol.height / 2 - otherCol.height / 2 - 3, false, false);
}
else
{
level.getMovementSystem().changePosition(otherPos, otherCol.getX(otherPos), platCol.getY(platPos) - platCol.height / 2 - otherCol.height / 2 - 0, false, false);
}
}
if (otherEnt.hasComponent(GlobalVars.VEL_TO_ZERO_COMPONENT_NAME))
{
VelToZeroComponent velZedComp = (VelToZeroComponent)otherEnt.getComponent(GlobalVars.VEL_TO_ZERO_COMPONENT_NAME);
velZedComp.blockSlow = true;
}
}
}
}
}
public void Update(GameTime gameTime, ref Point matrixPosition, Vector3 Position, VelocityComponent aiVelocity, GravityComponent gravity, AiComponent aiComponent)
{
worldMatrix = GameService.Instance.GameWorld;
worldEntityMatrix = GameService.Instance.EntityGameWorld;
matrixPosition = ExecuteState(gameTime, matrixPosition, Position, aiVelocity, gravity, aiComponent);
}
protected void ExecuteMove(GameTime gameTime, Vector3 currentBlock, Vector3 nextBlock, Vector3 position, VelocityComponent velocity, GravityComponent gravity, AiComponent aiComponent)
{
PlayerActions.AcceleratePlayerForwards(gameTime, velocity);
if (aiComponent.CurrentState == State.Winning)
{
if (Random.Next(0, 11) == 1) //20% chance to make random move
{
Console.WriteLine("RandomMove ");
if (Random.Next(0, 2) == 1) //50% chance to go left or right
{
PlayerActions.AcceleratePlayerLeftwards(gameTime, velocity);
if (!gravity.HasJumped)
{
PlayerActions.PlayerJump(gameTime, velocity, null);
gravity.HasJumped = true;
}
}
PlayerActions.AcceleratePlayerRightwards(gameTime, velocity);
if (!gravity.HasJumped)
{
PlayerActions.PlayerJump(gameTime, velocity, null);
gravity.HasJumped = true;
}
return;
}
}
Console.WriteLine("Regular move");
if (currentBlock.X < nextBlock.X) //if the block that AI wants to go to is "lower" X value AKA left of the current we need to jump left
{
PlayerActions.AcceleratePlayerLeftwards(gameTime, velocity);
if (!gravity.HasJumped)
{
PlayerActions.PlayerJump(gameTime, velocity, null);
gravity.HasJumped = true;
}
}
if (currentBlock.X > nextBlock.X) //if the block that AI wants to go to is "higher" X value AKA right of the current we need to jump right
{
PlayerActions.AcceleratePlayerRightwards(gameTime, velocity);
if (!gravity.HasJumped)
{
PlayerActions.PlayerJump(gameTime, velocity, null);
gravity.HasJumped = true;
}
}
if (currentBlock.X == nextBlock.X)
{
PlayerActions.AcceleratePlayerForwards(gameTime, velocity);
if (!gravity.HasJumped)
{
PlayerActions.PlayerJump(gameTime, velocity, null);
gravity.HasJumped = true;
}
}
}
