Interface.d

/***********************************\
              INTERFACE
\***********************************/

var int Print_List; //zCList_zCViewText@

//========================================
// Vergangene Zeit seit Systemstart
//========================================
// Danke an Sektenspinner
func int sysGetTime() {
    CALL__cdecl(sysGetTimePtr);
    return CALL_RetValAsInt();
};

//========================================
// Farbhandling
//========================================
func int RGBA(var int r, var int g, var int b, var int a) {
    if(!a){if(!b){if(!g){if(!r){return 1;};};};};
    return ((r&zCOLOR_CHANNEL)<<zCOLOR_SHIFT_RED)
          |((g&zCOLOR_CHANNEL)<<zCOLOR_SHIFT_GREEN)
          |((b&zCOLOR_CHANNEL)<<zCOLOR_SHIFT_BLUE)
          |((a&zCOLOR_CHANNEL)<<zCOLOR_SHIFT_ALPHA);
};

func int ChangeAlpha(var int zCol, var int a) {
    return ((zCol & ~(zCOLOR_CHANNEL<<zCOLOR_SHIFT_ALPHA)) | ((a&zCOLOR_CHANNEL)<<zCOLOR_SHIFT_ALPHA));
};

func int GetAlpha(var int zCol) {
    return (zCol&(zCOLOR_CHANNEL<<zCOLOR_SHIFT_ALPHA))>>zCOLOR_SHIFT_ALPHA;
};


//========================================
// Text generieren
//========================================

func int Print_CreateText(var string text, var string font) {
    var int hndl; hndl = new(zCViewText@);
    var zCViewText txt; txt = get(hndl);
    txt.timed = 0;
    txt.font = Print_GetFontPtr(font);
    txt.color = -1;
    txt.text = text;
    return hndl;
};

func int Print_CreateTextPtr(var string text, var string font) {
    var int ptr; ptr = create(zCViewText@);
    var zCViewText txt; txt = _^(ptr);
    txt.timed = 0;
    txt.font = Print_GetFontPtr(font);
    txt.text = text;
    txt.color = -1;
    return ptr;
};

func int Print_CreateTextPtrColored(var string text, var string font, var int color) {
    var int ptr; ptr = create(zCViewText@);
    var zCViewText txt; txt = _^(ptr);
    txt.timed = 0;
    txt.font = Print_GetFontPtr(font);
    txt.text = text;
    txt.color = color;
	if (!color == -1) {
		txt.colored = 1;
	};
    return ptr;
};

//========================================
// Text als zCViewText erhalten
//========================================
func zCViewText Print_GetText(var int hndl) {
    get(hndl);
};

func int Print_GetTextPtr(var int hndl) {
    return getPtr(hndl);
};

//========================================
// Text löschen
//========================================
func void Print_DeleteText(var int hndl) {
    if (!Hlp_IsValidHandle(hndl)) { return; };
    var zCViewText txt; txt = Print_GetText(hndl);
    zCViewText_Delete(txt);
    delete(hndl);
};

//========================================
// Mark: Print set alpha
//========================================
// pointer
func void PrintPtr_SetAlpha(var int ptr, var int a) {
	if (!ptr) { return; };
	var zCViewText txt; txt = MEM_PtrToInst(ptr);
	txt.colored = 1;
	txt.color = ChangeAlpha(txt.color, a);
};
// handle
func void Print_SetAlpha(var int hndl, var int a) {
	if (!Hlp_IsValidHandle(hndl)) { return; };
	PrintPtr_SetAlpha(getPtr(hndl), a);
};

//========================================
// Screengröße (in Pixeln)
//========================================
var int Print_Ratio; //float
func void _Print_Ratio() {
    Print_Ratio = mkf(Print_Screen[PS_X]);
    Print_Ratio = divf(Print_Ratio, mkf(Print_Screen[PS_Y]));
};


