Anti-Jammer-Thread

[Tiles]

Das mit dem CP T kommt von dem verdammten Facebook. Und sollte eigentlich CPT für Captain sein. Aber nicht mal das hat mir die Seite gegönnt. Ich musste das trennen :)

Das Video stammt von einer Russin namens Olga. Wie da Gere mit in die Beschreibung gerutscht ist, tja, die Wege des Marketings sind unergründlich. Ich beklage mich aber nicht. Für Marketing und Videomaterial ist der David zuständig ^^

[Schrompf]

Ich habe mit dem .357er-Argument gestern bis in die Nacht einen seltsamen Render-Flacker-Bug debuggt und dabei einen Bug gefunden, den ich glaube ich im Jahre 2004 eingebaut habe. Splatter, Crossfire II, alle meine ZfxAction-Beiträge sind damit live gegangen. Heilige Fäkalie.

Vielleicht sollte ich doch Alpaca-Züchter werden.

Positiv immerhin: ich glaube, dass könnte auch die Ursache eines wirklich seltenen Splatter-Fehlers sein, den mir manche Spieler*innen gemeldet oder gescreenshottet haben, bei denen großformatige einheitsfarbige Flächen zu sehen waren.

[Schrompf]

Und obwohl keiner gefragt hat, verteile ich trotzdem noch die dabei gewonnene Weisheit: Doppelte State-Zuweisungen in OGL, DirectX und so... bringen ordentlich Performance. Aber man darf sie nicht per Pointer machen.

Code: Alles auswählen

if( newStateObject == currentStateObject )
  return;

Geht halt schief, wenn man jedes Frame Sachen anlegt und wegwirft. Da die meisten Game Loops ja ziemlich allokationsarm sind, hat man ne gute Chance, dass ein new Object auf der gleichen Speicheradresse rauskommt wie ein vor kurzem gelöschtes Objekt, umso mehr wenn die gleich groß sind. Und damit schlägt obige Dopplungsvermeidung zu, obwohl's ein neues Objekt ist.

[Krishty]

Und obwohl keiner gefragt hat

Ich wollt’s, war aber fünf Stunden von den Formularen des Microsoft Store in Beschlag genommen :D Danke, dass ich jetzt nicht mehr fragen muss!

Doppelte State-Zuweisungen in OGL, DirectX und so... bringen ordentlich Performance.

Unter D3D 9 habe ich durch sowas starke Einsparungen gemessen, aber unter D3D 11 weniger. Die behaupten, dass sie das intern filtern. (Fun fact für den Anti-Jammer-Thread: In D3D 10 und später kannst du keine doppelten States anlegen. Wenn du z. B. 1000 identische Aufrufe an CreateRasterizerState() hast, sollte es 1000 identische Pointer mit steigendem Refcount zurückgeben.)

[Jonathan]

Bug gefunden :)

Vergleichsoperator für ein std::set im Wegfindungsalgorithmus:

Code: Alles auswählen

auto comp_cost = [&GetNode](const ivec2& l, const ivec2& r)
{
	// to allow the set to store different nodes with equal h_cost, we have to consider the position as well.
	if(GetNode(l).h_cost != GetNode(r).h_cost)
		return  GetNode(l).h_cost < GetNode(r).h_cost;
	if(l.x < r.x)
		return l.x < r.x;
	return l.y < r.y;
};

Letztendlich hat der Fehler dazu geführt, das es keine strict weak ordering relation war. In den allermeisten Fällen war das total egal, wegfindung funktionierte soweit korrekt und alles sah gut aus, nur ganz selten mal gab es eben einen Absturz. Zuletzt tatsächlich wochenlang nicht, obwohl ich viel damit gemacht habe.
Nun, auf jeden Fall gibt es jetzt wieder einen Bug weniger in dieser Welt :)

[Schrompf]

Wir benutzen seit... keine Ahnung, 2004 oder so, AngelScript als Scripting. Ich baue gerade mal wieder nen Patch für Splatter, in welchem primär unser Framework aktualisiert wurde. Und da gab's plötzlich nen komischen Crash im Scripting im Pumpstation-Level.

