public ArrayList<PVAR_INST_DEF> getActions(State s) throws EvalException {
ArrayList<PVAR_INST_DEF> actions = new ArrayList<PVAR_INST_DEF>();
ArrayList<PVAR_NAME> action_types = s._hmTypeMap.get("action-fluent");
boolean passed_constraints = false;
for (int j = 0; j < s._alActionNames.size(); j++) {
// Get a random action
PVAR_NAME p = s._alActionNames.get(j);
PVARIABLE_DEF pvar_def = s._hmPVariables.get(p);
// Get term instantations for that action and select *one*
ArrayList<ArrayList<LCONST>> inst = s.generateAtoms(p);
int[] index_permutation = Permutation.permute(inst.size(), _random);
for (int i = 0; i < index_permutation.length; i++) {
ArrayList<LCONST> terms = inst.get(index_permutation[i]);
// IMPORTANT: get random assignment that matches action type
Object value = null;
if (pvar_def._sRange.equals(RDDL.TYPE_NAME.BOOL_TYPE)) {
// bool
value = new Boolean(true);
} else if (pvar_def._sRange.equals(RDDL.TYPE_NAME.INT_TYPE)) {
// int
value = new Integer(_random.nextInt(MAX_INT_VALUE));
} else if (pvar_def._sRange.equals(RDDL.TYPE_NAME.REAL_TYPE)) {
// real
value = new Double(_random.nextDouble() * MAX_REAL_VALUE);
} else {
// enum: only other option for a range
ENUM_TYPE_DEF enum_type_def = (ENUM_TYPE_DEF) s._hmTypes.get(pvar_def._sRange);
int rand_index = _random.nextInt(enum_type_def._alPossibleValues.size());
value = enum_type_def._alPossibleValues.get(rand_index);
}
// Now set the action
actions.add(new PVAR_INST_DEF(p._sPVarName, value, terms));
passed_constraints = true;
try {
s.checkStateActionConstraints(actions);
} catch (EvalException e) {
// Got an eval exception, constraint violated
passed_constraints = false;
// System.out.println(actions + " : " + e);
// System.out.println(s);
// System.exit(1);
} catch (Exception e) {
// Got a real exception, something is wrong
System.out.println(
"\nERROR evaluating constraint on action set: "
+ actions
+ /*"\nConstraint: " +*/ e
+ "\n");
e.printStackTrace();
throw new EvalException(e.toString());
}
if (!passed_constraints) actions.remove(actions.size() - 1);
if (actions.size() == NUM_CONCURRENT_ACTIONS) break;
}
if (actions.size() == NUM_CONCURRENT_ACTIONS) break;
}
// Check if no single action passed constraint
if (!passed_constraints) {
// Try empty action
passed_constraints = true;
actions.clear();
try {
s.checkStateActionConstraints(actions);
} catch (EvalException e) {
passed_constraints = false;
System.out.println(actions + " : " + e);
throw new EvalException("No actions (even a) satisfied state constraints!");
}
}
// Return the action list
// System.out.println("**Action: " + actions);
return actions;
}
static String createXMLTurn(
State state,
int turn,
DOMAIN domain,
HashMap<PVAR_NAME, HashMap<ArrayList<LCONST>, Object>> observStore)
throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder db = dbf.newDocumentBuilder();
Document dom = db.newDocument();
Element rootEle = dom.createElement(TURN);
dom.appendChild(rootEle);
Element turnNum = dom.createElement(TURN_NUM);
Text textTurnNum = dom.createTextNode(turn + "");
turnNum.appendChild(textTurnNum);
rootEle.appendChild(turnNum);
// System.out.println("PO: " + domain._bPartiallyObserved);
if (!domain._bPartiallyObserved || observStore != null) {
for (PVAR_NAME pn :
(domain._bPartiallyObserved ? observStore.keySet() : state._state.keySet())) {
// System.out.println(turn + " check2 Partial Observ " + pn +" : "+
// domain._bPartiallyObserved);
// No problem to overwrite observations, only ever read from
if (domain._bPartiallyObserved && observStore != null)
state._observ.put(pn, observStore.get(pn));
ArrayList<ArrayList<LCONST>> gfluents = state.generateAtoms(pn);
for (ArrayList<LCONST> gfluent : gfluents) {
// for ( Map.Entry<ArrayList<LCONST>,Object> gfluent :
// (domain._bPartiallyObserved
// ? observStore.get(pn).entrySet()
// : state._state.get(pn).entrySet())) {
Element ofEle = dom.createElement(OBSERVED_FLUENT);
rootEle.appendChild(ofEle);
Element pName = dom.createElement(FLUENT_NAME);
Text pTextName = dom.createTextNode(pn.toString());
pName.appendChild(pTextName);
ofEle.appendChild(pName);
for (LCONST lc : gfluent) {
Element pArg = dom.createElement(FLUENT_ARG);
Text pTextArg = dom.createTextNode(lc.toString());
pArg.appendChild(pTextArg);
ofEle.appendChild(pArg);
}
Element pValue = dom.createElement(FLUENT_VALUE);
Object value = state.getPVariableAssign(pn, gfluent);
if (value == null) {
System.out.println("STATE:\n" + state);
throw new Exception("ERROR: Could not retrieve value for " + pn + gfluent.toString());
}
Text pTextValue = dom.createTextNode(value.toString());
pValue.appendChild(pTextValue);
ofEle.appendChild(pValue);
}
}
} else {
// No observations (first turn of POMDP)
Element ofEle = dom.createElement(NULL_OBSERVATIONS);
rootEle.appendChild(ofEle);
}
if (SHOW_XML) {
printXMLNode(dom);
System.out.println();
System.out.flush();
}
return (Client.serialize(dom));
} catch (Exception e) {
System.out.println("FATAL SERVER EXCEPTION: " + e);
e.printStackTrace();
throw e;
// System.exit(1);
// return null;
}
}