################################################################################
# "Triple Triad" mini-game
# By Unknown
################################################################################
class TriadCard
  attr_reader :north, :east, :south, :west, :type, :species

  def baseStatToValue(stat)
    return 10 if stat>=200
    return 9 if stat>=170
    return 8 if stat>=150
    return 7 if stat>=120
    return 6 if stat>=100
    return 5 if stat>=70
    return 4 if stat>=50
    return 3 if stat>=20
    return 2 if stat>=10
    return 1
  end

  def attack(panel)
    return [@west,@east,@north,@south][panel]
  end

  def defense(panel)
    return [@east,@west,@south,@north][panel]
  end

  def price
    maxvalue=[@west,@east,@north,@south].max
    return [
       100,100,100,100,500,500,1000,1500,1500,1500,2000
    ][maxvalue]
  end

  def bonus(opponent)
    atype=@type
    otype=opponent.type
    mod=PBTypes.getEffectiveness(atype,otype)
    return -2 if mod==0
    return -1 if mod==1
    return 1 if mod==4
    return 0
  end

  def initialize(species)
    dexdata=pbOpenDexData
    @species=species
    pbDexDataOffset(dexdata,species,10)
    dexdata.fgetb # HP
    @west=baseStatToValue(dexdata.fgetb) # Attack
    @east=baseStatToValue(dexdata.fgetb) # Defense
    dexdata.fgetb # Speed
    @north=baseStatToValue(dexdata.fgetb) # Special Attack
    @south=baseStatToValue(dexdata.fgetb) # Special Defense
    pbDexDataOffset(dexdata,species,8)
    @type=dexdata.fgetb # Type
    if isConst?(@type,PBTypes,:NORMAL)
      type2=dexdata.fgetb
      @type=type2 if !isConst?(type2,PBTypes,:NORMAL)
    end
    dexdata.close
  end

  def self.createBack(type=-1,noback=false)
    bitmap=BitmapWrapper.new(84,84)
    if !noback
      bitmap.fill_rect(0,0,84,84,Color.new(210,67,40))
      bitmap.fill_rect(2,2,80,80,Color.new(232,88,56))
    end
    if type>=0
      typebitmap=AnimatedBitmap.new(_INTL("Graphics/Pictures/types"))
      typerect=Rect.new(0,type*28,64,28)
      bitmap.blt(10,28,typebitmap.bitmap,typerect,192)
      typebitmap.dispose
    end
    return bitmap
  end

  def createBitmap(owner)
    if owner==0
      return TriadCard.createBack
    end
    bitmap=BitmapWrapper.new(84,84)
    iconfile=pbCheckPokemonIconFiles([@species,0,false,0,false])
    typebitmap=AnimatedBitmap.new(_INTL("Graphics/Pictures/types"))
    icon=AnimatedBitmap.new(iconfile)
    typerect=Rect.new(0,@type*28,64,28)
    if owner==2
      # opponent
      bitmap.fill_rect(0,0,84,84,Color.new(210,67,40))
      bitmap.fill_rect(2,2,80,80,Color.new(232,88,56))
    else
      # player
      bitmap.fill_rect(0,0,84,84,Color.new(58,58,80))
      bitmap.fill_rect(2,2,80,80,Color.new(80,80,104))
    end
    bitmap.blt(10,28,typebitmap.bitmap,typerect,192)
    bitmap.blt(10,2,icon.bitmap,Rect.new(0,0,64,64))
    pbSetSmallFont(bitmap)
    pbDrawTextPositions(bitmap,[
       ["0123456789A"[@north,1],84/2,2,2,Color.new(248,248,248),Color.new(96,96,96)],
       ["0123456789A"[@south,1],84/2,82-25,2,Color.new(248,248,248),Color.new(96,96,96)],
       ["0123456789A"[@west,1],2,(84/2)-12,0,Color.new(248,248,248),Color.new(96,96,96)],
       ["0123456789A"[@east,1],82,(84/2)-12,1,Color.new(248,248,248),Color.new(96,96,96)]
    ])
    icon.dispose
    typebitmap.dispose
    return bitmap
  end
end



class TriadSquare
  attr_accessor :owner, :card, :type

  def initialize
    @owner=0
    @card=nil
    @type=-1
  end

  def attack(panel)
    return @card.attack(panel)
  end

  def bonus(square)
    return @card.bonus(square.card)
  end

  def defense(panel)
    return @card.defense(panel)
  end
end



# Scene class for handling appearance of the screen
class TriadScene
# Update the scene here, this is called once each frame
  def pbUpdate
    pbUpdateSpriteHash(@sprites)
  end

