Создание игрового приложения для операционной системы Android

if(swarm.getNumMembersAlive() == 0) {

loadNextLevel();

return;

}

if( (motherShip.getState() == MotherShip.State.DEAD) && swarm.getNumTimesMovedDown() > 2 && (!p1.isDead()) ) {

if( Math.random()*10 < (0.5)*delta )

motherShip.reset();

}

if( (motherShip.getState() == MotherShip.State.ALIVE || motherShip.getState() == MotherShip.State.DYING) )

motherShip.update(delta);

boolean gameOver = swarm.update(delta);

swarm.updateBullets(delta);

gameOver = gameOver || p1.isDead();

if (gameOver) {

if(!p1.isDead())

p1.die();

changeScreen(MainGame.GAMEOVER_STATE);

}

}

else if(state == STATE_TRANSITION_GAMEOVERSCREEN){

transitionTime += delta;

if(transitionTime > transitionPeriod) {

game.changeScreen(MainGame.GAMEOVER_STATE);

}

motherShip.dieNow();

MainGame.mix(BG_COLOR, GameOverScreen.BG_COLOR, transitionTime / transitionPeriod, backgroundColor);

}

else if(state == STATE_ENTERING){

enterPos += 4;

if(enterPos >= 0){

enterPos = 0;

state = STATE_NORMAL;

p1.setState(Player.State.NORMAL);

transitionTime = 0;

return;

}

}

p1.update(delta);

collision();

}

public void draw(float delta){

float fadeTransparancy = 1f;

if(state == STATE_ENTERING)

fadeTransparancy = (START_ENTER_POS-enterPos)/START_ENTER_POS;

else if(state == STATE_TRANSITION_GAMEOVERSCREEN){

fadeTransparancy = 1f - transitionTime/transitionPeriod;

}

Gdx.gl.glEnable(GL20.GL_BLEND);

if( !backgroundColor.equals(BG_COLOR) ) {

game.sr.begin(ShapeRenderer.ShapeType.Filled);

game.sr.setColor(backgroundColor);

game.sr.rect(-MainGame.xOff, -MainGame.yOff, MainGame.viewportWidth, MainGame.viewportHeight);

game.sr.end();

}

game.sb.begin();

if (!(state == STATE_ENTERING)){

swarm.draw(game.sb);

}

else {

swarm.draw(game.sb, enterPos, 0);

font.draw(game.sb, layout, enterPos + MainGame.WIDTH, MainGame.HEIGHT/2f + layout.height/2);

}

if( !(motherShip.getState() == MotherShip.State.DEAD) )

motherShip.draw(game.sb);

p1.drawHUDText(game.sb, fadeTransparancy);

game.sb.end();

Gdx.gl.glEnable(GL20.GL_BLEND);

game.sr.begin(ShapeRenderer.ShapeType.Filled);

swarm.drawBullets(game.sr);

p1.drawBullets(game.sr);

p1.draw(game.sr);

p1.drawHUDShapes(game.sr, fadeTransparancy);

game.sr.setColor(1f, 1f, 1f, 0.25f);

game.sr.rect(0 - MainGame.xOff, 0 - MainGame.yOff, MainGame.xOff, MainGame.viewportHeight);

game.sr.rect(MainGame.WIDTH, 0 - MainGame.yOff, MainGame.xOff, MainGame.viewportHeight);

for(int i = 0; i < shields.length; ++i){

shields[i].draw(game.sr, fadeTransparancy);

}

game.sr.end();

game.sb.begin();

game.sb.end();

Gdx.gl.glDisable(GL20.GL_BLEND);

}

public void onPlayerRespawnStart(){

motherShip.pause();

swarm.pause();

}

public void onPlayerRespawnEnd(){

motherShip.resume();

swarm.resume();

}

public Color getBackgroundColor(){

return backgroundColor;

}

