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;
}
/** 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 void incDifficulty() {
DisplayMetrics displaymetrics = new DisplayMetrics();
this.difficulty++;
field.removeAll();
activity.getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
this.height = (int) (displaymetrics.heightPixels - (displaymetrics.density * dp + 0.5f));
this.width = displaymetrics.widthPixels;
levelObject = new Level(levelGround, this.width, this.height, this.difficulty);
levelObject.createLevel(levelGround);
field.addObject(levelObject);
figure.setScale(new BytehawksVector(levelObject.mScale, levelObject.mScale));
figure.mPosition.set(figure.mScale.mX * 32, figure.mScale.mX * 32);
figure.moveToDestination(new BytehawksVector(0, 0));
figureLayout = new BytehawksSpriteLayout(activity.mGLSurfaceView, 64, 64, R.drawable.android);
figure = new AndroidFigure(figureLayout, levelObject);
field.addObject(figure);
this.sequencebar.setMaxLength(levelObject.getMaxAllowedMoves());
this.sequencebar.setMinLength(levelObject.getMinAllowedMoves());
this.controlbar =
new Controlbar(
this.sequencebar,
(ImageButton) activity.findViewById(R.id.c_down),
(ImageButton) activity.findViewById(R.id.c_right),
(Button) activity.findViewById(R.id.c_delete),
(Button) activity.findViewById(R.id.c_start),
figure,
this);
this.sequencebar.clearSequence();
activity.setTitle(
"Level:" + levelObject.getDifficulty() + " Max moves:" + levelObject.getMaxAllowedMoves());
}
public GameUI(BytehawksActivity activity) {
super(activity);
this.activity = activity;
DisplayMetrics displaymetrics = new DisplayMetrics();
activity.getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
this.height = (int) (displaymetrics.heightPixels - (displaymetrics.density * dp + 0.5f));
this.width = displaymetrics.widthPixels;
field = addObject(new BytehawksObject());
levelGround = new BytehawksTileBank(activity.mGLSurfaceView, R.drawable.tilemap, 5, 5, 32, 32);
levelObject = new Level(levelGround, this.width, this.height, this.difficulty);
levelObject.createLevel(levelGround);
field.addObject(levelObject);
figureLayout = new BytehawksSpriteLayout(activity.mGLSurfaceView, 64, 64, R.drawable.android);
figure = new AndroidFigure(figureLayout, levelObject);
field.addObject(figure);
this.sequencebar =
new Sequence(
levelObject.getMinAllowedMoves(),
levelObject.getMaxAllowedMoves(),
activity,
(LinearLayout) activity.findViewById(R.id.seqeunce_container));
this.controlbar =
new Controlbar(
this.sequencebar,
(ImageButton) activity.findViewById(R.id.c_down),
(ImageButton) activity.findViewById(R.id.c_right),
(Button) activity.findViewById(R.id.c_delete),
(Button) activity.findViewById(R.id.c_start),
figure,
this);
activity.setTitle(
"Level:" + levelObject.getDifficulty() + " Max moves:" + levelObject.getMaxAllowedMoves());
}
public VolatileImage renderBackgroundLayer(int LayerNumber) {
// create hardware accellerated background layer (Volatile Image)
backgroundLayer[LayerNumber] =
this.getGraphicsConfiguration()
.createCompatibleVolatileImage(
loadedLevel.getWidth() * 16,
loadedLevel.getHeight() * 16,
Transparency.TRANSLUCENT);
Graphics2D g2d = backgroundLayer[LayerNumber].createGraphics();
g2d.setComposite(AlphaComposite.Src);
// Clear the image.
g2d.setColor(new Color(0, 0, 0, 0));
g2d.fillRect(
0, 0, backgroundLayer[LayerNumber].getWidth(), backgroundLayer[LayerNumber].getHeight());
g2d.setBackground(new Color(0, 0, 0, 0));
g2d.setColor(new Color(1f, 1f, 1f, 1f));
for (int i = 0;
i
< backgroundLayer[LayerNumber].getWidth(this)
/ backgroundImage[LayerNumber].getWidth(this);
i++) {
g2d.drawImage(
backgroundImage[LayerNumber], i * backgroundImage[LayerNumber].getWidth(this), 0, this);
}
return backgroundLayer[LayerNumber];
}
public GameController(Level level) {
this.level = level;
this.menu = level.getMenu();
this.gameOver = level.getGameOver();
this.store = level.getStore();
this.sound.playSound("menu");
}
/**
* Creates a type representing a level.
*
* @param dimension Dimension which values of this type must belong to, or null if not known
* @param hierarchy Hierarchy which values of this type must belong to, or null if not known
* @param level Level which values of this type must belong to, or null if
*/
public LevelType(Dimension dimension, Hierarchy hierarchy, Level level) {
this.dimension = dimension;
this.hierarchy = hierarchy;
this.level = level;
if (level != null) {
Util.assertPrecondition(hierarchy != null, "hierarchy != null");
Util.assertPrecondition(
level.getHierarchy() == hierarchy, "level.getHierarchy() == hierarchy");
}
if (hierarchy != null) {
Util.assertPrecondition(dimension != null, "dimension != null");
Util.assertPrecondition(
hierarchy.getDimension() == dimension, "hierarchy.getDimension() == dimension");
}
StringBuilder buf = new StringBuilder("LevelType<");
if (level != null) {
buf.append("level=").append(level.getUniqueName());
} else if (hierarchy != null) {
buf.append("hierarchy=").append(hierarchy.getUniqueName());
} else if (dimension != null) {
buf.append("dimension=").append(dimension.getUniqueName());
}
buf.append(">");
this.digest = buf.toString();
}
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();
}
/**
* 写日志操作处理方法
*
* @param caller 调用者类对象
* @param msg
* @param level
*/
private static void writeLog(Object caller, String msg, Level level) {
String logTag = "";
if (caller != null) {
if (caller instanceof String) {
logTag = caller.toString();
} else {
logTag = caller.getClass().getName();
}
}
if (level.getLevel() < logLevel.getLevel()) {
return;
}
if (!writeFile) {
return;
}
File logFile = checkLogFile(); // 检查日志文件
if (logFile == null) {
return;
}
/** * 组织日志输入内容 * */
String writeMsg = "[" + DateUtils.getCurrDateStr() + "] [";
writeMsg += level.getLevelDescn() + "] ";
writeMsg += logTag + ": ";
writeMsg += msg + "\n";
try {
FileWriter fw = new FileWriter(logFile, true);
fw.append(writeMsg);
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public Level createLevel(int id) {
Level lev = new Level(id);
for (SpriteBox box : myPaintableBoxes) {
lev.addNewSprite(box.getSprite());
}
return lev;
}
public boolean in(Level[] levels) {
for (Level level : levels) {
if (level.equals(this)) {
return true;
}
}
return false;
}
private static void start() {
CollisionEffect.kill();
level.reset();
double xSpeed = CalcHelp.gaussianDouble(3.5, 1);
double ySpeed = CalcHelp.randomDouble(-1, 1);
level.getBall().setVelocity(new Vector2d(xSpeed, ySpeed));
level.getBall().setLaunched(true);
}
/** @param i Value to adjust xp by. */
public final void modifyXp(final int i) {
xp += i;
if (xp < Level.getXPforLevel(level)) {
levelDrop();
} else if (xp < Level.getXPforLevel(level + 1)) {
levelGain();
}
}
private void processEndTag(EndTag tag) {
while (!stack.isEmpty()) {
Level popped = stack.pop();
if (popped.getTag().getName().equalsIgnoreCase(tag.getName())) {
break;
}
}
writer.write(tag.toString());
}
/**
* Checks to see if a param of the arry list is full
*
* @return true or false
*/
public boolean isFull() {
for (Level indiv_level : levels) {
if (!indiv_level.isFull()) {
return false;
}
}
return true;
}
private void warpPlayerToSpawn() {
Vector3f loc = EditorActivity.level.getPlayer().getLocation();
Level level = EditorActivity.level;
loc.setX(level.getSpawnX());
loc.setY(level.getSpawnY());
loc.setZ(level.getSpawnZ());
EditorActivity.save(this);
updatePlayerPositionText();
}
public Block getBlock(Vector2 pos) {
Array<Block> blocks = getBlocks(level.getWidth(), level.getHeight());
for (Block block : blocks) {
if (block.getBounds().contains(pos)) {
return block;
}
}
return null;
}
private String getNamespace(String prefix) {
String namespace = null;
for (Level level : stack) {
namespace = level.getNamespace(prefix);
if (namespace != null) {
break;
}
}
return namespace;
}
/**
* Adds car to array list if num of spots isnt full
*
* @param incomingCar
* @return the level the car was added to
*/
public int addCar(Car incomingCar) {
int counter = 1;
for (Level indiv_level : levels) {
if (!indiv_level.isFull()) {
indiv_level.addCar(incomingCar);
break;
}
counter++;
}
return counter;
}
@Transient
public boolean isStarted() {
Level firstLevel = levelMap.get(0);
for (Round round : firstLevel.getRoundMap().values()) {
if (round.isStarted()) {
return true;
}
}
return false;
}
/**
* 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]);
}
/**
* Generate a new level.
*
* @return a new level
*/
public Level generate() {
// Select a theme
int theme = random.nextInt(3);
switch (theme) {
case 0:
Level.theme = "normal";
break;
case 1:
Level.theme = "horror";
break;
case 2:
Level.theme = "oriental";
break;
}
Terrain terrain = new Terrain();
/*While not done because of Terrain*/
while (width < Terrain.width) {
// Fill a row
for (int i = Terrain.height - 1; i > height; i--) {
AbstractTerrainObject toAdd;
/*If its a 10 the block is explosive*/
if (random.nextInt(10) == 9) {
toAdd = new ExplosiveBuildingBlock(width, i);
} else {
toAdd = new SquareBuildingBlock(width, i);
}
terrain.addTerrainObject(toAdd);
}
/* If Random is a 5 */
if (random.nextInt(6) == 5) {
wormSpawns.add(new int[] {width, height - 1});
}
int nextAction = random.nextInt(5);
/* If its a 5 or 1 we go down */
if (nextAction == 0 && height < Terrain.height - 1) {
height++;
} else if (nextAction == 4 && height > 0) {
height--;
}
/* Else we keep the height */
width++;
}
Level level = new Level(terrain);
for (int[] spawn : wormSpawns) {
level.addWormStartPosition(spawn[0], spawn[1]);
}
return level;
}
public String getLoggerLevel(String loggerName) {
Logger l = logManager.getLogger(loggerName);
if (l == null) {
return null;
}
Level level = l.getLevel();
if (level == null) {
return EMPTY_STRING;
} else {
return level.getLevelName();
}
}
private double calculateLevelMaterializationTime(Level level) {
// the materialization cost in the level, it is the cost
// to materialize the last operator in the level.
// it is calculated by getting the cardinality
// from the estimator and then calculate the cost
// of writing each record on the memory depending
// in the memory write speed. (materialization in table memory)
int levelLength = level.getSubQquery().size();
double levelMaterializationRunTime = 0.0;
levelMaterializationRunTime =
level.getSubQquery().get(levelLength - 1).getOpMaterializationTimeEstimate();
return levelMaterializationRunTime;
}
public List<Level> levelsActualAtTime(long time) {
List<Level> ret = new LinkedList<Level>();
List<Level> preRet = levels();
List<Bar> atomicDeltas = atomicDeltas(time);
for (Level level : preRet) {
if (level.timeAppeared() < time) {
if (!levelNeutralizedByMovement(level, atomicDeltas)) {
ret.add(level);
}
}
}
return ret;
}
/**
* Saves the passed collection to the passed file.
*
* @param levelCollection the level collection to be saved
* @param fileName the file the level is to be saved to
* @throws IOException thrown when the level couldn't be saved
*/
public final void saveCollection(LevelCollection levelCollection, String fileName)
throws IOException {
// Create a PrintWriter for writing the data to hard disk.
PrintWriter collectionFile = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
// Write the collection data
if (!levelCollection.getTitle().isEmpty()) {
collectionFile.println("Title: " + levelCollection.getTitle());
}
Author collectionAuthor = levelCollection.getAuthor();
if (!collectionAuthor.getName().equals(Texts.getText("unknown"))) {
collectionFile.println("Author: " + collectionAuthor.getName());
}
if (!collectionAuthor.getEmail().isEmpty()) {
collectionFile.println("Email: " + collectionAuthor.getEmail());
}
if (!collectionAuthor.getWebsiteURL().isEmpty()) {
collectionFile.println("Homepage: " + collectionAuthor.getWebsiteURL());
}
if (!collectionAuthor.getComment().isEmpty()) {
collectionFile.println("Author comment: " + collectionAuthor.getComment());
}
if (!levelCollection.getComment().isEmpty()) {
collectionFile.println(levelCollection.getComment());
}
// Loop over all levels of the collection and write their data to the file.
// If the author of the level is identical to the collection author
// then don't write the author data for such levels.
for (Level level : levelCollection) {
Author levelAuthor = level.getAuthor();
if (levelAuthor.equals(collectionAuthor)) {
level.setAuthor(new Author());
}
writeLevelToFile(level, collectionFile);
level.setAuthor(levelAuthor);
}
// Check the error status.
boolean isFileSavingFailed = collectionFile.checkError();
// Close the file.
collectionFile.close();
// Throw exception in the case of an error.
if (isFileSavingFailed) {
throw new IOException(Texts.getText("errorBySaving"));
}
}
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);
}
public void createLevels() {
Level level1 = new Level();
Level level2 = new Level();
Level level3 = new Level();
Level level4 = new Level();
level1.positions.add(new Vector2(16, 120));
level1.positions.add(new Vector2(48, 120));
level1.goalPos = new Vector2(16, 188);
levels.add(level1);
level2.positions.add(new Vector2(16, 120));
level2.positions.add(new Vector2(48, 120));
level2.positions.add(new Vector2(116, 120));
level2.positions.add(new Vector2(116, 16));
level2.goalPos = new Vector2(16, 188);
levels.add(level2);
level3.positions.add(new Vector2(16, 112));
level3.positions.add(new Vector2(116, 112));
level3.positions.add(new Vector2(116, 80));
level3.positions.add(new Vector2(80, 208));
level3.goalPos = new Vector2(16, 144);
levels.add(level3);
level4.positions.add(new Vector2(16, 80));
level4.positions.add(new Vector2(116, 112));
level4.positions.add(new Vector2(80, 208));
level4.goalPos = new Vector2(116, 176);
levels.add(level4);
}
static {
boolean disabled;
if (SystemPropertyUtil.get("io.netty.noResourceLeakDetection") != null) {
boolean disabled = SystemPropertyUtil.getBoolean("io.netty.noResourceLeakDetection", false);
logger.debug("-Dio.netty.noResourceLeakDetection: {}", Boolean.valueOf(disabled));
logger.warn(
"-Dio.netty.noResourceLeakDetection is deprecated. Use '-D{}={}' instead.",
"io.netty.leakDetectionLevel",
DEFAULT_LEVEL.name().toLowerCase());
} else {
disabled = false;
}
Level defaultLevel = disabled ? Level.DISABLED : DEFAULT_LEVEL;
String levelStr =
SystemPropertyUtil.get("io.netty.leakDetectionLevel", defaultLevel.name())
.trim()
.toUpperCase();
Level level = DEFAULT_LEVEL;
for (Level l : EnumSet.allOf(Level.class)) {
if ((levelStr.equals(l.name())) || (levelStr.equals(String.valueOf(l.ordinal())))) {
level = l;
}
}
level = level;
if (logger.isDebugEnabled()) {
logger.debug("-D{}: {}", "io.netty.leakDetectionLevel", level.name().toLowerCase());
}
}
/**
* Set the logging level using one of the words "severe", "warning" etc corresponding to logging
* levels. This function is case insensitive.
*
* @param word
*/
public static void setLevelByName(String word) {
String s = word.toUpperCase();
Level level = Level.SEVERE;
if (s.equals("SEVERE")) level = Level.SEVERE;
if (s.equals("WARNING")) level = Level.WARNING;
if (s.equals("INFO")) level = Level.INFO;
if (s.equals("CONFIG")) level = Level.CONFIG;
if (s.equals("FINE")) level = Level.FINE;
if (s.equals("FINER")) level = Level.FINER;
if (s.equals("FINEST")) level = Level.FINEST;
logger.setLevel(level);
Level ll = logger.getLevel();
System.out.println("Logging level now " + ll.toString());
}
