From 21a92f69f3a088e85abe512952966a1051177e60 Mon Sep 17 00:00:00 2001 From: exane Date: Fri, 19 Jun 2015 14:14:37 +0200 Subject: [PATCH] add some abilities --- assets/data/abilities.js | 58 +- assets/data/cards.js | 97 +- assets/data/deck.js | 28 +- gulpfile.js | 17 +- public/index.html | 20 + public/js/client-lobby.js | 8 +- public/js/client.js | 56 +- server/Battle.js | 16 +- server/Battleside.js | 110 +- server/Card.js | 8 + server/Deck.js | 5 - server/Field.js | 4 + server/Hand.js | 11 + server/User.js | 9 + server/worker.js | 7 + test/SpecRunner.html | 1 + test/spec/filterSpec.js | 33 + test/spec/mainSpec.js | 5 + test/spec/spec.js | 3360 +++++++++++++++++++++++++++++++++++++ 19 files changed, 3772 insertions(+), 81 deletions(-) create mode 100644 test/spec/filterSpec.js create mode 100644 test/spec/mainSpec.js create mode 100644 test/spec/spec.js diff --git a/assets/data/abilities.js b/assets/data/abilities.js index c4e8b64..29db2aa 100644 --- a/assets/data/abilities.js +++ b/assets/data/abilities.js @@ -4,7 +4,19 @@ module.exports = { }, "medic": { + waitResponse: true, + onAfterPlace: function(card) { + var discard = this.getDiscard(); + discard = this.filter(discard, { + "ability": "hero", + "type": card.constructor.TYPE.SPECIAL + }) + + this.send("played:medic", { + cards: JSON.stringify(discard) + }, true); + } }, "morale_boost": { onAfterPlace: function(card) { @@ -19,14 +31,25 @@ module.exports = { } }, "muster": { + name: "muster", onAfterPlace: function(card){ - var name = card.getName(); + var musterType = card.getMusterType(); var self = this; - var cards = this.deck.find("name", name); - cards.forEach(function(_card) { + var cardsDeck = this.deck.find("musterType", musterType); + var cardsHand = this.hand.find("musterType", musterType); + + cardsDeck.forEach(function(_card) { self.deck.removeFromDeck(_card); - this.placeCard(_card); + self.placeCard(_card, { + suppress: "muster" + }); + }) + cardsHand.forEach(function(_card) { + self.hand.remove(_card); + self.placeCard(_card, { + suppress: "muster" + }); }) } }, @@ -128,5 +151,32 @@ module.exports = { var card = this.deck.removeFromDeck(cards[0]); this.placeCard(card); } + }, + "francesca_leader1": { + + }, + "francesca_leader2": { + + }, + "francesca_leader3": { + + }, + "francesca_leader4": { + + }, + "eredin_leader1": { + + }, + "eredin_leader2": { + + }, + "eredin_leader3": { + + }, + "eredin_leader4": { + + }, + "hero": { + } } \ No newline at end of file diff --git a/assets/data/cards.js b/assets/data/cards.js index 27f1124..314b617 100644 --- a/assets/data/cards.js +++ b/assets/data/cards.js @@ -204,7 +204,6 @@ module.exports = { }, - "francesca_pureblood_elf": { name: "Francesca, Pureblood Elf", power: -1, @@ -273,7 +272,7 @@ module.exports = { name: "Havekar Healer", power: 0, ability: "morale_boost", - img: "healerr", + img: "healer", faction: "Scoia'tael", type: 1 }, @@ -297,6 +296,7 @@ module.exports = { name: "Elven Skirmisher", power: 2, ability: "muster", + musterType: "skirmisher", img: "elven_skirmisher2", faction: "Scoia'tael", type: 1 @@ -305,6 +305,7 @@ module.exports = { name: "Dwarven Skirmisher", power: 3, ability: "muster", + musterType: "skirmisher", img: "skirmisher2", faction: "Scoia'tael", type: 0 @@ -332,7 +333,7 @@ module.exports = { img: "archer", faction: "Scoia'tael", type: 1 - },/* + }, /* "hav_caaren_medic": { name: "Hav’caaren Medic", power: 5, @@ -353,6 +354,7 @@ module.exports = { name: "Mahakaman Defender", power: 5, ability: "muster", + musterType: "defender", img: "defender2", faction: "Scoia'tael", type: 0 @@ -423,13 +425,12 @@ module.exports = { }, - "eredin_commander_of_the_red_riders": { name: "Eredin, Commander of the Red Riders", power: -1, ability: "eredin_leader1", img: "eredin_commander", - faction: "Monster", + faction: "monster", type: 3 }, "eredin_bringer_of_death": { @@ -437,7 +438,7 @@ module.exports = { power: -1, ability: "eredin_leader2", img: "eredin_bringer", - faction: "Monster", + faction: "monster", type: 3 }, "eredin_destroyer_of_worlds": { @@ -445,7 +446,7 @@ module.exports = { power: -1, ability: "eredin_leader3", img: "eredin_destroyer", - faction: "Monster", + faction: "monster", type: 3 }, "eredin_king_of_the_wild_hunt": { @@ -453,7 +454,7 @@ module.exports = { power: -1, ability: "eredin_leader4", img: "eredin_king", - faction: "Monster", + faction: "monster", type: 3 }, "kayran": { @@ -461,7 +462,7 @@ module.exports = { power: 8, ability: ["hero", "morale_boost"], img: "kayran", - faction: "Monster", + faction: "monster", type: 1 }, "leshen": { @@ -469,7 +470,7 @@ module.exports = { power: 10, ability: "hero", img: "leshen", - faction: "Monster", + faction: "monster", type: 1 }, "imlerith": { @@ -477,7 +478,7 @@ module.exports = { power: 10, ability: "hero", img: "imlerith", - faction: "Monster", + faction: "monster", type: 0 }, "draug": { @@ -485,23 +486,25 @@ module.exports = { power: 10, ability: "hero", img: "draug", - faction: "Monster", + faction: "monster", type: 0 }, "ghoul": { name: "Ghoul", power: 1, ability: "muster", + musterType: "ghoul", img: "ghoul1", - faction: "Monster", + faction: "monster", type: 0 }, "nekker": { name: "Nekker", power: 2, ability: "muster", + musterType: "nekker", img: "nekker", - faction: "Monster", + faction: "monster", type: 0 }, "wyvern": { @@ -509,7 +512,7 @@ module.exports = { power: 2, ability: null, img: "wyvern", - faction: "Monster", + faction: "monster", type: 1 }, "foglet": { @@ -517,7 +520,7 @@ module.exports = { power: 2, ability: null, img: "foglet", - faction: "Monster", + faction: "monster", type: 0 }, "celaeno_harpy": { @@ -525,7 +528,7 @@ module.exports = { power: 2, ability: null, img: "celaeno_harpy", - faction: "Monster", + faction: "monster", type: 1 }, "gargoyle": { @@ -533,7 +536,7 @@ module.exports = { power: 2, ability: null, img: "gargoyle", - faction: "Monster", + faction: "monster", type: 1 }, "cockatrice": { @@ -541,7 +544,7 @@ module.exports = { power: 2, ability: null, img: "cockatrice", - faction: "Monster", + faction: "monster", type: 1 }, "harpy": { @@ -549,7 +552,7 @@ module.exports = { power: 2, ability: "agile", img: "harpy", - faction: "Monster", + faction: "monster", type: 1 }, "endrega": { @@ -557,47 +560,52 @@ module.exports = { power: 2, ability: null, img: "endrega", - faction: "Monster", + faction: "monster", type: 1 }, "vampire_bruxa": { name: "Vampire: Bruxa", power: 4, ability: "muster", + musterType: "vampire", img: "vampire_bruxa", - faction: "Monster", + faction: "monster", type: 0 }, "vampire_fleder": { name: "Vampire: Fleder", power: 4, ability: "muster", + musterType: "vampire", img: "vampire_fleder", - faction: "Monster", + faction: "monster", type: 0 }, "vampire_garkain": { name: "Vampire: Garkain", power: 4, ability: "muster", + musterType: "vampire", img: "vampire_garkain", - faction: "Monster", + faction: "monster", type: 0 }, "vampire_ekimmara": { name: "Vampire: Ekimmara", power: 4, ability: "muster", + musterType: "vampire", img: "vampire_ekimmara", - faction: "Monster", + faction: "monster", type: 0 }, "arachas": { name: "Arachas", power: 4, ability: "muster", + musterType: "arachas", img: "arachas1", - faction: "Monster", + faction: "monster", type: 0 }, "botchling": { @@ -605,7 +613,7 @@ module.exports = { power: 4, ability: null, img: "botchling", - faction: "Monster", + faction: "monster", type: 0 }, "forktail": { @@ -613,7 +621,7 @@ module.exports = { power: 5, ability: null, img: "forktail", - faction: "Monster", + faction: "monster", type: 0 }, "plague_maiden": { @@ -621,7 +629,7 @@ module.exports = { power: 5, ability: null, img: "forktail", - faction: "Monster", + faction: "monster", type: 0 }, "griffin": { @@ -629,7 +637,7 @@ module.exports = { power: 5, ability: null, img: "griffin", - faction: "Monster", + faction: "monster", type: 0 }, "werewolf": { @@ -637,7 +645,7 @@ module.exports = { power: 5, ability: null, img: "werewolf", - faction: "Monster", + faction: "monster", type: 0 }, "frightener": { @@ -645,7 +653,7 @@ module.exports = { power: 5, ability: null, img: "frightener", - faction: "Monster", + faction: "monster", type: 0 }, "ice_giant": { @@ -653,7 +661,7 @@ module.exports = { power: 5, ability: null, img: "ice_giant", - faction: "Monster", + faction: "monster", type: 2 }, "grave_hag": { @@ -661,47 +669,52 @@ module.exports = { power: 5, ability: null, img: "grave_hag", - faction: "Monster", + faction: "monster", type: 1 }, /*"vampire_katakan": { name: "Vampire: Katakan", power: 5, ability: "muster", + musterType: "vampire", img: "vampire_katakan", - faction: "Monster", + faction: "monster", type: 0 },*/ "crone_whispess": { name: "Crone: Whispess", power: 6, ability: "muster", + musterType: "crone", img: "crone_whispess", - faction: "Monster", + faction: "monster", type: 0 }, "crone_brewess": { name: "Crone: Brewess", power: 6, ability: "muster", + musterType: "crone", img: "crone_brewess", - faction: "Monster", + faction: "monster", type: 0 }, "crone_weavess": { name: "Crone: Weavess", power: 6, ability: "muster", + musterType: "crone", img: "crone_weavess", - faction: "Monster", + faction: "monster", type: 0 }, "arachas_behemoth": { name: "Arachas Behemoth", power: 6, ability: "muster", + musterType: "arachas", img: "arachas_behemoth", - faction: "Monster", + faction: "monster", type: 2 }, "fire_elemental": { @@ -709,7 +722,7 @@ module.exports = { power: 6, ability: null, img: "fire_elemental", - faction: "Monster", + faction: "monster", type: 2 }, "fiend": { @@ -717,7 +730,7 @@ module.exports = { power: 6, ability: null, img: "fiend", - faction: "Monster", + faction: "monster", type: 0 }, "earth_elemental": { @@ -725,7 +738,7 @@ module.exports = { power: 6, ability: null, img: "earth_elemental", - faction: "Monster", + faction: "monster", type: 2 } } diff --git a/assets/data/deck.js b/assets/data/deck.js index b6495f5..58810fa 100644 --- a/assets/data/deck.js +++ b/assets/data/deck.js @@ -1,6 +1,6 @@ module.exports = { - "test": [ + "northern_realm": [ "redanian_foot_soldier", "poor_fucking_infantry", "redanian_foot_soldier", @@ -29,11 +29,8 @@ module.exports = { "impenetrable_fog" ], - "Scoia'tael": [ - "francesca_pureblood_elf", - "francesca_the_beautiful", + "scoiatael": [ "francesca_daisy_of_the_valley", - "francesca_queen_of_dol_blathanna", "saesenthessis", "iorveth", "isengrim_faoiltiarnah", @@ -41,17 +38,22 @@ module.exports = { "havekar_healer", "riordain", "toruviel", + "decoy", + "decoy", + "impenetrable_fog", "elven_skirmisher", + "elven_skirmisher", + "dwarven_skirmisher", "dwarven_skirmisher", "ciaran_aep_easnillien", "vrihedd_brigade_recruit", "dol_blathanna_archer", - //"hav_caaren_medic", "havekar_smuggler", "mahakaman_defender", "vrihedd_brigade_veteran", "dennis_cranmer", "filavandrel_aen_fidhail", + "filavandrel_aen_fidhail", "ida_emean_aep_sivney", "yaevinn", "barclay_els", @@ -60,15 +62,15 @@ module.exports = { ], "monster": [ - "eredin_commander_of_the_red_riders", - "eredin_bringer_of_death", - "eredin_destroyer_of_worlds", "eredin_king_of_the_wild_hunt", "kayran", "leshen", "imlerith", "draug", "ghoul", + "decoy", + "decoy", + "nekker", "nekker", "wyvern", "foglet", @@ -76,10 +78,15 @@ module.exports = { "gargoyle", "cockatrice", "harpy", + "impenetrable_fog", "endrega", "vampire_bruxa", + "vampire_bruxa", + "vampire_fleder", "vampire_fleder", "vampire_garkain", + "vampire_garkain", + "vampire_ekimmara", "vampire_ekimmara", "arachas", "botchling", @@ -92,7 +99,10 @@ module.exports = { "grave_hag", //"vampire_katakan", "crone_whispess", + "crone_whispess", "crone_brewess", + "crone_brewess", + "crone_weavess", "crone_weavess", "arachas_behemoth", "fire_elemental", diff --git a/gulpfile.js b/gulpfile.js index 43c0d8e..5ac1162 100644 --- a/gulpfile.js +++ b/gulpfile.js @@ -40,9 +40,24 @@ gulp.task('sass', function(){ })); }); +gulp.task("unit tests", function(){ + browserify('./test/spec/mainSpec.js', {standalone: "app", debug: true}) + .transform(babelify) + .bundle().on("error", function(err){ + console.log(err); + }) + .pipe(source('spec.js').on("error", function(err){ + console.log(err); + })) + .pipe(gulp.dest('./test/spec/').on("error", function(err){ + console.log(err); + })); +}) + gulp.task("watch", function(){ gulp.watch("./public/js/*", ["browserify"]); gulp.watch("./public/scss/*", ["sass"]); + gulp.watch("./test/spec/*", ["unit tests"]); }) -gulp.task("default", ["watch", "browserify", "sass"]); +gulp.task("default", ["watch", "browserify", "sass", "unit tests"]); diff --git a/public/index.html b/public/index.html index 33d7bda..7967776 100644 --- a/public/index.html +++ b/public/index.html @@ -160,6 +160,11 @@
+
@@ -213,6 +218,21 @@
close
+ diff --git a/public/js/client-lobby.js b/public/js/client-lobby.js index 89200b7..e9298c5 100644 --- a/public/js/client-lobby.js +++ b/public/js/client-lobby.js @@ -18,10 +18,12 @@ var Lobby = Backbone.View.extend({ events: { "click .create-room": "createRoom", "click .join-room": "joinRoom", - "blur .name-input": "changeName" + "blur .name-input": "changeName", + "change #deckChoice": "setDeck" }, render: function(){ this.$el.html(this.template(this.app.user.attributes)); + //this.$el.find("#deckChoice option[value='" + this.app.user.get("setDeck") + "']").attr("selected", "selected") return this; }, createRoom: function(){ @@ -30,6 +32,10 @@ var Lobby = Backbone.View.extend({ joinRoom: function(){ this.app.send("request:joinRoom"); }, + setDeck: function(e){ + var val = $(e.target).val(); + this.app.user.setDeck(val); + }, changeName: function(e){ var name = $(e.target).val(); this.app.user.setName(name); diff --git a/public/js/client.js b/public/js/client.js index d8aa4e7..ae2c3b5 100644 --- a/public/js/client.js +++ b/public/js/client.js @@ -304,7 +304,8 @@ var BattleView = Backbone.View.extend({ var side; if($discard.parent().hasClass("player")){ side = this.yourSide; - } else { + } + else { side = this.otherSide; } this.user.set("openDiscard", { @@ -327,6 +328,10 @@ var BattleView = Backbone.View.extend({ var modal = new Modal({model: this.user}); this.$el.prepend(modal.render().el); } + if(this.user.get("medicDiscard")){ + var modal = new MedicModal({model: this.user}); + this.$el.prepend(modal.render().el); + } if(this.user.get("waitForDecoy")){ var id = this.user.get("waitForDecoy"); @@ -337,7 +342,7 @@ var BattleView = Backbone.View.extend({ renderPreview: function(){ this.$el.find(".card-preview").html(this.templatePreview({src: this.user.get("showPreview")})) }, - clickLeader: function(e) { + clickLeader: function(e){ var $card = $(e.target).closest(".field-leader"); console.log("click leader"); if(!$card.parent().hasClass("player")) return; @@ -402,9 +407,29 @@ var Modal = Backbone.Modal.extend({ } }); +var MedicModal = Modal.extend({ + template: Handlebars.compile($("#modal-medic-template").html()), + events: { + "click .card": "onCardClick" + }, + onCardClick: function(e){ + console.log($(e.target).closest(".card")); + var id = $(e.target).closest(".card").data().id; + this.model.get("app").send("medic:chooseCardFromDiscard", { + cardID: id + }) + this.model.set("medicDiscard", false); + }, + cancel: function(){ + this.model.get("app").send("medic:chooseCardFromDiscard") + this.model.set("medicDiscard", false); + } +}); + var User = Backbone.Model.extend({ defaults: { - name: "" + name: "", + deckKey: "northern_realm" }, initialize: function(){ var self = this; @@ -444,15 +469,24 @@ var User = Backbone.Model.extend({ self.set("passing", passing); }) - app.receive("foe:left", function() { + app.receive("foe:left", function(){ console.log("your foe left the room"); $(".container").prepend('
Your foe left the battle!
') }) + app.receive("played:medic", function(data){ + var cards = JSON.parse(data.cards); + console.log("played medic"); + self.set("medicDiscard", { + cards: cards + }); + }) + app.on("createRoom", this.createRoom, this); app.on("joinRoom", this.joinRoom, this); app.on("setName", this.setName, this); + app.on("setDeck", this.setDeck, this); app.send("request:name", this.get("name") == "unnamed" ? null : {name: this.get("name")}); @@ -470,6 +504,11 @@ var User = Backbone.Model.extend({ }, setName: function(name){ this.get("app").send("request:name", {name: name}); + }, + setDeck: function(deckKey){ + console.log("deck: ", deckKey); + this.set("deckKey", deckKey); + this.get("app").send("set:deck", {deck: deckKey}); } }); @@ -490,10 +529,12 @@ var Lobby = Backbone.View.extend({ events: { "click .create-room": "createRoom", "click .join-room": "joinRoom", - "blur .name-input": "changeName" + "blur .name-input": "changeName", + "change #deckChoice": "setDeck" }, render: function(){ this.$el.html(this.template(this.user.attributes)); + /*this.$el.find("#deckChoice option[value='" + this.app.user.get("setDeck") + "']").attr("selected", "selected")*/ return this; }, createRoom: function(){ @@ -502,6 +543,11 @@ var Lobby = Backbone.View.extend({ joinRoom: function(){ this.app.trigger("joinRoom"); }, + setDeck: function(e){ + var val = $(e.target).val(); + this.app.trigger("setDeck", val); + this.$el.find("#deckChoice option[value='" + val + "']").attr("selected", "selected") + }, changeName: function(e){ var name = $(e.target).val(); this.app.trigger("setName", name); diff --git a/server/Battle.js b/server/Battle.js index e658d05..b7a4663 100644 --- a/server/Battle.js +++ b/server/Battle.js @@ -39,7 +39,8 @@ var Battle = (function(){ r.init = function(){ /*PubSub.subscribe("update", this.update.bind(this));*/ - this.on("Update", this.update); + this.on("Update", this.update);/* + this.on("AfterPlace", this.checkAbilityOnAfterPlace)*/ this.channel = this.socket.subscribe(this._id); @@ -56,13 +57,20 @@ var Battle = (function(){ r.start = function(){ this.p1.setLeadercard(); this.p2.setLeadercard(); - this.p1.draw(10); - this.p2.draw(10); + this.p1.draw(5); + this.p2.draw(5); + this.p1.hand.add(Card("dun_banner_medic")); + this.p2.hand.add(Card("dun_banner_medic")); + this.p1.hand.add(Card("isengrim_faoiltiarnah")); + this.p2.hand.add(Card("isengrim_faoiltiarnah")); + this.p1.addToDiscard([Card("kaedweni_siege_expert")]); + this.p2.addToDiscard([Card("kaedweni_siege_expert")]); +/* this.p1.hand.add(Card("decoy")); this.p1.hand.add(Card("impenetrable_fog")); this.p2.hand.add(Card("decoy")); - this.p2.hand.add(Card("impenetrable_fog")); + this.p2.hand.add(Card("impenetrable_fog"));*/ this.update(); diff --git a/server/Battleside.js b/server/Battleside.js index 5a9f8a3..37a59a2 100644 --- a/server/Battleside.js +++ b/server/Battleside.js @@ -1,9 +1,9 @@ -var io = global.io; var DeckData = require("../assets/data/deck"); var Deck = require("./Deck"); var Hand = require("./Hand"); var Card = require("./Card"); var Field = require("./Field"); +var _ = require("underscore"); var Battleside; @@ -16,6 +16,7 @@ Battleside = (function(){ * constructor here */ + var deck = user.getDeck(); var self = this; this._isWaiting = true; this.socket = user.socket; @@ -28,7 +29,7 @@ Battleside = (function(){ this._name = name; this.battle = battle; this.hand = Hand(); - this.deck = Deck(DeckData["test"]); + this.deck = Deck(DeckData[deck]); this._discard = []; this.runEvent = this.battle.runEvent.bind(this.battle); @@ -74,6 +75,20 @@ Battleside = (function(){ self.update(); self.runEvent("NextTurn", null, [self.foe]); }) + this.receive("medic:chooseCardFromDiscard", function(data){ + if(!data){ + self.runEvent("NextTurn", null, [self.foe]); + return; + } + var cardID = data.cardID; + var card = self.getCardFromDiscard(cardID); + if(card === -1) throw new Error("medic:chooseCardFromDiscard | unknown card: ", card); + + self.removeFromDiscard(card); + + self.playCard(card); + }) + this.on("Turn" + this.getID(), this.onTurnStart, this); }; @@ -115,6 +130,19 @@ Battleside = (function(){ var card = field.getCard(id); if(card !== -1) return card; } + /* + for(var i = 0; i < this._discard.length; i++) { + var c = this._discard[i]; + if(c.getID() === id) return c; + }*/ + return -1; + } + + r.getCardFromDiscard = function(id){ + for(var i = 0; i < this._discard.length; i++) { + var c = this._discard[i]; + if(c.getID() === id) return c; + } return -1; } @@ -237,8 +265,8 @@ Battleside = (function(){ this.runEvent("NextTurn", null, [this.foe]); } - r.placeCard = function(card){ - var obj = {}; + r.placeCard = function(card, obj){ + obj = _.extend({}, obj); this.checkAbilities(card, obj); if(obj._canclePlacement) return 0; @@ -246,13 +274,21 @@ Battleside = (function(){ var field = obj.targetSide.field[card.getType()]; field.add(card); - //PubSub.publish("onEachCardPlace"); - this.runEvent("OnEachCardPlace"); - this.checkAbilityOnAfterPlace(card); + this.runEvent("EachCardPlace"); + + this.checkAbilityOnAfterPlace(card, obj); + /* + this.runEvent("AfterPlace", this, [card, obj]);*/ this.update(); + if(obj._waitResponse){ + this.hand.remove(card); + this.update(); + return 0; + } + return 1; } @@ -260,6 +296,7 @@ Battleside = (function(){ var self = this; obj.targetSide = this; var ability = Array.isArray(__flag) || card.getAbility(); + if(Array.isArray(ability) && ability.length){ var ret = ability.slice(); ret = ret.splice(0, 1); @@ -267,8 +304,14 @@ Battleside = (function(){ ability = ability[0]; } - if(ability && !Array.isArray(ability)){/* - var ability = card.getAbility();*/ + if(ability && ability.name === obj.suppress){ + this.update(); + } + + if(ability && !Array.isArray(ability)){ + if(ability.waitResponse){ + obj._waitResponse = true; + } if(ability.changeSide){ obj.targetSide = this.foe; } @@ -307,9 +350,13 @@ Battleside = (function(){ } } - r.checkAbilityOnAfterPlace = function(card){ + r.checkAbilityOnAfterPlace = function(card, obj){ var ability = card.getAbility(); if(ability){ + if(ability.name && ability.name === obj.suppress){ + this.update(); + return; + } if(ability.onAfterPlace){ ability.onAfterPlace.call(this, card) } @@ -332,6 +379,17 @@ Battleside = (function(){ }); } + r.removeFromDiscard = function(card){ + for(var i = 0; i < this._discard.length; i++) { + var c = this._discard[i]; + if(c.getID() === card.getID()){ + + this._discard.splice(i, 1); + return + } + } + } + r.getDiscard = function(json){ if(json){ return JSON.stringify(this._discard); @@ -344,6 +402,38 @@ Battleside = (function(){ this.setPassing(false); } + r.filter = function(arrCards, opt){ + var arr = arrCards.slice(); + + for(var key in opt) { + var res = []; + var prop = key, val = opt[key]; + + + arrCards.forEach(function(card){ + var property = card.getProperty(prop); + if(_.isArray(property)){ + var _f = false; + for(var i = 0; i < property.length; i++) { + if(property[i] === val) { + _f = true; + break; + } + } + if(!_f){ + res.push(card); + } + } + else if(card.getProperty(prop) !== val){ + res.push(card); + } + }) + arr = _.intersection(arr, res); + } + + return arr; + } + return Battleside; })(); diff --git a/server/Card.js b/server/Card.js index 5a122ad..69f07b7 100644 --- a/server/Card.js +++ b/server/Card.js @@ -91,6 +91,9 @@ var Card = (function(){ r.getFaction = function(){ return this._data.faction; } + r.getMusterType = function() { + return this._data.musterType || null; + } r.getType = function(){ return this._data.type; } @@ -116,9 +119,14 @@ var Card = (function(){ } r.getProperty = function(prop){ + if(!this._data[prop]) return {}; return this._data[prop]; } + r.resetBoost = function() { + this._boost = 0; + } + return Card; })(); diff --git a/server/Deck.js b/server/Deck.js index 2978da8..bc86edb 100644 --- a/server/Deck.js +++ b/server/Deck.js @@ -78,11 +78,6 @@ var Deck = (function(){ var n = this.length(); for(var i = 0; i < n; i++) { - /*var cardID = this.getDeck()[i]; - if(id == cardID){ - this.getDeck().splice(i, 1); - return id; - }*/ var c = this.getDeck()[i]; if(c.getID() === card.getID()){ return this.getDeck().splice(i, 1)[0]; diff --git a/server/Field.js b/server/Field.js index 1c6d6f2..056811e 100644 --- a/server/Field.js +++ b/server/Field.js @@ -51,6 +51,7 @@ var Field = (function(){ r.replaceWith = function(oldCard, newCard){ var index = this.getPosition(oldCard); this._cards[index] = newCard; + oldCard.resetBoost(); return oldCard; } @@ -64,6 +65,9 @@ var Field = (function(){ r.removeAll = function() { var tmp = this._cards.slice(); + tmp.forEach(function(card) { + card.resetBoost(); + }) this._cards = []; return tmp; } diff --git a/server/Hand.js b/server/Hand.js index 95323d0..613a55d 100644 --- a/server/Hand.js +++ b/server/Hand.js @@ -49,6 +49,7 @@ var Hand = (function(){ if(this._hand[i].getID() != id) continue; return this._hand.splice(i, 1); } + return -1; } @@ -65,6 +66,16 @@ var Hand = (function(){ return this._hand.length; } + r.find = function(key, val) { + var res = []; + this._hand.forEach(function(card){ + if(card.getProperty(key) == val){ + res.push(card); + } + }); + return res; + } + return Hand; })(); diff --git a/server/User.js b/server/User.js index 1528c3f..4ce88fd 100644 --- a/server/User.js +++ b/server/User.js @@ -74,6 +74,15 @@ var User = (function(){ return this._rooms[0]; } + r.setDeck = function(deck) { + console.log("set deck: ", deck); + this._deck = deck; + } + + r.getDeck = function() { + return this._deck || "northern_realm"; + } + r.addRoom = function(room) { this._rooms.push(room); } diff --git a/server/worker.js b/server/worker.js index 99a19d8..afaf866 100644 --- a/server/worker.js +++ b/server/worker.js @@ -35,6 +35,13 @@ module.exports.run = function(worker){ socket.emit("response:name", {name: user.getName()}); }) + socket.on("set:deck", function(data) { + console.log(data); + if(data && data.deck){ + user.setDeck(data.deck); + } + }) + socket.on("request:gameLoaded", function(data){ console.log(data); connections.roomCollection[data._roomID].setReady(user); diff --git a/test/SpecRunner.html b/test/SpecRunner.html index c005d5e..c1b2b4c 100644 --- a/test/SpecRunner.html +++ b/test/SpecRunner.html @@ -17,6 +17,7 @@ + diff --git a/test/spec/filterSpec.js b/test/spec/filterSpec.js new file mode 100644 index 0000000..8ca5273 --- /dev/null +++ b/test/spec/filterSpec.js @@ -0,0 +1,33 @@ +var Card = require("../../server/Card"); +var Battleside = require("../../server/Battleside"); +var data = require("../../assets/data/abilities"); + + +describe("filter", function(){ + var card, side, filter, cards; + beforeEach(function(){ + filter = Battleside.prototype.filter; + cards = []; + cards.push(Card("iorveth")); + cards.push(Card("toruviel")); + cards.push(Card("isengrim_faoiltiarnah")); + cards.push(Card("decoy")); + }) + + it("it should filter heroes out", function(){ + var res = filter(cards, { + "ability": "hero" + }) + expect(res.length).toBe(2); + }) + + it("it should filter hero and special cards out", function(){ + var res = filter(cards, { + "ability": "hero", + "type": Card.TYPE.SPECIAL + }) + expect(res.length).toBe(1); + }) + + +}) \ No newline at end of file diff --git a/test/spec/mainSpec.js b/test/spec/mainSpec.js new file mode 100644 index 0000000..b5add0c --- /dev/null +++ b/test/spec/mainSpec.js @@ -0,0 +1,5 @@ +require("./filterSpec"); + +(function main(){ + +})(); diff --git a/test/spec/spec.js b/test/spec/spec.js new file mode 100644 index 0000000..c67490e --- /dev/null +++ b/test/spec/spec.js @@ -0,0 +1,3360 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.app = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= 0 && length <= MAX_ARRAY_INDEX; + }; + + // Collection Functions + // -------------------- + + // The cornerstone, an `each` implementation, aka `forEach`. + // Handles raw objects in addition to array-likes. Treats all + // sparse array-likes as if they were dense. + _.each = _.forEach = function(obj, iteratee, context) { + iteratee = optimizeCb(iteratee, context); + var i, length; + if (isArrayLike(obj)) { + for (i = 0, length = obj.length; i < length; i++) { + iteratee(obj[i], i, obj); + } + } else { + var keys = _.keys(obj); + for (i = 0, length = keys.length; i < length; i++) { + iteratee(obj[keys[i]], keys[i], obj); + } + } + return obj; + }; + + // Return the results of applying the iteratee to each element. + _.map = _.collect = function(obj, iteratee, context) { + iteratee = cb(iteratee, context); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length, + results = Array(length); + for (var index = 0; index < length; index++) { + var currentKey = keys ? keys[index] : index; + results[index] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + }; + + // Create a reducing function iterating left or right. + function createReduce(dir) { + // Optimized iterator function as using arguments.length + // in the main function will deoptimize the, see #1991. + function iterator(obj, iteratee, memo, keys, index, length) { + for (; index >= 0 && index < length; index += dir) { + var currentKey = keys ? keys[index] : index; + memo = iteratee(memo, obj[currentKey], currentKey, obj); + } + return memo; + } + + return function(obj, iteratee, memo, context) { + iteratee = optimizeCb(iteratee, context, 4); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length, + index = dir > 0 ? 0 : length - 1; + // Determine the initial value if none is provided. + if (arguments.length < 3) { + memo = obj[keys ? keys[index] : index]; + index += dir; + } + return iterator(obj, iteratee, memo, keys, index, length); + }; + } + + // **Reduce** builds up a single result from a list of values, aka `inject`, + // or `foldl`. + _.reduce = _.foldl = _.inject = createReduce(1); + + // The right-associative version of reduce, also known as `foldr`. + _.reduceRight = _.foldr = createReduce(-1); + + // Return the first value which passes a truth test. Aliased as `detect`. + _.find = _.detect = function(obj, predicate, context) { + var key; + if (isArrayLike(obj)) { + key = _.findIndex(obj, predicate, context); + } else { + key = _.findKey(obj, predicate, context); + } + if (key !== void 0 && key !== -1) return obj[key]; + }; + + // Return all the elements that pass a truth test. + // Aliased as `select`. + _.filter = _.select = function(obj, predicate, context) { + var results = []; + predicate = cb(predicate, context); + _.each(obj, function(value, index, list) { + if (predicate(value, index, list)) results.push(value); + }); + return results; + }; + + // Return all the elements for which a truth test fails. + _.reject = function(obj, predicate, context) { + return _.filter(obj, _.negate(cb(predicate)), context); + }; + + // Determine whether all of the elements match a truth test. + // Aliased as `all`. + _.every = _.all = function(obj, predicate, context) { + predicate = cb(predicate, context); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length; + for (var index = 0; index < length; index++) { + var currentKey = keys ? keys[index] : index; + if (!predicate(obj[currentKey], currentKey, obj)) return false; + } + return true; + }; + + // Determine if at least one element in the object matches a truth test. + // Aliased as `any`. + _.some = _.any = function(obj, predicate, context) { + predicate = cb(predicate, context); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length; + for (var index = 0; index < length; index++) { + var currentKey = keys ? keys[index] : index; + if (predicate(obj[currentKey], currentKey, obj)) return true; + } + return false; + }; + + // Determine if the array or object contains a given item (using `===`). + // Aliased as `includes` and `include`. + _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) { + if (!isArrayLike(obj)) obj = _.values(obj); + if (typeof fromIndex != 'number' || guard) fromIndex = 0; + return _.indexOf(obj, item, fromIndex) >= 0; + }; + + // Invoke a method (with arguments) on every item in a collection. + _.invoke = function(obj, method) { + var args = slice.call(arguments, 2); + var isFunc = _.isFunction(method); + return _.map(obj, function(value) { + var func = isFunc ? method : value[method]; + return func == null ? func : func.apply(value, args); + }); + }; + + // Convenience version of a common use case of `map`: fetching a property. + _.pluck = function(obj, key) { + return _.map(obj, _.property(key)); + }; + + // Convenience version of a common use case of `filter`: selecting only objects + // containing specific `key:value` pairs. + _.where = function(obj, attrs) { + return _.filter(obj, _.matcher(attrs)); + }; + + // Convenience version of a common use case of `find`: getting the first object + // containing specific `key:value` pairs. + _.findWhere = function(obj, attrs) { + return _.find(obj, _.matcher(attrs)); + }; + + // Return the maximum element (or element-based computation). + _.max = function(obj, iteratee, context) { + var result = -Infinity, lastComputed = -Infinity, + value, computed; + if (iteratee == null && obj != null) { + obj = isArrayLike(obj) ? obj : _.values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value > result) { + result = value; + } + } + } else { + iteratee = cb(iteratee, context); + _.each(obj, function(value, index, list) { + computed = iteratee(value, index, list); + if (computed > lastComputed || computed === -Infinity && result === -Infinity) { + result = value; + lastComputed = computed; + } + }); + } + return result; + }; + + // Return the minimum element (or element-based computation). + _.min = function(obj, iteratee, context) { + var result = Infinity, lastComputed = Infinity, + value, computed; + if (iteratee == null && obj != null) { + obj = isArrayLike(obj) ? obj : _.values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value < result) { + result = value; + } + } + } else { + iteratee = cb(iteratee, context); + _.each(obj, function(value, index, list) { + computed = iteratee(value, index, list); + if (computed < lastComputed || computed === Infinity && result === Infinity) { + result = value; + lastComputed = computed; + } + }); + } + return result; + }; + + // Shuffle a collection, using the modern version of the + // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle). + _.shuffle = function(obj) { + var set = isArrayLike(obj) ? obj : _.values(obj); + var length = set.length; + var shuffled = Array(length); + for (var index = 0, rand; index < length; index++) { + rand = _.random(0, index); + if (rand !== index) shuffled[index] = shuffled[rand]; + shuffled[rand] = set[index]; + } + return shuffled; + }; + + // Sample **n** random values from a collection. + // If **n** is not specified, returns a single random element. + // The internal `guard` argument allows it to work with `map`. + _.sample = function(obj, n, guard) { + if (n == null || guard) { + if (!isArrayLike(obj)) obj = _.values(obj); + return obj[_.random(obj.length - 1)]; + } + return _.shuffle(obj).slice(0, Math.max(0, n)); + }; + + // Sort the object's values by a criterion produced by an iteratee. + _.sortBy = function(obj, iteratee, context) { + iteratee = cb(iteratee, context); + return _.pluck(_.map(obj, function(value, index, list) { + return { + value: value, + index: index, + criteria: iteratee(value, index, list) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || a === void 0) return 1; + if (a < b || b === void 0) return -1; + } + return left.index - right.index; + }), 'value'); + }; + + // An internal function used for aggregate "group by" operations. + var group = function(behavior) { + return function(obj, iteratee, context) { + var result = {}; + iteratee = cb(iteratee, context); + _.each(obj, function(value, index) { + var key = iteratee(value, index, obj); + behavior(result, value, key); + }); + return result; + }; + }; + + // Groups the object's values by a criterion. Pass either a string attribute + // to group by, or a function that returns the criterion. + _.groupBy = group(function(result, value, key) { + if (_.has(result, key)) result[key].push(value); else result[key] = [value]; + }); + + // Indexes the object's values by a criterion, similar to `groupBy`, but for + // when you know that your index values will be unique. + _.indexBy = group(function(result, value, key) { + result[key] = value; + }); + + // Counts instances of an object that group by a certain criterion. Pass + // either a string attribute to count by, or a function that returns the + // criterion. + _.countBy = group(function(result, value, key) { + if (_.has(result, key)) result[key]++; else result[key] = 1; + }); + + // Safely create a real, live array from anything iterable. + _.toArray = function(obj) { + if (!obj) return []; + if (_.isArray(obj)) return slice.call(obj); + if (isArrayLike(obj)) return _.map(obj, _.identity); + return _.values(obj); + }; + + // Return the number of elements in an object. + _.size = function(obj) { + if (obj == null) return 0; + return isArrayLike(obj) ? obj.length : _.keys(obj).length; + }; + + // Split a collection into two arrays: one whose elements all satisfy the given + // predicate, and one whose elements all do not satisfy the predicate. + _.partition = function(obj, predicate, context) { + predicate = cb(predicate, context); + var pass = [], fail = []; + _.each(obj, function(value, key, obj) { + (predicate(value, key, obj) ? pass : fail).push(value); + }); + return [pass, fail]; + }; + + // Array Functions + // --------------- + + // Get the first element of an array. Passing **n** will return the first N + // values in the array. Aliased as `head` and `take`. The **guard** check + // allows it to work with `_.map`. + _.first = _.head = _.take = function(array, n, guard) { + if (array == null) return void 0; + if (n == null || guard) return array[0]; + return _.initial(array, array.length - n); + }; + + // Returns everything but the last entry of the array. Especially useful on + // the arguments object. Passing **n** will return all the values in + // the array, excluding the last N. + _.initial = function(array, n, guard) { + return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n))); + }; + + // Get the last element of an array. Passing **n** will return the last N + // values in the array. + _.last = function(array, n, guard) { + if (array == null) return void 0; + if (n == null || guard) return array[array.length - 1]; + return _.rest(array, Math.max(0, array.length - n)); + }; + + // Returns everything but the first entry of the array. Aliased as `tail` and `drop`. + // Especially useful on the arguments object. Passing an **n** will return + // the rest N values in the array. + _.rest = _.tail = _.drop = function(array, n, guard) { + return slice.call(array, n == null || guard ? 1 : n); + }; + + // Trim out all falsy values from an array. + _.compact = function(array) { + return _.filter(array, _.identity); + }; + + // Internal implementation of a recursive `flatten` function. + var flatten = function(input, shallow, strict, startIndex) { + var output = [], idx = 0; + for (var i = startIndex || 0, length = getLength(input); i < length; i++) { + var value = input[i]; + if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) { + //flatten current level of array or arguments object + if (!shallow) value = flatten(value, shallow, strict); + var j = 0, len = value.length; + output.length += len; + while (j < len) { + output[idx++] = value[j++]; + } + } else if (!strict) { + output[idx++] = value; + } + } + return output; + }; + + // Flatten out an array, either recursively (by default), or just one level. + _.flatten = function(array, shallow) { + return flatten(array, shallow, false); + }; + + // Return a version of the array that does not contain the specified value(s). + _.without = function(array) { + return _.difference(array, slice.call(arguments, 1)); + }; + + // Produce a duplicate-free version of the array. If the array has already + // been sorted, you have the option of using a faster algorithm. + // Aliased as `unique`. + _.uniq = _.unique = function(array, isSorted, iteratee, context) { + if (!_.isBoolean(isSorted)) { + context = iteratee; + iteratee = isSorted; + isSorted = false; + } + if (iteratee != null) iteratee = cb(iteratee, context); + var result = []; + var seen = []; + for (var i = 0, length = getLength(array); i < length; i++) { + var value = array[i], + computed = iteratee ? iteratee(value, i, array) : value; + if (isSorted) { + if (!i || seen !== computed) result.push(value); + seen = computed; + } else if (iteratee) { + if (!_.contains(seen, computed)) { + seen.push(computed); + result.push(value); + } + } else if (!_.contains(result, value)) { + result.push(value); + } + } + return result; + }; + + // Produce an array that contains the union: each distinct element from all of + // the passed-in arrays. + _.union = function() { + return _.uniq(flatten(arguments, true, true)); + }; + + // Produce an array that contains every item shared between all the + // passed-in arrays. + _.intersection = function(array) { + var result = []; + var argsLength = arguments.length; + for (var i = 0, length = getLength(array); i < length; i++) { + var item = array[i]; + if (_.contains(result, item)) continue; + for (var j = 1; j < argsLength; j++) { + if (!_.contains(arguments[j], item)) break; + } + if (j === argsLength) result.push(item); + } + return result; + }; + + // Take the difference between one array and a number of other arrays. + // Only the elements present in just the first array will remain. + _.difference = function(array) { + var rest = flatten(arguments, true, true, 1); + return _.filter(array, function(value){ + return !_.contains(rest, value); + }); + }; + + // Zip together multiple lists into a single array -- elements that share + // an index go together. + _.zip = function() { + return _.unzip(arguments); + }; + + // Complement of _.zip. Unzip accepts an array of arrays and groups + // each array's elements on shared indices + _.unzip = function(array) { + var length = array && _.max(array, getLength).length || 0; + var result = Array(length); + + for (var index = 0; index < length; index++) { + result[index] = _.pluck(array, index); + } + return result; + }; + + // Converts lists into objects. Pass either a single array of `[key, value]` + // pairs, or two parallel arrays of the same length -- one of keys, and one of + // the corresponding values. + _.object = function(list, values) { + var result = {}; + for (var i = 0, length = getLength(list); i < length; i++) { + if (values) { + result[list[i]] = values[i]; + } else { + result[list[i][0]] = list[i][1]; + } + } + return result; + }; + + // Generator function to create the findIndex and findLastIndex functions + function createPredicateIndexFinder(dir) { + return function(array, predicate, context) { + predicate = cb(predicate, context); + var length = getLength(array); + var index = dir > 0 ? 0 : length - 1; + for (; index >= 0 && index < length; index += dir) { + if (predicate(array[index], index, array)) return index; + } + return -1; + }; + } + + // Returns the first index on an array-like that passes a predicate test + _.findIndex = createPredicateIndexFinder(1); + _.findLastIndex = createPredicateIndexFinder(-1); + + // Use a comparator function to figure out the smallest index at which + // an object should be inserted so as to maintain order. Uses binary search. + _.sortedIndex = function(array, obj, iteratee, context) { + iteratee = cb(iteratee, context, 1); + var value = iteratee(obj); + var low = 0, high = getLength(array); + while (low < high) { + var mid = Math.floor((low + high) / 2); + if (iteratee(array[mid]) < value) low = mid + 1; else high = mid; + } + return low; + }; + + // Generator function to create the indexOf and lastIndexOf functions + function createIndexFinder(dir, predicateFind, sortedIndex) { + return function(array, item, idx) { + var i = 0, length = getLength(array); + if (typeof idx == 'number') { + if (dir > 0) { + i = idx >= 0 ? idx : Math.max(idx + length, i); + } else { + length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1; + } + } else if (sortedIndex && idx && length) { + idx = sortedIndex(array, item); + return array[idx] === item ? idx : -1; + } + if (item !== item) { + idx = predicateFind(slice.call(array, i, length), _.isNaN); + return idx >= 0 ? idx + i : -1; + } + for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) { + if (array[idx] === item) return idx; + } + return -1; + }; + } + + // Return the position of the first occurrence of an item in an array, + // or -1 if the item is not included in the array. + // If the array is large and already in sort order, pass `true` + // for **isSorted** to use binary search. + _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex); + _.lastIndexOf = createIndexFinder(-1, _.findLastIndex); + + // Generate an integer Array containing an arithmetic progression. A port of + // the native Python `range()` function. See + // [the Python documentation](http://docs.python.org/library/functions.html#range). + _.range = function(start, stop, step) { + if (stop == null) { + stop = start || 0; + start = 0; + } + step = step || 1; + + var length = Math.max(Math.ceil((stop - start) / step), 0); + var range = Array(length); + + for (var idx = 0; idx < length; idx++, start += step) { + range[idx] = start; + } + + return range; + }; + + // Function (ahem) Functions + // ------------------ + + // Determines whether to execute a function as a constructor + // or a normal function with the provided arguments + var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) { + if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args); + var self = baseCreate(sourceFunc.prototype); + var result = sourceFunc.apply(self, args); + if (_.isObject(result)) return result; + return self; + }; + + // Create a function bound to a given object (assigning `this`, and arguments, + // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if + // available. + _.bind = function(func, context) { + if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); + if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function'); + var args = slice.call(arguments, 2); + var bound = function() { + return executeBound(func, bound, context, this, args.concat(slice.call(arguments))); + }; + return bound; + }; + + // Partially apply a function by creating a version that has had some of its + // arguments pre-filled, without changing its dynamic `this` context. _ acts + // as a placeholder, allowing any combination of arguments to be pre-filled. + _.partial = function(func) { + var boundArgs = slice.call(arguments, 1); + var bound = function() { + var position = 0, length = boundArgs.length; + var args = Array(length); + for (var i = 0; i < length; i++) { + args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i]; + } + while (position < arguments.length) args.push(arguments[position++]); + return executeBound(func, bound, this, this, args); + }; + return bound; + }; + + // Bind a number of an object's methods to that object. Remaining arguments + // are the method names to be bound. Useful for ensuring that all callbacks + // defined on an object belong to it. + _.bindAll = function(obj) { + var i, length = arguments.length, key; + if (length <= 1) throw new Error('bindAll must be passed function names'); + for (i = 1; i < length; i++) { + key = arguments[i]; + obj[key] = _.bind(obj[key], obj); + } + return obj; + }; + + // Memoize an expensive function by storing its results. + _.memoize = function(func, hasher) { + var memoize = function(key) { + var cache = memoize.cache; + var address = '' + (hasher ? hasher.apply(this, arguments) : key); + if (!_.has(cache, address)) cache[address] = func.apply(this, arguments); + return cache[address]; + }; + memoize.cache = {}; + return memoize; + }; + + // Delays a function for the given number of milliseconds, and then calls + // it with the arguments supplied. + _.delay = function(func, wait) { + var args = slice.call(arguments, 2); + return setTimeout(function(){ + return func.apply(null, args); + }, wait); + }; + + // Defers a function, scheduling it to run after the current call stack has + // cleared. + _.defer = _.partial(_.delay, _, 1); + + // Returns a function, that, when invoked, will only be triggered at most once + // during a given window of time. Normally, the throttled function will run + // as much as it can, without ever going more than once per `wait` duration; + // but if you'd like to disable the execution on the leading edge, pass + // `{leading: false}`. To disable execution on the trailing edge, ditto. + _.throttle = function(func, wait, options) { + var context, args, result; + var timeout = null; + var previous = 0; + if (!options) options = {}; + var later = function() { + previous = options.leading === false ? 0 : _.now(); + timeout = null; + result = func.apply(context, args); + if (!timeout) context = args = null; + }; + return function() { + var now = _.now(); + if (!previous && options.leading === false) previous = now; + var remaining = wait - (now - previous); + context = this; + args = arguments; + if (remaining <= 0 || remaining > wait) { + if (timeout) { + clearTimeout(timeout); + timeout = null; + } + previous = now; + result = func.apply(context, args); + if (!timeout) context = args = null; + } else if (!timeout && options.trailing !== false) { + timeout = setTimeout(later, remaining); + } + return result; + }; + }; + + // Returns a function, that, as long as it continues to be invoked, will not + // be triggered. The function will be called after it stops being called for + // N milliseconds. If `immediate` is passed, trigger the function on the + // leading edge, instead of the trailing. + _.debounce = function(func, wait, immediate) { + var timeout, args, context, timestamp, result; + + var later = function() { + var last = _.now() - timestamp; + + if (last < wait && last >= 0) { + timeout = setTimeout(later, wait - last); + } else { + timeout = null; + if (!immediate) { + result = func.apply(context, args); + if (!timeout) context = args = null; + } + } + }; + + return function() { + context = this; + args = arguments; + timestamp = _.now(); + var callNow = immediate && !timeout; + if (!timeout) timeout = setTimeout(later, wait); + if (callNow) { + result = func.apply(context, args); + context = args = null; + } + + return result; + }; + }; + + // Returns the first function passed as an argument to the second, + // allowing you to adjust arguments, run code before and after, and + // conditionally execute the original function. + _.wrap = function(func, wrapper) { + return _.partial(wrapper, func); + }; + + // Returns a negated version of the passed-in predicate. + _.negate = function(predicate) { + return function() { + return !predicate.apply(this, arguments); + }; + }; + + // Returns a function that is the composition of a list of functions, each + // consuming the return value of the function that follows. + _.compose = function() { + var args = arguments; + var start = args.length - 1; + return function() { + var i = start; + var result = args[start].apply(this, arguments); + while (i--) result = args[i].call(this, result); + return result; + }; + }; + + // Returns a function that will only be executed on and after the Nth call. + _.after = function(times, func) { + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; + }; + + // Returns a function that will only be executed up to (but not including) the Nth call. + _.before = function(times, func) { + var memo; + return function() { + if (--times > 0) { + memo = func.apply(this, arguments); + } + if (times <= 1) func = null; + return memo; + }; + }; + + // Returns a function that will be executed at most one time, no matter how + // often you call it. Useful for lazy initialization. + _.once = _.partial(_.before, 2); + + // Object Functions + // ---------------- + + // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed. + var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString'); + var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', + 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; + + function collectNonEnumProps(obj, keys) { + var nonEnumIdx = nonEnumerableProps.length; + var constructor = obj.constructor; + var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto; + + // Constructor is a special case. + var prop = 'constructor'; + if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop); + + while (nonEnumIdx--) { + prop = nonEnumerableProps[nonEnumIdx]; + if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) { + keys.push(prop); + } + } + } + + // Retrieve the names of an object's own properties. + // Delegates to **ECMAScript 5**'s native `Object.keys` + _.keys = function(obj) { + if (!_.isObject(obj)) return []; + if (nativeKeys) return nativeKeys(obj); + var keys = []; + for (var key in obj) if (_.has(obj, key)) keys.push(key); + // Ahem, IE < 9. + if (hasEnumBug) collectNonEnumProps(obj, keys); + return keys; + }; + + // Retrieve all the property names of an object. + _.allKeys = function(obj) { + if (!_.isObject(obj)) return []; + var keys = []; + for (var key in obj) keys.push(key); + // Ahem, IE < 9. + if (hasEnumBug) collectNonEnumProps(obj, keys); + return keys; + }; + + // Retrieve the values of an object's properties. + _.values = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var values = Array(length); + for (var i = 0; i < length; i++) { + values[i] = obj[keys[i]]; + } + return values; + }; + + // Returns the results of applying the iteratee to each element of the object + // In contrast to _.map it returns an object + _.mapObject = function(obj, iteratee, context) { + iteratee = cb(iteratee, context); + var keys = _.keys(obj), + length = keys.length, + results = {}, + currentKey; + for (var index = 0; index < length; index++) { + currentKey = keys[index]; + results[currentKey] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + }; + + // Convert an object into a list of `[key, value]` pairs. + _.pairs = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var pairs = Array(length); + for (var i = 0; i < length; i++) { + pairs[i] = [keys[i], obj[keys[i]]]; + } + return pairs; + }; + + // Invert the keys and values of an object. The values must be serializable. + _.invert = function(obj) { + var result = {}; + var keys = _.keys(obj); + for (var i = 0, length = keys.length; i < length; i++) { + result[obj[keys[i]]] = keys[i]; + } + return result; + }; + + // Return a sorted list of the function names available on the object. + // Aliased as `methods` + _.functions = _.methods = function(obj) { + var names = []; + for (var key in obj) { + if (_.isFunction(obj[key])) names.push(key); + } + return names.sort(); + }; + + // Extend a given object with all the properties in passed-in object(s). + _.extend = createAssigner(_.allKeys); + + // Assigns a given object with all the own properties in the passed-in object(s) + // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) + _.extendOwn = _.assign = createAssigner(_.keys); + + // Returns the first key on an object that passes a predicate test + _.findKey = function(obj, predicate, context) { + predicate = cb(predicate, context); + var keys = _.keys(obj), key; + for (var i = 0, length = keys.length; i < length; i++) { + key = keys[i]; + if (predicate(obj[key], key, obj)) return key; + } + }; + + // Return a copy of the object only containing the whitelisted properties. + _.pick = function(object, oiteratee, context) { + var result = {}, obj = object, iteratee, keys; + if (obj == null) return result; + if (_.isFunction(oiteratee)) { + keys = _.allKeys(obj); + iteratee = optimizeCb(oiteratee, context); + } else { + keys = flatten(arguments, false, false, 1); + iteratee = function(value, key, obj) { return key in obj; }; + obj = Object(obj); + } + for (var i = 0, length = keys.length; i < length; i++) { + var key = keys[i]; + var value = obj[key]; + if (iteratee(value, key, obj)) result[key] = value; + } + return result; + }; + + // Return a copy of the object without the blacklisted properties. + _.omit = function(obj, iteratee, context) { + if (_.isFunction(iteratee)) { + iteratee = _.negate(iteratee); + } else { + var keys = _.map(flatten(arguments, false, false, 1), String); + iteratee = function(value, key) { + return !_.contains(keys, key); + }; + } + return _.pick(obj, iteratee, context); + }; + + // Fill in a given object with default properties. + _.defaults = createAssigner(_.allKeys, true); + + // Creates an object that inherits from the given prototype object. + // If additional properties are provided then they will be added to the + // created object. + _.create = function(prototype, props) { + var result = baseCreate(prototype); + if (props) _.extendOwn(result, props); + return result; + }; + + // Create a (shallow-cloned) duplicate of an object. + _.clone = function(obj) { + if (!_.isObject(obj)) return obj; + return _.isArray(obj) ? obj.slice() : _.extend({}, obj); + }; + + // Invokes interceptor with the obj, and then returns obj. + // The primary purpose of this method is to "tap into" a method chain, in + // order to perform operations on intermediate results within the chain. + _.tap = function(obj, interceptor) { + interceptor(obj); + return obj; + }; + + // Returns whether an object has a given set of `key:value` pairs. + _.isMatch = function(object, attrs) { + var keys = _.keys(attrs), length = keys.length; + if (object == null) return !length; + var obj = Object(object); + for (var i = 0; i < length; i++) { + var key = keys[i]; + if (attrs[key] !== obj[key] || !(key in obj)) return false; + } + return true; + }; + + + // Internal recursive comparison function for `isEqual`. + var eq = function(a, b, aStack, bStack) { + // Identical objects are equal. `0 === -0`, but they aren't identical. + // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal). + if (a === b) return a !== 0 || 1 / a === 1 / b; + // A strict comparison is necessary because `null == undefined`. + if (a == null || b == null) return a === b; + // Unwrap any wrapped objects. + if (a instanceof _) a = a._wrapped; + if (b instanceof _) b = b._wrapped; + // Compare `[[Class]]` names. + var className = toString.call(a); + if (className !== toString.call(b)) return false; + switch (className) { + // Strings, numbers, regular expressions, dates, and booleans are compared by value. + case '[object RegExp]': + // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i') + case '[object String]': + // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is + // equivalent to `new String("5")`. + return '' + a === '' + b; + case '[object Number]': + // `NaN`s are equivalent, but non-reflexive. + // Object(NaN) is equivalent to NaN + if (+a !== +a) return +b !== +b; + // An `egal` comparison is performed for other numeric values. + return +a === 0 ? 1 / +a === 1 / b : +a === +b; + case '[object Date]': + case '[object Boolean]': + // Coerce dates and booleans to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a === +b; + } + + var areArrays = className === '[object Array]'; + if (!areArrays) { + if (typeof a != 'object' || typeof b != 'object') return false; + + // Objects with different constructors are not equivalent, but `Object`s or `Array`s + // from different frames are. + var aCtor = a.constructor, bCtor = b.constructor; + if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor && + _.isFunction(bCtor) && bCtor instanceof bCtor) + && ('constructor' in a && 'constructor' in b)) { + return false; + } + } + // Assume equality for cyclic structures. The algorithm for detecting cyclic + // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. + + // Initializing stack of traversed objects. + // It's done here since we only need them for objects and arrays comparison. + aStack = aStack || []; + bStack = bStack || []; + var length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + if (aStack[length] === a) return bStack[length] === b; + } + + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + + // Recursively compare objects and arrays. + if (areArrays) { + // Compare array lengths to determine if a deep comparison is necessary. + length = a.length; + if (length !== b.length) return false; + // Deep compare the contents, ignoring non-numeric properties. + while (length--) { + if (!eq(a[length], b[length], aStack, bStack)) return false; + } + } else { + // Deep compare objects. + var keys = _.keys(a), key; + length = keys.length; + // Ensure that both objects contain the same number of properties before comparing deep equality. + if (_.keys(b).length !== length) return false; + while (length--) { + // Deep compare each member + key = keys[length]; + if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false; + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return true; + }; + + // Perform a deep comparison to check if two objects are equal. + _.isEqual = function(a, b) { + return eq(a, b); + }; + + // Is a given array, string, or object empty? + // An "empty" object has no enumerable own-properties. + _.isEmpty = function(obj) { + if (obj == null) return true; + if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0; + return _.keys(obj).length === 0; + }; + + // Is a given value a DOM element? + _.isElement = function(obj) { + return !!(obj && obj.nodeType === 1); + }; + + // Is a given value an array? + // Delegates to ECMA5's native Array.isArray + _.isArray = nativeIsArray || function(obj) { + return toString.call(obj) === '[object Array]'; + }; + + // Is a given variable an object? + _.isObject = function(obj) { + var type = typeof obj; + return type === 'function' || type === 'object' && !!obj; + }; + + // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError. + _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) { + _['is' + name] = function(obj) { + return toString.call(obj) === '[object ' + name + ']'; + }; + }); + + // Define a fallback version of the method in browsers (ahem, IE < 9), where + // there isn't any inspectable "Arguments" type. + if (!_.isArguments(arguments)) { + _.isArguments = function(obj) { + return _.has(obj, 'callee'); + }; + } + + // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8, + // IE 11 (#1621), and in Safari 8 (#1929). + if (typeof /./ != 'function' && typeof Int8Array != 'object') { + _.isFunction = function(obj) { + return typeof obj == 'function' || false; + }; + } + + // Is a given object a finite number? + _.isFinite = function(obj) { + return isFinite(obj) && !isNaN(parseFloat(obj)); + }; + + // Is the given value `NaN`? (NaN is the only number which does not equal itself). + _.isNaN = function(obj) { + return _.isNumber(obj) && obj !== +obj; + }; + + // Is a given value a boolean? + _.isBoolean = function(obj) { + return obj === true || obj === false || toString.call(obj) === '[object Boolean]'; + }; + + // Is a given value equal to null? + _.isNull = function(obj) { + return obj === null; + }; + + // Is a given variable undefined? + _.isUndefined = function(obj) { + return obj === void 0; + }; + + // Shortcut function for checking if an object has a given property directly + // on itself (in other words, not on a prototype). + _.has = function(obj, key) { + return obj != null && hasOwnProperty.call(obj, key); + }; + + // Utility Functions + // ----------------- + + // Run Underscore.js in *noConflict* mode, returning the `_` variable to its + // previous owner. Returns a reference to the Underscore object. + _.noConflict = function() { + root._ = previousUnderscore; + return this; + }; + + // Keep the identity function around for default iteratees. + _.identity = function(value) { + return value; + }; + + // Predicate-generating functions. Often useful outside of Underscore. + _.constant = function(value) { + return function() { + return value; + }; + }; + + _.noop = function(){}; + + _.property = property; + + // Generates a function for a given object that returns a given property. + _.propertyOf = function(obj) { + return obj == null ? function(){} : function(key) { + return obj[key]; + }; + }; + + // Returns a predicate for checking whether an object has a given set of + // `key:value` pairs. + _.matcher = _.matches = function(attrs) { + attrs = _.extendOwn({}, attrs); + return function(obj) { + return _.isMatch(obj, attrs); + }; + }; + + // Run a function **n** times. + _.times = function(n, iteratee, context) { + var accum = Array(Math.max(0, n)); + iteratee = optimizeCb(iteratee, context, 1); + for (var i = 0; i < n; i++) accum[i] = iteratee(i); + return accum; + }; + + // Return a random integer between min and max (inclusive). + _.random = function(min, max) { + if (max == null) { + max = min; + min = 0; + } + return min + Math.floor(Math.random() * (max - min + 1)); + }; + + // A (possibly faster) way to get the current timestamp as an integer. + _.now = Date.now || function() { + return new Date().getTime(); + }; + + // List of HTML entities for escaping. + var escapeMap = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`' + }; + var unescapeMap = _.invert(escapeMap); + + // Functions for escaping and unescaping strings to/from HTML interpolation. + var createEscaper = function(map) { + var escaper = function(match) { + return map[match]; + }; + // Regexes for identifying a key that needs to be escaped + var source = '(?:' + _.keys(map).join('|') + ')'; + var testRegexp = RegExp(source); + var replaceRegexp = RegExp(source, 'g'); + return function(string) { + string = string == null ? '' : '' + string; + return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string; + }; + }; + _.escape = createEscaper(escapeMap); + _.unescape = createEscaper(unescapeMap); + + // If the value of the named `property` is a function then invoke it with the + // `object` as context; otherwise, return it. + _.result = function(object, property, fallback) { + var value = object == null ? void 0 : object[property]; + if (value === void 0) { + value = fallback; + } + return _.isFunction(value) ? value.call(object) : value; + }; + + // Generate a unique integer id (unique within the entire client session). + // Useful for temporary DOM ids. + var idCounter = 0; + _.uniqueId = function(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; + }; + + // By default, Underscore uses ERB-style template delimiters, change the + // following template settings to use alternative delimiters. + _.templateSettings = { + evaluate : /<%([\s\S]+?)%>/g, + interpolate : /<%=([\s\S]+?)%>/g, + escape : /<%-([\s\S]+?)%>/g + }; + + // When customizing `templateSettings`, if you don't want to define an + // interpolation, evaluation or escaping regex, we need one that is + // guaranteed not to match. + var noMatch = /(.)^/; + + // Certain characters need to be escaped so that they can be put into a + // string literal. + var escapes = { + "'": "'", + '\\': '\\', + '\r': 'r', + '\n': 'n', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + var escaper = /\\|'|\r|\n|\u2028|\u2029/g; + + var escapeChar = function(match) { + return '\\' + escapes[match]; + }; + + // JavaScript micro-templating, similar to John Resig's implementation. + // Underscore templating handles arbitrary delimiters, preserves whitespace, + // and correctly escapes quotes within interpolated code. + // NB: `oldSettings` only exists for backwards compatibility. + _.template = function(text, settings, oldSettings) { + if (!settings && oldSettings) settings = oldSettings; + settings = _.defaults({}, settings, _.templateSettings); + + // Combine delimiters into one regular expression via alternation. + var matcher = RegExp([ + (settings.escape || noMatch).source, + (settings.interpolate || noMatch).source, + (settings.evaluate || noMatch).source + ].join('|') + '|$', 'g'); + + // Compile the template source, escaping string literals appropriately. + var index = 0; + var source = "__p+='"; + text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { + source += text.slice(index, offset).replace(escaper, escapeChar); + index = offset + match.length; + + if (escape) { + source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; + } else if (interpolate) { + source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; + } else if (evaluate) { + source += "';\n" + evaluate + "\n__p+='"; + } + + // Adobe VMs need the match returned to produce the correct offest. + return match; + }); + source += "';\n"; + + // If a variable is not specified, place data values in local scope. + if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n'; + + source = "var __t,__p='',__j=Array.prototype.join," + + "print=function(){__p+=__j.call(arguments,'');};\n" + + source + 'return __p;\n'; + + try { + var render = new Function(settings.variable || 'obj', '_', source); + } catch (e) { + e.source = source; + throw e; + } + + var template = function(data) { + return render.call(this, data, _); + }; + + // Provide the compiled source as a convenience for precompilation. + var argument = settings.variable || 'obj'; + template.source = 'function(' + argument + '){\n' + source + '}'; + + return template; + }; + + // Add a "chain" function. Start chaining a wrapped Underscore object. + _.chain = function(obj) { + var instance = _(obj); + instance._chain = true; + return instance; + }; + + // OOP + // --------------- + // If Underscore is called as a function, it returns a wrapped object that + // can be used OO-style. This wrapper holds altered versions of all the + // underscore functions. Wrapped objects may be chained. + + // Helper function to continue chaining intermediate results. + var result = function(instance, obj) { + return instance._chain ? _(obj).chain() : obj; + }; + + // Add your own custom functions to the Underscore object. + _.mixin = function(obj) { + _.each(_.functions(obj), function(name) { + var func = _[name] = obj[name]; + _.prototype[name] = function() { + var args = [this._wrapped]; + push.apply(args, arguments); + return result(this, func.apply(_, args)); + }; + }); + }; + + // Add all of the Underscore functions to the wrapper object. + _.mixin(_); + + // Add all mutator Array functions to the wrapper. + _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + var obj = this._wrapped; + method.apply(obj, arguments); + if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0]; + return result(this, obj); + }; + }); + + // Add all accessor Array functions to the wrapper. + _.each(['concat', 'join', 'slice'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + return result(this, method.apply(this._wrapped, arguments)); + }; + }); + + // Extracts the result from a wrapped and chained object. + _.prototype.value = function() { + return this._wrapped; + }; + + // Provide unwrapping proxy for some methods used in engine operations + // such as arithmetic and JSON stringification. + _.prototype.valueOf = _.prototype.toJSON = _.prototype.value; + + _.prototype.toString = function() { + return '' + this._wrapped; + }; + + // AMD registration happens at the end for compatibility with AMD loaders + // that may not enforce next-turn semantics on modules. Even though general + // practice for AMD registration is to be anonymous, underscore registers + // as a named module because, like jQuery, it is a base library that is + // popular enough to be bundled in a third party lib, but not be part of + // an AMD load request. Those cases could generate an error when an + // anonymous define() is called outside of a loader request. + if (typeof define === 'function' && define.amd) { + define('underscore', [], function() { + return _; + }); + } +}.call(this)); + +},{}],5:[function(require,module,exports){ +"use strict"; + +var DeckData = require("../assets/data/deck"); +var Deck = require("./Deck"); +var Hand = require("./Hand"); +var Card = require("./Card"); +var Field = require("./Field"); +var _ = require("underscore"); + +var Battleside; +Battleside = (function () { + var Battleside = function Battleside(name, n, battle, user) { + if (!(this instanceof Battleside)) { + return new Battleside(name, n, battle, user); + } + /** + * constructor here + */ + + var deck = user.getDeck(); + var self = this; + this._isWaiting = true; + this.socket = user.socket; + this.field = {}; + this.field[Card.TYPE.LEADER] = Field(Card.TYPE.LEADER); + this.field[Card.TYPE.CLOSE_COMBAT] = Field(Card.TYPE.CLOSE_COMBAT); + this.field[Card.TYPE.RANGED] = Field(Card.TYPE.RANGED); + this.field[Card.TYPE.SIEGE] = Field(Card.TYPE.SIEGE); + this.n = n ? "p2" : "p1"; + this._name = name; + this.battle = battle; + this.hand = Hand(); + this.deck = Deck(DeckData[deck]); + this._discard = []; + + this.runEvent = this.battle.runEvent.bind(this.battle); + this.on = this.battle.on.bind(this.battle); + this.off = this.battle.off.bind(this.battle); + + this.receive("activate:leader", function () { + if (self._isWaiting) return; + if (self.isPassing()) return; + + console.log("leader activated"); + + var leaderCard = self.getLeader(); + if (leaderCard.isDisabled()) return; + + var ability = leaderCard.getAbility(); + + ability.onActivate.apply(self); + leaderCard.setDisabled(true); + self.update(); + }); + this.receive("play:cardFromHand", function (data) { + if (self._isWaiting) return; + if (self.isPassing()) return; + var cardID = data.id; + var card = self.hand.getCard(cardID); + + self.playCard(card); + }); + this.receive("decoy:replaceWith", function (data) { + if (self._isWaiting) return; + var card = self.findCardOnFieldByID(data.cardID); + if (card === -1) throw new Error("decoy:replace | unknown card"); + self.runEvent("Decoy:replaceWith", self, [card]); + }); + this.receive("cancel:decoy", function () { + self.off("Decoy:replaceWith"); + }); + this.receive("set:passing", function () { + self.setPassing(true); + self.update(); + self.runEvent("NextTurn", null, [self.foe]); + }); + this.receive("medic:chooseCardFromDiscard", function (data) { + if (!data) { + self.runEvent("NextTurn", null, [self.foe]); + return; + } + var cardID = data.cardID; + var card = self.getCardFromDiscard(cardID); + if (card === -1) throw new Error("medic:chooseCardFromDiscard | unknown card: ", card); + + self.removeFromDiscard(card); + + self.playCard(card); + }); + + this.on("Turn" + this.getID(), this.onTurnStart, this); + }; + var r = Battleside.prototype; + /** + * methods && properties here + * r.property = null; + * r.getProperty = function() {...} + */ + r._name = null; + r._discard = null; + + r._rubies = 2; + r._score = 0; + r._isWaiting = null; + r._passing = null; + + r.field = null; + + r.socket = null; + r.n = null; + + r.foe = null; + r.hand = null; + r.battle = null; + r.deck = null; + + r.isPassing = function () { + return this._passing; + }; + + r.setUpWeatherFieldWith = function (p2) { + this.field[Card.TYPE.WEATHER] = p2.field[Card.TYPE.WEATHER] = Field(Card.TYPE.WEATHER); + }; + + r.findCardOnFieldByID = function (id) { + for (var key in this.field) { + var field = this.field[key]; + var card = field.getCard(id); + if (card !== -1) return card; + } + /* + for(var i = 0; i < this._discard.length; i++) { + var c = this._discard[i]; + if(c.getID() === id) return c; + }*/ + return -1; + }; + + r.getCardFromDiscard = function (id) { + for (var i = 0; i < this._discard.length; i++) { + var c = this._discard[i]; + if (c.getID() === id) return c; + } + return -1; + }; + + r.setPassing = function (b) { + this._passing = b; + this.send("set:passing", { passing: this._passing }, true); + }; + + r.wait = function () { + this._isWaiting = true; + this.send("set:waiting", { waiting: this._isWaiting }, true); + }; + + r.turn = function () { + this._isWaiting = false; + this.send("set:waiting", { waiting: this._isWaiting }, true); + }; + + r.setLeadercard = function () { + var leaderCard = this.deck.find("type", Card.TYPE.LEADER); + this.deck.removeFromDeck(leaderCard[0]); + /* + this.getYourside().setField("leader", leaderCard[0]);*/ + this.field[Card.TYPE.LEADER].add(leaderCard[0]); + }; + + r.getLeader = function () { + return this.field[Card.TYPE.LEADER].get()[0]; + }; + + r.getID = function () { + return this.n; + }; + + r.draw = function (times) { + while (times--) { + var card = this.deck.draw(); + this.hand.add(card); + } + + console.log("update:hand fired"); + + this.update(); + }; + + r.calcScore = function () { + var score = 0; + for (var key in this.field) { + score += +this.field[key].getScore(); + } + return this._score = score; + }; + + r.getInfo = function () { + return { + name: this.getName(), + lives: this._rubies, + score: this.calcScore(), + hand: this.hand.length(), + discard: this.getDiscard(true), + passing: this._passing + }; + }; + + r.getRubies = function () { + return this._rubies; + }; + + r.getScore = function () { + return +this.calcScore(); + }; + + r.removeRuby = function () { + this._rubies--; + }; + + r.getName = function () { + return this._name; + }; + + r.send = function (event, msg, isPrivate) { + msg = msg || {}; + isPrivate = typeof isPrivate === "undefined" ? false : isPrivate; + msg._roomSide = this.n; + + if (isPrivate) { + return this.socket.emit(event, msg); + } + this.battle.send(event, msg); + }; + + r.receive = function (event, cb) { + this.socket.on(event, cb); + }; + + r.update = function () { + //PubSub.publish("update"); + this.runEvent("Update"); + }; + + r.onTurnStart = function () { + this.foe.wait(); + this.turn(); + + //wait for cardplay event + }; + + r.playCard = function (card) { + if (card === null || card === -1) return; + + if (!this.placeCard(card)) return; + + this.hand.remove(card); + + this.update(); + + this.runEvent("NextTurn", null, [this.foe]); + }; + + r.placeCard = function (card, obj) { + obj = _.extend({}, obj); + + this.checkAbilities(card, obj); + if (obj._canclePlacement) return 0; + + var field = obj.targetSide.field[card.getType()]; + field.add(card); + + this.runEvent("EachCardPlace"); + + this.checkAbilityOnAfterPlace(card, obj); + /* + this.runEvent("AfterPlace", this, [card, obj]);*/ + + this.update(); + + if (obj._waitResponse) { + this.hand.remove(card); + this.update(); + return 0; + } + + return 1; + }; + + r.checkAbilities = function (card, obj, __flag) { + var self = this; + obj.targetSide = this; + var ability = Array.isArray(__flag) || card.getAbility(); + + if (Array.isArray(ability) && ability.length) { + var ret = ability.slice(); + ret = ret.splice(0, 1); + this.checkAbilities(card, obj, ret); + ability = ability[0]; + } + + if (ability && ability.name === obj.suppress) { + this.update(); + } + + if (ability && !Array.isArray(ability)) { + if (ability.waitResponse) { + obj._waitResponse = true; + } + if (ability.changeSide) { + obj.targetSide = this.foe; + } + if (ability.replaceWith) { + obj._canclePlacement = true; + + this.on("Decoy:replaceWith", function (replaceCard) { + if (replaceCard.getType() == Card.TYPE.LEADER || replaceCard.getType() == Card.TYPE.WEATHER || replaceCard.getType() == Card.TYPE.SPECIAL) { + return; + } + if (replaceCard.getName() === card.getName()) return; + self.off("Decoy:replaceWith"); + var field = self.field[replaceCard.getType()]; + + field.replaceWith(replaceCard, card); + + self.hand.add(replaceCard); + self.hand.remove(card); + self.update(); + + self.runEvent("NextTurn", null, [self.foe]); + }); + } + if (ability.onEachTurn) { + this.on("EachTurn", ability.onEachTurn, this, [card]); + } + if (ability.onEachCardPlace) { + //PubSub.subscribe("onEachCardPlace", ability.onEachCardPlace.bind(this, card)); + this.on("EachCardPlace", ability.onEachCardPlace, this, [card]); + } + + this.update(); + } + }; + + r.checkAbilityOnAfterPlace = function (card, obj) { + var ability = card.getAbility(); + if (ability) { + if (ability.name && ability.name === obj.suppress) { + this.update(); + return; + } + if (ability.onAfterPlace) { + ability.onAfterPlace.call(this, card); + } + } + }; + + r.clearMainFields = function () { + var cards1 = this.field[Card.TYPE.CLOSE_COMBAT].removeAll(); + var cards2 = this.field[Card.TYPE.RANGED].removeAll(); + var cards3 = this.field[Card.TYPE.SIEGE].removeAll(); + + var cards = cards1.concat(cards2.concat(cards3)); + this.addToDiscard(cards); + }; + + r.addToDiscard = function (cards) { + var self = this; + cards.forEach(function (card) { + self._discard.push(card); + }); + }; + + r.removeFromDiscard = function (card) { + for (var i = 0; i < this._discard.length; i++) { + var c = this._discard[i]; + if (c.getID() === card.getID()) { + + this._discard.splice(i, 1); + return; + } + } + }; + + r.getDiscard = function (json) { + if (json) { + return JSON.stringify(this._discard); + } + return this._discard; + }; + + r.resetNewRound = function () { + this.clearMainFields(); + this.setPassing(false); + }; + + r.filter = function (arrCards, opt) { + var arr = arrCards.slice(); + + for (var key in opt) { + var res = []; + var prop = key, + val = opt[key]; + + arrCards.forEach(function (card) { + var property = card.getProperty(prop); + if (_.isArray(property)) { + var _f = false; + for (var i = 0; i < property.length; i++) { + if (property[i] === val) { + _f = true; + break; + } + } + if (!_f) { + res.push(card); + } + } else if (card.getProperty(prop) !== val) { + res.push(card); + } + }); + arr = _.intersection(arr, res); + } + + return arr; + }; + + return Battleside; +})(); + +module.exports = Battleside; + +},{"../assets/data/deck":3,"./Card":6,"./Deck":7,"./Field":8,"./Hand":9,"underscore":4}],6:[function(require,module,exports){ +"use strict"; + +var CardData = require("../assets/data/cards"); +var AbilityData = require("../assets/data/abilities"); + +var Card = (function () { + var Card = function Card(key) { + if (!(this instanceof Card)) { + return new Card(key); + } + /** + * constructor here + */ + this.setDisabled(false); + this.channel = {}; + this._key = key; + this._data = CardData[key]; + this._data.key = key; + this._boost = 0; + this._forcedPower = -1; + this._init(); + }; + var r = Card.prototype; + /** + * methods && properties here + * r.property = null; + * r.getProperty = function() {...} + */ + r._key = null; + r._data = null; + r._id = null; + r._owner = null; + r._boost = null; + r._forcedPower = null; + r._disabled = null; + Card.__id = 0; + Card.TYPE = { + CLOSE_COMBAT: 0, + RANGED: 1, + SIEGE: 2, + LEADER: 3, + SPECIAL: 4, + WEATHER: 5 + }; + + r.channel = null; + + r._init = function () { + this._id = ++Card.__id; + }; + + r.getName = function () { + return this._data.name; + }; + r.getPower = function () { + if (this._data.power === -1) return 0; + if (this._forcedPower > -1) { + return this._forcedPower + this._boost; + } + return this._data.power + this._boost; + }; + r.getRawPower = function () { + return this._data.power; + }; + r.calculateBoost = function () { + this._boost = 0; + for (var key in this._boosts) { + var boost = this._boosts[key]; + this.boost(boost.getPower()); + } + }; + r.setForcedPower = function (nr) { + this._forcedPower = nr; + }; + r.getRawAbility = function () { + return this._data.ability; + }; + r.getAbility = function () { + if (Array.isArray(this._data.ability)) { + var res = []; + this._data.ability.forEach(function (ability) { + res.push(AbilityData[ability]); + }); + return res; + } + return AbilityData[this._data.ability]; + }; + r.getImage = function () { + return "../assets/cards/" + this._data.img + ".png"; + }; + r.getFaction = function () { + return this._data.faction; + }; + r.getMusterType = function () { + return this._data.musterType || null; + }; + r.getType = function () { + return this._data.type; + }; + r.getKey = function () { + return this._key; + }; + + r.getID = function () { + return this._id; + }; + + r.boost = function (nr) { + /*this.getPower(); //to recalculate this._power;*/ + this._boost += nr; + }; + + r.isDisabled = function () { + return this._disabled; + }; + + r.setDisabled = function (b) { + this._disabled = b; + }; + + r.getProperty = function (prop) { + if (!this._data[prop]) return {}; + return this._data[prop]; + }; + + r.resetBoost = function () { + this._boost = 0; + }; + + return Card; +})(); + +module.exports = Card; + +},{"../assets/data/abilities":1,"../assets/data/cards":2}],7:[function(require,module,exports){ +"use strict"; + +var Card = require("./Card"); +/*var CardManager = require("./CardManager");*/ + +var Deck = (function () { + var Deck = function Deck(deck) { + if (!(this instanceof Deck)) { + return new Deck(deck); + } + /** + * constructor here + */ + this._deck = []; + + this._originalDeck = []; + this.setDeck(deck); + }; + var r = Deck.prototype; + /** + * methods && properties here + * r.property = null; + * r.getProperty = function() {...} + */ + r._deck = null; + r._owner = null; + r._originalDeck = null; + + r.setDeck = function (deckData) { + this._originalDeck = deckData.slice(); + this._deck = deckData.slice(); + + this._loadCards(); + this.shuffle(); + }; + + r.getLength = function () { + return this._deck.length; + }; + + r.length = function () { + return this.getLength(); + }; + + r.getDeck = function () { + return this._deck; + }; + + r.draw = function () { + if (!this._deck.length) return 0; + var card = this.pop(); + return card; + }; + + r._loadCards = function () { + this._deck = this.getDeck().map(function (cardkey) { + return Card(cardkey); + }); + }; + + r.pop = function () { + var id = this._deck.pop(); + /* + var card = CardManager().getCardById(id);*/ + return id; + }; + + r.find = function (key, val) { + var res = []; + this.getDeck().forEach(function (card) { + if (card.getProperty(key) == val) { + res.push(card); + } + }); + return res; + }; + + r.removeFromDeck = function (card) { + var n = this.length(); + + for (var i = 0; i < n; i++) { + var c = this.getDeck()[i]; + if (c.getID() === card.getID()) { + return this.getDeck().splice(i, 1)[0]; + } + } + return -1; + }; + + r.shuffle = function () { + var deck = this.getDeck(); + + var n = this.length(); + for (var i = n - 1; i > 0; i--) { + var j = Math.random() * i | 0; + var tmp; + + tmp = deck[j]; + deck[j] = deck[i]; + deck[i] = tmp; + } + }; + + return Deck; +})(); + +module.exports = Deck; + +},{"./Card":6}],8:[function(require,module,exports){ +"use strict"; + +var Field = (function () { + var Field = function Field() { + if (!(this instanceof Field)) { + return new Field(); + } + /** + * constructor here + */ + + this._cards = []; + }; + var r = Field.prototype; + /** + * methods && properties here + * r.property = null; + * r.getProperty = function() {...} + */ + + r._cards = null; + r._score = 0; + + r.add = function (card) { + this._cards.push(card); + this.updateScore(); + }; + + r.get = function () { + return this._cards; + }; + + r.getScore = function () { + this.updateScore(); + return this._score; + }; + + r.updateScore = function () { + this._score = 0; + for (var i = 0; i < this._cards.length; i++) { + var card = this._cards[i]; + this._score += card.getPower(); + } + }; + + r.getPosition = function (card) { + for (var i = 0; i < this._cards.length; i++) { + if (this._cards[i].getID() === card.getID()) return i; + } + return -1; + }; + + r.replaceWith = function (oldCard, newCard) { + var index = this.getPosition(oldCard); + this._cards[index] = newCard; + oldCard.resetBoost(); + return oldCard; + }; + + r.getCard = function (id) { + for (var i = 0; i < this._cards.length; i++) { + var card = this._cards[i]; + if (card.getID() == id) return card; + } + return -1; + }; + + r.removeAll = function () { + var tmp = this._cards.slice(); + tmp.forEach(function (card) { + card.resetBoost(); + }); + this._cards = []; + return tmp; + }; + + return Field; +})(); + +module.exports = Field; + +},{}],9:[function(require,module,exports){ +/*var $ = require("jquery");*/ /* + var CardManager = require("./CardManager");*/ /* + var PubSub = require("./pubsub");*/ +"use strict"; + +var Card = require("./Card"); + +var Hand = (function () { + var Hand = function Hand() { + if (!(this instanceof Hand)) { + return new Hand(); + } + /** + * constructor here + */ + + this._hand = []; + }; + var r = Hand.prototype; + /** + * methods && properties here + * r.property = null; + * r.getProperty = function() {...} + */ + r._hand = null; + + r.add = function (card) { + this._hand.push(card); + }; + + r.getCards = function () { + return this._hand; + }; + + r.getCard = function (id) { + for (var i = 0; i < this.length(); i++) { + var card = this.getCards()[i]; + if (card.getID() === id) return card; + } + return -1; + }; + + r.remove = function (id) { + var n = this.length(); + + //console.trace(id); + id = id instanceof Card ? id.getID() : id; + + for (var i = 0; i < n; i++) { + if (this._hand[i].getID() != id) continue; + return this._hand.splice(i, 1); + } + + return -1; + }; + + r.getRandomCard = function () { + var rnd = Math.random() * this._hand.length | 0; + return this._hand[rnd]; + }; + + r.getLength = function () { + return this._hand.length; + }; + + r.length = function () { + return this._hand.length; + }; + + r.find = function (key, val) { + var res = []; + this._hand.forEach(function (card) { + if (card.getProperty(key) == val) { + res.push(card); + } + }); + return res; + }; + + return Hand; +})(); + +module.exports = Hand; + +},{"./Card":6}],10:[function(require,module,exports){ +"use strict"; + +var Card = require("../../server/Card"); +var Battleside = require("../../server/Battleside"); +var data = require("../../assets/data/abilities"); + +describe("filter", function () { + var card, side, filter, cards; + beforeEach(function () { + filter = Battleside.prototype.filter; + cards = []; + cards.push(Card("iorveth")); + cards.push(Card("toruviel")); + cards.push(Card("isengrim_faoiltiarnah")); + cards.push(Card("decoy")); + }); + + it("it should filter heroes out", function () { + var res = filter(cards, { + "ability": "hero" + }); + expect(res.length).toBe(2); + }); + + it("it should filter hero and special cards out", function () { + var res = filter(cards, { + "ability": "hero", + "type": Card.TYPE.SPECIAL + }); + expect(res.length).toBe(1); + }); +}); + +},{"../../assets/data/abilities":1,"../../server/Battleside":5,"../../server/Card":6}],11:[function(require,module,exports){ +"use strict"; + +require("./filterSpec"); + +(function main() {})(); + +},{"./filterSpec":10}]},{},[11])(11) +}); +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","Y:/htdocs/tim/2015/gwent/assets/data/abilities.js","Y:/htdocs/tim/2015/gwent/assets/data/cards.js","Y:/htdocs/tim/2015/gwent/assets/data/deck.js","node_modules/underscore/underscore.js","Y:/htdocs/tim/2015/gwent/server/Battleside.js","Y:/htdocs/tim/2015/gwent/server/Card.js","Y:/htdocs/tim/2015/gwent/server/Deck.js","Y:/htdocs/tim/2015/gwent/server/Field.js","Y:/htdocs/tim/2015/gwent/server/Hand.js","Y:/htdocs/tim/2015/gwent/test/spec/filterSpec.js","Y:/htdocs/tim/2015/gwent/test/spec/mainSpec.js"],"names":[],"mappings":"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ACV,eAAe,EACf,SAAS,EACT,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW;;AAEX,kBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,iBAAiB,CAClB;CACF,CAAA;;;AC/GD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5gDA,IAAI,QAAQ,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAC9C,IAAI,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7B,IAAI,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7B,IAAI,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7B,IAAI,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;AAC/B,IAAI,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAG9B,IAAI,UAAU,CAAC;AACf,UAAU,GAAG,CAAC,YAAU;AACtB,MAAI,UAAU,GAAG,SAAb,UAAU,CAAY,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC;AAC9C,QAAG,EAAE,IAAI,YAAY,UAAU,CAAA,AAAC,EAAC;AAC/B,aAAQ,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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","module.exports = {\r\n\r\n  \"agile\": {\r\n\r\n  },\r\n  \"medic\": {\r\n    waitResponse: true,\r\n    onAfterPlace: function(card) {\r\n      var discard = this.getDiscard();\r\n\r\n      discard = this.filter(discard, {\r\n        \"ability\": \"hero\",\r\n        \"type\": card.constructor.TYPE.SPECIAL\r\n      })\r\n\r\n      this.send(\"played:medic\", {\r\n        cards: JSON.stringify(discard)\r\n      }, true);\r\n    }\r\n  },\r\n  \"morale_boost\": {\r\n      onAfterPlace: function(card) {\r\n      var field = this.field[card.getType()];\r\n      var cards = field.get();\r\n\r\n      cards.forEach(function(_card) {\r\n        if(_card.getID() == card.getID()) return;\r\n        if(_card.getRawPower() === -1) return;\r\n        _card.boost(1);\r\n      })\r\n    }\r\n  },\r\n  \"muster\": {\r\n    name: \"muster\",\r\n    onAfterPlace: function(card){\r\n      var musterType = card.getMusterType();\r\n      var self = this;\r\n\r\n      var cardsDeck = this.deck.find(\"musterType\", musterType);\r\n      var cardsHand = this.hand.find(\"musterType\", musterType);\r\n\r\n      cardsDeck.forEach(function(_card) {\r\n        self.deck.removeFromDeck(_card);\r\n        self.placeCard(_card, {\r\n          suppress: \"muster\"\r\n        });\r\n      })\r\n      cardsHand.forEach(function(_card) {\r\n        self.hand.remove(_card);\r\n        self.placeCard(_card, {\r\n          suppress: \"muster\"\r\n        });\r\n      })\r\n    }\r\n  },\r\n  \"tight_bond\": {\r\n    onAfterPlace: function(card){\r\n      var field = this.field[card.getType()];\r\n      var cards = field.get();\r\n      var lastInsert = cards.length;\r\n\r\n      if(lastInsert < 2) return;\r\n\r\n      if(cards[lastInsert - 2].getName() == cards[lastInsert - 1].getName()){\r\n        cards[lastInsert - 2].boost(+cards[lastInsert - 2].getPower());\r\n        cards[lastInsert - 1].boost(+cards[lastInsert - 1].getPower());\r\n      }\r\n    }\r\n  },\r\n  \"spy\": {\r\n    changeSide: true,\r\n    onAfterPlace: function(card){\r\n      this.draw(2);\r\n    }\r\n  },\r\n  \"weather_fog\": {\r\n    onEachTurn: function(card) {\r\n      var targetRow = card.constructor.TYPE.RANGED;\r\n      var forcedPower = 1;\r\n      var field1 = this.field[targetRow].get();\r\n      var field2 = this.foe.field[targetRow].get();\r\n\r\n      var field = field1.concat(field2);\r\n\r\n      field.forEach(function(_card) {\r\n        if(_card.getRawAbility() == \"hero\") return;\r\n        _card.setForcedPower(forcedPower);\r\n      });\r\n    },\r\n    onEachCardPlace: function(card) {\r\n      var targetRow = card.constructor.TYPE.RANGED;\r\n      var forcedPower = 1;\r\n      var field1 = this.field[targetRow].get();\r\n      var field2 = this.foe.field[targetRow].get();\r\n\r\n      var field = field1.concat(field2);\r\n\r\n      field.forEach(function(_card) {\r\n        if(_card.getRawAbility() == \"hero\") return;\r\n        _card.setForcedPower(forcedPower);\r\n      });\r\n    }\r\n  },\r\n  \"weather_rain\": {\r\n    onEachTurn: function(card) {\r\n      var targetRow = card.constructor.TYPE.SIEGE;\r\n      var forcedPower = 1;\r\n      var field1 = this.field[targetRow].get();\r\n      var field2 = this.foe.field[targetRow].get();\r\n\r\n      var field = field1.concat(field2);\r\n\r\n      field.forEach(function(_card) {\r\n        if(_card.getRawAbility() == \"hero\") return;\r\n        _card.setForcedPower(forcedPower);\r\n      });\r\n\r\n    }\r\n  },\r\n  \"weather_frost\": {\r\n    onEachTurn: function(card) {\r\n      var targetRow = card.constructor.TYPE.CLOSE_COMBAT;\r\n      var forcedPower = 1;\r\n      var field1 = this.field[targetRow].get();\r\n      var field2 = this.foe.field[targetRow].get();\r\n\r\n      var field = field1.concat(field2);\r\n\r\n      field.forEach(function(_card) {\r\n        if(_card.getRawAbility() == \"hero\") return;\r\n        _card.setForcedPower(forcedPower);\r\n      });\r\n\r\n    }\r\n  },\r\n  \"clear_weather\": {\r\n    onAfterPlace: function(card) {\r\n      var targetRow = card.constructor.TYPE.WEATHER;\r\n      var field = this.field[targetRow].get();\r\n\r\n      //todo: remove weather cards\r\n    }\r\n  },\r\n  \"decoy\": {\r\n    replaceWith: true\r\n  },\r\n  \"foltest_leader1\": {\r\n    onActivate: function() {\r\n      var cards = this.deck.find(\"key\", \"impenetrable_fog\")\r\n      if(!cards.length) return;\r\n      var card = this.deck.removeFromDeck(cards[0]);\r\n      this.placeCard(card);\r\n    }\r\n  },\r\n  \"francesca_leader1\": {\r\n\r\n  },\r\n  \"francesca_leader2\": {\r\n\r\n  },\r\n  \"francesca_leader3\": {\r\n\r\n  },\r\n  \"francesca_leader4\": {\r\n\r\n  },\r\n  \"eredin_leader1\": {\r\n\r\n  },\r\n  \"eredin_leader2\": {\r\n\r\n  },\r\n  \"eredin_leader3\": {\r\n\r\n  },\r\n  \"eredin_leader4\": {\r\n\r\n  },\r\n  \"hero\": {\r\n\r\n  }\r\n}","/**\r\n * types\r\n * 0 close combat\r\n * 1 ranged\r\n * 2 siege\r\n * 3 leader\r\n * 4 special (decoy)\r\n * 5 weather\r\n */\r\n\r\n\r\nmodule.exports = {\r\n  \"redanian_foot_soldier\": {\r\n    name: \"Redanian Foot Soldier\",\r\n    power: 1,\r\n    ability: null,\r\n    img: \"foot_soldier1\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"poor_fucking_infantry\": {\r\n    name: \"Poor Fucking Infantry\",\r\n    power: 1,\r\n    ability: \"tight_bond\",\r\n    img: \"infantry\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"yarpen_zigrin\": {\r\n    name: \"Yarpen Zigrin\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"yarpen\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"blue_stripes_commando\": {\r\n    name: \"Blue Stripes Commando\",\r\n    power: 4,\r\n    ability: \"tight_bond\",\r\n    img: \"commando\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"sigismunt_dijkstra\": {\r\n    name: \"Sigismunt Dijkstra\",\r\n    power: 4,\r\n    ability: \"spy\",\r\n    img: \"dijkstra\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"prince_stennis\": {\r\n    name: \"Prince Stennis\",\r\n    power: 5,\r\n    ability: \"spy\",\r\n    img: \"stennis\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"siegfried_of_denesle\": {\r\n    name: \"Siegfried of Denesle\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"siegfried\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"ves\": {\r\n    name: \"Ves\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"ves\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"vernon_roche\": {\r\n    name: \"Vernon Roche\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"roche\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"john_natalis\": {\r\n    name: \"John Natalis\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"natalis\",\r\n    faction: \"Northern Realm\",\r\n    type: 0\r\n  },\r\n  \"sheldon_skaggs\": {\r\n    name: \"Sheldon Skaggs\",\r\n    power: 4,\r\n    ability: null,\r\n    img: \"skaggs\",\r\n    faction: \"Northern Realm\",\r\n    type: 1\r\n  },\r\n  \"sabrina_glevissig\": {\r\n    name: \"Sabrina Glevissig\",\r\n    power: 4,\r\n    ability: null,\r\n    img: \"sabrina\",\r\n    faction: \"Northern Realm\",\r\n    type: 1\r\n  },\r\n  \"crinfrid_reavers_dragon_hunter\": {\r\n    name: \"Crinfrid Reaver's Dragon Hunter\",\r\n    power: 5,\r\n    ability: \"tight_bond\",\r\n    img: \"crinfrid\",\r\n    faction: \"Northern Realm\",\r\n    type: 1\r\n  },\r\n  \"sile_de_tansarville\": {\r\n    name: \"Síle de Tansarville\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"sile\",\r\n    faction: \"Northern Realm\",\r\n    type: 1\r\n  },\r\n  \"keira_metz\": {\r\n    name: \"Keira Metz\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"keira\",\r\n    faction: \"Northern Realm\",\r\n    type: 1\r\n  },\r\n  \"dethmold\": {\r\n    name: \"Dethmold\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"dethmold\",\r\n    faction: \"Northern Realm\",\r\n    type: 1\r\n  },\r\n  \"kaedweni_siege_expert\": {\r\n    name: \"Kaedweni Siege Expert\",\r\n    power: 1,\r\n    ability: \"morale_boost\",\r\n    img: \"siege_expert1\",\r\n    faction: \"Northern Realm\",\r\n    type: 2\r\n  },\r\n  \"dun_banner_medic\": {\r\n    name: \"Dun Banner Medic\",\r\n    power: 5,\r\n    ability: \"medic\",\r\n    img: \"medic\",\r\n    faction: \"Northern Realm\",\r\n    type: 2\r\n  },\r\n  \"ballista\": {\r\n    name: \"Ballista\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"ballista1\",\r\n    faction: \"Northern Realm\",\r\n    type: 2\r\n  },\r\n  \"trebuchet\": {\r\n    name: \"Trebuchet\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"trebuchet1\",\r\n    faction: \"Northern Realm\",\r\n    type: 2\r\n  },\r\n  \"thaler\": {\r\n    name: \"Thaler\",\r\n    power: 1,\r\n    ability: \"spy\",\r\n    img: \"thaler\",\r\n    faction: \"Northern Realm\",\r\n    type: 2\r\n  },\r\n  \"foltest_king_of_temeria\": {\r\n    name: \"Foltest: King of Temeria\",\r\n    power: -1,\r\n    ability: \"foltest_leader1\",\r\n    img: \"foltest_king\",\r\n    faction: \"Northern Realm\",\r\n    type: 3\r\n  },\r\n  \"decoy\": {\r\n    name: \"Decoy\",\r\n    power: -1,\r\n    ability: \"decoy\",\r\n    img: \"decoy\",\r\n    faction: null,\r\n    type: 4\r\n  },\r\n  \"impenetrable_fog\": {\r\n    name: \"Impenetrable Fog\",\r\n    power: -1,\r\n    ability: \"weather_fog\",\r\n    img: \"fog\",\r\n    faction: null,\r\n    type: 5\r\n  },\r\n\r\n\r\n  \"francesca_pureblood_elf\": {\r\n    name: \"Francesca, Pureblood Elf\",\r\n    power: -1,\r\n    ability: \"francesca_leader1\",\r\n    img: \"francesca_pureblood\",\r\n    faction: \"Scoia'tael\",\r\n    type: 3\r\n  },\r\n  \"francesca_the_beautiful\": {\r\n    name: \"Francesca The Beautiful\",\r\n    power: -1,\r\n    ability: \"francesca_leader2\",\r\n    img: \"francesca_beatiful\",\r\n    faction: \"Scoia'tael\",\r\n    type: 3\r\n  },\r\n  \"francesca_daisy_of_the_valley\": {\r\n    name: \"Francesca, Daisy of The Valley\",\r\n    power: -1,\r\n    ability: \"francesca_leader3\",\r\n    img: \"francesca_daisy\",\r\n    faction: \"Scoia'tael\",\r\n    type: 3\r\n  },\r\n  \"francesca_queen_of_dol_blathanna\": {\r\n    name: \"Francesca, Queen of Dol Blathanna\",\r\n    power: -1,\r\n    ability: \"francesca_leader4\",\r\n    img: \"francesca_queen\",\r\n    faction: \"Scoia'tael\",\r\n    type: 3\r\n  },\r\n  \"saesenthessis\": {\r\n    name: \"Saesenthessis\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"saesenthessis\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"iorveth\": {\r\n    name: \"Iorveth\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"iorveth\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"isengrim_faoiltiarnah\": {\r\n    name: \"Isengrim Faoiltiarnah\",\r\n    power: 10,\r\n    ability: [\"hero\", \"morale_boost\"],\r\n    img: \"isengrim\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"eithne\": {\r\n    name: \"Eithne\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"eithne\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"havekar_healer\": {\r\n    name: \"Havekar Healer\",\r\n    power: 0,\r\n    ability: \"morale_boost\",\r\n    img: \"healer\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"riordain\": {\r\n    name: \"Riordain\",\r\n    power: 1,\r\n    ability: null,\r\n    img: \"riordain\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"toruviel\": {\r\n    name: \"Toruviel\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"toruviel\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"elven_skirmisher\": {\r\n    name: \"Elven Skirmisher\",\r\n    power: 2,\r\n    ability: \"muster\",\r\n    musterType: \"skirmisher\",\r\n    img: \"elven_skirmisher2\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"dwarven_skirmisher\": {\r\n    name: \"Dwarven Skirmisher\",\r\n    power: 3,\r\n    ability: \"muster\",\r\n    musterType: \"skirmisher\",\r\n    img: \"skirmisher2\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"ciaran_aep_easnillien\": {\r\n    name: \"Ciaran aep Easnillien\",\r\n    power: 3,\r\n    ability: \"agile\",\r\n    img: \"easnillien\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"vrihedd_brigade_recruit\": {\r\n    name: \"Vrihedd Brigade Recruit\",\r\n    power: 4,\r\n    ability: null,\r\n    img: \"recruit\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"dol_blathanna_archer\": {\r\n    name: \"Dol Blathanna Archer\",\r\n    power: 4,\r\n    ability: null,\r\n    img: \"archer\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  }, /*\r\n  \"hav_caaren_medic\": {\r\n    name: \"Hav’caaren Medic\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"\", //missing image\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },*/\r\n  \"havekar_smuggler\": {\r\n    name: \"Havekar Smuggler\",\r\n    power: 5,\r\n    ability: \"spy\",\r\n    img: \"smuggler1\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"mahakaman_defender\": {\r\n    name: \"Mahakaman Defender\",\r\n    power: 5,\r\n    ability: \"muster\",\r\n    musterType: \"defender\",\r\n    img: \"defender2\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"vrihedd_brigade_veteran\": {\r\n    name: \"Vrihedd Brigade Veteran\",\r\n    power: 5,\r\n    ability: \"agile\",\r\n    img: \"veteran1\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"dennis_cranmer\": {\r\n    name: \"Dennis Cranmer\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"cranmer\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"filavandrel_aen_fidhail\": {\r\n    name: \"Filavandrel aén Fidháil\",\r\n    power: 6,\r\n    ability: \"agile\",\r\n    img: \"fidhail\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"ida_emean_aep_sivney\": {\r\n    name: \"Ida Emean aep Sivney\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"sivney\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n  \"yaevinn\": {\r\n    name: \"Yaevinn\",\r\n    power: 6,\r\n    ability: \"agile\",\r\n    img: \"yaevinn\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"barclay_els\": {\r\n    name: \"Barclay Els\",\r\n    power: 6,\r\n    ability: \"agile\",\r\n    img: \"barclay\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"dol_blathanna_scout\": {\r\n    name: \"Dol Blathanna Scout\",\r\n    power: 6,\r\n    ability: \"agile\",\r\n    img: \"scout2\",\r\n    faction: \"Scoia'tael\",\r\n    type: 0\r\n  },\r\n  \"milva\": {\r\n    name: \"Milva\",\r\n    power: 10,\r\n    ability: \"morale_boost\",\r\n    img: \"milva\",\r\n    faction: \"Scoia'tael\",\r\n    type: 1\r\n  },\r\n\r\n\r\n  \"eredin_commander_of_the_red_riders\": {\r\n    name: \"Eredin, Commander of the Red Riders\",\r\n    power: -1,\r\n    ability: \"eredin_leader1\",\r\n    img: \"eredin_commander\",\r\n    faction: \"monster\",\r\n    type: 3\r\n  },\r\n  \"eredin_bringer_of_death\": {\r\n    name: \"Eredin, Bringer of Death\",\r\n    power: -1,\r\n    ability: \"eredin_leader2\",\r\n    img: \"eredin_bringer\",\r\n    faction: \"monster\",\r\n    type: 3\r\n  },\r\n  \"eredin_destroyer_of_worlds\": {\r\n    name: \"Eredin, Destroyer of Worlds\",\r\n    power: -1,\r\n    ability: \"eredin_leader3\",\r\n    img: \"eredin_destroyer\",\r\n    faction: \"monster\",\r\n    type: 3\r\n  },\r\n  \"eredin_king_of_the_wild_hunt\": {\r\n    name: \"Eredin, King of The Wild Hunt\",\r\n    power: -1,\r\n    ability: \"eredin_leader4\",\r\n    img: \"eredin_king\",\r\n    faction: \"monster\",\r\n    type: 3\r\n  },\r\n  \"kayran\": {\r\n    name: \"Kayran\",\r\n    power: 8,\r\n    ability: [\"hero\", \"morale_boost\"],\r\n    img: \"kayran\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"leshen\": {\r\n    name: \"Leshen\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"leshen\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"imlerith\": {\r\n    name: \"Imlerith\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"imlerith\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"draug\": {\r\n    name: \"Draug\",\r\n    power: 10,\r\n    ability: \"hero\",\r\n    img: \"draug\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"ghoul\": {\r\n    name: \"Ghoul\",\r\n    power: 1,\r\n    ability: \"muster\",\r\n    musterType: \"ghoul\",\r\n    img: \"ghoul1\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"nekker\": {\r\n    name: \"Nekker\",\r\n    power: 2,\r\n    ability: \"muster\",\r\n    musterType: \"nekker\",\r\n    img: \"nekker\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"wyvern\": {\r\n    name: \"Wyvern\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"wyvern\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"foglet\": {\r\n    name: \"Foglet\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"foglet\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"celaeno_harpy\": {\r\n    name: \"Celaeno Harpy\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"celaeno_harpy\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"gargoyle\": {\r\n    name: \"Gargoyle\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"gargoyle\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"cockatrice\": {\r\n    name: \"Cockatrice\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"cockatrice\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"harpy\": {\r\n    name: \"Harpy\",\r\n    power: 2,\r\n    ability: \"agile\",\r\n    img: \"harpy\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"endrega\": {\r\n    name: \"Endrega\",\r\n    power: 2,\r\n    ability: null,\r\n    img: \"endrega\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  \"vampire_bruxa\": {\r\n    name: \"Vampire: Bruxa\",\r\n    power: 4,\r\n    ability: \"muster\",\r\n    musterType: \"vampire\",\r\n    img: \"vampire_bruxa\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"vampire_fleder\": {\r\n    name: \"Vampire: Fleder\",\r\n    power: 4,\r\n    ability: \"muster\",\r\n    musterType: \"vampire\",\r\n    img: \"vampire_fleder\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"vampire_garkain\": {\r\n    name: \"Vampire: Garkain\",\r\n    power: 4,\r\n    ability: \"muster\",\r\n    musterType: \"vampire\",\r\n    img: \"vampire_garkain\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"vampire_ekimmara\": {\r\n    name: \"Vampire: Ekimmara\",\r\n    power: 4,\r\n    ability: \"muster\",\r\n    musterType: \"vampire\",\r\n    img: \"vampire_ekimmara\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"arachas\": {\r\n    name: \"Arachas\",\r\n    power: 4,\r\n    ability: \"muster\",\r\n    musterType: \"arachas\",\r\n    img: \"arachas1\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"botchling\": {\r\n    name: \"Botchling\",\r\n    power: 4,\r\n    ability: null,\r\n    img: \"botchling\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"forktail\": {\r\n    name: \"Forktail\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"forktail\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"plague_maiden\": {\r\n    name: \"Plague Maiden\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"forktail\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"griffin\": {\r\n    name: \"Griffin\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"griffin\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"werewolf\": {\r\n    name: \"Werewolf\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"werewolf\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"frightener\": {\r\n    name: \"Frightener\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"frightener\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"ice_giant\": {\r\n    name: \"Ice Giant\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"ice_giant\",\r\n    faction: \"monster\",\r\n    type: 2\r\n  },\r\n  \"grave_hag\": {\r\n    name: \"Grave Hag\",\r\n    power: 5,\r\n    ability: null,\r\n    img: \"grave_hag\",\r\n    faction: \"monster\",\r\n    type: 1\r\n  },\r\n  /*\"vampire_katakan\": {\r\n    name: \"Vampire: Katakan\",\r\n    power: 5,\r\n    ability: \"muster\",\r\n musterType: \"vampire\",\r\n    img: \"vampire_katakan\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },*/\r\n  \"crone_whispess\": {\r\n    name: \"Crone: Whispess\",\r\n    power: 6,\r\n    ability: \"muster\",\r\n    musterType: \"crone\",\r\n    img: \"crone_whispess\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"crone_brewess\": {\r\n    name: \"Crone: Brewess\",\r\n    power: 6,\r\n    ability: \"muster\",\r\n    musterType: \"crone\",\r\n    img: \"crone_brewess\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"crone_weavess\": {\r\n    name: \"Crone: Weavess\",\r\n    power: 6,\r\n    ability: \"muster\",\r\n    musterType: \"crone\",\r\n    img: \"crone_weavess\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"arachas_behemoth\": {\r\n    name: \"Arachas Behemoth\",\r\n    power: 6,\r\n    ability: \"muster\",\r\n    musterType: \"arachas\",\r\n    img: \"arachas_behemoth\",\r\n    faction: \"monster\",\r\n    type: 2\r\n  },\r\n  \"fire_elemental\": {\r\n    name: \"Fire Elemental\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"fire_elemental\",\r\n    faction: \"monster\",\r\n    type: 2\r\n  },\r\n  \"fiend\": {\r\n    name: \"Fiend\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"fiend\",\r\n    faction: \"monster\",\r\n    type: 0\r\n  },\r\n  \"earth_elemental\": {\r\n    name: \"Earth Elemental\",\r\n    power: 6,\r\n    ability: null,\r\n    img: \"earth_elemental\",\r\n    faction: \"monster\",\r\n    type: 2\r\n  }\r\n}\r\n","module.exports = {\r\n\r\n  \"northern_realm\": [\r\n    \"redanian_foot_soldier\",\r\n    \"poor_fucking_infantry\",\r\n    \"redanian_foot_soldier\",\r\n    \"poor_fucking_infantry\",\r\n    \"yarpen_zigrin\",\r\n    \"blue_stripes_commando\",\r\n    \"sigismunt_dijkstra\",\r\n    \"prince_stennis\",\r\n    \"siegfried_of_denesle\",\r\n    \"ves\",\r\n    \"vernon_roche\",\r\n    \"john_natalis\",\r\n    \"sheldon_skaggs\",\r\n    \"sabrina_glevissig\",\r\n    \"crinfrid_reavers_dragon_hunter\",\r\n    \"sile_de_tansarville\",\r\n    \"keira_metz\",\r\n    \"dethmold\",\r\n    \"kaedweni_siege_expert\",\r\n    \"dun_banner_medic\",\r\n    \"ballista\",\r\n    \"trebuchet\",\r\n    \"thaler\",\r\n    \"foltest_king_of_temeria\",\r\n    \"decoy\",\r\n    \"impenetrable_fog\"\r\n  ],\r\n\r\n  \"scoiatael\": [\r\n    \"francesca_daisy_of_the_valley\",\r\n    \"saesenthessis\",\r\n    \"iorveth\",\r\n    \"isengrim_faoiltiarnah\",\r\n    \"eithne\",\r\n    \"havekar_healer\",\r\n    \"riordain\",\r\n    \"toruviel\",\r\n    \"decoy\",\r\n    \"decoy\",\r\n    \"impenetrable_fog\",\r\n    \"elven_skirmisher\",\r\n    \"elven_skirmisher\",\r\n    \"dwarven_skirmisher\",\r\n    \"dwarven_skirmisher\",\r\n    \"ciaran_aep_easnillien\",\r\n    \"vrihedd_brigade_recruit\",\r\n    \"dol_blathanna_archer\",\r\n    \"havekar_smuggler\",\r\n    \"mahakaman_defender\",\r\n    \"vrihedd_brigade_veteran\",\r\n    \"dennis_cranmer\",\r\n    \"filavandrel_aen_fidhail\",\r\n    \"filavandrel_aen_fidhail\",\r\n    \"ida_emean_aep_sivney\",\r\n    \"yaevinn\",\r\n    \"barclay_els\",\r\n    \"dol_blathanna_scout\",\r\n    \"milva\"\r\n  ],\r\n\r\n  \"monster\": [\r\n    \"eredin_king_of_the_wild_hunt\",\r\n    \"kayran\",\r\n    \"leshen\",\r\n    \"imlerith\",\r\n    \"draug\",\r\n    \"ghoul\",\r\n    \"decoy\",\r\n    \"decoy\",\r\n    \"nekker\",\r\n    \"nekker\",\r\n    \"wyvern\",\r\n    \"foglet\",\r\n    \"celaeno_harpy\",\r\n    \"gargoyle\",\r\n    \"cockatrice\",\r\n    \"harpy\",\r\n    \"impenetrable_fog\",\r\n    \"endrega\",\r\n    \"vampire_bruxa\",\r\n    \"vampire_bruxa\",\r\n    \"vampire_fleder\",\r\n    \"vampire_fleder\",\r\n    \"vampire_garkain\",\r\n    \"vampire_garkain\",\r\n    \"vampire_ekimmara\",\r\n    \"vampire_ekimmara\",\r\n    \"arachas\",\r\n    \"botchling\",\r\n    \"forktail\",\r\n    \"plague_maiden\",\r\n    \"griffin\",\r\n    \"werewolf\",\r\n    \"frightener\",\r\n    \"ice_giant\",\r\n    \"grave_hag\",\r\n    //\"vampire_katakan\",\r\n    \"crone_whispess\",\r\n    \"crone_whispess\",\r\n    \"crone_brewess\",\r\n    \"crone_brewess\",\r\n    \"crone_weavess\",\r\n    \"crone_weavess\",\r\n    \"arachas_behemoth\",\r\n    \"fire_elemental\",\r\n    \"fiend\",\r\n    \"earth_elemental\"\r\n  ]\r\n}","//     Underscore.js 1.8.3\n//     http://underscorejs.org\n//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind,\n    nativeCreate       = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.8.3';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value)) return _.matcher(value);\n    return _.property(value);\n  };\n  _.iteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, undefinedOnly) {\n    return function(obj) {\n      var length = arguments.length;\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var property = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = property('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  function createReduce(dir) {\n    // Optimized iterator function as using arguments.length\n    // in the main function will deoptimize the, see #1991.\n    function iterator(obj, iteratee, memo, keys, index, length) {\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    }\n\n    return function(obj, iteratee, memo, context) {\n      iteratee = optimizeCb(iteratee, context, 4);\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      // Determine the initial value if none is provided.\n      if (arguments.length < 3) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      return iterator(obj, iteratee, memo, keys, index, length);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var key;\n    if (isArrayLike(obj)) {\n      key = _.findIndex(obj, predicate, context);\n    } else {\n      key = _.findKey(obj, predicate, context);\n    }\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      var func = isFunc ? method : value[method];\n      return func == null ? func : func.apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = isArrayLike(obj) ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, startIndex) {\n    var output = [], idx = 0;\n    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        //flatten current level of array or arguments object\n        if (!shallow) value = flatten(value, shallow, strict);\n        var j = 0, len = value.length;\n        output.length += len;\n        while (j < len) {\n          output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(arguments, true, true, 1);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    return _.unzip(arguments);\n  };\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a predicate test\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n            i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var args = slice.call(arguments, 2);\n    var bound = function() {\n      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last >= 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  function collectNonEnumProps(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object\n  // In contrast to _.map it returns an object\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys =  _.keys(obj),\n          length = keys.length,\n          results = {},\n          currentKey;\n      for (var index = 0; index < length; index++) {\n        currentKey = keys[index];\n        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n      }\n      return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s)\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(object, oiteratee, context) {\n    var result = {}, obj = object, iteratee, keys;\n    if (obj == null) return result;\n    if (_.isFunction(oiteratee)) {\n      keys = _.allKeys(obj);\n      iteratee = optimizeCb(oiteratee, context);\n    } else {\n      keys = flatten(arguments, false, false, 1);\n      iteratee = function(value, key, obj) { return key in obj; };\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(flatten(arguments, false, false, 1), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), and in Safari 8 (#1929).\n  if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = property;\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    return obj == null ? function(){} : function(key) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property, fallback) {\n    var value = object == null ? void 0 : object[property];\n    if (value === void 0) {\n      value = fallback;\n    }\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return '' + this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define === 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}.call(this));\n","var DeckData = require(\"../assets/data/deck\");\r\nvar Deck = require(\"./Deck\");\r\nvar Hand = require(\"./Hand\");\r\nvar Card = require(\"./Card\");\r\nvar Field = require(\"./Field\");\r\nvar _ = require(\"underscore\");\r\n\r\n\r\nvar Battleside;\r\nBattleside = (function(){\r\n  var Battleside = function(name, n, battle, user){\r\n    if(!(this instanceof Battleside)){\r\n      return (new Battleside(name, n, battle, user));\r\n    }\r\n    /**\r\n     * constructor here\r\n     */\r\n\r\n    var deck = user.getDeck();\r\n    var self = this;\r\n    this._isWaiting = true;\r\n    this.socket = user.socket;\r\n    this.field = {};\r\n    this.field[Card.TYPE.LEADER] = Field(Card.TYPE.LEADER);\r\n    this.field[Card.TYPE.CLOSE_COMBAT] = Field(Card.TYPE.CLOSE_COMBAT);\r\n    this.field[Card.TYPE.RANGED] = Field(Card.TYPE.RANGED);\r\n    this.field[Card.TYPE.SIEGE] = Field(Card.TYPE.SIEGE);\r\n    this.n = n ? \"p2\" : \"p1\";\r\n    this._name = name;\r\n    this.battle = battle;\r\n    this.hand = Hand();\r\n    this.deck = Deck(DeckData[deck]);\r\n    this._discard = [];\r\n\r\n    this.runEvent = this.battle.runEvent.bind(this.battle);\r\n    this.on = this.battle.on.bind(this.battle);\r\n    this.off = this.battle.off.bind(this.battle);\r\n\r\n\r\n    this.receive(\"activate:leader\", function(){\r\n      if(self._isWaiting) return;\r\n      if(self.isPassing()) return;\r\n\r\n      console.log(\"leader activated\");\r\n\r\n      var leaderCard = self.getLeader();\r\n      if(leaderCard.isDisabled()) return;\r\n\r\n\r\n      var ability = leaderCard.getAbility();\r\n\r\n      ability.onActivate.apply(self);\r\n      leaderCard.setDisabled(true);\r\n      self.update();\r\n    })\r\n    this.receive(\"play:cardFromHand\", function(data){\r\n      if(self._isWaiting) return;\r\n      if(self.isPassing()) return;\r\n      var cardID = data.id;\r\n      var card = self.hand.getCard(cardID);\r\n\r\n      self.playCard(card);\r\n    })\r\n    this.receive(\"decoy:replaceWith\", function(data){\r\n      if(self._isWaiting) return;\r\n      var card = self.findCardOnFieldByID(data.cardID);\r\n      if(card === -1) throw new Error(\"decoy:replace | unknown card\");\r\n      self.runEvent(\"Decoy:replaceWith\", self, [card]);\r\n    })\r\n    this.receive(\"cancel:decoy\", function(){\r\n      self.off(\"Decoy:replaceWith\");\r\n    })\r\n    this.receive(\"set:passing\", function(){\r\n      self.setPassing(true);\r\n      self.update();\r\n      self.runEvent(\"NextTurn\", null, [self.foe]);\r\n    })\r\n    this.receive(\"medic:chooseCardFromDiscard\", function(data){\r\n      if(!data){\r\n        self.runEvent(\"NextTurn\", null, [self.foe]);\r\n        return;\r\n      }\r\n      var cardID = data.cardID;\r\n      var card = self.getCardFromDiscard(cardID);\r\n      if(card === -1) throw new Error(\"medic:chooseCardFromDiscard | unknown card: \", card);\r\n\r\n      self.removeFromDiscard(card);\r\n\r\n      self.playCard(card);\r\n    })\r\n\r\n\r\n    this.on(\"Turn\" + this.getID(), this.onTurnStart, this);\r\n  };\r\n  var r = Battleside.prototype;\r\n  /**\r\n   * methods && properties here\r\n   * r.property = null;\r\n   * r.getProperty = function() {...}\r\n   */\r\n  r._name = null;\r\n  r._discard = null;\r\n\r\n  r._rubies = 2;\r\n  r._score = 0;\r\n  r._isWaiting = null;\r\n  r._passing = null;\r\n\r\n  r.field = null;\r\n\r\n  r.socket = null;\r\n  r.n = null;\r\n\r\n  r.foe = null;\r\n  r.hand = null;\r\n  r.battle = null;\r\n  r.deck = null;\r\n\r\n  r.isPassing = function(){\r\n    return this._passing;\r\n  }\r\n\r\n  r.setUpWeatherFieldWith = function(p2){\r\n    this.field[Card.TYPE.WEATHER] = p2.field[Card.TYPE.WEATHER] = Field(Card.TYPE.WEATHER);\r\n  }\r\n\r\n  r.findCardOnFieldByID = function(id){\r\n    for(var key in this.field) {\r\n      var field = this.field[key];\r\n      var card = field.getCard(id);\r\n      if(card !== -1) return card;\r\n    }\r\n    /*\r\n        for(var i = 0; i < this._discard.length; i++) {\r\n          var c = this._discard[i];\r\n          if(c.getID() === id) return c;\r\n        }*/\r\n    return -1;\r\n  }\r\n\r\n  r.getCardFromDiscard = function(id){\r\n    for(var i = 0; i < this._discard.length; i++) {\r\n      var c = this._discard[i];\r\n      if(c.getID() === id) return c;\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  r.setPassing = function(b){\r\n    this._passing = b;\r\n    this.send(\"set:passing\", {passing: this._passing}, true);\r\n  }\r\n\r\n  r.wait = function(){\r\n    this._isWaiting = true;\r\n    this.send(\"set:waiting\", {waiting: this._isWaiting}, true);\r\n  }\r\n\r\n  r.turn = function(){\r\n    this._isWaiting = false;\r\n    this.send(\"set:waiting\", {waiting: this._isWaiting}, true);\r\n  }\r\n\r\n  r.setLeadercard = function(){\r\n    var leaderCard = this.deck.find(\"type\", Card.TYPE.LEADER);\r\n    this.deck.removeFromDeck(leaderCard[0]);\r\n    /*\r\n        this.getYourside().setField(\"leader\", leaderCard[0]);*/\r\n    this.field[Card.TYPE.LEADER].add(leaderCard[0]);\r\n  }\r\n\r\n  r.getLeader = function(){\r\n    return this.field[Card.TYPE.LEADER].get()[0];\r\n  }\r\n\r\n  r.getID = function(){\r\n    return this.n;\r\n  }\r\n\r\n  r.draw = function(times){\r\n    while(times--) {\r\n      var card = this.deck.draw();\r\n      this.hand.add(card);\r\n    }\r\n\r\n    console.log(\"update:hand fired\");\r\n\r\n    this.update();\r\n  }\r\n\r\n  r.calcScore = function(){\r\n    var score = 0;\r\n    for(var key in this.field) {\r\n      score += +this.field[key].getScore();\r\n    }\r\n    return this._score = score;\r\n  }\r\n\r\n  r.getInfo = function(){\r\n    return {\r\n      name: this.getName(),\r\n      lives: this._rubies,\r\n      score: this.calcScore(),\r\n      hand: this.hand.length(),\r\n      discard: this.getDiscard(true),\r\n      passing: this._passing\r\n    }\r\n  }\r\n\r\n  r.getRubies = function(){\r\n    return this._rubies;\r\n  }\r\n\r\n  r.getScore = function(){\r\n    return +this.calcScore();\r\n  }\r\n\r\n  r.removeRuby = function(){\r\n    this._rubies--;\r\n  }\r\n\r\n  r.getName = function(){\r\n    return this._name;\r\n  }\r\n\r\n  r.send = function(event, msg, isPrivate){\r\n    msg = msg || {};\r\n    isPrivate = typeof isPrivate === \"undefined\" ? false : isPrivate;\r\n    msg._roomSide = this.n;\r\n\r\n    if(isPrivate){\r\n      return this.socket.emit(event, msg);\r\n    }\r\n    this.battle.send(event, msg);\r\n  }\r\n\r\n  r.receive = function(event, cb){\r\n    this.socket.on(event, cb);\r\n  }\r\n\r\n  r.update = function(){\r\n    //PubSub.publish(\"update\");\r\n    this.runEvent(\"Update\");\r\n  }\r\n\r\n  r.onTurnStart = function(){\r\n    this.foe.wait();\r\n    this.turn();\r\n\r\n    //wait for cardplay event\r\n\r\n\r\n  };\r\n\r\n  r.playCard = function(card){\r\n    if(card === null || card === -1) return;\r\n\r\n    if(!this.placeCard(card)) return;\r\n\r\n    this.hand.remove(card);\r\n\r\n    this.update();\r\n\r\n\r\n    this.runEvent(\"NextTurn\", null, [this.foe]);\r\n  }\r\n\r\n  r.placeCard = function(card, obj){\r\n    obj = _.extend({}, obj);\r\n\r\n    this.checkAbilities(card, obj);\r\n    if(obj._canclePlacement) return 0;\r\n\r\n    var field = obj.targetSide.field[card.getType()];\r\n    field.add(card);\r\n\r\n\r\n    this.runEvent(\"EachCardPlace\");\r\n\r\n    this.checkAbilityOnAfterPlace(card, obj);\r\n    /*\r\n        this.runEvent(\"AfterPlace\", this, [card, obj]);*/\r\n\r\n    this.update();\r\n\r\n    if(obj._waitResponse){\r\n      this.hand.remove(card);\r\n      this.update();\r\n      return 0;\r\n    }\r\n\r\n    return 1;\r\n  }\r\n\r\n  r.checkAbilities = function(card, obj, __flag){\r\n    var self = this;\r\n    obj.targetSide = this;\r\n    var ability = Array.isArray(__flag) || card.getAbility();\r\n\r\n    if(Array.isArray(ability) && ability.length){\r\n      var ret = ability.slice();\r\n      ret = ret.splice(0, 1);\r\n      this.checkAbilities(card, obj, ret);\r\n      ability = ability[0];\r\n    }\r\n\r\n    if(ability && ability.name === obj.suppress){\r\n      this.update();\r\n    }\r\n\r\n    if(ability && !Array.isArray(ability)){\r\n      if(ability.waitResponse){\r\n        obj._waitResponse = true;\r\n      }\r\n      if(ability.changeSide){\r\n        obj.targetSide = this.foe;\r\n      }\r\n      if(ability.replaceWith){\r\n        obj._canclePlacement = true;\r\n\r\n        this.on(\"Decoy:replaceWith\", function(replaceCard){\r\n          if(replaceCard.getType() == Card.TYPE.LEADER ||\r\n          replaceCard.getType() == Card.TYPE.WEATHER ||\r\n          replaceCard.getType() == Card.TYPE.SPECIAL){\r\n            return;\r\n          }\r\n          if(replaceCard.getName() === card.getName()) return;\r\n          self.off(\"Decoy:replaceWith\");\r\n          var field = self.field[replaceCard.getType()];\r\n\r\n\r\n          field.replaceWith(replaceCard, card);\r\n\r\n          self.hand.add(replaceCard);\r\n          self.hand.remove(card);\r\n          self.update();\r\n\r\n          self.runEvent(\"NextTurn\", null, [self.foe]);\r\n        })\r\n      }\r\n      if(ability.onEachTurn){\r\n        this.on(\"EachTurn\", ability.onEachTurn, this, [card])\r\n      }\r\n      if(ability.onEachCardPlace){\r\n        //PubSub.subscribe(\"onEachCardPlace\", ability.onEachCardPlace.bind(this, card));\r\n        this.on(\"EachCardPlace\", ability.onEachCardPlace, this, [card]);\r\n      }\r\n\r\n      this.update();\r\n    }\r\n  }\r\n\r\n  r.checkAbilityOnAfterPlace = function(card, obj){\r\n    var ability = card.getAbility();\r\n    if(ability){\r\n      if(ability.name && ability.name === obj.suppress){\r\n        this.update();\r\n        return;\r\n      }\r\n      if(ability.onAfterPlace){\r\n        ability.onAfterPlace.call(this, card)\r\n      }\r\n    }\r\n  }\r\n\r\n  r.clearMainFields = function(){\r\n    var cards1 = this.field[Card.TYPE.CLOSE_COMBAT].removeAll();\r\n    var cards2 = this.field[Card.TYPE.RANGED].removeAll();\r\n    var cards3 = this.field[Card.TYPE.SIEGE].removeAll();\r\n\r\n    var cards = cards1.concat(cards2.concat(cards3));\r\n    this.addToDiscard(cards);\r\n  }\r\n\r\n  r.addToDiscard = function(cards){\r\n    var self = this;\r\n    cards.forEach(function(card){\r\n      self._discard.push(card);\r\n    });\r\n  }\r\n\r\n  r.removeFromDiscard = function(card){\r\n    for(var i = 0; i < this._discard.length; i++) {\r\n      var c = this._discard[i];\r\n      if(c.getID() === card.getID()){\r\n\r\n        this._discard.splice(i, 1);\r\n        return\r\n      }\r\n    }\r\n  }\r\n\r\n  r.getDiscard = function(json){\r\n    if(json){\r\n      return JSON.stringify(this._discard);\r\n    }\r\n    return this._discard;\r\n  }\r\n\r\n  r.resetNewRound = function(){\r\n    this.clearMainFields();\r\n    this.setPassing(false);\r\n  }\r\n\r\n  r.filter = function(arrCards, opt){\r\n    var arr = arrCards.slice();\r\n\r\n    for(var key in opt) {\r\n      var res = [];\r\n      var prop = key, val = opt[key];\r\n\r\n\r\n      arrCards.forEach(function(card){\r\n        var property = card.getProperty(prop);\r\n        if(_.isArray(property)){\r\n          var _f = false;\r\n          for(var i = 0; i < property.length; i++) {\r\n            if(property[i] === val) {\r\n              _f = true;\r\n              break;\r\n            }\r\n          }\r\n          if(!_f){\r\n            res.push(card);\r\n          }\r\n        }\r\n        else if(card.getProperty(prop) !== val){\r\n          res.push(card);\r\n        }\r\n      })\r\n      arr = _.intersection(arr, res);\r\n    }\r\n\r\n    return arr;\r\n  }\r\n\r\n  return Battleside;\r\n})();\r\n\r\nmodule.exports = Battleside;","var CardData = require(\"../assets/data/cards\");\r\nvar AbilityData = require(\"../assets/data/abilities\");\r\n\r\nvar Card = (function(){\r\n  var Card = function(key){\r\n    if(!(this instanceof Card)){\r\n      return (new Card(key));\r\n    }\r\n    /**\r\n     * constructor here\r\n     */\r\n    this.setDisabled(false);\r\n    this.channel = {};\r\n    this._key = key;\r\n    this._data = CardData[key];\r\n    this._data.key = key;\r\n    this._boost = 0;\r\n    this._forcedPower = -1;\r\n    this._init();\r\n\r\n  };\r\n  var r = Card.prototype;\r\n  /**\r\n   * methods && properties here\r\n   * r.property = null;\r\n   * r.getProperty = function() {...}\r\n   */\r\n  r._key = null;\r\n  r._data = null;\r\n  r._id = null;\r\n  r._owner = null;\r\n  r._boost = null;\r\n  r._forcedPower = null;\r\n  r._disabled = null;\r\n  Card.__id = 0;\r\n  Card.TYPE = {\r\n    CLOSE_COMBAT: 0,\r\n    RANGED: 1,\r\n    SIEGE: 2,\r\n    LEADER: 3,\r\n    SPECIAL: 4,\r\n    WEATHER: 5\r\n  };\r\n\r\n  r.channel = null\r\n\r\n\r\n  r._init = function(){\r\n    this._id = ++Card.__id;\r\n  }\r\n\r\n  r.getName = function(){\r\n    return this._data.name;\r\n  }\r\n  r.getPower = function(){\r\n    if(this._data.power === -1) return 0;\r\n    if(this._forcedPower > -1){\r\n      return this._forcedPower + this._boost;\r\n    }\r\n    return this._data.power + this._boost;\r\n  }\r\n  r.getRawPower = function() {\r\n    return this._data.power;\r\n  }\r\n  r.calculateBoost = function() {\r\n    this._boost = 0;\r\n    for (var key in this._boosts) {\r\n      var boost = this._boosts[key];\r\n      this.boost(boost.getPower());\r\n    }\r\n  }\r\n  r.setForcedPower = function(nr){\r\n    this._forcedPower = nr;\r\n  }\r\n  r.getRawAbility = function(){\r\n    return this._data.ability;\r\n  }\r\n  r.getAbility = function(){\r\n    if(Array.isArray(this._data.ability)) {\r\n      var res = [];\r\n      this._data.ability.forEach(function(ability) {\r\n        res.push(AbilityData[ability]);\r\n      })\r\n      return res;\r\n    }\r\n    return AbilityData[this._data.ability];\r\n  }\r\n  r.getImage = function(){\r\n    return \"../assets/cards/\" + this._data.img + \".png\";\r\n  }\r\n  r.getFaction = function(){\r\n    return this._data.faction;\r\n  }\r\n  r.getMusterType = function() {\r\n    return this._data.musterType || null;\r\n  }\r\n  r.getType = function(){\r\n    return this._data.type;\r\n  }\r\n  r.getKey = function(){\r\n    return this._key;\r\n  }\r\n\r\n  r.getID = function(){\r\n    return this._id;\r\n  }\r\n\r\n  r.boost = function(nr){\r\n    /*this.getPower(); //to recalculate this._power;*/\r\n    this._boost += nr;\r\n  }\r\n\r\n  r.isDisabled = function() {\r\n    return this._disabled;\r\n  }\r\n\r\n  r.setDisabled = function(b) {\r\n    this._disabled = b;\r\n  }\r\n\r\n  r.getProperty = function(prop){\r\n    if(!this._data[prop]) return {};\r\n    return this._data[prop];\r\n  }\r\n\r\n  r.resetBoost = function() {\r\n    this._boost = 0;\r\n  }\r\n\r\n  return Card;\r\n})();\r\n\r\nmodule.exports = Card;","var Card = require(\"./Card\");\r\n/*var CardManager = require(\"./CardManager\");*/\r\n\r\nvar Deck = (function(){\r\n  var Deck = function(deck){\r\n    if(!(this instanceof Deck)){\r\n      return (new Deck(deck));\r\n    }\r\n    /**\r\n     * constructor here\r\n     */\r\n    this._deck = [];\r\n\r\n    this._originalDeck = [];\r\n    this.setDeck(deck);\r\n  };\r\n  var r = Deck.prototype;\r\n  /**\r\n   * methods && properties here\r\n   * r.property = null;\r\n   * r.getProperty = function() {...}\r\n   */\r\n  r._deck = null;\r\n  r._owner = null;\r\n  r._originalDeck = null;\r\n\r\n  r.setDeck = function(deckData){\r\n    this._originalDeck = deckData.slice();\r\n    this._deck = deckData.slice();\r\n\r\n    this._loadCards();\r\n    this.shuffle();\r\n  }\r\n\r\n  r.getLength = function(){\r\n    return this._deck.length;\r\n  }\r\n\r\n  r.length = function(){\r\n    return this.getLength();\r\n  }\r\n\r\n  r.getDeck = function(){\r\n    return this._deck;\r\n  }\r\n\r\n  r.draw = function(){\r\n    if(!this._deck.length) return 0;\r\n    var card = this.pop();\r\n    return card;\r\n  }\r\n\r\n\r\n  r._loadCards = function(){\r\n    this._deck = this.getDeck().map(function(cardkey){\r\n      return Card(cardkey);\r\n    });\r\n  }\r\n\r\n  r.pop = function(){\r\n    var id = this._deck.pop();\r\n    /*\r\n        var card = CardManager().getCardById(id);*/\r\n    return id;\r\n  }\r\n\r\n  r.find = function(key, val){\r\n    var res = [];\r\n    this.getDeck().forEach(function(card){\r\n      if(card.getProperty(key) == val){\r\n        res.push(card);\r\n      }\r\n    });\r\n    return res;\r\n  }\r\n\r\n  r.removeFromDeck = function(card){\r\n    var n = this.length();\r\n\r\n    for(var i = 0; i < n; i++) {\r\n      var c = this.getDeck()[i];\r\n      if(c.getID() === card.getID()){\r\n        return this.getDeck().splice(i, 1)[0];\r\n      }\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  r.shuffle = function(){\r\n    var deck = this.getDeck();\r\n\r\n    var n = this.length();\r\n    for(var i = n - 1; i > 0; i--) {\r\n      var j = (Math.random() * i) | 0;\r\n      var tmp;\r\n\r\n      tmp = deck[j];\r\n      deck[j] = deck[i];\r\n      deck[i] = tmp;\r\n    }\r\n  }\r\n\r\n  return Deck;\r\n})();\r\n\r\nmodule.exports = Deck;","var Field = (function(){\r\n  var Field = function(){\r\n    if(!(this instanceof Field)){\r\n      return (new Field());\r\n    }\r\n    /**\r\n     * constructor here\r\n     */\r\n\r\n    this._cards = [];\r\n  };\r\n  var r = Field.prototype;\r\n  /**\r\n   * methods && properties here\r\n   * r.property = null;\r\n   * r.getProperty = function() {...}\r\n   */\r\n\r\n  r._cards = null;\r\n  r._score = 0;\r\n\r\n  r.add = function(card){\r\n    this._cards.push(card);\r\n    this.updateScore();\r\n  }\r\n\r\n  r.get = function(){\r\n    return this._cards;\r\n  }\r\n\r\n  r.getScore = function(){\r\n    this.updateScore();\r\n    return this._score;\r\n  }\r\n\r\n  r.updateScore = function(){\r\n    this._score = 0;\r\n    for(var i = 0; i < this._cards.length; i++) {\r\n      var card = this._cards[i];\r\n      this._score += card.getPower();\r\n    }\r\n  }\r\n\r\n  r.getPosition = function(card){\r\n    for(var i = 0; i < this._cards.length; i++) {\r\n      if(this._cards[i].getID() === card.getID()) return i;\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  r.replaceWith = function(oldCard, newCard){\r\n    var index = this.getPosition(oldCard);\r\n    this._cards[index] = newCard;\r\n    oldCard.resetBoost();\r\n    return oldCard;\r\n  }\r\n\r\n  r.getCard = function(id){\r\n    for(var i = 0; i < this._cards.length; i++) {\r\n      var card = this._cards[i];\r\n      if(card.getID() == id) return card;\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  r.removeAll = function() {\r\n    var tmp = this._cards.slice();\r\n    tmp.forEach(function(card) {\r\n      card.resetBoost();\r\n    })\r\n    this._cards = [];\r\n    return tmp;\r\n  }\r\n\r\n  return Field;\r\n})();\r\n\r\nmodule.exports = Field;","/*var $ = require(\"jquery\");*//*\r\nvar CardManager = require(\"./CardManager\");*//*\r\nvar PubSub = require(\"./pubsub\");*/\r\nvar Card = require(\"./Card\");\r\n\r\n\r\nvar Hand = (function(){\r\n  var Hand = function(){\r\n    if(!(this instanceof Hand)){\r\n      return (new Hand());\r\n    }\r\n    /**\r\n     * constructor here\r\n     */\r\n\r\n    this._hand = [];\r\n  };\r\n  var r = Hand.prototype;\r\n  /**\r\n   * methods && properties here\r\n   * r.property = null;\r\n   * r.getProperty = function() {...}\r\n   */\r\n  r._hand = null;\r\n\r\n  r.add = function(card){\r\n    this._hand.push(card);\r\n  }\r\n\r\n  r.getCards = function(){\r\n    return this._hand;\r\n  }\r\n\r\n  r.getCard = function(id) {\r\n    for(var i=0; i< this.length(); i++) {\r\n      var card = this.getCards()[i];\r\n      if(card.getID() === id) return card;\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  r.remove = function(id){\r\n    var n = this.length();\r\n\r\n    //console.trace(id);\r\n    id = id instanceof Card ? id.getID() : id;\r\n\r\n    for(var i = 0; i < n; i++) {\r\n      if(this._hand[i].getID() != id) continue;\r\n      return this._hand.splice(i, 1);\r\n    }\r\n\r\n    return -1;\r\n  }\r\n\r\n  r.getRandomCard = function(){\r\n    var rnd = (Math.random() * this._hand.length) | 0;\r\n    return this._hand[rnd];\r\n  }\r\n\r\n  r.getLength = function(){\r\n    return this._hand.length;\r\n  }\r\n\r\n  r.length = function(){\r\n    return this._hand.length;\r\n  }\r\n\r\n  r.find = function(key, val) {\r\n    var res = [];\r\n    this._hand.forEach(function(card){\r\n      if(card.getProperty(key) == val){\r\n        res.push(card);\r\n      }\r\n    });\r\n    return res;\r\n  }\r\n\r\n\r\n  return Hand;\r\n})();\r\n\r\nmodule.exports = Hand;","var Card = require(\"../../server/Card\");\r\nvar Battleside = require(\"../../server/Battleside\");\r\nvar data = require(\"../../assets/data/abilities\");\r\n\r\n\r\ndescribe(\"filter\", function(){\r\n  var card, side, filter, cards;\r\n  beforeEach(function(){\r\n    filter = Battleside.prototype.filter;\r\n    cards = [];\r\n    cards.push(Card(\"iorveth\"));\r\n    cards.push(Card(\"toruviel\"));\r\n    cards.push(Card(\"isengrim_faoiltiarnah\"));\r\n    cards.push(Card(\"decoy\"));\r\n  })\r\n\r\n  it(\"it should filter heroes out\", function(){\r\n    var res = filter(cards, {\r\n      \"ability\": \"hero\"\r\n    })\r\n    expect(res.length).toBe(2);\r\n  })\r\n\r\n  it(\"it should filter hero and special cards out\", function(){\r\n    var res = filter(cards, {\r\n      \"ability\": \"hero\",\r\n      \"type\": Card.TYPE.SPECIAL\r\n    })\r\n    expect(res.length).toBe(1);\r\n  })\r\n\r\n\r\n})","require(\"./filterSpec\");\r\n\r\n(function main(){\r\n\r\n})();\r\n"]}