card_svr/src/rooms/logic/skill/TriggerMan.ts

// Learn cc.Class:
//  - [Chinese] https://docs.cocos.com/creator/manual/zh/scripting/class.html
//  - [English] http://docs.cocos2d-x.org/creator/manual/en/scripting/class.html
// Learn Attribute:
//  - [Chinese] https://docs.cocos.com/creator/manual/zh/scripting/reference/attributes.html
//  - [English] http://docs.cocos2d-x.org/creator/manual/en/scripting/reference/attributes.html
// Learn life-cycle callbacks:
//  - [Chinese] https://docs.cocos.com/creator/manual/zh/scripting/life-cycle-callbacks.html

import { SKillEffectData } from "message/SkillInfo";
import { PetHandler } from "../Handler/PetHandler";
import { Condition } from "./Condition";
import { Skill } from "./Skill";
import { CondDecideType, CondType, SkillEffectType, TriggerType } from "./SkillConst";
import { SkillParam, SkillTarget } from "./SkillParam";
import { Trigger } from "./Trigger";
import { TriggerCtrl } from "./TriggerCtrl";

let TriggerManager = {
    _skillmap: new Map(),

    _buffmap: new Map(),

    _triggermap: new Map(),

    _conditionmap: new Map(),

    addSkillTrigger(skill_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number): TriggerCtrl  {
        let obj = this.getSkillTrigger(skill_id);
        if (!obj) {
            obj = this._newTrigger(skill_id, tg_type, tg_cond, tg_cond_decide, tg_cond_v);
            this._skillmap.set(skill_id, obj);
        }
        return obj;
    },

    addBuffTrigger(buff_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number): TriggerCtrl {
        let obj = this.getBuffTrigger(buff_id);
        if (!obj) {
            obj = this._newTrigger(buff_id, tg_type, tg_cond, tg_cond_decide, tg_cond_v);
            this._buffmap.set(buff_id, obj);
        }
        return obj;
    },

    getSkillTrigger(skill_id: number): TriggerCtrl {
        return this._skillmap.get(skill_id);
    },

    getBuffTrigger(buff_id: number): TriggerCtrl {
        return this._buffmap.get(buff_id);
    },

    _newTrigger(id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number): TriggerCtrl {
        let tobj = this._triggermap.get(tg_type);
        if (!tobj) {
            tobj = new Trigger();
            tobj.init(tg_type);
            this._triggermap.set(tg_type, tobj);
        }

        let key = Number(tg_cond) + '|' + Number(tg_cond_decide) + '|' + tg_cond_v;
        let cobj = this._conditionmap.get(key);
        if (!cobj) {
            cobj = new Condition();
            cobj.init(tg_cond, tg_cond_decide, tg_cond_v);
            this._conditionmap.set(key, cobj);
        }

        let obj = new TriggerCtrl();
        obj.init(id, tobj, cobj);

        return obj;
    },


    onTrigger(sender: Skill, param: SkillParam): SkillTarget[] {
        let effectid = sender._data.effect_typeid;
        let env = sender.getEnhanceValue(param);
        let effv = sender.getEffValue(param.cardpoint);
        let tgts = sender.getTargets(param);
        if(!tgts || !tgts.length){
            return null;
        }
        
        switch (effectid) {
            case SkillEffectType.NONE:
                return null;

            case SkillEffectType.CARD_ADD:
            case SkillEffectType.CARD_ADD_LIMIT:
            case SkillEffectType.CARD_STEAL:
            case SkillEffectType.CARD_CHG_EN:
            case SkillEffectType.CARD_GETDIRECT:
                tgts.forEach((item)=>{
                    sender.handleCard(effectid, effv + env, item);
                });
                break;
            case SkillEffectType.POWER_ENHANCE:
            case SkillEffectType.POWEREX_ENHANCE:
            case SkillEffectType.HURT_POWER:
                tgts.forEach((item)=>{
                    sender.handlePower(effectid, effv + env, item);
                });
                break;
            case SkillEffectType.SUMMON_NPC:
            case SkillEffectType.SUMMON_SKILL:
                tgts.forEach((item)=>{
                    sender.summon(effectid, param, item);
                });
                break;
            case SkillEffectType.TAUNT:
                tgts.forEach((item)=>{
                    sender.taunt(item);
                });
                break;
            case SkillEffectType.HURT_HP:
                tgts.forEach((item)=>{
                    sender.handleHP(effv + env, item);
                });
                break;
            case SkillEffectType.POWER_ADD_BUFF:
                tgts.forEach((item)=>{
                    sender.addBuff(effectid, effv + env, item);
                });
                break;
            case SkillEffectType.HURT_REDUCE:
                tgts.forEach((item)=>{
                    sender.reduceHurt(effv + env, item);
                });
                break;
            default:
                break;
        }

        return tgts;
    },

    handleEffectParam(effectid: SkillEffectType, paramlst: any) {
        return paramlst;
        switch (effectid) {
            case SkillEffectType.NONE:
            case SkillEffectType.CARD_ADD:
            case SkillEffectType.CARD_ADD_LIMIT:
            case SkillEffectType.CARD_STEAL:
            case SkillEffectType.CARD_CHG_EN:
            case SkillEffectType.POWER_ENHANCE:
            case SkillEffectType.POWEREX_ENHANCE:
            case SkillEffectType.HURT_POWER:
            case SkillEffectType.SUMMON_NPC:
            case SkillEffectType.SUMMON_SKILL:
            case SkillEffectType.TAUNT:
            case SkillEffectType.HURT_HP:
            case SkillEffectType.POWER_ADD_BUFF:
            case SkillEffectType.HURT_REDUCE:
            break;
        }
    },
}

export default TriggerManager;