var int Print_Screen[2];
func void Print_GetScreenSize() {
    if (!_@(MEM_Game)) {
        // Initialize if called during level change
        MEM_InitGlobalInst();
    };
    var zCView screen; screen = _^(MEM_Game._zCSession_viewport);
    Print_Screen[PS_X] = screen.psizex;
    Print_Screen[PS_Y] = screen.psizey;
    _Print_Ratio();
};

//========================================
// Pixel in Virtuelle Koordinaten
//========================================
func int Print_ToVirtualF(var int pxl, var int dim) {
    Print_GetScreenSize();
    pxl *= PS_VMax;
    if(dim == PS_X) {
        return fracf(pxl, Print_Screen[PS_X]);
    }
    else if(dim == PS_Y) {
        return fracf(pxl, Print_Screen[PS_Y]);
    };
    return fracf(pxl, dim);
};
func int Print_ToPixelF(var int vrt, var int dim) {
    Print_GetScreenSize();
    if(dim == PS_X) {
        vrt *= Print_Screen[PS_X];
    }
    else if(dim == PS_Y) {
        vrt *= Print_Screen[PS_Y];
    }
    else {
        vrt *= dim;
    };
    return fracf(vrt, PS_VMax);
};

func int Print_ToVirtual(var int pxl, var int dim) {
    return roundf(Print_ToVirtualF(pxl, dim));
};
func int Print_ToPixel(var int vrt, var int dim) {
    return roundf(Print_ToPixelF(vrt, dim));
};


func int Print_ToRatio(var int size, var int dim) {
    if (dim == PS_Y) {
        return roundf(mulf(mkf(size), Print_Ratio));
    } else if (dim == PS_X) {
        return roundf(divf(mkf(size), Print_Ratio));
    };
    return -1;
};

func int Print_ToRadian(var int angle) {
    const int toRadian = 1016003125; // 0.017453292
    mulf(angle, toRadian);
};
func int Print_ToDegree(var int angle) {
    const int toDegree = 1113927393; // 57.29578
    mulf(angle, toDegree);
};

//========================================
// Erweitertes PrintScreen
//========================================

instance zCViewTextPrint(zCViewText) {
    _vtbl = zCViewText_vtbl;
    inPrintWin = 0;
    timer = 0;
    timed = 0;
    colored = 0;
    color = 0;
};

func void zCViewTextPrint_UnArchiver(var zCViewText this) {
    this._vtbl = PM_LoadInt("vtbl");
    this.posx = PM_LoadInt("posx");
    this.posy = PM_LoadInt("posy");
    this.text = PM_LoadString("text");
    this.font = Print_GetFontPtr(PM_LoadString("fontname"));
    this.timer = PM_LoadInt("timer");
    this.inPrintWin = PM_LoadInt("inPrintWin");
    this.color = PM_LoadInt("color");
    this.timed = PM_LoadInt("timed");
    this.colored = PM_LoadInt("colored");

    var zCView v; v = _^(MEM_Game.array_view[0]);
    if (v.textlines_next) {
        List_Add(v.textlines_next, MEM_InstToPtr(this));
    } else {
        v.textlines_next = List_Create(MEM_InstToPtr(this));
    };
};


func int Print_Ext(var int x, var int y, var string text, var string font, var int color, var int time) {
    if (!_@(MEM_Game)) || (!_@(MEM_StackPos)) {
        // Initialize if called during level change
        MEM_InitLabels();
        MEM_InitGlobalInst();
    };

    if (time == -1) {
        var int h; h = new(zCViewTextPrint);
        var zCViewText txt; txt = get(h);
    } else {
        h = -1;
        txt = _^(create(zCViewTextPrint));
    };

    if(!color) { color = 1; };

    txt.timed = (time != -1);
    if (time != -1) { txt.timer = mkf(time); };

    txt.font = Print_GetFontPtr(font);
    txt.color = color;
    txt.text = text;
    txt.colored = 1;

    txt.posx = x;
    if (x == -1) {
        txt.posx = (PS_VMax - Print_ToVirtual(Print_GetStringWidth(text, font), PS_X)) / 2;
    };
    txt.posy = y;
    if (y == -1) {
        txt.posy = (PS_VMax - Print_ToVirtual(Print_GetFontHeight(font), PS_Y)) / 2;
    };

    var zCView v; v = _^(MEM_Game.array_view[0]);
    if (v.textlines_next) {
        List_Add(v.textlines_next, MEM_InstToPtr(txt));
    } else {
        v.textlines_next = List_Create(MEM_InstToPtr(txt));
    };
    return h;
};

