iduel html replay

lib/action.rb

@@ -29,8 +29,7 @@ class Action
   class Go < Reset
     def run
       super
-      player_field.hand = player_field.deck.shift(5)
-      #player_field.hand.each{|card|card.position = :set}
+      player_field.hand = player_field.deck.pop(5)
     end
   end
   class FirstToGo < Go;  end
@@ -84,8 +83,7 @@ class Action
       @position = position
     end
     def run
-      puts '-----------------------------------'
-      p self
+      $log.debug('--------------move action run--------------'){self.inspect}
       from_field = case @from_pos
       when 0..10
         player_field.field
@@ -113,8 +111,6 @@ class Action
       else
         (@card.is_a?(Game_Card) ? from_field.index(@card) : from_field.index{|card|card.card == @card}) || from_field.index{|card|!card.known?}
       end
-     # p from_pos, from_field
-     # p from_field[from_pos] if from_pos
       to_field = case @to_pos
       when Integer
         player_field.field
@@ -129,14 +125,24 @@ class Action
       when :removed
         player_field.removed
       end
-      if from_pos && from_field[from_pos]
+      if from_pos
         card = case @card
         when Game_Card
           from_field[from_pos] = @card
         when nil, Card::Unknown
+          if !from_field[from_pos]
+            from_field[from_pos] = Game_Card.new(Card::Unknown)
+            $log.warn('卡片移动'){'似乎凭空产生了卡片' + self.inspect}
+            from_field[from_pos].position = :attack
+          end
           from_field[from_pos]
         when Card
+          if !from_field[from_pos]
+            from_field[from_pos] = Game_Card.new(@card)
+            from_field[from_pos].position = :attack
+          else
             from_field[from_pos].card = @card
+          end
           from_field[from_pos]
         when :deck
           player_field.deck.last
@@ -150,7 +156,7 @@ class Action
         end
       else
         card = @card == :deck ?  player_field.deck.first : Game_Card.new(@card)
-        $log.warn("似乎凭空产生了卡片？"){self.inspect}
+        $log.warn('卡片移动'){'似乎凭空产生了卡片' + self.inspect}
       end
       if @position
         if @position == :"face-up"
@@ -227,7 +233,42 @@ class Action
   end
   class Control < Move
     def initialize(from_player, from_pos, card)
-      super(from_player, from_pos, :opponent, card)
+      super(from_player, from_pos, nil, card)
+    end
+    def run
+      to_pos = opponent_field.field[6..10].index(nil)+6
+      unless to_pos
+        $log.warn('转移控制权'){'没有空余场位'}
+        return
+      end
+      
+      card = if @card.is_a? Game_Card
+        @card
+      elsif player_field.field[from_pos]
+        card = player_field.field[from_pos]
+        card.card = @card
+        card
+      else
+        Game_Card.new(@card)
+      end
+      
+      player_field.field[from_pos] = nil
+      opponent_field.field[to_pos] = card
+    end
+  end
+  class SendToOpponentGraveyard < SendToGraveyard
+    def run
+      card = if @card.is_a? Game_Card
+        @card
+      elsif player_field.field[from_pos]
+        card = player_field.field[from_pos]
+        card.card = @card
+        card
+      else
+        Game_Card.new(@card)
+      end
+      player_field.field[from_pos] = nil
+      opponent_field.graveyard.unshift card
     end
   end
   class Tribute < SendToGraveyard;  end
@@ -266,84 +307,127 @@ class Action
       player_field.hand += player_field.deck.pop(@count)
     end
   end
-  
-  class AllMonstersSendToGraveyard < SendToGraveyard
-    def initialize(from_player, cards)
-      @from_player = from_player
+  class MultiMove < Action
+    def initialize(from_player, from_pos, to_pos, cards=nil)
+      super(from_player)
+      @from_pos = from_pos
+      @to_pos = to_pos
       @cards = cards
     end
     def run
+      from_field = case @from_pos
+      when :hand
+        player_field.hand
+      when :graveyard
+        player_field.graveyard
+      when :spellsandtraps
+        player_field.field[0..5]
+      when :monsters
+        player_field.field[6..10]
+      end
       @cards = if @cards
         @cards.collect do |card|
-          if card.is_a? Game_Card
-            card
-          else
-            index = player_field.field[6..10].index{|fieldcard|fieldcard and fieldcard.card == card} || player_field.field[6..10].index{|fieldcard|fieldcard and !fieldcard.known?}
+          index = from_field.index{|fieldcard|fieldcard and fieldcard.card == card} || from_field.index{|fieldcard|fieldcard and !fieldcard.known?}
           if index
-              index += 6
-              card = player_field.field[index]
-              player_field.field[index] = nil
-              card
+            fieldcard = from_field[index]
+            from_field[index] = nil
+            fieldcard.card = card
+            fieldcard
           else
