# Hilfe bei Spielumsetzung



## Spieler (13. Apr 2014)

Ich habe eine Spielidee.

Man hat ein Fenster das in zwei Teile geteilt wird.
Auf der linken Seite ein Spielfeld aus Qudraten (ein Raster).
Auf der rechten Seite Sollen 8 verschiedene  Tetrissteini bis zur größe aus 6 Quadraten  zufällig angezeigt werden , und das zweimal.
Einmal die 8 Steine die man selbst zur verfügung hat und dann noch die 8 die dem Gegner gehören 
Diese werden dann von einem Startpunkt aus , der unten/oben in der Mitte liegt , per drag&drop auf das Spielfeld gelegt und im nachhinein noch per z.B. Pfeiltasten verschiebbar  und drehbar sein und dann durch das drücken von enter eingerastet werden.
Hierbei müssen die Spielsteine aber immer miteinander verbunden sein.

Ziel des Spiels ist es mit den Tetrissteinen und dem Spielfeldrand  eine größtmögliche  Fläche , die in Quadraten gezählt wird ,zu umschließen . 
Das Spiel ist zu Ende , wenn kein Spielzug mehr von beiden Seiten möglich ist oder beide Spieler passen.
Es wird abwechselnd gespielt und nach 6 halbzügen sollen die Steine erneut zufällig gewählt werden .

Der Computergegner soll per Minimax Algorithmus oder Alpha Beta Pruning funktionieren.
Die Heuristik soll so funktionieren , dass der Computer die Kästchen rechts und links vom Spielstein zählt .
Danach soll er dann durch den Minimax Algorithmus oder Alpha Beta Pruning den Besten zug auswählen ,mit einer Rechentiefe von 4.
Passen tut der Computergegner immer dann wenn er seine eigene Fläche nicht mehr vergrößern bzw. die gegnerische nicht verkleinern kann.



Jetzt zur eigentlichen Frage:

Kann mir jemand einen Rohcode für das Spiel geben ?

oder was mir eigentlich lieber wäre

Einen Beispielcode oder ein gutes Tutorial für:
1 Spielfelder
2 Tetrisobjekte erstellen und bewegbar machen
3 Drag & Drop von in 2 genannten Tetrissteinen
4  eingeschlossene Kästchen  zählen lassen 
5 Umsetzung von Heuristik und Minimax Algorithmus oder Alpha Beta Pruning
geben.

Ich weiß das ist eine ganze Menge auf einmal aber ich hoffe auf eine gute Antwort.


----------



## JCODA (13. Apr 2014)

Für welches Semester soll das sein? 
und wie viel bist du bereit auszugeben ? 

ansonsten wie immer: Quaxli's Spiele-Tutorial


----------



## Spieler (13. Apr 2014)

Erst mal danke für die schnelle Antwort.
Zum einen bin ich in keinem Semester.
Zum anderen hab ich nicht vor dafür zu bezahlen.

zum Tutuorial:
es ist zwar ganz nett , bringen tut es mir aber praktisch nichts

deswegen wäre es nett wenn mir jemand etwas genauere oder besser passende  Tutorials geben könnte.


----------



## DefconDev (13. Apr 2014)

Ich versteh deine Frage bezüglich des Roh-Codes nicht? Für was möchtest du den Roh Code, für dein ganzes Konzept?

Generell bräuchtest du Erfahrung in der GUI Programmierung mit Swing. Ist das überhaupt vorhanden? Sonst wäre da Spiel schon ein größeres Projekt für dich mit etwas viel einarbeitunsgzeit. Ohne jetzt die Algos zu berücksichtigen wie der Minimax, kenne den selber jetzt nicht.


----------



## Androbin (14. Apr 2014)

@"Spieler": :bloed:
Ich habe dir hier schon 'mal ein bisschen was zusammengeschrieben: 
1. Mach' dir einen 2-dimensionalen Array (für 4.). :bahnhof:
2. Mach' dir eine abstrakte Klasse "Tetrisstein" und eine HashMap. 
3. Da kann ich dir leider (noch) nicht helfen. :rtfm:
4. Frag' mit einer doppelten for-Schleife ab, ob alle umliegenden Felder besetzt sind. opcorn:
5. Mach es doch so, wie du es oben bereits beschrieben hast. :idea:
Ich hoffe, das hilft dir für's Erste! :toll:


----------



## Androbin (14. Apr 2014)

Weist du was? Ich glaube ich mache selber ein Tetris-Game (vorerst ohne Drag'n'Drop und einen CPU-Gegner)!
Wenn es fertig ist stelle ich es hier rein!


----------



## Androbin (14. Apr 2014)

Ich bin beinahe fertig, allerdings noch nicht ganz, was die Kollision betrifft! Hier der Code:

MainFrame:


Spoiler





