Ben Leskey's Blog: software

Fixing Intellj IDEA lag spikes on OpenSUSE KDE Plasma 6

Thu, 17 Apr 2025 12:00:00 +0000

I ran into JBR-6830. When using Intellij IDEA on KDE Plasma 6 (OpenSUSE Tumbleweed), I was getting random very noticeable lag spikes. The solution was to add

-Dwatch.desktop.geometry=false

to the Intellij IDEA custom VM options. No more lag spikes!

Fixing HP Victus 15 internal microphone drivers by compiling patched auto-updating kernel with openSUSE Tumbleweed Open Build Service

Wed, 25 Dec 2024 12:00:00 +0000

I've recently moved to a new laptop. OpenSUSE tumbleweed is still my OS of choice, and my recent experience cemented its position as my favorite Linux distro. My new device is an HP Victus 15, specs below:

Operating System: openSUSE Tumbleweed 20241222
KDE Plasma Version: 6.2.4
KDE Frameworks Version: 6.9.0
Qt Version: 6.8.1
Kernel Version: 6.12.6-5.gfb072de-default (64-bit)
Graphics Platform: X11
Processors: 12 × AMD Ryzen 5 7535HS with Radeon Graphics
Memory: 14.8 GiB of RAM
Graphics Processor: AMD Radeon 660M
Manufacturer: HP
Product Name: Victus by HP Gaming Laptop 15-fb2xxx

The only hardware issue encountered on this device was that the internal microphone was not recognized. For example, using arecord -l to list my sound devices, I only saw the unplugged microphone device, even though my devices were shown in inxi -A:

$ arecord -l
**** List of CAPTURE Hardware Devices ****
card 2: Generic_1 [HD-Audio Generic], device 0: ALC245 Analog [ALC245 Analog]
  Subdevices: 1/1
  Subdevice #0: subdevice #0

$ inxi -A
Audio:
  Device-1: Advanced Micro Devices [AMD/ATI] Navi 21/23 HDMI/DP Audio
    driver: snd_hda_intel
  Device-2: Advanced Micro Devices [AMD/ATI] Rembrandt Radeon High
    Definition Audio driver: snd_hda_intel
  Device-3: Advanced Micro Devices [AMD] ACP/ACP3X/ACP6x Audio Coprocessor
    driver: snd_pci_acp6x
  Device-4: Advanced Micro Devices [AMD] Family 17h/19h/1ah HD Audio
    driver: snd_hda_intel
  API: ALSA v: k6.12.6-5.gfb072de-default status: kernel-api
  Server-1: PipeWire v: 1.2.7 status: active

After much research I found the fix. I needed to add a linux kernel quirk patch for my specific model in the ACP6X sound driver for the internal microphone. The patch to the kernel itself is extremely simple, just adding my hardware to the quirk list so that even though Linux does not autodetect the correct driver, it will load it anyway:


diff --git a/sound/soc/amd/yc/acp6x-mach.c b/sound/soc/amd/yc/acp6x-mach.c
index ecf57a6..c95198c 100644
--- a/sound/soc/amd/yc/acp6x-mach.c
+++ b/sound/soc/amd/yc/acp6x-mach.c
@@ -458,6 +458,13 @@ static const struct dmi_system_id yc_acp_quirk_table[] = {
 			DMI_MATCH(DMI_PRODUCT_NAME, "OMEN by HP Gaming Laptop 16z-n000"),
 		}
 	},
