class Menu2
    def update;end

    def pbStartScene # CARGA LAS COSAS
        @sprites={}
        @viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
        @viewport.z=99999

        @sprites["bg"]=Sprite.new(@viewport)
        @sprites["bg"].bitmap=RPG::Cache.picture("menu_bg")

        logros=["Profesora Pokémon","Cotilla", "Loca de las setas"]
        textpos=[]
        textpos.push([_INTL("{1}",logros[$game_variables[51]]),50,10,0,
        Color.new(255,255,255),Color.new(88,88,80)])
        @sprites["logros"]=Sprite.new(@viewport)

    if $game_variables[51]==0
        @sprites["logros"].bitmap=pbBitmap("Graphics/Pictures/logros/logros0")
        #@sprites["logros"].bitmap=RPG::Cache.picture("logros")
        @sprites["logros"].x=10
        @sprites["logros"].y=8
        @sprites["logros"].z=99999
      end
    if $game_variables[51]==1
        @sprites["logros"].bitmap=pbBitmap("Graphics/Pictures/logros/logros1")
        @sprites["logros"].x=8
        @sprites["logros"].y=8
        @sprites["logros"].z=99999
      end
    if $game_variables[51]==2
        @sprites["logros"].bitmap=pbBitmap("Graphics/Pictures/logros/logros2")
        @sprites["logros"].x=3
        @sprites["logros"].y=6
        @sprites["logros"].z=99999
      end

        @sprites["overlay"]=BitmapSprite.new(Graphics.width,Graphics.height,@viewport)
        @sprites["overlay"].z = 99999
        @texts = @sprites["overlay"].bitmap
        @sprites["overlay"].bitmap.clear
        pbSetSystemFont(@sprites["overlay"].bitmap)
        pbDrawTextPositions(@texts,textpos)



       @totalElements = 9
        radius = 100

        counter = 0;
        @sprites["pokedex"]=Sprite.new(@viewport)
        @sprites["pokedex"].bitmap=RPG::Cache.picture("calculator")
        @sprites["pokedex"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["pokedex"].bitmap.width/2)
        @sprites["pokedex"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["pokedex"].bitmap.height/2)
        @sprites["pokedex"].z=99999

        counter += 1
        @sprites["pokeball"]=Sprite.new(@viewport)
        @sprites["pokeball"].bitmap=RPG::Cache.picture("record")
        @sprites["pokeball"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["pokeball"].bitmap.width/2)
        @sprites["pokeball"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["pokeball"].bitmap.height/2)
        @sprites["pokeball"].z=99999

        counter += 1
        @sprites["cofre"]=Sprite.new(@viewport)
        @sprites["cofre"].bitmap=RPG::Cache.picture("cofre")
        @sprites["cofre"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["cofre"].bitmap.width/2)
        @sprites["cofre"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["cofre"].bitmap.height/2)
        @sprites["cofre"].z=99999

        counter += 1
        @sprites["user"]=Sprite.new(@viewport)
        @sprites["user"].bitmap=RPG::Cache.picture("user")
        @sprites["user"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["user"].bitmap.width/2)
        @sprites["user"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["user"].bitmap.height/2)
        @sprites["user"].z=99999

        counter += 1
        @sprites["opciones"]=Sprite.new(@viewport)
        @sprites["opciones"].bitmap=RPG::Cache.picture("tools")
        @sprites["opciones"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["opciones"].bitmap.width/2)
        @sprites["opciones"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["opciones"].bitmap.height/2)
        @sprites["opciones"].z=99999

        counter += 1
        @sprites["save"]=Sprite.new(@viewport)
        @sprites["save"].bitmap=RPG::Cache.picture("save")
        @sprites["save"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["save"].bitmap.width/2)
        @sprites["save"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["save"].bitmap.height/2)
        @sprites["save"].z=99999

        counter += 1
        @sprites["exit"]=Sprite.new(@viewport)
        @sprites["exit"].bitmap=RPG::Cache.picture("exit")
        @sprites["exit"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["exit"].bitmap.width/2)
        @sprites["exit"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["exit"].bitmap.height/2)
        @sprites["exit"].z=99999

         counter += 1
        @sprites["misiones"]=Sprite.new(@viewport)
        @sprites["misiones"].bitmap=RPG::Cache.picture("misiones")
        @sprites["misiones"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["misiones"].bitmap.width/2)
        @sprites["misiones"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["misiones"].bitmap.height/2)
        @sprites["misiones"].z=99999

        counter += 1
        @sprites["misiones"]=Sprite.new(@viewport)
        @sprites["misiones"].bitmap=RPG::Cache.picture("misiones")
        @sprites["misiones"].x=getXPolygon(counter, @totalElements, Graphics.width/2, radius) - (@sprites["misiones"].bitmap.width/2)
        @sprites["misiones"].y=getYPolygon(counter, @totalElements, Graphics.height/2, radius) - (@sprites["misiones"].bitmap.height/2)
        @sprites["misiones"].z=99999

        @sprites["shine"]=Sprite.new(@viewport)
        @sprites["shine"].bitmap=RPG::Cache.picture("resplan")
        @sprites["shine"].x = @sprites["pokedex"].x
        @sprites["shine"].y = @sprites["pokedex"].y
        @sprites["shine"].z=99998

        @sprites["title"]=Sprite.new(@viewport)
        @sprites["title"].z=99999

        pbSEPlay("menu")
    end

    def pbEndScene # CUANDO TERMINA...
        pbDisposeSpriteHash(@sprites)
        @viewport.dispose if @viewport
    end

    def pbUpdate
        @xcount=0
        @posible1=0
        @posible2=0
        @posible3=0
        loop do
            Graphics.update
            Input.update

        ################### FUNCIONES AQUÍ #######

            if Input.trigger?(Input::RIGHT)
                @xcount=@xcount+1
            end

            if Input.trigger?(Input::LEFT)
                @xcount=@xcount-1
            end

            if (@xcount == -1)
                @xcount= @totalElements-1
            end

            if (@xcount == @totalElements)
                @xcount=0
            end

            if (@xcount==0)
                @sprites["title"].bitmap=RPG::Cache.picture("ndex")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["pokedex"].x - (@sprites["shine"].bitmap.width-@sprites["pokedex"].bitmap.width)/2
                @sprites["shine"].y = @sprites["pokedex"].y - (@sprites["shine"].bitmap.height-@sprites["pokedex"].bitmap.height)/2


                if Input.trigger?(Input::C) and !$Trainer.pokedex
                    Kernel.pbMessage(_INTL("You haven't got the pokédex."))
                end

                if Input.trigger?(Input::C)
                    if DEXDEPENDSONLOCATION
                        pbFadeOutIn(99999) {
                            scene=PokemonPokedexScene.new
                            screen=PokemonPokedex.new(scene)
                            screen.pbStartScreen
                            #@scene.pbRefresh
                        }
                    else
                        if $PokemonGlobal.pokedexViable.length==1
                            $PokemonGlobal.pokedexDex=$PokemonGlobal.pokedexViable[0]
                            $PokemonGlobal.pokedexDex=-1
                            if $PokemonGlobal.pokedexDex==$PokemonGlobal.pokedexUnlocked.length-1
                                pbFadeOutIn(99999) {
                                    scene=PokemonPokedexScene.new
                                    screen=PokemonPokedex.new(scene)
                                    screen.pbStartScreen
                                    #@scene.pbRefresh
                                }
                            else
                                pbLoadRpgxpScene(Scene_PokedexMenu.new)
                            end
                        end
                    end
                end
            end

            if (@xcount==1)
                @sprites["title"].bitmap=RPG::Cache.picture("npk")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["pokeball"].x - (@sprites["shine"].bitmap.width-@sprites["pokeball"].bitmap.width)/2
                @sprites["shine"].y = @sprites["pokeball"].y - (@sprites["shine"].bitmap.height-@sprites["pokeball"].bitmap.height)/2

                if $Trainer.party.length<1
                    if Input.trigger?(Input::C)
                        Kernel.pbMessage(_INTL("You haven't got any pokémon."))
                    end
                end
                if Input.trigger?(Input::C)
                    sscene=PokemonScreen_Scene.new
                    sscreen=PokemonScreen.new(sscene,$Trainer.party)
                    hiddenmove=nil
                    pbFadeOutIn(99999) {
                        hiddenmove=sscreen.pbPokemonScreen
                        if hiddenmove
                            pbEndScene
                        else
                            #@scene.pbRefresh
                        end
                    }
                    if hiddenmove
                        Kernel.pbUseHiddenMove(hiddenmove[0],hiddenmove[1])
                        return
                    end
                end
            end

            if (@xcount==2)
                @sprites["title"].bitmap=RPG::Cache.picture("nbag")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["cofre"].x - (@sprites["shine"].bitmap.width-@sprites["cofre"].bitmap.width)/2
                @sprites["shine"].y = @sprites["cofre"].y - (@sprites["shine"].bitmap.height-@sprites["cofre"].bitmap.height)/2

                if Input.trigger?(Input::C)
                    item=0
                    scene=PokemonBag_Scene.new
                    screen=PokemonBagScreen.new(scene,$PokemonBag)
                    pbFadeOutIn(99999) {
                    item=screen.pbStartScreen
                    if item>0
                        pbEndScene
                    else
                        #@scene.pbRefresh
                    end
                    }
                    if item>0
                        Kernel.pbUseKeyItemInField(item)
                        return
                    end
                end
            end

            if (@xcount==3)
                @sprites["title"].bitmap=RPG::Cache.picture("nplayer")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["user"].x - (@sprites["shine"].bitmap.width-@sprites["user"].bitmap.width)/2
                @sprites["shine"].y = @sprites["user"].y - (@sprites["shine"].bitmap.height-@sprites["user"].bitmap.height)/2

                if Input.trigger?(Input::C)
                    PBDebug.logonerr {
                        scene=PokemonTrainerCardScene.new
                        screen=PokemonTrainerCard.new(scene)
                        pbFadeOutIn(99999) {
                            screen.pbStartScreen
                            #@scene.pbRefresh
                        }
                    }
                end
            end

            if (@xcount==4)
                @sprites["title"].bitmap=RPG::Cache.picture("nop")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["opciones"].x - (@sprites["shine"].bitmap.width-@sprites["opciones"].bitmap.width)/2
                @sprites["shine"].y = @sprites["opciones"].y - (@sprites["shine"].bitmap.height-@sprites["opciones"].bitmap.height)/2

                if Input.trigger?(Input::C)
                    scene=PokemonOptionScene.new
                    screen=PokemonOption.new(scene)
                    pbFadeOutIn(99999) {
                        screen.pbStartScreen
                        pbUpdateSceneMap
                        #@scene.pbRefresh
                    }
                end
            end

            if (@xcount==5)
                @sprites["title"].bitmap=RPG::Cache.picture("nsv")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["save"].x - (@sprites["shine"].bitmap.width-@sprites["save"].bitmap.width)/2
                @sprites["shine"].y = @sprites["save"].y - (@sprites["shine"].bitmap.height-@sprites["save"].bitmap.height)/2

                if Input.trigger?(Input::C)
                    scene=PokemonSaveScene.new
                    screen=PokemonSave.new(scene)
                    if screen.pbSaveScreen
                        endscene=false
                        break
                    else
                        pbUpdateSceneMap
                    end
                end
            end

            if (@xcount==6)
                @sprites["title"].bitmap=RPG::Cache.picture("nxt")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["exit"].x - (@sprites["shine"].bitmap.width-@sprites["exit"].bitmap.width)/2
                @sprites["shine"].y = @sprites["exit"].y - (@sprites["shine"].bitmap.height-@sprites["exit"].bitmap.height)/2

                break if Input.trigger?(Input::C)
              end

              if (@xcount==7)
                @sprites["title"].bitmap=RPG::Cache.picture("nfo")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2

                @sprites["shine"].x = @sprites["misiones"].x - (@sprites["shine"].bitmap.width-@sprites["misiones"].bitmap.width)/2
                @sprites["shine"].y = @sprites["misiones"].y - (@sprites["shine"].bitmap.height-@sprites["misiones"].bitmap.height)/2

                if Input.trigger?(Input::C)
                    pbInformes()
                  end
                end

                  if (@xcount==8)
                @sprites["title"].bitmap=RPG::Cache.picture("noi")
                @sprites["title"].x = (Graphics.width-@sprites["title"].bitmap.width)/2
                @sprites["title"].y = (Graphics.height-@sprites["title"].bitmap.height)/2
                @sprites["shine"].x = @sprites["misiones"].x - (@sprites["shine"].bitmap.width-@sprites["misiones"].bitmap.width)/2
                @sprites["shine"].y = @sprites["misiones"].y - (@sprites["shine"].bitmap.height-@sprites["misiones"].bitmap.height)/2

                if Input.trigger?(Input::C)
                    showMissions()
                end
            end
        ###########################################

            break if Input.trigger?(Input::B) # CIERRA EL MENÚ

        end

    end

end # Cierra la class

###################################################

def pbCallMenu2
    scene=Menu2.new
    scene.pbStartScene
    scene.pbUpdate
    scene.pbEndScene
end


def getXPolygon(element, total, x_centre, radius)
    return radius * Math.cos(2*Math::PI*element/total + (Math::PI*1.5)) + x_centre
end

def getYPolygon(element, total, y_centre, radius)
    return radius * Math.sin(2*Math::PI*element/total + (Math::PI*1.5)) + y_centre
end