Background for Skyrim SE

The clib Script

    The clib script is a part of Skyrim SE’s Papyrus scripting ecosystem. This script is not present in the vanilla game, but can be found in modded sources like cLib-Papyrus Function Library (cLib).

    For this script, the Papyrus index knows about:

    • 400 functions


    Inheritance Tree

    No indexed scripts extend this script.

    Properties

    No properties found.

      Events

        No events found.

      Functions

      • intfunctioncGetVersion()Global

        Requirements: None

      • voidfunctionp(stringmsg)Global
      • FormfunctioncGetForm(intdecForm, stringhexForm="", stringmodName="")Global

        ====== Query/Analysis

        resolve form

      • Form[]functioncArrayHexIDToForms(string[]aArray, stringesXName, boolskipNones=true, booluseSKSE=true)Global

        Get forms from file
        ==> If all forms from same mod

      • Form[]functioncArrayIntIDToForms(int[]aArray, stringesXName, boolskipNones=true, booluseSKSE=true)Global

        ==> If all forms from same mod

      • Form[]functioncArrayIntIDModNamesToForms(int[]aArray, string[]esXName, boolskipNones=true, booluseSKSE=true)Global

        ==> Each can be different mod, String[] to supply name for each

      • Form[]functioncArrayHexIDModNamesToForms(string[]aArray, string[]esXNames, boolclearNones=true, booluseSKSE=true)Global

        ==> Each can be different mod, String[] to supply name for each

      • intfunctioncGetSKSEType(FormaForm, booluseSKSE=true)Global

        Non-SKSE version only works for inventory items that use 'vendor' type keywords which means that
        more obscure items could be missed but it covers quite a lot tbh (10,664 references)

      • FormfunctioncGetOwner(ObjectReferenceaObjectRef)Global

        Determine ownership

      • boolfunctioncIsPlayerOwner(ObjectReferenceaObjectRef, ActorplayerAct=NONE)Global

        Requirements: None

      • Requirements: None

      • boolfunctioncIsContainer(ObjectReferenceaObjectRef, booluseSKSE=true)Global

        Object query

      • stringfunctioncGetItemName(FormaForm, boolsimple=false)Global

        !simple appends "No Name-" to hexFormID return

      • string[]functioncArrayNameFromForms(Form[]aArray)Global

        Requirements: None

      • string[]functioncArrayNameFromFL(FormListaFormList)Global

        Requirements: None

      • intfunctioncGetIntSubID(intdecForm, stringhexForm="", FormaForm=NONE)Global

        used in GetFormFromFile

      • stringfunctioncGetHexSubID(intdecForm, stringhexForm="", FormaForm=NONE)Global

        Returns last 3 hex digits for light or 6 in regular. Input for this function assumes some prior
        validation. FormIDs must be 'fully loaded' (e.g. hexForm must be 8 digits). Using aForm argument
        requires that it be currently loaded but decForm || hexForm arguments does not

      • stringfunctioncGetHexIDFromForm(FormaForm)Global

        Requirements: None

      • int[]functioncArrayHexStringsToDecimal(string[]aArray)Global

        without SKSE array creation is limited to 128!

      • string[]functioncArrayDecimalsToHexStrings(int[]aArray)Global

        Requirements: None

      • boolfunctioncIDInVanillaRange(intdecForm, stringhexForm="", FormaForm=NONE)Global

        Requires full formID of a loaded plugin
        Checks if the dec FormID value is between 0 and SSEEdit value for next form in Dragonborn.esm
        NOTE: Injected records cannot be differentiated. This does not mean the form is valid, only that it's in range
        however, apart from this caveat it does confirm that it is not from a mod use cGetForm to test validity

      • boolfunctioncIsLight(stringhexForm="", intdecForm=0, FormformVar=NONE, booluseSKSE=true)Global

        ====== Mod Functions

      • intfunctioncArrayAddLVLI(LeveledItemaLeveledList, Form[]aArray, intlevel, intcount)Global

        ====== Leveled Item Lists
        all items in the form must have the same level and count

      • intfunctioncArrayAllAddLVLI(LeveledItemaLeveledList, Form[]aArray, int[]levels, int[]counts)Global

        accepts arrays for all three arguments, forms, levelss, countss
        Note: the levels and counts arrays use the cWrapInt function. This allows the following:
        A 21 index form array and levels and counts arrays of 7 forms each:
        Form[0] -> levels[0] -> counts[0]
        ...
        Form[6] -> levels[6] -> counts[6]
        Form[7] -> levels[0] -> counts[0]
        ...
        Form[13] -> levels[6] -> counts[6]
        Form[14] -> levels[0] -> counts[0]
        If all arrays are equal in size it will of course proceed in normal fashion

      • Form[]functioncGetAllEquippedForms(ActoraActor, intslot=-1)Global

        Requirement: None

      • stringfunctioncGetCellXYAsString(ObjectReferenceaObjectRef)Global

        Learned from Ashen thanks!!!
        Player Cell Position: https://www.nexusmods.com/skyrimspecialedition/mods/46173
        Convenience for display/messages
        Grid Map for reference
        https://docs.google.com/spreadsheets/d/1yhsNb12btLWpRNRIpZ2DfjVsWR946qEZTmVML_Wi9U8/edit?usp=sharing

      • int[]functioncGetCKCoordsFromXY(floatxVar, floatyVar, ObjectReferenceaObjectRef=NONE)Global

        If aObjectRef is provided then xVar and yVar are overwritten by its position
        Grid Map for reference
        https://docs.google.com/spreadsheets/d/1yhsNb12btLWpRNRIpZ2DfjVsWR946qEZTmVML_Wi9U8/edit?usp=sharing

      • float[]functioncGetCoCXYFromCKCoords(intckX, intckY, ObjectReferenceaObjectRef=NONE)Global

        If aObjectRef is provided then ckX and ckY are overwritten by its position
        Grid Map for reference
        https://docs.google.com/spreadsheets/d/1yhsNb12btLWpRNRIpZ2DfjVsWR946qEZTmVML_Wi9U8/edit?usp=sharing

      • float[]functioncArrayGetDistancesObjRef(ObjectReferenceaObj, ObjectReference[]aArray)Global

        get the distances of array of objects from object aObj

      • float[]functioncArrayGetAngle(ObjectReferenceaObj)Global

        .Get*() as an array && .Set*() accepts array

      • voidfunctioncArraySetAngle(ObjectReferenceaObj, float[]aArray)Global

        Requirements: None

      • float[]functioncArrayGetPosition(ObjectReferenceaObj)Global

        Requirements: None

      • voidfunctioncArraySetPosition(ObjectReferenceaObj, float[]aArray)Global

        Requirements: None

      • float[]functioncArrayGetPlacement(ObjectReferenceaObj)Global

        Placement == PosX&&PosY&&PosZ&&AngX&&AngY&&AngZ

      • voidfunctioncArraySetPlacement(ObjectReferenceaObj, float[]aArray)Global

        Requirements: None

      • voidfunctioncArrayTranslateTo(ObjectReferenceaObj, float[]pArray, floatspeed=50.0, floatmaxSpeed=0.0)Global

        Accepts placement array as an argument

      • ActorfunctioncTernaryActor(boolifThis, ActorreturnThis, ActorelseThis=NONE)Global

        ========================= Conditional statements
        NOTE: These functions can't short circuit like a traditional ternary. Thus, they're most efficient if only
        one argument is a function. If both are functions they both will be run before returning a value;
        Nesting these functions is perfectly fine with numbers or operator calculations but know this: nesting
        with multiple functions as arguments will results in allllll of the function being called. Use of
        traditional if/then is recommended in those cases. Nexting ternary functions inside if thens works
        great though (and will still shave lines off)

        Single value returns

      • AliasfunctioncTernaryAlias(boolifThis, AliasreturnThis, AliaselseThis=NONE)Global

        Requirements: None

      • floatfunctioncTernaryFloat(boolifThis, floatreturnThis, floatelseThis=0.0)Global

        Requirements: None

      • FormfunctioncTernaryForm(boolifThis, FormreturnThis, FormelseThis=NONE)Global

        Requirements: None

      • intfunctioncTernaryInt(boolifThis, intreturnThis, intelseThis=0)Global

        Requirements: None

      • ObjectReferencefunctioncTernaryObjRef(boolifThis, ObjectReferencereturnThis, ObjectReferenceelseThis=NONE)Global

        Requirements: None

      • stringfunctioncTernaryString(boolifThis, stringreturnThis, stringelseThis="")Global

        Requirements: None

      • Actor[]functioncTernaryArrayActor(boolifThis, Actor[]returnThis, Actor[]elseThis)Global

        Array returns

      • Alias[]functioncTernaryArrayAlias(boolifThis, Alias[]returnThis, Alias[]elseThis)Global

        Requirements: None

      • bool[]functioncTernaryArrayBool(boolifThis, bool[]returnThis, bool[]elseThis)Global

        Requirements: None

      • float[]functioncTernaryArrayFloat(boolifThis, float[]returnThis, float[]elseThis)Global

        Requirements: None

      • Form[]functioncTernaryArrayForm(boolifThis, Form[]returnThis, Form[]elseThis)Global

        Requirements: None

      • int[]functioncTernaryArrayInt(boolifThis, int[]returnThis, int[]elseThis)Global

        Requirements: None

      • ObjectReference[]functioncTernaryArrayObjRef(boolifThis, ObjectReference[]returnThis, ObjectReference[]elseThis)Global

        Requirements: None

      • string[]functioncTernaryArrayString(boolifThis, string[]returnThis, string[]elseThis)Global

        Requirements: None

      • ActorfunctioncIfActor(Actorthis, Actorthat)Global

        Simple version when returns ARE the conditions
        Single value returns

      • AliasfunctioncIfAlias(Aliasthis, Aliasthat)Global

        Requirements: None

      • floatfunctioncIfFloat(floatthis, floatthat)Global

        Requirements: None

      • FormfunctioncIfForm(Formthis, Formthat)Global

        Requirements: None

      • intfunctioncIfInt(intthis, intthat)Global

        Requirements: None

      • Requirements: None

      • stringfunctioncIfString(stringthis, stringthat)Global

        Requirements: None

      • Actor[]functioncIfArrayActor(Actor[]this, Actor[]that)Global

        Array returns

      • Alias[]functioncIfArrayAlias(Alias[]this, Alias[]that)Global

        Requirements: None

      • bool[]functioncIfArrayBool(bool[]this, bool[]that)Global

        Requirements: None

      • float[]functioncIfArrayFloat(float[]this, float[]that)Global

        Requirements: None

      • Form[]functioncIfArrayForm(Form[]this, Form[]that)Global

        Requirements: None

      • int[]functioncIfArrayInt(int[]this, int[]that)Global

        Requirements: None

      • Requirements: None

      • string[]functioncIfArrayString(string[]this, string[]that)Global

        Requirements: None

      • ActorfunctioncOrActor(Actorthis, Actorthat, ActororThat2=NONE, ActororThat3=NONE, ActororThat4=NONE, ActororThat5=NONE, ActororThat6=NONE, ActororThat7=NONE, ActororThat8=NONE, ActororThat9=NONE)Global

        Longer chains of conditional values

      • AliasfunctioncOrAlias(Aliasthis, Aliasthat, AliasorThat2=NONE, AliasorThat3=NONE, AliasorThat4=NONE, AliasorThat5=NONE, AliasorThat6=NONE, AliasorThat7=NONE, AliasorThat8=NONE, AliasorThat9=NONE)Global

        Requirements: None

      • floatfunctioncOrFloat(floatthis, floatthat, floatorThat2=0.0, floatorThat3=0.0, floatorThat4=0.0, floatorThat5=0.0, floatorThat6=0.0, floatorThat7=0.0, floatorThat8=0.0, floatorThat9=0.0)Global

        Requirements: None

      • FormfunctioncOrForm(Formthis, Formthat, FormorThat2=NONE, FormorThat3=NONE, FormorThat4=NONE, FormorThat5=NONE)Global

        Unnecessary really but I found it online and figured I'd include it

      • intfunctioncOrInt(intthis, intthat, intorThat2=0, intorThat3=0, intorThat4=0, intorThat5=0)Global

        Requirements: None

      • ObjectReferencefunctioncOrObjRef(ObjectReferencethis, ObjectReferencethat, ObjectReferenceorThat2=NONE, ObjectReferenceorThat3=NONE, ObjectReferenceorThat4=NONE, ObjectReferenceorThat5=NONE, ObjectReferenceorThat6=NONE, ObjectReferenceorThat7=NONE, ObjectReferenceorThat8=NONE, ObjectReferenceorThat9=NONE)Global

        Requirements: None

      • stringfunctioncOrString(stringthis, stringthat, stringorThat2="", stringorThat3="", stringorThat4="", stringorThat5="")Global

        Requirements: None

      • AliasfunctioncPseudoSwitchAlias(intcase, AliaselseDefault, Aliascase0, Aliascase1=NONE, Aliascase2=NONE, Aliascase3=NONE, Aliascase4=NONE, Aliascase5=NONE, Aliascase6=NONE, Aliascase7=NONE, Aliascase8=NONE, Aliascase9=NONE)Global

        Pseudo-switch statements

      • boolfunctioncPseudoSwitchBool(intcase, boolelseDefault, boolcase0, boolcase1=false, boolcase2=false, boolcase3=false, boolcase4=false, boolcase5=false, boolcase6=false, boolcase7=false, boolcase8=false, boolcase9=false)Global

        Requirements: None

      • floatfunctioncPseudoSwitchFloat(intcase, floatelseDefault, floatcase0, floatcase1=0.0, floatcase2=0.0, floatcase3=0.0, floatcase4=0.0, floatcase5=0.0, floatcase6=0.0, floatcase7=0.0, floatcase8=0.0, floatcase9=0.0)Global

        Requirements: None

      • FormfunctioncPseudoSwitchForm(intcase, FormelseDefault, Formcase0, Formcase1=NONE, Formcase2=NONE, Formcase3=NONE, Formcase4=NONE, Formcase5=NONE, Formcase6=NONE, Formcase7=NONE, Formcase8=NONE, Formcase9=NONE)Global

        Requirements: None

      • intfunctioncPseudoSwitchInt(intcase, intelseDefault, intcase0, intcase1=0, intcase2=0, intcase3=0, intcase4=0, intcase5=0, intcase6=0, intcase7=0, intcase8=0, intcase9=0)Global

        Requirements: None

      • stringfunctioncPseudoSwitchString(intcase, stringelseDefault, stringcase0, stringcase1="", stringcase2="", stringcase3="", stringcase4="", stringcase5="", stringcase6="", stringcase7="", stringcase8="", stringcase9="")Global

        Requirements: None

      • voidfunctioncActualSwitchTemplate(intcase)

        Actual switch used in message.Show() output

      • boolfunctioncIsEven(intaInt)Global

        ========================= Math / Logic

        Analysis

      • boolfunctioncIsOdd(intaInt)Global

        Requirements: None

      • boolfunctioncIsFloat(stringaString)Global

        may not work with very small/large numbers

      • boolfunctioncIsInt(stringaString)Global

        Requirements: None

      • boolfunctioncIsBetweenFloat(floataValue, floatminV, floatmaxV)Global

        Requirements: None

      • boolfunctioncIsBetweenInt(intaValue, intminV, intmaxV)Global

        Requirements: None

      • floatfunctioncClampFloat(floataValue, floatminV, floatmaxV, boolusePapUtil=true)Global

        Conditional manipulation

      • intfunctioncClampInt(intaValue, intminV, intmaxV, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncWrapIndex(intaValue, intendIndex, intstartIndex=0, boolusePapUtil=true)Global

        Adapted from PapyrusUtil function, awesome function!

      • intfunctioncWrapInt(intaValue, inthighVal, intlowVal=0, boolusePapUtil=true)Global

        Adapted from PapyrusUtil function, awesome function!

      • floatfunctioncWrapFloat(floataValue, floatmaxValue, floatminValue=0.0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • floatfunctioncRoundFloat(floataFloat, intplaces=1)Global
      • intfunctioncRoundInt(intaInt, intplaces=1)Global

        places == places to the left

      • floatfunctioncArraySumFloat(float[]aArray, boolusePapUtil=true)Global

        Entire array calculations

      • intfunctioncArraySumInt(int[]aArray, boolusePapUtil=true)Global

        Requirements: None

      • floatfunctioncArrayAverageFloat(float[]aArray)Global

        Requirements: None

      • intfunctioncArrayAverageInt(int[]aArray)Global

        remainder is dropped!

      • floatfunctioncRandomNumberGenFloat(floatthis, floatthat, boolusePO3=true)Global

        Random Number Generation (no limitation aside from VM capability at this point)

      • intfunctioncRandomNumberGenInt(intthis, intthat, boolusePO3=true)Global

        Requirements: None

      • float[]functioncArrayRandomFloats(intarraySize=128, floatthis=0.0, floatthat=100.0)Global

        array length capped at 128

      • int[]functioncArrayRandomInts(intarraySize=128, intthis=0, intthat=100)Global

        array length capped at 128

      • stringfunctioncD2H(intaInt, booluseSKSE=true)Global

        Hex <-> Decimal conversion

      • intfunctioncH2D(stringaString)Global

        Requirements: None, SKSE:Soft

      • intfunctioncBitwiseOp(inti1, inti2, intiBits=31, intiOp=1, boolbWarn=false)Global

        31 bitwise operations. Returns a negative number on errors
        Set iBits lower to limit the bitmask to the lower bits for efficiency - Def = 31bits
        Set bOp for the bitwise operation. 0 = NOT, 1 = AND(default), 2 = OR, 3 = XOR
        Set bWarn to True if you are too lazy to check the error return value, and want a notification
        Code from Milagros Osorio http://www.gamesas.com/bitwise-ops-t256983.html

      • intfunctioncLogicalAND(inti1, inti2, booluseSKSE=true)Global

        --> cBitwiseOp provides non-SKSE functionality for these

      • intfunctioncLogicalNOT(inti1, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • intfunctioncLogicalOR(inti1, inti2, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • intfunctioncLogicalXOR(inti1, inti2, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • intfunctioncBitShiftL(intaInt, intnumShifts)Global

        Requirements: None

      • intfunctioncBitShiftR(intaInt, intnumShifts)Global

        Requirements: None

      • boolfunctioncStringIsLetter(stringaLetter, booluseSKSE=true)Global

        Like the SKSE version, the non-SKSE version only checks the first char
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • boolfunctioncStringIsDigit(stringaDigit, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • boolfunctioncStringIsMiscChar(stringaChar)Global

        This is !cStringIsDigit(aChar) && !cStringIsLetter(aChar)
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • intfunctioncStringFind(stringinThis, stringfindThis, intstartIndex=0, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • intfunctioncStringLength(stringaString, booluseSKSE=true)Global

        Because the entire string must be parsed to calculate the size it is recommended to combine string handling
        functions if possible. Non-SKSE max length 128
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringGetNthChar(stringaString, intn, booluseSKSE=true)Global

        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringSubString(stringaString, intstartChar, intnumChars=0, booluseSKSE=true)Global

        Requirements None, SKSE:Soft

      • stringfunctioncStringReplace(stringaString, stringtoReplace, stringwithWhat="", booluseSKSE=true)Global

        Manipulation

      • stringfunctioncStringSetNthChar(stringaString, inta1stCharIndex, stringwithThis1st="", inta2ndCharIndex=0, stringwithThis2nd="&^", inta3rdCharIndex=0, stringwithThis3rd="&^")Global

        withThis2nd or 3rd == "*&^" allows mix/match of ""

      • stringfunctioncStringRemove(stringaString, stringtoRemove)Global

        String truncation
        Convenience version of cStringReplace()

      • stringfunctioncStringLeft(stringaString, intnumChars, booluseSKSE=true)Global

        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringRight(stringaString, intnumChars, booluseSKSE=true)Global

        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringSetLength(stringaString, intstringLength, stringfiller="")Global

        Think of this as a combination of 'ArrayResize' a 'string length clamp' for a string
        filler can be any length desired so long as the string doesn't exceed 128 chars!
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringTrimLeft(stringaString, stringcharToTrim="", booluseSKSE=true)Global

        charToTrim cannot be longer than one char (it will trim more than one just the string length can't be > 1)
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringTrimRight(stringaString, stringcharToTrim="", booluseSKSE=true)Global

        rewritten to allow charToTrim to be longer than one char in SKSE version only! One char only in non-SKSE
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringTrim(stringaString, stringcharToTrim="", booluseSKSE=true)Global

        rewritten to allow charToTrim to be longer than one char in SKSE version only! One char only in non-SKSE
        thank you cadpnq for the suggestion that made the non-SKSE version possible!

      • stringfunctioncStringAddCommaList(stringaString0, stringaString1, stringaString2="", stringaString3="", stringaString4="", stringaString5="", stringaString6="", stringaString7="", stringaString8="", stringaString9="")Global

        String join and split
        for convenience ensures no comma in front

      • stringfunctioncArrayJoinString(string[]aArray, stringdelimiterString="", intstartIndex=0, intnumIndices=-1)Global

        Requirements: None

      • stringfunctioncStringJoin(string[]aArray, stringdelimiterString="", boolusePapUtil=true)Global
      • string[]functioncStringToArray(stringaString, intnumChars=-1, booluseSKSE=true)Global

        Splits a string into an array of its characters

      • string[]functioncStringHexToArray(stringaString, booluseSKSE=true)Global

        Non-SKSE version only has to look through the 16 hex digits as opposed to all 69 ASCII chars

      • stringfunctioncStringRepeat(stringrepeatThis, intthisManyTimes)Global

        Generation

      • stringfunctioncStringAdd_ed(stringaString)Global

        useful for dynamic confirmation, progress, completion, log or error reporting messages.
        e.g. The function uses "save", "restore" or "remove" as an function argument.
        User's choice: argument == "save"

        1. cConcatenate("Do you want to ", argument, "?") == Do you want to save?
        2. cConcatenate(cStringAdd_ing(argument), "...") == Saving...
        3. cConcatenate("Successfully ", cStringAdd_ed(argument), "!") == Successfully saved!
          now you can make a single function that adds, saves, restores, clears and/or removes something and use a single
          set of dynamically constructed messages (this is just one part of that)
      • stringfunctioncStringAdd_ing(stringaString)Global

        useful for dynamic confirmation, progress, completion, log or error reporting messages.
        e.g. The function uses "save", "restore" or "remove" as an function argument.
        User's choice: argument == "save"

        1. cConcatenate("Do you want to ", argument, "?") == Do you want to save?
        2. cConcatenate(cStringAdd_ing(argument), "...") == Saving...
        3. cConcatenate("Successfully ", cStringAdd_ed(argument), "!") == Successfully saved!
          now you can make a single function that adds, saves, restores, clears and/or removes something and use a single
          set of dynamically constructed messages (this is just one part of that)
      • stringfunctioncStringASCIICheck(stringaString, stringbuiltString, string[]asciiChars)Global

        Returns next ASCII character in string without SKSE

      • stringfunctioncStringHexCheck(stringaString, stringbuiltString, string[]hexDigits)Global

        Returns next hex digit in string without SKSE

      • boolfunctioncFLReplaceValue(FormListaFormlist, FormreplaceThis, FormwithThis, boolforceAdd=false)Global

        Bool return is whether or not the replaced value is still there (can only remove ADDED forms)
        forceAdd forces the value to be added even if replaceThis can't be removed
        a return of TRUE == success, False == failed

      • FormListfunctioncArrayToFL(Form[]aArray, FormListaFormList, booluseSKSE=true)Global

        to/from Array

      • Form[]functioncFLToArray(FormListaFormList, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • floatfunctioncArraySmallestFloat(float[]aArray)Global

        Analysis/Comparison/Query/Tally

      • intfunctioncArraySmallestInt(int[]aArray)Global

        Requirements: None

      • floatfunctioncArrayLargestFloat(float[]aArray)Global

        Requirements: None

      • intfunctioncArrayLargestInt(int[]aArray)Global

        Requirements: None

      • intfunctioncArrayCountValueActor(Actor[]aArray, ActorvalueToCount=NONE, boolinvertIt=false, boolusePapUtil=true)Global

        Tally

      • intfunctioncArrayCountValueAlias(Alias[]aArray, AliasvalueToCount=NONE, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueBool(bool[]aArray, boolvalueToCount=true, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueFloat(float[]aArray, floatvalueToCount=0.0, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueForm(Form[]aArray, FormvalueToCount=NONE, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueInt(int[]aArray, intvalueToCount=0, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueObjRef(ObjectReference[]aArray, ObjectReferencevalueToCount=NONE, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueString(string[]aArray, stringvalueToCount="", boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayCountValueFormList(FormListaFormList, FormvalueToCount=NONE, boolinvertIt=false)Global

        Requirements: None

      • bool[]functioncArrayIntToBool(int[]aArray)Global

        see also: ArraySumFloat()
        ArraySumInt()
        ArrayAverageFloat()
        ArrayAverageInt()

        Conversion

      • int[]functioncArrayBoolToInt(int[]aArray)Global

        Requirements:None

      • Form[]functioncArrayActorToActorBase(Actor[]aArray)Global

        Requirements:None

      • Requirements:None

      • int[]functioncArrayGetValueIndicesActor(Actor[]aArray, ActorvalueToFind=NONE, boolinvertIt=false)Global

        Returns array of indices == valueToFind, also can provide the inverse

      • int[]functioncArrayGetValueIndicesAlias(Alias[]aArray, AliasvalueToFind=NONE, boolinvertIt=false)Global

        Requirements: None

      • int[]functioncArrayGetValueIndicesBool(bool[]aArray, boolvalueToFind=false, boolinvertIt=false)Global

        Requirements: None

      • int[]functioncArrayGetValueIndicesFloat(float[]aArray, floatvalueToFind=0.0, boolinvertIt=false)Global

        Requirements: None

      • int[]functioncArrayGetValueIndicesForm(Form[]aArray, FormvalueToFind=NONE, boolinvertIt=false)Global

        Requirements: None

      • int[]functioncArrayGetValueIndicesInt(int[]aArray, intvalueToFind=0, boolinvertIt=false)Global

        Requirements: None

      • int[]functioncArrayGetValueIndicesObjRef(ObjectReference[]aArray, ObjectReferencevalueToFind=NONE, boolinvertIt=false)Global

        Requirements: None

      • int[]functioncArrayGetValueIndicesString(string[]aArray, stringvalueToFind="", boolinvertIt=false)Global

        Requirements: None

      • intfunctioncArrayFindActor(Actor[]aArray, ActoraValue=NONE, intstartAt=0, boolinvertIt=true)Global

        Yes...This is .Find() and rFind() used for Bool invert (first value that != aValue)

      • intfunctioncArrayFindAlias(Alias[]aArray, AliasaValue=NONE, intstartAt=0, boolinvertIt=true)Global

        Requirements: None

      • intfunctioncArrayFindBool(bool[]aArray, boolaValue=false, intstartAt=0, boolinvertIt=true)Global

        Requirements: None

      • intfunctioncArrayFindFloat(float[]aArray, floataValue=0.0, intstartAt=0, boolinvertIt=true)Global

        Requirements: None

      • intfunctioncArrayFindForm(Form[]aArray, FormaValue=NONE, intstartAt=0, boolinvertIt=true)Global

        Requirements: None

      • intfunctioncArrayFindInt(int[]aArray, intaValue=0, intstartAt=0, boolinvertIt=true)Global

        kept for invertIt

      • intfunctioncArrayFindObjRef(ObjectReference[]aArray, ObjectReferenceaValue=NONE, intstartAt=0, boolinvertIt=true)Global

        kept for invert

      • intfunctioncArrayFindString(string[]aArray, stringaValue="", intstartAt=0, boolinvertIt=true)Global

        kept for invert

      • intfunctioncArrayRFindActor(Actor[]aArray, ActoraValue=NONE, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindAlias(Alias[]aArray, AliasaValue=NONE, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindBool(bool[]aArray, boolaValue=false, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindFloat(float[]aArray, floataValue=0.0, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindForm(Form[]aArray, FormaValue=NONE, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindInt(int[]aArray, intaValue=0, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindObjRef(ObjectReference[]aArray, ObjectReferenceaValue=NONE, intstartAt=0, boolinvertIt=true)Global

        use it for invertIt
        startAt requires a positive int and counts backwards from the end

      • intfunctioncArrayRFindString(string[]aArray, stringaValue="", intstartAt=-1, boolinvertIt=true)Global

        used for invertIt ; -1 == last element

      • Actor[]functioncArrayReplaceActor(Actor[]aArray, ActorreplaceThis, ActorwithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • Alias[]functioncArrayReplaceAlias(Alias[]aArray, AliasreplaceThis, AliaswithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • bool[]functioncArrayReplaceBool(bool[]aArray, boolreplaceThis, boolwithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • float[]functioncArrayReplaceFloat(float[]aArray, floatreplaceThis, floatwithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • Form[]functioncArrayReplaceForm(Form[]aArray, FormreplaceThis, FormwithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • int[]functioncArrayReplaceInt(int[]aArray, intreplaceThis, intwithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • ObjectReference[]functioncArrayReplaceObjRef(ObjectReference[]aArray, ObjectReferencereplaceThis, ObjectReferencewithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • string[]functioncArrayReplaceString(string[]aArray, stringreplaceThis, stringwithThis, boolforceAll=false)Global

        forceAll == TRUE replaces EVERYTHING with aValue

      • ActorfunctioncArrayReturnActor(Actor[]aArray, intreturnIndex=-1)Global
        1. allows return via .Find(), returnIndex == -1 returns 1st value that casts as TRUE
      • AliasfunctioncArrayReturnAlias(Alias[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • boolfunctioncArrayReturnBool(bool[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • floatfunctioncArrayReturnFloat(float[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • FormfunctioncArrayReturnForm(Form[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • intfunctioncArrayReturnInt(int[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • ObjectReferencefunctioncArrayReturnObjRef(ObjectReference[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • stringfunctioncArrayReturnString(string[]aArray, intreturnIndex=-1)Global

        Requirements: None

      • float[]functioncArrayAnalyzeFloat(float[]aArray)Global

        returns array [0] == smallest value, [1] == its index, [2] == largest value, [3] == its index,
        [4] == array length, [5] == array sum, [6] == array average

      • int[]functioncArrayAnalyzeInt(int[]aArray)Global

        returns array [0] == smallest value, [1] == its index, [2] == largest value, [3] == its index,
        [4] == array length, [5] == array sum, [6] == array average, [7] == average remainder (if any)

      • string[]functioncArrayAnalyzeString(string[]aArray)Global

        returns array [0] == smallest value (lex), [1] == its index, [2] == largest value (lex), [3] == its index,
        [4] == array length

      • Actor[]functioncArrayTidyActor(Actor[]aArray, boolclearNone=false, boolclearDupes=false)Global

        ====== Manipulation

        Housekeeping (returns original)
        ---@ Three(2 for objects) in one

      • Alias[]functioncArrayTidyAlias(Alias[]aArray, boolclearNone=false, boolclearDupes=false)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArrayTidyFloat(float[]aArray, boolclearZero=false, boolclearDupes=false, boolsortIt=false)Global

        Requirements: None

      • Form[]functioncArrayTidyForm(Form[]aArray, boolclearNone=false, boolclearDupes=false)Global

        Requirements: None

      • int[]functioncArrayTidyInt(int[]aArray, boolclearZero=false, boolclearDupes=false, boolsortIt=false)Global

        Requirements: None

      • ObjectReference[]functioncArrayTidyObjRef(ObjectReference[]aArray, boolclearNone=false, boolclearDupes=false)Global

        Requirements: None

      • string[]functioncArrayTidyString(string[]aArray, boolclearEmpty=false, boolclearDupes=false, boolsortIt=false)Global

        Requirements: None

      • Actor[]functioncArrayRemoveDuplicatesActor(Actor[]aArray, boolusePapUtil=true)Global

        HowTo: RemoveValue
        cArrayReplace.(replaceThis = (None,0,0.0,""), withThis = filler)
        cArrayClearNone.
        () == cArrayRemoveValue.(aArray, None)
        cArrayClearZero.
        () == cArrayRemoveValue.*(aArray, 0) <- 0.0 (Int/Float)
        cArrayClearBlank() == cArrayRemoveValueString(aArray, "") (String)
        cArrayClearEmpty() == cArrayRemoveValueString(aArray, "") (String)
        Remove duplicate records no Bool version, only returns 1-2 index array

      • Alias[]functioncArrayRemoveDuplicatesAlias(Alias[]aArray, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArrayRemoveDuplicatesFloat(float[]aArray, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Form[]functioncArrayRemoveDuplicatesForm(Form[]aArray, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • int[]functioncArrayRemoveDuplicatesInt(int[]aArray, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • ObjectReference[]functioncArrayRemoveDuplicatesObjRef(ObjectReference[]aArray, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • string[]functioncArrayRemoveDuplicatesString(string[]aArray, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • voidfunctioncArraySwapIndexActor(Actor[]aArray, intindex1, intindex2)Global

        Swap Indices

      • voidfunctioncArraySwapIndexAlias(Alias[]aArray, intindex1, intindex2)Global

        Requirements: None

      • voidfunctioncArraySwapIndexBool(bool[]aArray, intindex1, intindex2)Global

        Requirements: None

      • voidfunctioncArraySwapIndexFloat(float[]aArray, intindex1, intindex2)Global

        Requirements: None

      • voidfunctioncArraySwapIndexForm(Form[]aArray, intindex1, intindex2)Global

        Requirements: None

      • voidfunctioncArraySwapIndexInt(int[]aArray, intindex1, intindex2)Global

        Requirements: None

      • voidfunctioncArraySwapIndexObjRef(ObjectReference[]aArray, intindex1, intindex2)Global

        Requirements: None

      • voidfunctioncArraySwapIndexString(string[]aArray, intindex1, intindex2)Global

        Requirements: None

      • Actor[]functioncArrayRemoveTrailingActor(Actor[]aArray, ActortrailingValue=NONE)Global

        this assumes that the last indices are not supposed to be trailingValue

      • Alias[]functioncArrayRemoveTrailingAlias(Alias[]aArray, AliastrailingValue=NONE)Global

        this assumes that the last indices are not supposed to be trailingValue

      • bool[]functioncArrayRemoveTrailingBool(bool[]aArray, booltrailingValue=false)Global

        this assumes that the last indices are not supposed to be trailingValue

      • float[]functioncArrayRemoveTrailingFloat(float[]aArray, floattrailingValue=0.0)Global

        this assumes that the last indices are not supposed to be trailingValue

      • Form[]functioncArrayRemoveTrailingForm(Form[]aArray, FormtrailingValue=NONE)Global

        this assumes that the last indices are not supposed to be trailingValue

      • int[]functioncArrayRemoveTrailingInt(int[]aArray, inttrailingValue=0)Global

        this assumes that the last indices are not supposed to be trailingValue

      • this assumes that the last indices are not supposed to be trailingValue

      • string[]functioncArrayRemoveTrailingString(string[]aArray, stringtrailingValue="")Global

        this assumes that the last indices are not supposed to be trailingValue

      • Actor[]functioncArrayCompactActor(Actor[]aArray, ActorshiftValue=NONE)Global

        Shift all values that cast to Bool as False to the end

      • Alias[]functioncArrayCompactAlias(Alias[]aArray, AliasshiftValue=NONE)Global

        Requirements: None

      • float[]functioncArrayCompactFloat(float[]aArray, floatshiftValue=0.0)Global

        Requirements: None

      • Form[]functioncArrayCompactForm(Form[]aArray, FormshiftValue=NONE)Global

        Requirements: None

      • int[]functioncArrayCompactInt(int[]aArray, intshiftValue=0)Global

        Requirements: None

      • ObjectReference[]functioncArrayCompactObjRef(ObjectReference[]aArray, ObjectReferenceshiftValue=NONE)Global

        Requirements: None

      • string[]functioncArrayCompactString(string[]aArray, stringshiftValue="")Global

        Requirements: None

      • intfunctioncArrayPartitionFloat(float[]aArray, intlow, inthigh)Global

        Only for use as part of the cArraySortFloat function

      • voidfunctioncArraySortFloat(float[]aArray, intlow=-1, inthigh=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • intfunctioncArrayPartitionInt(int[]aArray, intlow, inthigh)Global

        Only for use as part of the cArraySortInt function

      • voidfunctioncArraySortInt(int[]aArray, intlow=-1, inthigh=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArrayBubbleSortFloat(float[]aArray, boolinvertIt=false, boolusePapUtil=true)Global

        Returns new array [cArraySortFloat/Int() faster but no return]

      • int[]functioncArrayBubbleSortInt(int[]aArray, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • string[]functioncArrayBubbleSortString(string[]aArray, boolinvertIt=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Actor[]functioncArrayReverseActor(Actor[]aArray)Global

        Reverse order (returns new array)

      • Alias[]functioncArrayReverseAlias(Alias[]aArray)Global

        Requirements: None

      • bool[]functioncArrayReverseBool(bool[]aArray)Global

        Requirements: None

      • float[]functioncArrayReverseFloat(float[]aArray)Global

        Requirements: None

      • Form[]functioncArrayReverseForm(Form[]aArray)Global

        Requirements: None

      • int[]functioncArrayReverseInt(int[]aArray)Global

        Requirements: None

      • Requirements: None

      • string[]functioncArrayReverseString(string[]aArray)Global

        Requirements: None

      • Actor[]functioncArrayRemoveIndexActor(Actor[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        'fill' empty values
        --> cArrayReplace.(replaceThis = (None,0,0.0,""), withThis = filler)
        Clear all values
        --> 'clear' == cArrayReplace.
        (replaceThis = (irrelevant), withThis = (None,0,0.0,""), forceAll = TRUE)
        OR
        --> 'clear' == cArrayCreate.()
        Add new value to end
        --> 'push' == cArrayResize.
        (newSize = aArray.length + 1, filler = new value)
        Remove Index [allows Pop & Shift behavior] (returns new array)
        --> 'shift' mimic cArrayRemoveIndex.(indexToRemove == 0)
        --> 'pop' mimic cArrayRemoveIndex.
        (indexToRemove == aArray.length)
        Add new index 'unshift'
        --> use cArrayMerge.*

      • Alias[]functioncArrayRemoveIndexAlias(Alias[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • bool[]functioncArrayRemoveIndexBool(bool[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArrayRemoveIndexFloat(float[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Form[]functioncArrayRemoveIndexForm(Form[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • int[]functioncArrayRemoveIndexInt(int[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • ObjectReference[]functioncArrayRemoveIndexObjRef(ObjectReference[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • string[]functioncArrayRemoveIndexString(string[]aArray, intindexToRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Actor[]functioncArrayRemoveIndicesActor(Actor[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Supply with array of ints and this removes those IndICES then returns new array

      • Alias[]functioncArrayRemoveIndicesAlias(Alias[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • bool[]functioncArrayRemoveIndicesBool(bool[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • float[]functioncArrayRemoveIndicesFloat(float[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • Form[]functioncArrayRemoveIndicesForm(Form[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • int[]functioncArrayRemoveIndicesInt(int[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • ObjectReference[]functioncArrayRemoveIndicesObjRef(ObjectReference[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • string[]functioncArrayRemoveIndicesString(string[]aArray, int[]indicesToRemove, intstopLength=0)Global

        Requirements: None

      • Actor[]functioncArrayRemoveValueActor(Actor[]aArray, ActortoRemove=NONE, boolusePapUtil=true)Global

        Removes all indices of said value (returns new array)

      • Alias[]functioncArrayRemoveValueAlias(Alias[]aArray, AliastoRemove=NONE, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • bool[]functioncArrayRemoveValueBool(bool[]aArray, booltoRemove=false, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArrayRemoveValueFloat(float[]aArray, floattoRemove=0.0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Form[]functioncArrayRemoveValueForm(Form[]aArray, FormtoRemove=NONE, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • int[]functioncArrayRemoveValueInt(int[]aArray, inttoRemove=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • ObjectReference[]functioncArrayRemoveValueObjRef(ObjectReference[]aArray, ObjectReferencetoRemove=NONE, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • string[]functioncArrayRemoveValueString(string[]aArray, stringtoRemove="", boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Actor[]functioncArrayCopyActor(Actor[]aArray)Global

        Array copying
        --> Returns new array copy

      • Alias[]functioncArrayCopyAlias(Alias[]aArray)Global

        Requirements: None

      • bool[]functioncArrayCopyBool(bool[]aArray)Global

        Requirements: None

      • float[]functioncArrayCopyFloat(float[]aArray)Global

        Requirements: None

      • Form[]functioncArrayCopyForm(Form[]aArray)Global

        Requirements: None

      • int[]functioncArrayCopyInt(int[]aArray)Global

        Requirements: None

      • Requirements: None

      • string[]functioncArrayCopyString(string[]aArray)Global

        Requirements: None

      • Actor[]functioncArrayCopyToActor(Actor[]aArray1, Actor[]aArray2, Actorfiller=NONE)Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • Alias[]functioncArrayCopyToAlias(Alias[]aArray1, Alias[]aArray2, Aliasfiller=NONE)Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • bool[]functioncArrayCopyToBool(bool[]aArray1, bool[]aArray2, boolfiller=false)Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • float[]functioncArrayCopyToFloat(float[]aArray1, float[]aArray2, floatfiller=0.0)Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • Form[]functioncArrayCopyToForm(Form[]aArray1, Form[]aArray2, Formfiller=NONE)Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • int[]functioncArrayCopyToInt(int[]aArray1, int[]aArray2, intfiller=0)Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • string[]functioncArrayCopyToString(string[]aArray1, string[]aArray2, stringfiller="")Global

        just copies one array to another, can be used for arrays of any size whether SKSE is installed or not

      • Actor[]functioncArrayResizeActor(Actor[]aArray, intnewSize, Actorfiller=NONE, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Resizing (mixed return, SKSE = resize original, vanilla = new copy)
        clampMinLength, clampMaxLength allows 'automated' conditional length

      • Alias[]functioncArrayResizeAlias(Alias[]aArray, intnewSize, Aliasfiller=NONE, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • bool[]functioncArrayResizeBool(bool[]aArray, intnewSize, boolfiller=false, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArrayResizeFloat(float[]aArray, intnewSize, floatfiller=0.0, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Form[]functioncArrayResizeForm(Form[]aArray, intnewSize, Formfiller=NONE, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • int[]functioncArrayResizeInt(int[]aArray, intnewSize, intfiller=0, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • ObjectReference[]functioncArrayResizeObjRef(ObjectReference[]aArray, intnewSize, ObjectReferencefiller=NONE, intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • string[]functioncArrayResizeString(string[]aArray, intnewSize, stringfiller="", intclampMinLength=-1, intclampMaxLength=-1, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Actor[]functioncArraySliceActor(Actor[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Slice copies a portion of aArray to new array and returns it

      • Alias[]functioncArraySliceAlias(Alias[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • bool[]functioncArraySliceBool(bool[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • float[]functioncArraySliceFloat(float[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Form[]functioncArraySliceForm(Form[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • int[]functioncArraySliceInt(int[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • ObjectReference[]functioncArraySliceObjRef(ObjectReference[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • string[]functioncArraySliceString(string[]aArray, intfromIndex, inttoIndex=0, boolusePapUtil=true)Global

        Requirements: None, PapyrusUtil:Soft

      • Actor[]functioncArraySpliceActor(Actor[]aArray, Actor[]toInsert, intinsertAtIndex=0)Global

        Inserts an array into another (returns new array)

      • Alias[]functioncArraySpliceAlias(Alias[]aArray, Alias[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • bool[]functioncArraySpliceBool(bool[]aArray, bool[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • float[]functioncArraySpliceFloat(float[]aArray, float[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • Form[]functioncArraySpliceForm(Form[]aArray, Form[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • int[]functioncArraySpliceInt(int[]aArray, int[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • ObjectReference[]functioncArraySpliceObjRef(ObjectReference[]aArray, ObjectReference[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • string[]functioncArraySpliceString(string[]aArray, string[]toInsert, intinsertAtIndex=0)Global

        Requirements: None

      • Actor[]functioncArrayMergeActor(Actor[]aArray1, Actor[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Merging (returns new array)

      • Alias[]functioncArrayMergeAlias(Alias[]aArray1, Alias[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • bool[]functioncArrayMergeBool(bool[]aArray1, bool[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • float[]functioncArrayMergeFloat(float[]aArray1, float[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • Form[]functioncArrayMergeForm(Form[]aArray1, Form[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • int[]functioncArrayMergeInt(int[]aArray1, int[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • ObjectReference[]functioncArrayMergeObjRef(ObjectReference[]aArray1, ObjectReference[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • string[]functioncArrayMergeString(string[]aArray1, string[]aArray2, booluseSKSE=true, boolusePapUtil=true)Global

        Requirements: None, SKSE:Soft, PapyrusUtil:Soft

      • Actor[]functioncArrayFromActors(ActoraActor0, ActoraActor1=NONE, ActoraActor2=NONE, ActoraActor3=NONE, ActoraActor4=NONE, ActoraActor5=NONE, ActoraActor6=NONE, ActoraActor7=NONE, ActoraActor8=NONE, ActoraActor9=NONE, boolskipTrailingNone=true)Global

        ====== CREATION

        See cStringToArray() in "String" section above
        Array from separated values (10 each)

      • Alias[]functioncArrayFromAliases(AliasaAlias0, AliasaAlias1=NONE, AliasaAlias2=NONE, AliasaAlias3=NONE, AliasaAlias4=NONE, AliasaAlias5=NONE, AliasaAlias6=NONE, AliasaAlias7=NONE, AliasaAlias8=NONE, AliasaAlias9=NONE, boolskipTrailingNone=true)Global

        Requirements: None

      • float[]functioncArrayFromFloats(floataFloat0, floataFloat1=0.0, floataFloat2=0.0, floataFloat3=0.0, floataFloat4=0.0, floataFloat5=0.0, floataFloat6=0.0, floataFloat7=0.0, floataFloat8=0.0, floataFloat9=0.0, boolskipTrailingZero=true)Global

        Requirements: None

      • Form[]functioncArrayFromForms(FormaForm0, FormaForm1=NONE, FormaForm2=NONE, FormaForm3=NONE, FormaForm4=NONE, FormaForm5=NONE, FormaForm6=NONE, FormaForm7=NONE, FormaForm8=NONE, FormaForm9=NONE, boolskipTrailingNone=true)Global

        Requirements: None

      • int[]functioncArrayFromInts(intaInt0, intaInt1=0, intaInt2=0, intaInt3=0, intaInt4=0, intaInt5=0, intaInt6=0, intaInt7=0, intaInt8=0, intaInt9=0, boolskipTrailingZero=true)Global

        Requirements: None

      • ObjectReference[]functioncArrayFromObjRefs(ObjectReferenceaObjRef0, ObjectReferenceaObjRef1=NONE, ObjectReferenceaObjRef2=NONE, ObjectReferenceaObjRef3=NONE, ObjectReferenceaObjRef4=NONE, ObjectReferenceaObjRef5=NONE, ObjectReferenceaObjRef6=NONE, ObjectReferenceaObjRef7=NONE, ObjectReferenceaObjRef8=NONE, ObjectReferenceaObjRef9=NONE, boolskipTrailingNone=true)Global

        Requirements: None

      • string[]functioncArrayFromStrings(stringaString0, stringaString1="", stringaString2="", stringaString3="", stringaString4="", stringaString5="", stringaString6="", stringaString7="", stringaString8="", stringaString9="", boolskipTrailingEmpty=true)Global

        Requirements: None

      • Actor[]functioncArrayNoneActor()Global

        None arrays (great for papyrus array spam handling, also 'resets' an array variable)

      • Alias[]functioncArrayNoneAlias()Global

        Requirements: None

      • bool[]functioncArrayNoneBool()Global

        Requirements: None

      • float[]functioncArrayNoneFloat()Global

        Requirements: None

      • Form[]functioncArrayNoneForm()Global

        Requirements: None

      • int[]functioncArrayNoneInt()Global

        Requirements: None

      • Requirements: None

      • Requirements: None

      • string[]functioncArrayNoneString()Global

        Requirements: None

      • bool[]functioncArrayDynamicComparisonBool(stringoperators, boolthis, bool[]thatArray)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||! (10 functions in one)
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • bool[]functioncArrayDynamicComparisonFloat(stringoperators, floatthis, float[]thatArray)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||! (10 functions in one)
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • bool[]functioncArrayDynamicComparisonForm(stringoperators, Formthis, Form[]thatArray)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • bool[]functioncArrayDynamicComparisonInt(stringoperators, intthis, int[]thatArray)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • bool[]functioncArrayDynamicComparisonString(stringoperators, stringthis, string[]thatArray)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • boolfunctioncDynamicComparisonBool(stringoperators, boolthis, boolthat)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • boolfunctioncDynamicComparisonFloat(stringoperators, floatthis, floatthat)Global

        Valid operators: ==, !=, <, <=, >, >=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • boolfunctioncDynamicComparisonForm(stringoperators, Formthis, Formthat)Global

        Valid operators: ==, !=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • boolfunctioncDynamicComparisonInt(stringoperators, intthis, intthat)Global

        Valid operators: ==, !=, <, <=, >, >=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • boolfunctioncDynamicComparisonString(stringoperators, stringthis, stringthat)Global

        Valid operators: ==, !=, <, <=, >, >=, &&, ||, !&&, &&!, !&&!, !||, ||!, !||!
        e.g. !&& == !this && that ; &&! == this && !that ; !&&! == !this && !that

      • float[]functioncArrayDynamicOperationFloat(stringoperation, floatthis, float[]thatArray)Global

        Valid operators: +, -, /, *, **, ^, pow

      • int[]functioncArrayDynamicOperationInt(stringoperation, intthis, int[]thatArray)Global

        Valid operators: +, -, /, *, <<, leftshift, lshift, >>, rightshift, rshift, AND, NOT, OR, XOR

      • string[]functioncArrayDynamicOperationString(stringoperation, stringthis, string[]thatArray)Global

        Valid operators: +s, s+, +s+

      • floatfunctioncDynamicOperationFloat(stringoperation, floatthis, floatthat)Global

        Valid operators: +, -, /, *, **, ^, pow

      • intfunctioncDynamicOperationInt(stringoperation, intthis, intthat)Global

        Valid operators: +, -, /, *, <<, leftshift, lshift, >>, rightshift, rshift, AND, NOT, OR, XOR

      • stringfunctioncDynamicOperationString(stringoperation, stringthis, strings)Global

        Valid operators: +s, s+, +s+

      • string[]functioncMapSet(stringkeyName, stringaValue, string[]aArray)Global

        MAP FUNCTIONS

      • stringfunctioncMapGet(stringkeyName, string[]aArray)Global

        Requirements: None

      • boolfunctioncMapGetBool(stringkeyName, string[]aArray)Global

        Requirements: None

      • floatfunctioncMapGetFloat(stringkeyName, string[]aArray)Global

        Requirements: None

      • FormfunctioncMapGetForm(stringkeyName, string[]aArray)Global

        Requirements: SKSE

      • intfunctioncMapGetInt(stringkeyName, string[]aArray)Global

        Requirements: None

      • string[]functioncMapCreate(stringkeyName, stringaValue="", intnumKeyPairs=64, booluseSKSE=true)Global

        Requirements: None, SKSE:Soft

      • string[]functioncMapAdd(stringkeyName, stringaValue, string[]aArray)Global

        Requirements: None

      • string[]functioncMapAddForm(stringkeyName, FormaForm, string[]aArray, booluseSKSE=true)Global

        Requirements: SKSE

      • boolfunctioncMapHasKey(stringkeyName, string[]aArray)Global

        Requirements: None

      • intfunctioncMapFirstFree(string[]aArray)Global

        Requirements: None

      • string[]functioncMapRemove(stringkeyName, string[]aArray)Global

        Requirements: None

      • string[]functioncArrayListSkillNames()Global

        ====== Retrieve temporary data for various functions
        ***CONFIRMED WORKING 21-11-02

      • string[]functioncArrayHexDigits()Global

        ***CONFIRMED WORKING 21-11-02

      • string[]functioncArrayDecDigits()Global

        ***CONFIRMED WORKING 21-11-02

      • string[]functioncArrayASCIIChars()Global

        ***CONFIRMED WORKING 21-11-02

      • stringfunctioncASCII2Hex(stringchar)
      • stringfunctioncASCII2Binary(stringchar)
      • string[]functioncArrayASCIIAsBinary()Global

        Requirements: None

      • string[]functioncArrayASCIIAsHex()Global

        Requirements: None

      • string[]functioncArrayLetterChars()Global

        ***CONFIRMED WORKING 21-11-02

      • voidfunctionclibTrace(stringfunctionName, stringmsg, interrorLevel, boolcondition=true, booluseConsoleUtil=true)Global

        Functions used to output error messages

      • voidfunctioncErrInvalidArg(stringfunctionName, stringargName="", stringreturnValue="", interrorLevel=2, boolcondition=true, booluseSKSE=true, booluseConsoleUtil=true)Global

        Requirements: None, ConsoleUtil:Soft

      • voidfunctioncErrArrInitFail(stringfunctionName, stringarrayName="ewArray", stringreturnValue="rrayNone", interrorLevel=2, boolcondition=true, booluseConsoleUtil=true)Global

        Requirements: None, ConsoleUtil:Soft

      • voidfunctioncErrReqDisabled(stringfunctionName, stringmodName="KSE", stringreturnValue="", interrorLevel=2, boolcondition=true, booluseConsoleUtil=true)Global

        Requirements: None, ConsoleUtil:Soft

      • stringfunctioncGetModName(stringhexForm="", intdecForm=0, FormformVar=NONE)Global

        Requirements: SKSE

      • stringfunctioncGetModNameForm(FormaForm)Global

        Requirements: SKSE

      • boolfunctioncIsInAnyMenu()Global

        In my experience more accurate thatn .IsInMenuMode()

      • bool[]functioncArePluginsInstalled(string[]listOfPlugins)Global

        Requirements: SKSE

      • string[]functionGetAllMods()Global
      • string[]functionGetAllRegularMods()Global
      • string[]functionGetAllLightMods()Global
      • intfunctioncFLFindByName(FormListaFormList, stringaName, boolbySubStr=true)Global

        Query

      • intfunctioncArrayFindByNameAlias(Alias[]aArray, stringaName, boolbySubStr=true)Global

        Requirements: SKSE

      • intfunctioncArrayFindByNameActor(Actor[]aArray, stringaName, boolbySubStr=true)Global

        Requirements: SKSE

      • intfunctioncArrayFindByNameForm(Form[]aArray, stringaName, boolbySubStr=true)Global

        Requirements: SKSE

      • intfunctioncArrayFindByNameObjRef(ObjectReference[]aArray, stringaName, boolbySubStr=true)Global
      • stringfunctioncColoredText(stringaString, boolddInstalled=false, stringtextColorHex="", stringtrimWhere="")Global

        Returns text with MCM menu color formatting

      • intfunctioncStringCountSubstring(stringcountThis, stringinThis)Global

        Requirements: SKSE

      • Requirements: SKSE

      • boolfunctioncModPerkPoints(intnumber=1)Global

        NOT compatible with Vokriinator Black!!

      • intfunctioncTotalPerkPoints(ActoraActor, stringsingleSkill="")Global

        Requirements: SKSE

      • string[]functioncArrayStringFromKeywords(Keyword[]aArray)Global

        Requirements: SKSE

      • stringfunctioncGetScriptName()Global

        Requirements: None

      Some data provided by the Skyrim Creation Kit Wiki. Licensed under the Creative Commons Attribution-ShareAlike license.