   # This is 10 by default, but some types of cards override it.
   startingSupply: (state) -> 10
 
-  #### Effect lists
-  # More complex effects of a card can be defined by a list of things that
-  # happen in response to certain events, such as the card being played or
-  # the card being bought. The list will typically have 0 or 1 things in it.
-  #
-  # Each element of the effect list should be a function that takes in the
-  # `state` and alters it.
-  #
-  # Note: As these functions are part of an array object
-  # and not part of the card itself, references to `this` will not work
-  # inside an effect list.
-
-  # What happens when the card is bought?
-  buyEffects: []
-  # What happens (besides the simple effects defined above) when the card is
-  # played?
-  playEffects: []
-  # What happens when this card is in play and another card is gained?
-  gainInPlayEffects: []
-  # What happens when this card is cleaned up from play?
-  cleanupEffects: []
-  # What happens when the card is in play as a Duration at the start of
-  # the turn?
-  # 
-  # *TODO*: replace durationEffects with a simple onDuration, so that
-  # duration effects may refer to `this`
-  durationEffects: []
-  # What happens when the card is shuffled into the draw deck?
-  shuffleEffects: []
-  # What happens when this card is in hand and an opponent plays an attack?
-  attackReactions: []
-  # What happens when this card is in hand and its owner gains a card?
-  gainReactions: []
-  
-  # Apply an effect list to the current game state.
-  doEffects: (effects, state) ->
-    for effect in effects
-      effect(state)
+  #### Complex effects
+  # More complex effects of a card can be defined using arbitrary functions
+  # that modify the state. These functions are no-ops in `basicCard`, and
+  # may be overridden by cards that need them:
+
+  # - What happens when the card is bought?
+  buyEffect: (state) ->
+  # - What happens (besides the simple effects defined above) when the card is
+  #   played?
+  playEffect: (state) ->
+  # - What happens when this card is in play and another card is gained?
+  gainInPlayEffect: (state) ->
+  # - What happens when this card is cleaned up from play?
+  cleanupEffect: (state) ->
+  # - What happens when the card is in play as a Duration at the start of
+  #   the turn?
+  durationEffect: (state) ->
+  # - What happens when the card is shuffled into the draw deck?
+  shuffleEffect: (state) ->
+  # - What happens when this card is in hand and an opponent plays an attack?
+  attackReaction: (state) ->
+  # - What happens when this card is in hand and its owner gains a card?
+  gainReaction: (state) ->
   
   # This defines everything that happens when a card is played, including
-  # basic effects and complex effects defined in `playEffects`.
+  # basic effects and complex effects defined in `playEffect`. Cards
+  # should not override `onPlay`; they should override `playEffect` instead.
   onPlay: (state) ->
     state.current.actions += this.getActions(state)
     state.current.coins += this.getCoins(state)

        {trash: 2}
      ])
      applyBenefit(state, benefit)
  ]
}


  cost: 4
  coins: 1
  buys: 1
  playEffect:
    (state) ->
      state.bridges += 1
}

makeCard 'Chapel', action, {
  cost: 2
  playEffect:
    (state) ->
      state.allowTrash(state.current, 4)
}

makeCard 'Coppersmith', action, {
  cost: 4
  playEffect:
    (state) ->
      state.copperValue += 1
}

makeCard 'Diadem', c.Silver, {
