Merge branch 'master' of git.kingsome.cn:node/card_svr

src/rooms/logic/CfgMan.ts

@@ -0,0 +1,26 @@
+import { BaseConst } from "../../constants/BaseConst";
+
+let CfgMan = {
+    /**
+     * findPlayerCfg
+     *playerid: numer
+    */
+
+    findPlayerCfg(playerid: number){
+        return global.$cfg.get(BaseConst.HERO).get(playerid);
+    },
+
+    findUnitCfg(unitid: number){
+        return global.$cfg.get(BaseConst.UNIT).get(unitid);
+    },
+
+    findSkillCfg(skillid: number){
+        return global.$cfg.get(BaseConst.SKILL).get(skillid);
+    },
+
+    findEffCardCfg(cardid: number){
+        return global.$cfg.get(BaseConst.EFFECTCARD).get(cardid);
+    }
+};
+
+export default CfgMan;

src/rooms/logic/Handler/BattleHandler.ts

@@ -0,0 +1,59 @@
+import {Player} from "../../schema/Player";
+import {Card} from "../../schema/Card";
+import {CardGameState} from "../../schema/CardGameState";
+import { PlayerHandler } from "./PlayerHandler";
+import CfgMan from "../CfgMan";
+import { EffectCardType } from "../skill/SkillConst";
+import { Pet } from "rooms/schema/Pet";
+
+export class BattleHandler {
+    private _cs: CardGameState;
+    private _players: PlayerHandler[];
+
+    public init(cs: CardGameState){
+        this._cs = cs;
+    };
+
+    public addPlayer(aplayer: Player){
+        let ph = new PlayerHandler();
+        ph.init(aplayer, this);
+        this._players.push(ph);
+    };
+
+    public delPlayer(aplayer: Player){
+        let idx = this._players.findIndex((item: PlayerHandler)=>{
+            return item._player == aplayer;
+        })
+        this._players.splice(idx, 1);
+    };
+
+    public getPlayer(aplayer: Player){
+        return this._players.find((item: PlayerHandler)=>{
+            return item._player == aplayer;
+        })
+    };
+
+    public useCard(obj:
+        {srcplayer: Player, card: Card, dbeff_cnt: number, dbpt_cnt: number, dstplayer: Player, dstpet: Pet})
+    {
+        if(!obj || obj.card){
+            return false;
+        }
+        let cfg = CfgMan.findEffCardCfg(obj.card.id);
+        if(!cfg){
+            return false;
+        }
+
+        let ph = this.getPlayer(obj.srcplayer);
+
+        if(!ph){
+            return false;
+        }
+
+        if(cfg.typeId == EffectCardType.NPC){    
+            
+        }else if(cfg.typeId == EffectCardType.MAGIC){
+
+        }
+    };
+}

src/rooms/logic/Handler/PetHandler.ts

@@ -0,0 +1,19 @@
+import { Pet } from "../../schema/Pet";
+
+import {Skill} from "../skill/Skill";
+import { PlayerHandler } from "./PlayerHandler";
+
+export class PetHandler {
+    private _pet: Pet;
+    private _owner: PlayerHandler;
+    public init(apet: Pet, owner: PlayerHandler){
+        this._pet = apet;
+        this._owner = owner;
+    };    
+    public addGroupAttr(attrstr: string, value: number){
+
+    };
+    public addAttr(attrstr: string, value: number, sender: Skill){
+
+    };
+}

src/rooms/logic/Handler/PlayerHandler.ts