+	{
+		.driver_data = &acp6x_card,
+		.matches = {
+			DMI_MATCH(DMI_BOARD_VENDOR, "HP"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Victus by HP Gaming Laptop 15-fb2xxx"),
+		}
+	},
 	{
 		.driver_data = &acp6x_card,
 		.matches = {

So far, so good. But here's where OpenSUSE shines: using the Open Build Service, I was able to create a new set of kernel packages with my patch that automatically keep up with the latest tumbleweed kernel. This reddit comment was very helpful, reproduced below:

Go to https://build.opensuse.org/package/show/openSUSE:Factory/kernel-source

sign in

click branch

optional step - use the command line tool osc to download, edit and test the build locally.

overwrite the config.tar.bz2 with your .config tar bzipped

Make package links to kernel-source and call them kernel-default, kernel-devel and kernel-syms

~~Draw the rest of the owl~~

Wait for it to build successfully

Add the repo to your TW installation (links are on the webpage) and switch the kernel packages over

I more or less followed these steps, with some details below:

First, I installed the kernel-source package so I could test and install my fix locally, using the following:


$ cd linux-build-directory

$ make -C /usr/src/linux O=$PWD oldconfig # Create a kernel config based on my running kernel config
[...]

# In the .config file, I updated CONFIG_LOCALVERSION to differentiate my compiled kernel,
# and removed the reference to the OpenSUSE keys in CONFIG_MODULE_SIG_KEYS

# I also added a modprobe configuration file:
$ cat /etc/modprobe.d/10-unsupported-modules.conf
allow_unsupported_modules 1

$ make -j12 # It builds.

$ sudo make modules_install -j12 # Adds the kernel modules to /usr/lib/modules

$ sudo make install -j12 # Installs the kernel to /boot and updates the bootloader

At this point I created the patch diff of my changes using the original file and my new file:


$ git diff /tmp/old-acp6x-mach.c ./sound/soc/amd/yc/acp6x-mach.c > /tmp/my-new-patch.patch

After this, I rebooted into my custom kernel to verify the fix. To remove the custom compiled kernel from the bootloader list, I just removed the files and updated the bootloader:


$ cd /boot
$ mkdir /home/user/old-linux
$ find | grep my-custom-kernel | sudo xargs -O{} -n1 mv {} /home/user/old-linux # Replace my-custom-kernel with what you put in CONFIG_LOCALVERSION
$ sudo update-bootloader # Get the removed custom kernel off the bootloader menu

I then:

"Branched" a new package from the openSUSE tumbleweed kernel-source package. This created my own kernel-source package that I could modify as needed. Importantly, it is linked to the upstream openSUSE kernel, so it will stay up to date while applying my patches.
Checked out my new package locally, using osc: $ osc -A https://api.opensuse.org checkout home:linewriter1024:branches:Kernel:stable/kernel-source

Linked repos as mentioned in the reddit comment + some additional.


$ osc linkpac home:linewriter1024:branches:Kernel:stable/kernel-source home:linewriter1024:branches:Kernel:stable/kernel-default
$ osc linkpac home:linewriter1024:branches:Kernel:stable/kernel-source home:linewriter1024:branches:Kernel:stable/kernel-devel
$ osc linkpac home:linewriter1024:branches:Kernel:stable/kernel-source home:linewriter1024:branches:Kernel:stable/kernel-docs
$ osc linkpac home:linewriter1024:branches:Kernel:stable/kernel-source home:linewriter1024:branches:Kernel:stable/kernel-syms
$ osc linkpac home:linewriter1024:branches:Kernel:stable/kernel-source home:linewriter1024:branches:Kernel:stable/kernel-macros

Added my patch to patches.addon.tar.bz2 inside my checked out directory, which has an empty directory patches.addon, into which directory I added my patch file 6.12.6-9999-local.patch and a text file named series with one line: 6.12.6-9999-local.patch, the name of the patch file.

Ran osc build and verified that my patch was being used:


$ cat /var/tmp/build-root/standard-x86_64/.build.log | grep addon
[   10s] + /usr/lib/rpm/rpmuncompress -x /home/abuild/rpmbuild/SOURCES/config.addon.tar.bz2
[   10s] + /usr/lib/rpm/rpmuncompress -x /home/abuild/rpmbuild/SOURCES/patches.addon.tar.bz2
[   22s] + patch -s -F0 -E -p1 --no-backup-if-mismatch -i /home/abuild/rpmbuild/BUILD/kernel-source-6.12.6/patches.addon/6.12.6-9999-local.patch

Ran osc commit and uploaded my changes. The open build service built my new kernel and after it was finished I added the repository to my package repositories and ran sudo zypper dup --from=https://download.opensuse.org/repositories/home:/linewriter1024:/branches:/Kernel:/stable/standard/ --allow-vendor-change to upgrade my kernel to my new patched version.
Rebooted and profited!

This OpenSUSE infrastructure is incredibly useful, and I am very pleased with my choice of distro and the (relative!) ease of fixing this internal microphone issue without sacrificing update flow. Next step, getting this patch into the upstream Linux kernel!

Switching to openSUSE Tumbleweed

Tue, 06 Aug 2024 12:00:00 +0000

After over ten years of Ubuntu with the i3 window manager and a host of custom scripts as my desktop OS, I've switched to using openSUSE Tumbleweed with KDE Plasma.

The Hardware

I took two identical Dell Inspiron 5577 laptops and cobbled them together into something slightly better. I chose one unit as the base for the new machine and the other as a donor unit since it had a random power off issue when using the graphics card. I swapped out the slow-as-sin hard drive in my chosen unit with a new SSD, then took the 8 GB RAM stick from the donor unit and stuck it into the chosen unit for a comfortable 16 GB RAM. I also had to steal the keyboard from the donor unit as the chosen unit's keyboard had a lot of dead keys from some damage. After the dust settled, I was left with a nice recycled build, as reported by KDE system information:

Operating System: openSUSE Tumbleweed 20240803
KDE Plasma Version: 6.1.3
KDE Frameworks Version: 6.4.0
Qt Version: 6.7.2
Kernel Version: 6.10.2-1-default (64-bit)
Graphics Platform: X11
Processors: 4 × Intel® Core™ i5-7300HQ CPU @ 2.50GHz
Memory: 15.4 GiB of RAM
Graphics Processor: NVIDIA GeForce GTX 1050/PCIe/SSE2
Manufacturer: Dell Inc.
Product Name: Inspiron 5577
System Version: 1.1.3

KDE + Software

KDE is an excellent desktop environment. Coming from i3, I find it very user-friendly, and entirely as powerful if more mouse-focused. The integration with the wide array of programs is refreshing.

The best part of openSUSE Tumbleweed is, of course, the software selection. New versions of everything, and a host of package repositories, all with frequent updates.

Decent hardware support

All the hardware is supported, including the NVIDIA graphics card. The only issue is (a classic Linux problem) with suspend and hibernate - the graphics card sometimes does not power back on. I don't need either state, so I just disabled them by masking their targets: sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target.

Setting up NVIDIA

The yast software installer automatically prompted me to install the NVIDIA drivers, and after they were installed I made them default with sudo prime-select boot nvidia. Fairly easy!

NVIDIA + Secure Boot

The biggest problem with the NVIDIA drivers is updating them. With UEFI secure boot enabled, each time the drivers were upgraded I had to enroll their keys at boot time. If I missed the 10 second window (and you only get one chance, even after rebooting), the graphical environment couldn't come up and I had to recover manually by running sudo mokutil --import /usr/share/nvidia-pubkeys/whatever-nvidia-pubkey.der from the recovery environment. You can also disable kernel module verification by running sudo mokutil --disable-validation. This will ask you to set up a small password and then disable the verification at next boot time (assuming you can remember the small password you set up).

Codecs

By default, openSUSE does not provide some codecs, e.g. for some internet video formats or for Discord live video streaming. The fix is simple but not prompted at all: sudo zypper install opi && sudo opi codecs will add the correct repositories and install the needed codecs.

Arcana Technoclysm update: Magical UPS, whistle crafting, and bionic installation

Fri, 17 May 2024 12:00:00 +0000

I've updated my mod Arcana Technoclysm for Cataclysm: DDA with some more new features.

First the changes. The vehicle whistles can now be crafted from each other, so if you find the boat whistle and really wanted the motorcycle whistle you can still craft it. The recipes are written in the Cleansing Flame book and the arcana lab journal. Also, there are some more Technoclysm item spawns in the strange warehouse, so poke around! Technoclysm items can also spawn rarely with other Arcana items in labs or magic locations.

The first new feature is an eternal UPS (power supply) which uses magical energy to constantly provide power to UPS-enabled tools. It has a recharge rate of about 2 kJ per minute and is fairly small, and can be either crafted or found.

The second, and more important, new feature is a magical means of installing bionics. Bionic talismans can be crafted from any power storage or power generation CBM. Using the bionic talisman will temporarily summon a magical avatar of the bionic, who will install any bionic for you before disappearing. This provides a means of installing bionics outside of the Exodii using another otherworldly force who may be more or less friendly.

Arcana Technoclysm: A small mod for Cataclysm: DDA

Fri, 20 Oct 2023 12:00:00 +0000

Cataclysm: DDA's premier magic mod is Magiclysm, which not only adds an entire magic system and slew of useful spells, items, and locations but also alters the lore of the game to imply that magic has existed throughout history. This lore breaks significantly from real world history, so I prefer mods that keep magic as something esoteric and hidden, such as the newly added mod Mind Over Matter or the mature Arcana mod.

However, there is one particular spell from Magiclysm that I love that is not available in any other mod: the Summon Motorcycle spell. This is amazingly useful and fun to play with, so I decided to port the idea over to Magiclysm in my own mod. This new mod, Arcana Technoclysm, currently adds three temporary summonable vehicles and a new location to find the magic whistles needed to summon these vehicles. It's a simple mod but fills in the summonable vehicle gap in the more lore-friendly magic mods. The vehicles currently available are an amphibious boat with wheels, a motorcycle, and a horseless carriage with plenty of cargo space. Each of the vehicles is a tradeoff between maneuverability, compatible terrain, and cargo space, so hopefully players will have incentive to find strange warehouses and collect all the magic whistles.

World map for a Wesnoth campaign: The Paradise Trap

Thu, 28 Sep 2023 12:00:00 +0000

I'm working on a Battle for Wesnoth campaign, The Paradise Trap, set in the western sea off the coast of the Great Continent in the world of Wesnoth. The world of Wesnoth has a canonical map, but working with a nice-looking map is beyond the scope of my project for now. Fortunately for me, Wesnoth's game map editor creates nice enough maps and has an automatable screenshot export function built in.

I built an approximation of the world map in the in-game map editor. This maps out the terrain of both the canonical continent and my own world building—Paradise. The scale is certainly off, but it doesn't matter; I'm not concerned about accuracy for this map which will only be used at the start of scenarios to roughly plot out the movement of the characters.

Finally, I use ImageMagick to add labels to the map. The labels are drawn using a built-in Wesnoth font, so the style at least somewhat matches the game. This final image is then used at the beginning of each scenario, and can be used for spatial reference as I write the story.

This is all automated through a script that exports the wesnoth map of the world to an image and then uses a long convert invocation to add all the labels. The script is included below for reference.

Map generation script


#!/bin/bash
if ! [[ ./images/worldmap.png -ot ./worldmap/worldmap.cfg ]] && ! [[ ./images/worldmap.png -ot ./worldmap/build.sh ]] ; then
	echo "Worldmap is up to date!"
	if [[ -n "$wx" ]]; then
		return 0
	else
		exit 0
	fi
fi

wesnoth --screenshot ./worldmap/worldmap.cfg ./images/worldmap.png > /dev/null

commandline=""
font="$(wesnoth --data-path)/fonts/OldaniaADFStd-Regular.otf"

label() {
	x=$1
	y=$2
	text="$3"
	scale=${4:-1}
	scalei="$(echo "$scale * 48" | bc | cut -d. -f1)"
	len="$(echo "$text" | wc -c)"

	commandline="$commandline -pointsize \"$scalei\" -font \"$font\" -fill white -gravity NorthWest -draw \"text $((x - (scalei * len) / 6)),$((y - $scalei)) \\\"$text\\\"\""
}

label 3510 1040 "Elensefar" 1.5
label 3732 1338 "Halstead"
label 3680 1616 "Aldril"
label 4000 1190 "Carcyn"
label 3303 2304 "Blackwater Port"
label 3024 2037 "Isle of Alduin"
label 2445 1134 "The Three Sisters"
label 2390 1575 "The Red Isle"

label 1606 1317 "Ialwas"

label 3357 441 "Glamdrol"
label 3837 282 "Rumyr"

label 5031 1866 "Dan Tonk" 1.5
label 5523 2349 "Weldyn" 1.5
label 5349 1722 "Tath"
label 4875 2844 "Fort Tahn"

label 4815 1362 "Gryphon Mountain"
label 5640 1086 "Swamp of Dread" 2
label 4380 213 "Lake Vrug" 2
label 3395 1890 "Bay of Pearls"

label 3960 760 "Wesmere Forest" 2
label 3774 2670 "Aethenwood"

label 423 1719 "Paradise" 3
label 4344 1911 "Wesnoth" 3

eval "convert $commandline ./images/worldmap.png ./images/worldmap.png"

Make horses milkable

Mon, 03 Jul 2023 12:00:00 +0000

See https://github.com/CleverRaven/Cataclysm-DDA/pull/66639

The Dillo Test

Sun, 05 Jan 2025 12:00:00 +0000

(Post updated on 2025-01-05 to correct the link to Dillo.)

You may not know what Dillo is.

That's Dillo. It's a plain graphical web browser with minimal feature set beyond being able to draw text and, sometimes, images. Why would anyone want that? Well, there's not much practical reason now—every modern browser supports a truckload of features beyond simple HTML—but it does indicate a simplicity and graceful degradation that is aesthetically desirable. This website, for instance, is entirely usable in Dillo. Javascript doesn't work, but everything has a fallback. If your site works in Dillo, then it is simple enough.

It's not even difficult to make this site work in Dillo. In fact, it avoids any kind of bloat. This site can't rely on Javascript, or on complicated styling, or on anything but simple text to get its message across. Functionality beyond that is, as is traditional, just window dressing on top of a simple HTML structure. Common? No. But if your site works in Dillo it will probably satisfy the hacker hipsters.

You can, of course, take it further and make the Lynx test ;). You'd better hope you've got alt text on your img elements!

Mapping tool 0.6.2 release & thanks to all testers

Mon, 08 May 2023 12:00:00 +0000

Hello everyone!

Thank you so much for supporting the development of the mapping tool with your feedback, bug reports, and suggestions!

Version 0.6.2 of the mapping tool is out, with several important improvements including unlimited scale and image exporting. This is the last version of the mapping tool to be developed as an MVNU project, as I have graduated! In the future, the mapping tool will be developed as an open source project.

You can download it here: https://github.com/mapper1024/mapper1024/blob/master/DOWNLOAD.md#download-options

You can use the online demo here: https://mapper1024.github.io/demo

Image Exporting

You can now save parts of the map as images to be used as illustrations for a book, for a website, or for whatever you want.

Unlimited Scale

The scale of your maps is now unlimited, with a few handy controls to set exactly what scale you want to edit your map at at any given moment: you can edit on the scale of meters to design a city, or on the scale of hundreds of kilometers to design a continent. Whatever you like, all in the same map.

What’s Next

Just because I graduated doesn’t mean that the mapping tool is done. I’m going to keep working on it! Features like altitude controls, better performance, alternate graphical styles, and more are all in the pipeline. I’ll also be releasing the tool as an open source project so that anyone interested can contribute ideas, code, and art.

Stay in Touch

Feel free to e-mail me at ben@benleskey.com for anything! You can also post feature requests or bug reports using the mapping tool issue tracker.

If you’d like to keep up with development of the mapping tool and try out new releases, all mapping tool news is posted on my website. An rss feed for news is available, as well as an atom feed for releases.

Thank you again for your support, and I hope you continue to enjoy the mapping tool as it grows and evolves!

Prototype post-apocalyptic roadtrip simulator for the Minetest engine

Sun, 23 Apr 2023 12:00:00 +0000

Introduction

Github repository: https://github.com/tigris-mt/roadtrip

I've begun work on a game project, smaller in scope and more relaxing than the text engine project. This new project uses the Minetest engine for voxel graphics, entities, and physics. This game, Roadtrip, is designed along the lines of The Long Drive as a post-apocalyptic roadtrip simulator and also takes inspiration from Cataclysm: Dark Days Ahead. It's written in Lua.

Minetest & Voxels

The Minetest engine provides a solid base for this type of game: procedural generation, low-poly graphics, built-in multiplayer, etc. I have quite a bit of experience with Minetest and Lua, so it's a good choice for game engine since I don't want to put too much development effort into this game. The world will consist of "voxels", blocks like in Minecraft that form the terrain, along with moveable "entities" such as the vehicles and the player.

Design

The basic design of the game is the player driving down a road in a procedurally generated environment. The player must survive (food, water, gasoline/electricity, shelter, etc.) as long as possible while enjoying the view and trip.

Like The Long Drive, Roadtrip will have a long highway extending indefinitely into the distance with a randomly generated environment surrounding it, maybe including side roads or broader road networks. The prototype environment will be a desert, but it will be easy to add new biomes.

In the prototype, the road runs from the south toward the north, with turns and corners defined by an equation that returns the X (east-west) coordinate of the road based on the Z (north-south) coordinate. The current equation is defined as

local z_factor = 60 + 60 * seed_random()
local z_factor_2 = 160 + 160 * seed_random()
local x_factor = 60 + 60 * seed_random()

local function road_x(z)
	return math.floor(math.sin(z / z_factor) * (math.sin(z / z_factor_2) ^ 4) * x_factor + 0.5)
end

where seed_random() is a random generator returning a random number between 0 and 1 according to the world seed. All other properties of the world, like the width of the road at any point, will be defined by similar procedural generation to ensure continuity as each chunk of the map is generated separately.

Vehicles

Vehicles are the focus of Roadtrip, so they will be very customizable. Vehicles will be individual components internally, such as the chassis, the wheels, the doors, etc., which can then be installed together and the models attached to display an entire car, truck, or other vehicle.

Survival

Survival elements including hunger, thirst, weather, and fuel will drive further exploration and resource gathering. There may be enemies as well, or some other active threat.

Exploration

Resources will be available in structures off the road, in abandoned cars, or from natural resources like lakes or trees. This will encourage exploration off road, both with and without a vehicle. Terrain generation can be improved to have hills, valleys, caves, etc. to spice up the landscape.

Development Challenges

The Minetest engine is limited in a number of ways that will make development more challenging. I do think my familiarity with the engine along the engine's simplicity will make it worth it, however.

Rotation

Most noticably, if the player is attached to an object and the object rotates, the player's viewport does not rotate with the object. My workaround, rotating both at the same time, suffers from network lag causing noticable drift that the player must manually correct. I may need to contribute a feature to the engine to support this for more realistic driving.

Collision

For performance reasons, an object's collisionbox cannot extend much beyond ~3 nodes in any direction before it starts to break. This means that entities like vehicles can't be too big or their physics won't work. Again, I may need to improve the engine here, or just live with innacurate collision on large vehicles.

Hud & Controls

Implementing the HUD and controls is a bit of a challenge as the Minetest engine is geared toward a Minecraft-like game. Nevertheless, I should be able to represent the dashboard on the HUD nearly as easily as the player's own stats. Controls are also a little harder, with a limited number of keybinds available to the game. I can use movement keys for driving, and I may be able to use hotbar items for actions like shifting gears or quick access of weapons or tools.

First place prize for my mapping tool presentation at MVNU's sURC

Tue, 25 Apr 2023 12:00:00 +0000

Update 2023-04-25: MVNU sURC press release featuring my mapping tool

I presented my Mapping Tool for fifteen minutes at MVNU's sURC on April 5th, taking home the first place prize of the Symposium. My friends and faculty showed up en masse at my presentation, making for a lively Q&A and a really fun time.

sURC itself was interesting. There were around twenty presenters in total. The Honors students presented their senior projects and other students presented their summer research projects in a conference format. In my room we had a wide variety of presentations: an analysis of continuous glucose monitors in diabetic patients, a presentation of a concussion-detecting device for athletes, an examination of religion and spirituality in occupational therapy, and my own software project.

This sURC presentation was my presentation for the Honors program portion of my project, so in it I focused on how user feedback shaped the development of the mapping tool with an overview of project features and the development process. Later I'll have a twenty-five minute presentation on the details of programming and engineering the project.

For more information on the mapping tool, including download links and a quick-start guide, see the mapping tool website.

(More about how I made the GIFs used in the presentation.)

Toward the ultimate text adventure game engine

Fri, 21 Apr 2023 12:00:00 +0000

Github repository: https://github.com/linewriter1024/textengine

Text adventure

Why text?

Text-based games have an extremely good complexity/development time ratio. There are no graphics to worry about, no programmer art beyond writing (what luck, I happen to enjoy writing), no controls beyond text processing, no frames per second, et cetera, et cetera. Fully text based games can be even more complex than turn-based 2D roguelike games like Cataclysm: DDA. There's just less extra to worry about—the development focus has one of the most basic interfaces imaginable. Additionally, fully text-based games are perfect for screen readers due to their simple interface (see this article about writing a screen-reader friendly text-based game).

The specific style of text-based game I'm talking about is the text adventure game. The computer tells you about your environment, your circumstances, and your character, and you choose what your character does or says. It's simple, straightforward, and very reminiscent of the conversational style of a tabletop RPG.

The problem is, a human game master will always be better than a computer here, right? A human game master can simulate any situation, can mediate any conflict, can act any character. (I exaggerate, but not very much.) A computer must be programmed to handle every specific situation in the game's world.

AI?

You can make ChatGPT play a roleplaying game with you. ChatGPT can be the game master, simulate the environment, accept the actions of your character, whatever you might want. A couple of pitfalls prevent full immersion, however. ChatGPT forgets details and must be reminded, and it can't stay on track with a game system, being a more freeform storyteller. I want something better.

MUDs?

The system I have in mind is similar to the MUD gameplay style, which is fully text-based as you pilot your character through a multiplayer world. MUDs are, however, limited in a number of ways: they are generally room based, their multiplayer nature requires real-time interaction, their systems are quite gamey, and the "dungeon master" is primarily concerned with combat mechanics.

Something new

I've started work on a new system at https://github.com/linewriter1024/textengine. This text engine is an effort toward building a flexible text-based game engine for simulating any scenario or world.

Goals

To simulate combat and action mechanics
To handle social interactions
To keep track of world events: political affiliations, kingdom economics, famines, shipping routes
To support singleplayer play or play with a small party
To support any genre of game: high fantasy action, low fantasy economic, sci-fi space battle, zombie apocalypse, etc.

These are very ambitious goals, but the text engine format lends itself well to managing all this complexity without the added requirements of graphical display and control.

This will be a long-term project, so development may be quite slow. There is no time pressure, however, so I can take it at my pace.

Learning Go

This project is also a way for me to learn the Go language, which has some unique syntax and ideas that I think will be perfect for a large text-based game engine like this.

Design

The basic structure is thus: everything in the world, whether a city, a man, a kingdom, a sword, or a lake, is an entity in relationship with other entities, capable of whatever actions and interactions make sense for it.

Let's example a sample scenario to illustrate the idea: a covered wagon of four merchants traveling down a road through a forest, about to be robbed by two bandits with crossbows. You are the lone guard for the wagon, wielding only a sword riding in the front with the driver while the other three merchants are sitting in the back.

Every bold word in that previous paragrah would be an entity (or a few entities). As an example, the wagon is an entity with two entities making it up: the front and the back. In the event that you wanted to hide underneath the wagon, an entity for the underneath would be generated as well. The front of the wagon is an entity that contains you and the driver. This contains relationship would be mirrored by in relationships that you and the driver have with the wagon. The wagon itself is on the road, while the road contains the wagon. The road itself is within the forest, and so forth.

You can see the complex interactions that can happen here. Each of the merchants and bandits has an AI corresponding with their generated personalities and skills, so some of the merchants might draw weapons while others might seek cover in the wagon from the bandits' crowssbows.

Dialogue would be represented by ideas, such as "The king expresses his gratitude with an undercurrent of disdain." or "The bandit threatens you with no trace of reason in his eyes." You can choose to respond however you see fit, by threatening, cajoling, warmly thanking, etc. to influence character's perceptions, attitudes, and ultimately actions.

Attitudes and actions would bubble upward as well to influence cities and kingdoms. If the player was not currently in a city it could be simulated on a macro level rather than each individual character in the city, so that the city's influence and politics would change and existing characters in the city would have their life stories altered without the need for a granular simulation.

I still need to work through the details of the system, and see what implementation issues I run into, but this should provide a base for further development in a new and exciting direction.

Github repository

I've started work at https://github.com/linewriter1024/textengine. The prototype is not yet a functioning game, but there is a command processing system and the basis of a generic game engine capable of singleplayer and multiplayer text-based gameplay.

Mapping tool quick start guide

Thu, 20 Apr 2023 12:00:00 +0000

See https://github.com/mapper1024/mapper1024/wiki/Quick-Start

OBS Studio -> ffmpeg -> ImageMagick for an optimized gif

Fri, 07 Apr 2023 12:00:00 +0000

Update: The gifs worked! I successfully presented at sURC, and won the top prize.

I've been working on my presentation to present my mapping tool senior Honors project at MVNU's sURC. For part of this presentation I wanted an animated gif illustrating the basic drawing functionality of the tool.

I started with OBS studio to record the actual video of me drawing a simple map. Then I imported the video into Kdenlive for editing. OBS recorded the video as 1920x1080, but the actual mapping tool window that I was recording was only 1916x1008 so when I imported it into Kdenlive there was a black bar along the bottom. To solve this, I set the resolution of the Kdenlive project to 1278x672 (the same scale but a smaller resolution to keep the GIF size small) and applied a transform effect to position the original clip within the proper resolution. I set the clip speed to 300%, so that in under 30 seconds people could see an example of an entire (if small) map being created.

With the Kdenlive project ready, I rendered it to an MP4 file for conversion to GIF.

I then converted the MP4 file using

ffmpeg -i in.mp4 -vf "scale=-1:-1,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -r 10 out.gif

10 fps struck a good balance between choppiness and size; I didn't need it to be smooth, just not so jumpy as to be annoying. I had ffmpeg generate a GIF palette itself with the palettegen and paletteuse combo.

Then I optimized the gif, lossily, using ImageMagick's mogrify command

mogrify -layers 'optimize' -fuzz 7% out.gif

The final size of the optimized GIF was 3.1MiB, down from a 21MiB unoptimized GIF, an 8.1MiB MP4 file, and an 11MiB original obs output file.

Here's the final GIF:

I took the ETS major field test for computer science

Thu, 16 Mar 2023 12:00:00 +0000

Every senior student at MVNU takes a standardized assessment. The assessment lets MVNU administration compare how well their students are doing against other institutions, and how well each program is teaching the fundamentals of the program's field. In my case the assessment was the ETS major field test for computer science.

While I knew the test was coming up, I wasn't given any information about what would be on the test, and since I knew it wouldn't affect my graduation or GPA I wasn't particularly concerned about studying for it. The day before the testing day I decided to look into exactly what I would be taking. I found a sample questions document (archived) by searching on google. These sample questions were representative of the actual test—as one'd expect—and there was nothing I hadn't seen in my courses at MVNU. The bulk of the questions seemed to be more "Computer Science" than "Computer Programming" and were covered by two courses in particular that I'd taken: Data Structures & Algorithm Design and Survey and Organization of Programming Languages. I didn't study much beyond checking out the sample questions.

On the day of the actual test classes were cancelled for everyone to let seniors take their major field assessments, juniors take their general education assessments (only every other junior class has to take these, I didn't have to last year), and everyone except graduating seniors to meet with their advisors and schedule classes for the next year. Sadly, I didn't get to enjoy much of the cancelled classes as I had to wake up for the major field test at 9 AM, and I still had my meeting with my Honors project advisor to keep wrapping things up. The test was proctored—as required by ETS—and administered in the main computer lab. The test itself was not very stressful; the sample questions were good preparation and representation of the actual assessment.

My score was displayed and e-mailed to me immediately after I completed the test. I scored 181 on a scale from 120–200, placing me in the 98th percentile. This is pretty good, and I'm happy with the score, and how it reflects on my learning at MVNU. I could have done a little better with more studying, but most of the questions could be solved with logic, and that's not something learned by cramming before a test—only years of practice can build that kind of understanding and that's what brought my score so high.

I couldn't find much other discussion online about the ETS major field test, just a couple blog posts from a student's blog.

Quirks of the results page

The results page pops up the individual results for the test that I took, but interestingly if I press an "illegal key" like the Windows key, it alerts me and leaves the page. Why? I don't know. Maybe it thinks I'm still taking the test.