329 lines
8.9 KiB
TypeScript
329 lines
8.9 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 { EffectCardType, GameUnitType, SkillType, 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";
|
|
|
|
export class PlayerHandler {
|
|
public _player: Player;
|
|
|
|
public _playercfg: HeroCfg;
|
|
|
|
public _self: PetHandler;
|
|
|
|
public _unitcfg: UnitCfg;
|
|
|
|
public _pets: PetHandler[] = [];
|
|
|
|
public _skills: Skill[] = [];
|
|
|
|
public _exskills: Skill[] = [];
|
|
|
|
public _owner: BattleHandler;
|
|
|
|
_friend: PlayerHandler;
|
|
|
|
public init(aplayer: Player, owner: BattleHandler){
|
|
this._owner = owner;
|
|
this._player = aplayer;
|
|
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.setParam(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(){
|
|
return 0;
|
|
};
|
|
|
|
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 getPet(pet: Pet){
|
|
return this._pets.find((item:PetHandler)=>{
|
|
return item._pet == pet;
|
|
})
|
|
};
|
|
|
|
public exportAllPets(ct: GameUnitType, param: SkillParam, expet: PetHandler, dst: SkillTarget[]): SkillTarget[]{
|
|
if(!dst){
|
|
return null;
|
|
}
|
|
switch(ct){
|
|
case GameUnitType.BATTLEUNIT:
|
|
let lst = this._pets.reverse();
|
|
lst.forEach(element => {
|
|
if(expet != element){
|
|
dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, element, GameUnitType.PET));
|
|
}
|
|
});
|
|
(expet != this._self) && dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, this._self, GameUnitType.PET));
|
|
break;
|
|
case GameUnitType.HERO:
|
|
(expet != this._self) && dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, this._self, GameUnitType.PET));
|
|
break;
|
|
case GameUnitType.PET:
|
|
lst.forEach(element => {
|
|
if(expet != element){
|
|
dst.push(new SkillTarget(param.skill, param.srcplayer, param.srcpet, element, GameUnitType.PET));
|
|
}
|
|
});
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return dst;
|
|
};
|
|
|
|
public useCard(obj: SkillParam)
|
|
{
|
|
let cfg = CfgMan.findEffCardCfg(obj.cardid);
|
|
if(!cfg){
|
|
return false;
|
|
}
|
|
|
|
if(cfg.type_id == EffectCardType.NPC){
|
|
let pet = this.newPet();
|
|
if(!pet){
|
|
return false;
|
|
}
|
|
obj.srcpet = pet;
|
|
pet.setParam(cfg.stageunit_id, obj,
|
|
[cfg.quoteskill1id, cfg.quoteskill2id, cfg.quoteskill3id, cfg.quoteskill4id]);
|
|
}else if(cfg.type_id == EffectCardType.MAGIC){
|
|
this.useSkills([cfg.quoteskill1id, cfg.quoteskill2id, cfg.quoteskill3id, cfg.quoteskill4id], obj);
|
|
}
|
|
};
|
|
|
|
public useSkills(skills: number[], obj: SkillParam)
|
|
{
|
|
if(!skills){
|
|
return;
|
|
}
|
|
|
|
skills.forEach((item: number)=>{
|
|
this.useSkill(item, 1, obj);
|
|
});
|
|
};
|
|
|
|
public useSkill(skillid: number, count: number, obj: SkillParam): SkillTarget[]{
|
|
let cfg = CfgMan.findSkillCfg(skillid);
|
|
let lst:SkillTarget[] = [];
|
|
if(cfg.skill_typeid == SkillType.MAGIC){
|
|
for(let i = 0; i < count; i++){
|
|
let sk = this.newSkill(skillid);
|
|
sk.checkTrigger(TriggerType.NO_COND, 0, obj,
|
|
(sk: Skill, sp: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
lst.concat(res);
|
|
}else{
|
|
lst.push()
|
|
}
|
|
});
|
|
//todo: build json -> client
|
|
}
|
|
}else {
|
|
for(let i = 0; i < count; i++){
|
|
this._self.addSkill(skillid, this.onHaloChanged);
|
|
}
|
|
}
|
|
return lst;
|
|
};
|
|
|
|
public newSkill(skillid: number): Skill{
|
|
let obj = SkillMan.getSkill(skillid);
|
|
if(obj){
|
|
obj.setOwner(this);
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
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.setParam(petid, exparam);
|
|
}
|
|
return n;
|
|
};
|
|
|
|
public addCard(count: number){
|
|
return this._owner.onPlayerAddCard(this, count, 0);
|
|
};
|
|
|
|
public addCardLimit(maxcount: number){
|
|
return this._owner.onPlayerAddCard(this, 0, maxcount);
|
|
};
|
|
|
|
public stealCard(dstplayer: PlayerHandler, count: number){
|
|
return this._owner.onPlayerStealCard(this, dstplayer, count);
|
|
};
|
|
|
|
public addHP(value: number){
|
|
this._player.hp += value;
|
|
if(value < 0){
|
|
this.die();
|
|
}
|
|
return value;
|
|
};
|
|
|
|
public getHP(){
|
|
return this._player.hp;
|
|
};
|
|
|
|
public checkHalo(apet:PetHandler){
|
|
this._pets.forEach((obj:PetHandler)=>{
|
|
obj.clearEffHalos();
|
|
});
|
|
this._pets.forEach((obj: PetHandler)=>{
|
|
if(obj != apet){
|
|
obj.checkHalo(apet);
|
|
}
|
|
apet.checkHalo(obj);
|
|
});
|
|
};
|
|
|
|
public setFriend(aplayer: PlayerHandler){
|
|
this._friend = aplayer;
|
|
};
|
|
|
|
public die(){
|
|
//todo:
|
|
};
|
|
|
|
public onPetBorned(apet: PetHandler, param: SkillParam){
|
|
this._owner.onAddPetNotify(apet);
|
|
|
|
// 战吼
|
|
let reslst: SkillTarget[] = [];
|
|
apet._bornSkills.forEach((item: Skill)=>{
|
|
item.checkTrigger(TriggerType.NO_COND, 0, param, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
reslst = reslst.concat(res);
|
|
}else{
|
|
let st = new SkillTarget(skill);
|
|
st.LoadParam(param);
|
|
reslst.push(st);
|
|
}
|
|
});
|
|
});
|
|
|
|
this._owner.onSkillResult(reslst);
|
|
};
|
|
|
|
public onPetDied(apet: PetHandler){
|
|
this._owner.onDelPetNotify(apet);
|
|
|
|
// 遗愿
|
|
let ps = new SkillParam(0, 0, 0, this, apet, null, null);
|
|
let reslst: SkillTarget[] = [];
|
|
apet._dieSkills.forEach((item: Skill)=>{
|
|
item.checkTrigger(TriggerType.NO_COND, 0, ps, (skill: Skill, ap: SkillParam, res: SkillTarget[])=>{
|
|
if(res){
|
|
reslst = reslst.concat(res);
|
|
}else{
|
|
let st = new SkillTarget(skill);
|
|
st.LoadParam(ps);
|
|
reslst.push(st);
|
|
}
|
|
});
|
|
});
|
|
|
|
this._owner.onSkillResult(reslst);
|
|
};
|
|
|
|
public onHaloChanged(apet: PetHandler){
|
|
this.checkHalo(apet);
|
|
};
|
|
|
|
public isMyPet(apet: PetHandler){
|
|
return this._pets.includes(apet);
|
|
};
|
|
|
|
public hasTransEffCardSkill(): boolean{
|
|
if(!this._self){
|
|
return false;
|
|
}
|
|
|
|
let bok = false;
|
|
for(let [key, val] of this._self._skills){
|
|
if(val.isTransEffCardSkill()){
|
|
bok = true;
|
|
break;
|
|
}
|
|
}
|
|
return bok;
|
|
};
|
|
|
|
onCardLinkReady(fromplayer: PlayerHandler){
|
|
|
|
};
|
|
|
|
onCardLinkEnd(linkcards: Card[]){
|
|
|
|
};
|
|
|
|
onCardDroped(dropcards: Card[], srcplayer: PlayerHandler){
|
|
|
|
};
|
|
|
|
onCardGetted(getcards: Card[], srcplayer: PlayerHandler){
|
|
|
|
};
|
|
|
|
onUseCardEnd(){
|
|
|
|
};
|
|
|
|
onRoundStart(){
|
|
|
|
};
|
|
|
|
onRoundEnd(){
|
|
|
|
}
|
|
}
|