Ergebnis 1 bis 5 von 5

Thema: main, scene_menu, scene_map, und game_temp

  1. #1

    main, scene_menu, scene_map, und game_temp

    He, leute! ein freund von mir braucht schnell main, scene_menu, scene_map, und game_temp!
    kann das wer in eine textdatei packen? wär echt nett

  2. #2
    Wieso besorgt er sich nicht die Trial vom RMXP? Da sind sie alle drin. o.O

  3. #3
    frag ich mich auch grad...
    ich hab ihn auch gefragt...
    er wirds wahrscheinlich tun...

  4. #4
    Hier sind sie trotzdem mal :

    Main:
    Code:
    #==============================================================================
    # ** Main
    #------------------------------------------------------------------------------
    #  After defining each class, actual processing begins here.
    #==============================================================================
    
    begin
      # Prepare for transition
      Graphics.freeze
      # Make scene object (title screen)
      $scene = Scene_Title.new
      # Call main method as long as $scene is effective
      while $scene != nil
        $scene.main
      end
      # Fade out
      Graphics.transition(20)
    rescue Errno::ENOENT
      # Supplement Errno::ENOENT exception
      # If unable to open file, display message and end
      filename = $!.message.sub("No such file or directory - ", "")
      print("Unable to find file #{filename}.")
    end
    scene_menu:
    Code:
    #==============================================================================
    # ** Scene_Menu
    #------------------------------------------------------------------------------
    #  This class performs menu screen processing.
    #==============================================================================
    
    class Scene_Menu
      #--------------------------------------------------------------------------
      # * Object Initialization
      #     menu_index : command cursor's initial position
      #--------------------------------------------------------------------------
      def initialize(menu_index = 0)
        @menu_index = menu_index
      end
      #--------------------------------------------------------------------------
      # * Main Processing
      #--------------------------------------------------------------------------
      def main
        # Make command window
        s1 = $data_system.words.item
        s2 = $data_system.words.skill
        s3 = $data_system.words.equip
        s4 = "Status"
        s5 = "Save"
        s6 = "End Game"
        @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
        @command_window.index = @menu_index
        # If number of party members is 0
        if $game_party.actors.size == 0
          # Disable items, skills, equipment, and status
          @command_window.disable_item(0)
          @command_window.disable_item(1)
          @command_window.disable_item(2)
          @command_window.disable_item(3)
        end
        # If save is forbidden
        if $game_system.save_disabled
          # Disable save
          @command_window.disable_item(4)
        end
        # Make play time window
        @playtime_window = Window_PlayTime.new
        @playtime_window.x = 0
        @playtime_window.y = 224
        # Make steps window
        @steps_window = Window_Steps.new
        @steps_window.x = 0
        @steps_window.y = 320
        # Make gold window
        @gold_window = Window_Gold.new
        @gold_window.x = 0
        @gold_window.y = 416
        # Make status window
        @status_window = Window_MenuStatus.new
        @status_window.x = 160
        @status_window.y = 0
        # Execute transition
        Graphics.transition
        # Main loop
        loop do
          # Update game screen
          Graphics.update
          # Update input information
          Input.update
          # Frame update
          update
          # Abort loop if screen is changed
          if $scene != self
            break
          end
        end
        # Prepare for transition
        Graphics.freeze
        # Dispose of windows
        @command_window.dispose
        @playtime_window.dispose
        @steps_window.dispose
        @gold_window.dispose
        @status_window.dispose
      end
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      def update
        # Update windows
        @command_window.update
        @playtime_window.update
        @steps_window.update
        @gold_window.update
        @status_window.update
        # If command window is active: call update_command
        if @command_window.active
          update_command
          return
        end
        # If status window is active: call update_status
        if @status_window.active
          update_status
          return
        end
      end
      #--------------------------------------------------------------------------
      # * Frame Update (when command window is active)
      #--------------------------------------------------------------------------
      def update_command
        # If B button was pressed
        if Input.trigger?(Input::B)
          # Play cancel SE
          $game_system.se_play($data_system.cancel_se)
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
        # If C button was pressed
        if Input.trigger?(Input::C)
          # If command other than save or end game, and party members = 0
          if $game_party.actors.size == 0 and @command_window.index < 4
            # Play buzzer SE
            $game_system.se_play($data_system.buzzer_se)
            return
          end
          # Branch by command window cursor position
          case @command_window.index
          when 0  # item
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Switch to item screen
            $scene = Scene_Item.new
          when 1  # skill
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Make status window active
            @command_window.active = false
            @status_window.active = true
            @status_window.index = 0
          when 2  # equipment
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Make status window active
            @command_window.active = false
            @status_window.active = true
            @status_window.index = 0
          when 3  # status
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Make status window active
            @command_window.active = false
            @status_window.active = true
            @status_window.index = 0
          when 4  # save
            # If saving is forbidden
            if $game_system.save_disabled
              # Play buzzer SE
              $game_system.se_play($data_system.buzzer_se)
              return
            end
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Switch to save screen
            $scene = Scene_Save.new
          when 5  # end game
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Switch to end game screen
            $scene = Scene_End.new
          end
          return
        end
      end
      #--------------------------------------------------------------------------
      # * Frame Update (when status window is active)
      #--------------------------------------------------------------------------
      def update_status
        # If B button was pressed
        if Input.trigger?(Input::B)
          # Play cancel SE
          $game_system.se_play($data_system.cancel_se)
          # Make command window active
          @command_window.active = true
          @status_window.active = false
          @status_window.index = -1
          return
        end
        # If C button was pressed
        if Input.trigger?(Input::C)
          # Branch by command window cursor position
          case @command_window.index
          when 1  # skill
            # If this actor's action limit is 2 or more
            if $game_party.actors[@status_window.index].restriction >= 2
              # Play buzzer SE
              $game_system.se_play($data_system.buzzer_se)
              return
            end
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Switch to skill screen
            $scene = Scene_Skill.new(@status_window.index)
          when 2  # equipment
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Switch to equipment screen
            $scene = Scene_Equip.new(@status_window.index)
          when 3  # status
            # Play decision SE
            $game_system.se_play($data_system.decision_se)
            # Switch to status screen
            $scene = Scene_Status.new(@status_window.index)
          end
          return
        end
      end
    end
    scene_map:
    Code:
    #==============================================================================
    # ** Scene_Map
    #------------------------------------------------------------------------------
    #  This class performs map screen processing.
    #==============================================================================
    
    class Scene_Map
      #--------------------------------------------------------------------------
      # * Main Processing
      #--------------------------------------------------------------------------
      def main
        # Make sprite set
        @spriteset = Spriteset_Map.new
        # Make message window
        @message_window = Window_Message.new
        # Transition run
        Graphics.transition
        # Main loop
        loop do
          # Update game screen
          Graphics.update
          # Update input information
          Input.update
          # Frame update
          update
          # Abort loop if screen is changed
          if $scene != self
            break
          end
        end
        # Prepare for transition
        Graphics.freeze
        # Dispose of sprite set
        @spriteset.dispose
        # Dispose of message window
        @message_window.dispose
        # If switching to title screen
        if $scene.is_a?(Scene_Title)
          # Fade out screen
          Graphics.transition
          Graphics.freeze
        end
      end
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      def update
        # Loop
        loop do
          # Update map, interpreter, and player order
          # (this update order is important for when conditions are fulfilled 
          # to run any event, and the player isn't provided the opportunity to
          # move in an instant)
          $game_map.update
          $game_system.map_interpreter.update
          $game_player.update
          # Update system (timer), screen
          $game_system.update
          $game_screen.update
          # Abort loop if player isn't place moving
          unless $game_temp.player_transferring
            break
          end
          # Run place move
          transfer_player
          # Abort loop if transition processing
          if $game_temp.transition_processing
            break
          end
        end
        # Update sprite set
        @spriteset.update
        # Update message window
        @message_window.update
        # If game over
        if $game_temp.gameover
          # Switch to game over screen
          $scene = Scene_Gameover.new
          return
        end
        # If returning to title screen
        if $game_temp.to_title
          # Change to title screen
          $scene = Scene_Title.new
          return
        end
        # If transition processing
        if $game_temp.transition_processing
          # Clear transition processing flag
          $game_temp.transition_processing = false
          # Execute transition
          if $game_temp.transition_name == ""
            Graphics.transition(20)
          else
            Graphics.transition(40, "Graphics/Transitions/" +
              $game_temp.transition_name)
          end
        end
        # If showing message window
        if $game_temp.message_window_showing
          return
        end
        # If encounter list isn't empty, and encounter count is 0
        if $game_player.encounter_count == 0 and $game_map.encounter_list != []
          # If event is running or encounter is not forbidden
          unless $game_system.map_interpreter.running? or
                 $game_system.encounter_disabled
            # Confirm troop
            n = rand($game_map.encounter_list.size)
            troop_id = $game_map.encounter_list[n]
            # If troop is valid
            if $data_troops[troop_id] != nil
              # Set battle calling flag
              $game_temp.battle_calling = true
              $game_temp.battle_troop_id = troop_id
              $game_temp.battle_can_escape = true
              $game_temp.battle_can_lose = false
              $game_temp.battle_proc = nil
            end
          end
        end
        # If B button was pressed
        if Input.trigger?(Input::B)
          # If event is running, or menu is not forbidden
          unless $game_system.map_interpreter.running? or
                 $game_system.menu_disabled
            # Set menu calling flag or beep flag
            $game_temp.menu_calling = true
            $game_temp.menu_beep = true
          end
        end
        # If debug mode is ON and F9 key was pressed
        if $DEBUG and Input.press?(Input::F9)
          # Set debug calling flag
          $game_temp.debug_calling = true
        end
        # If player is not moving
        unless $game_player.moving?
          # Run calling of each screen
          if $game_temp.battle_calling
            call_battle
          elsif $game_temp.shop_calling
            call_shop
          elsif $game_temp.name_calling
            call_name
          elsif $game_temp.menu_calling
            call_menu
          elsif $game_temp.save_calling
            call_save
          elsif $game_temp.debug_calling
            call_debug
          end
        end
      end
      #--------------------------------------------------------------------------
      # * Battle Call
      #--------------------------------------------------------------------------
      def call_battle
        # Clear battle calling flag
        $game_temp.battle_calling = false
        # Clear menu calling flag
        $game_temp.menu_calling = false
        $game_temp.menu_beep = false
        # Make encounter count
        $game_player.make_encounter_count
        # Memorize map BGM and stop BGM
        $game_temp.map_bgm = $game_system.playing_bgm
        $game_system.bgm_stop
        # Play battle start SE
        $game_system.se_play($data_system.battle_start_se)
        # Play battle BGM
        $game_system.bgm_play($game_system.battle_bgm)
        # Straighten player position
        $game_player.straighten
        # Switch to battle screen
        $scene = Scene_Battle.new
      end
      #--------------------------------------------------------------------------
      # * Shop Call
      #--------------------------------------------------------------------------
      def call_shop
        # Clear shop call flag
        $game_temp.shop_calling = false
        # Straighten player position
        $game_player.straighten
        # Switch to shop screen
        $scene = Scene_Shop.new
      end
      #--------------------------------------------------------------------------
      # * Name Input Call
      #--------------------------------------------------------------------------
      def call_name
        # Clear name input call flag
        $game_temp.name_calling = false
        # Straighten player position
        $game_player.straighten
        # Switch to name input screen
        $scene = Scene_Name.new
      end
      #--------------------------------------------------------------------------
      # * Menu Call
      #--------------------------------------------------------------------------
      def call_menu
        # Clear menu call flag
        $game_temp.menu_calling = false
        # If menu beep flag is set
        if $game_temp.menu_beep
          # Play decision SE
          $game_system.se_play($data_system.decision_se)
          # Clear menu beep flag
          $game_temp.menu_beep = false
        end
        # Straighten player position
        $game_player.straighten
        # Switch to menu screen
        $scene = Scene_Menu.new
      end
      #--------------------------------------------------------------------------
      # * Save Call
      #--------------------------------------------------------------------------
      def call_save
        # Straighten player position
        $game_player.straighten
        # Switch to save screen
        $scene = Scene_Save.new
      end
      #--------------------------------------------------------------------------
      # * Debug Call
      #--------------------------------------------------------------------------
      def call_debug
        # Clear debug call flag
        $game_temp.debug_calling = false
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Straighten player position
        $game_player.straighten
        # Switch to debug screen
        $scene = Scene_Debug.new
      end
      #--------------------------------------------------------------------------
      # * Player Place Move
      #--------------------------------------------------------------------------
      def transfer_player
        # Clear player place move call flag
        $game_temp.player_transferring = false
        # If move destination is different than current map
        if $game_map.map_id != $game_temp.player_new_map_id
          # Set up a new map
          $game_map.setup($game_temp.player_new_map_id)
        end
        # Set up player position
        $game_player.moveto($game_temp.player_new_x, $game_temp.player_new_y)
        # Set player direction
        case $game_temp.player_new_direction
        when 2  # down
          $game_player.turn_down
        when 4  # left
          $game_player.turn_left
        when 6  # right
          $game_player.turn_right
        when 8  # up
          $game_player.turn_up
        end
        # Straighten player position
        $game_player.straighten
        # Update map (run parallel process event)
        $game_map.update
        # Remake sprite set
        @spriteset.dispose
        @spriteset = Spriteset_Map.new
        # If processing transition
        if $game_temp.transition_processing
          # Clear transition processing flag
          $game_temp.transition_processing = false
          # Execute transition
          Graphics.transition(20)
        end
        # Run automatic change for BGM and BGS set on the map
        $game_map.autoplay
        # Frame reset
        Graphics.frame_reset
        # Update input information
        Input.update
      end
    end
    game_temp:
    Code:
    #==============================================================================
    # ** Game_Temp
    #------------------------------------------------------------------------------
    #  This class handles temporary data that is not included with save data.
    #  Refer to "$game_temp" for the instance of this class.
    #==============================================================================
    
    class Game_Temp
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :map_bgm                  # map music (for battle memory)
      attr_accessor :message_text             # message text
      attr_accessor :message_proc             # message callback (Proc)
      attr_accessor :choice_start             # show choices: opening line
      attr_accessor :choice_max               # show choices: number of items
      attr_accessor :choice_cancel_type       # show choices: cancel
      attr_accessor :choice_proc              # show choices: callback (Proc)
      attr_accessor :num_input_start          # input number: opening line
      attr_accessor :num_input_variable_id    # input number: variable ID
      attr_accessor :num_input_digits_max     # input number: digit amount
      attr_accessor :message_window_showing   # message window showing
      attr_accessor :common_event_id          # common event ID
      attr_accessor :in_battle                # in-battle flag
      attr_accessor :battle_calling           # battle calling flag
      attr_accessor :battle_troop_id          # battle troop ID
      attr_accessor :battle_can_escape        # battle flag: escape possible
      attr_accessor :battle_can_lose          # battle flag: losing possible
      attr_accessor :battle_proc              # battle callback (Proc)
      attr_accessor :battle_turn              # number of battle turns
      attr_accessor :battle_event_flags       # battle event flags: completed
      attr_accessor :battle_abort             # battle flag: interrupt
      attr_accessor :battle_main_phase        # battle flag: main phase
      attr_accessor :battleback_name          # battleback file name
      attr_accessor :forcing_battler          # battler being forced into action
      attr_accessor :shop_calling             # shop calling flag
      attr_accessor :shop_goods               # list of shop goods
      attr_accessor :name_calling             # name input: calling flag
      attr_accessor :name_actor_id            # name input: actor ID
      attr_accessor :name_max_char            # name input: max character count
      attr_accessor :menu_calling             # menu calling flag
      attr_accessor :menu_beep                # menu: play sound effect flag
      attr_accessor :save_calling             # save calling flag
      attr_accessor :debug_calling            # debug calling flag
      attr_accessor :player_transferring      # player place movement flag
      attr_accessor :player_new_map_id        # player destination: map ID
      attr_accessor :player_new_x             # player destination: x-coordinate
      attr_accessor :player_new_y             # player destination: y-coordinate
      attr_accessor :player_new_direction     # player destination: direction
      attr_accessor :transition_processing    # transition processing flag
      attr_accessor :transition_name          # transition file name
      attr_accessor :gameover                 # game over flag
      attr_accessor :to_title                 # return to title screen flag
      attr_accessor :last_file_index          # last save file no.
      attr_accessor :debug_top_row            # debug screen: for saving conditions
      attr_accessor :debug_index              # debug screen: for saving conditions
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      def initialize
        @map_bgm = nil
        @message_text = nil
        @message_proc = nil
        @choice_start = 99
        @choice_max = 0
        @choice_cancel_type = 0
        @choice_proc = nil
        @num_input_start = 99
        @num_input_variable_id = 0
        @num_input_digits_max = 0
        @message_window_showing = false
        @common_event_id = 0
        @in_battle = false
        @battle_calling = false
        @battle_troop_id = 0
        @battle_can_escape = false
        @battle_can_lose = false
        @battle_proc = nil
        @battle_turn = 0
        @battle_event_flags = {}
        @battle_abort = false
        @battle_main_phase = false
        @battleback_name = ''
        @forcing_battler = nil
        @shop_calling = false
        @shop_id = 0
        @name_calling = false
        @name_actor_id = 0
        @name_max_char = 0
        @menu_calling = false
        @menu_beep = false
        @save_calling = false
        @debug_calling = false
        @player_transferring = false
        @player_new_map_id = 0
        @player_new_x = 0
        @player_new_y = 0
        @player_new_direction = 0
        @transition_processing = false
        @transition_name = ""
        @gameover = false
        @to_title = false
        @last_file_index = 0
        @debug_top_row = 0
        @debug_index = 0
      end
    end

  5. #5

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •