KSG-Client/KSGClient/NachLogin/Editor/Karte/ShopSeite/KESSVorschau.cpp

#include "KESSVorschau.h"

#include <DateiSystem.h>
#include <Globals.h>

#include "../../../../Global/Initialisierung.h"
#include "../../../../Global/Variablen.h"

void kESSVorschauKSGSAktion(
    void* p, RCArray<KSGSVariable>* parameter, KSGSVariable** retVal)
{
    if (!p) return;
    ((KESSVorschauKarteScript*)p)->ksgsAktion(parameter, retVal);
}

// Inhalt der KESSVorschauKarteScript Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschauKarteScript::KESSVorschauKarteScript(TextFeld* zLog)
    : Thread()
{
    ksgs = Framework::getDLLRegister()->ladeDLL(
        "KSGScript.dll", "data/bin/KSGScript.dll");
    if (ksgs)
    {
        KSGSGetZeichnung getKSGScript
            = (KSGSGetZeichnung)GetProcAddress(ksgs, KSGS_START_FUNKTION);
        if (getKSGScript)
        {
            fenster = getKSGScript();
            fenster->setSchriftZ(
                dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
            fenster->setSize(555, 380);
            fenster->setCallbackParam(this);
            fenster->setCallbackFunktion(kESSVorschauKSGSAktion);
            fenster->setLog(dynamic_cast<TextFeld*>(zLog->getThis()));
        }
        else
        {
            fenster = 0;
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Der Einstiegspunkt '" KSGS_START_FUNKTION
                    "' in der DLL-Datei "
                    "'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
                new Text("Ok"),
                0);
        }
    }
    else
    {
        fenster = 0;
        nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
            new Text("Die DLL-Datei 'data/bin/KSGScript.dll' konnte nicht "
                     "geladen werden."),
            new Text("Ok"),
            0);
    }
    ram = new LRahmen();
    ram->setSize(555, 380);
    ram->setFarbe(0xFFFFFFFF);
    pos = Punkt(220, 10);
    sichtbar = 0;
    besitztTestVersion = 0;
    verbleibend = 0;
    vollversionErwerbbar = 1;
    testversionErwerbbar = 1;
    vvPreis = 0;
    tvPreis = 0;
    kupfer = 0;
    alpha = 0;
    aktion = 0;
    ak = 0;
}

// Destruktor
KESSVorschauKarteScript::~KESSVorschauKarteScript()
{
    if (fenster)
    {
        fenster->reset();
        fenster->release();
    }
    ram->release();
    if (ksgs) Framework::getDLLRegister()->releaseDLL("KSGScript.dll");
}

// nicht constant
void KESSVorschauKarteScript::thread()
{
    sichtbar = 0;
    while (alpha)
        Sleep(100);
    if (ak == 1)
    {
        pfad += "/seite/seite.ksgs";
        if (fenster) fenster->setScriptDatei(pfad);
    }
    fenster->neuLaden();
    sichtbar = 1;
    ak = 0;
    run = 0;
}

void KESSVorschauKarteScript::setScriptParams(
    bool hatTV, int tvVerb, bool vvEn, bool tvEn, int vvK, int tvK, int k)
{
    besitztTestVersion = hatTV;
    verbleibend = tvVerb;
    vollversionErwerbbar = vvEn;
    testversionErwerbbar = tvEn;
    vvPreis = vvK;
    tvPreis = tvK;
    kupfer = k;
    if (sichtbar)
    {
        ak = 2;
        start();
    }
}

void KESSVorschauKarteScript::ladeKarteSeite(const char* pfad)
{
    if (run) warteAufThread(5000);
    if (run) ende();
    this->pfad = pfad;
    ak = 1;
    start();
}