public void collision(){

p1.bulletsBounds();

boolean bulletHit;

for(int i = p1.getNumBullets()-1; i >= 0; --i){

Bullet bullet = p1.bullets[i];

bulletHit = false;

for(int j = swarm.members.length-1; j >= 0 && !bulletHit; --j){

Enemy enemy = swarm.members[j];

if(!enemy.isDead() && enemy.getRect().overlaps(bullet.getRect())){

p1.addToScore(enemy.getScoreAdd());

enemy.hit();

bullet.hit();

p1.removeBullet(i);

bulletHit = true;

}

}

Bullet[] enemyBullets = swarm.bullets;

int numBullets = swarm.getNumBullets();

for(int j = numBullets-1; j >= 0 && !bulletHit; --j){

if(enemyBullets[j].getRect().overlaps(bullet.getRect())){

enemyBullets[j].hit();

swarm.removeBullet(j);

p1.bullets[i].hit();

p1.removeBullet(i);

bulletHit = true;

}

}

if( motherShip.getState() == MotherShip.State.ALIVE && !bulletHit ){

if(motherShip.getRect().overlaps(bullet.getRect())){

bullet.hit();

p1.removeBullet(i);

String powerupStr = p1.generatePowerup();

motherShip.hit(powerupStr);

float x = motherShip.getRect().getX();

float y = motherShip.getRect().getY();

float width = motherShip.getRect().getWidth();

float height = motherShip.getRect().getHeight();

bulletHit = true;

}

}

for(int s = 0; s < shields.length; ++s){

Rectangle shieldRect = shields[s].getBoundingRect();

if(shieldRect.overlaps(bullet.getRect())){

ShieldPart shieldParts[] = shields[s].shieldParts;

for(int sp = 0; sp < shieldParts.length && bulletHit == false; ++sp) {

if(shieldParts[sp].isAlive()) {

Rectangle shieldPartRect = shieldParts[sp].getRect();

if(shieldPartRect.overlaps(bullet.getRect())) {

bullet.hit();

shieldParts[sp].hitPlayerBullet();

p1.removeBullet(i);

bulletHit = true;

}

}

}

}

}

}

SpecialBullet p1SpecialBullet = p1.getSpecialBullet();

if( !p1SpecialBullet.isDead() ){

// enemies

for (int e = swarm.members.length-1; e >= 0; --e) {

Enemy enemy = swarm.members[e];

if( !enemy.isDead() ) {

if (enemy.getRect().overlaps(p1SpecialBullet.getRect())) {

enemy.getScoreAdd();

p1SpecialBullet.hit();

enemy.hit();

}

}

}

if(motherShip.isAlive()) {

if (motherShip.getRect().overlaps(p1SpecialBullet.getRect())) {

p1SpecialBullet.hit();

String powerupStr = p1.generatePowerup();

motherShip.hit(powerupStr);

float x = motherShip.getRect().getX();

float y = motherShip.getRect().getY();

float width = motherShip.getRect().getWidth();

float height = motherShip.getRect().getHeight();

}

}

int numBullets = swarm.getNumBullets();

for(int j = numBullets-1; j >= 0; --j){

if(swarm.bullets[j].getRect().overlaps(p1SpecialBullet.getRect())){

swarm.bullets[j].hit();

swarm.removeBullet(j);

p1SpecialBullet.hitBullet();

}

}

for(int s = 0; s < shields.length; ++s){

Rectangle shieldRect = shields[s].getBoundingRect();

if(shieldRect.overlaps(p1SpecialBullet.getRect())){

ShieldPart shieldParts[] = shields[s].shieldParts;

for(int sp = 0; sp < shieldParts.length; ++sp) {

if(shieldParts[sp].isAlive()) {

Rectangle shieldPartRect = shieldParts[sp].getRect();

if(shieldPartRect.overlaps(p1SpecialBullet.getRect())) {

p1SpecialBullet.hit();

shieldParts[sp].hitSpecialBullet();

}

}

}

}

}

}

int numBullets = swarm.getNumBullets();

for(int i = numBullets-1; i >= 0; --i){

Bullet bullet = swarm.bullets[i];

if( bullet.getX() < 0 ||

bullet.getX()+bullet.getWidth() > MainGame.WIDTH ||

bullet.getY() < -MainGame.yOff) {

bullet.hit();

swarm.removeBullet(i);

}

if(p1.getState() == Player.State.NORMAL) {

p1.getLocationRects(recievePlayerRectangles);

for (int j = 0; j < recievePlayerRectangles.length; ++j) {

if (recievePlayerRectangles[j].overlaps(bullet.getRect())) {

p1.hit();

bullet.hit();

swarm.removeBullet(i);

break;

}

}

}

boolean enemyBulletHit = false;

for(int s = 0; s < shields.length; ++s){

Rectangle shieldRect = shields[s].getBoundingRect();

if(shieldRect.overlaps(bullet.getRect())){

ShieldPart shieldParts[] = shields[s].shieldParts;

for(int sp = 0; sp < shieldParts.length; ++sp) {

if(shieldParts[sp].isAlive()) {

Rectangle shieldPartRect = shieldParts[sp].getRect();

if(shieldPartRect.overlaps(bullet.getRect())) {

bullet.hit();

shieldParts[sp].hitEnemyBullet();

swarm.removeBullet(i);

break;

}

}

}

}

}

}

boolean shieldHit;

for(int s = 0; s < shields.length; ++s){

if(!shields[s].isDead()) {

shieldHit = false;

for (int e = swarm.members.length - 1; e >= 0; --e) {

if(!swarm.members[e].isDead()) {

if (shields[s].getBoundingRect().overlaps(swarm.members[e].getRect())) {

ShieldPart shieldParts[] = shields[s].shieldParts;

boolean shieldPartHit = false;

for(int sp = 0; sp < shieldParts.length && !shieldPartHit; ++sp){

if(shieldParts[sp].isAlive() && shieldParts[sp].getRect().overlaps(swarm.members[e].getRect())){

shieldPartHit = true;

}

}

if(shieldPartHit) {

shieldHit = true;

swarm.members[e].hit();

}

}

}

}

if (shieldHit)

shields[s].die();

}

}

}

@Override

public void show() {

}

@Override

public void resize(int width, int height) {

}

@Override

public void pause() {

if(p1.getScore() > game.getHighScore())

game.setHighScore(p1.getScore());

font.dispose();

}

@Override

public void resume() {

}

@Override

public void hide() {

}

@Override

public void dispose() {

if(p1.getScore() > game.getHighScore())

game.setHighScore(p1.getScore());

font.dispose();

}

@Override

public void keyDown(int keyCode) {

if(state == STATE_NORMAL && keyCode == Input.Keys.SPACE)

p1.shoot();

}

@Override

public void touchDown(float x, float y){

if(state == STATE_NORMAL)

p1.shoot();

}

}

package com.mygdx.spacedefender.GameScreens;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.Input;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.GL20;

import com.badlogic.gdx.graphics.Texture;

import com.badlogic.gdx.graphics.g2d.BitmapFont;

import com.badlogic.gdx.graphics.g2d.GlyphLayout;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.Entities.Button;

import com.mygdx.spacedefender.Entities.Player;

import com.mygdx.spacedefender.MainGame;

public class GameOverScreen extends GameScreen {

public static final Color BG_COLOR = new Color(0.88f, 0.4f, 0.4f, 0.75f);

private Button retryButton, mainMenuButton;

private BitmapFont font;

private GlyphLayout fontLayout;

private String mainText, thisScoreText, oldHighScoreText;

private int oldHighScore, thisScore;

public GameOverScreen(MainGame game, Player p1) {

super(game, p1);

this.retryButton = new Button(82, MainGame.HEIGHT-237, 70, new Color(0.576f, 0.769f, 0.49f, 1f), Color.BLACK, Button.ButtonSymbol.RETRY);

this.mainMenuButton = new Button(MainGame.WIDTH-152, MainGame.HEIGHT-237, 70, new Color(0.7f, 0.65f, 0.84f, 1f), Color.BLACK, Button.ButtonSymbol.EXIT);

this.font = new BitmapFont();

// smooth font

font.getRegion().getTexture().setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear);

this.fontLayout = new GlyphLayout();

}

public void init(){

super.init(BG_COLOR);

p1.clearBullets();

if(p1.isDead())

mainText = "Game Over";

else

mainText = "You Won!";

thisScore = p1.getScore();

oldHighScore = game.getHighScore();

if(thisScore > oldHighScore) {

thisScoreText = "New High Score: " + thisScore;

game.setHighScore(thisScore);

}

else

thisScoreText = "Score: " + thisScore;

oldHighScoreText = "Previous High Score: " + oldHighScore;

retryButton.reset();

mainMenuButton.reset();

p1.reset();

p1.respawn();

}

