Merge branch 'second' of git.kingsome.cn:node/card_svr into second

src/rooms/logic/Handler/BattleHandler.ts

@@ -3,14 +3,15 @@ import {Card} from "../../schema/Card";
 import {CardGameState} from "../../schema/CardGameState";
 import { PlayerHandler } from "./PlayerHandler";
 import CfgMan from "../CfgMan";
-import { EffectCardType, GameCampType, GameUnitType } from "../skill/SkillConst";
+import { EffectCardType, GameCampType, GameUnitType, SkillRangeUnitType } from "../skill/SkillConst";
 import { Pet } from "rooms/schema/Pet";
 import {SkillParam, SkillTarget} from "../skill/SkillParam";
 import { Room } from "colyseus";
 import { Skill } from "../skill/Skill";
 import { PetHandler } from "./PetHandler";
-import { SkillInfoMsg } from "message/SkillInfo";
+import { SKillEffectData, SkillInfoMsg } from "message/SkillInfo";
 import { PetInfo } from "message/PetInfo";
+import arrUtil from "utils/array.util";
 
 
 export class BattleHandler {
@@ -97,11 +98,59 @@ export class BattleHandler {
         }
     };
 
-    public getFinalTarget(players: PlayerHandler[], apet: PetHandler, ct: GameUnitType, 
+    public getFinalTarget(ut: SkillRangeUnitType, players: PlayerHandler[], apet: PetHandler, expet: PetHandler, ct: GameUnitType, 
         checktaunt: boolean=false): PetHandler
     {
         let pet = apet;
-        let bok = this.petIsValid(pet, players, ct);
+        let bok = false;
+        switch(ut){
+            case SkillRangeUnitType.RANDOM_ONE:
+                if(checktaunt){
+                    let lst:PetHandler[] = [];
+                    players.forEach((item:PlayerHandler)=>{
+                        item.findAllTauntPets(lst);
+                    });
+                    if(lst.length > 0){
+                        pet = arrUtil.randomOne(lst);
+                        bok = true;
+                    }
+                }
+                if(!bok){
+                    let lst:PetHandler[] = [];
+                    players.forEach((item:PlayerHandler)=>{
+                        item.findAllPets(lst);
+                    });
+                    if(lst.length > 0){
+                        pet = arrUtil.randomOne(lst);
+                        bok = true;
+                    }
+                }
+                break;
+            case SkillRangeUnitType.RANDOM_ONE_EXSELF:
+                if(checktaunt){
+                    let lst:PetHandler[] = [];
+                    players.forEach((item:PlayerHandler)=>{
+                        item.findAllTauntPets(lst, expet);
+                    });
+                    if(lst.length > 0){
+                        pet = arrUtil.randomOne(lst);
+                        bok = true;
+                    }
+                }
+                if(!bok){
+                    let lst:PetHandler[] = [];
+                    players.forEach((item:PlayerHandler)=>{
+                        item.findAllPets(lst, expet);
+                    });
+                    if(lst.length > 0){
+                        pet = arrUtil.randomOne(lst);
+                        bok = true;
+                    }
+                }
+                break;
+            default:
+                {
+                    bok = this.petIsValid(pet, players, ct);
                     if(checktaunt && (!bok || !pet.isTaunt())){
                         for(let i = 0; i < players.length;i++){
                             let obj = players[i].findTauntPet();
@@ -112,6 +161,10 @@ export class BattleHandler {
                             }
                         }
                     }
+                }
+                break;
+        }
+
         return bok? pet: null;
     };
 
@@ -133,7 +186,7 @@ export class BattleHandler {
                 case GameUnitType.BATTLEUNIT:
                 case GameUnitType.PET:
                     if(skill.isSingleTarget()){
-                        let pet = this.getFinalTarget(players, param.dstpet, skill._data.targetid,
+                        let pet = this.getFinalTarget(skill._data.rangeid, players, param.dstpet, param.srcpet, skill._data.targetid,
                             skill.isHurtPowerSkill());
                         pet && lst.push(new SkillTarget(skill, param.srcplayer, param.srcpet,
                             pet, pet._isHero? GameUnitType.HERO: GameUnitType.PET));
@@ -204,6 +257,44 @@ export class BattleHandler {
                     }
                 }
                 break;
+            case GameCampType.RANDOM_ENEMY:
+                {
+                    let tmp: PlayerHandler[] = [];
+                    for(let [key, obj] of this._players){
+                        if(obj != src && obj != src._friend && obj.isAlive()){
+                            tmp.push(obj);
+                        }
+                    }
+                    lst.push(arrUtil.randomOne(tmp));
+                }
+                break;
+            case GameCampType.RANDOM_US:
+                {
+                    let tmp: PlayerHandler[] = [];
+                    if(src){
+                        src.isAlive() && tmp.push(src);
+                        let obj = this.getFriend(src);
+                        obj && obj.isAlive() && tmp.push(obj);
+                    }
+                    (tmp.length > 0) && lst.push(arrUtil.randomOne(tmp));
+                }
+                break;
+            case GameCampType.FACE_ENEMY:
+                {
+                    let bfind = false;
+                    let player = this._room.getOppositePlayer(src.getId());
+                    if(player){
+                        let ph = this.getPlayer(player);
+                        if(ph){
+                            lst.push(ph);
+                            bfind = true;
+                        }
+                    }
+                    if(!bfind){
+                        return this.getTargetPlayers(GameCampType.RANDOM_ENEMY, src, dst);
+                    }
+                }
+                break;
             default:
                 break;
         }

src/rooms/logic/Handler/PlayerHandler.ts

@@ -10,6 +10,7 @@ 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";
 
 export class PlayerHandler {
     public _player: Player;
@@ -363,7 +364,43 @@ export class PlayerHandler {
         }
         return this._pets.find((item: PetHandler) =>{
             return item.isTaunt();
-        })
+        });
+    };
+
+    public findAllTauntPets(lst: PetHandler[], expet?: PetHandler): number{
+        if(!lst){
+            return -1;
+        }
+        let ncnt = 0;
+        if(this._self && this._self.isTaunt() && this._self != expet){
+            lst.push(this._self);
+            ncnt++;
+        }
+        this._pets.forEach((item: PetHandler) =>{
+            if(item.isTaunt() && this._self != expet){
+                lst.push(item);
+                ncnt++;
+            }
+        });
+        return ncnt;
+    };
+
+    public findAllPets(lst: PetHandler[], expet?: PetHandler): number{
+        if(!lst){
+            return -1;
+        }
+        let ncnt = 0;
+        if(this._self && this._self != expet){
+            lst.push(this._self);
+            ncnt++;
+        }
+        this._pets.forEach((item: PetHandler) =>{
+            if(this._self != expet){
+                lst.push(item);
+                ncnt++;
+            }
+        });
+        return ncnt;
     };
 
     public hasTransEffCardSkill(): boolean{

src/rooms/logic/skill/Skill.ts

@@ -335,7 +335,8 @@ export class Skill {
         let ncount = 1 + exparam.edd_cnt;
         switch(efftype){
             case SkillEffectType.SUMMON_NPC:
-                let n = tgt.dst.summonPet(this._data.quoteunitid, ncount, exparam);
+                let obj = tgt.srcpet? tgt.srcpet: tgt.srcplayer;
+                let n = obj.summonPet(this._data.quoteunitid, ncount, exparam);
                 if(n >= 0){
                     tgt.success(efftype, n);
                 }

src/rooms/logic/skill/SkillConst.ts

@@ -89,6 +89,15 @@ export const enum SkillType{
 };
 
 // 技能作用范围(对单位而言)
+/**
+ * 1.自己
+ * 2.单体：即（指定单体）可以由玩家指定一个目标
+ * 3.（自己外）单体：作用于一个目标，但是不包括技能的使用者
+ * 4.全体：作用于全体目标
+ * 5.（自己外）全体：作用于全体目标，但是不包括技能的使用者
+ * 6.随机单体：在可以选择的目标范围内，随机一个目标
+ * 7.（自己外）随机单体：自己除外
+ */
 export const enum SkillRangeUnitType{
   NONE = 0,
   SELF = 1,
@@ -96,6 +105,8 @@ export const enum SkillRangeUnitType{
   OTHER = 3,
   ALL = 4,
   ALL_EXSELF = 5,
+  RANDOM_ONE = 6,
+  RANDOM_ONE_EXSELF = 7,
 };
 
 // 技能效果类型