Ich beschreibe die Symptome im Supportforum, und zwei Stunden später krieg ich die erste Antwort von dem Typen. Einen Tag später hab ich ihm den Bug reproduziert und es stellt sich heraus, dass er seit den Bug seit vier Tagen in ner WIP-Version gefixt hat. Der macht das jetzt seit 20 Jahren. Mit Hausbau und zweijährigem Kind zu Hause während ner Pandemie. Heilige beischlafende Fäkalie.

Gleich mal was gespendet. Und falls jemals von euch jemand Scripting für irgendwas braucht: AngelScript rockt. Baut auf nahezu jedem Compiler, kann auf nahezu jeder Rechnerarchitektur Funktionen native aufrufen, man kann seine Matheklassen mit überladenen Operatoren, Konstruktoren und Casts im Skript anmelden, und man kriegt auch 20 Jahre später noch Support.

[Jonathan]

Flickerbug Framework Update? :D

Ich habe in meinem Framework ja tatsächlich auch AngelScript drin und würde an dieser Stelle noch die statische Typisierung als Vorteil nennen wollen. Allerdings habe ich für ein Aufbauspiel wie Der Landvogt noch nicht schrecklich viel Verwendung dafür gefunden: Levelscrippting ist ja irgendwie auch eine aufgeblasene Wenn-Dann Maschine, aber da es zurzeit noch nicht wirklich Events wie Feuer oder Dürre gibt und der Spieler nur Häuser baut, gibt es halt sowohl für die Wenn's wie auch für die Dann's recht wenig auswahl. Aber vielleicht mache ich damit ja mal ein Tutorial oder so.

[Tiles]

Valheim <3

[Matthias Gubisch]

Ein tolles Gefühl wenn die einzelen Kompnenten der (neuen) Engine endlich anfangen zusammen zuspielen.
Sobald mal mehr als ein paar einfarbige Quadrate über den Bildschirm flimmern gibt es eine ordentliche Projektvorstellung. Diesmal wirklich *selber an den Ohren zieh*

[Schrompf]

Sehr cool! Glückwunsch! Ich freue mich auf hoffentlich umfangreiche Technikberichte.

[scheichs]

Valheim <3

Kann ich nur unterschreiben. Wunderbar, was (größtenteils) 1 Mann da geschaffen hat.
Aus Entwicklersicht besonders interessant.
Auch wenn man sich die Alpha von vor 2,5 Jahren anschaut

und vergleicht mit der Releaseversion

Da sieht man IMHO gut wieviel Feinschliff/Polishing ausmacht.
Ich mein 2,5Jahre das is schon ne Menge Holz, vor allem da sie ab der Alpha zu 5t dran gearbeitet haben.

[Tiles]

Meine Begeisterung flaut grade ein wenig ab weil ich seit einer Woche nach einem Sumpf mit Dungeon suche damit ich endlich mal Eisen machen kann. Und mir stattdessen jetzt schon zweimal Moskitos aus den Ebenen mein Schiff auf offener See versenkt haben. Inklusive kompletter Kupferausrüstung. Aber nach wie vor ein echt gutes Game. Hat mich bisher bestens unterhalten :)

[D-eath]

Vielen Dank noch mal an die Glückwünsche!
Der erste Monat war recht aufregend, aber mittlerweile haben wir uns dran gewöhnt und ich freue mich schon drauf, wenn wir die ersten Zeilen coden werden. :)

[Schrompf]

Ich hab jetzt SO EINEN GROSSEN

Monitor.

Nur meine Humorqualität ist immer noch in Angström bemessen. Das Gerät ist ein LG UltraGear 32GN600, kann 160fps, 2560x1440 und HDR10. Wenn ich im Windows HDR aktiviere, ist alles erstmal weiß ausgewaschen. Muss ich mir irgendwann mal in nem Spiel anschauen. Die Framerate und das FreeSync scheinen aber ausm Stand kommentarlos zu laufen. Coole Sache. Das Bild ist nur jetzt so groß, dass ich den Eindruck habe, mir wird übel, wenn ich damit zocke. Hm.

