340 lines
9.8 KiB
TypeScript
340 lines
9.8 KiB
TypeScript
import { SkillCfg } from "cfg/parsers/SkillCfg";
|
|
import { SKillEffectData } from "message/SkillInfo";
|
|
import CfgMan from "../CfgMan";
|
|
import { PetHandler } from "../Handler/PetHandler";
|
|
import { PlayerHandler } from "../Handler/PlayerHandler";
|
|
import { GameCampType, GameUnitType, SkillEffectType, SkillEffectValueType, SkillRangeUnitType, SkillType, TriggerType } from "./SkillConst";
|
|
import { SkillParam, SkillTarget } from "./SkillParam";
|
|
import { TriggerCtrl } from "./TriggerCtrl";
|
|
import TriggerManager from "./TriggerMan";
|
|
|
|
export class Skill {
|
|
_currCount: number;
|
|
_roundCount: number;
|
|
_startround: number;
|
|
_delayround: number;
|
|
_id: number;
|
|
_data: SkillCfg;
|
|
_type: any;
|
|
_param: number;
|
|
_tgctrl: TriggerCtrl;
|
|
_man: any;
|
|
_owner: PlayerHandler;
|
|
_start: boolean;
|
|
_cb: any;
|
|
|
|
ap: number = 0;
|
|
rd: number = 0;
|
|
// LIFE-CYCLE CALLBACKS:
|
|
|
|
// onLoad () {};
|
|
|
|
// start () {};
|
|
|
|
// update (dt) {};
|
|
|
|
init(skillid: number, skilldata: SkillCfg, manager: any) {
|
|
this._currCount = 0; // 当前计数
|
|
this._roundCount = 0; // 回合数
|
|
this._startround = 0; // 触发后回合数
|
|
this._delayround = 0; // 延迟回合数
|
|
this._id = skillid;
|
|
this._data = skilldata;
|
|
this._type = skilldata.skill_typeid;
|
|
|
|
// todo: 根据bufftype处理paramlst
|
|
this._param = TriggerManager.handleEffectParam(this._type, skilldata.eff_num);
|
|
this._tgctrl = TriggerManager.addSkillTrigger(this._id, skilldata.tigger_typeid,
|
|
skilldata.cond_typeid, skilldata.cond_rangeid, skilldata.cond_num);
|
|
|
|
this._man = manager;
|
|
};
|
|
|
|
triggerType() {
|
|
return this._data.tigger_typeid;
|
|
};
|
|
|
|
skillname() {
|
|
return this._data.name;
|
|
};
|
|
|
|
clear() {
|
|
this._id = 0;
|
|
this._data = null;
|
|
};
|
|
|
|
removeSelf() {
|
|
|
|
};
|
|
|
|
isSkill() {
|
|
return true;
|
|
};
|
|
|
|
isOver() {
|
|
return false;
|
|
};
|
|
|
|
isSame(id: number) {
|
|
return this._id == id;
|
|
};
|
|
|
|
isBornSkill(){
|
|
return this._type == SkillType.BORN;
|
|
};
|
|
|
|
isDieSkill(){
|
|
return this._type == SkillType.DEAD;
|
|
};
|
|
|
|
isHaloSkill(){
|
|
return this._type == SkillType.HALO;
|
|
};
|
|
|
|
isTauntSkill(){
|
|
return this._data.effect_typeid == SkillEffectType.TAUNT;
|
|
};
|
|
|
|
isTransEffCardSkill(){
|
|
return this._data.effect_typeid == SkillEffectType.CARD_CHG_EN;
|
|
};
|
|
|
|
isSingleTarget(){
|
|
switch(this._data.rangeid){
|
|
case SkillRangeUnitType.SELF:
|
|
case SkillRangeUnitType.SINGLE:
|
|
case SkillRangeUnitType.OTHER:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
|
|
isAllTarget(){
|
|
return this._data.rangeid == SkillRangeUnitType.ALL;
|
|
};
|
|
|
|
isInRange(srcpet: PetHandler, dstpet: PetHandler){
|
|
switch(this._data.rangeid){
|
|
case SkillRangeUnitType.SELF:
|
|
return srcpet == dstpet;
|
|
case SkillRangeUnitType.SINGLE:
|
|
return false;
|
|
case SkillRangeUnitType.OTHER:
|
|
return false;
|
|
case SkillRangeUnitType.ALL:
|
|
return true;
|
|
case SkillRangeUnitType.ALL_EXSELF:
|
|
return srcpet != dstpet;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
|
|
isEffSelfPet(srcpet: PetHandler, dstpet: PetHandler){
|
|
if(this._data.friendlyid != GameCampType.SELF){
|
|
return false;
|
|
}
|
|
let tgok = false;
|
|
switch(this._data.targetid){
|
|
case GameUnitType.BATTLEUNIT:
|
|
tgok = this.isInRange(srcpet, dstpet);
|
|
case GameUnitType.HERO:
|
|
tgok = dstpet._isHero;
|
|
case GameUnitType.PET:
|
|
if(!dstpet._isHero){
|
|
tgok = this.isInRange(srcpet, dstpet);
|
|
}
|
|
}
|
|
return tgok;
|
|
};
|
|
|
|
getTargets(param: SkillParam): SkillTarget[]{
|
|
return this._owner._owner.getSkillTargets(this, param);
|
|
};
|
|
|
|
getEnhanceValue(param: SkillParam): number{
|
|
return CfgMan.calcEnhanceValue(this._data.edd_effid, this._data.edd_effnum, param.edd_cnt, param.cardpoint);
|
|
};
|
|
|
|
getEffValue(ap?: number): number{
|
|
return CfgMan.calcEffectValue(this._data.eff_numtypeid,
|
|
this._data.num_signid, this._data.eff_num, ap? ap: this._data.eff_num);
|
|
};
|
|
|
|
trigger(param: SkillParam, cb?: any) {
|
|
//触发buff效果
|
|
let res = TriggerManager.onTrigger(this, param);
|
|
|
|
this._currCount++;
|
|
|
|
if (!this._start) {
|
|
this._start = true;
|
|
}
|
|
|
|
cb && cb(this, param, res);
|
|
|
|
this._cb && this._cb(this, param, res);
|
|
|
|
this._man && this._man.onSkillTrigger(this, param, res);
|
|
|
|
if(this.isTotalCardSkill()){
|
|
this._owner && this._owner.resetTotalCard();
|
|
}
|
|
return res;
|
|
};
|
|
|
|
checkTrigger(tg_type: TriggerType, tg_value: any, tg_target: SkillParam, cb?: any) {
|
|
if (tg_type == TriggerType.ROUND_START_MYSELF) {
|
|
this._roundCount++;
|
|
if (this._start) {
|
|
this._startround++;
|
|
}
|
|
}
|
|
if(this._tgctrl.checkTrigger(tg_type, tg_value, this._owner)){
|
|
this.trigger(tg_target, cb);
|
|
return 1;
|
|
}else{
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
handleCard(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
|
|
let res = effvalue;
|
|
switch(efftype){
|
|
case SkillEffectType.CARD_ADD:
|
|
if(tgt.dsttype == GameUnitType.PLAYER){
|
|
let n = tgt.dst.addCard(res);
|
|
if(n >= 0){
|
|
tgt.success(efftype, n);
|
|
}
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
break;
|
|
case SkillEffectType.CARD_ADD_LIMIT:
|
|
if(tgt.dsttype == GameUnitType.PLAYER){
|
|
let n = tgt.dst.addCardLimit(res);
|
|
if(n >= 0){
|
|
tgt.success(efftype, n);
|
|
}
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
break;
|
|
case SkillEffectType.CARD_STEAL:
|
|
if(tgt.dsttype == GameUnitType.PLAYER){
|
|
let n = tgt.srcplayer.stealCard(tgt.dst, res);
|
|
if(n >= 0){
|
|
tgt.success(efftype, n);
|
|
}
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
break;
|
|
case SkillEffectType.CARD_CHG_EN:
|
|
//todo: 暂不处理
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
|
|
handlePower(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
|
|
switch(efftype){
|
|
case SkillEffectType.POWER_ENHANCE:
|
|
case SkillEffectType.POWEREX_ENHANCE:
|
|
if(tgt.dsttype != GameUnitType.NONE && tgt.dsttype != GameUnitType.PLAYER){
|
|
let n = efftype == SkillEffectType.POWER_ENHANCE? tgt.dst.addBaseAP(effvalue): tgt.dst.addExAP(effvalue);
|
|
tgt.success(efftype, n);
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
break;
|
|
case SkillEffectType.HURT_POWER:
|
|
if(tgt.dsttype != GameUnitType.NONE && tgt.dsttype != GameUnitType.PLAYER){
|
|
let n = tgt.dst.beHurt(effvalue);
|
|
tgt.success(efftype, n);
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
|
|
handleHP(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
|
|
if(efftype == SkillEffectType.HURT_HP){
|
|
if(tgt.dsttype == GameUnitType.PLAYER){
|
|
let n = tgt.dst.addHp(effvalue);
|
|
tgt.success(efftype, n);
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
}
|
|
};
|
|
|
|
summon(efftype: SkillEffectType, exparam: SkillParam, tgt: SkillTarget){
|
|
let ncount = 1 + exparam.edd_cnt;
|
|
switch(efftype){
|
|
case SkillEffectType.SUMMON_NPC:
|
|
let n = tgt.srcplayer.summonPet(this._data.quoteunitid, ncount, exparam);
|
|
if(n >= 0){
|
|
tgt.success(efftype, n);
|
|
}
|
|
break;
|
|
case SkillEffectType.SUMMON_SKILL:
|
|
let res = tgt.srcplayer.useSkill(this._data.quoteskillid, ncount, exparam);
|
|
if(res){
|
|
tgt.success(efftype, res.length);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
|
|
addBuff(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
|
|
|
|
};
|
|
|
|
reduceHurt(efftype: SkillEffectType, effvalue: number, tgt: SkillTarget){
|
|
if(efftype == SkillEffectType.HURT_REDUCE){
|
|
if(tgt.dsttype != GameUnitType.NONE && tgt.dsttype != GameUnitType.PLAYER){
|
|
let n = tgt.dst.addReduceHurt(effvalue);
|
|
tgt.success(efftype, n);
|
|
}else{
|
|
tgt.fail(efftype, -1);
|
|
}
|
|
}
|
|
};
|
|
|
|
setOwner(owner: PlayerHandler) {
|
|
this._owner = owner;
|
|
};
|
|
|
|
setTriggerCallback(cb: any) {
|
|
this._cb = cb;
|
|
};
|
|
|
|
isTotalCardSkill(){
|
|
return this._tgctrl._cond.isTempTotalCard();
|
|
};
|
|
|
|
clone() {
|
|
let obj = new Skill();
|
|
obj._currCount = 0; // 当前计数
|
|
obj._roundCount = 0; // 回合数
|
|
obj._startround = 0; // 触发后回合数
|
|
obj._delayround = 0; // 延迟回合数
|
|
obj._id = this._id;
|
|
obj._data = this._data;
|
|
obj._type = this._type;
|
|
obj._param = this._param;
|
|
obj._tgctrl = this._tgctrl;
|
|
obj._man = this._man;
|
|
return obj;
|
|
};
|
|
};
|