traffloat / traffloat Goto Github PK

View Code? Open in Web Editor NEW

19.0 2.0 0.0 2.21 MB

A cooperative web game of 3D logistics and space city building.

Home Page: https://traffloat.github.io/

License: GNU Affero General Public License v3.0

Rust 95.09% Fluent 4.91%

rust game tower-defense factory-game webassembly web-game webgl 3d-game hacktoberfest

traffloat's Introduction

Traffloat

A 3D traffic, factory, city building, tower defense web game.

Play the game | Rust API docs | Discuss | Report bug

What is this game about?

This game happens in a self-sustaining space colony. The player constructs buildings and corridors in the colony to produce and transfer different resources.

This game is about logistics. Most resources are created from other types with factories. Insufifciency or excess of resources will bottleneck the game.

This game is about traffic. Resources are transferred in different forms (cargo, liquid, gas, electricity, human). Optimize transportation routes to maximize production rate.

This game is about city building. Inhabitants are produced in the colony to boost productivity. Build schools to improve inhabitant skills and unlock new technologies.

This game is 3D. Explore new transportation mechanisms in a genuinely 3D network of buildings. Become a leading architect for 3D cities.

This game is cooperative. Players can join the colonies of other players, or create new colonies and establish trades with existing colonies.

This game involves tower defense. Colonies are attacked by waves of asteroids in the space, which can be propelled or dissolved into raw resources.

Compilation

This project uses Rust nightly-2021-11-17. The toolchain version is automatically installed if you installed Rust with rustup.

This project requites the wasm target for the Rust toolchain. Install it by running the following command inside a traffloat clone:

rustup target add wasm32-unknown-unknown

This project uses just to manage script commands, and trunk to manage WebAssembly and site building. To install these tools:

cargo install trunk just

See the justfile for common commands, in particular:

# Compile the scenario files
just client-scenarios-dev
# Compile the client for production
just client-build

To compile for development mode, use just client-build-dev instead. There is also just client-watch, which compiles the client and start a dev server, and recompiles if files have been modified.

While development build claims to produce "optimized" output, LTO (link time optimization) in release build can further improve performance and reduce file size at the cost of longer compile time. The release build also triggers wasm-opt with optimization level 4, which takes a long time to execute (more than 15 minutes of CPU time).

Contribution

The game is composed of multiple crates:

codegen/codegen-raw: Defines procedural macros used in the game.
types: Defines standard data types of vectors, units and gamerule definition.
types: Defines scenario schema.
common: Implements game world simulation.
client: Implements a web game client.
tfsave-builder: CLI tool to compile scenarios from human-readable TOML files.

Create a thread in Discussions if you would like to contribute and don't know where to start.

traffloat's People

Contributors

Stargazers

Watchers

traffloat's Issues

Create settings menu

Options for rendering.

