public void DeInit()
{
OnPlayerReconstruct.RemoveListener(CheckParts);
State = ConditionState.Uninitialized;
if (TaskManager.objectiveLocations[(Canvas as QuestCanvas).missionName].Contains(objectiveLocation))
{
TaskManager.objectiveLocations[(Canvas as QuestCanvas).missionName].Remove(objectiveLocation);
TaskManager.DrawObjectiveLocations();
}
}
public void CheckParts(string partId, int abilityId, string sector)
{
if (string.IsNullOrEmpty(sectorName) || sectorName == sector)
{
if (partId == partID && abilityId == abilityID)
{
State = ConditionState.Completed;
connectionKnobs[0].connection(0).body.Calculate();
}
}
}
public override BlockBase StartCondition(int lineNumber)
{
ConditionalBlock result = base.StartCondition(lineNumber) as ConditionalBlock;
if (state == ConditionState.ExpectingAlternate) //this is the If after Else for ElseIf
{
state = ConditionState.HasAlternateCondition; //mark myself to have ElseIf
result.IsAlternateCondition = true; //mark as ElseIf Condition
} //else this is just a nested Condition If () If () ;
return(result);
}
void MissionStatus(Mission mission)
{
if (mission.name == missionName)
{
if ((Mission.MissionStatus)missionStatus == mission.status)
{
state = ConditionState.Completed;
output.connection(0).body.Calculate();
}
}
}
protected void NotifyConditionDidRecover()
{
if (ConditionState == ConditionState.Recovered)
{
throw new Exception("Cannot notify about recovering in condition that is in Recovered state.");
}
ConditionState = ConditionState.Recovered;
DidRecover?.Invoke(this, EventArgs.Empty);
}
protected void NotifyConditionDidBreak()
{
if (ConditionState == ConditionState.Broken)
{
throw new Exception("Cannot notify about break in condition that is in Broken state.");
}
ConditionState = ConditionState.Broken;
DidBreak?.Invoke(this, EventArgs.Empty);
}
protected bool WasActive()
{
bool wasActive = false;
ConditionState alarm = GetAlarm();
if (alarm.Severity.Value > AlarmDefines.INACTIVE_SEVERITY)
{
wasActive = true;
}
return(wasActive);
}
public void DeInit()
{
OnYardCollect -= (CheckParts);
State = ConditionState.Uninitialized;
if (TaskManager.objectiveLocations[(Canvas as QuestCanvas).missionName].Contains(objectiveLocation))
{
TaskManager.objectiveLocations[(Canvas as QuestCanvas).missionName].Remove(objectiveLocation);
TaskManager.DrawObjectiveLocations();
}
}
public ConditionState Validate()
{
ConditionState thisState = Expression();
if (RelatedConditions.Any())
{
_relatedConditionsValidator.WithDefaultState(thisState);
return(_relatedConditionsValidator.Validate());
}
return(thisState);
}
public void DeInit()
{
// TODO: Find why the timer is sometimes null
if (timer != null)
{
TaskManager.Instance.StopCoroutine(timer);
}
timer = null;
State = ConditionState.Uninitialized;
Debug.Log("Timer stopped!");
}
private void AddState(Condition condition)
{
Type type = Type.GetType(tool.Name + "ConditionState");
if (type != null)
{
ConditionState conditionState = (ConditionState)Activator.CreateInstance(type, tool, condition, geometry);
conditionState.OnClickDelete = () => geoController.RemoveConditionOperation(condition);
stateController.AddConditionState(conditionState);
}
}
private void RangeCheck(float range)
{
if (rangeCheck)
{
var player = AIData.entities.Find(ent => ent.ID == "player");
var diff = range - distanceFromPlayer * distanceFromPlayer;
if ((lessThan && diff <= 0) || (!lessThan && diff > 0))
{
State = ConditionState.Completed;
connectionKnobs[0].connection(0).body.Calculate();
}
}
}
public void DurationOverwrite()
{
if (Error.instance.boolDropdown.value == 0)
{
state = ConditionState.condition;
LoadCondition(presets.value);
}
if (Error.instance.boolDropdown.value == 1)
{
state = ConditionState.current;
LoadCondition(presets.value);
}
}
protected bool ShouldEvent()
{
bool shouldEvent = false;
ConditionState alarm = GetAlarm();
ushort newSeverity = GetSeverity();
if (newSeverity != alarm.Severity.Value)
{
shouldEvent = true;
}
return(shouldEvent);
}
public void GetBranchesForConditionRefresh(List <IFilterTarget> events)
{
ConditionState alarm = m_alarm as ConditionState;
if (alarm != null)
{
Dictionary <string, ConditionState> branches = alarm.GetBranches();
foreach (BaseEventState branch in branches.Values)
{
events.Add(branch);
}
}
}
public bool HasBranches()
{
bool hasBranches = false;
ConditionState alarm = m_alarm as ConditionState;
if (alarm != null)
{
hasBranches = alarm.GetBranchCount() > 0;
}
return(hasBranches);
}
public void DeInit()
{
if (!loseMode)
{
OnBattleWin -= BattleEnd;
}
else
{
OnBattleLose -= BattleEnd;
}
state = ConditionState.Uninitialized;
}
private AcknowledgeableConditionState GetAlarmOrBranch(byte[] eventId)
{
AcknowledgeableConditionState alarmOrBranch = null;
AcknowledgeableConditionState alarm = GetAlarm();
ConditionState alarmOrBranchConditionState = alarm.GetEventByEventId(eventId);
if (alarmOrBranchConditionState != null)
{
alarmOrBranch = (AcknowledgeableConditionState)alarmOrBranchConditionState;
}
return(alarmOrBranch);
}
public void Init(int index)
{
if (!loseMode)
{
OnBattleWin += BattleEnd;
}
else
{
OnBattleLose += BattleEnd;
}
state = ConditionState.Listening;
}
public BaseEventState GetBranch(byte[] eventId)
{
BaseEventState state = null;
ConditionState alarm = m_alarm as ConditionState;
if (alarm != null)
{
state = alarm.GetBranch(eventId);
}
return(state);
}
/// <summary>
/// Adds a comment to the selected conditions.
/// </summary>
/// <param name="methodId">The NodeId for the method to call.</param>
/// <param name="comment">The comment to pass as an argument.</param>
private void CallMethod(NodeId methodId, string comment)
{
// build list of methods to call.
CallMethodRequestCollection methodsToCall = new CallMethodRequestCollection();
for (int ii = 0; ii < ConditionsLV.SelectedItems.Count; ii++)
{
ConditionState condition = (ConditionState)ConditionsLV.SelectedItems[ii].Tag;
CallMethodRequest request = new CallMethodRequest();
request.ObjectId = condition.NodeId;
request.MethodId = methodId;
request.Handle = ConditionsLV.SelectedItems[ii];
if (comment != null)
{
request.InputArguments.Add(new Variant(condition.EventId.Value));
request.InputArguments.Add(new Variant((LocalizedText)comment));
}
methodsToCall.Add(request);
}
if (methodsToCall.Count == 0)
{
return;
}
// call the methods.
CallMethodResultCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.Call(
null,
methodsToCall,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, methodsToCall);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, methodsToCall);
for (int ii = 0; ii < results.Count; ii++)
{
if (StatusCode.IsBad(results[ii].StatusCode))
{
ListViewItem item = (ListViewItem)methodsToCall[ii].Handle;
item.SubItems[8].Text = Utils.Format("{0}", results[ii].StatusCode);
}
}
}
private ConditionState GetConditionState(RelatedCondition relatedCondition, ConditionState comparisonState)
{
bool firstIsFulfilled = comparisonState == ConditionState.Fulfilled;
bool secondIsFulfilled = relatedCondition.Validate() == ConditionState.Fulfilled;
switch (relatedCondition.Relation)
{
case ConditionRelation.And:
{
if (firstIsFulfilled && secondIsFulfilled)
{
return(ConditionState.Fulfilled);
}
break;
}
case ConditionRelation.Or:
{
if (firstIsFulfilled || secondIsFulfilled)
{
return(ConditionState.Fulfilled);
}
break;
}
case ConditionRelation.AndNot:
{
if (firstIsFulfilled && !secondIsFulfilled)
{
return(ConditionState.Fulfilled);
}
break;
}
case ConditionRelation.OrNot:
{
if (firstIsFulfilled || !secondIsFulfilled)
{
return(ConditionState.Fulfilled);
}
break;
}
}
return(ConditionState.NotFulfilled);
}
private ConditionState GetConditionState(RelatedCondition relatedCondition, ConditionState comparisonState)
{
bool firstIsFulfilled = comparisonState == ConditionState.Fulfilled;
bool secondIsFulfilled = relatedCondition.Validate() == ConditionState.Fulfilled;
switch (relatedCondition.Relation)
{
case ConditionRelation.And:
{
if (firstIsFulfilled && secondIsFulfilled)
{
return ConditionState.Fulfilled;
}
break;
}
case ConditionRelation.Or:
{
if (firstIsFulfilled || secondIsFulfilled)
{
return ConditionState.Fulfilled;
}
break;
}
case ConditionRelation.AndNot:
{
if (firstIsFulfilled && !secondIsFulfilled)
{
return ConditionState.Fulfilled;
}
break;
}
case ConditionRelation.OrNot:
{
if (firstIsFulfilled || !secondIsFulfilled)
{
return ConditionState.Fulfilled;
}
break;
}
}
return ConditionState.NotFulfilled;
}
private ServiceResult OnAcknowledge(
ISystemContext context,
ConditionState condition,
byte[] eventId,
LocalizedText comment)
{
string eventIdString = Utils.ToHexString(eventId);
if (m_acked.Contains(eventIdString))
{
LogError("OnAcknowledge", EventErrorMessage(eventId) + " already acknowledged");
return(StatusCodes.BadConditionBranchAlreadyAcked);
}
AcknowledgeableConditionState alarm = GetAlarmOrBranch(eventId);
if (alarm == null)
{
LogError("OnAcknowledge", EventErrorMessage(eventId));
return(StatusCodes.BadEventIdUnknown);
}
m_acked.Add(eventIdString);
if (alarm.AckedState.Id.Value)
{
return(StatusCodes.BadConditionBranchAlreadyAcked);
}
// No Confirming on Acknowledge tests
if (m_alarmNodeManager.GetUnitFromNodeState(alarm) == "Acknowledge")
{
alarm.SetConfirmedState(SystemContext, confirmed: true);
Log("OnAcknowledge", "Ignore Confirmed State, setting confirmed to true");
}
else
{
alarm.Message.Value = "User Acknowledged Event " + DateTime.Now.ToShortTimeString();
Log("OnAcknowledge", "Setting Confirmed State to False");
alarm.SetConfirmedState(SystemContext, confirmed: false);
}
m_alarmController.OnAcknowledge();
// TODO This will need to go away
alarm.Retain.Value = GetRetainState();
return(ServiceResult.Good);
}
/// <summary>
/// Does any initialization required before the address space can be used.
/// </summary>
/// <remarks>
/// The externalReferences is an out parameter that allows the node manager to link to nodes
/// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and
/// should have a reference to the root folder node(s) exposed by this node manager.
/// </remarks>
public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences)
{
lock (Lock)
{
// ensure the namespace used by the node manager is in the server's namespace table.
m_typeNamespaceIndex = Server.NamespaceUris.GetIndexOrAppend(Namespaces.TestData);
m_namespaceIndex = Server.NamespaceUris.GetIndexOrAppend(Namespaces.TestData + "/Instance");
base.CreateAddressSpace(externalReferences);
// start monitoring the system status.
m_systemStatusCondition = (TestSystemConditionState)FindPredefinedNode(
new NodeId(Objects.Data_Conditions_SystemStatus, m_typeNamespaceIndex),
typeof(TestSystemConditionState));
if (m_systemStatusCondition != null)
{
m_systemStatusTimer = new Timer(OnCheckSystemStatus, null, 5000, 5000);
m_systemStatusCondition.Retain.Value = true;
}
// link all conditions to the conditions folder.
NodeState conditionsFolder = (NodeState)FindPredefinedNode(
new NodeId(Objects.Data_Conditions, m_typeNamespaceIndex),
typeof(NodeState));
foreach (NodeState node in PredefinedNodes.Values)
{
ConditionState condition = node as ConditionState;
if (condition != null && !Object.ReferenceEquals(condition.Parent, conditionsFolder))
{
condition.AddNotifier(SystemContext, null, true, conditionsFolder);
conditionsFolder.AddNotifier(SystemContext, null, false, condition);
}
}
// enable history for all numeric scalar values.
ScalarValueObjectState scalarValues = (ScalarValueObjectState)FindPredefinedNode(
new NodeId(Objects.Data_Dynamic_Scalar, m_typeNamespaceIndex),
typeof(ScalarValueObjectState));
scalarValues.Int32Value.Historizing = true;
scalarValues.Int32Value.AccessLevel = (byte)(scalarValues.Int32Value.AccessLevel | AccessLevels.HistoryRead);
m_system.EnableHistoryArchiving(scalarValues.Int32Value);
}
}
private void ReportChanges(ConditionState alarm)
{
// report changes to node attributes.
alarm.ClearChangeMasks(_nodeManager.SystemContext, true);
// check if events are being monitored for the source.
if (this.AreEventsMonitored)
{
// create a snapshot.
InstanceStateSnapshot e = new InstanceStateSnapshot();
e.Initialize(_nodeManager.SystemContext, alarm);
// report the event.
alarm.ReportEvent(_nodeManager.SystemContext, e);
}
}
public void DeInit()
{
State = ConditionState.Uninitialized;
if (Entity.OnEntitySpawn != null)
{
Entity.OnEntitySpawn -= GrabEntity;
}
if (entity)
{
entity.RangeCheckDelegate -= RangeCheck;
}
if (flag)
{
flag.RangeCheckDelegate -= RangeCheck;
}
}
/// <summary>
/// Setup queue of conditions. Adds two entries for each one handed target (left and right hand), and one entry for each two handed target.
/// Included fixation (or other image) conditon between targets.
/// </summary>
private void LoadTrialData()
{
trialConditions = new Queue <MarkerCondition>();
string[] lines = File.ReadAllLines(System.IO.Path.Combine(path, trialDataFile));
ConditionState currentState = ConditionState.SeatedOneHanded;
foreach (string cond in lines[participantNumber].Split(',').Skip(1))
{
if (cond.Equals(""))
{
if (currentState == ConditionState.SeatedOneHanded)
{
currentState = ConditionState.SeatedTwoHanded;
trialConditions.Enqueue(new MarkerCondition(twoHandLabel));
}
else if (currentState == ConditionState.SeatedTwoHanded)
{
currentState = ConditionState.StandingOneHanded;
trialConditions.Enqueue(new MarkerCondition(standUpLabel));
}
else if (currentState == ConditionState.StandingOneHanded)
{
currentState = ConditionState.StandingTwoHanded;
trialConditions.Enqueue(new MarkerCondition(twoHandLabel));
}
}
else if (currentState == ConditionState.SeatedOneHanded || currentState == ConditionState.StandingOneHanded)
{
trialConditions.Enqueue(new MarkerCondition(MarkerCondition.Hand.Left, cond));
trialConditions.Enqueue(new MarkerCondition(true));
trialConditions.Enqueue(new MarkerCondition(MarkerCondition.Hand.Right, cond));
trialConditions.Enqueue(new MarkerCondition(true));
}
else if (currentState == ConditionState.SeatedTwoHanded || currentState == ConditionState.StandingTwoHanded)
{
trialConditions.Enqueue(new MarkerCondition(MarkerCondition.Hand.Both, cond.Replace('-', ' ')));
trialConditions.Enqueue(new MarkerCondition(true));
}
}
trialConditions.Enqueue(new MarkerCondition(experiementCompleteLabel));
CurrentStatus = "Ready to begin!";
}
/// <summary>
/// Handles the Click event of the Conditions_MonitorMI control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void Conditions_MonitorMI_Click(object sender, EventArgs e)
{
try
{
if (ConditionsLV.SelectedItems.Count != 1)
{
return;
}
ConditionState condition = (ConditionState)ConditionsLV.SelectedItems[0].Tag;
new ViewEventDetailsDlg().ShowDialog(m_monitoredItem, condition.Handle as EventFieldList);
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Called when the alarm is confirmed.
/// </summary>
private ServiceResult OnConfirm(
ISystemContext context,
ConditionState condition,
byte[] eventId,
LocalizedText comment)
{
AlarmConditionState alarm = FindAlarmByEventId(eventId);
if (alarm == null)
{
return(StatusCodes.BadEventIdUnknown);
}
m_source.ConfirmAlarm(alarm.SymbolicName, GetRecordNumber(alarm), comment, GetUserName(context));
return(ServiceResult.Good);
}
public void Init(int index)
{
for (int i = 0; i < PlayerCore.Instance.cursave.missions.Count; i++)
{
//Debug.Log("Mission: " + PlayerCore.Instance.cursave.missions[i].name + ", status: " + PlayerCore.Instance.cursave.missions[i].status);
if (PlayerCore.Instance.cursave.missions[i].name == missionName &&
PlayerCore.Instance.cursave.missions[i].status == (Mission.MissionStatus)missionStatus)
{
state = ConditionState.Completed;
output.connection(0).body.Calculate();
return;
}
}
OnMissionStatusChange += MissionStatus;
state = ConditionState.Listening;
}
public ConditionsValidator WithDefaultState(ConditionState state)
{
_defaultState = state;
return this;
}
