/// <summary>
/// given a messageToSend, a receiver, a sender and any time delay, this function
/// routes the messageToSend to the correct entity (if no delay) or stores it
/// in the messageToSend queue to be dispatched at the correct time. Entities referenced
/// by iD.
/// </summary>
public static void DispatchMessage <T>(double delay, int sender,
int otherReceiver, Message message,
T additionalInfo = default(T))
{
//get the reciever
BaseEntityInfo receiver = EntityMgr.entityManager.GetEntityFromID(otherReceiver);
//make sure the Receiver is valid
if (receiver == null)
{
return;
}
//create the telegram
var telegram = new Telegram <object>(0, sender, otherReceiver, message, additionalInfo);
//if there is no delay, route telegram immediately
if (delay <= 0.0)
{
//send the telegram to the recipient
Discharge(receiver, telegram);
}
//else calculate the time when the telegram should be dispatched
else
{
double CurrentTime = Clock.Current();
telegram.DispatchTime = CurrentTime + delay;
//and put it in the queue
priorityQueue.Add(telegram);
}
}
private IEntity MakePlayer(BaseEntityInfo info, ActorImplNode actorMain)
{
IEntity entity = null;
if (info.CombatType == eCombatType.PC)
{
entity = new PC(info, actorMain);
}
else if (info.CombatType == eCombatType.Monster)
{
entity = new Monster(info, actorMain);
}
else if (info.CombatType == eCombatType.Hero)
{
entity = new Hero(info, actorMain);
}
if (entity != null)
{
entity.Initialize();
//actorMain.InitPlayer(player);
}
return(entity);
}
/// <summary>
/// this method is utilized by DispatchMessage or DispatchDelayedMessages.
/// This method calls the messageToSend handling member function of the receiving
/// entity, receiver, with the newly created telegram
/// </summary>
/// <param name="receiver"></param>
/// <param name="messageToSend"></param>
private static void Discharge <T>(BaseEntityInfo receiver, Telegram <T> message)
{
if (!receiver.HandleMessage(message))
{
//telegram could not be handled
}
}
public IEntity CreateEnterPlayer(BaseEntityInfo entityEnterInfo)
{
BaseEntityInfo info = null;
if (entityEnterInfo.CombatType == eCombatType.PC)
{
PCInfo pcinfo = entityEnterInfo as PCInfo;
info = pcinfo;
//info.AssetInfo.sp = pcinfo.SpriteData.assetName;
}
else if (entityEnterInfo.CombatType == eCombatType.Monster)
{
MonsterInfo monsterInfo = entityEnterInfo as MonsterInfo;
info = monsterInfo;
//info.AssetInfo.Path = monsterInfo.SpriteData.spriteName;
}
//info.ActorAsset.Pos = playerEnterInfo.SyncState._syncPos._pos;
//Vector3 dir = LEMath.RadianToDir3(LEMath.ByteToRadian(playerEnterInfo.SyncState._syncPos._direction));
//info.ActorAsset.Rotate = Quaternion.LookRotation(dir);
IEntity actor = MakePlayer(info);
return(actor);
}
public IEntity CreatePlayer(BaseEntityInfo info, AnimationEventStates animationEventStates)
{
LevelBase level = Global.NodeGraphMgr.WorldLevelRoot.ActorLevel;
ActorImplNode actorMain = Global.FactoryMgr.CreatePoolComponent <ActorImplNode>(ePath.Actor, info.AssetInfo.SpriteName,
info.AssetInfo.Position, info.AssetInfo.Rotation, level.transform);
//actorMain.Initialize(playMakerFsm, animationEventStates);
ActorRoot actor = new ActorRoot();
actorMain.Lock();
actor.AttachChild(actorMain);
IEntity entity = MakePlayer(info, actorMain);
if (info.CombatType == eCombatType.Hero)
{
m_hero = entity as Hero;
}
else if (info.CombatType == eCombatType.Monster)
{
}
AttachActor(level, actor);
return(entity);
}
public BaseEntity(BaseEntityInfo info, ActorImplNode actorMain)
{
m_actorMain = actorMain;
m_entityInfo = info;
m_messageListener = new EntityMessageListener(this);
EntityInfo.Stat.CalculateStat();
//actorMain.Speed = MoveSpeed;
}
private void SelectActorView(ActorRoot actorRootLook, BaseEntityInfo actorViewInfo)
{
m_actorRootLook = actorRootLook;
m_animationSpeed = 1.0f;
foreach (ISubCharacterViewer subCharacterViewer in m_characterViewerDic.Values)
{
subCharacterViewer.ChangeActor(m_actorRootLook);
}
}
public IEntity MakeActor_Editor(BaseEntityInfo info, AnimationEventStates animationEventStates)
{
IEntity actor = m_gameRepository.CreatePlayer(info, animationEventStates);
if (actor != null)
{
if (info.IsUser)
{
AudioListenerSingle.Instance.transform.SetParent(actor.Main.transform, false);
}
else
{
m_gameRepository.Insert(actor);
}
}
return(actor);
}
private void OnGUICharacterViewInfoList()
{
GUI.enabled = Application.isPlaying;
EditorGUILayout.BeginVertical("box");
{
GUI.color = Color.cyan;
eActorEditorType newState = (eActorEditorType)GUILayout.Toolbar((int)m_actorEditorType, System.Enum.GetNames(typeof(eActorEditorType)));
GUI.color = Color.white;
if (m_actorEditorType != newState)
{
m_actorEditorType = newState;
RefreshCharacterList();
}
m_lookDBInfoScrollPosition = EditorGUILayout.BeginScrollView(m_lookDBInfoScrollPosition, GUILayout.MinHeight(160));
{
for (int i = 0; i < m_actorInfoList.Count; ++i)
{
BaseEntityInfo actorInfo = m_actorInfoList[i];
bool selected = i == GetSelectedLookIndex(m_actorEditorType);
EditorGUIUtil.Label(actorInfo.Name, selected, 0, 2, EditorGUIUtil.GetSelectedTextColorByEditorSkin(selected));
if (EditorGUIEventUtil.IsLastRectClicked())
{
CreateActorBySelectLookID(i, m_actorEditorType);
}
}
}
EditorGUILayout.EndScrollView();
GUI.enabled = true;
string play = Application.isPlaying == false ? "Play" : "Stop";
Color color = Application.isPlaying == false ? Color.green : Color.red;
GUI.color = color;
if (GUILayout.Button(play, GUILayout.Height(25)))
{
playLookDeveloper = true;
}
GUI.color = Color.white;
}
EditorGUILayout.EndVertical();
}
/// <summary>
/// This function dispatches any telegrams with a timestamp that has
/// expired. Any dispatched telegrams are removed from the queue as it
/// sends out any delayed messages. This method is called each time through
/// the main game loop.
/// </summary>
public static void DispatchDelayedMessages()
{
double CurrentTime = Clock.Current();
//now peek at the queue to see if any telegrams need dispatching.
//remove all telegrams from the front of the queue that have gone
//past their sell by date
while (!(priorityQueue.Count == 0) &&
(priorityQueue.ElementAt(0).DispatchTime < CurrentTime) &&
(priorityQueue.ElementAt(0).DispatchTime > 0))
{
//read the telegram from the front of the queue
var telegram = priorityQueue.ElementAt(0);
//find the recipient
BaseEntityInfo receiver = EntityMgr.entityManager.GetEntityFromID(telegram.Receiver);
//send the telegram to the recipient
Discharge(receiver, telegram);
//remove it from the queue
priorityQueue.Remove(priorityQueue.ElementAt(0));
}
}
public Entity.Hero CreateHero(BaseEntityInfo info)
{
//Vector3 dir = LEMath.RadianToDir3(LEMath.ByteToRadian(playerEnterInfo.SyncState._syncPos._direction));
//PCInfo pcInfo = new PCInfo(eCombatType.Hero, playerEnterInfo.Name, playerEnterInfo.NetID, playerEnterInfo.TableID);
//{
// pcInfo.ActorAsset.Pos = playerEnterInfo.SyncState._syncPos._pos;
// pcInfo.ActorAsset.Rotate = Quaternion.LookRotation(dir);
// pcInfo.ActorAsset.Path = pcInfo.SpriteData.assetName;
// pcInfo.BattleTeam = playerEnterInfo.CombatTeam;
// pcInfo.StartTick = playerEnterInfo.SyncState._startTick;
//}
//Player.Hero hero = MakePlayer(pcInfo) as Player.Hero;
//PlayerButtonController playerButtonController = new PlayerButtonController();
//playerButtonController.InitActor(hero, hero.NetID);
//Global.InputMgr.AddController(playerButtonController);
//Global.CameraMgr.SetHero(hero.Main.transform);
return(null);
}
private IEnumerable <Field> GetAuditFields(BaseEntityInfo item)
{
var createdByUser = item.CreatedByUser(CurrentPortalId);
var lastModifiedByUser = item.LastModifiedByUser(CurrentPortalId);
return(new List <Field>
{
new Field(DefaultMetadataNames.Created)
{
DisplayName = LocalizationHelper.GetString("Field" + DefaultMetadataNames.Created + ".DisplayName"),
Type = typeof(DateTime),
Value = item.CreatedOnDate,
StringValue = item.CreatedOnDate.ToString()
},
new Field(DefaultMetadataNames.CreatedBy)
{
DisplayName = LocalizationHelper.GetString("Field" + DefaultMetadataNames.CreatedBy + ".DisplayName"),
Type = typeof(int),
Value = item.CreatedByUserID,
StringValue = createdByUser != null ? createdByUser.DisplayName : ""
},
new Field(DefaultMetadataNames.Modified)
{
DisplayName = LocalizationHelper.GetString("Field" + DefaultMetadataNames.Modified + ".DisplayName"),
Type = typeof(DateTime),
Value = item.LastModifiedOnDate,
StringValue = item.LastModifiedOnDate.ToString()
},
new Field(DefaultMetadataNames.ModifiedBy)
{
DisplayName = LocalizationHelper.GetString("Field" + DefaultMetadataNames.ModifiedBy + ".DisplayName"),
Type = typeof(int),
Value = item.LastModifiedByUserID,
StringValue = lastModifiedByUser != null ? lastModifiedByUser.DisplayName : ""
}
});
}
public Npc(BaseEntityInfo info, ActorImplNode actorMain) : base(info, actorMain)
{
}
public Monster(BaseEntityInfo info, ActorImplNode actorMain) : base(info, actorMain)
{
}
private void CreateActorBySelectLookID(int lookIndex, eActorEditorType actorEditorType)
{
int selectedLookIndex = GetSelectedLookIndex(actorEditorType);
if (selectedLookIndex == lookIndex)
{
return;
}
SetSelectedLookIndex(actorEditorType, lookIndex);
BaseEntityInfo actorInfo = null;
if (lookIndex >= 0 && lookIndex < m_actorInfoList.Count)
{
actorInfo = m_actorInfoList[lookIndex];
}
else
{
return;
}
if (m_actorRootLook != null)
{
Global.GameMgr.DestroyCombat(m_actorRootLook.Uid);
m_actorRootLook = null;
if (m_currentSubCharacterViewer != null)
{
m_currentSubCharacterViewer.ChangeActor(null);
}
}
//if (m_hero && actorInfo is PCInfo)
//{
// EntityAssetInfo entityAssetInfo = new EntityAssetInfo(IDFactory.GenerateActorID(), eLayerMask.Actor);
// entityAssetInfo.SpriteName = actorInfo.Entity.SpriteName;
// entityAssetInfo.Path = actorInfo.Entity.Path;
// PCInfo pcInfo = new PCInfo(eNodeType.Hero, entityAssetInfo, entityAssetInfo.ID, null);
// m_actorRootLook = Global.GameMgr.MakePlayer(pcInfo, ePath.MapActorAsset);
// SelectActorView(m_actorRootLook, pcInfo);
//}
//else
//{
// m_actorRootLook = Global.GameMgr.MakeActor(actorInfo, ePath.MapActorAsset);
// SelectActorView(m_actorRootLook, actorInfo);
//}
if (m_playerButtonController == null)
{
m_playerButtonController = new PlayerButtonController();
Global.InputMgr.AddController(m_playerButtonController);
}
//m_playerButtonController.InitActor(m_actorRootLook);
Global.CameraMgr.SetTargetActor(m_actorRootLook);
UpdateFSMStateList();
Repaint();
}
