From f7d83f8c0b3e0bb9052696b5dc120000cf8873f4 Mon Sep 17 00:00:00 2001 From: yuexin Date: Wed, 2 Dec 2020 20:07:32 +0800 Subject: [PATCH] add logic folder --- src/rooms/logic/CfgMan.ts | 26 ++ src/rooms/logic/Handler/BattleHandler.ts | 59 +++ src/rooms/logic/Handler/PetHandler.ts | 19 + src/rooms/logic/Handler/PlayerHandler.ts | 58 +++ src/rooms/logic/skill/Condition.ts | 63 +++ src/rooms/logic/skill/Skill.ts | 522 +++++++++++++++++++++++ src/rooms/logic/skill/SkillConst.ts | 77 ++++ src/rooms/logic/skill/SkillMan.ts | 49 +++ src/rooms/logic/skill/Trigger.ts | 12 + src/rooms/logic/skill/TriggerCtrl.ts | 37 ++ src/rooms/logic/skill/TriggerMan.ts | 122 ++++++ 11 files changed, 1044 insertions(+) create mode 100644 src/rooms/logic/CfgMan.ts create mode 100644 src/rooms/logic/Handler/BattleHandler.ts create mode 100644 src/rooms/logic/Handler/PetHandler.ts create mode 100644 src/rooms/logic/Handler/PlayerHandler.ts create mode 100644 src/rooms/logic/skill/Condition.ts create mode 100644 src/rooms/logic/skill/Skill.ts create mode 100644 src/rooms/logic/skill/SkillConst.ts create mode 100644 src/rooms/logic/skill/SkillMan.ts create mode 100644 src/rooms/logic/skill/Trigger.ts create mode 100644 src/rooms/logic/skill/TriggerCtrl.ts create mode 100644 src/rooms/logic/skill/TriggerMan.ts diff --git a/src/rooms/logic/CfgMan.ts b/src/rooms/logic/CfgMan.ts new file mode 100644 index 0000000..412404a --- /dev/null +++ b/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; \ No newline at end of file diff --git a/src/rooms/logic/Handler/BattleHandler.ts b/src/rooms/logic/Handler/BattleHandler.ts new file mode 100644 index 0000000..4e0c708 --- /dev/null +++ b/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){ + + } + }; +} \ No newline at end of file diff --git a/src/rooms/logic/Handler/PetHandler.ts b/src/rooms/logic/Handler/PetHandler.ts new file mode 100644 index 0000000..eda0f8d --- /dev/null +++ b/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){ + + }; +} \ No newline at end of file diff --git a/src/rooms/logic/Handler/PlayerHandler.ts b/src/rooms/logic/Handler/PlayerHandler.ts new file mode 100644 index 0000000..b3ebf6c --- /dev/null +++ b/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}) + { + + } + +} \ No newline at end of file diff --git a/src/rooms/logic/skill/Condition.ts b/src/rooms/logic/skill/Condition.ts new file mode 100644 index 0000000..c3bd762 --- /dev/null +++ b/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; \ No newline at end of file diff --git a/src/rooms/logic/skill/Skill.ts b/src/rooms/logic/skill/Skill.ts new file mode 100644 index 0000000..377c35c --- /dev/null +++ b/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; + }; +}; \ No newline at end of file diff --git a/src/rooms/logic/skill/SkillConst.ts b/src/rooms/logic/skill/SkillConst.ts new file mode 100644 index 0000000..794dee3 --- /dev/null +++ b/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, +}; \ No newline at end of file diff --git a/src/rooms/logic/skill/SkillMan.ts b/src/rooms/logic/skill/SkillMan.ts new file mode 100644 index 0000000..ec63384 --- /dev/null +++ b/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; \ No newline at end of file diff --git a/src/rooms/logic/skill/Trigger.ts b/src/rooms/logic/skill/Trigger.ts new file mode 100644 index 0000000..56310e1 --- /dev/null +++ b/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; + }; +} diff --git a/src/rooms/logic/skill/TriggerCtrl.ts b/src/rooms/logic/skill/TriggerCtrl.ts new file mode 100644 index 0000000..f015239 --- /dev/null +++ b/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(); + } + } + } +} diff --git a/src/rooms/logic/skill/TriggerMan.ts b/src/rooms/logic/skill/TriggerMan.ts new file mode 100644 index 0000000..65be66e --- /dev/null +++ b/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;