Environment Tile Studies

Josh Antolovic

2022-26

Four years of asking what makes an abstracted, repeated tile grid read as a believable environment, culminating (so far) in a live Unity tool that generates, animates, and paints tiles in one loop, and a simulation where the grid finally behaves like a place.

Role: Solo (concept, code, tools, and artwork)

Tools: p5.js, Unity, Houdini, Aseprite, pen plotter, printmaking & mixed media, colored pencil, LOVE2D (planned)

Themes: technical art, procedural generation, environment art, creative direction, tools & pipeline development, cross-media translation (procedural ↔ physical ↔ hand-drawn)

At a glance:

A family of custom Unity tile generators (brick, water, ground, flower, tree), culminating in a Tilemap Painter and Tile Behavior Editor that close the loop: generate, animate, and paint, live, inside one tool
A self-running simulation where green and asphalt tiles trade territory indefinitely
The same tile motif carried across six-plus mediums I've worked in, from editor scripting to printmaking to pen-plotter-assisted colored pencil
Includes the unfinished ideas and tool experiments that didn't pan out, not just the polished outcomes
Primarily technical art and creative direction work, not a systems or mechanics design case study

The Question (2022)

What makes a flat, repeated grid of 16-pixel tiles feel like a living place? Games like Pokémon Gold, Silver, and Crystal built entire worlds out of a small vocabulary of ground tiles, repeated constantly and limited to a handful of colors, and somehow it worked. I started this project trying to understand why.

