diff --git a/src/HighScore.txt b/src/HighScore.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2e66562e2705f8e5c5ddccceeecaab861194f30a
--- /dev/null
+++ b/src/HighScore.txt
@@ -0,0 +1 @@
+49
\ No newline at end of file
diff --git a/src/Images1/apple.png b/src/Images1/apple.png
new file mode 100644
index 0000000000000000000000000000000000000000..c3edbe2f59ba13ee04b59088d0c69a30e5724530
Binary files /dev/null and b/src/Images1/apple.png differ
diff --git a/src/Images1/blixt.png b/src/Images1/blixt.png
new file mode 100644
index 0000000000000000000000000000000000000000..4c5098efd02fe4ba34a86c653176ce31589b9905
Binary files /dev/null and b/src/Images1/blixt.png differ
diff --git a/src/Images1/dinosaur.png b/src/Images1/dinosaur.png
new file mode 100644
index 0000000000000000000000000000000000000000..c8ca237211f03535801067d4b638c1cb2babd6bb
Binary files /dev/null and b/src/Images1/dinosaur.png differ
diff --git a/src/Images1/fly.png b/src/Images1/fly.png
new file mode 100644
index 0000000000000000000000000000000000000000..d967e9553eb7379d5076ae3fc21cf1ca9d2e9bba
Binary files /dev/null and b/src/Images1/fly.png differ
diff --git a/src/Images1/heart.png b/src/Images1/heart.png
new file mode 100644
index 0000000000000000000000000000000000000000..417d80ac9510e8e089b02b121f6bf792f47766f4
Binary files /dev/null and b/src/Images1/heart.png differ
diff --git a/src/Images1/heart2.png b/src/Images1/heart2.png
new file mode 100644
index 0000000000000000000000000000000000000000..bbb43b56fa5e6965af0140aa0e96477597255539
Binary files /dev/null and b/src/Images1/heart2.png differ
diff --git a/src/Images1/lorry.png b/src/Images1/lorry.png
new file mode 100644
index 0000000000000000000000000000000000000000..d2eb7091670ee53a1a043b3b065905da3376da38
Binary files /dev/null and b/src/Images1/lorry.png differ
diff --git a/src/Images1/player2.png b/src/Images1/player2.png
new file mode 100644
index 0000000000000000000000000000000000000000..688812eaba4982520fa0e5a86e573f9ac64f57f9
Binary files /dev/null and b/src/Images1/player2.png differ
diff --git a/src/Images1/player2_sliding.png b/src/Images1/player2_sliding.png
new file mode 100644
index 0000000000000000000000000000000000000000..f87ac1d9abc8b7348ea582dbc05a762f9d26c34c
Binary files /dev/null and b/src/Images1/player2_sliding.png differ
diff --git a/src/Images1/player_sliding.png b/src/Images1/player_sliding.png
new file mode 100644
index 0000000000000000000000000000000000000000..57476f650e1d481d0c83eee28e6fbb8a315e73f0
Binary files /dev/null and b/src/Images1/player_sliding.png differ
diff --git a/src/Images1/runner.png b/src/Images1/runner.png
new file mode 100644
index 0000000000000000000000000000000000000000..04660d17d9d980bd6c8c4e7a7ecf5156ecbed4e1
Binary files /dev/null and b/src/Images1/runner.png differ
diff --git a/src/Images1/saucer.png b/src/Images1/saucer.png
new file mode 100644
index 0000000000000000000000000000000000000000..c806f57b8a3fb790348af4ffddb1460af59aef72
Binary files /dev/null and b/src/Images1/saucer.png differ
diff --git a/src/Images1/woman-running.png b/src/Images1/woman-running.png
new file mode 100644
index 0000000000000000000000000000000000000000..84cfab13a42b0d01201adb9af05da4888614fe99
Binary files /dev/null and b/src/Images1/woman-running.png differ
diff --git a/src/Images1/zap.png b/src/Images1/zap.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b3fae8eb2183d1b23fb0ebe3230a5caf16c0872
Binary files /dev/null and b/src/Images1/zap.png differ
diff --git a/src/constants/Constants.java b/src/constants/Constants.java
index e6bc02c2e422c5d48b51a0855aa51cbc0b05d30e..fb1a9138a056f47d089badd63643a6ef0f70abc0 100644
--- a/src/constants/Constants.java
+++ b/src/constants/Constants.java
@@ -1,5 +1,10 @@
package constants;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+import javafx.scene.image.Image;
+
public interface Constants {
/**
@@ -16,16 +21,31 @@ public interface Constants {
/*
* Define the size of the window
*/
- int SCREEN_WIDTH = 1000;
- int SCREEN_HEIGHT = 800;
+ final int screenWidth = 1000;
+ final int screenHeight = 500;
// Player
-
+ String slidingPlayerImg = "src/Images1/player_sliding.png";
+// String playerImg = "src/Images1/runner.png";
String playerImg = "src/Images1/player.png";
+ String slidingPlayerImg2 = "src/Images1/player2_sliding.png";
+// String playerImg2 = "src/Images1/woman-running.png";
+ String playerImg2 = "src/Images1/player2.png";
+ double playerWidth = 100;
+ double playerHeight = 100;
//colours
String Bluebackground = "-fx-background-color: #34495E;";
String Blackbackground = "-fx-background-color: #111111;";
+ //enemies
+ String enemyImg = "src/Images1/lorry.png";
+ String flyingEnemyImg = "src/Images1/saucer.png";
+ double enemyWidth = 100;
+ double enemyHeight = 100;
+
+// powerups
+ String lifeImg = "src/Images1/heart2.png";
+ String powerImge = "src/Images1/blixt.png";
}
diff --git a/src/main/GameFrame.java b/src/main/GameFrame.java
index 1e7ca79117abb37e8dd9a410e53c5af47143e000..cd07d05fb3efd6106a6502c7f2d0e42d8793d92b 100644
--- a/src/main/GameFrame.java
+++ b/src/main/GameFrame.java
@@ -1,6 +1,7 @@
package main;
import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
import states.GameModel;
/**
diff --git a/src/main/Main.java b/src/main/Main.java
index 0f3858f6701f47ece322a00431ee75edda02d0e2..07ed30ea344cd456d3c4fe6d94c87442cc4a46d0 100644
--- a/src/main/Main.java
+++ b/src/main/Main.java
@@ -1,6 +1,7 @@
package main;
import states.GameModel;
+
import constants.Constants;
import javafx.animation.AnimationTimer;
@@ -9,7 +10,7 @@ import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.input.KeyEvent;
import javafx.stage.Stage;
-
+//FFfffffffff
/**
* This Class is the entry point of the application.
* <p>
@@ -32,6 +33,11 @@ import javafx.stage.Stage;
* @author magni54, alomi60
*/
public class Main extends Application {
+
+ private GameModel model;
+ private Scene gameScene;
+ private GameFrame frame;
+
public static void main(String[] args) {
launch(args);
@@ -39,13 +45,16 @@ public class Main extends Application {
@Override
public void start(Stage gameStage) throws Exception {
- gameStage.setTitle("TotallyAwesomeGame, sort of");
- gameStage.setWidth(Constants.SCREEN_WIDTH);
- gameStage.setHeight(Constants.SCREEN_HEIGHT);
+
+
+
+ gameStage.setWidth(Constants.screenWidth);
+ gameStage.setHeight(Constants.screenHeight);
GameModel model = new GameModel();
- GameFrame frame = new GameFrame(model, 1000, 800);
+// GameFrame frame = new GameFrame(model, 1000, 800);
+ GameFrame frame = new GameFrame(model, Constants.screenWidth, Constants.screenHeight);
+
Scene gameScene = new Scene(frame);
- // Set the target number of frames per second
final double targetFps = 50.0;
// Calculate frequency in nano seconds
final double nanoPerUpdate = 1000000000.0 / targetFps;
@@ -55,6 +64,7 @@ public class Main extends Application {
// We set up a setOnKeyPressed, to handle keyboard input,
// like we had a onMouseClick in the canvas for the paint lab.
gameScene.setOnKeyPressed(new EventHandler<KeyEvent>() {
+
@Override
public void handle(KeyEvent event) {
// We send it on to the model, to handle it in the various
@@ -62,6 +72,8 @@ public class Main extends Application {
model.keyPressed(event);
}
});
+
+
// We set an AnimationTimer, to control the flow of the game.
new AnimationTimer() {
@@ -86,4 +98,4 @@ public class Main extends Application {
gameStage.show();
}
-}
+}
\ No newline at end of file
diff --git a/src/states/Antagonist.java b/src/states/Antagonist.java
new file mode 100644
index 0000000000000000000000000000000000000000..f93d6a72764dd90a54f25c8f54b6240957410b7d
--- /dev/null
+++ b/src/states/Antagonist.java
@@ -0,0 +1,59 @@
+package states;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+import javafx.scene.image.Image;
+
+public abstract class Antagonist {
+
+ protected double x;
+ protected double y;
+ protected Image img;
+ protected boolean collisionDetected;
+
+
+ public Antagonist(String image, double x, double y) {
+ this.x = x;
+ this.y = y;
+ this.collisionDetected = false;
+
+ try {
+ this.img = new Image(new FileInputStream(image));
+
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ public Antagonist(String image) {
+ this.collisionDetected = false;
+
+ try {
+ this.img = new Image(new FileInputStream(image));
+
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ public abstract boolean playerAntagonistCollision(Player player);
+
+ public void setAntagonistX(double pos) {
+ this.x = pos;
+ }
+
+ public double getX() {
+ return x;
+ }
+
+ public abstract double getY();
+
+
+ public Image getImage() {
+ return img;
+ }
+
+}
diff --git a/src/states/Enemy.java b/src/states/Enemy.java
new file mode 100644
index 0000000000000000000000000000000000000000..40c763ca93e9115288ed2a54e445900b51db97d0
--- /dev/null
+++ b/src/states/Enemy.java
@@ -0,0 +1,61 @@
+package states;
+
+import java.io.FileInputStream;
+
+import java.io.FileNotFoundException;
+
+import constants.Constants;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+
+public class Enemy extends Antagonist{
+
+ private double enemyX = -100.00;
+ private double enemyY = 250.00;
+ private Image image;
+ private ImageView enemyView;
+
+ public Enemy(String enemyImg, double x, double y) {
+ super(enemyImg, x, y);
+
+ }
+
+ // if (collided && enemy.getEnemyX() < player.getPlayerX()) {
+ // collided = false;
+ // }
+
+ @Override
+ public boolean playerAntagonistCollision(Player player) {
+// boolean hit = false;
+
+ boolean collisionX = player.getPlayerX() < (x + 60.00) && (player.getPlayerX() + 60.00) > x;
+
+ // Check for collision on the y-axis
+ boolean collisionY = player.getPlayerY() < (y + 45.00) && (player.getPlayerY() + 60.00) > y;
+
+ if (collisionY && collisionX && !collisionDetected) {
+ player.decreaseLives();
+
+ collisionDetected = true;
+ return true;
+ }
+
+ if (!collisionX) {
+ collisionDetected = false;
+ }
+
+ return false;
+
+ }
+
+
+
+
+ @Override
+ public double getY() {
+ return y;
+ }
+
+
+
+}
diff --git a/src/states/ExtraLifePowerUp.java b/src/states/ExtraLifePowerUp.java
new file mode 100644
index 0000000000000000000000000000000000000000..01641cf31eea0d1689eed087d03b4f39c3229a2f
--- /dev/null
+++ b/src/states/ExtraLifePowerUp.java
@@ -0,0 +1,16 @@
+package states;
+
+public class ExtraLifePowerUp extends PowerUp {
+
+ ExtraLifePowerUp(String image) {
+ super(image);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ public void use(Player player) {
+ // TODO Auto-generated method stub
+
+ }
+
+}
diff --git a/src/states/FlyingEnemy.java b/src/states/FlyingEnemy.java
new file mode 100644
index 0000000000000000000000000000000000000000..1b456bcdb99359741cabd74332cc78e4a9b64b8e
--- /dev/null
+++ b/src/states/FlyingEnemy.java
@@ -0,0 +1,107 @@
+package states;
+
+import java.util.ArrayList;
+import constants.Constants;
+import java.util.Random;
+
+import javafx.scene.image.Image;
+
+public class FlyingEnemy extends Antagonist{
+
+// private double enemyX = 800.00;
+ private ArrayList<Double> enemyY;
+ private double currY;
+ private Random rnd = new Random();
+
+
+ public FlyingEnemy(String enemyImg, double x, double y) {
+ super(enemyImg, x, y);
+ this.enemyY = new ArrayList<Double>();
+ this.enemyY.add(150.0);
+ this.enemyY.add(180.0);
+ this.enemyY.add(200.0);
+ this.enemyY.add(250.0);
+ // enemyY.add(265.00);
+ // enemyY.add(265.00);
+ // enemyY.add(265.00);
+ // enemyY.add(265.00);
+
+
+ // double[] enemyY = {250, 200, 150,100};
+ // enemyY[0] = 100.0;
+ // enemyY[1] = 150.0;
+ // enemyY[2] = 200.0;
+ // enemyY[3] = 250.0;
+
+ }
+
+ // System.out.println(weather.get(rnd.nextInt(weather.size())));
+
+
+
+// public boolean playerFlyingEnemyCollision(Player player) {
+// boolean hit = false;
+//
+// if ((enemyX < (player.getPlayerX() + 80.00)) && ((enemyX) > player.getPlayerX())) { //borde vara +80 på enemyx men funkar ej
+// // if((player.getPlayerY() + 60.00) >= enemyY) {
+// if((player.getPlayerY() + 60.00) >= currY) {
+// // if ((enemyY + 80 > (player.getPlayerY())) && ((player.getPlayerY() + 80) > enemyY)) {
+//
+// hit = true;
+// player.decreaseLives();
+// // if (hit && enemyX < player.getPlayerX() + 100) {
+// // hit = false;
+// // }
+//
+// }
+//
+// }
+//
+// return hit;
+//
+// // public void setEnemyY() {
+// // enemyY = 0.0;
+// //
+// }
+
+ public FlyingEnemy(String enemyImg) {
+ super(enemyImg);
+ this.enemyY = new ArrayList<Double>();
+ this.enemyY.add(200.00); //går att stå under
+ this.enemyY.add(210.00); //behöver ducka
+ this.enemyY.add(220.00); //behöver ducka
+ this.enemyY.add(250.00); //behöver hoppa
+ }
+
+ @Override
+ public boolean playerAntagonistCollision(Player player) {
+
+ boolean collisionX = player.getPlayerX() < (x + 60.00) && (player.getPlayerX() + 60.00) > x;
+
+ // Check for collision on the y-axis
+ boolean collisionY = player.getRect() < (currY + 60.00) && (player.getRect() + 60.00) > currY;
+
+
+ if (collisionX && collisionY && !collisionDetected) {
+ player.decreaseLives();
+ collisionDetected = true;
+ return true;
+ }
+
+ if (!collisionX) {
+ collisionDetected = false;
+ }
+
+
+ return false;
+
+ }
+
+ @Override
+ public double getY() {
+
+ currY = enemyY.get(rnd.nextInt(enemyY.size()));
+ return currY;
+ }
+
+}
diff --git a/src/states/GameState.java b/src/states/GameState.java
index 862f928f4d05f2fb25b2e4236312328f81962ae5..cba0ddd627d4898fa1497189881797d744757f2b 100644
--- a/src/states/GameState.java
+++ b/src/states/GameState.java
@@ -1,11 +1,13 @@
package states;
import javafx.scene.canvas.GraphicsContext;
+
import javafx.scene.input.KeyEvent;
+import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
-import static constants.Constants.SCREEN_HEIGHT;
-import static constants.Constants.SCREEN_WIDTH;
+
+import constants.Constants;
/**
* This class represents a state of the game. These states are different views
@@ -63,7 +65,7 @@ public abstract class GameState {
public void drawBg(GraphicsContext g, Color color) {
// Here we can draw a background if we so desire.
g.setFill(color);
- g.fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+ g.fillRect(0, 0, Constants.screenWidth, Constants.screenHeight);
}
diff --git a/src/states/HighScore.java b/src/states/HighScore.java
new file mode 100644
index 0000000000000000000000000000000000000000..98931e969c4f6abb254898de27d6354bb9aa6c2c
--- /dev/null
+++ b/src/states/HighScore.java
@@ -0,0 +1,50 @@
+package states;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class HighScore {
+
+
+ public void saveScore(int score) {
+ if (score > getHighScore()) {
+ try {
+ FileWriter writer = new FileWriter("src/HighScore.txt");
+ writer.write("");
+ writer.write(Integer.toString(score));
+ writer.close();
+ } catch (IOException ioe) {
+ ioe.printStackTrace();
+ }
+ }
+
+ }
+
+ public int getHighScore() {
+ int highScore = 0;
+
+ try {
+ File highScoreTxtFile = new File("src/HighScore.txt");
+ Scanner myReader = new Scanner(highScoreTxtFile);
+ while (myReader.hasNextLine()) {
+ String data = myReader.nextLine();
+ highScore = Integer.parseInt(data);
+ }
+ myReader.close();
+ } catch (FileNotFoundException e) {
+ System.out.println("File not found.");
+ e.printStackTrace();
+ }
+
+ return highScore;
+ }
+
+}
diff --git a/src/states/MenuState.java b/src/states/MenuState.java
index 21de0d2c9c891e838b18a53b1d9cd077b97c1ab3..e32016fb176fc04943f4b6cf1ba1a8f875de2715 100644
--- a/src/states/MenuState.java
+++ b/src/states/MenuState.java
@@ -1,13 +1,19 @@
package states;
import javafx.scene.canvas.GraphicsContext;
+
+
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.image.Image;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
-import static constants.Constants.SCREEN_HEIGHT;
-import static constants.Constants.SCREEN_WIDTH;
+import constants.Constants;
/**
* This state represents the menu of the Game The main responsibility of this
@@ -24,13 +30,23 @@ public class MenuState extends GameState {
private Color fontColor;
// A PlayState, so we can change to the PlayState from the menu.
private PlayState playState;
+ private Image dinosaur;
+ private boolean mode1;
public MenuState(GameModel model) {
super(model);
- playState = new PlayState(model);
- informationText = "Press Enter To Play\nEscape to exit";
- bgColor = Color.GREEN;
- fontColor = Color.RED;
+ informationText = "Welcome to the Dino game!\nTo play, press 1 for mode 1 or 2 for mode 2\nEscape to exit game";
+ bgColor = Color.GREY;
+ fontColor = Color.LIGHTBLUE;
+
+ try {
+
+ dinosaur = new Image(new FileInputStream("src/Images1/dinosaur.png"));
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
}
/**
@@ -39,62 +55,52 @@ public class MenuState extends GameState {
@Override
public void draw(GraphicsContext g) {
drawBg(g, bgColor);
-
g.setFill(fontColor);
g.setFont(new Font(30)); // Big letters
// Print the information text, centered on the canvas
- g.fillText(informationText, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2);
- // Can also use:
- // g.setStroke(fontColor);
- // g.strokeText(informationText, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2);
+ g.fillText(informationText, Constants.screenWidth/4, Constants.screenHeight / 4);
+ g.drawImage(dinosaur, Constants.screenWidth/2, Constants.screenHeight/2, 200, 200);
+
}
- /**
- *
- * @param key KeyEvent representing the pressed key
- *
- * This function prints the pressed key to the console it's used to
- * show that a change of state has been made
- *
- * For more information see GameState
- */
+
@Override
public void keyPressed(KeyEvent key) {
System.out.println("Trycker på " + key.getText() + " i MenuState");
- if (key.getCode() == KeyCode.ENTER) {
+ if (key.getCode() == KeyCode.DIGIT1) {
+ mode1 = true;
+ playState = new PlayState(model, mode1);
+ model.switchState(playState);
+ } else if (key.getCode() == KeyCode.DIGIT2) {
+ mode1 = false;
+ playState = new PlayState(model, mode1);
model.switchState(playState);
} else if (key.getCode() == KeyCode.ESCAPE) {
System.exit(0);
}
+
}
- /**
- * We have nothing to update in the menu, no moving objects etc. so we leave the
- * update method empty.
- */
@Override
public void update() {
+ // TODO Auto-generated method stub
+
}
- /**
- * We currently don't have anything to activate in the MenuState so we leave
- * this method empty in this case.
- */
@Override
public void activate() {
-
+ // TODO Auto-generated method stub
+
}
- /**
- * We currently don't have anything to deactivate in the MenuState so we leave
- * this method empty in this case.
- */
-
@Override
public void deactivate() {
-
+ // TODO Auto-generated method stub
+
}
+
+
}
diff --git a/src/states/PlayState.java b/src/states/PlayState.java
index ce9fa94d3daa499d66e1dc1d131257be32b8b291..8f95c702c5697fd62e9234daee7c8f314e98383f 100644
--- a/src/states/PlayState.java
+++ b/src/states/PlayState.java
@@ -1,16 +1,20 @@
package states;
-import testing.Tester;
-
import javafx.scene.canvas.GraphicsContext;
+
+import javafx.scene.image.Image;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.paint.Color;
-import javafx.scene.shape.Line;
+import javafx.scene.shape.Rectangle;
import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.Random;
-import static constants.Constants.SCREEN_HEIGHT;
-import static constants.Constants.SCREEN_WIDTH;
+import constants.Constants;
/**
* This state represents the Playing State of the Game The main responsibility
@@ -35,20 +39,80 @@ public class PlayState extends GameState {
* a way to make this more general and not duplicate variables?
*/
private String informationText;
+ private String livesleft;
+ private String gameOverText;
private Color bgColor;
+ private Color lineColor;
private Color fontColor;
- private Line dottedline;
+ private Player player;
+ private Enemy enemy;
+ private boolean collided = false;
+ private boolean up = false;
+ private boolean down = false;
+ private boolean gameOver = false;
+ private MenuState menu;
+ private HighScore score = new HighScore();
+ private int clearedEnemies;
+ private String scoreText;
+ private ExtraLifePowerUp extraLife;
+ private FlyingEnemy flyingEnemy;
+ private double tempy;
+ private Random engen;
+ private String slidingPlayer;
+ private int movingSpeed = 10;
+
/* Class only used for testing */
- private Tester tester;
- public PlayState(GameModel model) {
+ // TODO nästa steg, lägg in en flygande enemy för att testa glid funktionen, ändra boundsen på den glidande bilden!
+ // TODO kanske ta bort att skicka med image när man instansierar player
+
+ public PlayState(GameModel model, boolean mode) {
super(model);
- informationText = "Press Escape To Return To The Menu";
- bgColor = Color.WHITE;
- fontColor = Color.BLUE;
+ informationText = "Press Escape \nTo Return To The Menu";
+ livesleft = "Lives left: ";
+ gameOverText = "GAMEOVER\n" + informationText;
+ fontColor = Color.BLACK;
+ scoreText = "Highscore: " + Integer.toString(score.getHighScore());
+ // + Integer.toString(score.getHighScore());
+
+
+ if (mode) {
+ mode1();
+ } else {
+ mode2();
+ }
+
+
+ // menu = new MenuState(model);
+
+ }
+
+ public void mode1() {
+ player = new Player(Constants.playerImg);
+ slidingPlayer = Constants.slidingPlayerImg;
+ enemy = new Enemy(Constants.enemyImg, 800.00, 250.00);
+ extraLife = new ExtraLifePowerUp(Constants.lifeImg);
+ flyingEnemy = new FlyingEnemy(Constants.flyingEnemyImg);
+ flyingEnemy.setAntagonistX(800.00);
+ tempy = flyingEnemy.getY();
+ bgColor = Color.ROYALBLUE;
+ lineColor = Color.WHITE;
+
+ }
+
+ public void mode2() {
+ player = new Player(Constants.playerImg2);
+ slidingPlayer = Constants.slidingPlayerImg2;
+ enemy = new Enemy(Constants.enemyImg, 800.00, 250.00);
+ extraLife = new ExtraLifePowerUp(Constants.lifeImg);
+ flyingEnemy = new FlyingEnemy(Constants.flyingEnemyImg);
+ flyingEnemy.setAntagonistX(800.00);
+ tempy = flyingEnemy.getY();
+ bgColor = Color.BEIGE;
+ lineColor = Color.BLACK;
+
- tester = new Tester();
}
/**
@@ -60,44 +124,191 @@ public class PlayState extends GameState {
g.setFill(fontColor);
g.setFont(new Font(30)); // Big letters
- g.fillText(informationText, SCREEN_WIDTH / 3, SCREEN_HEIGHT / 3);
-// dottedline = new Line(20, 200, 120, 270);
-// dottedline.getStrokeDashArray().addAll(2d);
- g.setStroke(Color.BLACK);
+ // ritar liv kvar + nuvarande highscore om det inte är gameover, annars ritar den bara gemaovertexten
+
+ if (!gameOver) {
+ g.fillText(livesleft+player.getLives(), 0, 30);
+ g.fillText(informationText, Constants.screenWidth - 300, 30);
+ g.fillText(scoreText, 0, 60);
+ } else {
+ g.fillText(gameOverText, Constants.screenWidth/2, 200);
+ score.saveScore(player.getPasses());
+ }
+
+
+
+ g.setStroke(lineColor);
g.setLineWidth(1);
g.setLineDashes(2);
- g.strokeLine(SCREEN_WIDTH, 650, 0, 650);
- // Can also use:
- // g.setStroke(fontColor);
- // g.strokeText(informationText, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2);
-
- // This could be a call to all our objects that we want to draw.
- // Using the tester simply to illustrate how it could work.
- tester.delegate(g);
+ g.strokeLine(Constants.screenWidth, 350, 0, 350);
+
+
+ g.drawImage(player.getImage(), player.getPlayerX(), player.getPlayerY(), Constants.playerWidth, Constants.playerHeight);
+
+
+
+// Detta block används för att rita ut rectanglarna runt spelare och enemy
+ g.setStroke(Color.BLACK); // Set the rectangle's border color
+ g.setLineWidth(2); // Set the border width
+ g.strokeRect(flyingEnemy.getX(), tempy, Constants.enemyWidth, Constants.enemyHeight);
+ g.strokeRect(player.getPlayerX(), player.getRect(), Constants.playerWidth, Constants.playerHeight);
+
+
+
+ drawEnemy(g);
+
+
+
+
}
+ public void drawEnemy(GraphicsContext g) {
+ engen = new Random();
+
+
+ // g.drawImage(enemy.getImage(), enemy.getX(), enemy.getY(), Constants.enemyWidth, Constants.enemyHeight);
+ // if (enemy.getX() < 0 - Constants.enemyWidth) {
+ // enemy.setAntagonistX(Constants.screenWidth);
+ // player.updatePasses(1);
+ // }
+
+
+
+
+ g.drawImage(flyingEnemy.getImage(), flyingEnemy.getX(), tempy, Constants.enemyWidth, Constants.enemyHeight);
+ if (flyingEnemy.getX() < 0 - Constants.enemyWidth) {
+ flyingEnemy.setAntagonistX(Constants.screenWidth);
+ player.updatePasses(1);
+ tempy = flyingEnemy.getY();
+
+ if (player.getPasses() % 5 == 0) {
+ movingSpeed += 4;
+ }
+
+ }
+
+ }
+
+
+
+
+
+ //TODO om score är större än visst antal --> lotta mellan flying och vanlig, vi kan göra en random med 2 int, ochberoende på vad den blir kan vi rita en
+ //TODO göra en variabel för y positionen som hämtas om vi ritar flygande, för att den ska behålla samma position på hela y axeln
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@Override
public void keyPressed(KeyEvent key) {
- System.out.println("Trycker på " + key.getCode() + " i PlayState");
- if (key.getCode() == KeyCode.ESCAPE)
+
+ switch (key.getCode()) {
+
+ case ESCAPE:
model.switchState(new MenuState(model));
+ break;
+
+ case UP:
+ // Om spelaren duckar kan den inte hoppa, då ställer sig spelaren upp istället
+ if (down) {
+ player.standUp();
+ down = false;
+ } else {
+ up = true;
+ }
+ break;
+
+ case DOWN:
+ // Spelaren kan inte ducka om den är mitt i ett hopp
+ if (!up) {
+ down = true;
+
+ }
+ break;
+
+ default:
+ break;
+
+ }
+
+
+
}
@Override
public void update() {
- // Here one would probably instead move the player and any
- // enemies / moving obstacles currently active.
- tester.update();
+ //om enemy position är mindre än player och collide är true kollar den inte collision
+
+ // Enemy hoppar 10 snäpp till vänster för varje update
+ // enemy.setAntagonistX(enemy.getX()-10);
+ flyingEnemy.setAntagonistX(flyingEnemy.getX()-movingSpeed);
+ // flyingEnemy.setAntagonistX(flyingEnemy.getX() -10);
+
+ // Om
+ if (!gameOver) {
+
+ if (!collided) {
+ // collided = enemy.playerAntagonistCollision(player);
+ collided = flyingEnemy.playerAntagonistCollision(player);
+
+
+ if (Integer.valueOf(player.getLives()) == 0) {
+ gameOver = true;
+ }
+ }
+
+ //återställer boolean när enemy passerat
+ if (collided && flyingEnemy.getX() < player.getPlayerX()) {
+ collided = false;
+ }
+
+
+
+
+
+ if (up) {
+
+ player.jump(movingSpeed);
+ }
+
+ if (player.getPlayerY() == 265) {
+ up = false;
+ }
+
+ if (down) {
+
+ player.slide(slidingPlayer);
+
+ }
+
+ }
+
}
+
+
+ // Here one would probably instead move the player and any
+ // enemies / moving obstacles currently active.
+
/**
* We currently don't have anything to activate in the PlayState so we leave
* this method empty in this case.
*/
@Override
public void activate() {
-
+
}
/**
@@ -106,7 +317,7 @@ public class PlayState extends GameState {
*/
@Override
public void deactivate() {
-
+
}
}
diff --git a/src/states/Player.java b/src/states/Player.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1dfab951a659b1f86416d8f2346d8cff1c3e9f7
--- /dev/null
+++ b/src/states/Player.java
@@ -0,0 +1,175 @@
+package states;
+
+import java.io.FileInputStream;
+
+
+import java.io.FileNotFoundException;
+
+import constants.Constants;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.shape.Rectangle;
+
+public class Player {
+
+// TODO se över funktioner, kanske lättare att slå samman vissa
+
+ private double playerX = (Constants.screenWidth - Constants.playerWidth) / 2;
+ private double playerY = 265.00;
+ private int score = 0;
+ private int lives = 3;
+ private Image image;
+ private boolean down = false;
+ private boolean up = false;
+ private Image slidingImage;
+ private Image currImage = null;
+ private int passes = 0;
+ private Rectangle bounds;
+ private double topPos = playerY;
+
+
+
+
+
+ public int getPasses() {
+ return passes;
+ }
+
+
+
+
+
+ public void updatePasses(int passes) {
+ this.passes += passes;
+ }
+
+
+
+
+
+ public Player(String playerImg) {
+
+ bounds = new Rectangle(playerX, topPos, Constants.playerWidth, Constants.playerHeight);
+
+ try {
+ image = new Image(new FileInputStream(playerImg));
+ //slidingImage = new Image(new FileInputStream(Constants.slidingPlayerImg));
+
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ currImage = image;
+
+ }
+
+
+ public double getRect() {
+ return topPos;
+ }
+
+
+ public Image getImage() {
+ return currImage;
+ }
+
+
+ public String getLives() {
+ return Integer.toString(this.lives);
+ }
+
+
+ public void decreaseLives() {
+
+
+ this.lives--;
+
+ }
+
+
+ public double getPlayerX() {
+ return playerX;
+ }
+
+
+ public double getPlayerY() {
+ return playerY;
+ }
+
+
+
+
+
+
+ public void jump(int movingSpeed) {
+
+
+ if (!down) {
+
+ playerY -= movingSpeed;
+ topPos -= movingSpeed;
+
+ if (playerY <= 110) {
+
+ down = true;
+
+ }
+
+ }
+
+ if (down) {
+
+ playerY += movingSpeed;
+ topPos += movingSpeed;
+
+ if (playerY == 265) {
+ down = false;
+ }
+
+ }
+
+ }
+
+
+ public void slide(String img) {
+ try {
+ slidingImage = new Image(new FileInputStream(img));
+ //slidingImage = new Image(new FileInputStream(Constants.slidingPlayerImg));
+
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+
+ currImage = slidingImage;
+ topPos = 305.00;
+
+
+ }
+
+
+ public void setPlayerX(double playerX) {
+ this.playerX = playerX;
+ }
+
+
+ public void setPlayerY(double playerY) {
+ this.playerY = playerY;
+ }
+
+
+ public void standUp() {
+ currImage = image;
+ topPos = playerY;
+
+ }
+
+
+
+
+
+}
diff --git a/src/states/PowerUp.java b/src/states/PowerUp.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b5901d4abe5a36e92ce17495ef92fc02af0938f
--- /dev/null
+++ b/src/states/PowerUp.java
@@ -0,0 +1,54 @@
+package states;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+import constants.Constants;
+import javafx.scene.image.Image;
+
+public abstract class PowerUp {
+
+ private double powerUpX = (Constants.screenWidth - Constants.playerWidth) / 2;
+ private double powerUpY = 265.00;
+ private Image powerUpImage;
+
+ PowerUp(String image) {
+
+ try {
+ powerUpImage = new Image(new FileInputStream(image));
+
+ } catch (FileNotFoundException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ public double getPowerUpX() {
+ return powerUpX;
+ }
+
+ public void setPowerUpX(double powerUpX) {
+ this.powerUpX = powerUpX;
+ }
+
+ public double getPowerUpY() {
+ return powerUpY;
+ }
+
+ public Image getImage() {
+ return powerUpImage;
+ }
+
+ public boolean powerUpPlayerCollision(Player player) {
+ boolean hit = false;
+
+// här ska det finnas kod för att kolla kollisioner mellan spelare och powerup
+
+ return hit;
+ }
+
+ public abstract void use(Player player);
+
+// här kommer de två olika powerupsen avgöra vad som händer när ma ta den, denna klass kallar på kollisionen
+
+}
diff --git a/src/testing/Tester.java b/src/testing/Tester.java
index 3edb6af3be807e432f41d0190f37a3ff48fa0cb5..9fe95fcad9e613cd5ae7e48f6dcad51394eef9f5 100644
--- a/src/testing/Tester.java
+++ b/src/testing/Tester.java
@@ -101,17 +101,17 @@ public class Tester {
private void draw(GraphicsContext g) {
// if (position.x >= SCREEN_WIDTH || position.y >= SCREEN_HEIGHT) {
- if (position.x <= 0 || position.y >= Constants.SCREEN_HEIGHT) {
+ if (position.x <= 0 || position.y >= Constants.screenHeight) {
// The position is exiting the screen, so we reset it
// position.x = 0.0;
- position.x = 900.0;
+ position.x = 1000.0;
// position.y = 0.0;
position.y = 600.0;
}
- drawRotatedImage(g, smile, angle, 500, 400);
+// drawRotatedImage(g, smile, angle, 500, 400);
g.drawImage(car, position.x, position.y, 100, 100);
- g.drawImage(player, Constants.SCREEN_WIDTH/2-50, 600, 100, 100);
+ g.drawImage(player, Constants.screenWidth/2-50, 600, 100, 100);
g.drawImage(banana, position.x, position.y, 100, 100);
}
}