private void adjustDateLineCrossingPoints() { ArrayList<LatLon> corners = new ArrayList<LatLon>(Arrays.asList(sw, se, nw, ne)); if (!LatLon.locationsCrossDateLine(corners)) return; double lonSign = 0; for (LatLon corner : corners) { if (Math.abs(corner.getLongitude().degrees) != 180) lonSign = Math.signum(corner.getLongitude().degrees); } if (lonSign == 0) return; if (Math.abs(sw.getLongitude().degrees) == 180 && Math.signum(sw.getLongitude().degrees) != lonSign) sw = new Position(sw.getLatitude(), sw.getLongitude().multiply(-1), sw.getElevation()); if (Math.abs(se.getLongitude().degrees) == 180 && Math.signum(se.getLongitude().degrees) != lonSign) se = new Position(se.getLatitude(), se.getLongitude().multiply(-1), se.getElevation()); if (Math.abs(nw.getLongitude().degrees) == 180 && Math.signum(nw.getLongitude().degrees) != lonSign) nw = new Position(nw.getLatitude(), nw.getLongitude().multiply(-1), nw.getElevation()); if (Math.abs(ne.getLongitude().degrees) == 180 && Math.signum(ne.getLongitude().degrees) != lonSign) ne = new Position(ne.getLatitude(), ne.getLongitude().multiply(-1), ne.getElevation()); }
private int wrapPositionForTabbedTextWithOptimization( @NotNull CharSequence text, int tabSize, int startLineOffset, int endLineOffset, int targetRangeEndOffset) { int width = 0; int symbolWidth; int result = Integer.MAX_VALUE; boolean wrapLine = false; for (int i = startLineOffset; i < Math.min(endLineOffset, targetRangeEndOffset); i++) { char c = text.charAt(i); switch (c) { case '\t': symbolWidth = tabSize - (width % tabSize); break; default: symbolWidth = 1; } if (width + symbolWidth + FormatConstants.RESERVED_LINE_WRAP_WIDTH_IN_COLUMNS >= mySettings.RIGHT_MARGIN && (Math.min(endLineOffset, targetRangeEndOffset) - i) >= FormatConstants.RESERVED_LINE_WRAP_WIDTH_IN_COLUMNS) { // Remember preferred position. result = i - 1; } if (width + symbolWidth >= mySettings.RIGHT_MARGIN) { wrapLine = true; break; } width += symbolWidth; } return wrapLine ? result : -1; }
/* * We completed handling of a filtered block. Update false-positive estimate based * on the total number of transactions in the original block. * * count includes filtered transactions, transactions that were passed in and were relevant * and transactions that were false positives (i.e. includes all transactions in the block). */ protected void trackFilteredTransactions(int count) { // Track non-false-positives in batch. Each non-false-positive counts as // 0.0 towards the estimate. // // This is slightly off because we are applying false positive tracking before non-FP tracking, // which counts FP as if they came at the beginning of the block. Assuming uniform FP // spread in a block, this will somewhat underestimate the FP rate (5% for 1000 tx block). double alphaDecay = Math.pow(1 - FP_ESTIMATOR_ALPHA, count); // new_rate = alpha_decay * new_rate falsePositiveRate = alphaDecay * falsePositiveRate; double betaDecay = Math.pow(1 - FP_ESTIMATOR_BETA, count); // trend = beta * (new_rate - old_rate) + beta_decay * trend falsePositiveTrend = FP_ESTIMATOR_BETA * count * (falsePositiveRate - previousFalsePositiveRate) + betaDecay * falsePositiveTrend; // new_rate += alpha_decay * trend falsePositiveRate += alphaDecay * falsePositiveTrend; // Stash new_rate in old_rate previousFalsePositiveRate = falsePositiveRate; }
public Unit() { trm = (Math.random() * 10) - 5; prm = (Math.random() * 10) - 5; wtm = (Math.random() * 10) - 5; tkm = (Math.random() * 10) - 5; ped = (Math.random() * 5) + 5; }
// Returns the distance between two planets, rounded up to the next highest // integer. This is the number of discrete time steps it takes to get // between the two planets. public int Distance(int sourcePlanet, int destinationPlanet) { Planet source = planets.get(sourcePlanet); Planet destination = planets.get(destinationPlanet); double dx = source.X() - destination.X(); double dy = source.Y() - destination.Y(); return (int) Math.ceil(Math.sqrt(dx * dx + dy * dy)); }
public double nextDouble() { int c = read(); while (isSpaceChar(c)) c = read(); int sgn = 1; if (c == '-') { sgn = -1; c = read(); } double res = 0; while (!isSpaceChar(c) && c != '.') { if (c == 'e' || c == 'E') return res * Math.pow(10, nextInt()); if (c < '0' || c > '9') throw new InputMismatchException(); res *= 10; res += c - '0'; c = read(); } if (c == '.') { c = read(); double m = 1; while (!isSpaceChar(c)) { if (c == 'e' || c == 'E') return res * Math.pow(10, nextInt()); if (c < '0' || c > '9') throw new InputMismatchException(); m /= 10; res += (c - '0') * m; c = read(); } } return res * sgn; }
/** * Given a tissue sample, move all unsatisfied agents to a vacant cell * * @param tissue a 2-D character array that has been initialized * @param threshold the percentage of like agents that must surround the agent to be satisfied */ public static int moveAllUnsatisfied(char[][] tissue, int threshold) { ArrayList<Integer> list2 = new ArrayList<Integer>(); int counter = 0; ArrayList<Integer> list1 = new ArrayList<Integer>(); for (int i = 0; i < tissue.length; i++) { for (int x = 0; x < tissue[0].length; x++) { if (isSatisfied(tissue, i, x, threshold) == false) { list1.add(i); list2.add(x); } } } int num = list1.size(); char temp; int count = 0; do { int rand = (int) (Math.random() * tissue.length); int random = (int) (Math.random() * tissue.length); if (tissue[rand][random] == ' ') { temp = tissue[rand][random]; tissue[rand][random] = tissue[list1.get(counter)][list2.get(counter)]; tissue[list1.get(counter)][list2.get(counter)] = temp; counter++; count++; } } while (counter != num); return count; }
public int[] solve(String[] edgeStrings) { ArrayList<Integer> oddPoints = new ArrayList<Integer>(); int min = Integer.MAX_VALUE; for (String s : edgeStrings) { StringTokenizer st = new StringTokenizer(s); int from = Integer.parseInt(st.nextToken()); int to = Integer.parseInt(st.nextToken()); edges.add(new Edge(from, to)); min = Math.min(min, from); min = Math.min(min, to); oddPoint(oddPoints, from); oddPoint(oddPoints, to); } assert (oddPoints.size() < 3); if (oddPoints.size() > 0) { dfs(min(oddPoints)); return toArray(circuit); } else { dfs(min); return toArray(circuit); } }
public void paint(Graphics gg) { int faceSize = Math.min(getWidth() - 4, getHeight() - 4); if (face == null) face = new PADFaceMapped( Math.max(2, (getWidth() - faceSize) / 2), Math.max(2, (getHeight() - faceSize) / 2), faceSize); if (buffer == null) { im = this.createImage(getWidth(), getHeight()); buffer = im.getGraphics(); } super.paint(buffer); buffer.setColor(new Color(255, 255, 255, 0)); buffer.fillRect(0, 0, im.getWidth(null), im.getHeight(null)); face.setDimensions( Math.max(2, (getWidth() - faceSize) / 2), Math.max(2, (getHeight() - faceSize) / 2), faceSize); face.paint(buffer); // draw buffer to screen gg.drawImage(im, 0, 0, null, null); }
public double distanciaEuclidiana(int x1, int x2, int y1, int y2) { double a, b, c; a = Math.pow(x2 - x1, 2); b = Math.pow(y2 - y1, 2); c = Math.sqrt(a + b); return (c); }
private void renderBlackout(Graphics g, int x, int y, int radius) { if (radius > 320) return; int[] xp = new int[20]; int[] yp = new int[20]; for (int i = 0; i < 16; i++) { xp[i] = x + (int) (Math.cos(i * Math.PI / 15) * radius); yp[i] = y + (int) (Math.sin(i * Math.PI / 15) * radius); } xp[16] = 320; yp[16] = y; xp[17] = 320; yp[17] = 240; xp[18] = 0; yp[18] = 240; xp[19] = 0; yp[19] = y; g.fillPolygon(xp, yp, xp.length); for (int i = 0; i < 16; i++) { xp[i] = x - (int) (Math.cos(i * Math.PI / 15) * radius); yp[i] = y - (int) (Math.sin(i * Math.PI / 15) * radius); } xp[16] = 320; yp[16] = y; xp[17] = 320; yp[17] = 0; xp[18] = 0; yp[18] = 0; xp[19] = 0; yp[19] = y; g.fillPolygon(xp, yp, xp.length); }
public static void main(String[] args) throws IOException { input.init(System.in); PrintWriter out = new PrintWriter(System.out); int depth = input.nextInt(); int n = (1 << (depth + 1)); int[] as = new int[n]; for (int i = 2; i < n; i++) as[i] = input.nextInt(); int[] paths = new int[n]; int max = 0; ArrayList<Integer>[] under = new ArrayList[n]; for (int i = 0; i < n; i++) under[i] = new ArrayList<Integer>(); for (int i = (1 << (depth)); i < n; i++) { int cur = i; while (cur > 1) { under[cur].add(i); paths[i] += as[cur]; cur /= 2; } max = Math.max(max, paths[i]); } int res = 0; for (int i = 2; i < n; i++) { int cm = 0; for (int x : under[i]) cm = Math.max(cm, paths[x]); int diff = max - cm; res += diff; for (int x : under[i]) paths[x] += diff; } out.println(res); out.close(); }
// evaluate Fisher score of all indexes in current ^ featIndex private double evaluateFisher(HashSet<Integer> current, int featIndex) { ArrayList<Integer> d = new ArrayList<Integer>(current); d.add(featIndex); ArrayList<ArrayList<Integer>> vectors = new ArrayList<ArrayList<Integer>>(); for (int i = 0; i < getA().get_classes().size(); i++) { ArrayList<ArrayList<Integer>> cl = getA().features.get(getA().get_classes().get(i)); ArrayList<Integer> tmp = new ArrayList<Integer>(); for (int j = 0; j < cl.size(); j++) { int sum = 0; for (int k = 0; k < d.size(); k++) sum += cl.get(j).get(d.get(k)); if (sum == d.size()) tmp.add(1); else tmp.add(0); } vectors.add(tmp); } ArrayList<double[]> stats = new ArrayList<double[]>(); int count = 0; double sum = 0.0; for (int i = 0; i < vectors.size(); i++) { double[] res = computeMeanVariance(vectors.get(i)); sum += (vectors.get(i).size() * res[0]); count += vectors.get(i).size(); stats.add(res); } sum = sum / count; double num = 0.0; double denom = 0.0; for (int i = 0; i < stats.size(); i++) { num += (vectors.get(i).size() * Math.pow(stats.get(i)[0] - sum, 2)); denom += (vectors.get(i).size() * Math.pow(stats.get(i)[1], 2)); } if (denom == 0.0) return 0; else return num / denom; }
private String getPercentsTailHelper(BigDecimal percents) { return ((percents.doubleValue() - Math.floor(percents.doubleValue())) > 0) ? " целых " + Math.round((percents.doubleValue() - Math.floor(percents.doubleValue())) * 100) + " сотых" : ""; }
void go3(int x, int y, int v, int at) { if (at == -1) return; if (y < a[at] || x > b[at]) return; val[at] += (Math.min(b[at], y) - Math.max(a[at], x) + 1) * v; go3(x, y, v, left[at]); go3(x, y, v, right[at]); }
public static void main(String[] args) { Locale[] locales = Locale.getAvailableLocales(); int min = Integer.MAX_VALUE; int max = Integer.MIN_VALUE; Map map = new HashMap(locales.length); int conflicts = 0; for (int i = 0; i < locales.length; i++) { Locale loc = locales[i]; int hc = loc.hashCode(); min = Math.min(hc, min); max = Math.max(hc, max); Integer key = new Integer(hc); if (map.containsKey(key)) { conflicts++; System.out.println("conflict: " + (Locale) map.get(key) + ", " + loc); } else { map.put(key, loc); } } System.out.println( locales.length + " locales: conflicts=" + conflicts + ", min=" + min + ", max=" + max + ", diff=" + (max - min)); if (conflicts >= (locales.length / 10)) { throw new RuntimeException( "too many conflicts: " + conflicts + " per " + locales.length + " locales"); } }
private boolean isNotSeparatorRoom(Room separatorRoom, Room joinerRoom) { if (separatorRoom == null) return false; if (separatorRoom.isRotatable() && separatorRoom != joinerRoom) { separatorRoom.rotateRightRotatedType(); rotationMap.put( separatorRoom.getDistance() - Math.abs(separatorRoom.getRotation()), separatorRoom); return false; } if (separatorRoom.isRotatable() && separatorRoom == joinerRoom && separatorRoom.getExit() != null) { if (separatorRoom.getRotatedType() == RoomType.TYPE_7) { separatorRoom.rotateRightRotatedType(); } else if (separatorRoom.getRotatedType() == RoomType.TYPE_8 && separatorRoom.getEntrance() == Direction.LEFT) { separatorRoom.rotateLeftRotatedType(); } else if (separatorRoom.getRotatedType() == RoomType.TYPE_8 && separatorRoom.getEntrance() == Direction.RIGHT) { separatorRoom.rotateRightRotatedType(); } else if (separatorRoom.getRotatedType() == RoomType.TYPE_9 && separatorRoom.getEntrance() == Direction.TOP) { separatorRoom.rotateLeftRotatedType(); } else if (separatorRoom.getRotatedType() == RoomType.TYPE_9 && separatorRoom.getEntrance() == Direction.LEFT) { separatorRoom.rotateRightRotatedType(); } rotationMap.put( separatorRoom.getDistance() - Math.abs(separatorRoom.getRotation()), separatorRoom); return false; } return true; }
/** * The assignInstance method is used to assign the instances to the centroid which is closest to * them (By squared Euclidean distance */ private static void assignInstance(double[][] centroids, double[][] instances, KMeansResult res) { // for all instances to update centroids for (int i = 0; i < instances.length; i++) { // assign each instance to its closest centroid (index starts from 0) int centerId = -1; // initially set the distance of two points to be as big as possible // (which in math is regarded as infinite) double minDistance = Double.MAX_VALUE; // loop over centroids for (int j = 0; j < centroids.length; j++) { double currDistance = 0; // dimension for (int k = 0; k < centroids[j].length; k++) { currDistance = currDistance + Math.pow(instances[i][k] - centroids[j][k], 2); } currDistance = Math.sqrt(currDistance); if (currDistance < minDistance) { // update new distance to min distance minDistance = currDistance; // update new centroid centerId = j; } } res.clusterAssignment[i] = centerId; } }
public void mouseReleased(MouseEvent e) { left_mouse_pressed = false; double kvadrat = Math.sqrt(angleX * angleX + angleY * angleY); double tempx = angleX / kvadrat; double tempy = Math.sqrt(1 - tempx * tempx); if (angleY < 0) tempy = -tempy; Bullet b = new Bullet(); boolean next = false; if (type_bullet1 == true && count_sphere > 0) { b = new Sphere(); count_sphere--; next = true; } if (type_bullet2 == true && count_fireball > 0) { b = new FireBall(); count_fireball--; next = true; } if (type_bullet3 == true && count_rocket > 0) { b = new Rocket(); count_rocket--; next = true; } if (next == true) { b.bullet_x = player.getX() + 52 + 5 * Math.cos(angle); // + 50; //koef; b.bullet_y = player.getY() + 49 + 5 * Math.sin(angle); // player.getY() + 35; //25; b.current_direction_x = tempx; b.current_direction_y = tempy; bullet.addElement(b); allow_shoot = false; } }
private void bonbakKokatu() { int b = 0; int alt; int zab; while (b < this.bonbaKop) { alt = (int) (Math.random() * this.altuera - 1); zab = (int) (Math.random() * this.zabalera - 1); if (!(alt + 1 == this.hasAlt || alt - 1 == this.hasAlt) && !(zab + 1 == this.hasZab || zab - 1 == this.hasZab)) { // If honen baldintza luzea da, hasieran click // egin dugun posizioaren alboan bonbak ez kokatzeko if (laukiak[alt][zab] == null) { laukiak[alt][zab] = new Bonba(); bonbenKoor.add(alt); bonbenKoor.add(zab); b++; } else if (laukiak[alt][zab].banderaDu()) { laukiak[alt][zab].eskuinClickEgin(alt, zab); laukiak[alt][zab] = new Bonba(); laukiak[alt][zab].eskuinClickEgin(alt, zab); bonbenKoor.add(alt); bonbenKoor.add(zab); b++; } } } System.out.println("Bonbak kokatu dira"); }
public void printLoop(int n, float x[], float y[]) { // Need to swap the y component Polygon P = new Polygon(); for (int i = 0; i < n; i++) P.addPoint(Math.round(x[i]), Math.round(height - y[i])); poly_draw.add(P); poly_draw_color.add(curColor); }
/** * Gets the maximum extent of this envelope across all three dimensions. * * @return the maximum extent of this envelope */ @Override public double maxExtent() { if (isNull()) { return 0.0; } return Math.max(getWidth(), Math.max(getHeight(), getDepth())); }
public static int gainKillExperience(Thing h, Thing t) { int hlevel = h.getLevel(); int tlevel = t.getLevel(); int killcount = 0; if (h.isHero()) { killcount = incKillCount(t); if (killcount == 1) { Score.scoreFirstKill(t); } } int base = t.getStat("XPValue"); double xp = base; xp = xp * Math.pow(experienceDecay, killcount); xp = xp * Math.pow(experienceLevelMultiplier, tlevel - 1); // decrease xp gain for killing lower level monsters if (hlevel > tlevel) xp = xp / (hlevel - tlevel); int gain = (int) xp; Hero.gainExperience(gain); return gain; }
/** Returns angle in degrees from specified origin to specified destination. */ public static int getAngle(Point origin, Point destination) // origin != destination { double distance = getDistance(origin, destination); int add = 0; int x = destination.getx() - origin.getx(); int y = origin.gety() - destination.gety(); // Java flips things around double angleRad = Math.asin(Math.abs(y) / distance); double angleDeg = Math.toDegrees(angleRad); if ((x >= 0) && (y >= 0)) // Quadrant 1 { angleDeg = angleDeg; } if ((x < 0) && (y > 0)) // Quadrant 2 { angleDeg = 180 - angleDeg; } if ((x <= 0) && (y <= 0)) // Quadrant 3 { angleDeg = 180 + angleDeg; } if ((x > 0) && (y < 0)) // Quadrant 4 { angleDeg = 360 - angleDeg; } float angleFloat = Math.round(angleDeg); int angleInt = Math.round(angleFloat); return (angleInt); }
/*12. 求二叉树中节点的最大距离 具体分析(http://blog.csdn.net/lalor/article/details/7626678) 即二叉树中相距最远的两个节点之间的距离。 递归解法: (1)如果二叉树为空,返回0,同时记录左子树和右子树的深度,都为0 (2)如果二叉树不为空,最大距离要么是左子树中的最大距离,要么是右子树中的最大距离, 要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离, 同时记录左子树和右子树节点中到根节点的最大距离。 */ public static int getMaxDistance(TreeNode node, int maxLeft, int maxRight) { // maxLeft, 左子树中的节点距离左子树根节点的最远距离 // maxRight, 右子树中的节点距离左子树根节点的最远距离 if (node == null) { maxLeft = 0; maxRight = 0; return 0; } int maxLL = 0, maxLR = 0, maxRL = 0, maxRR = 0; int maxDistLeft, maxDistRight; if (node.left != null) { maxDistLeft = getMaxDistance(node.left, maxLL, maxLR); maxLeft = Math.max(maxLL, maxLR) + 1; } else { maxDistLeft = 0; maxLeft = 0; } if (node.right != null) { maxDistRight = getMaxDistance(node.right, maxRL, maxRR); maxRight = Math.max(maxRL, maxRR) + 1; } else { maxDistRight = 0; maxRight = 0; } int result = Math.max(Math.max(maxDistLeft, maxDistRight), maxLeft + maxRight + 1); return result; }
public static int maxProduct(int[] A) { if (A.length == 0) { return 0; } if (A.length == 1 && A[0] < 0) { return A[0]; } int max_product = 0; int current_max = 0; int current_min = 0; int prev_max = 1; int prev_min = 1; for (int i = 0; i < A.length; i++) { current_max = Math.max(Math.max(prev_max * A[i], prev_min * A[i]), A[i]); current_min = Math.min(Math.min(prev_max * A[i], prev_max * A[i]), A[i]); max_product = Math.max(max_product, current_max); prev_max = current_max; prev_min = current_min; } return max_product; }
public Trap makeADeprecatedTrap(Environmental unlockThis) { Trap theTrap = null; int roll = (int) Math.round(Math.random() * 100.0); if (unlockThis instanceof Exit) { if (((Exit) unlockThis).hasADoor()) { if (((Exit) unlockThis).hasALock()) { if (roll < 20) theTrap = (Trap) CMClass.getAbility("Trap_Open"); else if (roll < 80) theTrap = (Trap) CMClass.getAbility("Trap_Unlock"); else theTrap = (Trap) CMClass.getAbility("Trap_Enter"); } else { if (roll < 50) theTrap = (Trap) CMClass.getAbility("Trap_Open"); else theTrap = (Trap) CMClass.getAbility("Trap_Enter"); } } else theTrap = (Trap) CMClass.getAbility("Trap_Enter"); } else if (unlockThis instanceof Container) { if (((Container) unlockThis).hasALid()) { if (((Container) unlockThis).hasALock()) { if (roll < 20) theTrap = (Trap) CMClass.getAbility("Trap_Open"); else if (roll < 80) theTrap = (Trap) CMClass.getAbility("Trap_Unlock"); else theTrap = (Trap) CMClass.getAbility("Trap_Get"); } else { if (roll < 50) theTrap = (Trap) CMClass.getAbility("Trap_Open"); else theTrap = (Trap) CMClass.getAbility("Trap_Get"); } } else theTrap = (Trap) CMClass.getAbility("Trap_Get"); } else if (unlockThis instanceof Item) theTrap = (Trap) CMClass.getAbility("Trap_Get"); return theTrap; }
public static int distanceLevel(String geohash1, String geohash2, int treeDepth) { long[] bits1 = decomposeLatLng(geohash1, treeDepth); long[] bits2 = decomposeLatLng(geohash2, treeDepth); long latDelta = Math.abs(bits1[1] - bits2[1]); long lngDelta = Math.abs(bits1[0] - bits2[0]); return (int) Math.max(latDelta, lngDelta); }
public static void testTargetFeaturesAgainstImages( Vector<HaarFeature> features, Vector<IntegralImage> images) { int numberOfTrue = 0; int numberOfFalse = 0; for (IntegralImage ii : images) { float weightSum = 0.0f; float sum = 0.0f; for (HaarFeature hf : features) { // HaarFeature hf = allFeatures.get(slimFeature.featureNumber); // hf.threshold = slimFeature.threshold; float v = hf.weight * ii.evaluateAsClassifier(hf); sum += v; weightSum += hf.weight; } boolean success = (sum >= weightSum * 0.5f); // System.out.println("image " + ii.name + " is a " + success + " : " + sum + " > " + // weightSum*0.5f); if (success) { numberOfTrue++; } else { numberOfFalse++; } } System.out.println("*************"); System.out.println("true: " + numberOfTrue); System.out.println("false: " + numberOfFalse); int min = Math.min(numberOfFalse, numberOfTrue); int max = Math.max(numberOfFalse, numberOfTrue); float percentError = min * 100.0f / max; System.out.println("percentError = " + percentError); }
public InvisibleStalker() { super(); Random randomizer = new Random(System.currentTimeMillis()); username = "******"; setDescription("A shimmering blob of energy."); setDisplayText("An invisible stalker hunts here."); CMLib.factions().setAlignment(this, Faction.ALIGN_NEUTRAL); setMoney(0); basePhyStats.setWeight(10 + Math.abs(randomizer.nextInt() % 10)); baseCharStats().setStat(CharStats.STAT_INTELLIGENCE, 12 + Math.abs(randomizer.nextInt() % 3)); baseCharStats().setStat(CharStats.STAT_STRENGTH, 20); baseCharStats().setStat(CharStats.STAT_DEXTERITY, 13); basePhyStats().setDamage(16); basePhyStats().setSpeed(1.0); basePhyStats().setAbility(0); basePhyStats().setLevel(4); basePhyStats().setArmor(0); basePhyStats().setDisposition(basePhyStats().disposition() | PhyStats.IS_INVISIBLE); baseState.setHitPoints(CMLib.dice().roll(basePhyStats().level(), 20, basePhyStats().level())); addBehavior(CMClass.getBehavior("Aggressive")); addBehavior(CMClass.getBehavior("Mobile")); recoverMaxState(); resetToMaxState(); recoverPhyStats(); recoverCharStats(); }