You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1237 lines
37 KiB

/**
* Copyright 2022 Jamie Munro, All rights reserved
* CS5041 P1
* Game 1
*/
import java.util.Map;
import java.util.Iterator;
import processing.serial.*;
import ddf.minim.*;
Configuration conf;
DisplayDimensions dimensions;
Map<Integer, PImage> tileSet; //Maps tile id to related image (to avoid repeated/redundant image loads)
Map<String, PImage[]> spriteSet;
//sounds
Minim minim;
String activeSong;
Map<String, AudioPlayer> music;
Map<String, AudioPlayer> soundEffects;
Controller controller;
Serial port;
Player player;
Level level;
TileProperties props;
//viewport variables
int startCol;
int endCol;
int startRow;
int endRow;
//game state
boolean loading;
boolean titleScreen;
boolean story;
boolean pause;
boolean gameOver;
//scores
int score;
int lives;
int bombs;
int difficulty;
//timers
long startTime;
long pauseTime;
long lastShot;
long gameOverTime;
long spawnTime;
//story screen variables
int storyCounter;
float storyY;
int storyLines;
//rewards variables
int nextLife;
int nextBomb;
//projectiles
List<Projectile> playerProjectiles;
List<Projectile> enemyProjectiles;
Bomb bomb;
//enemy variables
List<Enemy> enemies;
void setup() {
fullScreen(P2D, 2);
try {
conf = new Configuration();
}
catch (Exception e) {
println("Unable to access valid configuration.properties file.");
e.printStackTrace();
exit();
}
dimensions = new DisplayDimensions(width, height, conf);
frameRate(conf.framerate);
controller = new MicrobitController(conf, false);
try {
//for (Object device : Serial.list()) {
// println(device);
//}
port = new Serial(this, Serial.list()[conf.serialDevice], conf.baudRate);
}
catch (Exception e) {
println("ERROR: could not access serial port. If your sure the device is connected and you have set the correct serialDevice in config.properties, try running as root/administrator.");
e.printStackTrace();
exit();
}
port.bufferUntil(conf.lineEnding);
//intialise game state
loading = true;
titleScreen = false;
story = false;
pause = false;
2 years ago
gameOver = false;
storyY = dimensions.heightOffset + (dimensions.adjustedHeight/1.75);
storyCounter = 0;
storyLines = countLines(conf.storyCrawl);
//initialise scores
score = 0;
lives = conf.initialLives;
bombs = conf.initialBombs;
difficulty = 0;
//initialise enemies
enemies = new ArrayList<Enemy>();
//initialise projectiles
playerProjectiles = new ArrayList<Projectile>();
enemyProjectiles = new ArrayList<Projectile>();
bomb = null;
//sounds
minim = new Minim(this);
//fonts
PFont mono = createFont(sketchPath() + System.getProperty("file.separator") + conf.fontPath + System.getProperty("file.separator") + "andalemo.ttf", 128);
textFont(mono);
//perform loading
thread("loadResources");
}
/**
* Called repeatedly, every 1/framerate seconds
*/
void draw() {
background(0);
if (loading) {
loadingScreen();
}
else if (titleScreen) {
titleScreen();
}
else if (story) {
storyScroll();
}
else if (pause) {
pause();
}
else if (gameOver) {
gameOver();
}
else {
game();
}
if (!loading) {
//music
if ((activeSong == null) || (!music.get(activeSong).isPlaying())) {
playRandomSong();
}
}
//println(frameRate);
}
void stop() {
//Close Minim audio classes
for (String song : music.keySet()) {
music.get(song).close();
}
for (String effect : soundEffects.keySet()) {
soundEffects.get(effect).close();
}
//Stop Minim before exiting
minim.stop();
super.stop();
}
void serialEvent(Serial p) {
String input = p.readString();
controller.decode(input.trim());
}
/**
* Main game loop
*/
void game() {
updateViewportVariables();
//draw level background
renderLevel();
//update and display projectiles
updateProjectiles();
renderProjectiles();
//handle bombs
if (bomb != null) {
boolean shouldDelete = bomb.update();
renderBomb();
detectBombCollision();
if (shouldDelete) {
bomb = null;
}
}
//update and display enemies
updateEnemies();
renderEnemies();
//update and display player
updatePosition();
renderPlayer();
//draw HUD
drawHud();
//handle button input
buttons();
//detect collisions with enemies
detectEnemyCollision();
//detect enemy projectile collisions
detectEnemyProjectileCollision();
//detect player projectile collisions
detectPlayerProjectileCollisions();
//spawn new enemies
spawnEnemy(false);
//update difficulty
long currentTime = millis();
long secondsElapsed = (currentTime - startTime) / 1000;
difficulty = (int) secondsElapsed / conf.difficultyInterval;
checkForRewards();
}
void updateViewportVariables() {
//Calculate viewport bounds based on player position and viewport dimensions
startCol = player.getX() - (conf.viewportWidth / 2);
endCol = player.getX() + (conf.viewportWidth / 2);
startRow = player.getY() - (conf.viewportHeight / 2);
endRow = player.getY() + (conf.viewportHeight / 2);
}
/**
* Renders the level for the player's current viewport
* Based on example here: https://developer.mozilla.org/en-US/docs/Games/Techniques/Tilemaps/Square_tilemaps_implementation:_Scrolling_maps
*/
void renderLevel() {
//iterate through appropriate tiles
for (int col = startCol; col <= endCol; col++) {
for (int row = startRow; row <= endRow; row++) {
Tile tile = this.level.getTile(col, row);
PImage img = this.tileSet.get(tile.getId());
//Calculate co-orindates to draw tile at based on tile position and dimensions and account for any nessessary offset due to aspect ratio
int x = dimensions.widthOffset + (col - startCol) * dimensions.tileWidth;
int y = dimensions.heightOffset + (row - startRow) * dimensions.tileHeight;
//render tile at specified location and dimenision
image(img, x, y, dimensions.tileWidth, dimensions.tileHeight);
}
}
}
/**
* Update players position based on control input
*/
void updatePosition() {
//handle Y engines
if (controller.accelerationY() < -conf.thresholdX) {
player.fireMainEngine();
stopSoundEffect("reverse");
playSoundEffect("forwards");
}
else if (controller.accelerationY() > conf.thresholdX) {
player.fireReverseEngine();
stopSoundEffect("forwards");
playSoundEffect("reverse");
}
else {
stopSoundEffect("forwards");
stopSoundEffect("reverse");
player.shutdownYEngines();
}
//handle rotation
int headingDifference = controller.currentHeading() - controller.initialHeading();
if (Math.abs(headingDifference) > conf.headingThreshold) {
playSoundEffect("rotate");
if (headingDifference < 0) {
player.fireRightEngine();
}
else {
player.fireLeftEngine();
}
}
else {
stopSoundEffect("rotate");
player.shutdownXEngines();
}
float newX = player.getX() + (player.getMomentum() * sin(radians(player.getRotation())));
float newY = player.getY() + (player.getMomentum() * -cos(radians(player.getRotation())));
if (!Boolean.parseBoolean(level.getTile(Math.round(newX), Math.round(newY)).getProperty("solid"))) {
player.setPosition((int) newX, (int) newY);
}
}
/*
* Update player position and draw to screen
*/
void renderPlayer() {
pushMatrix();
int x = dimensions.widthOffset + dimensions.adjustedWidth / 2;
int y = dimensions.heightOffset + dimensions.adjustedHeight / 2;
translate(x, y);
rotate(radians(player.getRotation()));
imageMode(CENTER);
image(player.getSprite(), 0, 0, dimensions.tileWidth * player.getScaleFactor(), dimensions.tileHeight * player.getScaleFactor());
if(player.getSheild()) {
tint(255, 126);
image(spriteSet.get("player")[9], 0, 0, dimensions.tileWidth * player.getScaleFactor(), dimensions.tileHeight * player.getScaleFactor());
noTint();
}
popMatrix();
}
/**
* Draw HUD elements
*/
void drawHud() {
//lives
imageMode(CORNER);
for (int i = 0; i < lives; i++) {
int liveX = dimensions.startLivesX + (i * dimensions.tileWidth * 9);
image(spriteSet.get("player")[0], liveX, dimensions.livesY, dimensions.tileWidth * 7, dimensions.tileHeight * 7);
}
//score
textSize(dimensions.scoreSize);
textAlign(CENTER);
text(score, dimensions.scoreX, dimensions.scoreY);
//momentum
rectMode(CORNER);
stroke(255);
strokeWeight(1);
noFill();
rect(dimensions.nMomentumX, dimensions.nMomentumY, dimensions.nMomentumWidth, dimensions.nMomentumHeight);
rect(dimensions.pMomentumX, dimensions.pMomentumY, dimensions.pMomentumWidth, dimensions.pMomentumHeight);
if (player.getMomentum() < 0) {
fill(235, 28, 28);
rect(dimensions.nMomentumX, dimensions.nMomentumY, dimensions.nMomentumWidth, (dimensions.nMomentumHeight/conf.maxRearMomentum) * Math.abs(player.getMomentum()));
}
else if (player.getMomentum() > 0) {
fill(28, 235, 38);
pushMatrix();
translate(dimensions.pMomentumX + dimensions.pMomentumWidth, dimensions.pMomentumY + dimensions.pMomentumHeight);
rotate(radians(180));
rect(0, 0, dimensions.pMomentumWidth, (dimensions.pMomentumHeight/conf.maxForwardsMomentum) * player.getMomentum());
popMatrix();
}
//back to defaults
fill(255);
strokeWeight(4);
//bombs
imageMode(CORNER);
for (int i = 0; i < bombs; i++) {
int bombX = dimensions.startBombsX + (i * dimensions.tileWidth * 9);
image(spriteSet.get("bomb")[0], bombX, dimensions.bombsY, dimensions.tileWidth * 7, dimensions.tileHeight * 7);
}
}
/**
* Respond to button presses
*/
void buttons() {
if (controller.buttonC()) {
stopAllSoundEffects();
playSoundEffect("pause");
pause = true;
pauseTime = millis();
}
if (controller.buttonA()) {
shoot();
}
2 years ago
if (controller.buttonB()) {
bomb();
}
}
/**
* Shoots a projectile if possible
*/
void shoot() {
if (playerProjectiles.size() - 1 <= conf.maxPlayerProjectiles) {
long currentTime = millis();
if (currentTime - lastShot >= conf.reloadTime) {
playSoundEffect("shoot");
int x = player.getX();// - Math.round((player.getScaleFactor() / 2) * sin(radians(player.getRotation())));
int y = player.getY();// + Math.round((player.getScaleFactor() / 2) * -cos(radians(player.getRotation())));
playerProjectiles.add(new Projectile(x, y, player.getRotation(), spriteSet.get("player")[10], 10, 1, 260, 2));
lastShot = currentTime;
}
}
}
/**
* Triggers a bomb if possible
*/
void bomb() {
if ((bomb == null) && (bombs > 0) && (!player.getSheild())) {
playSoundEffect("bomb");
bomb = new Bomb(player.getX(), player.getY(), conf);
bombs--;
}
}
/**
* Selects and spawns a random enemy based on difficulty level
*/
void spawnEnemy(boolean debug) {
long currentTime = millis();
if (currentTime - spawnTime > conf.spawnInterval) {
spawnTime = currentTime;
//select random starting position outside of viewport
int col = int(random(0, level.getCols()));
int row = int(random(0, level.getRows()));
//ensure x is not inside viewport
while ((col >= startCol) && (col <= endCol)) {
col = int(random(0, level.getCols()));
}
//ensure y is not inside viewport
while ((row >= startRow) && (row <= endRow)) {
row = int(random(0, level.getRows()));
}
int r = int(random(0, 101));
String name = "";
if ((r < Boss.CHANCE_OF_SPAWNING) && (difficulty >= Boss.MINIMUM_DIFFICULTY)) {
enemies.add(new Boss(col, row, spriteSet.get("boss"), spriteSet.get("boss")[2], level, player));
name = "Boss";
}
else if ((r < Saucer.CHANCE_OF_SPAWNING) && (difficulty >= Saucer.MINIMUM_DIFFICULTY)) {
enemies.add(new Saucer(col, row, spriteSet.get("saucer")[0], spriteSet.get("saucer")[1], level, player));
name = "Saucer";
}
else if ((r < GunPlatform.CHANCE_OF_SPAWNING) && (difficulty >= GunPlatform.MINIMUM_DIFFICULTY)) {
enemies.add(new GunPlatform(col, row, spriteSet.get("gunPlatform")[0], spriteSet.get("gunPlatform")[1], player));
name = "GunPlatform";
}
else if ((r < Jellyfish.CHANCE_OF_SPAWNING) && (difficulty >= Jellyfish.MINIMUM_DIFFICULTY)) {
enemies.add(new Jellyfish(col, row, spriteSet.get("jellyfish"), level, player));
name = "Jellyfish";
}
else if ((r < Asteroid2.CHANCE_OF_SPAWNING) && (difficulty >= Asteroid2.MINIMUM_DIFFICULTY)) {
enemies.add(new Asteroid2(col, row, spriteSet.get("asteroid")[2], level));
name = "Asteroid2";
}
else if ((r < Asteroid1.CHANCE_OF_SPAWNING) && (difficulty >= Asteroid1.MINIMUM_DIFFICULTY)) {
enemies.add(new Asteroid1(col, row, spriteSet.get("asteroid")[1], level));
name = "Asteroid1";
}
else if ((r < Asteroid0.CHANCE_OF_SPAWNING) && (difficulty >= Asteroid0.MINIMUM_DIFFICULTY)) {
enemies.add(new Asteroid0(col, row, spriteSet.get("asteroid")[0], level));
name = "Asteroid0";
}
if (debug) {
print(name);
print(" spawned at: ");
print(col);
print(", ");
println(row);
}
}
}
/**
* update enemy positions
*/
void updateEnemies() {
for (Enemy enemy : enemies) {
enemy.update();
if (enemy.projectile() != null) {
enemyProjectiles.add(enemy.projectile());
}
}
}
/**
* render enemies within viewport
*/
void renderEnemies() {
for (Enemy enemy : enemies) {
int col = enemy.getX();
int row = enemy.getY();
//only render if inside viewport
if ((col >= startCol) && (col <= endCol) && (row >= startRow) && (row <= endRow)) {
//Calculate co-orindates to draw tile at based on tile position and dimensions and account for any nessessary offset due to aspect ratio
int x = dimensions.widthOffset + (col - startCol) * dimensions.tileWidth;
int y = dimensions.heightOffset + (row - startRow) * dimensions.tileHeight;
pushMatrix();
translate(x,y);
rotate(radians(enemy.getRotation()));
imageMode(CENTER);
tint(enemy.getTintR(), enemy.getTintG(), enemy.getTintB());
image(enemy.getSprite(), 0, 0, dimensions.tileWidth * enemy.getScaleFactor(), dimensions.tileHeight * enemy.getScaleFactor());
popMatrix();
noTint();//return to default
}
}
}
/**
* update projectile positions
*/
void updateProjectiles() {
List<List<Projectile>> projectileLists = new ArrayList<List<Projectile>>();
projectileLists.add(playerProjectiles);
projectileLists.add(enemyProjectiles);
for(List<Projectile> projectiles: projectileLists) {
Iterator<Projectile> it = projectiles.iterator();
while(it.hasNext()) {
Projectile projectile = it.next();
boolean shouldDelete = projectile.update();
if (shouldDelete) it.remove();
}
}
}
/**
* render projectiles within viewport
*/
void renderProjectiles() {
List<List<Projectile>> projectileLists = new ArrayList<List<Projectile>>();
projectileLists.add(playerProjectiles);
projectileLists.add(enemyProjectiles);
for (List<Projectile> projectiles: projectileLists) {
for (Projectile projectile : projectiles) {
int col = projectile.getX();
int row = projectile.getY();
//only render if inside viewport
if ((col >= startCol) && (col <= endCol) && (row >= startRow) && (row <= endRow)) {
//Calculate co-orindates to draw tile at based on tile position and dimensions and account for any nessessary offset due to aspect ratio
int x = dimensions.widthOffset + (col - startCol) * dimensions.tileWidth;
int y = dimensions.heightOffset + (row - startRow) * dimensions.tileHeight;
pushMatrix();
translate(x,y);
rotate(radians(projectile.getRotation()));
imageMode(CENTER);
image(projectile.getSprite(), 0, 0, dimensions.tileWidth * projectile.getScaleFactor(), dimensions.tileHeight * projectile.getScaleFactor());
popMatrix();
}
}
}
}
/**
* detect collisions between player projectiles and enemies
*/
void detectPlayerProjectileCollisions() {
List<Enemy> newEnemies = new ArrayList<Enemy>();
Iterator<Enemy> enemyIterator = enemies.iterator();
while(enemyIterator.hasNext()) {
Enemy enemy = enemyIterator.next();
Iterator<Projectile> projectileIterator = playerProjectiles.iterator();
while(projectileIterator.hasNext()) {
Projectile projectile = projectileIterator.next();
//https://silentmatt.com/rectangle-intersection/
int eX1 = enemy.getX() - (enemy.getScaleFactor() / 2);
int eY1 = enemy.getY() - (enemy.getScaleFactor() / 2);
int eX2 = enemy.getX() + (enemy.getScaleFactor() / 2);
int eY2 = enemy.getY() + (enemy.getScaleFactor() / 2);
int pX1 = projectile.getX() - (projectile.getScaleFactor() / 2);
int pY1 = projectile.getY() - (projectile.getScaleFactor() / 2);
int pX2 = projectile.getX() + (projectile.getScaleFactor() / 2);
int pY2 = projectile.getY() + (projectile.getScaleFactor() / 2);
if ((eX1 < pX2) && (eX2 > pX1) && (eY1 < pY2) && (eY2 > pY1)) {
for (int i = 0; i < projectile.getDamage(); i++) {
if(enemy.hit()) {
//DESTROYED!
//TODO:ANIMATION
playSoundEffect("explosion");
score += enemy.getScore();
List<Enemy> spawnlings = enemy.spawnlings();
if (spawnlings != null) newEnemies.addAll(spawnlings);
enemyIterator.remove();
break;
}
}
projectileIterator.remove();
}
}
}
enemies.addAll(newEnemies);
}
/**
* detect collisions between enemy projectiles and player
*/
void detectEnemyProjectileCollision() {
//player cannot be hit whilst sheild is up
if(!player.getSheild()) {
Iterator<Projectile> projectileIterator = enemyProjectiles.iterator();
while(projectileIterator.hasNext()) {
Projectile projectile = projectileIterator.next();
//https://silentmatt.com/rectangle-intersection/
int eX1 = projectile.getX() - (projectile.getScaleFactor() / 2);
int eY1 = projectile.getY() - (projectile.getScaleFactor() / 2);
int eX2 = projectile.getX() + (projectile.getScaleFactor() / 2);
int eY2 = projectile.getY() + (projectile.getScaleFactor() / 2);
int pX1 = player.getX() - (player.getScaleFactor() / 2);
int pY1 = player.getY() - (player.getScaleFactor() / 2);
int pX2 = player.getX() + (player.getScaleFactor() / 2);
int pY2 = player.getY() + (player.getScaleFactor() / 2);
if ((eX1 < pX2) && (eX2 > pX1) && (eY1 < pY2) && (eY2 > pY1)) {
//if ((eX == player.getX()) && (eY == player.getY())) {
death();
projectileIterator.remove();
}
}
}
}
/*
* detect collisions between the player and enemies
*/
void detectEnemyCollision() {
//player cannot die whilst sheild is up
if(!player.getSheild()) {
List<Enemy> newEnemies = new ArrayList<Enemy>();
Iterator<Enemy> enemyIterator = enemies.iterator();
while(enemyIterator.hasNext()) {
Enemy enemy = enemyIterator.next();
//https://silentmatt.com/rectangle-intersection/
int eX1 = enemy.getX() - (enemy.getScaleFactor() / 2);
int eY1 = enemy.getY() - (enemy.getScaleFactor() / 2);
int eX2 = enemy.getX() + (enemy.getScaleFactor() / 2);
int eY2 = enemy.getY() + (enemy.getScaleFactor() / 2);
int pX1 = player.getX() - (player.getScaleFactor() / 2);
int pY1 = player.getY() - (player.getScaleFactor() / 2);
int pX2 = player.getX() + (player.getScaleFactor() / 2);
int pY2 = player.getY() + (player.getScaleFactor() / 2);
if ((eX1 < pX2) && (eX2 > pX1) && (eY1 < pY2) && (eY2 > pY1)) {
if(enemy.hit()) {
List<Enemy> spawnlings = enemy.spawnlings();
if (spawnlings != null) newEnemies.addAll(spawnlings);
enemyIterator.remove();
}
death();
}
}
enemies.addAll(newEnemies);
}
}
/*
* Render bomb
*/
void renderBomb() {
int col = bomb.x;
int row = bomb.y;
int x = dimensions.widthOffset + (col - startCol) * dimensions.tileWidth;
int y = dimensions.heightOffset + (row - startRow) * dimensions.tileHeight;
noFill();
strokeWeight(16);
ellipseMode(CENTER);
float diameter = bomb.getDiameter() * dimensions.tileWidth;
ellipse(x, y, diameter, diameter);
strokeWeight(4);
fill(255);
}
/*
* Destory enemies hit by bomb
*/
void detectBombCollision() {
List<Enemy> newEnemies = new ArrayList<Enemy>();
Iterator<Enemy> enemyIterator = enemies.iterator();
while(enemyIterator.hasNext()) {
Enemy enemy = enemyIterator.next();
if (sqrt((float) Math.pow((enemy.getX() - bomb.x), 2) + (float) Math.pow((enemy.getY() - bomb.y), 2)) < bomb.getDiameter()/2) {
score += enemy.getScore();
List<Enemy> spawnlings = enemy.spawnlings();
if (spawnlings != null) newEnemies.addAll(spawnlings);
enemyIterator.remove();
}
}
enemies.addAll(newEnemies);
}
/*
* Called when the player dies
*/
void death() {
player.hit();
playerProjectiles = new ArrayList<Projectile>();
enemyProjectiles = new ArrayList<Projectile>();
lives--;
if (lives == 0) {
stopAllSoundEffects();
playSoundEffect("death");
gameOverTime = millis();
gameOver = true;
}
else {
playSoundEffect("shield");
}
}
void checkForRewards() {
if (score >= nextBomb) {
nextBomb += conf.extraBombInterval;
if (bombs < conf.initialBombs) {
bombs++;
}
}
if (score >= nextLife) {
nextLife += conf.extraLifeInterval;
lives++;
2 years ago
}
}
/**
* Pause screen
*/
void pause() {
renderLevel();
textSize(dimensions.adjustedWidth / 11);
textAlign(CENTER);
int x = dimensions.widthOffset + dimensions.adjustedWidth / 2;
int y = dimensions.heightOffset + dimensions.adjustedHeight / 2 - (dimensions.adjustedHeight / 23);
text(conf.pauseMsg1, x, y);
textSize(dimensions.adjustedWidth / 20);
y = dimensions.heightOffset + dimensions.adjustedHeight / 2 + (dimensions.adjustedHeight / 23);
text(conf.pauseMsg2, x, y);
showControls();
if (controller.buttonA()) {
playSoundEffect("resume");
2 years ago
controller.resetInitialHeading();
pause = false;
//adjust timers to account for time paused
long currentTime = millis();
startTime += (currentTime - pauseTime);
}
}
/**
* Display loading screen while resources load
*/
void loadingScreen() {
textSize(dimensions.adjustedWidth / 11);
textAlign(CENTER);
int x = dimensions.widthOffset + dimensions.adjustedWidth / 2;
int y = dimensions.heightOffset + dimensions.adjustedHeight / 2;
text(conf.loadingMsg, x, y);
}
/**
* Display loading screen while resources load
*/
void gameOver() {
textSize(dimensions.adjustedWidth / 11);
textAlign(CENTER);
int x = dimensions.widthOffset + dimensions.adjustedWidth / 2;
int y = dimensions.heightOffset + dimensions.adjustedHeight / 2 - (dimensions.adjustedHeight / 23);
text(conf.gameOverMsg, x, y);
textSize(dimensions.adjustedWidth / 20);
y = dimensions.heightOffset + dimensions.adjustedHeight / 2 + (dimensions.adjustedHeight / 23);
String scoreString = "Score: " + score;
text(scoreString, x, y);
textAlign(LEFT);
textSize(dimensions.adjustedWidth / 45);
x = dimensions.widthOffset + (dimensions.adjustedWidth / 72);
y = dimensions.heightOffset + dimensions.adjustedHeight / 2 + (dimensions.adjustedHeight / 8);
text(conf.credits, x, y);
long currentTime = millis();
if (currentTime - gameOverTime > 5000) {
titleScreen = true;
gameOver = false;
story = false;
pause = false;
score = 0;
lives = conf.initialLives;
bombs = conf.initialBombs;
difficulty = 0;
enemies = new ArrayList<Enemy>();
}
}
/**
* Show title Screen
*/
void titleScreen() {
storyCounter++;
renderLevel();
textSize(dimensions.adjustedWidth / 11);
textAlign(CENTER);
int x = dimensions.widthOffset + dimensions.adjustedWidth / 2;
int y = dimensions.heightOffset + dimensions.adjustedHeight / 2 - (dimensions.adjustedHeight / 23);
text(conf.title, x, y);
textSize(dimensions.adjustedWidth / 25);
y = dimensions.heightOffset + dimensions.adjustedHeight / 2 + (dimensions.adjustedHeight / 23);
text(conf.titleMsg1, x, y);
showControls();
textSize(dimensions.adjustedWidth / 50);
x = dimensions.widthOffset + dimensions.adjustedWidth - dimensions.adjustedWidth/15;
y = dimensions.heightOffset + dimensions.adjustedHeight - dimensions.adjustedHeight/45;
text(conf.copyright, x, y);
if (storyCounter >= conf.storyWaitTime * conf.framerate) {
titleScreen = false;
story = true;
}
if ((controller.buttonA()) && (controller.buttonB())) {
playSoundEffect("shield");
titleScreen = false;
storyCounter = 0;
controller.resetInitialHeading();
nextLife = conf.extraLifeInterval;
nextBomb = conf.extraBombInterval;
player = new Player(level.getStartX(), level.getStartY(), 0, spriteSet.get("player"));
startTime = millis();
lastShot = millis();
spawnTime = millis();
}
}
/*
* Show controls
*/
void showControls() {
textAlign(LEFT);
textSize(dimensions.adjustedWidth / 45);
int x = dimensions.widthOffset + (dimensions.adjustedWidth / 72);
int y = dimensions.heightOffset + dimensions.adjustedHeight / 2 + (dimensions.adjustedHeight / 8);
text(conf.controlsMsg, x, y);
}
/*
* count the number of lines in a string
* taken from: https://stackoverflow.com/a/18816371
*/
int countLines(String str) {
if(str == null || str.isEmpty())
{
return 0;
}
int lines = 1;
int pos = 0;
while ((pos = str.indexOf("\n", pos) + 1) != 0) {
lines++;
}
return lines;
}
/*
* Star wars style scrolling text
*/
void storyScroll() {