DEV Community: Matthew Odle

Message Queue MUD Dockerization Update

Matthew Odle — Fri, 08 Feb 2019 05:38:29 +0000

I made progress on that MUD I’ve been working on.

Try it out (yea, naming things is hard):

git clone -b v0.1.0_share https://gitlab.com/modle13/queue-mud.git
cd queue-mud
docker-compose up

Over the weekend, I got it working nearly back to the state it was before dockerizing. There’s a bit less logic (the creatures decision point just returns a string), and the Angular frontend is still disabled. I had had a publisher and consumer working back in early January, but now it has the whole chain: command > validate > attack if command is attack and there’s a target > response queue.

The main problem I solved was how to have separate queues for the different decision points. I also solved the problem of getting gunicorn and python to output stdout and stderr properly to the docker-compose logs (check out the Dockerfile CMD flags; -u for python and "--access-logfile", "-", "--error-logfile", "-" for gunicorn). I learned some things about naming services and containers, querying the RabbitMQ API, .env files for docker-compose, and using custom python modules across multiple containers.

After I added the 2nd and 3rd queues, I had the strong urge to abstract the boilerplate into a module (that’s what modules are for: extensible boilerplate :D), so I did that and it was glorious. I added a module for publishing too, and split the responsibility of the publisher flask app into an ingester (flask POST and status endpoints only), and a publisher module (simple python, used in all decision points and the ingester). This way I don’t have to worry about the boilerplate at all. I just set the queue and exchange parameter and custom on_message function on initialization of the decision point to set up a new queue, and pass the name of the target exchange with the message to the publisher module.

The key focus today was cleaning it up so using it sucked less. Writing the shared modules was a big step. Now new modules only need to set the two parameters and override the on_message method. I should probably do this with inheritance, but this’ll do for now. I cleaned up the READMEs, listed required and optional system dependencies (only docker-ce and docker-compose are required). I added a tmuxinator profile (so cool) that spins up the custom queue_watcher script (queries the RabbitMQ API and parses out some data using python), the log tailer (message output by the response queue consumer), docker-compose (the thing actually running the game), and a verification step (verify.sh, which POSTs a few example values to the ingester and checks the status endpoint).

The status endpoint also has an unnecessary feature. It uses a goodreads API to pull random George Orwell quotes. Here’s the module. Don’t make fun of the try/except.

The next steps are to figure out how to handle world state, and how to manage creatures, both likely have the same set of problems.. Currently responses just get dumped to the volume mounted log file. This is fine for now (it could be playable locally) but eventually there will need to be size considerations. It would also be interesting to be able to replay the history, and for that something a little smarter would be needed.

Simple 3D Camera Movement in Unity

Matthew Odle — Fri, 26 Oct 2018 02:03:17 +0000

I'm making a 3D village management sim, and when things get crazy, I like to be able to zoom in on the action in a specific region.

This camera control script looks for horizontal and vertical axis inputs (WASD and arrow keys) to allow the player to pan around. It also watches the mouse scrollwheel to allow the player to raise and lower the camera.

Just drop it on your Main Camera gameobject in your scene, and you're good to go.

The basic pattern is:

if input
- create a new Vector3(x, y, z) using the target inputs
  - x and z for pan, y for zoom, the rest 0
- multiply the Vector3 by some predefined speed
- add the new Vector3 to the position of the camera transform

I've inverted the mouse scrollwheel input so that scrolling up zooms in and scrolling down zooms out.

using UnityEngine;

public class CameraController : MonoBehaviour {

    private float moveSpeed = 0.5f;
    private float scrollSpeed = 10f;

    void Update () {
        if (Input.GetAxisRaw("Horizontal") != 0 || Input.GetAxisRaw("Vertical") != 0) {
            transform.position += moveSpeed * new Vector3(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical"));
        }

        if (Input.GetAxis("Mouse ScrollWheel") != 0) {
            transform.position += scrollSpeed * new Vector3(0, -Input.GetAxis("Mouse ScrollWheel"), 0);
        }
    }

}

Simple UI Element Dragging Script in Unity C#

Matthew Odle — Fri, 26 Oct 2018 01:21:09 +0000

Attach this script to your gameobject/prefab to enable a simple drag mechanism for your UI elements. You'll also need to add the EventSystem object to your scene.

It's fairly straightforward. The overridden UnityEngine.EventSystems.OnPointerDown and OnPointerUp methods simply toggle the dragging bool. Then the Update method will modify the position of the object this script is attached to.

With this solution, the UI element's center will snap to the cursor, but to make this cleaner, an offset can be added based on the position within the UI element when the OnPointerDown is triggered.

using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class UIElementDragger : EventTrigger {

    private bool dragging;

    public void Update() {
        if (dragging) {
            transform.position = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
        }
    }

    public override void OnPointerDown(PointerEventData eventData) {
        dragging = true;
    }

    public override void OnPointerUp(PointerEventData eventData) {
        dragging = false;
    }
}

Scripting Android with QPython3

Matthew Odle — Sat, 26 May 2018 15:07:18 +0000

This is my (fledgling and abandoned, due to general lack of efficiency) mobile-only script development workflow (full post here).

Dev On the Go

Last summer, I went on a road trip, and wanted to experiment with a mobile-only workflow. The main components I needed were an interpreter, an IDE, and source control.

The suite of apps I discovered and used are as follows:

QPython3 (a python IDE and script runner)
SGit (source control)
LabCoat (GitLab repository viewer)
Dropbox (ad-hoc, easy-access file storage)
Dropsync (one- or two-way sync between directories on your mobile device)
Epsilon Notes (a markdown editor and renderer)

In this tutorial, I will cover my experience with QPython3.

Takeaways from this endeavor:

Plus:

It's all in your pocket
Short feedback loop for testing code

Delta:

Difficult to view information across multiple apps
Editing code can be a chore
Not enough charging stations with comfortable seating in that one mall I went to

Recommendations:

Get a bluetooth keyboard
Bring the portable charger
Sit uncomfortably close to strangers so you can share the charging station and maybe they'll leave (they didn't leave, but offered to rearrange the seating so we could chum comfortably whilst staring silently at our phones)