@@ -0,0 +1,58 @@
+import { Player } from "../../schema/Player";
+import { PetHandler } from "./PetHandler";
+import { HeroCfg } from "../../../cfg/parsers/HeroCfg";
+import { BattleHandler } from "./BattleHandler";
+import CfgMan from "../CfgMan";
+import { Card } from "rooms/schema/Card";
+import { Pet } from "rooms/schema/Pet";
+
+export class PlayerHandler {
+    public _player: Player;
+
+    public _playercfg: HeroCfg;
+
+    public _pets: PetHandler[];
+
+    private _owner: BattleHandler;
+
+    public init(aplayer: Player, owner: BattleHandler){
+        this._owner = owner;
+        this._player = aplayer;
+        this._playercfg = CfgMan.findPlayerCfg(this._player.heroId);
+    };
+
+    public getCurrCardCount(){
+        return 0;
+    };
+
+    public getTotalCardCount(){
+        return 0;
+    };
+
+    public newPet(): PetHandler {
+        let res = null;
+        let pr = null;
+        for(let key in this._player.pets){
+            let obj = this._player.pets.get(key);
+            if(obj.ap == 0){
+                res = obj;
+                break;
+            }
+        }
+        
+        if(res){
+            pr = new PetHandler;
+            pr.init(res, this);
+            this._pets.push(pr);
+        }
+
+        return pr;
+    };
+
+    public useCard(obj:
+        {card: Card, dbeff_cnt: number, dbpt_cnt: number, dstplayer: Player, dstpet: Pet})
+    {
+
+    }
+
+}

src/rooms/logic/skill/Condition.ts

@@ -0,0 +1,63 @@
+// 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
+//  - [English] https://www.cocos2d-x.org/docs/creator/manual/en/scripting/life-cycle-callbacks.html
+
+import { PlayerHandler } from "../Handler/PlayerHandler";
+import { CondType, CondDecideType } from "./SkillConst";
+
+export class Condition {
+    public _type: number;
+    private _cdt: CondDecideType;
+
+    public init(cond_type: number, cond_dt: CondDecideType){
+        this._type = cond_type;
+        this._cdt = cond_dt;
+    };
+
+    public isOK(tg_value: any, tg_owner: PlayerHandler, cond_v: number){
+        if(this._type == CondType.NO_COND){
+            return true;
+        }
+        let v;
+        switch (this._type) {
+            case CondType.CARD_COUNT_CURR:
+                v = tg_owner.getCurrCardCount();
+                return this._isok(v,cond_v,this._cdt);
+            case CondType.CARD_COUNT_TOTAL:
+                v = tg_owner.getTotalCardCount();
+                return this._isok(v,cond_v,this._cdt);
+            case CondType.CARD_ACTION_LINK:
+                return (tg_value == this._type);
+            case CondType.CARD_ACTION_LINK_OTHER:
+                return (tg_value == this._type);
+            case CondType.CARD_ACTION_LINK_SELF:
+                return (tg_value == this._type);
+            default:
+                break;
+        }
+        return true;
+    };
+
+    private _isok(realv: number, cfgv: number, dt: CondDecideType){
+        switch(dt){
+            case CondDecideType.NO_DECIDE:
+                return true;
+            case CondDecideType.LESS:
+                return realv < cfgv;
+            case CondDecideType.GREATER:
+                return realv > cfgv;
+            case CondDecideType.EQUAL:
+                return realv == cfgv;
+            default:
+                return false;
+        }
+    }
+};
+
+module.exports = Condition;

src/rooms/logic/skill/Skill.ts

