RingTilengine 拡張機能

RingTilengine 拡張機能の用法を解説します。

この拡張機能では Tilengine の機能を全て使えます。

Tilengine はラスターエフェクトが使える「セガ メガドライブ」や「任天堂 スーパーファミコン」風の 2D レトロゲーム制作に向いたゲーム、およびグラフィックスエンジンです。

Tilengine の URL: https://github.com/megamarc/Tilengine

参考文献 (原著のドキュメントの読者は C プログラマを想定しています)

開発で使えるツール

サポート先

入門

用例 (1):

load "tilengine.ring"

TLN_Init(400, 240, 1, 0, 0)
TLN_SetLoadPath("assets\sonic")
foreground = TLN_LoadTilemap ("Sonic_md_fg1.tmx", NULL)
TLN_SetLayerTilemap(0, foreground)

TLN_CreateWindow(NULL, 0)
while TLN_ProcessWindow()
        TLN_DrawFrame(0)
end

TLN_DeleteTilemap(foreground)
TLN_Deinit()

スクリーンショット:

tilengine

追加サンプル

用例 (2):

load "tilengine.ring"

WIDTH  = 400
HEIGHT = 240

frame = 0

/* エンジンのセットアップ */
TLN_Init(WIDTH, HEIGHT, 1,0,0)

/* レイヤーの読み込み */
tilemap = TLN_LoadTilemap("assets/sonic/Sonic_md_fg1.tmx", NULL)

/* レイヤーのセットアップ */
TLN_SetLayer(0, NULL, tilemap)
TLN_SetBGColor(32,32,128)

/* メインループ */
TLN_CreateWindow(NULL, 0)
while TLN_ProcessWindow ()

        /* フレームごとにレイヤーを 1 ピクセルのスクロールをする */
        TLN_SetLayerPosition (0, frame, 0)

        /* ウィンドウへ描画 */
        TLN_DrawFrame (0)

        frame++
end

/* リソースの解放 */
TLN_DeleteTilemap(tilemap)
TLN_Deinit()

スクリーンショット:

tilengine

用例 (3):

load "tilengine.ring"

/* エンジンの初期化 */
TLN_Init(640,480,0,0,1)

/* リソースの読み込み */
TLN_SetLoadPath("assets/color")
background = TLN_LoadBitmap("beach.png")
palette    = TLN_GetBitmapPalette(background)
sp         = TLN_LoadSequencePack("beach.sqx")
sequence   = TLN_FindSequence(sp, "beach")

/* セットアップ */
TLN_SetBGBitmap(background)
TLN_SetPaletteAnimation(0, palette, sequence, true)

/* メインループ */
TLN_CreateWindow(NULL, 0)
TLN_DisableCRTEffect()
while(TLN_ProcessWindow())
        TLN_DrawFrame(0)
end

TLN_DeleteBitmap(background)
TLN_DeleteSequencePack(sp)
TLN_Deinit()

スクリーンショット:

tilengine

用例 (4):

load "tilengine.ring"

WIDTH = 400
HEIGHT= 240

LAYER_FOREGROUND = 0
LAYER_BACKGROUND = 1
MAX_LAYER = 2


player_x = -16
player_y = 160

/* 基本セットアップ */
TLN_Init(WIDTH, HEIGHT, MAX_LAYER,1,0)
TLN_SetBGColor(0, 96, 184)

/* リソースの読み込み */
TLN_SetLoadPath("assets/smw")
foreground = TLN_LoadTilemap("smw_foreground.tmx", NULL)
background = TLN_LoadTilemap("smw_background.tmx", NULL)
TLN_SetLayerTilemap(LAYER_FOREGROUND, foreground)
TLN_SetLayerTilemap(LAYER_BACKGROUND, background)
TLN_SetLayerPosition(LAYER_FOREGROUND, 0,48)
TLN_SetLayerPosition(LAYER_BACKGROUND, 0,80)

/* スプライトのセットアップ */
spriteset = TLN_LoadSpriteset("smw_sprite")
TLN_SetSpriteSet(0, spriteset)
TLN_SetSpritePicture(0, 0)
TLN_SetSpritePosition(0, player_x, player_y)

/* アニメーションのセットアップ */
seq_walking = TLN_CreateSpriteSequence(NULL, spriteset, "walking", 6)
TLN_SetSpriteAnimation(0, seq_walking, 0)

/* メインループ */
TLN_CreateWindow(NULL, 0)
while TLN_ProcessWindow()
        player_x += 1
        if player_x >= WIDTH
                player_x = -16
        ok
        TLN_SetSpritePosition(0, player_x, player_y)
        TLN_DrawFrame(0)
end

/* 使用終了処理 */
TLN_DeleteTilemap(foreground)
TLN_DeleteTilemap(background)
TLN_Deinit()

スクリーンショット:

tilengine

用例 (5):

load "tilengine.ring"

HRES = 424
VRES = 240

LAYER_PROPS_FRONT       = 0
LAYER_FOREGROUND        = 1
LAYER_PROPS             = 2
LAYER_MIDDLEGROUND      = 3
LAYER_BACKGROUND        = 4
NUM_LAYERS              = 5

xworld = 0
oldx = -1

TLN_Init(HRES, VRES, NUM_LAYERS, 8, 0)

/* アセットの読み込み */
TLN_SetLogLevel(TLN_LOG_ERRORS)
TLN_SetLoadPath("assets/forest")
foreground = TLN_LoadTilemap("map.tmx", "Main Layer")
middleground = TLN_LoadBitmap("middleground.png")
background = TLN_LoadBitmap("background.png")
atlas = TLN_LoadSpriteset("atlas.png")
props_list = TLN_LoadObjectList("map.tmx", NULL)

/* レイヤーのセットアップ */
TLN_SetLayer(LAYER_FOREGROUND, NULL, foreground)
TLN_SetLayerBitmap(LAYER_MIDDLEGROUND, middleground)
TLN_SetLayerBitmap(LAYER_BACKGROUND, background)
width = TLN_GetLayerWidth(LAYER_FOREGROUND)
height = TLN_GetLayerHeight(LAYER_FOREGROUND)

/* オブジェクトレイヤー: 後方へオブジェクトを追加 (スプライトの裏側) */
TLN_SetLayerObjects(LAYER_PROPS, props_list, NULL)

/* メインレイヤーとプロパティレイヤー (props layer) を同期 */
TLN_SetLayerParent(LAYER_PROPS_FRONT, LAYER_FOREGROUND)
TLN_SetLayerParent(LAYER_PROPS, LAYER_FOREGROUND)