[Krishty]

Üblicherweise behandelt man Handles unter Windows wie Zeiger, aber in Wirklichkeit sind es 32-Bit-Integer. Genau wie Deskriptoren unter Linux.

Mind=blown. Ich nehme mir drei Wochen Zeit, um in allen meinen Programmen kompakteren Code zu erzeugen. Tschühüss!

[Alexander Kornrumpf]

Humblebundle hat sich auf seine Ursprünge besonnen und macht ein Charity Bundle für Covid-Hilfen. Ich denke die Spiele sind "es" wert:

https://www.humblebundle.com/humble-hea ... -19-bundle

Auch wenn das für das Charity Ziel jetzt kontraproduktiv ist, ich habe jetzt ziemlich viele der Keys doppelt, wer also sowieso nicht gespendet hätte und gerne eines der Spiele hätte, bitte PN. [Ich bin zu faul hinzuschreiben, welche "verfügbar" sind, schaut halt auf der Seite und es gibt eine ~50% Chance dass ich den Key abgeben kann. Gilt auch für die Software die im Paket ist, aber ich denke die will keiner :)]

[Jonathan]

vielen Dank :)

[joggel]

joggel setzt jetzt auf Test-Driven Development.
Mal schauen wie die Qualität des Codes dadurch wird...

[Jonathan]

D.h. Funktionsdeklaration schreiben, Unit-Tests entwerfen und dann Funktion implementieren, bis alle Tests durchlaufen?

Was für Codeänderungen erwartest du dadurch? Klar, man weiß, dass der Code robuster wird, weil direkt auffällt wenn irgendetwas, was früher mal ging jetzt kaputt ist. Aber davon sieht der Code ja nicht zwangsläufig anders aus, oder? Man wird vermutlich noch an einigen Stellen extra Code benötigen um die Tests anzubinden, aber ist die Erwartung, dass das den Code schöner macht (weil granularer / besser strukturiert) oder eher hässlicher (weil man mehr Code hat, der nichts zur Funktionalität beiträgt und nur für die Tests wichtig ist)?

Ich finde die Grundidee interessant, bin aber noch der Meinung, dass es für viele Fälle nicht so wirklich einsetzbar ist. Für klassische Unit-Tests braucht man halt klar definierte Ein- und Ausgabe und idealerweise sollten Funktionen für sich getestet werden können und nicht von allem anderen abhängen. Wenn man jetzt aber Spiellogik schreibt, dann man man einfach sehr komplizierte Systeme in denen alles mit allem interagiert, oder für manche Situationen sind die Tests genau so schwer zu schreiben wie die Implementierung (und man baut die selbe Regel einfach zweimal ein) oder man rendert etwas und muss dafür Screenshots vergleichen (was ich mir auch sehr aufwändig vorstelle), und schlussendlich hatte ich bisher nur ganz selten Fehler die dadurch entstanden sind, dass ich woanders etwas geändert habe und somit durch Unit-Tests früher aufgefallen wäre.

Um was für ein Projekt geht es denn bei dir?

[joggel]

Nunja, ich erwarte, dass der Code robuster und unabhängiger (==feiner granuliert?) wird, da ich ja vorwiegend Funktionen teste.
Auf Arbeit fingen ich erst mitten im Projekt an, UnitTests zu schreiben, und mir fielen einige Bugs dabei auf die mir erst viel später aufgefallen wären.
Also, besser Trennung des Codes und robuster => das erwarte ich.
Aber ich werde das Thema mal noch etwas vertiefen...

Um was für ein Projekt es geht?
Nunja... im weitesten Sinne so etwas wie ein Node Graph.
Ich bin nur extrem langsam in der Entwicklung (investiere noch nicht wirklich viel Zeit).
Also bevor ich hier größere Töne spucke, erzähle ich mal nicht so viel; weil es so nicht allzu schlimm ist wenn es nichts wird :D

[Lord Delvin]

Also bevor ich hier größere Töne spucke, erzähle ich mal nicht so viel; weil es so nicht allzu schlimm ist wenn es nichts wird :D

