예제 #1
10
  public void render() {
    Graphics g = screen.getGraphics();
    // Drawing Things!
    sky.render(g);
    level.render(
        g,
        (int) sX,
        (int) sY,
        (pixel.width / Tile.tileSize) + 2,
        (pixel.height / Tile.tileSize) + 2);
    character.render(g);
    inventory.render(g);
    health.render(g);

    for (int i = 0; i < mob.toArray().length; i++) {
      mob.get(i).render(g);
    }
    g = getGraphics();

    g.drawImage(screen, 0, 0, size.width, size.height, 0, 0, pixel.width, pixel.height, null);

    g.dispose();
  }
  public int countImagesInSector(Sector sector, int levelNumber) {
    if (sector == null) {
      String msg = Logging.getMessage("nullValue.SectorIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }

    Level targetLevel = this.levels.getLastLevel();
    if (levelNumber >= 0) {
      for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
        if (this.levels.isLevelEmpty(i)) continue;

        targetLevel = this.levels.getLevel(i);
        break;
      }
    }

    // Collect all the tiles intersecting the input sector.
    LatLon delta = targetLevel.getTileDelta();
    Angle latOrigin = this.levels.getTileOrigin().getLatitude();
    Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
    final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude(), latOrigin);
    final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude(), lonOrigin);
    final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude(), latOrigin);
    final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude(), lonOrigin);

    int numRows = nwRow - seRow + 1;
    int numCols = seCol - nwCol + 1;

    return numRows * numCols;
  }
예제 #3
1
 /** Reads in the file and checks the expected values like the square and game parameters. */
 @Test
 public void normalLevelTest() throws FileNotFoundException {
   assertArrayEquals(square, level.getSquare());
   int[] params = level.getParams();
   assertEquals(1, params[0]);
   assertEquals(1, params[1]);
   assertEquals(8, params[2]);
   assertEquals(1, params[3]);
   assertEquals(1, params[4]);
 }
  public int computeLevelForResolution(Sector sector, Globe globe, double resolution) {
    if (sector == null) {
      String message = Logging.getMessage("nullValue.SectorIsNull");
      Logging.logger().severe(message);
      throw new IllegalStateException(message);
    }

    if (globe == null) {
      String message = Logging.getMessage("nullValue.GlobeIsNull");
      Logging.logger().severe(message);
      throw new IllegalStateException(message);
    }

    double texelSize = 0;
    Level targetLevel = this.levels.getLastLevel();
    for (int i = 0; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
      if (this.levels.isLevelEmpty(i)) continue;

      texelSize = this.levels.getLevel(i).getTexelSize();
      if (texelSize > resolution) continue;

      targetLevel = this.levels.getLevel(i);
      break;
    }

    Logging.logger()
        .info(
            Logging.getMessage(
                "layers.TiledImageLayer.LevelSelection", targetLevel.getLevelNumber(), texelSize));
    return targetLevel.getLevelNumber();
  }
예제 #5
0
 /**
  * Reads in the file and checks the expected values like the square and game parameters based on
  * standing parameters back to back.
  */
 @Test
 public void normalLevelTest3() throws FileNotFoundException {
   fileName = "level11.txt";
   level = new Level(fileName);
   assertArrayEquals(square, level.getSquare());
   int[] params = level.getParams();
   assertEquals(1, params[0]);
   assertEquals(1, params[1]);
   assertEquals(8, params[2]);
   assertEquals(1, params[3]);
   assertEquals(1, params[4]);
 }
예제 #6
0
 private int logValue(Level l) {
   if (l.equals(Level.FINEST)) {
     return 0;
   } else if (l.equals(Level.FINE)) {
     return 1;
   } else if (l.equals(Level.INFO)) {
     return 2;
   } else if (l.equals(Level.WARNING)) {
     return 3;
   } else if (l.equals(Level.SEVERE)) {
     return 4;
   }
   return -1;
 }
  private boolean atMaxLevel(DrawContext dc) {
    Position vpc = dc.getViewportCenterPosition();
    if (dc.getView() == null || this.getLevels() == null || vpc == null) return false;

    if (!this.getLevels().getSector().contains(vpc.getLatitude(), vpc.getLongitude())) return true;

    Level nextToLast = this.getLevels().getNextToLastLevel();
    if (nextToLast == null) return true;

    Sector centerSector =
        nextToLast.computeSectorForPosition(
            vpc.getLatitude(), vpc.getLongitude(), this.getLevels().getTileOrigin());
    return this.needToSplit(dc, centerSector);
  }
