Add Lorescale Coatl

Fixes #232

lib/magic/cards/lorescale_coatl.rb

@@ -0,0 +1,21 @@
+module Magic
+  module Cards
+    class LorescaleCoatl < Creature
+      card_name "Lorescale Coatl"
+      cost "{1}{G}{U}"
+      creature_type "Snake"
+      power 2
+      toughness 2
+
+      def event_handlers
+        {
+          Events::CardDraw => ->(receiver, event) {
+            return unless receiver.controller == event.player
+
+            trigger_effect(:add_counter, source: receiver, counter_type: Counters::Plus1Plus1, target: receiver)
+          }
+        }
+      end
+    end
+  end
+end

lib/magic/cards/mazemind_tome.rb

@@ -36,7 +36,7 @@ def activated_abilities = [ActivatedAbility, ActivatedAbility2]
 
       def event_handlers
         {
-          Events::CounterAdded => ->(receiver, event) {
+          Events::CounterAddedToPermanent => ->(receiver, event) {
             return unless event.permanent == receiver
 
             if receiver.counters.of_type(Magic::Counters::Page).count >= 4

lib/magic/cards/nine_lives.rb

@@ -26,7 +26,7 @@ def event_handlers
 
             receiver.controller.lose!
           end,
-          Events::CounterAdded => -> (receiver, event) do
+          Events::CounterAddedToPermanent => -> (receiver, event) do
             if receiver.counters.of_type(Counters::Incarnation).count >= 9
               receiver.trigger_effect(:exile, target: receiver)
 

lib/magic/events/counter_added_to_permanent.rb

@@ -0,0 +1,17 @@
+module Magic
+  module Events
+    class CounterAddedToPermanent
+      attr_reader :permanent, :counter_type, :amount
+
+      def initialize(permanent: nil, counter_type:, amount:)
+        @permanent = permanent
+        @counter_type = counter_type
+        @amount = amount
+      end
+
+      def inspect
+        "#<Events::CounterAdded permanent: #{permanent.name}, type: #{counter_type}, amount: #{amount}>"
+      end
+    end
+  end
+end

lib/magic/events/counter_added_to_player.rb

@@ -0,0 +1,17 @@
+module Magic
+  module Events
+    class CounterAddedToPlayer
+      attr_reader :player, :counter_type, :amount
+
+      def initialize(player: nil, counter_type:, amount:)
+        @player = player
+        @counter_type = counter_type
+        @amount = amount
+      end
+
+      def inspect
+        "#<Events::CounterAdded player: #{player.name}, type: #{counter_type}, amount: #{amount}>"
+      end
+    end
+  end
+end

lib/magic/events/player_lost.rb

@@ -0,0 +1,15 @@
+module Magic
+  module Events
+    class PlayerLost
+      attr_reader :player
+
+      def initialize(player:)
+        @player = player
+      end
+
+      def inspect
+        "#<Events::PlayerLost player: #{player.name}>"
+      end
+    end
+  end
+end

lib/magic/permanent.rb

@@ -271,7 +271,7 @@ def cleanup!
 
     def add_counter(counter_type, amount: 1)
       @counters = Counters::Collection.new(@counters + [counter_type.new] * amount)
-      counter_added = Events::CounterAdded.new(
+      counter_added = Events::CounterAddedToPermanent.new(
         permanent: self,
         counter_type: counter_type,
         amount: amount

lib/magic/player.rb

@@ -130,6 +130,12 @@ def lost?
     end
 
     def lose!
+      game.notify!(
+        Events::PlayerLost.new(
+          player: self,
+        )
+      )
+
       @lost = true
     end
 
@@ -283,7 +289,7 @@ def protected_from?(card)
 
     def add_counter(counter_type, amount: 1)
       @counters = Counters::Collection.new(@counters + [counter_type.new] * amount)
-      counter_added = Events::CounterAdded.new(
+      counter_added = Events::CounterAddedToPlayer.new(
         player: self,
         counter_type: counter_type,
         amount: amount

spec/cards/lorescale_coatl_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+RSpec.describe Magic::Cards::LorescaleCoatl do
+  include_context "two player game"
+
+  subject(:lorescale_coatl) { ResolvePermanent("Lorescale Coatl") }
+
+  before do
+    p1.library.add(Card("Forest"))
+  end
+
+  it "gets a +1/+1 counter whenever its controller draws a card" do
+    expect(lorescale_coatl.power).to eq(2)
+    expect(lorescale_coatl.toughness).to eq(2)
+
+    p1.draw!
+    expect(lorescale_coatl.counters.of_type(Magic::Counters::Plus1Plus1).count).to eq(1)
+  end
+end