【开源】使用Angular9和TypeScript开发RPG游戏(补充了Buffer技能)

时间 2020-04-06

标签开源使用 angular9 angular typescript 开发 rpg 游戏补充 buffer 技能栏目 AngularJS 繁體版

原文原文链接

RPG系统构造

经过对于斗罗大陆小说的游戏化过程，熟悉Angular的结构以及使用TypeScript的面向对象开发方法。
Github项目源代码地址
git

RPG系统构造

ver0.02 2020/03/31github

人物

和其余RPG游戏相似，游戏里面的人物角色大体有这样的一些属性：生命值，魔法值（魂力），攻击力，防护力，速度。RPG游戏中的角色随着等级的提升，这些属性都会提高，属性提高的快慢则取决于资质，同时，因为在实际战斗中，会出现各类增益和光环效果，这些值都是动态变化的，因此这里将这些属性都设置了Base和Real两套数据。typescript

Base属性是指人物的初始属性，是一种固有属性，在整个游戏开始的时候就固定下来的。而后每一个人物根据不一样的资质，有一个成长值，例如SSR的角色，成长值能够是1.5，普通角色是1。这个成长值关系到每提高一个等级，角色属性的增长值，代码大体以下：数组

/**通过增益以后的生命最大值 */
    get RealMaxHP(): number {
        var R = this.BaseMaxHP + (this.LV - 1) * this.MaxHPUpPerLv * this.GrowthFactor;
        ...
        ...
        ...
        return Math.round(R);
    }

这里的 MaxHPUpPerLv 表示每一个等级的最大生命值提高数值，GrowthFactor则表示成长值。dom

注意：这里使用了TypeScript的get属性，也就是只读/计算属性来处理Real系的属性，这些属性都是实时计算出来的！函数

在小说里面，常常能够看到3成功力的角色，为了表示这种状况，代码里面还设定了一个Factor变量，经过这个变量能够设定总体的缩放比例。这个值默认为1，表示不缩放。this

/**通过增益以后的生命最大值 */
    get RealMaxHP(): number {
        var R = this.BaseMaxHP + (this.LV - 1) * this.MaxHPUpPerLv * this.GrowthFactor;
        R = R * this.Factor;
        ...
        ...
        ...
        return Math.round(R);
    }

因为乘法计算会出现小数点，这里使用了Math.round对结果进行取整。设计

技能

技能是一个游戏的战斗核心，全部技能本质上都是为了改变角色状态。若是要具体细分大体能够分为指针

攻击类：对于指定角色产生伤害
回复类：对于指定角色，回复生命值和魔法值
状态改变类：这里其实包含了Buffer和状态变化两种状况，Buffer类大可能是被动技能，游戏中只要某个角色在战场上就得到，而且效果是持续性的。状态变化则通常必须主动施放技能才行，并且持续时间也是有限制的。

同时技能设计的时候，还须要设定使用的方向，既这个技能是对于我方使用，仍是敌方使用，仍是无差异使用。另外这个技能的对象是某个对象，仍是群体。code

/**技能类型 */
export enum enmSkillType {
    /**攻击 */
    Attact,
    /**治疗 */
    Heal,
    /**光环和状态  */
    Buffer
}

/**技能范围 */
export enum enmRange {
    Self,       //本身
    PickOne,    //选择一我的
    RandomOne,  //随机选择一我的
    FrontAll,   //前排全部人
    BackAll,    //后排全部人
    EveryOne,   //战场全部人
}

/**技能方向 */
export enum enmDirect {
    MyTeam,     //本方
    Enemy,      //敌方
    All,        //全体
}

通常使用枚举来编写这样相对固定，项目较少的列表

技能的设计，这里使用了OOP的继承来实现，技能的基类定义了一些共通的属性和抽象方法。设计的时候还考虑到如下几种特殊状况

每一种具体技能必需要实现一个执行（施放）方法：Excute，这里使用抽象函数，来强制子类型必需要实现这个方法
对于复杂技能，须要有一个自定义的执行方法：CustomeExcute，同时经过返回值来告诉系统是否是该技能有自定义执行方法。则跳过固有的Excute方法。
对于有些技能可能要同时实现两种效果，这里增长了AddtionSkill变量

