Paramecium Core

じ☆ve冰风

Paramecium Core

This is my core script, used by my other scripts. It contains classes and methods that may be useful to other script writers. It requires Paramecium Save Extensions.

The Script



##################################################                                                ##                Paramecium Core V 1             ##                August 22, 2015                 ##                                                ##################################################=beginThis is my core script, required for some of my other scripts. You may use the classes and methods in it in your scripts as long as you give me credit.=end($imported ||= {})["Paramecium"] = truemodule Paramecium#Contains some methods        #Uses the Box–Muller transform to generate normally distributed random numbers        def self.stnRand()                return Math.sqrt( -2 * Math.log(rand())) * Math.cos( 2 * Math:
I * rand())        end                #Generates normally distributed numbers with a mean of μ and a standard deviation of σ.        def self.nRand(μ,σ)                return μ + stnRand()* σ        end                #Performs a "skill check" with a difficulty level of 'difficulty'.        #returns true if the player (or whoever is performing the skill check)        #passes it and false if they fail. When the skill level is equal to the        #difficulty level, there is a fifty percent chance of passing. This        #method uses a default standard deviation of 2.5, which was chosen arbitrarily.        def self.skillCheck(skillLevel, difficulty,s = 2.5)                x = nRand(skillLevel, s)                return x >= difficulty        end        def self.show_selection(array)                params = []                choices = []                array.each{|item|                        choices.push(item[0])                }                                params.push(choices)                params.push(0)                params[0].each {|s| $game_message.choices.push(s) }                $game_message.choice_proc = Proc.new {|x| $paramecium_choice =(x) }        end                def self.get_choice(array)                array[$paramecium_choice][1]        end                        # This method calls a scene that shows a list of choices for the player and ]        # returns an object depending on their choice and the array you put into this        # method. The parameter 'array' is an array of the form:        #[["string_0",object_0],["string_1",object_1],...,["string_(n-1)",object_(n-1)]];        # with a length of n. The method will display the strings in a choice window,         # similar to the one used for events                def self.selection(array)                show_selection(array)                Fiber.yield until not $game_message.busy?                get_choice(array)        end                # This is similar to the above method but allows the user to select multiple values.        def self.multipleChoice(array,duplicates=false)                array << ["End","End"]                results = []                while true                        r = selection(array)                        r == "End" ? break : results << r                end                duplicates ? results : results.uniq || results        end        def self.invContains?(array,type)                case type.downcase[0,1]                when "i"                        getVal = Proc.new {|n| $game_party.item_number($data_items[n])}                when "w"                        getVal = Proc.new {|n| $game_party.item_number($data_weapons[n])}                when "a"                        getVal = Proc.new {|n| $game_party.item_number($data_armors[n])}                else                        return false                end                array.each {|entry|                        return false unless getVal.call(entry[0]) >= entry[1]                }        end        def self.changeInv(array,type)                case type.downcase[0,1]                when "i"                        change = Proc.new {|n, amount|                                if n >= 0                                        $game_party.gain_item($data_items[n], amount)                                else                                        $game_party.lose_item($data_items[n], amount)                                end                        }                when "w"                        change = Proc.new {|n, amount|                                if n >= 0                                        $game_party.gain_item($data_weapons[n], amount)                                else                                        $game_party.lose_item($data_weapons[n], amount)                                end                        }                when "a"                        change = Proc.new {|n, amount|                                if n >= 0                                        $game_party.gain_item($data_armors[n], amount)                                else                                        $game_party.lose_item($data_armors[n], amount)                                end                        }                else                        return false                end                array.each {|entry|                        change.call(entry[0],entry[1])                }        end        # Returns an array with the specified position(s) in its sub-arrays negated.        def self.negatePos(array,pos)                r = []                if pos.is_a? Array                        myCheck = Proc.new {|i| pos.include?(i)}                else                        myCheck = Proc.new {|i| i == pos}                end                array.each{|entry|                        entryClone = []                        entry.each_index {|i|                                entryClone.push(myCheck.call(i)? -1*entry : entry)                        }                        r.push(entryClone)                }                r        end                # Loads a square array of strings from a file.        def self.getStrArr(filename,min[=2],max[=4])                return nil unless FileTest.exist?(filename)                 strArr = []                i = 0                myFile = File.open(filename)                myFile.each_line {|line|                        strArr = line.scan(/\S{min,max}/)                        i += 1                }                return strArr        end        def self.intParse(str)                        end                EX_ACTION_HASH = {                :items => {                        17 => 1,                        13 => 2                },                :armors => {                        1 => 4,                        14 => 1                },                :weapons =>{                        18 => 3                },                :SE => ["wind7.ogg", 100, 100],        }                PROC_ACTIONS = {                :items => Proc.new{|items|                        items.each_pair{|id,n|                                n > 0 ? $game_party.gain_item($data_items[id], n) : $game_party.lose_item($data_items[id], n)                        }                },                :armors => Proc.new{|armors|                        armors.each_pair{|id,n|                                n > 0 ? $game_party.gain_item($data_armors[id], n) : $game_party.lose_item($data_armors[id], n)                        }                },                :weapons => Proc.new{|weapons|                        weapons.each_pair{|id,n|                                n > 0 ? $game_party.gain_item($data_armors[id], n) : $game_party.lose_item($data_armors[id], n)                        }                },                :SE => Proc.new {|args| Audio.se_play(args[0], args[1], args[2])}        }                # A method that does the commands in a hash, the things it does can all be done in events but this is        # useful when you want something to be entirely contained in a script (e.g. in the config) or for making        # something a bit more dynamic. I originally intended to add more functionality to this but I am currently        # working on something that will essentially the same thing but be better        def self.doAction(actHash)                actHash.each_pair{|key,value|                        PROC_ACTIONS[key].call(value) if PROC_ACTIONS[key]                }        end                class MultiMap                def initialize(hash)                        @data = hash                        @length = hash.length                        @domain = hash.keys                end                def image(x)                        return @hash[x]                end                def preImage(y)                        arr = Array.new                        for i in 0..@length-1                                if @data[@domain].index(y)                                        arr << @domain                                end                        end                        return arr                end                def compose(map)                        #...                end                def inverse                        #...                end        end                class Ranking        #         This implements a priority queue in which each element consists of an        # object (e.g a string, an array, or a number [such as an item id]) and a rank        # (e.g actor ID and number of skills), in that order. It is initialized from        # an array of the form:        #                         [[object-1,rank-1],[object-2,rank-2],...[object-n,rank-n]].        # The nested array [object-i,rank-i] is called an entry.         #        #        The methods 'max' and 'min' return the entries with the highest and lowest        # rankings respectively. When two or more entries have the same rank, it        # returns the one that has the lowest index in the array {i.e. that comes        # first).         #         The method 'sort!' sorts the data from highest ranked to lowest ranked. If        # two or more entries have the same rank, the one that had the        # lowest index before 'sort!' will have the lowest index after, with entries         # of equal rank following behind. The method 'add' adds another entry to the        # Ranking.        #         The method 'nextR!' returns the entry with the highest rank (in cases of         # equal rank, the same rule as above applies) and removes it from the Ranking.        #         The method 'next!' returns the object in the entry        # with the highest rank and removes its entry from the Ranking.        #                The 'blackjack(n)' method returns the object with the value closest to but        # not exceeding n, like in the card game blackjack the goal is to get as close        # to 21 without going over.        #         The 'blackjack!(n)' method does the same thing as 'blackjack' but also        # removes entry of the returned object.                def initialize(array)                        @data = array                        @length = array.length                end                def min                        m = @data[0]                        for i in 1..@length-1                                if @data[1]<m[1]                                        m = @data                                end                        end                        return m;                end                def max()                        m = @data[0]                        for i in 1..@length-1                                if @data[1]>m[1]                                        m = @data                                end                        end                        return m;                end                def sort!                        arr = Array.new                        for i in 0..@length-1                                arr <<self.nextR!                        end                        @data = arr                end                def add(newEntry)                        if newEntry.is_a?(Array) && newEntry[1].is_a(Numeric)                                @data << newEntry                                @length += 1                        end                end                def nextR!                        m = @data[0]                        index = 0                        for i in 1..@length-1                                if @data[1]>m[1]                                        m = @data                                        index = i                                end                        end                        @data.delete_at(index)                        @length -= 1                        return m;                end                def next!                        return self.nextR![0]                end                def blackjack(n)                        b = @data[0]                        for i in 1..@length-1                                if ((m[1]>n&&@data[1]<=n)||(@data[1]<n&&@data[1]>m[1]))                                        m = @data                                end                        end                        return m                end                def blackjack!(n)                        b = @data[0]                        index = 0                        for i in 1..@length-1                                if ((m[1]>n&&@data[1]<=n)||(@data[1]<n&&@data[1]>m[1]))                                        m = @data                                        index = i                                end                        end                        @data.delete_at(index)                        return m                end        end                class EventChannel        # This is a class for an event channel. Currently, all event channels are stored in the global variable        # '$Global_Events', which is a hash that stores them by name. I am considering making another global         # variable to store event channels for the current map and may do so in the future. Any object can subscribe        # to an event channel (using the subscribeTo method in the module Subscription). When subscribing, it must        # provide the name (as a symbol) of one of its methods. This method will be called whenever the event channel        # is published/fires/occurs. The method will be called with the arguments data, which is the data for the event,        # and sender, which is the object that sent the event. Any object can publish to any event (using a method in        # the module Publishing).                def initialize()                        @subscribers = {}                end                def subscribe(obj,m)                        @subscribers[obj] = m if m.is_a?(Symbol)                end                def unsubscribe(obj)                        @subscribers[obj] = nil                end                def publish(data,sender)                        return unless @subscribers && (not @subscibers.empty?)                        @subscribers.each_pair{|obj,m|                                obj.method(m).call(data,sender)                        }                end        end                # This is the module for subscribing to events. 'include' this in any class you want to make        # subscribe to events. To make an object subscribe to an event, call the method 'subscribeTo(event,m)'        # where 'event' is the name of the event channel for it to subscribe to (if the event channel        # does not exist, it will create a new one.)        module Subscription                def subscribeTo(event,m)                        ($Global_Events[event]||=EventChannel.new).subscribe(self,m)                end                def unsubscribeTo(event)                        ($Global_Events[event]||=EventChannel.new).unsubscribe(self)                end        end                # This method allows objects to publish events. 'include' this in any class you want to make        # publish events. To make an object publish an event, call the method 'publish(event,data)'        # where 'event' is the name of the event and 'data' is the data to publish.        module Publishing                def publish(event,data)                        return unless $Global_Events[event]                        $Global_Events[event].publish(data,self)                end                def anonPublish(event,data)                        return unless $Global_Events[event]                        $Global_Events[event].publish(data,nil)                end        end        end# Adds two new methods to the 'Array' classclass Array        # Is this array a subset of 'other'? (i.e are all elements of this array         # elements of the other array?)        def subset?(other)                self.each{|item|                        return false unless other.include?(item)                }                return true        end        # Is this array a superset of 'other' (is 'other' a subset of this array)?         # (i.e are all elements of the other array elements of this array?)        def superset?(other)                other.subset?(self)        end        # Does 'other' have the same elements as 'self' and 'self' the same elements        # as 'other'?         # [Are the two arrays equal, ignoring order?]                def setEquals?(other)                self.subset?(other) && self.superset?(other)        end        unless $imported[:ve_basic_module]                def random                        self[rand(self.length)]                end        endendSaveExtensions::New_Game_Procs.push(Proc.new{        $Global_Events = {}})SaveExtensions::Save_Procs.push(Proc.new{|contents|        contents[:eventChannels]  = $Global_Events})SaveExtensions::Load_Procs.push(Proc.new{|contents|        $Global_Events  = contents[:eventChannels]}) 