/* スプライトシーケンスの作成 */
idle = TLN_CreateSpriteSequence(NULL, atlas, "player-idle/player-idle-", 6)
skip = TLN_CreateSpriteSequence(NULL, atlas, "player-skip/player-skip-", 6)

/* メインプレイヤーのスプライトをセットアップ */
xplayer = 48
yplayer = 144
TLN_ConfigSprite(0, atlas, 0)
TLN_SetSpriteAnimation(0, idle, 0)

/* ウィンドウとメインループの作成 */
TLN_CreateWindow(NULL, 0)
TLN_DisableCRTEffect()
while TLN_ProcessWindow()
        TLN_DrawFrame(0)

        /* メインレイヤーを左右 3 ピクセル移動 */
        if (TLN_GetInput(INPUT_LEFT) && xworld > 0)
                xworld -= 3
        elseif (TLN_GetInput(INPUT_RIGHT) && xworld < width - HRES)
                xworld += 3
        ok

        /* 変更のために更新 */
        if xworld != oldx
                TLN_SetLayerPosition(LAYER_FOREGROUND, xworld, 32)
                TLN_SetLayerPosition(LAYER_MIDDLEGROUND, xworld / 2, 0)
                TLN_SetLayerPosition(LAYER_BACKGROUND, xworld / 3, 0)
                TLN_SetSpritePosition(0, xplayer - xworld, yplayer)
                oldx = xworld
        ok
end

/* リソースの解放 */
TLN_DeleteTilemap(foreground)
TLN_DeleteBitmap(middleground)
TLN_CloseResourcePack()
TLN_DeleteSpriteset(atlas)
TLN_DeleteObjectList(props_list)

TLN_DeleteWindow()
TLN_Deinit()

スクリーンショット:

tilengine

用例 (6):

load "tilengine.ring"
load "sin.ring"

WIDTH            = 400
HEIGHT           = 240
FIXED_BITS       = 16
LAYER_FOREGROUND = 0
LAYER_BACKGROUND = 1
MAX_LAYER        = 2
MAP_HORIZON      = 0
MAP_TRACK        = 1
MAX_MAP          = 2

road             = NULL
x                = NULL
y                = NULL
angle            = NULL

func main

        /* エンジンのセットアップ */

                TLN_Init (WIDTH,HEIGHT, MAX_LAYER, 0, 0)
                TLN_SetRasterCallback ("raster_callback()")
                TLN_SetBGColor (0,0,0)

        /* リソースの読み込み */

                TLN_SetLoadPath ("assets/smk")
                road = TLN_LoadTilemap ("track1.tmx", NULL)
                horizon = TLN_LoadTilemap ("track1_bg.tmx", NULL)

        /* 表示開始 */

                TLN_CreateWindow (NULL, 0)
                x = int2fix(-136)
                y = int2fix(336)
                s = 0
                a = float2fix(0.2)
                angle = 0
                BuildSinTable ()

        /* メインループ */

                while (TLN_ProcessWindow ())
                        TLN_SetLayerTilemap (LAYER_FOREGROUND, horizon)
                        TLN_SetLayerTilemap (LAYER_BACKGROUND, horizon)
                        TLN_SetLayerPosition (LAYER_FOREGROUND, lerp(angle*2, 0,360, 0,256), 24)
                        TLN_SetLayerPosition (LAYER_BACKGROUND, lerp(angle, 0,360, 0,256), 0)
                        TLN_ResetLayerMode (LAYER_BACKGROUND)

                        /* 入力処理 */

                                if (TLN_GetInput (INPUT_LEFT))
                                        angle-=2
                                elseif (TLN_GetInput (INPUT_RIGHT))
                                        angle+=2
                                ok

                                if (TLN_GetInput (INPUT_UP))
                                        s += a
                                        if (s > int2fix(2))
                                                s = int2fix(2)
                                        ok
                                elseif (s >= a)
                                        s -= a
                                ok

                                if (TLN_GetInput (INPUT_DOWN))
                                        s -= a
                                        if (s < -int2fix(2))
                                                s = -int2fix(2)
                                        ok
                                elseif (s <= -a)
                                        s += a
                                ok

                                if (s != 0)
                                        angle = angle%360
                                        if (angle < 0)
                                                angle += 360
                                        ok

                                        x += CalcSin (angle, s)
                                        y -= CalcCos (angle, s)
                                ok

                        /* ウィンドウへ描画 */

                                TLN_DrawFrame (0)
        end

        /* 使用終了処理 */

                TLN_DeleteTilemap (road)
                TLN_DeleteTilemap (horizon)
                TLN_DeleteWindow ()
                TLN_Deinit ()


/* ラスターのコールバック (仮想 HBLANK) */

func raster_callback

        line = TLN_GETSCANLINE()

        if (line = 24)
                TLN_SetLayerTilemap (LAYER_BACKGROUND, road)
                TLN_SetLayerPosition (LAYER_BACKGROUND, fix2int(x), fix2int(y))
                TLN_DisableLayer (LAYER_FOREGROUND)
        elseif (line >= 24)
                s0 = float2fix (0.2)
                s1 = float2fix (5.0)
                s = lerp (line, 24,HEIGHT, s0,s1)
                scale = fix2float (s)
                TLN_SetLayerTransform (LAYER_BACKGROUND, angle, WIDTH/2, HEIGHT, scale, scale)
        ok

func lerp x,x0,x1,fx0,fx1
        return (fx0) + ((fx1) - (fx0)) * ((x) - (x0))/((x1) - (x0))

func float2fix f        return f * (1 << FIXED_BITS)
func int2fix i          return i << FIXED_BITS
func fix2int f          return f >> FIXED_BITS
func fix2float f        return f/(1 << FIXED_BITS)

スクリーンショット:

tilengine

用例 (7):

load "tilengine.ring"
load "sin.ring"

WIDTH   =       320
HEIGHT  =       192
COLUMNS = WIDTH/8 + 2

/* レイヤー */
LAYER_FOREGROUND = 0
LAYER_BACKGROUND = 1
MAX_LAYER = 2

frame = 0
column = list(COLUMNS)

