# Works with dbstring.
f_dbstr_adddw(dst, number)  # Print dword to dst
f_dbstr_addptr(dst, number)  # Print pointer (%08X format)
f_dbstr_addstr(dst, src)  # Print dbstring / string
f_dbstr_print(dst, *args)  # Print multiple dword/ptr/str in once
# f_dbstr function is desgiend for concatanetion.
# All f_dbstr~ returns end of the string, so to create a string, you'll need something like:
# a = DBString(1024)  # DBString with 1024byte capicity
# end = f_dbstr_adddw(a, 1)
# end = f_dbstr_adddw(end, 2)  # Print after end
# end = f_dbstr_adddw(end, 3)  # Print after end

f_simpleprint(*args)  # Just print!  use hptr(~) to print pointer as hexadecimal.


f_getuserplayerid()
f_playerexist(player)  # Works only on multiplayer


# Dword RW
f_dwepdread_epd(targetplayer)  # Read ptr/epd from epd
f_dwread_epd(targetplayer)  # Read dword/ptr only
f_epdread_epd(targetplayer)  # Read epd only

f_dwbreak(number)  # Break dword to w1/w2/b1/b2/b3/b4
# f_dwbreak(0xDDCCBBAA) = 0xBBAA, 0xDDCC, 0xAA, 0xBB, 0xCC, 0xDD
# In memory, f_dwbreak(AA BB CC DD) = AA BB, CC DD, AA, BB, CC, DD
f_dwbreak2(number)  # Same as dwbreak, but break it in differnt way
# f_dwbreak2(0xDDCCBBAA) = 0xBBAA, 0xDDCC0000, 0xAA, 0xBB00, 0xCC0000, 0xDD000000
f_bitsplit(a)  # Split dword in bit level. ret[0] = LSB, ret[31] = MSB

f_dwwrite_epd(targetplayer, value)
f_dwadd_epd(targetplayer, value)
f_dwsubtract_epd(targetplayer, value)


# Set/get current player.
f_setcurpl(cp)  # SetCurrentPlayer action does exactly same as this
f_getcurpl()


# Math functions
f_lengthdir(length, angle)  # return len*cos(angle), len*sin(angle)


# Random functions
f_srand(seed)
f_getseed()
f_randomize()
f_rand()
f_dwrand()


# Block memory IO
f_repmovsd_epd(dstepdp, srcepdp, copydwn)  # Copy dwords. way FASTER than memcpy
f_memcpy(dst, src, copylen)
f_strcpy(dst, src)
f_strcmp(s1, s2)


# Patch functions. Everything patched by f_*pathch* can be undone by f_unpatchall
f_blockpatch_epd(dstepd, srcepd, dwn)
f_dwpatch_epd(dstepd, value)  # Patch value
f_unpatchall()  # Unpatch everything


# Pointerwize read/write functions.
f_bread(ptr)  # Byte read
f_bwrite(ptr, b)  # Byte write
f_wread(ptr)  # Word read
f_wwrite(ptr, w)  # Word write
f_dwread(ptr)  # Dword read
f_dwwrite(ptr, dw)  # Dword write

  1 from eudplib import *
  2 
  3 
  4 # Variable definition.
  5 a = EUDVariable()  # Create in-SC variable. Initial value is 0
  6 b = EUDVariable(1)  # Create in-SC variable with initial value 1
  7 
  8 # IMPORTANT : Every variable is static.
  9 c = a + b  # Internally "a + b" creates new EUD variable. Assign name c to it.
 10 c << a * b  # Assign a * b to variable C.
 11 # Almost every C operator works here too, with division being // instead of /
 12 
 13 
 14 # -----------------------------------------------------------------------------
 15 
 16 
 17 # If
 18 if EUDIf()([cond1, cond2, cond3]):
 19     pass  # Code
 20 if EUDElseIf()(cond4):
 21     pass  # code
 22 if EUDElse()():
 23     pass
 24 EUDEndIf()
 25 
 26 
 27 # While / LoopN
 28 if EUDWhile()(conds):
 29     pass  # Code
 30 EUDEndIf()
 31 
 32 
 33 # EUDLoopList
 34 for ptr, epd in EUDLoopList(ptr):
 35     pass
 36 EUDEndIf()
 37 
 38 
 39 # Break & Continue
 40 # While / LoopN
 41 if EUDWhile()(conds):
 42     EUDBreak()  # Break out
 43     EUDBreakIf(cond)  # Break if
 44     EUDContinue()  # Goto continue point
 45     EUDContinueIf(cond)  # Continue if
 46     # Some codes
 47     EUDSetContinuePoint()  # Here is continue point.
 48     # Do some i++ thing here
 49 EUDEndIf()
 50 
 51 
 52 # Function definition. no recursion allowed
 53 @EUDFunc
 54 def funcname(arg1, arg2):
 55     # Use arguments to do stuff.
 56     # All arguments are EUDVariable type
 57 
 58     # EUDReturn to return value
 59     EUDReturn(arg1 + arg2)
 60 
 61     # Legacy support, but use this only on the very end of the function.
 62     return arg1 + arg2
 63 
 64 
 65 # -----------------------------------------------------------------------------
 66 
 67 # Resource declaration
 68 
 69 a = Db(4)  # Create empty space with size 4byte
 70 a = Db(b'\x04\x01\x06\x08')  # Create memory with initial value 04 01 06 08
 71 a = EUDGrp("test.grp")  # Create inmemory GRP from "test.grp"  (From script)