# End the scene here
  def pbEndScene
    pbBGMFade(1.0)
    # Fade out all sprites
    pbFadeOutAndHide(@sprites) { pbUpdate }
    # Dispose all sprites
    pbDisposeSpriteHash(@sprites)
    @bitmaps.each{|bm| bm.dispose }
    # Dispose the viewport
    @viewport.dispose
  end

  def pbStartScene(battle)
    # Create sprite hash
    @sprites={}
    @bitmaps=[]
    @battle=battle
    # Allocate viewport
    @viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
    @viewport.z=99999
    addBackgroundPlane(@sprites,"background","triadbg",@viewport)
    @sprites["helpwindow"]=Window_AdvancedTextPokemon.newWithSize("",
       0,Graphics.height-64,Graphics.width,64,@viewport)
    for i in 0...@battle.width*@battle.height
      @sprites["sprite#{i}"]=SpriteWrapper.new(@viewport)
      cardX=Graphics.width/2 - 126 + (i%3)*84
      cardY=46 + (i/3)*84
      @sprites["sprite#{i}"].z=2
      @sprites["sprite#{i}"].x=cardX
      @sprites["sprite#{i}"].y=cardY
      bm=TriadCard.createBack(@battle.board[i].type,true)
      @bitmaps.push(bm)
      @sprites["sprite#{i}"].bitmap=bm
    end
    @cardBitmaps=[]
    @opponentCardBitmaps=[]
    @cardIndexes=[]
    @opponentCardIndexes=[]
    @boardSprites=[]
    @boardCards=[]
    for i in 0...@battle.maxCards
      @sprites["player#{i}"]=Sprite.new(@viewport)
      @sprites["player#{i}"].z=2
      @sprites["player#{i}"].x=Graphics.width-96
      @sprites["player#{i}"].y=40+16*i
      @cardIndexes.push(i)
    end
    @sprites["overlay"]=Sprite.new(@viewport)
    @sprites["overlay"].bitmap=BitmapWrapper.new(Graphics.width,Graphics.height)
    pbSetSystemFont(@sprites["overlay"].bitmap)
    pbDrawTextPositions(@sprites["overlay"].bitmap,[
       [@battle.opponentName,54,0,2,Color.new(248,248,248),Color.new(96,96,96)],
       [@battle.playerName,Graphics.width-54,0,2,Color.new(248,248,248),Color.new(96,96,96)]
    ])
    @sprites["score"]=Sprite.new(@viewport)
    @sprites["score"].bitmap=BitmapWrapper.new(Graphics.width,Graphics.height)
    pbSetSystemFont(@sprites["score"].bitmap)
    pbBGMPlay("Polemon")
    # Fade in all sprites
    pbFadeInAndShow(@sprites) { pbUpdate }
  end

  def pbUpdateScore
    bitmap=@sprites["score"].bitmap
    bitmap.clear
    playerscore=0
    oppscore=0
    for i in 0...@battle.width*@battle.height
      if @boardSprites[i]
        playerscore+=1 if @battle.board[i].owner==1
        oppscore+=1 if @battle.board[i].owner==2
      end
    end
    if @battle.countUnplayedCards
      playerscore+=@cardIndexes.length
      oppscore+=@opponentCardIndexes.length
    end
    pbDrawTextPositions(bitmap,[
       [_INTL("{1}-{2}",oppscore,playerscore),Graphics.width/2,0,2,Color.new(248,248,248),Color.new(96,96,96)]
    ])
  end

  def pbNotifyCards(playerCards,opponentCards)
    @playerCards=playerCards
    @opponentCards=opponentCards
  end

  def pbDisplay(text)
    @sprites["helpwindow"].text=text
    60.times do
      Graphics.update
      Input.update
      pbUpdate
    end
  end

  def pbDisplayPaused(text)
    @sprites["helpwindow"].letterbyletter=true
    @sprites["helpwindow"].text=text+"\1"
    loop do
      Graphics.update
      Input.update
      pbUpdate
      if Input.trigger?(Input::C)
        if @sprites["helpwindow"].busy?
          pbPlayDecisionSE() if @sprites["helpwindow"].pausing?
          @sprites["helpwindow"].resume
        else
          break
        end
      end
    end
    @sprites["helpwindow"].letterbyletter=false
    @sprites["helpwindow"].text=""
  end

  def pbShowPlayerCards(cards)
    for i in 0...@battle.maxCards
      @sprites["player#{i}"]=Sprite.new(@viewport)
      @sprites["player#{i}"].z=2
      @sprites["player#{i}"].x=Graphics.width-96
      @sprites["player#{i}"].y=34+48*i
      @sprites["player#{i}"].bitmap=TriadCard.new(cards[i]).createBitmap(1)
      @cardBitmaps.push(@sprites["player#{i}"].bitmap)
    end
  end

  def pbShowOpponentCards(cards)
    for i in 0...@battle.maxCards
      @sprites["opponent#{i}"]=Sprite.new(@viewport)
      @sprites["opponent#{i}"].z=2
      @sprites["opponent#{i}"].x=12
      @sprites["opponent#{i}"].y=34+48*i
      @sprites["opponent#{i}"].bitmap=@battle.openHand ? TriadCard.new(cards[i]).createBitmap(2) : TriadCard.createBack(-1)
      @opponentCardBitmaps.push(@sprites["opponent#{i}"].bitmap)
      @opponentCardIndexes.push(i)
    end
  end

  def pbViewOpponentCards(numCards)
    @sprites["helpwindow"].text=_INTL("Comprueba las cartas del oponente.")
    choice=0
    lastChoice=-1
    loop do
      if lastChoice!=choice
        y=34
        for i in 0...@opponentCardIndexes.length
          @sprites["opponent#{@opponentCardIndexes[i]}"].bitmap=@opponentCardBitmaps[@opponentCardIndexes[i]]
          @sprites["opponent#{@opponentCardIndexes[i]}"].z=(i==choice) ? 4 : 2
          @sprites["opponent#{@opponentCardIndexes[i]}"].x=(i==choice) ? 34 : 12
          @sprites["opponent#{@opponentCardIndexes[i]}"].y=y
          y+=48
        end
        lastChoice=choice
      end
      if choice==-1
        break
      end
      Graphics.update
      Input.update
      pbUpdate
      if Input.repeat?(Input::DOWN)
        pbPlayCursorSE()
        choice+=1
        choice=0 if choice>=numCards
      elsif Input.repeat?(Input::UP)
        pbPlayCursorSE()
        choice-=1
        choice=numCards-1 if choice<0
      elsif Input.trigger?(Input::B)
        pbPlayCancelSE()
        choice=-1
      end
    end
    return choice
  end

  def pbPlayerChooseCard(numCards)
    if @battle.openHand
      @sprites["helpwindow"].text=_INTL("Escoge una carta o comprueba las del oponente con Z.")
    else
      @sprites["helpwindow"].text=_INTL("Escoge una carta.")
    end
    choice=0
    lastChoice=-1
    loop do
      if lastChoice!=choice
        y=34
        for i in 0...@cardIndexes.length
          @sprites["player#{@cardIndexes[i]}"].bitmap=@cardBitmaps[@cardIndexes[i]]
          @sprites["player#{@cardIndexes[i]}"].z=(i==choice) ? 4 : 2
          @sprites["player#{@cardIndexes[i]}"].x=(i==choice) ? Graphics.width-118 : Graphics.width-96
          @sprites["player#{@cardIndexes[i]}"].y=y
          y+=48
        end
        lastChoice=choice
      end
      Graphics.update
      Input.update
      pbUpdate
      if Input.repeat?(Input::DOWN)
        pbPlayCursorSE()
        choice+=1
        choice=0 if choice>=numCards
      elsif Input.repeat?(Input::UP)
        pbPlayCursorSE()
        choice-=1
        choice=numCards-1 if choice<0
      elsif Input.trigger?(Input::C)
        pbPlayDecisionSE()
        break
      elsif Input.trigger?(Input::A) && @battle.openHand
        pbPlayDecisionSE()
        pbViewOpponentCards(numCards)
        @sprites["helpwindow"].text=_INTL("Escoge una carta o comprueba las del oponente con Z.")
        choice=0
        lastChoice=-1
      end
    end
    return choice
  end

  def pbRefresh
    for i in 0...@battle.width*@battle.height
      x=i%@battle.width
      y=i/@battle.width
      if @boardSprites[i]
        owner=@battle.getOwner(x,y)
        @boardSprites[i].bitmap.dispose if @boardSprites[i].bitmap
        @boardSprites[i].bitmap=@boardCards[i].createBitmap(owner)
      end
    end
  end

  def pbEndPlaceCard(position, cardIndex)
    spriteIndex=@cardIndexes[cardIndex]
    boardIndex=position[1]*@battle.width+position[0]
    @boardSprites[boardIndex]=@sprites["player#{spriteIndex}"]
    @boardCards[boardIndex]=TriadCard.new(@playerCards[spriteIndex])
    pbRefresh
    @cardIndexes.delete_at(cardIndex)
    pbUpdateScore
  end

  def pbEndOpponentPlaceCard(position, cardIndex)
    spriteIndex=@opponentCardIndexes[cardIndex]
    boardIndex=position[1]*@battle.width+position[0]
    @boardSprites[boardIndex]=@sprites["opponent#{spriteIndex}"]
    @boardCards[boardIndex]=TriadCard.new(@opponentCards[spriteIndex])
    pbRefresh
    @opponentCardIndexes.delete_at(cardIndex)
    pbUpdateScore
  end

  def pbOpponentPlaceCard(triadCard, position, cardIndex)
    y=34
    for i in 0...@opponentCardIndexes.length
      sprite=@sprites["opponent#{@opponentCardIndexes[i]}"]
      if i!=cardIndex
        sprite.z=2
        sprite.y=y
        sprite.x=12
        y+=48
      else
        @opponentCardBitmaps[@opponentCardIndexes[i]]=triadCard.createBitmap(2)
        sprite.bitmap.dispose if sprite.bitmap
        sprite.bitmap=@opponentCardBitmaps[@opponentCardIndexes[i]]
        sprite.z=2
        sprite.x=Graphics.width/2 - 126 + position[0]*84
        sprite.y=46 + position[1]*84
      end
    end
  end

  def pbPlayerPlaceCard(card, cardIndex)
    @sprites["helpwindow"].text=_INTL("Place the card.")
    choice=0
    boardX=0
    boardY=0
    doRefresh=true
    loop do
      if doRefresh
        y=34
        for i in 0...@cardIndexes.length
          if i!=cardIndex
            @sprites["player#{@cardIndexes[i]}"].z=2
            @sprites["player#{@cardIndexes[i]}"].y=y
            @sprites["player#{@cardIndexes[i]}"].x=Graphics.width-96
            y+=48
          else
            @sprites["player#{@cardIndexes[i]}"].z=4
            @sprites["player#{@cardIndexes[i]}"].x=Graphics.width/2 - 126 + boardX*84
            @sprites["player#{@cardIndexes[i]}"].y=46 + boardY*84
          end
        end
        doRefresh=false
      end
      Graphics.update
      Input.update
      pbUpdate
      if Input.repeat?(Input::DOWN)
        pbPlayCursorSE()
        boardY+=1
        boardY=0 if boardY>=@battle.height
        doRefresh=true
      elsif Input.repeat?(Input::UP)
        pbPlayCursorSE()
        boardY-=1
        boardY=@battle.height-1 if boardY<0
        doRefresh=true
      elsif Input.repeat?(Input::LEFT)
        pbPlayCursorSE()
        boardX-=1
        boardX=@battle.width-1 if boardX<0
        doRefresh=true
      elsif Input.repeat?(Input::RIGHT)
        pbPlayCursorSE()
        boardX+=1
        boardX=0 if boardX>=@battle.width
        doRefresh=true
      elsif Input.trigger?(Input::B)
        return nil
      elsif Input.trigger?(Input::C)
        if @battle.isOccupied?(boardX,boardY)
          pbPlayBuzzerSE()
        else
          pbPlayDecisionSE()
          @sprites["player#{@cardIndexes[cardIndex]}"].z=2
          break
        end
      end
    end
    return [boardX,boardY] 
  end

  def pbChooseTriadCard(cardStorage)
    commands=[]
    chosenCards=[]
    for item in cardStorage
      commands.push(_INTL("{1} x{2}",PBSpecies.getName(item[0]),item[1]))
    end
    command=Window_CommandPokemonEx.newWithSize(commands,0,0,256,Graphics.height-64,@viewport)
    @sprites["helpwindow"].text=_INTL("Escoge {1} cartas para usar en esta partida.",@battle.maxCards)
    preview=Sprite.new(@viewport)
    preview.z=4
    preview.x=276
    preview.y=60
    index=-1
    chosenSprites=[]
    for i in 0...@battle.maxCards
      @sprites["player#{i}"]=Sprite.new(@viewport)
      @sprites["player#{i}"].z=2
      @sprites["player#{i}"].x=Graphics.width-96
      @sprites["player#{i}"].y=34+48*i
    end
    loop do
      Graphics.update
      Input.update
      pbUpdate
      command.update
      if command.index!=index
        preview.bitmap.dispose if preview.bitmap
        if command.index<cardStorage.length
          item=cardStorage[command.index]
          preview.bitmap=TriadCard.new(item[0]).createBitmap(1)
        end
        index=command.index
      end
      if Input.trigger?(Input::B)
        if chosenCards.length>0
          item=chosenCards.pop
          @battle.pbAdd(cardStorage,item)
          commands=[]
          for item in cardStorage
            commands.push(_INTL("{1} x{2}",PBSpecies.getName(item[0]),item[1]))
          end
          command.commands=commands
          index=-1
        else
          pbPlayBuzzerSE()
        end
      elsif Input.trigger?(Input::C)
        if chosenCards.length==@battle.maxCards
          break
        end
        item=cardStorage[command.index]
        if !item || (@battle.pbQuantity(cardStorage,item[0])==0)
          pbPlayBuzzerSE()
        else
          pbPlayDecisionSE()
          sprite=@sprites["player#{chosenCards.length}"]
          sprite.bitmap.dispose if sprite.bitmap
          @cardBitmaps[chosenCards.length]=TriadCard.new(item[0]).createBitmap(1)
          sprite.bitmap=@cardBitmaps[chosenCards.length]
          chosenCards.push(item[0])
          @battle.pbSubtract(cardStorage,item[0])
          commands=[]
          for item in cardStorage
            commands.push(_INTL("{1} x{2}",PBSpecies.getName(item[0]),item[1]))
          end
          command.commands=commands
          command.index=commands.length-1 if command.index>=commands.length
          index=-1
        end
      end
      if Input.trigger?(Input::C) || Input.trigger?(Input::B)
        for i in 0...@battle.maxCards
          @sprites["player#{i}"].visible=(i<chosenCards.length)
        end
        if chosenCards.length==@battle.maxCards
          @sprites["helpwindow"].text=_INTL("{1} han sido escogidas.",@battle.maxCards)
          command.visible=false
          command.active=false
          preview.visible=false
        else
          @sprites["helpwindow"].text=_INTL("Escoge {1} cartas para usar en esta partida.",@battle.maxCards)
          command.visible=true
          command.active=true
          preview.visible=true
        end
      end
    end
    command.dispose
    preview.bitmap.dispose if preview.bitmap
    preview.dispose
    return chosenCards
  end