public void update(float delta){

if(state == STATE_ENTERING){

transitionTime += delta;

if(transitionTime > transitionPeriod) {

transitionTime = 0;

state = STATE_NORMAL;

}

}

else if(state == STATE_TRANSITION_PLAYSCREEN){

transitionTime += delta;

MainGame.mix(BG_COLOR, PlayScreen.BG_COLOR, transitionTime / transitionPeriod, backgroundColor);

if(transitionTime > transitionPeriod) {

game.changeScreen(MainGame.PLAY_STATE);

}

}

else if(state == STATE_TRANSITION_MENUSCREEN){

transitionTime += delta;

MainGame.mix(BG_COLOR, MenuScreen.BG_COLOR, transitionTime / transitionPeriod, backgroundColor);

if(transitionTime > transitionPeriod) {

game.changeScreen(MainGame.MENU_STATE);

}

}

p1.update(delta);

collision();

}

public void draw(float delta){

float fadeTransparancy = 1f;

if(state == STATE_ENTERING)

fadeTransparancy = transitionTime/transitionPeriod;

else if(state == STATE_TRANSITION_PLAYSCREEN || state == STATE_TRANSITION_MENUSCREEN)

fadeTransparancy = 1f-(transitionTime/transitionPeriod);

Gdx.gl.glEnable(GL20.GL_BLEND);

game.sr.begin(ShapeRenderer.ShapeType.Filled);

game.sr.setColor(backgroundColor);

game.sr.rect(-MainGame.xOff, -MainGame.yOff, MainGame.viewportWidth, MainGame.viewportHeight);

retryButton.drawShape(game.sr, fadeTransparancy);

mainMenuButton.drawShape(game.sr, fadeTransparancy);

game.sr.end();

game.sr.begin(ShapeRenderer.ShapeType.Filled);

p1.drawBullets(game.sr);

p1.draw(game.sr);

game.sr.setColor(1f,1f,1f,0.25f);

game.sr.rect(0 - MainGame.xOff, 0 - MainGame.yOff, MainGame.xOff, MainGame.viewportHeight);

game.sr.rect(MainGame.WIDTH, 0 - MainGame.yOff, MainGame.xOff, MainGame.viewportHeight);

game.sr.end();

game.sb.begin();

retryButton.drawSymbol(game.sb, fadeTransparancy);

mainMenuButton.drawSymbol(game.sb, fadeTransparancy);

font.setColor(1,1,1,fadeTransparancy);

font.getData().setScale(4f);

fontLayout.setText(font, mainText);

float mainTextHeight = fontLayout.height;

float mainTextX = MainGame.WIDTH/2 - fontLayout.width/2;

float mainTextY = MainGame.HEIGHT - mainTextHeight / 2;

font.draw(game.sb, fontLayout, mainTextX, mainTextY);

// your score

font.getData().setScale(2f);

fontLayout.setText(font, thisScoreText);

float thisScoreTextHeight = fontLayout.height;

float thisScoreTextX = MainGame.WIDTH/2 - fontLayout.width/2;

float thisScoreTextY = mainTextY - mainTextHeight*2;

font.draw(game.sb, fontLayout, thisScoreTextX, thisScoreTextY);

// old high score

font.getData().setScale(1.5f);

fontLayout.setText(font, oldHighScoreText);

float oldHighScoreTextX = MainGame.WIDTH/2 - fontLayout.width/2;

float oldHighScoreTextY = thisScoreTextY - thisScoreTextHeight*2;

font.draw( game.sb, fontLayout, oldHighScoreTextX, oldHighScoreTextY );

game.sb.end();

Gdx.gl.glDisable(GL20.GL_BLEND);

}

@Override

public void keyDown(int keyCode) {

if( (state == STATE_NORMAL || state == STATE_ENTERING) && keyCode == Input.Keys.SPACE)

p1.shoot();

}

@Override

public void touchDown(float x, float y) {

if(state == STATE_NORMAL || state == STATE_ENTERING)

p1.shoot();

}

@Override

public void dispose() {

font.dispose();

retryButton.dispose();

mainMenuButton.dispose();

}

public void collision(){

p1.bulletsBounds();

for(int i = p1.getNumBullets()-1; i >= 0; --i) {

Rectangle bulletRect = p1.bullets[i].getRect();

if (retryButton.visible && bulletRect.overlaps(retryButton.getRect())) {

retryButton.hit();

p1.bullets[i].hit();

p1.removeBullet(i);

changeScreen(MainGame.PLAY_STATE);

}

if (mainMenuButton.visible && bulletRect.overlaps(mainMenuButton.getRect())) {

mainMenuButton.hit();

p1.bullets[i].hit();

p1.removeBullet(i);

changeScreen(MainGame.MENU_STATE);

}

}

}

@Override

public void resize(int width, int height) {

super.resize(width, height);

}

@Override

public void show() {

super.show();

}

@Override

public void pause() {

super.pause();

}

@Override

public void resume() {

super.resume();

}

@Override

public void hide() {

super.hide();

}

}

package com.mygdx.spacedefender.Level;

import com.badlogic.gdx.utils.Array;

public class Level {

private float minMovePeriod, maxMovePeriod;

private float minShootChance, maxShootChance;

public int[] members;

private String name;

public Level(String name, float minMovePeriod, float maxMovePeriod,

float minShootChance, float maxShootChance,

int[] members){

this.name = name;

this.minMovePeriod = minMovePeriod;

this.maxMovePeriod = maxMovePeriod;

this.minShootChance = minShootChance;

this.maxShootChance = maxShootChance;

this.members = members;

}

public float getMinMovePeriod(){ return minMovePeriod; }

public float getMaxMovePeriod(){ return maxMovePeriod; }

public float getMinShootPeriod(){ return minShootChance; }

public float getMaxShootPeriod(){ return maxShootChance; }

public static Level level1(){

int[] levelArray = {

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1

};

Level level = new Level("Stage - 1.0", 0.1f, 0.5f, 0.01f, 0.05f, levelArray);

return level;

}

public static Level level2(){

int[] levelArray = {

2, 2, 2, 1, 1, 1, 1, 2, 2, 2,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 2, 2, 2, 2, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2

};

Level level = new Level("Stage - 2.0", 0.1f, 0.6f, 0.1f, 0.3f, levelArray);

return level;

}

public static Level level3(){

int[] levelArray = {

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2

};

Level level = new Level("Stage - 2.1", 0.1f, 0.7f, 0.1f, 0.2f, levelArray);

return level;

}

public static Level level4(){

int[] levelArray = {

3, 1, 1, 1, 1, 1, 1, 1, 1, 3,

3, 1, 1, 1, 3, 3, 1, 1, 1, 3,

3, 1, 1, 1, 3, 3, 1, 1, 1, 3,

3, 1, 1, 1, 1, 1, 1, 1, 1, 3,

1, 3, 3, 3, 1, 1, 3, 3, 3, 1

};

Level level = new Level("Stage - 3.0", 0.1f, 0.8f, 0.1f, 0.3f, levelArray);

return level;

}

public static Level level5(){

int[] levelArray = {

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

3, 3, 3, 3, 3, 3, 3, 3, 3, 3

};

Level level = new Level("Stage - 3.1", 0.1f, 0.9f, 0.1f, 0.4f, levelArray);

return level;

}

public static Level levelTest(){

int[] levelArray = {

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1, 1, 1, 0, 0, 0, 0, 0, 0, 0,

1, 1, 1, 0, 0, 0, 0, 0, 0, 0

};

Level level = new Level("Stage - Test", 0.09f, 0.2f, 0.01f, 0.04f, levelArray);

return level;

}

public static Array<Level> getLevels(){

Array<Level> levels = new Array<Level>(true, 5);

levels.addAll( level5(), level4(), level3(), level2(), level1() );

return levels;

}

public String getName(){

return name;

}

}