/** 技能 */
export abstract class SkillInfo {
    Name: string;
    Order: number;   //第N魂技
    SkillType: enmSkillType;
    Range: enmRange;
    Direct: enmDirect;
    Description: string;
    Source: string;
    get MpUsage(): number {
        return Math.pow(2, this.Order);
    }
    /**武魂融合技的融合者列表 */
    Combine: string[];
    abstract Excute(c: character, fs: FightStatus): void;
    /**自定义执行方法 */
    CustomeExcute(c: character, fs: FightStatus): boolean {
        return false;
    }
    //攻击并中毒这样的两个效果叠加的技能
    AddtionSkill: SkillInfo = undefined;
}

export class AttactSkillInfo extends SkillInfo {
    SkillType = enmSkillType.Attact;
    Harm: number;
    Excute(c: character, fs: FightStatus) {
        //若是自定义方法被执行，则跳事后续代码
        if (this.CustomeExcute(c, fs)) return;
        let factor = fs.currentActionCharater.LV / 100;
        c.HP -= Math.round(this.Harm * factor);
        if (c.HP <= 0) c.HP = 0;
        //若是须要产生其余效果
        if (this.AddtionSkill !== undefined) this.AddtionSkill.Excute(c, fs);
    }
}

undefined来检测是否拥有对象

Buffer技能

Buffer，能够叫作状态增益，本系统的Buffer以下所示：该结构标明了Buffer的做用，来源，剩余回合数，已经对于状态的影响。

其中，状态有常规的攻防增益，中毒，也有一些特殊的，例如施法以后产生的Flag型状态：浴火凤凰,幽冥影分身,飞行等就属于这种特殊状态。

/**状态 */
export enum characterStatus {
    /**通用 */
    魂技,
    /**增益 */
    攻击增益,
    防护增益,
    速度增益,
    生命增益,
    魂力增益,

    /**每回合失去生命值 */
    中毒,
    /**没法使用技能 */
    禁言,
    /**没法物理和技能攻击 */
    晕眩,
    /**没法普通攻击，可使用技能 */
    束缚,
    /**物理攻击免疫 */
    物免,
    /**技能攻击免疫 */
    魔免,
    /**所有免疫 */
    无敌,
    //特点特殊状态:战斗开始的时候将被清除掉
    /**马红俊 */
    浴火凤凰,
    /**朱竹清 */
    幽冥影分身,
    /**香肠效果 */
    飞行
}

/**Buffer */
export class Buffer {
    //Value表示绝对值，Percent表示百分比

    MaxHPValue: number = undefined;
    MaxHPFactor: number = undefined;

    HPValue: number = undefined;
    HPFactor: number = undefined;

    MaxMPValue: number = undefined;
    MaxMPFactor: number = undefined;

    MPValue: number = undefined;
    MPFactor: number = undefined;

    SpeedValue: number = undefined;
    SpeedFactor: number = undefined;

    AttactValue: number = undefined;
    AttactFactor: number = undefined;

    DefenceValue: number = undefined;
    DefenceFactor: number = undefined;
    /**来源 */
    Source: string;
    /**持续回合数 */
    Turns: number = 999;    //默认999回合
    /**状态 */
    Status: characterStatus[] = [characterStatus.魂技];
}

在技能里面有一类是Buffer技能，这个时候须要将Buffer放入角色的BufferList中，注意，因为技能描述中的Buffer是对于Skill的描述，是一个类，不能直接放入到人物BufferList中。而应该将Buffer的副本放入人物BufferList中去。

/**增益和减弱 */
export class BufferStatusSkillInfo extends SkillInfo {
    SkillType = enmSkillType.Buffer;
    Buffer: Buffer = new Buffer();
    /**Buffer强度是否和施法者等级挂钩？ */