//========================================
// Erweitertes PrintScreen (pixel)
//========================================
func int Print_ExtPxl(var int x, var int y, var string text, var string font, var int color, var int time) {
    Print_Ext(Print_ToVirtual(x, PS_X), Print_ToVirtual(y, PS_Y), text, font, color, time);
};

//========================================
// Textfeld
//========================================

func string Print_LongestLineExt(var string text, var string font, var string separator) {
    var int cnt; cnt = STR_SplitCount(text, separator);
    var int i; i = 0;
    var int max; max = 0;
    var int tmp; tmp = 0;

    var int pos; pos = MEM_StackPos.position;
        if (i >= cnt) {
            return STR_Split(text, separator, i-1);
        };
        tmp = Print_GetStringWidth(STR_Split(text, separator, i), font);
        if (tmp > max) {
            max = tmp;
        };
    i+=1;
    MEM_StackPos.position = pos;
};

func string Print_LongestLine(var string text, var string font) {
	Print_LongestLineExt(text, font, Print_LineSeperator);
};

func int Print_LongestLineLengthExt(var string text, var string font, var string separator) {
    return Print_GetStringWidth(Print_LongestLineExt(text, font, separator), font);
};

func int Print_LongestLineLength(var string text, var string font) {
    return Print_LongestLineLengthExt(text, font, Print_LineSeperator);
};

func int Print_TextFieldColored(var int x, var int y, var string text, var string font, var int height, var int color) {
    var int cnt; cnt = STR_SplitCount(text, Print_LineSeperator);
    var int i; i = 1;
    var int ptr; ptr = Print_CreateTextPtrColored(STR_Split(text, Print_LineSeperator, 0), font, color);
    var zCViewText txt; txt = _^(ptr);
    txt.posx = x;
    txt.posy = y;

    var int list; list = List_Create(Ptr);
    var int pos; pos = MEM_StackPos.position;
    if (i >= cnt) {
        return list;
    };
        ptr = Print_CreateTextPtrColored(STR_Split(text, Print_LineSeperator, i), font, color);
        txt = _^(ptr);
        txt.posx = x;
        txt.posy = y+(height*i);

        List_Add(list, ptr);
        i+=1;

    MEM_StackPos.position = pos;
};

func int Print_TextField(var int x, var int y, var string text, var string font, var int height) {
	return Print_TextFieldColored(x, y, text, font, height, -1);
};

func int Print_TextFieldPxl(var int x, var int y, var string text, var string font) {
    return Print_TextField(Print_ToVirtual(x, PS_X), Print_ToVirtual(y, PS_Y), text, font, Print_ToVirtual(Print_GetFontHeight(font), PS_Y));
};



//========================================
// Klasse für PermMem
//========================================
class gCPrintS {
    var int a8_Alpha;    // Anim8(h)
    var int a8_Movement; // Anim8(h)
    var int tv_Text;     // Print(h)
    var int vr_Pos;
    var int vr_Offs;
};
instance gCPrintS@(gCPrintS);

var int gCPrintS_Act;
var int gCPrintS_COff;

func void gCPrintS_Delete(var gCPrintS this) {
    Anim8_Delete(this.a8_Movement);
    Print_DeleteText(this.tv_Text);
};