Rendering perspectives (e.g. #177)
Reticle rendering
Debug information rendering (only available when compiled with that flag)

Add a quit button to quit game and rule editor

For quitting game:

Button next to Save
Hotkey
Ask if auto save is desired

For rule editor:

Add at the bottom of navbar

Cylinder last triangle is wrong

This is because texture position of 1 is passed as 0 due to the cycling vertices.

GameDefinition seems empty

It appears that GameDefinition::default() was used to populate GameDefinition before client::initial initializes it.

Electricity system

Discussed in #156

Generalize reactions and node features

In particular, some node features like pumps need to consume inputs just like reactions. Consider turning these into special features of a reaction instead of features of a node.

Inhabitant motion

For tasked inhabitants, store target and pathfinding in a component
Upon arrival at a node, check if next path is still valid, recompute pathfinding if needed
For idle inhabitants, select random node to go to
For each edge entry, ensure number of inhabitants at starting zone
For each edge exit, check target node capacity. Stay in edge of jammed.
For each entry, exit or jammed exit, recompute velocity of all moving inhabitants in the path.

app/editor/mod.rs: Error case is still reachable

Seems that close hook is not re-rendering in time

Suggested fix: Load into SaveFile before calling new Component

Style type

let style = style! {
    "background-color": "white",
    "border": "black solid",
};

let style2 = style! {
    "padding": "1px 2px",
    ..style,
};

let style3 = style! {
    "color": "red",
    ..style,
    ..style2,
};

html! {
    <div style=style3>
        <span style=style!(..style3, "color": "blue") />
    </div>
}

Liquid pipe entities are initialized correctly in duct editor

Legion needs system dependency

Legion does not currently provide an API to ensure one system is executed before another.

Compute electricity reachability

Need to take cable throughput into consideration

Don't really need to care about resistance, since this also happens IRL

Need to find maximum flow for a flow graph, possibly a modification of EK algorithm

In each simulation frame, transfer liquid across each pipe

TSVT to TSV(B) converter

Currently, vanilla.tsvt is shipped as a text file.

While this is useful for git diff, it is inefficient to transport across the wire. It also creates inconsistency as both TSVT and TSVB are save formats.

It would be a better idea to provide a tsvconv binary that converts between the two formats, and only allow TSVB (without the need to specify the b in the file extension anymore) for the web client.

In display, clamp the liquid storage to their storage constraints, but maintain negative/overflown values in memory.

Sun still renders even if it is behind camera

The sun position is calculated as a vector direction. Need to calculate if it is in front of or behind camera.

Randomize electricity grid graph

As an optional enhancement for #188, buildings that do not receive enough electricity should sometimes get enough of it

Star background looks "weird"

Stars are moving when they are near the screen center. Maybe looks like an inverted sphere?

Construction mechanism

Introduce construction hotkey
Click on node to choose construction base
Menu to select construction target
Click air to select construction location
Render inactivated target
Render menu for construction process
Build corridors
Edit corridors by cross section

Merge happiness with other skills

Lots of code have to handle both happiness and skills separately. It appears that happiness can be generalized as a kind of skill.

Group electricity cables into electricity grid subgraphs

Conversion of cursor coordinates to world coordinate seems not precise

Liquid system

Implement `shape::Unit::between` for `Cylinder`

Unit tests are passing, but the user interaction appears to be incorrect.

Implement resistance and throughput limit for electricity cables

Implement union shapes for buildings

Currently, only sphere, cylinder and cube are implemented. It should not be too difficult to extend the mechanism to accept a union of shapes as the building shape.

Modify definition schema
Update rendering
Update raytracing
Update sunlight casting

View-based ECS

This proposes a major change in the ECS API design.

Motivation

traffloat/common/src/save.rs

Lines 89 to 112 in 7034454

 #[codegen::system(Visualize)] 

 #[read_component(node::Id)] 

 #[read_component(node::Name)] 

 #[read_component(edge::Id)] 

 #[read_component(edge::Size)] 

 #[read_component(edge::Design)] 

 #[read_component(Position)] 

 #[read_component(Shape)] 

 #[read_component(units::Portion<units::Hitpoint>)] 

 #[read_component(cargo::StorageList)] 

 #[read_component(cargo::StorageCapacity)] 

 #[read_component(cargo::StorageSize)] 

 #[read_component(liquid::Storage)] 

 #[read_component(liquid::StorageList)] 

 #[read_component(liquid::StorageCapacity)] 

 #[read_component(liquid::StorageSize)] 

 #[read_component(gas::StorageList)] 

 #[read_component(gas::StorageCapacity)] 

 #[read_component(gas::StorageSize)] 

 #[read_component(defense::Core)] 

 #[read_component(population::Housing)] 

 #[read_component(vehicle::RailPump)] 

 #[read_component(liquid::Pump)] 

 #[read_component(gas::Pump)]

traffloat/common/src/save.rs

Lines 125 to 152 in 7034454

 nodes: <( 

 Entity, 

 &node::Id, 

 &node::Name, 

 &Position, 

 &Shape, 

 &units::Portion<units::Hitpoint>, 

 &cargo::StorageList, 

 &cargo::StorageCapacity, 

 &liquid::StorageList, 

 &gas::StorageList, 

 &gas::StorageCapacity, 

 )>::query() 

 .iter(world) 

 .map( 

 |( 

 entity, 

 &id, 

 name, 

 &position, 

 shape, 

 &hitpoint, 

 cargo, 

 &cargo_capacity, 

 liquid, 

 gas, 

 &gas_capacity, 

 )| {

The huge amount of component reads makes the code too verbose. It is easy to forget some component reads too.

Guide-level explanation

Consider this original system:

fn create_entity(
    buf: &mut CommandBuffer,
    drag: Drag, boost: Boost, stuff: Stuff,
    position: Position, velocity: Velocity, size: Size, more: More, unused: Unused,
) {
    let child = buf.push((
        drag, boost, stuff,
    ));
    buf.push((
        position, velocity, size, ChildRef::new(child), more, unused,
    ))
}

#[codegen::system(Simulation)]
#[write_component(Position)]
#[read_component(Velocity)]
#[read_component(Size)]
#[read_component(ChildRef)]
#[read_component(Drag)]
fn simulate(world: &mut SubWorld) {
    let query = <(&mut Position, &Velocity, &Size, &ChildRef)>::query();
    let (mut query_world, entry_world) = query;
    for (pos, vel, size, child) in query.iter_mut(&mut query_world) {
        *pos += compute_delta(vel, size, child, &entry_world);
    }
}

fn compute_delta(vel: &Velocity, size: &Size, child: &ChildRef, world: &SubWorld) -> Vector3 {
    let entity = world.entry_ref(child.entity).unwrap();
    let drag: &Drag = entity.get_component::<Drag>().unwrap();
    let boost: &Boost = entity.get_component::<Boost>().unwrap();
    *vel * *size - *drag * *boost
}

We want to write the code like this instead:

#[derive(codegen::ComponentSet)]
pub struct Parent {
    pub position: Position,
    pub velocity: Velocity,
}
#[derive(legion::ComponentSet)]
pub struct ParentMeta {
    pub size: Size,
    pub more: More,
    pub unused: Unused,
}
#[derive(legion::ComponentSet)]
pub struct Child {
    pub drag: Drag,
    pub boost: Boost,
}

fn create_entity(buf: &mut CommandBuffer, parent: Parent, meta: ParentMeta, child: Child, stuff: Stuff) -> Entity {
    let child: Entity = buf.push_sets((child,))); // push_sets(x: Set<Set<Comp>>) = push(union(x))
    let child_ref = ChildRef::new(child);
    buf.push_sets_comps((parent, meta), (child_ref,)) // push_sets_comps(x: Set<Set<Comp>>, y: Set<Comp>) = push(union(x) union y)
}

#[derive(codegen::ComponentSetView)]
#[view(Parent)] // verify that fields are from Parent
struct SimulationParentView<'t> {
    position: &'t mut Position,
    velocity: &'t Velocity,
}
// autogenerate static assertions to verify that `*SimulationParentView.position` and `Parent.position` have the same type

#[derive(codegen::ComponentSetView)]
struct SimulationView<'t> {
    #[view(subview)] // recurse into a subview
    parent: SimulationParentView<'t>,
    #[view(type Parent)] // verify from Parent like above
    size: &'t Size,
    #[view(~)] // skip verification, this is a standalone component
    child: &'t Child,
}

