from eudtrg import *

BOARD_WIDTH = 240
BOARD_HEIGHT = 240
TABLE_LENGTH = (BOARD_WIDTH // 2) * 2 * BOARD_HEIGHT

class KeyState:
    _base_address = 0x596A18
    _KEY_DOWN = 1
    _KEY_UP = 0
    def __init__(self, *keys):
        '''
        usage
            ks = KeyState( 'I', "J", "k", 'l', '3' )
            ks = KeyState( 'A', 0x1B, 0x15 ) # 0x1B : VK_ESCAPE. 0x15 : VK_HANGUEL
        '''
        keys = list(keys)
        # convert to VK-Codes
        for i, key in enumerate(keys):
            if isinstance(key, str):
                key = key.upper()
                assert len(key) == 1 and ord('0') <= ord(key) <= ord('Z'), "__init__ error. read usage"
                keys[i] = ord(key)

        self.dictionary = dict()

        # check for existence from 1 ( VK_LBUTTON ) to 0xFE ( VK_OEM_CLEAR )
        for i in range(1, 0x100):
            if i in keys:
                #self.dictionary[i] = ( prevValue, currValue )
                self.dictionary[i] = ( EUDLightVariable(), EUDCreateVariables(1) )


    def newlyKeyDown(self, key):
        if isinstance(key, str):
            key = ord(key.upper())
        assert key in self.dictionary, "key %s not found" % key
        return  [ self.dictionary[key][0].Exactly( KeyState._KEY_UP ),
                  self.dictionary[key][1].Exactly( KeyState._KEY_DOWN )  ]

    def newlyKeyUp(self, key):
        if isinstance(key, str):
            key = ord(key.upper())
        assert key in self.dictionary, "key %s not found" % key
        return  [ self.dictionary[key][0].Exactly( KeyState._KEY_DOWN ),
                  self.dictionary[key][1].Exactly( KeyState._KEY_UP )    ]

    def currentlyKeyDown(self, key):
        if isinstance(key, str):
            key = ord(key.upper())
        assert key in self.dictionary, "key %s not found" % key
        return  self.dictionary[key][1].Exactly( KeyState._KEY_DOWN )

    def currentlyKeyUp(self, key):
        if isinstance(key, str):
            key = ord(key.upper())
        assert key in self.dictionary, "key %s not found" % key
        return  self.dictionary[key][1].Exactly( KeyState._KEY_UP )

    def update(self):
        # update previous values
        for key in self.dictionary:
            Trigger(
                conditions = self.dictionary[key][1].Exactly( KeyState._KEY_UP ),
                actions = self.dictionary[key][0].SetNumber( KeyState._KEY_UP )
            )
            Trigger(
                conditions = self.dictionary[key][1].Exactly( KeyState._KEY_DOWN ),
                actions = self.dictionary[key][0].SetNumber( KeyState._KEY_DOWN )
            )

        # update current values
        for p in range(0, 0x100 // 4):
            broken = None
            for i in range(4):
                if 4*p+i in self.dictionary:
                    if broken == None:
                        broken = f_dwbreak(f_dwread_epd(EPD( KeyState._base_address ) + p))

                    self.dictionary[4*p+i][1] << broken[2+i]

class Tuple:
    def __init__(self, *args):
        self.data = args
    def __lshift__(self, other):
        assert len(self.data) == len(other), "assign length error"
        for i, d in enumerate(self.data):
            if isinstance(d, EUDVariable):
                d << other[i]
def f_makeBoard():
    global BOARD_WIDTH, BOARD_HEIGHT, TABLE_LENGTH
    emptyLine = b'\x42\xFF' * ( BOARD_WIDTH // 2 ) # two white space
    boardGrpHeader = b''.join([
            b'\x00\x00',                   # offset 0 2 byte padding
            b'\x01\x00',                   # 2
            binio.i2b2( BOARD_WIDTH ),     # 4
            binio.i2b2( BOARD_HEIGHT ),    # 6
            b'\x00\x00',                   # 8 frameXOffset, frameYOffset
            binio.i2b1( BOARD_WIDTH ),     # 10
            binio.i2b1( BOARD_HEIGHT ),    # 11
            b'\x00\x00\x00\x00',           # 12 linetableOffset IMPORTANT : SHOULD BE MODIFIED
        ])
    boardGrpLineOffsets = [ BOARD_HEIGHT*2 + len(emptyLine)*i for i in range( BOARD_HEIGHT ) ]
    assert boardGrpLineOffsets[-1] < 65536, "lineoffsets are short type"

    boardGrpLineOffsets = b''.join(map(binio.i2b2, boardGrpLineOffsets))
    boardGrpLines = emptyLine * BOARD_HEIGHT

    boardGRP = b''.join([boardGrpHeader, boardGrpLineOffsets, boardGrpLines])

    '''important values'''
    grpTableOffset = len(boardGrpHeader) + len(boardGrpLineOffsets)
    print('tablelength', len(boardGrpLines))

    return boardGRP, grpTableOffset

def f_refreshScreen():
    addr = 0x006CEFF8
    i = EUDCreateVariables(1)
    i << EPD(addr)
    EUDWhileNot( i >= EPD(addr + 1200) )
    f_dwwrite_epd( i, 0x01010101 )
    i << i + 1
    EUDEndWhile()

def f_rightClicked():
    num, ret = EUDCreateVariables(2)
    num << f_dwread_epd(EPD(0x6CDDC0))
    ret << 0
    for i in range(31, 3, -1):
        Trigger(
                conditions = num.AtLeast(2**i),
                actions = num.SubtractNumber(2**i)
            )
    return num.AtLeast(2**3)

@EUDFunc
def f_command(buf, size):
    prov_maxbuffer = f_dwread_epd(EPD(0x57F0D8))
    cmdqlen = f_dwread_epd(EPD(0x654AA0))
    if EUDIfNot(cmdqlen + size + 1 >= prov_maxbuffer):
        f_memcpy(0x654880 + cmdqlen, buf, size)
        SetVariables(EPD(0x654AA0), cmdqlen + size)
    EUDEndIf()

@EUDFunc
def f_commandRightClick(x, y):
    RightClickCommand = Db(b'...\x14XXYY\0\0\xE4\0\x00')
    SetVariables(EPD(RightClickCommand + 4), x + f_mul(y, 1<<16))
    f_command(RightClickCommand + 3, 10)

@EUDFunc
def f_fillBoard_epd(table_epd, c):
    i, content = EUDCreateVariables(2)
    i << table_epd
    DoActions( [table_epd.AddNumber(TABLE_LENGTH // 4)] )
    content << f_mul(c, 0x01000100) + 0x420042

    start, end = NextTrigger(), Forward()
    EUDJumpIf( i >= table_epd, end )
    f_dwwrite_epd( i, content )
    DoActions( [i.AddNumber(1)] )
    EUDJump(start)

    end << NextTrigger()

@EUDFunc
def ClearBoardwhile(table_epd):
    i, j = EUDCreateVariables(2)
    i << table_epd

    start, end = NextTrigger(), Forward()
    EUDWhileNot( i >= table_epd + TABLE_LENGTH // 4 )
    f_dwwrite_epd( i, 0xFF42FF42 )
    i << i+1
    EUDEndWhile()

    end << NextTrigger()

@EUDFunc
def f_setPixel2by2(table_offset, x, y, c):
    '''
    fill
        ( [x/2]*2, y - 1 ), ( [x/2]*2 + 1, y - 1 )
        ( [x/2]*2, y     ), ( [x/2]*2 + 1, y     )
    as color c (assert 0 <= c < 256 )
    '''
    xs, rem, c2, c4, table_epd = EUDCreateVariables(5)
    pc1, pc2 = EUDCreateVariables(2) # previous color
    end = Forward()
    EUDJumpIf( x >= BOARD_WIDTH, end )
    EUDJumpIf( y >= BOARD_HEIGHT, end )

    rem << f_div(x, 4)[1] # rem <- 0, 1, 2, 3

    table_epd << f_epd(table_offset + x + f_mul( y, BOARD_WIDTH ))

    if EUDIf( rem <= 1 ):
        c << f_mul( c, 1<<8 )
        j1, j1c = NextTrigger(), Forward()
        pc2 << f_dwbreak(f_dwread_epd(table_epd))[5]
        f_dwwrite_epd( table_epd, c + f_mul(pc2, 1<<24) + 0x420042 )
        Trigger( actions = SetNextPtr(j1c, end) )
        j1c << Trigger(
                conditions = y.AtLeast(1),
                actions = [
                    y.SetNumber(0),
                    table_epd.SubtractNumber(BOARD_WIDTH // 4),
                    SetNextPtr(j1c, j1)
                ]
            )
    if EUDElse():
        c << f_mul( c, 1<<24 )
        j2, j2c = NextTrigger(), Forward()
        pc1 << f_dwbreak(f_dwread_epd(table_epd))[3]
        f_dwwrite_epd( table_epd, f_mul(pc1, 1<<8) + c + 0x420042 )
        Trigger( actions = SetNextPtr(j2c, end) )
        j2c << Trigger(
                nextptr = j2,
                conditions = y.AtLeast(1),
                actions = [
                    y.SetNumber(0),
                    table_epd.SubtractNumber(BOARD_WIDTH // 4),
                    SetNextPtr(j2c, j2)
                ]
            )
    EUDEndIf()

    end << NextTrigger()

@EUDFunc
def f_setPixel(table_offset, x, y, c, size):
    '''
    for tmp2 = y - size to y + size
        for tmp1 = x - size to x + size
            setpixel2by2( tmp1, tmp2 )
    '''
    tmp1, tmp2 = EUDCreateVariables(2)

    tmp2 << y - size
    start, end = NextTrigger(), Forward()
    EUDJumpIf( tmp2 >= y + size, end)

    tmp1 << x - size
    innerstart, innerend = NextTrigger(), Forward()
    EUDJumpIf( tmp1 >= x + size, innerend)

    f_setPixel2by2(table_offset, tmp1, tmp2, c)

    DoActions( tmp1.AddNumber(1) )
    EUDJump( innerstart )
    innerend << NextTrigger()

    DoActions( tmp2.AddNumber(1) )
    EUDJump( start )
    end << NextTrigger()

#@EUDFunc
#def f_stopunit_epd(unitEPD):
#    locdb = Db(bytes(16))
#    unitId, playerId, curPosX, curPosY = EUDCreateVariables(4)
#
#    f_repmovsd(EPD(locdb), EPD(0x58DC60), 4)
#    curPosXY = f_dwbreak(f_dwread_epd(unitEPD + 0x28//4))[0:2]
#    curPosX << curPosXY[0]
#    curPosY << curPosXY[1]
#    playerId << f_dwbreak(f_dwread_epd(unitEPD + 0x4C//4))[2]
#    unitId << f_dwbreak(f_dwread_epd(unitEPD + 0x64//4))[0]
#    moveUni = Forward()
#
#    SeqCompute([
#        (EPD(0x58DC60), SetTo, curPosX),
#        (EPD(0x58DC64), SetTo, curPosY),
#        (EPD(0x58DC68), SetTo, curPosX),
#        (EPD(0x58DC6C), SetTo, curPosY),
#        (EPD(moveUni + 0x10), SetTo, playerId),
#        (EPD(moveUni + 0x18), SetTo, unitId),
#        (EPD(moveUni + 0x18), Add, 39 << 16),
#    ])
#    Trigger(
#        actions=[
#            moveUni << MoveUnit(0, 0, 0, 1, 1), # 1 : Location 0
#        ]
#    )
#    f_repmovsd(EPD(0x58DC60), EPD(locdb), 4)


LoadMap( 'C:\\Program Files (x86)\\StarCraft\\maps\\MyEUDmap\\catchmindbase2mus.scx' )

########################################
#               DATA PART              #
########################################
pyVar_ks = KeyState('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 0xDB, 0xDD, 0x1B) # [ ] esc
pyVar_bg, pyVar_to = f_makeBoard()
s_boardDb = Db(pyVar_bg) # Board Grp Db
v_bgtableoff, v_bgtableepd = EUDCreateVariables(2)
v_penUnitPtr = EUDCreateVariables(1)
v_boardLeft, v_boardTop, v_boardRight, v_boardBottom = EUDCreateVariables(4)
v_screenX, v_screenY, v_mouseX, v_mouseY = EUDCreateVariables(4)

v_commandX, v_commandY = EUDCreateVariables(2)
v_curColor, v_curSize = EUDCreateVariables(2)
v_localPlayer, v_musicTimer = EUDCreateVariables(2)
pyVar_musicLength = 3240*2

s_start = NextTrigger()
pyVar_colorList = [
        ( 0x55, '\x16하양' ), # 0
        ( 0x6F, '\x08빨강' ), # 1
        ( 0x9C, '\x11주황' ), # 2
        ( 0x3D, '\x17노랑' ), # 3
        ( 0xB9, '\x1D연두' ), # 4
        ( 0xB6, '\x18초록' ), # 5
        ( 0x7B, '\x0E파랑' ), # 6
        ( 0xA1, '\x10보라' ), # 7
        ( 0x20, '\x1B상아' ), # 8
        ( 0x8A, '\x05검정' ), # 9
    ]
########################################
#          EXECUTED ONCE PART          #
########################################
pyVar_penUnitPtr = 0x59CCA8
pyVar_boardImagePtr = 0x57D728
v_penUnitPtr << pyVar_penUnitPtr # Barracks
SeqCompute([
        (EPD(s_boardDb) + 3, SetTo, s_boardDb+16), # make GRP
        (EPD(pyVar_boardImagePtr + 0x2C), SetTo, s_boardDb+2), # Set First image's grp
    ])
v_bgtableoff << s_boardDb + pyVar_to
v_bgtableepd << f_epd(v_bgtableoff)

# set default color by black
v_curColor << 0
v_curSize << 1


########################################
#               LOOP PART              #
########################################

if EUDWhile(Always()):
    # turbo trigger
    DoActions(SetDeaths(203151, SetTo, 0, 0))
    v_localPlayer << f_dwread_epd( EPD(0x512684) )
    f_setcurpl( v_localPlayer )

    f_refreshScreen()

    s_gameIntro = NextTrigger()
    f_fillBoard_epd(v_bgtableepd, 0)
    s_gameStart, s_tmp, s_endloop = Forward(), Forward(), Forward()

    # normal trigger
    Trigger(
        conditions = ElapsedTime(AtLeast, 1),
        actions = [
            DisplayText(
                '\x13\x1E펜 소유주는 단어를 생각 후 그림을 그립니다.\n'
                '\x13\x1E펜을 쥔 상태로 마우스 오른쪽 버튼으로 드래그!\n'
                ),
            PlayWAV("staredit\\wav\\myeff2.wav"),
        ],
        preserved = False
        )
    Trigger(
        conditions = ElapsedTime(AtLeast, 6),
        actions = [
            DisplayText(
                '\x13\x0E펜을 선택한 채로 단축키를 눌러 설정 변경이 가능합니다.\n'
                '\x13\x110~9\x04: 색변경, \x11[]\x04: 펜 크기 변경, \x11ESC\x04: 다 지우기\n'
                ),
            PlayWAV("staredit\\wav\\myeff2.wav"),
        ],
        preserved = False
        )

    Trigger(
        conditions = ElapsedTime(AtLeast, 11),
        actions = [
            DisplayText(
                '\x13\x1C누군가가 답을 맞추었다면 레이스로 답을 맞춘 플레이어의 깃발에 레이스를 보내어주세요!\n'
                '\x13\x1D펜을 양도가능합니다!\n'
                ),
            PlayWAV("staredit\\wav\\myeff2.wav"),
        ],
        preserved = False
        )
    Trigger(
        conditions = ElapsedTime(AtLeast, 16),
        actions = [
            DisplayText(
                '\x13\x04캐치마인드 \x05[Minimal]\n'
                '\x13\x152014-11-27\n'
                ),
            SetNextPtr(s_gameIntro, s_gameStart),
            v_musicTimer.SetNumber(pyVar_musicLength),
            v_musicTimer.SubtractNumber(30),
        ],
        preserved = False
        )
    for i in range(7):
        Trigger(
            conditions = [ElapsedTime(AtLeast, 16), Command(i, Exactly, 1, "Flag")],
            actions = [
                GiveUnits(1, "Terran Barracks", P8, "Anywhere", i),
            ]
        )

    s_tmp << Trigger( nextptr = s_endloop )
    s_gameStart << NextTrigger()
    EUDExecuteOnce()
    f_fillBoard_epd( v_bgtableepd, 0xFF )
    EUDEndExecuteOnce()

    # barrack!
    for i in range(7):
        if EUDIf( Command(i, Exactly, 1, "Flag") ):
            DoActions(MoveLocation("FlagLocation", "Flag", i, "Anywhere"))
            Trigger(
                    conditions = Bring(Force1, AtLeast, 2, "Terran Wraith", "FlagLocation"),
                    actions = GiveUnits(1, "Terran Barracks", Force1, "Anywhere", i)
                )
        EUDEndIf()

    # setting image information
    _tmp_broken = f_dwbreak(f_dwread_epd(EPD(pyVar_boardImagePtr + 0x1C)))
    v_boardLeft << _tmp_broken[0]
    v_boardRight << _tmp_broken[0]
    v_boardTop << _tmp_broken[1]
    v_boardBottom << _tmp_broken[1]
    DoActions([
            v_boardRight.AddNumber(BOARD_WIDTH),
            v_boardBottom.AddNumber(BOARD_HEIGHT),
        ])


    # analyze command
    Tuple(v_commandX, v_commandY) << f_dwbreak(f_dwread_epd(EPD(pyVar_penUnitPtr + 0x58)))[0:2]
    if EUDIf( [ v_commandX >= v_boardLeft, v_commandY >= v_boardTop ] ):
        f_setPixel( v_bgtableoff, v_commandX - v_boardLeft, v_commandY - v_boardTop, v_curColor, v_curSize )
    EUDEndIf()

    for i, tup in enumerate( pyVar_colorList ):
        if EUDIf( [ v_commandX == 400 + i, v_commandY == 400 ] ):
            DoActions([
                    DisplayText('  \x1F[SYSTEM] \x04색 선택 : %s' % tup[1]),
                    PlayWAV('staredit\\wav\\myeff.wav'),
                    v_curColor.SetNumber(tup[0])
                ])
        EUDEndIf()
    if EUDIf( [ v_commandX == 500, v_commandY == 500 ] ):
        DoActions([
                DisplayText('  \x1F[SYSTEM] \x1C붓 사이즈 \x15감소'),
                PlayWAV('staredit\\wav\\myeff.wav'),
            ])
        v_curSize << f_div(v_curSize, 2)[0]
    EUDEndIf()
    if EUDIf( [ v_commandX == 600, v_commandY == 600 ] ):
        DoActions([
                DisplayText('  \x1F[SYSTEM] \x1C붓 사이즈 \x1E증가'),
                PlayWAV('staredit\\wav\\myeff.wav'),
                v_curSize.AddNumber(1)
            ])
        v_curSize << v_curSize + f_div(v_curSize, 2)[0]
        Trigger(
            conditions = v_curSize >= 45, # Set MAXIMUM SIZE for Size
            actions = v_curSize.SetNumber(45),
            )
    EUDEndIf()
    if EUDIf( [ v_commandX == 700, v_commandY == 700 ] ):
        DoActions([
                DisplayText('  \x1F[SYSTEM] \x0F보드 다 지우기'),
                PlayWAV('staredit\\wav\\myeff.wav'),
                f_fillBoard_epd( v_bgtableepd, 0xFF )
            ])
    EUDEndIf()

    '''
    # f_fillBoard_epd(v_bgtableepd, 0xFF)
    for ttt in range(-5, 5):
        for kkk in range(-5, 5):
            f_setPixel2by2( v_bgtableoff, i+ttt, j+kkk, 0x80)

    i<<i+dx
    Trigger(
        conditions = i.AtLeast(BOARD_WIDTH),
        actions = i.SubtractNumber(BOARD_WIDTH)
        )
    j<<j+dy
    Trigger(
        conditions = j.AtLeast(BOARD_HEIGHT),
        actions = j.SubtractNumber(BOARD_HEIGHT)
        )
    '''



    pyVar_ks.update()

    # give command
    if EUDIf( Memory(0x6284B8, Exactly, pyVar_penUnitPtr) ):
        if EUDIf( f_rightClicked() ):
            v_screenX << f_dwread_epd(EPD(0x62848C))
            v_screenY << f_dwread_epd(EPD(0x6284A8))
            v_mouseX << f_dwread_epd(EPD(0x6CDDC4))
            v_mouseY << f_dwread_epd(EPD(0x6CDDC8))
            f_commandRightClick( v_screenX + v_mouseX, v_screenY + v_mouseY )
        EUDEndIf()

        for i, tup in enumerate( pyVar_colorList ):
            if EUDIf( pyVar_ks.newlyKeyDown(str(i))):
                f_commandRightClick( 400 + i, 400 )
            EUDEndIf()
        if EUDIf( pyVar_ks.newlyKeyDown( 0xDB ) ):
            f_commandRightClick( 500, 500 )
        EUDEndIf()
        if EUDIf( pyVar_ks.newlyKeyDown( 0xDD ) ):
            f_commandRightClick( 600, 600 )
        EUDEndIf()
        if EUDIf( pyVar_ks.newlyKeyDown( 0x1B ) ):
            f_commandRightClick( 700, 700 )
        EUDEndIf()
    EUDEndIf()

    # finishing...
    # f_stopunit_epd(EPD(pyVar_penUnitPtr))
    Trigger(
        actions = MoveUnit(1, "Terran Barracks", Force1, "Anywhere", "PenLocation")
        )
    Trigger(
            conditions = v_musicTimer.Exactly( pyVar_musicLength ),
            actions = [
                PlayWAV("staredit\\wav\\ThePretender.wav"),
                DisplayText("   \x1F[Music♪] \x1EFoo Fighters - The Pretender"),
                v_musicTimer.SetNumber(0)
            ]
        )
    DoActions(v_musicTimer.AddNumber(1))

    s_endloop << NextTrigger()
    EUDDoEvents()
EUDEndWhile()

SaveMap( 'C:\\Program Files (x86)\\StarCraft\\maps\\MyEUDmap\\캐치마인드test.scx', s_start )