Community Project Main Features

[Frogpants]

Gameplay, Editor, World, Rendering, Multiplayer Systems

Player Movement System

Handles player translation, room transitions, and camera tracking.

player.pos += velocity * deltaTime;
camera.pos = player.pos;

Room-aware sync:

multiplayer.sync(player.pos, player.room, player.room);

Collision-aware movement:

moveWithCollisionMarkers(player, markers);

---

Room System

Rooms organize world space and determine spawning, rendering, and transitions.

Room-aware spawning:

spawnTreeOnMarkerForRoom(marker, currentRoom);

Room filtering during rendering:

if (marker.room == player.room)
{
    drawTreeSpawnMarkerTile(marker);
}

Room-linked door placement:

makeDoorForRoom(currentRoom, nextRoom);

---

Door Progression System

Doors connect rooms and trigger stage transitions.

Door creation:

Door d;
d.roomA = roomA;
d.roomB = roomB;
doors.push_back(d);

Stage transition trigger:

spawnNextStage();

Door rendering:

Renderer::DrawDoor(door.position);

---

Task / Objective System

Tasks drive progression and multiplayer synchronization.

Task progress serialization:

SerializeTaskProgress(objectives);

Remote update handling:

ApplyRemoteTaskProgressState(progressData);

Task placement override:

ApplyTaskPositionOverride(taskIndex, newPosition);

Task completion trigger:

if(task.completed)
{
    spawnNextStage();
}

---

Multiplayer Player Sync

Synchronizes player position and room state.

Position sync:

multiplayer.sync(player.pos, player.room, player.room);

Remote player update:

remotePlayer.pos = packet.pos;
remotePlayer.room = packet.room;

Snapshot-based updates:

ApplyRemoteTaskProgressState(remoteState);

---

Multiplayer Task Sync

Shares objective progress across players.

Transmit progress:

multiplayer.setTaskProgress(taskIndex, completed);

Apply remote completion:

objectives[i].completed = remoteState[i];

Stage trigger from shared progress:

if(allTasksComplete)
{
    spawnNextStage();
}

---

Tile Placement Editor

Handles runtime tile placement and deletion.

Tile placement:

tiles.push_back(Tile(mouseGridPosition, tileType));

Tile deletion:

eraseTileAt(mouseGridPosition);

Tileset selection:

tilesetTile = selectedTileIndex;

Atlas tile rendering:

drawFromSheet(tilesetTexture, tileIndex);

---

Platform Tile System

Places platform atlas-based geometry.

Platform placement:

platformTiles.push_back(Tile(mouseGridPosition, platformTile));

Platform rendering:

drawFromSheet(platformTexture, platformTile);

---

House Tile System

Supports prefab house placement and tileset-based construction.

Prefab placement:

drawHousePrefab(prefabID, position);

Tileset placement:

drawHouseTilesetTile(houseTileIndex, position);

Prefab rendering:

Renderer::DrawHouseTile(tile.texture, tile.position);

---

Task Placement Editor Mode

Allows dragging and repositioning objectives.

Drag detection:

if(editorTaskPlacementMode)
{
    objectives[i].position = mouseWorldPosition;
}

Override persistence:

SaveTaskPositionOverrides(objectives);

Reload overrides:

LoadTaskPositionOverrides(objectives);

---

Marker System

Supports special-purpose tiles used for spawning and collision.

Tree spawn marker placement:

markers.push_back(TreeSpawnMarker(mouseGridPosition));

Collision marker placement:

markers.push_back(CollisionMarker(mouseGridPosition));

Marker rendering:

drawCollisionMarkerTile(marker);

---

Tree Spawn System

Spawns props based on marker positions.

Marker detection:

spawnTreeOnMarkerForRoom(marker, currentRoom);

Tree creation:

spawnedTrees.push_back(TreeProp(marker.position));

Tree rendering:

Renderer::DrawTree(tree.texture, tree.position);

---

Collision Marker System

Uses marker tiles as blocking geometry.

Collision detection:

collidesWithCollisionMarker(player, marker);

Movement constraint:

moveWithCollisionMarkers(player, markers);

Marker filtering:

if(marker.room == player.room)
{
    applyCollision(marker);
}

---

Tile Atlas Rendering

Draws tiles from packed textures.

Atlas lookup:

drawFromSheet(textureAtlas, tileIndex);

Texture coordinate mapping:

float u = (tileIndex % columns) * tileWidth;
float v = (tileIndex / columns) * tileHeight;

Quad rendering:

glBegin(GL_QUADS);

---

House Prefab Rendering

Draws multi-tile structures.

Prefab iteration:

for(auto& tile : prefab.tiles)
{
    drawHouseTilesetTile(tile.index, tile.position);
}

Prefab placement:

placeHousePrefab(prefabID, worldPosition);

---

Main Menu System

Handles entry screen rendering and transitions.

Menu draw:

UI::DrawMainMenu();

Menu exit condition:

if(startPressed)
{
    inMainMenu = false;
}

Scene transition:

enterGameplayScene();

---

Procedural World Generation

Creates room layouts and stage structure.

World generation call:

genWorld(worldDimensions);

Room allocation:

rooms.push_back(Room(position));

Connectivity:

connectRooms(roomA, roomB);

---

Stage Progression System

Triggers environment transitions after objectives complete.

Completion detection:

if(allTasksComplete)
{
    spawnNextStage();
}

Stage creation:

spawnNextStage(currentStageIndex);

Door linking:

makeDoorForRoom(stageA, stageB);

---

Task Position Persistence System

Stores custom editor placements.

Save overrides:

SaveTaskPositionOverrides(objectives);

Load overrides:

LoadTaskPositionOverrides(objectives);

Apply override:

ApplyTaskPositionOverride(taskIndex, position);

---

Immediate Mode Rendering Pipeline

Handles debug geometry and tile visualization.

Marker rendering:

glBegin(GL_LINE_LOOP);

Tile rendering:

glVertex2f(x, y);

Finalize geometry:

glEnd();

---

Input Handling System

Processes gameplay and editor input.

Key detection:

Input::IsPressed("t");

Editor toggle:

mode = !mode;

Tile selection:

tile = selectedTile;

Task placement toggle:

editorTaskPlacementMode = true;