/// <summary>
/// Send a message directly to an Entity through this method.
/// This function MUST be called only from QSGame, otherwise it will never mark the message properly for release
/// and it will leak memory.
/// </summary>
/// <param name="message">Message to send</param>
/// <returns>Returns true if message was handled</returns>
public virtual bool ExecuteMessage(IMessage message)
{
switch (message.Type)
{
case MessageType.GetName:
{
MsgGetName msgGetName = message as MsgGetName;
message.TypeCheck(msgGetName);
msgGetName.Name = this.name;
}
break;
case MessageType.GetParentID:
{
MsgGetParentID msgGetID = message as MsgGetParentID;
message.TypeCheck(msgGetID);
if (this.parentEntity != null)
{
msgGetID.ParentEntityID = this.parentEntity.UniqueID;
}
}
break;
case MessageType.SetPosition:
{
MsgSetPosition setPositionMsg = message as MsgSetPosition;
message.TypeCheck(setPositionMsg);
this.Position = setPositionMsg.Position;
}
break;
case MessageType.ModifyPosition:
{
MsgModifyPosition modPosMsg = message as MsgModifyPosition;
message.TypeCheck(modPosMsg);
this.Position += modPosMsg.Position;
}
break;
case MessageType.GetPosition:
{
MsgGetPosition getPosMsg = message as MsgGetPosition;
message.TypeCheck(getPosMsg);
getPosMsg.Position = this.position;
}
break;
case MessageType.SetRotation:
{
MsgSetRotation setRotMsg = message as MsgSetRotation;
message.TypeCheck(setRotMsg);
this.Rotation = setRotMsg.Rotation;
}
break;
case MessageType.ModifyRotation:
{
MsgModifyRotation modRotMsg = message as MsgModifyRotation;
message.TypeCheck(modRotMsg);
this.Rotation *= modRotMsg.Rotation;
}
break;
case MessageType.GetRotation:
{
MsgGetRotation getRotMsg = message as MsgGetRotation;
message.TypeCheck(getRotMsg);
getRotMsg.Rotation = this.rotation;
}
break;
case MessageType.GetVectorForward:
{
MsgGetVectorForward getVectorMsg = message as MsgGetVectorForward;
message.TypeCheck(getVectorMsg);
getVectorMsg.Forward = this.rotation.Forward;
}
break;
case MessageType.GetVectorUp:
{
MsgGetVectorUp getVectorMsg = message as MsgGetVectorUp;
message.TypeCheck(getVectorMsg);
getVectorMsg.Up = this.rotation.Up;
}
break;
case MessageType.GetVectorRight:
{
MsgGetVectorRight getVectorMsg = message as MsgGetVectorRight;
message.TypeCheck(getVectorMsg);
getVectorMsg.Right = this.rotation.Right;
}
break;
case MessageType.LookAtPosition:
{
MsgLookAtPosition setPositionMsg = message as MsgLookAtPosition;
message.TypeCheck(setPositionMsg);
this.LookAt(setPositionMsg.Position);
}
break;
case MessageType.Pitch:
{
MsgModifyPitch camPitchMsg = message as MsgModifyPitch;
message.TypeCheck(camPitchMsg);
Pitch(camPitchMsg.PitchAmount);
}
break;
case MessageType.Yaw:
{
MsgModifyYaw camYawMsg = message as MsgModifyYaw;
message.TypeCheck(camYawMsg);
Yaw(camYawMsg.YawAmount);
}
break;
case MessageType.YawWorldUp:
{
MsgModifyYawWorldUp camYawMsg = message as MsgModifyYawWorldUp;
message.TypeCheck(camYawMsg);
YawAroundWorldUp(camYawMsg.YawAmount);
}
break;
case MessageType.SetParent:
{
MsgSetParent msgSetParent = message as MsgSetParent;
message.TypeCheck(msgSetParent);
SetParent(msgSetParent.ParentEntity);
}
break;
case MessageType.RemoveChild:
{
MsgRemoveChild msgRemChild = message as MsgRemoveChild;
message.TypeCheck(msgRemChild);
RemoveChild(msgRemChild.Child);
}
break;
case MessageType.ParentRemoved:
{
MsgParentRemoved msgParentRem = message as MsgParentRemoved;
message.TypeCheck(msgParentRem);
if (parentEntity == msgParentRem.Parent)
{
SetParent(null);
}
}
break;
case MessageType.ParentAdded:
{
MsgParentAdded msgParentAdded = message as MsgParentAdded;
message.TypeCheck(msgParentAdded);
SetParent(msgParentAdded.Parent);
}
break;
case MessageType.ChildRemoved:
{
MsgChildRemoved msgChildRem = message as MsgChildRemoved;
message.TypeCheck(msgChildRem);
if (msgChildRem.Child != null)
{
this.children.Remove(msgChildRem.Data.UniqueID);
}
}
break;
case MessageType.ChildAdded:
{
MsgChildAdded msgChildAdd = message as MsgChildAdded;
message.TypeCheck(msgChildAdd);
if (msgChildAdd.Child != null && msgChildAdd.Child != this)
{
this.children.Add(msgChildAdd.Data.UniqueID, msgChildAdd.Child);
}
}
break;
default:
return(SendMessageThroughComponents(message));
}
// For messages handled directly by the Entity but aren't Request Protocol,
// we still pass them to the Entity's components in case those components care.
if (message.Protocol != MessageProtocol.Request)
{
return(SendMessageThroughComponents(message));
}
return(true);
}
/// <summary>
/// Message handler for messages meant only for the scene manager.
/// </summary>
/// <param name="message">Incoming message</param>
/// <exception cref="ArgumentException">Thrown if a <see cref="MessageType"/> is not handled properly."/></exception>
public bool ExecuteMessage(IMessage message)
{
switch (message.Type)
{
case MessageType.RemoveEntity:
{
MsgRemoveEntity remEntityMsg = message as MsgRemoveEntity;
message.TypeCheck(remEntityMsg);
if (remEntityMsg.EntityID != QSGame.UniqueIDEmpty)
{
BaseEntity entity;
if (this.entities.TryGetValue(remEntityMsg.EntityID, out entity))
{
ShutdownEntity(entity);
}
}
}
return(true);
case MessageType.GetEntityIDList:
{
MsgGetEntityIDList msgGetEntityIDs = message as MsgGetEntityIDList;
message.TypeCheck(msgGetEntityIDs);
msgGetEntityIDs.EntityIDList = new Int64[this.entities.Count];
this.entities.Keys.CopyTo(msgGetEntityIDs.EntityIDList, 0);
}
return(true);
case MessageType.SetControlledEntity:
{
MsgSetControlledEntity msgSetControlled = message as MsgSetControlledEntity;
message.TypeCheck(msgSetControlled);
Int64 oldControlledEntity = this.controlledEntity;
this.controlledEntity = msgSetControlled.ControlledEntityID;
// Was there a change
if (oldControlledEntity != this.controlledEntity)
{
if (oldControlledEntity != QSGame.UniqueIDEmpty)
{
MsgRemoveChild msgRemoveChild = ObjectPool.Aquire <MsgRemoveChild>();
msgRemoveChild.Child = this.sceneMgrRootEntity;
msgRemoveChild.UniqueTarget = oldControlledEntity;
this.Game.SendMessage(msgRemoveChild);
MsgSetIsControlled msgControlled = ObjectPool.Aquire <MsgSetIsControlled>();
msgControlled.Controlled = false;
msgControlled.UniqueTarget = oldControlledEntity;
this.Game.SendMessage(msgControlled);
}
// If the new ID is empty, there is no more controlled entity
if (this.controlledEntity == QSGame.UniqueIDEmpty)
{
CreateAndStartFreeMovingCamera();
}
else
{
MsgSetIsControlled msgControlled = ObjectPool.Aquire <MsgSetIsControlled>();
msgControlled.Controlled = true;
msgControlled.UniqueTarget = this.controlledEntity;
this.Game.SendMessage(msgControlled);
BaseEntity controlledEntity;
if (entities.TryGetValue(this.controlledEntity, out controlledEntity))
{
CreateAndStartArcBallCamera();
}
}
}
}
return(true);
case MessageType.GetControlledEntity:
{
MsgGetControlledEntity msgGetControlled = message as MsgGetControlledEntity;
message.TypeCheck(msgGetControlled);
msgGetControlled.ControlledEntityID = this.controlledEntity;
}
return(true);
case MessageType.GetEntityByID:
{
MsgGetEntityByID msgGetEntity = message as MsgGetEntityByID;
message.TypeCheck(msgGetEntity);
BaseEntity entity;
if (this.entities.TryGetValue(msgGetEntity.EntityID, out entity))
{
msgGetEntity.Entity = entity;
}
}
return(true);
case MessageType.GetFogSettings:
{
if (this.activeScene != null)
{
MsgGetFogSettings msgGetFog = message as MsgGetFogSettings;
message.TypeCheck(msgGetFog);
msgGetFog.Settings = this.activeScene.FogSettings;
}
}
return(true);
default:
return(false);
}
}