예제 #8
0
 public static void loadMap(int layer, Player player, RandomAccessFile loadfile)
     throws IOException {
   Level level =
       new Level(Art.load("/res/map/layer_" + layer + ".png"), null, player, layer, true);
   for (int x = 0; x < level.w; x++) {
     for (int y = 0; y < level.h; y++) {
       if (x == 0 && y == 0) {
         System.out.printf("Entering first tile at %d!\n", loadfile.getFilePointer());
       }
       Tile tileToSave = level.getTile(x, y);
       tileToSave.loadTile(loadfile);
     }
   }
   level.init();
   loadedMaps.put(layer, level);
 }
예제 #9
0
 public void saveMap(int layer, RandomAccessFile savefile) throws IOException {
   System.out.printf("Saving map %d at %d!\n", layer, savefile.getFilePointer());
   Level level = loadedMaps.get(layer);
   if (level == null) {
     return;
   }
   savefile.writeInt(layer);
   for (int x = 0; x < level.w; x++) {
     for (int y = 0; y < level.h; y++) {
       if (x == 0 && y == 0) {
         System.out.printf("Entering first tile at %d!\n", savefile.getFilePointer());
       }
       Tile tileToSave = level.getTile(x, y);
       tileToSave.saveTile(savefile);
     }
   }
 }
  private MercatorTextureTile[][] getTilesInSector(Sector sector, int levelNumber) {
    if (sector == null) {
      String msg = Logging.getMessage("nullValue.SectorIsNull");
      Logging.logger().severe(msg);
      throw new IllegalArgumentException(msg);
    }

    Level targetLevel = this.levels.getLastLevel();
    if (levelNumber >= 0) {
      for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++) {
        if (this.levels.isLevelEmpty(i)) continue;

        targetLevel = this.levels.getLevel(i);
        break;
      }
    }

    // Collect all the tiles intersecting the input sector.
    LatLon delta = targetLevel.getTileDelta();
    Angle latOrigin = this.levels.getTileOrigin().getLatitude();
    Angle lonOrigin = this.levels.getTileOrigin().getLongitude();
    final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude(), latOrigin);
    final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude(), lonOrigin);
    final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude(), latOrigin);
    final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude(), lonOrigin);

    int numRows = nwRow - seRow + 1;
    int numCols = seCol - nwCol + 1;
    MercatorTextureTile[][] sectorTiles = new MercatorTextureTile[numRows][numCols];

    for (int row = nwRow; row >= seRow; row--) {
      for (int col = nwCol; col <= seCol; col++) {
        TileKey key =
            new TileKey(targetLevel.getLevelNumber(), row, col, targetLevel.getCacheName());
        Sector tileSector = this.levels.computeSectorForKey(key);
        MercatorSector mSector = MercatorSector.fromSector(tileSector); // TODO: check
        sectorTiles[nwRow - row][col - nwCol] =
            new MercatorTextureTile(mSector, targetLevel, row, col);
      }
    }

    return sectorTiles;
  }
  private static MeshTile[] createTiles(LevelSet levelSet, int levelNumber, MeshCoords coords) {
    Sector sector = levelSet.getSector();
    Level level = levelSet.getLevel(levelNumber);
    Angle dLat = level.getTileDelta().getLatitude();
    Angle dLon = level.getTileDelta().getLongitude();
    Angle latOrigin = levelSet.getTileOrigin().getLatitude();
    Angle lonOrigin = levelSet.getTileOrigin().getLongitude();

    // Determine the row and column offset from the common World Wind global tiling origin.
    int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin);
    int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin);
    int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin);
    int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin);

    int numLatTiles = lastRow - firstRow + 1;
    int numLonTiles = lastCol - firstCol + 1;

    AffineTransform sectorTransform = createTransform(sector, coords);

    MeshTile[] tiles = new MeshTile[numLatTiles * numLonTiles];
    int index = 0;

    Angle p1 = Tile.computeRowLatitude(firstRow, dLat, latOrigin);

    for (int row = firstRow; row <= lastRow; row++) {
      Angle p2 = p1.add(dLat);

      Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin);

      for (int col = firstCol; col <= lastCol; col++) {
        Angle t2 = t1.add(dLon);

        Sector tileSector = new Sector(p1, p2, t1, t2);
        MeshCoords tileCoords = transformSector(sectorTransform, tileSector);
        tiles[index++] = new MeshTile(tileSector, level, row, col, tileCoords);

        t1 = t2;
      }
      p1 = p2;
    }

    return tiles;
  }