package com.mygdx.spacedefender.Input;

import com.badlogic.gdx.Game;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.Input;

import com.badlogic.gdx.InputProcessor;

import com.mygdx.spacedefender.GameScreens.GameScreen;

public class InputHandler implements InputProcessor {

private GameScreen screen;

public InputHandler(Game game){

this.screen = (GameScreen)game.getScreen();

}

@Override

public boolean keyDown(int keycode) {

if(keycode == Input.Keys.ESCAPE){

Gdx.app.exit();

}

screen.keyDown(keycode);

return true;

}

@Override

public boolean touchDown(int screenX, int screenY, int pointer, int button) {

screen.touchDown(screenX, screenY);

return true;

}

public void setScreen(GameScreen screen){

this.screen = screen;

}

@Override

public boolean touchUp(int screenX, int screenY, int pointer, int button) {

return false;

}

@Override

public boolean touchDragged(int screenX, int screenY, int pointer) {

return false;

}

@Override

public boolean mouseMoved(int screenX, int screenY) {

return false;

}

@Override

public boolean scrolled(int amount) {

return false;

}

@Override

public boolean keyUp(int keycode) {

return false;

}

@Override

public boolean keyTyped(char character) {

return false;

}

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.Rectangle;

public class Bullet {

protected int x, y, width, height;

private Rectangle rect;

protected float xSpeed, ySpeed;

public Color color;

public enum Type{

RECT, ROUND

}

private Type type;

public Bullet(){

this.rect = new Rectangle();

}

public void reset(int x, int y, int width, int height, float ySpeed, Color color, Type type){

reset(x, y, width, height, 0, ySpeed, color, type);

}

public void reset(int x, int y, int width, int height, float xSpeed, float ySpeed, Color color,Type type){

this.x = x;

this.y = y;

this.width = width;

this.height = height;

this.xSpeed = xSpeed;

this.ySpeed = ySpeed;

this.color = color;

this.type = type;

}

public void update(float delta){

x += xSpeed *delta*60;

y += ySpeed *delta*60;

}

public void draw(ShapeRenderer sr){

sr.setColor(color);

if(this.type == Type.ROUND)

sr.ellipse(x, y, width, height);

else if(this.type == Type.RECT)

sr.rect(x, y, width, height);

}

public void hit(){

float tempYSpeed = ySpeed > 0 ? 0 : -ySpeed*0.3f;

}

public int getX(){

return x;

}

public int getY(){

return y;

}

public int getWidth(){

return width;

}

public int getHeight(){

return height;

}

public Rectangle getRect(){

rect.set(x, y, width, height);

return rect;

}

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.audio.Sound;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.Texture;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.MainGame;

public class Button {

public static Texture exitSymbol;

public static Texture playSymbol;

public static Texture settingsSymbol;

public static Texture retrySymbol;

public static Texture okaySymbol;

public static Sound hitSound;

public enum ButtonSymbol{

EXIT, PLAY, SETTINGS, RETRY, OKAY

}

private float x, y, symX, symY;

private Rectangle rect;

private float size, symSize;

private Color buttonColor, symbolColor;

private Texture symbol;

public boolean visible;

private ButtonSymbol type;

public Button(float x, float y, float size, Color buttonColor, Color symbolColor, ButtonSymbol buttonSymbol){

this.x = x;

this.y = y;

this.size = size;

this.buttonColor = buttonColor;

this.symbolColor = symbolColor;

visible = true;

symX = x + size/6;

symY = y + size/6;

symSize = size/6*4;

this.rect = new Rectangle();

this.type = buttonSymbol;

if(type == ButtonSymbol.EXIT)

this.symbol = exitSymbol;

else if(type == ButtonSymbol.PLAY)

this.symbol = playSymbol;

else if(type == ButtonSymbol.SETTINGS)

this.symbol = settingsSymbol;

else if(type == ButtonSymbol.RETRY)

this.symbol = retrySymbol;

else if(type == ButtonSymbol.OKAY)

this.symbol = okaySymbol;

}

public void reset(){

this.visible = true;

}

public void dispose(){

symbol.dispose();

}

public void drawShape(ShapeRenderer sr, float transparancy){

if(!visible)

return;

sr.setColor(buttonColor.r, buttonColor.g, buttonColor.b, transparancy);

sr.rect(x, y, size, size);

}

public void drawSymbol(SpriteBatch sb, float transparancy){

if(!visible)

return;

sb.setColor(symbolColor.r, symbolColor.g, symbolColor.b, transparancy);

sb.draw(symbol, symX, symY, symSize, symSize);

}

public Rectangle getRect(){

rect.set(x, y, size, size);

return rect;

}

public void hit(){

hitSound.play(MainGame.volume);

visible = false;

}

public float getX(){

return x;

}

public float getY(){

return y;

}

public float getSize(){

return size;

}

public ButtonSymbol getType(){

return type;

}

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.audio.Sound;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.GameScreens.PlayScreen;

import com.mygdx.spacedefender.MainGame;

public abstract class Enemy {

public static final int BULLET_WIDTH = 5;

public static final int BULLET_HEIGHT = 10;

public static final int BULLET_SPEED = -2;

public static Sound hitSound;

protected static boolean useImageOne;

protected boolean shoots;

protected boolean dead;

protected Rectangle rect;

protected Swarm swarm;

protected int index;

public Enemy(Swarm swarm, int x, int y, int width, int height, int index){

this.rect = new Rectangle(x, y, width, height);

useImageOne = true;

this.swarm = swarm;

this.index = index;

}

public abstract void shoot(Bullet bullet);

public abstract void draw(SpriteBatch batch);

public abstract void draw(float xOff, float yOff, SpriteBatch batch);

public abstract void hit();

public void die(){

dead = true;

swarm.memberDied(index);

}

public boolean move(int direction){

rect.x += MainGame.UNIT * direction;

return rect.x+rect.width > MainGame.WIDTH || rect.x < 0;

}

public boolean moveDown(){

rect.y -= MainGame.UNIT;

return rect.y < PlayScreen.LOSE_HEIGHT;

}

public Rectangle getRect(){

return rect;

}

public int getX(){

return (int)rect.x;

}

public int getY(){

return (int)rect.y;

}

public int getWidth(){

return (int)rect.width;

}

public int getHeight(){

return (int)rect.height;

}

public static void changeImage(){

useImageOne = !useImageOne;

}

public void setShoots(boolean val){

shoots = val;

}

public boolean isShooter(){

return shoots;

}

public boolean isDead(){

return dead;

}

public abstract int getScoreAdd();

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.audio.Sound;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.Texture;

import com.badlogic.gdx.graphics.g2d.BitmapFont;

import com.badlogic.gdx.graphics.g2d.GlyphLayout;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import com.badlogic.gdx.graphics.g2d.TextureRegion;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.MainGame;

public class MotherShip {

public enum State{

ALIVE, DYING, DEAD, PAUSED

}

private State state;

private static final float WIDTH = MainGame.UNIT*4;

private static final float HEIGHT = MainGame.UNIT*1.5f;

public static TextureRegion image;

public static Sound sound;

public static final Color COLOR = Color.RED;

private Rectangle rect;

private float xSpeed;

private float startOffset = MainGame.UNIT;

private BitmapFont font;

private GlyphLayout layout;

private final int dyingPeriod = 3;

private float dyingTime;

public MotherShip(){

this.state = State.DEAD;

this.rect = new Rectangle(0, MainGame.HEIGHT - MainGame.UNIT * 4, WIDTH, HEIGHT);

startOffset = 30f;

this.font = new BitmapFont();

font.getRegion().getTexture().setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear);

font.getData().setScale(1f);

this.layout = new GlyphLayout();

}

public void reset(){

sound.loop(MainGame.volume*0.5f);

this.state = State.ALIVE;

float x;

if(Math.random() < 0.5){

x = -startOffset;

this.xSpeed = 80f;

} else{

x = MainGame.WIDTH + startOffset;

this.xSpeed = -80f;

}

this.rect.setX(x);

this.dyingTime = 0;

}

public void update(float delta){

if(state == State.DEAD)

return;

if(state == State.DYING){

dyingTime += delta;

if(dyingTime > dyingPeriod)

state = State.DEAD;

}

else if(state == State.ALIVE) {

rect.x += delta * xSpeed;

if (rect.x > MainGame.WIDTH + startOffset || rect.x + rect.width < 0 - startOffset)

dieNow();

}

}

public void draw(SpriteBatch sb) {

if (state == State.ALIVE || state == State.PAUSED) {

sb.setColor(COLOR);

sb.draw(image, rect.x, rect.y, rect.width, rect.height);

}

else if(state == State.DYING){

float x = rect.x+rect.width/2;

if(x-layout.width/2 < 0)

x = layout.width/2;

else if(x+layout.width/2 > MainGame.WIDTH)

x = MainGame.WIDTH-layout.width/2;

font.draw(sb, layout, x, rect.y);

}

}

public void die(String powerupStr){

layout.setText(font, powerupStr, Color.WHITE, rect.width, 0, false);

sound.stop();

state = State.DYING;

}

public void dieNow(){

sound.stop();

state = State.DEAD;

}

public void hit(String powerupStr) {

die(powerupStr);

}

public void pause(){

if(state == State.ALIVE) {

sound.pause();

state = State.PAUSED;

}

}

public void resume(){

if(state == State.PAUSED) {

sound.resume();

state = State.ALIVE;

}

}

public boolean isAlive(){

return state == State.ALIVE;

}

public Rectangle getRect(){

return rect;

}

public State getState(){

return state;

}

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.Input;

import com.badlogic.gdx.audio.Sound;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.MathUtils;

import com.badlogic.gdx.math.Vector2;

import com.mygdx.spacedefender.GameScreens.GameScreen;

import com.mygdx.spacedefender.GameScreens.PlayScreen;

import com.mygdx.spacedefender.MainGame;

import com.badlogic.gdx.math.Rectangle;

public class Player {

public enum Powerup{

NONE, DOUBLESHOT, LEFTSHOT, RIGHTSHOT, VERTICALSHOT, EXTRA_LIVE

}

public enum State{

ENTERING, NORMAL, RESPAWNING, DEAD

}

private State state;

private Powerup powerup;

private float powerupTimeLeft;

public static final int WIDTH = (int)(MainGame.UNIT*3.5);

public static final int HEIGHT = (int)(MainGame.UNIT*2);

public static final int Y = MainGame.UNIT*2;

private final Color color = new Color(1.0f, 1.0f, 1.0f, 2f);

public static Sound shootSound;

public static Sound hitSound;

public static Sound gong;

private GameScreen currentScreen;

private Rectangle[] rects;

private Vector2 loc;

private float xAcc, xVel;

private float xAccelerometerVel;

public Bullet[] bullets;

private int numBullets;

private SpecialBullet specialBullet;

private int lives;

private int score;

private float shootPeriod = 1;

private float bulletOneShootTime;

private float bulletTwoShootTime;

private float respawnTimer;

private final float respawnTime = 4;

private PlayerHUD hud;

public Player(){

this.loc = new Vector2(MainGame.WIDTH/2 - WIDTH /2f, Y);

this.rects = new Rectangle[] {

new Rectangle(0, 0, WIDTH, (5f/8f)* HEIGHT),

new Rectangle(WIDTH *0.5f - WIDTH *(3f/13f)/2f, (5f/8f)* HEIGHT, WIDTH *(3f/13f), (2f/8f)* HEIGHT),

new Rectangle(WIDTH *0.5f - WIDTH *(1f/13f)/2f, (7f/8f)* HEIGHT, WIDTH *(1f/13f), (1f/8f)* HEIGHT)

};

this.bullets = new Bullet[]{new Bullet(), new Bullet()};

this.specialBullet = new SpecialBullet();

this.hud = new PlayerHUD(this);

reset();

}

public void reset(){

this.lives = 3;

this.xAcc = 0;

this.xVel = 0;

this.xAccelerometerVel = 0;

this.numBullets = 0;

this.specialBullet.die();

this.powerup = Powerup.NONE;

this.bulletOneShootTime = shootPeriod;

this.bulletTwoShootTime = shootPeriod;

this.state = State.NORMAL;

this.score = 0;

}

public void setCurrentScreen(GameScreen currentScreen){

this.currentScreen = currentScreen;

}

public void draw(ShapeRenderer sr){

if( isRespawning() ){

float alpha;

float startFlashingAt = respawnTime/8;

float flashTime = (respawnTime-startFlashingAt)/3;

alpha = ((respawnTimer-startFlashingAt) % flashTime) * (2 / flashTime);

if (alpha > 1)

alpha = 1 - (alpha - 1);

sr.setColor(color.r, color.g, color.b, alpha);

}

else if(state == State.DEAD){

return;

}

else {

sr.setColor(color);

}

for(int i = 0; i < rects.length; ++i) {

sr.rect(loc.x + rects[i].getX(), loc.y + rects[i].getY(), rects[i].getWidth(), rects[i].getHeight());

}

}

public void drawBullets(ShapeRenderer sr){

for(int i = 0; i < numBullets; ++i){

bullets[i].draw(sr);

}

if( !specialBullet.isDead() ) {

specialBullet.draw(sr);

}

}

public void drawHUDShapes(ShapeRenderer sr, float transparency){

hud.drawShapes(sr, transparency);

}

public void drawHUDText(SpriteBatch sb, float transparency){

hud.drawText(sb, transparency);

}

public void update(float delta) {

if(isRespawning()){

respawnTimer += delta;

if(respawnTimer > respawnTime) {

state = State.NORMAL;

currentScreen.onPlayerRespawnEnd();

}

else

return;

}

move(delta);

if (powerup != Powerup.NONE) {

if(state == State.NORMAL) {

powerupTimeLeft -= delta;

if (powerupTimeLeft < 0) {

powerupTimeLeft = 0;

powerup = Powerup.NONE;

}

}

if (powerup == Powerup.DOUBLESHOT) {

if (bulletTwoShootTime < shootPeriod) {

bulletTwoShootTime += delta;

if (bulletTwoShootTime > shootPeriod)

bulletTwoShootTime = shootPeriod;

}

}

}

if (bulletOneShootTime < shootPeriod) {

bulletOneShootTime += delta;

if (bulletOneShootTime > shootPeriod)

bulletOneShootTime = shootPeriod;

}

for(Bullet bullet: bullets){

bullet.update(delta);

}

if( !specialBullet.isDead() )

specialBullet.update(delta);

}

public void friction(float force){

xVel *= force;

}

public void move(float delta){

if( isRespawning() || isDead() )

return;

xAccelerometerVel = Gdx.input.getAccelerometerY();

xAccelerometerVel /= 5f;

if(xAccelerometerVel > 1)

xAccelerometerVel = 1;

friction(0.9f);

xVel += xAccelerometerVel;

xVel += xAcc;

loc.x += xVel * delta*60;

boolean left = Gdx.input.isKeyPressed(Input.Keys.LEFT);

boolean right = Gdx.input.isKeyPressed(Input.Keys.RIGHT);

boolean space = Gdx.input.isKeyPressed(Input.Keys.SPACE);

if(left && !right){

xVel -= 1.0f;

} else if(right && !left){

xVel += 1.0f;

}

if(xVel > 5)

xVel = 5;

else if(xVel < -5)

xVel = -5;

xAcc = 0;

if(loc.x+ WIDTH > MainGame.WIDTH)

loc.x = MainGame.WIDTH - WIDTH;

else if(loc.x < 0)

loc.x = 0;

}

public void shoot(){

if( isRespawning() || isDead() )

return;

if( ( (numBullets == 1 && powerup == Powerup.DOUBLESHOT) || numBullets == 0 )

&& state != State.ENTERING ){

if(powerup == Powerup.DOUBLESHOT && bulletTwoShootTime >= shootPeriod){

bullets[numBullets].reset((int) loc.x + WIDTH / 2 - (5 / 2), (int) loc.y + HEIGHT, 5, 10, /*2*/8, color, Bullet.Type.RECT);

++numBullets;

shootSound.play(MainGame.volume);

bulletTwoShootTime -= shootPeriod;

}

else if(bulletOneShootTime >= shootPeriod) {

if(powerup == Powerup.RIGHTSHOT){

specialBullet.reset((int) loc.x + WIDTH / 2 - (5 / 2), (int) loc.y + HEIGHT, SpecialBullet.Direction.RIGHT);

powerup = Powerup.NONE;

}

else if(powerup == Powerup.LEFTSHOT){

specialBullet.reset((int) loc.x + WIDTH / 2 - (5 / 2), (int) loc.y + HEIGHT, SpecialBullet.Direction.LEFT);

powerup = Powerup.NONE;

}

else if(powerup == Powerup.VERTICALSHOT){

specialBullet.reset((int) loc.x + WIDTH / 2 - (5 / 2), (int) loc.y + HEIGHT, SpecialBullet.Direction.VERTICAL);

powerup = Powerup.NONE;

}

else{

bullets[numBullets].reset((int) loc.x + WIDTH / 2 - (5 / 2), (int) loc.y + HEIGHT, 5, 10, /*2*/8, color, Bullet.Type.RECT);

++numBullets;

bulletOneShootTime -= shootPeriod;

}

shootSound.play(MainGame.volume);

}

}

}

public void removeBullet(int index){

if(numBullets > 0 && numBullets < 3) {

Bullet temp = bullets[index];

bullets[index] = bullets[numBullets - 1];

bullets[numBullets - 1] = temp;

--numBullets;

}

}

public void hit(){

if(lives > 0)

--lives;

hitSound.play(MainGame.volume);

if(lives > 0){

respawn();

}

else{

state = State.DEAD;

}

}

public void die(){

lives = 0;

state = State.DEAD;

}

public void center(){

loc.x = MainGame.WIDTH/2 - getWidth()/2;

}

public void respawn(){

currentScreen.onPlayerRespawnStart();

state = State.RESPAWNING;

respawnTimer = 0;

clearBullets();

powerup = Powerup.NONE;

xVel = 0;

center();

}

public void bulletsBounds(){

int count = 0;

if(numBullets > 1) {

if (bullets[1].getX() < 0 ||

bullets[1].getX() + bullets[1].getWidth() > MainGame.WIDTH ||

bullets[1].getY() + bullets[1].getHeight() > MainGame.HEIGHT+MainGame.yOff) {

bullets[1].hit();

removeBullet(1);

gong.play(MainGame.volume);

count++;

}

}

if(numBullets > 0){

if (bullets[0].getX() < 0 ||

bullets[0].getX() + bullets[0].getWidth() > MainGame.WIDTH ||

bullets[0].getY() + bullets[0].getHeight() > MainGame.HEIGHT+MainGame.yOff) {

bullets[0].hit();

removeBullet(0);

gong.play(MainGame.volume);

count++;

}

}

if( !specialBullet.isDead() ) {

if (specialBullet.getX() < 0 ||

specialBullet.getX() + specialBullet.getWidth() > MainGame.WIDTH ||

specialBullet.getY() + specialBullet.getHeight() > MainGame.HEIGHT + MainGame.yOff) {

specialBullet.hit();

specialBullet.die();

gong.play(MainGame.volume);

count++;

}

}

}

public void getLocationRects(Rectangle[] outRects){

outRects[0].set(rects[0]);

outRects[1].set(rects[1]);

outRects[2].set(rects[2]);

for(int i = 0; i < outRects.length; ++i){

outRects[i].x += loc.x;

outRects[i].y += loc.y;

}

}

public Rectangle[] getShapeRects(){

return rects;

}

public Color getBackgroundColor(){

return ((PlayScreen)currentScreen).getBackgroundColor();

}

public float getX(){

return loc.x;

}

public float getY(){

return loc.y;

}

public int getWidth(){

return WIDTH;

}

public int getHeight(){

return HEIGHT;

}

public int getNumBullets(){

return numBullets;

}

public void setState(State state){

this.state = state;

}

public boolean isDead(){

return lives <= 0;

}

public int getScore(){

return score;

}

public void addToScore(int val){

score += val;

}

public String generatePowerup(){

Powerup powerup;

this.powerupTimeLeft = 30;

double r = MathUtils.random();

float dividor = 6f;

if(lives < 3)

dividor = 8f;

if(r < 2f/6f)

powerup = Powerup.DOUBLESHOT;

else if(r < 4f/dividor)

powerup = Powerup.VERTICALSHOT;

else if(r < 5f/dividor)

powerup = Powerup.LEFTSHOT;

else if(r <= 6f/dividor)

powerup = Powerup.RIGHTSHOT;

else {

powerupTimeLeft = 5;

if(lives < 3)

lives++;

powerup = Powerup.EXTRA_LIVE;

}

this.powerup = powerup;

return getPowerupString(this.powerup);

}

public SpecialBullet getSpecialBullet(){

return specialBullet;

}

public void killSpecialBullet() {

specialBullet.die();

}

public String getPowerupString(Powerup powerup){

String s = "";

if(powerup == Powerup.DOUBLESHOT)

s = "Double Shot";

else if(powerup == Powerup.RIGHTSHOT)

s = "Right Shot";

else if(powerup == Powerup.LEFTSHOT)

s = "Left Shot";

else if(powerup == Powerup.VERTICALSHOT)

s = "Vertical Shot";

else if(powerup == Powerup.EXTRA_LIVE){

s = "Extra Life";

}

return s;

}

public void clearBullets(){

numBullets = 0;

specialBullet.die();

}

public boolean isRespawning(){

return state == State.RESPAWNING;

}

public float getBulletOneShootTimePercent(){

return bulletOneShootTime / shootPeriod;

}

public float getBulletTwoShootTimePercent(){

return bulletTwoShootTime / shootPeriod;

}

public Powerup getPowerup(){

return powerup;

}

public int getLives(){

return lives;

}

public float getPowerupTimeLeft(){

return powerupTimeLeft;

}

public State getState() { return state; }

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.MainGame;

public class Shield {

public static final float HEIGHT = ShieldPart.HEIGHT*4;

public static final float WIDTH = ShieldPart.WIDTH*4;

public static final float AT_HEIGHT = Player.Y + Player.HEIGHT + MainGame.UNIT*3;

public static final float GAP_WIDTH = (MainGame.WIDTH - WIDTH*4)/5;

private float x, y;

private Rectangle rect;

public ShieldPart shieldParts[];

public Color color;

public Shield(float x, float y, Color color){

this.x = x;

this.y = y;

this.color = color.cpy();

shieldParts = new ShieldPart[16];

this.rect = new Rectangle(x, y, WIDTH, HEIGHT);

int j = 0;

for(int i = 0; i < shieldParts.length; i += 4){

shieldParts[i] = new ShieldPart(x, y + (j * ShieldPart.HEIGHT), this);

shieldParts[i + 1] = new ShieldPart(x + ShieldPart.WIDTH, y + (j * ShieldPart.HEIGHT), this);

shieldParts[i + 2] = new ShieldPart(x + ShieldPart.WIDTH * 2, y + (j * ShieldPart.HEIGHT), this);

shieldParts[i + 3] = new ShieldPart(x + ShieldPart.WIDTH * 3, y + (j * ShieldPart.HEIGHT), this);

++j;

}

}

public void reset(){

for(int i = 0; i < shieldParts.length; ++i){

shieldParts[i].reset();

}

}

public void draw(ShapeRenderer sr, float fadeTransparency){

for(int i = 0; i < shieldParts.length; ++i) {

sr.setColor(color.r, color.g, color.b, fadeTransparency);

shieldParts[i].draw(sr);

}

}

public void die(){

int count = 0;

for(int i = 0; i < shieldParts.length; ++i){

if(shieldParts[i].isAlive()){

count++;

}

}

for(int i = 0; i < shieldParts.length; ++i){

if(shieldParts[i].isAlive()){

shieldParts[i].hitEnemy();

}

}

if(count > 0)

Player.hitSound.play();

}

public Rectangle getBoundingRect(){

return rect;

}

public boolean isDead(){

boolean answer = true;

for(int i = 0; i < shieldParts.length; ++i){

answer = answer && !shieldParts[i].isAlive();

}

return answer;

}

}

package com.mygdx.spacedefender.Entities;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.audio.Sound;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.mygdx.spacedefender.Level.Level;

import com.mygdx.spacedefender.MainGame;

public class Swarm {

public enum State{

NORMAL, PAUSED

}

public static final int ROWS = 5;

public static final int COLS = 10;

public static Sound moveSound;

private int direction = 1;

public static final int START_HEIGHT = MainGame.HEIGHT - MainGame.UNIT*4;

private State state;

private int numTimesMovedDown;

public Enemy[] members;

public double sideWidth;

public Bullet[] bullets;

private int numBullets;

private int numMembersAlive;

private float movePeriod;

private float timeSinceMove = 0;

private float shootChance = 0.1f;

private float minMovePeriod, maxMovePeriod, minShootChance, maxShootChance;

public Swarm(){

members = new Enemy[ROWS*COLS];

bullets = new Bullet[20];

for(int i = bullets.length-1; i >= 0; --i)

bullets[i] = new Bullet();

int swarmWidth = (COLS*3* MainGame.UNIT) + (COLS-1)* MainGame.UNIT;

sideWidth = (MainGame.WIDTH-swarmWidth)/2.0;

this.moveSound = Gdx.audio.newSound(Gdx.files.internal("fastinvader116bit.wav"));

numBullets = 0;

numTimesMovedDown = 0;

this.state = State.NORMAL;

}

public boolean update(float delta){

if(state == State.PAUSED)

return false;

boolean gameOver = false;

timeSinceMove += delta;

while(timeSinceMove > movePeriod) {

moveSound.play(MainGame.volume);

Enemy.changeImage();

gameOver = move();

for(int i = 0; i < members.length; ++i){

if(numBullets < bullets.length && Math.random() < shootChance){

if(members[i].isShooter() && !members[i].isDead()) {

if(members[i] instanceof EnemyThree && numBullets < bullets.length-1) {

Bullet[] tempBullets = new Bullet[]{bullets[numBullets], bullets[numBullets+1]};

((EnemyThree)members[i]).shoot(tempBullets);

numBullets += 2;

}

else {

members[i].shoot(bullets[numBullets]);

++numBullets;

}

}

}

}

timeSinceMove -= movePeriod;

}

return gameOver;

}

public void updateBullets(float delta){

for(int i = 0; i < numBullets; ++i){

bullets[i].update(delta);

}

}

public void draw(SpriteBatch batch){

for(int i = 0; i < members.length; ++i){

if(!members[i].isDead())

members[i].draw(batch);

}

}

public void draw(SpriteBatch batch, float xRel, float yRel){

for(int i = 0; i < members.length; ++i) {

if(!members[i].isDead())

members[i].draw(xRel, yRel, batch);

}

}

public void drawBullets(ShapeRenderer sr){

for(int i = 0; i < numBullets; ++i) {

bullets[i].draw(sr);

}

}

public void removeBullet(int index){

if(numBullets > 0 && numBullets < bullets.length) {

Bullet temp = bullets[index];

bullets[index] = bullets[numBullets - 1];

bullets[numBullets - 1] = temp;

--numBullets;

}

}

public boolean move(){

boolean gonePastEdge = false;

for(int i = 0; i < members.length; ++i){

if(!members[i].isDead())

gonePastEdge = members[i].move(direction) || gonePastEdge;

}

// if any went past edge of screen, then flip speed, move down, and move back twice

// also capture if enemies have gone to low, then the game would be over

boolean gameOver = false;

if(gonePastEdge) {

++numTimesMovedDown;

direction *= -1;

for(int i = 0; i < members.length; ++i){

if(!members[i].isDead()) {

members[i].move(direction);

gameOver = members[i].moveDown() || gameOver;

}

}

}

// returns true if the game is over

return gameOver;

}

public void loadLevel(Level level){

numMembersAlive = 0;

for(int x = 0; x < COLS; ++x){

for(int y = 0; y < ROWS; ++y){

int membersIndex = x*ROWS + y;

int levelIndex = y*COLS + x;

if(level.members[levelIndex] == 1){

int X = (int)sideWidth + (x* MainGame.UNIT*4);

int Y = START_HEIGHT - (y* MainGame.UNIT*3);

members[membersIndex] = new EnemyOne(this, X, Y, membersIndex);

++numMembersAlive;

}

else if(level.members[levelIndex] == 2){

int X = (int)sideWidth + (x* MainGame.UNIT*4);

int Y = START_HEIGHT - (y* MainGame.UNIT*3);

members[membersIndex] = new EnemyTwo(this, X, Y, membersIndex);

++numMembersAlive;

}

else if(level.members[levelIndex] == 3){

int X = (int)sideWidth + (x* MainGame.UNIT*4) + (MainGame.UNIT/2);

int Y = START_HEIGHT - (y* MainGame.UNIT*3);

members[membersIndex] = new EnemyThree(this, X, Y, membersIndex);

++numMembersAlive;

}

else{

members[membersIndex] = new EnemyThree(this, 0, 0, membersIndex);

members[membersIndex].dead = true;

}

if(y == 4)

members[membersIndex].setShoots(true);

}

}

this.minMovePeriod = level.getMinMovePeriod();

this.maxMovePeriod = level.getMaxMovePeriod();

this.minShootChance = level.getMinShootPeriod();

this.maxShootChance = level.getMaxShootPeriod();

this.movePeriod = maxMovePeriod;

this.shootChance = minShootChance;

this.numBullets = 0;

movePeriod = maxMovePeriod;

numTimesMovedDown = 0;

this.state = State.NORMAL;

}

public void memberDied(int index){

--numMembersAlive;

float percent = (float)(numMembersAlive)/(float)(ROWS*COLS);

float percentSqrt = (float)Math.sqrt((double)percent);

movePeriod = minMovePeriod + percentSqrt*(maxMovePeriod-minMovePeriod);

shootChance = minShootChance + (1f - percentSqrt)*(maxShootChance-minShootChance);

if(members[index].isShooter()) {

--index;

while (index >= 0) {

if (!(members[index].isDead() && members[index].isDead())) {

members[index].setShoots(true);

break;

}

--index;

}

}

}

public void pause(){

state = State.PAUSED;

}

public void resume(){

state = State.NORMAL;

}

public int getNumBullets(){

return numBullets;

}

public int getNumMembersAlive(){

return numMembersAlive;

}

public int getNumTimesMovedDown() { return numTimesMovedDown; }

}

Размещено на Allbest.ru

...