363 lines
10 KiB
TypeScript
363 lines
10 KiB
TypeScript
import {PlayerHandler} from "../Handler/PlayerHandler";
|
|
import {PetHandler} from "../Handler/PetHandler";
|
|
import { Skill } from "./Skill";
|
|
import { GameUnitType, SkillEffectType, SkillUserType } from "./SkillConst";
|
|
import { SKillEffectData, SkillInfoData, SkillInfoMsg } from "../../../message/SkillInfo";
|
|
import { PetInfo } from "message/PetInfo";
|
|
|
|
export class SkillParam{
|
|
cardid: number;
|
|
cardpoint: number;
|
|
edd_cnt: number;
|
|
srcplayer: PlayerHandler;
|
|
dstplayer: PlayerHandler;
|
|
dstpet: PetHandler;
|
|
|
|
srcpet: PetHandler;
|
|
|
|
constructor(cardid: number, cardpoint: number, effcnt: number, srcplayer: PlayerHandler, srcpet: PetHandler,
|
|
dstplayer: PlayerHandler, dstpet: PetHandler){
|
|
this.cardid = cardid;
|
|
this.cardpoint = cardpoint;
|
|
this.edd_cnt = effcnt;
|
|
this.srcplayer = srcplayer;
|
|
this.srcpet = srcpet;
|
|
this.dstplayer = dstplayer;
|
|
this.dstpet = dstpet;
|
|
};
|
|
|
|
clone(){
|
|
return new SkillParam(this.cardid, this.cardpoint, this.edd_cnt,
|
|
this.srcplayer, this.srcpet, this.dstplayer, this.dstpet);
|
|
};
|
|
|
|
oppClone(){
|
|
return new SkillParam(this.cardid, this.cardpoint, this.edd_cnt,
|
|
this.dstplayer, this.dstpet, this.srcplayer, this.srcpet);
|
|
};
|
|
|
|
reverse(){
|
|
let tmpplayer = this.srcplayer;
|
|
let tmppet = this.srcpet;
|
|
this.srcplayer = this.dstplayer;
|
|
this.srcpet = this.dstpet;
|
|
this.dstpet = tmppet;
|
|
this.dstplayer = tmpplayer;
|
|
};
|
|
|
|
changeSrc(pet: PetHandler){
|
|
if(!pet){
|
|
return;
|
|
}
|
|
this.srcpet = pet;
|
|
this.srcplayer = pet._owner;
|
|
|
|
}
|
|
};
|
|
|
|
export class SkillResult{
|
|
effect_type: number;
|
|
effect_res: number;
|
|
err: number;
|
|
bsuccess: boolean;
|
|
beffsrc: boolean;
|
|
|
|
constructor(efftype: number, effres: number, issuccess: boolean, err: number = 0, issrc: boolean = false) {
|
|
this.effect_type = efftype;
|
|
this.effect_res = effres;
|
|
this.err = err;
|
|
this.bsuccess = issuccess;
|
|
this.beffsrc = issrc;
|
|
}
|
|
};
|
|
|
|
export class SkillTarget{
|
|
srcplayer: PlayerHandler;
|
|
srcpet: PetHandler;
|
|
srcskill: Skill;
|
|
srcskillid: number;
|
|
srcskilltype: number;
|
|
dst: PlayerHandler | PetHandler;
|
|
dsttype: GameUnitType;
|
|
|
|
lasttime: number;
|
|
bresok: boolean = false;
|
|
|
|
res: SkillResult[];
|
|
|
|
constructor(skill: Skill | number, splayer?: PlayerHandler, spet?: PetHandler, dstobj?: any, dsttype?: GameUnitType) {
|
|
let bsk = skill instanceof Skill;
|
|
let sk = bsk? (skill as Skill): null;
|
|
let sid = !bsk? (skill as number): 0;
|
|
this.srcplayer = splayer;
|
|
this.srcpet = spet;
|
|
this.srcskill = sk;
|
|
this.srcskillid = sk? sk._id: sid;
|
|
this.srcskilltype = sk? sk._data.effect_typeid: 0;
|
|
this.dst = dstobj;
|
|
this.dsttype = dsttype;
|
|
this.lasttime = sk? sk._data.indicate_time: 0;
|
|
};
|
|
|
|
public LoadParam(sp: SkillParam){
|
|
this.srcplayer = sp.srcplayer;
|
|
this.srcpet = sp.srcpet;
|
|
if(sp.dstpet){
|
|
this.dsttype = sp.dstpet._isHero? GameUnitType.HERO: GameUnitType.PET;
|
|
this.dst = sp.dstpet;
|
|
}else if(sp.dstplayer){
|
|
this.dsttype = GameUnitType.PLAYER;
|
|
this.dst = sp.dstplayer;
|
|
}
|
|
};
|
|
|
|
public isHurtSkill(){
|
|
let effctid = this.srcskilltype;
|
|
return effctid == SkillEffectType.HURT_POWER || effctid == SkillEffectType.HURT_HP ||
|
|
effctid == SkillEffectType.HURT_ALL || effctid == SkillEffectType.ATTACK ||
|
|
effctid == SkillEffectType.ATTACK_BACK;
|
|
};
|
|
|
|
public targetIsPet(){
|
|
return this.dsttype == GameUnitType.PET || this.dsttype == GameUnitType.BATTLEUNIT;
|
|
};
|
|
|
|
public targetPlayer(): PlayerHandler{
|
|
if(this.dsttype == GameUnitType.NONE || !this.dst){
|
|
return null;
|
|
}
|
|
|
|
if(this.dsttype == GameUnitType.PLAYER){
|
|
return (this.dst as PlayerHandler);
|
|
}
|
|
|
|
return (this.dst as PetHandler)._owner;
|
|
};
|
|
|
|
public getTarget(usertype: SkillUserType): PlayerHandler | PetHandler{
|
|
let obj;
|
|
switch(usertype){
|
|
case SkillUserType.NONE:
|
|
obj = this.srcpet? this.srcpet: this.srcplayer;
|
|
break;
|
|
case SkillUserType.TARGET:
|
|
obj = this.dst;
|
|
break;
|
|
case SkillUserType.SRC:
|
|
obj = this.srcPet();
|
|
break;
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
public srcPet(): PetHandler{
|
|
if(this.srcpet){
|
|
return this.srcpet;
|
|
}
|
|
if(this.srcplayer){
|
|
return this.srcplayer._self;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
public srcPlayer(): PlayerHandler{
|
|
if(this.srcplayer){
|
|
return this.srcplayer;
|
|
}
|
|
if(this.srcpet){
|
|
return this.srcpet._owner;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
public clone(){
|
|
return new SkillTarget(this.srcskill, this.srcplayer, this.srcpet, this.dst, this.dsttype);
|
|
};
|
|
|
|
public oppClone(){
|
|
let st = new SkillTarget(this.srcskill);
|
|
|
|
if(this.dsttype != GameUnitType.NONE){
|
|
if(this.dsttype == GameUnitType.PLAYER){
|
|
st.srcplayer = (this.dst as PlayerHandler);
|
|
st.srcpet = st.srcplayer._self;
|
|
}else {
|
|
st.srcpet = (this.dst as PetHandler);
|
|
st.srcplayer = st.srcpet._owner;
|
|
}
|
|
}
|
|
if(this.srcpet){
|
|
st.dst = this.srcpet;
|
|
st.dsttype = this.srcpet._isHero? GameUnitType.HERO: GameUnitType.PET;
|
|
}else{
|
|
st.dst = this.srcplayer;
|
|
st.dsttype = GameUnitType.PLAYER;
|
|
}
|
|
return st;
|
|
};
|
|
|
|
public checkRes(){
|
|
if(!this.res){
|
|
this.res = [];
|
|
}
|
|
};
|
|
|
|
public success(efftype: number, effres: number, effsrc: boolean = false){
|
|
this.checkRes();
|
|
this.res.push(new SkillResult(efftype, effres, true, 0, effsrc));
|
|
this.bresok = true;
|
|
};
|
|
|
|
public fail(efftype: number, err: number){
|
|
this.checkRes();
|
|
this.res.push(new SkillResult(efftype, 0, false, err));
|
|
};
|
|
|
|
public getLastTime(){
|
|
return this.bresok? this.lasttime: 0;
|
|
};
|
|
|
|
// 暂无用
|
|
public exportData(): SkillInfoMsg{
|
|
let msg = new SkillInfoMsg();
|
|
msg.data = new SkillInfoData();
|
|
let obj = msg.data;
|
|
obj.skill_id = this.srcskillid;
|
|
obj.player = this.srcplayer.getId(),
|
|
obj.pos = this.srcpet? this.srcpet._idx: 0;
|
|
obj.datas = [];
|
|
if(!this.res){
|
|
msg.errcode = -1;
|
|
}else{
|
|
this.res.forEach((item: SkillResult) => {
|
|
let ed = this.exportResData(item);
|
|
ed && obj.datas.push(ed);
|
|
});
|
|
}
|
|
return msg;
|
|
};
|
|
|
|
public exportMsg(lst: SkillTarget[]): SkillInfoMsg{
|
|
if(!lst || lst.length == 0){
|
|
return null;
|
|
}
|
|
let st = lst[0];
|
|
let msg = new SkillInfoMsg();
|
|
msg.data = new SkillInfoData();
|
|
let obj = msg.data;
|
|
obj.skill_id = st.srcskillid;
|
|
obj.player = st.srcplayer.getId(),
|
|
obj.pos = st.srcpet? st.srcpet._idx: 0;
|
|
obj.datas = [];
|
|
lst.forEach((item: SkillTarget) => {
|
|
let eds = item.exportEffDatas();
|
|
eds && obj.datas.push(...eds);
|
|
// item.res && item.res.forEach((skres: SkillResult) => {
|
|
// let ed = item.exportResData(skres);
|
|
// ed && obj.datas.push(ed);
|
|
// });
|
|
});
|
|
return msg;
|
|
};
|
|
|
|
public exportResData(skres: SkillResult, sk?: SkillTarget): SKillEffectData{
|
|
let item = sk? sk: this;
|
|
let res = skres;
|
|
|
|
if(res){
|
|
let ed = new SKillEffectData();
|
|
if(res.beffsrc){
|
|
ed.pos = item.srcPet()._idx;
|
|
ed.player = item.srcPlayer().getId();
|
|
}else{
|
|
if(item.dsttype == GameUnitType.PLAYER){
|
|
ed.pos = 0;
|
|
ed.player = (item.dst as PlayerHandler).getId();
|
|
}else {
|
|
ed.pos = (item.dst as PetHandler)._idx;
|
|
ed.player = (item.dst as PetHandler)._owner.getId();
|
|
}
|
|
}
|
|
|
|
ed.effect_id = res.effect_type;
|
|
ed.val = res.bsuccess? res.effect_res: res.err;
|
|
ed.result = res.bsuccess? 0: -1;
|
|
|
|
return ed;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
public exportEffData(reslst: SkillResult[], bopp: boolean = false): SKillEffectData{
|
|
if(!reslst || reslst.length <= 0){
|
|
return null;
|
|
}
|
|
let ed = new SKillEffectData();
|
|
let item = this;
|
|
if(bopp){
|
|
ed.pos = item.srcPet()._idx;
|
|
ed.player = item.srcPlayer().getId();
|
|
}else{
|
|
if(item.dsttype == GameUnitType.PLAYER){
|
|
ed.pos = 0;
|
|
ed.player = (item.dst as PlayerHandler).getId();
|
|
}else {
|
|
ed.pos = (item.dst as PetHandler)._idx;
|
|
ed.player = (item.dst as PetHandler)._owner.getId();
|
|
}
|
|
}
|
|
|
|
reslst.forEach((item: SkillResult) => {
|
|
let obj = {
|
|
effect_id: item.effect_type,
|
|
val: item.bsuccess? item.effect_res: item.err,
|
|
result: item.bsuccess? 0: -1,
|
|
};
|
|
if(!ed.data){
|
|
ed.data = [obj];
|
|
}else{
|
|
ed.data.push(obj);
|
|
}
|
|
});
|
|
|
|
return ed;
|
|
};
|
|
|
|
public exportEffDatas(): SKillEffectData[]{
|
|
if(!this.res){
|
|
return null;
|
|
}
|
|
let r1: SkillResult[] = [];
|
|
let r2: SkillResult[] = [];
|
|
|
|
this.res.forEach((item: SkillResult) => {
|
|
if(item.beffsrc){
|
|
r2.push(item);
|
|
}else{
|
|
r1.push(item);
|
|
}
|
|
});
|
|
|
|
let reslst = [];
|
|
|
|
let res = this.exportEffData(r1);
|
|
res && reslst.push(res);
|
|
|
|
res = this.exportEffData(r2, true);
|
|
res && reslst.push(res);
|
|
|
|
return reslst;
|
|
}
|
|
};
|
|
|
|
|
|
export class PetUpdateProcess{
|
|
info: PetInfo;
|
|
from: PetHandler;
|
|
|
|
constructor(pet: PetHandler, from: PetHandler){
|
|
this.from = from;
|
|
this.info = pet.exportInfo();
|
|
};
|
|
}; |