void KESSVorschauKarteScript::ksgsAktion(
    RCArray<KSGSVariable>* parameter, KSGSVariable** retVal)
{
    KSGSVariable* befehl = parameter->z(0);
    if (!befehl) return;
    Text* b = befehl->getText();
    if (!b) return;
    if (b->istGleich("GetBesitzStatus"))
    {
        int besitz = (int)besitztTestVersion;
        KSGSGetVariable getKSGSVariable
            = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
        if (getKSGSVariable)
        {
            KSGSVariableDef def
                = {KSGS_INT, 0, 3, (Text() += besitz).getText()};
            *retVal = getKSGSVariable(fenster, &def);
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION
                    "' in der DLL-Datei "
                    "'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
                new Text("Ok"),
                0);
        }
        b->release();
        return;
    }
    if (b->istGleich("GetPreis"))
    {
        KSGSVariable* version = parameter->z(1);
        if (!version)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                    "Sie könnte eventuell nicht richtig funktionieren."),
                new Text("Ok"),
                0);
        }
        else
        {
            bool testVersion = !version->getInt();
            int k = testVersion ? tvPreis : vvPreis;
            KSGSGetVariable getKSGSVariable
                = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
            if (getKSGSVariable)
            {
                KSGSVariableDef def = {KSGS_INT, 0, 3, (Text() += k).getText()};
                *retVal = getKSGSVariable(fenster, &def);
            }
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                    new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION
                             "' in der DLL-Datei "
                             "'data/bin/KSGScript.dll' konnte nicht gefunden "
                             "werden."),
                    new Text("Ok"),
                    0);
            }
        }
        b->release();
        return;
    }
    if (b->istGleich("GetTestVersionVerbleibend"))
    {
        KSGSGetVariable getKSGSVariable
            = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
        if (getKSGSVariable)
        {
            KSGSVariableDef def
                = {KSGS_INT, 0, 3, (Text() += verbleibend).getText()};
            *retVal = getKSGSVariable(fenster, &def);
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION
                    "' in der DLL-Datei "
                    "'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
                new Text("Ok"),
                0);
        }
        b->release();
        return;
    }
    if (b->istGleich("GetErwerbbarStatus"))
    {
        int erwerbbar = ((int)testversionErwerbbar & 0x1)
                      | (((int)vollversionErwerbbar << 1) & 0x2);
        KSGSGetVariable getKSGSVariable
            = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
        if (getKSGSVariable)
        {
            KSGSVariableDef def
                = {KSGS_INT, 0, 3, (Text() += erwerbbar).getText()};
            *retVal = getKSGSVariable(fenster, &def);
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION
                    "' in der DLL-Datei "
                    "'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
                new Text("Ok"),
                0);
        }
        b->release();
        return;
    }
    if (b->istGleich("GetKupfer"))
    {
        KSGSGetVariable getKSGSVariable
            = (KSGSGetVariable)GetProcAddress(ksgs, KSGS_VARIABLE_FUNKTION);
        if (getKSGSVariable)
        {
            KSGSVariableDef def
                = {KSGS_INT, 0, 3, (Text() += kupfer).getText()};
            *retVal = getKSGSVariable(fenster, &def);
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION
                    "' in der DLL-Datei "
                    "'data/bin/KSGScript.dll' konnte nicht gefunden werden."),
                new Text("Ok"),
                0);
        }
        b->release();
        return;
    }
    if (b->istGleich("Kaufen"))
    {
        KSGSVariable* version = parameter->z(1);
        if (!version)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                    "Sie könnte eventuell nicht richtig funktionieren."),
                new Text("Ok"),
                0);
        }
        b->release();
        return;
    }
    if (b->istGleich("GetBild"))
    {
        KSGSVariable* pfad = parameter->z(1);
        KSGSVariable* name = parameter->z(2);
        if (!pfad || !name)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(
                    "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                    "Sie könnte eventuell nicht richtig funktionieren."),
                new Text("Ok"),
                0);
        }
        else
        {
            Text* pf = pfad->getText();
            Text* n = name->getText();
            if (!pf || !n)
            {
                nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                    new Text(
                        "Auf dieser Seite befindet sich ein Fehler im "
                        "KSG-Script. "
                        "Sie könnte eventuell nicht richtig funktionieren."),
                    new Text("Ok"),
                    0);
            }
            else
            {
                KSGSGetVariable getKSGSVariable
                    = (KSGSGetVariable)GetProcAddress(
                        ksgs, KSGS_VARIABLE_FUNKTION);
                if (getKSGSVariable)
                {
                    int p = n->positionVon(".ltdb/");
                    if (p < 0)
                        p = 0;
                    else
                        p += 6;
                    Text nn = Text(pf->getText()) + "/"
                            + (const char*)(n->getText() + p);
                    Bild* b = bilder->get(nn);
                    if (b)
                    {
                        KSGSVariableDef def = {KSGS_BILD, 0, 3, ""};
                        KSGSVariable* ret = getKSGSVariable(fenster, &def);
                        KSGSSetBild setKSGSBild = (KSGSSetBild)GetProcAddress(
                            ksgs, KSGS_SET_BILD_FUNKTION);
                        if (!setKSGSBild)
                        {
                            nachLogin->zNachrichtenListe()->addNachricht(
                                new Text("Fehler"),
                                new Text("Der Einstiegspunkt "
                                         "'" KSGS_SET_BILD_FUNKTION
                                         "' in der DLL-Datei "
                                         "'data/bin/KSGScript.dll' konnte "
                                         "nicht gefunden werden."),
                                new Text("Ok"),
                                0);
                            b->release();
                        }
                        else
                            setKSGSBild(ret, b);
                        *retVal = ret;
                    }
                }
                else
                {
                    nachLogin->zNachrichtenListe()->addNachricht(
                        new Text("Fehler"),
                        new Text("Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION
                                 "' in der DLL-Datei "
                                 "'data/bin/KSGScript.dll' konnte nicht "
                                 "gefunden werden."),
                        new Text("Ok"),
                        0);
                }
            }
            if (pf) pf->release();
            if (n) n->release();
        }
        b->release();
        return;
    }
}

