Javaspel programmering handledning - Flappy fågeln Redux (10 / 12 steg)

Steg 10: Lägga till fågeln

I det här steget kommer vi lägga fågel spelaren till skärmen och dess associerade rörelse logik. Detta innebär inte mycket ny kod - ändringarna kommer att ses av att lägga till en KeyListener för att tillåta användaren att göra fågeln hoppa och startar ett nytt spel att göra några tillägg i gameScreen, logik för att uppdatera spelet poängen adderas och slutbehandling av klassen PlayGameScreen.

Några nya globala variabler har införts i detta steg: BIRD_WIDTH, BIRD_HEIGHT, BIRD_X_LOCATION, BIRD_JUMP_DIFF, BIRD_FALL_DIFF och BIRD_JUMP_HEIGHT för konstanter; gamePlay, birdThrust, birdFired, släppt, och birdYTracker för de globala variablerna.

Till att börja, ska vi lägga till viktiga lyssnaren, så importera klasserna KeyEvent och KeyListener lägga KeyListener till en av de genomförda klasser som TopClass använder, och skapa den standard keyPressed(...), keyReleased(...) och keyTyped(...) metoder. Bara skapa skelettet för dessa tre metoder; Fyll inte dem ännu.

------
Inom gameScreen gör vi några tillägg att lägga till fågelns funktioner till spelet. Först skapa en instans av fågel nära toppen av metoden, skapa två variabler att spåra fågelns X (oförändrad) och Y-koordinater. Det är värt att notera, y = 0 är toppen av skärmen, så när fågeln hoppar, du faktiskt minska fågelns y-koordinat.

Inom spel slingan, kommer att du se flera villkorssats tillägg relevanta för fågeln; var och en kommer att kontrollera om vi är faktiskt på spelet och inte välkomstskärmen med! isSplash. I den första villkorliga testar vi om fågeln har fått höra att flytta (användaren trycker på mellanslagstangenten, som ändrar birdFired till true). Så uppdaterar vi den globala fågel Y koordinaten variabeln för att vara lokalt viktiga Y-koordinaten och ändra birdFired till false.

Nästa testa vi om fågeln har fortfarande dragkraft, vilket betyder att vi tittar på om fågeln rör sig fortfarande från föregående mellanslag press. Så, checkar vi om talande fågeln att hoppa igen kommer att tvinga den från toppen av skärmen. Om inte, vi tillåter en fullständig hoppa. Annars anges fågelns y-koordinaten till noll (överst på skärmen), uppdatera den globala variabeln och ändra birdThrust till false, som fågeln inte kan hoppa längre.

Nästa annat uttalande indikerar att fågelns hoppa åtgärden har slutförts, så uppdatera den globala variabeln och ändra birdThrust till false så att fågeln inte kan röra sig vertikalt längre.

Nästa annat om uttalandet talar fågeln falla när det finns inget utfärdade kommando.

Efter BottomPipe och TopPipe X och Y koordinater är inställda, har vi en snabb om uttalande att göra detsamma för att uppdatera fågel objektets X- och Y-koordinater, samt sätta fågeln objektet i pgs.

I den slutliga villkorliga kallar vi metoden updateScore i TopClass att testa om poängen bör uppdateras. Observera att i uttrycket tillstånd för denna om-uttryck, vi kolla om fågel objektets bredd inte är noll. Detta är att undvika ett udda resurs-lastning problem som uppstår under kollision upptäckt i nästa steg. Vet bara du behöver att koden här.

------
Går vidare till den updateScore metoden, allt vi gör här är test om objektet fågel har passerat ett av de BottomPipe. Vi gör detta genom att kontrollera om det är mellan ytterkanten och ingen längre än den yttre kanten plus X_MOVEMENT_DIFFERENCE. Om det är inom detta spänner, anropa metoden incrementJump inom PlayGameScreen att uppdatera spelet poängen.