end



# Screen class for handling game logic
class TriadScreen
  attr_accessor :openHand,:countUnplayedCards
  attr_reader :width,:height

  def initialize(scene)
    @scene=scene
    @width              = 3
    @height             = 3
    @sameWins           = false
    @openHand           = false
    @wrapAround         = false
    @elements           = false
    @randomHand         = false
    @countUnplayedCards = false
    @trade              = 0
  end

  def board
    @board
  end

  def playerName
    @playerName
  end

  def opponentName
    @opponentName
  end

  def maxCards
    numcards=@width*@height
    if numcards%2 == 1
      numcards=numcards/2+1
    else
      numcards=numcards/2
    end
    return numcards
  end

  def isOccupied?(x,y)
    return @board[y*@width+x].owner!=0
  end

  def getOwner(x,y)
    return @board[y*@width+x].owner
  end

  def getPanel(x,y)
    return @board[y*@width+x]
  end

  def pbQuantity(items,item)
    return ItemStorageHelper.pbQuantity(items,$PokemonGlobal.triads.maxSize,item)
  end

  def pbAdd(items,item)
    return ItemStorageHelper.pbStoreItem(items,$PokemonGlobal.triads.maxSize,
       $PokemonGlobal.triads.maxPerSlot,item,1)
  end

  def pbSubtract(items,item)
    return ItemStorageHelper.pbDeleteItem(items,$PokemonGlobal.triads.maxSize,
       item,1)
  end

  def flipBoard(x,y,attackerParam=nil,recurse=false)
    panels=[x-1,y,x+1,y,x,y-1,x,y+1]
    panels[0]=(@wrapAround ? @width-1 : 0) if panels[0]<0 # left
    panels[2]=(@wrapAround ? 0 : @width-1) if panels[2]>@width-1 # right
    panels[5]=(@wrapAround ? @height-1 : 0) if panels[5]<0 # top
    panels[7]=(@wrapAround ? 0 : @height-1) if panels[7]>@height-1 # bottom
    attacker=attackerParam!=nil ? attackerParam : @board[y*@width+x]
    flips=[]
    return nil if attackerParam!=nil && @board[y*@width+x].owner!=0
    return nil if !attacker.card || attacker.owner==0
    for i in 0...4
      defenderX=panels[i*2]
      defenderY=panels[i*2+1]
      defender=@board[defenderY*@width+defenderX]
      next if !defender.card
      if attacker.owner!=defender.owner
        attack=attacker.attack(i)
        defense=defender.defense(i)
        if @elements
          # If attacker's type matches the tile's element, add
          # a bonus of 1 (only for original attacker, not combos)
          attack+=1 if !recurse && attacker.type==attacker.card.type
        else
          # Modifier depends on opponent's Pokémon type:
          # +1 - Super effective
          # -1 - Not very effective
          # -2 - Immune