func void gCPrintS_Alpha(var int h, var int value) {
    var gCPrintS p; p = get(h);
    var zCViewText t; t = get(p.tv_Text);
    t.color = ChangeAlpha(t.color, value);
    if(gCPrintS_COff > p.vr_Offs) {
        p.vr_Pos -= (gCPrintS_COff - p.vr_Offs) * PF_TextHeight;
        Anim8(p.a8_Movement, p.vr_Pos, PF_MoveYTime, A8_SlowEnd);
        p.vr_Offs = gCPrintS_COff;
    };
};

func void gCPrintS_Position(var int h, var int value) {
    var gCPrintS p; p = get(h);
    var zCViewText t; t = get(p.tv_Text);
    t.posY = value;
};

//========================================
// Softprint
//========================================
func void PrintS_Ext(var string txt, var int color) {
    var int h; h = new(gCPrintS@);
    var gCPrintS p; p = get(h);
    var int v;

    v = Anim8_NewExt(1, gCPrintS_Alpha, h, false);
    Anim8_RemoveIfEmpty(v, true);
    Anim8_RemoveDataIfEmpty(v, true);
    Anim8 (v, 255, PF_FadeInTime,  A8_Constant);
    Anim8q(v, 0,   PF_WaitTime,    A8_Wait);
    Anim8q(v, 0,   PF_FadeOutTime, A8_SlowStart);
    p.a8_Alpha = v;

    v = Anim8_NewExt(PF_PrintY, gCPrintS_Position, h, false);
    Anim8 (v, PF_PrintY - PF_TextHeight, PF_MoveYTime, A8_SlowEnd);
    p.a8_Movement = v;

    p.tv_Text = Print_Ext(PF_PrintX, PF_PrintY, txt, PF_Font, color, -1);
    p.vr_Pos = PF_PrintY - PF_TextHeight;
    gCPrintS_COff += 1;
    if(!gCPrintS_Act) {
        gCPrintS_COff = 0;
    };
    gCPrintS_Act += 1;
    p.vr_Offs = gCPrintS_COff;
};
func void AI_PrintS_Ext(var c_npc slf, var string txt, var int color) {
    AI_Function_SI(slf, PrintS_Ext, txt, color);
};

//========================================
// vereinfachter Softprint
//========================================
func void PrintS(var string txt) {
    PrintS_Ext(txt, RGBA(255,255,255,0));
};
func void AI_PrintS(var c_npc slf, var string txt) {
    AI_Function_S(slf, PrintS, txt);
};

//========================================
// PrintScreen fixen
//========================================
func void Print_FixPS() {
    /* All zCView::PrintTimed* functions that are called by the externals PrintScreen and AI_PrintScreen
     * call zCView::CreateText with the arguments "color" and "colored" set to zero/False. These are
     * overwritten here to force white text, regardless of previous prints.
     */

    const int addr_color[4]   = { zCView__PrintTimed_color,     zCView__PrintTimedCX_color,
                                  zCView__PrintTimedCY_color,   zCView__PrintTimedCXY_color   };
    const int addr_colored[4] = { zCView__PrintTimed_colored,   zCView__PrintTimedCX_colored,
                                  zCView__PrintTimedCY_colored, zCView__PrintTimedCXY_colored };
    const int offset[4]       = { 28, 64, 32, 60 }; // Function stack offsets for value of "color"

    repeat(i, 4); var int i;
        // Set argument "color" to white
        var int addr; addr = MEM_ReadStatArr(addr_color, i);
        MemoryProtectionOverride(addr, 8);
        MEM_WriteInt(addr, 2376903); // mov DWORD [esp+offset], -1
        MEM_WriteByte(addr+3, MEM_ReadStatArr(offset, i));
        MEM_WriteInt(addr+4, -1);

        // Set argument "colored" to true
        addr = MEM_ReadStatArr(addr_colored, i);
        MemoryProtectionOverride(addr, 4);
        MEM_WriteInt(addr, 23761040); // nop; nop; push 1
    end;
};