Handmade Network»Wassimulator

Recent Activity

Over the last two or so weeks I've been working on a little handmade image viewer, and since I've started a new job I won't have much time to add more features to it. Since it's stable and I already use it on my own rig, I'm releasing CactusViewer alongside the source code today!

Features:

  • Supports PNG, JPG, JPEG, BMP, and GIF extensions.
  • Scans folder of opened image and allows flipping through supported images within folder.
  • Multithreaded file loading.
  • image pan and zoom with fitting modes; to width or height.
  • Pixel color inspector and a quick copy of HEX value to clipboad.
  • Animated GIF support with play/pause and seek controls.
  • Quick toggle between nearest-neighbor and linear filtering for pixelart images.
  • Pixel grid.
  • Customizable background color with support for checkerboard with custom colors.
  • Drag and drop support to opening image files.
  • Switches to turn individual RGB channels off and switch between premultiplied alpha and straight RGB.
  • Keyboard controls to pan, zoom, flip through files and GIF controls.
  • Customizable settings to save each image's zoom and pan locations within a session, or to reset image zoom and pan upon file change.

You can check out the source code, and find prebuilt binaries for Windows here:
https://github.com/Wassimulator/CactusViewer
&cactus

Not programming, but art: I’ve been working on hand and foot studies over the last two weeks, here’s 21 hours’ worth of sketches. Plus a time-lapse video of the process: https://youtu.be/yql2Xtx2MrM

Over the last week I've been working on a small lightweight** image viewer **(calling it Cactus Viewer), GPU rendered. So far we have: Folder scanning, Multithreaded loading of images, zoom and pan, a quick switch between nearest neighbor and linear filtering for pixel art, a pixel grid toggle, pixel inspector with a quick copy to clipboard color HEX. Adding a couple of more features and releasing this alongside the source code very soon!

Writing menu systems for games can be easily overcomplicated. In this article I go through writing a simple and robust menu system based around functions without using any data structures. The upshot is robust, readable, scalable code that flows logically, produces fewer bugs, and is easy to debug and work with.

&AV-Racer
https://wassimulator.com/blog/programming/av-racer/devlog_6.html

To preserve platform compatibility, I used SDL2 to manage rumble events. However, The functions were too simple and restrictive. So I wrote a rumble event manager to handle custom vibration events over multiple frames for the game, in this article I go over how it's done:

https://wassimulator.com/blog/programming/av-racer/devlog_5.html#
&AV-Racer

SimplyRend is the standalone header graphics engine that runs AV-Racer, in this detailed article I go through how it works. The diagram below sums up the implementation and render algorithm. https://wassimulator.com/blog/programming/av-racer/devlog_4.html &AV-Racer

No idea why I took so long to do it. Anyway AV-Racer now supports Steam Achievements.

You can get it here for like 3 bucks btw: https://store.steampowered.com/app/1978850/AVRacer/

&AV-Racer

Basic shadow mapping, an evening project with @archon

My little handmade project, AV-Racer is finally released on Steam! Featuring career championships with 5 car classes and 24 playable tracks + two-player splitscreen with controller support. The project started on new year's and now it's complete. Thanks to everyone here for your support, I am proud to have been part of this awesome community while making this.

You can get it now on Steam: https://store.steampowered.com/app/1978850/AVRacer/

Inspired (and equally humbled) by the amazing rrespacker from @raysan5, I finally bit the bullet and spent the evening on writing a small packer for AV-Racer. It is very barebones, the packer is a commandline tool that packs a single file type without compression into one file, and a simple API to handle fetching addresses. It is now in the game to be released. it's on GitHub : https://github.com/Wassimulator/SimplyPack

After 4 Months since starting this project, AV-Racer is finally now live on Steam with planned release sometime next month! Featuring career championships with 5 car classes and 24 playable tracks + two-player splitscreen with controller support. The game is handmade in C using some libraries like OpenGL, stb, and SDL. If you find it interesting, feel free to wishlist on Steam! https://store.steampowered.com/app/1978850/AVRacer/ &av-racer

I wrote a post explaining how I make the maps and map files for my car game, AV-Racer.

https://wassimulator.wordpress.com/2022/04/15/av-racer-devlog-2-maps-and-the-editor/ &av-racer

Hey everyone, AV-Racer is in a relatively finished state, we're working on the Steam set up and I'm currently looking for people who are interested in playtesting the latest version and would kindly give feedback to their experience, before we release this thing publically. the game features a career mode with unlockable tracks, single player, and local two-player split screen. if anyone is interested, feel free to DM me.