-              Game_Card.new(@card)
             $log.warn '似乎凭空产生了卡片'
-            end
+            Game_Card.new(@card)
           end
         end
       else
-        player_field.field[6..10].compact
+        from_field.compact
+      end
+      to_field, position = case @to_pos
+      when :hand
+        [player_field.hand, :set]
+      when :graveyard
+        [player_field.graveyard, :attack]
+      when :deck
+        [player_field.deck, :set]
+      when :removed
+        [player_field.removed, :attack]
       end
       
-      player_field.field[6..10] = nil
-      player_field.graveyard += @cards
+      #执行部分
+      case @from_pos
+      when :hand
+        player_field.hand.clear
+      when :graveyard
+        player_field.graveyard.clear
+      when :spellsandtraps
+        player_field.field[0..5] = Array.new(6, nil)
+      when :monsters
+        player_field.field[6..10] = Array.new(5, nil)
+      end
+      if to_field == player_field.hand or to_field == player_field.deck
+        @cards.each{|card|card.position = position; to_field.push card}
+      else
+        @cards.each{|card|card.position = position; to_field.unshift card}
+      end
+      super
     end
   end
-  class AllMonstersRemove < Remove
+=begin #似乎不需要细分
+  class MonstersSendToGraveyard < MultiMove
     def initialize(from_player, cards)
-      @from_player = from_player
-      @cards = cards
+      super(from_player, :monsters, :graveyard, cards)
     end
-    def run
-      @cards ||= player_field.field[6..10].compact
-      player_field.field[6..10] = nil
-      player_field.removed += @cards
+  end
+  class MonstersRemove < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :monsters, :remove, cards)
     end
   end
-  class AllMonstersReturnToDeck < ReturnToDeck
+  class MonstersReturnToDeck < MultiMove
     def initialize(from_player, cards)
-      @from_player = from_player
-      @cards = cards
+      super(from_player, :monsters, :deck, cards)
     end
-    def run
-      @cards ||= player_field.field[6..10].compact
-      player_field.field[6..10] = nil
-      player_field.deck += @cards
+  end
+  class MonstersReturnToHand < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :monsters, :hand, cards)
     end
   end
-  class AllMonstersReturnToHand < ReturnToHand
+  class SpellsAndTrapsSendToGraveyard < MultiMove
     def initialize(from_player, cards)
-      @from_player = from_player
-      @cards = cards
+      super(from_player, :spellsandtraps, :graveyard, cards)
     end
-    def run
-      @cards ||= player_field.field[6..10].compact
-      player_field.field[6..10] = nil
-      player_field.hand += @cards
   end
+  class SpellsAndTrapsRemove < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :spellsandtraps, :remove, cards)
     end
-  class AllMonstersCounter < Counter
-    def initialize(from_player)
-      @from_player = from_player
   end
-    def run
-      player_field.field[6..10].each_with_index do |card, index|
-        if card
-          player_field.removed << card
-          player_field.field[index+6] = nil
+  class SpellsAndTrapsReturnToDeck < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :spellsandtraps, :deck, cards)
+    end
+  end
+  class SpellsAndTrapsReturnToHand < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :spellsandtraps, :hand, cards)
     end
   end
+  class HandSendToGraveyard < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :hand, :graveyard, cards)
+    end
+  end
+  class HandRemove < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :hand, :remove, cards)
     end
   end
+  class HandReturnToDeck < MultiMove
+    def initialize(from_player, cards)
+      super(from_player, :hand, :deck, cards)
+    end
+  end
+=end
   class RefreshField < Action
     attr_reader :field
     def initialize(from_player, field, msg=nil)
@@ -357,22 +441,26 @@ class Action
       if player_field.hand.size > @field[:hand]
         player_field.hand.pop(player_field.hand.size-@field[:hand])
       elsif player_field.hand.size < @field[:hand]
-        (@field[:hand]-player_field.hand.size).times{player_field.hand.push Game_Card.new(Card::Unknown)}
+        (@field[:hand]-player_field.hand.size).times{$log.warn('刷新场地-手卡'){'似乎凭空产生了卡片'};player_field.hand.push Game_Card.new(Card::Unknown)}
       end
       if player_field.deck.size > @field[:deck]
         player_field.deck.pop(player_field.deck.size-@field[:deck])
       elsif player_field.deck.size < @field[:deck]
-        (@field[:deck]-player_field.deck.size).times{player_field.deck.push Game_Card.new(Card::Unknown)}
+        (@field[:deck]-player_field.deck.size).times{$log.warn('刷新场地-卡组'){'似乎凭空产生了卡片'};player_field.deck.push Game_Card.new(Card::Unknown)}
       end
       if player_field.graveyard.size > @field[:graveyard]
         player_field.graveyard.pop(player_field.graveyard.size-@field[:graveyard])
       elsif player_field.graveyard.size < @field[:graveyard]