#         attack+=attacker.bonus(defender)
        end
#       p [attacker.card.north,attacker.card.west,
#          attacker.card.east,attacker.card.south],
#          [defender.card.north,defender.card.west,
#          defender.card.east,defender.card.south],
#          [attack,defense,attacker.bonus(defender)] if attackerParam==nil
        if attack>defense || (attack==defense && @sameWins)
          flips.push([defenderX,defenderY])
          if attackerParam==nil
            defender.owner=attacker.owner
            if @sameWins
              # Combo with the "sameWins" rule
              ret=flipBoard(defenderX,defenderY,nil,true)
              flips.concat(ret) if ret
            end
          else
            if @sameWins
              # Combo with the "sameWins" rule
              ret=flipBoard(defenderX,defenderY,attackerParam,true)
              flips.concat(ret) if ret
            end
          end
        end
      end
    end
    return flips
  end

# If pbStartScreen includes parameters, it should
# pass the parameters to pbStartScene.
  def pbStartScreen(opponentName,minLevel,maxLevel,rules=nil,oppdeck=nil,prize=nil)
    if minLevel<0 || minLevel>9
      raise _INTL("Minimum level must be 0 through 9.")
    end
    if maxLevel<0 || maxLevel>9
      raise _INTL("Maximum level must be 0 through 9.")
    end
    if maxLevel<minLevel
      raise _INTL("Maximum level shouldn't be less than the minimum level.")
    end
    if rules && rules.is_a?(Array) && rules.length>0
      for rule in rules
        @sameWins           = true if rule=="samewins"
        @openHand           = true if rule=="openhand"
        @wrapAround         = true if rule=="wrap"
        @elements           = true if rule=="elements"
        @randomHand         = true if rule=="randomhand"
        @countUnplayedCards = true if rule=="countunplayed"
        @trade              = 1    if rule=="direct"
        @trade              = 2    if rule=="winall"
      end
    end
    @triadCards=[]
    if !$PokemonGlobal
      $PokemonGlobal=PokemonGlobalMetadata.new
    end
    count=0
    for i in 0...$PokemonGlobal.triads.length
      item=$PokemonGlobal.triads[i]
      ItemStorageHelper.pbStoreItem(@triadCards,
         $PokemonGlobal.triads.maxSize,
         $PokemonGlobal.triads.maxPerSlot,
         item[0],item[1]
      )
      count+=item[1] # Add item count to total count
    end
    @board=[]
    @playerName=$Trainer ? $Trainer.name : "Jugador"
    @opponentName=opponentName
    for i in 0...@width*@height
      square=TriadSquare.new
      if @elements
        begin
          square.type=rand(PBTypes.maxValue+1)
        end until !PBTypes.isPseudoType?(square.type)
      end
      @board.push(square)
    end
    @scene.pbStartScene(self) # (param1, param2)
    # Check whether there are enough cards.
    if count<self.maxCards
      @scene.pbDisplayPaused(_INTL("No tienes cartas suficientes."))
      @scene.pbEndScene
      return 0
    end
    # Set the player's cards.
    cards=[]
    if @randomHand   # Determine hand at random
      self.maxCards.times do
        randCard=@triadCards[rand(@triadCards.length)]
        pbSubtract(@triadCards,randCard[0])
        cards.push(randCard[0]) 
      end
      @scene.pbShowPlayerCards(cards)
    else
      cards=@scene.pbChooseTriadCard(@triadCards)
    end
    # Set the opponent's cards.
    if oppdeck && oppdeck.is_a?(Array) && oppdeck.length==self.maxCards # Preset
      opponentCards=[]
      for i in oppdeck
        card=getID(PBSpecies,i)
        if card<=0
          @scene.pbDisplayPaused(_INTL("El oponente tiene una carta ilegal, \"{1}\".",i))
          @scene.pbEndScene
          return 0
        end
        opponentCards.push(card)
      end
    else
      candidates=[]
      while candidates.length<200
        card=0
        loop do
          card=rand(PBSpecies.maxValue)+1
          cname=getConstantName(PBSpecies,card) rescue nil
          break if cname
        end
        triad=TriadCard.new(card)
        total=triad.north+triad.south+triad.east+triad.west
        # Add random species and its total point count
        candidates.push([card,total])
        if candidates.length<200 && $Trainer && $Trainer.owned[card]
          # Add again if Trainer owns the species
          candidates.push([card,total])
        end
      end
      # sort by total point count
      candidates.sort!{|a,b| a[1]<=>b[1] }
      minIndex=minLevel*20
      maxIndex=maxLevel*20+20
      opponentCards=[]
      for i in 0...self.maxCards
        # generate random card based on level
        index=minIndex+rand(maxIndex-minIndex)
        opponentCards.push(candidates[index][0])
      end
    end
    originalCards=cards.clone
    originalOpponentCards=opponentCards.clone
    @scene.pbNotifyCards(cards.clone,opponentCards.clone)
    @scene.pbShowOpponentCards(opponentCards)
    @scene.pbDisplay(_INTL("Escogiendo quién va primero..."))
    @scene.pbUpdateScore
    playerTurn=false
    if rand(2)==0
      @scene.pbDisplay(_INTL("{1} irá primero.",@playerName))
      playerTurn=true
    else
      @scene.pbDisplay(_INTL("{1} irá primero.",@opponentName))
      playerTurn=false
    end
    for i in 0...@width*@height
      position=nil
      triadCard=nil
      cardIndex=0
      if playerTurn
        # Player's turn
        while !position
          cardIndex=@scene.pbPlayerChooseCard(cards.length)
          triadCard=TriadCard.new(cards[cardIndex])
          position=@scene.pbPlayerPlaceCard(triadCard,cardIndex)
        end
      else
        # Opponent's turn
        @scene.pbDisplay(_INTL("{1} está pensando su jugada...",@opponentName))    
        scores=[]
        for cardIndex in 0...opponentCards.length
          square=TriadSquare.new
          square.card=TriadCard.new(opponentCards[cardIndex])
          square.owner=2
          for i in 0...@width*@height
            x=i%@width
            y=i/@width
            square.type=@board[i].type
            flips=flipBoard(x,y,square)
            if flips!=nil
              scores.push([cardIndex,x,y,flips.length])
            end
          end
        end
        # Sort by number of flips
        scores.sort!{|a,b| 
           if b[3]==a[3]
             next [-1,1,0][rand(3)]
           else
             next b[3]<=>a[3]
           end
        } 
        scores=scores[0,opponentCards.length] # Get the best results
        if scores.length==0
          @scene.pbDisplay(_INTL("{1} no puede colocar...",@opponentName))
          playerTurn=!playerTurn
          continue
        end
        result=scores[rand(scores.length)]
        cardIndex=result[0]
        triadCard=TriadCard.new(opponentCards[cardIndex])
        position=[result[1],result[2]]
        @scene.pbOpponentPlaceCard(triadCard,position,cardIndex)
      end
      boardIndex=position[1]*@width+position[0]
      board[boardIndex].card=triadCard
      board[boardIndex].owner=playerTurn ? 1 : 2
      flipBoard(position[0],position[1])
      if playerTurn
        cards.delete_at(cardIndex)
        @scene.pbEndPlaceCard(position,cardIndex)
      else
        opponentCards.delete_at(cardIndex)
        @scene.pbEndOpponentPlaceCard(position,cardIndex)
      end
      playerTurn=!playerTurn
    end
    # Determine the winner
    playerCount=0
    opponentCount=0
    for i in 0...@width*@height
      playerCount+=1 if board[i].owner==1
      opponentCount+=1 if board[i].owner==2
    end
    if @countUnplayedCards
      playerCount+=cards.length
      opponentCount+=opponentCards.length
    end
    result=0
    if playerCount==opponentCount
      @scene.pbDisplayPaused(_INTL("¡El resultado es... Empate!"))
      result=3
      case @trade
      when 1
        # Keep only cards of your color
        for card in originalCards
          $PokemonGlobal.triads.pbDeleteItem(card)
        end
        for i in cards
          $PokemonGlobal.triads.pbStoreItem(i)
        end
        for i in 0...@width*@height
          if board[i].owner==1
            $PokemonGlobal.triads.pbStoreItem(board[i].card.species)
          end
        end
        @scene.pbDisplayPaused(_INTL("Conservas todas tus cartas de tu color."))
      end
    elsif playerCount>opponentCount
      @scene.pbDisplayPaused(_INTL("{1} ha ganado contra {2}.",@playerName,@opponentName))
      result=1
      if prize
        card=getID(PBSpecies,prize)
        if card>0 && $PokemonGlobal.triads.pbStoreItem(card)
          cardname=PBSpecies.getName(card)
          @scene.pbDisplayPaused(_INTL("Conseguiste la carta de {1}.",cardname))
        end
      else
        case @trade
        when 0
          # Gain 1 random card from opponent's deck
          card=originalOpponentCards[rand(originalOpponentCards.length)]
          if $PokemonGlobal.triads.pbStoreItem(card)
            cardname=PBSpecies.getName(card)
            @scene.pbDisplayPaused(_INTL("Conseguiste la carta de {1}.",cardname))
          end
        when 1
          # Keep only cards of your color
          for card in originalCards
            $PokemonGlobal.triads.pbDeleteItem(card)
          end
          for i in cards
            $PokemonGlobal.triads.pbStoreItem(i)
          end
          for i in 0...@width*@height
            if board[i].owner==1
              $PokemonGlobal.triads.pbStoreItem(board[i].card.species)
            end
          end
          @scene.pbDisplayPaused(_INTL("Conservas todas tus cartas de tu color."))
        when 2
          # Gain all opponent's cards
          for card in originalOpponentCards
            $PokemonGlobal.triads.pbStoreItem(card)
          end
          @scene.pbDisplayPaused(_INTL("Conseguiste todas las cartas del oponente."))
        end
      end
    else
      @scene.pbDisplayPaused(_INTL("{1} perdió contra {2}.",@playerName,@opponentName))
      result=2
      case @trade
      when 0
        # Lose 1 random card from your deck
        card=originalCards[rand(originalCards.length)]
        $PokemonGlobal.triads.pbDeleteItem(card)
        cardname=PBSpecies.getName(card)
        @scene.pbDisplayPaused(_INTL("El oponente consiguió tu carta de {1}.",cardname))
      when 1
        # Keep only cards of your color
        for card in originalCards
          $PokemonGlobal.triads.pbDeleteItem(card)
        end
        for i in cards
          $PokemonGlobal.triads.pbStoreItem(i)
        end
        for i in 0...@width*@height
          if board[i].owner==1
            $PokemonGlobal.triads.pbStoreItem(board[i].card.species)
          end
        end
        @scene.pbDisplayPaused(_INTL("Te quedas con todas las cartas de tu color.",cardname))
      when 2
        # Lose all your cards
        for card in originalCards
          $PokemonGlobal.triads.pbDeleteItem(card)
        end
        @scene.pbDisplayPaused(_INTL("Tu oponente consiguió todas tus cartas."))
      end
    end
    @scene.pbEndScene
    return result
  end