#[codegen::system]
pub fn simulate(mut query: ViewQuery<SimulationView>, entry: ViewEntry<DeltaChildView<'_>>) {
    for view in query.iter_mut() {
       *view.position += compute_delta(view.project(), entry);
    }
}

#[derive(codegen::ComponentSetView)]
struct DeltaParentView<'t> {
    #[view(type Parent)]
    velocity: &'t Velocity,
    #[view(type Parent)]
    size: &'t Size,
    #[view(~)]
    child: &'t Child,
}

#[derive(codegen::ComponentSetView)]
#[view(type Child)]
struct DeltaChildView<'t> {
    drag: &'t Drag,
    boost: &'t Boost,
}

fn compute_delta(parent: impl Project<DeltaParentView<'_>>, entry: ViewEntry<DeltaChildView<'_>>) -> Vector3 {
    let child = entry.for_entity(*parent.child);
    *parent.vel * *parent.size - *child.drag * *child.boost
}

Future enhancement

If typeof and named type arguments are implemented in Rust, we can have a macro to autogenerate view macros.

trace_entity does not need to run every frame

It should only run when camera or cursor position is moved.

Inhabitant system

Store parent node/edge of each inhabitant
Store subnode position of each inhabitant as a point relative to node center
Store subedge position of each inhabitant as a function in the form p(t) = p0 + v (t - t0)
Render inhabitants
Skip inhabitants when zoom is sufficiently large
Store inventory for each inhabitant

Support cylinder-shaped nodes

Implement shape::Unit::contains
#151
Implement shape::Unit::bb_under
Adapt cylinder position/normal buffer for node rendering
Add cylinder texture type
- curve.svg: f(x, y) = (cos 2x pi, sin 2x pi, y)
- top.svg and bottom.svg: f(x, y) = (x, y, 0 or 1), area beyond unit circle unused
Check other places hardcoded with shape::Cube

Unit test game systems

Most systems are untested right now. In particular, we need unit tests to ensure that #[read_component] and #[write_component] are correctly added. It is so easy to forget this.

`just pp` does not exit with error

https://github.com/traffloat/traffloat/pull/193/checks?check_run_id=3318856961#step:8:1221

Construction tasks

Implement corridor editor for ducts

- Add a component to store ducts
- Implement an SVG-based interface to display ducts
- Add button in edge preview to open duct viewer.
- #212
Add entities based on duct design
- Rails
- Pipes
- Cables
- Gas diffusion

Implement buttons to draw ducts

Liquid distribution perspective.

Cache uniform locations

Do not keep calling getUniformLocation on the webgl context.

Cache uniforms locations
Cache attribute locations

Recompute electricity grid only if graph structure changed

Use a better file extension

.tsv means "tab-separataed values" (similar to csv). This extension is too common and needs to be changed.

Cargo system

Store cargo count of each type in each node
Implement data structure to search and count cargo
Implement perspective that renders cargo availability

Game saves

Save data
Load data
Make editing schema easier, don't use numeric IDs (see also #157)

Discussed in #155

^{Originally posted by SOF3 July 27, 2021}

Things to store

Game definition
Game time
Node state
Edge state

Serialization formats

Binary-based format for transferring, e.g. MsgPack
Text-based format for source control, e.g. YAML