My first experiments were small and procedural: a p5.js algorithm I built generated grids of 8x8 tiles, collaged into palettes to browse and curate from. Each version tested a different constraint: full color capped at three hues per tile (matching the Game Boy Color's actual limitation), then black and white, then narrower moods built around a single pairing: green and red, brown and tan, green and black. The constraint was the point. Working inside such a narrow range made it obvious to me how much of "realism" here was really about the relationship between colors and patterns.

Around the same time, I took the question off the screen and into a physical art object: an iPad mounted on a small kiosk stand, where touching the screen made a water drop fall and, eventually, a green tile take root. This piece was genuinely interactive. I explored the inverse in a related study, as a static image rather than an interactive piece: a grid of concrete and asphalt tiles being overtaken, or held back, by green growth, tracked with a minesweeper-style board of hidden growth points, a sketch of the idea rather than something built to be played. Both pieces asked the same question as the palette work: what does it take for something abstract and repeated to read as environment, not just pattern? (The green-vs-asphalt idea returns later in this study as a full simulation.)

First Maps, By Hand (2023)

With a curated set of tiles in hand, my next question was what to build with them. Starting in January 2023, I began a daily practice: one map a day, assembling curated tiles from the p5.js work into small Game Boy-style layouts: paths, rooms, water crossings, biome transitions. The practice ran through January into February and produced enough material to show the range the tile vocabulary could support: dense dungeon-like interiors, open winding paths, small resource clusters.

Building the Tool, v1: A Family of Generators (summer 2023)

By summer 2023, curating tiles by hand (generating in p5.js, exporting to Aseprite, arranging into maps) had become a bottleneck for me. A map or two took a few hours, and I needed the process to move faster than that. With ChatGPT's help translating the algorithmic logic into Unity's editor scripting, I collapsed a workflow that had lived across two separate pieces of software into one: p5.js's generative logic, rebuilt to run natively inside Unity.

What I built wasn't a single tool but a small family of them, each targeting one tile type with its own generation logic: a brick generator built on layered noise, aggregating into two-color patterned ground; a water generator that expanded from a simple three-color palette toward something meant to suggest shifting light on the surface; a ground generator combining noise with weighted random colors; a flower generator built from layered circular shapes rather than noise; and a tree generator that ended up reading more like a totem pole than a tree. In parallel, I ran a related experiment layering small non-repeating "soil" tiles at 8x8 into patchwork sheets, with different soil types placed edge to edge rather than generated as one continuous texture.

Lorem Ipsum...

To be precise about what version 1 actually produced: each generator saved its curated output to a folder, building a growing library of individual tiles, but I hadn't assembled any of it into a tilemap yet. That bridge became version 2.

Carrying It into Houdini (spring 2024)

Before building that bridge, I tested the established ideas against a different tool entirely. In spring 2024, I brought the flower generator from summer 2023 into Houdini, rebuilt and taken further, another attempt at carrying an established idea into a new tool. Still built from layered circular petal shapes, it was now animated through a full growth cycle, from a single sprout to a stem to a bud to a bloom, captured as a sprite sequence rather than a single static output. Parameters like petal radius, division count, and uniform scale controlled the shape directly, closer to a proper procedural asset than my earlier Unity version had been.

That same semester, I also ran two smaller experiments that explored the edges of the idea rather than extending it: layering vector lines directly on top of the tile grid (tried, then set aside), and a mockup of what the tilemap and its assets might look like held in someone's hands, rendered onto a handheld device screen.

Building the Tool, v2: From Tiles to Tilemap (summer 2024)

The unresolved question from version 1 finally got an answer: could I get the tile generators to paint directly into a tilemap, rather than just saving individual tiles to a folder? In summer 2024, I extended the same generator logic from 2023 and built the missing bridge. A generator panel controlled palette, color weighting, and live preview, much like in 2023, but now sat alongside a Tilemap Painter component that could paint the generated tile straight into the scene at a chosen brush size and tile type.

A second piece, a Tile Behavior Editor, added a layer my earlier generators never had: tiles could now be animated, looping or ping-ponging through a sequence of frames, and made interactive, changing on step and reverting after a delay. This tool didn't yet have any data-driven properties: no nutrients, moisture, or temperature deciding what grew where, since that was still only a concept for me, not something built. What it did have was the full loop I'd been reaching for since 2023: generate, animate, and paint, all inside one tool, live.

The Simulation: Green versus Asphalt (fall 2025)

When I came back to this project in fall 2025, it was with a piece that could finally hold time inside itself: a simulation where green and asphalt tiles traded territory on their own, animating rather than sitting static. Green drifted and shifted at the edges, got slowly overtaken by black asphalt, and the asphalt itself eventually cracked and crumbled, letting green reclaim the ground, a cycle that could run indefinitely rather than resolving into one final image. The static minesweeper-style study from 2022 had become a living system.

Off Generation: By Hand (2023, 2025-2026)

Twice in this study, the tile motif has left the screen entirely, and the two moments bookend it.

Spring 2023 was the first: the motif as a stamp kit, through a stencil, layered with paint and actual dried grass and straw. Where the digital maps built the tile vocabulary through curation and assembly, this stretch asked me a more material question: what does the pattern become once it has grain, tear, and texture, once it's something pressed into paper by hand rather than generated. A house-shaped stencil covered in a green pixel-tile print, small stamped grid studies colored in with pencil, and mixed-media panels built around dried grass and straw all came out of this period.

The second came in 2025 and 2026: tile studies finger-drawn directly on an iPhone art app rather than generated or coded. A spiral motif tessellated across a grid, water-related compositions built from blocky geometric shapes, checkerboard and striped tile arrangements in mixed palettes, and a small looping tile animation.

The clearest piece of this hand-made turn came at the very end of spring 2026, and it's one of the few places where the digital and the hand-drawn sit directly on top of each other on the same page: I used a pen plotter to produce a light trace of a tile, then colored it in by hand with colored pencil and compiled it into a sixteen-frame animated waterfall. The piece is still in progress, the most recent work in this entire study.

What’s Next

My next step, not yet built, is a tool for LOVE2D (or something similar) that approaches the whole problem from the opposite direction of everything before it. Every generator I've made so far, from the Unity tools in 2023 to the procedural tile painter in 2024, worked forward: generate a tile, then decide what to do with it. I want the next tool to work backward instead, starting with decisions about the tileset itself, color palette, tree types, stone types, footpath variants, before ever touching a map. Only once those pieces exist would it move to laying out a map and choosing its properties: field objects, barriers, battle tiles, and whatever else a given map calls for.

Whether this becomes a personal tool or something I release as a shippable library is still an open question for me. What's settled is the order of operations: build the pieces first, then build the world they go into.

Once a working version exists, I want to put it in front of other game designers, not just use it myself. Watching where the interface confuses someone who didn't build it, and revising the UX and UI based on what actually trips people up, feels like the real second half of this project: the part where the tool stops being mine alone and starts being something other people can pick up and experiment with.

@joshantolovic

Index Next →