end



class PokemonGlobalMetadata
  attr_accessor :triads

  def triads
    @triads=TriadStorage.new if !@triads
    return @triads
  end
end



class TriadStorage
  def maxSize
    return PBSpecies.getCount
  end

  def maxPerSlot
    return 99
  end

  def initialize
    @items=[]
  end

  def empty?
    return @items.length==0
  end

  def length
    @items.length
  end

  def [](i)
    @items[i]
  end

  def getItem(index)
    if index<0 || index>=@items.length
      return 0
    else
      return @items[index][0]
    end
  end

  def getCount(index)
    if index<0 || index>=@items.length
      return 0
    else
      return @items[index][1]
    end
  end

  def pbQuantity(item)
    return ItemStorageHelper.pbQuantity(@items,self.maxSize,item)
  end

  def pbDeleteItem(item,qty=1)
    return ItemStorageHelper.pbDeleteItem(@items,self.maxSize,item,qty)
  end

  def pbCanStore?(item,qty=1)
    return ItemStorageHelper.pbCanStore?(@items,self.maxSize,self.maxPerSlot,item,qty)
  end

  def pbStoreItem(item,qty=1)
    return ItemStorageHelper.pbStoreItem(@items,self.maxSize,self.maxPerSlot,item,qty)
  end
end



