[Skriptpaket] LeGo #4

**piootrek86** · 20.04.2020 18:35

Hi,

I have a problem with lego bar, Bar_SetAlpha function. I use as below:

PHP-Code:


Bar_SetAlpha(MyBar_ST, Bar_Transp);

it does work but.... it change aplha of backTex = "Bar_Back.tga"; instead of barTex = "Bar_Misc.tga";

any idea why? and how to fix it?

Edit: Here you can see what I mean:

https://www.youtube.com/watch?v=1tZYRm5cTig

**Lehona** · 20.04.2020 20:35

Bar_SetAlpha should change the transparency of both textures equally, not just the background. Are you using the newest version of LeGo and can you post the function Bar_SetAlpha (in LeGo/Bars.d) just so we can make sure we're both talking about the same code? The function is very simple and I see no reason why it would work for only one of the textures.

**piootrek86** · 20.04.2020 21:20

I am using version 2.5.1.

Spoiler:(zum lesen bitte Text markieren)

func void Bar_SetAlpha(var int bar, var int alpha) {
if(!Hlp_IsValidHandle(bar)) { return; };
var _bar b; b = get(bar);
var zCView v; v = View_Get(b.v0);
v.alpha = alpha;
v = View_Get(b.v1);
v.alpha = alpha;
};

I managed to fix it thanks to @Siemekk, by adding v.alphaFunc = 2;

**Kirides** · 28.04.2020 11:03

Hey

Ich spiele gerade wieder ein wenig mit LeGo, Ninja, etc.

Wie lösche ich ein Item aus der Welt korrekt, sodass es im nächsten Aufruf meines Hooks nicht mehr als hero.focus_vob erkannt wird?

Aktuell habe ich lediglich ein MEM_DeleteVob(her.focus_vob); Aufruf.

insgesamt sieht es in etwa so aus:

Code:

// Hooken
HookEngineF(oCNpc__GetFocusVob, 6, MeinHook);

// MeinHook() ... Etwas ausgelassener Code für input validierung ...

var oCNpc her; her = Hlp_GetNpc(hero);
if (Hlp_Is_oCItem(her.focus_vob)) {
	var C_Item targetItem; targetItem = MEM_PtrToInst(her.focus_vob);
	if (!Hlp_IsValidItem(targetItem)) { return ; };
	
	MEM_DeleteVob(her.focus_vob); // oder Wld_RemoveItem(targetItem);
};

Aktuell behelfe ich mir mit einem

Code:

if (lastPtr == her.focus_vob) { return; };

EDIT:

Wenn ich gerade schon dabei bin... Wld_RemoveItem triggert leider keine "Ertappt" Ereignisse wenn etwas "aufgehoben" wird.
Kann man diese separat ausführen? (Script oder bestehende Engine-Funktion?)

EDIT 2:

Mit einer Abwandlung von F A W K E S' Script habe ich das gewünschte Ergebnis erhalten können.

**F a w k e s** · 28.04.2020 19:51

Hello Kirides,
I guess you can just set her.focus_vob to 0 before you use Wld_RemoveItem function.
(There is quite interesting feature in G1 - where if you call this function Wld_RemoveItem on focus_vob while holding Ctrl as a player - item will not be removed from world, not sure how G2A behaves)

To remove item from the world and to move it to NPCs inventory, you can probably use NPC_DoTakeVob (her, her.focus_vob)