Event Based Programming: Creating a Kill Counter 

Here is a script that uses the tools for event based programming in Paramecium Core to to create a kill counter.



class KillCounter# Stored in the global variable $KillCount        include Paramecium::Subscription        def initialize                @count = Hash.new(0)                subscribeTo("EnemyDeath",:updateCount)        end        # Call this method ($KillCount.count(key)) to get the kill count for enemy_id 'key'.        def count(key)                return @count[key] if key.is_a?(Integer)        end        # This is the method that it provides when it subscribes to the "EnemyDeath" event channel        def updateCount(data,sender)                @count[sender.enemy_id] += 1        endend# This makes enemies publish to the event channel "EnemyDeath" when they die.class Game_Enemy < Game_Battler        alias oldDie die        include Paramecium:
ublishing        def die                publish("EnemyDeath",nil)                oldDie                endendSaveExtensions::New_Game_Procs.push(Proc.new{        $KillCount = KillCounter.new})SaveExtensions::Save_Procs.push(Proc.new{|contents|        contents[:kilCount]       = $KillCount})SaveExtensions::Load_Procs.push(Proc.new{|contents|        $KillCount      = contents[:kilCount]}) 

Terms of Use

This script is free to use in any commercial or non-commercial game provided I am given Credit.


本贴来自国际rpgmaker官方论坛作者:Paramecium13处,因国际论坛即将永久关站,为了存档多年珍贵资料,署名转载到本论坛存档,由于官方帖子为英文原帖，需要中文翻译请点击论坛顶部切换语言为中文就可以将帖子翻译成中文浏览,方便大家随时查看,原文地址：https://forums.rpgmakerweb.com/threads/paramecium-core.43988/