def pbBuyTriads
  commands=[]
  realcommands=[]
  for i in 1..PBSpecies.maxValue
    if $Trainer.owned[i]
      speciesname=PBSpecies.getName(i)
      next if !speciesname
      price=TriadCard.new(i).price
      commands.push([price,speciesname,_INTL("{1} {2}",speciesname,price),i])
    end
  end
  if commands.length==0
    Kernel.pbMessage(_INTL("No puedes comprar ninguna carta.")) 
    return
  end
  commands.sort!{|a,b| 
     if a[0]==b[0]
       a[1]<=>b[1] # sort by name
     else
       a[0]<=>b[0] # sort by price
     end
  }
  for command in commands
    realcommands.push(command[2])
  end
  # Scroll right before showing screen
  pbScrollMap(4,3,5)
  cmdwindow=Window_CommandPokemonEx.newWithSize(realcommands,0,0,256,Graphics.height)
  cmdwindow.z=99999
  moneyString=_INTL("{1}",$PokemonGlobal.coins)
  goldwindow=Window_UnformattedTextPokemon.newWithSize(
     _INTL("Monedas:\n{1}",moneyString),0,0,32,32)
  goldwindow.resizeToFit(goldwindow.text,Graphics.width)
  goldwindow.y=0
  goldwindow.x=Graphics.width-goldwindow.width
  goldwindow.z=99999
  Graphics.frame_reset
  done=false
  while !done
    loop do
      Graphics.update
      Input.update
      cmdwindow.active=true
      cmdwindow.update
      goldwindow.update
      if Input.trigger?(Input::B)
        done=true
        break
      end
      if Input.trigger?(Input::C)
        price=commands[cmdwindow.index][0]
        item=commands[cmdwindow.index][3]
        itemname=commands[cmdwindow.index][1]
        cmdwindow.active=false
        cmdwindow.update
        if $PokemonGlobal.coins<price
          Kernel.pbMessage(_INTL("No tienes dinero suficiente."))
          break
        end
        maxafford=(price<=0) ? 99 : $PokemonGlobal.coins/price
        maxafford=99 if maxafford>99
        params=ChooseNumberParams.new
        params.setRange(1,maxafford)
        params.setInitialValue(1)
        params.setCancelValue(0)
        quantity=Kernel.pbMessageChooseNumber(
           _INTL("¿La carta de {1}?  Por supuesto.\r\n¿Cuantas quieres?",itemname),params)
        if quantity>0
          price*=quantity
          if !Kernel.pbConfirmMessage(_INTL("{1}, y quieres {2}.\r\nEso serán ${3}. ¿Vale?",itemname,quantity,price))
            break
          end
          if $PokemonGlobal.coins<price
            Kernel.pbMessage(_INTL("No tienes dinero suficiente."))
            break
          end
          if !$PokemonGlobal.triads.pbCanStore?(item,quantity)
            Kernel.pbMessage(_INTL("No tienes espacio para más cartas."))
          else
            $PokemonGlobal.triads.pbStoreItem(item,quantity)
            $PokemonGlobal.coins-=price
            moneyString=_INTL("{1}",$PokemonGlobal.coins)
            goldwindow.text=_INTL("Monedas:\n{1}",moneyString)
            Kernel.pbMessage(_INTL("¡Aquí tienes!\r\n¡Gracias!"))
          end
        end
      end
    end
  end
  cmdwindow.dispose
  goldwindow.dispose
  Graphics.frame_reset
  # Scroll right before showing screen
  pbScrollMap(6,3,5)