@@ -0,0 +1,522 @@
+import { PetHandler } from "../Handler/PetHandler";
+import TriggerManager from "./TriggerMan";
+
+let con = require('constant');
+
+let SK_TYPE = con.SKILL_TYPE;
+let TG_TYPE = con.TRIGGER_TYPE;
+
+export class Skill {
+    _currCount: number;
+    _roundCount: number;
+    _startround: number;
+    _delayround: number;
+    _movegrid: number;
+    _visiongrid: number;
+    _id: number;
+    _data: any;
+    _type: any;
+    _show_effect: any[];
+    _params: any;
+    _tgctrl: any;
+    _condv: any;
+    _condv2: any;
+    _maxvalue: any;
+    _man: any;
+    _splashinfo: {};
+    _owner: PetHandler;
+    attr_value: any;
+    groupattr_value: any;
+    _aclst: any;
+    _skill1pr: any;
+    _skill2pr: any;
+    start: any;
+    _start: boolean;
+    _cb: any;
+    atk_attr: any;
+    _tmp: any;
+    atk_type: any;
+    atk_value: any;
+    atk_count: any;
+    _attrmap: any;
+    wudi: any;
+    _need_disappear: boolean;
+    _atkfirst: any;
+    _no_move: any;
+    _no_atk: any;
+    _no_atkback: any;
+    _hide: any;
+    _imm_ph: any;
+    _imm_magic: any;
+    _immeffid: number;
+    _immlst: any;
+    _acrp: any;
+    attr: any;
+    groupattr: any;
+    // LIFE-CYCLE CALLBACKS:
+
+    // onLoad () {};
+
+    // start () {};
+
+    // update (dt) {};
+
+    init(skillid: number, skilldata: any, manager: any) {
+        this._currCount = 0; // 当前计数
+        this._roundCount = 0; // 回合数
+        this._startround = 0; // 触发后回合数
+        this._delayround = 0; // 延迟回合数
+        this._movegrid = 0;
+        this._visiongrid = 0;
+        this._id = skillid;
+        this._data = skilldata;
+        this._type = skilldata.effec_id;
+        this._show_effect = this.initSkillShowEffectData();
+        // todo: 根据bufftype处理paramlst
+        this._params = TriggerManager.handleEffectParam(this._type, skilldata.effec_valu);
+        this._tgctrl = TriggerManager.addSkillTrigger(this._id, skilldata.triggerType, skilldata.condType, skilldata.condition_valu);
+
+        if (this._params.length > 4) {
+            this._maxvalue = this._params[4];
+        }
+        this._man = manager;
+    };
+
+    initSkillShowEffectData() {
+        //0: "3,0,1,1,1,1"
+        let _show_effect = [];
+        for (let i = 0; i < this._data.show_effect.length; i++) {
+            let effect = this._data.show_effect[i].split(',');
+            if (effect == '') {
+                continue;
+            }
+            let tmp = {
+                'times': Number(effect[0]),
+                'fight_type': Number(effect[1]),
+                'delay': Number(effect[2]),
+                'trigger': Number(effect[3]),
+                'effect': Number(effect[4]),
+                'loop': Number(effect[5]),
+                'speed': Number(effect[6]),
+                'data': this._data,
+                'sound': effect.length > 7? ''+effect[7]: ''
+            }
+            _show_effect.push(tmp);
+        }
+        return _show_effect;
+    };
+
+    triggerType() {
+        return this._data.trigger_id;
+    };
+
+    skillname() {
+        return this._data.name;
+    };
+
+    icon() {
+        return this._data.icon ? this._data.icon : '';
+    };
+
+    clear() {
+        this._id = 0;
+        this._data = null;
+    };
+
+    removeSelf() {
+
+    };
+
+    isSkill() {
+        return true;
+    };
+
+    // 是否是稀有技能
+    isRareSkill() {
+        return this._data && (this._data.is_sp == 1);
+    };
+
+    // 是否是位移技能
+    isMapSkill() {
+        return false; //this._type == SK_TYPE.DASH_ATK || this._type == SK_TYPE.BACK_ATK;
+    };
+
+    // 是否是获得即起效技能
+    isIMMSkill() {
+        return this._data && (this._data.trigger_id == TG_TYPE.IMM);
+    };
+
+    // 是否是抢先攻击技能
+    isDefFirstSkill() {
+        return this._data && (this._type == SK_TYPE.ATK_FIRST);
+    };
+
+    canComposition() {
+        return this._data.is_composition == 1;
+    };
+
+    // 割草技能溅射相关
+    splashInfo() {
+        return this._splashinfo;
+    };
+
+    trigger(param: any) {
+        //触发buff效果
+        let bok = TriggerManager.onTrigger(this, param);
+
+        this._currCount++;
+
+        if (!this.start) {
+            this._start = true;
+        }
+
+        this._cb && this._cb(this, param, bok);
+
+        this._man && this._man.onSkillTrigger(this, param, bok);
+    };
+
+    checkTrigger(tg_type: any, tg_value: any, tg_target: any, cb: any) {
+        if (tg_type == TG_TYPE.MYGROUPROUND_START) {
+            this._roundCount++;
+            if (this._start) {
+                this._startround++;
+            }
+        }
+        this._tgctrl.checkTrigger(tg_type, tg_value, this._condv, this._owner, () => {
+            cb && cb(this);
+            this.trigger(tg_target);
+        });
+    };
+
+    setOwner(owner: PetHandler) {
+        this._owner = owner;
+    };
+
+    setTriggerCallback(cb: any) {
+        this._cb = cb;
+    };
+
+    isOver() {
+        return false;
+    };
+
+    isSame(id: number) {
+        return this._id == id;
+    };
+
+    // 获取攻击属性
+    getAtkAttr() {
+        let n = this.atk_attr ? this.atk_attr : 0;
+        if (this._tmp) {
+            this.atk_attr = 0;
+        }
+        return n;
+    };
+
+    // 获取攻击类型
+    getAtkType() {
+        return this.atk_type ? this.atk_type : 0;
+    };
+
+    // 获取攻击力加值
+    getAtkValue() {
+        return this.atk_value ? this.atk_value : 0;
+    };
+
+    // 获取连续攻击次数
+    getAtkCount() {
+        let res = this.atk_count ? this.atk_count : 0;
+        this.atk_count = 0;
+        return res;
+    };
+
+    // 获取属性加值
+    getAttrValue(typestr: string) {
+        if (!this._attrmap) {
+            this._attrmap = {};
+        }
+        let v = this._attrmap[typestr];
+        if (v && (this._startround >= this._delayround)) {
+            if (this._tmp) {
+                this._attrmap[typestr] = 0;
+            }
+            return v;
+        }
+        return 0;
+    };
+
+    // 获取是否无敌
+    getInvincible() {
+        let bwudi = this.wudi;
+        if (this._tmp) {
+            this.wudi = false;
+        }
+        return bwudi;
+    };
+
+    // 获取是否需要消失
+    getDisappear() {
+        return this._need_disappear && (this._startround >= this._delayround);
+    };
+
+    // 获取是否先出手
+    getAtkFirst() {
+        let bok = this._atkfirst;
+        if (this._tmp) {
+            this._atkfirst = false;
+        }
+        return bok;
+    };
+
+    canMove() {
+        return !this._no_move;
+    };
+
+    canAtk() {
+        return !this._no_atk;
+    };
+
+    canAtkBack() {
+        return !this._no_atkback;
+    };
+
+    isHide() {
+        return this._hide;
+    };
+
+    // 物理免疫
+    isImmPH() {
+        return this._imm_ph;
+    };
+
+    // 魔法免疫
+    isImmMagic() {
+        return this._imm_magic;
+    };
+
+    // 技能免疫
+    isImmSkill(effectid: number) {
+        return this._immeffid && (this._immeffid == effectid);
+    };
+
+    // buff免疫
+    isImmBuff(buffid: number) {
+        if (!this._immlst) {
+            return false;
+        }
+        return this._immlst.includes(buffid);
+    };
+
+    // 获取增加的移动力
+    getMoveGrid() {
+        return this._movegrid;
+    };
+
+    // 获取增加的视野
+    getVisionGrid() {
+        return this._visiongrid;
+    };
+
+    // 设置攻击属性
+    setAtkAttr(attr_type: any) {
+        this.atk_attr = attr_type;
+    };
+
+    setTempAtkAttr(attr_type: any) {
+        this.atk_attr = attr_type;
+        this._tmp = true;
+    };
+
+    // 设置攻击类型
+    setAtkType(atk_type: any) {
+        this.atk_type = atk_type;
+    };
+
+    // 设置连续攻击次数
+    setAtkCount(value: number) {
+        if (this.canComposition()) {
+            this.atk_count ? (this.atk_count += value) : (this.atk_count = value);
+            if (typeof (this._maxvalue) == 'number') {
+                if ((value > 0 && this.atk_count > this._maxvalue) || (value < 0 && this.atk_count < this._maxvalue)) {
+                    this.atk_count = this._maxvalue;
+                }
+            }
+        } else {
+            this.atk_count = value;
+        }
+    };
+
+    addGroupAttr(attrstr: string, value: number) {
+        this._owner.addGroupAttr(attrstr, value);
+        this.groupattr_value = value;
+    };
+
+    // 是否是团队加属性技能
+    isGroupAttrSkill() {
+        if (this.groupattr) {
+            return true;
+        }
+        return false;
+    };
+
+    // 增加属性
+    addAttr(attrstr: string, value: number) {
+        // if(!this._attrmap){
+        //     this._attrmap = {};
+        // }
+        // this._tmp = btemp;
+        // let n = this._attrmap[attrstr];
+        // if(n){
+        //     this._attrmap[attrstr] = n + value;
+        // }else{
+        //     this._attrmap[attrstr] = value;
+        // }
+
+        // this._delayround = delaycount? delaycount: 0;
+        this._owner.addAttr(attrstr, value, this);
+    };
+
+    // 是否是加属性技能
+    isAttrSkill() {
+        if (this.attr) {
+            return true;
+        }
+        return false;
+    };
+
+    isDelAttr() {
+        return this.attr_value < 0;
+    };
+
+    isAddAttr() {
+        return this.attr_value > 0;
+    };
+
+    getLastAttr() {
+        return this.attr;
+    };
+
+    getLastAttrValue() {
+        return 0;
+    };
+
+    // 设置是否无敌
+    setInvincible(bInv: boolean) {
+        this.wudi = bInv;
+        this._tmp = true;
+    };
+
+    // 设置存在回合数（到达次数后消失）
+    setExistRound(count: number) {
+        this._delayround = count;
+        this._need_disappear = true;
+    };
+
+    // 设置不能移动
+    setNoMove() {
+        this._no_move = true;
+    };
+
+    getNoMove() {
+        return this._no_move;
+    };
+
+    // 设置不能攻击
+    setNoAtk() {
+        this._no_atk = true;
+    };
+
+    getNoAtk() {
+        return this._no_atk;
+    };
+
+    // 设置不能还击
+    setNoAtkBack() {
+        this._no_atkback = true;
+    };
+
+    getNoAtkBack() {
+        return this._no_atkback;
+    };
+
+    // 设置隐身属性
+    setHide() {
+        this._hide = true;
+    };
+
+    // 设置是否先出手
+    setTempAtkFirst() {
+        this._atkfirst = true;
+        this._tmp = true;
+    };
+
+    // 物理免疫
+    setPhImm() {
+        this._imm_ph = true;
+    };
+
+    // 魔法免疫
+    setMagicImm() {
+        this._imm_magic = true;
+    };
+
+    setSkillImm(effectid: number) {
+        this._immeffid = effectid;
+    };
+
+    setBuffImm(bufflst: any[]) {
+        if (!this._immlst) {
+            this._immlst = [];
+        }
+        if (!this.canComposition()) {
+            this._immlst.length = 0;
+        }
+        let nmax = bufflst.length;
+        // if(typeof(this._maxvalue) == 'number'){
+        //     if(nmax + this._immlst.length > this._maxvalue){
+        //         nmax = this._maxvalue - this._immlst.length;
+        //     }
+        // }
+        // 【2020.09.08】策划要求不限制
+        for (let i = 0; i < nmax; i++) {
+            if (!Number(bufflst[i])) {
+                break;
+            }
+            this._immlst.push(Number(bufflst[i]));
+        }
+    };
+
+    getMPReduce() {
+        return this._acrp ? this._acrp : 0;
+    };
+
+    setMPReduce(rper: number) {
+        this._acrp = rper;
+    };
+
+    clone() {
+        let obj = new Skill();
+        obj._currCount = 0; // 当前计数
+        obj._roundCount = 0; // 回合数
+        obj._startround = 0; // 触发后回合数
+        obj._delayround = 0; // 延迟回合数
+        obj._movegrid = 0;
+        obj._visiongrid = 0;
+        obj._id = this._id;
+        obj._data = this._data;
+        obj._type = this._type;
+        this._params.forEach((element: any) => {
+            if (!obj._params) {
+                obj._params = [];
+            }
+            obj._params.push(element);
+        });
+        // obj._params = this._params;
+        obj._tgctrl = this._tgctrl;
+        obj._condv = this._condv;
+        obj._man = this._man;
+        obj._show_effect = this._show_effect;
+        obj._maxvalue = this._maxvalue;
+        return obj;
+    };
+};

