/// <summary>
/// Schedule an actor for deletion. Deletion will occur before the next physics simulation step.
/// </summary>
/// <param name="actor">Actor to delete</param>
public void ScheduleForDeletion(IPhysicsActor actor)
{
if (actor is BEPUActor)
{
deletionList.Add((actor as BEPUActor));
}
}
/// <summary>
/// Creates an actor using shape info and information from the parent BaseEntity.
/// </summary>
/// <param name="PhysicsScene">Reference to the physics scene</param>
protected virtual void CreateActor(IPhysicsScene PhysicsScene)
{
ShapeDesc newShape = CreateShapeFromType(shapeType);
if (newShape == null)
{
throw new Exception("Shape did not load properly");
}
ActorDesc desc = new ActorDesc();
desc.Orientation = this.parentEntity.Rotation;
desc.Mass = this.mass;
desc.Dynamic = this.isDynamic;
desc.AffectedByGravity = this.affectedByGravity;
desc.Position = this.parentEntity.Position;
desc.Shapes.Add(newShape);
desc.EntityID = this.parentEntity.UniqueID;
desc.Game = this.parentEntity.Game;
desc.Type = ActorType.Basic;
if (newShape is TriangleMeshShapeDesc)
{
var triDesc = newShape as TriangleMeshShapeDesc;
if (triDesc.Vertices.Count > 100)
{
desc.Type = ActorType.Static;
}
}
this.actor = PhysicsScene.CreateActor(desc);
}
void Start()
{
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 10);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
StartCoroutine(AI());
}
private void Awake()
{
collider_ = GetComponent <Collider2D>();
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 10);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
transform_ = transform;
enemyScript_ = GetComponent <EnemyScript>();
}
private new void Awake()
{
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 10);
mySenses_.SetLookForNearbyCover(true, 3);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
base.Awake();
}
/// <summary>
/// Adds a <see cref="IPhysicsActor"/> to the overall scene.
/// </summary>
/// <param name="inActor">Actor to be placed in the scene.</param>
public void AddActor(Int64 EntityUniqueID, IPhysicsActor inActor)
{
this.actors.Add(EntityUniqueID, inActor);
this.PhysicsScene.AddActor(inActor);
#if WINDOWS && DEBUG
if (inActor.ActorType != ActorType.Terrain)
{
this.game.PhysicsRenderer.modelDrawer.Add(inActor.SpaceObject);
}
#endif //WINDOWS && DEBUG
}
void Start()
{
movable_ = GetComponent <IMovableActor>();
senses_ = GetComponent <ISensingActor>();
senses_.SetLookForPlayerLoS(true, maxDistance: 20);
me_ = GetComponent <IEnemy>();
physicsActor_ = GetComponent <IPhysicsActor>();
bulletPool_ = SceneGlobals.Instance.EnemyIceBulletPool;
audioManager_ = SceneGlobals.Instance.AudioManager;
StartCoroutine(AI());
}
/// <summary>
/// Removes an actor from the overall scene.
/// </summary>
/// <param name="targetActor">Actor to be removed.</param>
public void RemoveActor(Int64 EntityUniqueID, IPhysicsActor targetActor)
{
#if WINDOWS && DEBUG
if (targetActor.ActorType != ActorType.Terrain)
{
this.game.PhysicsRenderer.modelDrawer.Remove(targetActor.SpaceObject);
}
#endif //WINDOWS && DEBUG
this.physicsScene.ScheduleForDeletion(targetActor);
this.actors.Remove(EntityUniqueID);
}
private new void Awake()
{
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 12);
mySenses_.SetLookForNearbyCover(true, maxDistance: 4);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
bulletPool_ = SceneGlobals.Instance.DragonHatchlingProjectilePool;
audioManager_ = SceneGlobals.Instance.AudioManager;
transform_ = transform;
base.Awake();
}
private void Start()
{
enemyScript_ = GetComponent <EnemyScript>();
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 10);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
rendererTransform_ = enemyScript_.SpriteRenderer.transform;
transform_ = transform;
body_ = GetComponent <Rigidbody2D>();
Timing.RunCoroutine(AICo().CancelWith(gameObject));
}
private void Awake()
{
collider_ = GetComponent <Collider2D>();
aiPath_ = GetComponent <AIPath>();
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 10);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
transform_ = transform;
enemyScript_ = GetComponent <EnemyScript>();
bulletPool_ = SceneGlobals.Instance.MinotaurProjectilePool;
audioManager_ = SceneGlobals.Instance.AudioManager;
}
private void Awake()
{
collider_ = GetComponent <Collider2D>();
aiPath_ = GetComponent <AIPath>();
myMovement_ = GetComponent <IMovableActor>();
mySenses_ = GetComponent <ISensingActor>();
mySenses_.SetLookForPlayerLoS(true, maxDistance: 10);
me_ = GetComponent <IEnemy>();
myPhysics_ = GetComponent <IPhysicsActor>();
transform_ = transform;
enemyScript_ = GetComponent <EnemyScript>();
enemyScript_.SetDamageFilter(DamageFilter);
shield_ = GetComponentInChildren <ShieldScript>();
shield_.gameObject.SetActive(false);
}
private void Start()
{
movable_ = GetComponent <IMovableActor>();
senses_ = GetComponent <ISensingActor>();
senses_.SetLookForPlayerLoS(true, maxDistance: 20);
me_ = GetComponent <IEnemy>();
physicsActor_ = GetComponent <IPhysicsActor>();
bulletPool_ = new List <GameObjectPool>()
{
SceneGlobals.Instance.ElfIceArrowProjectilePool, SceneGlobals.Instance.ElfFireArrowProjectilePool
};
triggerActions = new List <Func <Vector3, IEffect> >()
{
IceArrowEffect, FireArrowEffect
};
audioManager_ = SceneGlobals.Instance.AudioManager;
StartCoroutine(AI());
}
public void SetOwner(IPhysicsActor forceReceiver) => forceReceiver_ = forceReceiver;
public void SetOwner(IPhysicsActor _)
{
}
public void AddActor(IPhysicsActor actor)
{
this.physicsSpace.Add(actor.SpaceObject);
}
/// <summary>
/// Message handler for all incoming messages.
/// </summary>
/// <param name="message">Incoming message</param>
/// <exception cref="ArgumentException">Thrown if a <see cref="MessageType"/> is not handled properly."/></exception>
public override bool ExecuteMessage(IMessage message)
{
switch (message.Type)
{
case MessageType.GetPhysicsScene:
{
var getPhysSceneMsg = message as MsgGetPhysicsScene;
message.TypeCheck(getPhysSceneMsg);
getPhysSceneMsg.PhysicsScene = this.physicsScene;
}
return(true);
case MessageType.AddEntityToPhysicsScene:
{
var msgAddEntity = message as MsgAddEntityToPhysicsScene;
message.TypeCheck(msgAddEntity);
if (msgAddEntity.EntityID != QSGame.UniqueIDEmpty &&
msgAddEntity.Actor != null)
{
AddActor(msgAddEntity.EntityID, msgAddEntity.Actor);
}
}
return(true);
case MessageType.RemoveEntityFromPhysicsScene:
{
var remPhysMsg = message as MsgRemoveEntityFromPhysicsScene;
message.TypeCheck(remPhysMsg);
if (remPhysMsg.EntityID != QSGame.UniqueIDEmpty)
{
IPhysicsActor actor;
if (this.actors.TryGetValue(remPhysMsg.EntityID, out actor))
{
RemoveActor(remPhysMsg.EntityID, actor);
}
}
}
return(true);
case MessageType.BeginPhysicsFrame:
{
var msgBeginFrame = message as MsgBeginPhysicsFrame;
message.TypeCheck(msgBeginFrame);
// Begin next physics frame. If not enough time has elapsed since the last
// physics frame this will do nothing this frame.
msgBeginFrame.FrameBegan = this.physicsScene.BeginFrame(msgBeginFrame.GameTime);
}
return(true);
case MessageType.EndPhysicsFrame:
{
var msgEndFrame = message as MsgEndPhysicsFrame;
message.TypeCheck(msgEndFrame);
// Wait for previous physics frame to finish.
msgEndFrame.FrameEnded = this.physicsScene.EndFrame();
}
return(true);
case MessageType.SetGravity:
{
var msgSetGrav = message as MsgSetGravity;
message.TypeCheck(msgSetGrav);
this.physicsScene.Gravity = msgSetGrav.Gravity;
}
return(true);
case MessageType.GetGravity:
{
var msgGetGrav = message as MsgGetGravity;
message.TypeCheck(msgGetGrav);
msgGetGrav.Gravity = this.physicsScene.Gravity;
}
return(true);
case MessageType.SetPhysicsTimeStep:
{
var msgSetPhysStep = message as MsgSetPhysicsTimeStep;
message.TypeCheck(msgSetPhysStep);
this.physicsScene.SetPhysicsTimeStep(msgSetPhysStep.TimeStep);
}
return(true);
case MessageType.GetPhysicsActor:
{
var msgGetActor = message as MsgGetPhysicsActor;
message.TypeCheck(msgGetActor);
Debug.Assert(msgGetActor.UniqueTarget != QSGame.UniqueIDEmpty, "You must specify a target entity ID when sending the MsgGetPhysicsActor message.");
IPhysicsActor actor = null;
if (this.actors.TryGetValue(msgGetActor.UniqueTarget, out actor))
{
msgGetActor.Actor = actor;
}
}
return(true);
case MessageType.SetActorToCollisionGroup:
{
var msgSetCollGroup = message as MsgSetActorToCollisionGroup;
message.TypeCheck(msgSetCollGroup);
if (msgSetCollGroup.Actor.SpaceObject is Entity)
{
var entity = msgSetCollGroup.Actor.SpaceObject as Entity;
entity.CollisionInformation.CollisionRules.Group = GetCollisionGroup(msgSetCollGroup.GroupType);
}
else if (msgSetCollGroup.Actor.SpaceObject is BroadPhaseEntry)
{
var entry = msgSetCollGroup.Actor.SpaceObject as BroadPhaseEntry;
entry.CollisionRules.Group = GetCollisionGroup(msgSetCollGroup.GroupType);
}
}
return(true);
case MessageType.AddPhysicsToModelViewer:
{
var msgAddPhys = message as MsgAddPhysicsToModelViewer;
message.TypeCheck(msgAddPhys);
Debug.Assert(msgAddPhys.SpaceObject != null, "You cannot add a null object to the model viewer.");
AddSpaceObjectForModelViewer(msgAddPhys.SpaceObject);
}
return(true);
default:
return(false);
}
}
public QSBody(IPhysicsActor actor)
: base()
{
this.actor = actor;
this.additionalForce = Vector3.Zero;
}