    Excute(c: character, fs: FightStatus) {
        if (this.CustomeExcute(c, fs)) return;
        //增长Buffer来源信息，相同的不叠加
        if (c.BufferList.find(x => x.Source === this.Name) !== undefined) return;
        //增幅强度和等级关联:若是是和施法者相关，必须使用currentActionCharater的信息
        if (this.BufferFactorByLV) {
            let factor = fs.currentActionCharater.LV / 100;
            //如下不使用 1 + factor 是由于RealTimeAct()计算使用了 R += R * element.AttactFactor; 
            if (this.Buffer.AttactFactor !== undefined) this.Buffer.AttactFactor = factor;
            if (this.Buffer.DefenceFactor !== undefined) this.Buffer.DefenceFactor = factor;
            if (this.Buffer.MaxHPFactor !== undefined) this.Buffer.MaxHPFactor = factor;
            if (this.Buffer.MaxMPFactor !== undefined) this.Buffer.MaxMPFactor = factor;
            if (this.Buffer.SpeedFactor !== undefined) this.Buffer.SpeedFactor = factor;
        }
        //从技能使用点开始就起效的属性变化的调整:因为使用了get自动属性功能，Real系的都会自动计算
        let MaxHpBefore = c.RealMaxHP;
        let MaxMpBefore = c.RealMaxMP;
        this.Buffer.Source = this.Name;
        //这里必须使用副本
        c.BufferList.push(JSON.parse(JSON.stringify(this.Buffer)));
        let MaxHpAfter = c.RealMaxHP;
        let MaxMpAfter = c.RealMaxMP;
        //魂力和生命的等比缩放
        if (MaxHpAfter !== MaxHpBefore) c.HP = Math.round(c.HP * (MaxHpAfter / MaxHpBefore))
        if (MaxMpAfter !== MaxMpBefore) c.MP = Math.round(c.MP * (MaxMpAfter / MaxMpBefore))
        //生命值和魂力的Buffer，还须要对于HP和MP进行修正
        if (c.HP > c.RealMaxHP) c.HP = c.RealMaxHP;
        if (c.MP > c.RealMaxMP) c.MP = c.RealMaxMP;
        if (fs.IsDebugMode) {
            console.log("技能对象：" + c.Name);
            c.BufferList.forEach(element => {
                console.log("回合数：" + element.Turns + "\t状态" + element.Status.toString() + "\t来源" + element.Source);
            });
        }
        if (this.AddtionSkill !== undefined) this.AddtionSkill.Excute(c, fs);
    }
}

剧情

剧情暂时使用传统的列表在当前位置指针方式来制做

export const FightPrefix = "[FightScene]";
export const ChangeScenePrefix = "[ChangeScene]";
export const Scene0000: SceneInfo = {
    Title: "引子 穿越的唐家三少",
    Background: "唐门",
    Lines: [
        "唐门唐三@我知道，偷入内门，偷学本门绝学罪不可恕，门规所不容。但唐三能够对天发誓，绝未将偷学到的任何一点本门绝学泄露与外界。",
        FightPrefix + "Battle0001",
        "唐门唐三@我说这些，并非但愿获得长老们的宽容，只是想告诉长老们，唐三从未忘本。之前没有，之后也没有。",
        "唐门唐三@唐三的一切都是唐门给的，不管是生命仍是所拥有的能力，都是唐门所赋予，不论何时，唐三生是唐门的人，死是唐门的鬼，",
        "唐门唐三@我知道，长老们是不会容许我一个触犯门规的外门弟子尸体留在唐门的，既然如此，就让我骨化于这巴蜀天然之中吧。",
        "唐门长老@玄天宝录，你居然连玄天宝录中本门最高内功也学了？",
        "唐门唐三@赤裸而来，赤裸而去，佛怒唐莲算是唐三最后留给本门的礼物。",
        "唐门唐三@如今，除了我这我的之外，我再没有带走唐门任何东西，秘籍都在我房间门内第一块砖下。唐三如今就将一切都还给唐门。",
        "唐门唐三@哈哈哈哈哈哈哈……。",
        "唐门长老@等一下。",
        "唐门唐三@(云雾很浓，带着阵阵湿气，带走了阳光，也带走了那将一辈子贡献给了唐门和暗器的唐三。)",
        ChangeScenePrefix + "Scene0001"
    ]
};

这里使用 FightPrefix表示进入战斗，ChangeScenePrefix表示场景转换。对话列表则使用@符号将角色和台词进行区分。

