Splitscreen

Status
Nicht offen für weitere Antworten.
N

Nova

Bekanntes Mitglied
Hallo,

Ich möchte in meinem Spiel einen Splitscreen benutzen, d.h. Spieler 1 hat z.B. die obere Hälfte des Bildschirms, Spieler 2 die untere Hälfte des Bildschirms. Ich habe aber keine Ahnung wie ich das machen soll.
Hinzukommt dass das Spielfeld größer werden soll, z.B. 3000x2000 Pixel wobei immer nur z.B.1000x300 angezeigt werden (immer auf das Flugzeug zentriert).

Kurze Beschreibung des Programms:
-2 Spieler
-2D
-JFrame
-jeder Spieler steuert ein Flugzeug (=>KeyListener) und versucht den anderen Spieler abzuschießen
-Es gibt eine Matrix, jeder Wert entspricht einem Pixel (momentan 1000x600 Pixel das heißt eine 1000x600 Matrix).
0 bedeutet an dieser Stelle ist "nichts", 1 bedeutet momentan Landschaft (=>wenn ein Flugzeug an eine solche Stelle fliegt wird es zerstört), dann noch verschiedene Werte für die Flugzeuge und ihre Geschosse.



Hier mal der Code aus den für diesen Fall 2 wichtigsten Klassen:
"Startklasse" mit erstellung eines JFrames:
Code: 
import java.awt.*;
import javax.swing.JFrame;

public class Dogfight{
	
	public static void main(String[]args){
		JFrame application = new JFrame("Dogfight V0.5");
		
		application.setLayout(new BorderLayout());
		PaintPanel paintPanel = new PaintPanel();	
		application.add(paintPanel);
		application.addKeyListener(paintPanel);
				
		application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//application.setUndecorated(true); //Fensterrahmen ausblenden
		application.setSize(1010,635);
		application.setVisible(true);
	}
}

Und hier die PaintPanel-Klasse:
Code: 
import java.awt.*;
import java.awt.event.*;
import javax.swing.JPanel;
import java.util.LinkedList;
import javax.swing.JOptionPane;

public class PaintPanel extends JPanel implements KeyListener,Runnable{

    public static int[][] matrix;
    public final static int MAX_WIDTH = 1000, MAX_HEIGHT = 600;
    private final int DELAY = 0;
    private Flugzeug flugzeug1, flugzeug2;
    
    public PaintPanel(){
        matrix = new int[MAX_WIDTH][MAX_HEIGHT];

	    Point p1 = new Point(80,MAX_HEIGHT/2);
     	Point p2 = new Point(MAX_WIDTH-80,MAX_HEIGHT/2);
     	
     	Flugobjekt.setMatrix(matrix); // Matrix an Flugobjekt übergeben, somit "kennen" alle Flugobjekte die Matrix
     	
     	// Begrenzung
        for (int x = 0; x <= (MAX_WIDTH)-1; x++){
	        matrix[x][0] = 1;
	        matrix[x][1] = 1;
	        matrix[x][2] = 1;
	        matrix[x][3] = 1;
	        matrix[x][MAX_HEIGHT-1] = 1;
	        matrix[x][MAX_HEIGHT-2] = 1;
	        matrix[x][MAX_HEIGHT-3] = 1;
	        matrix[x][MAX_HEIGHT-4] = 1;
        }
	    for (int y = 0; y <= (MAX_HEIGHT)-1; y++){
	        matrix[0][y] = 1;
	        matrix[1][y] = 1;
	        matrix[2][y] = 1;
	        matrix[3][y] = 1;
	        matrix[MAX_WIDTH-1][y] = 1;
	        matrix[MAX_WIDTH-2][y] = 1;
	        matrix[MAX_WIDTH-3][y] = 1;
	        matrix[MAX_WIDTH-4][y] = 1;
	    }
     	
	    flugzeug1 = new Flugzeug(p1,10000,0,1); // Flugzeug 1 erstellen
	    flugzeug2 = new Flugzeug(p2,20000,180,1); // Flugzeug 2 erstellen
	    
	    Thread th = new Thread(this);
	    th.start();
    }
    
