public bool InqRunRate(ref float rate)
{
// get run skill from WorldObject
uint runSkill = 0;
var creature = WorldObject as Creature;
if (creature != null)
{
runSkill = creature.GetCreatureSkill(Skill.Run).Current;
}
//rate = (float)MovementSystem.GetRunRate(0.0f, 300, 1.0f);
rate = (float)MovementSystem.GetRunRate(0.0f, (int)runSkill, 1.0f);
//Console.WriteLine($"{WorldObject.Name} ({WorldObject.Guid}) - WeenieObject.InqRunRate: runSkill = {runSkill}, rate = {rate}");
return(true);
}
private void Initialize()
{
audioManager = new AudioManager();
renderer = new ImmediateModeRenderer();
sprites = new List <Sprite>();
sources = new List <Source>();
entities = new List <Entity>();
string script = "";
using (StreamReader file = new StreamReader("Assets/Scripts/movement_script.lua"))
{
script = file.ReadToEnd();
}
Entity entity = new Entity(0);
entity.AddComponent(new Position(0, 0));
entity.AddComponent(new Input(new KeyboardAndMouse()));
entity.AddComponent(new Velocity(0, 0));
entity.AddComponent(new SpriteComponent(new Sprite(0, 0, 20, 20, SceneManager.AssetManager.LoadTexture("Assets/Images/heart.png"))));
entity.AddComponent(new Player());
entities.Add(entity);
for (int i = 1; i < 2000; i++)
{
entity = new Entity(i);
entity.AddComponent(new Position(i * 40, 0));
entity.AddComponent(new Velocity(0, 1));
//entity.AddComponent(new SpriteComponent(new Sprite(0, 0, 20, 20, SceneManager.AssetManager.LoadTexture("Assets/Images/heart.png"))));
entity.AddComponent(new Rain());
entities.Add(entity);
}
movementSystem = new MovementSystem();
scriptingSystem = new ScriptingSystem();
renderingSystem = new RenderingSystem(renderer);
inputSystem = new InputSystem();
collisionSystem = new CollisionSystem();
collisionHandler = new CollisionHandler();
sources.Add(new Source(SceneManager.AssetManager.LoadWave("Assets/Audio/main game.wav")));
sources[0].Play();
sources[0].SetPosition(350, 200);
sources[0].ReferenceDistance = 200f;
//sources[0].SetVelocity(0, 0);
}
private void ProcessLateralMovement(MovementSystem movementSystem)
{
float direction = 1f; // направление бокового движения (по умолчанию вправо)
if (_elapsedTimeLaterialMovement < 0) // изменение направления движения корабля (влево)
{
direction = -1f;
}
movementSystem.LateralMovement(direction * Time.deltaTime * 0.1f);
_elapsedTimeLaterialMovement -= Time.deltaTime; // отсчёт прошедшего времени бокового движения
if (_elapsedTimeLaterialMovement < -_periodLaterialMovement) // если мы вышли за рамки периода,
{
_elapsedTimeLaterialMovement = _periodLaterialMovement; // снова устанавливаем "секундомер" на заданный период
}
}
public void GetMovementSpeed()
{
var moveSpeed = MotionTable.GetRunSpeed(MotionTableId);
if (moveSpeed == 0)
{
moveSpeed = 2.5f;
}
var scale = ObjScale ?? 1.0f;
var runSkill = GetCreatureSkill(Skill.Run).Current;
RunRate = (float)MovementSystem.GetRunRate(0.0f, (int)runSkill, 1.0f);
MoveSpeed = moveSpeed * RunRate * scale;
//Console.WriteLine(Name + " - Run: " + runSkill + " - RunRate: " + RunRate + " - Move: " + MoveSpeed + " - Scale: " + scale);
}
protected override void ProcessHandling(MovementSystem movementSystem)
{
switch (_movementBehaviour)
{
case MovementBehaviour.Linear:
movementSystem.LongitudinalMovement(Time.deltaTime);
break;
case MovementBehaviour.Sinusoid:
movementSystem.LongitudinalMovement(Time.deltaTime);
movementSystem.LateralMovement((float)Mathf.Sin(transform.position.y));
break;
case MovementBehaviour.Random:
movementSystem.LongitudinalMovement(Time.deltaTime);
movementSystem.LateralMovement(Random.Range(-1, 2) * Time.deltaTime);
break;
}
}
protected override void ProcessHandling(MovementSystem movementSystem)
{
if (_userControl == null)
{
return;
}
float positionX = _userControl.X * Time.deltaTime;
Vector3 transformPosition = transform.position;
if (GameAreaHelper.RestrictLateralMovement(ref transformPosition, positionX, _representation.bounds, Camera.main))
{
movementSystem.LateralMovement(positionX);
}
else
{
transform.position = transformPosition;
}
}
protected override void ProcessHandling(MovementSystem movementSystem)
{
var move = new Vector3(inputStrategy.GetHorizontalMove(Camera.main.WorldToScreenPoint(transform.position).x) * Time.deltaTime, 0, 0);
if (GameAreaHelper.IsInGameplayAreaFull(transform, _representation.bounds))
{
lastPosition = transform.position;
movementSystem.LateralMovement(move.x);
}
else
{
transform.position = lastPosition;
}
if (inputStrategy.IsStrategySwitchedPressed(out InputStrategy newStrategy))
{
inputStrategy = newStrategy;
}
}
public virtual BaseActor SpawnTrigger(SpawnParams spawnParam)
{
BaseActor actor = m_ActorService.AddActor(spawnParam.ActorType);
//TransformComponent transform = actor.AddComponent<TransformComponent>(spawnParam.InitPos.HasValue ? spawnParam.InitPos.Value : Vector3.Zero,
// spawnParam.InitRot.HasValue ? spawnParam.InitRot.Value : Quaternion.Identity, spawnParam.InitScale.HasValue ? spawnParam.InitScale.Value : Vector3.One);
actor.AddComponent(spawnParam.AttributeComponent, spawnParam.AttributeKey);
TriggerComponent trigger = actor.AddComponent <TriggerComponent>();
trigger.Owner = spawnParam.Owner;
MovementSystem movementSysten = m_ActorService.GetComponentSystem <MovementSystem>();
movementSysten.Transform(actor, spawnParam.InitPos, spawnParam.InitRot, spawnParam.InitScale);
return(actor);
}
// 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)
{
brain = animator.GetComponent <BrainManager>();
ms = animator.GetComponent <MovementSystem>();
float min = Vector3.Distance(animator.transform.position, brain.manager.playerUnits[0].transform.position);
int playerToAttack = 0;
for (int i = 1; i < brain.manager.playerUnits.Count; i++)
{
float temp = Vector3.Distance(animator.transform.position, brain.manager.playerUnits[i].transform.position);
if (temp < min)
{
min = temp;
playerToAttack = i;
}
}
Target = brain.manager.playerUnits[playerToAttack];
abilitiesContainer = brain.creature.abilityContainer;
}
public void TestMovementSystem()
{
var state = new GameState();
for (int i = 0; i < NUMBER_OF_ENTITIES; ++i)
{
state.GameData.Transforms[i] = new Transform(new Vector2(50.0f, 600.0f), 0.0f, new Vector2(1.0f), new Vector2(16.0f, 16.0f));
state.GameData.Velocities[i] = new Vector2(1.0f, 1.0f);
state.GameData.Tags[i] = 1;
state.EntityCount++;
}
Console.WriteLine($"Number of entities: {state.EntityCount}");
for (int i = 1; i < 33; ++i)
{
var system = new MovementSystem("Movement", state);
RunSystem(system, i);
}
state.ClearState();
}
public void UpdateMovesPlayerToNextFloorIfPlayerStandsAboveStairsDownAndShiftDotKeysAreDown(Keys shiftKey)
{
// Arrange
const int StairsX = 3;
const int StairsY = 3;
var player = new Entity();
player.Set(new MoveToKeyboardComponent(player));
var system = new MovementSystem(player);
var map = new ArrayMap <AbstractMapTile>(5, 5);
for (var y = 0; y < map.Height; y++)
{
for (var x = 0; x < map.Width; x++)
{
map[x, y] = new FloorTile();
}
}
map[StairsX, StairsY] = new StairsDownTile();
EventBus.Instance.Broadcast("Map changed", map);
player.Position.X = StairsX;
player.Position.Y = StairsY;
SadConsole.Global.KeyboardState.KeysDown.Add(AsciiKey.Get(shiftKey));
SadConsole.Global.KeyboardState.KeysDown.Add(AsciiKey.Get(Keys.OemPeriod));
bool usedStairs = false;
EventBus.Instance.Register <string>("Player used stairs", (floorNumber) => usedStairs = true);
// Act
system.Update(0);
// Assert
Assert.That(usedStairs, Is.True);
}
public void UpdateChangesPlayerPositionIfNewPositionIsWalkable(bool isDestinationWalkable)
{
// Arrange
var player = new Entity();
var system = new MovementSystem(player);
player.Set(new MoveToKeyboardComponent(player));
player.Position.X = 3;
system.Add(player);
player.Position.Y = 3;
var playerMoved = false;
var map = new ArrayMap <AbstractMapTile>(5, 5);
for (var y = 0; y < map.Height; y++)
{
for (var x = 0; x < map.Width; x++)
{
map[x, y] = new FloorTile();
}
}
map[player.Position.X - 1, player.Position.Y].IsWalkable = isDestinationWalkable;
SadConsole.Global.KeyboardState.KeysPressed.Add(AsciiKey.Get(Keys.Left));
// Update the map in the movement system
EventBus.Instance.Broadcast("Map changed", map);
EventBus.Instance.Register <Player>("Player moved", (data) => playerMoved = true);
var expectedX = isDestinationWalkable ? player.Position.X - 1 : player.Position.X;
// Act
system.Update(0);
// Assert
Assert.That(player.Position.X, Is.EqualTo(expectedX)); // Position changed
Assert.That(playerMoved, Is.EqualTo(isDestinationWalkable)); // Event fired (or not)
}
private void Awake()
{
mTransform = transform;
collisionSystem = GetComponent <CollisionSystem>();
if (!collisionSystem)
{
collisionSystem = gameObject.AddComponent <CollisionSystem>();
}
movementSystem = GetComponent <MovementSystem>();
if (!movementSystem)
{
movementSystem = gameObject.AddComponent <MovementSystem>();
}
stairsSystem = GetComponent <StairsSystem>();
if (!stairsSystem)
{
stairsSystem = gameObject.AddComponent <StairsSystem>();
}
}
public void selectFigurine(GameObject figurine)
{
assist.ClearThrowPath();
assist.ClearWalkPath();
dijSys.resetDijkstra();
player = figurine;
if (figurine == null)
{
player = null;
rotationScript.setNewTarget(null);
figurGewaehlt = false;
}
else
{
attr = (AttributeComponent)player.GetComponent(typeof(AttributeComponent));
movement = (MovementSystem)player.GetComponent(typeof(MovementSystem));
Cell currentCell = (Cell)attr.getCurrentCell().GetComponent(typeof(Cell));
dijSys.executeDijsktra(currentCell, attr.actMovRange, attr.items.getCurrentWeapon().weaponRange);
manager.setSelectedFigurine(figurine);
figurGewaehlt = true;
rotationScript.setNewTarget(player);
}
}
public void Rollback()
{
const float deltaTime = 1f / 10f; // Running 10 FPS
const float fixedDeltaTime = 1f / 5f; // Fixed tick at 5 FPS
var world = new World(EcsConfig.Default);
var inputSystem = new PlayerInputSystem();
var movementSystem = new MovementSystem();
var config = SimulationConfig.Default;
config.FixedTick = fixedDeltaTime;
var simulation = new ClientSimulation <SingletonInputComponent>(
config: config,
world: world,
update:
new Systems(world)
.Add(inputSystem),
fixedUpdate:
new Systems(world)
.Add(movementSystem));
simulation.Create();
var testDriver = new SimulationManagerTestDriver <SingletonInputComponent>(
simulation,
fixedDeltaTime);
// Singleton input entity
var entityInput = world.NewEntity();
// Singleton player entity.
var entityPlayer = world.NewEntity();
entityPlayer.GetComponent <SingletonPlayerComponent>();
ref var movement = ref entityPlayer.GetComponent <MovementComponent>();
// Use this for initialization
void Start()
{
// getting the MS logger to see which version the MS is
MSL = GameObject.Find("MSLogger").GetComponent <MSLogger>().MS;
// getting the gradient data
GameObject playArea = GameObject.FindGameObjectWithTag("PlayArea");
gradientData = playArea.GetComponent <DataReader>().gradientData;
// getting the right hand
rightHand = GameObject.FindGameObjectWithTag("SensorRight");
// getting the GameObject the Audio Listener is on
audioListener = GameObject.FindGameObjectWithTag("Ears");
// getting the CasA
if (MSL == MovementSystem.MS1)
{
CasALeft = GameObject.FindGameObjectWithTag("SuperNovaLeft");
CasARight = GameObject.FindGameObjectWithTag("SuperNovaRight");
}
else
{
CasA = GameObject.FindGameObjectWithTag("SuperNova");
}
// getting the rotator transform
rotator = transform.parent.transform;
// getting the headfollow
headFollow = GameObject.FindGameObjectWithTag("HeadFollow");
curFacingDir = transform.forward;
}
private void InstantiateSystemsManager()
{
SystemsManager = Instantiate(new GameObject());
SystemsManager.name = "SystemsManager";
movementSystem = SystemsManager.AddComponent <MovementSystem>();
keyboardInputSystem = SystemsManager.AddComponent <KeyboardInputSystem>();
mouseInputSystem = SystemsManager.AddComponent <MouseInputSystem>();
factorySystem = SystemsManager.AddComponent <FactorySystem>();
lSystemSystem = SystemsManager.AddComponent <LSystemSystem>();
lSystemFactorySystem = SystemsManager.AddComponent <LSystemFactorySystem>();
entityPool = SystemsManager.AddComponent <EntityPool>();
entityPool.InitialiseEntitiesList();
movementSystem.entityPool = entityPool;
keyboardInputSystem.entityPool = entityPool;
mouseInputSystem.entityPool = entityPool;
factorySystem.entityPool = entityPool;
lSystemSystem.entityPool = entityPool;
lSystemFactorySystem.entityPool = entityPool;
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Create game systems
InputSystem = new InputSystem(this);
NetworkSystem = new NetworkSystem(this);
RenderingSystem = new RenderingSystem(this);
MovementSystem = new MovementSystem(this);
WeaponSystem = new WeaponSystem(this);
EnemyAISystem = new EnemyAISystem(this);
NpcAISystem = new NpcAISystem(this);
GarbagemanSystem = new GarbagemanSystem(this);
CollisionSystem = new Systems.CollisionSystem(this);
RoomChangingSystem = new RoomChangingSystem(this);
QuestLogSystem = new QuestLogSystem(this);
SpriteAnimationSystem = new SpriteAnimationSystem(this);
SkillSystem = new SkillSystem(this);
TextSystem = new TextSystem(this);
EngineeringOffenseSystem = new EngineeringOffenseSystem(this);
HUDSystem = new HUDSystem(this);
SplashSystem = new SplashSystem(this);
InputHelper.Load(4);
HUDSystem.LoadContent();
// Testing code.
LevelManager.LoadContent();
LevelManager.LoadLevel("D01F01R01");
//Song bg = Content.Load<Song>("Audio/Main_Loop");
//MediaPlayer.Stop();
//MediaPlayer.IsRepeating = true;
//MediaPlayer.Play(bg);
//End Testing Code
}
void Start()
{
selectIndicator.SetActive(false);
combatSystem = GetComponent <CombatSystem>();
movementSystem = GetComponent <MovementSystem>();
}
public List <Tile> FindPath(Tile goal, Tile[,] grid, MovementSystem ms)
{
List <Node> openList = new List <Node>();
List <Node> closedList = new List <Node>();
Node start = new Node(null, ms.currentTile.x, ms.currentTile.y);
start.g = start.h = start.f = 0;
Node end = new Node(null, goal.x, goal.y);
end.g = end.h = end.f = 0;
openList.Add(start);
while (openList.Count > 0)
{
Node currentNode = openList[0];
int currentIndex = 0;
for (int i = 0; i < openList.Count; i++)
{
if (openList[i].f < currentNode.f)
{
currentNode = openList[i];
currentIndex = i;
}
}
openList.RemoveAt(currentIndex);
closedList.Add(currentNode);
if (currentNode.x == end.x && currentNode.y == end.y)
{
List <Tile> path = new List <Tile>();
Node current = currentNode;
while (current != null)
{
path.Add(grid[current.x, current.y]);
current = current.parent;
}
return(path);
}
List <Node> children = new List <Node>();
//check surronding tiles
Node nodePos = new Node(currentNode, currentNode.x + 1, currentNode.y);
if (nodePos.x < 49 && nodePos.y < 49)
{
if (grid[nodePos.x, nodePos.y] && grid[nodePos.x, nodePos.y].walkable && !grid[nodePos.x, nodePos.y].unitOnTile)
{
children.Add(nodePos);
}
}
nodePos = new Node(currentNode, currentNode.x, currentNode.y + 1);
if (nodePos.x < 49 && nodePos.y < 49)
{
if (grid[nodePos.x, nodePos.y] && grid[nodePos.x, nodePos.y].walkable && !grid[nodePos.x, nodePos.y].unitOnTile)
{
children.Add(nodePos);
}
}
nodePos = new Node(currentNode, currentNode.x - 1, currentNode.y);
if (nodePos.x < 49 && nodePos.y < 49)
{
if (grid[nodePos.x, nodePos.y] && grid[nodePos.x, nodePos.y].walkable && !grid[nodePos.x, nodePos.y].unitOnTile)
{
children.Add(nodePos);
}
}
nodePos = new Node(currentNode, currentNode.x, currentNode.y - 1);
if (nodePos.x < 49 && nodePos.y < 49)
{
if (grid[nodePos.x, nodePos.y] && grid[nodePos.x, nodePos.y].walkable && !grid[nodePos.x, nodePos.y].unitOnTile)
{
children.Add(nodePos);
}
}
foreach (Node child in children)
{
bool stop = false;
foreach (Node closedChild in closedList)
{
if (!stop && child == closedChild)
{
stop = true;
}
}
if (!stop)
{
child.g = currentNode.g + 1;
child.h = Mathf.RoundToInt(Vector3.Distance(goal.transform.position, grid[child.x, child.y].transform.position));
child.f = child.g + child.h;
foreach (Node openNode in openList)
{
if (!stop && child == openNode && child.g > openNode.g)
{
stop = true;
}
}
if (!stop)
{
openList.Add(child);
}
}
}
}
return(null);
}
private void Awake()
{
_Instance = this;
}
private void Awake()
{
systemsObj = this.transform.Find("Systems");
systemListenersObj = this.transform.Find("System Listeners");
movementSystem = systemsObj.GetComponent <MovementSystem>();
}
private void Start()
{
movementSystem = GetComponent <MovementSystem>();
}
// Passes player input to movement system
protected override void ProcessHandling(MovementSystem movementSystem)
{
movementSystem.LateralMovement(Input.GetAxis(_horizontalMovement) * Time.deltaTime);
}
protected override void ProcessMove(MovementSystem movementSystem)
{
//movementSystem.LateralMovement(Time.deltaTime);
//movementSystem.LongitudinalMovement(Time.deltaTime);
movementSystem.RandomMovement(Time.deltaTime);
}
public bool InqJumpVelocity(float extent, ref float velocityZ)
{
velocityZ = MovementSystem.GetJumpHeight(1.0f, 100, 1.0f, 1.0f) * 19.6f;
return(true);
}
public void HandleActionJump(JumpPack jump)
{
StartJump = new ACE.Entity.Position(Location);
//Console.WriteLine($"JumpPack: Velocity: {jump.Velocity}, Extent: {jump.Extent}");
var strength = Strength.Current;
var capacity = EncumbranceSystem.EncumbranceCapacity((int)strength, AugmentationIncreasedCarryingCapacity);
var burden = EncumbranceSystem.GetBurden(capacity, EncumbranceVal ?? 0);
// calculate stamina cost for this jump
var extent = Math.Clamp(jump.Extent, 0.0f, 1.0f);
var staminaCost = MovementSystem.JumpStaminaCost(extent, burden, PKTimerActive);
//Console.WriteLine($"Strength: {strength}, Capacity: {capacity}, Encumbrance: {EncumbranceVal ?? 0}, Burden: {burden}, StaminaCost: {staminaCost}");
// ensure player has enough stamina to jump
/*if (staminaCost > Stamina.Current)
* {
* // get adjusted power
* extent = MovementSystem.GetJumpPower(Stamina.Current, burden, false);
*
* staminaCost = (int)Stamina.Current;
*
* // adjust jump velocity
* var velocityZ = MovementSystem.GetJumpHeight(burden, GetCreatureSkill(Skill.Jump).Current, extent, 1.0f);
*
* jump.Velocity.Z = velocityZ;
* }*/
IsJumping = true;
LastJumpTime = DateTime.UtcNow;
UpdateVitalDelta(Stamina, -staminaCost);
IsJumping = false;
//Console.WriteLine($"Jump velocity: {jump.Velocity}");
// TODO: have server verify / scale magnitude
if (FastTick)
{
if (!PhysicsObj.IsMovingOrAnimating)
{
//PhysicsObj.UpdateTime = PhysicsTimer.CurrentTime - Physics.PhysicsGlobals.MinQuantum;
PhysicsObj.UpdateTime = PhysicsTimer.CurrentTime;
}
// perform jump in physics engine
PhysicsObj.TransientState &= ~(Physics.TransientStateFlags.Contact | Physics.TransientStateFlags.WaterContact);
PhysicsObj.calc_acceleration();
PhysicsObj.set_on_walkable(false);
PhysicsObj.set_local_velocity(jump.Velocity, false);
if (CombatMode == CombatMode.Magic && MagicState.IsCasting)
{
FailCast();
}
}
else
{
PhysicsObj.UpdateTime = PhysicsTimer.CurrentTime;
// set jump velocity
//var glob_velocity = Vector3.Transform(jump.Velocity, Location.Rotation);
//PhysicsObj.set_velocity(glob_velocity, true);
// perform jump in physics engine
PhysicsObj.TransientState &= ~(Physics.TransientStateFlags.Contact | Physics.TransientStateFlags.WaterContact);
PhysicsObj.calc_acceleration();
PhysicsObj.set_on_walkable(false);
PhysicsObj.set_local_velocity(jump.Velocity, false);
}
// this shouldn't be needed, but without sending this update motion / simulated movement event beforehand,
// running forward and then performing a charged jump does an uncharged shallow arc jump instead
// this hack fixes that...
var movementData = new MovementData(this);
movementData.IsAutonomous = true;
movementData.MovementType = MovementType.Invalid;
movementData.Invalid = new MovementInvalid(movementData);
EnqueueBroadcast(new GameMessageUpdateMotion(this, movementData));
// broadcast jump
EnqueueBroadcast(new GameMessageVectorUpdate(this));
if (MagicState.IsCasting && RecordCast.Enabled)
{
RecordCast.OnJump(jump);
}
}
public TargetSelection(Game1 myGame)
{
system = myGame.SystemManager.sMovement;
TList = new List <Vector2>();
mouseVector = new Vector2();
}
//движение врага по прямой (по направлению корабля)
protected override void ProcessHandling(MovementSystem movementSystem)
{
movementSystem.LongitudinalMovement(Time.deltaTime);
}
public IState UpdateState(ref GameSettings gameSettings, GameTime gameTime, Camera camera, KeyboardState currentKey, KeyboardState prevKey, MouseState currentMouse, MouseState prevMouse)
{
Guid playerId = this._components.Entities.Where(c => c.HasComponents(ComponentFlags.IS_PLAYER)).FirstOrDefault().Id;
// Level input
if (currentKey.IsKeyDown(Keys.Escape) && prevKey.IsKeyUp(Keys.Escape))
{
return(new PauseState(this._content, this));
}
if (currentKey.IsKeyDown(Keys.Q) && prevKey.IsKeyUp(Keys.Q))
{
return(new TestLevel(this._content, camera));
}
if (currentKey.IsKeyDown(Keys.F) && prevKey.IsKeyUp(Keys.F))
{
this._components.DelayedActions.Add(new Action(() =>
{
for (int i = 0; i < 10; i++)
{
Guid testId = ArkCreation.SpawnEntityWithOverrides(Constants.Ark.Monsters.TestNpc, ref this._components, new BaseEntity(ComponentFlags.POSITION)
{
Position = new Position()
{
OriginPosition = new Vector2(Constants.Random.Next(20, this._gridCols * 48), Constants.Random.Next(0, this._gridRows * 48))
}
});
InventorySystem.GenerateRandomInventoryItemsForEntity(this._components, testId);
}
}));
}
if (currentKey.IsKeyDown(Keys.E) && prevKey.IsKeyUp(Keys.E))
{
this._components.DelayedActions.Add(new Action(() =>
{
Guid testId = ArkCreation.SpawnEntityWithOverrides(Constants.Ark.Monsters.TestNpc, ref this._components, new BaseEntity(ComponentFlags.POSITION)
{
Position = new Position()
{
OriginPosition = this._components.Positions[playerId].OriginPosition
}
});
InventorySystem.GenerateRandomInventoryItemsForEntity(this._components, testId);
}));
}
if (currentKey.IsKeyDown(Keys.R) && prevKey.IsKeyUp(Keys.R))
{
this._components.DelayedActions.Add(new Action(() =>
{
Guid id = this._components.Entities.Where(x => x.HasDrawableSprite() && !x.HasComponents(ComponentFlags.IS_PLAYER) && x.HasComponents(ComponentFlags.INVENTORY)).First().Id;
InventorySystem.DropEntityInventory(this._components, id);
this._components.DestroyEntity(id);
}));
}
// Camera Updates
CameraSystem.ControlCamera(currentKey, prevKey, camera, gameTime);
CameraSystem.PanCamera(camera, gameTime);
// Entity Movement Updates
this._components.Entities.ForEach(c =>
{
if (c.IsMovable())
{
switch (this._components.Movements[c.Id].MovementType)
{
case MovementType.AI:
//AI Movement System Call
break;
case MovementType.INPUT:
MovementSystem.InputMovement(currentKey, prevKey, gameTime, this._components.Positions[c.Id], this._components.Movements[c.Id]);
break;
case MovementType.DIRECTED:
MovementSystem.UpdateMovingEntities(this._components.Movements[c.Id], this._components.Positions[c.Id], gameTime, this._components, c);
break;
}
}
});
// Entity Information Updates
// Collision
CollisionSystem.CheckForCollisions(this._components, this._collisionPartition);
CollisionSystem.HandleCollisions(this._components);
// Set up for next frame
CameraSystem.UpdateCameraTarget(this._components, camera);
CollisionSystem.ResetCollisions(ref this._components);
this._components.InvokeDelayedActions();
return(this);
}
public bool InqRunRate(ref float rate)
{
// get run skill from WorldObject
rate = (float)MovementSystem.GetRunRate(0.0f, 300, 1.0f);
return true;
}