------
Vi utse tre nycklar till att den används i detta program: mellanslagstangenten hoppar fågeln, "b"-knappen startar en ny runda efter att vi förlorar, och på escape-tangenten kommer att helt avsluta programmet. I den keyPressed metoden, den första om-satsen kontrollerar att om mellanslagstangenten trycks, spelet spelas (gamePlay == true), och på mellanslagstangenten har släppts, gör något av följande:

* Kontrollera om birdThrust är sant, som kontrollerar om fågeln rör sig fortfarande från tidigare att trycka på mellanslagstangenten. I så fall ändra birdFired till sant att registrera den nya knappen tryck.
* Nästa ändra variabeln birdThrust till sant start fågel flytta om det inte redan
* Slutligen Visa att mellanslag har registrerats och alla relaterade operationer är komplett genom att ändra släppt till false.

Nästa vi kontrollera om spelet inte längre spelas (dvs. en kollision upptäcktes), och om "b"-knappen trycktes, då vi återställa fågeln i början av höjd, ta bort någon dragkraft som det kan ha haft när kollisionen upptäcktes, och simulera tryck på knapp startGame (starta om spelet är inte annorlunda än att trycka på startGame).

Om knappen escape trycktes, vill vi slutligen helt avsluta spelet, vilket sker med hjälp av System.exit(0).

Inom keyReleased, vi helt enkelt registrera sig på mellanslagstangenten trycks genom att ändra släppt till true (inom om-uttryck).

import java.awt.Dimension;
import java.awt.Font;
import java.awt.Image;
import java.awt.Color;
import java.awt.LayoutManager;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.*;

