What's everyone working on this week (42/2018)?


New week, new Rust! What are you folks up to?

What's everyone working on this week (18/2018)?

During the last few weeks I:

Wrote the first issue of “Новости Rust” (“Rust news”) - a monthly digest about Rust’s ecosystem to promote Rust in the Russian programming community.

Worked on Zemeroth game:

  • Implemented hit chances. Added attack_accuracy and dodge stats to Agent component and used these fields for some basic hit chances math.

    Attacks with strength > 1 have additional hit chances - with reduced damage (each strength point gives 10% hit chance improvement).

    Wounded agents become less accurate.

    Hit chances demo

  • Updated objects’ placement logic: agents are now created on the different “lines” described in the scenario (using enum Line { Any, Front, Middle, Back }). This prevents Imp Summoners from being created only a tile away from enemies and thus not having any chances to survive.

    A screenshot of a test scenario with lots of demons to make the lines visible.

  • Updated Poison passive ability: it can’t, by itself, kill an agent anymore. “Poisoned” status is removed when a target’s strength is reduced to 1. This should make battles a little bit less frustrating and more dramatic.

  • Updated ‘Summon’ ability: Each use of it now creates one more imp (up to 6). It should force the player to be more aggressive.

  • Removed some data duplication from the .ron config with objects descriptions using serde’s default annotations and helper init functions.

Still working on a campaign mode with a carryover of the fighters from one battle to the next.


Porting my very early “space dwarf fortress” game from piston to ggez which made it easy to drop a star field shader in for fun (need to replace it with something handwritten) and hopefully should make the code more maintainable.

Uses specs, imgui, ggez, and the oryx sci-fi tileset.


mostly worked on my CTF game; there’s some initial levels, i wrote an introduction, the debugger/emulator is starting to be somewhat usable, made an importer for REXPaint files (going to open source that), and have a working WebAssembly terminal shim (thanks to web-sys and wasm-bindgen), so it was possible to play it on the web !

which is not that useful without a server-side for a leaderboard and such, and asset management also needs to be rewritten, but found it pretty neat to have it running in a browser, just like that :slight_smile:


I’m adding Windows support to Rutie — The Tie Between Ruby and Rust.


Still working on path arithmetic for FlowBetween’s flo_curve crate. It’s mostly working, which means I’m probably 40% done. I’ve hooked it up to the selection ‘ghost’ renderer so it’s possible to actually see what’s happening by dragging things around.

Simple cases like this are working great:


However, FlowBetween really encourages a much more - painterly, I suppose - style of working, which tends to result in some really complicated input paths, like this (with control points highlighted):


Dragging this exposes a few bugs with the algorithm (I’ve turned off an optimisation here to reveal more glitches than might otherwise appear):


It’s closer than it might look: the glitches are pretty much all cases where an edge is missed by my ray casting algorithm (which results in an exterior edge being marked as interior, generating a straight line when the ‘bad’ path is closed). So I’m hoping to fix this over the next week or so: there are two remaining cases I know of that generate this condition - ray intersects a curve on a tangent and an interior point that’s an intersection.

I’m planning to use this a lot in FlowBetween: to make frame-by-frame rendering faster, for generating the output SVG and for tools like a lasso and paint bucket (and the eraser, come to think of it).


I worked mainly on two issues this week:

  1. NURBS patches (see issue 65)
  2. Fixing motion blur (see issue 66)

There is also a basic exporter for Blender, which I use to create simple scenes for certain renderer features I’m working on:


Worked on reducing number of double compilations (multiple versions of the same crate being built), by bumping dependencies of a number of crates:

Also, halfway through implementing enum deserialization from TOML (PR), so you can deserialize this:

my_enum = [
    { Plain = {} },
    { Tuple = { 0 = 123, 1 = true } },
    { NewType = "value" },
    { Struct = { value = 123 } }

for this type:

#[derive(Debug, Deserialize)]
struct Config {
    my_enum: Vec<MyEnum>,

#[derive(Debug, Deserialize)]
enum MyEnum {
    Tuple(i64, bool),
    Struct { value: i64 },