:
(I use this one, this way I don't have to set focus_vob to 0, also it sends perception PERC_ASSESSTHEFT)

Code:

FUNC VOID NPC_DoTakeVob (var int slfInstance, var int itemPtr)
{
    //006A0D10  .text     Debug data           ?DoTakeVob@oCNpc@@UAEHPAVzCVob@@@Z
    const int oCNpc__DoTakeVob_G1 = 6950160;
    
    //0x007449C0 public: virtual int __thiscall oCNpc::DoTakeVob(class zCVob *)
    const int oCNpc__DoTakeVob_G2 = 7621056;


    var oCNPC slf; slf = Hlp_GetNPC (slfInstance);
    
    if (Hlp_IsValidNPC (slf)) {
        if (Hlp_Is_oCItem (itemPtr)) {
            CALL_PtrParam (itemPtr);
            CALL__thiscall (MEM_InstToPtr (slf), MEMINT_SwitchG1G2 (oCNpc__DoTakeVob_G1, oCNpc__DoTakeVob_G2));
        };
    };
};

**piootrek86** · 30.04.2020 15:02

Hello,

Could someone tell me, is it possible to set npc behaviour depence on lego talent? I made something like this:

Code:

var int npc_self;    var int npc_other;
npc_self = TAL_GetValue(self, T_Test);
npc_other = TAL_GetValue(other, T_Test);

if (npc_self == 1) && (npc_other == 2)    || (npc_self == 2) && (npc_other == 1)
{
   B_Attack (self, other, AR_GuildEnemy, 0);

};

Both npc have T_Test set up. One npc have 1, another have 2.
Unfortunately nothing is happening as when I printed it:

Code:

PrintS_Ext(IntToString(npc_other), RGBA(203, 114, 227, 1));

it does return value -1; It works only if npc see player, but does not work if npc see another npc. Is there any way I can make it work?

P.S. I use hook HookEngineF(7609360,6,_Test);//0x00683480 0 6 public: int __thiscall oCNpc::EV_CanSeeNpc(oCMsgMovement

**mud-freak** · 02.05.2020 14:07

Zitat von F a w k e s

I guess you can just set her.focus_vob to 0 before you use Wld_RemoveItem function.

I guess the issue is already resolved, but just to note on the statement: You should not change the focus vob by assignment, because it involves object references. Instead have a look at this post (list item 4).

Zitat von piootrek86

Hello,

Could someone tell me, is it possible to set npc behaviour depence on lego talent? I made something like this:

Code:

var int npc_self;    var int npc_other;
npc_self = TAL_GetValue(self, T_Test);
npc_other = TAL_GetValue(other, T_Test);

if (npc_self == 1) && (npc_other == 2)    || (npc_self == 2) && (npc_other == 1)
{
   B_Attack (self, other, AR_GuildEnemy, 0);

};

Both npc have T_Test set up. One npc have 1, another have 2.
Unfortunately nothing is happening as when I printed it:

Code:

PrintS_Ext(IntToString(npc_other), RGBA(203, 114, 227, 1));

it does return value -1; It works only if npc see player, but does not work if npc see another npc. Is there any way I can make it work?

P.S. I use hook HookEngineF(7609360,6,_Test);//0x00683480 0 6 public: int __thiscall oCNpc::EV_CanSeeNpc(oCMsgMovement

Can you elaborate a bit more. Maybe it helps if you supply more code:

When is the above code executed?
What does it have to do with oCNpc::EV_CanSeeNpc?
How/where do you set the talents?
How do you initialize LeGo?

**F a w k e s** · 02.05.2020 14:14

Zitat von mud-freak

I guess the issue is already resolved, but just to note on the statement: You should not change the focus vob by assignment, because it involves object references. Instead have a look at this post (list item 4).

Thank you! I will have a look again, seems like I missed your previous post completely.

**Atariar** · 15.05.2020 07:29

Hallo zusammen,

in meiner Modifikation nutze ich fast ausschließlich PrintS für Print-Anzeigen. Z. B. Tagebucheinträge, die EXP-Anzeigen, etc. - meine Tester und auch die Spieler der Atariar Edition (seit Version 1.4) haben festgestellt, dass nicht immer die PrintS angezeigt werden.

Dabei sind mehrere Dinge aufgefallen:

das Einblendungen nicht angezeigt werden, scheint willkürlich und tritt ab und zu mal auf
beim Speichern werden alle PrintS übereinander angezeigt und summieren sich auf
nach einem Spielneustart und Neuladen des betroffenen Saves funktionieren die PrintS wieder korrekt
Tester mit DX11-Renderer melden diesen Fehler, Tester, die ohne den Renderer spielen haben scheinbar keine Probleme (ob hier eine Kausalität besteht, weiß ich nicht)

Hier im Video vom Beta Test der 1.5 bei Plasquar gut zu sehen (7:03:55 - und davor beim Töten von Tieren und CO. keine Einblendung des Prints):
https://youtu.be/m6bJsWKVP6k?t=25435

Hier meine Scripte: Lego 2.6.0, Ikarus 1.2.1

Die virtuellen Positionen verändere ich im Spiel in Abhängigkeit zu verschiedenen States.

Auszug aus Userconst.d (Lego) - PF_PrintX als Variable definiert.

Code:

var int    PF_PrintX;         // Startposition Xvar int    PF_PrintY;         // Startposition Y
const int    PF_TextHeight  = 180;     // Abstand zwischen einzelnen Zeilen

Ich ändere sie dann abhängig von den Einstellungen des Spielers im Menu.

ApplySettings wird in der Startup gehooked.
HookEngineF (cGameManager__ApplySomeSettings_rtn, 6, ApplySettings);

Code:

func void ApplySettings () {    
    // 1. Print Position
    PositionPrints = STR_ToInt(MEM_GetGothOpt("ATARIAR", "PrintPosition"));
    if (PositionPrints == 0) {            // Mittig Mittig
        PF_PrintX = PF_PrintX_Center;
        PF_PrintY = PF_PrintY_CenterTop;
    } else if (PositionPrints == 1) {    // Links Mittig
        PF_PrintX = PF_PrintX_Left;
        PF_PrintY = PF_PrintY_Center;
    } else if (PositionPrints == 2) {    // Links unten
        PF_PrintX = PF_PrintX_Left;
        PF_PrintY = PF_PrintY_Bottom;
    } else {                            // Links oben
        PF_PrintX = PF_PrintX_Left;
        PF_PrintY = PF_PrintY_Top;
    };
};

Dazu kommt noch die Besonderheit, dass ich die Quickslotbar von Siemiekk nutze (https://forum.worldofplayers.de/foru...1#post26162947) - allerdings habe ich den Code überarbeitet.

Hier wird pro Frame abgefragt, ob das Inventar offen ist. Wenn ja, dann passe die Printposition an (damit die Prints mittig angezeigt werden und nicht mit dem geöffneten Inventar überlappen).

Code:

var int block;
// Per Frame loop
func void QS_RenderHook()
{
    if !Hlp_IsValidNpc(hero) {
        return;
    };
    
    var int posY; posY = 8192 - Print_ToVirtual(140, PS_Y); 
    if (QS_IsInvOpen()) {
        PF_PrintX = PF_PrintX_Center;
        PF_PrintY = PF_PrintY_CenterTop;
        block = TRUE;
        posY = QS_posY_OpenInv;
    } else {
        if block == TRUE {
            if (PositionPrints == 0) {            // Mittig Mittig
                PF_PrintX = PF_PrintX_Center;
                PF_PrintY = PF_PrintY_CenterTop;
            } else if (PositionPrints == 1) {    // Links Mittig
                PF_PrintX = PF_PrintX_Left;
                PF_PrintY = PF_PrintY_Center;
            } else if (PositionPrints == 2) {    // Links unten
                PF_PrintX = PF_PrintX_Left;
                PF_PrintY = PF_PrintY_Bottom;
            } else {                            // Links oben
                PF_PrintX = PF_PrintX_Left;
                PF_PrintY = PF_PrintY_Top;
            };
            block = FALSE;
        };
    };    
// ...

B_LogEntry.d

Code:

// **********// B_LogEntry
// **********
var string lastPrintTopic;
var int lastPrintTime;


func void B_LogEntry (var string topic, var string entry)
{
    Log_AddEntry    (topic, entry);
    
    if (Hlp_StrCmp(lastPrintTopic, topic) == True) 
    && (MEM_Timer.totalTime == lastPrintTime) {
        return;
    };


    lastPrintTopic = topic;
    lastPrintTime = MEM_Timer.totalTime;
    
    if (PrintLogs == 0)    {
        PrintS (ConcatStrings ("Tagebucheintrag (",ConcatStrings(topic,")")));
    } else if (PrintLogs == 1)  {
        PrintS             (PRINT_NewLogEntry);
    } else if (PrintLogs == 2)  {
    
    } else {
        PrintS (ConcatStrings ("Tagebucheintrag (",ConcatStrings(topic,")")));
    };
    Snd_Play         ("LogEntry");
};

Auszug Lego-Scripte: Interface.d und Anim8.d

Spoiler:(zum lesen bitte Text markieren)

Interface.d

Code:

/***********************************\
              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_ToVirtual(var int pxl, var int dim) {
    Print_GetScreenSize();
    pxl *= 8192;
    if(dim == PS_X) {
        return pxl / Print_Screen[PS_X];
    }
    else if(dim == PS_Y) {
        return pxl / Print_Screen[PS_Y];
    };
    return pxl / dim;
};
func int Print_ToPixel(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 vrt / 8192;
};


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_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) {
    return Print_Ext(Print_ToVirtual(x, PS_X), Print_ToVirtual(y, PS_Y), text, font, color, time); // Atariar Fix 02.05.2020
    // 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;
};

Anim8

Code:

/***********************************\
                ANIM8
\***********************************/


//========================================
// [intern] Variablen und Klassen
//========================================


class A8Head {
    var int value;
    var int fnc;
    var int dfnc;
    var int flt;
    var int data;
    var int dif;
    var int ddif;
    var int queue; //zCList<A8Command(h)>*
};


// const string A8Head_Struct = "auto|3 zCList*";


func void A8Head_Archiver(var A8Head this) {
    PM_SaveInt("value", this.value);
    if(this.fnc) { PM_SaveFuncPtr("loop",  this.fnc);  };
    if(this.dfnc){ PM_SaveFuncPtr("del",   this.dfnc);  };
    if(this.flt) { PM_SaveFloat  ("float", this.flt);  };
    if(this.data){ PM_SaveInt    ("data",  this.data); };
    if(this.dif) { PM_SaveInt    ("dif",   this.dif);  };
    if(this.ddif){ PM_SaveInt    ("ddif",  this.ddif); };
    PM_SaveClassPtr("queue", this.queue, "zCList");
};


func void A8Head_UnArchiver(var A8Head this) {
    this.value = PM_Load("value");
    if(PM_Exists("loop"))  { this.fnc  = PM_LoadFuncPtr("loop"); };
    if(PM_Exists("del"))   { this.dfnc = PM_LoadFuncPtr("del");  };
    if(PM_Exists("float")) { this.flt  = PM_LoadFloat("float");  };
    if(PM_Exists("data"))  { this.data = PM_LoadInt("data");     };
    if(PM_Exists("dif"))   { this.dif  = PM_LoadInt("dif");      };
    if(PM_Exists("ddif"))  { this.ddif = PM_LoadInt("ddif");     };
    this.queue = PM_Load("queue");
};


func void A8Head_Empty(var A8Head h) {
    if(!h.queue) { return; };
    List_ForF(h.queue, A8Head_EmptySub);
    List_Destroy(h.queue);
    h.queue = 0;
};


func void A8Head_EmptySub(var int node) {
    if(Hlp_IsValidHandle(MEM_ReadInt(node))) {
        delete(MEM_ReadInt(node));
    };
};


func void A8Head_Delete(var A8Head this) {
    A8Head_Empty(this);
    if (this.dfnc) {
        MEM_CallByPtr(this.dfnc);
    };
};


instance A8Head@(A8Head);


class A8Command {
    var int target;
    var int timeSpan;
    var int startVal;
    var int startTime;
    var int velo;
    var int startV;
    var int interpol;
};


instance A8Command@(A8Command);


//========================================
// Neues Objekt erstellen
//========================================
func int Anim8_New(var int value, var int IsFloat) {
    var int hndl; hndl = new(A8Head@);
    var A8Head h; h = get(hndl);
    if(!IsFloat) {
        h.value = mkf(value);
    }
    else {
        h.value = value;
    };
    h.flt = !!IsFloat;
    return hndl;
};


//========================================
// Neues Objekt mit Handler erstellen
//========================================
func int Anim8_NewExt(var int value, var func handler, var int data, var int IsFloat) {
    var int hndl; hndl = Anim8_New(value, IsFloat);
    var A8Head h; h = get(hndl);
    h.fnc = MEM_GetFuncPtr(handler);
    h.data = data;
    return hndl;
};


//========================================
// Objekt komplett löschen
//========================================
func void Anim8_Delete(var int hndl) {
    if(!Hlp_IsValidHandle(hndl)) {
        MEM_Warn("A8_Delete: Invalid handle");
        return;
    };
    delete(hndl);
};


//========================================
// [intern] Beschleunigung berechnen
//========================================
func void _Anim8_SetVelo(var A8Head h, var A8Command c) {
    if(c.interpol == A8_Wait) { return; };
    if(c.interpol == A8_Constant) {
        // v = s/t;
        c.velo = divf(subf(c.target, h.value), c.timeSpan);
    }
    else {
        //a = 2*s/t^2
        c.velo = divf(mulf(mkf(2), subf(c.target, h.value)), mulf(c.timeSpan, c.timeSpan));
        if(c.interpol == A8_SlowEnd) {
            c.startV = mulf(c.velo, c.timeSpan);
            c.velo = negf(c.velo);
        };
    };
};


//========================================
// [intern] Neuer Befehl
//========================================
func void _Anim8_Ext(var int hndl, var int targetVal, var int timeSpan, var int interpol, var int UseQueue) {
    var A8Head h; h = get(hndl);
    if(!UseQueue) {
        A8Head_Empty(h);
    };
    if(!h.queue) {
        h.queue = List_Create(0);
    };
    var int cmd; cmd = new(A8Command@);
    var A8Command c; c = get(cmd);
    c.target = targetVal;
    if(!h.flt) {
        c.target = mkf(c.target);
    };
      //if((h.value == c.target) && (!UseQueue)) { interpol = A8_Wait; }; // This seemed to be useless and responsible for a bug
    c.startVal = h.value;
    c.startTime = TimerGT();
    c.timeSpan = mkf(timeSpan);
    c.interpol = interpol;
    _Anim8_SetVelo(h, c);
    List_Add(h.queue, cmd);
};


//========================================
// [intern] FF-Loop
//========================================
func void _Anim8_FFLoop() {
    MEM_PushIntParam(A8Head@);
    MEM_GetFuncID(_Anim8_Loop);
    MEM_StackPos.position = foreachHndl_ptr;
};
func int _Anim8_Loop(var int hndl) {
    var A8Head h; h = get(hndl);
    if(!h.queue) {
        return rContinue;
    };
    if(h.queue < 1048576) {
        var int s; s = SB_New();
        SB ("A8 sucks. Handle ");
        SBi(hndl);
        SB (" of instance ");
        SB (_PM_InstName(getInst(hndl)));
        SB (" messed up with a queue of ");
        SBi(h.queue);
        SB (". I will ignore it.");
        SB (STR_Unescape("\n"));
        SB ("The pointer was ");
        SBi(getPtr(hndl));
        SB ("...");
        MEM_Warn(SB_ToString());
        SB_Destroy();
        return rContinue;
    };
    if(!List_HasLength(h.queue, 2)) {
        return rContinue;
    };


    var int ldata; ldata = List_Get(h.queue, 2);
    if(!ldata) {
        List_Delete(h.queue, 2);
        return rContinue;
    };


    var A8Command c; c = get(ldata);


    // Eigentliche Interpolierung
    var int t; t = mkf(TimerGT() - c.startTime);


    if(c.interpol&&c.interpol < A8_Wait) {
        if(c.interpol == A8_Constant) {
            // s = v*t;
            h.value = mulf(c.velo, t);
        }
        else if(c.interpol == A8_SlowEnd) {
            // s = a/2*t^2 + v0*t
            h.value = addf(mulf(mulf(c.velo, floatHalb), mulf(t, t)), mulf(c.startV, t));
        }
        else if(c.interpol == A8_SlowStart) {
            // s = a/2*t^2
            h.value = mulf(mulf(c.velo, floatHalb), mulf(t, t));
        };
        h.value = addf(c.startVal, h.value);
    };


    if(gef(t, c.timeSpan)) {
        if(c.interpol != A8_Wait) {
            h.value = c.target;
        };
    };


    if(h.fnc) {
        if(h.data) {
            h.data;
        };
        if(h.flt) {
            h.value;
        }
        else {
            roundf(h.value);
        };
        MEM_CallByPtr(h.fnc);
    };


    if(gef(t, c.timeSpan)) {
        delete(ldata);
        List_Delete(h.queue, 2);
        // ggf. Liste aktualisieren
        if(List_HasLength(h.queue, 2)) {
            ldata = List_Get(h.queue, 2);
            if(!ldata) {
                List_Delete(h.queue, 2);
                return rContinue;
            };
            c = get(ldata);
            c.startVal = h.value;
            c.startTime = TimerGT();
            _Anim8_SetVelo(h, c);
        }
        else if(h.dif) {
            if(h.ddif) {
                if(h.data) {
                    delete(h.data);
                };
            };
            delete(hndl);
        };
    };
    return 0; // Atariar Fix 02.05.2020
};


//========================================
// Wert eines Objektes holen
//========================================
func int Anim8_Get(var int hndl) {
    if(!Hlp_IsValidHandle(hndl)) {
        return 0;
    };
    var A8Head h; h = get(hndl);
    if(h.flt) {
        return h.value;
    };
    return roundf(h.value);
};


//========================================
// Wert eines Objektes setzen
//========================================
func void Anim8_Set(var int hndl, var int v) {
    if(!Hlp_IsValidHandle(hndl)) {
        return;
    };
    var A8Head h; h = get(hndl);
    h.value = v;
};


//========================================
// Objekt zerstören wenn es leer ist?
//========================================
func void Anim8_RemoveIfEmpty(var int hndl, var int on) {
    if(!Hlp_IsValidHandle(hndl)) {
        return;
    };
    var A8Head h; h = get(hndl);
    h.dif = !!on;
};


//========================================
// Objektdata zerstören wenn es leer ist?
//========================================
func void Anim8_RemoveDataIfEmpty(var int hndl, var int on) {
    if(!Hlp_IsValidHandle(hndl)) {
        return;
    };
    var A8Head h; h = get(hndl);
    h.ddif = !!on;
};


//========================================
// Registriere eine on-remove Funktion
//========================================
func void Anim8_CallOnRemove(var int hndl, var func dfnc) {
    if (!Hlp_IsValidHandle(hndl)) {
        return;
    };
    var A8Head h; h = get(hndl);
    h.dfnc = MEM_GetFuncPtr(dfnc);
};


//========================================
// Ist das Objekt leer?
//========================================
func int Anim8_Empty(var int hndl) {
    if(!Hlp_IsValidHandle(hndl)) {
        return 1;
    };
    var A8Head h; h = get(hndl);
    if(!h.queue) { return 1; };
    return !List_HasLength(h.queue, 2);
};


//========================================
// Neuer Befehl
//========================================
func void Anim8(var int hndl, var int target, var int span, var int interpol) {
    _Anim8_Ext(hndl, target, span + (!span), interpol, 0);
};


//========================================
// Neuen Befehl anhängen
//========================================
func void Anim8q(var int hndl, var int target, var int span, var int interpol) {
    _Anim8_Ext(hndl, target, span + (!span), interpol, 1);
};

Was meint ihr dazu? Woran könnte es liegen? Vielen lieben Dank!

Atariar

**mud-freak** · 15.05.2020 17:13

Ich muss sagen, ich habe wirklich nur ganz grob drauf geschaut;

Möglicherweise liegt das an deinem gut-gemeinten Fix in Anim8.d in Zeile 266.

Code:

return 0; // Atariar Fix 02.05.2020

Damit wird die Anim8-Loop unterbrochen. Versuche es stattdessen mal mit

Code:

return rContinue;

Ich kann nichts versprechen, aber das kannst du mal ausprobieren.

**Atariar** · 15.05.2020 17:33

Danke dir, Mud-Freak! Das teste ich.

EDIT: Ich teste fleißig und bisher wurden alle Prints korrekt angezeigt. Falls sich daran was ändert, gebe ich nochmal bescheid und suche weiter nach möglichen Gründen. Bis jetzt passt aber alles.

**Bloodfly91** · 03.06.2020 09:51

Ich möchte einen neuen Statusbalken an der Position vom Gothic 2 Lebensbalken des Spielers erstellen, dazu rufe ich in einer FrameFunction folgenden Code auf:

Code:

func void barNew_Loop(){ 
    var int barNew;
    
    var oCViewStatusBar hpBar; hpBar = MEM_PtrToInst(MEM_Game.hpBar);


    dynEndX = hpBar.zCView_pposx;
    dynEndY = hpBar.zCView_pposy;
    dynEndWidth = hpBar.zCView_psizex;
    dynEndHeight = hpBar.zCView_psizey;
    
    Bar_SetMax(barNew, valueOne);
    Bar_SetValue(barNew, valueTwo);
    
    var zcView rangeBar; rangeBar = MEM_PtrToInst(hpBar.value_bar);


    dynEndBarTop = rangeBar.pposy - hpBar.zCView_pposy;
    dynEndBarLeft = rangeBar.pposx - hpBar.zCView_pposx;
    
    if (!Hlp_IsValidHandle(barNew)) 
    {    
        barNew = Bar_Create(newBar);
    };
    
    if (MEM_Game.pause_screen || !InfoManager_HasFinished())
    {
        Bar_Delete(barNew);
    };
};

Der Balken:

Code:

instance newBar(GothicBar) {    
    x = dynEndX;
    y = dynEndY;
    
    barTop = dynEndBarTop;
    barLeft = dynEndBarLeft;
    
    width = dynEndWidth;
    height = dynEndHeight;
    
    backTex = "ZXY.tga";
    barTex = "XYZ.tga";
    
    value = barValue;
    valueMax = barValueMax;
};

Damit der Balken auch korrekt skaliert, wenn der Spieler die Auflösung ändert, lösche ich den Balken, sobald ein Menü geöffnet wird und lasse ihn erneut erstellen.

Allerdings ist der neue Balken von Anfang an an einer völlig anderen Position, als der Lebensbalken:

[Bild: Gothic2_2020_06_03_10_36_54_061.jpg]

Der ist zu weit oben und zu weit links.

Sollten mit hpBar.zCView_pposx bzw. hpBar.zCView_pposy nicht eigentlich die genauen Werte vom Lebensbalken kopiert und auf den neuen angewandt werden?

Edit: Mir ist außerdem aufgefallen, dass der Balken nur beim ersten Mal entfernt wird, wenn man mit einem NPC redet. Nach Dialogende wird der erneut erstellt, verschwindet dann aber weder wenn man das Menü öffnet, noch wenn man einen NPC anquatscht. Bar_Delete wird aber auf jeden Fall aufgerufen. Beim Pausieren existiert dieses Problem nicht, solange man noch nicht mit einem NPC geredet hat, wird der Balken ausgeblendet.

**Cryp18Struct** · 03.06.2020 11:44

Was die Position angeht: Die LeGo bars verwenden die übergebenen Werte als Mittelpunkt der bar.
Ausschnitt Dirty Swamp sprintcode als Lösungsvorschlag:

Code:

// LeGo bars benutzen den Mittelpunkt, daher jeweils um die Hälfte verschieben, liegt dann genau auf der mana bar
dynEndX = dynEndX + dynEndWidth/2;
dynEndY = dynEndY + dynEndHeight/2;

**mud-freak** · 03.06.2020 12:36

Zitat von Bloodfly91

Ich möchte einen neuen Statusbalken an der Position vom Gothic 2 Lebensbalken des Spielers erstellen

Falls du den Lebensbalken nachahmen möchtest, um dessen Textur zu ändern, kann ich dir das overrideBars Skript ans Herz legen. Damit lassen sich die existierenden Balken modifizieren, anstatt sie alle neu zu malen und sinnvoll verstecken, anzeigen und fortlaufend der Auflösung anpassen zu müssen. Dadurch ersparst du dir eine Menge Arbeit.

Die Funktionen getNPCHealthState, getPCManaState und getPCSwimState werden fortlaufend aufgerufen und erlauben dir die Texturen zu bestimmen. In der ersten Funktion kannst du den NPC nach hero abfragen, um Änderungen gezielt nur am Lebensbalken des Spielers vorzunehmen. (Die Funktion zum Schwimm-Balken ist mit einem Beispiel gefüllt und sollte geleert werden.)

**Bloodfly91** · 03.06.2020 16:34

Zitat von Cryp18Struct

Was die Position angeht: Die LeGo bars verwenden die übergebenen Werte als Mittelpunkt der bar.
Ausschnitt Dirty Swamp sprintcode als Lösungsvorschlag:

Code:

// LeGo bars benutzen den Mittelpunkt, daher jeweils um die Hälfte verschieben, liegt dann genau auf der mana bar
dynEndX = dynEndX + dynEndWidth/2;
dynEndY = dynEndY + dynEndHeight/2;

Vielen Dank, hat geklappt und der Balken skaliert nun mit (scheinbar) allen Auflösungen korrekt mit.

Zitat von mud-freak

Falls du den Lebensbalken nachahmen möchtest, um dessen Textur zu ändern, kann ich dir das overrideBars Skript ans Herz legen. Damit lassen sich die existierenden Balken modifizieren, anstatt sie alle neu zu malen und sinnvoll verstecken, anzeigen und fortlaufend der Auflösung anpassen zu müssen. Dadurch ersparst du dir eine Menge Arbeit.

Die Funktionen getNPCHealthState, getPCManaState und getPCSwimState werden fortlaufend aufgerufen und erlauben dir die Texturen zu bestimmen. In der ersten Funktion kannst du den NPC nach hero abfragen, um Änderungen gezielt nur am Lebensbalken des Spielers vorzunehmen. (Die Funktion zum Schwimm-Balken ist mit einem Beispiel gefüllt und sollte geleert werden.)

Danke für den Hinweis. Aber mein Ziel war es, sämtliche Statusbalken ordentlich in einer bestimmten Reihenfolge auf die linke Seite zu bekommen.

**mud-freak** · 03.06.2020 16:55

Zitat von Bloodfly91

Danke für den Hinweis. Aber mein Ziel war es, sämtliche Statusbalken ordentlich in einer bestimmten Reihenfolge auf die linke Seite zu bekommen.

Ah, das stimmt. Das ist natürlich ein anderes Vorhaben.
Da du ja evtl. inhaltlich an den Balken nicht viel ändern willst und alle so erhalten bleiben, frage ich mich, ob es nicht auch dort einfacher ist einfach die Koordinaten der bestehenden Balken zu überschreiben.

**mud-freak** · 04.06.2020 12:28

Zitat von mud-freak

Ah, das stimmt. Das ist natürlich ein anderes Vorhaben.
Da du ja evtl. inhaltlich an den Balken nicht viel ändern willst und alle so erhalten bleiben, frage ich mich, ob es nicht auch dort einfacher ist einfach die Koordinaten der bestehenden Balken zu überschreiben.

Ich habe es mir nicht nehmen lassen, diese Behauptung einmal auszuprobieren. Mit diesem Skript lassen sich die Balken sehr einfach und ohne großen Aufwand umpositionieren.

**Bloodfly91** · 04.06.2020 14:28

Zitat von mud-freak

Ich habe es mir nicht nehmen lassen, diese Behauptung einmal auszuprobieren. Mit diesem Skript lassen sich die Balken sehr einfach und ohne großen Aufwand umpositionieren.

Sehr cool, vielen Dank dafür!

Ich war gestern zwar bereits mit meinem Skript fertig, das zumindest bisher auch zu funktionieren scheint, aber deine Lösung ist da auf jeden Fall die bessere.

**Bisasam** · 13.06.2020 11:17

Kann es sein, dass für die Buttons eine besondere Handhabung notwendig ist?

Achtung! Tests sind für g1 Version gemacht worden!

Ich verwende Button_create und Button_show einmalig zum Anzeigen des Buttons und button_hide und button_delete um selbige loszuwerden. Meist lösche ich den betreffenden Button mit der eigenen on_click Funktion (macht Sinn wenn ich nicht 15 Buttons zeitgleich aktiv haben möchte). Auf die Buttons wird über Integervars zugegriffen, in denen bei create sofort die Adresse/id gespeichert wurde. (Die createfuncs sind ja mit return)

An einigen Stellen gibt es aber Access Violations beim klicken auf den Button und es gibt ein paar Funktionen, die wohl nicht in Kombination genutzt werden können.

1. On_click abstürze in unregelmäßigen Intervallen. Der niedrigste war 3 klicks, der höchste war 20 Klicks. Ich habe sowohl Klicks auf den gleichen, wie auf verschiedene Buttons getestet. Selbst Buttons mit leeren on_clicks erzeugen Abstürze.

2. Keine Tagebucheinträge möglich. Sobald man b_LogEntry benutzt, gibts ne Assess violation. 100% reproduzierbar.

3. Keine B_GiveInvItem möglich. Ebenfalls sofortiger Absturz. Seltsamerweise gehen Createinvitems und Npc_Removeinvitems ohne Distributionsfunktion perfekt.

Sowohl 2 als auch 3 enthalten eine printscreen-funktion. Kann es sein, dass es da inkompatibilität gibt?

**mud-freak** · 13.06.2020 12:05

Kannst du Code zeigen, der problematisch ist? Welche LeGo version benutzt du? Welche Pakete initialisierst du?

PS: Damit meine ich ein minimales Code-Beispiel, dass ich nur bei mir in die Skripte einfügen muss um den Fehler reproduzieren zu können.

[Skriptpaket] LeGo #4

Themen-Optionen

Lego Bar - Bar_SetAlpha

NPC_DoTakeVob

Lego Talent - NPC Assess NPC

PrintS wird manchmal nicht angezeigt / Beim Speichern dann komplett

Berechtigungen