Es zu versuchen und am Ende zu scheitern ist keine Schande. Bei Hobbyprojekten ist das Problem ohnehin meistens der schiere Aufwand, den es bräuchte, um es wirklich fertig zu machen.

Ich habe sehr gute Erfahrungen mit Systemtests gemacht, z.B. https://github.com/tyr-lang/test.conformance. Bei meinem Projekt ist es natürlich relativ leicht so halbwegs aussagekräftige Tests zu definieren und die Testausführung sind auch unter tausend Zeilen. (Btw. kannst du an der Aktivität da meine Planungsphasen ganz gut sehen;) ) Mit Unittests im eigentlichen Sinne habe ich relativ schlechte Erfahrungen gemacht, weil sie zu sehr das interne API zementieren und deswegen real sehr viel Wartungsaufwand verursachen für teils geringen Nutzen.
Was du dir auf jeden Fall überlegen solltest, bevor du eine Zeile Code schreibst, ist, was du eigentlich genau erreichen willst.
Jedenfalls, wenn du am Ende ein Ergebnis haben willst. Ich habe das früher bei den Sachen die ich hier entwickelt/präsentiert habe nie gemacht.
Rückblickend würde ich sagen, dass es vollkommen ok war, weil es am Ende vor allem dazu geführt hat, dass ich etwas gelernt habe.
Wenn du wirklich Geld verdienen willst, dann solltest du dir aber ein paar leicht prüfbare Akzeptanzbedingungen überlegen und dazu Tests entwickeln (die man btw. auch mit einem Unittestframework ausführen kann).
Dabei ist es gar nicht so wichtig, dass die Tests per se irgendwas sicherstellen, solange du mit einer leichten manuellen Prüfung sicherstellen kannst, dass insgesamt passiert was du willst.
D.h. wenn es dir um Bilder geht, kannst du auch versuchen dir am Ende des Tests einen Screenshot auszugeben, automatisch deren Existenz prüfen und dann selbst ab und zu drauf schauen, um zu sehen, dass noch alles richtig ist.

EDIT: Test execution sieht bei mir immernoch grob so aus: https://github.com/tyr-lang/compiler/bl ... Test.scala

[joggel]

Also bevor ich hier größere Töne spucke, erzähle ich mal nicht so viel; weil es so nicht allzu schlimm ist wenn es nichts wird :D

Es zu versuchen und am Ende zu scheitern ist keine Schande. Bei Hobbyprojekten ist das Problem ohnehin meistens der schiere Aufwand, den es bräuchte, um es wirklich fertig zu machen.

Stimmt auch wieder.
Also es soll ein CSG-Tree-Editor werden.
Ich verfolge damit nichts konkretes; also denke nicht daran damit Geld zuverdienen oder so. Glaube auch nicht, das so ein Editor besser als ein herkömmlicher 3D-Editor, wie Blender oder Maya oder what ever, wäre.
Ob es so etwa schon gibt, weiß ich auch nicht. Kenne nur dieses OpenSCAD; was aber eher Textbbasiert ist.
Aber wie gesagt: ich werd' mal sehen wie weit ich komme, und ob man damit arbeiten könnte...
Wenn ich was zeigen kann, dann tue ich das auch hier...

@Unittest und Links
Danke, werd' ich mir mal anschauen :)

[Lord Delvin]

Nachdem ich erst 5 Stunden Freizeit damit verbrannt habe, dass xtext meine Sprache nicht parsen können wird und dann nochmal eine um lernen zu müssen, dass ich kein VSCode Plugin auf Ubuntu 20.04 entwickeln kann, weil das einfach zu alt ist (dafuq?), hab' ich mich mal hingesetzt und endlich mal versucht die Parameter Typinferenz für Binder zu machen. Grob 4h und die Sache läuft:

Code: Alles auswählen

  test "infered c" {
    "\n".bytes().forall c do {
      c == 10i8
    }
  }

Ich sollte mich mehr mit Dingen beschäftigen, in denen ich gut bin :)

[Chromanoid]

Kudos zum Erfolg 😊

