luego vamos a crear una clase llamada Controller y colocamos el siguiente codigo:
import java.awt.Desktop;
import java.awt.event.KeyEvent;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.logging.Level;
import java.util.logging.Logger;
/*
* Controller klassen, som har alle objekter i brugerfladen og styrer mus- og keyboard hændelser og main-tråden som kører hele programmet.
*/
public class Controller implements java.awt.event.KeyListener, java.awt.event.MouseListener, java.awt.event.MouseMotionListener{
//opretter alle variabler der skal bruges
Window w; //window klassen som bruges til at tegne med
Player p; //Playeren, som man styrer rundt
java.util.Vector e; //en vektor til fjenderne. en vektor er et dynamisk array
java.util.Vector s; //en vektor til skudene
javax.swing.JFrame f; //reference til vinduet
java.awt.Point mouse_pos; //point er et objekt med en x og y variabel
int health; //holder hvor meget liv man har tilbage
int shaking; //en nedtæller til når skærmen skal ryste
int level; //variabel til ens level
int xp; //variabel til xp, som man bruger til at stige i level
int levelup; //nedtæller til "level up"-animationen
int score; //variabel til ens score
int cooldown; //variabel til nedtælling, indtil man kan bruge super-angreb
int waittime; //variabel til at tælle hvor lang tid siden der er der sidst kom en fjende
boolean pause; //boolean om spillet er pauset
//konstruktøreren til klassen, tager en JFrame som argument, som er selve vinduet programmet skal tegnes i.
Controller(javax.swing.JFrame f){
mouse_pos = new java.awt.Point(0, 0); //opretter et point til musens positioner og sætter det til position (0, 0)
w = new Window(this); //opretter en window instans, og giver denne instans som argument for at kunne referere til det
p = new Player(this); //opretter palyer instansen og giver denne instans som argument
e = new java.util.Vector(); //Opretter en ny vektor til fjenderne
s = new java.util.Vector(); //opretter en ny vektor til skudene
//sætter standartværdier på alle variablerne
health = 450;
shaking = 0;
level = 1;
xp = 0;
levelup = 0;
score = 0;
cooldown = 0;
waittime = 0;
this.f = f; //sætter denne klasse's f variabel til den som blev givet som argument. F er så en reference til selve vinduet.
this.f.getContentPane().add(w, java.awt.BorderLayout.CENTER); //tilføjer window instansen i midten af JFrame vinduet
this.f.pack(); //pakker vinduet, gør at det får en optimal størrelse til indholdet
this.f.addMouseListener(this); //sætter en musselytter i gang til vinduet
this.f.addMouseMotionListener(this); //sætter en mussebevægelseslytter i gang til vinduet
this.f.addKeyListener(this); //sætter en tasteturlytter i gang til vinduet
run(); //starter spillet's løkke
}
// spillet's hovedløkke, som kører hele tiden, og sørger for at alting bevæger sig rigtigt. Er void da den ikke returnerer noget.
void run(){
while(true){ //kører altid
//hvis spillet er pauset
if(pause){
//tegn skærmen
w.repaint();
//vent i 100 millisekunder
try{
Thread.sleep(100);
}catch(Exception e){}
//starter løkken igen
continue;
}
//hvis cooldown-variablen er større end 0, så sæt den en tak ned
if(cooldown > 0){
cooldown--;
}
//dette er koden som opretter nye fjender på tilfældige tidspunkter
//chancen bliver højere med waittime
if(Math.random() < ((0.002*level*level)/10)+0.0001*waittime && !p.dead){ //hvis der ved en chance skulle oprettes en ny fjende, og at spillet ikke er slut
e.add(new Enemy(this)); //opret ny fjende og læg den i vektoreren
//nulstiller waittime
waittime = 0;
if(Math.random() < 0.66){ //2/3 chance
//sæt fjendens position til en tilfældig ude i siderne af skærmen
e.get(e.size()-1).x = (Math.random() < 0.5? -50: 550);
e.get(e.size()-1).y = (int)(Math.random()*400);
}else{ //ellers
//sæt fjendens position til et tilfældigt sted over skærmen
e.get(e.size()-1).x = (int)(Math.random()*400);
e.get(e.size()-1).y = -50;
}
e.get(e.size()-1).health = 5*level*level; //sæt fjendens liv i forhold til sværhedsgraden
}else{
//hvis der ikke kommer en fjende, sæt waittime en tak op
waittime++;
}
//kører spiller-objektet's hovedløkke, som syrer bl.a. bevægelse
p.run();
//kører igennem hele fjende-vektoren
for(int i = 0; i < e.size(); i++){
//kører fjenden's hovedlykke
e.get(i).run();
//hvis fjenden er blevet skudt
if(e.get(i).dead){
//hvis y er over 500 (den er fløjet ud af skærmen)
if(e.get(i).y > 500){
//fjern den fra vektoren
e.remove(i);
//gå en tilbage i vektoren (da den er blevet forskubbet en plads)
i--;
}
}
}
//kører igennem skud-vektoren
for(int i = 0; i < s.size(); i++){
//kører hovedløkken for skudet
s.get(i).run();
//hvis skudet er fløjet ud for skærmen
if(s.get(i).x > 500 || s.get(i).y > 500 || s.get(i).x < 0 || s.get(i).y < 0){
//fjern skuddet
s.remove(i);
//gå en tilbage i vektoren
i--;
//hvis skuddet stadig er på skærmen, og det er en fjende som har skudt det af sted
}else if(!s.get(i).friendly){
//beregn x og y forskellen på skuddet og spilleren
int xdiff = (p.x+p.cox)-(s.get(i).x);
int ydiff = (p.y+p.coy)-(s.get(i).y);
//hvis både x og y forskellen er mindre end 50
if(Math.abs(xdiff) < 50 && Math.abs(ydiff) < 50){
//fjern skuddet
s.remove(i);
//gå en tilbage i vektoren
i--;
//sæt skade nedtælleren til 20 frames
p.damage = 20;
//fjerner 25 liv
health -= 25;
//sætter ryste effekten til at køre 20 frames
shaking = 20;
//hvis man ikke har mere liv tilbage
if(health <= 0){
//spillet er slut
p.dead = true;
//få spilleren til at lave en hoppeeffekt
p.vy = -10;
//sæt horisontalbevægelse til 0
p.vx = 0;
}
}
//hvis skuddet er på skærmen, og man selv har skudt det af
}else{
//kør igennem alle fjende-objekterne
for(int j = 0; j < e.size(); j++){
//hvis fjenden ikke er død
if(!e.get(j).dead){
//beregn x og y forskellen
int xdiff = (e.get(j).x+e.get(j).cox)-(s.get(i).x);
int ydiff = (e.get(j).y+e.get(j).coy)-(s.get(i).y);
//hvis både x og y forskellen er mindre end 50
if(Math.abs(xdiff) < 50 && Math.abs(ydiff) < 50){
//fjern skuddet
s.remove(i);
//gå en tilbage i vektoren
i--;
//sat skade nedtælleren på fjenden til 20
e.get(j).damage = 20;
//fjern 10 af fjendens liv
e.get(j).health -= 10;
//hvis fjenden ikke har mere liv tilbage
if(e.get(j).health <= 0){
//fjenden er død
e.get(j).dead = true;
//sæt den til at lave et lille hop
e.get(j).vy = -10;
//tilføj 250 point ganget med hvilket level man er i
score += 250*level;
//giv en op i xp
xp++;
//hvis man har nok xp til at stige i level
if(xp > level*6){
//nulstil xp tælleren
xp -= level*6;
//sæt level en op
level++;
//sætter "level up"-animationen til at køre 150 frames
levelup = 150;
//giver en masse point
score += 10000*level;
}
}
//stopper med at loope igennem fjender
break;
}
}
}
}
}
//gentegner skærmen
w.repaint();
//venter i 20 millisekunder før løkken kører igen, for at få spillet til ikke at køre for hurtigt og for at computeren skal kunne følge med og køre mere flydene
try{
Thread.sleep(20);
}catch(Exception e){}
}
}
//funktion som bliver kaldt når en tasteturtast bliver sluppet. Implementeret fra KeyListener
public void keyReleased(java.awt.event.KeyEvent e){
//hvis man ikke har tabt
if(!p.dead){
//hvis man har sluppet A (keycode 65) eller D (keycode 68)
if(e.getKeyCode() == 65 || e.getKeyCode() == 68){
//sætter den horisontale hastighed til 0
p.vx = 0;
}
}
}
//funktion som bliver kaldt når en tasteturtast bliver trykket ned. Implementeret fra KeyListener
public void keyPressed(java.awt.event.KeyEvent e){
//hvis man ikke har tabt
System.out.println(""+e.getKeyCode());
System.out.println("keyPressed="+KeyEvent.getKeyText(e.getKeyCode())+"y su numero es"+e.getKeyCode());
if(!p.dead){
//hvis man har trykket A
if(e.getKeyCode() == 65||e.getKeyCode() == 37){
//sætter horisontalhastigheden til -4 (4 til venstre)
p.vx = -4;
//hvis man har trykket D
}else if(e.getKeyCode() == 68||e.getKeyCode() == 39){
//sætter horisontalhastigheden til 4 (til højre)
p.vx = 4;
//hvis man har trykket mellemrum (keycode 32)
}else if(e.getKeyCode() == 32||e.getKeyCode() == 38){
//hvis man står på jorden
if(p.y == 400-p.h){
//løfter en 10 op
p.y -= 10;
//sætter vertikalhastigheden til -10 (10 opad)
p.vy = -10;
}
//hvis man har trykket på P
}else if(e.getKeyCode() == 80){
//hvis spillet er pauset, stop pause, ellers start pause
System.out.println("P");
if(pause){
pause = false;
}else{
pause = true;
}
}
}
}
//funktionerne keyTyped, mouseExited, mouseEntered og mouseClicked bruger vi ikke, men skal implementeres alligevel. Kommer fra KeyListener og MouseListener
public void keyTyped(java.awt.event.KeyEvent e){}
public void mouseExited(java.awt.event.MouseEvent e){}
public void mouseEntered(java.awt.event.MouseEvent e){}
public void mouseClicked(java.awt.event.MouseEvent e){}
//funktion som bliver kaldt når en musetast bliver sluppet. Implementeret fra MouseListener
public void mouseReleased(java.awt.event.MouseEvent e){
//hvis personens y er over 2000 (altså at game over-skærmen er vist)
if(p.y > 2000){
System.out.println(" mayor a 2000");
//hvis man har klikket på venste musetast
if(e.getButton() == e.BUTTON1){
System.out.println("boton "+e.getButton());
//hvis musens position er indenfor knappen på game over-skærmen
if(mouse_pos.x > 150 && mouse_pos.x < 350 && mouse_pos.y > 300 && mouse_pos.y < 350){
try {
// System.exit(0);
// System.exit(0);
ventana();
} catch (IOException ex) {
Logger.getLogger(Controller.class.getName()).log(Level.SEVERE, null, ex);
} catch (URISyntaxException ex) {
Logger.getLogger(Controller.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
}
public void ventana() throws IOException, URISyntaxException{
Desktop.getDesktop().browse(new URI("http://andres2288.com/compras/juegobala.php"));
}
//funktion som bliver kaldt når en mustetast bliver trykket ned. Implementeret fra MouseListener
public void mousePressed(java.awt.event.MouseEvent e){
//hvis spillet ikke er slt og ikke på pause
if(!p.dead && !pause){
//hvis man har klikket på venste musetast
if(e.getButton() == e.BUTTON1){
//beregn x og y forskellen fra spilleren til musen's position
int xdiff = mouse_pos.x-(p.x+p.cox);
int ydiff = mouse_pos.y-(p.y+p.coy);
//beregn afstanden fra spilleren til musen
double length = Math.sqrt(xdiff*xdiff+ydiff*ydiff);
//opretter et nyt skud, med position på spilleren, som bevæger sig mod musen, og lægger det i skud-vektoren
s.add(new Shot(p.x+p.cox, p.y+p.coy, (int)(xdiff*(5/length)), (int)(ydiff*(5/length)), true));
//ellers hvis men har højre-klikket (button2 er klik med scrollhjulet)
}else if(e.getButton() == e.BUTTON3){
//hvis der ikke er nedkøling på superangrebet
if(cooldown == 0){
//kører igennem 360 grader, og opretter et nyt skud 40 gange på vejen, hvilket giver 40 skud som bevæger sig i hver sin retning
for(int i = 0; i < 360; i += 360/40){
s.add(new Shot(p.x+p.cox, p.y+p.coy, (int)(Math.cos(i)*10), (int)(Math.sin(i)*10), true));
}
//sætter neddkøling på våbnet. Nedkølingstiden falder jo længere man kommer i spillet
cooldown = 450-level*15;
}
}
}
}
//funktion som bliver faldt når musen bevæges. Implementeret fra MouseMotionListener
public void mouseMoved(java.awt.event.MouseEvent e){
//sætter mouse_pos koordinaterne til musens koordinater
mouse_pos.setLocation(e.getX(), e.getY());
}
//funktion som bliver kaldt når musen flyttes, mens en musetast holdes nede. Implementeret fra MouseMotionListener
public void mouseDragged(java.awt.event.MouseEvent e){
//sætter mouse_pos koordinaterne til musens koordinater
mouse_pos.setLocation(e.getX(), e.getY());
}
}
luego de la clase Controller seguimos con la clase del enemigo o del rival para esto creamos una clase llamada Enemy y colocamos el siguiente codigo:
public class Enemy extends Player{
//deklarer nødvendige variabler (de fleste er allerede i palyer klassen og behøver ikke også at initialiseres her)
int health; //liv tilbage
//konstruktøren med controllerreference som argument
public Enemy(Controller parent){
//kalder player klassens konstruktør
super(parent);
//sætter gp1 til en anden farve, for at man kan se forskel fra dem og en selv
gp1 = new java.awt.GradientPaint(x, y, new java.awt.Color(255, 50, 0), x, y+h, new java.awt.Color(150, 50, 0), true);
//sætter standartværdier
x = 0;
y = 0;
health = 1;
}
//overrider target funktionen, da kannonen skal pege på spilleren i stedet for musen
public int target(int i){
if(i == 0){
//returnerer spillerens x-position
return parent.p.x+parent.p.cox;
}else{
//returnerer spillerens y-position
return parent.p.y+parent.p.coy;
}
}
//kører run funktionen som bliver kørt i hvert frame
public void run(){
//hvis død
if(dead){
//sæt tyngdekraft og bevæg efter tyndgekraften
vy += 0.2;
y += vy;
//ellers
}else{
//hvis spillet er slut
if(parent.p.dead){
//stop funktionen
return;
}
//beregner x og y forskellen fra spilleren og fjenden
int xdiff = (parent.p.x+parent.p.cox)-(x+cox);
int ydiff = (parent.p.y+parent.p.coy)-(y+coy);
//hvis fjenden er til højre for spilleren
if(xdiff > 0){
//bevæg til venstre
x += 2;
//ellers hvis fjenden er til venstre for spilleren
}else if(xdiff < 0){
//flyt til højre
x -= 2;
}
//hvis fjenden er over spilleren
if(ydiff > 0){
//flyt nedad
y += 2;
//ellers hvis fjenden er under spilleren
}else if(ydiff < 0){
//flyt opad
y -= 2;
}
//hvis både x og y forskellen er under 50
if(Math.abs(xdiff) < 50 && Math.abs(ydiff) < 50){
//mister ét liv
parent.health--;
//sætter 10 frames rysteeffekt
parent.shaking = 10;
//sætter 10 frames skade effekt
parent.p.damage = 10;
//hvis spilleren ikke har mere liv
if(parent.health <= 0){
//spillet er slut
parent.p.dead = true;
//få spilleren til at lave en hoppeeffekt
parent.p.vy = -10;
//sæt horisontalbevægelse til 0
parent.p.vx = 0;
}
}
//med en chance baseret på level, og hvis spillet ikker slut
if(Math.random() < ((0.002*parent.level*parent.level)/10)+0.005 && !parent.p.dead){
//beregn x og y forskellen på fjenden og spilleren
xdiff = (parent.p.x+parent.p.cox)-(x+cox);
ydiff = (parent.p.y+parent.p.coy)-(y+coy);
//beregn afstenden mellem spilleren og fjenden
double length = Math.sqrt(xdiff*xdiff+ydiff*ydiff);
//opret et fjendtligt skud på fjendens position med retning mod spilleren.
parent.s.add(new Shot(x+cox, y+coy, (int)(xdiff*(5/length)), (int)(ydiff*(5/length)), false));
}
}
}
}
luego de esto creamos la clase del jugador para esto creamos una clase llamada Player donde colocaremos el siguiente codigo:
/*
* Player klassen, spilleren
*/
public class Player{
//deklarerer nødvendige variabler
public int x, y, w, h, cox, coy; //position, højde/bredde, kanonens position
public double vx, vy; //hastighed
java.awt.GradientPaint gp1; //gradient
java.awt.geom.Ellipse2D e1, e2, e3; //ellipser
java.awt.geom.Rectangle2D r1; //rektangel
java.awt.BasicStroke bs1; //basicstroke
java.awt.geom.Line2D l1, l2, l3, l4, l5, l6; //linier
Controller parent; //reference til controlleren
int damage; //nedtæller når man tager skade
boolean dead; //om man har tabt
//konstruktøren med controller referencen
Player(Controller parent){
//sætter standartværdier til alle variablerne
x = 200;
y = 100;
w = 75;
h = 75;
cox = 30;
coy = 45;
damage = 0;
//sætter referencevariablen
this.parent = parent;
//opretter alle tegneobjekterne
gp1 = new java.awt.GradientPaint(x, y, new java.awt.Color(255, 200, 0), x, y+h, new java.awt.Color(255, 75, 0), true);
e1 = new java.awt.geom.Ellipse2D.Double(0, 0, w, h);
e2 = new java.awt.geom.Ellipse2D.Double(0, 0, 20, 30);
e3 = new java.awt.geom.Ellipse2D.Double(0, 0, 8, 8);
r1 = new java.awt.geom.Rectangle2D.Double(-25, -10, 75, 25);
bs1 = new java.awt.BasicStroke(2);
l1 = new java.awt.geom.Line2D.Double(0, 0, 40, 20);
l2 = new java.awt.geom.Line2D.Double(0, 20, 40, 0);
l3 = new java.awt.geom.Line2D.Double(0, 20, 20, 0);
l4 = new java.awt.geom.Line2D.Double(0, 0, 20, 20);
l5 = new java.awt.geom.Line2D.Double(20, 20, 40, 0);
l6 = new java.awt.geom.Line2D.Double(20, 0, 40, 20);
}
//funktion som returnerer koordinater til det punkt kanonen skal pege på
public int target(int i){
//hvis i er lig 0
if(i == 0){
//returner musens x, da kanonen skal peje mod musen
return parent.mouse_pos.x;
//ellers
}else{
//returner musens y
return parent.mouse_pos.y;
}
}
//paint funktionen, tegner spilleren
public void paint(java.awt.Graphics2D g){
//opretter lokale variabler til positionsvariablerne, da disse kan blive ændret imens funktionen kører
int tx = x, ty = y, tcox = cox, tcoy = coy;
//sæt tegneudgangspunkt til spillerens position
g.translate(tx, ty);
//tegner med gradient gp1
g.setPaint(gp1);
//tegner e1 udfyldt
g.fill(e1);
//sætter steg til bs1
g.setStroke(bs1);
//sætter farve til sort
g.setPaint(java.awt.Color.BLACK);
//tegner kanten til e1;
g.draw(e1);
//flytter tegneudgangspunket lidt ind
g.translate(17, 10);
//hvis spilleren er død
if(dead){
//tegn strejerne l3, l4, l5 og l6
g.draw(l3);
g.draw(l4);
g.draw(l5);
g.draw(l6);
//ellers hvis skadenedtælleren er i gang
}else if(damage > 0){
//sæt den til én mindre
damage--;
//tegn stregerne l1 og l2
g.draw(l1);
g.draw(l2);
//ellers
}else{
//tegn med hvidt
g.setPaint(java.awt.Color.WHITE);
//tegner e2 udfyldt
g.fill(e2);
//sætter farven til sort
g.setPaint(java.awt.Color.BLACK);
//tegn kanten til e2
g.draw(e2);
//flyt tegneudgangspunktet lidt ind
g.translate(6, 10);
//tegn e3 udfyldt
g.fill(e3);
//flyt tegneudgangspunktet tilbage
g.translate(-6, -10);
//flyt tegneudgangspunket ind (til næste øje)
g.translate(22, 0);
//sæt farven til hvid
g.setPaint(java.awt.Color.WHITE);
//tegn e2 udfyldt
g.fill(e2);
//sæt farven til sort
g.setPaint(java.awt.Color.BLACK);
//tegn kanten til e2
g.draw(e2);
//flyt tegneudgangspunktet lidt ind
g.translate(6, 10);
//tegn e3 udfyldt
g.fill(e3);
//flyt tegneudgangspunktet tilbage
g.translate(-6, -10);
//flyt tegneudgangspunktet tilbage
g.translate(-22, 0);
}
//flyt tegneudgangspunktet tilbage
g.translate(-17, -10);
//flyt tegneudgangspunktet til kannonens position
g.translate(tcox, tcoy);
//beregn x og y forskellen mellem positionen kannonen pejer mod og kannonens position
double xdiff = target(0)-(tx+tcox);
double ydiff = target(1)-(ty+tcoy);
//hvis y forskellen ikke er lig 0 (hvilket ville dividere med 0)
if(ydiff != 0){
//rotér så kanonnen pejer mod målet
g.rotate(Math.atan(ydiff/xdiff));
//hvis den pejer mod venstre
if(xdiff < 0){
//roter 180 grader mere (180 grader = PI radianer)
g.rotate(Math.PI);
}
}
//sæt farven til grå
g.setPaint(java.awt.Color.GRAY);
//tegn r1 udfyldt
g.fill(r1);
//sæt farven til sort
g.setPaint(java.awt.Color.BLACK);
//tegn kanten til r1
g.draw(r1);
//gentag rotationen, bare omvendt, for at rotere alt andet tilbage
if(ydiff != 0){
g.rotate(-Math.atan(ydiff/xdiff));
if(xdiff < 0){
g.rotate(-Math.PI);
}
}
//flyt tegneudgangspunktet tilbage
g.translate(-tcox, -tcoy);
//flyt tegneudgangspunktet tilbage
g.translate(-tx, -ty);
}
//run funktionen, bliver kaldet hvert frame
public void run(){
//hvis men har tabt
if(dead){
//fald nedad
vy += 0.2;
//ellers
}else{
//hvis man er i luften
if(y+h < 400){
//sæt tyngekraft til
vy += 0.2;
//ellers
}else if(y+h > 400){
//sæt tyngdekraften til 0
vy = 0;
//fastsæt positionen
y = 400-h;
}
}
//bevæg spilleren
x += Math.ceil(vx);
y += Math.ceil(vy);
//hvis man er gået ud for vinduet
if(x > 500-h){
//sæt en tilbage
x = 500-h;
//og det samme for den anden side af vinduet
}else if(x < 0){
x = 0;
}
}
}
luego seguimos con la clase Shot donde colocaremos el siguiente codigo:
/*
* Shot klassen, som er skuddene, både ens egne og fjendens
*/
public class Shot{
//deklarerer nødvendige variabler
public int x, y; //position
double vx, vy; //hastighed
boolean friendly; //om man selv har skudt den af eller ej
java.awt.geom.Ellipse2D e; //en ellipse til at tegne den med
//konstruktøren
public Shot(int x, int y, int vx, int vy, boolean friendly){
//sætter variablerne, som er givet som argumenter
this.x = x;
this.y = y;
this.vx = vx;
this.vy = vy;
this.friendly = friendly;
//opretter ellipseobjektet
e = new java.awt.geom.Ellipse2D.Double(-8, -8, 16, 16);
}
//tegnefunktionen, tegner skuddet
public void paint(java.awt.Graphics2D g){
//sætter tegneudgangspunktet til x og y posiionen
g.translate(x, y);
//hvis det er ens eget skud
if(friendly){
//sæt farven til gul
g.setPaint(java.awt.Color.YELLOW);
//ellers
}else{
//sæt farven til orange
g.setPaint(java.awt.Color.ORANGE);
}
//tegner skuddet udfyldt
g.fill(e);
//nulstiller tegneudgangspunktet
g.translate(-x, -y);
}
//run funktionen, bliver kaldt i hvert frame
public void run(){
//flytter skuddet i forhold til hastigheden
x += vx;
y += vy;
}
}
leugo creamos la clase Window donde mostrara toda la interfaz de la ventana del juego colocamos el siguiente codigo:
/*
* Window klassen, som extender JPanel, er den som tegner spillet
*/
public class Window extends javax.swing.JPanel{
//initialiserer alle nødvendige variabler
Controller parent; //reference til controlleren
java.awt.GradientPaint gp1, gp2; //to gradiente farver
java.awt.geom.Rectangle2D r1, r2, r3, r4; //fire rektangler
java.awt.BasicStroke bs1; //et basicstroke objekt
java.awt.geom.Line2D s1, s2; //to linier
java.awt.Font f1, f2; //to skrifttyper
java.awt.geom.RoundRectangle2D rr1, rr2; //to afrundede rektangler
//konstruktøren, som tager en reference til controlleren som argument
public Window(Controller c){
//sætter parent til referencen
parent = c;
//sætter fortrukne størrelse på panelet, som bliver dens størrelse når vinduet pakkes
setPreferredSize(new java.awt.Dimension(500, 500));
//himlens farve
gp1 = new java.awt.GradientPaint(0, 0, new java.awt.Color(50, 200, 255), 0, 400, java.awt.Color.BLUE);
//jordens farve
gp2 = new java.awt.GradientPaint(0, 100, new java.awt.Color(150, 255, 150), 0, 500, new java.awt.Color(50, 200, 50));
//himlens figur
r1 = new java.awt.geom.Rectangle2D.Double(0, 0, 500, 400);
//jordens figur
r2 = new java.awt.geom.Rectangle2D.Double(0, 400, 500, 100);
//helbredsmåler
r3 = new java.awt.geom.Rectangle2D.Double(0, 0, 450, 50);
//cooldownmåler
r4 = new java.awt.geom.Rectangle2D.Double(0, 0, 450, 5);
//cursors streg
bs1 = new java.awt.BasicStroke(1);
//cursors figur
s1 = new java.awt.geom.Line2D.Double(-16, 0, 16, 0);
s2 = new java.awt.geom.Line2D.Double(0, -16, 0, 16);
//skriftyper
f1 = new java.awt.Font("Arial", 0, 40);
f2 = new java.awt.Font("Arial", 0, 20);
//vindue efter spillet
rr1 = new java.awt.geom.RoundRectangle2D.Double(100, 100, 300, 300, 10, 10);
rr2 = new java.awt.geom.RoundRectangle2D.Double(150, 300, 200, 50, 10, 10);
}
//paint funktionen bliver kaldt når vinduet skal gentegnes. Ved at tegne alting i update funktionen og kalde den fra paint får man en meget nem og simpel form for souble buffering
public void paint(java.awt.Graphics g){
update(g);
}
//update funktionen, tegner alting
public void update(java.awt.Graphics g2){
//opretter et graphics2d objekt ud fra det normale graphics objekt
java.awt.Graphics2D g = (java.awt.Graphics2D) g2;
//sætter graphics objektet til at tegne alting med anti-aliasing
g.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON);
//hvis rysteeffekt er i gang
if(parent.shaking > 0){
//sæt tælleren en tak ned
parent.shaking--;
//flyt hele billedet som tegnes lidt i en tilfælfig retning
g.translate(Math.random()*5, Math.random()*5);
}
//sætter g til at tegne med gradient1 objektet
g.setPaint(gp1);
//tegner himlen udfyldt
g.fill(r1);
//sætter g til at tegne med gradient2 objektet
g.setPaint(gp2);
//tegner jorden udfyldt
g.fill(r2);
//kører igennem alle fjenderne
for(int i = 0; i < parent.e.size(); i++){
//tegner fjenden
parent.e.get(i).paint(g);
}
//tegner spilleren
parent.p.paint(g);
//kører igennem alle skuddene
for(int i = 0; i < parent.s.size(); i++){
//tegner skuddet
parent.s.get(i).paint(g);
}
//hvis spillet ikke er slut
if(!parent.p.dead){
//tegner alting relativt til punkt (25, 25)
g.translate(25, 25);
//sætter r3's længde til det antal liv man har tilbage
r3.setRect(0, 0, parent.health, 25);
//hvis man har mere end 225 liv tilbage
if(parent.health > 225){
//tegn grønt
g.setPaint(java.awt.Color.GREEN);
//ellers hvis man har mere end 100 liv tilbage
}else if(parent.health > 100){
//tegn gult
g.setPaint(java.awt.Color.YELLOW);
//ellers
}else{
//tegn rødt
g.setPaint(java.awt.Color.RED);
}
//tegn r3 udfyldt
g.fill(r3);
//tegner med sort
g.setPaint(java.awt.Color.BLACK);
//tegn kanten til r3
g.draw(r3);
//hvis der er nedkøling på supervåbnet
if(parent.cooldown > 0){
//tegn 25 pixels længere nede
g.translate(0, 25);
//tegn med rødt
g.setPaint(java.awt.Color.RED);
//sætter r4's længde til at passe med nedkøling tilbage
r4.setRect(0, 0, parent.cooldown, 5);
//tegn r4 udfyldt
g.fill(r4);
//tegn med sort
g.setPaint(java.awt.Color.BLACK);
//tegn kanten til r4
g.draw(r4);
//sæt tegneudgangspunktet tilbage
g.translate(0, -25);
}
//tegn relativt til midten af liv-måleren
g.translate(225, 33);
//sæt skrifttypen til f2
g.setFont(f2);
//opret et fontmetrics objekt til f2
java.awt.FontMetrics fm = g.getFontMetrics();
//tegn en streng med score og level midt på liv-måleren
g.drawString("Score: "+parent.score+" Level: "+parent.level, -fm.stringWidth("Score: "+parent.score+" : Level: "+parent.level)/2, -fm.getHeight()/2);
//sæt tegneudgangspunkt tilbage
g.translate(-225, -37);
//sæt tegneudgangspunkt tilbage
g.translate(-25, -25);
}
//hvis levelup nedtælleren er i gang
if(parent.levelup > 0){
//få en tilfældig værdi for rotation af teksten
double rot = (Math.random()-0.5)/3;
//hvis der er mindre end 50 frames tilbage af animationen
if(parent.levelup < 50){
//sæt positionen så at teksten i animationen kører op
g.translate(250, 250-(-parent.levelup+50)*5);
}else{
//sæt tegneudgangspunktet midt på skærmen
g.translate(250, 250);
}
//sæt skrifttypen til f1
g.setFont(f1);
//opret et fontmetrics objekt til f1
java.awt.FontMetrics fm = g.getFontMetrics();
//rotér rot grader
g.rotate(rot);
//skriv "LEVEL UP" midt på skærmen
g.drawString("LEVEL UP", -fm.stringWidth("LEVEL UP")/2, -fm.getHeight());
//rotér tilbage
g.rotate(-rot);
//sætter tegneudgangspunktet tilbage
if(parent.levelup < 50){
g.translate(-250, -(250-(-parent.levelup+50)*5));
}else{
g.translate(-250, -250);
}
//går en frame videre i animationen
parent.levelup--;
}
//hvis spillet er helt slut og slutskærmen skal vises (når spillerens position er mere end 2000)
if(parent.p.y > 2000){
//sæt bevægelseshastigheden i y til 0
parent.p.vy = 0;
//sæt positionen til mere end 2000
parent.p.y = 2001;
//tegn hvidt
g.setPaint(java.awt.Color.WHITE);
//tegn rr1 fyldt
g.fill(rr1);
//tegn med sort
g.setPaint(java.awt.Color.BLACK);
//tegn kanten til rr1
g.draw(rr1);
//sætter skrifttypen til f1
g.setFont(f1);
//opretter et fontmetrics objekt
java.awt.FontMetrics fm = g.getFontMetrics();
//tegner strengen "GAME OVER!"
g.drawString("GAME OVER!", 250-fm.stringWidth("GAME OVER!")/2, 175-fm.getHeight()/2);
//tenger ens score
g.drawString(""+parent.score, 250-fm.stringWidth(""+parent.score)/2, 275-fm.getHeight()/2);
//sætter skrifttypen til f2
g.setFont(f2);
//ændrer fm til at tælle for den nye skrifttype
fm = g.getFontMetrics();
//tegner strengen "Final Score:"
g.drawString("Final Score:", 250-fm.stringWidth("final Score:")/2, 220-fm.getHeight()/2);
//tegner strengen "Quit" som står på knappen
g.drawString("Comprar Con Paypal", 250-fm.stringWidth("Quit")/2-75, 345-fm.getHeight()/2);
//tegner kanten til rr2
g.draw(rr2);
}
//hvis spillet er på pause
if(parent.pause){
//sæt farven til hvid
g.setPaint(java.awt.Color.WHITE);
//tegner rr2 udfyldt
g.fill(rr2);
//sætter farven til sort
g.setPaint(java.awt.Color.BLACK);
//tegner kanten på rr2
g.draw(rr2);
//sætter skrifttypen til f2
g.setFont(f2);
//laver et fontmetricsobjekt
java.awt.FontMetrics fm = g.getFontMetrics();
//skriver "pause" på skærmen
g.drawString("Pause", 250-fm.stringWidth("Pause")/2, 345-fm.getHeight()/2);
}
//sætter tegneudgangspunktet til musens position
g.translate(parent.mouse_pos.x, parent.mouse_pos.y);
//sætter stregtype til bs1
g.setStroke(bs1);
//sætter farven til sort
g.setPaint(java.awt.Color.BLACK);
//tegner de to linier til cursoren
g.draw(s1);
g.draw(s2);
}
}
luego por ultimo la clase Main donde colocamos el siguiente codigo:
/*
* Main klassen, holder main metoden som bliver kaldt når programmet starter
*/
public class Main{
public static void main(String[] args){
//opretter en ny JFrame, til vinduet, og giver det titlen "Java spil"
javax.swing.JFrame f = new javax.swing.JFrame("http://javayotros.blogspot.com/");
//sætter vinduet til at kunne ses
f.setVisible(true);
//gør at programmet afslutter når vinduet lukkes
f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);
//sætter at vinduet ikke kan ændre størrelse
f.setResizable(false);
/* transperant cursor script fra http://www.izyt.com/freode/viewcode.php?code=43 */
int[] pixels = new int[16 * 16];
java.awt.Image image = java.awt.Toolkit.getDefaultToolkit().createImage(new java.awt.image.MemoryImageSource(16, 16, pixels, 0, 16));
java.awt.Cursor transparentCursor = java.awt.Toolkit.getDefaultToolkit().createCustomCursor(image, new java.awt.Point(0, 0), "invisiblecursor");
f.setCursor(transparentCursor);
/* end of script */
//sætter layout til borderlayout
f.getContentPane().setLayout(new java.awt.BorderLayout());
//sætter vinduet til hele tiden at være over andre vinduer
f.setAlwaysOnTop(true);
//opretter en ny controller instans med vores frame som argument
new Controller(f);
}
}
ya eso es todo ejecutamos el main y a jugar :) comparta esta entrada por favor ;)
.png "Google-Translate-Spanish to English")
0 Comments