public virtual void OnExit()
{
if (QLogger.CanLogInfo)
{
QLogger.LogInfo("OnExit called for " + this.GetType());
}
}
public virtual void OnPushedToFront()
{
if (QLogger.CanLogInfo)
{
QLogger.LogInfo("OnPushedToFront called for " + this.GetType());
}
}
public void EquipWeapon(GameObject WeaponObject)
{
GameObject = WeaponObject;
Animator = GameObject.GetComponent <Animator>();
Inputs = GameObject.GetComponent <WeaponInputs>();
Common = new WeaponCommon(this);
controller = new FSMController <WeaponController, eStates>(this);
controller.RegisterState(eStates.Idle, new WeaponIdle());
controller.RegisterState(eStates.Shoot, new WeaponShoot());
controller.RegisterState(eStates.Reload, new WeaponReload());
controller.RegisterState(eStates.Recoil, new WeaponRecoil());
controller.AddMapping(eStates.Idle, eStates.Shoot, eStates.Reload);
controller.AddMapping(eStates.Shoot, eStates.Recoil);
controller.AddMapping(eStates.Reload, eStates.Idle, eStates.Shoot);
controller.AddMapping(eStates.Recoil, eStates.Idle, eStates.Shoot, eStates.Reload);
controller.SetLogToGUI(true, 2);
controller.SetState(eStates.Idle);
Common.Init();
// sanity checks
QLogger.Assert(Inputs.magCapacity > 0);
QLogger.Assert(Inputs.reloadTime > 0 && Inputs.recoilTime > 0 && Inputs.accuracy > 0);
// if ( Inputs.shotType == eShotType.BURST )
// QLogger.Assert ( Inputs.burstBulletCount > 1 );
QLogger.Assert(Inputs.damage > 0 && Inputs.range > 0);
QLogger.Assert(Inputs.muzzlePositionAndDirection != null);
}
public override void Update()
{
if (Main.Instance.uIManager == null)
{
GameObject uiManagerGo = GameObject.Instantiate(ResourceManager.Instance.LoadAsset <UnityEngine.Object> ("UI/UiManager")) as GameObject;
if (uiManagerGo == null)
{
QLogger.LogErrorAndThrowException("UiManager was not instantiated");
}
Main.Instance.uIManager = uiManagerGo.GetComponent <UIManager>();
if (Main.Instance.uIManager == null)
{
QLogger.LogErrorAndThrowException("UiManager script was not instantiated");
}
if (QLogger.CanLogInfo)
{
QLogger.LogInfo("UI manager was instantiated");
}
ResourceManager.Instance.LoadLevel("Lobby", true,
delegate()
{
Main.Instance.gameStateManager.SetGameState(GameStateManager.GameStates.Frontend, null);
}, true
);
}
}
public virtual void Reset()
{
if (QLogger.CanLogInfo)
{
QLogger.LogInfo("Reset called for " + this.GetType());
}
}
//void m_TransDispatcher_SyncCompleted(object sender, SyncItemEventArgs<TransactionItem> e)
//{
// //TODO:
// //e.Item.SyncExpired();
//}
public void LoadTopicConfig()
{
var config = QueueServerConfig.GetConfig();
var items = config.RemoteQueueSettings;
foreach (QueueServerConfigItem item in items)
{
//var prop = new QProperties(item.QueueName, item.IsTrans, (CoverMode)item.CoverMode);
if (item.IsTopic)
{
var publisher = new TopicPublisher()
{
TopicId = item.QueueName,
TopicName = item.QueueName
};
string[] strsubs = item.TargetPath.SplitTrim('|');
foreach (var s in strsubs)
{
publisher.AddSubscriber(TopicSubscriber.Create(s, item.QueueName));
}
var mq = AddQueue(item);
QLogger.InfoFormat("Queue Topic Added: {0}", item.Print());
}
}
}
/// <summary>
/// OnStop
/// </summary>
protected override void OnStop()
{
base.OnStop();
AgentManager.StopController();
QLogger.InfoFormat("TcpServerListener stoped :{0}", this.Settings.HostName);
}
// Use this for initialization
void Start()
{
QLogger.SetLoggingLevel(QLogger.Level.Info);
gameStateManager = new GameStateManager();
gameStateManager.SetGameState(GameStateManager.GameStates.Loading, null);
}
public IQueueItem AddQueue(QProperties prop, out MQueue mq)
{
if (MQ.ContainsKey(prop.QueueName))
{
//if (prop.ReloadOnStart)
//{
// MQueue q = new MQueue(prop);
// MQ[prop.QueueName] = q;
// mq = q;
//}
//else
//{
// mq = MQ[prop.QueueName];
//}
mq = MQ[prop.QueueName];
return(QueueItem.Ack(MessageState.AllreadyExists, QueueCmd.AddQueue, "AllreadyExists, Name: " + prop.QueueName, null));
}
//if (prop.IsDbQueue)
//{
// AddDbQueue(prop.QueueName, prop.IsTrans);
//}
MQueue queue = new MQueue(prop);
//LoadQueue(queue, prop);
MQ[prop.QueueName] = queue;
mq = queue;
QLogger.InfoFormat("AddQueue : {0}", prop.Print());
//return MessageState.Ok;
return(QueueItem.Ack(MessageState.Ok, QueueCmd.AddQueue));
}
private void handleGetCharactersEvent(bool result, Dictionary <string, CharacterData> data)
{
_characterSelectionManager.GetCharactersEvent -= handleGetCharactersEvent;
if (!result)
{
return;
}
try
{
_characters = data;
_characterSlots.Clear();
foreach (var character in _characters)
{
var instance = Instantiate(_characterSlotPFB);
instance.gameObject.name = character.Key;
instance.transform.SetParent(_container, false);
instance.SlotClickEvent += handleSlotClickEvent;
instance.Initialize(character.Value);
_characterSlots.Add(character.Key, instance);
}
}
catch (Exception ex)
{
QLogger.LogException(ex);
}
}
/// <summary>Creates Message Queuing queue by specified properties.</summary>
/// <param name="prop">The queue properties. </param>
/// <returns>A <see cref="T:Nistec.Messaging.MQueue"></see> that represents the new queue.</returns>
public MQueue AddQueue(IQProperties prop)
{
//prop.IsValid(lockKey);
if (MQ.ContainsKey(prop.QueueName))
{
//if (prop.ReloadOnStart)
//{
// MQueue q = new MQueue(prop);
// MQ[prop.QueueName] = q;
// return q;
//}
return((MQueue)MQ[prop.QueueName]);
}
//if (prop.IsDbQueue)
//{
// AddDbQueue(prop.QueueName, prop.IsTrans);
//}
MQueue queue = new MQueue(prop);
//LoadQueue(queue,prop);
MQ[prop.QueueName] = queue;
QLogger.InfoFormat("AddQueue : {0}", prop.QueueName);
return(queue);
}
public TransStream GetQueueReport(IQueueMessage message)
{
MQueue queue = Get(message.Host);
if (queue == null)
{
var ack = new QueueItem()//MessageState.QueueNotFound, "QueueNotFound: " + message.Host, null, message.Host);
{
MessageState = MessageState.QueueNotFound,
Label = "QueueNotFound: " + message.Host,
Host = message.Host
};
QLogger.InfoFormat("QueueController GetQueueReport QueueNotFound : {0}", message.Host);
return(ack.ToTransStream());
}
var report = queue.GetReport();
string result = null;
if (report != null)
{
result = Nistec.Serialization.JsonSerializer.Serialize(report);
}
var item = new QueueItem()//MessageState.Ok, result, null, message.Host);
{
MessageState = MessageState.Ok,
Label = result,
Host = message.Host
};
item.SetBody(report);
QLogger.InfoFormat("QueueController GetQueueReport : {0}", result);
return(item.ToTransStream());
}
/// <summary>
/// OnStop
/// </summary>
protected override void OnStop()
{
base.OnStop();
QLogger.InfoFormat("PipeServerManager stoped :{0}", PipeName);
//AgentManager.Queue.Stop();
}
public virtual void OnPusedBack()
{
if (QLogger.CanLogInfo)
{
QLogger.LogInfo("OnPushedBack called for " + this.GetType());
}
}
public void AddMapping(T state1, T state2)
{
if (GetKeyValueMap(state1, state2) != null)
{
QLogger.LogErrorAndThrowException("We already have a mapping between " + state1.ToString() + state2.ToString());
}
stateMapping.Add(new MyKeyValuePair <T, T>(state1, state2));
}
public QueueSettings()
{
//XmlTable table = NetConfig.GetCustomConfig("QueueSettings");
var section = QueueServerConfig.GetConfig();
var table = section.QueueSettings;
if (table == null)
{
throw new ArgumentException("Can not load XmlTable config");
}
RootPath = table.Get <string>("RootPath", DefaultRootPath);
QueuesPath = Path.Combine(RootPath, QueuesFolder);
MaxSize = table.Get <long>("MaxSize", QueueDefaults.DefaultQueueMaxSize);
DefaultExpiration = table.Get <int>("DefaultExpiration", 30);
SyncInterval = table.Get <int>("SyncInterval", 60);
InitialCapacity = table.Get <int>("InitialCapacity", QueueDefaults.InitialCapacity);
EnableLog = table.Get <bool>("EnableLog", false);
ReceiveBufferSize = table.Get <int>("ReceiveBufferSize", 8192);
SendBufferSize = table.Get <int>("SendBufferSize", 8192);
QueueConfigFile = table.Get("QueueConfigFile");
EnableFileWatcher = table.Get <bool>("EnableFileWatcher", false);
TaskerTimeout = table.Get <int>("TaskerTimeout", 60);
EnableAsyncTask = table.Get <bool>("EnableAsyncTask", true);
EnableMailerQueue = table.Get <bool>("EnableMailerQueue", false);
EnableQueueManager = table.Get <bool>("EnableQueueManager", false);
//EnableQueueController = table.Get<bool>("EnableQueueController", false);
//EnableTopicController = table.Get<bool>("EnableTopicController", false);
EnableJournalQueue = table.Get <bool>("EnableJournalQueue", false);
EnableDebugLog = table.Get <bool>("EnableDebugLog", false);
//LogMonitorCapacityLines = table.Get<int>("LogMonitorCapacityLines", 1000);
EnablePipeConsumer = table.Get <bool>("EnablePipeConsumer", false);
EnableTcpConsumer = table.Get <bool>("EnableTcpConsumer", false);
EnableHttpConsumer = table.Get <bool>("EnableHttpConsumer", false);
EnablePipeProducer = table.Get <bool>("EnablePipeProducer", false);
EnableTcpProducer = table.Get <bool>("EnableTcpProducer", false);
EnableHttpProducer = table.Get <bool>("EnableHttpProducer", false);
EnableFolderListener = table.Get <bool>("EnableFolderListener", false);
EnableDbListener = table.Get <bool>("EnableDbListener", false);
EnableSizeHandler = table.Get <bool>("EnableSizeHandler", false);
EnablePerformanceCounter = table.Get <bool>("EnablePerformanceCounter", false);
QueueDefaults.DefaultExpiration = DefaultExpiration;
QueueDefaults.EnableLog = EnableLog;
QLogger.SetLogger(EnableLog, EnableDebugLog);
}
public void RegisterState(T key, FSMState state)
{
if (!typeof(T).IsEnum)
{
QLogger.LogErrorAndThrowException("TEnum must be an enum.");
}
if (statesDictionary.ContainsKey(key))
{
QLogger.LogErrorAndThrowException("Already contains key " + key.ToString());
}
statesDictionary.Add(key, state);
}
public void FireBullet(float accuracy)
{
QLogger.Assert(bulletsRemainingInMag > 0);
GameObject bullet = GameObject.Instantiate(inputs.bulletReference);
bullet.transform.position = inputs.muzzlePositionAndDirection.position;
bullet.transform.forward = inputs.muzzlePositionAndDirection.forward;
Bullet bulletScript = bullet.GetComponent <Bullet>();
QLogger.Assert(bulletScript != null);
bulletScript.Init(inputs.muzzlePositionAndDirection.forward, inputs.damage, inputs.range);
bulletsRemainingInMag--;
}
public void LoadQueueConfig()
{
var config = QueueServerConfig.GetConfig();
var items = config.RemoteQueueSettings;
foreach (QueueServerConfigItem item in items)
{
//var prop = new QProperties(item.QueueName, item.IsTrans, (CoverMode)item.CoverMode);
if (item.IsTopic == false)
{
var mq = AddQueue(item);
QLogger.InfoFormat("Queue Added: {0}", item.Print());
}
}
}
public PriorityPersistQueue(IQProperties qp)
: base(qp.QueueName)
{
int numProcs = Environment.ProcessorCount;
int concurrencyLevel = numProcs * 2;
int initialCapacity = 101;
QueueList = new ConcurrentDictionary <Ptr, IQueueItem>(concurrencyLevel, initialCapacity);
CommitMode = (CommitMode)(int)qp.CommitMode;
CoverMode = qp.Mode;
if (CoverMode == CoverMode.Persistent)
{
DbLiteSettings settings = new DbLiteSettings()
{
Name = qp.QueueName,
CommitMode = (CommitMode)(int)qp.CommitMode,
DbPath = AgentManager.Settings.QueuesPath
};
//settings.SetFast();
m_db = new PersistentBinary <IQueueItem>(settings);
//m_db = new PersistentDictionary(settings);
m_db.BeginLoading += M_db_BeginLoading;
m_db.LoadCompleted += M_db_LoadCompleted;
m_db.ErrorOcurred += M_db_ErrorOcurred;
m_db.ClearCompleted += M_db_ClearCompleted;
//m_db.ItemChanged += M_db_ItemChanged;
m_db.ItemLoaded = (item) =>
{
this.ReEnqueue(item);
};
if (qp.ReloadOnStart)
{
QLogger.InfoFormat("PriorityPersistQueue will load items to : {0}", qp.QueueName);
}
else
{
QLogger.InfoFormat("PriorityPersistQueue will clear all items from : {0}", qp.QueueName);
}
m_db.ReloadOrClearPersist(qp.ReloadOnStart);
}
}
public void Update()
{
//@todo find a better place for cheats
// @todo hard coded controls
if (Input.GetKeyDown(KeyCode.C))
{
QLogger.ShowOrHideGUI();
}
if (gameStateManager != null)
{
gameStateManager.Update();
}
if (uIManager != null)
{
uIManager.DoUpdate();
}
}
private void Send_Immediate(EventDetails evnt)
{
SuscribeListenerCallback actionListener;
listeners.TryGetValue(evnt.category, out actionListener);
if (actionListener != null)
{
actionListener(evnt.action, evnt.sender, evnt.context);
return;
}
if (QLogger.CanLogInfo)
{
QLogger.LogInfo(string.Format("GlobalEventsManager.Send found unhandled Event. [ Category: {0} Action: {1} Sender: {2} Context: {3} ]",
evnt.category, evnt.action, (evnt.sender == null ? "null" : evnt.sender.ToString()), (evnt.context == null ? "null" : evnt.context.ToString())));
}
}
public void QueueState(T newState, System.Object context)
{
if (currentState.HasValue && currentState.Value.Equals(newState))
{
if (QLogger.CanLogWarning)
{
QLogger.LogWarning(" Setting same state again " + newState.ToString());
}
return;
}
if (QLogger.CanLogInfo)
{
QLogger.LogInfo(string.Format("FSM:Queued \"{0}\" state ", newState));
}
nextState = newState;
contextForNextState = context;
}
/// <summary>Deletes a queue on a Message Queuing server.</summary>
/// <param name="queueName">The location of the queue to be deleted. </param>
public IQueueItem RemoveQueue(string queueName)
{
if (queueName == null)
{
throw new ArgumentNullException("queueName");
}
if (queueName.Length == 0)
{
throw new ArgumentException("InvalidParameter", "queueName");
}
//RemoveDbQueue(queueName);
MQueue queue;
bool removed = MQ.TryRemove(queueName, out queue);
QLogger.InfoFormat("RemoveQueue : {0}, {1}", queueName, removed);
return(QueueItem.Ack(removed?MessageState.Ok: MessageState.OperationFailed, QueueCmd.RemoveQueue, removed? "Queue was removed" : "Queue was not removed", null));
}
internal IQueueItem ExecGet(QueueMessage request)
{
try
{
MQueue Q = Get(request.Host);
if (Q == null)
{
throw new MessageException(MessageState.InvalidMessageHost, "message.Host is invalid " + request.Host);
}
switch (request.Command)
{
case QueueCmd.Dequeue:
return(Q.Dequeue());
case QueueCmd.DequeuePriority:
return(Q.Dequeue(request.Priority));
case QueueCmd.Peek:
return(Q.Peek());
case QueueCmd.PeekPriority:
return(Q.Peek(request.Priority));
}
}
catch (MessageException mex)
{
QLogger.ErrorFormat("ExecGet MessageException: " + mex.Message);
}
catch (ArgumentException ase)
{
QLogger.ErrorFormat("ExecGet ArgumentException: " + ase.Message);
}
catch (SerializationException se)
{
QLogger.ErrorFormat("ExecGet SerializationException: " + se.Message);
}
catch (Exception ex)
{
QLogger.ErrorFormat("ExecGet Exception: " + ex.Message);
}
return(null);
}
void SetNextState()
{
if (currentState.HasValue)
{
if (GetKeyValueMap(currentState.Value, nextState.Value) == null)
{
QLogger.LogErrorAndThrowException("There is no mapping between " + currentState.Value.ToString() + " and " + nextState.Value.ToString());
nextState = null;
return;
}
}
//set current to peviousState
previousState = currentState;
//exit previousState
if (previousState.HasValue)
{
if (QLogger.CanLogInfo)
{
QLogger.LogInfo(string.Format("FSM:On Exit called for \"{0}\" state ", previousState.Value));
}
statesDictionary[previousState.Value].OnExit();
}
//set currentState to Next
currentState = nextState;
//enter current state
if (currentState.HasValue)
{
if (QLogger.CanLogInfo)
{
QLogger.LogInfo(string.Format("FSM:On Enter called for \"{0}\" state ", currentState.Value));
}
statesDictionary[currentState.Value].OnEnter();
statesDictionary[currentState.Value].OnContext(contextForNextState /* this can be null if there is no context */);
}
//set nextState to Null
nextState = null;
contextForNextState = null;
}
public override void OnContext(System.Object context)
{
base.OnContext(context);
collisionProcessor = new CollisionProcessor();
GameObject voxelCharacter = GameObject.Instantiate(ResourceManager.Instance.LoadAsset <UnityEngine.Object> ("Characters/VoxelGirl/MainCharacter")) as GameObject;
if (voxelCharacter == null)
{
QLogger.LogErrorAndThrowException("VoxelGirl is not instantiated");
}
// Main.Instance.uIManager = uiManagerGo.GetComponent<UIManager>();
// if ( Main.Instance.uIManager == null ) QLogger.LogErrorAndThrowException ( "UiManager script was not instantiated");
player = new iPlayer();
CharacterController controller = new CharacterController();
controller.Init(voxelCharacter, player);
WeaponController weaponController = new WeaponController();
player.Init(controller, weaponController);
CollisionListener playerCollisionListener = voxelCharacter.GetComponentInChildren <CollisionListener>();
Core.QLogger.Assert(playerCollisionListener != null);
playerCollisionListener.Init(collisionProcessor.ProcessCollision, player);
cameraScript = GameObject.Find("ThirdPersonCamera").GetComponent <ThirdPersonCamera>();
cameraScript.SetCharacterToFollow(voxelCharacter.transform);
player.EquipWeapon(eInventoryItem.Pistol);
Core.Updater.Instance.FixedUpdater += FixedUpdate;
Core.Updater.Instance.LateUpdater += LateUpdate;
}
internal MessageState ExecSet(QueueMessage request)
{
try
{
if (request == null)
{
throw new ArgumentNullException("QueueManager.ExecSet message");
}
if (request.Host == null)// || message.Host.Count == 0)
{
throw new ArgumentNullException("QueueManager.ExecSet message.Host is invalid");
}
MQueue Q = Get(request.Host);
if (Q == null)
{
throw new MessageException(MessageState.InvalidMessageHost, "message.Host is invalid " + request.Host);
}
Q.Enqueue(request.GetQueueItem());
//TODO: DISTREBUTING TO HOSTS LIST
//foreach (var host in request.Host)
//{
// if (host.IsLocal)
// {
// MQueue Q = Get(host.HostName);
// if (Q == null)
// {
// throw new MessageException(MessageState.InvalidMessageHost, "message.Host is invalid " + message.Host);
// }
// Q.Enqueue(item);
// }
// else
// {
// //TODO:not supported
// throw new Exception("Host not IsLocal not supported!");
// }
//}
}
catch (MessageException mex)
{
QLogger.ErrorFormat("ExecSet MessageException: " + mex.Message);
return(MessageState.MessageError);
}
catch (ArgumentException ase)
{
QLogger.ErrorFormat("ExecSet ArgumentException: " + ase.Message);
return(MessageState.ArgumentsError);
}
catch (SerializationException se)
{
QLogger.ErrorFormat("ExecSet SerializationException: " + se.Message);
return(MessageState.SerializeError);
}
catch (Exception ex)
{
QLogger.ErrorFormat("ExecSet Exception: " + ex.Message);
return(MessageState.UnExpectedError);
}
return(MessageState.Ok);
}
/// <summary>
/// OnStart
/// </summary>
protected override void OnStart()
{
base.OnStart();
QLogger.InfoFormat("HttpServerListener started :{0}", this.Settings.HostName);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
int oldIndentLevel = EditorGUI.indentLevel;
label = EditorGUI.BeginProperty(position, label, property);
Rect contentPosition = EditorGUI.PrefixLabel(position, label);
if (position.height > 16f)
{
position.height = 16f;
EditorGUI.indentLevel += 1;
contentPosition = EditorGUI.IndentedRect(position);
contentPosition.y += 18f;
}
contentPosition.width *= 0.75f;
EditorGUI.indentLevel = 0;
SerializedProperty serObj = property.FindPropertyRelative("obj");
UnityEngine.Object obj = serObj.objectReferenceValue;
EditorGUI.PropertyField(contentPosition, serObj, GUIContent.none);
contentPosition.x += contentPosition.width;
contentPosition.width /= 3f;
EditorGUIUtility.labelWidth = 14f;
SerializedProperty pathObj = property.FindPropertyRelative("path");
//Debug.Log("Path:" + pathObj.stringValue);
SerializedProperty boolObj = property.FindPropertyRelative("overridePath");
bool overridePathGeneration = boolObj.boolValue;
bool enableModifications = true;
if (obj != null && !overridePathGeneration && enableModifications)
{
pathObj.stringValue = AssetDatabase.GetAssetPath(obj);
if (!pathObj.stringValue.StartsWith("Assets/Content/"))
{
serObj.objectReferenceValue = null;
QLogger.LogError("Only assets from /Assets/Content/ should be added");
}
pathObj.stringValue = pathObj.stringValue.Substring("Assets/Content/".Length); // removes Assets/Content/
pathObj.stringValue = pathObj.stringValue.Substring(0, pathObj.stringValue.IndexOf('.')); // removes file extentions
EditorGUILayout.LabelField(pathObj.stringValue);
}
if (overridePathGeneration)
{
pathObj.stringValue = EditorGUILayout.TextField(pathObj.stringValue);
}
else if (obj == null)
{
{
pathObj.stringValue = "";
EditorGUILayout.LabelField("");
}
}
overridePathGeneration = EditorGUILayout.Toggle("Override", overridePathGeneration);
boolObj.boolValue = overridePathGeneration;
EditorGUI.EndProperty();
EditorGUI.indentLevel = oldIndentLevel;
}
