Guerre d'avion
Préface
L'apprentissage de Java est arrivé au stade du filetage. Ensuite, résumons comment tirer à la main un jeu de guerre d'avion fileté
À ce stade, nous devons penser de manière systématique. Pour créer un jeu comme celui-ci, de quoi avons-nous besoin et quel est notre ordre.
Empruntez d'abord une photo pour jeter un œil à nos idées de design.
Sans plus tarder, j'ai commencé.
Nous avons remarqué que c'était un avion ennemi ou une balle, etc.Objet volant, Ensuite, nous pouvons utiliserMéthode héritée, Écrivez-en unSuperclasse d'objets volants, Les sous-classes d'autres objets volants en héritent plus tard, puis remplacent les méthodes à l'intérieur.
Classe parent FlyingObject
Si vous souhaitez concevoir une classe qui contient une méthode membre spéciale, l'implémentation spécifique de la méthode est déterminée par ses sous-classes, vous pouvez alors déclarer la méthode en tant que méthode abstraite dans la classe parente.
Le mot clé Abstract peut également être utilisé pour déclarer des méthodes abstraites. Une méthode abstraite contient uniquement un nom de méthode et aucun corps de méthode.
La méthode de vol de l'objet volant ici peut être différente du jugement transfrontalier, mais les règles de collision sont les mêmes, nous avons donc écrit deux méthodes abstraites.
public abstract class FlyingObject {
protected BufferedImage image;// 图片命名--java包自有的
protected int width; // 宽
protected int height; // 高
protected int x; // x坐标
protected int y; // y坐标
// 飞行方法
public abstract void step();
// 越界方法
public abstract boolean outOfBounds();
// 敌人被子弹撞，传入Bullet类的对象，获取子弹的x,y坐标
public boolean shootBy(Bullet bullet) {
// this:敌人 other：子弹
int x1 = this.x;
int x2 = this.x + this.width;
int y1 = this.y;
int y2 = this.y + this.height;
int x = bullet.x;
int y = bullet.y;
//矩形检测原理
return x > x1 && x < x2 && y > y1 && y < y2;
}
}
Dans notre jeu, nous avons le principe de notation et le principe de récompense, nous devons donc écrire une méthode qui peut être utilisée dans toutes les classes, similaire à notre écouteur de souris, ici nous utiliseronsInterface
Interface ennemie
//攻击敌人得分
public interface Enemy {
public int getScore();
}
Interface de récompense
//l击中特殊飞行物获得奖励
public interface Award {
public static final int DOUBLE_FIRE = 0; // int DOUBLE_FIRE = 0;
public static final int LIFE = 1; // int LIFE = 1;
// 获取奖励方法
public int getType();
}
AirPlane (ennemi)
Ici nous héritonsFlyingObjectLa classe parente, et utilisons ce que nous définissonsEnnemiInterface
public class AirPlane extends FlyingObject implements Enemy {
private int speed = 2;// 敌机走步的步数
//构造方法，实例化类的时候自动调用
public AirPlane() {
image = ShootGame.airplane;
width = image.getWidth();
height = image.getHeight();
Random rand = new Random();
x = rand.nextInt(ShootGame.WIDTH - this.width);
y = -this.height; // y:负的敌机的高
}
// 重写 getScore();
public int getScore() {
return 5;
}
//重写飞行方法
public void step() {
y += speed;
}
//重写越界方法
public boolean outOfBounds() {
return this.y > ShootGame.HEIGHT; // 敌机的y坐标大于窗口的高
}
}
Abeille (objets volants spéciaux)
Ici nous héritonsFlyingObjectLa classe parente, et utilisons ce que nous définissonsPrixInterface
//Bee也是飞行物，击中能获取奖励，并且飞行轨迹不定
public class Bee extends FlyingObject implements Award {
private int xSpeed = 1; // x坐标走步步数
private int ySpeed = 2; // y坐标走步步数
private int awardType; // 奖励类型
//构造器，实例化类时调用
public Bee() {
image = ShootGame.bee;
width = image.getWidth();
height = image.getHeight();
Random rand = new Random();
x = rand.nextInt(ShootGame.WIDTH - this.width);
y = -this.height;
awardType = rand.nextInt(2);// 随机生成奖励类型
}
//重写获取奖励方法
public int getType() {
return awardType;
}
//重写飞行方法
public void step() {
if (x >= ShootGame.WIDTH - this.width) {
xSpeed = -1;
}
if (x <= 0) {
xSpeed = 1;
}
x += xSpeed;
y += ySpeed;
}
//重写越界方法
public boolean outOfBounds() {
return this.y > ShootGame.HEIGHT;
}
}
Classe de balle (puce)
Ici nous héritonsFlyingObjectClasse parent
public class Bullet extends FlyingObject{
//子弹走步步数，只有y坐标在变,x发射以后不再改变
private int speed = 3;
public Bullet(int x,int y){//子弹的坐标随着英雄机的变化而变化
image = ShootGame.bullet;
width = image.getWidth();
height = image.getHeight();
this.x = x;
this.y = y;
}
//重写飞行方法
public void step(){
y -= speed;
}
//重写越界方法
public boolean outOfBounds(){
return this.y < -this.height;
}
}
Cours de héros (ma machine)
Ici nous héritonsFlyingObjectClasse parent
//英雄机是飞行物
public class Hero extends FlyingObject {
private int life; // 命
private int doubleFire; // 火力值
private BufferedImage[] images; // 图片数组
private int index; // 协助图片切换
public Hero() {
image = ShootGame.hero0;
width = image.getWidth();
height = image.getHeight();
x = 150;
y = 400;
life = 3; // 3条命
doubleFire = 0; // 单倍火力
images = new BufferedImage[] { ShootGame.hero0, ShootGame.hero1 };
index = 0;
}
public void step() {
// 每100毫秒切一次,动态感出现
image = images[index++ / 10 % images.length];
}
public Bullet[] shoot() {
int xStep = this.width / 4;
if (doubleFire > 0) { // 双发
Bullet[] bullets = new Bullet[2];
bullets[0] = new Bullet(this.x + 1 * xStep, this.y - 20);
bullets[1] = new Bullet(this.x + 3 * xStep, this.y - 20);
doubleFire -= 2; // 发射双倍火力，每次减2，实际就是2倍火力的持续时间
return bullets;
} else { // 单发
Bullet[] bullets = new Bullet[1];
bullets[0] = new Bullet(this.x + 2 * xStep, this.y - 20);
return bullets;
}
}
//飞机随鼠标位置移动
public void moveTo(int x, int y) {
this.x = x - this.width / 2;
this.y = y - this.height / 2;
}
public boolean outOfBounds() {
return false; // 英雄机永不越界
}
// 加命
public void addLife() {
life++;
}
// 获取命
public int getLife() {
return life;
}
public void addDoubleFire() {
doubleFire += 40;
}
// 活力值清零
public void setDoubleFire(int doubleFire) {
this.doubleFire = doubleFire;
}
// 英雄机撞敌人
public boolean hit(FlyingObject other) {
int x1 = other.x - this.width / 2;
int x2 = other.x + other.width + this.width / 2;
int y1 = other.y - this.height / 2;
int y2 = other.y + other.height + this.height / 2;
int hx = this.x + this.width / 2;
int hy = this.y + this.height / 2;
return hx > x1 && hx < x2 && hy > y1 && hy < y2;
}
// 减命
public void subtractLife() {
life--;
}
}
Ce qui précède est notre classe de base et notre interface. Après avoir terminé les préparatifs ci-dessus, nous pouvons dire que notre jeu a été complété par plus de la moitié. Ensuite, nous n'avons qu'à compléter nos règles de tir et notre interface de jeu. Mettez-le dans (2) et mettez d'abord la capture d'écran.
