Android Open Source - nahwc-g Nahwc Game

• Back to Libgdx/Snake  ↑

From Project

Back to project page nahwc-g.

License

The source code is released under:

Apache License

Java Source Code

/*
 *   Copyright 2013 oddlydrawn/*from  ww w  .ja  va  2  s  .  c  o m*/
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

package com.tumblr.oddlydrawn.stupidworm;

import java.util.Random;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.math.Rectangle;

/** @author oddlydrawn */
public class NahwcGame {
  private final float SCREEN_WIDTH_PX = 480;
  private final float SCREEN_HEIGHT_PX = 320;
  private final float WORM_SIZE_PX = 80;
  private final float START_TIME = 0.85f;
  private final int WORM_LENGTH = 10; // 10
  private final int NUMBER_OF_FOOD = 5;
  private final int COLOR_MULTIPLE = 10;
  private final int OUTLINE_MULTIPLE = 20;
  private final int SCREEN_WIDTH_TILES = 59;
  private final int SCREEN_HEIGHT_TILES = 39;
  private final int TEXT_PADDING = 2;
  private float timeToUpdate = 0.2f; // 0.2f
  private OrthographicCamera cam;
  private Renderer renderer;
  private Rectangle bounds;
  private Worm worm;
  private Food food;
  private CheckCollision collision;
  private Random rnd;
  private Rectangle testRect;
  private Level level;
  private MyMusic musicPlayer;
  private Controller controller;
  private float timeSinceLastUpdate;
  private float delta;
  private float startX;
  private float startY;
  private float animSize;
  private float decreaseSpeed;
  private float timeToStartGame;
  private float halfUpdate;
  private int levelNumber;
  private int counter;
  private int score;
  private int hiScore;
  private int tmpScore;
  private boolean isFaster;
  private boolean isColor;
  private boolean isAnimate;
  private boolean isSound;
  private boolean gameOver;
  private boolean isOutline;
  private boolean isPermOutline;
  private boolean startGame = false;
  private SavedStuff savedStuff;

  public NahwcGame () {
    init();
  }

  public void runGame () {
    if (Gdx.input.isKeyPressed(Keys.ESCAPE)) {
      if (score > hiScore) {
        hiScore = score;
        savedStuff.saveScore(hiScore);
      }
      Gdx.app.exit();
    }

    delta = Math.min(0.06f, Gdx.graphics.getDeltaTime());
    timeSinceLastUpdate += delta;

    renderer.update(animSize);
    cam.update();

    // Gets current score (worm size - original worm size).
    score = worm.getScore();
    if (score > hiScore) hiScore = score;

    renderer.setHiScore(hiScore);

    if (startGame) {
      // Pauses time between worm movement.
      if (timeSinceLastUpdate > timeToUpdate) {
        controller.update();
        worm.update();
        timeSinceLastUpdate = 0;
        if (counter <= 2) counter++;
        // Checking for collisions has to happen after worm head is off body
        if (counter > 2) {
          if (collision.wormAndWall() || collision.wormAndWorm()) {
            Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
            savedStuff.saveScore(hiScore);
            gameOver = true;
          }
        }
      }

      calculateAnimationSize();
      controller.processInput();
      checkWormAndFoodCollision();
    } else {
      timeToStartGame += delta;
      if (timeToStartGame > START_TIME) startGame = true;
    }
  }

  private void calculateAnimationSize () {
    halfUpdate = timeToUpdate / 2;
    if (timeSinceLastUpdate < halfUpdate) {
      // A formula for scale in relation to time (8 to 16 for first half
      // of a pause between worm timeToUpdate updates).
      animSize = WORM_SIZE_PX * timeSinceLastUpdate + Level.SIZE;
    } else if (timeSinceLastUpdate > halfUpdate) {
      // This shrinks the scale for the second half of the worm update.
      animSize = -WORM_SIZE_PX * timeSinceLastUpdate + Level.SIZE * 3;
    } else {
      animSize = 0;
    }
  }

  private void checkWormAndFoodCollision () {
    if (collision.wormAndFood()) {
      if (isSound) musicPlayer.playPickup();
      if (isAnimate) worm.markHead();
      worm.bodyPlusPlus();
      makeNewFood();
      score = worm.getScore();
      // XXX Score is 1 less than actual score.
      tmpScore = score + 1;
      if (isFaster) timeToUpdate -= decreaseSpeed;
      if (isColor) {
        if (tmpScore % COLOR_MULTIPLE == 0) renderer.changeColor();
      }
      if (isOutline && !isPermOutline) {
        if (tmpScore % OUTLINE_MULTIPLE == 0) renderer.changeOutline();
      }
    }
  }

  private void init () {
    savedStuff = new SavedStuff();
    savedStuff.loadPreferencesAndScore();
    
    levelNumber = savedStuff.getLevelNumber();
    isFaster = savedStuff.isFaster();
    isColor = savedStuff.isColor();
    isAnimate = savedStuff.isAnimate();
    isSound = savedStuff.isSound();
    isOutline = savedStuff.isOutline();
    isPermOutline = savedStuff.isPermOutline();
    decreaseSpeed = savedStuff.getDecreaseSpeed();
    timeToUpdate = savedStuff.getTimeToUpdate();
    levelNumber = savedStuff.getLevelNumber();
    hiScore = savedStuff.getHiScore();
    
    // Loads level based on selected level
    level = new Level(levelNumber);
    level.loadLevel();
    startX = level.getStartCoords().x;
    startY = level.getStartCoords().y;
    
    bounds = new Rectangle(startX, startY, Level.SIZE, Level.SIZE);
    worm = new Worm(bounds, WORM_LENGTH);
    cam = new OrthographicCamera();
    cam.setToOrtho(false, SCREEN_WIDTH_PX, SCREEN_HEIGHT_PX);
    food = new Food();
    renderer = new Renderer(cam, worm, food, level);
    testRect = new Rectangle(0, 0, Level.SIZE, Level.SIZE);
    rnd = new Random();

    collision = new CheckCollision(food, worm, level);
    musicPlayer = new MyMusic();
    for (int i = 0; i < NUMBER_OF_FOOD; i++) {
      makeInitialFood();
    }
    renderer.init();
    controller = new Controller(worm);
    if (isPermOutline) {
      renderer.changeOutline();
    }
  }

  public void makeInitialFood () {
    do {
      testRect.x = rnd.nextInt(SCREEN_WIDTH_TILES) * Level.SIZE;
      testRect.y = rnd.nextInt(SCREEN_HEIGHT_TILES - TEXT_PADDING) * Level.SIZE;
    } while (collision.thisAndAll(testRect));
    food.createInitial(testRect.x, testRect.y, Level.SIZE);
  }

  public void makeNewFood () {
    do {
      testRect.x = rnd.nextInt(SCREEN_WIDTH_TILES) * Level.SIZE;
      testRect.y = rnd.nextInt(SCREEN_HEIGHT_TILES - TEXT_PADDING) * Level.SIZE;
    } while (collision.thisAndAll(testRect));
    food.createOne(testRect.x, testRect.y, Level.SIZE);
  }

  public boolean getIfGameOver () {
    return gameOver;
  }

  public void dispose () {
    renderer.dispose();
    musicPlayer.dispose();
  }
}

Java Source Code List

• Back to Libgdx/Snake  ↑