I’m testing new gameplay footage from MMO Studio, my 2D online RPG engine built for creating multiplayer RPGs with RPG Maker-style workflows and MMO-ready systems.

This trailer-style test shows early gameplay movement, world exploration, combat, pets, enemies, and the overall feel of a live online RPG world. MMO Studio is designed to let creators build their own multiplayer RPGs with tools for maps, quests, NPCs, items, combat, pets, crafting, and more.

This is still a work-in-progress gameplay test, but it shows the direction MMO Studio is heading: making online RPG creation easier, faster, and more accessible for indie developers.

Try MMO Studio here:
https://mmo.ed5enterprise.com/

I never really saw the point in making a GDD a big detailed thing down to the color of things and such, and I still think that it's mostly over the top but I know it's still useful, especially for big production projects, tho as a solo dev, I find it more of a waste of time for most things. I don't need to coordinate 20+ people for the art style and gameplay feel, I'm just doing it so what's the point right?

But these days I found myself trying to define some complex architecture about some behaviors, handling and how should certain things exist and be able to interact, and especially how it should be defined and how to use said definition. I was writing down a bunch of small "ruleset" of things and I realised this kind of looks like a GDD, it's missing images, graphs and explanations on why, what, where and all that, but I have the how.

So what do you think, does this count as a GDD or is it just some architecture notes that have nothing to do with a GDD?

"GDD" pastebin Link:

https://pastebin.com/SULNViuP

"GDD" Pasted as code block:

#region Misc
/*
 * Things should always have a cost, the heat death of the universe might very well be coming
 * Things should always have at least one defining feature to make themselves stand appart
 * Things should always "make sense"
 * 
 * Impact calculation:
 *  Impact Force = Difference between 1st and 2nd source
 *  Impact Multiplyer = Source velocity / Impact Force (Multiplyer results in damage received and potential ressources effect potency
 *      Ex: (1st = -1 vel) (2nd = 3vel) Impact Force = 4 (1st Multiplyer = 4/1 = 4) (2nd Multiplyer = 4/3 = 1.33)
 * 
 */
#endregion
#region Components
/* 
 * Components defined by graphs:
 *  Logic Gate Entry like OnTick, OnImpact etc...
 *  Logic nodes will compose logic chain processors
 *  Logic chains will have entry points as nodes
 *  Logic processing from entry event node to resolution (Consumation, production etc...)
 *  Possibility for conditional activation logic
 *  OnTick, OnTrigger and other will be events/delegates stored on the SO, they will be usable to propagate (call/invoke) logic chain processors
 * 
 * 
 * Stats randomness:
 *  Old prototype had random stats on every stats possible, but the game needs basic material consistency.
 *  So stats variance can be achieved in a couple of ways =>
 *  -Material variance (concentration/purity)
 *  -Module variance/quality (ex: rotation speed, transmission efficiency etc, sort of like build quality of specific parts of components)
 *  -WIP (Uncertain) Could have some permanent modifiers/slot system on components to affect their stats/behaviors,
 *      think of the marice/matrix cores concept modifying components
 *      (an old idea example was a core that would enables the compatibility of two faction technologies)
 */
#endregion
#region Ressources
/*
 * Ressources defined by graphs:
 *  Logic Gate Entry like OnTick, OnImpact etc...
 *  Logic Reaction with other ressources
 *  Logic behaviors like storable, transmitable etc...
 *  Ressource type/broad material, mineral, crystal, biologic/organic
 *  Ressource state/state change condition, liquid, solid, gas, concentrations, pression etc...
 * 
 * Ressources can be generatedd in a multitude of ways, from environmental effects, components, in world locations or entities.
 * Ressources can be transfered from components to components that have the required utilities and the required ressources
 * Ressources can be harvested from multiple sources, from the environement, from incoming components (projectiles or ships) or even from their own composition
 * Ressources can be used in different ways by different things, they can arm, they can be used for production, they can boost certain things or hinder other mechanisms
 * 
 * Ressources can be materials like steel, or effects like fire or ice, in other words heat or cold
 * Ressources can have different states based on concentration like if enough heat, depending on material resistance, ignites in fire
 * Ressources can be on components by themselves and have a certain spread/concentration per valid pixels (amount and spread/concentration of ressources is stored)
 * Ressources can act in unique ways depending on what other ressource they interact with, like fungus with organic vs inorganic ressources
 * 
 * Ressources can have their own behaviors and capabilities like storing, spread, dissipation, growth state etc...
 * Ressources can have/be in different concentration/qualities altering stats/behaviors, ex reflective crystal has reverse properties, maybe reflective instead of absorbing
 * 
 * Ressources Interaction/quality/state Ideas:
 * Heat -> Fire Ignition -> Explosion
 * Energy -> Quick Lighting -> Black Hole/Vortex
 * Spores -> Fungus -> Spread + Spawn
 * Cold -> Freeze -> Deep Freeze/Shatter (Impact deep penetration)
 * 
 * Reflective Crystal -> Troubled Crystal -> Translucent Crystal -> Crystal -> Alligned Crystal -> Bialigned Crystal -> Quad Formation Crystal -> Gravitational Crystal -> Harbringer Crystal
 * Low Density Mineral -> Mineral -> Compressed Mineral -> High Density Mineral -> ICHD IncompressableHighDensity/HDC HighDesityCompressed/OCM OverCompressedMaterial/OC OverCompressed Mineral

 * Liquid types: apply, over 100% -> Leak inside -> Leak outside

 * Fire + Energy -> Plasma
 */
