Skip to main content
100%

asp map generation with connectivity constraints

✓ Published0🌍 Public
Aaman-tiwari
Last edited Nov 20, 2017
Created on Nov 20, 2017

An Answer Set Programming (ASP) constraint solver generates a 5x5 tile map where each cell is assigned a path tile (straight, corner, plus, or empty), subject to edge-matching and global connectivity rules. The visualization renders the resulting tile grid and highlights edges between walkable adjacent tiles, using the ASP solver to enforce that all tiles appear and that the top-left and bottom-right corners are connected through a continuous path.

AI-generated description

Similar vizzes

Loading thumbnail…

wfc with edge labels in clingo

This visualization generates a 3×3 tile grid using Answer Set Programming in Clingo, where each cell is assigned a tile pattern (straight, corner, or empty) with edge labels indicating path or empty connections. The grid must satisfy adjacency constraints so that neighboring tile edges are connectable, and every pattern appears at least once. The logic program defines tile rotations, legal neighbor relationships via the `legal/4` predicate, and enforces consistency through integrity constraints. The example demonstrates constraint-based procedural generation of a complete, valid wfc-style layout without external rendering libraries.

Aaman-tiwari
62% match
Loading thumbnail…

wfc in clingo?

This example shows a constraint-solving approach to generating a grid of tiles, where each cell is assigned one of two patterns (a or b) so that adjacent cells follow a set of legal pairings. It encodes the Wave Function Collapse algorithm as an answer-set program in Clingo, using a 5×5 grid defined by `cell(1..n, 1..n)` and rules that generate exactly one assignment per cell. The constraints check every adjacent pair via `dx` offsets and forbid any neighbor combination not listed in the `legal` facts. The output is the `assign/3` relation, which reveals the resulting tile layout.

Aaman-tiwari
55% match
Loading thumbnail…

TATUBAAR - map thumbnail

This interactive map editor displays a grid-based game map, where colored cells represent character spawn points for different teams, grey cells are obstacles, black cells are holes, and white cells are walkable terrain. The visualization parses a plain-text string into a grid of cells and renders them using D3.js v4 with SVG rectangles, assigning colors from a categorical color scale. The map layout is defined by an eight-by-eight grid, and the interface includes a separate rendered character sprite with its own SVG definition.

BBrunoDumas
51% match
Loading thumbnail…

TATUBAAR - map creator

This map creator lets users design a grid-based game board by clicking cells to cycle through terrain types: walkable, obstacle, hole, and character spawn. It uses D3 v4 to render the SVG grid and handles click events to update cell content. The code includes save functionality to export the map, and it visualizes spawn points by cloning a character icon from an SVG file loaded via `d3.xml`. Cell colors are mapped with a categorical color scale, and the interface includes a toolbar with instructions.

BBrunoDumas
51% match
Loading thumbnail…

graph

This interactive HTML visualization demonstrates a Smart Adaptive Emergency Routing System on a 20-node grid. It shows how different navigation algorithms (Adaptive Dijkstra, Adaptive A*, and Static Dijkstra) find paths between user-selected source and destination nodes under various scenario conditions, including heavy traffic, bad weather, and accidents. The system displays the computed route directly on an SVG canvas, with edge weights and blocked routes dynamically adjusted based on the selected scenario. The interface uses HTML select elements, buttons, and JavaScript to recompute paths, while the SVG rendering and CSS styling provide a dark-themed network map.

RRuchithaSriSaiValliThanmayPotladurthy@my.unt.edu
50% match
Loading thumbnail…

Prims Algorithm

This animated canvas visualization demonstrates Prim’s algorithm for generating a spanning tree on a 900×600 grid. A web worker computes the maze structure using a minimum-heap priority queue, randomly selecting edges to connect cells. The animation then floods the resulting tree from its root, using D3’s Cubehelix color scale to map hue to Manhattan distance from the root. The canvas rendering updates in timed intervals, creating a smooth color wave that reveals the tree’s structure.

Aadamhurst
50% match
Loading thumbnail…

Cellular automata

A one-dimensional cellular automaton stands at the center of this visualization, which arranges all 256 possible nearest-neighbor rules in a grid. The display uses a tile-based procedural map via Polymaps, with a worker script (`cell-worker.js`) computing each rule’s evolution from a random initial state. Color intensity indicates cell state, and zooming reveals the structure of individual rules. The rendering leverages Polymaps’ `po.map`, `po.procedural`, and `po.hash` APIs, while the worker handles the pixel-level computation and postMessage communication, following the example from MathWorld.

Mmbostock
50% match
Loading thumbnail…

Better-Only Search

A maze is generated using random traversal, then solved with “better-only search,” a best-first search variant restricted to north and east moves. The canvas renders the maze as a white grid on black, with gray fill marking explored cells and magenta highlighting the current best path. The solver uses a min-heap frontier and animation via d3.timer, updating ten cells per tick to show the search progression toward the goal.

Mmbostock
49% match