/* エントリーポイント */
func main

        /* エンジンのセットアップ */

                TLN_Init (WIDTH,HEIGHT, MAX_LAYER, 0, 5)
                TLN_SetRasterCallback ("raster_callback()")
                TLN_SetBGColor (0,0,0)

        /* リソースの読み込み */

                TLN_SetLoadPath ("assets/tf3")
                foreground = TLN_LoadTilemap ("tf3_bg2.tmx", NULL)
                background = TLN_LoadTilemap ("tf3_bg3.tmx", NULL)
                TLN_SetLayerTilemap (LAYER_FOREGROUND, foreground)
                TLN_SetLayerTilemap (LAYER_BACKGROUND, background)

                BuildSinTable ()

                # カラムリストから整数配列へ変換
                        intArray = "" for item in column intArray += int2Bytes(item) next

                TLN_SetLayerColumnOffset (LAYER_BACKGROUND, :intArray)

        /* メインループ */

                TLN_CreateWindow (NULL, 0)
                while (TLN_ProcessWindow ())

                        /* スクロール */

                                TLN_SetLayerPosition (LAYER_FOREGROUND, frame*3, 0)
                                TLN_SetLayerPosition (LAYER_BACKGROUND, frame, 0)

                        /* カラムオフセットテーブルの更新 */

                                for c=1 to COLUMNS
                                        column[c] = CalcSin (frame*5 + c*20, 3)
                                next

                        /* ウィンドウへ描画 */

                                TLN_DrawFrame (frame)
                                frame++

                end

                /* 使用終了処理 */

                        TLN_DeleteTilemap (foreground)
                        TLN_DeleteTilemap (background)
                        TLN_Deinit ()

func raster_callback

        /* ラスターのコールバック (仮想 HBLANK) */

                line = TLN_GetScanLine()
                TLN_SetLayerPosition (LAYER_FOREGROUND, frame*2, CalcSin((frame+line)<<1, 8) + 8)
                TLN_SetLayerPosition (LAYER_BACKGROUND, frame + CalcSin((frame + line)<<1, 10), 0)

func lerp x,x0,x1,fx0,fx1

        /* 線形補間 */

                return (fx0) + ((fx1) - (fx0))*((x) - (x0))/((x1) - (x0))

スクリーンショット:

tilengine

用例 (8):

load "tilengine.ring"

WIDTH  = 400
HEIGHT = 240

sky = [
        [0x1D, 0x44, 0x7B],
        [0x7F, 0xA4, 0xD9],
        [0x0B, 0x00, 0x4E],
        [0xEB, 0x99, 0x9D]
]

sky_hi_r = 0
sky_hi_g = 0
sky_hi_b = 0
sky_lo_r = 0
sky_lo_g = 0
sky_lo_b = 0

frame = 0
xpos = 0
speed = 2
max_xpos = 4720

/* レイヤー */
        LAYER_FOREGROUND = 0
        LAYER_BACKGROUND = 1
        MAX_LAYER = 2


/* エントリーポイント */
func main

        /* エンジンのセットアップ */
                TLN_Init (WIDTH, HEIGHT, 2,1,0)
                TLN_SetBGColor (0,128,238)
                TLN_SetRasterCallback ("raster_callback()")

        /* リソースの読み込み */
                TLN_SetLoadPath ("assets/sotb")
                foreground = TLN_LoadTilemap ("SOTB_fg.tmx", NULL)
                background = TLN_LoadTilemap ("SOTB_bg.tmx", NULL)
                TLN_SetLayerTilemap (LAYER_FOREGROUND, foreground)
                TLN_SetLayerTilemap (LAYER_BACKGROUND, background)

        spriteset = TLN_LoadSpriteset ("SOTB")
        walk = TLN_CreateSpriteSequence (NULL, spriteset, "walk", 6)

        TLN_SetSpriteSet (0, spriteset)
        TLN_SetSpritePosition (0, 200,160)
        TLN_SetSpriteAnimation (0, walk, 0)

        xpos = 2000

        sky_hi_r = sky[1][1]
        sky_hi_g = sky[1][2]
        sky_hi_b = sky[1][3]
        sky_lo_r = sky[2][1]
        sky_lo_g = sky[2][2]
        sky_lo_b = sky[2][3]

        /* メインループ */
        TLN_CreateWindow (NULL, 0)
        TLN_DisableCRTEffect()
        while (TLN_ProcessWindow ())
        {
                if (xpos < max_xpos)
                {
                        xpos += speed
                        if (xpos >= max_xpos)
                        {
                                TLN_DisableSpriteAnimation (0)
                                TLN_SetSpritePicture (0, 0)
                        }
                }

                /* グラデーションで空を描く */
                if (frame>=300 && frame<=900)
                {
                        /* 上部の色を補完 */
                        sky_hi_r = lerp (frame, 300,900, sky[1][1], sky[3][1])
                        sky_hi_g = lerp (frame, 300,900, sky[1][2], sky[3][2])
                        sky_hi_b = lerp (frame, 300,900, sky[1][3], sky[3][3])

                        /* 下部の色を補完 */
                        sky_lo_r = lerp (frame, 300,900, sky[2][1], sky[4][1])
                        sky_lo_g = lerp (frame, 300,900, sky[2][2], sky[4][2])
                        sky_lo_b = lerp (frame, 300,900, sky[2][3], sky[4][3])
                }

                TLN_SetLayerPosition (LAYER_FOREGROUND, xpos, 0)

                /* ウィンドウへ描画 */
                TLN_DrawFrame (frame)
                frame++
        }

        /* リソースの解放 */
        TLN_DeleteSequence(walk)
        TLN_DeleteTilemap (foreground)
        TLN_DeleteTilemap (background)
        TLN_Deinit ()

func raster_callback

        line = TLN_GetScanLine()
        pos = 0

        /* 空色 */
        if (line < 192)
        {
                //color = new RGB
                /* 上部から下部までの色を補完 */
                r = lerp (line, 0,191, sky_hi_r, sky_lo_r)
                g = lerp (line, 0,191, sky_hi_g, sky_lo_g)
                b = lerp (line, 0,191, sky_hi_b, sky_lo_b)
                TLN_SetBGColor (r, g ,b)
        }

        /* 背景レイヤー */
        pos = -1
        if (line = 0 || line = 24 || line = 64 || line = 88 || line = 96)
                pos = lerp (line, 0,96, xpos*0.7 , xpos*0.2 )
        elseif (line = 120)
                pos = xpos/2
        elseif (line = 208 || line = 216 || line = 224 || line = 232)
                pos = lerp (line,208,232,xpos*1,xpos*2)
        ok

        if (pos != -1)
                TLN_SetLayerPosition (LAYER_BACKGROUND, pos, 0)
        ok

        /* 前景レイヤー */
        pos = -1
        if (line = 0)
                pos = xpos
        elseif (line = 216)
                pos = xpos*3
        ok
        if (pos != -1)
                TLN_SetLayerPosition (LAYER_FOREGROUND, pos, 0)
        ok

