從零開始實現放置游戲（十五）——實現戰斗掛機（6）在線打怪練級

　　本章初步實現游戲的核心功能——戰斗邏輯。

　　戰斗系統牽涉的范圍非常廣，比如前期人物的屬性、怪物的配置等，都是在為戰斗做鋪墊。

　　戰斗中，人物可以施放魔法、技能，需要技能系統支持。

　　戰斗勝利后，進行經驗、掉落結算。又需要背包、裝備系統支持。裝備系統又需要隨機詞綴附魔系統。

　　可以說是本游戲最硬核的系統。

　　因為目前技能、背包、裝備系統都還沒有實現。我們先初步設計實現一個簡易戰斗邏輯。

　　戰斗動作僅包括普通攻擊，有可能產生未命中、閃避和暴擊。

　　整個戰斗邏輯的流程大致如下圖所示：

 

一、戰斗消息設計

　　參照其他消息，戰斗動作需要發送請求並接收返回消息，我們先定義兩個消息代碼 ：

　　　　CBattleMob = "30003001"

　　　　SBattleMob = "60003001"

 

　　這里我們先僅考慮在線打怪，發送戰斗請求，我們僅需要知道怪物id即可，戰斗時從數據庫讀取怪物屬性。

　　新建客戶端消息類如下：

@Data
public final class CBattleMobMessage extends ClientMessage {
    private String mobId;
}

　　服務端需要返回戰斗的最終結果信息，以及每個回合每個角色的戰斗動作記錄作給客戶端，一遍客戶端播放。

　　新建服務端的消息類如下：

@Data
public class SBattleMobMessage extends ServerMessage {
    private BattleMobResult battleMobResult;
}

@Data
public class BattleMobResult implements Serializable {
    // 總回合數
    private Integer totalRound;
    // 回合列表
    private List<BattleRound> roundList;
    // 是否玩家獲勝
    private Boolean playerWin;
    // 戰斗結果信息
    private String resultMessage;

    public BattleMobResult() {
        this.roundList = new ArrayList<>();
    }

    public void putBattleRound(BattleRound battleRound) {
        this.roundList.add(battleRound);
    }
}

@Data
public class BattleRound implements Serializable {
    // 當前回合數
    private Integer number;
    // 回合內戰斗記錄
    private List<String> messages;
    // 是否戰斗結束
    private Boolean end;

    public BattleRound() {
        this.messages = new ArrayList<>();
        this.end = false;
    }

    public BattleRound(Integer roundNum) {
        this();
        this.number = roundNum;
    }

    public void putMessage(String message) {
        this.messages.add(message);
    }
}

　　這里 BattleMobResult 和 BattleRound 兩個類，是返回給頁面使用的視圖模型，新建時放在game.hub.message.vo.battle包中。

二、戰斗單位建模

　　在戰斗開始時，我們把參戰單位那一時刻的屬性取出來存一份副本，此后，均以此副本為准進行計算。

　　怪物和玩家包的類含的屬性差別較大，為了方便統一計算，我們抽象一個BattleUnit類，存儲一些通用屬性，比如等級，血量。

　　其中還定義了一些抽象方法，比如獲取攻擊強度getAP()，和獲取護甲等級getAC()。玩家和怪物需要分別實現這兩個抽象方法。

　　玩家，戰斗屬性（二級屬性）是由力量、敏捷、耐力、智力這些一級屬性進一步計算得出。比如，戰士的攻擊強度=等級*3+力量*2-20。速度=敏捷。護甲等級=耐力*2。命中率=0.95。閃避和暴擊=敏捷*0.0005。

　　怪物，只是用來練級的，則沒那么麻煩，錄入數據時就只有傷害和護甲兩項屬性。攻擊強度直接取傷害值即可。速度直接取0。命中率默認0.95。閃避和暴擊率默認0.05。

　　這里虛類BattleUnit中又有一個巧妙的實方法getDR()，獲取傷害減免。將其寫在虛基類中，不管是玩家還是怪物實例，都可以根據自身的AC，計算出相應的DR。

