Sword | SpringBlade front-end UI project

I was able to solve my issue by resizing my view and readding my nodes in again

One option is to consolidate your tests in an object, using a shorthand identifier

In your Store class the goods array is not initialized. It will work if you change it to

Found out how to do it: Instead of a texture, I created an image.

movsx eax, SWORD PTR [esi] to sign-extend it into a dword register for WriteInt.

WriteInt always looks at the whole 32 bits, and the 32-bit number you gave it (with bit-pattern 0x0000fff6), interpreted as 32-bit 2's complement, represents a positive number.

If there was a WriteShort function, you could call it and it would look at bit #15 instead of bit #31 to decide if the number was negative, but there's no need for one when we can just sign-extend up to a full register.

Notice the mov eax,0 you used before loading AX: you are explicitly zero-extending by doing that, as an inefficient way to emulate movzx eax, word ptr [esi]. (If you didn't do that, the high 16 bits of EAX would hold whatever garbage was there from the code that called main.)

There are other ways to do 2's complement sign-extension, i.e. copy the sign-bit of a number to higher bits of the full register. For example, cwde after already loading into AX, or even shl eax, 16 / sar eax, 16. But MOVSX is the most efficient when you don't already have the narrow value in a register.

Or with a 16-bit add result in AX, cwde is just a more efficient way to write movsx eax, ax.

(Fun fact: CWDE is the 32-bit version of an instruction that dates back to 8086. Before 386, you could only sign-extend efficiently with your number in AL or AX, not from anywhere to any register.)

To avoid the possibility of signed overflow in the add, you may want to movsx both inputs before add. e.g. this makes it possible to get 0x7fff + 0x7fff = 0x0000fffe, 65534.
Not 0xfffffffe, aka -2, which you'd get if you sign-extended after a 16-bit add of two positive numbers overflowed to produce a negative result.

(The sum or difference of two n-bit numbers takes at most n+1 bits to represent exactly, so widening at all makes overflow impossible. To overflow a 32-bit sum, you'd have to add about 2^16 words.)

It is very easy to get lost in a sea of quotes. Maybe catch the env variables using -v like this:

This in no way a complete answer. I assume you don't want to map/create classes for each "sub class", e.g. Barbarian, Wizard etc. You could perhaps use JsonConverter. The example only handles the first "anonymous" range of objects. Maybe you'll find some of this useful.

You mention you're using C++20. This is indeed an error as of C++20: the use of simple-template-ids for constructors was deemed error-prone and redundant, and removed. See [diff.cpp17.class]/2.

As you mentioned, you can fix the error by using an injected class name instead:

It looks like you stopped following the pattern that you applied in the beginning. As you'll see, prior to line 310, you have used