IEnumerator Shock()
{
agent.SetDestination(enemy.transform.position);
LookAtPlayer();
yield return(new WaitForSeconds(shockTime));
alertState = AlertStates.ONTHEWAY;
}
IEnumerator Shock()
{
agent.SetDestination(enemy.transform.position);
GetComponent <Enemy>().LookAtPlayer();//cambiar
yield return(new WaitForSeconds(shockTime));
alertState = AlertStates.OnTheWay;
isMoving = false;
}
public void writeNewMessage(string message, AlertStates alertState = AlertStates.none)
{
string add = "[" + Tools.convert(Time.time) + "] : ";
_messages.Insert(0, add + message);
_alertStates.Insert(0, alertState);
unityConsoleMessage(add + message, alertState);
if (_messages.Count > _maxMessages)
{
_messages.RemoveAt(_messages.Count - 1);
_alertStates.RemoveAt(_alertStates.Count - 1);
}
}
protected GUIStyle returnStyle(AlertStates alertState)
{
switch (alertState)
{
case AlertStates.warning:
return _yellow;
case AlertStates.error:
return _red;
case AlertStates.validation:
return _green;
default:
return _white;
}
}
protected void unityConsoleMessage(string message, AlertStates alertState)
{
switch (alertState)
{
case AlertStates.warning:
Debug.LogWarning(message);
break;
case AlertStates.error:
Debug.LogError(message);
break;
default:
Debug.Log(message);
break;
}
}
void Update()
{
if (!enemy.isDead)
{
if (!player.GetZombieMode())
{
if (enemy.state == EnemyStates.ALERT)
{
if (alertState == AlertStates.Normal)
{
warningObj.SetActive(true);
warningObj.GetComponent <AudioSource>().Play();
alertState = AlertStates.Shocked;
StartCoroutine(Shock());
}
else if (alertState == AlertStates.OnTheWay)
{
if (isMoving == false && destinationPosi != Vector3.zero)
{
isMoving = true;
agent.SetDestination(destinationPosi);
}
else if (agent.remainingDistance < agent.stoppingDistance)
{
alertState = AlertStates.Checking;
StartCoroutine(Checking());
}
}
}
}
else
{
enemy.state = EnemyStates.CONFUSED;
warningObj.SetActive(false);
}
}
else
{
warningObj.SetActive(false);
}
}
// Update is called once per frame
void Update()
{
if (enemy.state == EnemyStates.ALERT)
{
if (alertState == AlertStates.NORMAL)
{
alertState = AlertStates.SHOCKED;
StartCoroutine(Shock());
}
else if (alertState == AlertStates.ONTHEWAY)
{
if (!agent.hasPath && destinationPos != Vector3.zero)
{
agent.SetDestination(destinationPos);
}
else if (agent.remainingDistance < agent.stoppingDistance)
{
alertState = AlertStates.CHECKING;
StartCoroutine(Checking());
}
}
}
}
public void Init()
{
alertState = AlertStates.Normal;
destinationPosi = Vector3.zero;
warningObj.SetActive(false);
}
/// <summary>
/// Process Records
/// </summary>
protected override void ProcessRecord()
{
var queries = new Dictionary <string, string>();
if (MaxAlerts.HasValue)
{
queries.Add("maxAlerts", MaxAlerts.ToString());
}
if (AlertCategories != null && AlertCategories.Any())
{
List <string> alertCategories = AlertCategories.ToList().ConvertAll <string>(x => x.ToString().First().ToString().ToLower() + x.ToString().Substring(1));
queries.Add("alertCategoryList", string.Join(",", alertCategories));
}
if (AlertStates != null && AlertStates.Any())
{
List <string> alertStates = AlertStates.ToList().ConvertAll <string>(x => x.ToString().First().ToString().ToLower() + x.ToString().Substring(1));
queries.Add("alertStateList", string.Join(",", alertStates));
}
if (AlertSeverities != null && AlertSeverities.Any())
{
List <string> alertSeverities = AlertSeverities.ToList().ConvertAll <string>(x => x.ToString().First().ToString().ToLower() + x.ToString().Substring(1));
queries.Add("alertSeverityList", string.Join(",", alertSeverities));
}
if (ResolutionIds != null && ResolutionIds.Any())
{
queries.Add("resolutionIdList", string.Join(",", ResolutionIds));
}
if (AlertIds != null && AlertIds.Any())
{
queries.Add("alertIdList", string.Join(",", AlertIds));
}
if (AlertTypes != null && AlertTypes.Any())
{
queries.Add("alertTypeList", string.Join(",", AlertTypes));
}
if (StartTime.HasValue)
{
queries.Add("startDateUsecs", StartTime.ToString());
}
if (EndTime.HasValue)
{
queries.Add("endDateUsecs", EndTime.ToString());
}
var queryString = string.Empty;
if (queries.Any())
{
queryString = "?" + string.Join("&", queries.Select(q => $"{q.Key}={q.Value}"));
}
var preparedUrl = $"/public/alerts{queryString}";
WriteDebug(preparedUrl);
var result = Session.ApiClient.Get <IEnumerable <Model.Alert> >(preparedUrl);
WriteObject(result, true);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#endregion
#region class public methods
// =====================================================================================
/// <summary>
/// This class sets the value according with the field name.
/// </summary>
/// <param name="fieldname">AlertFieldNames: an alert's field name</param>
/// <param name="Value">string: an alert's value</param>
/// <returns> Evado.Model.EvEventCodes: an event code</returns>
/// <remarks>
/// This method consists of the following steps:
///
/// 1. Initialize the local variables and objects of the method including: date, status and type
///
/// 2. Switch the fieldname and update value for the property defined by the alert field names.
/// </remarks>
// ------------------------------------------------------------------------------------
public Evado.Model.EvEventCodes setValue(EvAlert.AlertFieldNames fieldname, string Value)
{
//
// Initialise the methods local variables and objects.
//
DateTime date = EvcStatics.CONST_DATE_NULL;
EvAlert.AlertStates status = EvAlert.AlertStates.Null;
EvAlert.AlertTypes type = EvAlert.AlertTypes.Null;
//
// The switch determines the item to be updated.
//
switch (fieldname)
{
case EvAlert.AlertFieldNames.Alert_Id:
{
this._AlertId = Value;
break;
}
case EvAlert.AlertFieldNames.Trial_Id:
{
this._ProjectId = Value;
break;
}
case EvAlert.AlertFieldNames.To_Org_Id:
{
this._ToOrgId = Value;
break;
}
case EvAlert.AlertFieldNames.To_User:
{
this._ToUser = Value;
break;
}
case EvAlert.AlertFieldNames.Alert_Subject:
{
this._Subject = Value;
break;
}
case EvAlert.AlertFieldNames.New_Message:
this._NewMessage = Value;
break;
case EvAlert.AlertFieldNames.Message:
this._Message = Value;
break;
case EvAlert.AlertFieldNames.From_User_UserId:
this._FromUserUserId = Value;
break;
case EvAlert.AlertFieldNames.From_User:
this.FromUser = Value;
break;
case EvAlert.AlertFieldNames.Raised_Date:
if (DateTime.TryParse(Value, out date) == true)
{
this._Raised = date;
break;
}
else
{
return(Evado.Model.EvEventCodes.Data_Date_Casting_Error);
}
case EvAlert.AlertFieldNames.Acknowledged_By_UserId:
{
this._AcknowledgedByUserId = Value;
break;
}
case EvAlert.AlertFieldNames.Acknowledged_By:
{
this._AcknowledgedBy = Value;
break;
}
case EvAlert.AlertFieldNames.Acknowledged_Date:
if (DateTime.TryParse(Value, out date) == true)
{
this._Acknowledged = date;
break;
}
else
{
return(Evado.Model.EvEventCodes.Data_Date_Casting_Error);
}
case EvAlert.AlertFieldNames.Closed_By_UserId:
{
this._ClosedByUserId.ToString( );
break;
}
case EvAlert.AlertFieldNames.Closed_By:
{
this._ClosedBy = Value;
break;
}
case EvAlert.AlertFieldNames.Closed_Date:
if (DateTime.TryParse(Value, out date) == true)
{
this._Closed = date;
break;
}
else
{
return(Evado.Model.EvEventCodes.Data_Date_Casting_Error);
}
case EvAlert.AlertFieldNames.Type_Id:
{
if (Evado.Model.EvStatics.tryParseEnumValue <EvAlert.AlertTypes> (Value, out type) == false)
{
return(Evado.Model.EvEventCodes.Data_Enumeration_Casting_Error);
}
this._TypeId = type;
break;
}
case EvAlert.AlertFieldNames.Alert_State:
{
if (Evado.Model.EvStatics.tryParseEnumValue <EvAlert.AlertStates> (Value, out status) == false)
{
return(Evado.Model.EvEventCodes.Data_Enumeration_Casting_Error);
}
this._State = status;
break;
}
default:
return(0);
}//END Switch
return(0);
}//END getValue method
public void Init()
{
alertState = AlertStates.NORMAL;
destinationPos = Vector3.zero;
}