void KESSVorschauKarteScript::doPublicMausEreignis(MausEreignis& me)
{
    me.mx -= pos.x;
    me.my -= pos.y;
    if (fenster) fenster->doPublicMausEreignis(me);
    me.mx += pos.x;
    me.my += pos.y;
}

void KESSVorschauKarteScript::doTastaturEreignis(TastaturEreignis& te)
{
    if (fenster) fenster->doTastaturEreignis(te);
}

bool KESSVorschauKarteScript::tick(double zeit)
{
    bool rend = fenster ? fenster->tick(zeit) : 0;
    if (!sichtbar && alpha > 0)
    {
        if (alpha - zeit * 150 < 0)
            alpha = 0;
        else
            alpha -= (unsigned char)(zeit * 150);
        rend = 1;
    }
    if (sichtbar && alpha < 255)
    {
        if (alpha + zeit * 150 > 255)
            alpha = 255;
        else
            alpha += (unsigned char)(zeit * 150);
        rend = 1;
    }
    return rend;
}

void KESSVorschauKarteScript::render(Bild& zRObj)
{
    if (!zRObj.setDrawOptions(pos.x, pos.y, ram->getBreite(), ram->getHeight()))
        return;
    zRObj.setAlpha(alpha);
    ram->render(zRObj);
    if (fenster) fenster->render(zRObj);
    zRObj.releaseAlpha();
    zRObj.releaseDrawOptions();
}

// Inhalt der KESSVorschauKarte Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschauKarte::KESSVorschauKarte()
    : ReferenceCounter()
{
    auswählen = initKnopf(173, 73, 22, 22, 0, "");
    auswählen->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt
                        | Knopf::Style::Rahmen | Knopf::Style::Hintergrund
                        | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
    auswählen->setHintergrundBildZ(
        bilder->get("data/client/bilder/shop.ltdb/weiter.png"));
    initToolTip(auswählen, "Karte auswählen.");
    auswählen->setRahmenBreite(1);
    hintergrund = 0;
    ausgewählt = new AlphaFeld();
    ausgewählt->setPosition(1, 1);
    ausgewählt->setSize(198, 98);
    ausgewählt->setFarbe(0x0000FF00);
    ausgewählt->setStrength(10);
    ram = new LRahmen();
    ram->setPosition(10, 10);
    ram->setSize(200, 100);
    ram->setFarbe(0xFFFFFFFF);
    ausw = 0;
    rend = 0;
}

// Destruktor
KESSVorschauKarte::~KESSVorschauKarte()
{
    auswählen->release();
    if (hintergrund) hintergrund->release();
    ausgewählt->release();
    ram->release();
}

// nicht constant
void KESSVorschauKarte::ladeKarte(const char* pfad)
{
    LTDBDatei* datei = new LTDBDatei();
    Text* bdpf = new Text(pfad);
    bdpf->append("/titelbg.ltdb");
    datei->setDatei(bdpf);
    hintergrund = datei->laden(0, new Text("auswbg.jpg"));
    datei->release();
}

bool KESSVorschauKarte::doPublicMausEreignis(MausEreignis& me)
{
    bool vera = me.verarbeitet;
    auswählen->doPublicMausEreignis(me);
    if (!vera && me.verarbeitet && me.id == ME_RLinks)
    {
        ausw = 1;
        return 1;
    }
    return 0;
}