```
package net.diegamingbrueder.games.Tetris;

import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class MainFrame extends JFrame implements ActionListener {
	
	// Deklarationen
	
    private static final long serialVersionUID = 1L;
    
	private static JFrame frame;
	private JButton BPlay, BCredits, BExit;
	
	// Konstruktoren
	
    public MainFrame() {
		
		// Frame erzeugen
		
		super( "HeartBleed" );
		setSize( 200, 200 );
		setResizable( false );
		setLocationRelativeTo( null );
		setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		setIconImage( Toolkit.getDefaultToolkit().getImage( "res/Tetris/icon.png" ) );
		
		// Elemente hinzufügen
		
		setLayout( null );
		
		BPlay = new JButton( "Spiel starten" );
		BCredits = new JButton( "Credits" );
		BExit = new JButton( "Beenden" );
		
		BPlay.addActionListener( this );
		BCredits.addActionListener( this );
		BExit.addActionListener( this );
		
		BPlay.setBounds( 20, 20, 150, 30 );
		BCredits.setBounds( 20, 70, 150, 30 );
		BExit.setBounds( 20, 120, 150, 30 );
		
		add( BPlay );
		add( BCredits );
		add( BExit );
		
		setVisible( true );
		
	}
	
	// Methoden
	
	public static void main( String[] args ) { frame = new MainFrame(); }
	
	public void actionPerformed( ActionEvent e ) {
		
		if ( e.getSource().equals( BPlay ) ) { new GameFrame(); 
		
		}
		else if ( e.getSource().equals( BCredits ) ) { new Credits(); }
		else if ( e.getSource().equals( BExit ) ) { frame.dispose(); }
		
	}
	
}
```



GameFrame:


Spoiler





```
package net.diegamingbrueder.games.Tetris;

import java.awt.Color;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class GameFrame extends JFrame implements KeyListener {
	
	// Deklarationen
	
    private static final long serialVersionUID = 1L;
	
    private Game game;
    private static final int width = 519, height = 541;
    
    // Konstruktoren
    
    public GameFrame() {
		
		// Frame vorbereiten
			
			super( "Tetris -  Build 1.0.0" );
			setSize( width, height );
			setResizable( false );
			setLocationRelativeTo( null );
			setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
			addKeyListener( this );
			setIconImage( Toolkit.getDefaultToolkit().getImage( "res/Tetris/icon.png" ) );
			setBackground( Color.BLACK );
			
			try { setCursor( Toolkit.getDefaultToolkit().createCustomCursor(
			ImageIO.read( new File( "res/Tetris/cursor.png" ) ), new Point( 0, 0 ), "Tetris") ); }
			catch ( IOException e ) { e.printStackTrace(); }
			
			setLayout( null );
			
			game = new Game();
			game.setBounds( 0, 0, getWidth(), getHeight() );
			add( game );
			
			setVisible( true );
		
	}
    
	@ Override
    public void keyPressed( KeyEvent e ) { game.keyPressed( e ); }
	
	@ Override
    public void keyReleased( KeyEvent e ) { game.keyReleased( e ); }
	
	@ Override
    public void keyTyped( KeyEvent e ) { }
    
}
```



Game:


Spoiler





```
package net.diegamingbrueder.games.Tetris;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JPanel;

public class Game extends JPanel implements KeyListener, Runnable {
	
	// Deklarationen
	
    private static final long serialVersionUID = 1L;
	
    private static boolean[][] Fields = new boolean[ 16 ][ 16 ];
    private Stein stein;
    
    private boolean isRunning;
    
    private static final int size = 32;
    
    // Konstruktoren
    
    public Game() {
		
		// Frame vorbereiten
			
			setName( "Tetris" );
			addKeyListener( this );
			setBackground( Color.BLACK );
			
			try { setCursor( Toolkit.getDefaultToolkit().createCustomCursor(
			ImageIO.read( new File( "res/Tetris/cursor.png" ) ), new Point( 0, 0 ), "Tetris") ); }
			catch ( IOException e ) { e.printStackTrace(); }
		
		isRunning = true;
		stein = new Stein();
		
		setVisible( true );
		
		new Thread( this ).start();
		
	}
    
    public static boolean[][] getFields() { return Fields; }
    
    @Override
    public void paintComponent( Graphics g ) {
    	
    	super.paintComponent( g );
    	
    	g.setColor( Color.WHITE );
    	
    	for ( int x = 0; x < Fields.length; x++ ) {
    		
    		for ( int y = 0; y < Fields[ 0 ].length; y++ ) {
    			
    			g.drawRect( x * size, y * size, size, size );
    			
    		}
    		
    	}
    	
    	for ( int x = 0; x < Fields.length; x++ ) {
    		
    		for ( int y = 0; y < Fields[ 0 ].length; y++ ) {
    			
    			if ( Fields[ x ][ y ] == true ) {
    				
    				g.fillRect( x * size, y * size, size, size );
    				
    			}
    			
    		}
    		
    	}
    	
    	for ( int x = 0; x < Stein.getFields().length; x++ ) {
    		
    		for ( int y = 0; y < Stein.getFields()[ 0 ].length; y++ ) {
    			
    			if ( Stein.getFields()[ x ][ y ] == true ) {
    				
    				g.fillRect( ( x + Stein.getPoint().x ) * size, ( y + Stein.getPoint().y ) * size, size, size );
    				
    			}
    			
    		}
    		
    	}
    	
    	if ( !isRunning ) {
    		
    		g.setColor( Color.BLACK );
    		g.fillRect( 0, 0, getWidth(), getHeight() );
    		g.setColor( Color.WHITE );
    		g.drawString( "Game Paused", getWidth() / 2 - 40, getHeight() / 2 - 20 );
    		
    	}
    	
    }
    
	@ Override
    public void run() {
		
		while( isVisible() ) {
			
			try { Thread.sleep( 500 ); }
			catch ( InterruptedException e ) { e.printStackTrace(); }
			
			if ( isRunning ) {
				
				if ( stein == null ) { stein = new Stein(); }
				else {
					
					if ( stein.canMove( 'D' ) ) { stein.move( 'D' ); }
					else { manifest(); }
					
				}
				
			}
			
			repaint();
			
		}
		
	}
	
	private void manifest() {
		
    	for ( int x = 0; x < Stein.getFields().length; x++ ) {
    		
    		for ( int y = 0; y < Stein.getFields()[ 0 ].length; y++ ) {
    			
    			if ( Stein.getFields()[ x ][ y ] == true ) {
    				
    				Fields[ x + Stein.getPoint().x ][ y + Stein.getPoint().y ] = true;
    				
    			}
    			
    		}
    		
    	}
    	
    	stein = null;
		
	}
	
	@ Override
    public void keyPressed( KeyEvent e ) {
		
		switch ( e.getKeyCode() ) {
			
			case KeyEvent.VK_SPACE : isRunning = false; break;
			
			case KeyEvent.VK_LEFT : stein.move( 'L' ); break;
			case KeyEvent.VK_RIGHT : stein.move( 'R' ); break;
			case KeyEvent.VK_DOWN : stein.move( 'D' ); break;
			
		}
		
	}
	
	@ Override
    public void keyReleased( KeyEvent e ) {
		
		switch ( e.getKeyCode() ) {
			
			case KeyEvent.VK_SPACE : isRunning = true; break;
			
		}
		
	}
	
	@ Override
    public void keyTyped( KeyEvent e ) { }
    
}
```