#endregion
#region Capabilities/Component examples
/*
 * Capabilities examples
 * 
 * Solar Panel:
 *  -Produce Ressource<Energy>
 *      -Conditional => Require Sunlight
 *  -Output Ressource<Energy>
 * 
 * 
 * Intra Reflection Solar Panel:
 *  -Produce Ressource<Heat>
 *      -Condutional => Require Sunlight
 *  -Output Ressource<Heat>
 * 
 * 
 * Energy Battery:
 *  -Hold Ressource<Energy>
 *  -Intake Ressource<Energy>
 *      -Produce Ressource<Heat>
 *  -Output Ressource<Energy>
 *      -Produce Ressource<Heat>
 *  -Dissipate Ressource<Heat>
 *  -Output Ressource<Heat>
 *  
 * 
 * Cannon:
 *  -Intake Ressource<Projectile>
 *  -Trigger
 *      -Create Entity
 *      -Consume Ressource<Projectile>
 *      -Produce Ressource<Heat>
 *      -SFX
 *      -VFX
 *      -Physics Feedback
 * 
 * 
 * Thruster:
 *  -Intake Ressource<Energy>
 *  -Trigger
 *      -Physics Feedback
 *      -VFX
 *      -SFX
 *      -Consume Ressource<Energy>
 *      -Produce Ressource<Heat>
 *      
 * 
 * Loader:
 *  -Intake Ressource<Projectile>
 *  -Output Ressource<Projectile>
 * 
 * 
 * Steam Loader:
 *  -Intake Ressource<Projectile>
 *  -Output Ressource<Projectile>
 *  -Intake Ressource<Heat>
 *  -Use Ressource<Heat>
 *  Note: At higher heat, higher efficiency, at no heat, efficiency reduces to zero
 *  
 * 
 * Hardpoint:
 *  -Intake Ressource<Energy>
 *  -Trigger
 *      -Use Ressource<Energy>
 *      -Rotates Attached Anchor Point (Component)
 *  Note: At construction, can have an anchor point attached
 * 
 * 
 * Small setup Example:
 *  Cannon with SteamLoader, SteamLoader has a small heat gen inputed,
 *  then on fire the cannon feedback loops the generated heat into the steam loader
 *  making the steam loader reload faster the cannon then firering faster and again and again
 *  until either the cannon or steam loader reaches a critical limit and explodes or just melts and breaks
 */
#endregion
#region Notes
/*
 * Old Notes:
 *  StatsWithModifiers:
 *      Variables with modifiers, not sure how to handle them or what they would exactly be,
 *      like heat should be on maybe every components and other "ressource" types should have the possibility to be in different components
 *      like biomass or fungal growth could be ressources in of themselves.
 * 
 */
#endregion

I'm a regular office worker with zero coding background, trying to make my first game after work with AI helping me with the code side.

It's a small cozy shop sim where you run a potion store and try to figure out what each customer actually needs so you can recommend the right potion. No combat, no romance, no decorating. Just a simple cozy loop.

Before touching any code, I spent most of my time figuring out the design with AI and writing everything down:

- the economy

- all 20 customers

- their likes, dislikes, and needs

- potion recipes and progression

The biggest surprise so far has been how interconnected balancing is. Change one number and suddenly a bunch of other systems need to be adjusted too.

One thing I'm already getting stuck on is how to keep the customer/item logic from turning into a mess.