Covered in this post:

How to run a 'Hello World!' script in QPython3
How to load files into a QPython3 script
How I come up with names for my pets

Install list

QPython3 (v1.0.3)

Run Qpython3 and Open hello_world.py

Select Programs > hello_world.py > Open to view the script contents.

Super standard python3 here. The script uses the SL4A library (Scripting Layer for Android) to show an Android toast, then prints Hello world! to the console.

Click the right-arrow on the bottom toolbar of the script editor screen to run the script. You can also back out of the editor, click hello_world.py again, and choose Run.

That's it!

Play around with some of the other default scripts if you like. To see some of the SL4A library functionality in action, run test.py to run a series of tests on various sensors and UI elements. It will demo a few things like text to voice, various form input elements, and progress bars.

Demo Qpython3 App - Item Name Generator!

Now that you're able to execute python scripts on your Android device, let's do the only logical next thing: write a short fantasy equipment name generator script.

Loading the Files

First, we need to load the file contents. I wrote a quick loadfile function, which takes a filename and returns a list of strings contained in the file.

weapons.txt

bow
axe
mace
sword
spear
flail
etc

Each line in the loaded file will be stored as a separate string in the list by splitting on newline, or \n.

fileutils.py

def loadfile(filename):
    root_path = '/storage/emulated/0/qpython/scrdipts3/modules/namegen/assets/'
    file_path = '{}{}'.format(root_path, filename)
    loaded_file = open (file_path, 'r')
    return loaded_file.read().split('\n')

That root_path is pretty ugly, but QPython3 does not work with relative paths. It can be improved by using the os library:

import os

def loadfile(filename):
    root_path = os.path.dirname(os.path.abspath(__file__))
    ...

This will let you run the script on other devices, such as a Linux VM.

The Name Generator Script

This script will:

Import the loadfile function from our fileutils.py module
Read the contents from 3 text files into lists: prefixes, weapons, and suffixes
For each weapon in the weapons list:
- Print a string which consists of the current weapon name and a random prefix and suffix

Step 1: Load the files. Import the loadfile function from our fileutils module.

from fileutils import loadfile

Step 2: Invoke loadfile to create a weapons list, then print it out to verify.

from fileutils import loadfile

weapons = loadfile('weapons.txt')
print (weapons)

If you run the script, you should see a list with an entry for each weapon printed to the console:

['bow', 'axe', ...]

Step 3: Invoke loadfile for the prefixes and suffixes.

from fileutils import loadfile

weapons = loadfile('weapons.txt')
prefixes = loadfile('prefixes.txt')
suffixes = loadfile('suffixes.txt')

Step 4: Finally, loop through the weapon list, select a random prefix and suffix, and print out the combination. Don't forget to import the random module.

import random
from fileutils import loadfile

weapons = loadfile('weapons.txt')
prefixes = loadfile('prefixes.txt')
suffixes = loadfile('suffixes.txt')

for weapon in weapons:
    prefix = random.choice(prefixes)
    suffix = random.choice(suffixes)
    print ("{} {} of {}".format(prefix, weapon, suffix))

You should see something similar to this in your console:

Conclusion

You should now be familiar with writing and executing python modules on your Android device! Add your own prefixes, suffixes, and weapons to roll your equally awesome counterparts to such legendary names as satisfactory cuisses of pain, repressed flail of efficacy, and gesticulating bow of obscurity!

Thanks for reading!

Handling Sounds With HTML5 Canvas

Matthew Odle — Wed, 16 May 2018 00:57:52 +0000

There are two takeaways here: initialize assets and reuse them, and if you want to play event-triggered sounds that could overlap (laser firing, for example), you'll want multiple copies of the asset available.

I learned pretty early to initialize static assets once and then reuse them. The original implementation was adding a new asset for each game object. This meant every laser fired would add another sound to the DOM. As you can imagine, this allows you to figure out the upper limit on the quantity of elements in the DOM pretty quickly.

The solution was to not tie the sounds directly to objects, but rather to create a pool of sounds, then cycle through the pool when a sound was triggered.

Here is the implementation:

https://github.com/modle/centipede/blob/260fa54dadce91f25148638cf1eb10d46ff13dec/app/scripts/sound.js

init() will get called by the loader script, and will loop on the keys of the tracks object, creating the sounds and adding them to the DOM.

To play the sound, we just call playSound() with the type matching the key we want. playSound() will call getSound(), which will use mod to set the target index to the next index, or 0 if previous index was the end of the array. Then the sound element at that index will get returned and played.

Mirroring My Canvas Games Between GitLab and GitHub

Matthew Odle — Tue, 15 May 2018 17:28:13 +0000

I migrated my private projects to GitLab about 2 years ago when we started using it at work. I have nothing against GitHub, but I really like GitLab's interface. The problem is GitHub is THE place to host your stuff if you want others to have easy access to it. This meant I had to maintain two different remotes for every project.

Today, I fixed that.

GitLab's mirror push interface is really easy to use. You can access it via Settings > Repository > Push to a remote repository.

Usage:

Add the GitHub project's URL with the proper credentials to the 'Git repository URL' field
Click 'Update Now'
GitLab will show:
GitHub will show:

Woo.

Sources: