public void ProcessTick(Move move, float dt) { if (puzzleObject.Position - origPosition == new Vector2(xDistance, yDistance)) { puzzleObject.Physics.Velocity = Vector2.Zero; ProcessList.Instance.RemoveObject(puzzleObject); } }
public void ProcessTick(Move move, float elapsed) { if (move != null) { // set our test object's Velocity based on stick/keyboard input _sceneObject.Physics.VelocityX = move.Sticks[0].X*20.0f; if(_sceneObject.Physics.VelocityX < 0) { Orientation = Orientation.Left; if(Action != Action.Walking) { ((T2DAnimatedSprite)_sceneObject).PlayAnimation( TorqueObjectDatabase.Instance.FindObject<T2DAnimationData>(Game.Instance.Player + "Walking") ); } Action = Action.Walking; _sceneObject.FlipX =Game.Instance.Player == "steve" ? true :false; } else if (_sceneObject.Physics.VelocityX > 0) { Orientation = Orientation.Right; if (Action != Action.Walking) { ((T2DAnimatedSprite)_sceneObject).PlayAnimation( TorqueObjectDatabase.Instance.FindObject<T2DAnimationData>(Game.Instance.Player + "Walking") ); } Action = Action.Walking; _sceneObject.FlipX = Game.Instance.Player == "steve" ? false : true; } else { if (Action != Action.Standing) { ((T2DAnimatedSprite)_sceneObject).PlayAnimation( TorqueObjectDatabase.Instance.FindObject<T2DAnimationData>(Game.Instance.Player + "Standing") ); } Action = Action.Standing; } } }
/// <summary> /// Checks whether all the switches are on or not. If they are, /// the puzzle object runs all specified behaviors. If not, /// it just sits there and looks pretty. /// </summary> /// <param name="move">Some move crap that's not applicable to this component.</param> /// <param name="dt">The time passed since last update.</param> public virtual void ProcessTick(Move move, float dt) { if (!allSwitchesOn) { allSwitchesOn = true; foreach (SwitchTrigger switchObj in switches) allSwitchesOn &= switchObj.IsOn; } if (allSwitchesOn) { foreach (PuzzleBehavior behavior in behaviors) behavior.Run(SceneObject);// behavior.Execute(SceneObject); } }
public virtual void ProcessTick(Move move, float elapsed) { if (playerEntered) { if(!camera.IsMoving) { if (!transitionFinished) { transitionFinished = true; hulk.PlayIntro(); } } if (hulk.AnimationManager.CurrentState.StateName == "intro") { if (hulk.AnimatedSprite.CurrentFrame == hulk.AnimatedSprite.FinalFrame) { T2DSceneObject player = (T2DSceneObject)TorqueObjectDatabase.Instance.FindObject("Amanda"); camera.ReturnToPlayer(player, 200f); } } if (hulk.AnimationManager.PreviousState != null) { if (hulk.AnimationManager.PreviousState.StateName == "intro") { if (!camera.IsMoving) { camera.Zoom(0.5f, 3000f); T2DSceneObject player = (T2DSceneObject)TorqueObjectDatabase.Instance.FindObject("Amanda"); PlayerActorComponent actor = player.Components.FindComponent<PlayerActorComponent>(); ((PlayerController)actor.Controller).TogglePlayerControl(); SceneObject.MarkForDelete = true; } } } } }
///<summary> ///Called each tick ///</summary> ///<param name="move"></param> ///<param name="dt"> ///The amount of elapsed time since the last call, in seconds. ///</param> public virtual void ProcessTick(Move move, float dt) { PauseEngineSound = Program.GamePaused; if (_engineCue == null) return; _engineCue.SetVariable( "EngineSpeed", (SceneObject.Physics.Velocity.LengthSquared() / 10000.0f * 100.0f)); //maxVelSq _engineCue.SetVariable( "AngularSpeed", (System.Math.Abs(SceneObject.Physics.AngularVelocity) / 75.0f * 100.0f)); //maxAngVel }
public override void ProcessTick(Move move, float elapsed) { #if DEBUG Profiler.Instance.StartBlock("T2DSceneCamera.ProcessTick"); #endif // WARNING: changing the call order of the methods here could cause // camera interpolation bugs, camera jitter, or mounting failure - be // aware of any changes here! // what does this mean? // 1) base.StartTick should be explicitly called before any positions are // set so the previous tick can be logged and any changes in position // can be correctly recorded as occuring during "this tick" // 2) changes in position (camera animation and camera shake and any other // custom camera movements) happen next. // 3) base.ProcessTick must happen last. this is for two reasons. first, if // the camera is mounted it has to be updated after the camera has it's say // about where it wants to go. second, the tick is officially ended at the end // of base.ProcessTick, so if we change the position or try to start the tick // after that, the order will be screwed and interpolation won't work correctly. // 4) the actual view region of the camera is updated based on any changes to // position of rotation that might have just happened. // phew... // ...enough chatter, here it is: // 1) explicitly call StatTick here... // this is normally done in moving objects by the physics component, // but cameras don't require one. we need to call this to make sure that // position and rotation are interpolated and updated properly. base.StartTick(); // 2) perform any position or rotation changes... // interpolate zoom and position _Animate(); // upate camera shake _UpdateShake(); // 3)call base.ProcessTick... // call T2DSceneObject's ProcessTick to update our position // based on our mountee's position (if we are mounted to another object) base.ProcessTick(move, elapsed); // 4) update the scene region... // recalculate our extents and transforms _UpdateSceneRegion(); // see? // piece of cake! >_<; #if DEBUG Profiler.Instance.EndBlock("T2DSceneCamera.ProcessTick"); #endif }
/// <summary> /// IT2DForceGenerator interface method. Called by the Physics component after the current move is processed. /// </summary> /// <param name="move">Move is generally ignored by MoveComponents because their control is intended to come from /// a MoveController, rather than user input.</param> /// <param name="elapsed">Elapsed time since last PostUpdateForces call.</param> public virtual void PostUpdateForces(Move move, float elapsed) { _postUpdate(elapsed); }
public void ProcessTick(Move move, float dt) { obj.Position += new Vector2((float)Math.Sin(dt * 100), 0); }
/// <summary> /// Called each tick /// </summary> /// <param name="dt"> /// The amount of elapsed time since the last call, in seconds. /// </param> public virtual void ProcessTick(Move move, float dt) { if (MyGame.Instance.GamePaused) return; if (_goalRegulator.IsReady) { GenerateGoal(); } }
public override void ProcessTick(Move move, float elapsed) { base.ProcessTick(move, elapsed); // don't allow spawning if we're not enabled if (!_spawnEnabled) return; _currentTime += (elapsed * 1000.0f); if (_currentTime >= _nextSpawn) { DoSpawn(); Assert.Fatal(_maxSpawnTime >= _minSpawnTime, "T2DSpawnObject::ProcessTick: MaxSpawnTime is less than MinSpawnTime!"); if (_maxSpawnTime < _minSpawnTime) _maxSpawnTime = _minSpawnTime; // generate a new spawn time _nextSpawn = TorqueUtil.GetRandomFloat(_minSpawnTime, _maxSpawnTime); // make sure we didn't generate a negative time Assert.Fatal(_nextSpawn >= 0.0f, "T2DSpawnObject::ProcessTick: spawn rate is negative!"); if (_nextSpawn < 0.0f) _nextSpawn = 0.0f; _nextSpawn += _currentTime; } }
/// <summary> /// Called each tick /// </summary> /// <param name="dt"> /// The amount of elapsed time since the last call, in seconds. /// </param> public virtual void ProcessTick(Move move, float dt) { if (MindcraftersComponentLibrary.GamePaused) return; // todo: perform processing for component here }
/// <summary> /// Generates move for the move manager. In order to generate a new move type one would /// derive a new class from Move and a new move manager type from MoveManager. Then one /// would override this method to generate moves of the desired type. Call base._GenerateMove /// with a move of the desired type to have base class fill in the buttons, triggers, /// levers, and sticks. If simply using stock moves, there is no need to override this /// method. /// </summary> /// <param name="move">The move to fill in if already generated (by derived class) or null if creating move is our responsibility.</param> /// <returns>New move.</returns> protected internal virtual Move _GenerateMove(Move move) { // we may or may not supply our own move if (move == null) move = _move; // but we will always set the move data we know about ourself move._buttons = _buttons; move._triggers = _triggers; move._levers = _levers; move._sticks = _sticks; return move; }
///<summary> ///Called each tick ///</summary> ///<param name="move"></param> ///<param name="dt"> ///The amount of elapsed time since the last call, in seconds. ///</param> public virtual void ProcessTick(Move move, float dt) { float inputParameter = 0; if (null != _monitoredInterface && null != _monitoredObject && _monitoredObject.IsRegistered) { inputParameter = _monitoredInterface.Value; } float fractionOfMax = (inputParameter - _minRange) / _maxRange; if (_reverse) SceneObject.Rotation = fractionOfMax * -360.0f + _rotationOffset; else SceneObject.Rotation = fractionOfMax * 360.0f + _rotationOffset; }
public void ProcessTick(Move move, float dt) { if (Math.Abs(_scrollAmountX) > 0.1f) ScrollX(_scrollAmountX * _scrollSpeed); if (Math.Abs(_scrollAmountY) > 0.1f) ScrollY(_scrollAmountY * _scrollSpeed); }
public virtual void ProcessTick(Move move, float elapsed) { if (playerHasControl) { // check if move exists if (move != null) { // set horizontal actor movement flags if (move.Sticks[0].X < 0) _moveLeft(); else if (move.Sticks[0].X > 0) _moveRight(); else _horizontalStop(); // keep track of whether or not the down button is pressed // (so we know whether this is a normal jump, or a down-jump) bool movingDown = false; // set vertical actor movement flags if (move.Sticks[0].Y < -0.25) { _moveDown(); movingDown = true; } else _verticalStop(); // set jump only on initial button down and button release if (move.Buttons[0].Pushed) { _jump(); if (movingDown) _jumpDown(); } // set attack only on initial button down and button release if (move.Buttons[1].Pushed) { if (!_attackButton) { foreach (PlayerActorComponent actor in Movers) actor.Punch(); _attackButton = true; } } else if (move.Buttons[2].Pushed) { if (!_attackButton) { foreach (PlayerActorComponent actor in Movers) actor.Swipe(); _attackButton = true; } } else if (move.Triggers[0].Value == 1 || move.Buttons[3].Pushed) { if (!_attackButton) { foreach (PlayerActorComponent actor in Movers) actor.Shoot(); _attackButton = true; } } else if (_attackButton) { _attackButton = false; } } } }
public override void Process(Move move, float dt, ref float val) { if (move == null) return; Assert.Fatal(TriggerIndex >= 0 && TriggerIndex < move.Triggers.Count, "TriggerIndex out of range"); if (TriggerIndex >= move.Triggers.Count || TriggerIndex < 0) return; float input = move.Triggers[TriggerIndex].Value; _Update(ref val, input, false); }
public virtual void ProcessTick(Move move, float elapsed) { // check distance and spawn objects if appropriate if (_proximityTarget == null) return; // check for objects to spawn if (SpawnCount < SpawnLimit) { float distance = Vector2.Distance(ProximityBasisObject.Position, _proximityTarget.Position); if (distance <= _maxSpawnDistance && distance >= _minSpawnDistance) Spawn(); } // check for objects to despawn if (_autoDespawn && SpawnedObjects.Count > 0) { for (int i = 0; i < SpawnedObjects.Count; i++) { T2DSceneObject obj = SpawnedObjects[i]; if (obj == null) continue; // if they are not the same direction away, skip if ((obj.Position.X - Target.Position.X < 0) != (ProximityBasisObject.Position.X - Target.Position.X < 0)) continue; float distance = Vector2.Distance(ProximityBasisObject.Position, _proximityTarget.Position); float objDistance = Vector2.Distance(obj.Position, _proximityTarget.Position); // if they are far enough away and the spawn point is far enough away, despawn! if (distance > _maxSpawnDistance * 1.5 && objDistance > _maxSpawnDistance * 1.5) { Despawn(obj); // decrement the counter // (one fewer object) i--; } } } }
public void ProcessTick(Move move, float dt) { for (int i = 0; i < _processors.Count; i++) { ProcessData pd = _processData[i]; float val = pd.Interface.Value; pd.PreTick = val; _processors[i].Process(move, dt, ref val); pd.Interface.Value = val; pd.PostTick = val; _processData[i] = pd; } }
///<summary> ///Called everytime the engine processes a tick. This is guaranteed to ///happen at the tick rate, though it may not happen at the exact tick ///boundaries. ///</summary> ///<param name="move"> ///The move structure that contains information about user input. ///</param> ///<param name="dt"> ///The amount of time passed. This is always the tick rate. ///</param> public void ProcessTick(Move move, float dt) { FSM.Instance.Execute(this); }
public override void Process(Move move, float dt, ref float val) { if (move == null) return; Assert.Fatal(ButtonIndex >= 0 && ButtonIndex < move.Buttons.Count, "ButtonIndex out of range"); if (ButtonIndex >= move.Buttons.Count || ButtonIndex < 0) return; float input = move.Buttons[ButtonIndex].Pushed ? 1.0f : 0.0f; _Update(ref val, input, false); }
public void ProcessTick(Move move, float elapsed) { // call update on this AI controller _update(); }
public override void Process(Move move, float dt, ref float val) { if (move == null) return; Assert.Fatal(LeverIndex >= 0 && LeverIndex < move.Levers.Count, "LeverIndex out of range"); if (LeverIndex >= move.Levers.Count || LeverIndex < 0) return; float input = move.Levers[LeverIndex].Value; input = 0.5f * (input + 1.0f); _Update(ref val, input, false); }
///<summary> ///Called each tick ///</summary> ///<param name="move"></param> ///<param name="dt"> ///The amount of elapsed time since the last call, in seconds. ///</param> public virtual void ProcessTick(Move move, float dt) { if (Program.GamePaused) { //TODO: save velocity. zero on pause. restore on no pause? return; } ForwardThrust = MathHelper.Clamp(ForwardThrust, 0.0f, 1.0f); ReverseThrust = MathHelper.Clamp(ReverseThrust, 0.0f, 1.0f); LateralThrust = MathHelper.Clamp(LateralThrust, -1.0f, 1.0f); AngularThrust = MathHelper.Clamp(AngularThrust, -1.0f, 1.0f); Braking = MathHelper.Clamp(Braking, 0.0f, 1.0f); _heading.Value = SceneObject.Rotation; //Rotation SceneObject.Physics.AngularVelocity *= AngularDamping; SceneObject.Physics.AngularVelocity += (1.0f - AngularDamping) * AngularThrust * MaxAngularSpeed; //Forwards and Backwards SceneObject.Physics.VelocityX *= Damping; SceneObject.Physics.VelocityY *= Damping; SceneObject.Physics.VelocityX += (1.0f - Damping) * (float)System.Math.Sin(MathHelper.ToRadians( SceneObject.Rotation)) * (ForwardThrust * MaxForwardSpeed - ReverseThrust * MaxReverseSpeed); SceneObject.Physics.VelocityY -= (1.0f - Damping) * (float)System.Math.Cos(MathHelper.ToRadians( SceneObject.Rotation)) * (ForwardThrust * MaxForwardSpeed - ReverseThrust * MaxReverseSpeed); //Lateral thrust if (!LateralThrustEnabled) return; SceneObject.Physics.VelocityX += (1.0f - Damping) * (float)System.Math.Cos( MathHelper.ToRadians(SceneObject.Rotation)) * LateralThrust * MaxLateralSpeed; SceneObject.Physics.VelocityY += (1.0f - Damping) * (float)System.Math.Sin( MathHelper.ToRadians( SceneObject.Rotation)) * LateralThrust * MaxLateralSpeed; }
public override void Process(Move move, float dt, ref float val) { if (move == null) return; Assert.Fatal(StickIndex >= 0 && StickIndex < move.Sticks.Count, "StickIndex out of range"); if (StickIndex >= move.Sticks.Count || StickIndex < 0) return; float x = move.Sticks[StickIndex].X; float y = move.Sticks[StickIndex].Y; float len = (float)Math.Sqrt(x * x + y * y); _Update(ref val, len, false); }
/// <summary> /// Called each tick /// </summary> /// <param name="dt"> /// The amount of elapsed time since the last call, in seconds. /// </param> public virtual void ProcessTick(Move move, float dt) { if (MindcraftersComponentsLibrary.GamePaused) return; // Timer to restrict how fast a tank shell may be fired. if (_countdownToFire > 0f) { _countdownToFire -= dt; } if (!IsAI && move != null) { // The user has requested a tank shell be fired. if (move.Buttons[0].Pushed) { if (_countdownToFire <= 0f) { _Fire(); } } } else if (IsAI && _HaveTargetInLOS()) { if (_countdownToFire <= 0f) { _Fire(); } } }
public override void Process(Move move, float dt, ref float val) { if (move == null) return; Assert.Fatal(StickIndex >= 0 && StickIndex < move.Sticks.Count, "StickIndex out of range"); if (StickIndex >= move.Sticks.Count || StickIndex < 0) return; float x = move.Sticks[StickIndex].X; float y = move.Sticks[StickIndex].Y; if (x * x + y * y < 0.01f) // zero length, can't determine angle so leave angle as is return; float invLen = 1.0f / (float)Math.Sqrt(x * x + y * y); x *= invLen; y *= invLen; float theta = (float)Math.Acos(-x); if (y < 0.0f) theta = -theta; float targetRotation = (MathHelper.ToDegrees(theta) + 270.0f) % 360.0f; _Update(ref val, targetRotation, true); }
public virtual void ProcessTick(Move move, float elapsed) { if (!_fallTriggered) return; _totalElapsed += elapsed; if (_totalElapsed >= _timeout) _platform.Physics.VelocityY += _gravity * elapsed * 100; if (!(Owner.IsRegistered && _totalElapsed >= _timeout + _deleteAfterFallTimeout)) return; _platformComponent.PlatformEnabled = false; if (!Owner.TestObjectType(PlatformerData.SpawnedObjectType)) { TorqueObjectDatabase.Instance.Unregister(Owner); return; } SpawnedObjectComponent spawnedObject = Owner.Components.FindComponent<SpawnedObjectComponent>(); if (_autoRecover && spawnedObject != null) spawnedObject.SpawnPoint.ResetSpawnPoint(); else TorqueObjectDatabase.Instance.Unregister(Owner); }
/// <summary> /// Processor does it's work in this method. If writing your own Processor this is /// where you do your thing. /// </summary> /// <param name="move">The move passed into ProcessTick for the object.</param> /// <param name="dt">The elapsed time, in seconds, passed into ProcessTick for the object.</param> /// <param name="val">The output value.</param> public abstract void Process(Move move, float dt, ref float val);
public void ProcessTick(Move move, float dt) { #if DEBUG Profiler.Instance.StartBlock(Profiler_ProcessTick); #endif T2DSceneObject sceneObject = SceneObject; sceneObject.StartTick(); if (sceneObject.IsMounted) { // scene object handles mount behavior if (AngularVelocity != 0.0f) sceneObject.SetRotation(sceneObject.Rotation + AngularVelocity * dt, false); // slam this component with it's mount parent's velocity values if (sceneObject.MountedTo != null && sceneObject.MountedTo.Physics != null) { Velocity = SceneObject.MountedTo.Physics.Velocity; if (sceneObject.TrackMountRotation) AngularVelocity = sceneObject.MountedTo.Physics.AngularVelocity; } #if DEBUG Profiler.Instance.EndBlock(Profiler_ProcessTick); #endif return; } // apply forces for this turn if (_forceGenerators != null) { for (int i = 0; i < _forceGenerators.Count; i++) { _forceGenerators[i].Wrap.PreUpdateForces(move, dt); } } bool atRest = false; if (!_processCollisionsAtRest && Math.Abs(_velocity.X) < Epsilon.Value && Math.Abs(_velocity.Y) < Epsilon.Value && Math.Abs(_angularVelocity) < Epsilon.Value) { // clamp velocity to zero and short cut collision checking. _velocity.X = 0.0f; _velocity.Y = 0.0f; _angularVelocity = 0.0f; atRest = true; } int iterations = 5; while (iterations-- > 0 && dt > 0.00001f) { float firstCollideTime = dt; _collisions.Clear(); // only check collisions if we haven't already exhausted all checking...just move if we can't // resolve (note: this gives objects every opportunity to behave properly but still prevents // them from getting stuck...which is worse than minor tunneling/penetration issues). if (iterations > 0) { if (sceneObject.Collision != null && !atRest) sceneObject.Collision.TestMove(ref firstCollideTime, _velocity, _collisions); else if (!atRest && sceneObject.WorldLimit != null) sceneObject.WorldLimit.TestMove(ref firstCollideTime, _velocity, _collisions); } if (firstCollideTime > 0.0f && _collisions.Count != 0) { // back off a little pre-collision firstCollideTime = MathHelper.Max(firstCollideTime - 0.001f, 0.0f); } if (firstCollideTime > 0.0f) { // integrate position and rotation if (!atRest) { sceneObject.SetPosition(sceneObject.Position + Velocity * firstCollideTime, false); // Note: this is different than TGB. In TGB, don't rotate if we collide. sceneObject.SetRotation((sceneObject.Rotation + AngularVelocity * firstCollideTime + 360.0f) % 360.0f, false); } } else if (sceneObject.Collision == null || sceneObject.Collision.SolveOverlap) { Vector2 penetration = new Vector2(); // need to resolve overlap for (int i = 0; i < _collisions.Count; i++) { float pushScale = 1.05f; float ourInvMass = InverseMass; float theirInvMass = 0.0f; T2DSceneObject theirObj = _collisions[i].SceneObject; if (theirObj != null) { if (theirObj.Collision != null && !theirObj.Collision.SolveOverlap) // if they don't solve overlap, don't solve overlap even though it's our turn continue; if (theirObj.Physics != null) theirInvMass = theirObj.Physics.InverseMass; } if (ourInvMass > Epsilon.Value || theirInvMass < Epsilon.Value) { // displace us -- either we're movable or they're immovable Vector2 addPenetration = pushScale * _collisions[i].Penetration; float len2 = penetration.LengthSquared(); // If we have multiple contacts we need to be careful about adding up sources of // penetration. In the following we make sure not to accumulate the same penetration // multiple times. if (len2 > Epsilon.Value) addPenetration -= (Vector2.Dot(penetration, addPenetration) / len2) * penetration; penetration += addPenetration; } else // (ourInvMass <= Epsilon.Value && theirInvMass >= Epsilon.Value) { // displace them -- special case in which we're immovable and we ram something which isn't theirObj.Position = theirObj.Position - pushScale * _collisions[i].Penetration; } } sceneObject.SetPosition(sceneObject.Position + penetration, false); } // allow force generators to apply forces for elapsed time if (_forceGenerators != null) { for (int i = 0; i < _forceGenerators.Count; i++) { // how do we handle force generator that moves object rather than // pushes it? undo work? convert to 1 time velocity? _forceGenerators[i].Wrap.PostUpdateForces(move, firstCollideTime); } } _ResolveCollisions(_collisions); atRest = false; // get rid of objects marked for delete so that // we don't run into things that are going away if (Owner != null) sceneObject.Manager.DeleteMarkedObjects(); if (Owner == null) { #if DEBUG Profiler.Instance.EndBlock(Profiler_ProcessTick); #endif // deleted ourself... get out now return; } dt -= firstCollideTime; } sceneObject.UpdateSpatialData(); #if DEBUG Profiler.Instance.EndBlock(Profiler_ProcessTick); #endif }
public override void Process(Move move, float dt, ref float val) { if (move == null) return; Assert.Fatal(StickIndex >= 0 && StickIndex < move.Sticks.Count, "StickIndex out of range"); if (StickIndex >= move.Sticks.Count || StickIndex < 0) return; float input = Axis == 0 ? move.Sticks[StickIndex].X : move.Sticks[StickIndex].Y; input = 0.5f * (input + 1.0f); _Update(ref val, input, false); }