Merge remote-tracking branch 'remotes/master-origin/dor' into dor-sie…

…ge-warfare

client/GameComponents/Card.jsx

@@ -207,6 +207,7 @@ class Card extends React.Component {
                 cardHeight *= 2;
                 break;
         }
+
         let attachmentCount = this.props.source === 'play area' ? _.size(this.props.card.attachments) : 0;
         let attachments = this.props.card.attachments;
         let totalTiers = 0;
@@ -227,8 +228,8 @@ class Card extends React.Component {
     }
 
     getAttachments() {
-
-        if(this.props.source !== 'play area') {
+        const provinces = ['province 1', 'province 2', 'province 3', 'province 4', 'stronghold province'];
+        if(this.props.source !== 'play area' && !provinces.includes(this.props.source)) {
             return null;
         }
 
@@ -495,7 +496,7 @@ class Card extends React.Component {
     render() {
         if(this.props.wrapped) {
             return (
-                <div className={ 'card-wrapper ' + this.getWrapper() } style={ Object.assign({}, this.props.style ? this.props.style : {},this.getWrapperStyle()) }>
+                <div className={ 'card-wrapper ' + this.getWrapper() } style={ Object.assign({}, this.props.style ? this.props.style : {}, this.getWrapperStyle()) }>
                     { this.getCard() }
                     { this.getAttachments() }
                 </div>);

client/GameComponents/Province.jsx

@@ -47,6 +47,41 @@ class Province extends React.Component {
         }
     }
 
+    getWrapperStyle(provinceCard) {
+        let wrapperStyle = {};
+        let attachmentOffset = 13;
+        let cardHeight = 84;
+        switch(this.props.size) {
+            case 'large':
+                attachmentOffset *= 1.4;
+                cardHeight *= 1.4;
+                break;
+            case 'small':
+                attachmentOffset *= 0.8;
+                cardHeight *= 0.8;
+                break;
+            case 'x-large':
+                attachmentOffset *= 2;
+                cardHeight *= 2;
+                break;
+        }
+
+        let attachmentCount = _.size(provinceCard.attachments);
+        let attachments = provinceCard.attachments;
+        let totalTiers = 0;
+        _.forEach(attachments, attachment => {
+            if(attachment.bowed) {
+                totalTiers += 1;
+            }
+        });
+
+        if(attachmentCount > 0) {
+            wrapperStyle = { marginLeft:(4 + attachmentCount * attachmentOffset) + 'px', minHeight: (cardHeight + totalTiers * attachmentOffset) + 'px' };
+        }
+
+        return wrapperStyle;
+    }
+
     render() {
         var className = 'panel province ' + this.props.size;
         var cardCount = this.props.cardCount || (this.props.cards ? this.props.cards.length : '0');
@@ -89,7 +124,7 @@ class Province extends React.Component {
 
         return (
             <div className={ className } onDragLeave={ this.onDragLeave } onDragOver={ this.onDragOver } onDrop={ event => this.onDragDrop(event, this.props.source) }
-                onClick={ this.onCollectionClick }>
+                onClick={ this.onCollectionClick } style={ provinceCard ? Object.assign({}, this.getWrapperStyle(provinceCard)) : {} }>
                 <div className='panel-header'>
                     { headerText }
                 </div>

server/game/CardSelector.js

@@ -3,7 +3,6 @@ const MaxStatCardSelector = require('./CardSelectors/MaxStatCardSelector');
 const SingleCardSelector = require('./CardSelectors/SingleCardSelector');
 const UnlimitedCardSelector = require('./CardSelectors/UnlimitedCardSelector');
 const UpToXCardSelector = require('./CardSelectors/UpToXCardSelector');
-
 const { TargetModes, CardTypes } = require('./Constants');
 
 const defaultProperties = {

server/game/Constants.ts

@@ -54,6 +54,7 @@ export enum EffectNames {
     DelayedEffect = 'delayedEffect',
     DoesNotBow = 'doesNotBow',
     DoesNotReady = 'doesNotReady',
+    FateCostToAttack = 'fateCostToAttack',
     GainAbility = 'gainAbility',
     GainExtraFateWhenPlayed = 'gainExtraFateWhenPlayed',
     GainPlayAction = 'gainPlayAction',
@@ -115,7 +116,8 @@ export enum EffectNames {
     ChangeConflictSkillFunction = 'skillFunction',
     ModifyConflictElementsToResolve = 'modifyConflictElementsToResolve',
     RestrictNumberOfDefenders = 'restrictNumberOfDefenders',
-    ResolveConflictEarly = 'resolveConflictEarly'
+    ResolveConflictEarly = 'resolveConflictEarly',
+    SetBaseGlory = "setBaseGlory"
 };
 
 export enum Durations {

server/game/Effects/EffectValue.js

@@ -17,6 +17,10 @@ class EffectValue {
         return this.value;
     }
 
+    recalculate() {
+        return false;
+    }
+
     setContext(context) {
         this.context = context;
     }

server/game/Effects/StaticEffect.js

@@ -86,7 +86,7 @@ class StaticEffect {
     }
 
     recalculate() {
-        return false;
+        return this.value.recalculate();
     }
 
     setContext(context) {

server/game/Effects/SuppressEffect.js

@@ -0,0 +1,21 @@
+const EffectValue = require('./EffectValue');
+
+class SuppressEffect extends EffectValue {
+    constructor(predicate) {
+        super([]);
+        this.predicate = predicate;
+    }
+
+    recalculate() {
+        if(typeof this.predicate !== 'function') {
+            return false;
+        }
+        const oldValue = this.value;
+        const suppressedEffects = this.context.game.effectEngine.effects.filter(effect => this.predicate(effect.effect));
+        const newValue = suppressedEffects.map(effect => effect.effect);
+        this.setValue(newValue);
+        return oldValue.length !== newValue.length || oldValue.some(element => !newValue.includes(element));
+    }
+}
+
+module.exports = SuppressEffect;

server/game/Effects/restriction.js

@@ -1,6 +1,6 @@
 const EffectValue = require('./EffectValue');
 
-const { CardTypes } = require('../Constants');
+const { AbilityTypes, CardTypes } = require('../Constants');
 
 const checkRestrictions = {
     attachmentsWithSameClan: (context, effect, card) =>
@@ -24,6 +24,7 @@ const checkRestrictions = {
         context.player && context.player === effect.context.player.opponent && context.source.type === 'ring',
     opponentsTriggeredAbilities: (context, effect) =>
         context.player === effect.context.player.opponent && context.ability.isTriggeredAbility(),
+    reactions: context => context.ability.abilityType === AbilityTypes.Reaction,
     source: (context, effect) => context.source === effect.context.source
 };
 

server/game/GameActions/AttachAction.ts

@@ -13,7 +13,7 @@ export interface AttachActionProperties extends CardActionProperties {
 export class AttachAction extends CardGameAction {
     name = 'attach';
     eventName = EventNames.OnCardAttached;
-    targetType = [CardTypes.Character];
+    targetType = [CardTypes.Character, CardTypes.Province];
     defaultProperties: AttachActionProperties = {
         ignoreType: false,
         takeControl: false
@@ -33,7 +33,7 @@ export class AttachAction extends CardGameAction {
 
     canAffect(card: BaseCard, context: AbilityContext, additionalProperties = {}): boolean {
         let properties = this.getProperties(context, additionalProperties) as AttachActionProperties;
-        if(!context || !context.player || !card || card.location !== Locations.PlayArea) {
+        if(!context || !context.player || !card || card.location !== Locations.PlayArea && card.type !== CardTypes.Province) {
             return false;
         } else if(!properties.attachment || properties.attachment.anotherUniqueInPlay(context.player) || !properties.attachment.canAttach(card, context, properties.ignoreType)) {
             return false;
@@ -42,7 +42,8 @@ export class AttachAction extends CardGameAction {
         }
         return card.allowAttachment(properties.attachment) && super.canAffect(card, context);
     }
-
+
+
     checkEventCondition(event, additionalProperties): boolean {
         return this.canAffect(event.parent, event.context, additionalProperties);
     }

server/game/GameActions/CardGameAction.ts

@@ -31,7 +31,7 @@ export class CardGameAction extends GameAction {
             const additionalCosts = card.getEffects(EffectNames.UnlessActionCost).filter(properties => properties.actionName === this.name);
             if(additionalCosts.length > 0) {
                 let allCostsPaid = true;
-                for(const properties of additionalCosts) {                    
+                for(const properties of additionalCosts) {
                     context.game.queueSimpleStep(() => {
                         let cost = properties.cost;
                         if(typeof cost === 'function') {
@@ -52,11 +52,11 @@ export class CardGameAction extends GameAction {
                                         context.game.addMessage('{0} chooses not to {1}', card.controller, this.getEffectMessage(context, additionalProperties));
                                     }
                                 ]
-                            });    
+                            });
                         } else {
                             allCostsPaid = false;
                             context.game.addMessage('{0} cannot pay the additional cost required to {1}', card.controller, this.getEffectMessage(context, additionalProperties));
-                        }    
+                        }
                     });
                 }
                 context.game.queueSimpleStep(() => {
@@ -114,7 +114,7 @@ export class CardGameAction extends GameAction {
                 fateEvent.isContingent = true;
                 contingentEvents.push(fateEvent);
             }
-            return contingentEvents;    
+            return contingentEvents;
         }
     }
 

server/game/GameActions/DiscardStatusAction.ts

@@ -11,7 +11,7 @@ export class DiscardStatusAction extends TokenAction {
     cost = 'discarding {0}\'s status token';
 
     eventHandler(event): void {
-        if(event.token.card.personalHonor === event.token) {
+        if(event.token.card && event.token.card.personalHonor === event.token) {
             event.token.card.makeOrdinary();
         }
     }

server/game/GameActions/MultipleGameAction.ts

@@ -52,9 +52,11 @@ export class MultipleGameAction extends GameAction {
     addEventsToArray(events: any[], context: AbilityContext, additionalProperties = {}): void {
         let properties = this.getProperties(context, additionalProperties);
         for(const gameAction of properties.gameActions) {
-            if(gameAction.hasLegalTarget(context, additionalProperties)) {
-                gameAction.addEventsToArray(events, context, additionalProperties);
-            }
+            context.game.queueSimpleStep(() => {
+                if(gameAction.hasLegalTarget(context, additionalProperties)) {
+                    gameAction.addEventsToArray(events, context, additionalProperties);
+                }    
+            });
         }
     }
 

server/game/GameActions/PlayCardAction.ts

@@ -3,7 +3,7 @@ import AbilityResolver = require('../gamesteps/abilityresolver');
 import DrawCard = require('../drawcard');
 import Event = require('../Events/Event');
 import { CardGameAction, CardActionProperties } from './CardGameAction';
-import { Locations, PlayTypes }  from '../Constants';
+import { Locations, PlayTypes, Stages }  from '../Constants';
 
 class PlayCardResolver extends AbilityResolver {
     playGameAction: PlayCardAction;
@@ -18,6 +18,21 @@ class PlayCardResolver extends AbilityResolver {
         this.cancelPressed = false;
     }
 
+    resolveEarlyTargets() {
+        if(this.gameActionProperties.playCardTarget) {
+            this.context.stage = Stages.PreTarget;
+            this.targetResults = {
+                canIgnoreAllCosts: false,
+                cancelled: false,
+                payCostsFirst: false,
+                delayTargeting: null
+            };
+            this.gameActionProperties.playCardTarget(this.context, this.gameActionProperties);
+        } else {
+            super.resolveEarlyTargets();
+        }
+    }
+
     checkForCancel() {
         super.checkForCancel();
         if(this.cancelled && this.gameActionProperties.resetOnCancel) {
@@ -67,6 +82,8 @@ export interface PlayCardProperties extends CardActionProperties {
     resetOnCancel?: boolean;
     postHandler?: (context: AbilityContext) => void;
     playType?: PlayTypes;
+    playCardTarget?: (context: AbilityContext, properties: PlayCardProperties) => void;
+    location?: Locations;
     destination?: Locations;
     destinationOptions?: object;
     payCosts?: boolean;

server/game/GameObject.js

@@ -27,22 +27,16 @@ class GameObject {
     }
 
     getEffects(type) {
-        let suppressedEffects = this.getSuppressedEffects();
-        let filteredEffects = this.effects.filter(effect => effect.type === type && !suppressedEffects.includes(effect));
+        let filteredEffects = this.getRawEffects().filter(effect => effect.type === type);
         return filteredEffects.map(effect => effect.getValue(this));
     }
 
     getRawEffects() {
-        let suppressedEffects = this.getSuppressedEffects();
+        const suppressEffects = this.effects.filter(effect => effect.type === EffectNames.SuppressEffects);
+        const suppressedEffects = suppressEffects.reduce((array, effect) => array.concat(effect.getValue(this)), []);
         return this.effects.filter(effect => !suppressedEffects.includes(effect));
     }
 
-    getSuppressedEffects() {
-        let suppressingEffects = this.effects.filter(effect => effect.type === EffectNames.SuppressEffects);
-        let suppressedEffects = this.effects.filter(effect => suppressingEffects.some(suppressingEffect => suppressingEffect.value.value(effect)));
-        return suppressedEffects;
-    }
-
     sumEffects(type) {
         let filteredEffects = this.getEffects(type);
         return filteredEffects.reduce((total, effect) => total + effect, 0);

server/game/Interfaces.ts

@@ -163,12 +163,17 @@ export interface PersistentEffectProps {
     effect: Function | Function[];
 };
 
+export type traitLimit = {
+    [trait: string]: number
+};
+
 export interface AttachmentConditionProps {
     limit?: number;
     myControl?: boolean;
     unique?: boolean;
     faction?: string | string[];
     trait?: string | string[];
+    limitTrait?: traitLimit | traitLimit[]
 };
 
 interface HonoredToken {