Jump to content

meko

Core Developers
  • Content Count

    363
  • Joined

  • Days Won

    46

Files posted by meko

  1. Hash table

    This plugin exposes the internal hash table (strdb) to the script engine to provide a key-value store.
    See documentation on hercules-hashtable/doc/script_commands.txt
     
    Download here: https://github.com/Helianthella/hercules-hashtable

    7 downloads

    0 comments

    Updated

  2. Randomization helper functions

    This script provides syntactic sugar for randomization.
    Works fine with both strings and integers.
     
     
    any(<arg>{, <arg>{, ...}})
    > returns a random argument from the passed arguments
    emotion(any(e_hmm, e_grat, e_yawn)); // do any of those 3 emotes  


    any_of(<array>)
    > returns a random entry from the passed array setarray(.@foo, 1, 2, 3, 4); // build the array // ... later in the code: mes(any_of(.@foo)); // print any number from the array  


    relative_array_random(<array: 0, {[value, probability]...}>{, <recalculate>})
    a more powerful version of any_of(), which allows to assign arbitrary probabilities to every entry instead of being rand(size) for every one.
    the first value of the array is reserved and must be 0, and every entry must be a tuple of [value, probability].
    if the array is modified between invocations please pass true as second argument to re-calculate the total probability.
    probabilities are arbitrary and can be any number between 1 and INT_MAX.
    > returns the random entry
    setarray(.@foo, 0, // <= always 0 111, 6, 222, 12, // <= [value, probability] 333, 20, 444, 4); relative_array_random(.@foo); // => 333 (example, unpredictable)  
     
     
    --------------------------------------------------------------------------------------
    This script was made by me, for The Mana World + Evol.
    License: public domain (CC0)

    24 downloads

    0 comments

    Updated

  3. Area timer functions

    This script provides functions to add (or remove) timers to every player in the area or map.
     
     
     
    areatimer("<map>", <x1>, <y1>, <x2>, <y2>, <tick>, "<event>")
    makes all players in the square area call <event> after <tick> ms
    > returns the number of affected players
    areatimer("prontera", 55, 60, 150, 180, 500, "MyNPC:MyEvent");    
     
    areatimer2("<map>", <x1>, <y1>, <x2>, <y2>, <tick>, "<event>")
    identical to areatimer, but also removes any existing timer before adding the new one
    > returns the number of affected players
    areatimer2("prontera", 55, 60, 150, 180, 500, "MyNPC:MyEvent");    
     
    areadeltimer("<map>", <x1>, <y1>, <x2>, <y2>, "<event>")
    makes all players in the square area remove their timers for <event>
    > returns the number of affected players
    areadeltimer("prontera", 55, 60, 150, 180, "MyNPC:MyEvent");    
     
    maptimer("<map>", <tick>, "<event>")
    makes all players in the map call <event> after <tick> ms
    > returns the number of affected players
    maptimer("prontera", 500, "MyNPC:MyEvent");    
     
    maptimer2("<map>", <tick>, "<event>")
    identical to maptimer() but also removes any existing timer before adding the new one
    > returns the number of affected players
    maptimer2("prontera", 500, "MyNPC:MyEvent");    
     
    mapdeltimer("<map>", "<event>")
    makes all players on the map remove their timers for <event>
    > returns the number of affected players
    mapdeltimer("prontera", "MyNPC:MyEvent");         globaltimer(<tick>, "<event>")
    makes all players everywhere call <event> after <tick> ms
    > returns the number of affected players globaltimer(500, "MyNPC:MyEvent");  
     
     
     
    Requires Hercules v2018.06.03 or newer version
     
     
    --------------------------------------------------------------------------------------
    This script was made by me, for The Mana World + Evol.
    License: public domain (CC0)

    36 downloads

    0 comments

    Updated

  4. Array manipulation functions

    This script provides various array manipulation functions, and more might be added in the future.
    All of those functions (except the arithmetic ones) work with both integer and string arrays.
    The start of the array is always implicitly index 0, unless an index is specified, ie @array[index]



    array_pad(<array>, <size>, <value>)
    pads the array left or right with <value> until it reaches <size> size. If <size> is negative it will pad left.
    > returns the number of added entries
    setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_pad(.@foo, 8, 69); // => 3 // array is now: 1, 2, 3, 4, 5, 69, 69, 69 setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_pad(.@foo, -8, 69); // => 3 // array is now: 69, 69, 69, 1, 2, 3, 4, 5


    array_replace(<array>, <needle>, <replacement>{, <neq>})
    finds every occurrence of <needle> within the array and replaces it with <replacement>. if <neq> is true, finds entries that do not match instead
    > returns the number of changed entries setarray(.@foo, 1, 1, 3, 1, 5); // initialize the array array_replace(.@foo, 1, 69); // => 3 // array is now: 69, 69, 3, 69, 5


    array_find(<array>, <needle>{, <neq>})
    finds the first occurrence of <needle> within the array. if <neq> is true, finds entries that do not match instead
    > returns the index, or if none is found returns -1 setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_find(.@foo, 3); // => 2 array_find(.@foo, 1); // => 0 array_find(.@foo, 6); // => -1


    array_rfind(<array>, <needle>{, <neq>})
    like array_find, but finds the last occurrence. if <neq> is true, finds entries that do not match instead
    > returns the index, or if none is found returns -1 setarray(.@foo, 1, 2, 3, 4, 3); // initialize the array array_rfind(.@foo, 3); // => 4 array_rfind(.@foo, 4); // => 3 array_rfind(.@foo, 6); // => -1


    array_exists(<array>, <needle>{, <neq>})
    very similar to array_find() but it instead just checks if it exists or not. if <neq> is true, finds entries that do not match instead > returns true or false setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_exists(.@foo, 3); // => true array_exists(.@foo, 6); // => false


    array_count(<array>, <needle>{, <neq>})
    similar to array_find() but iterates through the whole array. if <neq> is true, finds entries that do not match instead
    > returns the total number of occurrences of <needle> setarray(.@foo, 1, 69, 3, 69, 5); // initialize the array array_count(.@foo, 69); // => 2


    array_entries(<array>)
    a wrapper around array_count(). behaves similarly to getaraysize() but does not count holes
    > returns the number of non-empty entries setarray(.@foo, 1, 2, 0, 0, 5); // initialize the array getarraysize(.@foo); // => 5 array_entries(.@foo); // => 3



    array_remove(<array>, <needle>{, <neq>})
    finds and removes every occurrence of <needle> from the array, while shifting left. if <neq> is true, finds entries that do not match instead
    > returns the number of removed entries setarray(.@foo, 1, 69, 3, 69, 5); // initialize the array array_remove(.@foo, 69); // => 2 // array is now: 1, 3, 5


    array_reverse(<array>)
    reverses the array
    > returns true setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_reverse(.@foo); // => true // array is now: 5, 4, 3, 2, 1


    array_sum(<array>)
    iterates through the whole array to perform an arithmetic addition
    > returns the sum of every entries of the array setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_sum(.@foo); // ((((1 + 2) + 3) + 4) + 5) => 15


    array_difference(<array>)
    iterates through the whole array to perform an arithmetic subtraction
    > returns the difference of every entries of the array setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_difference(.@foo); // ((((1 - 2) - 3) - 4) - 5) => -13


    array_product(<array>)
    iterates through the whole array to perform an arithmetic multiplication
    > returns the product of every entries of the array setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_product(.@foo); // ((((1 * 2) * 3) * 4) * 5) => 120


    array_quotient(<array>)
    iterates through the whole array to perform an arithmetic division
    > returns the quotient of every entries of the array setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_quotient(.@foo); // ((((1 / 2) / 3) / 4) / 5) => 0


    array_shift(<array>)
    removes the first entry of the array, while shifting left
    > returns the value of the removed entry setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_shift(.@foo); // => 1 // array is now: 2, 3, 4, 5


    array_unshift(<array>, <value>)
    adds <value> to the start of the array, while shifting right
    > returns the new size of the array setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_unshift(.@foo, 69); // => 6 // array is now: 69, 1, 2, 3, 4, 5


    array_pop(<array>)
    removes the last entry of the array
    > returns the value of the removed entry setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_pop(.@foo); // => 5 // array is now: 1, 2, 3, 4


    array_push(<array>, <value>)
    adds <value> to the end of the array
    > returns the new size of the array setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_push(.@foo, 69); // => 6 // array is now: 1, 2, 3, 4, 5, 69


    array_shuffle(<array>)
    shuffles the array
    > returns true setarray(.@foo, 1, 2, 3, 4, 5); // initialize the array array_shuffle(.@foo); // => true // array is now: 1, 4, 2, 3, 5 (example, unpredictable)


    array_unique(<array>{, <threshold>})
    allows array entries to appear up to <threshold> times (1 by default) and removes the extraneous ones. useful to remove duplicate entries
    > returns the number of removed entries
    setarray(.@foo, 1, 3, 3, 4, 5); // initialize the array array_unique(.@foo); // => 1 // array is now: 1, 3, 4, 5


    array_diff(<base array>, <array>{, <array>...}, <result array>)
    compares the base array against one or more other arrays and fills the result array with the entries in base array that are not present in any of the other arrays
    > returns the number of entries not found in other arrays
    setarray(.@base, 1, 2, 3, 4, 5, 6, 7, 8); // initialize the base array // fill the arrays to compare with the base array: setarray(.@foo, 2, 3, 4, 5, 6, 7, 8); // missing "1" setarray(.@bar, 1, 2, 3, 4, 6, 7, 8); // missing "5" setarray(.@baz, 1, 2, 3, 4, 5, 6, 7); // missing "8" // compare foo, bar and baz against base, and fill result: array_diff(.@base, .@foo, .@bar, .@baz, .@result); // => 3 // .@result is now: 1, 5, 8


    array_filter(<array>, "<function>")
    filters the array using a function that is tested against every entries. if the function returns false, the relevant entry is removed and the array is shifted left
    > returns the number of removed entries
    function script is_prime { if (getarg(0) <= 1) return false; for (.@i = 2; .@i <= getarg(0) / 2; ++.@i) if ((getarg(0) % .@i) == 0) return false; return true; } setarray(.@foo, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); array_filter(.@foo, "is_prime"); // => 9 // array is now: 2, 3, 5, 7, 11, 13


    array_sort(<array>)
    sorts the array in ascending order
    > returns true
    setarray(.@foo, 2, 1, 8, 4, 5, 7, 6, 3); // initialize the array array_sort(.@foo); // => true // array is now: 1, 2, 3, 4, 5, 6, 7, 8


    array_rsort(<array>)
    sorts the array in descending order
    > returns true
    setarray(.@foo, 2, 1, 8, 4, 5, 7, 6, 3); // initialize the array array_rsort(.@foo); // => true // array is now: 8, 7, 6, 5, 4, 3, 2, 1



    Requires Hercules of June 24 2017 or newer version


     
    --------------------------------------------------------------------------------------
    This script was made by me, for The Mana World + Evol.
    License: public domain (CC0)

    262 downloads

    14 comments

    Updated

  5. Date and Time functions

    This script provides functions to easily calculate date and time. More functions might be added in the future.
     
     
    now()
    a shorthand function to get the current time
    > returns the number of seconds elapsed since the Unix epoch
    now() // => 1497119219 (example, increments every second)


    time_from_ms(<delta>)
    calculates a Unix timestamp relative to the current time
    > returns the number of seconds elapsed since the Unix epoch, plus or minus <delta> ms
    time_from_ms(0) // => 1497119219 (example, increments every second) time_from_ms(+1000) // => 1497119220 time_from_ms(-1000) // => 1497119218


    time_from_seconds(<delta>)
    calculates a Unix timestamp relative to the current time
    > returns the number of seconds elapsed since the Unix epoch, plus or minus <delta> seconds
    time_from_seconds(0) // => 1497119219 (example, increments every second) time_from_seconds(+1) // => 1497119220 time_from_seconds(-1) // => 1497119218


    time_from_minutes(<delta>)
    calculates a Unix timestamp relative to the current time
    > returns the number of seconds elapsed since the Unix epoch, plus or minus <delta> minutes
    time_from_minutes(0) // => 1497119219 (example, increments every second) time_from_minutes(+1) // => 1497119279 time_from_minutes(-1) // => 1497119159


    time_from_hours(<delta>)
    calculates a Unix timestamp relative to the current time
    > returns the number of seconds elapsed since the Unix epoch, plus or minus <delta> hours
    time_from_hours(0) // => 1497119219 (example, increments every second) time_from_hours(+1) // => 1497122819 time_from_hours(-1) // => 1497115619


    time_from_days(<delta>)
    calculates a Unix timestamp relative to the current time
    > returns the number of seconds elapsed since the Unix epoch, plus or minus <delta> days
    time_from_days(0) // => 1497119219 (example, increments every second) time_from_days(+1) // => 1497205619 time_from_days(-1) // => 1497032819


    FuzzyTime(<unix timestamp>)
    converts a Unix timestamp to a human-readable format
    > returns human-friendly relative time
    FuzzyTime(0) // => 47 years, 172 days, 18 hours, 52 minutes, and 28 seconds ago FuzzyTime(time_from_hours(+28)) // => in 1 day and 4 hours

     
    --------------------------------------------------------------------------------------
    This script was made by me, for The Mana World + Evol.
    License: public domain (CC0)

    59 downloads

    0 comments

    Updated

  6. Safe string manipulation functions

    This script provides safe string manipulation functions that do not require PCRE to be enabled at compile time, making your scripts more portable.



    startswith("<string>", "<substring>")
    returns true if <string> begins with <substring>
    startswith("hypothermia", "hypo") // true startswith("hypothermia", "hyper") // false


    endswith("<string>", "<substring>")
    returns true if <string> ends with <substring> endswith("hypothermia", "thermia") // true endswith("hypothermia", "glycemia") // false


    capitalize("<string>")
    returns <string> with its first letter being capitalized capitalize("the quick brown fox") // The quick brown fox


    titlecase("<string>")
    returns <string> with the first letter of every word capitalized titlecase("the quick brown fox") // The Quick Brown Fox


    camelcase("<string>")
    returns <string> concatenated in a camelCase fashion camelcase("the quick brown fox") // theQuickBrownFox


    zfill("<string>"{, <width>{, "<padding>"}})
    returns <string> padded to the left up to <width> with <padding> zfill(69, 6, "0"); // 000069 zfill(1337, 6, "0"); // 001337


    format_number(<number>{, "<separator>"})
    formats a number with <separator> format_number(50) // 50 format_number(50000) // 50,000 format_number(5000000) // 5,000,000


    strip("<string>")
    returns <string> without spaces at the beginning or end strip(" the quick brown fox") // "the quick brown fox" strip("the quick brown fox ") // "the quick brown fox" strip(" the quick brown fox ") // "the quick brown fox"


    reverse("<string>")
    returns <string> reversed reverse("Hello world!") // !dlrow olleH


    repeat("<string>", <multiplier>)
    repeats <string> <multiplier> times repeat("Foo", 4) // FooFooFooFoo


    shuffle("<string>")
    returns <string> shuffled
    shuffle("abcdefg") // dgabefc (example, unpredictable)
     

    23 downloads

    0 comments

    Updated

  7. Soul Menhir

    The Soul Menhir slowly regenerates the SP of anyone sitting near it.
     
    Make sure to change the map, x, y and the sprite.
     
     
    Requires Hercules of April 8th 2017 or newer version
     
     
    --------------------------------------------------------------------------------------
    This script was made by me, for The Mana World + Evol.
    License: public domain (CC0)

    129 downloads

    0 comments

    Updated

×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.