node/card_svr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

handle card...

Browse Source
This commit is contained in:
yuexin 2020-12-04 15:45:25 +08:00
parent b895e8c1c8
commit 99497bf4e4
7 changed files with 296 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
src/rooms/logic/Handler/BattleHandler.ts
View File

@ -3,11 +3,12 @@ import {Card} from "../../schema/Card";
import {CardGameState} from "../../schema/CardGameState";
import { PlayerHandler } from "./PlayerHandler";
import CfgMan from "../CfgMan";
import { EffectCardType } from "../skill/SkillConst";
import { EffectCardType, GameCampType, GameUnitType } from "../skill/SkillConst";
import { Pet } from "rooms/schema/Pet";
import {SkillParam} from "../skill/SkillParam";
import {SkillParam, SkillTarget} from "../skill/SkillParam";
import { Room } from "colyseus";
import { Skill } from "../skill/Skill";
import { PetHandler } from "./PetHandler";
export class BattleHandler {
@ -22,27 +23,137 @@ export class BattleHandler {
this._room = room;
};
public addPlayer(aplayer: Player){
public addPlayer(aplayer: Player): PlayerHandler{
let ph = new PlayerHandler();
ph.init(aplayer, this);
this._players.set(aplayer, ph);
return ph;
};
public delPlayer(aplayer: Player){
this._players.delete(aplayer);
};
public getPlayer(aplayer: Player){
public getPlayer(aplayer: Player): PlayerHandler{
return aplayer? this._players.get(aplayer): null;
};
public getSkillTargets(skill: Skill, param: SkillParam): any{
//todo:
return null;
public getFriend(aplayer: PlayerHandler): PlayerHandler{
let obj;
for(let [key, obj] of this._players){
if(obj._friend == aplayer){
break;
}
}
return obj;
};
public petIsValid(pet: PetHandler, players: PlayerHandler[], ct: GameUnitType): boolean{
if(!players || players.length == 0 || !pet){
return false;
}
let obj = players.find( (item: PlayerHandler) =>{
item.isMyPet(pet);
});
if(!obj){
return false;
}
switch(ct){
case GameUnitType.BATTLEUNIT:
return true;
case GameUnitType.HERO:
return pet._isHero;
case GameUnitType.PET:
return !pet._isHero;
default:
return false;
}
};
public getSkillTargets(skill: Skill, param: SkillParam): SkillTarget[]{
let lst: SkillTarget[] = [];
let players = this.getTargetPlayers(skill._data.friendlyid, param.srcplayer, param.dstplayer);
if(players.length > 0){
switch(skill._data.targetid){
case GameUnitType.PLAYER:
players.forEach((item:PlayerHandler)=>{
lst.push(new SkillTarget(param.srcplayer, param.srcpet, skill, item, GameUnitType.PLAYER));
});
break;
case GameUnitType.BATTLEUNIT:
case GameUnitType.HERO:
case GameUnitType.PET:
if(skill.isSingleTarget()){
if(param.dstpet && this.petIsValid(param.dstpet, players, skill._data.targetid)){
lst.push(new SkillTarget(param.srcplayer, param.srcpet, skill,
param.dstpet, param.dstpet._isHero? GameUnitType.HERO: GameUnitType.PET));
}
}else{
if(skill.isAllTarget()){
players.forEach((item: PlayerHandler)=>{
item.exportAllPets(skill._data.targetid, param, null, lst);
});
}else{
if(param.srcpet){
players.forEach((item: PlayerHandler)=>{
item.exportAllPets(skill._data.targetid, param, param.srcpet, lst);
});
}else{
players.forEach((item: PlayerHandler)=>{
if(item != param.srcplayer){
item.exportAllPets(skill._data.targetid, param, param.srcpet, lst);
}
});
}
}
}
break;
default:
break;
}
}
return lst;
};
public getTargetPlayers(gct: GameCampType, src:PlayerHandler, dst:PlayerHandler): PlayerHandler[]{
let lst: PlayerHandler[] = [];
switch(gct){
case GameCampType.SELF:
lst.push(src);
break;
case GameCampType.FRIEND:
lst.push(this.getFriend(src));
break;
case GameCampType.MYTEAM:
if(src){
lst.push(src);
lst.push(this.getFriend(src));
}
break;
case GameCampType.ENEMY:
if(dst && dst._friend != src){
lst.push(dst);
}
break;
case GameCampType.ENEMYTEAM:
for(let [key, obj] of this._players){
if(obj != src && obj != src._friend){
lst.push(obj);
}
}
break;
case GameCampType.ALL:
for(let [key, obj] of this._players){
lst.push(obj);
}
break;
default:
break;
}
return lst;
};
/**
* 使用卡片
* @param obj
@ -151,4 +262,8 @@ export class BattleHandler {
public onPlayerRoundEnd(aplayer: Player){
};
public onAddPetNotify(apet: PetHandler){
this._room.bAddPet(apet.exportData());
}
}

55
src/rooms/logic/Handler/PlayerHandler.ts
View File

@ -5,10 +5,10 @@ import { BattleHandler } from "./BattleHandler";
import CfgMan from "../CfgMan";
import { Card } from "rooms/schema/Card";
import { Pet } from "rooms/schema/Pet";
import { EffectCardType } from "../skill/SkillConst";
import { EffectCardType, GameUnitType } from "../skill/SkillConst";
import { UnitCfg } from "cfg/parsers/UnitCfg";
import { Skill } from "../skill/Skill";
import { SkillParam } from "../skill/SkillParam";
import { SkillParam, SkillTarget } from "../skill/SkillParam";
export class PlayerHandler {
public _player: Player;
@ -74,6 +74,36 @@ export class PlayerHandler {
})
};
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.srcplayer, param.srcpet, param.skill, element, GameUnitType.PET));
}
});
(expet != this._self) && dst.push(new SkillTarget(param.srcplayer, param.srcpet, param.skill, this._self, GameUnitType.PET));
break;
case GameUnitType.HERO:
(expet != this._self) && dst.push(new SkillTarget(param.srcplayer, param.srcpet, param.skill, this._self, GameUnitType.PET));
break;
case GameUnitType.PET:
lst.forEach(element => {
if(expet != element){
dst.push(new SkillTarget(param.srcplayer, param.srcpet, param.skill, element, GameUnitType.PET));
}
});
break;
default:
break;
}
return dst;
};
public useCard(obj: SkillParam)
{
let cfg = CfgMan.findEffCardCfg(obj.cardid);
@ -81,17 +111,20 @@ export class PlayerHandler {
return false;
}
let pt = obj.cardpoint;
if(cfg.followdouble && obj.pt_cnt){
pt *= obj.pt_cnt;
}
if(cfg.type_id == EffectCardType.NPC){
let pet = this.newPet();
if(!pet){
return false;
}
pet.setParam({id: cfg.stageunit_id, ap:obj.cardpoint, effcnt: obj.eff_cnt, exskillid:
pet.setParam({id: cfg.stageunit_id, ap:pt, effcnt: obj.eff_cnt, exskillid:
[cfg.quoteskill1id, cfg.quoteskill2id, cfg.quoteskill3id, cfg.quoteskill4id]});
//todo: build pet init json -> client
this._owner._room.bAddPet(pet.exportData());
obj.srcpet = pet;
pet.born(obj);
}else if(cfg.type_id == EffectCardType.MAGIC){
@ -122,10 +155,18 @@ export class PlayerHandler {
};
public onPetBorned(apet: PetHandler, param: SkillParam){
//todo: build pet init json -> client
this._owner.onAddPetNotify(apet);
// 战吼
let reslst: SkillTarget[] = [];
apet._bornSkills.forEach((item: Skill)=>{
item.trigger(param);
let lst = item.trigger(param);
reslst = reslst.concat(lst);
});
//todo: build bornskill json -> client
// 光环
this.checkHalo(apet);

332
src/rooms/logic/skill/Skill.ts
View File

@ -1,8 +1,10 @@
import { SkillCfg } from "cfg/parsers/SkillCfg";
import { SKillEffectData } from "message/SkillInfo";
import { PetHandler } from "../Handler/PetHandler";
import { PlayerHandler } from "../Handler/PlayerHandler";
import { GameCampType, GameUnitType, SkillEffectType, SkillRangeUnitType, SkillType, TriggerType } from "./SkillConst";
import { SkillParam } from "./SkillParam";
import { SkillParam, SkillTarget } from "./SkillParam";
import { TriggerCtrl } from "./TriggerCtrl";
import TriggerManager from "./TriggerMan";
export class Skill {
@ -17,7 +19,7 @@ export class Skill {
_type: any;
_show_effect: any[];
_param: number;
_tgctrl: any;
_tgctrl: TriggerCtrl;
_maxvalue: any;
_man: any;
_splashinfo: {};
@ -99,6 +101,14 @@ export class Skill {
return true;
};
isOver() {
return false;
};
isSame(id: number) {
return this._id == id;
};
isBornSkill(){
return this._type == SkillType.BORN;
};
@ -119,14 +129,19 @@ export class Skill {
return this._data.effect_typeid == SkillEffectType.CARD_CHG_EN;
};
// 是否是稀有技能
isRareSkill() {
return false;
isSingleTarget(){
switch(this._data.rangeid){
case SkillRangeUnitType.SELF:
case SkillRangeUnitType.SINGLE:
case SkillRangeUnitType.OTHER:
return true;
default:
return false;
}
};
// 是否是获得即起效技能
isIMMSkill() {
return this._data && (this._data.tigger_typeid == TriggerType.NO_COND);
isAllTarget(){
return this._data.rangeid == SkillRangeUnitType.ALL;
};
isEffectValidPet(apet: PetHandler){
@ -176,18 +191,13 @@ export class Skill {
}
};
canComposition() {
return false;
};
// 割草技能溅射相关
splashInfo() {
return this._splashinfo;
getSkillTargets(param: SkillParam): SkillTarget[]{
return this._owner._owner._owner.getSkillTargets(this, param);
};
trigger(param: SkillParam) {
//触发buff效果
let bok = TriggerManager.onTrigger(this, param);
let res = TriggerManager.onTrigger(this, param);
this._currCount++;
@ -195,24 +205,30 @@ export class Skill {
this._start = true;
}
this._cb && this._cb(this, param, bok);
this._cb && this._cb(this, param, res);
this._man && this._man.onSkillTrigger(this, param, bok);
this._man && this._man.onSkillTrigger(this, param, res);
return res;
};
checkTrigger(tg_type: any, tg_value: any, tg_target: any, cb: any) {
checkTrigger(tg_type: TriggerType, tg_value: any, tg_target: any, cb: any) {
if (tg_type == TriggerType.ROUND_START_MYSELF) {
this._roundCount++;
if (this._start) {
this._startround++;
}
}
cb && (this._cb = cb);
this._tgctrl.checkTrigger(tg_type, tg_value, this._owner, () => {
cb && cb(this);
this.trigger(tg_target);
});
};
handleCard(efftype: SkillEffectType){
};
setOwner(owner: PetHandler) {
this._owner = owner;
};
@ -221,282 +237,6 @@ export class Skill {
this._cb = cb;
};
isOver() {
return false;
};
isSame(id: number) {
return this._id == id;
};
// 获取攻击属性
getAtkAttr() {
let n = this.atk_attr ? this.atk_attr : 0;
if (this._tmp) {
this.atk_attr = 0;
}
return n;
};
// 获取攻击类型
getAtkType() {
return this.atk_type ? this.atk_type : 0;
};
// 获取攻击力加值
getAtkValue() {
return this.atk_value ? this.atk_value : 0;
};
// 获取连续攻击次数
getAtkCount() {
let res = this.atk_count ? this.atk_count : 0;
this.atk_count = 0;
return res;
};
// 获取属性加值
getAttrValue(typestr: string) {
if (!this._attrmap) {
this._attrmap = {};
}
let v = this._attrmap[typestr];
if (v && (this._startround >= this._delayround)) {
if (this._tmp) {
this._attrmap[typestr] = 0;
}
return v;
}
return 0;
};
// 获取是否无敌
getInvincible() {
let bwudi = this.wudi;
if (this._tmp) {
this.wudi = false;
}
return bwudi;
};
// 获取是否需要消失
getDisappear() {
return this._need_disappear && (this._startround >= this._delayround);
};
// 获取是否先出手
getAtkFirst() {
let bok = this._atkfirst;
if (this._tmp) {
this._atkfirst = false;
}
return bok;
};
canMove() {
return !this._no_move;
};
canAtk() {
return !this._no_atk;
};
canAtkBack() {
return !this._no_atkback;
};
isHide() {
return this._hide;
};
// 物理免疫
isImmPH() {
return this._imm_ph;
};
// 魔法免疫
isImmMagic() {
return this._imm_magic;
};
// 技能免疫
isImmSkill(effectid: number) {
return this._immeffid && (this._immeffid == effectid);
};
// buff免疫
isImmBuff(buffid: number) {
if (!this._immlst) {
return false;
}
return this._immlst.includes(buffid);
};
// 获取增加的移动力
getMoveGrid() {
return this._movegrid;
};
// 获取增加的视野
getVisionGrid() {
return this._visiongrid;
};
// 设置攻击属性
setAtkAttr(attr_type: any) {
this.atk_attr = attr_type;
};
setTempAtkAttr(attr_type: any) {
this.atk_attr = attr_type;
this._tmp = true;
};
// 设置攻击类型
setAtkType(atk_type: any) {
this.atk_type = atk_type;
};
// 设置连续攻击次数
setAtkCount(value: number) {
if (this.canComposition()) {
this.atk_count ? (this.atk_count += value) : (this.atk_count = value);
if (typeof (this._maxvalue) == 'number') {
if ((value > 0 && this.atk_count > this._maxvalue) || (value < 0 && this.atk_count < this._maxvalue)) {
this.atk_count = this._maxvalue;
}
}
} else {
this.atk_count = value;
}
};
// 是否是团队加属性技能
isGroupAttrSkill() {
if (this.groupattr) {
return true;
}
return false;
};
// 是否是加属性技能
isAttrSkill() {
if (this.attr) {
return true;
}
return false;
};
isDelAttr() {
return this.attr_value < 0;
};
isAddAttr() {
return this.attr_value > 0;
};
getLastAttr() {
return this.attr;
};
getLastAttrValue() {
return 0;
};
// 设置是否无敌
setInvincible(bInv: boolean) {
this.wudi = bInv;
this._tmp = true;
};
// 设置存在回合数（到达次数后消失）
setExistRound(count: number) {
this._delayround = count;
this._need_disappear = true;
};
// 设置不能移动
setNoMove() {
this._no_move = true;
};
getNoMove() {
return this._no_move;
};
// 设置不能攻击
setNoAtk() {
this._no_atk = true;
};
getNoAtk() {
return this._no_atk;
};
// 设置不能还击
setNoAtkBack() {
this._no_atkback = true;
};
getNoAtkBack() {
return this._no_atkback;
};
// 设置隐身属性
setHide() {
this._hide = true;
};
// 设置是否先出手
setTempAtkFirst() {
this._atkfirst = true;
this._tmp = true;
};
// 物理免疫
setPhImm() {
this._imm_ph = true;
};
// 魔法免疫
setMagicImm() {
this._imm_magic = true;
};
setSkillImm(effectid: number) {
this._immeffid = effectid;
};
setBuffImm(bufflst: any[]) {
if (!this._immlst) {
this._immlst = [];
}
if (!this.canComposition()) {
this._immlst.length = 0;
}
let nmax = bufflst.length;
// if(typeof(this._maxvalue) == 'number'){
// if(nmax + this._immlst.length > this._maxvalue){
// nmax = this._maxvalue - this._immlst.length;
// }
// }
// 【2020.09.08】策划要求不限制
for (let i = 0; i < nmax; i++) {
if (!Number(bufflst[i])) {
break;
}
this._immlst.push(Number(bufflst[i]));
}
};
getMPReduce() {
return this._acrp ? this._acrp : 0;
};
setMPReduce(rper: number) {
this._acrp = rper;
};
clone() {
let obj = new Skill();
obj._currCount = 0; // 当前计数

28
src/rooms/logic/skill/SkillConst.ts
View File

@ -26,6 +26,17 @@ export const enum CondDecideType {
};
// 触发类型
/**
* 0.无条件发动
* 1.系统确认由该玩家吃牌后
* 2.胡牌，并打出后（自摸/吃牌）：（仅前端使用）
* 3.选择发动效果牌，结束
* 4.自己回合出一张牌后
* 5.自己回合结束
* 6.获得新的卡牌后
* 7.丢弃一张卡牌后：自己回合出一张牌，不算此列
* 8.自己回合开始
*/
export const enum TriggerType
{
NO_COND = 0,
@ -121,13 +132,20 @@ export const enum EffectCardType
};
// 技能效果强化类型
/**
* 1.（使效果参数）+效果强化参数*效果强化牌数
* 2.（使效果参数）+效果强化参数的倍速*联合牌总点数*效果强化牌数
* 3.（使引用随从、技能的次数）+效果强化牌数
* 4.（使出场战力）+效果强化参数*效果强化牌数
* 5.（使出场战力）+效果强化参数的倍速*联合牌总点数*效果强化牌数
*/
export const enum EnhanceEffectType {
NONE = 0,
EN_SKILL_BYCFG = 1, // 1.（使效果参数）+效果强化参数*效果强化牌数
EN_SKILL_BYAP = 2, // 2.（使效果参数）+效果强化参数的倍速*联合牌总点数*效果强化牌数
EN_SUBSKILL_BYCFG = 3, // 3.（使引用随从、技能的次数）+效果强化牌数
EN_POWER_BYCFG = 4, // 4.（使出场战力）+效果强化参数*效果强化牌数
EN_POWER_BYAP = 5,// 5.（使出场战力）+效果强化参数的倍速*联合牌总点数*效果强化牌数
EN_SKILL_BYCFG = 1,
EN_SKILL_BYAP = 2,
EN_SUBSKILL_BYCFG = 3,
EN_POWER_BYCFG = 4,
EN_POWER_BYAP = 5,
};
// 游戏单位类型

52
src/rooms/logic/skill/SkillParam.ts
View File

@ -1,5 +1,7 @@
import {PlayerHandler} from "../Handler/PlayerHandler";
import {PetHandler} from "../Handler/PetHandler";
import { Skill } from "./Skill";
import { GameUnitType } from "./SkillConst";
export class SkillParam{
cardid: number;
@ -9,6 +11,10 @@ export class SkillParam{
srcplayer: PlayerHandler;
dstplayer: PlayerHandler;
dstpet: PetHandler;
srcpet: PetHandler = null;
skill: Skill;
constructor(cardid: number, cardpoint: number, ptcnt: number, effcnt: number, srcplayer: PlayerHandler, dstplayer: PlayerHandler, dstpet: PetHandler){
this.cardid = cardid;
@ -18,5 +24,51 @@ export class SkillParam{
this.srcplayer = srcplayer;
this.dstplayer = dstplayer;
this.dstpet = dstpet;
};
};
export class SkillResult{
effect_type: number;
effect_res: number;
err: number;
constructor(efftype: number, effres: number, err: number = 0) {
this.effect_type = efftype;
this.effect_res = effres;
this.err = err;
}
};
export class SkillTarget{
srcplayer: PlayerHandler;
srcpet: PetHandler;
srcskill: Skill;
dst: any;
dsttype: GameUnitType;
res: SkillResult[];
constructor(splayer: PlayerHandler, spet: PetHandler, skill: Skill, ds: any, dstp: GameUnitType) {
this.srcplayer = splayer;
this.srcpet = spet;
this.srcskill = skill;
this.dst = ds;
this.dsttype = dstp;
};
public checkRes(){
if(!this.res){
this.res = [];
}
};
public success(efftype: number, effres: number){
this.checkRes();
this.res.push(new SkillResult(efftype, effres));
};
public fail(efftype: number, err: number){
this.checkRes();
this.res.push(new SkillResult(efftype, 0, err));
}
};

3
src/rooms/logic/skill/TriggerCtrl.ts
View File

@ -7,6 +7,7 @@
// Learn life-cycle callbacks:
// - [Chinese] https://docs.cocos.com/creator/manual/zh/scripting/life-cycle-callbacks.html
import { PetHandler } from "../Handler/PetHandler";
import { PlayerHandler } from "../Handler/PlayerHandler";
import { Condition } from "./Condition";
import { TriggerType } from "./SkillConst";
@ -23,7 +24,7 @@ export class TriggerCtrl{
this._cond = condobj;
};
checkTrigger(tg_type: TriggerType, tg_value: any, tg_owner: PlayerHandler, callback: any){
checkTrigger(tg_type: TriggerType, tg_value: any, tg_owner: any, callback: any){
if(tg_type == TriggerType.NO_COND){
// callback && callback();
return;

25
src/rooms/logic/skill/TriggerMan.ts
View File

@ -11,7 +11,7 @@ import { PetHandler } from "../Handler/PetHandler";
import { Condition } from "./Condition";
import { Skill } from "./Skill";
import { CondDecideType, CondType, SkillEffectType, TriggerType } from "./SkillConst";
import { SkillParam } from "./SkillParam";
import { SkillParam, SkillTarget } from "./SkillParam";
import { Trigger } from "./Trigger";
import { TriggerCtrl } from "./TriggerCtrl";
@ -24,7 +24,7 @@ let TriggerManager = {
_conditionmap: new Map(),
addSkillTrigger(skill_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number) {
addSkillTrigger(skill_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number): TriggerCtrl {
let obj = this.getSkillTrigger(skill_id);
if (!obj) {
obj = this._newTrigger(skill_id, tg_type, tg_cond, tg_cond_decide, tg_cond_v);
@ -33,7 +33,7 @@ let TriggerManager = {
return obj;
},
addBuffTrigger(buff_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number) {
addBuffTrigger(buff_id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number): TriggerCtrl {
let obj = this.getBuffTrigger(buff_id);
if (!obj) {
obj = this._newTrigger(buff_id, tg_type, tg_cond, tg_cond_decide, tg_cond_v);
@ -42,15 +42,15 @@ let TriggerManager = {
return obj;
},
getSkillTrigger(skill_id: number) {
getSkillTrigger(skill_id: number): TriggerCtrl {
return this._skillmap.get(skill_id);
},
getBuffTrigger(buff_id: number) {
getBuffTrigger(buff_id: number): TriggerCtrl {
return this._buffmap.get(buff_id);
},
_newTrigger(id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number) {
_newTrigger(id: number, tg_type: TriggerType, tg_cond: CondType, tg_cond_decide: CondDecideType, tg_cond_v: number): TriggerCtrl {
let tobj = this._triggermap.get(tg_type);
if (!tobj) {
tobj = new Trigger();
@ -72,17 +72,16 @@ let TriggerManager = {
},
onTrigger(sender: Skill, target: SkillParam) {
onTrigger(sender: Skill, target: SkillParam): SkillTarget[] {
let effectid = sender._type;
let paramlst = sender._param;
let owner = sender._owner;
let bResOk = true;
let tgts = sender._owner._owner._owner.getSkillTargets(sender, target);
if(!tgts){
return;
let tgts = sender.getSkillTargets(target);
if(!tgts || !tgts.length){
return null;
}
switch (effectid) {
case SkillEffectType.NONE:
return null;
case SkillEffectType.CARD_ADD:
case SkillEffectType.CARD_ADD_LIMIT:
case SkillEffectType.CARD_STEAL:
@ -99,7 +98,7 @@ let TriggerManager = {
break;
}
return bResOk;
return tgts;
},
handleEffectParam(effectid: SkillEffectType, paramlst: any) {