first commit

Dino/src/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: /home/simon/Dokumente/JavaCode/_Library_/basisUTF8151112.jar
+Main-Class: github.stringBoy.Logic

Dino/src/github/stringBoy/Animation.java

@@ -0,0 +1,72 @@
+package github.stringBoy;
+
+import basis.SpriteBild;
+
+public class Animation implements Runnable {
+    Dino dino;
+    int i;
+    private SpriteBild spriteLinks;
+    private SpriteBild spriteRechts;
+    private SpriteBild spriteMitte;
+
+    public Animation(Dino dino) {
+        this.dino = dino;
+
+        spriteLinks = new SpriteBild("/home/simon/Dokumente/JavaCode/Dino/src/res/DinoLinks.png");
+        spriteLinks.setzeGroesse(spriteLinks.breite() / 2, spriteLinks.hoehe() / 2);
+        spriteLinks.spiegeleBild(false);
+
+        spriteMitte = new SpriteBild("/home/simon/Dokumente/JavaCode/Dino/src/res/Dino.png");
+        spriteMitte.setzeGroesse(spriteMitte.breite() / 2, spriteMitte.hoehe() / 2);
+        spriteMitte.spiegeleBild(false);
+
+        spriteRechts = new SpriteBild("/home/simon/Dokumente/JavaCode/Dino/src/res/DinoRechts.png");
+        spriteRechts.setzeGroesse(spriteRechts.breite() / 2, spriteRechts.hoehe() / 2);
+        spriteRechts.spiegeleBild(false);
+
+        i = 0;
+    }
+
+    public void placeDino(int x, int y) {
+        spriteLinks.setzePosition(x - spriteLinks.mittelpunkt().getX(), y - spriteLinks.mittelpunkt().getY() * 2);
+        spriteMitte.setzePosition(x - spriteMitte.mittelpunkt().getX(), y - spriteMitte.mittelpunkt().getY() * 2);
+        spriteRechts.setzePosition(x - spriteRechts.mittelpunkt().getX(), y - spriteRechts.mittelpunkt().getY() * 2);
+    }
+
+    public SpriteBild getSprite() {
+        return spriteLinks;
+    }
+
+    @Override
+    public void run() {
+        while (!Thread.currentThread().isInterrupted()) {
+            placeDino(dino.getX(), dino.getY());
+            if (!dino.isJumping) {
+                if (i == 0) {
+                    spriteLinks.setzeSichtbar(true);
+                    spriteMitte.setzeSichtbar(false);
+                    spriteRechts.setzeSichtbar(false);
+                    i = 1;
+                } else if (i == 1) {
+                    spriteLinks.setzeSichtbar(false);
+                    spriteMitte.setzeSichtbar(true);
+                    spriteRechts.setzeSichtbar(false);
+                    i = 2;
+                } else if (i == 2) {
+                    spriteLinks.setzeSichtbar(false);
+                    spriteMitte.setzeSichtbar(false);
+                    spriteRechts.setzeSichtbar(true);
+                    i = 0;
+                }
+                try {
+                    for (int i = 0; i < 10; i++) {
+                        Thread.sleep(10);
+                        placeDino(dino.getX(), dino.getY());
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }
+    }
+}

Dino/src/github/stringBoy/Background.java

@@ -0,0 +1,26 @@
+package github.stringBoy;
+
+import basis.*;
+
+public class Background {
+    private Stift pen;
+    private Frame frame;
+    private Bild sonne;
+    private int y;
+
+    public Background(Frame frame, int y) {
+        this.frame = frame;
+        pen = new Stift();
+        pen.setzeLinienBreite(5);
+        pen.setzeFuellMuster(1);
+        sonne = new Bild("/home/simon/Dokumente/JavaCode/Dino/src/res/Sonne.png");
+        sonne.setzeGroesse(sonne.breite() / 2.5, sonne.hoehe() / 2.5);
+        sonne.setzePosition(frame.width() - sonne.breite() - 50, 50);
+        this.y = y;
+    }
+
+    public void drawGround() {
+        pen.setzeFarbe(Farbe.rgb(235, 255, 86));
+        pen.rechteck(0, y, frame.width(), frame.height() - y);
+    }
+}

Dino/src/github/stringBoy/Cactus.java

@@ -0,0 +1,58 @@
+package github.stringBoy;
+
+import basis.*;
+
+public class Cactus extends Obstacle {
+    private SpriteBild obstacleSprite;
+    private Highscore highscore;
+
+    private int width, height;
+
+    public Cactus(int px, int py, Highscore highscore) {
+        super(px, py);
+        obstacleSprite = new SpriteBild("/home/simon/Dokumente/JavaCode/Dino/src/res/Cactus.png");
+
+        width = obstacleSprite.breite();
+        height = obstacleSprite.hoehe();
+
+        obstacleSprite.setzeGroesse(width / 5, height / 7);
+        this.highscore = highscore;
+
+        place();
+    }
+
+    public SpriteBild getSprite() {
+        return obstacleSprite;
+    }
+
+    @Override
+    public void move(int score) {
+        setX(((int) getX() - 5 - score / 50));
+        place();
+        if (getX() < 0) {
+            if (Hilfe.zufall(0,1) == 1){
+                obstacleSprite.setzeGroesse(width/5,height/10);
+            } else {
+                obstacleSprite.setzeGroesse(width/5,height/7);
+            }
+            setX(Hilfe.zufall(800 + highscore.getScore(), 1920));
+        }
+    }
+
+         @Override
+    public void place() {
+        obstacleSprite.setzePosition(getX() - obstacleSprite.mittelpunkt().getX(), getY() - obstacleSprite.mittelpunkt().getY() * 2);
+    }
+
+    @Override
+    public void run() {
+        while (!Thread.currentThread().isInterrupted()) {
+            move(highscore.getScore());
+            try {
+                Thread.sleep(5);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+}

Dino/src/github/stringBoy/CrashDetection.java

@@ -0,0 +1,43 @@
+package github.stringBoy;
+
+import basis.SpriteBild;
+
+public class CrashDetection implements Runnable {
+    private SpriteBild dinoSprite;
+    private SpriteBild obstacleSprite;
+
+    private Dino dino;
+    private Obstacle obstacle;
+
+    private boolean crashed;
+
+    public CrashDetection(SpriteBild dinoSp, SpriteBild obstacleSp, Dino dino, Obstacle obstacle) {
+        this.dinoSprite = dinoSp;
+        this.obstacleSprite = obstacleSp;
+
+        this.dino = dino;
+        this.obstacle = obstacle;
+
+        crashed = false;
+
+        obstacleSprite.setzeVereinfachteKollisionerkennung(false);
+    }
+
+    public void crashed() {
+        if (obstacleSprite.kollisionErkanntMit(dinoSprite)) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    public boolean isCrashed() {
+        return crashed;
+    }
+
+    @Override
+    public void run() {
+        while (!Thread.currentThread().isInterrupted()) {
+            crashed();
+        }
+        crashed = true;
+    }
+}

Dino/src/github/stringBoy/Dino.java

@@ -0,0 +1,68 @@
+package github.stringBoy;
+
+import basis.*;
+
+import java.awt.*;
+
+public class Dino implements Runnable {
+    public boolean isJumping;
+    private Point dino;
+
+    SpriteBild[] sprites;
+
+    private Tastatur keyboard;
+
+    public Dino(int x, int y) {
+        dino = new Point(x, y);
+
+        keyboard = new Tastatur();
+
+        isJumping = false;
+    }
+
+    public int getX() {
+        return (int) dino.getX();
+    }
+
+    public int getY() {
+        return (int) dino.getY();
+    }
+
+    public void setY(int y) {
+        dino.y = y;
+    }
+
+
+    public void jump() {
+        isJumping = true;
+        for (int i = 0; i < 9; i++) {
+            setY((int) dino.getY() - 20);
+            Hilfe.warte(12);
+        }
+        for (int i = 0; i < 5; i++) {
+            setY((int) dino.getY() - 4);
+            Hilfe.warte(15);
+        }
+        for (int i = 5; i > 0; i--) {
+            setY((int) dino.getY() + 4);
+            Hilfe.warte(15);
+        }
+        for (int i = 9; i > 0; i--) {
+            setY((int) dino.getY() + 20);
+            Hilfe.warte(12  );
+        }
+        isJumping = false;
+    }
+
+    @Override
+    public void run() {
+        int i = 0;
+        Hilfe.kurzePause();
+        while (!Thread.currentThread().isInterrupted()) {
+            Hilfe.kurzePause();
+            if (keyboard.istGedrueckt(' ')) {
+                jump();
+            }
+        }
+    }
+}

Dino/src/github/stringBoy/Frame.java

@@ -0,0 +1,87 @@
+package github.stringBoy;
+
+import basis.*;
+
+import java.awt.*;
+
+public class Frame {
+    public boolean isVisible;
+    private Fenster frame;
+    private Stift pen;
+    private Bild deadDino;
+
+    public Frame(boolean normalFrame) {
+        frame = new Fenster();
+        frame.setzeGroesse(Hilfe.monitorBreite(), Hilfe.monitorHoehe());
+        frame.setzeTitel("Dino Jump & Run");
+        frame.setzeHintergrundFarbe(Farbe.rgb(154, 210, 255));
+
+        if (!normalFrame){
+            deadDino = new Bild("Dino/src/res/DeadDino.png");
+            deadDino.setzeGroesse(deadDino.breite()*1.5,deadDino.hoehe()*1.5);
+            deadDino.spiegeleBild(false);
+            deadDino.setzePosition(frame.breite()/2-deadDino.breite()/2,frame.hoehe()/2-deadDino.hoehe()/2);
+        }
+
+        pen = new Stift(frame);
+    }
+
+    public Frame(Color customColor, boolean normalFrame) {
+        frame = new Fenster();
+        frame.setzeGroesse(Hilfe.monitorBreite(), Hilfe.monitorHoehe());
+        frame.setzeTitel("Dino Jump & Run");
+        frame.setzeHintergrundFarbe(customColor);
+
+        if (!normalFrame){
+            deadDino = new Bild("Dino/src/res/DeadDino.png");
+            deadDino.setzeGroesse(deadDino.breite()*1.5,deadDino.hoehe()*1.5);
+            deadDino.spiegeleBild(false);
+            deadDino.setzePosition(frame.breite()/2-deadDino.breite()/2,frame.hoehe()/2-deadDino.hoehe()/2);
+        }
+
+        pen = new Stift(frame);
+    }
+
+    public void visible(boolean isVisible) {
+        this.isVisible = isVisible;
+        if (isVisible == true) {
+            frame.setzeSichtbar(true);
+        } else {
+            frame.setzeSichtbar(false);
+        }
+    }
+
+    public void makeDinoInvis(boolean invis) {
+        if (invis) {
+            deadDino.setzeSichtbar(false);
+        }
+    }
+
+    public void writeText(String text, boolean centered, int size, Color color, int y){
+        pen.setzeFarbe(color);
+        if (centered){
+            pen.bewegeAuf(this.width()/2 - text.length()*size/4,this.height()/2-y);
+        } else {
+            pen.bewegeAuf(0,100);
+        }
+        pen.setzeSchriftGroesse(size);
+        pen.schreibeText(text);
+    }
+
+    public boolean isVisible() {
+        return isVisible;
+    }
+
+    public int width() {
+        return frame.breite();
+    }
+
+    public int height() {
+        return frame.hoehe();
+    }
+
+    public void delete() {
+        frame.gibFrei();
+    }
+
+}

Dino/src/github/stringBoy/Highscore.java

@@ -0,0 +1,58 @@
+package github.stringBoy;
+
+import basis.*;
+import reader.NumberReader;
+
+public class Highscore implements Runnable {
+    private TextFeld scoreFeld;
+    private TextFeld highscoreFeld;
+    private NumberReader reader;
+    private int score;
+    private int highscore;
+
+    public Highscore() {
+        scoreFeld = new TextFeld();
+        scoreFeld.setzeHintergrundFarbe(Farbe.rgb(154, 210, 255));
+        scoreFeld.setzeText("Score: " + String.format("%03d",score));
+        scoreFeld.setzeSchriftGroesse(35);
+        scoreFeld.setzeGroesse(230, 50);
+        scoreFeld.setzePosition(960 - scoreFeld.breite() / 2, 50);
+        scoreFeld.setzeSchriftStil(Schrift.FETT);
+        scoreFeld.entferneRand();
+
+        reader = new NumberReader("/home/simon/Dokumente/JavaCode/Dino/src/res/.highscore.txt");
+        highscore = reader.read();
+
+        highscoreFeld = new TextFeld();
+        highscoreFeld.setzeHintergrundFarbe(Farbe.rgb(154, 210, 255));
+        highscoreFeld.setzeText("Highscore: " + highscore);
+        highscoreFeld.setzeSchriftGroesse(15);
+        highscoreFeld.setzeGroesse(150, 30);
+        highscoreFeld.setzePosition(960 - highscoreFeld.breite() / 2, 100);
+        highscoreFeld.setzeSchriftStil(Schrift.FETT);
+        highscoreFeld.entferneRand();
+
+        score = 0;
+    }
+
+    public int getScore() {
+        return score;
+    }
+
+    public int getHighscore() {
+        return highscore;
+    }
+
+    @Override
+    public void run() {
+        while (!Thread.currentThread().isInterrupted()) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            ++score;
+            scoreFeld.setzeText("Score: " + String.format("%03d",score));
+        }
+    }
+}

Dino/src/github/stringBoy/Logic.java

@@ -0,0 +1,120 @@
+package github.stringBoy;
+
+import basis.*;
+import writer.Writer;
+
+import java.awt.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class Logic {
+    private Frame startFrame;
+    private Animation animation;
+    private Frame gameFrame;
+    private Dino dino;
+    private Background background;
+    private Obstacle cactus;
+    private Frame endFrame;
+    private CrashDetection crashDetection;
+    private Highscore highscore;
+    private Writer writer;
+    //Threads
+    private ExecutorService executor = Executors.newCachedThreadPool();
+
+    private Runnable[] runables;
+
+    private Tastatur keyboard;
+
+    boolean interrupted;
+
+    public Logic() {
+        startFrame = new Frame(Color.BLACK,true);
+        gameFrame = new Frame(true);
+        gameFrame.visible(false);
+        highscore = new Highscore();
+        dino = new Dino(200, gameFrame.height() - 200);
+        background = new Background(gameFrame, gameFrame.height() - 200);
+        cactus = new Cactus(1800, gameFrame.height() - 200, highscore);
+        animation = new Animation(dino);
+        crashDetection = new CrashDetection(animation.getSprite(), (SpriteBild) cactus.getSprite(), dino, cactus);
+        endFrame = new Frame(Color.RED,false);
+        endFrame.visible(false);
+
+        writer = new Writer("Dino/src/res/.highscore.txt");
+
+        keyboard = new Tastatur();
+        
+        runables = new Runnable[]{highscore, dino, crashDetection, cactus, animation};
+
+        interrupted = false;
+    }
+
+    /*TODO: Make a function that enables the player to play the game
+            multiple times without having to start a new game every Time.*/
+
+    public static void main(String[] args) {
+        Logic l;
+        l = new Logic();
+        l.runThis();
+    }
+
+    private void prepEndFrame(){
+        if (highscore.getScore() < highscore.getHighscore()) {
+            endFrame.writeText("YOU DIED!", true, 100, Farbe.WEISS, 400);
+            endFrame.writeText("Dein Score: " + highscore.getScore(), true, 75, Farbe.WEISS, -endFrame.height() / 2 + 150);
+            endFrame.writeText("Dein Highscore: " + highscore.getHighscore(), true, 25, Farbe.WEISS, -endFrame.height() / 2 + 100);
+        } else {
+            endFrame.writeText("YOU DIED!", true, 100, Farbe.WEISS, 400);
+        }
+    }
+
+    private void prepInterruptFrame(){
+            endFrame.writeText("INTERRUPTED", true, 100, Farbe.WEISS, 0);
+            endFrame.makeDinoInvis(true);
+    }
+
+    public void runThis() {
+        boolean stopped = false;
+        startFrame.writeText("Press ENTER to start the game!", true, 75, Farbe.WEISS, 0);
+        while (!stopped){
+            Hilfe.kurzePause();
+            if (keyboard.istGedrueckt(Zeichen.ENTER)){
+                startFrame.visible(false);
+                gameFrame.visible(true);
+                stopped = true;
+            }
+        }
+        background.drawGround();
+        for (Runnable r : runables) {
+            executor.execute(r);
+        }
+        new  Sound();
+        while (!executor.isShutdown()) {
+            if (keyboard.istGedrueckt(Zeichen.ESC)) {
+                executor.shutdown();
+                executor.shutdownNow();
+                interrupted = true;
+            } else if (crashDetection.isCrashed()) {
+                executor.shutdown();
+                executor.shutdownNow();
+            }
+        }
+        if (highscore.getHighscore() < highscore.getScore()) {
+            writer.write("" + highscore.getScore(), false);
+            System.out.println("NEW HIGHSCORE!");
+        }
+        if (!interrupted) {
+            endFrame.visible(true);
+            gameFrame.visible(false);
+            prepEndFrame();
+            Hilfe.warte(2000);
+            System.exit(0);
+        } else {
+            endFrame.visible(true);
+            gameFrame.visible(false);
+            prepInterruptFrame();
+            Hilfe.warte(2000);
+            System.exit(0);
+        }
+    }
+}

Dino/src/github/stringBoy/Obstacle.java

@@ -0,0 +1,38 @@
+package github.stringBoy;
+
+import basis.Bild;
+
+import java.awt.*;
+
+public abstract class Obstacle implements Runnable {
+    private Point obstacle;
+
+    public Obstacle(int x, int y) {
+        obstacle = new Point(x, y);
+    }
+
+    abstract public void move(int score);
+
+    abstract public void place();
+
+    abstract public void run();
+
+    abstract Bild getSprite();
+
+    public double getX() {
+        return obstacle.getX();
+    }
+
+    public void setX(int x) {
+        obstacle.x = x;
+    }
+
+    public double getY() {
+        return obstacle.getY();
+    }
+
+    public void setY(int y) {
+        obstacle.y = y;
+    }
+}
+

Dino/src/github/stringBoy/Sound.java

@@ -0,0 +1,9 @@
+package github.stringBoy;
+import javax.sound.sampled.*;
+public class Sound {
+    Clip clip;
+    public Sound(){
+
+    }
+
+}

Dino/src/res/.highscore.txt

@@ -0,0 +1 @@
+591