307 lines
9.5 KiB
TypeScript
307 lines
9.5 KiB
TypeScript
import { EffectCardCfg } from "cfg/parsers/EffectCardCfg";
|
|
import { HeroCfg } from "cfg/parsers/HeroCfg";
|
|
import { SkillCfg } from "cfg/parsers/SkillCfg";
|
|
import { UnitCfg } from "cfg/parsers/UnitCfg";
|
|
import arrUtil from "../../utils/array.util";
|
|
import { BaseConst } from "../../constants/BaseConst";
|
|
import { EffectCardType, EnhanceCalcType, EnhanceCustomType, EnhanceEffectType, SkillEffectSignType, SkillEffectValueType, SkillTargetType } from "./skill/SkillConst";
|
|
|
|
let CfgMan = {
|
|
/**
|
|
* findPlayerCfg
|
|
*playerid: numer
|
|
*/
|
|
_cardcache: new Map(),
|
|
|
|
_typecards: new Map(),
|
|
|
|
findPlayerCfg(playerid: number): HeroCfg{
|
|
return global.$cfg.get(BaseConst.HERO).get(playerid);
|
|
},
|
|
|
|
findUnitCfg(unitid: number): UnitCfg{
|
|
return global.$cfg.get(BaseConst.UNIT).get(unitid);
|
|
},
|
|
|
|
findSkillCfg(skillid: number): SkillCfg{
|
|
return global.$cfg.get(BaseConst.SKILL).get(skillid);
|
|
},
|
|
|
|
findEffCardCfg(cardid: number): EffectCardCfg{
|
|
return global.$cfg.get(BaseConst.EFFECTCARD).get(cardid);
|
|
},
|
|
|
|
calcEnhanceValue(
|
|
eT: EnhanceEffectType,
|
|
eV: number,
|
|
eC: number,
|
|
aP: number,
|
|
): number{
|
|
switch(eT){
|
|
case EnhanceEffectType.EN_POWER_BYAP:
|
|
case EnhanceEffectType.EN_EFFV_BYAP:
|
|
return eV * eC * aP;
|
|
case EnhanceEffectType.EN_POWER_BYCFG:
|
|
case EnhanceEffectType.EN_EFFV_BYCV:
|
|
return eV * eC;
|
|
case EnhanceEffectType.EN_QCOUNT:
|
|
return eC;
|
|
default:
|
|
return 0;
|
|
}
|
|
},
|
|
|
|
calcEffectValue(
|
|
eVT: SkillEffectValueType,
|
|
eST: SkillEffectSignType,
|
|
eV: number,
|
|
eVMax: number,
|
|
aP: number
|
|
): number{
|
|
let n = this.roundV(eV, eVMax);
|
|
switch(eST){
|
|
case SkillEffectSignType.PERCENT:
|
|
n /= 100;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch(eVT){
|
|
case SkillEffectValueType.RATIO_AP:
|
|
n *= aP;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return n;
|
|
},
|
|
|
|
_calcValue(ev: number, et: SkillEffectSignType){
|
|
let n = ev;
|
|
switch(et){
|
|
case SkillEffectSignType.PERCENT:
|
|
n /= 100;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return n;
|
|
},
|
|
|
|
calcEffctValueEx(
|
|
eCT: EnhanceCustomType,
|
|
eVT: SkillEffectValueType,
|
|
eST: SkillEffectSignType,
|
|
eV: number,
|
|
aP: number,
|
|
sP: number)
|
|
{
|
|
let n = this._calcValue(eV, eST);
|
|
if(eCT == EnhanceCustomType.EFF_VALUE){
|
|
switch(eVT){
|
|
case SkillEffectValueType.RATIO_AP:
|
|
aP && (n *= aP);
|
|
break;
|
|
case SkillEffectValueType.RATIO_SP:
|
|
sP && (n *= sP);
|
|
break;
|
|
}
|
|
}
|
|
return n;
|
|
},
|
|
|
|
canEnhanceValue(eCT: EnhanceCustomType, eET: EnhanceEffectType): boolean{
|
|
switch(eCT){
|
|
case EnhanceCustomType.EFF_VALUE:
|
|
return eET == EnhanceEffectType.EN_EFFV_BYAP ||
|
|
eET == EnhanceEffectType.EN_EFFV_BYAP_MAX ||
|
|
eET == EnhanceEffectType.EN_EFFV_BYAP_MM ||
|
|
eET == EnhanceEffectType.EN_EFFV_BYCV ||
|
|
eET == EnhanceEffectType.EN_EFFV_BYCV_MAX ||
|
|
eET == EnhanceEffectType.EN_EFFV_BYCV_MM;
|
|
case EnhanceCustomType.ENHANCE_MAGIC:
|
|
return eET == EnhanceEffectType.EN_EM;
|
|
case EnhanceCustomType.QUOTE_TIMES:
|
|
case EnhanceCustomType.GET_TIMES:
|
|
return eET == EnhanceEffectType.EN_QCOUNT ||
|
|
eET == EnhanceEffectType.EN_QCOUNT_MAX ||
|
|
eET == EnhanceEffectType.EN_QCOUNT_MM;
|
|
case EnhanceCustomType.POWER:
|
|
return eET == EnhanceEffectType.EN_POWER_BYAP ||
|
|
eET == EnhanceEffectType.EN_POWER_BYCFG;
|
|
case EnhanceCustomType.RELEASE_TIMES:
|
|
return eET == EnhanceEffectType.EN_SKILL_RELEASE_MAX ||
|
|
eET == EnhanceEffectType.EN_SKILL_RELEASE_MIN ||
|
|
eET == EnhanceEffectType.EN_SKILL_RELEASE_MM;
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
},
|
|
|
|
randomEffValue(
|
|
vMin: number,
|
|
vMax: number,
|
|
|
|
eET: EnhanceEffectType,
|
|
|
|
eST: SkillEffectSignType,
|
|
eEV: number,
|
|
|
|
aC: number
|
|
): number{
|
|
let eV = this._calcValue(eEV, eST);
|
|
let nmin = vMin;
|
|
let nmax = vMax;
|
|
if(aC){
|
|
switch(eET){
|
|
case EnhanceEffectType.EN_EFFV_BYCV:
|
|
nmin += eV * aC;
|
|
break;
|
|
case EnhanceEffectType.EN_EFFV_BYAP:
|
|
nmin += eV * aC;
|
|
break;
|
|
case EnhanceEffectType.EN_QCOUNT:
|
|
nmin += aC;
|
|
break;
|
|
case EnhanceEffectType.EN_POWER_BYCFG:
|
|
nmin += eV * aC;
|
|
nmax = nmin;
|
|
break;
|
|
case EnhanceEffectType.EN_POWER_BYAP:
|
|
nmin += eV * aC;
|
|
nmax = nmin;
|
|
break;
|
|
case EnhanceEffectType.EN_SKILL_RELEASE_MIN:
|
|
nmin += aC;
|
|
break;
|
|
case EnhanceEffectType.EN_SKILL_RELEASE_MAX:
|
|
nmax += aC;
|
|
break;
|
|
case EnhanceEffectType.EN_QCOUNT_MAX:
|
|
nmax += aC;
|
|
break;
|
|
case EnhanceEffectType.EN_EFFV_BYCV_MAX:
|
|
nmax += eV * aC;
|
|
break;
|
|
case EnhanceEffectType.EN_EFFV_BYCV_MM:
|
|
nmin += eV * aC;
|
|
nmax += eV * aC;
|
|
break;
|
|
case EnhanceEffectType.EN_EFFV_BYAP_MAX:
|
|
nmax += eV * aC;
|
|
break;
|
|
case EnhanceEffectType.EN_EFFV_BYAP_MM:
|
|
nmin += eV * aC;
|
|
nmax += eV * aC;
|
|
break;
|
|
case EnhanceEffectType.EN_QCOUNT_MM:
|
|
nmin += aC;
|
|
nmax += aC;
|
|
break;
|
|
case EnhanceEffectType.EN_SKILL_RELEASE_MM:
|
|
nmin += aC;
|
|
nmax += aC;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return this.roundV(nmin, nmax);
|
|
},
|
|
|
|
getTargetByCard(cardid: number): SkillTargetType{
|
|
let obj = this._cardcache.get(cardid + '');
|
|
if(obj){
|
|
return obj.target;
|
|
}
|
|
|
|
let cardcfg = this.findEffCardCfg(cardid);
|
|
if(!cardcfg){
|
|
return SkillTargetType.NONE;
|
|
}
|
|
let res = SkillTargetType.NONE;
|
|
|
|
let skilllst: number[] = [];
|
|
|
|
cardcfg.quoteskill1id && skilllst.push(cardcfg.quoteskill1id);
|
|
cardcfg.quoteskill2id && skilllst.push(cardcfg.quoteskill2id);
|
|
cardcfg.quoteskill3id && skilllst.push(cardcfg.quoteskill3id);
|
|
cardcfg.quoteskill4id && skilllst.push(cardcfg.quoteskill4id);
|
|
|
|
if(cardcfg.type_id == EffectCardType.NPC){
|
|
let unitcfg = this.findUnitCfg(cardcfg.stageunit_id);
|
|
if(unitcfg){
|
|
unitcfg.base_skill1id && skilllst.push(unitcfg.base_skill1id);
|
|
unitcfg.base_skill2id && skilllst.push(unitcfg.base_skill2id);
|
|
unitcfg.base_skill3id && skilllst.push(unitcfg.base_skill3id);
|
|
}
|
|
}
|
|
|
|
for(let i = 0; i < skilllst.length; i++){
|
|
let skillcfg = this.findSkillCfg(skilllst[i]);
|
|
if(skillcfg && skillcfg.select_targetID != SkillTargetType.NONE){
|
|
res = skillcfg.select_targetID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
this._cardcache.set(cardid + '', {target: res});
|
|
|
|
return res;
|
|
},
|
|
|
|
randomCard(subtype: number): number{
|
|
if(this._typecards.size == 0){
|
|
for(let [key, val] of global.$cfg.get(BaseConst.EFFECTCARD)){
|
|
let id1 = val.affix1id;
|
|
let id2 = val.affix2id;
|
|
if(id1){
|
|
let lst = this._typecards.get(id1 + '');
|
|
if(!lst){
|
|
lst = [key];
|
|
this._typecards.set(id1 + '', lst);
|
|
}else{
|
|
lst.push(key);
|
|
}
|
|
}
|
|
|
|
if(id2 && id2 != id1){
|
|
let lst = this._typecards.get(id2 + '');
|
|
if(!lst){
|
|
lst = [key];
|
|
this._typecards.set(id2 + '', lst);
|
|
}else{
|
|
lst.push(key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let obj = this._typecards.get(subtype + '');
|
|
|
|
return obj? arrUtil.randomOne(obj): 0;
|
|
},
|
|
|
|
roundV(minv: number, maxv: number): number{
|
|
if(!maxv){
|
|
return minv;
|
|
}
|
|
return Math.round(Math.random() * maxv + minv);
|
|
},
|
|
|
|
hasSummonPetSkill(skillids: number[]){
|
|
let bok = false;
|
|
for(let i=0; i<skillids.length;i++){
|
|
let cfg = this.findSkillCfg(skillids[i]);
|
|
if(cfg && cfg.quoteunitid && cfg.tigger_typeid == 0){
|
|
bok = true;
|
|
break;
|
|
}
|
|
}
|
|
return bok;
|
|
}
|
|
};
|
|
|
|
export default CfgMan;
|