java小游戏之【王者荣耀】

news2024/11/26 4:37:34

首先创建一个新的Java项目命名为“王者荣耀”，并在src下创建两个包分别命名为“com.sxt"、”com.stx.beast",在相应的包中创建所需的类。

代码

package com.sxt;
 
import javax.swing.*;
import java.awt.*;
 
public class Background extends GameObject {
 
    public Background(GameFrame gameFrame) {
		super(gameFrame);
		// TODO Auto-generated constructor stub
	}
 
	Image bg = Toolkit.getDefaultToolkit().getImage("img/Map.jpg");
 
    public void paintSelf(Graphics g){
        g.drawImage(bg,0,0,null);
 
    }
 
	@Override
	public Rectangle getRec() {
		// TODO Auto-generated method stub
		return null;
	}
}
package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
 
import com.sxt.beast.Beast;
 
public class Bullet extends GameObject {
 
	// 发射子弹的游戏元素
	GameObject attacker;
	// 目标
	GameObject target;
	// 攻击力
	int ad;
 
	public Bullet(GameFrame gameFrame, GameObject attacker, GameObject target, int ad, int spd) {
		super(attacker.getX(), attacker.getY(), gameFrame);
		this.attacker = attacker;
		this.target = target;
		setAd(ad);
		setSpd(spd);
		// TODO Auto-generated constructor stub
	}
 
	public Bullet(GameFrame gameFrame, GameObject attacker, GameObject target, int ad, int spd, String img) {
		super(attacker.getX(), attacker.getY(), gameFrame);
		this.attacker = attacker;
		this.target = target;
		setImg(img);
		setAd(ad);
		setSpd(spd);
		// TODO Auto-generated constructor stub
	}
	public Bullet() {
		super();
		// TODO Auto-generated constructor stub
	}
 
	public void move() {
		// 子弹与目标碰撞，子弹消失，目标减血
		if (recIntersectsRec(getRec(), target.getRec())) {
			if (Beast.class.isAssignableFrom(target.getClass())) {
				target.setTarget(gameFrame.player);
				target.setHasTarget(true);
			}
 
			target.setCurrentHp(target.getCurrentHp() - getAd());
			gameFrame.removeList.add(this);
		}
		double dis = getDis(getX(), getY(), target.getX(), target.getY());
		int xSpeed = (int) (getSpd() * (target.getX() - getX()) / dis);
		int ySpeed = (int) (getSpd() * (target.getY() - getY()) / dis);
		setX(getX() + xSpeed);
		setY(getY() + ySpeed);
	}
 
	@Override
	public void paintSelf(Graphics g) {
		// TODO Auto-generated method stub
		g.drawImage(getImg(), getX() - 16, getY() - 16, null);
		if (this.getImg() == null) {
			g.setColor(Color.BLACK);
			g.fillOval(getX() - 5, getY() - 5, 10, 10);
			g.drawRect(getX() - 5, getY() - 5, 10, 10);
		}
		move();
	}
 
	@Override
	public Rectangle getRec() {
		// TODO Auto-generated method stub
		return new Rectangle(getX() - 5, getY() - 5, 10, 10);
	}
 
	/**
	 * @return the ad
	 */
	public int getAd() {
		return ad;
	}
 
	/**
	 * @param ad the ad to set
	 */
	public void setAd(int ad) {
		this.ad = ad;
	}
 
}

 

package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
 
import javax.swing.JButton;
 
public abstract class Champion extends GameObject {
 
	// 移动
	public boolean up, down, left, right;
	// 移动图集
	static String[] imgs = new String[8];
	// 第几张图片
	int moveCount = 1;
	//技能图片
	Image abilityOne;
	Image abilityTwo;
	Image abilityThree;
	//英雄头像
	Image classical;
	//技能冷却时间
	int coolDownTimeOne;
	int coolDownTimeTwo;
	int coolDownTimeThree;
	//三个技能是否处于冷却状态
	boolean coolDownOne = true;
	boolean coolDownTwo = true;
	boolean coolDownThree = true;
	//英雄列表
	ArrayList<Champion> championList = new ArrayList<Champion>();
	
	static {
		for (int i = 1; i < 8; i++) {
			imgs[i] = "img/" + i + ".png";
		}
	}
 
	public Champion(GameFrame gameFrame, int x, int y) {
		super(gameFrame);
		setImg("img/stand.png");
		setX(x);
		setY(y);
		setSpd(75);
		setHp(24000);
		setDis(250);
		setAttackCoolDownTime(100);
		setCurrentHp(getHp());
		championList.add(new ChampionDaji(gameFrame));
		championList.add(new ChampionHouyi(gameFrame));
	}
	
	public Champion(GameFrame gameFrame) {
		// TODO Auto-generated constructor stub
		super(gameFrame);
		setImg("img/stand.png");
		setX(700);
		setY(3800);
		setSpd(75);
		setHp(24000);
		setDis(250);
		setAttackCoolDownTime(100);
		setCurrentHp(getHp());
	}
 
	public void keyPressed(KeyEvent e) {
		int key = e.getKeyCode();
		if (key == KeyEvent.VK_D) {
			right = true;
		}
		if (key == KeyEvent.VK_A) {
			left = true;
		}
		if (key == KeyEvent.VK_W) {
			up = true;
		}
		if (key == KeyEvent.VK_S) {
			down = true;
		}
	}
 
	public void keyReleased(KeyEvent e) {
		int key = e.getKeyCode();
		if (key == KeyEvent.VK_D) {
			right = false;
		}
		if (key == KeyEvent.VK_A) {
			left = false;
		}
		if (key == KeyEvent.VK_W) {
			up = false;
		}
		if (key == KeyEvent.VK_S) {
			down = false;
		}
	}
 
	public void move() {
		if (up) {
			setY(getY() - getSpd());
		}
		if (down) {
			setY(getY() + getSpd());
		}
		if (left) {
			setX(getX() - getSpd());
		}
		if (right) {
			setX(getX() + getSpd());
		}
		if (up || down || left || right) {
			setImg(imgs[moveCount]);
			moveCount++;
			if (moveCount == 8) {
				moveCount = 1;
			}
		} else {
			setImg("img/stand.png");
		}
	}
	
	/**
	 * 添加三个技能按钮
	 * */
	public void addButton() {
		JButton button1 = new JButton();
		button1.setSize(100, 100);
		button1.setLocation(1056, 513);
		button1.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				abilityOne();
			}
		});
		JButton button2 = new JButton();
		button2.setSize(100, 100);
		button2.setLocation(1090, 370);
		button2.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				abilityTwo();
			}
		});
		JButton button3 = new JButton();
		button3.setSize(100, 100);
		button3.setLocation(1220, 300);
		button3.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				abilityThree();
			}
		});
		gameFrame.add(button1);
		gameFrame.add(button2);
		gameFrame.add(button3);
	}
 
	public abstract void abilityOne();
	public abstract void abilityTwo();
	public abstract void abilityThree();
	public abstract void abilityEffect(Graphics g);
	
	@Override
	public void paintSelf(Graphics g) {
		// TODO Auto-generated method stub
		// 生命值为0
		if (getCurrentHp() <= 0) {
			setAlive(false);
			gameFrame.removeList.add(this);
 
		} else {
			// 添加生命值
			addHp(g, 30, 80, 80, 20, Color.GREEN);
			//绘制技能图片
			g.drawImage(abilityOne, getX() + 360, getY() + 180, null);
			g.drawImage(abilityTwo, getX() + 400, getY() + 40, null);
			g.drawImage(abilityThree, getX() + 520, getY() - 30, null);
			// 绘制图片
			g.drawImage(this.getImg(), getX() - 33, getY() - 50, null);
			// 改变画笔颜色
			//g.setColor(Color.GREEN);
			// 绘制中心圆点
			//g.fillOval(getX(), getY(), 10, 10);
			// 绘制矩形边框
			//g.drawRect(getX() - 23, getY() - 50, 60, 120);
			move();
			abilityEffect(g);
		}
	}
 
	@Override
	public Rectangle getRec() {
		// TODO Auto-generated method stub
		return new Rectangle(getX() - 30, getY() - 60, 60, 120);
	}
 
}
package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Polygon;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Random;
 
import com.sxt.beast.Beast;
 
public class ChampionDaji extends Champion {
 
	// 技能是否处于释放状态
	boolean ifAbilityOne = false;
	boolean ifAbilityTwo = false;
	// 鼠标监视器
	MouseMonitor m;
	// 一技能多边形
	Polygon p;
	// 一技能三角函数
	double sin;
	double cos;
	// 一技能已经攻击过的目标
	ArrayList<GameObject> attacked;
	// 一技能移动次数
	int step = 0;
	// 技能二目标
	GameObject abilityTwoTarget;
	// 技能二子弹
	Bullet abilityTwoBullet;
	// 三技能子弹列表
	Bullet[] bulletList = { new Bullet(), new Bullet(), new Bullet(), new Bullet(), new Bullet() };
 