func lerp x,x0,x1,fx0,fx1
        /* 線形補間 */
        return (fx0 + (fx1-fx0)*(x-x0)/(x1-x0))

スクリーンショット:

tilengine

用例 (9):

load "tilengine.ring"

WIDTH    = 400
HEIGHT = 240

MIN_SCALE = 50
MAX_SCALE       = 200

/* RGB による空色 */
sky = [
        [0x19, 0x54, 0x75],
        [0x2C, 0xB0, 0xDC]
]

/* レイヤー */
LAYER_FOREGROUND = 0
LAYER_BACKGROUND = 1
MAX_LAYER = 2

xpos=0 ypos=0 scale=0

/* エントリーポイント */
func main

        /* エンジンのセットアップ */
        TLN_Init (WIDTH, HEIGHT, MAX_LAYER,0,0)
        TLN_SetBGColor (34,136,170)
        TLN_SetRasterCallback ("raster_callback()")

        /* リソースの読み込み */
        TLN_SetLoadPath ("assets/fox")
        foreground = TLN_LoadTilemap ("psycho.tmx", NULL)
        background = TLN_LoadTilemap ("rolo.tmx", NULL)
        TLN_SetLayerTilemap (LAYER_FOREGROUND, foreground)
        TLN_SetLayerTilemap (LAYER_BACKGROUND, background)

        /* 初期値 */
        xpos = 0
        ypos = 192
        scale = 100

        /* メインループ */
        TLN_CreateWindow (NULL, 0)
        TLN_DisableCRTEffect()
        while TLN_ProcessWindow ()
                /* ユーザ入力 */
                if TLN_GetInput (INPUT_LEFT)
                        xpos-- ok
                if TLN_GetInput (INPUT_RIGHT)
                        xpos++ ok
                if TLN_GetInput (INPUT_UP) && ypos > 0
                        ypos-- ok
                if TLN_GetInput (INPUT_DOWN)
                        ypos++ ok
                if TLN_GetInput (INPUT_A) && scale < MAX_SCALE
                        scale += 1 ok
                if TLN_GetInput (INPUT_B) && scale > MIN_SCALE
                        scale -= 1 ok

                /* 固定基準地点をもとにスケール計数を計算します */
                fgscale = scale/100.0f
                bgscale = lerp(scale, MIN_SCALE,MAX_SCALE, 0.75,1.5)

                /* スケールは下部のクリッピングに依存します */
                maxy = 640 - (240*100/scale)
                if ypos > maxy
                        ypos = maxy
                ok

                /* 位置の更新 */
                bgypos = lerp(scale,MIN_SCALE,MAX_SCALE, 0,80)
                TLN_SetLayerPosition (LAYER_FOREGROUND, xpos*2, ypos)
                TLN_SetLayerPosition (LAYER_BACKGROUND, xpos, bgypos)
                TLN_SetLayerScaling (LAYER_FOREGROUND, fgscale, fgscale)
                TLN_SetLayerScaling (LAYER_BACKGROUND, bgscale, bgscale)

                /* ウィンドウへ描画 */
                TLN_DrawFrame (0)
        end

        /* リソースの解放 */
        TLN_DeleteTilemap (foreground)
        TLN_DeleteTilemap (background)
        TLN_Deinit ()


/* ラスターエフェクトを適用した空色 */
func raster_callback
        line = TLN_GetScanLine()
        if line <= 152
                r = lerp (line, 0,152, sky[1][1], sky[2][1])
                g = lerp (line, 0,152, sky[1][2], sky[2][2])
                b = lerp (line, 0,152, sky[1][3], sky[2][3])
                TLN_SetBGColor (r, g, b)
        ok

/* 線形補間 */
func lerp x,x0,x1,fx0,fx1
        return (fx0) + ((fx1) - (fx0))*((x) - (x0))/((x1) - (x0))

スクリーンショット:

tilengine

用例 (10):

load "tilengine.ring"

WIDTH    = 400
HEIGHT = 240

sky = [
        [0x1B, 0x00, 0x8B],
        [0x00, 0x74, 0xD7],
        [0x24, 0x92, 0xDB],
        [0x1F, 0x7F, 0xBE]
]

/* レイヤー */
LAYER_FOREGROUND = 0
LAYER_BACKGROUND = 1
MAX_LAYER = 2

pos_foreground = 0
pos_background = list(6)
inc_background = list(6)
speed = 0
ypos = 0

color = list(3)

/* エントリーポイント */
func main

        /* エンジンのセットアップ */
        TLN_Init (WIDTH,HEIGHT, MAX_LAYER, 0, 1)
        TLN_SetRasterCallback ("raster_callback()")
        TLN_SetBGColor (0,128,238)

        /* リソースの読み込み */
        TLN_SetLoadPath ("assets/sonic")
        foreground = TLN_LoadTilemap ("Sonic_md_fg1.tmx", NULL)
        background = TLN_LoadTilemap ("Sonic_md_bg1.tmx", NULL)
        TLN_SetLayerTilemap (LAYER_FOREGROUND, foreground)
        TLN_SetLayerTilemap (LAYER_BACKGROUND, background)
        sp = TLN_LoadSequencePack ("Sonic_md_seq.sqx")
        sequence = TLN_FindSequence (sp, "seq_water")

        /* カラーシーケンスの割り当てをパレットへ個別登録します */
        palette = TLN_GetLayerPalette (LAYER_BACKGROUND)
        TLN_SetPaletteAnimation (TLN_GetAvailableAnimation(), palette, sequence, true)

        /* 背景スクロールの可変速度を増分するための計算 */
        inc_background[1] = 0.562f
        inc_background[2] = 0.437f
        inc_background[3] = 0.375f
        inc_background[4] = 0.625f
        inc_background[5] = 1.0f
        inc_background[6] = 2.0f

        /* 表示開始 */
        TLN_CreateWindow (NULL, 0)

        /* メインループ */
        while TLN_ProcessWindow ()
                if TLN_GetInput (INPUT_RIGHT)
                        speed += 0.02
                        if speed > 1.0
                                speed = 1.0f
                        ok
                elseif speed > 0.0
                        speed -= 0.02
                        if speed < 0.0
                                speed = 0.0f
                        ok
                ok

                if TLN_GetInput (INPUT_LEFT)
                        speed -= 0.02
                        if speed < -1
                                speed = -1
                        ok
                elseif speed < 0
                        speed += 0.02
                        if speed > 0
                                speed = 0
                        ok
                ok

                /* スクロール */
                pos_foreground += 3*speed
                TLN_SetLayerPosition (LAYER_FOREGROUND, pos_foreground, ypos)
                for c=1 to 6
                        pos_background[c] += (inc_background[c] * speed)
                next

                /* ウィンドウへ描画 */
                TLN_DrawFrame (0)
        end

        /* 使用終了処理 */
        TLN_DeleteTilemap (foreground)
        TLN_DeleteTilemap (background)
        TLN_DeleteSequencePack (sp)
        TLN_Deinit ()

