The following article serves as a comprehensive developer log for the first three days of building Malevolent Planet, a 2D top-down survival game in Unity. Malevolent Planet: Unity 2D Development Log (Day 1 - Day 3)
Developing a survival game requires a delicate balance between atmosphere and mechanics. In Malevolent Planet, the player is stranded on a hostile alien world where the environment itself is the primary antagonist. Day 1: Project Setup and Movement Mechanics
The focus for Day 1 was stability and "feel." A survival game fails if the character movement feels sluggish or unresponsive. Core Architecture
Universal Render Pipeline (URP): Established the project using URP to take advantage of 2D Lights and Shadows, which are essential for the "malevolent" atmosphere.
Folder Structure: Organized the project into Scripts, Prefabs, Sprites, and ScriptableObjects to ensure scalability. Player Controller
Rigidbody2D Physics: Implemented a FixedUpdate movement system to ensure smooth collisions with alien flora.
Input System: Integrated the New Input System package for easier porting and rebindable keys.
Flip Logic: Created a simple script to flip the player sprite based on the mouse position, ensuring the character always faces the threat. Day 2: The Hostile Environment and Procedural Generation
On Day 2, the goal was to make the "Planet" part of the title come to life. A static map feels predictable, so a basic procedural system was introduced. Tilemap Systems
Rule Tiles: Used Unity’s 2D Extras to create Rule Tiles for the alien terrain. This allows the ground textures to automatically connect, saving hours of manual painting.
Hazard Spawning: Developed a Spawner script that uses Poisson Disc Sampling to distribute "Malevolent Spores" across the map without them overlapping awkwardly. Environmental Hazards
Damage Zones: Created a generic Hazard script. If the player stays within a certain trigger area (like a toxic gas cloud), they take incremental damage over time. malevolent planet unity2d day1 to day3 public link
Visual Feedback: Added a simple shader graph effect that makes the screen edge pulse red when the player is in danger. Day 3: Resource Management and UI Foundation
Survival isn't just about avoiding death; it’s about managing scarcity. Day 3 focused on the player’s vitals. The Survival Manager
ScriptableObjects: Used ScriptableObjects to store player stats (Health, Oxygen, Battery). This makes it easy to balance the game later without digging through code.
Oxygen Decay: Implemented a constant drain on the Oxygen stat. The player must find "Air Pockets" or "Refill Stations" to survive. User Interface (UI)
Dynamic Bars: Created a UI Canvas with sliders that update in real-time based on the Survival Manager’s data.
Inventory Prototype: Built a basic grid-based inventory system to hold scavenged alien scrap. Public Project Link
You can follow the real-time progress, view the source code, and test the latest WebGL builds via the public repository link below:
[Link: Malevolent Planet - GitHub Repository / Playable Alpha]
(Note: Ensure your browser supports WebGL 2.0 for the best experience during the Day 3 build.) What’s Next?
With the foundation built, Day 4 will focus on Enemy AI and the Day/Night Cycle, where the planet becomes significantly more aggressive once the sun goes down. To help you get the most out of this project, let me know:
Do you need help setting up the URP 2D lights used in the project? The following article serves as a comprehensive developer
I can provide code snippets or setup guides for any of these areas.
It sounds like you're referring to a Unity 2D project (possibly a game or interactive experience) titled "Malevolent Planet" with a focus on Days 1–3 of gameplay or development, and you're looking for a public share link.
Since I can’t generate live URLs or host files, I can help you produce a descriptive text that explains what the project is, how to access a public link (if you have one), and what content is covered for Days 1–3. Below is a template you can use or adapt for your game’s release page, forum post, or devlog.
.exe or .appAdvanced Unity2D Mechanic: The game uses a "Dynamic Tilemap" system. On Day 2, specific tiles (grass, mud, stone) swap their collision masks every 15 minutes. If you suddenly clip through the floor, jump immediately—you are falling through a tile that just dematerialized.
Final day focused on feedback and deployability.
Added:
Polishing (juice):
WebGL export settings:
Public link (simulated):
👉 Play "Malevolent Planet" Prototype – Days 1-3 Build
(Replace with actual Itch.io or GitHub Pages link)
E on wreckage parts. You need 5x Scrap Metal.Warning: Many search results for this keyword lead to malicious fake downloads. Below is the correct method to access the legitimate link.
As of this writing, the official public link is distributed through the following channels: How to Run the Project
#public-builds channel regularly pins the Day 1 to Day 3 public link. Look for messages from the role @Developer.Direct Access Note: Due to the dynamic nature of public links, the raw URL changes every few weeks to prevent link-harvesting bots. Do not trust random Reddit posts claiming a static Dropbox link. Always verify the file hash (MD5) or download directly from Itch.io.
Unity 2D with Tilemaps forms the ground. I used a Rule Tile for varied terrain (dirt, corrupted patches, magma cracks). The malevolence is driven by a PlanetController singleton that manages global hostility.
Key components Day 1:
Tilemap for ground.PlayerController (rigidbody2D, collider, basic movement).HazardSpawner – spawns hazards every 5–10 seconds within camera view.Hazard types (ScriptableObjects):
MagmaVent – damages player on contact.CorruptionPuddle – slows player and deals DOT.LivingVine – extends from ground, pulls player.Code snippet – Hazard spawning:
public class HazardSpawner : MonoBehaviour public GameObject[] hazards; public float spawnIntervalMin = 5f, spawnIntervalMax = 10f;void Start() StartCoroutine(SpawnRoutine()); IEnumerator SpawnRoutine() while (true) yield return new WaitForSeconds(Random.Range(spawnIntervalMin, spawnIntervalMax)); Vector2 spawnPos = GetRandomGroundPosition(); Instantiate(hazards[Random.Range(0, hazards.Length)], spawnPos, Quaternion.identity); Vector2 GetRandomGroundPosition() // Raycast from random x at top of screen to find ground float randX = Random.Range(-Camera.main.orthographicSize * Camera.main.aspect, Camera.main.orthographicSize * Camera.main.aspect); RaycastHit2D hit = Physics2D.Raycast(new Vector2(randX, 10f), Vector2.down, 20f, LayerMask.GetMask("Ground")); return hit.point;
End of Day 1: Basic hostile planet with spawning hazards. Public build: [Day1 build link placeholder].
The first day is dedicated to establishing the foundation of the game. The focus is on the Unity interface and basic 2D physics.
The developers have kept the final game behind a Patreon or Itch.io paywall, but promotional events occasionally unlock a public link for the Day 1–3 segment. This allows new players to experience the core loop before committing to a purchase.