-        (@field[:graveyard]-player_field.graveyard.size).times{player_field.graveyard.push Game_Card.new(Card::Unknown)}
+        (@field[:graveyard]-player_field.graveyard.size).times{$log.warn('刷新场地-墓地'){'似乎凭空产生了卡片'};player_field.graveyard.push Game_Card.new(Card::Unknown)}
       end
       (0..10).each do |pos|
         if @field[pos]
-          player_field.field[pos] ||= Game_Card.new(@field[pos][:card])
+          if player_field.field[pos]
             player_field.field[pos].card = @field[pos][:card]
+          else
+            $log.warn("刷新场地-#{pos}"){'似乎凭空产生了卡片'}
+            player_field.field[pos] = Game_Card.new(@field[pos][:card])
+          end
           player_field.field[pos].position = @field[pos][:position]
         else
           player_field.field[pos] = nil
@@ -409,17 +497,51 @@ class Action
     end
   end
   class EffectActivate < Move
-    def initialize(from_player, from_pos, card, target_pos = nil, target_player=nil)
+    def initialize(from_player, from_pos, card)
       if (0..10).include?(from_pos)
         position = :"face-up"
       else
         position = nil
       end
       super(from_player, from_pos, to_pos, card, nil, position)
+    end
+  end
+  class ActivateAsk < Action
+    def initialize(from_player)
+      super(from_player)
+    end
+  end
+  class ActivateAnswer < Action
+    def initialize(from_player, activate)
+      super(from_player)
+      @activate = activate
+    end
+  end
+  class Target < Action
+    def initialize(from_player, from_pos, card, target_player ,target_pos, target_card)
+      super(from_player)
+      @from_pos = from_pos
+      @card = card
+      @target_pos = target_player
       @target_pos = target_pos
-      @target_player = target_player
+      @target_card = target_card
     end
+    def run
+      card = if @card.is_a? Game_Card
+        @card
+      else
+        if player_field.field[@from_pos]
+          player_field.field[@from_pos].card = @card
+          player_field.field[@from_pos]
+        else
+          $log.warn('攻击宣言'){'似乎凭空产生了卡片' + self.inspect}
+          player_field[@from_pos] = Card.new(@card)
+        end
+      end
+      $log.info('攻击宣言'){self.inspect}
     end
+  end
+  
   class ViewDeck < Action;  end
   class LP < Action
     attr_accessor :operator, :value
@@ -439,13 +561,94 @@ class Action
       end
     end
   end
+  class Attack < Action
+    def initialize(from_player, from_pos, to_pos=nil, card)
+      super(from_player)
+      @from_pos = from_pos
+      @to_pos = to_pos
+      @card = card
+    end
+    def run
+      card = if @card.is_a? Game_Card
+        @card
+      elsif @from_pos
+        if player_field.field[@from_pos]
+          player_field.field[@from_pos].card = @card
+        else
+          $log.warn('攻击宣言'){'似乎凭空产生了卡片' + self.inspect}
+          player_field.field[@from_pos] = Game_Card.new(@card)
+          player_field.field[@from_pos].position = :attack
+        end
+        player_field.field[@from_pos]
+      else
+        $log.info('直接攻击'){'功能未实现'}
+        @card
+      end
+    end
+  end
+  class Counter < Action
+    def initialize(from_player, from_pos, card, operator, value)
+      super(from_player)
+      @from_pos = from_pos
+      @card = card
+      @operator = operator
+      @value = value
+    end
+    def run
+      card = if @card.is_a? Game_Card
+        @card
+      else
+        if player_field.field[@from_pos]
+          player_field.field[@from_pos].card = @card
+        else
+          $log.warn('指示物操作'){'似乎凭空产生了卡片' + self.inspect}
+          player_field.field[@from_pos] = Game_Card.new(@card)
+          player_field.field[@from_pos].position = :attack
+        end
+        player_field.field[@from_pos]
+      end
+      case @operator
+      when :become
+        card.counters = @value
+      else
+        $log.warn('指示物操作'){'become以外的未实现' + self.inspect}
+      end
+    end
+  end
+  class Add < Action
+    def initialize(from_player, card)
+      super(from_player)
+      @card = card
+    end
+    def run
+      if @card.extra?
+        player_field.extra << Game_Card.new(@card)
+      else
+        player_field.hand << Game_Card.new(@card)
+      end
+    end
+  end
+  class Destroy < Action
+    def initialize(from_player, from_pos, card)
+      super(from_player)
+      @from_pos = from_pos
+      @card = card
+    end
+    def run
+      if @from_pos <= 10
+        player_field.field[@from_pos] = nil
+      else
+        player_field.hand.delete_at(@from_pos - 11)
+      end
+    end
+  end
   class Unknown < Action
     def initialize(str)
       @str = str