Muratori's Pizza also has donuts &av-racer

we got split screen local play. Progress in Career mode unlocks more tracks to be playable in single race and split screen modes &av-racer

Gameplay demo below. cleaned up the UI, created new menus, new effects, game loop . I'm committed to the CRT effect (watch video in Fullscreen), decided on a new name, AV-Racer. At the end of the video, there's a race result screen. &av-racer

Shader work using SimplyRend, I tried this cool shader I found on ShaderToy. 2 post processing passes. Pixelate and quantize, then curve screen and add TV effect. &av-racer

Finally, migrated the game to OpenGL, in the process I created a single header small rendering library for easily getting a project up and running in OpenGL instead of the limited SDL renderer. it uses a couple of stb libraries, and a personal math library I made.

It offers streamlined sprite loading and packing, render layers, custom shaders, a text renderer with simple functions, load, and render. It utilizes immediate mode, and has two basic pipelines for basic shapes and textured quads.

The goal is ease of use, with modularity, and since I always start with SDL2 to get an idea up and running and then struggle with the migration (with migranes) this is a solution.

Particularly proud of this one, here it is: https://github.com/Wassimulator/SimplyRend &av-racer

I finally have a working (handmade) collision detection and resolving system of multiple objects and walls.

It’s a Body Oriented Intersection Negation & Kinetics system. Also known as B.O.I.N.K &av-racer

New AI system that projects a point forward and measures steering accordingly, results in the car following the AI spline very well, instead of waving around as per the previous version.

A difficult problem to tackle in a non-uniform spline based AI is acceleration and deceleration, and deducing the right times to hit the gas and brakes. The problem might blow up to require entirely new AI line organization, either uniform spline sizes, vectors and curves, or corner/straight based AI lines to make the car decide dynamically when to change inputs, as the decision is always based on the upcoming corner and that can be anything really. Being a vague problem, and also being unnecessary to make a dynamic model in a game that uses premade tracks, I ended up tackling the acceleration deceleration problem by just recording relative speeds at every nodes myself once, and then saving the values in the track metadata file. The AI then adjusts gas and brake accordingly, the results are pretty good as demonstrated in the video.

I also discovered through testing that adding a scaler to all of those values made the AI faster or slower without any loss in accuracy (up to a point. at some level the car gets too fast to make the corners). The speed points relative to each other was the determining factor in performance and not the exact speed values in a node per se. The car now adjusts speeds dynamically. This will make difficulty levels and driver performance difference much easier to design.

Now as you can see, the car is whoppingly fast around the corners, and the AI now beat my own record with the controller in lap times, and the system was deterministic enough to get accurate reproducable lap times up to a 100th of a second in lap time accuracy.

Randomness and overtaking systems should be easeir to make now by adjusting next AI node locations within a limit &av-racer

***Finally ***got the collision system to work properly without clipping bugs.

The challenge was resolving collision relative to what side of the wall the car was, determining a "right" side was also dependent on how the walls were created in the editor (clockwise or anticlockwise stacked nodes). The second challenge was resolving the angular velocity and linear velocity vectors in a way that makes sense, the more steep the attack angle, the stronger the change in these velocity vector directions should be. If a scaler wasn't isn't there, the car would bounce off the same regardless of how fast it attacks the wall, which looks unnatural.

with this in place, AI cars come next.

&av-racer

Editor finished. using the metadata drawn in it, I could determine collisions with walls (collision resolving still needs some work) and whether the car is on or off the track, this allowed to make tarmac grippy and non tarmac surfaces drifty, and helps determine the car's relative position on the circuit. with this information we could simulate tyre wear on different surfaces. Here's a lousy lap to demonstrate: &av-racer

two control modes, simulation and arcade, they're vastly different, arcade has automatic shifting and is simple enough to be played with a keyboard, the former requires delicate analog input, it simulates individual tyre forces, grip and traction, while arcade is just fun to drive with no hassle. also finally got to making a better track, and added a minimap, right now I'm making an editor to easily create track metadata like walls, surface info, and AI nodes and waypoints. The next step is to get the editor and parsing to work (more tedious than complicated) then we should be able to start working on a gameloop

&av-racer

Added tire spin and loss of traction, oversteer, weight transfers, Gforces and a G-meter &av-racer

