404 lines
9.8 KiB
Java
404 lines
9.8 KiB
Java
import javax.swing.*;
|
|
import java.awt.*;
|
|
import java.util.Random;
|
|
import java.util.ArrayList;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.KeyListener;
|
|
import java.util.Scanner;
|
|
import java.io.*;
|
|
import java.io.IOException;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Paths;
|
|
import java.util.List;
|
|
import java.util.Scanner;
|
|
|
|
public class rotation extends JFrame implements KeyListener {
|
|
|
|
private int feld[][] = // Feld... duh
|
|
|
|
{ { -1, -1, -1, -1, -1 }, // -1=wand, 0=leeres feld, 1-3=bloecke, -2=ausgang
|
|
{ -1, 0, 1, 1, -1 },
|
|
{ -1, 2, 0, 3, -1 },
|
|
{ -1, 2, 0, 3, -1 },
|
|
{ -1, -1, -2, -1, -1 } };
|
|
|
|
private int fl, ppX, len; // laengen und tmp ints
|
|
public boolean cheggin, moved, canMove;
|
|
Scanner scan;
|
|
public static String filename;
|
|
public String[] array, tmpArray;
|
|
public String[][] sArray;
|
|
|
|
ArrayList<Integer> mBlocks = new ArrayList<Integer>();
|
|
|
|
public static void main(String[] args) {
|
|
if (args.length != 0) {
|
|
filename = args[0];
|
|
}
|
|
new rotation();
|
|
|
|
}
|
|
|
|
@Override
|
|
public void keyTyped(KeyEvent e) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void keyPressed(KeyEvent e) {
|
|
System.out.println("Key: " + e.getKeyChar());
|
|
if (e.getKeyChar() == 'a') {
|
|
ld();
|
|
}
|
|
if (e.getKeyChar() == 'd') {
|
|
rd();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void keyReleased(KeyEvent e) {
|
|
|
|
}
|
|
|
|
public void readFile() {
|
|
try {
|
|
scan = new Scanner(new File(filename));
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public void createString() {
|
|
|
|
List<String> listOfStrings = new ArrayList<String>();
|
|
|
|
// load the data from file
|
|
try {
|
|
listOfStrings = Files.readAllLines(Paths.get(filename));
|
|
} catch (IOException e) {
|
|
|
|
}
|
|
// convert arraylist to array
|
|
array = listOfStrings.toArray(new String[0]);
|
|
for (int i = 0; i < array.length; i++) {
|
|
array[i] = array[i].replace(' ', 'a');
|
|
|
|
}
|
|
|
|
System.out.println(array[3]);
|
|
}
|
|
|
|
public void dimension() {
|
|
tmpArray = new String[array.length];
|
|
sArray = new String[array.length][array.length];
|
|
for (int i = 0; i < array.length; i++) {
|
|
scan = new Scanner(array[i]).useDelimiter("\\s*\\s*");
|
|
int j = 0;
|
|
while (scan.hasNext()) {
|
|
tmpArray[j] = scan.next();
|
|
// tmpArray[j] = tmpArray[j].replace("#","-1");
|
|
tmpArray[j] = tmpArray[j].replace("a", "99");
|
|
System.out.println(tmpArray[j]);
|
|
j++;
|
|
for (int k = 0; k < tmpArray.length; k++) {
|
|
System.out.println(tmpArray[k]);
|
|
}
|
|
}
|
|
sArray[i] = tmpArray;
|
|
}
|
|
System.out.println(sArray[0][0]);
|
|
System.out.println(sArray[4][4]);
|
|
|
|
for (int x = 0; x < sArray.length; x++) {
|
|
for (int y = 0; y < sArray.length; y++) {
|
|
if (sArray[y][x] == "#") {
|
|
sArray[y][x] = "-1";
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void fill() {
|
|
|
|
feld = new int[sArray.length][sArray.length];
|
|
for (int x = 0; x < sArray.length; x++) {
|
|
for (int y = 0; y < sArray.length; y++) {
|
|
feld[y][x] = Integer.parseInt(sArray[y][x]);
|
|
System.out.println(feld[y][x]);
|
|
|
|
if (feld[y][x] == 99) {
|
|
feld[y][x] = 0;
|
|
} else if (feld[y][x] >= 0) {
|
|
feld[y][x]++;
|
|
}
|
|
System.out.println(feld[y][x]);
|
|
|
|
}
|
|
}
|
|
|
|
printNew();
|
|
|
|
}
|
|
|
|
public void printNew() {
|
|
for (int x = 0; x < sArray.length; x++) {
|
|
for (int y = 0; y < sArray.length; y++) {
|
|
System.out.print(sArray[x][y] + " \t");
|
|
}
|
|
System.out.println();
|
|
}
|
|
|
|
}
|
|
|
|
public rotation() {
|
|
|
|
setSize(800, 800);
|
|
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
setLocationRelativeTo(null);
|
|
setVisible(true);
|
|
// anzeigenTxt();
|
|
setBackground(new Color(0, 0, 0));
|
|
addKeyListener(this);
|
|
if (filename != null) {
|
|
readFile();
|
|
createString();
|
|
dimension();
|
|
fill();
|
|
}
|
|
richten();
|
|
fl = feld.length;
|
|
}
|
|
|
|
public void rd() {
|
|
|
|
rotateClockwise();
|
|
checkFall();
|
|
|
|
}
|
|
|
|
public void ld() {
|
|
|
|
// TODO: BS
|
|
rotateClockwise();
|
|
rotateClockwise();
|
|
rotateClockwise();
|
|
checkFall();
|
|
|
|
}
|
|
|
|
public void richten() {
|
|
|
|
rotateClockwise();
|
|
fl = feld.length;
|
|
|
|
int[][] matrixNeu = new int[feld.length][feld.length];
|
|
for (int m = 0; m < 5; m++) {
|
|
for (int l = 0; l < 5; l++) {
|
|
matrixNeu[m][l] = feld[fl - 1 - m][l];
|
|
}
|
|
}
|
|
feld = matrixNeu;
|
|
repaint();
|
|
}
|
|
|
|
public void checkFall() {
|
|
|
|
moved = false;
|
|
|
|
mBlocks.clear();
|
|
for (int y = 0; y < fl; y++) {
|
|
for (int x = 0; x < fl; x++) {
|
|
if (feld[x][y] > 0 && movedBlocks(x, y) == false) {
|
|
mBlocks.add(feld[x][y]);
|
|
fall(x, y, feld[x][y]);
|
|
repaint();
|
|
// System.out.println("yeet");
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public boolean movedBlocks(int px, int py) {
|
|
// DONE check array-list, ob zahl schon abgefragt wurde
|
|
if (mBlocks.contains(feld[px][py])) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void fall(int pX, int pY, int block) {
|
|
if (horizontal(pX, pY, block) == true) {
|
|
fallH(pX, pY, block);
|
|
} else {
|
|
fallV(pX, pY, block);
|
|
}
|
|
}
|
|
|
|
public boolean horizontal(int pX, int pY, int block) {
|
|
if (feld[pX + 1][pY] == block) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void fallH(int pX, int pY, int block) {
|
|
ppX = pX;
|
|
len = 0;
|
|
|
|
while (feld[ppX][pY] == block) {
|
|
// System.out.println("ppX"+ppX+"py"+pY+"block"+block);
|
|
len++;
|
|
ppX++;
|
|
}
|
|
|
|
canMove = true;
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
if (feld[pX + i][pY + 1] != 0) {
|
|
canMove = false;
|
|
}
|
|
}
|
|
|
|
if (canMove == true) {
|
|
for (int i = 0; i < len; i++) {
|
|
feld[pX + i][pY + 1] = block;
|
|
feld[pX + i][pY] = 0;
|
|
wait(100);
|
|
repaint();
|
|
}
|
|
checkFall();
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
public void fallV(int pX, int pY, int block) {
|
|
cheggin = true;
|
|
int i = 0;
|
|
int ppY = pY;
|
|
|
|
while (cheggin == true) {
|
|
|
|
if (feld[pX][ppY] != block) {
|
|
cheggin = false;
|
|
} else {
|
|
ppY++;
|
|
}
|
|
}
|
|
// DONE siegesabfrage
|
|
// System.out.println("ppy:"+ppY+"px:"+pX);
|
|
|
|
if (feld[pX][ppY] == -2) {
|
|
delete(block);
|
|
}
|
|
|
|
if (feld[pX][ppY] == 0) {
|
|
for (int j = ppY; j > pY; j--) {
|
|
feld[pX][j] = feld[pX][j - 1];
|
|
feld[pX][j - 1] = 0;
|
|
wait(100);
|
|
repaint();
|
|
}
|
|
|
|
checkFall();
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
public void delete(int input) {
|
|
|
|
int[][] matrixNeu = new int[feld.length][feld.length];
|
|
matrixNeu = feld;
|
|
for (int m = 0; m < fl; m++) {
|
|
for (int l = 0; l < fl; l++) {
|
|
if (matrixNeu[m][l] == input) {
|
|
matrixNeu[m][l] = 0;
|
|
wait(50);
|
|
}
|
|
}
|
|
}
|
|
feld = matrixNeu;
|
|
repaint();
|
|
}
|
|
|
|
public void paint(Graphics g) {
|
|
feldAnzeigen(g);
|
|
}
|
|
|
|
public void neuzeichnen() {
|
|
repaint();
|
|
}
|
|
|
|
public void anzeigen(Graphics g) {
|
|
feldAnzeigen(g);
|
|
}
|
|
|
|
public void feldAnzeigen(Graphics g) {
|
|
|
|
for (int j = 0; j < 5; j++) {
|
|
for (int i = 0; i < 5; i++) {
|
|
|
|
if (feld[j][i] == 0) {
|
|
g.setColor(new Color(255, 255, 255));
|
|
}
|
|
if (feld[j][i] == -1) {
|
|
g.setColor(new Color(100, 100, 100));
|
|
}
|
|
if (feld[j][i] == 1) {
|
|
g.setColor(new Color(255, 0, 0));
|
|
}
|
|
if (feld[j][i] == 2) {
|
|
g.setColor(new Color(0, 255, 0));
|
|
}
|
|
if (feld[j][i] == 3) {
|
|
g.setColor(new Color(0, 0, 255));
|
|
}
|
|
if (feld[j][i] == -2) {
|
|
g.setColor(new Color(255, 215, 0));
|
|
}
|
|
g.fillRect(100 + 42 * j, 100 + 42 * i, 40, 40);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void anzeigenTxt() {
|
|
|
|
for (int xpos = 0; xpos < feld.length; xpos++) {
|
|
|
|
for (int ypos = 0; ypos < feld[0].length; ypos++) {
|
|
System.out.println(feld[xpos][ypos] + " x:" + xpos + " y:" + ypos);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public void wait(int milliseconds) {
|
|
try {
|
|
Thread.sleep(milliseconds);
|
|
} catch (Exception e) {
|
|
// ignoring exception at the moment
|
|
}
|
|
}
|
|
|
|
void rotateClockwise() {
|
|
|
|
int[][] matrixNeu = new int[feld.length][feld.length];
|
|
for (int m = 0; m < 5; m++) {
|
|
for (int l = 0; l < 5; l++) {
|
|
matrixNeu[feld.length - 1 - m][l] = feld[l][m];
|
|
|
|
}
|
|
}
|
|
feld = matrixNeu;
|
|
repaint();
|
|
}
|
|
|
|
}
|