예제 #12
0
    // Package private method to get a Level property.
    // If the property is not defined or cannot be parsed
    // we return the given default value.
    Level getLevelProperty(String name, Level defaultValue) {
	String val = getProperty(name);
	if (val == null) {
	    return defaultValue;
	}
	try {
	    return Level.parse(val.trim());
	} catch (Exception ex) {
	    return defaultValue;
	}
    }
 /**
  * Construct a LogRecord with the given level and message values.
  *
  * <p>The sequence property will be initialized with a new unique value. These sequence values are
  * allocated in increasing order within a VM.
  *
  * <p>The millis property will be initialized to the current time.
  *
  * <p>The thread ID property will be initialized with a unique ID for the current thread.
  *
  * <p>All other properties will be initialized to "null".
  *
  * @param level a logging level value
  * @param msg the raw non-localized logging message (may be null)
  */
 public LogRecord(Level level, String msg) {
   // Make sure level isn't null, by calling random method.
   level.getClass();
   this.level = level;
   message = msg;
   // Assign a thread ID and a unique sequence number.
   sequenceNumber = globalSequenceNumber.getAndIncrement();
   threadID = defaultThreadID();
   millis = System.currentTimeMillis();
   needToInferCaller = true;
 }
  private void createTopLevelTiles() {
    MercatorSector sector = (MercatorSector) this.levels.getSector();

    Level level = levels.getFirstLevel();
    Angle dLat = level.getTileDelta().getLatitude();
    Angle dLon = level.getTileDelta().getLongitude();

    Angle latOrigin = this.levels.getTileOrigin().getLatitude();
    Angle lonOrigin = this.levels.getTileOrigin().getLongitude();

    // Determine the row and column offset from the common World Wind global tiling origin.
    int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin);
    int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin);
    int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin);
    int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin);

    int nLatTiles = lastRow - firstRow + 1;
    int nLonTiles = lastCol - firstCol + 1;

    this.topLevels = new ArrayList<MercatorTextureTile>(nLatTiles * nLonTiles);

    // Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
    double deltaLat = dLat.degrees / 90;
    double d1 = -1.0 + deltaLat * firstRow;
    for (int row = firstRow; row <= lastRow; row++) {
      // Angle p2;
      // p2 = p1.add(dLat);
      double d2 = d1 + deltaLat;

      Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin);
      for (int col = firstCol; col <= lastCol; col++) {
        Angle t2;
        t2 = t1.add(dLon);

        this.topLevels.add(
            new MercatorTextureTile(new MercatorSector(d1, d2, t1, t2), level, row, col));
        t1 = t2;
      }
      d1 = d2;
    }
  }
예제 #15
0
  private void initLogLevel() {
    String logLevelStr = getProperty(logLevelKey, Level.OFF.getName());
    Level[] validLevels =
        new Level[] {
          Level.SEVERE,
          Level.WARNING,
          Level.INFO,
          Level.CONFIG,
          Level.FINE,
          Level.FINER,
          Level.FINEST,
          Level.ALL,
          Level.OFF,
        };

    logLevel = Level.OFF;
    for (Level level : validLevels) {
      if (level.getName().equalsIgnoreCase(logLevelStr)) {
        logLevel = level;
        break;
      }
    }
  }
예제 #16
0
 public void tick() {
   if (inGame) {
     level.tick(
         (int) sX,
         (int) sY,
         (pixel.width / Tile.tileSize) + 2,
         (pixel.height / Tile.tileSize) + 2);
     character.tick();
     sky.tick();
     health.tick();
     for (int i = 0; i < mob.toArray().length; i++) {
       mob.get(i).tick();
     }
   }
 }
예제 #17
0
  private void initLogger() {
    ConsoleHandler consoleHandler = null;

    Logger rootLogger = LogManager.getLogManager().getLogger("");
    Handler[] handlers = rootLogger.getHandlers();
    for (Handler handler : handlers) {
      if (handler instanceof ConsoleHandler) {
        consoleHandler = (ConsoleHandler) handler;
        rootLogger.removeHandler(handler);
      }
    }

    logger = Logger.getLogger(contextId);
    logger.setLevel(logLevel);
    if (!logLevel.equals(Level.OFF)) {
      LogFormatter formatter = new LogFormatter();
      if (consoleLog) {
        if (consoleHandler == null) {
          consoleHandler = new ConsoleHandler();
        }
        consoleHandler.setFormatter(formatter);
        consoleHandler.setLevel(logLevel);
        logger.addHandler(consoleHandler);
      }
      String userHomePath = getProperty("user.home", ".");
      File logDir = new File(userHomePath, '.' + contextId + "/log");
      logDir.mkdirs();
      String logFilePattern = new File(logDir, contextId + "-%g.log").getPath();
      try {
        FileHandler fileHandler = new FileHandler(logFilePattern);
        fileHandler.setFormatter(formatter);
        fileHandler.setLevel(logLevel);
        logger.addHandler(fileHandler);
      } catch (IOException e) {
        System.err.println("Error: Failed to create log file: " + logFilePattern);
      }
    }
  }
 @Override
 public String toString() {
   return "P: " + profile.toString() + " L: " + level.toString();
 }