bool KESSVorschauKarte::tick(double zeit)
{
    rend |= ausgewählt->tick(zeit);
    rend |= auswählen->tick(zeit);
    int a = (ausgewählt->getFarbe() >> 24) & 0xFF;
    if (ausw && a < 255)
    {
        if (a + 150 * zeit > 255)
            a = 255;
        else
            a += (int)(zeit * 150);
        ausgewählt->setFarbe(
            ((a << 24) & 0xFF000000) | (ausgewählt->getFarbe() & 0xFFFFFF));
        rend = 1;
    }
    if (!ausw && a > 0)
    {
        if (a - 150 * zeit < 0)
            a = 0;
        else
            a += (int)(zeit * 150);
        ausgewählt->setFarbe(
            ((a << 24) & 0xFF000000) | (ausgewählt->getFarbe() & 0xFFFFFF));
        rend = 1;
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void KESSVorschauKarte::render(Bild& zRObj)
{
    ram->render(zRObj);
    if (!zRObj.setDrawOptions(ram->getX(), ram->getY(), 200, 100)) return;
    if (hintergrund) zRObj.drawBild(1, 1, 198, 98, *hintergrund);
    ausgewählt->render(zRObj);
    auswählen->render(zRObj);
    zRObj.releaseDrawOptions();
}

// Inhalt der KESSVorschau Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschau::KESSVorschau()
    : Zeichnung()
{
    tr = new TextRenderer(
        dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
    log = initTextFeld(10,
        400,
        860,
        90,
        TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt,
        "Log:\n");
    script = new KESSVorschauKarteScript(log);
    karte = new KESSVorschauKarte();
    beenden = initKnopf(10, 500, 100, 20, Knopf::Style::Sichtbar, "Zurück");
    besitztTestVersion = initAuswahlBox(10,
        120,
        200,
        20,
        ABSTYLE,
        {"Besitzt Testversion nicht", "Besitzt Testversion"});
    spieleVerbleibend
        = initTextFeld(110, 150, 100, 20, TextFeld::Style::TextFeld, "0");
    spieleVerbleibend->setTastaturEreignis(_nurNummernTE);
    vvErwerbbar = initAuswahlBox(10,
        180,
        200,
        20,
        ABSTYLE,
        {"Vollversion erwerbbar", "Vollversion nicht erwerbbar"});
    tvErwerbbar = initAuswahlBox(10,
        210,
        200,
        20,
        ABSTYLE,
        {"Testversion erwerbbar", "Testversion nicht erwerbbar"});
    vvPreis = initTextFeld(110, 240, 100, 20, TextFeld::Style::TextFeld, "0");
    vvPreis->setTastaturEreignis(_nurNummernTE);
    tvPreis = initTextFeld(110, 270, 100, 20, TextFeld::Style::TextFeld, "0");
    tvPreis->setTastaturEreignis(_nurNummernTE);
    kupfer = initTextFeld(110, 300, 100, 20, TextFeld::Style::TextFeld, "0");
    pfad = "";
    alpha = 0;
    sichtbar = 0;
    tickVal = 0;
    aktion = 0;
    rend = 0;
}

// Destruktor
KESSVorschau::~KESSVorschau()
{
    tr->release();
    script->release();
    karte->release();
    beenden->release();
    besitztTestVersion->release();
    spieleVerbleibend->release();
    vvErwerbbar->release();
    tvErwerbbar->release();
    vvPreis->release();
    tvPreis->release();
    kupfer->release();
    log->release();
}

// nicht constant
int KESSVorschau::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

void KESSVorschau::ladeKarte(const char* pfad)
{
    karte->ladeKarte(pfad);
    this->pfad = pfad;
}

void KESSVorschau::setSichtbar(bool sicht)
{
    sichtbar = sicht;
}

void KESSVorschau::doPublicMausEreignis(MausEreignis& me)
{
    if (!sichtbar) return;
    bool paramUpdate = 0;
    int ausw = vvErwerbbar->getAuswahl();
    vvErwerbbar->doPublicMausEreignis(me);
    if (ausw != vvErwerbbar->getAuswahl() && me.id == ME_RLinks)
    {
        vvErwerbbar->einklappen();
        paramUpdate = 1;
    }
    ausw = tvErwerbbar->getAuswahl();
    tvErwerbbar->doPublicMausEreignis(me);
    if (ausw != tvErwerbbar->getAuswahl() && me.id == ME_RLinks)
    {
        tvErwerbbar->einklappen();
        paramUpdate = 1;
    }
    ausw = besitztTestVersion->getAuswahl();
    besitztTestVersion->doPublicMausEreignis(me);
    if (ausw != besitztTestVersion->getAuswahl() && me.id == ME_RLinks)
    {
        besitztTestVersion->einklappen();
        paramUpdate = 1;
    }
    script->doPublicMausEreignis(me);
    if (karte->doPublicMausEreignis(me)) script->ladeKarteSeite(pfad);
    bool vera = me.verarbeitet;
    beenden->doPublicMausEreignis(me);
    if (!vera && me.verarbeitet && me.id == ME_RLinks) aktion = 1;
    vvPreis->doPublicMausEreignis(me);
    tvPreis->doPublicMausEreignis(me);
    kupfer->doPublicMausEreignis(me);
    spieleVerbleibend->doPublicMausEreignis(me);
    log->doPublicMausEreignis(me);
    if (paramUpdate)
    {
        script->setScriptParams(besitztTestVersion->getAuswahl() == 1,
            (int)*spieleVerbleibend->zText(),
            vvErwerbbar->getAuswahl() == 0,
            tvErwerbbar->getAuswahl() == 0,
            (int)*vvPreis->zText(),
            (int)*tvPreis->zText(),
            (int)*kupfer->zText());
    }
}

void KESSVorschau::doTastaturEreignis(TastaturEreignis& te)
{
    if (!sichtbar) return;
    if (!te.verarbeitet && te.id == TE_Release && te.virtualKey == T_Enter)
    {
        if (spieleVerbleibend->hatStyle(TextFeld::Style::Fokus)
            || vvPreis->hatStyle(TextFeld::Style::Fokus)
            || tvPreis->hatStyle(TextFeld::Style::Fokus)
            || kupfer->hatStyle(TextFeld::Style::Fokus))
        {
            script->setScriptParams(besitztTestVersion->getAuswahl() == 1,
                (int)*spieleVerbleibend->zText(),
                vvErwerbbar->getAuswahl() == 0,
                tvErwerbbar->getAuswahl() == 0,
                (int)*vvPreis->zText(),
                (int)*tvPreis->zText(),
                (int)*kupfer->zText());
        }
    }
    script->doTastaturEreignis(te);
    spieleVerbleibend->doTastaturEreignis(te);
    vvPreis->doTastaturEreignis(te);
    tvPreis->doTastaturEreignis(te);
    kupfer->doTastaturEreignis(te);
}

bool KESSVorschau::tick(double zeit)
{
    bool ret = script->tick(zeit);
    ret |= karte->tick(zeit);
    ret |= beenden->tick(zeit);
    ret |= spieleVerbleibend->tick(zeit);
    ret |= vvPreis->tick(zeit);
    ret |= tvPreis->tick(zeit);
    ret |= kupfer->tick(zeit);
    ret |= log->tick(zeit);
    ret |= tvErwerbbar->tick(zeit);
    ret |= vvErwerbbar->tick(zeit);
    ret |= besitztTestVersion->tick(zeit);
    tickVal += zeit * 150;
    int val = 0;
    if (tickVal > 1)
        val = (int)tickVal;
    else
        return ret;
    if (sichtbar && alpha != 255)
    {
        if (alpha + val > 255)
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if (!sichtbar && alpha != 0)
    {
        if (alpha - val < 0)
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    return ret;
}

void KESSVorschau::render(Bild& zRObj)
{
    zRObj.setAlpha(alpha);
    script->render(zRObj);
    karte->render(zRObj);
    beenden->render(zRObj);
    spieleVerbleibend->render(zRObj);
    log->render(zRObj);
    vvPreis->render(zRObj);
    tvPreis->render(zRObj);
    kupfer->render(zRObj);
    tr->setSchriftSize(12);
    Text txt = "Test Spiele:";
    tr->renderText(10, 154, txt, zRObj, 0xFFFFFFFF);
    txt = "Voll Preis:";
    tr->renderText(10, 244, txt, zRObj, 0xFFFFFFFF);
    txt = "Test Preis:";
    tr->renderText(10, 274, txt, zRObj, 0xFFFFFFFF);
    txt = "Kupfer Besitz:";
    tr->renderText(10, 304, txt, zRObj, 0xFFFFFFFF);
    txt = "Diese Werte sind nur zum\nTesten und haben keinerlei\nEinfluss auf "
          "den Shop.";
    tr->renderText(10, 334, txt, zRObj, 0xFFFFFFFF);
    tvErwerbbar->render(zRObj);
    vvErwerbbar->render(zRObj);
    besitztTestVersion->render(zRObj);
    zRObj.releaseAlpha();
}

// constant
bool KESSVorschau::istSichtbar() const
{
    return sichtbar;
}