src/rooms/logic/skill/SkillConst.ts

@@ -0,0 +1,77 @@
+export const enum CondType
+{
+  NO_COND = 0,
+
+  CARD_COUNT_CURR = 1,
+
+  CARD_COUNT_TOTAL = 2,
+
+  CARD_ACTION_LINK = 3,
+
+  CARD_ACTION_LINK_OTHER = 4,
+
+  CARD_ACTION_LINK_SELF = 5,
+};
+
+export const enum CondDecideType {
+    NO_DECIDE = 0,
+
+    LESS = 1,
+
+    GREATER = 2,
+
+    EQUAL = 3,
+};
+
+export const enum TriggerType
+{
+  NO_COND = 0,
+
+  CARD_LINK_BEFORE = 1,
+
+  CARD_LINK_AFTER = 2,
+
+  CARD_USED = 3,
+
+  CARD_DROP = 4,
+
+  ROUND_END_MYSELF = 5,
+
+  CARD_GETTED = 6,
+};
+
+export const enum SkillType{
+    NONE = 0,
+    MAGIC = 1,
+    SHOUT = 2,
+    DEAD = 3,
+    HALO = 4,
+    NORMAL = 5,
+    EN_EFF = 6,
+    EN_POINT = 7,
+};
+
+export const enum SkillEffectType
+{
+    NONE = 0,
+    CARD_ADD = 1,
+    CARD_ADD_LIMIT = 2,
+    CARD_STEAL = 3,
+    CARD_CHG_EN = 4,
+    POWER_ENHANCE = 5,
+    HALO_ENHANCE = 5,
+    HURT_POWER = 6,
+    SUMMON_NPC = 7,
+    SUMMON_SKILL = 8,
+    TAUNT = 9,
+    HURT_HP = 10,
+    POWER_ADD_BORN = 11,
+    HURT_RED = 12,
+};
+
+export const enum EffectCardType
+{
+    NONE = 0,
+    NPC = 1,
+    MAGIC = 2,
+};

