mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-10 02:09:41 +00:00
292 lines
7.2 KiB
Plaintext
292 lines
7.2 KiB
Plaintext
// Script -> BYOND code procs
|
|
#define SCRIPT_MAX_REPLACEMENTS_ALLOWED 200
|
|
// --- List operations (lists known as vectors in n_script) ---
|
|
|
|
// Clone of list()
|
|
/proc/n_list()
|
|
var/list/returnlist = list()
|
|
for(var/e in args)
|
|
returnlist.Add(e)
|
|
return returnlist
|
|
|
|
// Clone of pick()
|
|
/proc/n_pick()
|
|
var/list/finalpick = list()
|
|
for(var/e in args)
|
|
if(isobject(e))
|
|
if(istype(e, /list))
|
|
var/list/sublist = e
|
|
for(var/sube in sublist)
|
|
finalpick.Add(sube)
|
|
continue
|
|
finalpick.Add(e)
|
|
|
|
return pick(finalpick)
|
|
|
|
// Clone of list[]
|
|
/proc/n_listpos(var/list/L, var/pos, var/value)
|
|
if(!istype(L, /list)) return
|
|
if(isnum(pos))
|
|
if(!value)
|
|
if(L.len >= pos)
|
|
return L[pos]
|
|
else
|
|
if(L.len >= pos)
|
|
L[pos] = value
|
|
else if(istext(pos))
|
|
if(!value)
|
|
return L[pos]
|
|
else
|
|
L[pos] = value
|
|
|
|
// Clone of list.Copy()
|
|
/proc/n_listcopy(var/list/L, var/start, var/end)
|
|
if(!istype(L, /list)) return
|
|
return L.Copy(start, end)
|
|
|
|
// Clone of list.Add()
|
|
/proc/n_listadd()
|
|
var/list/chosenlist
|
|
var/i = 1
|
|
for(var/e in args)
|
|
if(i == 1)
|
|
if(isobject(e))
|
|
if(istype(e, /list))
|
|
chosenlist = e
|
|
i = 2
|
|
else
|
|
if(chosenlist)
|
|
chosenlist.Add(e)
|
|
|
|
// Clone of list.Remove()
|
|
/proc/n_listremove()
|
|
var/list/chosenlist
|
|
var/i = 1
|
|
for(var/e in args)
|
|
if(i == 1)
|
|
if(isobject(e))
|
|
if(istype(e, /list))
|
|
chosenlist = e
|
|
i = 2
|
|
else
|
|
if(chosenlist)
|
|
chosenlist.Remove(e)
|
|
|
|
// Clone of list.Cut()
|
|
/proc/n_listcut(var/list/L, var/start, var/end)
|
|
if(!istype(L, /list)) return
|
|
return L.Cut(start, end)
|
|
|
|
// Clone of list.Swap()
|
|
/proc/n_listswap(var/list/L, var/firstindex, var/secondindex)
|
|
if(!istype(L, /list)) return
|
|
if(L.len >= secondindex && L.len >= firstindex)
|
|
return L.Swap(firstindex, secondindex)
|
|
|
|
// Clone of list.Insert()
|
|
/proc/n_listinsert(var/list/L, var/index, var/element)
|
|
if(!istype(L, /list)) return
|
|
return L.Insert(index, element)
|
|
|
|
// --- Miscellaneous functions ---
|
|
|
|
// Clone of sleep()
|
|
/proc/delay(var/time)
|
|
sleep(time)
|
|
|
|
// Clone of prob()
|
|
/proc/prob_chance(var/chance)
|
|
return prob(chance)
|
|
|
|
// Merge of list.Find() and findtext()
|
|
/proc/smartfind(var/haystack, var/needle, var/start = 1, var/end = 0)
|
|
if(haystack && needle)
|
|
if(isobject(haystack))
|
|
if(istype(haystack, /list))
|
|
if(length(haystack) >= end && start > 0)
|
|
var/list/listhaystack = haystack
|
|
return listhaystack.Find(needle, start, end)
|
|
|
|
else
|
|
if(istext(haystack))
|
|
if(length(haystack) >= end && start > 0)
|
|
return findtext(haystack, needle, start, end)
|
|
|
|
// Clone of copytext()
|
|
/proc/docopytext(var/string, var/start = 1, var/end = 0)
|
|
if(istext(string) && isnum(start) && isnum(end))
|
|
if(start > 0)
|
|
return copytext(string, start, end)
|
|
|
|
// Clone of length()
|
|
/proc/smartlength(var/container)
|
|
if(container)
|
|
if(istype(container, /list) || istext(container))
|
|
return length(container)
|
|
|
|
// BY DONKIE~
|
|
// String stuff
|
|
/proc/n_lower(var/string)
|
|
if(istext(string))
|
|
return lowertext(string)
|
|
|
|
/proc/n_upper(var/string)
|
|
if(istext(string))
|
|
return uppertext(string)
|
|
|
|
/*
|
|
//Makes a list where all indicies in a string is a seperate index in the list
|
|
// JUST A HELPER DON'T ADD TO NTSCRIPT
|
|
proc/string_tolist(var/string)
|
|
var/list/L = new/list()
|
|
|
|
var/i
|
|
for(i=1, i<=lentext(string), i++)
|
|
L.Add(copytext(string, i, i))
|
|
|
|
return L
|
|
|
|
proc/string_explode(var/string, var/separator)
|
|
if(istext(string))
|
|
if(istext(separator) && separator == "")
|
|
return string_tolist(string)
|
|
var/i
|
|
var/lasti = 1
|
|
var/list/L = new/list()
|
|
|
|
for(i=1, i<=lentext(string)+1, i++)
|
|
if(copytext(string, i, i+1) == separator) // We found a separator
|
|
L.Add(copytext(string, lasti, i))
|
|
lasti = i+1
|
|
|
|
L.Add(copytext(string, lasti, lentext(string)+1)) // Adds the last segment
|
|
|
|
return L
|
|
|
|
Just found out there was already a string explode function, did some benchmarking, and that function were a bit faster, sticking to that.
|
|
*/
|
|
proc/string_explode(var/string, var/separator)
|
|
if(istext(string) && istext(separator))
|
|
return splittext(string, separator)
|
|
|
|
proc/n_repeat(var/string, var/amount)
|
|
if(istext(string) && isnum(amount))
|
|
var/i
|
|
var/newstring = ""
|
|
if(length(newstring)*amount >=1000)
|
|
return
|
|
for(i=0, i<=amount, i++)
|
|
if(i>=1000)
|
|
break
|
|
newstring = newstring + string
|
|
|
|
return newstring
|
|
|
|
proc/n_reverse(var/string)
|
|
if(istext(string))
|
|
var/newstring = ""
|
|
var/i
|
|
for(i=lentext(string), i>0, i--)
|
|
if(i>=1000)
|
|
break
|
|
newstring = newstring + copytext(string, i, i+1)
|
|
|
|
return newstring
|
|
|
|
// I don't know if it's neccesary to make my own proc, but I think I have to to be able to check for istext.
|
|
proc/n_str2num(var/string)
|
|
if(istext(string))
|
|
return text2num(string)
|
|
|
|
// Number shit
|
|
proc/n_num2str(var/num)
|
|
if(isnum(num))
|
|
return num2text(num)
|
|
|
|
// Squareroot
|
|
proc/n_sqrt(var/num)
|
|
if(isnum(num))
|
|
return sqrt(num)
|
|
|
|
// Magnitude of num
|
|
proc/n_abs(var/num)
|
|
if(isnum(num))
|
|
return abs(num)
|
|
|
|
// Round down
|
|
proc/n_floor(var/num)
|
|
if(isnum(num))
|
|
return round(num)
|
|
|
|
// Round up
|
|
proc/n_ceil(var/num)
|
|
if(isnum(num))
|
|
return round(num)+1
|
|
|
|
// Round to nearest integer
|
|
proc/n_round(var/num)
|
|
if(isnum(num))
|
|
if(num-round(num)<0.5)
|
|
return round(num)
|
|
return n_ceil(num)
|
|
|
|
// Clamps N between min and max
|
|
proc/n_clamp(var/num, var/min=-1, var/max=1)
|
|
if(isnum(num)&&isnum(min)&&isnum(max))
|
|
if(num<=min)
|
|
return min
|
|
if(num>=max)
|
|
return max
|
|
return num
|
|
|
|
// Returns 1 if N is inbetween Min and Max
|
|
proc/n_inrange(var/num, var/min=-1, var/max=1)
|
|
if(isnum(num)&&isnum(min)&&isnum(max))
|
|
return ((min <= num) && (num <= max))
|
|
// END OF BY DONKIE :(
|
|
|
|
// Non-recursive
|
|
// Imported from Mono string.ReplaceUnchecked
|
|
/proc/string_replacetext(var/haystack,var/a,var/b)
|
|
if(istext(haystack)&&istext(a)&&istext(b))
|
|
var/i = 1
|
|
var/lenh=lentext(haystack)
|
|
var/lena=lentext(a)
|
|
//var/lenb=lentext(b)
|
|
var/count = 0
|
|
var/list/dat = list()
|
|
while (i < lenh)
|
|
var/found = findtext(haystack, a, i, 0)
|
|
//log_misc("findtext([haystack], [a], [i], 0)=[found]")
|
|
if (found == 0) // Not found
|
|
break
|
|
else
|
|
if (count < SCRIPT_MAX_REPLACEMENTS_ALLOWED)
|
|
dat+=found
|
|
count+=1
|
|
else
|
|
//log_misc("Script found [a] [count] times, aborted")
|
|
break
|
|
//log_misc("Found [a] at [found]! Moving up...")
|
|
i = found + lena
|
|
if (count == 0)
|
|
return haystack
|
|
//var/nlen = lenh + ((lenb - lena) * count)
|
|
var/buf = copytext(haystack,1,dat[1]) // Prefill
|
|
var/lastReadPos = 0
|
|
for (i = 1, i <= count, i++)
|
|
var/precopy = dat[i] - lastReadPos-1
|
|
//internal static unsafe void CharCopy (String target, int targetIndex, String source, int sourceIndex, int count)
|
|
//fixed (char* dest = target, src = source)
|
|
//CharCopy (dest + targetIndex, src + sourceIndex, count);
|
|
//CharCopy (dest + curPos, source + lastReadPos, precopy);
|
|
buf+=copytext(haystack,lastReadPos,precopy)
|
|
log_misc("buf+=copytext([haystack],[lastReadPos],[precopy])")
|
|
log_misc("[buf]")
|
|
lastReadPos = dat[i] + lena
|
|
//CharCopy (dest + curPos, replace, newValue.length);
|
|
buf+=b
|
|
log_misc("[buf]")
|
|
buf+=copytext(haystack,lastReadPos, 0)
|
|
return buf
|