/* ラスターのコールバック (仮想 HBLANK) */
func raster_callback

        line = TLN_GetScanLine()
        pos =- 1

        if line=0
                pos = pos_background[1]
        elseif line=32
                pos = pos_background[2]
        elseif line=48
                pos = pos_background[3]
        elseif line=64
                pos = pos_background[4]
        elseif line=112
                pos = pos_background[5]
        elseif line >= 152
                pos = lerp (line, 152,224, pos_background[5], pos_background[6])
        ok

        if pos != -1
                TLN_SetLayerPosition (LAYER_BACKGROUND, pos, 0)
        ok

        /* 背景色をグラデーションにする */
        if line < 112
                InterpolateColor (line, 0,112, sky[1], sky[2], color)
                TLN_SetBGColor (color[1], color[2], color[3])
        elseif line >= 144
                InterpolateColor (line, 144,HEIGHT, sky[3], sky[4], color)
                TLN_SetBGColor (color[1], color[2], color[3])
        ok

func InterpolateColor v,v1,v2,color1,color2,result
        result[1] = lerp (v, v1,v2, color1[1], color2[1])
        result[2] = lerp (v, v1,v2, color1[2], color2[2])
        result[3] = lerp (v, v1,v2, color1[3], color2[3])

/* 線形補間 */
func lerp x,x0,x1,fx0,fx1
        return (fx0) + ((fx1) - (fx0))*((x) - (x0))/((x1) - (x0))

スクリーンショット:

tilengine

LibSDL と Tilengine の併用

用例 (11):

load "tilengine.ring"
load "libsdl.ring"

width  = 640
height = 480

func main

        # Tilengine の開始
                TLN_Init(width, height, 2, 80, 0)

        # LibSDL の開始
                SDL_Init(SDL_INIT_EVERYTHING)
                win = SDL_CreateWindow("Using LibSDL and Tilengine", 100, 100, width, height, SDL_WINDOW_SHOWN|SDL_WINDOW_OPENGL)
                ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC )

        # Tilengine の描画で用いるサーフェースを LibSDL で作成
                surface = SDL_CreateRGBSurface(0, width, height, 32, 0,0,0,0)
        # Surface 構造体からサーフェースの pixels ポインタを取得
                pixels = SDL_Get_SDL_Surface_Pixels(surface)
        # Pixels のポインタを Tilengine へ渡す
                TLN_SetRenderTarget(pixels, width * 4)

        # Tilengine の使用
                TLN_SetLoadPath("assets\sonic")
                foreground = TLN_LoadTilemap ("Sonic_md_fg1.tmx", NULL)
                TLN_SetLayerTilemap(0, foreground)

        # LibSDL のイベントループを使用
                oEvent = SDL_New_SDL_Event()

                while true

                        # フレームの更新で Tilengine を使用
                                        TLN_UpdateFrame(0)

                        # LibSDL の処理結果を Tilengine で描画
                        # ( サーフェース --> テクスチャ --> レンダー)
                                tex = SDL_CreateTextureFromSurface(ren, surface);
                                SDL_RenderCopy2(ren,tex)
                                SDL_DestroyTexture(tex)

                        # LibSDL で長方形を描画
                                rect = SDL_New_SDL_Rect()
                                SDL_Set_SDL_Rect_x(rect,10)
                                SDL_Set_SDL_Rect_y(rect,10)
                                SDL_Set_SDL_Rect_w(rect,100)
                                SDL_Set_SDL_Rect_h(rect,100)
                                SDL_SetRenderDrawColor(ren,255,255,255,255)
                                SDL_RenderDrawRect(ren,rect)
                                SDL_Destroy_SDL_Rect(rect)

                        # LibSDL の処理結果を描画
                                SDL_RenderPresent(ren)

                        # イベントの確認

                                        SDL_PollEvent(oEvent)
                                        switch SDL_Get_SDL_Event_Type(oEvent)
                                                        on SDL_Get_SDL_Quit()
                                                                        exit
                                                        on SDL_Get_SDL_Keydown()
                                                                        Key = SDL_Get_SDL_Event_key_Keysym_Sym(oEvent)
                                                                        if key = 27 exit ok
                                        off
                end

        # Tilengine の使用終了
                TLN_Deinit()

        # LibSDL の使用終了
                SDL_DestroyWindow(win)
                SDL_Quit()

スクリーンショット:

tilengine

用例 (12):

load "tilengine.ring"
load "libsdl.ring"

factor = 3
width  = 400*factor
height = 220*factor

