private void ReplaceBehavior(Behavior behavior, Character character)
{
DebugIf("all", "ReplaceBehavior '" + behavior.Id + "' on character '" + character.ToString() + "'");
CancelCurrentPlan();
List<BehaviorNode> nodes = SolveConstraints(behavior.Nodes);
if (character != null) ScheduleBehavior(new BehaviorExecutionContext(behavior, nodes, character));
else ScheduleBehavior(new BehaviorExecutionContext(behavior, nodes));
}
private void RebuildEventsMap(Character character)
{
Dictionary<string, ThalamusClientProxy> clients;
lock (character.Clients.RemoteClients)
{
clients = new Dictionary<string, ThalamusClientProxy>(character.Clients.RemoteClients);
}
foreach (ThalamusClientProxy client in clients.Values)
{
if (!client.Connected) continue;
actionPublicationMap[client] = new Dictionary<string, List<ThalamusClientProxy>>();
perceptionPublicationMap[client] = new Dictionary<string, List<ThalamusClientProxy>>();
actionSubscriptionMap[client] = new Dictionary<string, List<ThalamusClientProxy>>();
perceptionSubscriptionMap[client] = new Dictionary<string, List<ThalamusClientProxy>>();
lock (client.SubscribedEvents)
{
foreach (string ev in client.SubscribedEvents)
{
if (!character.Clients.SubscribedToEvent.ContainsKey(ev) || !character.Clients.EventInfo.ContainsKey(ev)) continue;
PML pml = character.Clients.EventInfo[ev];
if (pml.EventType == PMLEventType.Action) actionSubscriptionMap[client][ev] = character.Clients.SubscribedToEvent[ev];
else perceptionSubscriptionMap[client][ev] = character.Clients.SubscribedToEvent[ev];
}
}
lock (client.AnnouncedEvents)
{
foreach (string ev in client.AnnouncedEvents)
{
if (!character.Clients.PublishesEvent.ContainsKey(ev) || !character.Clients.EventInfo.ContainsKey(ev)) continue;
PML pml = character.Clients.EventInfo[ev];
if (pml.EventType == PMLEventType.Action) actionPublicationMap[client][ev] = character.Clients.PublishesEvent[ev];
else perceptionPublicationMap[client][ev] = character.Clients.PublishesEvent[ev];
}
}
}
foreach (ThalamusClientProxy client in clients.Values)
{
/*actionPublicationMap[client] = FilterActionPublicationMap(client, actionPublicationMap[client]);
perceptionPublicationMap[client] = FilterPerceptionPublicationMap(client, perceptionPublicationMap[client]);
actionSubscriptionMap[client] = FilterActionSubscriptionMap(client, actionSubscriptionMap[client]);*/
var z = FilterPerceptionSubscriptionMap(client, perceptionSubscriptionMap[client]);
perceptionSubscriptionMap[client] = z;
}
}
public void SetFunnel(Character character, ConflictRule selectedConflict, string selectedFunnel)
{
conflictRules[character.Name][selectedConflict.FullEventName][selectedConflict.ConflictType].AddFunnel(selectedFunnel);
SaveSettings(character);
}
public BehaviorExecutionContext(Behavior behavior, List<BehaviorNode> nodes, Character character)
{
Behavior = behavior;
Nodes = nodes;
Character = character;
}
void Instance_EventInformationChanged(Character character)
{
Thread t = new Thread(new ParameterizedThreadStart(DetectConflicts));
t.Start(character);
}
public void DeleteCharacter(Character Character)
{
lock (Characters) {
Characters.Remove (Character.Name);
Character.Dispose ();
}
}
internal void ConflictsChanged(Character character)
{
RefreshInfo();
}
public Behavior(string id, Character character):this(id,character, new List<BehaviorNode>()) {}
public Behavior(Character character, List<BehaviorNode> nodes, CompositionType composition, List<Constraint.Constraint> constraints) : this("UnspecifiedBehavior" + Counter++, character, nodes, composition, constraints) { }
public Behavior(Character character):this("UnspecifiedBehavior" + Counter++,character,new List<BehaviorNode>()) {}
public Behavior(Character character, List<BehaviorNode> nodes):this("UnspecifiedBehavior" + Counter++,character,nodes) {}
public void ResetCSV(Character c)
{
if (Properties.Settings.Default.UniqueLogFile)
{
csvLogFilenameTimestamp = "";
}
else
{
csvLogFilenameTimestamp = DateTime.Now.Year.ToString() + "-" + DateTime.Now.Month.ToString() + "-" + DateTime.Now.Day.ToString() + "at" + DateTime.Now.Hour.ToString().PadLeft(2) + "-" + DateTime.Now.Minute.ToString().PadLeft(2) + "-" + DateTime.Now.Second.ToString().PadLeft(2);
}
string csvPath = Properties.Settings.Default.LogDirectory + "CSV_" + c.Name + (Properties.Settings.Default.UniqueLogFile ? "" : "_" + csvLogFilenameTimestamp);
if (Directory.Exists(Manager.CorrectPath(csvPath)) && Properties.Settings.Default.UniqueLogFile)
{
Directory.Delete(csvPath, true);
}
if (!Directory.Exists(Manager.CorrectPath(csvPath))) Directory.CreateDirectory(Manager.CorrectPath(csvPath));
}
private void LogCSV(Character character, PML ev)
{
}
public void LogEvent(bool outwards, Character character, ThalamusClientProxy client, PML ev)
{
LogEntry l = new LogEntry(outwards, CentralTimePassed().TotalSeconds, character.Name, client == null ? "GUI" : client.Name, ev);
DebugLog(l.ToString());
NotifyEventLogged(l);
logs.Add(l);
if (character.LogToCSV) lock (csvLogs) { csvLogs.Add(l); }
}
private void LoadSelectedScenario()
{
if (!selectedScenario.IsNull)
{
Character[] chars = new Character[thalamus.Characters.Count];
thalamus.Characters.Values.CopyTo(chars, 0);
foreach (Character c in chars) thalamus.DeleteCharacter(c);
CloseClients("");
foreach (CharacterDefinition cd in selectedScenario.Characters)
{
Character newCharacter = new Character(cd.Name);
if (selectedCharacter == null) selectedCharacter = newCharacter;
if (logToCsvDefault && selectedCharacter != null)
{
selectedCharacter.LogToCSV = true;
Environment.Instance.ResetCSV(selectedCharacter);
}
thalamus.AddCharacter(newCharacter);
foreach (CharacterDefinition.Client client in cd.Clients)
{
Thread t = new Thread(new ParameterizedThreadStart(ClientThread));
t.Start(new string[] { client.CommandLine, client.Arguments, newCharacter.Name});
Thread.Sleep(1000);
}
}
lstCharacters.SelectedIndex = lstCharacters.Items.Count - 1;
}
}
public Behavior(string id, Character character, List<BehaviorNode> nodes) : this(id, character, nodes, CompositionType.Merge) {}
public void AddCharacter(Character character)
{
lock (Characters) {
if (Characters.ContainsKey (character.Name))
Characters [character.Name] = character;
else
Characters.Add (character.Name, character);
}
if (HasSetup) character.Setup();
if (HasStarted) character.Start();
DebugIf("all", "Added Character '" + character.ToString() + "'");
}
public Behavior(string id, Character character, List<BehaviorNode> nodes, List<Constraint.Constraint> constraints) : this(id, character, nodes, CompositionType.Merge, constraints) { }
public void NotifyEventInformationChanged(Character character)
{
if (EventInformationChanged != null) EventInformationChanged(character);
}
public Behavior(string id, Character character, List<BehaviorNode> nodes, CompositionType composition) : this(id, character, nodes, composition, new List<Constraint.Constraint>()) { }
public virtual bool Setup(Character character)
{
this.character = character;
return Setup();
}
public Behavior(string id, Character character, List<BehaviorNode> nodes, CompositionType composition, List<Constraint.Constraint> constraints)
{
this.id = id;
this.character = character;
this.nodes = nodes;
this.Composition = composition;
this.constraints = constraints;
foreach (BehaviorNode bn in nodes)
{
bn.ParentBehavior = this;
if (bn is BehaviorNodes.Action)
{
(bn as BehaviorNodes.Action).RequiredAction = false;
(bn as BehaviorNodes.Action).ParentNode = bn;
}
else if (bn is BehaviorNodes.Required)
{
foreach (BehaviorNodes.Action a in (bn as BehaviorNodes.Required).Actions)
{
a.ParentNode = bn;
a.RequiredAction = true;
a.ParentBehavior = this;
}
}
}
}
private void SaveSettings(Character character = null)
{
if (Properties.Settings.Default.ConflictRulesFile != "")
{
ConflictSettings settings = new ConflictSettings();
settings.ConflictRules = this.ConflictRules;
settings.DefaultRuleOnActionPublishingConflict = this.defaultRuleOnActionPublishingConflict;
settings.DefaultRuleOnActionSubscriptionConflict = this.defaultRuleOnActionSubscriptionConflict;
settings.DefaultRuleOnPerceptionPublishingConflict = this.defaultRuleOnPerceptionPublishingConflict;
settings.DefaultRuleOnPerceptionSubscriptionConflict = this.defaultRuleOnPerceptionSubscriptionConflict;
ConflictSettings.Save(Properties.Settings.Default.ConflictRulesFile, settings);
Debug("Saved settings to " + Properties.Settings.Default.ConflictRulesFile);
NotifySettingsSaved();
if (character != null) NotifyConflictsChanged(character);
}
else
{
DebugError("Did not save Conflict Rules file because its path is not defined!");
}
}
private void lstCharacters_SelectedIndexChanged(object sender, EventArgs e)
{
if (thalamus.Characters.ContainsKey(lstCharacters.SelectedItem.ToString()))
{
selectedCharacter = thalamus.Characters[lstCharacters.SelectedItem.ToString()];
lstBodyServer.Items.Clear();
selectedCharacter = thalamus.Characters[lstCharacters.SelectedItem.ToString()];
foreach (ThalamusClientProxy rc in selectedCharacter.Clients.RemoteClients.Values) lstBodyServer.Items.Add(rc);
}
else selectedCharacter = null;
RefreshInfo();
}
private void NotifyConflictsChanged(Character character)
{
if (ConflictsChanged != null) ConflictsChanged(character);
}
private Character NewCharacter(string name)
{
selectedCharacter = new Character(name);
if (logToCsvDefault && selectedCharacter != null)
{
selectedCharacter.LogToCSV = true;
Environment.Instance.ResetCSV(selectedCharacter);
}
thalamus.AddCharacter(selectedCharacter);
/*selectedCharacter.Clients.ClientInfoChanged += new ClientInfoChangedHandler((ClientInfoChangedHandler)(
(clientId) =>
{
if (!isClosing) tabControl1.Invoke((MethodInvoker)(() => RefreshInfo()));
}
));*/
//RefreshInfo();
return selectedCharacter;
}
public void SetRule(Character character, string fullEventName, ConflictRule.ConflictTypes conflictType, string clientName, bool ruleState)
{
lock (conflictRules)
{
if (conflictRules.ContainsKey(character.Name) && conflictRules[character.Name].ContainsKey(fullEventName) && conflictRules[character.Name][fullEventName].ContainsKey(conflictType))
{
bool changed = false;
ConflictRule rule = conflictRules[character.Name][fullEventName][conflictType];
if (rule.ClientsRules.ContainsKey(clientName) && rule.ClientsRules[clientName] != ruleState) changed = true;
rule.ClientsRules[clientName] = ruleState;
if (rule.UnsolvedClients.Contains(clientName)) rule.UnsolvedClients.Remove(clientName);
if (rule.UnsolvedClients.Count == 0) rule.Solved = true;
conflictRules[character.Name][fullEventName][conflictType] = rule;
if (changed) SaveSettings(character);
}
}
}
private void btnCreateCharacter_Click(object sender, EventArgs e)
{
if (thalamus.Characters.ContainsKey(txtName.Text))
{
//MessageBox.Show("A character named '" + txtName.Text + "' already exists!", "Create Character", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
CloseClients(txtName.Text);
thalamus.DeleteCharacter(txtName.Text);
selectedCharacter = null;
RefreshInfo();
}
else
{
NewCharacter(txtName.Text);
RefreshInfo();
}
}
public bool RunBML(string bml, Character character)
{
try
{
BehaviorPlan.Instance.Add(BmlToBehavior(GBML.GBML.LoadFromText(bml)), character);
return true;
}
catch (Exception e)
{
DebugIf("error", e.Message);
return false;
}
}
public void Add(Behavior behavior, Character character)
{
switch (behavior.Composition)
{
case Behavior.CompositionType.Append:
AppendBehavior(behavior, character);
break;
case Behavior.CompositionType.Merge:
MergeBehavior(behavior, character);
break;
case Behavior.CompositionType.Replace:
ReplaceBehavior(behavior, character);
break;
}
}