-      $log.info  'unkonwn action ' + str
+      $log.warn('unkonwn action') { str }
     end
     def run
-      $log.info  'unkonwn action run ' + @str
+      $log.warn('unkonwn action run'){ @str }
     end
   end
   def self.reset

lib/card.rb

@@ -111,22 +111,22 @@ class Card
       @all.clear #清空缓存
     end
   end
-attr_accessor :id
-attr_accessor :number
-attr_accessor :name
-attr_accessor :card_type
-attr_accessor :monster_type
-attr_accessor :atk
-attr_accessor :def
-attr_accessor :attribute
-attr_accessor :type
-attr_accessor :level
-attr_accessor :lore
-attr_accessor :status
-attr_accessor :stats
-attr_accessor :archettypes
-attr_accessor :mediums
-attr_accessor :tokens
+  attr_accessor :id
+  attr_accessor :number
+  attr_accessor :name
+  attr_accessor :card_type
+  attr_accessor :monster_type
+  attr_accessor :atk
+  attr_accessor :def
+  attr_accessor :attribute
+  attr_accessor :type
+  attr_accessor :level
+  attr_accessor :lore
+  attr_accessor :status
+  attr_accessor :stats
+  attr_accessor :archettypes
+  attr_accessor :mediums
+  attr_accessor :tokens
 
   def initialize(hash)
     @id = hash['id'].to_i
@@ -145,17 +145,27 @@ attr_accessor :tokens
     @archettypes = hash['archettypes'].split("\t").collect{|archettype|stat.to_sym}
     @mediums = hash['mediums'].split("\t").collect{|medium|medium.to_sym}
     @tokens = hash['tokens'] && hash['tokens'].split("\t").collect{|token|token.to_i}
+    @token = hash['token']
     
     Card.cache[@id] = self
+    
+  end
+  def create_image
+    @image ||= Surface.load("graphics/field/card.jpg").display_format
   end
   def image
-    @image ||= Surface.load "#{PicPath}/#{@id-1}.jpg" rescue Surface.load "graphics/field/card.jpg"
+    @image ||= Surface.load("#{PicPath}/#{@id-1}.jpg").display_format rescue create_image
   end
   def image_small
     @image_small ||= image.transform_surface(0xFF000000,0,54.0/image.w, 81.0/image.h,Surface::TRANSFORM_SAFE)
   end
   def image_horizontal
-    @image_horizontal ||= image_small.transform_surface(0xFF000000,90,1,1,Surface::TRANSFORM_SAFE)
+    if @image_horizontal.nil?
+      image_horizontal = image_small.transform_surface(0xFF000000,90,1,1,Surface::TRANSFORM_SAFE)
+      @image_horizontal = image_horizontal.copy_rect(1, 1, 81, 54) #SDL的bug，会多出1像素的黑边
+      image_horizontal.destroy
+    end
+    @image_horizontal
   end
   def unknown?
     @id == 1
@@ -169,6 +179,12 @@ attr_accessor :tokens
   def spell?
     [:通常魔法, :速攻魔法, :装备魔法, :场地魔法, :仪式魔法, :永续魔法].include? card_type 
   end
+  def extra?
+    [:融合怪兽, :同调怪兽, :超量怪兽].include? card_type 
+  end
+  def token?
+    @token
+  end
   def inspect
     "[#{card_type}][#{name}]"
   end

lib/game_card.rb

 #encoding: UTF-8
 class Game_Card
-  attr_accessor :card, :position #attack|defense|set,
-  attr_accessor :atk, :def
+  attr_accessor :card, :position, :counters
+  attr_writer :atk, :def
   @@count = 0
   def initialize(card=nil)
     @@count += 1
@@ -13,16 +13,19 @@ class Game_Card
     @card.atk.to_i #把"?"转为0
   end
   def def
-    @card.atk.to_i #把"?"转为0
+    @card.def.to_i #把"?"转为0
   end
   def reset(reset_position = true)
     @position = :set if reset_position
     @atk = @card.atk
     @def = @card.def
+    @counters = 0
   end
   def card=(card)
+    return if @card == card
     @card = card  
-    reset(false)
+    @atk = @card.atk
+    @def = @card.def
   end
   def known?
     @card != Card::Unknown

lib/iduel/action.rb

 #encoding: UTF-8
 #这个文件iduel和nbx相同，编辑时推荐使用软/硬链接来保持一致
 class Action
-  CardFilter = /((?:<)?(?:\[.*?\])?\[(?:.*?)\].*?(?:>)?|一张怪兽卡|一张魔\/陷卡|\?\?)/
+  CardFilter = /((?:<)?(?:\[.*?\])?\[(?:.*?)\].*?(?:>)?|一张怪兽卡|一张魔\/陷卡|一张卡|\?\?)/
   PosFilter = /((?:手卡|手牌|场上|魔陷区|怪兽区|墓地|额外牌堆|除外区|卡组|卡组顶端|\(\d+\)){1,2})/
   PositionFilter = /(表攻|表守|里守|攻击表示|防守表示|里侧表示|背面守备表示)/
   PhaseFilter = /(抽卡`阶段|准备`阶段|主`阶段1|战斗`阶段|主`阶段2|结束`阶段)/