Each customer has a specific problem they want solved, but they also have their own likes and dislikes. Each potion is supposed to solve certain problems, but it also has its own element and category. So every time I tweak one part, a bunch of other stuff suddenly feels off.

If you've designed systems like this before, how do you usually organize it early on? Is there a good way to structure customer needs, item tags, and preferences without the whole thing getting messy every time you change something?

What I've finished so far:

- full design docs for the core systems

- all 20 customers designed on paper (first draft)

- full-body concept art for every customer

Here's customer #1, Mira:

https://preview.redd.it/j7r46wvw8fah1.png?width=969&format=png&auto=webp&s=c1aa1c48ea7987dbcd115ea5fee0e32aa86aff29

Mostly posting this to keep myself accountable so I don't quietly drop it halfway through. Planning to update once a week if I can keep it going.

If anyone else here started from zero and is building with AI help, I'd love to hear how it's going for you.

We got to share how we used DOTS/ECS to make our city builder Life Below, and it's now in the official "Resources" section of Unity's website! If anyone has any questions, feel free to ask them here and I'll try to respond ^^

If anyone is interested in the game, it's currently in the steam summer sale!

On the right : 5,000 cubes. Each of these cubes has its own position animation. Since a position uses 3 axes, this represents a total of 15,000 curve evaluations per frame in 4ms.

On the left : a single cube playing 10,000 simultaneous position animations in 4.6ms, which is equivalent to 30,000 curve evaluations per frame.

Today, I’d like to share some of the optimizations I implemented to achieve these results, in the hope that they might help in your own projects… Of course, optimizations are always contextual. I’ll explain my goals so you can judge for yourself whether these techniques are relevant to your situation.

You see, I’m developing an animation tool focused on rapidly integrating visual feedback (game feel) in Unity. My goal is to be able to animate any property of a GameObject while respecting three core principles: additivity, reversibility, and scale.

To achieve this level of scale, my tool needs to evaluate thousands of animation curves every frame, perform the required calculations, and apply all transformations. Until recently, only my architecture was pointing in this direction, but two weeks ago I started taking a closer look at the profiler, and here are some of the optimizations I was able to implement.

1: Baking animation curves

I need to evaluate large numbers of animation curves every frame:

public AnimationCurve Curve;

float Evaluate(float t)
{
   return Curve.Evaluate(t);
}

One way to optimize this is to bake animation curves to achieve much faster evaluation.

public AnimationCurve Curve;
float[] BakedCurve;
int Resolution = 512;
float Evaluate(float t)
{
   t = Mathf.Repeat(t, 1f);
   int index = (int)(t * (Resolution - 1));
   return BakedCurve[index];
}
void Bake(AnimationCurve curve)
{
   float[] baked = new float[Resolution];
   for (int i = 0; i < Resolution; i++)
   {
       float t = (float)i / (Resolution - 1);
       baked[i] = curve.Evaluate(t);
   }
}

Ouch, big problem. This change was supposed to give me a significant performance boost, yet my profiler was suddenly dying… And that’s where context matters. In a game, visual feedback is rarely active for long periods. Instead, we tend to trigger many short bursts of effects one after another. As a result, I ended up baking curves every frame!

Fortunately, the solution is quite simple: using a unique hash generated whenever a curve is modified in the inspector, I can cache baked curves for fast access.

Dictionary<int, float[]> BakedCurves = new Dictionary<int, float[]>();
public int GetHashForCurve()
{
   HashCode hash = new HashCode();
   foreach (Keyframe k in Curve.keys)
   {
       hash.Add(k.time);
       hash.Add(k.value);
       hash.Add(k.inTangent);
       hash.Add(k.outTangent);
       hash.Add(k.inWeight);
       hash.Add(k.outWeight);
       hash.Add((int)k.weightedMode);
   }
   hash.Add((int)Curve.preWrapMode);
   hash.Add((int)Curve.postWrapMode);
   return hash.ToHashCode();
}
public float[] Fetch(int hash, AnimationCurve curve)
{
   if (BakedCurves.TryGetValue(hash, out float[] baked))
       return baked;
   return Store(hash, curve);
}
float[] Store(int hash, AnimationCurve curve)
{
   float[] baked = new float[Resolution];
   for (int i = 0; i < Resolution; i++)
   {
       float t = (float)i / (Resolution - 1);
       baked[i] = curve.Evaluate(t);
   }
   BakedCurves.Add(hash, baked);
   return baked;
}

2: Avoiding unnecessary comparisons

