842 lines
25 KiB
TypeScript
842 lines
25 KiB
TypeScript
import { Player } from "../../schema/Player";
|
|
import { PetHandler } from "./PetHandler";
|
|
import { HeroCfg } from "../../../cfg/parsers/HeroCfg";
|
|
import { BattleHandler } from "./BattleHandler";
|
|
import CfgMan from "../CfgMan";
|
|
import { Pet } from "rooms/schema/Pet";
|
|
import { CondDecideType, CondType, EffectCardType, GameUnitType, SkillEffectType, SkillType, SkillUserType, TriggerType } from "../skill/SkillConst";
|
|
import { UnitCfg } from "cfg/parsers/UnitCfg";
|
|
import { Skill } from "../skill/Skill";
|
|
import { SkillParam, SkillTarget } from "../skill/SkillParam";
|
|
import SkillMan from "../skill/SkillMan";
|
|
import { Card } from "rooms/schema/Card";
|
|
import arrUtil from "utils/array.util";
|
|
import { SKillEffectData } from "message/SkillInfo";
|
|
|
|
export class PlayerHandler {
|
|
public _player: Player;
|
|
|
|
public _playercfg: HeroCfg;
|
|
|
|
public _self: PetHandler;
|
|
|
|
public _unitcfg: UnitCfg;
|
|
|
|
public _pets: PetHandler[] = [];
|
|
|
|
public _owner: BattleHandler;
|
|
|
|
public _friend: PlayerHandler;
|
|
|
|
public _cardstate: CondType = CondType.NO_COND;
|
|
|
|
_totalcc: number = 0;
|
|
|
|
private _totalem: number = 0;
|
|
|
|
public init(aplayer: Player, owner: BattleHandler){
|
|
this._owner = owner;
|
|
this._player = aplayer;
|
|
this._friend = null;
|
|
this.updateHero(true);
|
|
};
|
|
|
|
public clear(){
|
|
this._pets.forEach((item: PetHandler) =>{
|
|
this.delPet(item, true);
|
|
});
|
|
this._self = null;
|
|
this._pets.length = 0;
|
|
this._totalcc = 0;
|
|
this._totalem = 0;
|
|
this._cardstate = CondType.NO_COND;
|
|
};
|
|
|
|
public updateHero(bclear: boolean = false){
|
|
bclear && this.clear();
|
|
this._playercfg = CfgMan.findPlayerCfg(this._player.heroId);
|
|
this._self = new PetHandler();
|
|
this._self.init(null, this, 0);
|
|
this._self._isHero = true;
|
|
let lst = this._playercfg.ex_skill? [this._playercfg.ex_skill]: null;
|
|
let ps = new SkillParam(0, 0, 0, this, this._self, null, null);
|
|
this._self.loadData(this._playercfg.herounit_id, ps, lst);
|
|
this._unitcfg = this._playercfg && CfgMan.findUnitCfg(this._playercfg.herounit_id);
|
|
};
|
|
|
|
public getCurrCardCount(){
|
|
return this._player.cards.size;
|
|
};
|
|
|
|
public getTotalCardCount(ct: CondDecideType, v: number): number{
|
|
if(ct == CondDecideType.EQUAL && this._totalcc > v){
|
|
return v;
|
|
}
|
|
return this._totalcc;
|
|
};
|
|
|
|
public getId(): string{
|
|
return this._player.id + '';
|
|
};
|
|
|
|
public newPet(): PetHandler {
|
|
let res = null;
|
|
let pr = null;
|
|
let n = 0;
|
|
for(let [key, obj] of this._player.pets){
|
|
if(n != 0){
|
|
if(obj.state == 0 || obj.state == 2){
|
|
res = obj;
|
|
break;
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
|
|
if(res){
|
|
pr = new PetHandler;
|
|
pr.init(res, this, n);
|
|
this._pets.push(pr);
|
|
}
|
|
|
|
return pr;
|
|
};
|
|
|
|
public delPet(pet: PetHandler, isbatchdel: boolean = false){
|
|
if(!pet){
|
|
return;
|
|
}
|
|
this.onEMChanged(pet._enmagic);//删除法强
|
|
pet.clear(isbatchdel);
|
|
|
|
if(!isbatchdel){
|
|
let idx = this._pets.indexOf(pet);
|
|
(idx >= 0) && this._pets.splice(idx, 1);
|
|
}
|
|
|
|
this._owner.onDelPetNotify(pet);
|
|
};
|
|
|
|
public getPet(pet: Pet): PetHandler{
|
|
return this._pets.find((item:PetHandler)=>{
|
|
return item._pet == pet;
|
|
});
|
|
};
|
|
|
|
public findPet(pos: number): PetHandler{
|
|
if(pos < 0){
|
|
return null;
|
|
}
|
|
if(pos == 0){
|
|
return this._self;
|
|
}
|
|
return this._pets.find((item:PetHandler)=>{
|
|
return item._idx == pos;
|
|
})
|
|
};
|
|
|
|
public exportAllPets(skill: Skill, param: SkillParam, expet: PetHandler, dst: SkillTarget[]): SkillTarget[]{
|
|
if(!dst){
|
|
return null;
|
|
}
|
|
let ct = skill._data.targetid;
|
|
switch(ct){
|
|
case GameUnitType.BATTLEUNIT:
|
|
{
|
|
let lst = this._pets.reverse();
|
|
lst.forEach(element => {
|
|
if(expet != element && element.isAlive()){
|
|
dst.push(new SkillTarget(skill, param.srcplayer, param.srcpet, element, GameUnitType.PET));
|
|
}
|
|
});
|
|
(expet != this._self) && dst.push(new SkillTarget(skill, param.srcplayer, param.srcpet, this._self, GameUnitType.HERO));
|
|
}
|
|
break;
|
|
case GameUnitType.HERO:
|
|
(expet != this._self) && dst.push(new SkillTarget(skill, param.srcplayer, param.srcpet, this._self, GameUnitType.HERO));
|
|
break;
|
|
case GameUnitType.PET:
|
|
{
|
|
let lst = this._pets.reverse();
|
|
lst.forEach(element => {
|
|
if(expet != element && element.isAlive()){
|
|
dst.push(new SkillTarget(skill, param.srcplayer, param.srcpet, element, GameUnitType.PET));
|
|
}
|
|
});
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return dst;
|
|
};
|
|
|
|
public useCard(obj: SkillParam, oldpos?: number)
|
|
{
|
|
let cfg = CfgMan.findEffCardCfg(obj.cardid);
|
|
if(!cfg){
|
|
return false;
|
|
}
|
|
|
|
let lst = [];
|
|
cfg.quoteskill1id && lst.push(cfg.quoteskill1id);
|
|
cfg.quoteskill2id && lst.push(cfg.quoteskill2id);
|
|
cfg.quoteskill3id && lst.push(cfg.quoteskill3id);
|
|
cfg.quoteskill4id && lst.push(cfg.quoteskill4id);
|
|
|
|
let oldpet = this.findPet(oldpos);
|
|
if(oldpet == this._self){
|
|
oldpet = null;
|
|
}
|
|
|
|
if(cfg.type_id == EffectCardType.NPC || cfg.type_id == EffectCardType.NPC_CUSTOM){
|
|
let exap = 0;
|
|
if(oldpet){
|
|
exap = oldpet.totalAP();
|
|
this.delPet(oldpet);
|
|
}
|
|
|
|
let pet = this.newPet();
|
|
if(!pet){
|
|
return false;
|
|
}
|
|
obj.srcpet = pet;
|
|
if(!obj.dstpet){
|
|
if(obj.dstplayer && obj.dstplayer.isMyPet(pet)){
|
|
obj.dstpet = pet;
|
|
}
|
|
}
|
|
pet.loadData(cfg.stageunit_id, obj, lst, exap);
|
|
}else if(cfg.type_id == EffectCardType.MAGIC){
|
|
if(oldpet && CfgMan.hasSummonPetSkill(lst)){
|
|
this.delPet(oldpet);
|
|
}
|
|
this.useSkills(lst, obj);
|
|
}
|
|
};
|
|
|
|
public useSkills(skills: number[], obj: SkillParam)
|
|
{
|
|
skills && skills.forEach((item: number)=>{
|
|
this.handleSkill(item, 1, 0, this._self, this._self, obj);
|
|
});
|
|
};
|
|
|
|
public newSkill(skillid: number): Skill{
|
|
let obj = SkillMan.getSkill(skillid);
|
|
if(obj){
|
|
obj.setOwner(this);
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
public handleSkill(skillid: number, count: number, tgtflag: number, pet: PetHandler, sender?: PetHandler, param?: SkillParam):SkillTarget[]{
|
|
let cfg = CfgMan.findSkillCfg(skillid);
|
|
if(!cfg){
|
|
return null;
|
|
}
|
|
let sp = param;
|
|
let lst: Skill[] = [];
|
|
if(cfg.skill_typeid == SkillType.MAGIC){
|
|
for(let i = 0; i < count; i++){
|
|
let sk = this.newSkill(skillid);
|
|
sk.setOrignParam(param.edd_cnt, param.cardpoint, sender, pet, tgtflag);
|
|
lst.push(sk);
|
|
}
|
|
}else {
|
|
let bhalo = false;
|
|
let bchged = false;
|
|
let sl = pet.addSkill(skillid, count, param.edd_cnt, param.cardpoint, tgtflag, sender);
|
|
if(sl && sl.length > 0){
|
|
bchged = true;
|
|
sl.forEach((obj: Skill)=>{
|
|
if(obj.isBornSkill()){
|
|
lst.push(obj);
|
|
}else if(obj.isDieSkill()){
|
|
//nothing to do
|
|
}else if(obj.isAPHaloSkill() || obj.isBuffHaloSkill()){
|
|
//only handle halo, not handle skill
|
|
bhalo = true;
|
|
}else{
|
|
lst.push(obj);
|
|
}
|
|
});
|
|
}
|
|
if(bhalo){
|
|
this.onHaloAdd(pet, true);
|
|
}
|
|
if(bchged){
|
|
pet.dataChanged(pet);
|
|
sp = param.clone();
|
|
sp.changeSrc(pet);
|
|
}
|
|
}
|
|
return this.simpleCheckSkills(lst, false, pet, sp);
|
|
};
|
|
|
|
public summonPet(petid: number, count: number = 1, exparam: SkillParam):number{
|
|
let n = -1;
|
|
for(let i = 0; i < count; i++){
|
|
let pet = this.newPet();
|
|
if(!pet){
|
|
break;
|
|
}
|
|
n++;
|
|
pet.loadData(petid, exparam);
|
|
}
|
|
return n;
|
|
};
|
|
|
|
public summonSkill(skillid: number, count: number, usertype: SkillUserType, from: Skill, param: SkillParam): SkillTarget[]{
|
|
if(!skillid){
|
|
return null;
|
|
}
|
|
return this.handleSkill(skillid, count, usertype, this._self, from._petowner, param);
|
|
};
|
|
|
|
public addCard(count: number, from?: PlayerHandler): number{
|
|
return this._owner.onPlayerAddCardNotify(this, count, 0, from);
|
|
};
|
|
|
|
public addCardLimit(maxcount: number, from?: PlayerHandler): number{
|
|
return this._owner.onPlayerAddCardNotify(this, 0, maxcount, from);
|
|
};
|
|
|
|
public addDirectCard(cardid: number, count: number, from?: PlayerHandler){
|
|
return this._owner.onPlayerAddDirectCardNotify(this, count, cardid, from);
|
|
};
|
|
|
|
public stealCard(dstplayer: PlayerHandler, count: number): number{
|
|
return this._owner.onPlayerStealCardNotify(this, dstplayer, count);
|
|
};
|
|
|
|
public dropCard(count: number, from?: PlayerHandler): number{
|
|
return this._owner.onPlayerDropCardNotify(this, count, from);
|
|
};
|
|
|
|
public addHP(value: number, from: PetHandler): number{
|
|
let oldhp = this.getHP();
|
|
let newhp = this._owner.onPlayerAddHPNotify(this, value, from._owner);
|
|
return newhp - oldhp;
|
|
};
|
|
|
|
public addBaseAP(value: number, from: PetHandler): number{
|
|
return this._self? this._self.addBaseAP(value, from): 0;
|
|
};
|
|
|
|
public addExAP(value: number, sender: Skill, from: PetHandler): number{
|
|
return this._self? this._self.addExAP(value, sender, from): 0;
|
|
};
|
|
|
|
public getHP(){
|
|
return this._player.hp;
|
|
};
|
|
|
|
public addHPS(value: number, from: PetHandler): number{
|
|
return this._self? this._self.addHPS(value, from): 0;
|
|
};
|
|
|
|
public getHPS(): number{
|
|
return this._self? this._self._hps: 0;
|
|
};
|
|
|
|
public addEM(value: number): number{
|
|
return this._self? this._self.addEM(value): 0;
|
|
};
|
|
|
|
public getEM(): number{
|
|
return this._totalem;
|
|
};
|
|
|
|
public onEMChanged(value: number){
|
|
if(value == 0){
|
|
return;
|
|
}
|
|
this._totalem += value;
|
|
if(this._totalem < 0){
|
|
this._totalem = 0;
|
|
}
|
|
};
|
|
|
|
public addReduceHurt(value: number, from: PetHandler){
|
|
return this._self? this._self.addReduceHurt(value, from): 0;
|
|
};
|
|
|
|
public totalAP(){
|
|
return this._self? this._self.totalAP(): 0;
|
|
};
|
|
|
|
public bakTotalAP(){
|
|
return this._self? this._self.bakTotalAP(): 0;
|
|
};
|
|
|
|
public setFriend(aplayer: PlayerHandler){
|
|
this._friend = aplayer;
|
|
};
|
|
|
|
public die(){
|
|
this.clear();
|
|
//todo:
|
|
};
|
|
|
|
public reborn(from: PetHandler): boolean{
|
|
return this._self? this._self.reborn(from): false;
|
|
};
|
|
|
|
public attack(sk: Skill, apet: PetHandler, param: SkillParam, ev: number, isAtkBack: boolean = false){
|
|
return this._self? this._self.attack(sk, apet, param, ev, isAtkBack): 0;
|
|
};
|
|
|
|
public beHurt(value: number, from: PetHandler): number{
|
|
return this._self? this._self.beHurt(value, from): 0;
|
|
};
|
|
|
|
public beSilent(count: number){
|
|
return this._self? this._self.beSilent(count): 0;
|
|
};
|
|
|
|
public taunt(){
|
|
this._self && this._self.taunt();
|
|
};
|
|
|
|
public canAttack(){
|
|
return this._self? this._self.canAttack(): false;
|
|
};
|
|
|
|
public canBeKill(subhp: number): boolean{
|
|
if(subhp >= 0){
|
|
return false;
|
|
}
|
|
let hp = this.getHP();
|
|
return (hp + subhp <= 0);
|
|
};
|
|
|
|
public isAlive(): boolean{
|
|
return this._player.state != 2;
|
|
};
|
|
|
|
public onPetBorned(apet: PetHandler, param: SkillParam){
|
|
this._owner.onAddPetNotify(apet);
|
|
this.onEMChanged(apet._enmagic);//增加法强
|
|
// 战吼
|
|
if(!apet.isSilent()){
|
|
this.simpleCheckSkills(apet._bornSkills, true, apet, param);
|
|
}
|
|
|
|
this.checkSkills(TriggerType.PET_BORN, null, null, apet);
|
|
};
|
|
|
|
public onPetDied(apet: PetHandler): boolean{
|
|
// 遗愿
|
|
if(!apet.isSilent()){
|
|
this.simpleCheckSkills(apet._dieSkills, true);
|
|
}
|
|
|
|
if(apet.isAlive()){
|
|
return false;
|
|
}
|
|
|
|
// this.delPet(apet);
|
|
this.checkSkills(TriggerType.PET_DIE, null, null, apet);
|
|
|
|
return true;
|
|
};
|
|
|
|
public onPetChanged(apet: PetHandler, from: PetHandler){
|
|
this._owner.onUpdatePetNotify(apet, from);
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param apet : 新增的光环怪
|
|
* @param only_checkother : 只检查apet加给别人的光环
|
|
*/
|
|
public onHaloAdd(apet: PetHandler, only_checkother: boolean = false){
|
|
let pets: Map<PetHandler, number> = new Map();
|
|
|
|
if(only_checkother){
|
|
this._pets.forEach((obj: PetHandler)=>{
|
|
let n = apet.addEffHalo(obj);
|
|
if(n != 0){
|
|
pets.set(obj, n);
|
|
}
|
|
});
|
|
|
|
if(this._self != apet){
|
|
let n = apet.addEffHalo(this._self);
|
|
if(n != 0){
|
|
pets.set(this._self, n);
|
|
}
|
|
}
|
|
}else{
|
|
// apet加给自己
|
|
let n = apet.addEffHalo(apet);
|
|
if(n != 0){
|
|
pets.set(apet, n);
|
|
}
|
|
|
|
// apet加给别人/别人加给apet
|
|
this._pets.forEach((obj: PetHandler)=>{
|
|
if(obj != apet){
|
|
let n = obj.addEffHalo(apet);
|
|
if(n != 0){
|
|
if(pets.has(apet)){
|
|
pets.set(apet, pets.get(apet) + n);
|
|
}else{
|
|
pets.set(apet, n);
|
|
}
|
|
}
|
|
n = apet.addEffHalo(obj);
|
|
if(n != 0){
|
|
pets.set(obj, n);
|
|
}
|
|
}
|
|
});
|
|
|
|
// _self加给apet/apet加给_self
|
|
if(this._self != apet && this._self){
|
|
let n = this._self.addEffHalo(apet);
|
|
if(n != 0){
|
|
if(pets.has(apet)){
|
|
pets.set(apet, pets.get(apet) + n);
|
|
}else{
|
|
pets.set(apet, n);
|
|
}
|
|
}
|
|
n = apet.addEffHalo(this._self);
|
|
if(n != 0){
|
|
pets.set(this._self, n);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(pets.size > 0){
|
|
for(let [k, v] of pets){
|
|
let sk = this._owner.singleSkillTarget(null, apet, k);
|
|
sk.success(SkillEffectType.POWEREX_ENHANCE, v);
|
|
sk.success(SkillEffectType.CHG_AP, v);
|
|
}
|
|
this._owner.onUpdatePetsNotify([...pets.keys()], apet);
|
|
}
|
|
};
|
|
|
|
public onHaloRemove(apet: PetHandler){
|
|
let lst: PetHandler[] = [];
|
|
this._pets.forEach((obj: PetHandler)=>{
|
|
if(apet != obj){
|
|
if(obj.removeEffHalo(apet)){
|
|
lst.push(obj);
|
|
}
|
|
}
|
|
});
|
|
|
|
if(this._self && this._self != apet){
|
|
if(this._self.removeEffHalo(apet)){
|
|
lst.push(this._self);
|
|
}
|
|
}
|
|
|
|
this._owner.onUpdatePetsNotify(lst, apet);
|
|
};
|
|
|
|
public onAttackBefore(apet: PetHandler, sp?: SkillParam){
|
|
this.singleCheckSkills(apet, TriggerType.BEFORE_ATTACK, null, sp);
|
|
};
|
|
|
|
public onAttackAfter(apet: PetHandler, sp?: SkillParam){
|
|
this.singleCheckSkills(apet, TriggerType.AFTER_ATTACK, null, sp);
|
|
};
|
|
|
|
// 暂不用
|
|
public onBeAttack(apet: PetHandler, sp?: SkillParam){
|
|
this.singleCheckSkills(apet, TriggerType.BE_ATTACK, null, sp);
|
|
};
|
|
|
|
public onBeHurt(apet: PetHandler, value: number, from: PetHandler){
|
|
this.singleCheckSkills(apet, TriggerType.BE_HURT, from._owner);
|
|
};
|
|
|
|
public onShieldUsed(apet: PetHandler){
|
|
this.singleCheckSkills(apet, TriggerType.SHIELD_USED);
|
|
};
|
|
|
|
public isMyPet(apet: PetHandler){
|
|
if(apet == this._self){
|
|
return true;
|
|
}
|
|
return this._pets.includes(apet);
|
|
};
|
|
|
|
public findTauntPet(): PetHandler{
|
|
if(this._self && this._self.isTaunt()){
|
|
return this._self;
|
|
}
|
|
return this._pets.find((item: PetHandler) =>{
|
|
return item.isAlive() && item.isTaunt();
|
|
});
|
|
};
|
|
|
|
public findAllTauntPets(lst: PetHandler[], exself: boolean, expet?: PetHandler): number{
|
|
if(!lst){
|
|
return -1;
|
|
}
|
|
let ncnt = 0;
|
|
if(!exself && this._self && this._self.isTaunt() && this._self != expet){
|
|
lst.push(this._self);
|
|
ncnt++;
|
|
}
|
|
this._pets.forEach((item: PetHandler) =>{
|
|
if(item.isTaunt() && item != expet && item.isAlive()){
|
|
lst.push(item);
|
|
ncnt++;
|
|
}
|
|
});
|
|
return ncnt;
|
|
};
|
|
|
|
public findAllPets(lst: PetHandler[], exself: boolean, expet?: PetHandler): number{
|
|
if(!lst){
|
|
return -1;
|
|
}
|
|
let ncnt = 0;
|
|
if(!exself && this._self && this._self != expet){
|
|
lst.push(this._self);
|
|
ncnt++;
|
|
}
|
|
this._pets.forEach((item: PetHandler) =>{
|
|
if(item != expet && item.isAlive()){
|
|
lst.push(item);
|
|
ncnt++;
|
|
}
|
|
});
|
|
return ncnt;
|
|
};
|
|
|
|
public findAllNoShieldPets(lst: PetHandler[], exself: boolean, expet?: PetHandler): number{
|
|
if(!lst){
|
|
return -1;
|
|
}
|
|
let ncnt = 0;
|
|
if(!exself && this._self && this._self != expet && !this._self.hasShield()){
|
|
lst.push(this._self);
|
|
ncnt++;
|
|
}
|
|
this._pets.forEach((item: PetHandler) =>{
|
|
if(item != expet && item.isAlive() && !item.hasShield()){
|
|
lst.push(item);
|
|
ncnt++;
|
|
}
|
|
});
|
|
return ncnt;
|
|
};
|
|
|
|
public getMaxAPPet(exself: boolean): PetHandler{
|
|
let res: PetHandler = exself? null: this._self;
|
|
this._pets.forEach((item: PetHandler) =>{
|
|
if(!res){
|
|
res = item;
|
|
}else if(res.totalAP() < item.totalAP()){
|
|
res = item;
|
|
}
|
|
});
|
|
return res;
|
|
};
|
|
|
|
public getMinAPPet(exself: boolean): PetHandler{
|
|
let res: PetHandler = exself? null: this._self;
|
|
this._pets.forEach((item: PetHandler) =>{
|
|
if(!res){
|
|
res = item;
|
|
}else if(res.totalAP() > item.totalAP()){
|
|
res = item;
|
|
}
|
|
});
|
|
return res;
|
|
};
|
|
|
|
public getLastPet(): PetHandler{
|
|
if(this._pets.length > 0){
|
|
return this._pets[this._pets.length - 1];
|
|
}
|
|
return null;
|
|
};
|
|
|
|
public hasTransEffCardSkill(): boolean{
|
|
if(!this._self){
|
|
return false;
|
|
}
|
|
|
|
let obj = this._self._skills.find((val: Skill)=>{
|
|
return val.isTransEffCardSkill();
|
|
});
|
|
return !!obj;
|
|
};
|
|
|
|
public getTransEffCardRate(): number{
|
|
if(!this._self){
|
|
return 0;
|
|
}
|
|
|
|
let obj = this._self._skills.find((val: Skill)=>{
|
|
return val.isTransEffCardSkill();
|
|
});
|
|
|
|
return obj? obj.getEffValue(): 0;
|
|
};
|
|
|
|
onCardLinkReady(fromplayer: PlayerHandler){
|
|
this.checkSkills(TriggerType.CARD_LINK_BEFORE);
|
|
};
|
|
|
|
onCardLinkEnd(linkcards: Card[], fromplayer: PlayerHandler){
|
|
this._cardstate = fromplayer? CondType.CARD_ACTION_LINK_OTHER: CondType.CARD_ACTION_LINK_SELF;
|
|
this.checkSkills(TriggerType.CARD_LINK_AFTER, fromplayer);
|
|
};
|
|
|
|
onCardDroped(dropcards: Card[], srcplayer: PlayerHandler){
|
|
this.checkSkills(TriggerType.CARD_DROP_MYROUND);
|
|
};
|
|
|
|
onCardDiscarded(discardcard: Card){
|
|
this.checkSkills(TriggerType.CARD_DISCARD_MYROUND);
|
|
};
|
|
|
|
onCardGetted(getcards: Card[], srcplayer: PlayerHandler){
|
|
getcards && (this._totalcc += getcards.length);
|
|
this.checkSkills(TriggerType.CARD_GETTED);
|
|
};
|
|
|
|
onCardChanged(srcplayer: PlayerHandler){
|
|
this.checkSkills(TriggerType.CARD_CHANGED, srcplayer);
|
|
};
|
|
|
|
onUseCardEnd(sp: SkillParam){
|
|
this.checkSkills(TriggerType.CARD_USED);
|
|
this._cardstate = CondType.NO_COND; // 重置状态
|
|
};
|
|
|
|
onRoundStart(){
|
|
this.checkSkills(TriggerType.ROUND_START_MYSELF);
|
|
};
|
|
|
|
onRoundEnd(){
|
|
this.checkSkills(TriggerType.ROUND_END_MYSELF);
|
|
this._cardstate = CondType.NO_COND; // 重置状态
|
|
};
|
|
|
|
onGameStart(){
|
|
this.checkSkills(TriggerType.PLAYER_BORN);
|
|
};
|
|
|
|
onPlayerDie(srcplayer: PlayerHandler){
|
|
this.checkSkills(TriggerType.PLAYER_DIE, srcplayer);
|
|
};
|
|
|
|
checkSkills(tgttype: TriggerType, tgtvalue?: PlayerHandler, tgtsp?: SkillParam, expet?: PetHandler){
|
|
let sp = tgtsp;
|
|
if(!sp){
|
|
sp = new SkillParam(0, 0, 0, this, this._self, null, null);
|
|
}
|
|
|
|
let reslst: SkillTarget[] = [];
|
|
this._self && (this._self != expet) && this._self.checkSkills(tgttype, tgtvalue, sp, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
reslst.push(...res);
|
|
}else{
|
|
let st = new SkillTarget(skill);
|
|
st.LoadParam(sp);
|
|
reslst.push(st);
|
|
}
|
|
});
|
|
|
|
this._pets.forEach((item: PetHandler) => {
|
|
if(!item.isAlive()){
|
|
return;
|
|
}
|
|
if(item == expet){
|
|
return;
|
|
}
|
|
sp.srcpet = item;
|
|
item.checkSkills(tgttype, tgtvalue, sp, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
reslst.push(...res);
|
|
}else{
|
|
let st = new SkillTarget(skill);
|
|
st.LoadParam(sp);
|
|
reslst.push(st);
|
|
}
|
|
});
|
|
});
|
|
|
|
this._owner.onSkillResult(reslst);
|
|
};
|
|
|
|
singleCheckSkills(apet: PetHandler, tgttype: TriggerType, tgtvalue?: PlayerHandler, tgtsp?: SkillParam){
|
|
let sp = tgtsp;
|
|
if(!sp){
|
|
sp = new SkillParam(0, 0, 0, this, apet, null, null);
|
|
}
|
|
let reslst: SkillTarget[] = [];
|
|
apet.checkSkills(tgttype, tgtvalue, sp, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
reslst.push(...res);
|
|
}else{
|
|
let st = new SkillTarget(skill);
|
|
st.LoadParam(sp);
|
|
reslst.push(st);
|
|
}
|
|
});
|
|
this._owner.onSkillResult(reslst);
|
|
};
|
|
|
|
simpleCheckSkills(skills: Skill[], runimm: boolean, apet?: PetHandler, param?: SkillParam): SkillTarget[]{
|
|
if(!skills || skills.length <= 0){
|
|
return null;
|
|
}
|
|
let sp = param? param: new SkillParam(0, 0, 0, this, apet, this, apet);
|
|
let reslst: SkillTarget[] = [];
|
|
skills.forEach((item: Skill)=>{
|
|
item.checkTrigger(runimm? TriggerType.NO_COND: TriggerType.NORMAL, null, sp, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
reslst.push(...res);
|
|
}else{
|
|
let st = new SkillTarget(skill);
|
|
st.LoadParam(sp);
|
|
reslst.push(st);
|
|
}
|
|
});
|
|
});
|
|
|
|
this._owner.onSkillResult(reslst);
|
|
|
|
return reslst;
|
|
};
|
|
|
|
checkPets(breset: boolean = false){
|
|
for(let i = this._pets.length - 1; i >= 0; i--){
|
|
let pet = this._pets[i];
|
|
if(pet && !pet.isAlive()){
|
|
this.delPet(pet);
|
|
}else if(breset){
|
|
pet.resetBakAP();
|
|
}
|
|
}
|
|
};
|
|
|
|
resetTotalCard(){
|
|
this._totalcc = 0;
|
|
};
|
|
|
|
addTotalCard(v: number){
|
|
this._totalcc += v;
|
|
};
|
|
|
|
addBuff(buffid: number, buffcount: number, from: PetHandler): number{
|
|
return this._self? this._self.addBuff(buffid, buffcount, from): 0;
|
|
};
|
|
|
|
delBuff(buffid: number, buffcount: number, from: PetHandler): number{
|
|
return this._self? this._self.delBuff(buffid, buffcount, from): -1;
|
|
}
|
|
}
|