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

src/cfg/parsers/SkillCfg.ts

@@ -19,6 +19,7 @@ export class SkillCfg implements Cfg{
 	public targetid: number;
 	public ridicule: number;
 	public spellpower: number;
+	public halve: number;
 	public rangeid: number;
 	public select_targetID: number;
 	public eff_numtypeid: number;
@@ -74,6 +75,7 @@ export class SkillCfg implements Cfg{
         this.targetid = data.targetid;
         this.ridicule = data.ridicule;
         this.spellpower = data.spellpower;
+        this.halve = data.halve;
         this.rangeid = data.rangeid;
         this.select_targetID = data.select_targetID;
         this.eff_numtypeid = data.eff_numtypeid;

src/rooms/logic/Handler/BattleHandler.ts

@@ -3,9 +3,9 @@ import {Card} from "../../schema/Card";
 import {CardGameState} from "../../schema/CardGameState";
 import { PlayerHandler } from "./PlayerHandler";
 import CfgMan from "../CfgMan";
-import { EffectCardType, GameCampType, GameUnitType, SkillRangeUnitType } from "../skill/SkillConst";
+import { EffectCardType, GameCampType, GameUnitType, SkillEffectType, SkillRangeUnitType } from "../skill/SkillConst";
 import { Pet } from "rooms/schema/Pet";
-import {PetUpdateProcess, SkillParam, SkillTarget} from "../skill/SkillParam";
+import {PetUpdateProcess, SkillParam, SkillResult, SkillTarget} from "../skill/SkillParam";
 import { nosync, Room } from "colyseus";
 import { Skill } from "../skill/Skill";
 import { PetHandler } from "./PetHandler";
@@ -737,6 +737,8 @@ export class BattleHandler {
         ph.onCardGetted(getcards, fromph);
 
         // return this.endFlow('onCardGetted');
+
+        
         return 0;
     };
 
@@ -895,9 +897,60 @@ export class BattleHandler {
     };
 
     public onSkillResultNotify(skillres: SkillTarget[]){
+        /**
+         * indexOfAttack
+        start: number: number*/
+        let __indexOfAttack = function(start: number): number {
+            for(let i = start; i < skillres.length;i++){
+                if(skillres[i].bresok && skillres[i].isAttackSkill()){
+                    return i;
+                }
+            }
+            return -1;
+        };
+
+        let __indexOfAttackBk = function(start: number, atkres: SkillTarget): number{
+            for(let i = start; i < skillres.length;i++){
+                let obj = skillres[i];
+                if(obj.bresok && obj.isAttackBackSkill() 
+                    && atkres.dst == obj.srcPet() && obj.dst == atkres.srcPet()){
+                    return i;
+                }
+            }
+            return -1;
+        };
+
+
         if(!skillres || skillres.length <= 0){
             return;
         }
+
+        // 合并冲锋/反击
+        let nstart = 0;
+        while(true){
+            if(nstart >= skillres.length){
+                break;
+            }
+            let natk = __indexOfAttack(nstart);
+            if(natk < 0){
+                break;
+            }
+            nstart = natk + 1;
+            let atkobj = skillres[natk];
+            let natkbk = __indexOfAttackBk(nstart, atkobj);
+            if(natkbk){
+                let atkbkobj = skillres[natkbk];
+                atkbkobj.res && atkbkobj.res.forEach((item: SkillResult) => {
+                    if(item.bsuccess){
+                        if(item.effect_type == SkillEffectType.CHG_AP || item.effect_type == SkillEffectType.CHG_HP){
+                            atkobj.success(item.effect_type, item.effect_res, true);
+                        }
+                    }
+                });
+                skillres.splice(natkbk, 1);
+            }
+        }
+
         let checklst: PlayerHandler[] = [];
         let lst: SkillInfoMsg[] = [];
         let resmap: Map<string, SkillTarget[]> = new Map;

src/rooms/logic/Handler/PlayerHandler.ts

@@ -29,6 +29,7 @@ export class PlayerHandler {
     public _friend: PlayerHandler;
 
     public _cardstate: CondType = CondType.NO_COND;
+    public _cardlinkfrom: PlayerHandler = null;
 
     _totalcc: number = 0;
 
@@ -50,6 +51,7 @@ export class PlayerHandler {
         this._totalcc = 0;
         this._totalem = 0;
         this._cardstate = CondType.NO_COND;
+        this._cardlinkfrom = null;
     };
 
     public updateHero(bclear: boolean = false){
@@ -690,29 +692,39 @@ export class PlayerHandler {
 
     onCardLinkEnd(linkcards: Card[], fromplayer: PlayerHandler){
         this._cardstate = fromplayer? CondType.CARD_ACTION_LINK_OTHER: CondType.CARD_ACTION_LINK_SELF;
+        this._cardlinkfrom = fromplayer;
         this.checkSkills(TriggerType.CARD_LINK_AFTER, fromplayer);
     };
 
     onCardDroped(dropcards: Card[], srcplayer: PlayerHandler){
+        this.onCardChanged(srcplayer);
+
         this.checkSkills(TriggerType.CARD_DROP_MYROUND);
     };
 
     onCardDiscarded(discardcard: Card){
+        this.onCardChanged();
+
         this.checkSkills(TriggerType.CARD_DISCARD_MYROUND);
     };
 
     onCardGetted(getcards: Card[], srcplayer: PlayerHandler){
+        this.onCardChanged(srcplayer);
+
         getcards && (this._totalcc += getcards.length);
         this.checkSkills(TriggerType.CARD_GETTED);
     };
 
-    onCardChanged(srcplayer: PlayerHandler){
+    onCardChanged(srcplayer?: PlayerHandler){
         this.checkSkills(TriggerType.CARD_CHANGED, srcplayer);
     };
 
     onUseCardEnd(sp: SkillParam){
         this.checkSkills(TriggerType.CARD_USED);
+
+        this.onCardChanged(this._cardlinkfrom);
         this._cardstate = CondType.NO_COND; // 重置状态
+        this._cardlinkfrom = null;
     };
 
     onRoundStart(){
@@ -722,6 +734,7 @@ export class PlayerHandler {
     onRoundEnd(){
         this.checkSkills(TriggerType.ROUND_END_MYSELF);
         this._cardstate = CondType.NO_COND; // 重置状态
+        this._cardlinkfrom = null;
     };
 
     onGameStart(){

src/rooms/logic/skill/Skill.ts

@@ -485,7 +485,7 @@ export class Skill {
                 break;
             case SkillEffectType.HURT_POWER:
             case SkillEffectType.HURT_ALL:
-                let effv = this.EMV(effvalue);
+                let effv = this.EMV(effvalue, tgt.targetIsFriend());
                 if(tgt.dsttype != GameUnitType.NONE){
                     let oldhp = tgt.dst.getHP();
                     let n = tgt.dst.beHurt(effv, tgt.srcPet());
@@ -521,7 +521,7 @@ export class Skill {
     handleHP(effvalue: number, tgt: SkillTarget){
         let efftype = SkillEffectType.HURT_HP;
         if(tgt.dsttype != GameUnitType.NONE){
-            let effv = this.EMV(effvalue);
+            let effv = this.EMV(effvalue, tgt.targetIsFriend());
             let n = tgt.dst.addHP(effv, tgt.srcPet());
             tgt.success(efftype, n);
             tgt.success(SkillEffectType.CHG_HP, n);
@@ -663,12 +663,16 @@ export class Skill {
         }
     };
 
-    EMV(effvalue: number){
+    EMV(effvalue: number, isfriend: boolean){
+        let v = effvalue;
+        if(this._data.halve && isfriend){
+            v /= 2;
+        }
         if(!this._data.spellpower){
-            return effvalue;
+            return v;
         }
         let ev = this._owner.getEM();
-        return effvalue + ev;
+        return v + ev;
     };
 
     canEM(){

src/rooms/logic/skill/SkillParam.ts

@@ -68,6 +68,10 @@ export class SkillResult{
         this.err = err;
         this.bsuccess = issuccess;
         this.beffsrc = issrc;
+    };
+
+    public isSame(efftype: number, issrc: boolean): boolean{
+        return this.bsuccess && this.effect_type == efftype && this.beffsrc == issrc;
     }
 };
 
@@ -118,6 +122,20 @@ export class SkillTarget{
             effctid == SkillEffectType.ATTACK_BACK;
     };
 
+    public isAttackSkill(){
+        return this.srcskilltype == SkillEffectType.ATTACK;
+    };
+
+    public isAttackBackSkill(){
+        return this.srcskilltype == SkillEffectType.ATTACK_BACK;
+    };
+
+    public targetIsFriend(){
+        let srcp = this.srcPlayer();
+        let dstp = this.targetPlayer();
+        return srcp == dstp || (srcp && srcp._friend == dstp);
+    };
+
     public targetIsPet(){
         return this.dsttype == GameUnitType.PET || this.dsttype == GameUnitType.BATTLEUNIT;
     };
@@ -202,9 +220,23 @@ export class SkillTarget{
         }
     };
 
+    public findRes(efftype: number, effsrc: boolean): SkillResult{
+        for(let i =0; i < this.res.length; i++){
+            if(this.res[i].isSame(efftype, effsrc)){
+                return this.res[i];
+            }
+        }
+        return null;
+    };
+
     public success(efftype: number, effres: number, effsrc: boolean = false){
         this.checkRes();
-        this.res.push(new SkillResult(efftype, effres, true, 0, effsrc));
+        let obj = this.findRes(efftype, effsrc);
+        if(obj){
+            obj.effect_res += effres;
+        }else{
+            this.res.push(new SkillResult(efftype, effres, true, 0, effsrc));
+        }
         this.bresok = true;
     };