Celestian Achievement Script Call

Discussion in 'RGSSx Script Support' started by LynX, May 23, 2016.

  1. LynX

    LynX Veteran Veteran

    Messages:
    81
    Likes Received:
    7
    Location:
    Poland
    First Language:
    Polish
    Hi I have a problem with this script i cant figure out how to script call via my common event.

    Code:
    #========================================================================
    #    Author:   Calestian
    #    Name:     Achievement System
    #    Created:  02-04-2015
    #    Version:  1.4
    #---------------------------------------------------------------------------
    #                       VERSION HISTORY
    #
    #    v1.0 - Initial Release
    #    v1.1 - Quick Bug Fix
    #    v1.2 - Added Repeatable Achievements
    #    v1.3 - Added Notification Sounds - Updated Prerequisites
    #    v1.4 - Quick Fixes - Updated Event Methods
    #---------------------------------------------------------------------------
    #                       FEATURES
    #    
    #    * Achievement Categories
    #    * Locked Achievements (Prerequisites)
    #    * Completed Achievements (Colored)
    #    * Achievement Rewards
    #    * Achievement Point Rewards
    #    * Achievement Progression Track
    #    * Achievement Notification (Completed | Unlocked | Achievement Points Reached)
    #---------------------------------------------------------------------------
    #                       How to Setup
    #
    #    * Set in the Achievement_Categories array your Categories:
    #         Achievement_Categories[index] = ["CategoryName", "CategoryDescription"]
    #
    #    * Set in the Achievements hash your achievement info:
    #         :Prerequisite
    #             Set to :none means there is no prerequisite 
    #             Set to [AchievementID, Repeated, Objective]
    #                e.g [0, 5, 200]
    #         :Item => [ItemType, ItemID, Amount]
    #             ItemType: 0 -> Item | 1 -> Armor | 2 -> Weapon
    #             ItemID: Taken from Database
    #             Amount: How many of the selected item to be given as a reward
    #         :Repeatable => false | value
    #             false -> One time Achievement
    #             value (eg. 50) -> Repeatable value(50) times
    #    
    #    * Set in the Achievement_Point_Rewards array your AP rewards:
    #         Achievement_Point_Rewards[index] = [[ItemType, ItemID, Amount], [ItemType, ItemID, Amount], ... , [ItemType, ItemID, Amount]
    #  
    #    * Edit Settings
    #---------------------------------------------------------------------------
    #                       How to Use
    #
    #    In the Event -> Script:
    #       * gain_achievement(amount, index)     # Index -> Achievements Hash Index
    #       * lose_achievement(amount, index)
    #       *  set_achievement(amount, index)
    #      
    #       * gain_achievement_points(amount)
    #       * lose_achievement_points(amount)
    #       *  set_achievement_points(amount)
    #
    #       * achievement_name(index) 
    #       * achievement_item(index)
    #       * achievement_gold(index)
    #       * achievement_points(index)
    #       * achievement_title(index)
    #       * achievement_repeated(index)
    #       * achievement_progress(index)
    #       * achievement_status(index)
    #       * party_achievement_points
    #---------------------------------------------------------------------------
    #                       LICENSE INFO
    #
    #    Free for non-commercial & commercial use, as long as credit is given
    #    to Calestian
    #===========================================================================
     
    #===========================================================================
    # *** Editable Region
    #===========================================================================
    module Clstn_Achievement_System
     
      #--------------------------------------------------------------------------
      # * Achievement Categories
      #--------------------------------------------------------------------------
      Achievement_Categories = []
     
      Achievement_Categories[0] = ["General"      , "General Category Description"]
      Achievement_Categories[1] = ["Explore"      , "Explore the World"           ]
      Achievement_Categories[2] = ["Slayer"       , "Slay Stuff"                  ]
      Achievement_Categories[3] = ["Weapon Master", "Use Weapons"                 ]
      Achievement_Categories[4] = ["Competitive"  , "Be the best"                 ]
      Achievement_Categories[5] = ["PvP"          , "PvP Achievements"            ]
     
      #--------------------------------------------------------------------------
      # * Achievements
      #--------------------------------------------------------------------------
      Achievements = {
     
        0 => {
          :Name              => "Be awesome",
          :Tiers             => [5],
          :Help              => "Just be awesome",
          :Title             => "Awesome Guy",
          :RewardItem        => [0, 005, 50],
          :RewardGold        => 100,
          :Category          => "General",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 5,
        },
       
        1 => {
          :Name              => "Treasure Hunter",
          :Tiers             => [50, 100, 150, 200, 250],
          :Help              => "Find Treasures",
          :Title             => :none,
          :RewardItem        => :none,
          :RewardGold        => :none,
          :Category          => "General",
          :AchievementPoints => :none,
          :Prerequisite      => [0, 2, 4],
          :Repeatable        => 10,
        },
       
        2 => {
          :Name              => "Key Collector",
          :Tiers             => [50, 100, 150, 200, 250],
          :Help              => "Find Keys",
          :Title             => "Key Collector",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "General",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => false,
        },
       
        3 => {
          :Name              => "House Explorer",
          :Tiers             => [50],
          :Help              => "Explore Houses",
          :Title             => "House Explorer",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "Explore",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => false,
        },
       
        4 => {
          :Name              => "Cave Explorer",
          :Tiers             => [50],
          :Help              => "Explore Caves",
          :Title             => "Cave Explorer",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "Explore",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => false,
        },
       
        5 => {
          :Name              => "Sea Explorer",
          :Tiers             => [50, 100, 150, 200],
          :Help              => "Explore Seas",
          :Title             => "Sea Explorer",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "Explore",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 50,
        },
       
       
        6 => {
          :Name              => "Mountain Explorer",
          :Tiers             => [50, 100, 150],
          :Help              => "Explore Mountains",
          :Title             => "Mountain Explorer",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "Explore",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 50,
        },
     
        7 => {
          :Name              => "Dragon Slayer",
          :Tiers             => [50, 100, 150, 200, 250],
          :Help              => "Kill Dragons",
          :Title             => "Dragon Slayer",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "Slayer",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 50,
        },
       
        8 => {
          :Name              => "Demon Slayer",
          :Tiers             => [50, 100, 150, 200, 250],
          :Help              => "Kill Demons",
          :Title             => "Demon Slayer",
          :RewardItem        => [1, 001, 50],
          :RewardGold        => 100,
          :Category          => "Slayer",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 50,
        },
       
        9 => {
          :Name              => "God Slayer",
          :Tiers             => [50, 100, 150, 200, 250],
          :Help              => "Kill Gods",
          :Title             => "God Slayer",
          :RewardItem        => [2, 001, 50],
          :RewardGold        => 100,
          :Category          => "Slayer",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 50,
        },
       
        10 => {
          :Name              => "Rabbit Slayer",
          :Tiers             => [50, 100, 150, 200, 250],
          :Help              => "Kill Rabbits",
          :Title             => "Rabbit Slayer",
          :RewardItem        => [0, 001, 50],
          :RewardGold        => 100,
          :Category          => "Slayer",
          :AchievementPoints => 100,
          :Prerequisite      => :none,
          :Repeatable        => 50,
        },
       
      }
     
      Achievement_Point_Rewards    = []
      Achievement_Point_Rewards[0] = [1000,   [[1, 001, 50], [0, 001, 10], [2, 001, 30]]]
      Achievement_Point_Rewards[1] = [5000,   [[1, 001, 50], [0, 001, 10], [2, 001, 30]]]
      Achievement_Point_Rewards[2] = [10000,  [[1, 001, 50], [0, 001, 10], [2, 001, 30]]]
      Achievement_Point_Rewards[3] = [50000,  [[1, 001, 50], [0, 001, 10], [1, 001, 30]]]
      Achievement_Point_Rewards[4] = [100000, [[1, 001, 50], [0, 001, 10], [1, 001, 30]]]
     
       
      #-----------------------------------------------------------------------
      # * Settings
      #-----------------------------------------------------------------------
      Achievement_Display        = :Both     # :Color | :Icon | :Both
      Category_Icon_Disabled     = 337       # Category Icon when not Expanded
      Category_Icon_Enabled      = 345       # Category Icon when Expanded
      Achievement_Points_Icon    = 361       # Achievement_Points_Icon = IconID
      Achievement_Unlocked_Icon  = 359       # Achievement_Unlocked_Icon = IconID
      Achievement_Locked_Icon    = 243       # Achievement_Locked_Icon = IconID
      Achievement_Completed_Icon = 431       # Achievement_Completed_Icon = IconID
      Achievement_Points_color   = 21        # Achievement_Points_Color = ColorID
      Notification_Sound         = "Absorb2" # "SoundName"
      Notification_Window        = true      # Notification Window Enabled
       
    #===========================================================================
    # *** End of Editable Region
    #===========================================================================
     
      #--------------------------------------------------------------------------
      # * Get Achievement Categories
      #--------------------------------------------------------------------------
      def self.get_achievement_categories
        @achievement_categories = []
        Achievement_Categories.each { |value|
          @achievement_categories.push(value[0])
        }
        return @achievement_categories
      end
     
      #--------------------------------------------------------------------------
      # * Get Category Achievements
      #--------------------------------------------------------------------------
      def self.get_category_achievements
        category = []
        Achievement_Categories.each { |key|
          temp = []
          Achievements.each_value { |value|
            temp.push(value[:Name]) if value[:Category] == key[0]
          }
          category.push(temp.empty? ? 0 : temp)
        }
        return category
      end
     
      #--------------------------------------------------------------------------
      # * Tier?
      #--------------------------------------------------------------------------
      def self.tier?(item)
        progress = $game_party.achievements[find_achievement_index(item[:Name])]
        item[:Tiers].size.times { |i|
          return item[:Tiers].size - 1 if item[:Tiers][-1] == progress
          return i if item[:Tiers][i] > progress
        }
      end
     
      #--------------------------------------------------------------------------
      # * Locked?
      #--------------------------------------------------------------------------
      def self.locked?(item)
        item = Achievements[find_achievement_index(item)] if item.is_a?(String)
        return false if item[:Prerequisite] == :none
        return completed?(item) ? false : true
      end
      
      #--------------------------------------------------------------------------
      # * Completed?
      #--------------------------------------------------------------------------
      def self.completed?(item)
        index = item[:Prerequisite][0]
        limit = item[:Prerequisite][1]
        tier  = item[:Prerequisite][2]
        return $game_party.achievement_repeated[index] >= limit && $game_party.achievements[index] >= tier ? true : false
      end
     
     
      #--------------------------------------------------------------------------
      # * Find Achievement Index
      #--------------------------------------------------------------------------
      def self.find_achievement_index(item)
        Achievements.size.times { |index|
          return index if item == Achievements[index][:Name]
        }
      end
     
      #--------------------------------------------------------------------------
      # * Find Category Index
      #--------------------------------------------------------------------------
      def self.find_category_index(item)
        Achievement_Categories.size.times { |index|
          return index if item[index][0] == Achievement_Categories[index]
        }
      end
     
      #--------------------------------------------------------------------------
      # * Get Achievement Point Rewards
      #--------------------------------------------------------------------------
      def self.get_point_rewards
        Achievement_Point_Rewards.each { |value|
          return value[0] if value[0] > $game_party.achievement_points
        }
        return Achievement_Point_Rewards[-1][0]
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Status
      #--------------------------------------------------------------------------
      def self.get_achievement_status
        status = []
        Achievements.each_value { |value|
          value[:Prerequisite] == :none ? status.push(:Unlocked) : status.push(:Locked)
        }
        return status
      end
     
    end
     
    #===========================================================================
    # *** Window Menu Command
    #===========================================================================
    class Window_MenuCommand < Window_Command
     
      #--------------------------------------------------------------------------
      # * Aliases
      #--------------------------------------------------------------------------
      alias :clstn_achievements_add_original_commands :add_original_commands
      alias :clstn_achievements_initialize            :initialize
      
      #--------------------------------------------------------------------------
      # * Initialize
      #--------------------------------------------------------------------------
      def initialize 
        clstn_achievements_initialize
        $game_party.notifications.clear
        $game_party.notification_enabled = false
      end
     
      #--------------------------------------------------------------------------
      # * Original Command
      #--------------------------------------------------------------------------
      def add_original_commands
        clstn_achievements_add_original_commands
        add_command("Achievements", :achievements, true)
      end
     
    end
     
    #===========================================================================
    # *** Window Achievement Header
    #===========================================================================
    class Window_AchievementHeader < Window_Base
     
      #--------------------------------------------------------------------------
      # * Initialize
      #--------------------------------------------------------------------------
      def initialize
        super(0, 0, Graphics.width, 50)
        refresh
      end
     
      #--------------------------------------------------------------------------
      # * Refresh
      #--------------------------------------------------------------------------
      def refresh
        contents.font.size = 22
        next_reward = Clstn_Achievement_System::get_point_rewards
        change_color(text_color(Clstn_Achievement_System::Achievement_Points_color))
        draw_icon(Clstn_Achievement_System::Achievement_Points_Icon, 10, 0)
        draw_text(35, 1, contents.width, contents.height, $game_party.achievement_points)
        change_color(text_color(0))
        draw_text( 0, 1, contents.width, contents.height, "Next Reward: ", 1)
        change_color(text_color(Clstn_Achievement_System::Achievement_Points_color))
        draw_icon(Clstn_Achievement_System::Achievement_Points_Icon, 315, 1)
        draw_text(340, 2, contents.width, contents.height, next_reward)
      end
     
    end
     
    #===========================================================================
    # *** Window Achievement Info
    #===========================================================================
    class Window_AchievementInfo < Window_Base
     
      #--------------------------------------------------------------------------
      # * Initialize
      #--------------------------------------------------------------------------
      def initialize
        super(Graphics.width - 250, 50, Graphics.width - 295, Graphics.height - 50)
      end
     
      #--------------------------------------------------------------------------
      # * Refresh
      #--------------------------------------------------------------------------
      def refresh(item, symbol)
        contents.clear
        @item = item
        if symbol == :category
          draw_name
        elsif symbol == :achievement
          @index = Clstn_Achievement_System::find_achievement_index(item[:Name])
          draw_name(false)
          draw_progress
          draw_reward
        end
      end
     
      #--------------------------------------------------------------------------
      # * Draw Name
      #--------------------------------------------------------------------------
      def draw_name(enabled = true)
        draw_information(22, enabled ? 16 : 0, 0, 0, enabled ? @item[0] : @item[:Name], 1)
        draw_information(20, enabled ? 0 : 16, 0, 30, enabled ? @item[1] : @item[:Help])
      end
     
      #--------------------------------------------------------------------------
      # * Draw Progress
      #--------------------------------------------------------------------------
      def draw_progress
        tier = Clstn_Achievement_System::tier?(@item)
        draw_information(22,  0,  0,  60, "Progression")
        draw_horz_line(75)
        draw_information(20,  0,  0,  90,      "Tier: ")
        draw_information(20, 16, 50,  90,          tier)
        draw_information(20,  0,  0, 120, "Objective: ")
        draw_information(20, 16, 90, 120, $game_party.achievements[@index].to_s + "/" + @item[:Tiers][tier].to_s)
        draw_gauge(0, 142, contents.width, get_achievement_rate(@item[:Tiers][tier], @index), text_color(22), text_color(23))
      end
     
      #--------------------------------------------------------------------------
      # * Draw Rewards
      #--------------------------------------------------------------------------
      def draw_reward
        repeatable  = check_variable_condition(@item[:Repeatable],        false)
        gold        = check_variable_condition(@item[:RewardGold],        :none)
        points      = check_variable_condition(@item[:AchievementPoints], :none)
        title       = check_variable_condition(@item[:Title],             :none)
        item_reward = check_variable_condition(@item[:RewardItem],        :none)
        draw_horz_line(185)
        draw_information(22, 0, 0, 170, "Rewards")
        draw_information(20, 0, 0, 200,  "Item: ")
        if item_reward == "-"
          draw_information(20, 16, 50, 200, "-")
        else
          draw_item_name($game_party.get_item(item_reward), 50, 204, true, 172)
        end
        draw_information(20,  0,  0, 230,     "Gold: ")
        draw_information(20, 16, 50, 230,         gold)
        draw_information(20,  0,  0, 260,    "Title: ")
        draw_information(20, 16, 60, 260,        title)
        draw_information(20, 21, 25, 289,       points)
        draw_icon(Clstn_Achievement_System::Achievement_Points_Icon, 0, 290)
        draw_prerequisites(repeatable)
      end
      
      #--------------------------------------------------------------------------
      # * Draw Prerequisites
      #--------------------------------------------------------------------------
      def draw_prerequisites(repeatable)
        draw_information(18, 16,  0, 320, "Repeatable") if repeatable && $game_party.achievement_repeated[@index] == -1 && $game_party.achievement_status[@index] != :Locked
        draw_information(18, 16,  0, 320, "Repeated" + "  " + $game_party.achievement_repeated[@index].to_s + "/" + Clstn_Achievement_System::Achievements[@index][:Repeatable].to_s) if repeatable && $game_party.achievement_repeated[@index] >= 0
        pre_achievement = Clstn_Achievement_System::Achievements
        if $game_party.achievement_status[@index] == :Locked
          pre_achievement = Clstn_Achievement_System::Achievements
          current_information = $game_party.achievement_repeated[@item[:Prerequisite][0]] >= @item[:Prerequisite][1] ? 2 : 1
          time = (@item[:Prerequisite][current_information] - pre_achievement[@index][:Prerequisite][current_information]) == 1  ? "once" : " times"
          prerequisite = time == "once" ? "" : @item[:Prerequisite][current_information]
          draw_information(18, 16,  0, 320, line = current_information == 1 ? "Repeat " : "Update ") 
          draw_information(18, 21, text_size(line).width, 320, name = pre_achievement[@item[:Prerequisite][0]][:Name])
          draw_information(18, 16, text_size(line).width + text_size(name).width, 320, " " + prerequisite.to_s + time)
        end
      end
      
      #--------------------------------------------------------------------------
      # * Check Variable Condition
      #--------------------------------------------------------------------------
      def check_variable_condition(variable, condition)
        return variable == condition ? condition == false ? false : "-" : condition == false ? true : variable 
      end
      
      #--------------------------------------------------------------------------
      # * Draw Information
      #--------------------------------------------------------------------------
      def draw_information(font_size, color_id, x, y, text, allignment = 0)
        contents.font.size = font_size
        change_color(text_color(color_id))
        draw_text(x, y, contents.width, 30, text, allignment)
      end
     
      #--------------------------------------------------------------------------
      # * Draw Item Name
      #--------------------------------------------------------------------------
      def draw_item_name(item, x, y, enabled = true, width = 172)
        return unless item
        draw_icon(item.icon_index, x, y, enabled)
        change_color(text_color(16), enabled)
        draw_text(x + 24, y, width, line_height, item.name)
      end
     
      #--------------------------------------------------------------------------
      # * To Tier Number
      #--------------------------------------------------------------------------
      def to_tier(tier)
        case tier
        when 0
          return "I"
        when 1
          return "II"
        when 2
          return "III"
        when 3
          return "IV"
        when 4
          return "V"
        when 5
          return "VI"
        when 6
          return "VII"
        when 7
          return "VIII"
        when 8
          return "IX"
        when 9
          return "X"
        end
      end
     
      #--------------------------------------------------------------------------
      # * Get Achievement Rate
      #--------------------------------------------------------------------------
      def get_achievement_rate(objective, index)
        return ($game_party.achievements[index].to_f / objective.to_f)
      end
     
      #--------------------------------------------------------------------------
      # * Draw Horizontal Line
      #--------------------------------------------------------------------------
      def draw_horz_line(y)
        line_y = y + line_height / 2 - 1
        contents.fill_rect(0, line_y, contents_width, 2, text_color(16))
      end
     
    end
     
    #===========================================================================
    # *** Window Achievements
    #===========================================================================
    class Window_Achievements < Window_Selectable
     
      #--------------------------------------------------------------------------
      # * Initialize
      #--------------------------------------------------------------------------
      def initialize(x, y, width, height)
        super
        @achievement_info_window = Window_AchievementInfo.new
        @data = []
        @category = []
        @achievements = []
        @category_icons = []
        set_category_icons
        refresh
        select(0)
      end
     
      #--------------------------------------------------------------------------
      # * Category Icons
      #--------------------------------------------------------------------------
      def set_category_icons
        Clstn_Achievement_System::Achievement_Categories.each { |value|
          @category_icons.push(Clstn_Achievement_System::Category_Icon_Disabled)
        }
      end
     
      #--------------------------------------------------------------------------
      # * Get Item
      #--------------------------------------------------------------------------
      def item
        @data && index >= 0 ? @data[index] : nil
      end
     
      #--------------------------------------------------------------------------
      # * Get Item Max
      #--------------------------------------------------------------------------
      def item_max
        @data ? @data.size : 1
      end
     
      #--------------------------------------------------------------------------
      # * Make Item List
      #--------------------------------------------------------------------------
      def make_item_list
        @category = Clstn_Achievement_System::get_achievement_categories     unless !@category.empty?
        @achievements = Clstn_Achievement_System::get_category_achievements  unless !@achievements.empty?
        @data = Clstn_Achievement_System::get_achievement_categories         unless !@data.empty?
      end
     
      #--------------------------------------------------------------------------
      # * Draw Item
      #--------------------------------------------------------------------------
      def draw_item(index)
        contents.font.size = 22
        @category_helper = index == 0 ? index : @category_helper
        item = @data[index]
        rect = item_rect(index)
        change_color(text_color(0))
        if item && category?(item)
          draw_icon(@category_icons[@category_helper], rect.x + 10, rect.y)
          draw_text(rect.x + 40, rect.y, contents.width - 40, line_height, item)
          @category_helper += 1
        elsif item
          id = Clstn_Achievement_System::find_achievement_index(item)
          temp = find_item_achievement(item)
          change_color(text_color(21)) if $game_party.achievement_status[id] == :Completed && (Clstn_Achievement_System::Achievement_Display == :Color || Clstn_Achievement_System::Achievement_Display == :Both)
          if Clstn_Achievement_System::Achievement_Display == :Icon || Clstn_Achievement_System::Achievement_Display == :Both
            if $game_party.achievement_status[id] == :Completed
              icon = Clstn_Achievement_System::Achievement_Completed_Icon
            elsif $game_party.achievement_status[id] == :Locked
              icon = Clstn_Achievement_System::Achievement_Locked_Icon
            else
              icon = Clstn_Achievement_System::Achievement_Unlocked_Icon
            end
            draw_icon(icon, rect.x + 7, rect.y)
          else
            draw_icon(Clstn_Achievement_System::Achievement_Unlocked_Icon, rect.x + 7, rect.y)
          end
          draw_text(rect.x + 35, rect.y, rect.width, line_height, item)
          contents.font.size = 15
          change_color(text_color(16))
          draw_text(227, rect.y + 1, rect.width, line_height, "Locked") if $game_party.achievement_status[id] == :Locked
          change_color(text_color(0))
        end
      end
     
      #--------------------------------------------------------------------------
      # * Item Rect
      #--------------------------------------------------------------------------
      def item_rect(index)
        update_info_window(@data[index])
        x_spacing = category?(@data[index]) ? 0 : 20
        rect = Rect.new
        rect.width = item_width - x_spacing
        rect.height = item_height
        rect.x = index % col_max * (item_width + spacing) + x_spacing
        rect.y = index / col_max * item_height
        rect
      end
     
      #--------------------------------------------------------------------------
      # * Update Info Window
      #--------------------------------------------------------------------------
      def update_info_window(item)
        if category?(item)
          item = find_item_category(item)
          symbol = :category
        else
          item = find_item_achievement(item)
          symbol = :achievement
        end
        @achievement_info_window.refresh(item, symbol)
      end
     
      #--------------------------------------------------------------------------
      # * Find Item Achievement
      #--------------------------------------------------------------------------
      def find_item_achievement(item)
        Clstn_Achievement_System::Achievements.each_value { |value|
          return value if value[:Name] == item
        }
      end
     
      #--------------------------------------------------------------------------
      # * Find Item Category
      #--------------------------------------------------------------------------
      def find_item_category(item)
        Clstn_Achievement_System::Achievement_Categories.each { |value|
          return value if value[0] == item
        }
      end
     
      #--------------------------------------------------------------------------
      # * Expand
      #--------------------------------------------------------------------------
      def expand
        data_index = get_data_index(item)
        @category_index = get_category_index(item)
        if category?(item)
          @category_icons[@category_index] = @category_icons[@category_index] == Clstn_Achievement_System::Category_Icon_Enabled ? Clstn_Achievement_System::Category_Icon_Disabled : Clstn_Achievement_System::Category_Icon_Enabled
          if @achievements[@category_index] != 0
            @achievements[@category_index].size.times { |i|
              expanded?(@category_index) ? @data.insert(data_index + 1 + i, @achievements[@category_index][i]) : @data.delete_at(data_index + 1)
            }
          end
        end
        refresh
      end
     
      #--------------------------------------------------------------------------
      # * Get Category Index
      #--------------------------------------------------------------------------
      def get_category_index(item)
        @category.size.times { |index|
          return index if @category[index] == item
        }
      end
     
      #--------------------------------------------------------------------------
      # * Get Data Index
      #--------------------------------------------------------------------------
      def get_data_index(item)
        @data.size.times { |index|
          return index if @data[index] == item
        }
      end
     
      #--------------------------------------------------------------------------
      # * Expanded?
      #--------------------------------------------------------------------------
      def expanded?(index)
        return @category_icons[index] == Clstn_Achievement_System::Category_Icon_Enabled && @category[index] != 0 ? true : false
      end
     
      #--------------------------------------------------------------------------
      # * Category?
      #--------------------------------------------------------------------------
      def category?(item)
        return @category.include?(item)
      end
     
      #--------------------------------------------------------------------------
      # * Refresh
      #--------------------------------------------------------------------------
      def refresh
        make_item_list
        create_contents
        draw_all_items
      end
      
      #--------------------------------------------------------------------------
      # * Dispose
      #--------------------------------------------------------------------------
      def dispose
        super
        @achievement_info_window.dispose
      end
     
    end
     
    #===========================================================================
    # *** Class Window_AchievementNotification
    #===========================================================================
    class Window_AchievementNotification < Window_Base
     
      #--------------------------------------------------------------------------
      # * Initialize
      #--------------------------------------------------------------------------
      def initialize
        @window = $game_party.notifications[0][1]
        @item   = $game_party.notifications[0][0]
        super(x, 0, width, height)
        $game_party.notification_enabled = false
        refresh
      end
     
      #--------------------------------------------------------------------------
      # * Aliases
      #--------------------------------------------------------------------------
      alias :clstn_update_windowbase :update
     
      #--------------------------------------------------------------------------
      # * Get x
      #--------------------------------------------------------------------------
      def x
        case @window
        when :completed
          return Graphics.width / 4
        when :unlocked
          return Graphics.width / 4 + 28
        when :points
          return Graphics.width / 4 - 3
        end
      end
     
      #--------------------------------------------------------------------------
      # * Get Width
      #--------------------------------------------------------------------------
      def width
        case @window
        when :completed
          return Graphics.width / 2
        when :unlocked
          return Graphics.width / 2 - 56
        when :points
          return Graphics.width / 2 + 6
        end
      end
     
      #--------------------------------------------------------------------------
      # * Get Height
      #--------------------------------------------------------------------------
      def height
        case @window
        when :completed
          return Graphics.height - 310
        when :unlocked
          return 0 if @item.empty?
          return 50 + @item.size * 25
        when :points
          return 50 + @item[1].size * 26
        end
      end
     
      #--------------------------------------------------------------------------
      # * Refresh
      #--------------------------------------------------------------------------
      def refresh
        contents.clear
        RPG::SE.new(Clstn_Achievement_System::Notification_Sound, 80, 100).play
        case @window
        when :completed
          draw_completed
        when :unlocked
          draw_unlocked
        when :points
          draw_points
        end
      end
     
      #--------------------------------------------------------------------------
      # * Notification: Achievement Completed
      #--------------------------------------------------------------------------
      def draw_completed
        title = @item[:Title] == :none ? "-" : @item[:Title].to_s
        points =  @item[:AchievementPoints] == :none ? "-" : @item[:AchievementPoints]
        contents.font.size = 20
        draw_text(0, 0, contents.width, 20, "Achievement Completed!", 1)
        draw_horz_line(10)
        contents.font.size = 19
        draw_text(0, 20, contents.width, 30, @item[:Name], 1)
        draw_text(0, 40, contents.width, 30, "Title: " + title, 1)
        change_color(text_color(16))
        draw_icon(Clstn_Achievement_System::Achievement_Points_Icon, 90, 60)
        change_color(text_color(21))
        draw_text(115, 60, contents.width, 30, points, 0)
      end
     
      #--------------------------------------------------------------------------
      # * Notification: Achievement Unlocked
      #--------------------------------------------------------------------------
      def draw_unlocked
        contents.font.size = 20
        draw_text(0, 0, contents.width, 20, "Achievements Unlocked", 1)
        draw_horz_line(10)
        @item.size.times { |i|
          draw_text(0, 30 + 25 * i, contents.width, 20, @item[i], 1)
        }
      end
     
      #--------------------------------------------------------------------------
      # * Notification: Achievement Points Reached
      #--------------------------------------------------------------------------
      def draw_points
        draw_text(0, 0, contents.width, 20, "Achievement Point Rewards", 1)
        draw_horz_line(13)
        i = 0
        @item[1].each { |key|
          item = key
          draw_item_name($game_party.get_item(item), key[2], 0, 30 + 25 * i)
          i += 1
        }
      end
     
      #--------------------------------------------------------------------------
      # * Draw Item Name
      #--------------------------------------------------------------------------
      def draw_item_name(item, amount, x, y)
        return unless item
        contents.font.size = 21
        draw_icon(item.icon_index, x, y)
        draw_text(x + 24, y, contents.width, line_height, item.name)
        change_color(text_color(16))
        contents.font.size = 18
        draw_text(0, y - 1, contents.width, 30, "x" + amount.to_s, 2)
        change_color(text_color(0))
      end
     
      #--------------------------------------------------------------------------
      # * Draw Horizontal Line
      #--------------------------------------------------------------------------
      def draw_horz_line(y)
        line_y = y + line_height / 2 - 1
        contents.fill_rect(0, line_y, contents_width, 2, text_color(16))
      end
     
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      def update
        if !disposed? && self.opacity > 0
          self.opacity -= 1
          self.contents_opacity -= 1
          self.back_opacity -= 1
        else
          $game_party.notifications.delete_at(0) unless $game_party.notifications.empty?
          if !$game_party.notifications.empty?
            $game_party.notification_enabled = true
            SceneManager.call(Scene_Map) 
          else
            $game_party.notification_enabled = false
          end
        end
      end
     
    end
     
    #===========================================================================
    # *** Scene Menu
    #===========================================================================
    class Scene_Menu < Scene_MenuBase
     
      #--------------------------------------------------------------------------
      # * Aliases
      #--------------------------------------------------------------------------
      alias :clstn_create_command_window :create_command_window
     
      #--------------------------------------------------------------------------
      # * Create Command Window
      #--------------------------------------------------------------------------
      def create_command_window
        clstn_create_command_window
        @command_window.set_handler(:achievements, method(:command_achievements))
      end
     
      #--------------------------------------------------------------------------
      # * Command Achievements
      #--------------------------------------------------------------------------
      def command_achievements
        SceneManager.call(Scene_Achievements)
      end
     
    end
     
    #===========================================================================
    # *** Scene Achievements
    #===========================================================================
    class Scene_Achievements < Scene_Base
     
      #--------------------------------------------------------------------------
      # * Start Processing
      #--------------------------------------------------------------------------
      def start
        create_main_viewport
        create_achievement_windows
      end
     
      #--------------------------------------------------------------------------
      # * Create Achievement Window
      #--------------------------------------------------------------------------
      def create_achievement_windows
        create_achievement_header_window
        create_achievement_window
      end
     
      #--------------------------------------------------------------------------
      # * Create Achievement Header Window
      #--------------------------------------------------------------------------
      def create_achievement_header_window
         @achievementheader_window = Window_AchievementHeader.new
      end
     
      #--------------------------------------------------------------------------
      # * Create Achievement Window
      #--------------------------------------------------------------------------
      def create_achievement_window
        @achievement_window = Window_Achievements.new(0, 50, Graphics.width - 250, Graphics.height - 50)
        @achievement_window.set_handler(:ok,     method(:expand_ok   ))
        @achievement_window.set_handler(:cancel, method(:return_scene))
        @achievement_window.activate
      end
     
      #--------------------------------------------------------------------------
      # * Expand [OK]
      #--------------------------------------------------------------------------
      def expand_ok
        @achievement_window.expand
        @achievement_window.activate
      end
     
    end
     
    #===========================================================================
    # *** Class Scene_Map
    #===========================================================================
    class Scene_Map < Scene_Base
     
      #--------------------------------------------------------------------------
      # * Aliases
      #--------------------------------------------------------------------------
      alias :clstn_create_all_windows_scene_map :create_all_windows
     
      #--------------------------------------------------------------------------
      # * Create All Windows
      #--------------------------------------------------------------------------
      def create_all_windows
        clstn_create_all_windows_scene_map
        create_notification_window unless Clstn_Achievement_System::Notification_Window == false || $game_party.notification_enabled == false
      end
     
      #--------------------------------------------------------------------------
      # * Create Notification Window
      #--------------------------------------------------------------------------
      def create_notification_window
        @notification_window = Window_AchievementNotification.new
        @notification_window.viewport = @viewport
      end
     
    end
     
    #===========================================================================
    # *** Class Game_Party
    #===========================================================================
    class Game_Party < Game_Unit
     
      attr_accessor :achievements
      attr_accessor :achievement_points
      attr_accessor :achievement_repeated
      attr_accessor :achievement_status
      attr_accessor :notification_enabled
      attr_accessor :notifications
      #--------------------------------------------------------------------------
      # * Aliased
      #--------------------------------------------------------------------------
      alias :clstn_achievements_gameparty_initialize :initialize
     
      #--------------------------------------------------------------------------
      # * Initialize
      #--------------------------------------------------------------------------
      def initialize
        clstn_achievements_gameparty_initialize
        @notification_enabled = false
        @achievement_points = 0
        @notifications = []
        @achievements = []
        @achievement_repeated = []
        @achievement_status = []
        init_achievements
        init_achievement_repeated
        init_achievement_status
      end
     
      #--------------------------------------------------------------------------
      # * Initialize Achievements
      #--------------------------------------------------------------------------
      def init_achievements
        Clstn_Achievement_System::Achievements.each_value { |value|
          @achievements.push(0)
        }
      end
      
      #--------------------------------------------------------------------------
      # * Initialize Achievement Repeated
      #--------------------------------------------------------------------------
      def init_achievement_repeated
        Clstn_Achievement_System::Achievements.each_value { |value|
          @achievement_repeated.push(-1)
        }
      end
      
      #--------------------------------------------------------------------------
      # * Initialize Achievement Status
      #--------------------------------------------------------------------------
      def init_achievement_status
        @achievement_status = Clstn_Achievement_System::get_achievement_status
      end
     
      #--------------------------------------------------------------------------
      # * Achievement Completed
      #--------------------------------------------------------------------------
      def achievement_completed(index)
        array = Clstn_Achievement_System::Achievements[index]
        if @achievements[index] >= array[:Tiers][-1]
          check_status_completed(index)
          @achievements[index] = array[:Tiers][array[:Tiers].size - 1]
          next_reward = Clstn_Achievement_System::get_point_rewards
          gain_gold(array[:RewardGold])                                     unless array[:RewardGold]        == :none
          gain_item(get_item(array[:RewardItem]), array[:RewardItem][2])    unless array[:RewardItem]        == :none
          @achievement_points += array[:AchievementPoints]                  unless array[:AchievementPoints] == :none
          notification(array, :completed)
          next_achievement(next_reward)
        end
        unlocked = check_unlock(index)
        notification(unlocked, :unlocked) unless unlocked.empty?
      end
     
      #--------------------------------------------------------------------------
      # * Next Achievement
      #--------------------------------------------------------------------------
      def next_achievement(next_reward)
        if @achievement_points >= next_reward
          array = Clstn_Achievement_System::Achievement_Point_Rewards
          index = find_achievement_reward_index(next_reward)
          array[index][1].each { |key|
            item = key
            gain_item(get_item(item), key[2])
          }    
          notification(array[index], :points)
        end
      end
     
      #--------------------------------------------------------------------------
      # * Find Achievement Reward Index
      #--------------------------------------------------------------------------
      def find_achievement_reward_index(next_reward)
        array = Clstn_Achievement_System::Achievement_Point_Rewards
        array.size.times { |index|
          return index if array[index][0] == next_reward
        }
      end
      
      #--------------------------------------------------------------------------
      # * Check Status Completed
      #--------------------------------------------------------------------------
      def check_status_completed(index)
        array = Clstn_Achievement_System::Achievements[index]
        if array[:Repeatable] == false
          @achievement_status[index] = :Completed if array[:Tiers][-1] == @achievements[index]
        else
          @achievement_status[index] = :Completed if array[:Tiers][-1] == @achievements[index] && @achievement_repeated[index] == array[:Repeatable]
        end
      end
     
      #--------------------------------------------------------------------------
      # * Check Unlocked
      #--------------------------------------------------------------------------
      def check_unlock(index)
        unlocked = []
        item = Clstn_Achievement_System::Achievements
        Clstn_Achievement_System::Achievements.size.times { |i|
          unlocked.push(item[i][:Name]) if completed?(item[i], index, i)
        }
        return unlocked
      end
      
      #--------------------------------------------------------------------------
      # * Completed?
      #--------------------------------------------------------------------------
      def completed?(item, index, i)
        return false if item[:Prerequisite] == :none
        if item[:Prerequisite][0] == index
          limit = item[:Prerequisite][1]
          tier  = item[:Prerequisite][2]
          if @achievements[index] >= tier && @achievement_repeated[index] >= limit && @achievement_status[i] == :Locked
            @achievement_status[i] = :Unlocked
            return true
          else
            return false
          end
        end
      end
     
      #--------------------------------------------------------------------------
      # * Get Item
      #--------------------------------------------------------------------------
      def get_item(item)
        case item[0]
        when 0; item = $data_items[item[1]]
        when 1; item = $data_weapons[item[1]]
        when 2; item = $data_armors[item[1]]
        end
        return item
      end
     
      #--------------------------------------------------------------------------
      # * Notifications [Trigger]
      #--------------------------------------------------------------------------
      def notification(item, symbol)
        @notification_enabled = true
        temp = [item, symbol]
        @notifications.push(temp)
        SceneManager.call(Scene_Map) unless @notifications.size > 1
      end
     
    end
     
    #===========================================================================
    # *** Class Game_Interpreter
    #===========================================================================
    class Game_Interpreter
     
      #--------------------------------------------------------------------------
      # * Increase Achievements
      #--------------------------------------------------------------------------
      def gain_achievement(amount, index)
        item = Clstn_Achievement_System::Achievements[index]
        tier = Clstn_Achievement_System::tier?(Clstn_Achievement_System::Achievements[index])
        if $game_party.achievements[index] != item[:Tiers][-1]
          if !Clstn_Achievement_System::locked?(item)
            if amount <= item[:Tiers][tier]
              $game_party.achievements[index] += amount
              set_achievement(item[:Tiers][tier], index) if $game_party.achievements[index] > Clstn_Achievement_System::Achievements[index][:Tiers][tier]
            else
              set_achievement(item[:Tiers][tier], index)
            end
          end
          $game_party.achievement_completed(index)
          if $game_party.achievements[index] == item[:Tiers][-1] && item[:Repeatable] != false && item[:Repeatable] > $game_party.achievement_repeated[index]
            $game_party.achievements[index] = 0
            $game_party.achievement_repeated[index] += 1
          end
        end
      end
     
      #--------------------------------------------------------------------------
      # * Decrease Achievements
      #--------------------------------------------------------------------------
      def lose_achievement(amount, index)
        item = Clstn_Achievement_System::Achievements[index]
        if $game_party.achievements[index] != item[:Tiers][-1]
          $game_party.achievements[index] -= amount unless Clstn_Achievement_System::locked?(Clstn_Achievement_System::Achievements[index])
        end
      end
     
      #--------------------------------------------------------------------------
      # * Set Achievements
      #--------------------------------------------------------------------------
      def set_achievement(amount, index)
        item = Clstn_Achievement_System::Achievements[index]
        if $game_party.achievements[index] != item[:Tiers][-1]
          $game_party.achievements[index] = amount unless Clstn_Achievement_System::locked?(Clstn_Achievement_System::Achievements[index])
          $game_party.achievement_completed(index)
          if $game_party.achievements[index] == item[:Tiers][-1] && item[:Repeatable] != false && item[:Repeatable] > $game_party.achievement_repeated[index]
            $game_party.achievements[index] = 0
            $game_party.achievement_repeated[index] += 1
          end
        end
      end
     
      #--------------------------------------------------------------------------
      # * Gain Achievement Points
      #--------------------------------------------------------------------------
      def gain_achievement_points(amount)
        $game_party.achievement_points += amount
      end
     
      #--------------------------------------------------------------------------
      # * Lose Achievement Points
      #--------------------------------------------------------------------------
      def lose_achievement_points(amount)
        $game_party.achievement_points -= amount
      end
     
      #--------------------------------------------------------------------------
      # * Set Achievement Points
      #--------------------------------------------------------------------------
      def set_achievement_points(amount)
        $game_party.achievement_points = amount
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Name
      #--------------------------------------------------------------------------
      def achievement_name(index)
        return Clstn_Achievement_System::Achievements[index][:Name]
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Item Reward
      #--------------------------------------------------------------------------
      def achievement_item(index)
        return $game_party.get_item(Clstn_Achievement_System::Achievements[index][:RewardItem]).name
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Gold Reward
      #--------------------------------------------------------------------------
      def achievement_gold(index)
        return Clstn_Achievement_System::Achievements[index][:RewardGold]
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Points Reward
      #--------------------------------------------------------------------------
      def achievement_points(index)
        return Clstn_Achievement_System::Achievements[index][:AchievementPoints]
      end
      
      #--------------------------------------------------------------------------
      # * Disable Achievements
      #--------------------------------------------------------------------------
      def achievement_title(index)
        return Clstn_Achievement_System::Achievements[index][:Title]
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Times Repeated 
      #--------------------------------------------------------------------------
      def achievement_repeated(index)
        return $game_party.achievement_repeated[index]
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Progress
      #--------------------------------------------------------------------------
      def achievement_progress(index)
        return $game_party.achievements[index]
      end
      
      #--------------------------------------------------------------------------
      # * Get Achievement Status
      #--------------------------------------------------------------------------
      def achievement_status(index)
        return false if Clstn_Achievement_System::Achievement[index][:Repeatable] == false
        return $game_party.achievement_status[index]
      end
      
      #--------------------------------------------------------------------------
      # * Get Party Achievement Points
      #--------------------------------------------------------------------------
      def party_achievement_points
        return $game_party.achievement_points
      end
      
    end
     
    Last edited by a moderator: May 30, 2016
    #1
  2. Sharm

    Sharm Pixel Tile Artist Veteran

    Messages:
    12,619
    Likes Received:
    10,301
    Location:
    USA
    First Language:
    English
    Primarily Uses:
    N/A
    I've moved this thread to RGSSx Script Support.  I also put the script in a spoiler tag to make things easier for others to read.  Please be sure to post your threads in the correct forum next time. Thank you.
     
    #2

Share This Page