func main

        # Tilengine の開始
                TLN_Init(width, height, 2, 80, 0)

        # LibSDL の開始
                SDL_Init(SDL_INIT_EVERYTHING)
                win = SDL_CreateWindow("Using LibSDL and Tilengine", 40, 40, width, height, SDL_WINDOW_SHOWN|SDL_WINDOW_OPENGL)
                ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC )

        # Tilengine の描画で用いるサーフェースを LibSDL で作成
                surface = SDL_CreateRGBSurface(0, width, height, 32, 0,0,0,0)
        # Surface 構造体からサーフェースの pixels ポインタを取得
                pixels = SDL_Get_SDL_Surface_Pixels(surface)
        # Pixels のポインタを Tilengine へ渡す
                TLN_SetRenderTarget(pixels, width * 4)

        # Tilengine の使用
                TLN_SetLoadPath("assets\sonic")
                foreground = TLN_LoadTilemap ("Sonic_md_fg1.tmx", NULL)
                TLN_SetLayerTilemap(0, foreground)

        # LibSDL のイベントループを使用
                oEvent = SDL_New_SDL_Event()

                while true

                        # フレームの更新で Tilengine を使用
                                        TLN_UpdateFrame(0)

                        # LibSDL の処理結果を Tilengine で描画
                        # ( サーフェース --> テクスチャ --> レンダー)
                                tex = SDL_CreateTextureFromSurface(ren, surface);

                                rectSource = SDL_New_SDL_Rect()
                                SDL_Set_SDL_Rect_x(rectSource,0)
                                SDL_Set_SDL_Rect_y(rectSource,0)
                                SDL_Set_SDL_Rect_w(rectSource,400)
                                SDL_Set_SDL_Rect_h(rectSource,220)

                                rectDest = SDL_New_SDL_Rect()
                                SDL_Set_SDL_Rect_x(rectDest,0)
                                SDL_Set_SDL_Rect_y(rectDest,0)
                                SDL_Set_SDL_Rect_w(rectDest,width)
                                SDL_Set_SDL_Rect_h(rectDest,height)

                                SDL_RenderCopy(ren,tex,rectSource,rectDest)
                                SDL_Destroy_SDL_Rect(rectSource)
                                SDL_Destroy_SDL_Rect(rectDest)
                                SDL_DestroyTexture(tex)

                        # LibSDL で長方形を描画
                                rect = SDL_New_SDL_Rect()
                                SDL_Set_SDL_Rect_x(rect,40)
                                SDL_Set_SDL_Rect_y(rect,5)
                                SDL_Set_SDL_Rect_w(rect,230)
                                SDL_Set_SDL_Rect_h(rect,200)
                                SDL_SetRenderDrawColor(ren,255,255,255,255)
                                SDL_RenderDrawRect(ren,rect)
                                SDL_Destroy_SDL_Rect(rect)

                        # LibSDL の処理結果を描画
                                SDL_RenderPresent(ren)

                        # イベントの確認

                                        SDL_PollEvent(oEvent)
                                        switch SDL_Get_SDL_Event_Type(oEvent)
                                                        on SDL_Get_SDL_Quit()
                                                                        exit
                                                        on SDL_Get_SDL_Keydown()
                                                                        Key = SDL_Get_SDL_Event_key_Keysym_Sym(oEvent)
                                                                        if key = 27 exit ok
                                        off
                end

        # Tilengine の使用終了
                TLN_Deinit()

        # LibSDL の使用終了
                SDL_DestroyWindow(win)
                SDL_Quit()

スクリーンショット:

tilengine

リファレンス

定数:

  • TILENGINE_VER_MAJ

  • TILENGINE_VER_MIN

  • TILENGINE_VER_REV

  • TILENGINE_HEADER_VERSION

  • FLAG_NONE

  • FLAG_FLIPX

  • FLAG_FLIPY

  • FLAG_ROTATE

  • FLAG_PRIORITY

  • FLAG_MASKED

  • BLEND_NONE

  • BLEND_MIX25

  • BLEND_MIX50

  • BLEND_MIX75

  • BLEND_ADD

  • BLEND_SUB

  • BLEND_MOD

  • BLEND_CUSTOM

  • MAX_BLEND

  • BLEND_MIX

  • TLN_OVERLAY_NONE

  • TLN_OVERLAY_SHADOWMASK

  • TLN_OVERLAY_APERTURE

  • TLN_OVERLAY_SCANLINES

  • TLN_OVERLAY_CUSTOM

  • TLN_MAX_OVERLAY

  • PLAYER1

  • PLAYER2

  • PLAYER3

  • PLAYER4

  • INPUT_NONE

  • INPUT_UP

  • INPUT_DOWN

  • INPUT_LEFT

  • INPUT_RIGHT

  • INPUT_BUTTON1

  • INPUT_BUTTON2

  • INPUT_BUTTON3

  • INPUT_BUTTON4

  • INPUT_BUTTON5

  • INPUT_BUTTON6

  • INPUT_START

  • INPUT_QUIT

  • INPUT_CRT

  • INPUT_P1

  • INPUT_P2

  • INPUT_P3

  • INPUT_P4

  • INPUT_A

  • INPUT_B

  • INPUT_C

  • INPUT_D

  • INPUT_E

  • INPUT_F

  • CWF_FULLSCREEN

  • CWF_VSYNC

  • CWF_S1

  • CWF_S2

  • CWF_S3

  • CWF_S4

  • CWF_S5

  • TLN_ERR_OK

  • TLN_ERR_OUT_OF_MEMORY

  • TLN_ERR_IDX_LAYER

  • TLN_ERR_IDX_SPRITE

  • TLN_ERR_IDX_ANIMATION

  • TLN_ERR_IDX_PICTURE

  • TLN_ERR_REF_TILESET

  • TLN_ERR_REF_TILEMAP

  • TLN_ERR_REF_SPRITESET

  • TLN_ERR_REF_PALETTE

  • TLN_ERR_REF_SEQUENCE

  • TLN_ERR_REF_SEQPACK

  • TLN_ERR_REF_BITMAP

  • TLN_ERR_NULL_POINTER

  • TLN_ERR_FILE_NOT_FOUND

  • TLN_ERR_WRONG_FORMAT

  • TLN_ERR_WRONG_SIZE

  • TLN_ERR_UNSUPPORTED

  • TLN_ERR_REF_LIST

  • TLN_MAX_ERR

  • TLN_LOG_NONE

  • TLN_LOG_ERRORS

  • TLN_LOG_VERBOSE

