/** This method is from GPSListener, used to notify the ProximityListener. */ public void sentenceReceived(NMEASentence sen) { // Check if this sentence has location info if (sen.getHeader().equals(GGASentence.HEADER)) { Coordinates cur = null; Location loc = null; try { loc = this.getLocation(-1); cur = loc.getQualifiedCoordinates(); } catch (InterruptedException e) { // TODO: This method should bail properly if it fails. System.err.println("Fail 1"); } catch (LocationException e) { // TODO: This method should bail properly if it fails. System.err.println("Fail 2"); } for (int i = 0; i < listeners.size(); i++) { Object[] array = listeners.get(i); ProximityListener pl = (ProximityListener) array[0]; Coordinates to = (Coordinates) array[1]; Float rad = (Float) array[2]; // Now check radius against coordinate and notify listener. if (cur.distance(to) <= rad.floatValue()) { // Remove this ProximityListener because it should be notified only once. // I prefer to do this BEFORE notifying the pl because the user might try // to re-add the pl in proximityEvent(). LocationProvider.removeProximityListener(pl); pl.proximityEvent(to, loc); } } // TODO: Handle LocationListeners here instead of inner? } }
/** if this line can not be current => stepOver & return true. return false on the other hand. */ boolean resolveCanBeCurrent(ThreadReference tr) { try { Location l = tr.frame(0).location(); if (l == null) return false; return resolveCanBeCurrent( tr, Utils.getLineForSource(l.declaringType().name(), l.sourceName(), l.lineNumber())); } catch (Exception e) { } return false; }
private Orderable parseMove(ParseContext pc, OrderPrefix op, final String[] tokens) throws OrderException { /* 3-StP: Army St Petersburg -> Moscow. (*bounce*) 1-Smy: Army Constantinople -> Aegean Sea -> Greece. keep parsing Locations until END or a -> is reached. so we keep looking for a -> until no more are found. if we have more than one, we'll add them to a list and then add that to the order Move order. */ LinkedList pathList = new LinkedList(); int idx = op.tokenIndex; int movTokIdx = findNextMoveToken(idx, tokens); while (movTokIdx != -1) { Location loc = parseLocation(pc, idx, movTokIdx, tokens); pathList.addLast(loc.getProvince()); idx = movTokIdx + 1; movTokIdx = findNextMoveToken(idx, tokens); } // add last location final Location loc = parseLocation(pc, idx, tokens.length, tokens); pathList.addLast(loc.getProvince()); // create Move order if (pathList.size() == 1) { if (pc.isRetreatPhase()) { return pc.orderFactory.createRetreat(op.power, op.location, op.unit, loc); } else { return pc.orderFactory.createMove(op.power, op.location, op.unit, loc); } } else if (pathList.size() > 1) { if (pc.isRetreatPhase()) { throw new OrderException("Convoyed Retreat orders are not allowed. Order: " + pc.orderText); } // add source location at beginning of move list pathList.addFirst(op.location.getProvince()); final Province[] route = (Province[]) pathList.toArray(new Province[pathList.size()]); return pc.orderFactory.createMove(op.power, op.location, op.unit, loc, route); } else { // this probably will not occur.... throw new OrderException("Invalid movement path in Move order: " + pc.orderText); } } // parseMove()
/** * Calculates whether certain Location is suitable for spawning a new Building (out of bounds, * overlapping) * * @param loc Location that should be checked * @return Boolean indicating elgibility to spawn new Building * @see Building */ public Boolean checkPositionElgibility(Location loc) { for (Building b : WorldManager.getInstance().getBuildings()) { if (loc.X() >= b.getPosition().X() - SimulationConfig.getBuildingSpriteWidth() && loc.X() <= b.getPosition().X() + SimulationConfig.getBuildingSpriteWidth() && loc.Y() >= b.getPosition().Y() - SimulationConfig.getBuildingSpriteHeight() && loc.Y() <= b.getPosition().Y() + SimulationConfig.getBuildingSpriteHeight()) return false; } return true; }
public void move() { if (last_move_time == null || last_move_time.doubleValue() < world.time) { last_move_time = new Double(world.time); double max_dist, dist_right, dist_left, theta, x, y, dist_diff; double delta_theta, turn_radius, new_theta, new_x, new_y; Location location; Orientation orientation; orientation = orientation(); location = location(); max_dist = max_speed / world.ticks_per_second; dist_right = right_motor.output() * max_dist; dist_left = left_motor.output() * max_dist; theta = orientation.theta; x = location.x; y = location.y; old_location.x = x; old_location.y = y; dist_diff = dist_right - dist_left; // System.out.println("dist_diff: " + dist_diff); delta_theta = dist_diff / wheel_base; if (Math.abs(dist_diff) < .0001) { turn_radius = 0.0; } else { turn_radius = (dist_right / delta_theta) - (wheel_base / 2); } // System.out.println("turn_radius: " + turn_radius); new_theta = theta + delta_theta; if (turn_radius == 0.0) { // System.out.println("turn_radius == 0"); new_x = x + Math.cos(theta) * dist_left; new_y = y + Math.sin(theta) * dist_left; } else { // System.out.println("new_theta= " + new_theta + " theta= " + theta); new_x = x + ((Math.sin(new_theta) - Math.sin(theta)) * turn_radius); new_y = y - ((Math.cos(new_theta) - Math.cos(theta)) * turn_radius); } orientation.theta = new_theta; location.x = new_x; location.y = new_y; maybe_fire_guns(); } }
public WorldEditorException(final String msg, final Location loc) { super( msg + " at " + loc.getWorld().getName() + ":" + loc.getBlockX() + ":" + loc.getBlockY() + ":" + loc.getBlockZ()); this.loc = loc; }
static synchronized String sourceLine(Location location, int lineNumber) throws IOException { if (lineNumber == -1) { throw new IllegalArgumentException(); } try { String fileName = location.sourceName(); Iterator<SourceCode> iter = sourceCache.iterator(); SourceCode code = null; while (iter.hasNext()) { SourceCode candidate = iter.next(); if (candidate.fileName().equals(fileName)) { code = candidate; iter.remove(); break; } } if (code == null) { BufferedReader reader = sourceReader(location); if (reader == null) { throw new FileNotFoundException(fileName); } code = new SourceCode(fileName, reader); if (sourceCache.size() == SOURCE_CACHE_SIZE) { sourceCache.remove(sourceCache.size() - 1); } } sourceCache.add(0, code); return code.sourceLine(lineNumber); } catch (AbsentInformationException e) { throw new IllegalArgumentException(); } }
public int compareTo(Object other) { int thisLoc = mStart.getLocation(); int thatLoc = ((Entry) other).mStart.getLocation(); if (thisLoc < thatLoc) { return -1; } else if (thisLoc > thatLoc) { return 1; } else { return 0; } }
public void testLocation() throws Exception { JSONArray array = getJSONArrayFromClassPath("/dao/trends-available.json"); ResponseList<Location> locations = LocationJSONImpl.createLocationList(array, conf.isJSONStoreEnabled()); Assert.assertEquals(23, locations.size()); Location location = locations.get(0); Assert.assertEquals("GB", location.getCountryCode()); Assert.assertEquals("United Kingdom", location.getCountryName()); Assert.assertEquals("United Kingdom", location.getName()); Assert.assertEquals(12, location.getPlaceCode()); Assert.assertEquals("Country", location.getPlaceName()); Assert.assertEquals("http://where.yahooapis.com/v1/place/23424975", location.getURL()); Assert.assertEquals(23424975, location.getWoeid()); }
public void setProperty(final String path, final Location loc) { set((path == null ? "" : path + ".") + "world", loc.getWorld().getName()); set((path == null ? "" : path + ".") + "x", loc.getX()); set((path == null ? "" : path + ".") + "y", loc.getY()); set((path == null ? "" : path + ".") + "z", loc.getZ()); set((path == null ? "" : path + ".") + "yaw", loc.getYaw()); set((path == null ? "" : path + ".") + "pitch", loc.getPitch()); }
private void dumpStack(ThreadReference thread, boolean showPC) { // ### Check for these. // env.failure("Thread no longer exists."); // env.failure("Target VM must be in interrupted state."); // env.failure("Current thread isn't suspended."); // ### Should handle extremely long stack traces sensibly for user. List<StackFrame> stack = null; try { stack = thread.frames(); } catch (IncompatibleThreadStateException e) { env.failure("Thread is not suspended."); } // ### Fix this! // ### Previously mishandled cases where thread was not current. // ### Now, prints all of the stack regardless of current frame. int frameIndex = 0; // int frameIndex = context.getCurrentFrameIndex(); if (stack == null) { env.failure("Thread is not running (no stack)."); } else { OutputSink out = env.getOutputSink(); int nFrames = stack.size(); for (int i = frameIndex; i < nFrames; i++) { StackFrame frame = stack.get(i); Location loc = frame.location(); Method meth = loc.method(); out.print(" [" + (i + 1) + "] "); out.print(meth.declaringType().name()); out.print('.'); out.print(meth.name()); out.print(" ("); if (meth.isNative()) { out.print("native method"); } else if (loc.lineNumber() != -1) { try { out.print(loc.sourceName()); } catch (AbsentInformationException e) { out.print("<unknown>"); } out.print(':'); out.print(loc.lineNumber()); } out.print(')'); if (showPC) { long pc = loc.codeIndex(); if (pc != -1) { out.print(", pc = " + pc); } } out.println(); } out.show(); } }
/** Executes breakpoint hit event. */ public void exec(com.sun.jdi.event.Event ev) { // S ystem.out.println ("exec "); // NOI18N removeStepRequest(); StepEvent event = (StepEvent) ev; ThreadReference tr = event.thread(); Location loc = event.location(); int ln = -1; String methodName = "?"; // NOI18N String className = "?"; // NOI18N String lineNumber = "?"; // NOI18N String threadName = tr.name(); Line l = null; if (loc != null) { if (loc.method() != null) methodName = loc.method().name(); className = loc.declaringType().name(); ln = loc.lineNumber(); if (ln >= 0) lineNumber = "" + loc.lineNumber(); } if (ln != -1) try { l = Utils.getLineForSource(className, loc.sourceName(), ln); } catch (AbsentInformationException e) { l = Utils.getLine(className, ln); } if (resolveCanBeCurrent(tr, l)) // if this line can not be current resolveCanBeCurrent () calls stepOver return; // line can be current if ((l == null) && (getLastAction() == ACTION_TRACE_INTO)) // try to find another "intelligent" line of code traceToSourceCode(tr); // you know - intelligent means that one with source code else { makeCurrent(threadName, className, methodName, lineNumber, l != null, tr); operator.stopRequest(); } }
public static Location toCenter(Location l) { return new Location(l.getWorld(), l.getBlockX() + .5, l.getBlockY() + 1, l.getBlockZ() + .5); }
private void commandList(StringTokenizer t) throws NoSessionException { ThreadReference current = context.getCurrentThread(); if (current == null) { env.error("No thread specified."); return; } Location loc; try { StackFrame frame = context.getCurrentFrame(current); if (frame == null) { env.failure("Thread has not yet begun execution."); return; } loc = frame.location(); } catch (VMNotInterruptedException e) { env.failure("Target VM must be in interrupted state."); return; } SourceModel source = sourceManager.sourceForLocation(loc); if (source == null) { if (loc.method().isNative()) { env.failure("Current method is native."); return; } env.failure("No source available for " + Utils.locationString(loc) + "."); return; } ReferenceType refType = loc.declaringType(); int lineno = loc.lineNumber(); if (t.hasMoreTokens()) { String id = t.nextToken(); // See if token is a line number. try { lineno = Integer.valueOf(id).intValue(); } catch (NumberFormatException nfe) { // It isn't -- see if it's a method name. List<Method> meths = refType.methodsByName(id); if (meths == null || meths.size() == 0) { env.failure( id + " is not a valid line number or " + "method name for class " + refType.name()); return; } else if (meths.size() > 1) { env.failure(id + " is an ambiguous method name in" + refType.name()); return; } loc = meths.get(0).location(); lineno = loc.lineNumber(); } } int startLine = (lineno > 4) ? lineno - 4 : 1; int endLine = startLine + 9; String sourceLine = source.sourceLine(lineno); if (sourceLine == null) { env.failure("" + lineno + " is an invalid line number for " + refType.name()); } else { OutputSink out = env.getOutputSink(); for (int i = startLine; i <= endLine; i++) { sourceLine = source.sourceLine(i); if (sourceLine == null) { break; } out.print(i); out.print("\t"); if (i == lineno) { out.print("=> "); } else { out.print(" "); } out.println(sourceLine); } out.show(); } }
/** * Move through a list of stack frames, searching for references to code found in the current * sketch. Return with a RunnerException that contains the location of the error, or if nothing is * found, just return with a RunnerException that wraps the error message itself. */ protected SketchException findException( String message, ObjectReference or, ThreadReference thread) { try { // use to dump the stack for debugging // for (StackFrame frame : thread.frames()) { // System.out.println("frame: " + frame); // } List<StackFrame> frames = thread.frames(); for (StackFrame frame : frames) { try { Location location = frame.location(); String filename = null; filename = location.sourceName(); int lineNumber = location.lineNumber() - 1; SketchException rex = build.placeException(message, filename, lineNumber); if (rex != null) { return rex; } } catch (AbsentInformationException e) { // Any of the thread.blah() methods can throw an AbsentInformationEx // if that bit of data is missing. If so, just write out the error // message to the console. // e.printStackTrace(); // not useful exception = new SketchException(message); exception.hideStackTrace(); listener.statusError(exception); } } } catch (IncompatibleThreadStateException e) { // This shouldn't happen, but if it does, print the exception in case // it's something that needs to be debugged separately. e.printStackTrace(); } // before giving up, try to extract from the throwable object itself // since sometimes exceptions are re-thrown from a different context try { // assume object reference is Throwable, get stack trace Method method = ((ClassType) or.referenceType()) .concreteMethodByName("getStackTrace", "()[Ljava/lang/StackTraceElement;"); ArrayReference result = (ArrayReference) or.invokeMethod( thread, method, new ArrayList<Value>(), ObjectReference.INVOKE_SINGLE_THREADED); // iterate through stack frames and pull filename and line number for each for (Value val : result.getValues()) { ObjectReference ref = (ObjectReference) val; method = ((ClassType) ref.referenceType()) .concreteMethodByName("getFileName", "()Ljava/lang/String;"); StringReference strref = (StringReference) ref.invokeMethod( thread, method, new ArrayList<Value>(), ObjectReference.INVOKE_SINGLE_THREADED); String filename = strref == null ? "Unknown Source" : strref.value(); method = ((ClassType) ref.referenceType()).concreteMethodByName("getLineNumber", "()I"); IntegerValue intval = (IntegerValue) ref.invokeMethod( thread, method, new ArrayList<Value>(), ObjectReference.INVOKE_SINGLE_THREADED); int lineNumber = intval.intValue() - 1; SketchException rex = build.placeException(message, filename, lineNumber); if (rex != null) { return rex; } } // for (Method m : ((ClassType) or.referenceType()).allMethods()) { // System.out.println(m + " | " + m.signature() + " | " + m.genericSignature()); // } // Implemented for 2.0b9, writes a stack trace when there's an internal error inside core. method = ((ClassType) or.referenceType()).concreteMethodByName("printStackTrace", "()V"); // System.err.println("got method " + method); or.invokeMethod( thread, method, new ArrayList<Value>(), ObjectReference.INVOKE_SINGLE_THREADED); } catch (Exception e) { e.printStackTrace(); } // Give up, nothing found inside the pile of stack frames SketchException rex = new SketchException(message); // exception is being created /here/, so stack trace is not useful rex.hideStackTrace(); return rex; }
@SuppressWarnings("unchecked") public void load() { for (String s : worlds) { //////////// --------- Tubes ------------ /////////////// try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + File.separator + s + "Tubes.loc")); Object result = ois.readObject(); ArrayList<String> t = new ArrayList<String>(); t = (ArrayList<String>) result; ArrayList<Location> holder = new ArrayList<Location>(); for (String x : t) { String[] split = x.split(","); holder.add( new Location( server.getWorld(split[0]), toInt(split[1]), toInt(split[2]), toInt(split[3]))); } tubes.put(s, holder); if (tubes == null || tubes.get(s) == null) { tubes.put(s, new ArrayList<Location>()); } } catch (Exception e) { // e.printStackTrace(); } //////////// --------- Tubes End ------------ /////////////// //////////// --------- cornucopia ------------ /////////////// try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + File.separator + s + "Corn.loc")); Object result = ois.readObject(); String[] split = ((String) result).split(","); Location c = new Location( server.getWorld(split[0]), toInt(split[1]), toInt(split[2]), toInt(split[3])); ServerGames.cornucopia.put(s, c); } catch (Exception e) { // e.printStackTrace(); } //////////// --------- cornucopia End ------------ /////////////// } //////////// --------- Score ------------ /////////////// try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + File.separator + "Score.loc")); Object result = ois.readObject(); score = (HashMap<String, Integer>) result; } catch (Exception e) { // e.printStackTrace(); } //////////// --------- Score End ------------ /////////////// //////////// --------- Waiting ------------ /////////////// try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + File.separator + "Wait.loc")); Object result = ois.readObject(); String[] split = ((String) result).split(","); Location w = new Location( server.getWorld(split[0]), toInt(split[1]), toInt(split[2]), toInt(split[3])); ServerGames.waiting = w; } catch (Exception e) { // e.printStackTrace(); } //////////// --------- Waiting End ------------ /////////////// //////////// --------- Shop ------------ /////////////// try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + File.separator + "Shops.loc")); Object result = ois.readObject(); ArrayList<String> it = ((ArrayList<String>) result); for (String i : it) { String[] split = i.split(","); int id = Integer.parseInt(split[0]); int score = Integer.parseInt(split[1]); Location w = new Location( server.getWorld(split[2]), toInt(split[3]), toInt(split[4]), toInt(split[5])); items.add(new ShopItem(w.getWorld().getBlockAt(w), id, score)); } } catch (Exception e) { // e.printStackTrace(); } //////////// --------- Shop End ------------ /////////////// //////////// --------- Shop ------------ /////////////// try { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path + File.separator + "Shop.loc")); Object result = ois.readObject(); String[] split = ((String) result).split(","); Location s = new Location( server.getWorld(split[0]), toInt(split[1]), toInt(split[2]), toInt(split[3])); ServerGames.shop = s; } catch (Exception e) { // e.printStackTrace(); } //////////// --------- Shop End ------------ /////////////// }
public void save() { File file = null; for (String s : worlds) { //////////// --------- Tubes ------------ /////////////// if (tubes != null && tubes.get(s) != null) { file = new File(path + File.separator + s + "Tubes.loc"); new File(path).mkdir(); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { // e.printStackTrace(); } } ArrayList<String> t = new ArrayList<String>(); for (Location x : tubes.get(s)) { t.add( x.getWorld().getName() + "," + x.getBlockX() + "," + x.getBlockY() + "," + x.getBlockZ()); } try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + File.separator + s + "Tubes.loc")); oos.writeObject(t); oos.flush(); oos.close(); } catch (Exception e) { // e.printStackTrace(); } } //////////// --------- Tubes End ------------ /////////////// //////////// --------- cornucopia ------------ /////////////// if (cornucopia.get(s) != null) { file = new File(path + File.separator + s + "Corn.loc"); new File(path).mkdir(); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { // e.printStackTrace(); } } String c = ""; c = (cornucopia.get(s).getWorld().getName() + "," + cornucopia.get(s).getBlockX() + "," + cornucopia.get(s).getBlockY() + "," + cornucopia.get(s).getBlockZ()); cornucopia .get(s) .getWorld() .setSpawnLocation( cornucopia.get(s).getBlockX(), cornucopia.get(s).getBlockY(), cornucopia.get(s).getBlockZ()); try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + File.separator + s + "Corn.loc")); oos.writeObject(c); oos.flush(); oos.close(); } catch (Exception e) { // e.printStackTrace(); } } //////////// --------- cornucopia End ------------ /////////////// } //////////// --------- Waiting ------------ /////////////// if (waiting != null) { file = new File(path + File.separator + "Wait.loc"); new File(path).mkdir(); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } String w = ""; w = (waiting.getWorld().getName() + "," + waiting.getBlockX() + "," + waiting.getBlockY() + "," + waiting.getBlockZ()); try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + File.separator + "Wait.loc")); oos.writeObject(w); oos.flush(); oos.close(); } catch (Exception e) { // e.printStackTrace(); } } //////////// --------- Waiting End ------------ /////////////// //////////// --------- Score ------------ /////////////// if (score != null) { file = new File(path + File.separator + "Score.loc"); new File(path).mkdir(); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + File.separator + "Score.loc")); oos.writeObject(score); oos.flush(); oos.close(); } catch (Exception e) { // e.printStackTrace(); } } //////////// --------- Score End ------------ /////////////// //////////// --------- Shops ------------ /////////////// if (items != null) { file = new File(path + File.separator + "Shops.loc"); new File(path).mkdir(); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } ArrayList<String> it = new ArrayList<String>(); for (ShopItem i : items) { String ss = i.id + "," + i.price + "," + i.holder.getLocation().getWorld().getName() + "," + i.holder.getLocation().getX() + "," + i.holder.getLocation().getY() + "," + i.holder.getLocation().getZ(); it.add(ss); } try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + File.separator + "Shops.loc")); oos.writeObject(it); oos.flush(); oos.close(); } catch (Exception e) { // e.printStackTrace(); } } //////////// --------- Shops End ------------ /////////////// //////////// --------- Shop ------------ /////////////// if (waiting != null) { file = new File(path + File.separator + "Shop.loc"); new File(path).mkdir(); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } String s = ""; s = (shop.getWorld().getName() + "," + shop.getBlockX() + "," + shop.getBlockY() + "," + shop.getBlockZ()); try { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path + File.separator + "Shop.loc")); oos.writeObject(s); oos.flush(); oos.close(); } catch (Exception e) { // e.printStackTrace(); } } //////////// --------- Shop End ------------ /////////////// }
/** Get source object associated with a Location. */ public SourceModel sourceForLocation(Location loc) { return sourceForClass(loc.declaringType()); }
public boolean equals(Object other) { if (other instanceof Entry) { return mStart.getLocation() == ((Entry) other).mStart.getLocation(); } return false; }
public String toString() { return "start_pc=" + mStart.getLocation() + " => " + "line_number=" + mLineNumber; }