@Override
public void visitState(ATNState p) {
if (p.getClass() == ATNState.class && p.getNumberOfTransitions() == 1) {
ATNState q = p.transition(0).target;
if (p.transition(0) instanceof RuleTransition) {
q = ((RuleTransition) p.transition(0)).followState;
}
if (q.getClass() == ATNState.class) {
// we have p-x->q for x in {rule, action, pred, token, ...}
// if edge out of q is single epsilon to block end
// we can strip epsilon p-x->q-eps->r
Transition trans = q.transition(0);
if (q.getNumberOfTransitions() == 1
&& trans.isEpsilon()
&& !(trans instanceof ActionTransition)) {
ATNState r = trans.target;
if (r instanceof BlockEndState
|| r instanceof PlusLoopbackState
|| r instanceof StarLoopbackState) {
// skip over q
if (p.transition(0) instanceof RuleTransition) {
((RuleTransition) p.transition(0)).followState = r;
} else {
p.transition(0).target = r;
}
atn.removeState(q);
}
}
}
}
}
/*
* input transition exp loop through transition experiences
*
* for each transition t use Q update rule oldState and action comes from t
* new state comes from t
*
* for Q update fill up Q_table (output)
*/
public void Qsweep(List<Transition> transitions) {
if (firstTimeQ) initTable(transitions);
for (int index = 0; index < transitions.size(); index++) {
Transition t = transitions.get(index);
// get reward (if any)
float reward = -0.08f; // small penalty for each timestep used
if (t.getNextState().getEnemyHealth() < 0.001) {
reward = 5;
} else if (t.getNextState().getOgreHealth() < 0.001) {
reward = -10;
} else if ( // t.getNextState().getEnemyHealth() <
// t.getCurrentState()
// .getEnemyHealth()&&
t.getNextState().getOgreEnergy() < t.getCurrentState().getOgreEnergy()) {
// if we just got him with the bow
reward = 5;
// System.out.println("got reward");
}
Q_table[index][0] += alpha * (reward + gamma * queryBestState(t) - Q_table[index][0]);
// original version
if (Q_table[index][0] > 10) Q_table[index][0] = 10;
if (Q_table[index][0] < -10) Q_table[index][0] = -10;
// System.out.println("Q: "+index+": "+Q_tableNN[index][0]);
}
firstTimeQ = false;
}
/**
* (non-Javadoc).
*
* @return the string
* @see dj.DigitalDJ#toXML()
*/
@Override
public String toXML() {
StringBuilder sb = new StringBuilder(2000);
sb.append(toXMLGeneralParameters());
sb.append("\t<" + Const.XML_DJ_TRANSITIONS + ">\n");
for (Transition transition : transitions) {
sb.append(
"\t\t<"
+ Const.XML_DJ_TRANSITION
+ " "
+ Const.XML_DJ_FROM
+ "='"
+ transition.getFrom().toXML()
+ "' "
+ Const.XML_DJ_TO
+ "='"
+ transition.getTo().toXML()
+ "' "
+ Const.XML_DJ_NUMBER
+ "='"
+ transition.getNbTracks()
+ "'/>\n");
}
sb.append("\t</" + Const.XML_DJ_TRANSITIONS + ">\n");
sb.append("</" + Const.XML_DJ_DJ + ">\n");
return sb.toString();
}
@Override
public void render(float delta) {
if (to == null) {
if (onTo) main.setScreen(nextScreen);
} else {
if ((to.finished() && onTo) || previousScreen == nextScreen) main.setScreen(nextScreen);
}
if (from == null) {
onTo = true;
} else {
if (from.finished()) {
onTo = true;
}
}
if (onTo) {
if (nextScreen != null) nextScreen.render(delta);
main.batch.begin();
if (to != null) to.render(main);
main.batch.end();
} else {
if (previousScreen != null && previousScreen != this) previousScreen.render(delta);
main.batch.begin();
from.render(main);
main.batch.end();
}
}
/** Returns a string representation of this automaton. */
@Override
public String toString() {
StringBuilder b = new StringBuilder();
b.append("initial state: ").append(initial).append("\n");
for (int i = 0; i < size; i++) {
b.append("state " + i);
if (accept[i]) b.append(" [accept]:\n");
else b.append(" [reject]:\n");
for (int j = 0; j < points.length; j++) {
int k = transitions[i * points.length + j];
if (k != -1) {
char min = points[j];
char max;
if (j + 1 < points.length) max = (char) (points[j + 1] - 1);
else max = Character.MAX_VALUE;
b.append(" ");
Transition.appendCharString(min, b);
if (min != max) {
b.append("-");
Transition.appendCharString(max, b);
}
b.append(" -> ").append(k).append("\n");
}
}
}
return b.toString();
}
public int getNumberOfEnabledTransitions() {
int numberOfEnabledTransitions = 0;
for (Transition transition : this.transitions) {
if (transition.isEnabled()) numberOfEnabledTransitions++;
}
return numberOfEnabledTransitions;
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append("Fireable transitions: ");
lock.readLock().lock();
try {
for (Transition transition : this.getAllEnabledTransitions()) {
result.append(transition.getFullLabel() + " ");
}
if (this.getAllEnabledTransitions().isEmpty()) {
result.append("-NONE-");
}
result.append("\nPlaces: ");
for (Place place : petriNet.getRootSubnet().getPlacesRecursively()) {
result.append(place.getLabel() + ":" + getTokens(place) + " ");
}
if (petriNet.getRootSubnet().getPlacesRecursively().isEmpty()) {
result.append("-NONE-");
}
} finally {
lock.readLock().unlock();
}
return result.toString();
}
@Override
public String toJpdl() throws InvalidModelException {
StringWriter jpdl = new StringWriter();
String type = "";
if (outgoings.size() <= 1) type = "join";
else type = "fork";
jpdl.write(" <" + type);
jpdl.write(JsonToJpdl.transformAttribute("name", name));
if (bounds != null) {
jpdl.write(bounds.toJpdl());
} else {
throw new InvalidModelException("Invalid Wait activity. Bounds is missing.");
}
if (outgoings.size() > 0) {
jpdl.write(" >\n");
for (Transition t : outgoings) {
jpdl.write(t.toJpdl());
}
jpdl.write(" </" + type + ">\n\n");
} else {
jpdl.write(" />\n\n");
}
return jpdl.toString();
}
@NotNull
public Handle elemList(@NotNull List<Handle> els) {
int n = els.size();
for (int i = 0; i < n - 1; i++) { // hook up elements (visit all but last)
Handle el = els.get(i);
// if el is of form o-x->o for x in {rule, action, pred, token, ...}
// and not last in alt
Transition tr = null;
if (el.left.getNumberOfTransitions() == 1) tr = el.left.transition(0);
boolean isRuleTrans = tr instanceof RuleTransition;
if (el.left.getClass() == ATNState.class
&& el.right.getClass() == ATNState.class
&& tr != null
&& (isRuleTrans || tr.target == el.right)) {
// we can avoid epsilon edge to next el
if (isRuleTrans) ((RuleTransition) tr).followState = els.get(i + 1).left;
else tr.target = els.get(i + 1).left;
atn.removeState(el.right); // we skipped over this state
} else { // need epsilon if previous block's right end node is complicated
epsilon(el.right, els.get(i + 1).left);
}
}
Handle first = els.get(0);
Handle last = els.get(n - 1);
if (first == null || last == null) {
g.tool.errMgr.toolError(ErrorType.INTERNAL_ERROR, "element list has first|last == null");
}
return new Handle(first.left, last.right);
}
public static double nearestValue(double energy, double distance, double action) {
// if(distance>0.43&&energy>0.5)
// System.out.print("test");
// scale energy to nearest 0.1
energy *= 10;
energy = Math.round(energy);
energy /= 10;
double closestDist = 100;
Transition trans;
double bestValue = 1;
int bestIndex = 1;
for (int index = 0; index < transitionList.size(); index += 2) {
trans = transitionList.get(index);
if (Math.abs(trans.getCurrentState().getOgreEnergy() - energy) < 0.001
&& Math.abs(trans.getCurrentState().getEnemyDistance() - distance) < closestDist) {
closestDist = Math.abs(trans.getCurrentState().getEnemyDistance() - distance);
bestIndex = index;
}
}
// value of evade
bestValue = Q_table[bestIndex][0];
// if attack then use that value
if (bestIndex + 1 < transitionList.size())
if (action < 0.5) bestValue = Q_table[bestIndex + 1][0];
return bestValue;
}
@Override
public String toJpdl() throws InvalidModelException {
StringWriter jpdl = new StringWriter();
jpdl.write(" <esb");
jpdl.write(JsonToJpdl.transformAttribute("name", name));
try {
jpdl.write(JsonToJpdl.transformRequieredAttribute("category", category));
jpdl.write(JsonToJpdl.transformRequieredAttribute("service", service));
} catch (InvalidModelException e) {
throw new InvalidModelException("Invalid Esb activity. " + e.getMessage());
}
if (bounds != null) {
jpdl.write(bounds.toJpdl());
} else {
throw new InvalidModelException("Invalid ESB activity. Bounds is missing.");
}
jpdl.write(" >\n");
for (Part p : part) {
jpdl.write(p.toJpdl());
}
for (Transition t : outgoings) {
jpdl.write(t.toJpdl());
}
jpdl.write(" </esb>\n\n");
return jpdl.toString();
}
public static Set<String> getStringValues() {
final Set<String> res = new HashSet<String>();
for (final Transition transitions : Transition.values()) {
res.add(transitions.toString());
}
return res;
}
@Override
public final ListenableFuture<State> stop() {
lock.lock();
try {
if (state == State.NEW) {
state = State.TERMINATED;
terminated(State.NEW);
startup.set(State.TERMINATED);
shutdown.set(State.TERMINATED);
} else if (state == State.STARTING) {
shutdownWhenStartupFinishes = true;
startup.set(State.STOPPING);
} else if (state == State.RUNNING) {
state = State.STOPPING;
stopping(State.RUNNING);
doStop();
}
} catch (Throwable shutdownFailure) {
// put the exception in the future, the user can get it via Future.get()
notifyFailed(shutdownFailure);
} finally {
lock.unlock();
}
return shutdown;
}
public Transition addTransition(Transition value) {
if (value.sign == null
|| value.sign.equals("")
|| transitions.containsKey(value.sign) && !transitions.get(value.sign).equals(value)) {
Iterator<String> it = transitions.keySet().iterator();
int i = 0;
while (it.hasNext()) {
String act = it.next();
if (act.matches("^t[0-9]+$")) {
try {
i = Math.max(i, Integer.parseInt(act.substring(1)));
} catch (NumberFormatException e) {
// Never happens
// throw new PNException("InvalidNameFormat", "Error");
}
}
}
++i;
value.sign = "t" + i;
} else if (transitions.containsKey(value.sign) && transitions.get(value.sign).equals(value)) {
return transitions.get(value.sign);
}
value._net = this;
transitions.put(value.sign, value);
return value;
}
public double queryBestState(Transition t) {
double energy = t.getNextState().getOgreEnergy();
double distance = t.getNextState().getEnemyDistance();
double vAttack = FQ_learner.nearestValue(energy, distance, 0);
double vEvade = FQ_learner.nearestValue(energy, distance, 1);
if (vAttack > vEvade) return vAttack;
else return vEvade;
}
@Override
public void tickUpdate() {
if (onTo) {
if (to != null) to.tickUpdate(main);
} else {
if (from != null) from.tickUpdate(main);
}
}
/**
* Gets the transition.
*
* @param ambience DOCUMENT_ME
* @return transition mapping this FROM ambience or null if none maps it
*/
public Transition getTransition(Ambience ambience) {
for (Transition transition : transitions) {
if (CollectionUtils.containsAny(transition.getFrom().getGenres(), ambience.getGenres())) {
return transition;
}
}
return null;
}
/**
* Gets the ambience.
*
* @param genre DOCUMENT_ME
* @return ambience associated with a genre known in transitions or null if none
*/
private Ambience getAmbience(Genre genre) {
for (Transition transition : transitions) {
if (transition.getFrom().getGenres().contains(genre)) {
return transition.getFrom();
}
}
return null;
}
public void clearPetrinet() {
for (Place place : this.places) {
place.setNumberOfTokens(0);
}
for (Transition transition : this.transitions) {
transition.setEnabled(false);
}
}
private Transition find(Iterable<Transition> transitions, String what) {
for (Transition t : transitions) {
if (what.equalsIgnoreCase(t.getName())) {
return t;
}
}
return null;
}
@Override
public void removeReferences() {
// Remove place and transition's references to each other
startPlace.removeOutTransition(endTransition);
endTransition.removeInPlace(startPlace);
// Remove references to this edge in the vertices
startPlace.removeOutEdge(this);
endTransition.removeInEdge(this);
}
public Builder transition(Transition transition) {
Preconditions.checkArgument(
states.contains(transition.from()),
"Originating state does not exist: " + transition.from());
Preconditions.checkArgument(
states.contains(transition.to()), "Destination state does not exist: " + transition.to());
outTransitions.put(transition.from(), transition);
return this;
}
public void enableTransitions() {
for (Transition transition : transitions) {
Boolean enabled = true;
for (Place inPlace : transition.getIncomingPlaces()) {
if (inPlace.hasTokens() == false) enabled = false;
}
transition.setEnabled(enabled);
}
}
public static JSONArray getTransitions(List<Transition> outgoings) throws JSONException {
JSONArray outgoing = new JSONArray();
for (Transition t : outgoings) {
JSONObject tt = new JSONObject();
tt.put("resourceId", t.getUuid());
outgoing.put(tt);
}
return outgoing;
}
/**
* @see Transition#update(org.newdawn.slick.state.StateBasedGame, org.newdawn.slick.GameContainer,
* int)
*/
public void update(StateBasedGame game, GameContainer container, int delta)
throws SlickException {
for (int i = 0; i < transitions.size(); i++) {
Transition t = (Transition) transitions.get(i);
if (!t.isComplete()) {
t.update(game, container, delta);
}
}
}
@Override
public String toString() {
String ret = "InEdge";
if (startPlace.getName() != null
&& !startPlace.getName().equals("")
&& endTransition.getName() != null
&& !endTransition.getName().equals("")) {
ret += ":" + startPlace.getName() + "\u21e8" + endTransition.getName();
}
return ret;
}
/**
* This implements a deep copy of the class for replicating FSM information.
*
* @throws CloneNotSupportedException if clone method is not supported
* @return Object
*/
@Override
public Object clone() throws CloneNotSupportedException {
Transition retval = (Transition) super.clone();
if (retval != null) {
if (this.from != null) retval.from = new String(this.from);
if (this.to != null) retval.to = new String(this.to);
if (this.event != null) retval.event = new String(this.event);
}
return retval;
}
/** Same thing, but with compound unary transitions */
public void testCompoundUnaryTransitions() {
for (String treeText : treeStrings) {
Tree tree = convertTree(treeText);
List<Transition> transitions = CreateTransitionSequence.createTransitionSequence(tree, true);
State state = ShiftReduceParser.initialStateFromGoldTagTree(tree);
for (Transition transition : transitions) {
state = transition.apply(state);
}
assertEquals(tree, state.stack.peek());
}
}
public static BufferedImage createBlurbGraphic(Dimension preferredSize) {
BufferedImage frameA = AbstractTransition.createImage(400, "A", true, true);
BufferedImage frameB = AbstractTransition.createImage(400, "B", false, true);
BufferedImage finalImage = new BufferedImage(400, 400, BufferedImage.TYPE_INT_ARGB);
Transition transition = new CubeTransition3D(Transition.LEFT, true, Color.WHITE);
float fraction = .55f;
Graphics2D g = finalImage.createGraphics();
g.setRenderingHints(Transition2DDemo.createQualityHints());
transition.paint(g, frameA, frameB, fraction);
g.dispose();
return finalImage;
}
public void addTransition(Transition transition) {
if (!transitions.isEmpty()
&& !transition.getS().equals(transitions.get(transitions.size() - 1).getsPrime())) {
throw new RuntimeException(
"Cannot add transition. Initial state is not the same as final state of previous transition");
}
if (allStates.isEmpty()) {
allStates.add(transition.getS());
}
transitions.add(transition);
allStates.add(transition.getsPrime());
}