src/rooms/logic/skill/SkillMan.ts

@@ -0,0 +1,49 @@
+// 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 { Skill } from "./Skill";
+
+let SkillManager = {
+    _skillmap: {},
+    _tilemap: {},
+
+    onSkillTrigger(skill, param, bok) {
+        this._skillcb && this._skillcb(skill, param, bok, skill._owner);
+    },
+
+    getSkillMaxLevel(id) {
+        let obj = this._skillmap[id];
+        if (obj) {
+            return obj._data.max_lv;
+        } else {
+            return null;
+        }
+    },
+
+    addSkill(id, data) {
+        let obj = new Skill();
+        obj.init(id, data, this);
+        this._skillmap[id] = obj;
+    },
+
+    getSkill(id) {
+        let obj = this._skillmap[id];
+        if (obj) {
+            return obj.clone();
+            // return comutils.cloneFull(obj);
+        }
+        return null;
+    },
+
+    setSkillCallback(cb) {
+        this._skillcb = cb;
+    }
+};
+
+export default SkillManager;

src/rooms/logic/skill/Trigger.ts

@@ -0,0 +1,12 @@
+import { TriggerType } from "./SkillConst";
+
+export class Trigger {
+    private _type: TriggerType;
+    public init(tg_type: TriggerType){
+        this._type = tg_type;
+    };
+
+    isOK(tg_type: any){
+        return this._type == tg_type;
+    };
+}