-  CountersFilter = /\((\d+)\)/
-  FieldFilter = /(?:LP:(\d+)\n手卡(?:数)?:(\d+)\n卡组:(\d+)\n墓地:(\d+)\n除外:(\d+)\n前场:\n     <(?:#{CountersFilter}?#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}?#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}?#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}?#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}?#{PositionFilter}\|#{CardFilter})?>\n后场:<#{CardFilter}?><#{CardFilter}?><#{CardFilter}?><#{CardFilter}?><#{CardFilter}?>\n场地\|<(?:无|#{CardFilter})>\n(?:◎|●)→＼＼)/
+  CountersFilter = /(?:\()?(\d+)?(?:\))?/
+  FieldFilter = /(?:LP:(\d+)\n手卡(?:数)?:(\d+)\n卡组:(\d+)\n墓地:(\d+)\n除外:(\d+)\n前场:\n     <(?:#{CountersFilter}#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}#{PositionFilter}\|#{CardFilter})?>\n     <(?:#{CountersFilter}#{PositionFilter}\|#{CardFilter})?>\n后场:<(?:#{CountersFilter}#{CardFilter})?><(?:#{CountersFilter}#{CardFilter})?><(?:#{CountersFilter}#{CardFilter})?><(?:#{CountersFilter}#{CardFilter})?><(?:#{CountersFilter}#{CardFilter})?>\n场地\|<(?:无|#{CountersFilter}#{CardFilter})>\n(?:◎|●)→＼＼)/
   def self.parse_pos(pos)
     if index = pos.index("(")
       index += 1
-      pos[index, pos.index(")")-index].to_i
+      result = pos[index, pos.index(")")-index].to_i
+      result += 10 if pos["手卡"]
+      result
     else
       case pos
       when "手卡", "手牌"
@@ -47,25 +49,25 @@ class Action
       [card["表守"] ? :defense : card["里守"] ? :set : :attack, parse_card(card)]
     end
   end
-  def self.parse_field(arr)
-    #LP, 手卡, 卡组，墓地，除外，6表示形式，6卡，7表示形式，7卡，8表示形式，8卡，9表示形式，9卡，10表示形式，10卡，1,2,3,4,5,0
+  def self.parse_field(matched)
+    #LP, 手卡, 卡组, 墓地, 除外, 6指示物, 6表示形式, 6卡, 7指示物, 7表示形式, 7卡, 8指示物, 8表示形式, 8卡, 9指示物, 9表示形式, 9卡, 10指示物, 10表示形式, 10卡, 1指示物, 1卡, 2指示物, 2卡, 3指示物, 3卡, 4指示物, 4卡, 5指示物, 5卡, 0指示物, 0卡
     {
-      :lp => arr[0].to_i,
-      :hand => arr[1].to_i,
-      :deck => arr[2].to_i,
-      :graveyard => arr[3].to_i,
-      :removed => arr[4].to_i,
-      6 => arr[7] && {:counters => arr[5].to_i, :position => parse_position(arr[6]), :card => parse_card(arr[7])},
-      7 => arr[10] && {:counters => arr[8].to_i, :position => parse_position(arr[9]), :card => parse_card(arr[10])},
-      8 => arr[13] && {:counters => arr[11].to_i, :position => parse_position(arr[12]), :card => parse_card(arr[13])},
-      9 => arr[16] && {:counters => arr[14].to_i, :position => parse_position(arr[15]), :card => parse_card(arr[16])},
-      10 => arr[19] && {:counters => arr[17].to_i, :position => parse_position(arr[18]), :card => parse_card(arr[19])},
-      1 => arr[20] && {:position => arr[20] == "??" ? :set : :attack, :card => parse_card(arr[20])},
-      2 => arr[21] && {:position => arr[21] == "??" ? :set : :attack, :card => parse_card(arr[21])},
-      3 => arr[22] && {:position => arr[22] == "??" ? :set : :attack, :card => parse_card(arr[22])},
-      4 => arr[23] && {:position => arr[23] == "??" ? :set : :attack, :card => parse_card(arr[23])},
-      5 => arr[24] && {:position => arr[24] == "??" ? :set : :attack, :card => parse_card(arr[24])},
-      0 => arr[25] && {:position => arr[25] == "??" ? :set : :attack, :card => parse_card(arr[25])}
+      :lp  => matched[0].to_i,
+      :hand => matched[1].to_i,
+      :deck => matched[2].to_i,
+      :graveyard => matched[3].to_i,
+      :removed => matched[4].to_i,
+      6 => matched[7]  && {:counters => parse_counters(matched[5]),  :position => parse_position(matched[6]),  :card => parse_card(matched[7])},
+      7 => matched[10] && {:counters => parse_counters(matched[8]),  :position => parse_position(matched[9]),  :card => parse_card(matched[10])},
+      8 => matched[13] && {:counters => parse_counters(matched[11]), :position => parse_position(matched[12]), :card => parse_card(matched[13])},
+      9 => matched[16] && {:counters => parse_counters(matched[14]), :position => parse_position(matched[15]), :card => parse_card(matched[16])},
+      10=> matched[19] && {:counters => parse_counters(matched[17]), :position => parse_position(matched[18]), :card => parse_card(matched[19])},
+      1 => matched[21] && {:counters => parse_counters(matched[20]), :position => matched[21] == "??" ? :set : :attack, :card => parse_card(matched[21])},
+      2 => matched[23] && {:counters => parse_counters(matched[22]), :position => matched[23] == "??" ? :set : :attack, :card => parse_card(matched[23])},
+      3 => matched[25] && {:counters => parse_counters(matched[24]), :position => matched[25] == "??" ? :set : :attack, :card => parse_card(matched[25])},
+      4 => matched[27] && {:counters => parse_counters(matched[26]), :position => matched[27] == "??" ? :set : :attack, :card => parse_card(matched[27])},
+      5 => matched[29] && {:counters => parse_counters(matched[28]), :position => matched[29] == "??" ? :set : :attack, :card => parse_card(matched[29])},
+      0 => matched[31] && {:counters => parse_counters(matched[30]), :position => matched[31] == "??" ? :set : :attack, :card => parse_card(matched[31])}
     }
   end
   def self.parse_position(position)
@@ -148,8 +150,6 @@ class Action
       "里守"
     end
   end
-
-
   def self.escape_phase(phase)
     case phase
     when :DP
@@ -166,6 +166,9 @@ class Action
       "结束`阶段"
     end
   end
+  def self.parse_counters(counters)
+    counters.to_i
+  end
   def self.parse(str)
     from_player = nil
     case str
@@ -208,6 +211,12 @@ class Action
           Shuffle.new from_player
         when "查看卡组"
           ViewDeck.new from_player
+        when "要连锁吗？"
+          ActivateAsk.new from_player
+        when "我要连锁！"
+          ActivateAnswer.new from_player, true
+        when "请继续吧~"
+          ActivateAnswer.new from_player, false
         when "将顶牌放回卡组底部"
           ReturnToDeckBottom.new(from_player, :deck)
         when /抽取\((\d+)\)张卡/
@@ -258,15 +267,59 @@ class Action
           EffectActivate.new(from_player, parse_pos($1), parse_card($2))
         when /#{PosFilter}#{CardFilter}(?:变|改)为#{PositionFilter}/
           ChangePosition.new(from_player, parse_pos($1), parse_card($2), parse_position($3))
+        when /#{PosFilter}#{CardFilter}转移控制权/
+          Control.new(from_player, parse_pos($1), parse_card($2))
         when /#{PosFilter}#{CardFilter}打开/
           Flip.new(from_player, parse_pos($1), parse_card($2))
-        when /己方场上所有怪兽卡\|(~#{CardFilter})*~全部送往墓地/
+        when /#{PosFilter}#{CardFilter}反转/
+          FlipSummon.new(from_player, parse_pos($1), parse_card($2))
+        when /#{PosFilter}#{CardFilter}向(左|右)移动/
+          from_pos = parse_pos($1)
+          to_pos = $3 == '左' ? from_pos - 1 : from_pos + 1
+          Move.new(from_player, from_pos, to_pos, parse_card($2))
+        when /己方(场上所有怪兽卡\||场上所有魔\/陷卡\||所有手卡\||墓地\|,,,,,\|\*:\d+张:\*)(?:~#{CardFilter})*~全部(放回卡组顶端|送往墓地|除外|加入手卡)/
+          from_pos = case $1
+          when "场上所有怪兽卡|"
+            :monsters
+          when "场上所有魔\/陷卡|"
+            :spellsandtraps
+          when "所有手卡|"
+            :hand
+          else
+            if $1["墓地"]
+              :graveyard
+            end
+          end
+          to_pos = case $3
+          when "放回卡组顶端"
+            :deck
+          when "送往墓地"
+            :graveyard
+          when "除外"
+            :removed
+          when "加入手卡"
+            :hand
+          end
           cards = $&.scan(CardFilter).collect{|matched|parse_card matched.first}
-          AllMonstersSendToGraveyard.new(from_player, cards)
+          MultiMove.new(from_player, from_pos, to_pos, cards)
+        when /己方#{PosFilter}#{CardFilter}送入对手墓地/
+          SendToOpponentGraveyard.new(from_player, parse_pos($1), parse_card($2))
+        when /#{PosFilter}#{CardFilter}选择(我方)?-#{PosFilter}- #{CardFilter}为效果对象/
+          Target.new(from_player, parse_pos($1), parse_card($2), $3 ? true : false, parse_pos($4), parse_card($5))
         when /#{PhaseFilter}/
           ChangePhase.new(from_player, parse_phase($1))
         when /LP(损失|回复|变成)<(-?\d+)>/
           LP.new(from_player, case $1 when "损失"; :lose; when "回复"; :increase; when "变成"; :become end, $2.to_i)
+        when /#{PosFilter}#{CardFilter}攻击-#{PosFilter}- #{CardFilter}/
+          Attack.new(from_player, parse_pos($1), parse_pos($3), parse_card($2))
+        when /#{CardFilter}(?:直接)?攻击/
+          Attack.new(from_player, nil, nil, parse_card($1))
+        when /(?:清空)?#{PosFilter}#{CardFilter}的指示物(?:加一|减一)?,现为#{CountersFilter}/
+          Counter.new(from_player, parse_pos($1), parse_card($2), :become, parse_counters($3))
+        when /添加一张手牌#{CardFilter}/
+          Add.new(from_player, parse_card($1))
+        when /将#{PosFilter}#{CardFilter}撕掉!/
+          Destroy.new(from_player, parse_pos($1), parse_card($2))
         else
           Unknown.new str
         end

lib/iduel/replay.rb

 #encoding: UTF-8
 class Replay
-  Delimiter = /^.+?\(\d+\)(?:\(\d+:\d+:\d+\))?(?::   |：)\n ?/
-  Player_Filter = /^(.+?)\((\d+)\)(?:\(\d+:\d+:\d+\))?(?::   |：)\n ?\[\d+\] ◎→/
-  Opponent_Filter =/^(.+?)\((\d+)\)(?:\(\d+:\d+:\d+\))?(?::   |：)\n ?\[\d+\] ●→/
+  User_Filter = /(.+?)\((\d+)\)(?:\(\d+:\d+:\d+\))?(?::|：) */
+  Delimiter = /^#{User_Filter}\n ?/
+  Player_Filter = /#{Delimiter}\[\d+\] ◎→/
+  Opponent_Filter =/#{Delimiter}\[\d+\] ●→/
+  HTML_Player_Filter = /<font color=blue><strong>#{User_Filter}<\/strong>/
+  HTML_Opponent_Filter = /<font color=red><strong>#{User_Filter}<\/strong>/
   attr_accessor :room, :player1, :player2, :actions
   def add(action)
     #    user = action.from_player ? $game.player1 : $game.player2
@@ -13,26 +16,55 @@ class Replay
     file = open(filename)
     file.set_encoding "GBK", "UTF-8", :invalid => :replace, :undef => :replace
     result = self.new(file)
-    contents = file.read
-    if contents =~ Player_Filter
-      result.player1 = User.new($2.to_i, $1)
+    contents = file.read.strip
+    if contents[0,7] == "<table>"
+      result.player1 = User.new($2.to_i, $1) if contents =~ HTML_Player_Filter
+      result.player2 = User.new($2.to_i, $1) if contents =~ HTML_Opponent_Filter
+      from_players =  contents.scan(Regexp.union(HTML_Player_Filter, HTML_Opponent_Filter)).collect{|matched|matched[0] ? true : false} #匹配player成功matched前两位有值，opponent成功后两位有值，["尸体", "100015", nil, nil], il, nil], [nil, nil, "游戏的徒弟", "288436"]
+      #去除HTML标签
+      contents.gsub!(/<.*?>/,'')
+      #处理HTML转义字符
+      require 'cgi'
+      contents = CGI.unescape_html(contents)
     else
-      result.player1 = User.new(0, "我")
-    end
-    if contents =~ Opponent_Filter
-      result.player2 = User.new($2.to_i, $1)
+      result.player1 = User.new($2.to_i, $1) if contents =~ Player_Filter
+      result.player2 = User.new($2.to_i, $1) if contents =~ Opponent_Filter
+      from_players = contents.scan(Delimiter).collect do |matched|
+        id = matched[1].to_i
+        name = matched[0]
+        if result.player1 and result.player1.id == id
+          true
+        elsif result.player2 and result.player2.id == id
+          false
+        elsif result.player1.nil?
+          result.player1 = User.new(id, name)
+          true
+        elsif result.player2.nil?
+          result.player2 = User.new(id, name)
+          false
         else
-      result.player2 = User.new(1, "对手")
+          #无法匹配玩家，一般是观战消息..
+          false
+        end
+      end
     end
-    result.actions = contents.split(Delimiter).collect do |action_str|
-      action_str.strip!
-      next if action_str.empty?
+    result.player1 ||= User.new(0, "我")
+    result.player2 ||= User.new(1, "对手")
+    lines = contents.split(Delimiter)
+    lines.shift #split后，在第一个操作之前会多出一个空白元素
+    lines = lines.each_slice(lines.size/from_players.size).collect{|a|a.last.strip}
+    from_players = from_players.to_enum
+    result.actions = lines.collect do |action_str|
       action = Action.parse action_str
+      action.from_player = from_players.next
       Game_Event::Action.new(action, action_str)
-    end.compact
+    end
     $game.room = result.room = Room.new(0, "Replay", result.player1, result.player2)
     result
   end
+  def self.html_decode(text)
+    text.gsub(Regexp.new(HTML_Replacement.keys.collect{|key|Regexp.escape key}.join('|')), HTML_Replacement)
+  end
   def get
     @actions.shift
   end

lib/scene_duel.rb

@@ -39,13 +39,16 @@ class Scene_Duel < Scene
     @fieldback_window = Window_FieldBack.new(130,174)
     @cardinfo_window = Window_CardInfo.new(715, 0)
     
-    @player_lp_window = Window_LP.new(0,0, @room.player1, true)
-    @opponent_lp_window = Window_LP.new(360,0, @room.player2, false)
     @player_field_window = Window_Field.new(4, 398, $game.player_field, true)
     @opponent_field_window = Window_Field.new(4, 60, $game.opponent_field, false)
+    @player_lp_window = Window_LP.new(0,0, @room.player1, true)
+    @opponent_lp_window = Window_LP.new(360,0, @room.player2, false)
+
     
     @chat_window = Window_RoomChat.new(@cardinfo_window.x, @cardinfo_window.height, 1024-@cardinfo_window.x, 768-@cardinfo_window.height)
     create_action_window
+    Card.find(:方程式同调士)
+    Card.find(:异星的最终战士)
     
     super
   end
@@ -151,11 +154,11 @@ class Scene_Duel < Scene
     super
   end
   def refresh
+    @fieldback_window.card = $game.player_field.field[0] || $game.opponent_field.field[0]
     @player_field_window.refresh
     @opponent_field_window.refresh
     @phases_window.player = $game.turn_player
     @phases_window.phase = $game.phase
-      @fieldback_window.card = $game.player_field.field[0] || $game.opponent_field.field[0]
     @player_lp_window.lp = $game.player_field.lp
     @opponent_lp_window.lp = $game.opponent_field.lp
   end

lib/window_field.rb

@@ -89,18 +89,27 @@ class Window_Field < Window
     if (6..10).include?(index) and @cards[index].position != :attack
       @contents.put(@cards[index].image_horizontal, x, y)
       @contents.put(@border_horizontal, x-1, y-1) if status == 1 
+      x += (Card_Size[1]-Card_Size[0])/2
+      y -= (Card_Size[1]-Card_Size[0])/2
     else
       @contents.put(@cards[index].image_small, x, y)
       @contents.put(@border, x-1, y-1) if status == 1
     end
     if (6..10).include?(index) and @cards[index].position != :set
       spacing, height = @font.text_size('/')
-      x += (Card_Size[0] - spacing) / 2
-      y += Card_Size[1] - height
-      @font.draw_blended_utf8(@contents, '/' , x, y, 0xFF, 0xFF, 0xFF)
-      @font.draw_blended_utf8(@contents, @cards[index].atk.to_s , x - @font.text_size(@cards[index].atk.to_s)[0], y, 0xFF, 0xFF, 0xFF)
-      @font.draw_blended_utf8(@contents, @cards[index].def.to_s , x + spacing, y, 0xFF, 0xFF, 0xFF)
+      atkdef_x = x + (Card_Size[0] - spacing) / 2
+      atkdef_y = y + Card_Size[1] - height
+      @font.draw_blended_utf8(@contents, '/' , atkdef_x, atkdef_y, 0xFF, 0xFF, 0xFF)
+      @font.draw_blended_utf8(@contents, @cards[index].atk.to_s , atkdef_x - @font.text_size(@cards[index].atk.to_s)[0], atkdef_y, 0xFF, 0xFF, 0xFF)
+      @font.draw_blended_utf8(@contents, @cards[index].def.to_s , atkdef_x + spacing, atkdef_y, 0xFF, 0xFF, 0xFF)
+    end
+    if @cards[index].counters != 0
+      height ||= @font.text_size('/')[1] #不太规范，凑合能用
+      counters_x = x
+      counters_y = y + Card_Size[1] - height*2
+      @font.draw_blended_utf8(@contents, @cards[index].counters.to_s , counters_x, counters_y, 0xFF, 0xFF, 0xFF)
     end
+    
   end
   def item_rect(index)
     @items[index]