end

def pbSellTriads
  commands=[]
  for i in 0...$PokemonGlobal.triads.length
    item=$PokemonGlobal.triads[i]
    speciesname=PBSpecies.getName(item[0])
    commands.push(_INTL("{1} x{2}",speciesname,item[1]))
  end
  commands.push(_INTL("CANCEL"))
  if commands.length==1
    Kernel.pbMessage(_INTL("No tienes cartas."))
    return
  end
  # Scroll right before showing screen
  pbScrollMap(4,3,5)
  cmdwindow=Window_CommandPokemonEx.newWithSize(commands,0,0,256,Graphics.height)
  cmdwindow.z=99999
  moneyString=_INTL("{1}",$PokemonGlobal.coins)
  goldwindow=Window_UnformattedTextPokemon.newWithSize(
     _INTL("Monedas:\n{1}",moneyString),0,0,32,32)
  goldwindow.resizeToFit(goldwindow.text,Graphics.width)
  goldwindow.y=0
  goldwindow.x=Graphics.width-goldwindow.width
  goldwindow.z=99999
  done=false
  Graphics.frame_reset
  while !done
    loop do
      Graphics.update
      Input.update
      cmdwindow.active=true
      cmdwindow.update
      goldwindow.update
      if Input.trigger?(Input::B)
        done=true
        break
      end
      if Input.trigger?(Input::C)
        if cmdwindow.index>=$PokemonGlobal.triads.length
          done=true
          break
        end
        item=$PokemonGlobal.triads.getItem(cmdwindow.index)
        itemname=PBSpecies.getName(item)
        quantity=$PokemonGlobal.triads.pbQuantity(item)
        price=TriadCard.new(item).price
        if price==0
          pbDisplayPaused(_INTL("¿La carta de {1}?  Oh, no.\r\nNo puedo comprarla.",itemname))
          break
        end
        cmdwindow.active=false
        cmdwindow.update
        if quantity>1
          params=ChooseNumberParams.new
          params.setRange(1,quantity)
          params.setInitialValue(1)
          params.setCancelValue(0)
          quantity=Kernel.pbMessageChooseNumber(
             _INTL("¿La carta de {1}?  ¿Cuántas quieres vender?",itemname),params)
        end
        if quantity>0
          price/=4
          price*=quantity
          if Kernel.pbConfirmMessage(_INTL("Puedo pagarte ${1}. ¿Te parece bien?",price))
            $PokemonGlobal.coins+=price
            moneyString=_INTL("{1}",$PokemonGlobal.coins)
            goldwindow.text=_INTL("Monedas:\n{1}",moneyString)
            $PokemonGlobal.triads.pbDeleteItem(item,quantity)
            Kernel.pbMessage(_INTL("Vendiste la carta de {1} y recibiste ${2} a cambio.",itemname,price))
            commands=[]
            for i in 0...$PokemonGlobal.triads.length
              item=$PokemonGlobal.triads[i]
              speciesname=PBSpecies.getName(item[0])
              commands.push(_INTL("{1} x{2}",speciesname,item[1]))
            end
            commands.push(_INTL("CANCEL"))
            cmdwindow.commands=commands
            break
          end
        end
      end
    end
  end
  cmdwindow.dispose
  goldwindow.dispose
  Graphics.frame_reset
  # Scroll right before showing screen
  pbScrollMap(6,3,5)