src/rooms/logic/skill/TriggerCtrl.ts

@@ -0,0 +1,37 @@
+// 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 { PlayerHandler } from "../Handler/PlayerHandler";
+import { Condition } from "./Condition";
+import { TriggerType } from "./SkillConst";
+import { Trigger } from "./Trigger";
+
+export class TriggerCtrl{
+    private _id: number;
+    private _tg: Trigger;
+    private _cond: Condition;
+    
+    init(id:number, tgobj:Trigger, condobj: Condition){
+        this._id = id;
+        this._tg = tgobj;
+        this._cond = condobj;
+    };
+
+    checkTrigger(tg_type: TriggerType, tg_value: any, condv: any, tg_owner: PlayerHandler, callback: any){
+        if(tg_type == TriggerType.NO_COND){
+            // callback && callback();
+            return;
+        }
+        if(this._tg.isOK(tg_type)){
+            if(this._cond.isOK(tg_value, tg_owner, condv)){
+                callback && callback();
+            }
+        }
+    }
+}

src/rooms/logic/skill/TriggerMan.ts

@@ -0,0 +1,122 @@
+// 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 { PetHandler } from "../Handler/PetHandler";
+import { Condition } from "./Condition";
+import { Skill } from "./Skill";
+import { CondDecideType, CondType, SkillEffectType, TriggerType } from "./SkillConst";
+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) {
+        let obj = this.getSkillTrigger(skill_id);
+        if (!obj) {
+            obj = this._newTrigger(skill_id, tg_type, tg_cond, tg_cond_decide);
+            this._skillmap.set(skill_id, obj);
+        }
+        return obj;
+    },
+
+    addBuffTrigger(buff_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType) {
+        let obj = this.getBuffTrigger(buff_id);
+        if (!obj) {
+            obj = this._newTrigger(buff_id, tg_type, tg_cond, tg_cond_decide);
+            this._buffmap.set(buff_id, obj);
+        }
+        return obj;
+    },
+
+    getSkillTrigger(skill_id: number) {
+        return this._skillmap.get(skill_id);
+    },
+
+    getBuffTrigger(buff_id: number) {
+        return this._buffmap.get(buff_id);
+    },
+
+    _newTrigger(id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType) {
+        let tobj = this._triggermap.get(tg_type);
+        if (!tobj) {
+            tobj = new Trigger();
+            tobj.init(tg_type);
+            this._triggermap.set(tg_type, tobj);
+        }
+
+        let cobj = this._conditionmap.get(tg_cond);
+        if (!cobj) {
+            cobj = new Condition();
+            cobj.init(tg_cond, tg_cond_decide);
+            this._conditionmap.set(tg_cond, cobj);
+        }
+
+        let obj = new TriggerCtrl();
+        obj.init(id, tobj, cobj);
+
+        return obj;
+    },
+
+
+    onTrigger(sender: Skill, target: any) {
+        let effectid = sender._type;
+        let paramlst = sender._params;
+        let owner = sender._owner; 
+        let bResOk = true;
+        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.HALO_ENHANCE:
+            case SkillEffectType.HURT_POWER:
+            case SkillEffectType.SUMMON_NPC:
+            case SkillEffectType.SUMMON_SKILL:
+            case SkillEffectType.TAUNT:
+            case SkillEffectType.HURT_HP:
+            case SkillEffectType.POWER_ADD_BORN:
+            case SkillEffectType.HURT_RED:
+            break;
+        }
+
+        return bResOk;
+    },
+
+    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.HALO_ENHANCE:
+            case SkillEffectType.HURT_POWER:
+            case SkillEffectType.SUMMON_NPC:
+            case SkillEffectType.SUMMON_SKILL:
+            case SkillEffectType.TAUNT:
+            case SkillEffectType.HURT_HP:
+            case SkillEffectType.POWER_ADD_BORN:
+            case SkillEffectType.HURT_RED:
+            break;
+        }
+    },
+}
+
+export default TriggerManager;