private void addClauseButton_Click(object sender, EventArgs e)
{
Actor epsilonActor = new Actor("ϵ");
switch (currentClause)
{
case 0:
{
Initially stmt = ((InitiallyClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
clausesListBox.Items.Add(stmt);
_domain.AddInitiallyClause(stmt);
}
break;
}
case 1:
{
Causes stmt = ((CausesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Causes(stmt.Action, stmt.Exclusion, availableActors, stmt.Effect, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddCausesClause(stmt);
}
break;
}
case 2:
{
TypicallyCauses stmt = ((TypicallyCausesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new TypicallyCauses(stmt.Action, stmt.Exclusion, availableActors, stmt.Effect, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddTypicallyCausesClause(stmt);
}
break;
}
case 3:
{
Releases stmt = ((ReleasesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Releases(stmt.Action, stmt.Exclusion, availableActors, stmt.Fluent, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddReleasesClause(stmt);
}
break;
}
case 4:
{
Preserves stmt = ((PreservesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Preserves(stmt.Action, stmt.Exclusion, availableActors, stmt.Fluent, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddPreservesClause(stmt);
}
break;
}
case 5:
{
Always stmt = ((AlwaysClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
clausesListBox.Items.Add(stmt);
_domain.AddAlwaysClause(stmt);
}
break;
}
case 6:
{
Impossible stmt = ((ImpossibleClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Impossible(stmt.Action, stmt.Exclusion, availableActors, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddImpossibleClause(stmt);
}
break;
}
}
}
public void AddTypicallyCausesClause(TypicallyCauses clause)
{
TypicallyCausesClauses.Add(clause);
}
public void DeleteTypicallyCausesClause(TypicallyCauses clause)
{
TypicallyCausesClauses.Remove(clause);
}
public void Alice()
{
World world = World.Instance;
var hatterActor = new Actor("Hatter");
var drinkAction = new Action("Drink");
var eatAction = new Action("Eat");
var hatterMadFluent = new Fluent("hatterMad");
var cakeExistsFluent = new Fluent("cakeExists");
var elixirExistsFluent = new Fluent("elixirExists");
var fluentList = new List <Fluent> {
hatterMadFluent, cakeExistsFluent, elixirExistsFluent
};
var domain = new Domain();
var initially1 = new Initially(new Conjunction(new Negation(hatterMadFluent), cakeExistsFluent, elixirExistsFluent));
var causes1 = new Causes(drinkAction, false, new List <Actor> {
hatterActor
}, hatterMadFluent, elixirExistsFluent);
var causes2 = new Causes(eatAction, false, new List <Actor> {
hatterActor
}, new Negation(cakeExistsFluent));
var tCauses1 = new TypicallyCauses(eatAction, false, new List <Actor> {
hatterActor
}, new Negation(hatterMadFluent), hatterMadFluent);
var impossible1 = new Impossible(eatAction, false, new List <Actor> {
hatterActor
}, new Negation(cakeExistsFluent));
var releases1 = new Releases(drinkAction, false, new List <Actor> {
hatterActor
}, elixirExistsFluent, elixirExistsFluent);
domain.AddInitiallyClause(initially1);
domain.AddCausesClause(causes1);
domain.AddTypicallyCausesClause(tCauses1);
domain.AddImpossibleClause(impossible1);
domain.AddReleasesClause(releases1);
domain.AddCausesClause(causes2);
world.SetActions(new List <Action> {
drinkAction, eatAction
});
world.SetActors(new List <Actor> {
hatterActor
});
world.SetFluents(fluentList);
world.SetDomain(domain);
Assert.IsTrue(world.Build());
State state0 = new State(fluentList, new List <bool> {
false, true, true
});
State state1 = new State(fluentList, new List <bool> {
true, true, true
});
State state2 = new State(fluentList, new List <bool> {
true, false, true
});
State state3 = new State(fluentList, new List <bool> {
false, false, true
});
State state4 = new State(fluentList, new List <bool> {
true, false, false
});
State state5 = new State(fluentList, new List <bool> {
true, true, false
});
State state6 = new State(fluentList, new List <bool> {
false, true, false
});
State state7 = new State(fluentList, new List <bool> {
false, false, false
});
ISet <State> expectedResN, expectedResAb, actualResN, actualResAb;
// drink; hatter; -hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state1, state5
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state0, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state0, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state1, state5
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state1, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state1, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
state2, state4
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state2, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state2, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; -hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
state2, state4
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state3, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state3, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state4
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state4, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state4, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state5
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state5, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state5, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; -hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state6
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state6, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state6, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; -hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state7
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state7, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state7, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state3
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state0, false);
actualResAb = world.GetStates(eatAction, hatterActor, state0, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state3
};
expectedResAb = new HashSet <State> {
state2
};
actualResN = world.GetStates(eatAction, hatterActor, state1, false);
actualResAb = world.GetStates(eatAction, hatterActor, state1, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state2, false);
actualResAb = world.GetStates(eatAction, hatterActor, state2, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state3, false);
actualResAb = world.GetStates(eatAction, hatterActor, state3, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state4, false);
actualResAb = world.GetStates(eatAction, hatterActor, state4, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state7
};
expectedResAb = new HashSet <State> {
state4
};
actualResN = world.GetStates(eatAction, hatterActor, state5, false);
actualResAb = world.GetStates(eatAction, hatterActor, state5, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state7
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state6, false);
actualResAb = world.GetStates(eatAction, hatterActor, state6, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state7, false);
actualResAb = world.GetStates(eatAction, hatterActor, state7, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
}