	public ChampionDaji(GameFrame gameFrame) {
		super(gameFrame);
		abilityOne = Toolkit.getDefaultToolkit().getImage("img/abilityOne.jpg");
		abilityTwo = Toolkit.getDefaultToolkit().getImage("img/abilityTwo.jpg");
		abilityThree = Toolkit.getDefaultToolkit().getImage("img/abilityThree.jpg");
		classical = Toolkit.getDefaultToolkit().getImage("img/Classical.jpg");
		// 三个技能冷却时间
		coolDownTimeOne = 6000;
		coolDownTimeTwo = 8000;
		coolDownTimeThree = 8000;
	}
 
	public void exit() {
		this.gameFrame.removeMouseListener(m);
	}
 
	public void abilityOneMove() {
		p.translate((int) (50 * cos), -(int) (50 * sin));
		for (GameObject redObj : gameFrame.objList) {
			// 是红色方小兵 && 发生碰撞 && 没在attacked列表里
			if (redObj instanceof MinionRed && p.intersects(redObj.getRec()) && attacked.indexOf(redObj) == -1) {
				// 小兵扣血，添加到attacked里
				redObj.setCurrentHp(redObj.getCurrentHp() - 400);
				attacked.add(redObj);
			}else if (Beast.class.isAssignableFrom(redObj.getClass()) && p.intersects(redObj.getRec()) && attacked.indexOf(redObj) == -1) {
				redObj.setCurrentHp(redObj.getCurrentHp() - 400);
				attacked.add(redObj);
			}
			
		}
	}
 
	@Override
	public void abilityOne() {
		// TODO Auto-generated method stub
		if (coolDownOne) {
			m = new MouseMonitor();
			p = new Polygon();
			gameFrame.addMouseListener(m);
			attacked = new ArrayList<GameObject>();
		}
	}
 
	@Override
	public void abilityTwo() {
		// TODO Auto-generated method stub
		if (coolDownTwo) {
			boolean find = false;
			for (GameObject redObj : gameFrame.objList) {
				// 是红色小兵 && 距离小于250 && 存活
				if ((redObj instanceof MinionRed || Beast.class.isAssignableFrom(redObj.getClass())) && recIntersectsCir(redObj.getRec(), getX(), getY(), 250)
						&& redObj.isAlive()) {
					// 添加子弹
					abilityTwoBullet = new Bullet(gameFrame, this, redObj, 250, 60, "img/abilityTwoBullet.png");
					gameFrame.objList.add(abilityTwoBullet);
					// 给目标赋值
					abilityTwoTarget = redObj;
					// 释放二技能
					ifAbilityTwo = true;
					find = true;
					break;
				}
			}
			if (find) {
				new AbilityTwoCD().start();
				find = false;
			}
		}
	}
 
	/**
	 * 点击技能三释放技能 先将技能范围内目标储存到targetList里 提前定义五个子弹 技能释放时初始化五个子弹 子弹目标从targetList里随机选择
	 * 如果期间目标死亡，制作一个目标替身，生命值设置为true 子弹与目标或替身碰撞后消失
	 */
	@Override
	public void abilityThree() {
		// TODO Auto-generated method stub
		// 三技能没在冷却状态
		if (coolDownThree) {
			// 创建列表来储存目标
			ArrayList<GameObject> targetList = new ArrayList<GameObject>();
			// 遍历redList
			for (int i = 0; i < gameFrame.objList.size(); i++) {
				GameObject target = gameFrame.objList.get(i);
				// 是红色小兵 && 在技能范围里 && 存活
				if ((target instanceof MinionRed || Beast.class.isAssignableFrom(target.getClass())) && recIntersectsCir(target.getRec(), getX(), getY(), 250)
						&& target.isAlive()) {
					targetList.add(target);
				}
			}
			//找到目标
			if(targetList.size() != 0) {
				//初始化五个子弹，随机攻击列表里的目标
				Random random = new Random();
				int count = 0;
				while(count < 5) {
					int r = random.nextInt(targetList.size());
					if(!targetList.get(r).isAlive()) {
						//目标死亡，制作替身
						GameObject substitute = targetList.get(r);
						substitute.setAlive(true);
						bulletList[count] = new Bullet(gameFrame, this, substitute, 250, 60, "img/abilityTwoBullet.png");
					}else {
						bulletList[count] = new Bullet(gameFrame, this, targetList.get(r), 250, 60, "img/abilityTwoBullet.png");
					}
					count++;
				}
				new AbilityThreeBulletCD().start();
				new AbilityThreeCD().start();
			}
		}
	}
 
	@Override
	public void abilityEffect(Graphics g) {
		// TODO Auto-generated method stub
		if (ifAbilityOne) {
			g.setColor(Color.RED);
			g.fillPolygon(p);
			abilityOneMove();
			step++;
			if (step == 10) {
				step = 0;
				ifAbilityOne = false;
			}
		}
		if (ifAbilityTwo) {
			System.out.println(abilityTwoTarget.beControlled);
			if (abilityTwoBullet.getRec().intersects(abilityTwoTarget.getRec())) {
				new AbilityControllCD().start();
				ifAbilityTwo = false;
			}
		}
	}
 
