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, target: SkillTarget): SkillTarget[] {
        let effectid = sender._data.effect_typeid;

        let effv = sender.getEffValue(param.edd_cnt, param.cardpoint);
        
        let tgts;
        if(target && effectid == SkillEffectType.ATTACK_BACK){
            tgts = sender.getOppTargets(target);
        }else{
            tgts = sender.getTargets(param);
        }

        if(!tgts || tgts.length <= 0){
            return null;
        }
        
        switch (effectid) {
            case SkillEffectType.NONE:
                tgts.forEach((item: SkillTarget) =>{
                    item.success(effectid, 0);
                });
                break;
            case SkillEffectType.CARD_ADD:
            case SkillEffectType.CARD_ADD_LIMIT:
            case SkillEffectType.CARD_STEAL:
            case SkillEffectType.CARD_CHG_EN:
            case SkillEffectType.CARD_GETDIRECT:
            case SkillEffectType.CARD_DROP:
                tgts.forEach((item)=>{
                    sender.handleCard(effectid, effv, item);
                });
                break;
            case SkillEffectType.POWER_ENHANCE:
            case SkillEffectType.POWEREX_ENHANCE:
            case SkillEffectType.HURT_POWER:
            case SkillEffectType.HURT_ALL:
                tgts.forEach((item)=>{
                    sender.handlePower(effectid, effv, item);
                });
                break;
            case SkillEffectType.SUMMON_NPC:
            case SkillEffectType.SUMMON_SKILL:
            case SkillEffectType.SKILL_GET:
                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, item);
                });
                break;
            case SkillEffectType.POWER_ADD_BUFF:
            case SkillEffectType.BUFF_SHIELD:
                tgts.forEach((item)=>{
                    sender.addBuff(effectid, effv, item);
                });
                break;
            case SkillEffectType.HURT_REDUCE:
                tgts.forEach((item)=>{
                    sender.reduceHurt(effv, item);
                });
                break;
            case SkillEffectType.REBORN:
                tgts.forEach((item)=>{
                    sender.reborn(item);
                });
                break;
            case SkillEffectType.ENHANCE_MAGIC:
                tgts.forEach((item)=>{
                    sender.enhanceMagic(effv, item);
                });
                break;
            case SkillEffectType.SILENT:
                tgts.forEach((item)=>{
                    sender.silent(effv, item);
                });
                break;
            case SkillEffectType.ATTACK:
            case SkillEffectType.ATTACK_BACK:
                let atkback = effectid == SkillEffectType.ATTACK_BACK;
                tgts.forEach((item)=>{
                    let obj = item.srcpet? item.srcpet: item.srcplayer;
                    // let ev = atkback? sender.getEffValue(0, 0, obj.bakTotalAP()): 0;
                    let ev = atkback? obj.bakTotalAP(): 0;
                    sender.attack(ev, item, param, atkback);
                });
                break;
            case SkillEffectType.HP_STEAL_ENHANCE:
                tgts.forEach((item)=>{
                    sender.handleHPS(effv, item);
                });
                break;
            default:
                break;
        }

        return tgts;
    },

    handleEffectParam(effectid: SkillEffectType, paramlst: any) {
        return paramlst;
    },
}

export default TriggerManager;