public static boolean attackAUnit(Unit attackUnit,Unit defenseUnit,boolean isAttackingSupportLine,boolean isAttackAtSupportLine) {
if(attackUnit.getUnitType() == HQ) {
return false;
}
if(defenseUnit.isSmoke()) {
return false; // 烟幕单位不可以被攻击
}
if(defenseUnit.getBelongs() == attackUnit.getBelongs()) {
return false; // 不可攻击自己的单位
}
if(attackUnit.pinned > 0) {
return false; // 被压制的单位不能攻击
}
if(!attackUnit.isBlitz() && attackUnit.deployed) {
return false; // 非闪击单位不能部署后立即攻击
}
if((attackUnit.isFury() && attackUnit.attacked == 2) || (!attackUnit.isFury() && attackUnit.attacked == 1)) {
return false; // 奋战单位一回合不能攻击超过2次，非奋战单位一回合不能攻击超过1次
}
if(attackUnit.getUnitType() == Artillery) { // 除烟幕属性外，火炮可以攻击任意目标且不被反击
if(isAttackingSupportLine) {
if(currentTurn != PLAYER1) {
defenseUnit.defense -= (attackUnit.attack - defenseUnit.getHeavyArmour());
if(defenseUnit.defense < 1) {
player1SupportLine.remove(defenseUnit);
}
}else if(currentTurn != PLAYER2) {
defenseUnit.defense -= (attackUnit.attack - defenseUnit.getHeavyArmour());
if(defenseUnit.defense < 1) {
player2SupportLine.remove(defenseUnit);
}
}else{
return false;
}
}else{
defenseUnit.defense -= (attackUnit.attack - defenseUnit.getHeavyArmour());
if(defenseUnit.defense < 1) {
frontLine.remove(defenseUnit);
if(frontLine.isEmpty()) {
frontLineControl = NOPLAYER;
}
}
}
++attackUnit.attacked; // 攻击计数加一
return true; // 攻击成功
}
if(attackUnit.getUnitType() == Boomber) { // 只要同一阵线不存在战斗机即可以攻击任意单位无视单位属性
if(isAttackingSupportLine) {
if(currentTurn != PLAYER1) {
if(hasFighter(player1SupportLine)) {
if(defenseUnit.getUnitType() != Fighter) {
return false; // 支援阵线有战斗机时，轰炸机不可以攻击非战斗机单位
}
}
}else if(currentTurn != PLAYER2) {
if(hasFighter(player2SupportLine)) {
if(defenseUnit.getUnitType() != Fighter) {
return false; // 支援阵线有战斗机时，轰炸机不可以攻击非战斗机单位
}
}
}else{
return false;
}
}else{
if(hasFighter(frontLine)) {
if(defenseUnit.getUnitType() != Fighter) {
return false; // 前线有战斗机时，轰炸机不可以攻击非战斗机单位
}
}
}
}
if(!defenseUnit.isGuard() && attackUnit.getUnitType() != Boomber) { // 守护属性战斗机不适用于本算法
if(isAttackingSupportLine) {
if(currentTurn != PLAYER1) {
int defenseUnitIndex = player1SupportLine.indexOf(defenseUnit);
if(defenseUnitIndex == 0) { // 支援阵线最左侧的单位
if(player1SupportLine.size() > 1) {
if(player1SupportLine.get(1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}else if(defenseUnitIndex == player1SupportLine.size()-1) { // 支援阵线最右侧的单位
if(player1SupportLine.size() > 1) {
if(player1SupportLine.get(defenseUnitIndex-1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}else { // 支援阵线中间的单位
if(player1SupportLine.get(defenseUnitIndex-1).isGuard() || player1SupportLine.get(defenseUnitIndex+1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}else if(currentTurn != PLAYER2) {
int defenseUnitIndex = player2SupportLine.indexOf(defenseUnit);
if(defenseUnitIndex == 0) { // 支援阵线最左侧的单位
if(player2SupportLine.size() > 1) {
if(player2SupportLine.get(1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}else if(defenseUnitIndex == player2SupportLine.size()-1) { // 支援阵线最右侧的单位
if(player2SupportLine.size() > 1) {
if(player2SupportLine.get(defenseUnitIndex-1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}else { // 支援阵线中间的单位
if(player2SupportLine.get(defenseUnitIndex-1).isGuard() || player1SupportLine.get(defenseUnitIndex+1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}else{
return false;
}
}else{
int defenseUnitIndex = frontLine.indexOf(defenseUnit);
if(defenseUnitIndex == 0) { // 前线最左侧的单位
if(frontLine.get(1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}else if(defenseUnitIndex == frontLine.size()-1) { // 前线最右侧的单位
if(player2SupportLine.get(defenseUnitIndex-1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}else { // 前线中间的单位
if(player2SupportLine.get(defenseUnitIndex-1).isGuard() || player1SupportLine.get(defenseUnitIndex+1).isGuard()) {
return false; // 非火炮轰炸机单位不可以攻击本身没有守卫属性但相邻有守卫属性的单位
}
}
}
}
if((isAttackingSupportLine && isAttackAtSupportLine) && (attackUnit.getUnitType() == Infantry || attackUnit.getUnitType() == Armour)) {
return false; // 在支援阵线的步兵和装甲单位不能攻击对方支援阵线
}
if(attackUnit.moved && attackUnit.getUnitType() != Armour) {
return false; // 非装甲单位移动后不可以攻击
}
if(isAttackingSupportLine) {
if(currentTurn != PLAYER1) {
defenseUnit.defense -= (attackUnit.attack - defenseUnit.getHeavyArmour());
if(attackUnit.getUnitType() != Boomber) {
if(defenseUnit.getUnitType() != Boomber) {
attackUnit.defense -= (defenseUnit.attack - attackUnit.getHeavyArmour()); // 非轰炸机单位进攻会被反击,轰炸机不会反击
}
}else{
if(defenseUnit.getUnitType() == Fighter) {
attackUnit.defense -= (defenseUnit.attack - attackUnit.getHeavyArmour()); // 轰炸机会被战斗机反击
}
}
if(defenseUnit.defense < 1) {
player1SupportLine.remove(defenseUnit);
}
if(attackUnit.defense < 1) {
if(isAttackAtSupportLine) {
player2SupportLine.remove(attackUnit);
}else{
frontLine.remove(attackUnit);
if(frontLine.isEmpty()) {
frontLineControl = NOPLAYER;
}
}
}
}else if(currentTurn != PLAYER2) {
defenseUnit.defense -= (attackUnit.attack - defenseUnit.getHeavyArmour());
if(attackUnit.getUnitType() != Boomber) {
if(defenseUnit.getUnitType() != Boomber) {
attackUnit.defense -= (defenseUnit.attack - attackUnit.getHeavyArmour()); // 非轰炸机单位进攻会被反击,轰炸机不会反击
}
}else{
if(defenseUnit.getUnitType() == Fighter) {
attackUnit.defense -= (defenseUnit.attack - attackUnit.getHeavyArmour()); // 轰炸机会被战斗机反击
}
}
if(defenseUnit.defense < 1) {
player2SupportLine.remove(defenseUnit);
}
if(attackUnit.defense < 1) {
if(isAttackAtSupportLine) {
player1SupportLine.remove(attackUnit);
}else{
frontLine.remove(attackUnit);
if(frontLine.isEmpty()) {
frontLineControl = NOPLAYER;
}
}
}
}else{
return false;
}
}else{
defenseUnit.defense -= (attackUnit.attack - defenseUnit.getHeavyArmour());
if(attackUnit.getUnitType() != Boomber) {
if(defenseUnit.getUnitType() != Boomber) {
attackUnit.defense -= (defenseUnit.attack - attackUnit.getHeavyArmour()); // 非轰炸机单位进攻会被反击,轰炸机不会反击
}
}else{
if(defenseUnit.getUnitType() == Fighter) {
attackUnit.defense -= (defenseUnit.attack - attackUnit.getHeavyArmour()); // 轰炸机会被战斗机反击
}
}
if(defenseUnit.defense < 1) {
frontLine.remove(defenseUnit);
}
if(attackUnit.defense < 1) {
if(currentTurn == PLAYER1) {
player1SupportLine.remove(attackUnit);
}else if (currentTurn == PLAYER2) {
player2SupportLine.remove(attackUnit);
}else{
return false;
}
}
}
++attackUnit.attacked; // 攻击计数加一
return true; // 攻击成功
}
这只是一个java函数，来描述场上单位的进攻行为，如果不能进攻则返回false并且不会造成任何数值上的改变，
想要完整的工程文件的可以来找我。
下列是测试代码
public class TestMain implements UnitType,BattleFieldSize{
public static void main(String[] args) {
// TODO Auto-generated method stub
boolean [] results = new boolean [100];
BattleField.init();
BattleField.startTurn();
BattleField.deployAUnit(Unit.createUnit(10, 10, 0, Infantry, true, true, true, true, true, null, BattleField.currentTurn), BattleField.currentTurn);
BattleField.deployAUnit(Unit.createUnit(8, 8, 2, Armour, false, false, false, false, false, null, BattleField.currentTurn), BattleField.currentTurn);
BattleField.deployAUnit(Unit.createUnit(1, 2, 0, Fighter, false, false, false, false, false, null, BattleField.currentTurn), BattleField.currentTurn);
results[0] = BattleField.attackAUnit(BattleField.player1SupportLine.get(3), BattleField.player2SupportLine.get(0), true, true);
BattleField.player1SupportLine.get(3).setBlitz();
BattleField.player1SupportLine.get(3).defense += 20; // 指令：光辉的时刻
results[1] = BattleField.attackAUnit(BattleField.player1SupportLine.get(3), BattleField.player2SupportLine.get(0), true, true);
results[2] = BattleField.attackAUnit(BattleField.player1SupportLine.get(3), BattleField.player2SupportLine.get(0), true, true);
BattleField.player1SupportLine.get(3).setFury();
BattleField.player1SupportLine.get(3).attack += 1; // 指令：火力爆发
results[3] = BattleField.attackAUnit(BattleField.player1SupportLine.get(3), BattleField.player2SupportLine.get(0), true, true);
results[4] = BattleField.attackAUnit(BattleField.player1SupportLine.get(3), BattleField.player2SupportLine.get(0), true, true);
System.out.println(BattleField.player2SupportLine.get(0).defense);
BattleField.player1SupportLine.get(3).removeFury();
BattleField.endTurn();
BattleField.startTurn();
BattleField.deployAUnit(Unit.createUnit(2, 1, 0, Infantry, false, false, false, false, true, null, BattleField.currentTurn), BattleField.currentTurn);
BattleField.deployAUnit(Unit.createUnit(2, 3, 0, Artillery, false, false, true, false, true, null, BattleField.currentTurn), BattleField.currentTurn);
BattleField.deployAUnit(Unit.createUnit(5, 4, 0, Fighter, false, false, false, false, true, null, BattleField.currentTurn), BattleField.currentTurn);
BattleField.deployAUnit(Unit.createUnit(3, 2, 0, Boomber, false, false, false, false, true, null, BattleField.currentTurn), BattleField.currentTurn);
results[5] = BattleField.attackAUnit(BattleField.player2SupportLine.get(1), BattleField.player1SupportLine.get(3), true, true);
BattleField.moveAUnit(BattleField.player2SupportLine.get(1), 0, BattleField.currentTurn);
results[6] = BattleField.attackAUnit(BattleField.frontLine.get(0), BattleField.player1SupportLine.get(0), true, false);
results[7] = BattleField.attackAUnit(BattleField.frontLine.get(0), BattleField.player1SupportLine.get(1), true, false);
results[8] = BattleField.attackAUnit(BattleField.frontLine.get(0), BattleField.player1SupportLine.get(2), true, false);
results[9] = BattleField.attackAUnit(BattleField.frontLine.get(0), BattleField.player1SupportLine.get(3), true, false);
results[10] = BattleField.attackAUnit(BattleField.player2SupportLine.get(1), BattleField.player1SupportLine.get(0), true, true);
results[11] = BattleField.attackAUnit(BattleField.player2SupportLine.get(1), BattleField.player1SupportLine.get(1), true, true);
results[12] = BattleField.attackAUnit(BattleField.player2SupportLine.get(1), BattleField.player1SupportLine.get(2), true, true);
results[13] = BattleField.attackAUnit(BattleField.player2SupportLine.get(1), BattleField.player1SupportLine.get(3), true, true);
results[14] = BattleField.attackAUnit(BattleField.player2SupportLine.get(2), BattleField.player1SupportLine.get(0), true, true);
results[15] = BattleField.attackAUnit(BattleField.player2SupportLine.get(2), BattleField.player1SupportLine.get(1), true, true);
results[16] = BattleField.attackAUnit(BattleField.player2SupportLine.get(2), BattleField.player1SupportLine.get(2), true, true);
results[17] = BattleField.attackAUnit(BattleField.player2SupportLine.get(2), BattleField.player1SupportLine.get(3), true, true);
results[18] = BattleField.attackAUnit(BattleField.player2SupportLine.get(3), BattleField.player1SupportLine.get(0), true, true);
results[19] = BattleField.attackAUnit(BattleField.player2SupportLine.get(3), BattleField.player1SupportLine.get(1), true, true);
results[20] = BattleField.attackAUnit(BattleField.player2SupportLine.get(3), BattleField.player1SupportLine.get(2), true, true);
results[21] = BattleField.attackAUnit(BattleField.player2SupportLine.get(3), BattleField.player1SupportLine.get(3), true, true);
for (int i = 0; i < 22; i++) {
System.out.println(results[i]);
}
}
}
都测试了什么呢，首先玩家1开始了回合，部署了1个10/10守卫烟幕（全属性）的步兵单位在基地右边，然后又部署了1个8/8重甲2的白板坦克，又部署了1个1/2的白板战斗机，这时候测试战斗机能不能攻击敌方基地，发现不可以，然后给这个白板战斗机加上闪击属性和20点血，测试后可以攻击敌方基地，然后再次实验可以不可以攻击敌方基地，发现不可以，于是给他加上了奋战属性和+1攻击力，然后再次攻击就又成功了。第4次尝试攻击的时候依然是失败，玩家1结束了他的回合。
玩家2开始了回合，部署了1个2/1闪击步兵，2/3 闪击奋战火炮，5/4闪击飞机， 3/2闪击轰炸机，然后2/1步兵尝试攻击玩家1的2/22战斗机，因为不在前线不能攻击，然后移动到前线，再次尝试攻击1号玩家基地，步兵，坦克，战斗机，均以失败告终，因为步兵移动后不可以攻击（德国232暂时不考虑）。
然后2/3奋战火炮轮番尝试攻击1号玩家基地，步兵，坦克，战斗机，攻击基地成功，造成2点伤害，攻击步兵失败，因为步兵具有烟幕属性，攻击坦克成功，但是由于坦克的2点重甲，造成0点伤害，攻击战斗机失败，因为本回合已经攻击2次。
接下来5/4闪击飞机轮番尝试攻击1号玩家基地，步兵，坦克，战斗机，因为前三项，基地和坦克处在守护状态，步兵处在烟幕状态，所以攻击失败，最后只对战斗机进行了攻击，受到2点伤害对其造成5点伤害。
接下来同样的过程3/2闪击轰炸机也去尝试了，但是由于战斗机保护，只能攻击2/17战斗机，攻击后自己被击毁。对其造成3点伤害。