testklasse

.idea/Tetris.iml

@@ -7,14 +7,6 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="module-library" exported="">
+    <orderEntry type="library" exported="" name="sqlite-jdbc-3.36.0.3" level="project" />
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/Datenbank/sqlite-jdbc-3.36.0.3.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
   </component>
 </module>

.idea/aws.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="accountSettings">
+    <option name="activeRegion" value="us-east-1" />
+    <option name="recentlyUsedRegions">
+      <list>
+        <option value="us-east-1" />
+      </list>
+    </option>
+  </component>
+</project>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

.idea/libraries/sqlite_jdbc_3_36_0_3.xml

@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="sqlite-jdbc-3.36.0.3">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/sqlite-jdbc-3.36.0.3.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/runConfigurations.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="com.android.tools.idea.compose.preview.runconfiguration.ComposePreviewRunConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>

src/Tetris/Board.java

@@ -1,7 +1,6 @@
 package Tetris;
 
-import java.awt.Color;
+import java.awt.*;
-import java.awt.Graphics;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
@@ -11,157 +10,172 @@ import javax.swing.JPanel;
 import javax.swing.Timer;
 
 //Ewen Kerbs,Zhe Wang-Holkenbrink
-public class Board extends JPanel implements KeyListener
+public class Board extends JPanel implements KeyListener {
-{
+    private static int FPS = 60;
-  private  static int FPS =60;
+    private static int delay = FPS / 1000;
-  private  static int delay =FPS/1000;
 
-  //Spielfeld Breite und Länge
+    //Spielfeld Breite und Länge
-  public static final int BOARD_WIDTH=11;
+    public static final int BOARD_WIDTH = 11;
-  public static final int BOARD_HEIGHT=20;
+    public static final int BOARD_HEIGHT = 20;
-  public static final int BLOCK_SIZE=30;
+    public static final int BLOCK_SIZE = 30;
 
-  private Timer loop;
+    private Timer loop;
-  private Color[][] board = new Color[BOARD_HEIGHT][BOARD_WIDTH];
+    private Color[][] board = new Color[BOARD_HEIGHT][BOARD_WIDTH];
-  private Stein [] steine=new Stein[7];
+    private Stein[] steine = new Stein[7];
-  private Stein currenStein;
+    private Stein currenStein;
-  private Random ran;
+    private Random ran;
+    private boolean gameOver = false;
 
-  // Steinfarben
+    // Steinfarben
-  private Color[] colors ={Color.decode("#ff00bf"),Color.decode("#0000ff"),Color.decode("#00ff80"),Color.decode("#ff8000"),Color.decode("#ffb3b3"),
+    private Color[] colors = {Color.decode("#ff00bf"), Color.decode("#0000ff"), Color.decode("#00ff80"), Color.decode("#ff8000"), Color.decode("#ffb3b3"),
-        Color.decode("#8000ff"),Color.decode("#ff0040"),};
+            Color.decode("#8000ff"), Color.decode("#ff0040"),};
 
 
-// Steinform
+    // Steinform
-  public Board() {
+    public Board() {
-    ran = new Random();
+        ran = new Random();
-    steine[0]= new Stein(new int[][]{
+        steine[0] = new Stein(new int[][]{
-            {1,1,1},
+                {1, 1, 1},
-            {0,1,0},
+                {0, 1, 0},
 
-    }, this,colors[0]);
+        }, this, colors[0]);
-    steine[1]= new Stein(new int[][]{
+        steine[1] = new Stein(new int[][]{
-            {1,1},
+                {1, 1},
-            {1,1}
+                {1, 1}
 
-    }, this,colors[1]);
+        }, this, colors[1]);
-    steine[2]= new Stein(new int[][]{
+        steine[2] = new Stein(new int[][]{
-            {1,1,1},
+                {1, 1, 1},
-            {1,0,0}
+                {1, 0, 0}
-    }, this,colors[2]);
+        }, this, colors[2]);
-    steine[3]= new Stein(new int[][]{
+        steine[3] = new Stein(new int[][]{
-            {1,1,1},
+                {1, 1, 1},
-            {0,0,1}
+                {0, 0, 1}
-    }, this,colors[3]);
+        }, this, colors[3]);
-    steine[4]= new Stein(new int[][]{
+        steine[4] = new Stein(new int[][]{
-            {0,1,1},
+                {0, 1, 1},
-            {1,1,0}
+                {1, 1, 0}
-    }, this,colors[4]);
+        }, this, colors[4]);
-    steine[5]= new Stein(new int[][]{
+        steine[5] = new Stein(new int[][]{
-            {1,1,0},
+                {1, 1, 0},
-            {0,1,1}
+                {0, 1, 1}
-    }, this,colors[5]);
+        }, this, colors[5]);
-    steine[6]= new Stein(new int[][]{
+        steine[6] = new Stein(new int[][]{
-            {1,1,1,1}
+                {1, 1, 1, 1}
-    }, this,colors[6]);
+        }, this, colors[6]);
 
-    currenStein= steine[0];
+        currenStein = steine[0];
 
-    loop = new Timer(delay, new ActionListener() {
+        loop = new Timer(delay, new ActionListener() {
-      int n = 0;
+            int n = 0;
 
-      @Override
+            @Override
-      public void actionPerformed(ActionEvent e) {
+            public void actionPerformed(ActionEvent e) {
-        update();
+                update();
-        repaint();
+                repaint();
-        //System.out.println(n++);
+                //System.out.println(n++);
-      }
+            }
-    });
+        });
-    loop.start();
+        loop.start();
-  }
+    }
 
-  private void update(){
+    private void update() {
-    currenStein.update();
+        if (spielbeenden()) {
-  }
+            loop.stop();
-
+            return;
-
-  public void setCurrenStein() {
-    currenStein = steine[ran.nextInt(steine.length)];
-    currenStein.reset();
-  }
-
-  public Stein getCurrenStein() {
-    return currenStein;
-  }
-
-  public Color[][] getBoard(){
-    return board;
-  }
-
-  @Override
-  protected void paintComponent(Graphics g) {
-    super.paintComponent(g);
-    g.fillRect(0, 0, getWidth(), getHeight());
-    g.setColor(Color.lightGray);
-
-    currenStein.render(g);
-
-    for(int row=0;row< board.length;row++){
-      for(int col = 0;col< board[row].length;col++){
-        if(board[row][col] !=null){
-          g.setColor(board[row][col]);
-          //
-          g.fillRect(col*BLOCK_SIZE,row*BLOCK_SIZE,BLOCK_SIZE,BLOCK_SIZE);
         }
-      }
+        currenStein.update();
     }
 
-    //shape mit 2-Forschleife
+    private boolean spielbeenden() {
-
+        if (!gameOver) {
-
+            for (int i = 0; i < currenStein.getCoords().length; i++) {
-    for (int row = 0; row < BOARD_HEIGHT+1; row++) {
+                for (int j = 0; j < currenStein.getCoords()[0].length; j++) {
-      g.drawLine(0, BLOCK_SIZE * row, BLOCK_SIZE * BOARD_WIDTH, BLOCK_SIZE * row);
+                    if (currenStein.getCoords()[i][j] != 0) {
-    }
+                        if (board[currenStein.getY() + i][currenStein.getX() + j] != null) {
-    for (int col = 0; col < BOARD_WIDTH+1; col++) {
+                            gameOver = true;
-      g.drawLine(col * BLOCK_SIZE, 0, col * BLOCK_SIZE, BLOCK_SIZE * BOARD_HEIGHT);
+                        }
+                    }
+                }
+            }
+        }
+        return false;
     }
 
-  }
 
-  //Bewegen die Steine mit Taste, Taste-Space : nach unten, Taste d : nach rechts, Taste a : nach links, leider klappt nicht.
+    public void setCurrenStein() {
-  @Override
+        currenStein = steine[ran.nextInt(steine.length)];
-  public void keyTyped(KeyEvent e) {
+        currenStein.reset();
-//    switch(e.getKeyChar()) {
-//      case KeyEvent.VK_SPACE:
-//        currenStein.speedup();
-//        break;
-//      case KeyEvent.VK_A:
-//        currenStein.moveLeft();
-//        break;
-//      case KeyEvent.VK_D:
-//        currenStein.moveRight();
-//        break;
-//    }
-  }
-
-
-  //Bewegen die Steine mit Taste, Taste-Space : nach unten, Taste Enter : nach rechts, Taste Escape : nach links
-  @Override
-  public void keyPressed(KeyEvent e) {
-    if(e.getKeyChar() == KeyEvent.VK_SPACE){
-      currenStein.speedup();
-    }else if(e.getKeyChar() == KeyEvent.VK_ENTER){
-      currenStein.moveRight();
-    }
-    else if(e.getKeyChar() == KeyEvent.VK_ESCAPE){
-      currenStein.moveLeft();
-      }
     }
 
-  @Override
+    public Stein getCurrenStein() {
-  public void keyReleased(KeyEvent e) {
+        return currenStein;
-    if(e.getKeyChar() == KeyEvent.VK_SPACE){
+    }
-      currenStein.speedDown();
+
+    public Color[][] getBoard() {
+        return board;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        g.fillRect(0, 0, getWidth(), getHeight());
+        g.setColor(Color.lightGray);
+
+        currenStein.render(g);
+
+        for (int row = 0; row < board.length; row++) {
+            for (int col = 0; col < board[row].length; col++) {
+                if (board[row][col] != null) {
+                    g.setColor(board[row][col]);
+                    //
+                    g.fillRect(col * BLOCK_SIZE, row * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
+                }
+            }
+        }
+
+        //linien mit 2-Forschleife
+
+
+        for (int row = 0; row < BOARD_HEIGHT + 1; row++) {
+            g.drawLine(0, BLOCK_SIZE * row, BLOCK_SIZE * BOARD_WIDTH, BLOCK_SIZE * row);
+        }
+        for (int col = 0; col < BOARD_WIDTH + 1; col++) {
+            g.drawLine(col * BLOCK_SIZE, 0, col * BLOCK_SIZE, BLOCK_SIZE * BOARD_HEIGHT);}
+        if (gameOver) {
+            String gameOverString = "GAME OVER";
+            g.setColor(Color.GREEN);
+            g.setFont(new Font("SANS_SERIF", Font.BOLD, 30));
+            g.drawString(gameOverString, 50, GameGui.height / 2);
+        }
+    }
+
+
+    @Override
+    public void keyTyped(KeyEvent e) {
+
+    }
+
+    //Tastatur eingabe zur steinbewegung
+    //wang/kerbs
+    @Override
+    public void keyPressed(KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_SPACE) {
+            currenStein.speedup();
+        } else if (e.getKeyCode() == KeyEvent.VK_D) {
+            currenStein.moveRight();
+        } else if (e.getKeyCode() == KeyEvent.VK_A) {
+            currenStein.moveLeft();
+        } else if (e.getKeyCode() == KeyEvent.VK_W) {
+            currenStein.steinRotiert();
+        }
+
+    }
+
+    @Override
+    public void keyReleased(KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_SPACE) {
+            currenStein.speedDown();
+        }
     }
-  }
 }

src/Tetris/Stein.java

@@ -6,6 +6,8 @@ import java.io.FileNotFoundException;
 import java.util.Scanner;
 
 public class Stein {
+
+
     //SteineTyp Block;
    private int x = 4, y = 0;
     private int normal = 850;
@@ -56,6 +58,7 @@ public class Stein {
                     }
                 }
             }
+            linieLöschen();
             board.setCurrenStein();
             return;
         }
@@ -91,18 +94,35 @@ public class Stein {
                     }
                 }
             }
-            if (!collision) {
+                if (!collision) {
                 y++;
+                }
+            }
+            else {
+                collision = true;
             }
-
-        } else {
-            collision = true;
-        }
 
         beginTime = System.currentTimeMillis();
     }
 
 }