end

def pbTriadList
  commands=[]
  for i in 0...$PokemonGlobal.triads.length
    item=$PokemonGlobal.triads[i]
    speciesname=PBSpecies.getName(item[0])
    commands.push(_INTL("{1} x{2}",speciesname,item[1]))
  end
  commands.push(_INTL("CANCEL"))
  if commands.length==1
    Kernel.pbMessage(_INTL("No tienes cartas."))
    return
  end
  cmdwindow=Window_CommandPokemonEx.newWithSize(commands,0,0,256,Graphics.height)
  cmdwindow.z=99999
  sprite=Sprite.new
  sprite.z=99999
  sprite.x=256+40
  sprite.y=48
  moneyString=_INTL("${1}",$PokemonGlobal.coins)
  done=false
  lastIndex=-1
  while !done
    loop do
      Graphics.update
      Input.update
      cmdwindow.update
      if lastIndex!=cmdwindow.index
        sprite.bitmap.dispose if sprite.bitmap
        if cmdwindow.index<$PokemonGlobal.triads.length
          sprite.bitmap=TriadCard.new($PokemonGlobal.triads.getItem(cmdwindow.index)).createBitmap(1)
        end
        lastIndex=cmdwindow.index
      end
      if Input.trigger?(Input::B)
        done=true
        break
      end
      if Input.trigger?(Input::C)
        if cmdwindow.index>=$PokemonGlobal.triads.length
          done=true
          break
        end
      end
    end
  end
  cmdwindow.dispose
  sprite.dispose
end

def pbTriadDuel(name,minLevel,maxLevel,rules=nil,oppdeck=nil,prize=nil)
  ret=0
  pbFadeOutInWithMusic(99999){
     scene=TriadScene.new
     screen=TriadScreen.new(scene)
     ret=screen.pbStartScreen(name,minLevel,maxLevel,rules,oppdeck,prize)
  }
  return ret
end

def pbGiveTriadCard(species,quantity=1)
  if species.is_a?(String) || species.is_a?(Symbol)
    species=getID(PBSpecies,species)
  end
  return false if !species || species<=0
  if $PokemonGlobal.triads.pbCanStore?(species,quantity)
    $PokemonGlobal.triads.pbStoreItem(species,quantity)
    return true
  end
  return false
end