Before applying changes, I need to ensure the targeted component still exists:

Transform transform = GetComponent(); // Cached
Vector3 Offset = Vector3.zero;
foreach (Layer l in Layers)
{
   // Offset calculation logic
}
if (transform != null)
   transform.position = Offset;

You can see that the comparison and the position assignment still happen even when no animation layer actually modified the value. In isolation, this is negligible, but across tens of thousands of calls per frame, the cost starts to add up.

The solution was simple: adding a boolean IsDirty. This way I check and apply changes only when a modification actually occurred.

Transform transform = GetComponent(); // Cached
Vector3 Offset = Vector3.zero;
bool IsDirty = false;
foreach (Layer l in Layers)
{
   // Offset calculation logic
   IsDirty = true;
}
if (IsDirty && transform != null)
   transform.position = Offset;

3: Optimizing iterations

I didn’t realize how expensive my foreach loops were at the scale I was targeting.

public List<string> List = new List<string>();
foreach (string s in List)
{
   // Do something
}

Each foreach first creates an enumerator, which then performs multiple operations on every MoveNext. And I have TONS of loops like this in my code…

The target was clear. I built a small utility class that keeps the enumerator-like state and allows me to iterate more efficiently:

namespace FeelCraft.Core.Trackers.Utils
{
   public class EnumerableList<T>
   {
       public bool Active = false;
       public IEnumerator<T> Enumerator;
       public List<T> List;
       public int Index = -1;
       public int Count = 0;
       public EnumerableList()
       {
           List = new List<T>();
       }
       public void Refresh()
       {
           Index = -1;
           Count = List.Count;
           Active = Count > 0;
           Enumerator = List.GetEnumerator();
       }
       public bool MoveNext()
       {
           Index++;
           if (Index >= Count)
           {
               Index = -1;
               return false;
           }
           return true;
       }
       public T Current
       {
           get { return List[Index]; }
       }
   }
}
public EnumerableList<string> MyList = new EnumerableList<string>();
string s = "";
for (int i = 0; i < Count; i++)
{
   while (MyList.MoveNext())
   {
       s = MyList.Current;
       // Do something
   }
}

On 1,000,000 iterations, the foreach version takes 147ms, while my custom class reduces this to 55ms.

But do not use this code : it's trash...  Because in trying to be clever, I fell straight into a reasoning bias… I was so focused on the idea of the enumerator that I didn’t even consider the simplest solution... It's only after refactoring all my iterations that I realized a much simpler and faster approach existed 🤦

for (int j = 0; j < List.Count; j++)
{
   s = List[j];
}

Just like that.
8ms for 1,000,000 iterations

All these optimizations played a role in v2.2.0 of my tool to stack tens of thousands of simultaneous animations and offer a linear scale across both multi-object expension and multi-animation stacking. That's perfect for building small indie projects or being fully equipped for Game Jams. For creating projects packed with game feel. Projects that make both the player and developer experience incredibly satisfying!

If you're curious, feel free to check out the tool page on itch or on the asset store

Thanks for reading ! :)

Thank You for the Incredible Support! ❤️ Here's the Making-of Video for My Dhurandhar-Inspired Game

Hey everyone!

A few days ago, I shared the gameplay montage of my fan-made Dhurandhar-inspired game prototype, and I honestly didn't expect it to receive so much love. Reading your comments, suggestions, and encouragement was incredibly motivating. Thank you to everyone who took the time to watch, upvote, and leave feedback—it genuinely means a lot, especially as a solo indie game developer.

One of the most common questions I received was: "How did you make this?" and "How long did it take?"

So I decided to document the entire journey.

I challenged myself to build the game in just 72 hours using Unity. In my latest video, I show everything that happened behind the scenes—from planning the project and finding assets to implementing gameplay, fixing bugs, adding effects, and trying to make everything come together before the deadline.

It wasn't easy. There were plenty of moments where I thought I wouldn't finish in time, but that's what made the challenge so much fun. Whether you're into game development or just enjoy seeing how games are made, I think you'll enjoy the process.

The project is completely fan-made and was created purely as a creative challenge inspired by the atmosphere and action shown in the trailer. It's not an official game—just my attempt to imagine what a playable version could feel like.

If you enjoyed the gameplay montage, I'd really appreciate it if you checked out the making-of video as well. I'd love to hear your thoughts on what worked, what could be improved, and what movie or game you'd like to see me recreate next.

Maybe the mesh deform thing is a tad bit tech and code, but I am just gonna mark this as generic for now