    public void run(){
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
	    Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

		// Solange true ist läuft der Thread weiter
		while (true)
		{		
	        flugzeug1.moveFlugzeug(); // Flugzeug 1 bewegen
	        flugzeug2.moveFlugzeug(); // Flugzeug 2 bewegen
	        double schaden1 = flugzeug1.moveWeapon1(); // Geschosse von Flugzeug1 bewegen und angerichteten Schaden speichern
	        if (schaden1 != 0){
	        	flugzeug2.damaged(schaden1);
	        }
	        double schaden2 = flugzeug2.moveWeapon1(); // Geschosse von Flugzeug2 bewegen und angerichteten Schaden speichern
	        if (schaden2 != 0){
	        	flugzeug1.damaged(schaden2);
	        }
			
			repaint();

			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep(20);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}

			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}    	
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);
	    
	    setBackground(Color.white);
	    
	    g.setColor(Color.white);
	    g.fillRect(0,0,MAX_WIDTH,MAX_HEIGHT);
	    
	    g.setColor(Color.black);
	    g.fillRect(0,0,MAX_WIDTH,5);
	    g.fillRect(0,MAX_HEIGHT-5,MAX_WIDTH,5);
	    g.fillRect(0,0,3,MAX_HEIGHT);
	    g.fillRect(MAX_WIDTH-5,0,5,MAX_HEIGHT);
	    
	    flugzeug1.paintStatus(new Point(20,20),g); // Status Flugzeug 1 zeichnen
	    flugzeug2.paintStatus(new Point(MAX_WIDTH-100,20),g); // Status Flugzeug2 zeichnen
	    
	    flugzeug1.drawFlugzeug(g);
	    flugzeug2.drawFlugzeug(g);
	    
	    flugzeug1.drawWeapon1(g);
	    flugzeug2.drawWeapon1(g);
    }

    public void keyPressed(KeyEvent event){
    	switch(event.getKeyCode()){
    		// Flugzeug 1:
    		case KeyEvent.VK_UP: flugzeug1.setSpeed_key_pressed(true); break;
    		case KeyEvent.VK_DOWN: flugzeug1.setBreak_key_pressed(true); break;
    		case KeyEvent.VK_LEFT: flugzeug1.setLeft_key_pressed(true); break;
    		case KeyEvent.VK_RIGHT: flugzeug1.setRight_key_pressed(true); break;
    		case KeyEvent.VK_SPACE: flugzeug1.setFire1_key_pressed(true); break;
    		// Flugzeug 2:
    		case KeyEvent.VK_W: flugzeug2.setSpeed_key_pressed(true); break;
    		case KeyEvent.VK_S: flugzeug2.setBreak_key_pressed(true); break;
    		case KeyEvent.VK_A: flugzeug2.setLeft_key_pressed(true); break;
    		case KeyEvent.VK_D: flugzeug2.setRight_key_pressed(true); break;
    		case KeyEvent.VK_CONTROL: flugzeug2.setFire1_key_pressed(true); break;     		
    	}
    }

    public void keyReleased(KeyEvent event){
    	switch(event.getKeyCode()){
    		// Flugzeug 1:
    		case KeyEvent.VK_UP: flugzeug1.setSpeed_key_pressed(false); break;
    		case KeyEvent.VK_DOWN: flugzeug1.setBreak_key_pressed(false); break;
    		case KeyEvent.VK_LEFT: flugzeug1.setLeft_key_pressed(false); break;
    		case KeyEvent.VK_RIGHT: flugzeug1.setRight_key_pressed(false); break;
    		case KeyEvent.VK_SPACE: flugzeug1.setFire1_key_pressed(false); break;
    		// Flugzeug 2:
    		case KeyEvent.VK_W: flugzeug2.setSpeed_key_pressed(false); break;
    		case KeyEvent.VK_S: flugzeug2.setBreak_key_pressed(false); break;
    		case KeyEvent.VK_A: flugzeug2.setLeft_key_pressed(false); break;
    		case KeyEvent.VK_D: flugzeug2.setRight_key_pressed(false); break;
    		case KeyEvent.VK_CONTROL: flugzeug2.setFire1_key_pressed(false); break;     		
    	}    	
    }

    public void keyTyped(KeyEvent event){}
}



Hat jemand eine Idee?


mfg
Christian
 
M

mic_checker

Top Contributor
Ich weiss nicht ob es für deine Zwecke sinnvoll ist, bzw. passt, aber im generellen kannst du solche "geteilten" Bildschirme durch JSplitPane erreichen....
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen


Oben