関数:

  • TLN_Engine TLN_Init(int hres, int vres, int numlayers, int numsprites, int numanimations)

  • void TLN_Deinit(void)

  • bool TLN_DeleteContext(TLN_Engine context)

  • bool TLN_SetContext(TLN_Engine context)

  • TLN_Engine TLN_GetContext(void)

  • int TLN_GetWidth(void)

  • int TLN_GetHeight(void)

  • uint32_t TLN_GetNumObjects(void)

  • uint32_t TLN_GetUsedMemory(void)

  • uint32_t TLN_GetVersion(void)

  • int TLN_GetNumLayers(void)

  • int TLN_GetNumSprites(void)

  • void TLN_SetBGColor(uint8_t r, uint8_t g, uint8_t b)

  • bool TLN_SetBGColorFromTilemap(TLN_Tilemap tilemap)

  • void TLN_DisableBGColor(void)

  • bool TLN_SetBGBitmap(TLN_Bitmap bitmap)

  • bool TLN_SetBGPalette(TLN_Palette palette)

  • void TLN_SetRenderTarget(uint8_t* data, int pitch)

  • void TLN_UpdateFrame(int frame)

  • void TLN_SetLoadPath(const char * path)

  • void TLN_SetCustomBlendFunction(TLN_BlendFunction)

  • void TLN_SetLogLevel(TLN_LogLevel log_level)

  • bool TLN_OpenResourcePack(const char * filename, const char * key)

  • void TLN_CloseResourcePack(void)

  • void TLN_SetLastError(TLN_Error error)

  • TLN_Error TLN_GetLastError(void)

  • const char *TLN_GetErrorString(TLN_Error error)

  • bool TLN_CreateWindow(const char * overlay, int flags)

  • bool TLN_CreateWindowThread(const char * overlay, int flags)

  • void TLN_SetWindowTitle(const char * title)

  • bool TLN_ProcessWindow(void)

  • bool TLN_IsWindowActive(void)

  • bool TLN_GetInput(TLN_Input id)

  • void TLN_EnableInput(TLN_Player player, bool enable)

  • void TLN_AssignInputJoystick(TLN_Player player, int index)

  • void TLN_DefineInputKey(TLN_Player player, TLN_Input input, uint32_t keycode)

  • void TLN_DefineInputButton(TLN_Player player, TLN_Input input, uint8_t joybutton)

  • void TLN_DrawFrame(int frame)

  • void TLN_WaitRedraw(void)

  • void TLN_DeleteWindow(void)

  • void TLN_EnableBlur(bool mode)

  • void TLN_EnableCRTEffect(TLN_Overlay overlay, uint8_t overlay_factor, uint8_t threshold, uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, bool blur, uint8_t glow_factor)

  • void TLN_DisableCRTEffect(void)

  • void TLN_Delay(uint32_t msecs)

  • uint32_t TLN_GetTicks(void)

  • int TLN_GetWindowWidth(void)

  • int TLN_GetWindowHeight(void)

  • TLN_Spriteset TLN_CreateSpriteset(TLN_Bitmap bitmap, TLN_SpriteData* data, int num_entries)

  • TLN_Spriteset TLN_LoadSpriteset(const char * name)

  • TLN_Spriteset TLN_CloneSpriteset(TLN_Spriteset src)

  • bool TLN_GetSpriteInfo(TLN_Spriteset spriteset, int entry, TLN_SpriteInfo* info)

  • TLN_Palette TLN_GetSpritesetPalette(TLN_Spriteset spriteset)

  • int TLN_FindSpritesetSprite(TLN_Spriteset spriteset, const char * name)

  • bool TLN_SetSpritesetData(TLN_Spriteset spriteset, int entry, TLN_SpriteData* data, void* pixels, int pitch)

  • bool TLN_DeleteSpriteset(TLN_Spriteset Spriteset)

  • TLN_Tileset TLN_CreateTileset(int numtiles, int width, int height, TLN_Palette palette, TLN_SequencePack sp, TLN_TileAttributes* attributes)

  • TLN_Tileset TLN_CreateImageTileset(int numtiles, TLN_TileImage* images)

  • TLN_Tileset TLN_LoadTileset(const char * filename)

  • TLN_Tileset TLN_CloneTileset(TLN_Tileset src)

  • bool TLN_SetTilesetPixels(TLN_Tileset tileset, int entry, uint8_t* srcdata, int srcpitch)

  • int TLN_GetTileWidth(TLN_Tileset tileset)

  • int TLN_GetTileHeight(TLN_Tileset tileset)

  • int TLN_GetTilesetNumTiles(TLN_Tileset tileset)

  • TLN_Palette TLN_GetTilesetPalette(TLN_Tileset tileset)

  • TLN_SequencePack TLN_GetTilesetSequencePack(TLN_Tileset tileset)

  • bool TLN_DeleteTileset(TLN_Tileset tileset)

  • TLN_Tilemap TLN_CreateTilemap(int rows, int cols, TLN_Tile tiles, uint32_t bgcolor, TLN_Tileset tileset)

  • TLN_Tilemap TLN_LoadTilemap(const char * filename, const char * layername)

  • TLN_Tilemap TLN_CloneTilemap(TLN_Tilemap src)

  • int TLN_GetTilemapRows(TLN_Tilemap tilemap)

  • int TLN_GetTilemapCols(TLN_Tilemap tilemap)

  • TLN_Tileset TLN_GetTilemapTileset(TLN_Tilemap tilemap)

  • bool TLN_GetTilemapTile(TLN_Tilemap tilemap, int row, int col, TLN_Tile tile)

  • bool TLN_SetTilemapTile(TLN_Tilemap tilemap, int row, int col, TLN_Tile tile)

  • bool TLN_CopyTiles(TLN_Tilemap src, int srcrow, int srccol, int rows, int cols, TLN_Tilemap dst, int dstrow, int dstcol)

  • bool TLN_DeleteTilemap(TLN_Tilemap tilemap)

  • TLN_Palette TLN_CreatePalette(int entries)

  • TLN_Palette TLN_LoadPalette(const char * filename)

  • TLN_Palette TLN_ClonePalette(TLN_Palette src)

  • bool TLN_SetPaletteColor(TLN_Palette palette, int color, uint8_t r, uint8_t g, uint8_t b)

  • bool TLN_MixPalettes(TLN_Palette src1, TLN_Palette src2, TLN_Palette dst, uint8_t factor)

  • bool TLN_AddPaletteColor(TLN_Palette palette, uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8_t num)

  • bool TLN_SubPaletteColor(TLN_Palette palette, uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8_t num)

  • bool TLN_ModPaletteColor(TLN_Palette palette, uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8_t num)

  • uint8_t* TLN_GetPaletteData(TLN_Palette palette, int index)

  • bool TLN_DeletePalette(TLN_Palette palette)

  • TLN_Bitmap TLN_CreateBitmap(int width, int height, int bpp)

  • TLN_Bitmap TLN_LoadBitmap(const char * filename)

  • TLN_Bitmap TLN_CloneBitmap(TLN_Bitmap src)

  • uint8_t* TLN_GetBitmapPtr(TLN_Bitmap bitmap, int x, int y)

  • int TLN_GetBitmapWidth(TLN_Bitmap bitmap)

  • int TLN_GetBitmapHeight(TLN_Bitmap bitmap)

  • int TLN_GetBitmapDepth(TLN_Bitmap bitmap)

  • int TLN_GetBitmapPitch(TLN_Bitmap bitmap)

  • TLN_Palette TLN_GetBitmapPalette(TLN_Bitmap bitmap)

  • bool TLN_SetBitmapPalette(TLN_Bitmap bitmap, TLN_Palette palette)

  • bool TLN_DeleteBitmap(TLN_Bitmap bitmap)

  • TLN_ObjectList TLN_CreateObjectList(void)

  • bool TLN_AddTileObjectToList(TLN_ObjectList list, uint16_t id, uint16_t gid, uint16_t flags, int x, int y)

  • TLN_ObjectList TLN_LoadObjectList(const char * filename, const char * layername)

  • TLN_ObjectList TLN_CloneObjectList(TLN_ObjectList src)

  • int TLN_GetListNumObjects(TLN_ObjectList list)

  • bool TLN_GetListObject(TLN_ObjectList list, TLN_ObjectInfo* info)

  • bool TLN_DeleteObjectList(TLN_ObjectList list)

  • bool TLN_SetLayer(int nlayer, TLN_Tileset tileset, TLN_Tilemap tilemap)

  • bool TLN_SetLayerTilemap(int nlayer, TLN_Tilemap tilemap)

  • bool TLN_SetLayerBitmap(int nlayer, TLN_Bitmap bitmap)

  • bool TLN_SetLayerPalette(int nlayer, TLN_Palette palette)

  • bool TLN_SetLayerPosition(int nlayer, int hstart, int vstart)

  • bool TLN_SetLayerScaling(int nlayer, float xfactor, float yfactor)

  • bool TLN_SetLayerAffineTransform(int nlayer, TLN_Affine *affine)

  • bool TLN_SetLayerTransform(int layer, float angle, float dx, float dy, float sx, float sy)

  • bool TLN_SetLayerPixelMapping(int nlayer, TLN_PixelMap* table)

  • bool TLN_SetLayerBlendMode(int nlayer, TLN_Blend mode, uint8_t factor)

  • bool TLN_SetLayerColumnOffset(int nlayer, int* offset)

  • bool TLN_SetLayerClip(int nlayer, int x1, int y1, int x2, int y2)

  • bool TLN_DisableLayerClip(int nlayer)

  • bool TLN_SetLayerMosaic(int nlayer, int width, int height)

  • bool TLN_DisableLayerMosaic(int nlayer)

  • bool TLN_ResetLayerMode(int nlayer)

  • bool TLN_SetLayerObjects(int nlayer, TLN_ObjectList objects, TLN_Tileset tileset)

  • bool TLN_SetLayerPriority(int nlayer, bool enable)

  • bool TLN_SetLayerParent(int nlayer, int parent)

  • bool TLN_DisableLayerParent(int nlayer)

  • bool TLN_DisableLayer(int nlayer)

  • TLN_Palette TLN_GetLayerPalette(int nlayer)

  • bool TLN_GetLayerTile(int nlayer, int x, int y, TLN_TileInfo* info)

  • int TLN_GetLayerWidth(int nlayer)

  • int TLN_GetLayerHeight(int nlayer)

  • bool TLN_ConfigSprite(int nsprite, TLN_Spriteset spriteset, uint32_t flags)

  • bool TLN_SetSpriteSet(int nsprite, TLN_Spriteset spriteset)

  • bool TLN_SetSpriteFlags(int nsprite, uint32_t flags)

  • bool TLN_EnableSpriteFlag(int nsprite, uint32_t flag, bool enable)

  • bool TLN_SetSpritePosition(int nsprite, int x, int y)

  • bool TLN_SetSpritePicture(int nsprite, int entry)

  • bool TLN_SetSpritePalette(int nsprite, TLN_Palette palette)

  • bool TLN_SetSpriteBlendMode(int nsprite, TLN_Blend mode, uint8_t factor)

  • bool TLN_SetSpriteScaling(int nsprite, float sx, float sy)

  • bool TLN_ResetSpriteScaling(int nsprite)

  • int TLN_GetSpritePicture(int nsprite)

  • int TLN_GetAvailableSprite(void)

  • bool TLN_EnableSpriteCollision(int nsprite, bool enable)

  • bool TLN_GetSpriteCollision(int nsprite)

  • bool TLN_GetSpriteState(int nsprite, TLN_SpriteState* state)

  • bool TLN_SetFirstSprite(int nsprite)

  • bool TLN_SetNextSprite(int nsprite, int next)

  • bool TLN_EnableSpriteMasking(int nsprite, bool enable)

  • void TLN_SetSpritesMaskRegion(int top_line, int bottom_line)

  • bool TLN_SetSpriteAnimation(int nsprite, TLN_Sequence sequence, int loop)

  • bool TLN_DisableSpriteAnimation(int nsprite)

  • bool TLN_DisableSprite(int nsprite)

  • TLN_Palette TLN_GetSpritePalette(int nsprite)

  • TLN_Sequence TLN_CreateSequence(const char * name, int target, int num_frames, TLN_SequenceFrame* frames)

  • TLN_Sequence TLN_CreateCycle(const char * name, int num_strips, TLN_ColorStrip* strips)

  • TLN_Sequence TLN_CreateSpriteSequence(const char * name, TLN_Spriteset spriteset, const char * basename, int delay)

  • TLN_Sequence TLN_CloneSequence(TLN_Sequence src)

  • bool TLN_GetSequenceInfo(TLN_Sequence sequence, TLN_SequenceInfo* info)

  • bool TLN_DeleteSequence(TLN_Sequence sequence)

  • TLN_SequencePack TLN_CreateSequencePack(void)

  • TLN_SequencePack TLN_LoadSequencePack(const char * filename)

  • TLN_Sequence TLN_GetSequence(TLN_SequencePack sp, int index)

  • TLN_Sequence TLN_FindSequence(TLN_SequencePack sp, const char * name)

  • int TLN_GetSequencePackCount(TLN_SequencePack sp)

  • bool TLN_AddSequenceToPack(TLN_SequencePack sp, TLN_Sequence sequence)

  • bool TLN_DeleteSequencePack(TLN_SequencePack sp)

  • bool TLN_SetPaletteAnimation(int index, TLN_Palette palette, TLN_Sequence sequence, bool blend)

  • bool TLN_SetPaletteAnimationSource(int index, TLN_Palette)

  • bool TLN_GetAnimationState(int index)

  • bool TLN_SetAnimationDelay(int index, int frame, int delay)

  • int TLN_GetAvailableAnimation(void)

  • bool TLN_DisablePaletteAnimation(int index)

  • void TLN_SetRasterCallback(const char *cCode)

  • void TLN_SetFrameCallback(const char *cCode)

  • void TLN_SetSDLCallback(const char *cCode)

  • int TLN_GetScanLine(void)

  • SDL_Event *TLN_GetSDLEvent(void)