Wrote a little program that tests your reflexes, it takes the average of 10 tests. People who game regularly, especially FPS tend to have measurably faster reflexes. it's limited by hardware latency so its data is objective within tests done on one machine (if anyone has any practical tips on how to resolve measurement with hardware latency I'd welcome it)

https://drive.google.com/file/d/1C3yqOimQOmWs-i6NT155HmoVGpSorirt/view?usp=sharing

Implemented engine sounds using OpenAL, added gears, RPM, torque curves, and engine braking, and added a local split screen multiplayer mode. &av-racer

2D Car simulation collaboration with @archon. Here we simulate the tyre forces and solve for the sum of longitudinal and lateral forces based on the slip angle and using Pacejka's formula on each of the four tyres. (There is surprisingly sparse material online on how to simulate this so we had to come up with our own interpretations) torque, track resistance, and brake force applied on the tires determine the final velocity vector of the car, and using the coefficients on the top corner, one could adjust to simulate different road and tyre conditions, and car performance. Currently working on a local multiplayer mode (Online maybe too) and up next is gears and torque curve simulation. &av-racer

Work in progress simple 2D car game together with @archon we're (still) working on simulating car and wheel forces. &av-racer

Added a genome coding system to the cell simulations. The DNA string below every column contains the information of their respective cells. A parser also can decode the string to cell info that works for the game, meaning the game can now have the ability of genome editing and creating different kinds of cells as a player

Hot reloading of in-game structures for the simulation.

The game parses two files, one that has a numbered list of all symbols and items inside the simulation, the other file has cell structures of enzymes and other data. It was hard-coded previously, now I can edit those files and with one command parse them into an intermediary number based code (using a small tool I made for this) and with a console command in-game, I can update the simulation with the new data while it's running. Took a lot of time to set up but this will streamline testing game design concepts.

EDIT: check the thread, now I run the batch file from within the game. It's all one command now

Smooth pixel art filtering, using the smoothstep anti aliased texture filtering function in the shaders from: https://www.shadertoy.com/view/ltBfRD

Rewritten the renderer in OpenGL, the game now runs with under 20 draw calls and less than 1 mb data buffered to GPU. reduced used RAM by around 600mb by placing all sprites into one texture and sending it to VRAM, the entire game sprite pixel data and font atlasses are on one giant texture stored in the GPU, used VRAM ~ 300 mb. (you can see debug info on the left, gif is low FPS and has artifacts, the thing runs at 60 with no problems).

The "Render layers" is a system that solves alpha blending problems as it is order dependent. The renderer splits the 2d space into layers so that those at the bottom get rendered first and translucent objects blend correctly. This still doesn't produce that many draw calls as you can see below.

Looks the same as before, just runs better with more control + shaders!

Update 0.2.0 is officially released! there's a ton of new features, overhauled simulation, graphics, objectives, scenarios, the works! check it out here: https://astrobion.wordpress.com/2021/08/12/alpha-v-0-2-0/

Working on simulating organic looking cell reproduction. anyway, here's a very inefficient way to draw a white rectangle:

Hot reloading live raytracing shapes using SDF equations and ray marching. collab with @archon

performance friendly Markdown parsing and live rendering with links to different pages within the game. (don't mind the filler text)

3D rope simulation using Verlet integration, enforcing constraints using the Jakobsen method, rendered in OpenGL. collaboration with @archon

Real time basic ray tracer, using compute shaders in OpenGL running on the GPU, collaboration with @archon

I managed to get drop-down menus working in my game and added textboxes where you could type

This is not strictly programming related, but I wanted to share my new game logo design:

in my Astrobiology puzzle game I've added a solution based system where you feed the cell through a pump that adds to the wash-fluid. Next I'm planning to add a simplified molecule-synthesizer that lets you place orders on custom pharmaceuticals to use and test on cells.

Consider following my little project, there’s playable alphas as well: https://discord.gg/UNNBd34J

I’m Making a puzzle game about being an astrobiologist and figuring out alien organisms. You can read more about it here: https://ragsterb.WordPress.com

We also have a discord server: https://discord.gg/aQc3Ud5W3D Your opinions would be much appreciated!

I am writing a puzzle game (C/C++ with an engine from scratch) where you play as an astrobiologist trying to figure out alien organisms. Here’s the website if you’re interested, it has playable alpha versions and links to dev streams: https://ragsterb.wordpress.com