	// 技能一冷却时间
	class AbilityOneCD extends Thread {
		public void run() {
			// 将技能一设置为冷却状态
			coolDownOne = false;
			// 线程休眠
			try {
				// one来表示一技能冷却时间
				int one = coolDownTimeOne;
				while (one > 0) {
					Thread.sleep(1000);
					System.out.println("一技能冷却时间： " + one / 1000);
					one -= 1000;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将技能一设置为攻击状态
			coolDownOne = true;
			// 线程终止
			this.stop();
		}
	}
 
	// 技能二冷却时间
	class AbilityTwoCD extends Thread {
		public void run() {
			// 将技能二设置为冷却状态
			coolDownTwo = false;
			// 线程休眠
			try {
				// one来表示二技能冷却时间
				int two = coolDownTimeTwo;
				while (two > 0) {
					Thread.sleep(1000);
					System.out.println("二技能冷却时间： " + two / 1000);
					two -= 1000;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将技能二设置为攻击状态
			coolDownTwo = true;
			// 线程终止
			this.stop();
		}
	}
 
	// 技能二控制时间
	class AbilityControllCD extends Thread {
		public void run() {
			abilityTwoTarget.beControlled = true;
			// 线程休眠
			try {
				Thread.sleep(20000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			abilityTwoTarget.beControlled = false;
			this.stop();
		}
 
	}
	// 技能三冷却时间
	class AbilityThreeCD extends Thread {
		public void run() {
			// 将技能三设置为冷却状态
			coolDownThree = false;
			// 线程休眠
			try {
				// three来表示三技能冷却时间
				int three = coolDownTimeThree;
				while (three > 0) {
					Thread.sleep(1000);
					System.out.println("三技能冷却时间： " + three / 1000);
					three -= 1000;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将技能三设置为攻击状态
			coolDownThree = true;
			// 线程终止
			this.stop();
		}
	}
	
	//技能三子弹时间间隔
	class AbilityThreeBulletCD extends Thread{
		public void run() {
			try {
				gameFrame.objList.add(bulletList[0]);
				Thread.sleep(200);
				gameFrame.objList.add(bulletList[1]);
				Thread.sleep(200);
				gameFrame.objList.add(bulletList[2]);
				Thread.sleep(200);
				gameFrame.objList.add(bulletList[3]);
				Thread.sleep(200);
				gameFrame.objList.add(bulletList[4]);
			}catch(Exception e) {
				e.printStackTrace();
			}
			this.stop();
		}
	}
 
	// 鼠标监视器
	private class MouseMonitor extends MouseAdapter {
		@Override
		public void mousePressed(MouseEvent e) {// 当鼠标点击时
			int mouseX = e.getX(), mouseY = e.getY(), playerX = 700, playerY = 350;
			double dis = getDis(mouseX, mouseY, playerX, playerY);
			// 三角函数
			cos = (mouseX - playerX) / dis;
			sin = -(mouseY - playerY) / dis;
			// 坐标差
			int difX = (int) (60 * sin);
			int difY = (int) (60 * cos);
			p.addPoint(getX() - difX, getY() - difY);
			p.addPoint(getX() + difX, getY() + difY);
			p.addPoint(getX() + difX + (int) (20 * cos), getY() + difY - (int) (20 * sin));
			p.addPoint(getX() - difX + (int) (20 * cos), getY() - difY - (int) (20 * sin));
			exit();
			new AbilityOneCD().start();
			ifAbilityOne = true;
		}
	}
}

 

package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Polygon;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
 
import javax.swing.JButton;
 
import com.sxt.beast.Beast;
 
public class ChampionHouyi extends Champion {
 
	// 技能是否处于释放状态
	boolean ifAbilityThree = false;
	boolean ifAbilityTwo = false;
	// 鼠标监视器
	MouseMonitor m;
	MouseMonitorTwo m2;
	// 三技能多边形
	Polygon p;
	// 三技能三角函数
	double sin;
	double cos;
	// 三技能命中的目标
	GameObject abilityThreeTarget;
	// 三技能是否出界
	boolean ifXOutside;
	boolean ifYOutside;
	// 二技能位置
	int X_AbilityTwo;
	int Y_AbilityTwo;
 
	public ChampionHouyi(GameFrame gameFrame) {
		super(gameFrame);
		abilityOne = Toolkit.getDefaultToolkit().getImage("img/HyabilityOne.jpg");
		abilityTwo = Toolkit.getDefaultToolkit().getImage("img/HyabilityTwo.jpg");
		abilityThree = Toolkit.getDefaultToolkit().getImage("img/HyabilityThree.jpg");
		classical = Toolkit.getDefaultToolkit().getImage("img/后羿-辉光之辰.jpg");
		// 三个技能冷却时间
		coolDownTimeOne = 14000;
		coolDownTimeTwo = 10000;
		coolDownTimeThree = 28000;
		// TODO Auto-generated constructor stub
	}
 
	public ChampionHouyi(GameFrame gameFrame, int i, int j) {
		// TODO Auto-generated constructor stub
		super(gameFrame, i, j);
	}
 
	public void exit(MouseAdapter ma) {
		this.gameFrame.removeMouseListener(ma);
	}
 
	public void attack() {
		if (isAttackCoolDown()) {
			ArrayList<GameObject> targets = new ArrayList<GameObject>();// 目标列表，最多三个目标
			for (GameObject redObj : this.gameFrame.redList) {
				if (this.recIntersectsCir(redObj.getRec(), getX() - 250, getY() - 250, 500)) {
					targets.add(redObj);
					if (targets.size() == 3) {
						break;
					}
				}
			}
			for (GameObject beastObj : this.gameFrame.beast.beastList) {
				if (this.recIntersectsCir(beastObj.getRec(), getX() - 250, getY() - 250, 500)) {
					targets.add(beastObj);
					if (targets.size() == 3) {
						break;
					}
				}
			}
			for (int i = 0; i < targets.size(); i++) {
				Bullet bullet;
				if (i == 0) {
					bullet = new Bullet(gameFrame, this, targets.get(i), 400, 50, "img/bullet.gif");
				} else {
					bullet = new Bullet(gameFrame, this, targets.get(i), 200, 50, "img/bullet.gif");
				}
				gameFrame.objList.add(bullet);
			}
			new AttackCD().start();
		}
	}
 
	public void abilityTwoAttack() {
		for (GameObject redObj : this.gameFrame.objList) {
			if (redObj instanceof MinionRed || Beast.class.isAssignableFrom(redObj.getClass())) {
				if (this.recIntersectsCir(redObj.getRec(), X_AbilityTwo - 60, Y_AbilityTwo - 60, 120)) {
					redObj.setCurrentHp(redObj.getCurrentHp() - 400);
				}
				if (this.recIntersectsCir(redObj.getRec(), X_AbilityTwo - 30, Y_AbilityTwo - 30, 60)) {
					redObj.setCurrentHp(redObj.getCurrentHp() - 200);
				}
			}
		}
	}
 
	public void abilityThreeMove() {
		p.translate((int) (50 * cos), -(int) (50 * sin));
		for (GameObject redObj : gameFrame.objList) {
			// 是红色方小兵 && 发生碰撞
			if ((redObj instanceof MinionRed || Beast.class.isAssignableFrom(redObj.getClass()))
					&& p.intersects(redObj.getRec())) {
				// 击中目标后，目标减血并眩晕，多边形消失
				redObj.setCurrentHp(redObj.getCurrentHp() - 400);
				abilityThreeTarget = redObj;
				new AbilityControlCD().start();
				ifAbilityThree = false;
				new AbilityThreeCD().start();
			}
		}
		if (!ifXOutside) {
			for (int x : p.xpoints) {
				if (x < 0 || x >= 5165) {
					ifXOutside = true;
					break;
				}
			}
		}
		if (!ifYOutside) {
			for (int y : p.ypoints) {
				if (y < 0 || y >= 4085) {
					ifYOutside = true;
					break;
				}
			}
		}
	}
 
	/**
	 * 一技能 制作游戏界面攻击按钮的替身 替换攻击按钮 新的攻击按钮事件： 1. 定义目标列表 2. 添加目标，最多添加三个 3.
	 * 目标列表第一个造成400伤害，其余200伤害 4. 持续5秒，结束后替换攻击按钮️
	 */
	@Override
	public void abilityOne() {
		// TODO Auto-generated method stub
		if (coolDownOne) {
			new AbilityOneDuration().start();// 强化普攻持续时间
			new AbilityOneCD().start();
		}
	}
 
	/**
	 * 二技能 先点击按钮释放技能 再点击技能范围内任意位置 之后点击的位置会出现 两个大小不同的圆 在大圆内会受到300伤害 在小圆内受到额外200伤害
	 */
	@Override
	public void abilityTwo() {
		// TODO Auto-generated method stub
		if (coolDownTwo) {
			m2 = new MouseMonitorTwo();
			gameFrame.addMouseListener(m2);
			X_AbilityTwo = 0;
			Y_AbilityTwo = 0;
		}
 
	}
 
	@Override
	public void abilityThree() {
		// TODO Auto-generated method stub
		if (coolDownThree) {
			m = new MouseMonitor();
			p = new Polygon();
			gameFrame.addMouseListener(m);
			ifAbilityThree = true;
			ifXOutside = false;
			ifYOutside = false;
		}
	}
 
	@Override
	public void abilityEffect(Graphics g) {
		// TODO Auto-generated method stub
		if (ifAbilityTwo) {
			System.out.println("222");
			g.setColor(Color.RED);
			g.fillOval(X_AbilityTwo - 60, Y_AbilityTwo - 60, 120, 120);
			g.setColor(Color.BLACK);
			g.fillOval(X_AbilityTwo - 30, Y_AbilityTwo - 30, 60, 60);
			abilityTwoAttack();
			X_AbilityTwo = 0;
			Y_AbilityTwo = 0;
			ifAbilityTwo = false;
			new AbilityTwoCD().start();
		}
		if (ifAbilityThree) {
			System.out.println("333");
			g.setColor(Color.RED);
			g.fillPolygon(p);
			abilityThreeMove();
			// 如果出界，技能释放结束
			if (ifXOutside || ifYOutside) {
				ifAbilityThree = false;
				p = new Polygon();
				new AbilityThreeCD().start();
			}
		}
	}
 
	// 攻击冷却时间
	class AttackCD extends Thread {
		public void run() {
			// 将攻击功能设置为冷却状态
			setAttackCoolDown(false);
			// 线程休眠
			try {
				Thread.sleep(getAttackCoolDownTime());
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将攻击功能设置为攻击状态
			setAttackCoolDown(true);
			// 线程终止
			this.stop();
		}
	}
 
	// 一技能冷却时间
	class AbilityOneCD extends Thread {
		public void run() {
			// 将攻击功能设置为冷却状态
			coolDownOne = false;
			// 休眠
			try {
				// one用来储存冷却时间
				int one = coolDownTimeOne;
				while (coolDownTimeOne > 0) {
					Thread.sleep(1000);
					System.out.println("技能一冷却时间： " + coolDownTimeOne / 1000);
					coolDownTimeOne -= 1000;
				}
				coolDownTimeOne = one;
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将攻击功能解除冷却状态
			coolDownOne = true;
			// 线程终止
			this.stop();
		}
	}
 
	// 技能一持续时间
	class AbilityOneDuration extends Thread {
		public void run() {
			// 制作攻击按钮的替身
			JButton substitute = gameFrame.attackButton;
			gameFrame.remove(gameFrame.attackButton);
 
			JButton button = new JButton();
			button.setSize(130, 132);
			button.setLocation(1150, 430);
			button.addActionListener(new ActionListener() {
				@Override
				public void actionPerformed(ActionEvent e) {
					// 获取到的事件源就是按钮本身
					attack();
				}
			});
			gameFrame.add(button);
			// 休眠
			try {
				Thread.sleep(5000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			gameFrame.remove(button);
			gameFrame.add(substitute);
			// 线程终止
			this.stop();
		}
	}
 
	// 二技能冷却时间
	class AbilityTwoCD extends Thread {
		public void run() {
			// 将二技能设置为冷却状态
			coolDownTwo = false;
			// 休眠
			try {
				int two = coolDownTimeTwo;
				while (coolDownTimeTwo > 0) {
					Thread.sleep(1000);
					System.out.println("技能二冷却时间： " + coolDownTimeTwo / 1000);
					coolDownTimeTwo -= 1000;
				}
				coolDownTimeTwo = two;
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将攻击功能解除冷却状态
			coolDownTwo = true;
			// 线程终止
			this.stop();
		}
	}
 
	// 技能三冷却时间
	class AbilityThreeCD extends Thread {
		public void run() {
			// 将技能三设置为冷却状态
			coolDownThree = false;
			// 线程休眠
			try {
				// three来表示三技能冷却时间
				int three = coolDownTimeThree;
				while (three > 0) {
					Thread.sleep(1000);
					System.out.println("三技能冷却时间： " + three / 1000);
					three -= 1000;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将技能三设置为攻击状态
			coolDownThree = true;
			// 线程终止
			this.stop();
		}
	}
 
	// 技能三控制时间
	class AbilityControlCD extends Thread {
		public void run() {
			abilityThreeTarget.beControlled = true;
			// 线程休眠
			try {
				Thread.sleep(20000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			abilityThreeTarget.beControlled = false;
			this.stop();
		}
 
	}
 
	// 鼠标监视器
	private class MouseMonitorTwo extends MouseAdapter {
		@Override
		public void mousePressed(MouseEvent e) {// 当鼠标点击时
			System.out.println("pressed");
			int mouseX = e.getX(), mouseY = e.getY(), playerX = 700, playerY = 350;
			double dis = getDis(mouseX, mouseY, playerX, playerY);
			if (dis < 250) {
				X_AbilityTwo = e.getX() - playerX + getX();
				Y_AbilityTwo = e.getY() - playerY + getY();
			}
			ifAbilityTwo = true;
			exit(this);
		}
	}
 
	// 鼠标监视器
	private class MouseMonitor extends MouseAdapter {
		@Override
		public void mousePressed(MouseEvent e) {// 当鼠标点击时
			int mouseX = e.getX(), mouseY = e.getY(), playerX = 700, playerY = 350;
			double dis = getDis(mouseX, mouseY, playerX, playerY);
			// 三角函数
			cos = (mouseX - playerX) / dis;
			sin = -(mouseY - playerY) / dis;
			// 坐标差
			int difX = (int) (60 * sin);
			int difY = (int) (60 * cos);
			p.addPoint(getX() - difX, getY() - difY);
			p.addPoint(getX() + difX, getY() + difY);
			p.addPoint(getX() + difX + (int) (20 * cos), getY() + difY - (int) (20 * sin));
			p.addPoint(getX() - difX + (int) (20 * cos), getY() - difY - (int) (20 * sin));
			ifAbilityThree = true;
			exit(this);
		}
	}
 
}

 

package com.sxt;
 
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
import com.sxt.beast.Beast;
 
public class GameFrame extends JFrame {
 
	// 游戏模式 0 选择英雄，1 游戏开始，2 游戏胜利，3 游戏失败
	int state = 0;
	// 窗口尺寸
	private int windowWidth = 1400;
	private int windowHeight = 700;
	// 双缓冲图片
	private Image offScreenImage = null;
	// 攻击图片
	private Image attack = Toolkit.getDefaultToolkit().getImage("img/attack.jpg");
	//游戏胜利失败图片
	private Image gameWin = Toolkit.getDefaultToolkit().getImage("img/gameWin.png");
	private Image gameLose = Toolkit.getDefaultToolkit().getImage("img/gameLose.png");
	// 游戏背景
	Background background = new Background(this);
	// 游戏玩家
	Champion player;
	Champion champion = new ChampionHouyi(this,700,3800);
	// 双方小兵
	MinionBlue mb = new MinionBlue(this);
	MinionRed mr = new MinionRed(this);
	// 防御塔
	Turret turret = new Turret(this);
	//野怪
	public Beast beast = new Beast(this);
	// 攻击按钮
	JButton attackButton;
	// 游戏元素列表
	public ArrayList<GameObject> objList = new ArrayList<GameObject>();
	ArrayList<GameObject> redList = new ArrayList<GameObject>();// 红色方
	ArrayList<GameObject> blueList = new ArrayList<GameObject>();// 蓝色方
	public ArrayList<GameObject> removeList = new ArrayList<GameObject>();// 存放将要删除的元素
 
	public void launch() {
		// 设置尺寸
		setSize(windowWidth, windowHeight);
		// 窗口居中
		setLocationRelativeTo(null);
		// 关闭事件
		setDefaultCloseOperation(3);
		// 用户不能调整窗口大小
		setResizable(false);
		// 标题
		setTitle("王者荣耀");
		// 窗口可见
		setVisible(true);
		// 添加键盘监视器
		this.addKeyListener(new GameFrame.KeyMonitor());
		// 添加游戏元素
		objList.add(background);
		objList.addAll(turret.turretList);
		objList.addAll(beast.beastList);
		blueList.add(turret.turretList.get(0));
		redList.add(turret.turretList.get(4));
 
		/**
		 * 攻击按钮
		 */
		attackButton = new JButton();
		attackButton.setSize(130, 132);
		attackButton.setLocation(1150, 430);
		attackButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				// 按钮事件
				player.attack(redList);
			}
		});
		this.add(attackButton);
 
		while (true) {
			if (state == 1) {
				// 添加小兵
				//mb.createMinion(this, blueList);
				//mr.createMinion(this, redList);
				// 添加防御塔
				turret.addTurret();
			}
			repaint();
			try {
				Thread.sleep(17);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
 
	public void paint(Graphics g) {
		if (offScreenImage == null) {
			offScreenImage = this.createImage(5984, 4452);
		}
		Graphics gImage = offScreenImage.getGraphics();
		if (state == 0) {
			for(int i = 0; i < champion.championList.size(); i++) {
				//添加图片
				Image classical = champion.championList.get(i).classical;
				gImage.drawImage(classical, i*160, 20, null);
				
				//添加按钮
				JButton championButton = new JButton();
				championButton.setSize(150, 150);
				championButton.setLocation(i*150, 0);
				int a = i;
				championButton.addActionListener(new ActionListener() {
					@Override
					public void actionPerformed(ActionEvent e) {
						state = 1;
						player = champion.championList.get(a);
						objList.add(player);
						player.addButton();
					}
				});
				this.add(championButton);
			}
		} else if (state == 1) {
			for (int i = 0; i < objList.size(); i++) {
				objList.get(i).paintSelf(gImage);
			}
			// 绘制攻击图片
			gImage.drawImage(attack, player.getX() + 500, player.getY() + 100, null);
			objList.removeAll(removeList);
		} else if (state == 2) {//游戏胜利
			gImage.drawImage(gameWin, 0, 5, null);
		} else if (state == 3) {//游戏失败
			gImage.drawImage(gameLose, 0, 5, null);
		}
		if (state != 1) {
			g.drawImage(offScreenImage, 0, 0, null);
		} else {
			g.drawImage(offScreenImage, -player.getX() + 700, -player.getY() + 350, null);
		}
		/**
		 * 添加按钮后不能调用键盘事件 因为程序的焦点变成了按钮 this.requestFocus() 把焦点重新改变到游戏界面上
		 */
		this.requestFocus();
	}
 
	// main方法
	public static void main(String[] args) {
		GameFrame gameFrame = new GameFrame();
		gameFrame.launch();
	}
 
	// 键盘事件
	private class KeyMonitor extends KeyAdapter {
		@Override
		public void keyPressed(KeyEvent e) {
			int key = e.getKeyCode();
			player.keyPressed(e);
		}
 
		@Override
		public void keyReleased(KeyEvent e) {
			int key = e.getKeyCode();
			player.keyReleased(e);
		}
	}
}

 

package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.util.ArrayList;
 
import com.sxt.beast.Beast;
 
public abstract class GameObject {
 
	// 坐标
	private int x;
	private int y;
	// 图片
	private Image img;
	// 游戏界面
	public GameFrame gameFrame;
	// 速度
	private int spd;
	// 初始生命值
	private int hp;
	// 当前生命值
	private int currentHp;
	// 攻击目标
	private GameObject target;
	// 是否有目标
	private boolean hasTarget = false;
	// 攻击距离
	private int dis;
	// 攻击时间间隔
	private int attackCoolDownTime;
	// 攻击是否冷却
	private boolean attackCoolDown = true;
	// 是否存活
	private boolean alive = true;
	// 是否被控制
	boolean beControlled = false;
 
	public GameObject(GameFrame gameFrame) {
		this.gameFrame = gameFrame;
	}
 
	public GameObject(int x, int y, GameFrame gameFrame) {
		this.x = x;
		this.y = y;
		this.gameFrame = gameFrame;
	}
 
	public GameObject() {
		// TODO Auto-generated constructor stub
	}
 
	public void addHp(Graphics g, int difX, int difY, int width, int height, Color color) {
		// 绘制外部轮廓
		g.setColor(Color.black);
		g.drawRect(getX() - difX, getY() - difY, width, height);
		// 填充矩形
		g.setColor(color);
		g.fillRect(getX() - difX, getY() - difY, (int) (width * getCurrentHp() / getHp()), height);
	}
 
	public double getDis(int x1, int y1, int x2, int y2) {
		return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
	}
 
	// 矩形矩形碰撞检测
	public boolean recIntersectsRec(Rectangle r1, Rectangle r2) {
		return r1.intersects(r2);
	}
 
	public boolean recIntersectsCir(Rectangle rec, int x, int y, int r) {
		/** 矩形于圆相交： 圆心到至少一个矩形定点的距离小于r */
		if ((getDis(x, y, rec.x, rec.y) < r) || (getDis(x, y, rec.x, rec.y + rec.height) < r)
				|| (getDis(x, y, rec.x + rec.width, rec.y) < r)
				|| (getDis(x, y, rec.x + rec.width, rec.y + rec.height) < r)) {
			return true;
		}
		return false;
	}
 
	// 攻击方法
	public void attack(ArrayList<GameObject> gameObjList) {
		if (hasTarget) {
			// 目标离开范围后寻找新的目标
			if (!recIntersectsCir(target.getRec(), getX(), getY(), getDis())) {
				setHasTarget(false);
			}
			// 目标死亡，寻找新目标
			else if (!target.isAlive()) {
				setHasTarget(false);
			} else if (isAttackCoolDown() && isAlive()) {
				Bullet bullet = null;
				// 防御塔攻击
				if (Turret.class.isAssignableFrom(getClass())) {
					bullet = new Bullet(gameFrame, this, getTarget(), 500, 50);
				}
				// 小兵攻击
				else if (Minion.class.isAssignableFrom(getClass())) {
					bullet = new Bullet(gameFrame, this, getTarget(), 50, 30);
				}
				// 玩家攻击
				else if (this instanceof Champion) {
					bullet = new Bullet(gameFrame, this, getTarget(), 500, 50, "img/bullet.gif");
				}
				gameFrame.objList.add(bullet);
				// 线程开始
				new AttackCD().start();
			}
		} else {
			// 遍历列表
			for (GameObject obj : gameObjList) {
				// 判断攻击范围（圆形）与敌方（矩形）是否相交
				if (recIntersectsCir(obj.getRec(), getX(), getY(), getDis())) {
					// 找到目标
					setTarget(obj);
					setHasTarget(true);
					// 跳出循环
					break;
				}
			}
			// 玩家是否在攻击范围内
			if (!hasTarget && gameObjList == gameFrame.blueList) {
				if (recIntersectsCir(gameFrame.player.getRec(), getX(), getY(), getDis())) {
					// 找到目标
					setTarget(gameFrame.player);
					setHasTarget(true);
				}
			} else {
				for (GameObject obj : gameFrame.beast.beastList) {
					// 判断攻击范围（圆形）与敌方（矩形）是否相交
					if (recIntersectsCir(obj.getRec(), getX(), getY(), getDis())) {
						// 找到目标
						setTarget(obj);
						setHasTarget(true);
						// 跳出循环
						break;
					}
				}
			}
		}
	}
 
	class AttackCD extends Thread {
		public void run() {
			// 将攻击功能设置为冷却状态
			setAttackCoolDown(false);
			// 线程休眠
			try {
				Thread.sleep(attackCoolDownTime);
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将攻击功能设置为攻击状态
			setAttackCoolDown(true);
			// 线程终止
			this.stop();
		}
	}
 
	// 绘制元素
	public abstract void paintSelf(Graphics g);
 
	// 返回矩形
	public abstract Rectangle getRec();
 
	/**
	 * @return the x
	 */
	public int getX() {
		return x;
	}
 
	/**
	 * @param x the x to set
	 */
	public void setX(int x) {
		this.x = x;
	}
 
	/**
	 * @return the y
	 */
	public int getY() {
		return y;
	}
 
	/**
	 * @param y the y to set
	 */
	public void setY(int y) {
		this.y = y;
	}
 
	/**
	 * @return the img
	 */
	public Image getImg() {
		return img;
	}
 
	/**
	 * @param img the img to set
	 */
	public void setImg(String img) {
		this.img = Toolkit.getDefaultToolkit().getImage(img);
	}
 
	/**
	 * @return the spd
	 */
	public int getSpd() {
		return spd;
	}
 
	/**
	 * @param spd the spd to set
	 */
	public void setSpd(int spd) {
		this.spd = spd;
	}
 
	/**
	 * @return the hp
	 */
	public int getHp() {
		return hp;
	}
 
	/**
	 * @param hp the hp to set
	 */
	public void setHp(int hp) {
		this.hp = hp;
	}
 
	/**
	 * @return the currentHp
	 */
	public int getCurrentHp() {
		return currentHp;
	}
 
	/**
	 * @param currentHp the currentHp to set
	 */
	public void setCurrentHp(int currentHp) {
		if (currentHp < getHp()) {
			if (Beast.class.isAssignableFrom(getClass())) {
				System.out.println("yes");
				setTarget(gameFrame.player);
				setHasTarget(true);
			}
		}
		this.currentHp = currentHp;
	}
 
	/**
	 * @return the target
	 */
	public GameObject getTarget() {
		return target;
	}
 
	/**
	 * @param target the target to set
	 */
	public void setTarget(GameObject target) {
		this.target = target;
	}
 
	/**
	 * @return the hasTarget
	 */
	public boolean isHasTarget() {
		return hasTarget;
	}
 
	/**
	 * @param hasTarget the hasTarget to set
	 */
	public void setHasTarget(boolean hasTarget) {
		this.hasTarget = hasTarget;
	}
 
	/**
	 * @return the dis
	 */
	public int getDis() {
		return dis;
	}
 
	/**
	 * @param dis the dis to set
	 */
	public void setDis(int dis) {
		this.dis = dis;
	}
 
	/**
	 * @return the attackCoolDownTime
	 */
	public int getAttackCoolDownTime() {
		return attackCoolDownTime;
	}
 
	/**
	 * @param attackCoolDownTime the attackCoolDownTime to set
	 */
	public void setAttackCoolDownTime(int attackCoolDownTime) {
		this.attackCoolDownTime = attackCoolDownTime;
	}
 
	/**
	 * @return the attackCoolDown
	 */
	public boolean isAttackCoolDown() {
		return attackCoolDown;
	}
 
	/**
	 * @param attackCoolDown the attackCoolDown to set
	 */
	public void setAttackCoolDown(boolean attackCoolDown) {
		this.attackCoolDown = attackCoolDown;
	}
 
	/**
	 * @return the alive
	 */
	public boolean isAlive() {
		return alive;
	}
 
	/**
	 * @param alive the alive to set
	 */
	public void setAlive(boolean alive) {
		this.alive = alive;
	}
}

 

package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.util.ArrayList;
 
public abstract class Minion extends GameObject {
 
	// 是否生成下一个小兵
	private boolean nextMinion = true;
	// 是否生成下一波小兵
	private boolean nextLine = true;
	// 生成小兵数量
	private int minionCount = 0;
	// 是否检测到目标
	private boolean ifFindTarget = false;
 
	public Minion(GameFrame gameFrame) {
		super(gameFrame);
		setHp(800);
		setCurrentHp(getHp());
		setDis(100);
		setAttackCoolDownTime(2000);
		// TODO Auto-generated constructor stub
	}
 
	/**
	 * (1325, 3750) (4425, 3750) (5050, 3125) (5050, 1125)
	 */
 
	public abstract void move(ArrayList<GameObject> objList);
 
	/**
	 * @param x:       下一步的横坐标
	 * @param y:       下一步的纵坐标
	 * @param objList: 小兵列表
	 * @return 下一步位置与其他小兵是否碰撞
	 */
	public boolean hitMinion(int x, int y, ArrayList<GameObject> objList) {
		// 新的区域生成矩形
		Rectangle r = new Rectangle(x - 16, y - 16, 45, 45);
		for (GameObject obj : objList) {
			// 相同类 && 不是自身
			if (obj.getClass() == this.getClass() && obj != this) {
				if (r.intersects(obj.getRec())) {
					return true;
				}
			}
		}
		return false;
	}
 
	public void findTarget(ArrayList<GameObject> objList) {
		for (GameObject obj : objList) {
			if (recIntersectsCir(obj.getRec(), getX(), getY(), 200)) {
				setTarget(obj);
				setIfFindTarget(true);
			}
		}
		if (objList == gameFrame.blueList) {
			if (recIntersectsCir(gameFrame.player.getRec(), getX(), getY(), 200)) {
				setTarget(gameFrame.player);
				setIfFindTarget(true);
			}
		}
	}
 
	public void moveToTarget() {
		double dis = getDis(getX(), getY(), getTarget().getX(), getTarget().getY());
		int xSpeed = (int) (getSpd() * (getTarget().getX() - getX()) / dis);
		int ySpeed = (int) (getSpd() * (getTarget().getY() - getY()) / dis);
		if (!hitMinion(getX() + xSpeed, getY(), gameFrame.objList)) {
			setX(getX() + xSpeed);
		}
		if (!hitMinion(getX(), getY() + ySpeed, gameFrame.objList)) {
			setY(getY() + ySpeed);
		}
	}
 
	public void createMinion(GameFrame gameFrame, ArrayList<GameObject> minionList) {
		if (nextLine) {
			if (nextMinion) {
				// 蓝色方小兵
				if (minionList == this.gameFrame.blueList) {
					MinionBlue mb = new MinionBlue(gameFrame);
					gameFrame.objList.add(mb);
					minionList.add(mb);
				}
				// 红色方小兵
				else {
					MinionRed mr = new MinionRed(gameFrame);
					gameFrame.objList.add(mr);
					minionList.add(mr);
				}
				minionCount++;
				new NextMinion().start();
			}
			if (minionCount == 3) {
				minionCount = 0;
				new NextLine().start();
			}
		}
	}
 
	// 每个小兵生成时间
	class NextMinion extends Thread {
		public void run() {
			nextMinion = false;
			// 休眠1.5s
			try {
				Thread.sleep(1500);
			} catch (Exception e) {
				e.printStackTrace();
			}
			nextMinion = true;
			// 线程终止
			this.stop();
		}
	}
 
	// 每波小兵生成时间
	class NextLine extends Thread {
		public void run() {
			nextLine = false;
			// 休眠15s
			try {
				Thread.sleep(15000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			nextLine = true;
			// 线程终止
			this.stop();
		}
	}
 
	@Override
	public void paintSelf(Graphics g) {
		// TODO Auto-generated method stub
		// 生命值为0
		if (getCurrentHp() <= 0) {
			setAlive(false);
			gameFrame.removeList.add(this);
			if (this instanceof MinionBlue) {
				gameFrame.blueList.remove(this);
			} else {
				gameFrame.redList.remove(this);
			}
		} else {
			// 添加生命值
			if (this instanceof MinionBlue) {
				this.addHp(g, 17, 28, 45, 10, Color.GREEN);
			} else {
				this.addHp(g, 17, 28, 45, 10, Color.RED);
			}
			g.drawImage(getImg(), getX() - 16, getY() - 16, null);
			//绘制检测范围圆形
			//g.setColor(Color.RED);
			//g.fillOval(getX(), getY(), 10, 10);
			//g.drawRect(getX() - 16, getY() - 16, 45, 45);
			// 小兵移动
			if (!beControlled) {
				if (this instanceof MinionBlue) {
					move(gameFrame.redList);
				} else {
					move(gameFrame.blueList);
				}
			}
		}
	}
 
	@Override
	public Rectangle getRec() {
		// TODO Auto-generated method stub
		return new Rectangle(getX() - 16, getY() - 16, 45, 45);
	}
 
	/**
	 * @return the ifFindTarget
	 */
	public boolean isIfFindTarget() {
		return ifFindTarget;
	}
 
	/**
	 * @param ifFindTarget the ifFindTarget to set
	 */
	public void setIfFindTarget(boolean ifFindTarget) {
		this.ifFindTarget = ifFindTarget;
	}
 
}
package com.sxt;
 
import java.util.ArrayList;
 
public class MinionBlue extends Minion {
 
	public MinionBlue(GameFrame gameFrame) {
		super(gameFrame);
		setImg("img/blue.jpg");
		setX(1325);
		setY(3750);
		// TODO Auto-generated constructor stub
	}
 
	@Override
	public void move(ArrayList<GameObject> objList) {
		// TODO Auto-generated method stub
		if (isIfFindTarget()) {
			// 离开检测范围
			if (!recIntersectsCir(getTarget().getRec(), getX(), getY(), 200)) {
				setIfFindTarget(false);
			} else {
				if (!isHasTarget()) {
					moveToTarget();
				}
				attack(objList);
			}
		} else {
			findTarget(objList);
			// 原路线移动
			if (getX() < 4425) {
				setSpd(25);
				if (!hitMinion(getX() + getSpd(), getY(), gameFrame.blueList)) {
					setX(getX() + getSpd());
 
				}
			} else if (getX() < 5100 && getX() >= 4425) {
				setSpd(20);
				if (!hitMinion(getX() + getSpd(), getY(), gameFrame.blueList)) {
					setX(getX() + getSpd());
				}
				if (!hitMinion(getX(), getY() - getSpd(), gameFrame.blueList)) {
					setY(getY() - getSpd());
				}
			} else if (getX() >= 4900) {
				setSpd(18);
				if (!hitMinion(getX(), getY() - getSpd(), gameFrame.blueList)) {
					setY(getY() - getSpd());
				}
			}
		}
	}
}
package com.sxt;
 
import java.util.ArrayList;
 
public class MinionRed extends Minion {
 
	public MinionRed(GameFrame gameFrame) {
		super(gameFrame);
		setImg("img/red.jpg");
		setX(5050);
		setY(1125);
		// TODO Auto-generated constructor stub
	}
 
	@Override
	public void move(ArrayList<GameObject> objList) {
		// TODO Auto-generated method stub
		if (isIfFindTarget()) {
			// 离开检测范围
			if (!recIntersectsCir(getTarget().getRec(), getX(), getY(), 200)) {
				setIfFindTarget(false);
			} else {
				if (!isHasTarget()) {
					moveToTarget();
				}
				attack(objList);
			}
		} else {
			findTarget(objList);
			// 原路线移动
			if (getY() < 3125) {
				setSpd(18);
				if (!hitMinion(getX(), getY() + getSpd(), gameFrame.redList)) {
					setY(getY() + getSpd());
				}
			} else if (getY() < 3750 && getY() >= 3125) {
				setSpd(20);
				if (!hitMinion(getX(), getY() + getSpd(), gameFrame.redList)) {
					setY(getY() + getSpd());
				}
				if (!hitMinion(getX() - getSpd(), getY(), gameFrame.redList)) {
					setX(getX() - getSpd());
				}
			} else if (getY() >= 3750) {
				setSpd(25);
				if (!hitMinion(getX() - getSpd(), getY(), gameFrame.redList)) {
					setX(getX() - getSpd());
				}
			}
		}
	}
 
}
package com.sxt;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.util.ArrayList;
 
public class Turret extends GameObject {
 
	ArrayList<Turret> turretList = new ArrayList<Turret>();
	public Turret turretBlueOne;
	public Turret turretBlueTwo;
	public Turret turretBlueThree;
	public Turret turretBlueBase;
	public Turret turretRedOne;
	public Turret turretRedTwo;
	public Turret turretRedThree;
	public Turret turretRedBase;
 
	public Turret(GameFrame gameFrame) {
		super(gameFrame);
		setImg("img/turret.png");
 
		// 初始化八个防御塔
		turretList.add(turretBlueOne = new TurretBlue(1860, 3790, gameFrame));
		turretList.add(turretBlueTwo = new TurretBlue(2650, 3820, gameFrame));
		turretList.add(turretBlueThree = new TurretBlue(3995, 3830, gameFrame));
		turretList.add(turretBlueBase = new TurretBlue(1130, 3650, gameFrame));
		turretList.add(turretRedOne = new TurretRed(5100, 3030, gameFrame));
		turretList.add(turretRedTwo = new TurretRed(5120, 2100, gameFrame));
		turretList.add(turretRedThree = new TurretRed(5060, 1570, gameFrame));
		turretList.add(turretRedBase = new TurretRed(4850, 1100, gameFrame));
 
		// TODO Auto-generated constructor stub
	}
 
	public Turret(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/turret.png");
		setHp(6000);
		setCurrentHp(getHp());
		setAttackCoolDownTime(1000);
		setDis(300);
	}
	
	public void addTurret() {
		/**
		 * 添加到objList里会被绘制出来，添加到redList和blueList才会被攻击 前一个防御塔爆炸后再把后一个添加到列表里
		 */
		if (!gameFrame.turret.turretBlueOne.isAlive() && gameFrame.turret.turretBlueTwo.isAlive()
				&& gameFrame.blueList.indexOf(gameFrame.turret.turretBlueTwo) == -1) {
			gameFrame.blueList.add(gameFrame.turret.turretBlueTwo);
		}
		if (!gameFrame.turret.turretBlueTwo.isAlive() && gameFrame.turret.turretBlueThree.isAlive()
				&& gameFrame.blueList.indexOf(gameFrame.turret.turretBlueThree) == -1) {
			gameFrame.blueList.add(gameFrame.turret.turretBlueThree);
		}
		if (!gameFrame.turret.turretBlueThree.isAlive() && gameFrame.turret.turretBlueBase.isAlive()
				&& gameFrame.blueList.indexOf(gameFrame.turret.turretBlueBase) == -1) {
			gameFrame.blueList.add(gameFrame.turret.turretBlueBase);
		}
		if (!gameFrame.turret.turretBlueBase.isAlive()) {
			//游戏失败
			gameFrame.state = 3;
		}
 
		if (!gameFrame.turret.turretRedOne.isAlive() && gameFrame.turret.turretRedTwo.isAlive()
				&& gameFrame.redList.indexOf(gameFrame.turret.turretRedTwo) == -1) {
			gameFrame.redList.add(gameFrame.turret.turretRedTwo);
		}
		if (!gameFrame.turret.turretRedTwo.isAlive() && gameFrame.turret.turretRedThree.isAlive()
				&& gameFrame.redList.indexOf(gameFrame.turret.turretRedThree) == -1) {
			gameFrame.redList.add(gameFrame.turret.turretRedThree);
		}
		if (!gameFrame.turret.turretRedThree.isAlive() && gameFrame.turret.turretRedBase.isAlive()
				&& gameFrame.redList.indexOf(gameFrame.turret.turretRedBase) == -1) {
			gameFrame.redList.add(gameFrame.turret.turretRedBase);
		}
		if (!gameFrame.turret.turretRedBase.isAlive()) {
			//游戏胜利
			gameFrame.state = 2;
		}
	}
	
 
	@Override
	public void paintSelf(Graphics g) {
		// 生命值为0
		if (getCurrentHp() <= 0) {
			setAlive(false);
			gameFrame.removeList.add(this);
			if (this instanceof TurretBlue) {
				gameFrame.blueList.remove(this);
			} else {
				gameFrame.redList.remove(this);
			}
		} else {
			// 添加生命值
			if (this instanceof TurretBlue) {
				this.addHp(g, 50, 130, 100, 20, Color.GREEN);
				attack(gameFrame.redList);
			} else {
				this.addHp(g, 50, 130, 100, 20, Color.RED);
				attack(gameFrame.blueList);
			}
			g.drawImage(getImg(), getX() - 50, getY() - 100, null);
			g.drawOval(getX() - 300, getY() - 300, 600, 600);
		}
	}
 
	@Override
	public Rectangle getRec() {
		// TODO Auto-generated method stub
		return new Rectangle(getX() - 50, getY() - 100, 100, 180);
	}
 
}
package com.sxt;
 
public class TurretBlue extends Turret {
 
	public TurretBlue(GameFrame gameFrame) {
		super(gameFrame);
		// TODO Auto-generated constructor stub
	}
	
	public TurretBlue(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
	}
 
}
package com.sxt;
 
public class TurretRed extends Turret {
 
	public TurretRed(GameFrame gameFrame) {
		super(gameFrame);
		// TODO Auto-generated constructor stub
	}
	
	public TurretRed(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
	}
	
}
package com.sxt.beast;
 
import com.sxt.GameFrame;
 
public class Bear extends Beast {
 
	public Bear(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/bear.jpg");
		width = 85;
		height = 112;
		setDis(65);
		// TODO Auto-generated constructor stub
	}
 
}
package com.sxt.beast;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.util.ArrayList;
 
import com.sxt.*;
 
public class Beast extends GameObject {
 
	public ArrayList<Beast> beastList = new ArrayList<Beast>();
	int width;
	int height;
 
	// 初始坐标
	int initialX;
	int initialY;
 
	// 有没有仇恨值
	public boolean isAggressive = false;
 
	// 复活的元素
	Beast beast = null;
 
	public Beast(GameFrame gameFrame) {
		super(gameFrame);
		beastList.add(new RedBuff(3045, 3170, gameFrame));
		beastList.add(new Bear(2800, 2855, gameFrame));
		beastList.add(new Bird(3570, 3380, gameFrame));
		beastList.add(new Xiyi(4585, 2365, gameFrame));
		beastList.add(new BlueBuff(4025, 2295, gameFrame));
		beastList.add(new Wolf(4235, 1945, gameFrame));
	}
 
	public Beast(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setHp(1000);
		setCurrentHp(getHp());
		setSpd(10);
		setAttackCoolDownTime(2000);
		initialX = getX();
		initialY = getY();
		beast = this;
	}
 
	public void moveToTarget() {
		double dis = getDis(getX(), getY(), getTarget().getX(), getTarget().getY());
		if (dis > 500) {
			isAggressive = false;
			setHasTarget(false);
		} else {
			int xSpeed = (int) (getSpd() * (getTarget().getX() - getX()) / dis);
			int ySpeed = (int) (getSpd() * (getTarget().getY() - getY()) / dis);
			setX(getX() + xSpeed);
			setY(getY() + ySpeed);
		}
	}
 
	public void moveToInitialLocation() {
		double dis = getDis(getX(), getY(), initialX, initialY);
		if (dis < getSpd()) {
			setX(initialX);
			setY(initialY);
			isAggressive = true;
		} else {
			int xSpeed = (int) (getSpd() * (initialX - getX()) / dis);
			int ySpeed = (int) (getSpd() * (initialY - getY()) / dis);
			setX(getX() + xSpeed);
			setY(getY() + ySpeed);
		}
	}
 
	/**
	判断有没有目标及野怪的仇恨值（又没有攻击性）
		true，判断是否到攻击范围
			false，向目标移动,若中途离开出生点距离大于300或与目标距离大于400，则不再有攻击性。
			true，发射子弹，线程开始
		false，没有目标，回到出生地，自动回血，再次有攻击性
	*/
	public void move() {
		if (isHasTarget() && isAggressive) {
			if (!recIntersectsCir(getTarget().getRec(), getX(), getY(), getDis())) {
				moveToTarget();
			} else if (isAttackCoolDown() && isAlive()) {
				Bullet bullet = new Bullet(gameFrame, this, getTarget(), 500, 50, "img/bullet.gif");
				gameFrame.objList.add(bullet);
				new AttackCD().start();
			}
		} else {
			moveToInitialLocation();
			if (getCurrentHp() < getHp()) {
				setCurrentHp(getCurrentHp() + 100);
			}
		}
 
	}
 
	@Override
	public void paintSelf(Graphics g) {
		// TODO Auto-generated method stub// 生命值为0
		if (getCurrentHp() <= 0) {
			System.out.println("beast die");
			setAlive(false);
			gameFrame.removeList.add(this);
			gameFrame.beast.beastList.remove(this);
			new ReviveCD().start();
		} else {
			// 添加生命值
			addHp(g, width / 2, 80, width, 20, Color.GREEN);
			g.drawImage(getImg(), getX() - width / 2, getY() - height / 2, null);
			g.setColor(Color.RED);
			g.fillOval(getX(), getY(), 10, 10);
			g.drawOval(getX() - getDis(), getY() - getDis(), 2 * getDis(), 2 * getDis());
			move();
		}
	}
 
	@Override
	public Rectangle getRec() {
		// TODO Auto-generated method stub
		return new Rectangle(getX() - width / 2, getY() - height / 2, width, height);
	}
 
	class AttackCD extends Thread {
		public void run() {
			// 将攻击功能设置为冷却状态
			setAttackCoolDown(false);
			// 线程休眠
			try {
				Thread.sleep(getAttackCoolDownTime());
			} catch (Exception e) {
				e.printStackTrace();
			}
			// 将攻击功能设置为攻击状态
			setAttackCoolDown(true);
			// 线程终止
			this.stop();
		}
	}
 
	class ReviveCD extends Thread {
		public void run() {
			// 线程休眠
			try {
				Thread.sleep(5000);
			} catch (Exception e) {
				e.printStackTrace();
			}
			Beast reviveBeast;
			if (beast instanceof RedBuff) {
				reviveBeast = new RedBuff(3045, 3170, gameFrame);
			} else if (beast instanceof Bear) {
				reviveBeast = new Bear(2800, 2855, gameFrame);
			} else if (beast instanceof Bird) {
				reviveBeast = new Bird(3570, 3380, gameFrame);
			} else if (beast instanceof Xiyi) {
				reviveBeast = new Xiyi(4585, 2365, gameFrame);
			} else if (beast instanceof BlueBuff) {
				reviveBeast = new BlueBuff(4025, 2295, gameFrame);
			} else {
				reviveBeast = new Wolf(4235, 1945, gameFrame);
			}
			gameFrame.objList.add(reviveBeast);
			gameFrame.beast.beastList.add(reviveBeast);
		}
	}
 
}
package com.sxt.beast;
 
import com.sxt.GameFrame;
 
public class Bird extends Beast {
 
	public Bird(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/红隼.jpg");
		width = 122;
		height = 98;
		setDis(125);
		// TODO Auto-generated constructor stub
	}
 
}
package com.sxt.beast;
 
import com.sxt.GameFrame;
 
public class BlueBuff extends Beast {
 
	public BlueBuff(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/blueBuff.jpg");
		width = 142;
		height = 176;
		setDis(70);
		// TODO Auto-generated constructor stub
	}
 
}
package com.sxt.beast;
 
import com.sxt.GameFrame;
 
public class RedBuff extends Beast {
 
	public RedBuff(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/redBuff.jpg");
		width = 103;
		height = 150;
		setDis(70);
		// TODO Auto-generated constructor stub
	}
}
package com.sxt.beast;
 
import com.sxt.GameFrame;
 
public class Wolf extends Beast {
 
	public Wolf(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/wolf.jpg");
		width = 145;
		height = 140;
 
		setDis(65);
		// TODO Auto-generated constructor stub
	}
 
}
package com.sxt.beast;
 
import com.sxt.GameFrame;
 
public class Xiyi extends Beast {
 
	public Xiyi(int x, int y, GameFrame gameFrame) {
		super(x, y, gameFrame);
		setImg("img/蜥蜴.jpg");
		width = 111;
		height = 65;
		setDis(125);
		// TODO Auto-generated constructor stub
	}
}

结果

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1255241.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

以非常规思维去做一个嵌入式音视频开发项目！

以非常规思维去做一个嵌入式音视频开发项目！

前言&#xff1a; 大家好&#xff0c;在上周的文章里面&#xff0c;给大家介绍了一个音视频项目&#xff0c;本周继续来分享音视频项目&#xff0c;之前说过&#xff0c;如果你不知道做什么功能开发嘛&#xff0c;因为接触的少&#xff1b;我突然想到&#xff0c;可以去参考市面…
阅读更多...
win10下载Remix IDE桌面版以及空白页面的解决

win10下载Remix IDE桌面版以及空白页面的解决

文章目录 Remix IDE 的下载Remix IDE 空白页面的解决 Remix IDE 的下载 到 github 地址 https://github.com/ethereum/remix-desktop/releases 选择exe文件或根据自己电脑版本选择对应的zip文件进行下载&#xff0c;然后正常安装即可。 Remix IDE 空白页面的解决 有时打开Remix…
阅读更多...
容器技术——Cgroup

容器技术——Cgroup

目录 容器技术容器技术概述要区分好共享与隔离的概念容器技术的三大核心容器对比虚拟机 namespaceUnionFs容器操作系统的来源操作系统的来源完整操作系统的镜像docker image是什么&#xff1f;如何构成的 如何为容器安装操作系统UnionFS&#xff08;联合文件系统&#xff09;的…
阅读更多...
Echart力引导依赖关系布局图

Echart力引导依赖关系布局图

Echarts ECharts&#xff08;Enterprise Charts&#xff09;Apache ECharts是百度开发的一款开源的 JavaScript 数据可视化库。它提供了丰富的图表和图形&#xff0c;适用于在 Web 应用程序中创建各种交互式和动态的数据可视化图表。ECharts支持各种图表类型&#xff0c;包括折…
阅读更多...
【LeetCode】挑战100天 Day17（热题+面试经典150题）

【LeetCode】挑战100天 Day17（热题+面试经典150题）

【LeetCode】挑战100天 Day17&#xff08;热题面试经典150题&#xff09; 一、LeetCode介绍二、LeetCode 热题 HOT 100-192.1 题目2.2 题解 三、面试经典 150 题-193.1 题目3.2 题解 一、LeetCode介绍 LeetCode是一个在线编程网站&#xff0c;提供各种算法和数据结构的题目&…
阅读更多...
Hugging Face宣布最受欢迎的AI机构，开源模型ChatGLM-6B广受认可

Hugging Face宣布最受欢迎的AI机构，开源模型ChatGLM-6B广受认可

近日&#xff0c;Hugging Face作为开源AI社区的代表&#xff0c;总结了社区最欢迎的前15个公司和机构&#xff0c;几乎囊括了全部国内外风头正盛的AI科技机构&#xff0c;Stability AI、Meta AI、Runway占据排名前三&#xff0c;大众熟知的OpenAI、谷歌、微软也榜上有名。 其中…
阅读更多...
算法通关村-----字符串冲刺题

算法通关村-----字符串冲刺题

最长公共前缀 问题描述 编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀&#xff0c;返回空字符串 “”。详见leetcode14 问题分析 直观上来看&#xff0c;有竖直和水平两种方式&#xff0c;竖直方式是指我们依次比较所有字符串的第一个字符&#xff0c;…
阅读更多...
数据库基础教程之序列自增设置（三）

数据库基础教程之序列自增设置（三）

点击public来选择一个模式。 选择其他-》序列。 选择新建序列。 设置序列参数&#xff08;最大值不超过2的63次方-1&#xff09;。 点击保存。 刷新序列列表&#xff0c;可以看见新建序列。 设置主键自增 打开设计表-》选中字段-》默认值设置为&#xff1a;nextval(‘log_text’…
阅读更多...
2024年最新最全的Jmeter接口测试必会知识点：jmeter连接数据库

2024年最新最全的Jmeter接口测试必会知识点：jmeter连接数据库

jmeter连接mysql数据库 大致步骤如下&#xff1a; 1、下载mysql的jar包放入到jmeter的lib下&#xff0c;然后重启jmeter 2、配置JDBC Connection Configuration 3、配置JDBC Request 4、在请求中引用查询到的结果变量&#xff0c;可以结合计数器取每一个结果值&#xff1a…
阅读更多...
【代码随想录刷题】Day18 二叉树05

【代码随想录刷题】Day18 二叉树05

文章目录 1.【513】找树左下角的值1.1题目描述1.2 解题思路1.2.1 迭代法思路1.2.2 递归法思路 1.3 java代码实现1.3.1 迭代法java代码实现1.3.2 递归法java代码实现 2. 【112】路径总和2.1题目描述2.2 解题思路2.3 java代码实现 3.【106】从中序与后序遍历序列构造二叉树3.1题目…
阅读更多...
04:2440---内存控制器

04:2440---内存控制器

目录 一:介绍 1:引入 2:概念 3:通信 A:片选信号 B:片选信号的地址空间范围 ​​​​ 4:地址线 A:不同位数的接法 B:访问原理 C:访问地址 5:时序 1:NOR FLASH A:2440NOR FLASH时序 B:原理/时序图 C:寄存器 6:SDARM A:访问方式 B:原理图 C:BWSCON D:BANKCON…
阅读更多...
DDD落地：从阿里单据系统，看DDD在大厂如何落地？

DDD落地：从阿里单据系统，看DDD在大厂如何落地？

尼恩说在前面 在40岁老架构师 尼恩的读者交流群(50)中&#xff0c;最近有小伙伴拿到了一线互联网企业如阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试资格&#xff0c;遇到很多很重要的面试题&#xff1a; 谈谈你的DDD落地经验&#xff1f; 谈谈你对DDD的理解&#x…
阅读更多...
Android系统新特性——功耗的改进

Android系统新特性——功耗的改进

移动设备的续航时间无疑是所有用户都非常在意的。我们都希望自己的手机一次充电可以使用更长的时间。但遗憾的是&#xff0c;近几年移动设备的电池元件一直没有重大的技术突破。并且&#xff0c;随着硬件性能的提升却带来了更多的电量消耗。 如果对比近几年的Android和ios手机&…
阅读更多...
关于反射、枚举以及Lambda表达式你了解多少呢？快来看看吧~

关于反射、枚举以及Lambda表达式你了解多少呢？快来看看吧~

目录 1、反射 1.1、定义 1.2、用途 1.3、反射基本信息 1.4、反射相关的类【重点】 1.5、Class类&#xff08;反射机制的起源&#xff09; 1.6、Class类中相关的方法 1.7、获得Class对象的三种方式 1.8、反射的使用 1.9、反射的优点、缺点 2、枚举 2.1、背景及定义 …
阅读更多...
docker基础学习笔记

docker基础学习笔记

文章目录 Docker简介Linux下安装DockerDocker常用命令Docker网络Docker存储docker-composedockerfile制作镜像私有仓库镜像导入导出参考 Docker简介 定义&#xff1a;Docker是一个开源的应用容器引擎优势&#xff1a; 一键部署&#xff0c;开箱即用&#xff1a;容器使用基于im…
阅读更多...
二次创作Z01语言

二次创作Z01语言

目录 一&#xff0c;字符集 二&#xff0c;编译分词 三&#xff0c;token含义 四&#xff0c;Z01翻译成C 五&#xff0c;执行翻译后的代码 六&#xff0c;打印Hello World! 一&#xff0c;字符集 假设有门语言叫Z01语言&#xff0c;代码中只有0和1这两种字符。 二&#…
阅读更多...
大数据基础 HDFS客户端操作

大数据基础 HDFS客户端操作

一、Maven概述 Maven是一个专门用于管理和构建Java项目的工具。我们之所以要使用Maven&#xff0c;是因为Maven可以为我们提供一套标准化的项目结构、一套标准化的构建流程和一套方便的依赖管理机制&#xff0c;这些功能可以使得我们的项目结构更加清晰&#xff0c;导入jar包的…
阅读更多...
WebUI自动化学习(Selenium+Python+Pytest框架)001

WebUI自动化学习(Selenium+Python+Pytest框架)001

开启另一篇学习之路_WebUI自动化 先来一波基础概念 1.自动化适合什么类型的项目: 重复性高,迭代频率高的回归测试。数据量大、手工难以实现的压力测试&#xff0c;手工执行效率低的兼容测试 2.自动化的优点: 高效率、可重复、减少人为错误、克服手工测试的局限性 3.自动化…
阅读更多...
（离散数学）命题逻辑推理二：间接推理

（离散数学）命题逻辑推理二：间接推理

阅读更多...
电子学会C/C++编程等级考试2021年03月（三级）真题解析

电子学会C/C++编程等级考试2021年03月（三级）真题解析

C/C++等级考试（1~8级）全部真题・点这里 第1题：找和为K的两个元素 在一个长度为n(n < 1000)的整数序列中，判断是否存在某两个元素之和为k。 时间限制：1000 内存限制：65536输入 第一行输入序列的长度n和k，用空格分开。 第二行输入序列中的n个整数，用空格分开。输出 如…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023