xy-server/game/horse/HorseSkill.ts

import SkillBase from "../skill/core/SkillBase";
import SkillUtil from "../skill/core/SkillUtil";
import DB from "../utils/DB";
import SKDataUtil from "../gear/SKDataUtil";
import Player from "../object/Player";
import SKLogger from "../gear/SKLogger";
import ItemUtil from "../core/ItemUtil";
import GameUtil from "../core/GameUtil";
import {MsgCode, Operate} from "../role/EEnum";
import SKCxfUtil from "../gear/SKCxfUtil";

export enum RefiningOperate {
    REFINING = 1,
    REPLACE = 2,
}

export default class HorseSkill {

    static skillMax: number = 12;
    owner: Player;
    dict: { [key: number]: SkillBase };

    constructor(player: Player) {
        this.owner = player;
        this.dict = {};
    }
    // 从数据库中读档
    setDB(rows: any) {
        if (rows == null) {
            return;
        }
        if (rows.length > 0) {
            for (let item of rows) {
                let skill = SkillUtil.getHorseSkill(item.skill_id);
                if (skill) {
                    skill.exp = item.exp;
                    this.dict[item.position] = skill;
                }
            }
        }
        let hasFixed = false;
        // 修正
        for (let position = 1; position <= HorseSkill.skillMax; position++) {
            let skill = this.dict[position];
            if (skill == null) {
                let skill = SkillUtil.getRandomHorseSkill(position - 1);
                if (skill) {
                    SKLogger.debug(`玩家[${this.owner.roleid}:${this.owner.name}]随机坐骑技能[${position}:${skill.skill_name}]`);
                    skill.exp = 0;
                    this.dict[position] = skill;
                    hasFixed = true;
                } else {
                    SKLogger.debug(`玩家[${this.owner.roleid}:${this.owner.name}]随机坐骑技能[${position}]为空!`);
                }
            }
        }
    }
    // 存档
    saveDB(callback?: (code: number, msg: string) => void) {
        DB.saveHorseSkillList(this.owner.roleid, this.dict, (error: any, rows: any[]) => {
            if (callback) {
                if (error) {
                    let info = DB.errorInfo(error);
                    callback(MsgCode.FAILED, info);
                    return;
                }
                callback(MsgCode.SUCCESS, "");
            } else {
                if (error != null) {
                    SKLogger.warn(`存档:玩家[${this.owner.roleid}:${this.owner.name}]坐骑技能存档失败[${DB.errorInfo(error)}]!`);
                } else {
                    SKLogger.debug(`存档:玩家[${this.owner.roleid}:${this.owner.name}]坐骑技能存档完成!`);
                }
            }
        });
    }
    // 获得管制技能列表
    getList(control: number): SkillBase[] {
        let list: SkillBase[] = [];
        if (control == 0) {
            return list;
        }
        // 1个种族4个坐骑,1个坐骑位3个技能
        let horseIndex = control % 4;
        let start = ((horseIndex == 0 ? 4 : horseIndex) - 1) * 3 + 1;
        for (let i = 0; i < 3; i++) {
            let skill = this.dict[start + i];
            if (skill) {
                list.push(skill);
            }
        }
        return list;
    }
    getSkill(position: number): SkillBase {
        let result = this.dict[position];
        return result;
    }
    // 洗炼
    refining(data: any) {
        let operate = data.operate;
        let position = data.horseIndex;
        if (operate == RefiningOperate.REFINING) {
            let itemData = ItemUtil.getItemData(GameUtil.horseRefiningItemId);
            let count = ItemUtil.getBagItemCount(this.owner, itemData.id);
            if (count < 3) {
                this.owner.send('s2c_notice', {
                    strRichText: `您需要至少3个[${itemData.name}]才能洗炼坐骑技能!`
                });
                return;
            }
            let group = (position - 1) * 3;
            let right = group + 1 + HorseSkill.skillMax;
            for (let i = 0; i < 3; i++) {
                let skill = SkillUtil.getRandomHorseSkill(group + i);
                if(skill.skill_name.substring(0,2) == "高级"){
                    let r = GameUtil.random(0,100)
                    if(r >= 20){
                        i--;
                        continue;
                    }
                }
                this.dict[right + i] = skill;
                SKLogger.debug(`玩家[${this.owner.roleid}:${this.owner.name}]坐骑技能洗炼:[${right + i}:${skill.skill_name}]`);
            }
            this.owner.addItem(itemData.id, -3, false, "坐骑洗炼");
            let params = this.toObj();
            if(this.owner){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: this.owner.roleid,
                    roleName: this.owner.name,
                    operateType: Operate.HORSE,
                    operateDepict: "坐骑洗练",
                    operateResSerial: position,
                    operateResName: this.owner.name,
                    operateContent: SKDataUtil.toJson(this.toObj(), "{}")
                })
            }
            this.owner.send("s2c_horse_skill", params);
        } else if (operate == RefiningOperate.REPLACE) {
            if (data.locks) {
                let total = 0;
                for (let lock of data.locks) {
                    if (lock == 1) {
                        total++;
                    }
                }
                if (total > 0) {
                    total = SKDataUtil.clamp(total, 1, 2);
                    let jade = GameUtil.lockJade[total - 1];
                    if (ItemUtil.getBagItemCount(this.owner,20026) < jade) {
                        this.owner.send('s2c_notice', {
                            strRichText: `您的坐骑炼化锁不足,坐骑洗炼锁住${total}条技能需消耗坐骑炼化锁${jade}`,
                        });
                        return;
                    }
                    this.owner.addBagItem(20026, -jade, `坐骑洗炼锁住${total}条技能,消耗坐骑锁：${jade}`);
                   // this.owner.addMoney(GameUtil.goldKind.Jade, -jade, `坐骑洗炼锁住${total}条技能,消耗仙玉${jade}`);
                }
            }
            let left = (position - 1) * 3 + 1;
            let right = left + HorseSkill.skillMax;
            for (let i = 0; i < 3; i++) {
                let leftSkill = this.dict[left + i];
                let rightSkill = this.dict[right + i];
                if (rightSkill == null) {
                    continue;
                }
                if (data.locks && i < data.locks.length) {
                    let lock = data.locks[i];
                    if (lock == 1) {
                        this.dict[right + i] = null;
                        continue;
                    }
                }
                rightSkill.exp = leftSkill.exp;
                this.dict[left + i] = rightSkill;
                this.dict[right + i] = null;
                SKLogger.debug(`玩家[${this.owner.roleid}:${this.owner.name}]坐骑技能洗炼替换:[${leftSkill.skill_name}]->[${rightSkill.skill_name}]`);
            }
            let params = this.toObj();
            this.owner.send("s2c_horse_skill", params);
            let control = (this.owner.race - 1) * 4 + position;
            if(this.owner){
                SKCxfUtil.getCxfRecordOperate({
                    roleId: this.owner.roleid,
                    roleName: this.owner.name,
                    operateType: Operate.HORSE,
                    operateDepict: "保存坐骑洗练",
                    operateResSerial: position,
                    operateResName: this.owner.name,
                    operateContent: SKDataUtil.toJson(this.toObj(), "{}")
                })
            }
            this.owner.updatePetControl(control);
        }
    }

    toObj(): any {
        let result = [];
        for (let position in this.dict) {
            let skill: SkillBase = this.dict[position];
            if (skill) {
                let obj = {
                    position: SKDataUtil.numberBy(position),
                    skillId: SKDataUtil.numberBy(skill.skill_id),
                    exp: skill.exp,
                };
                result.push(obj);
            }
        }
        return { list: result };
    }
}