openbasic

Now that's a straw man. Congratulations.

You missed the whole point. Raining, cold, pregnant wife. Or maybe he was accompanied by his elderly father. Or young kid.

Not everyone is a healthy 20 year old.

I've been looking for something decent in Linux too.

I think the easiest way to get started is mapping. This is a very cool map editor for Q1 and Q2:

https://github.com/kduske/TrenchBroom

There's plenty of good content here:

http://forum.tastyspleen.net/quake/index.php?topic=21859.0

http://maps.rcmd.org/tutorials/

Map compiling and texture tools are included in the engine code:

https://github.com/klaussilveira/qengine/tree/master/src/too...

The Quake community is awesome: https://quakewiki.org/wiki/Mapping_tutorials

https://www.quaddicted.com/forum/

http://www.celephais.net/board/forum.php

Never thought of that. What if code is compiled to VM bytecode first?

PRs are welcome! :D

I wish they released UT99 under the GPL.

There's two other cool engines with a software renderer that support colored lighting:

http://super8.qbism.com/

https://github.com/leilei-/Engoo

Both are Q1 though. However, the gray-ish/brown-ish look is entirely dependent on the color palette that you chose to use in your game. You have 256 colors to choose from, and with the 256x320 colormap, you get 64 shades of each.

I don't like QuakeC or the QuakeC VM.

Cool maps, btw. :)

The license can be a problem for some studios, specially ones with uncomfortable contracts with publishers. If you are in that situation, I highly recommend writing a LuaJIT integration layer.

The game code is very well separated from the engine, and qengine already removes a lot of non-generic game code from Q2. So all you have to do is delete a little bit more, write some glue code to tie in Lua, and you can write the entire game logic in a separate codebase, with a separate license. Also, you get moddability.

From my perspective, that odd lighting and tint is part of the aesthetic that makes it great. You can learn more about how the renderer works here:

http://fabiensanglard.net/quake2/quake2_software_renderer.ph...

You can create your own palette using the included pcx2pal: https://github.com/klaussilveira/qengine/blob/master/src/too...

After that, you might want to generate the colormap: https://github.com/klaussilveira/qengine/blob/master/src/too...

If you enjoy the code of Q2, but also would like more modern rendering, I highly recommend quake2xp from Barnes: https://www.moddb.com/mods/quake-2-xp

Yamagi is the gold standard for all Q2 engines: https://github.com/yquake2/yquake2

And some art help: http://maps.rcmd.org/tutorials/q2_palette_textures/

Emscripten has an SDL implementation so you can just SDL_BlitSurface inside a <canvas>.

If you dig software rendering:

https://github.com/ssloy/tinyrenderer

https://www.youtube.com/watch?v=HQYsFshbkYw

https://www.youtube.com/watch?v=Y_vvC2G7vRo&list=PLEETnX-uPt...

https://www.amazon.com/Tricks-Programming-Gurus-Advanced-Gra...

https://github.com/kduske/TrenchBroom is the new cool

Having no OpenGL makes an HTML5 port even easier.

The software renderer of Quake 2 has a very unique look that is hard to reproduce with shaders. Limitations are part of the fun. Games can use the existing Q2 palette, create their own, or use the palettes from Doom, Duke Nukem or Q1.

More?

https://github.com/nem0/LumixEngine

https://www.banshee3d.com/

https://github.com/AtomicGameEngine/AtomicGameEngine

http://torque3d.org/

https://www.panda3d.org/

https://github.com/xenko3d/xenko

https://github.com/begla/Intrinsic

https://github.com/godotengine/godot

https://github.com/fredakilla/GPlayEngine

https://github.com/volcoma/EtherealEngine

https://casual-effects.com/g3d/www/index.html

I love the idea behind this and PostgREST, but one thing keeps me from using on projects with a team: versioning. I've been using it for personal projects and, while doing CREATE POLICY, CREATE ROLE here and there is easy when working alone, I can only expect a nightmare when working with a medium-sized team.

Migrations are, of course, a possible solutions, but I'm yet to see a decent toolset for managing schema changes.

https://martinfowler.com/articles/evodb.html

http://www.jeremyjarrell.com/using-flyway-db-with-distribute...

Is it possible to do JWT rotation?

I've been hearing this argument since CoffeeCup, HighPowerSites and Dreamweaver were still a thing.

What makes you think Xorg is on his way out?

That's the thing. You don't escape from those problems in native environments. You still have to deal with different GFX drivers doing different crap on different platforms, cards that they that support a GL extension but don't, etc. And that's just OpenGL.

With the browser, you're just adding another abstraction layer that has even more complexity. WebGL is far for a decent spec. And we're talking just graphics, as I mentioned before, audio and networking have tons of unstable and untested code.

Multimedia programming is already hard on native environments. I don't see the web being a friendly environment anytime soon. There's no silver bullet, "code once, run anywhere" for games and multimedia.

One does not simply develop cross-browser. Different browsers have different issues with different graphics cards. As soon as you're not drawing a textured triangle anymore, things get hairy. Same for the audio API. And don't get me started on the sad state of WebRTC and websockets.

Scala, huh?

The whole environment handling bothers me, specially when working with containers. Why can't we have something normal like a .env?

What's the common use-case scenario for migration handling in the C# world? I've seen a lot of people doing checks on application startup: Do I have pending migrations? If so, run them. In the Ruby world, checking and running migrations is usually part of the deploy routine, not application startup, and are usually handled by a separate CLI command.

Slow.

Thank you! :)

What would be a good book and project to get started with this? Object recognition? Product recommendations?