　　這里DR的計算公式： 傷害減免 = 護甲等級 / (護甲等級 + 85*玩家（怪物等級 + 400）

    /**
     * 獲取傷害減免Damage Reduce
     *
     * @return
     */
    public Double getDR() {
        Integer ac = this.getAC();
        return ac / (ac + 85 * this.level + 400.0);
    }

　　3個類的UML圖如下，具體實現可以下載源代碼查看。

三、戰斗機制

　　模型建完，就剩戰斗邏輯了。其中，一個核心的問題就是戰斗動作的判定。即發起一次普通攻擊后，到底是被閃避了，還是被格擋了，還是產生了暴擊，或者僅僅是命中。其中，每一項可能的結果需要單獨ROLL點嗎？這里不同的游戲會有不同的實現。我們參考使用魔獸的判定方法，圓桌理論，即只ROLL一次點，這樣邏輯更加容易處理。

　　圓桌理論

　　"一個圓桌的面積是固定的，如果幾件物品已經占據了圓桌的所有面積時，其它的物品將無法再被擺上圓桌"

　　這個理論在戰斗邏輯中，即把可能產生的結果按優先級擺放到桌上，比如以下這種情形（其中的概率會因屬性、裝備等的不同而變化，這里只是舉例）：

• 未命中（5%）
• 躲閃（5%）
• 招架（20%）
• 格擋（20%）
• 暴擊（5%）
• 普通攻擊

　　只ROLL一次點，如果ROLL到3，則玩家未命中怪物；如果ROLL到49，則玩家的攻擊被怪物格擋；超過55的部分，都是普通攻擊。

　　假如這里玩家換上暴擊裝，暴擊率達到60%。則圓桌上全部結果的概率已超出100%，ROLL到50-100全部判定為暴擊，普通攻擊被踢下圓桌，永遠不會發生。

 

　　在本此實現中，我們僅考慮物理未命中、閃避和暴擊。暫不考慮二次ROLL點（攻擊產生暴擊，但被閃避或格擋了），以及法術技能的ROLL點。

四、戰斗邏輯實現

　　有了以上基礎，我們就可以通過代碼實現完整的戰斗邏輯了。

　　這里，雖然目前僅包含在線打怪，但以后可能會包含組隊戰斗，副本戰斗，PVP等邏輯。我們把戰斗邏輯放到單獨的包里，com.idlewow.game.logic.battle，在這里新建戰斗邏輯的核心類BattleCore，具體實現代碼如下：

package com.idlewow.game.logic.battle;

import com.idlewow.character.model.Character;
import com.idlewow.character.model.LevelProp;
import com.idlewow.character.service.CharacterService;
import com.idlewow.character.service.LevelPropService;
import com.idlewow.common.model.CommonResult;
import com.idlewow.game.GameConst;
import com.idlewow.game.logic.battle.dto.BattleMonster;
import com.idlewow.game.logic.battle.dto.BattlePlayer;
import com.idlewow.game.logic.battle.util.ExpUtil;
import com.idlewow.game.hub.message.vo.battle.BattleMobResult;
import com.idlewow.game.logic.battle.dto.BattleUnit;
import com.idlewow.game.logic.battle.util.BattleUtil;
import com.idlewow.game.hub.message.vo.battle.BattleRound;
import com.idlewow.mob.model.MapMob;
import com.idlewow.mob.service.MapMobService;
import com.idlewow.support.util.CacheUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

@Component
public final class BattleCore {
    private static final Logger logger = LogManager.getLogger(BattleCore.class);
    // 戰斗最大回合數
    private static final Integer MaxRound = 20;
    // 暴擊系數
    private static final Integer CriticalFactor = 2;

    @Autowired
    MapMobService mapMobService;
    @Autowired
    LevelPropService levelPropService;
    @Autowired
    CharacterService characterService;

    /**
     * 在線打怪
     *
     * @param character
     * @param mobId
     * @return
     */
    public BattleMobResult battleMapMob(Character character, String mobId) {
        // 獲取地圖怪物信息
        CommonResult commonResult = mapMobService.find(mobId);
        if (!commonResult.isSuccess()) {
            logger.error("未找到指定怪物：id" + mobId);
            return null;
        }

        // 初始化參戰方信息
        MapMob mapMob = (MapMob) commonResult.getData();
        List<BattleUnit> atkList = new LinkedList<>();
        atkList.add(this.getBattlePlayer(character, GameConst.BattleTeam.ATK));
        List<BattleUnit> defList = new LinkedList<>();
        defList.add(this.getBattleMonster(mapMob, GameConst.BattleTeam.DEF));
        List<BattleUnit> battleList = new LinkedList<>();
        battleList.addAll(atkList);
        battleList.addAll(defList);
        battleList = BattleUtil.sortUnitBySpeed(battleList);
        // 回合循環
        BattleMobResult battleMobResult = new BattleMobResult();
        for (int i = 0; i < MaxRound; i++) {
            BattleRound battleRound = new BattleRound(i + 1);
            for (BattleUnit battleUnit : battleList) {
                if (!battleUnit.getIsDefeat()) {
                    // 選定攻擊目標
                    BattleUnit targetUnit = null;
                    if (battleUnit.getTeam().equals(GameConst.BattleTeam.ATK)) {
                        Integer targetIndex = new Random().nextInt(defList.size());
                        targetUnit = defList.get(targetIndex);
                    } else if (battleUnit.getTeam().equals(GameConst.BattleTeam.DEF)) {
                        Integer targetIndex = new Random().nextInt(atkList.size());
                        targetUnit = atkList.get(targetIndex);
                    }

                    // 攻方出手ROLL點
                    Integer roll = new Random().nextInt(100);
                    Double miss = (1 - battleUnit.getHitRate() / (battleUnit.getHitRate() + battleUnit.getDodgeRate())) * 100;
                    Double critical = battleUnit.getCriticalRate() * 100;
                    logger.info("round: " + i + "atk: " + battleUnit.getName() + " def: " + targetUnit.getName() + " roll:" + roll + " miss: " + miss + " cri: " + critical);
                    String desc = "";
                    if (roll <= miss) {
                        desc = battleUnit.getName() + " 的攻擊未命中 " + targetUnit.getName();
                    } else if (roll <= miss + critical) {
                        Integer damage = BattleUtil.actualDamage(battleUnit.getAP(), targetUnit.getDR()) * CriticalFactor;
                        desc = battleUnit.getName() + " 的攻擊暴擊，對 " + targetUnit.getName() + " 造成 " + damage + " 點傷害（" + targetUnit.getHp() + " - " + damage + " ）";
                        targetUnit.setHp(targetUnit.getHp() - damage);
                    } else {
                        Integer damage = BattleUtil.actualDamage(battleUnit.getAP(), targetUnit.getDR());
                        desc = battleUnit.getName() + " 的攻擊，對 " + targetUnit.getName() + " 造成 " + damage + " 點傷害（" + targetUnit.getHp() + " - " + damage + " ）";
                        targetUnit.setHp(targetUnit.getHp() - damage);
                    }

                    // 檢測守方存活
                    if (targetUnit.getHp() <= 0) {
                        targetUnit.setIsDefeat(true);
                        desc += "， " + targetUnit.getName() + " 陣亡";
                        if (battleUnit.getTeam().equals(GameConst.BattleTeam.ATK)) {
                            defList.remove(targetUnit);
                        } else if (battleUnit.getTeam().equals(GameConst.BattleTeam.DEF)) {
                            atkList.remove(targetUnit);
                        }
                    } else {
                        // 檢測守方反擊動作
                        // todo
                    }

                    battleRound.putMessage(desc);
                    // 檢測戰斗結束
                    if (atkList.size() == 0 || defList.size() == 0) {
                        Boolean playerWin = defList.size() == 0;
                        battleRound.setEnd(true);
                        battleMobResult.setTotalRound(i);
                        battleMobResult.setPlayerWin(playerWin);
                        String resultMessage = "戰斗結束！ " + character.getName() + (playerWin ? " 獲得勝利！" : " 不幸戰敗！");
                        battleMobResult.putBattleRound(battleRound);
                        battleMobResult.setResultMessage(resultMessage);
                        // 玩家獲勝 進行戰斗結算
                        if (playerWin) {
                            // 經驗結算
                            this.settleExp(character.getLevel(), mapMob.getLevel(), character);
                            // 更新角色數據
                            characterService.updateSettle(character);
                        }

                        return battleMobResult;
                    }
                }
            }

            battleMobResult.putBattleRound(battleRound);
        }

        battleMobResult.setTotalRound(MaxRound);
        battleMobResult.setResultMessage("戰斗回合數已用盡！守方獲勝！");
        return battleMobResult;
    }

    /**
     * 經驗值結算
     * @param charLevel 角色等級
     * @param mobLevel 怪物等級
     * @param character 角色信息
     */
    private void settleExp(Integer charLevel, Integer mobLevel, Character character) {
        Integer exp = ExpUtil.getBattleMobExp(charLevel, mobLevel);
        if (exp > 0) {
            Integer levelUpExp = CacheUtil.getLevelExp(charLevel);
            if (character.getExperience() + exp >= levelUpExp) {
                character.setLevel(charLevel + 1);
                character.setExperience(character.getExperience() + exp - levelUpExp);
            } else {
                character.setExperience(character.getExperience() + exp);
            }
        }
    }


    /**
     * 獲取角色戰斗狀態
     * @param character 角色信息
     * @param battleTeam 所屬隊伍
     * @return
     */
    private BattlePlayer getBattlePlayer(Character character, String battleTeam) {
        LevelProp levelProp = levelPropService.findByJobAndLevel(character.getJob(), character.getLevel());
        BattlePlayer battlePlayer = new BattlePlayer();
        battlePlayer.setId(character.getId());
        battlePlayer.setName(character.getName());
        battlePlayer.setJob(character.getJob());
        battlePlayer.setLevel(character.getLevel());
        battlePlayer.setHp(levelProp.getHp());
        battlePlayer.setStrength(levelProp.getStrength());
        battlePlayer.setStamina(levelProp.getStamina());
        battlePlayer.setAgility(levelProp.getAgility());
        battlePlayer.setIntellect(levelProp.getIntellect());
        battlePlayer.setTeam(battleTeam);
        return battlePlayer;
    }

    /**
     * 獲取怪物戰斗狀態
     * @param mapMob 怪物信息
     * @param battleTeam 所屬隊伍
     * @return
     */
    private BattleMonster getBattleMonster(MapMob mapMob, String battleTeam) {
        BattleMonster battleMonster = new BattleMonster();
        battleMonster.setId(mapMob.getId());
        battleMonster.setName(mapMob.getName());
        battleMonster.setLevel(mapMob.getLevel());
        battleMonster.setHp(mapMob.getHp());
        battleMonster.setDamage(mapMob.getDamage());
        battleMonster.setArmour(mapMob.getArmour());
        battleMonster.setTeam(battleTeam);
        return battleMonster;
    }
}

　　如上圖代碼，首先我們初始化一份各參戰單位的屬性副本，並添加到創建的3個列表中，其中atkList, defList用來檢測是否其中一方全部陣亡，battleList則用來對參戰單位按速度排序，確定出手順序。

　　這里使用了歸並排序來對集合進行排序，具體算法在BattleUtil類中。考慮到這里對集合的添加、修改、刪除操作較多，使用LinkedList鏈表來保存參戰集合。（實際上數據較少，使用ArrayList可能也沒什么差別）。

　　這里僅僅在回合開始前確定了一次出手順序，因為目前沒有引入技能，假如引入技能后，比如獵人施放豹群守護，我方全體速度+50，那么需要對出手列表進行重新排序。

　　進入循環后，隨機選定攻擊目標 --> 確定出手動作 --> 存活檢測 --> 戰斗結束檢測， 這里注釋和代碼比較清楚，就不一一講解了。

　　這里攻擊動作和結果確定后，會在返回信息中添加對此的描述，后面考慮如果后端傳輸這些內容太多不夠優雅，也可以定義一套規則，只傳輸關鍵數據，戰斗記錄由前端生成。不過目前先不考慮。

　　戰斗結束后，如果玩家勝利，需要結算經驗值。經驗值相關的計算在ExpUtil中，文后會附上經驗值計算公式。

五、播放戰斗記錄

　　戰斗計算完成后，后端會返回戰斗信息給前端，前端只負責播放即可。

　　播放記錄的方法代碼如下：

 

    // 加載在線打怪戰況
    loadBattleMobResult: async function (data) {
        let that = this;
        $('.msg-battle').html('');
        let rounds = data.battleMobResult.roundList;
        if (data.battleMobResult.totalRound > 0) {
            for (let i = 0; i < rounds.length; i++) {
                let round = rounds[i];
                let content = "<p>【第" + round.number + "回合】</p>";
                for (let j = 0; j < round.messages.length; j++) {
                    content += "<p>" + round.messages[j] + "</p>";
                }

                content += "<hr />";
                $('.msg-battle').append(content);
                await this.sleep(1500);
            }

            $('.msg-battle').append("<p><strong>" + data.battleMobResult.resultMessage + "</strong></p>");
            if (data.battleMobResult.playerWin) {
                that.sendLoadCharacter();
            }

            if (that.isBattle) {
                that.battleInterval = setTimeout(function () {
                    that.sendBattleMob(that.battleMobId);
                }, 5000);
            }

            // await this.sleep(5000).then(function () {
            //     that.sendBattleMob(data.battleMobResult.mobId);
            // });
        }
    },

　　上面的代碼中，最后3行被注釋掉的代碼，即5秒鍾后，再次攻擊此怪。如果只考慮打怪和用setTimeout方法實現，其實沒有差別。

　　但在業務上，考慮玩家可能需要點擊停止打怪，那么用setTimeout來執行循環，可以用clearInterval來終止函數執行。

/* 在線打怪 */
function battleMob(mobId) {
    let diff = new Date().getTime() - wowClient.battleMobTime;
    if (diff < TimeLag.BattleMob * 1000) {
        let waitSeconds = parseInt(TimeLag.BattleMob - diff / 1000);
        alert('請勿頻繁點擊！' + waitSeconds + '秒后可再操作！');
        return;
    }

    if (mobId === wowClient.battleMobId) {
        alert("已經在戰斗中！請勿重復點擊！");
        return;
    }

    wowClient.battleMobId = mobId;
    wowClient.battleMobTime = new Date().getTime();
    if (!wowClient.isBattle) {
        wowClient.isBattle = true;
        wowClient.sendBattleMob(mobId);
    }
}

　　上圖中是點擊‘打怪’按鈕的方法，這里我直接把代碼貼出來，顯得比較清晰簡單。實際上做的時候，經過反復改動和考慮。代碼中解決的一些問題，可能三言兩語也不太好體現出來，需要自己實際編寫代碼才能體會。

　　比如考慮這個場景，玩家A，在線攻擊怪物a ， 開啟的對a的戰斗循環。A升級后，想攻擊更高級的怪物b。這時比較合理的操作方式就是玩家直接點擊b的戰斗按鈕。

　　那么我們可能要考慮幾個問題：

　　　　怪物a的戰斗循環需不需要停止，怎么停止；如果要停止戰斗，但此時正在播放戰斗記錄，還沒進入5秒的循環，停止循環函數不會生效，該怎么辦；播放中對a的戰斗記錄需不需要立即清除；對b的戰斗需不需點擊后立即開始。。。

　　起初我是按照兩條線程的思路來進行實現，即a的線程仍在進行，建立標志位將其停止，點擊后立即開啟b的線程，但實現起來非常復雜，而且有些問題不好解決，比如a的戰斗記錄沒播放完，b已經發送了戰斗請求，那么就需要停止播放a的記錄，並清屏，開始播放b的戰斗記錄。

　　后來發現，只需要一個線程即可。僅需要標記戰斗目標的怪物id，戰斗線程僅對標記的怪物id發送戰斗請求，切換戰斗目標后，因為被標記的怪物id已經變了，所以a的戰斗記錄播放完畢后，5秒后自動請求戰斗的怪物id已變成了b，這樣自動切換到了對b的戰斗。從頁面表現上，也更符合邏輯。

F&Q

　　Q.在初始化戰斗時，為什么要把玩家和怪物放到列表中？

　　A.考慮后面會有組隊戰斗。以及戰斗技能，比如法師召喚水元素，獵人帶寵物。雖然目前僅是1v1，但實現時作為隊伍來考慮更方便擴展。

　　

　　Q.為什么角色陣亡后，僅把其從攻方（守方）列表中移除，不從全體出手列表中移除？

　　A.考慮到牧師，騎士可以施放復活技能，陣亡后的角色仍保留在列表中，對性能影響不大，方便以后技能的實現。

附-經驗值計算

艾澤拉斯的怪物經驗公式是 45+等級*5
外域的怪物經驗公式是 235+等級*5
基礎知識
魔獸里你選取怪物以后一般名字級別上面有顏色,它指示你和怪物之間的等級差別,
骷髏級別 怪物級別大於等於玩家級別的10級
紅色 怪物級別大於等於玩家級別的5級
橙色 怪物級別大於等於玩家級別的3或者4級
黃色 怪物級別小於等於玩家級別2級和大於大於等於玩家級別2級之間
綠色 怪物級別小於玩家級別3級,但是還未變灰
灰色 玩家級別1-5級: 灰色級別小於等於0(沒有灰色的怪)
玩家級別 6-39級:灰色級別小於等於 玩家級別－(玩家級別÷10取整數上限) －5
玩家級別 40-59級:灰色級別小於等於 玩家級別－(玩家級別÷5取整數上限) －1
玩家級別 60-70級:灰色級別小於等於 玩家級別－9
注:整數上限是指不小於該值的最小整數,比如4.2整數上限是5，3.0整數上限是3
單殺怪的經驗
殺死灰色級別的怪是沒有經驗的，其他顏色級別的怪單殺的經驗值計算如下：（艾澤拉斯）
相同級別的怪：
經驗＝（玩家等級×5＋45）
高等級怪：
經驗＝（玩家等級×5＋45）×（1＋0.05×（怪物等級－玩家等級） ，當怪物等級大於玩家等級4級以上均按4級計算，哪怕精英怪
低等級怪：
有一個零差值系數ZD （zero difference value）
ZD = 5, when Char Level = 1 - 7
ZD = 6, when Char Level = 8 - 9
ZD = 7, when Char Level = 10 - 11
ZD = 8, when Char Level = 12 - 15
ZD = 9, when Char Level = 16 - 19
ZD = 11, when Char Level = 20 - 29
ZD = 12, when Char Level = 30 - 39
ZD = 13, when Char Level = 40 - 44
ZD = 14, when Char Level = 45 - 49
ZD = 15, when Char Level = 50 - 54
ZD = 16, when Char Level = 55 - 59
ZD = 17, when Char Level = 60＋
經驗＝（玩家等級×5＋45）×（1－（玩家等級－怪物等級）÷ 零差值系數）
計算的例子如下：
假設玩家等級 = 20.
那么灰名怪物等級 = 13, 根據以上表格獲得.
殺掉任何 13 級或者以下的怪得不到經驗。
同等級基礎經驗為 (20 * 5 + 45) = 145. 殺掉一個 20 級別的怪將能獲得145點經驗。
對於一個 21級怪, 你將獲得 145 * (1 + 0.05 * 1) = 152.2 四舍五入為 152 點經驗.
根據上面表格ZD值是11。
對於18級的怪, 我們將有 145 * (1 - 2/11) = 118.6 四舍五入為 119點經驗。
對於16級的怪, 我們將有 145 * (1 - 4/11) = 92.3四舍五入為 92點經驗.
對於14級的怪, 我們將有 145 * (1 - 6/11) = 65.91四舍五入為 66點經驗.


對於燃燒的遠征外域的怪，經驗計算較多，筆者根據表格值推論公式如下：
相同級別的怪：
經驗＝（玩家等級×5＋235）
高等級怪：
經驗＝（玩家等級×5＋235）×（1＋0.05×（怪物等級－玩家等級） ，當怪物等級大於玩家等級4級以上均按4級計算，哪怕精英怪。
低等級怪：
經驗＝（玩家等級×5＋235）×（1－（玩家等級－怪物等級）÷ 零差值系數）
精英怪經驗＝普通同等級怪經驗×2
精力充沛時間經驗＝普通計算經驗×2 （耗盡精力充沛點數為止，故而最后一個精力充沛期間殺的怪未必能達到經驗×2）
影響殺怪經驗的因素
對於大號帶小號或者搶怪的情況，玩家殺怪的經驗值就會有變化。
一般來說，原則如下：
如果你開怪並造成了傷害，那么怪物就是你的；這個時候，如果有別的玩家或者大號來殺了這個怪，那么如果幫助殺怪的人對於這個級別的怪他能夠獲得經驗，則屬於搶怪，不會影響你的經驗獲得；
如果幫助你殺怪的人對於這個級別的怪或不得經驗，那么就是就屬於帶小號了，你獲得很少很少的經驗，非常的不划算。因此，對於一個60級的玩家來帶小號，不管什么級別的怪，他都沒有經驗（TBC以前），所以小號獲得的經驗非常少！而如果是59的玩家幫忙殺50＋的怪，那么經驗都是小號的！
戰斗中如果有別人幫你加血，加血只會扣掉你很少的經驗，用大號跟隨加血小號練級是不錯的辦法；別人給你加的傷害護盾（比如說荊棘術什么的）只會影響你非常少的經驗，5－10點最壞情況，基本可以無視了，放心的加吧。
綜上所述，用不滿級的相同等級區間里的號帶小號效率最高，比如49的帶40的，59的帶50的…… 但是，大號基本都是60的，沒辦法，呵呵，只能幫帶任務或者副本了。
組隊經驗值
根據wiki的資料，這個只是推論，未必精確
假設一個隊伍中的人都是同等級的，那么
每個人的經驗＝單殺怪的經驗÷人數×系數
系數是：
1人：1
2人：1
3人：1.166
4人：1.3
5人：1.4
例子如下:
殺100經驗的怪
1人 = 100xp
2人 = 50xp 每人.
3人 = ~39xp 每人.
4人 = ~33xp 每人.
5人 = ~28xp 每人.
兩人隊伍計算公式
假設 玩家1級別>玩家2級別
那么 基礎經驗按玩家1級別計算
最后分得的經驗
玩家1獲得 基礎經驗×玩家1級別÷（玩家1級別＋玩家2級別）
玩家1獲得 基礎經驗×玩家2級別÷（玩家1級別＋玩家2級別）
團隊里面經驗值要打折（除以2）

效果演示

本章小結

　　注意，之前數據庫和模型有個列名的單詞寫錯了，我在源碼中修正了。

　　即map_mob的護甲字段，應為armour，之前寫成了amour。如需運行源碼，請先修正數據庫中的列名。

 

　　至此，游戲最重要的戰斗功能已有了。

　　后面可以開始逐步擴展背包，裝備，掉落，隨機附魔等重要功能。

 

　　本文原文地址： https://www.cnblogs.com/lyosaki88/p/idlewow_15.html

　　本章源碼下載地址： https://474b.com/file/14960372-445773378

　　項目交流群：329989095

　　

demo 演示地址： http://175.24.107.27:20010/   （服務器到期啦，等有時間搭了新服務器再更新這里）

創建角色時，請選擇 人類 - 戰士， 因為其他種族和職業的數值沒有配置。