Stein:


Spoiler





```
package net.diegamingbrueder.games.Tetris;

import java.awt.Point;
import java.util.Random;

public class Stein {
	
	// Deklarationen
	
	private static int x, y;
	private static boolean[][] Fields = new boolean[ 3 ][ 3 ];
	
	private Random random = new Random();
	
	// Konstruktoren
	
	public Stein() {
		
		x = random.nextInt( Game.getFields().length );
		
    	for ( int x = 0; x < Fields.length; x++ ) {
    		
    		for ( int y = 0; y < Fields[ 0 ].length; y++ ) {
    			
    			if ( random.nextBoolean() ) { Fields[ x ][ y ] = true; }
    			
    		}
    		
    	}
		
	}
	
	// Methoden
	
	public static boolean[][] getFields() { return Fields; }
	public static Point getPoint() { return new Point( x, y ); }
	
	public void move( char dir ) {
		
		if ( canMove( dir ) ) {
			
			switch( dir ) {
				
				case 'L' : x--; break;
				case 'D' : y++; break;
				case 'R' : x++; break;
				
			}
			
		}
		
	}
	
	public boolean canMove( char dir ) {
		
		switch ( dir ) {
			
			case 'L' :
				
				if ( x == 0 ) return false;
				
				break;
			
			case 'D' :
				
				if ( y + Fields[ 0 ].length == Game.getFields()[ 0 ].length ) return false;
				
				break;
			
			case 'R' :
				
				if ( x + Fields.length == Game.getFields().length ) return false;
				
				break;
			
		}
		
		return true;
		
	}
	
}
```



Credits:


Spoiler





```
package net.diegamingbrueder.games.Tetris;

import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Credits extends JFrame {
	
	// Deklarationen
	
    private static final long serialVersionUID = 1L;
    
    private JLabel ProgrammerL, ProgrammerV, TexturesL, TexturesV;
	
    // Konstruktoren
    
    public Credits() {
    	
    	// Frame vorbereiten
    		
    		super( "Tetris - Credits" );
    		setSize( 250, 120 );
    		setResizable( false );
    		setLocationRelativeTo( null );
    		setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
    		setIconImage( Toolkit.getDefaultToolkit().getImage( "res/Tetris/icon.png" ) );
		
    	// Elemente hinzufügen
    		
    		setLayout( null );
    		
    		ProgrammerL = new JLabel( "Programmierer: " );
    		ProgrammerV = new JLabel( "Richtsfeld Robin" );
    		TexturesL = new JLabel( "Texturen: " );
    		TexturesV = new JLabel( "Wagner Jonas" );
    		
    		ProgrammerL.setBounds( 20, 20, 100, 20 );
    		ProgrammerV.setBounds( 130, 20, 100, 20 );
    		TexturesL.setBounds( 55, 50, 100, 20 );
    		TexturesV.setBounds( 130, 50, 100, 20 );
    		
    		add( ProgrammerL );
    		add( ProgrammerV );
    		add( TexturesL );
    		add( TexturesV );
    	
		setVisible( true);
    	
    }
    
}
```



Ich hoffe, das hilft!


----------