Keine Ahnung, ob Du das tust, aber mach lieber einen Language Server (https://langserver.org/), oder?

[Lord Delvin]

Kudos zum Erfolg 😊

Keine Ahnung, ob Du das tust, aber mach lieber einen Language Server (https://langserver.org/), oder?

Danke. Hatte ich eigentlich erstmal nicht vor, weil ich lieber eine richtige IDE haben wollte und ich keinen brauchbaren LSP Client kenne. Der VSCode-Weg ist aber genau das. Vermutlich muss ich das Plugin jetzt einfach unter Windows soweit bauen, bis er den Server automatisch findet und startet und kann dann wieder produktiv arbeiten.
Allerdings muss man ihnen zugestehen, dass sie seit meiner letzten Begegnung wenigstens mal das Syntaxhighlighting und das "run project" dazugebaut haben. Mit so einer TextMate-Grammatik kommst du noch weniger weit als mit ANTLR 3. Und es ist unfassbar unproduktiv da was halbwegs richtiges hinzustellen.
Und die Sprache hat halt langsam eine Komplexität erreicht, wo man mit C-Syntaxhighlighting doch nicht mehr wirklich weiter kommt.

EDIT: Wobei man sagen muss, dass man schon irgendwie irgendwas hinbekommt. Weiter als das gehe ich jetzt aber ohne LSP basiertes Syntaxhighlighting wirklich nicht.

[NytroX]

@LordDelvin: Kommt mir alles sehr bekannt vor :-)
Nur FYI anbei ein Beispiel für Highlighting und für sehr simples auto-complete (einfach ein paar Keywords).
Anbei mal der Code für "mylang", falls ihr mal einen Schnellstart in VSCode für eine eigene Sprache braucht, bevor ihr einen richtigen LanguageServer habt.

Fand ich für "ich will keine Arbeit reinstecken, aber es soll was bringen" schon ganz nett; hätte ich damals so ein simples Beispiel gehabt, hätte ich nicht ewig rummachen müssen.

File: extension.js

Code: Alles auswählen

const vscode = require('vscode');

module.exports = {
    activate,
    deactivate
}

/**
 * @param {vscode.ExtensionContext} context
 */
function activate(context) {

    vscode.languages.registerHoverProvider('mylang', {
        provideHover(document, position, token) {
            return {
                contents: ['Hover Content']
            };
        }
    });

    const provider1 = vscode.languages.registerCompletionItemProvider('mylang', {
        provideCompletionItems(document, position, token, context) {
            const ty = new vscode.CompletionItem('type');
            ty.kind = vscode.CompletionItemKind.Keyword;
            const fn = new vscode.CompletionItem('func');
            fn.kind = vscode.CompletionItemKind.Keyword;
            const lt = new vscode.CompletionItem('let');
            lt.kind = vscode.CompletionItemKind.Keyword;
            const retn = new vscode.CompletionItem('return');
            retn.kind = vscode.CompletionItemKind.Keyword;
            return [ty, fn, lt, retn];
        }
    });
    context.subscriptions.push(provider1);
}


function deactivate() {

}

File: mylang.tmGrammar.json

Code: Alles auswählen

{
  "$schema": "./tmLanguage.json",
  "comment": "other good styles are: || punctuation.definition.tag (lightgrey) | string.regexp (reddish) | token.error-token (red) | constant.regexp (lila)",
  "scopeName": "source.mylang",
  "fileTypes": [
    "*.mylang"
  ],
  "patterns": [
    {
      "include": "#comment_block"
    },
    {
      "include": "#comment_line"
    },
    {
      "include": "#literal_string"
    },
    {
      "include": "#keyword"
    },
    {
      "include": "#type_builtin"
    },
    {
      "include": "#operator_assign"
    },
    {
      "include": "#literal_bool"
    },
    {
      "include": "#literal_number"
    },
    {
      "include": "#identifier"
    },
    {
      "include": "#namespace"
    }
  ],
  "repository": {
    "comment_line": {
      "name": "comment.line",
      "begin": "//",
      "end": "$"
    },
    "comment_block": {
      "name": "comment.block",
      "begin": "/\\*",
      "end": "\\*/"
    },
    "literal_number": {
      "name": "string.regexp",
      "match": "\\b[0-9]+\\b"
    },
    "literal_bool": {
      "name": "constant.character.escape",
      "match": "\\b(true|false)\\b"
    },
    "literal_string": {
      "name": "string.quoted",
      "begin": "\"",
      "end": "\"",
      "patterns": [
        {
          "name": "constant.character.escape",
          "match": "\\."
        }
      ]
    },
    "keyword": {
      "name": "keyword.control",
      "match": "\\b(let|func|type|if|else|while|for|return)\\b"
    },
    "type_builtin": {
      "name": "storage.type",
      "match": "\\b(atom|bool|int|float|string|std#atom|std#bool|std#int|std#float|std#string)\\b"
    },
    "operator": {
      "name": "keyword.operator",
      "match": "\\b(==|>=|<=|!=|+=|-=|=|>|<|+|-|\\*|/)\\b"
    },
    "identifier": {
      "name": "entity.name",
      "match": "\\b[a-zA-Z][a-zA-Z0-9]*\\b"
    },
    "namespace": {
      "name": "token.error-token",
      "match": "\\b(#)\\b"
    }
  }
}

Edit: bevor es Fragen gibt, der Code ist komplett von mir und ich gebe ihn unter der SPDX:0BSD frei.
D.h. macht damit, was ihr wollt :-)