allmän klass TopClass implementerar ActionListener, KeyListener {
globala konstant variabler
privata statisk sista int skärmbredd = (int) Toolkit.getDefaultToolkit().getScreenSize().getWidth();
privata statisk sista int SCREEN_HEIGHT = (int) Toolkit.getDefaultToolkit().getScreenSize().getHeight();
privata statisk sista int PIPE_GAP = SCREEN_HEIGHT/5; avståndet i bildpunkter mellan rören
privata statisk sista int PIPE_WIDTH = skärmbredd/8, PIPE_HEIGHT = 4 * PIPE_WIDTH;
privata statisk sista int BIRD_WIDTH = 120, BIRD_HEIGHT = 75.
privata statisk sista int UPDATE_DIFFERENCE = 25; tid i ms mellan uppdateringar
privata statisk sista int X_MOVEMENT_DIFFERENCE = 5; distansera det rör flytten varje uppdatering
privata statisk sista int SCREEN_DELAY = 300; behövs på grund av långa laddningstider tvingar rör dyka upp halva skärmen
privata statisk sista int BIRD_X_LOCATION = skärmbredd/7;
privata statisk sista int BIRD_JUMP_DIFF = 10, BIRD_FALL_DIFF = BIRD_JUMP_DIFF/2, BIRD_JUMP_HEIGHT = PIPE_GAP - BIRD_HEIGHT - BIRD_JUMP_DIFF * 2;

globala variabler
privata boolean loopVar = sant; falskt -> Kör inte slinga; -True > springa slinga för rör
privata boolean gamePlay = false; falskt -> spelet inte spelas
privata boolean birdThrust = false; falskt -> nyckel inte har tryckt att flytta fågeln vertikalt
privata boolean birdFired = false; sant -> knappen intryckt innan hoppet har slutförts
privata boolean släppt = sant; mellanslagstangenten för släppt; startar som sant så först tryck registren
privata int birdYTracker = SCREEN_HEIGHT/2 - BIRD_HEIGHT;
privata objekt buildComplete = ny objekt();

globala swing objekt
privat JFrame f = nya JFrame ("Flappy fågeln Redux");
privat JButton startGame;
privat JPanel topPanel; förklarat globalt att rymma måla verksamheten och möjliggöra removeAll(), etc.

andra globala objekt
privata statisk TopClass tc = nya TopClass();
privata statisk PlayGameScreen pgs; panel som har rörliga bakgrunden i början av spelet

/**
* Standardkonstruktör
*/
offentliga TopClass() {

}

/**
* Huvudsakliga körbara metoden anropas när du kör hittar.jar-filen
* args
*/
offentliga statisk void main (String [] args) {
bygga GUI på en ny tråd

javax.swing.SwingUtilities.invokeLater (nya Runnable() {
public void run() {
tc.buildFrame();

skapa en ny tråd för att hålla det grafiska Gränssnittet lyhörd medan spelet körs
Gänga t = nya Thread() {
public void run() {
tc.gameScreen(true);
}
};
t.start();
}
});
}

/**
-Metoden att bygga JFrame och lägga till programmet innehåll
*/
privata void buildFrame() {
Bildikon = Toolkit.getDefaultToolkit().getImage(this.getClass().getResource("resources/blue_bird.png"));
f.setContentPane(createContentPane());
f.setResizable(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setAlwaysOnTop(false);
f.setVisible(true);
f.setMinimumSize (ny Dimension (skärmbredd * 1/4, SCREEN_HEIGHT * 1/4));
f.setExtendedState(JFrame.MAXIMIZED_BOTH);
f.setIconImage(icon);
f.addKeyListener(this);
}

privat JPanel createContentPane() {
topPanel = nya JPanel(); översta JPanel i layout hierarki
topPanel.setBackground(Color.BLACK);
Tillåt oss till lagret panelerna
LayoutManager overlay = nya OverlayLayout(topPanel);
topPanel.setLayout(overlay);

Starta spelet JButton
startGame = ny JButton ("börja spela!");
startGame.setBackground(Color.BLUE);
startGame.setForeground(Color.WHITE);
startGame.setFocusable(false); snarare än bara setFocusabled(false)
startGame.setFont (nya typsnitt ("kaliber", Font.BOLD, 42));
startGame.setAlignmentX(0.5f); Centrera vågrätt på skärmen
startGame.setAlignmentY(0.5f); Centrera lodrätt på skärmen
startGame.addActionListener(this);
topPanel.add(startGame);

måste lägga till sist för att säkerställa knappens synlighet
PGS = nya PlayGameScreen (skärmbredd, SCREEN_HEIGHT, true); sant -> vi vill pgs vara startbilden
topPanel.add(pgs);

returnera topPanel;
}

/**
* Genomförandet för åtgärder händelser
*/
public void actionPerformed (ActionEvent e) {
IF(e.GetSource() == startGame) {
stoppa startbilden
loopVar = false;

fadeOperation();
}
annat if(e.getSource() == buildComplete) {
Gänga t = nya Thread() {
public void run() {
loopVar = sant;
gamePlay = sant;
tc.gameScreen(false);
}
};
t.start();
}
}

public void keyPressed (KeyEvent e) {
IF(e.getKeyCode() == KeyEvent.VK_SPACE & & gamePlay == true & & släppta == true) {
uppdatera ett booleskt värde som testas i spelet slinga att flytta fågeln
IF(birdThrust) {//need detta att registrera tryck på knapp och återställa birdYTracker före hoppet är klart
birdFired = sant;
}
birdThrust = sant;
släppt = false;
}
annat if(e.getKeyCode() == KeyEvent.VK_B & & gamePlay == false) {
birdYTracker = SCREEN_HEIGHT/2 - BIRD_HEIGHT; måste återställa fågelns start höjd
birdThrust = false; om användaren trycker utrymme innan kollisionen och en kollision inträffar innan den når max höjd, få du kvarvarande hoppa, så detta är förebyggande
actionPerformed (nya ActionEvent (startGame, -1, ""));
}
IF(e.getKeyCode() == KeyEvent.VK_ESCAPE) {
System.Exit(0);
}
}

public void keyReleased (KeyEvent e) {
IF(e.getKeyCode() == KeyEvent.VK_SPACE) {
släppt = sant;
}
}

public void keyTyped (KeyEvent e) {

}

/**
* Utföra fade operation som sker innan rundor
*/
privata void fadeOperation() {
Gänga t = nya Thread() {
public void run() {
topPanel.remove(startGame);
topPanel.remove(pgs);
topPanel.revalidate();
topPanel.repaint();

panelen att blekna
JPanel temp = nya JPanel();
int alpha = 0; alfakanal variabel
temp.setBackground (ny färg (0, 0, 0, alfa)); transparent, svart JPanel
topPanel.add(temp);
topPanel.add(pgs);
topPanel.revalidate();
topPanel.repaint();

långa currentTime = System.currentTimeMillis();

While(temp.getBackground().getAlpha()! = 255) {
IF((system.currentTimeMillis() - currentTime) > UPDATE_DIFFERENCE/2) {
om (alpha < 255-10) {
alpha + = 10.
}
annat {
alpha = 255;
}

temp.setBackground (ny färg (0, 0, 0, alfa));

topPanel.revalidate();
topPanel.repaint();
currentTime = System.currentTimeMillis();
}
}

topPanel.removeAll();
topPanel.add(temp);
PGS = nya PlayGameScreen (skärmbredd, SCREEN_HEIGHT, false);
pgs.sendText(""); ta bort rubriktext
topPanel.add(pgs);

While(temp.getBackground().getAlpha()! = 0) {
IF((system.currentTimeMillis() - currentTime) > UPDATE_DIFFERENCE/2) {
om (alfa > 10) {
alpha-= 10.
}
annat {
alpha = 0;
}

temp.setBackground (ny färg (0, 0, 0, alfa));

topPanel.revalidate();
topPanel.repaint();
currentTime = System.currentTimeMillis();
}
}

actionPerformed (nya ActionEvent (buildComplete, -1, "Bygga avslutad"));
}
};

t.start();
}

/**
* Metod som utför plaska skärm grafik rörelser
*/
privata void gameScreen (boolean isSplash) {
BottomPipe bp1 = ny BottomPipe (PIPE_WIDTH, PIPE_HEIGHT);
BottomPipe bp2 = ny BottomPipe (PIPE_WIDTH, PIPE_HEIGHT);
TopPipe tp1 = ny TopPipe (PIPE_WIDTH, PIPE_HEIGHT);
TopPipe tp2 = ny TopPipe (PIPE_WIDTH, PIPE_HEIGHT);
Fågel fågel = ny fågel (BIRD_WIDTH, BIRD_HEIGHT);

variabler att spåra x och y bild platser för nedre röret
int xLoc1 = skärmbredd + SCREEN_DELAY, xLoc2 = (int) ((dubbel) 3.0/2.0*SCREEN_WIDTH+PIPE_WIDTH/2.0)+SCREEN_DELAY;
int yLoc1 = bottomPipeLoc(), yLoc2 = bottomPipeLoc();
int birdX = BIRD_X_LOCATION, birdY = birdYTracker;

variabel att hålla slingan starttid
långa startTime = System.currentTimeMillis();

While(loopVar) {
IF((system.currentTimeMillis() - startTime) > UPDATE_DIFFERENCE) {
Kontrollera om en uppsättning rör har skärmen
om så är fallet, Återställ rörets X läge och tilldela en ny Y plats
om (xLoc1 < (0-PIPE_WIDTH)) {
xLoc1 = skärmbredd;
yLoc1 = bottomPipeLoc();
}
annars om (xLoc2 < (0-PIPE_WIDTH)) {
xLoc2 = skärmbredd;
yLoc2 = bottomPipeLoc();
}

minska på röret platser med förutbestämda belopp
xLoc1-= X_MOVEMENT_DIFFERENCE;
xLoc2-= X_MOVEMENT_DIFFERENCE;

om (birdFired & &! isSplash) {
birdYTracker = birdY;
birdFired = false;
}

om (birdThrust & &! isSplash) {
gå fågel vertikalt
om (birdYTracker - birdY - BIRD_JUMP_DIFF < BIRD_JUMP_HEIGHT) {
om (birdY - BIRD_JUMP_DIFF > 0) {
birdY-= BIRD_JUMP_DIFF; koordinater olika
}
annat {
birdY = 0;
birdYTracker = birdY;
birdThrust = false;
}
}
annat {
birdYTracker = birdY;
birdThrust = false;
}
}
annat if(!isSplash) {
birdY += BIRD_FALL_DIFF;
birdYTracker = birdY;
}

uppdatera BottomPipe och TopPipe platserna
BP1.setX(xLoc1);
BP1.setY(yLoc1);
bp2.setX(xLoc2);
bp2.setY(yLoc2);
TP1.setX(xLoc1);
TP1.setY(yLoc1-PIPE_GAP-PIPE_HEIGHT); säkerställa tp1 på rätt plats
TP2.setX(xLoc2);
TP2.setY(yLoc2-PIPE_GAP-PIPE_HEIGHT); säkerställa tp2 på rätt plats

IF(!isSplash) {
bird.setX(birdX);
bird.setY(birdY);
pgs.setBird(bird);
}

som de BottomPipe och TopPipe lokala variablerna i PlayGameScreen genom att analysera de lokala variablerna
pgs.setBottomPipe (bp1, bp2);
pgs.setTopPipe (tp1, tp2);

om (! isSplash & & bird.getWidth()! = -1) {//need den andra delen eftersom om fågeln inte på skärmen, inte kan få bildens bredd och har CSS fel i kollision
updateScore (bp1 bp2, fågel);
}

uppdatera pgs's JPanel
topPanel.revalidate();
topPanel.repaint();

uppdatera variabeln tid-spårning efter alla som har slutförts
startTime = System.currentTimeMillis();
}
}
}

/**
* Beräknar ett slumpmässigt heltal för botten rörets placering
* int
*/
privata int bottomPipeLoc() {
int temp = 0;
iterera tills temp är ett värde som gör att båda rören vara på skärmen
medan (temp < = PIPE_GAP + 50 || temp > = SCREEN_HEIGHT-PIPE_GAP) {
Temp = (int) ((dubbel) Math.random()*((double)SCREEN_HEIGHT));
}
returnera härda;
}

/**
* Metod som kontrollerar om poängen behöver uppdateras
* bp1 första BottomPipe objekt
* bp2 andra BottomPipe objektet
* fågel fågel objekt
*/
privata void updateScore (BottomPipe bp1, BottomPipe bp2, fågel fågel) {
IF(BP1.getX() + PIPE_WIDTH < bird.getX() & & bp1.getX() + PIPE_WIDTH > bird.getX() - X_MOVEMENT_DIFFERENCE) {
pgs.incrementJump();
}
annat if(bp2.getX() + PIPE_WIDTH < bird.getX() & & bp2.getX() + PIPE_WIDTH > bird.getX() - X_MOVEMENT_DIFFERENCE) {
pgs.incrementJump();
}
}
}

Slutligen i det här steget avslutar vi koden för klassen PlayGameScreen. För att avsluta detta, vi skapa globala fågel-objekt, lägga till en global variabel som spårar poängen, skapa en global variabel för bredden på poäng texten, lägga till ett par rader kod i metoden paintComponent och skapa tre enkla metoder.

I paintComponent lägger vi villkorssats för att kolla om vi är inte längre på startbilden och se till att fågeln inte är null. Om nöjd, dra vi objektet fågel. I try-catch-block, tilldela scoreWidth baserat på nuvarande värdering med hjälp av FontMetrics. Slutligen, om vi inte på startbilden, rita antalet lyckade hopp på skärmen.

Nu skapar vi tre enkla metoder. Först setBird anger fågel objektet i PlayGameScreen, incrementJump ökar den globala hoppa variabeln, och getScore returnerar antalet lyckade hopp (ingen funktionalitet i detta spel).

import javax.swing.*;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Color;

allmän klass PlayGameScreen utökar JPanel {
standard referens-ID
privata statisk sista långa serialVersionUID = 1L;

globala variabler
privata int screenWidth, screenHeight;
privata boolean isSplash = sant;
privata int successfulJumps = 0;
privata sträng meddelande = "Flappy fågeln";
privat Font primaryFont = nya teckensnitt ("Goudy Stout", Font.BOLD, 56), failFont = nya teckensnitt ("kaliber", Font.BOLD, 56);
privata int messageWidth = 0, scoreWidth = 0;
privat BottomPipe bp1, bp2;
privat TopPipe tp1, tp2;
privat fågel fågel; < /p >< p > / **
* Standardkonstruktor för klassen PlayGameScreen
*/
offentliga PlayGameScreen (int screenWidth, int screenHeight, boolean isSplash) {
this.screenWidth = screenWidth;
this.screenHeight = screenHeight;
this.isSplash = isSplash;
}

/**
* Manuellt styra vad dras på denna JPanel genom att anropa metoden paintComponent
* med graphics-objektet och målning med objektet
*/
public void paintComponent (Graphics g) {
super.paintComponent(g);

g.setColor (ny färg (89, 81, 247)); färg för den blå himlen
g.fillRect (0, 0, screenWidth, screenHeight * 7/8); skapa den sky rektangeln
g.setColor (ny färg (147, 136, 9)); brun färg för marken
g.fillRect (0, screenHeight * 7/8, screenWidth, screenHeight/8); skapa den mark rektangeln
g.setColor(Color.BLACK); dividera Linjefärg
g.drawLine (0, screenHeight * 7/8, screenWidth, screenHeight * 7/8); dra skiljelinjen

objekt måste instantieras innan de är dras!
om (bp1! = null & & bp2! = null & & tp1! = null & & tp2! = null) {
g.drawImage(bp1.getPipe(), bp1.getX(), bp1.getY(), null);
g.drawImage(bp2.getPipe(), bp2.getX(), bp2.getY(), null);
g.drawImage(tp1.getPipe(), tp1.getX(), tp1.getY(), null);
g.drawImage(tp2.getPipe(), tp2.getX(), tp2.getY(), null);
}

om (! isSplash & & fågel! = null) {
g.drawImage(bird.getBird(), bird.getX(), bird.getY(), null);
}

behövs om primära teckensnittet inte finns
försök {
g.setFont(primaryFont);
FontMetrics mått = g.getFontMetrics(primaryFont);
messageWidth = metric.stringWidth(message);
scoreWidth = metric.stringWidth (String.format ("%d", successfulJumps));
}
fånga (undantag e) {
g.setFont(failFont);
FontMetrics mått = g.getFontMetrics(failFont);
messageWidth = metric.stringWidth(message);
scoreWidth = metric.stringWidth (String.format ("%d", successfulJumps));
}

g.drawString (meddelande, screenWidth/2-messageWidth/2, screenHeight/4);

IF(!isSplash) {
g.drawString (String.format ("%d", successfulJumps), screenWidth/2-scoreWidth/2, 50);
}
}

/**
* När metoden för Playgamescreens globala BottomPipe variabler
* bp1 den första BottomPipe
* bp2 den andra BottomPipe
*/
public void setBottomPipe (BottomPipe bp1, BottomPipe bp2) {
This.BP1 = bp1;
This.bp2 = bp2;
}

/**
* När metoden för Playgamescreens globala TopPipe variabler
* tp1 den första TopPipe
* tp2 den andra TopPipe
*/
public void setTopPipe (TopPipe tp1, TopPipe tp2) {
This.TP1 = tp1;
This.TP2 = tp2;
}

/**
* När metoden för Playgamescreen's global fågel variabel
* fågel fågel objektet
*/
public void setBird (fågel fågel) {
This.Bird = fågel.
}

/**
* Metod som kallas för att anropa en ökning i variabeln spåra nuvarande
* hoppa poäng
*/
public void incrementJump() {
successfulJumps ++;
}

/**
* Metoden kallas för att returnera den nuvarande hoppa poängen
*
*/
Public int getScore() {
återvända successfulJumps;
}

/**
* Metod som kallas för att tolka ett meddelande på skärmen
* meddelande meddelandet att tolka
*/
public void sendText (String meddelande) {
This.Message = meddelande;
}
}