public List<GridState> getAdjacentStates(GridState s) {
List<GridState> result = new ArrayList<GridState>();
GridState northState = this.getState(s.getRow() - 1, s.getColumn());
GridState southState = this.getState(s.getRow() + 1, s.getColumn());
GridState eastState = this.getState(s.getRow(), s.getColumn() + 1);
GridState westState = this.getState(s.getRow(), s.getColumn() - 1);
if (!isStateBlocked(northState)) {
result.add(northState);
}
if (!isStateBlocked(southState)) {
result.add(southState);
}
if (!isStateBlocked(eastState)) {
result.add(eastState);
}
if (!isStateBlocked(westState)) {
result.add(westState);
}
if (!isStateBlocked(s)) {
result.add(s);
}
return result;
}
private void applyEvent(GridEvent event) {
String fullJobId = event.getJobId();
GridJob job = state.getJobByFullId(fullJobId);
// Update the run state
state.applyEvent(event);
// Update the actor state
switch (event.getType()) {
case SUB:
if (job == null) {
job = new GridJob(event.getSnapshotJob());
}
applySub(job);
break;
case START:
if (job == null) {
log.error("Cannot start null job");
} else {
applyStart(job);
}
break;
case END:
if (job == null) {
log.error("Cannot end null job");
} else {
applyEnd(job, event.getOffset());
}
break;
default:
log.warn("Unrecognized event type: {}", event.getType());
break;
}
}
public Goal(GridState state) {
char[][][] wWorld = state.getWumpusWorld();
int size = state.getWorldSize();
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
if (wWorld[i][j][2] == 'G') {
this.locationOfGold = new XYPair(j, i);
break;
}
}
public Action determineActionToState(GridState currentState, GridState targetState) {
int rowDiff = currentState.getRow() - targetState.getRow();
int colDiff = currentState.getColumn() - targetState.getColumn();
if (rowDiff == 0 && colDiff == 0) return null;
if (Math.abs(rowDiff) >= Math.abs(colDiff)) {
if (rowDiff < 0) return GridWorld.ACTION_SOUTH;
else return GridWorld.ACTION_NORTH;
} else {
if (colDiff < 0) return GridWorld.ACTION_EAST;
else return GridWorld.ACTION_WEST;
}
}
private void initState() {
int numNodes = state.getNodeMap().size();
int numSlots = numNodes * slotsPerNode;
this.legend = new Legend(null, null, 0);
int latSides = (int) Math.ceil(Math.pow(numNodes, 1 / 3.0));
log.info("Lattice of " + numNodes + " requires " + latSides + " per side");
this.lattice = new Lattice<Lattice<Void>>(latSides);
List<String> nodeNames = new ArrayList<String>();
List<Lattice<Void>> nodeLatti = new ArrayList<Lattice<Void>>();
for (GridNode node : state.getNodeMap().values()) {
Lattice<Void> nodeLattice = new Lattice<Void>(nodeLatSides);
List<String> slotNames = new ArrayList<String>();
List<Void> slots = new ArrayList<Void>();
for (int i = 0; i < slotsPerNode; i++) {
slotNames.add("" + i);
slots.add(null);
}
nodeLattice.addItems(slotNames, slots);
nodeNames.add(node.getShortName());
nodeLatti.add(nodeLattice);
// log.warn("Adding lattice for node "+node.getShortName());
}
lattice.addItems(nodeNames, nodeLatti);
// Initialize actors from the grid state
for (GridNode node : state.getNodeMap().values()) {
int s = 0;
for (GridJob job : node.getSlots()) {
if (job == null) continue;
String slotName = s + "";
JobActor jobActor = createJobActor(job);
jobActor.pos = getLatticePos(node.getShortName(), slotName);
log.info(
"Starting job {} on slot: {}",
job.getFullJobId(),
node.getShortName() + "#" + slotName);
addJobActor(job.getFullJobId(), jobActor);
s++;
}
}
}
private JobActor cloneJobActor(String fullJobId) {
Collection<JobActor> actors = jobActorMap.get(fullJobId);
if (actors == null || actors.isEmpty()) {
log.error("Cannot expand actors for non-existing job: " + fullJobId);
return null;
}
JobActor jobActor = actors.iterator().next(); // first actor
GridJob job = state.getJobByFullId(fullJobId);
if (job == null) {
log.error("Cannot expand actors for unknown job: " + fullJobId);
return null;
}
JobActor copy = jobActor.copy();
copy.name += "#" + actors.size();
jobActorMap.put(fullJobId, copy);
return copy;
}
public static double euclideanDistance(GridState s1, GridState s2) {
double d =
EncogMath.square(s1.getRow() - s2.getRow())
+ EncogMath.square(s1.getColumn() - s2.getColumn());
return Math.sqrt(d);
}
@Override
public void run() {
while (true) {
switch (playState) {
case BUFFERING:
bufferToNextPosition();
break;
case PLAYING:
Date currDate = new Date();
long elapsed = (int) ((currDate.getTime() - lastSliceRequestDate.getTime()) * playSpeed);
this.lastSliceRequestDate = currDate;
// Check if we've been truncated, and move forward if necessary
if (totalElapsed < timeline.getFirstOffset()) {
log.info(
"Elapsed time ({}) occurs before the current timeline ({})",
totalElapsed,
timeline.getFirstOffset());
long position = elapsed;
boolean noMatch = true;
while (noMatch) {
if (position != timeline.getFirstOffset()) {
position = timeline.getFirstOffset();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// Ignore
}
} else {
noMatch = false;
}
}
log.info("Will buffer to new position: {}", position);
bufferAtPosition(position);
break;
}
// Update actors and build a usage map
Map<String, Integer> slotsUsedByUser = new HashMap<String, Integer>();
Iterator<? extends Actor> i = getJobActors().values().iterator();
while (i.hasNext()) {
Actor actor = i.next();
if (actor instanceof JobActor) {
JobActor jobActor = (JobActor) actor;
if (jobActor.defunct) {
removeJobActor(jobActor.name, jobActor);
} else {
int slots = 1;
if (jobActor.queued) {
// If a job is queued then it is represented by a single sprite, so we need the
// actual number of slots
GridJob job = state.getJobByFullId(jobActor.name);
if (job != null) {
slots = job.getSlots();
}
}
if (jobActor.getName().contains(":")) {
// Parse a jobId like this: 1275988.2828-4000:1
try {
Pattern p = Pattern.compile("(\\d+)\\.(\\d+)-(\\d+):(\\d+)");
Matcher m = p.matcher(jobActor.getName());
if (m.matches()) {
int start = Integer.parseInt(m.group(2));
int end = Integer.parseInt(m.group(3));
int interval = Integer.parseInt(m.group(4));
slots = (end - start) / interval;
}
} catch (Exception e) {
log.error("Error parsing jobId: " + jobActor.getName(), e);
}
} else if (jobActor.getName().contains(",")) {
// Parse a jobId like this: 2968157.205,211
try {
Pattern p = Pattern.compile("(\\d+)\\.(\\d+),(\\d+)");
Matcher m = p.matcher(jobActor.getName());
if (m.matches()) {
int first = Integer.parseInt(m.group(2));
int second = Integer.parseInt(m.group(3));
// There are two jobs listed here, so we require twice the number of slots
slots *= 2;
}
} catch (Exception e) {
log.error("Error parsing jobId: " + jobActor.getName(), e);
}
}
String user = jobActor.getUsername();
if (!slotsUsedByUser.containsKey(user)) {
slotsUsedByUser.put(user, 0);
}
if (!jobActor.queued) {
slotsUsedByUser.put(user, slotsUsedByUser.get(user) + slots);
}
}
}
}
legend.retain(slotsUsedByUser);
updateState(elapsed);
break;
case READY:
break;
case PAUSED:
break;
case END:
return;
default:
log.error("Invalid play state: " + playState);
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// Ignore
}
}
}