[Lord Delvin]

@NytroX: ja was in der Richtung habe ich jetzt auch. Hat mich grob einen Tag gekostet und ist so gut, dass ich es jetzt statt eines Texteditors verwende.

Davon abgesehen habe ich die ganze Zeit mit Sorge beobachtet wie schnell das tyr.lang.tl wächst, weil ich einfach Angst hatte, dass meine Darstellung zu ineffizient ist...hab' grad' beim Debuggen gelernt, dass ich grob 2,5k Symbole drin hab' was etwa 32Byte/Symbol entspricht. Mein Dump der Linknamen ist länger :D

Jetzt muss mir nur noch einer verraten, warum Ref[Unsigned[64]] nicht korrekt gelinkt wird :)

[Schrompf]

Vor bald zwei Jahren hab ich auf Arbeit ein Konzept vorgestellt, wie wir unsere Preisberechnung vektorisieren können. Immer wieder Konzepte, Präsentationen, Demos, Benchmarks, immer wieder gab's "Das wird nicht fliegen" oder "Das braucht Jahre". Vor drei Monaten haben wir das erste Ticket in den Sprint gezogen, den Großteil hab auch ich gemacht.

Heute ging der erste Teil online und hat quer über alle Veranstalter x2 bis x10 Performance gebracht. Ich hoffe, meine Chefin nimmt das mit, die mich gestern noch im Geld-Gespräch abgewatscht hat

[joggel]

Ich musste erst mal googeln was "abgewatscht" heißt^^
Aber joar, kenne ich auch abgewatscht zu werden :/

Ansonsten: Glückwunsch!

[Lord Delvin]

Code: Alles auswählen

type T {
  new{}

  type val f = new T;

  test "use" {
    null != f
  }
}

Damit das mit Abhängigkeitsprüfungen geht erstmal mehr Code geändert, als das erste von mir hier vorgestellte Projekt hatte. Alle anderen Tests wieder zum Laufen gebracht...ging nicht:

Code: Alles auswählen

[error] @ test/mar.tyr from 10:10 until 10:12
[error] could not realize access with expected type (Null, T) : any
[error] note: a viable alternative might be:
[error]   observablePointer.!=(this : observablePointer, v : observablePointer) : bool

"type" durch "class" ersetzt...ich mache doch was richtig, wenn mein Compiler langsam deutlich besser ist als ich :)

Was mir erst beim Aufschreiben auffällt: Ich bin ehrlich gesagt selbst überrascht, dass mein Compiler das != als Alternative findet. Das ist ein Bottomtyp, d.h. Null erbt implizit alle anderen Klassen. Dass ich das schon soweit richtig gemacht habe, ist...interessant. Vielleicht kann ich doch demnächst mal ein kleines Demospiel basteln.