道具系统

能够将道具看做一种特殊的技能,只是这种技能是能够购买的。固然特殊的剧情道具则不属于这个范畴，设计起来比较复杂，须要配合场景的经过条件来使用。

export enum enmToolType {
    /**暗器 */
    HiddenWeapon,
    /**可购入的通常道具 */
    StoreItem,
    /**剧情道具 */
    Spacial
}

战斗流程

ver0.02 2020/03/30

回合开始

每个回合开始的时候，首先对上一个回合进行一次清算。

状态回合数的递减
中毒状态的伤害计算

BufferTurnDown() {
        this.BufferList.forEach(element => {
            if (element.Status.find(x => x === characterStatus.中毒) !== undefined) {
                //中毒状态，若是存在HP伤害部分，则这里处理，因为使用了get自动属性功能，Real系的都会自动计算
                if (element.HPFactor !== undefined) this.HP += this.HP * element.HPFactor;
                if (element.HPValue !== undefined) this.HP += element.HPValue;
            }
            element.Turns -= 1;
        });
        this.BufferList = this.BufferList.filter(x => x.Turns > 0);
    }

极端状况下，敌我双方均可能被束缚，没法行动，因此先作一下判断是否有能够行动的角色。

按照出手速度，将全部角色放在一个数组里面，而后决定第一个出手的人，若是是我方人员，等待用户界面的指令输入，若是是敌方的话，则使用AI进行行动。不管是AI仍是用户界面的指令，一旦完成，则执行ActionDone方法，进行胜负断定，切换当前的行动角色。

/**当前角色动做完成 */
    ActionDone() {
        //胜负统计
        let MyTeamLive = this.MyTeam.find(x => x !== undefined && x.HP > 0);
        if (MyTeamLive === undefined) {
            console.log("团灭");
            this.MyTeam.forEach(element => { this.InitRole(element) });
            this.ResultEvent.emit(0);
            return;
        }

        let EnemyTeamLive = this.Enemy.find(x => x !== undefined && x.HP > 0);
        if (EnemyTeamLive === undefined) {
            console.log("胜利");
            this.MyTeam.forEach(element => { this.InitRole(element) });
            this.ResultEvent.emit(1);
            return;
        }
        //气绝者去除
        this.MyTeam = this.MyTeam.map(x => x !== undefined && x.HP > 0 ? x : undefined);
        this.Enemy = this.Enemy.map(x => x !== undefined && x.HP > 0 ? x : undefined);

        if (this.TurnList.length == 0) {
            console.log("回合结束");
            this.NewTurn();
        } else {
            let Role = this.TurnList.pop();
            let block = Role.BufferStatusList.find(x => x.Status === characterStatus.束缚);

            if (Role === undefined || block !== undefined) {
                console.log(Role.Name + ":角色已经气绝,或者角色被束缚");
                this.ActionDone();
            } else {
                console.log("当前角色：" + Role.Name + "[" + Role.IsMyTeam + "]");
                this.currentActionCharater = Role;
                if (!Role.IsMyTeam) {
                    //AI For Enemy
                    RPGCore.EnemyAI(Role, this);
                    this.ActionDone();
                }
            }
        }
    }

这里使用了@Output()的EventEmitter<>向外部发送消息战斗结束。因为敌方AI运行速度极快，因此这里没有发送消息给用户界面指示我方能够行动了。

ngOnInit(): void {
        this.ge.InitFightStatus();
        this.Message = this.ge.fightStatus.currentActionCharater.Name + "的行动";
        this.ge.fightStatus.ResultEvent.subscribe((x) => {
            if (x === 0) {
                this.FightResultTitle = "团灭了......魂力不足"
                this.ge.gamestatus.lineIdx--;
            } else {
                this.FightResultTitle = "胜利了......奥力给"
                this.ge.gamestatus.lineIdx++;
            }
            this.FightEnd = true;
            console.log("jump to scene");
            setTimeout(() => { this.router.navigateByUrl("scene"); }, 3000);
        }, null, null);
    }

EventEmitter在用户界面使用subscribe进行订阅