+
+public void linieLöschen(){
+        int bollomLine = board.getBoard().length - 1;
+        for(int topLine =  board.getBoard().length - 1; topLine > 0; topLine--){
+             int anZahl = 0;
+             for(int col = 0; col < board.getBoard()[0].length; col++){
+                 if(board.getBoard()[topLine][col] != null) {
+                     anZahl++;
+                 }
+                 board.getBoard()[bollomLine][col] = board.getBoard()[topLine][col];
+             }
+             if(anZahl < board.getBoard()[0].length){
+                 bollomLine--;
+             }
+        }
+}
+
 public void render(Graphics g){
     for(int row=0;row< coords.length;row++){
         for(int col = 0;col< coords[0].length;col++){
@@ -114,8 +134,64 @@ public void render(Graphics g){
         }
     }
 }
+/*Kerbs Ewen
+Hier wird der stein rotiert dazu wurden die hilfs methoden : datenarrayflippen, steineflippen implementiert
+diese helfen das komplexe steinrotiert verständlich zu machen.
+Beim datenarrayflippen wird einmal das neue array ausgerechnet wie es auszusehen hat.
+Da aber die bei dieser formatierung das array falsch herum aufgebaut wird benötigt man die hilfsmethode steineflippen
+Diese dreht dreht das array um sodas der stein richtig gezeigt werden kann
 
-public void speedup(){
+* */
+public void steinRotiert()
+{
+    int[][] rotierterstein = null;
+    rotierterstein = datenarrayflippen(coords);
+    rotierterstein = steineflippen(rotierterstein);
+    //grenzen ueberprufeung damit wird gewährleistet das der stein nicht aus dem array/koordiantensystem/spielbrett raus geht
+    if ((x + rotierterstein[0].length > 10) || (y + rotierterstein.length > 20)) {
+        return;
+    }
+    //ueberpruefung ob bereits ein stein im weg ist sollte dies sein kann der stein sich nicht drehen
+    for (int i = 0; i < rotierterstein.length; i++) {
+        for (int j = 0; j < rotierterstein[i].length; j++) {
+            if(rotierterstein[i][j] !=0)
+            {
+                if (board.getBoard()[y+i][x+j] !=null)
+                {
+                    return;
+                }
+            }
+        }
+
+    }
+    coords = rotierterstein;
+}
+
+    private int[][] datenarrayflippen(int[][] altesArray)
+    {
+        int[][] updatedArray = new int[altesArray[0].length][altesArray.length];
+        for (int i = 0; i < altesArray.length; i++) {
+            for (int j = 0; j < altesArray[0].length; j++) {
+                updatedArray[j][i] = altesArray[i][j];
+            }
+        }
+        return updatedArray;
+    }
+
+    private int[][] steineflippen(int[][] rotierenedesArray)
+    {
+        int mittelpunkt = rotierenedesArray.length / 2;
+        for (int i = 0; i < mittelpunkt; i++) {
+            int[] rotiertesArray = rotierenedesArray[i];
+            rotierenedesArray[i] = rotierenedesArray[rotierenedesArray.length - i - 1];
+            rotierenedesArray[rotierenedesArray.length - i - 1] = rotiertesArray;
+        }
+        return rotierenedesArray;
+    }
+
+
+
+    public void speedup(){
     delayTime=fast;
 }
 public void speedDown(){
@@ -127,4 +203,14 @@ public void moveRight(){
     public void moveLeft(){
         deltax = -1;
     }
+    public int[][] getCoords() {
+        return coords;
+    }
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
 }

src/Tetris/SteineTyp.java

@@ -1,11 +0,0 @@
-package Tetris;
-
-import java.util.concurrent.ThreadLocalRandom;
-
-public enum SteineTyp {
-    I,O,T,L,J,Z,S;
-    public static SteineTyp randomSteine()
-    {
-        return values()[ThreadLocalRandom.current().nextInt(0,values().length)];
-    }
-}

src/Tetris/Test.java

@@ -0,0 +1,8 @@
+package Tetris;
+
+public class Test {
+  //test klasse falls probleme mit der datenbank vorhanden sind
+  public static void main(String[] args) {
+      GameGui test = new GameGui("test");
+  }
+}