Skip to content
The Chat Archive
llama-3.3-70b-instruct· Meta LMArena Human Preference 140K

What do you think of this tactic in indie game dev ? For one of the first games: - At…

  1. User

    What do you think of this tactic in indie game dev ? For one of the first games:

    • At first, focus on the essential, the underlying system on which the game run have to work, even if the player don't really see that system.
    • Then, focus on making all mechanics of the game in a relatively functionning state, everything have to be done, even if it's half working or if they are very clunky.
    • Implement the bare minimum at first, for examples for the 50 monsters, each with their animations and attacks, let's them have biting and tail swipe, for all of them at first.
    • The idea is to make a functionning game as fast as possible, even if it's crap.
    • Then fix, develop, upgrade, render more complex and so on every parts that were implemented.
    • Keep for the last the most difficult ones, so the experience gained from the easier parts translate to make the harder parts easier than if done directly.
    • Develop everything as modules, that can be added, replaced or removed easilly.
    • visual assets come last, just have the bare minimum at first, with half baked animations too, these can be fixed later.
  2. Assistant

    I think this tactic is excellent for indie game development, especially for a first game. Here's why:

    1. Focus on core systems: By prioritizing the underlying systems, you ensure that the game's foundation is solid. This will save you from headaches down the line when trying to build upon a shaky foundation.
    2. Functional over polished: Getting all mechanics in a working state, even if they're not perfect, allows you to test and validate the game's overall design. This approach helps you identify and fix major issues early on.
    3. Minimum Viable Product (MVP): Implementing the bare minimum for each feature, like the monster example, enables you to create a functional game quickly. You can then iterate and improve upon these features.
    4. Iterative development: By fixing, developing, and upgrading each part in a modular fashion, you can refine the game without having to redo everything from scratch.
    5. Modular design: Developing features as modules makes it easier to add, replace, or remove them as needed. This flexibility is crucial for indie game development, where resources are often limited.
    6. Visual assets last: Focusing on gameplay and mechanics first, and leaving visual assets for later, is a common and effective approach. This allows you to create a solid game foundation before investing time and resources into polishing the visuals.
    7. Learning and experience: By tackling easier tasks first, you gain experience and knowledge that will help you tackle more challenging tasks later on.

    This approach is often referred to as the "Minimum Viable Product" (MVP) or "Vertical Slice" approach. It's a great way to:

    • Validate game ideas and mechanics
    • Identify and fix major issues early on
    • Create a functional game quickly
    • Iterate and improve upon the game
    • Manage resources and scope effectively

    Some additional benefits of this approach include:

    • Reduced risk of feature creep
    • Easier testing and debugging
    • Improved game balance and tuning
    • More efficient use of resources (time, money, and personnel)

    Overall, this tactic is a great way to approach indie game development, especially for a first game. It allows you to create a functional game quickly, iterate and improve upon it, and ultimately deliver a polished and engaging experience to your players.

  3. User

    I'm talking to two LLMs at once, one of you said:

    • "Actually: hardest tech spikes first, hardest content last.", and "The 'unknown unknown' might break your engine or design late in the project. Spike the riskiest tech FIRST (networking, streaming, etc). You don’t need final code; just prove it’s feasible.", and it's actually part of the "underlying system", if the game is a multiplayer one, having the multiplayer part work is the first thing to do, even if it's the absolute hardest. The "underlying system" could have been named "the very core of the game" too, if you take minecraft, it could be it's world generation, if you take shadow of the mordor it may be it's genesis system, if you take a 4X, it may be the AI and the resource system.
    • "Building 50 half-working monsters is costly and clutters your bug list.", and if it's 500 monsters to make it even more extrem for my argument, split in 5-10 skeletons, each with just these animations: idle, walk, bite, tail swipe, ( and dead position if no ragdoll), with each monsters with each skeleton having one shared model, with at most a swap color or some fast details/trinkets to differentiate them (a crest, spikes, bulbs, frills, ect.), those will be done very fast at first, and if there's no eating animation yet, don't matter, it can be added later, and even if they are unique monsters, they would share some animations too, just look at the kut ku compared to the rathalos in monster hunter, both have the same skeleton, and uses some common animations, with only on top their specific ones. And for the "demo" or when working on implementing the fighting with more than "bite + tail attack", you may create a model for one monster to really test it.
  4. Assistant

    It seems like we're having a great discussion across multiple LLMs.

    I completely agree with the points you're making. Let me break them down and provide some additional insights:

    1. Hardest tech spikes first: You're absolutely right. If your game relies on complex technology, such as multiplayer networking or advanced AI, it's crucial to tackle those challenges early on. This approach helps you identify potential roadblocks and ensures that your game's core systems are feasible. By spiking the riskiest tech first, you can avoid costly rework or even project cancellation later on.
    2. Core systems first: I love how you've rephrased "underlying system" to "the very core of the game." This emphasizes the importance of identifying and prioritizing the essential components that make your game unique. Whether it's world generation, AI, or resource management, getting these core systems working is vital to building a solid foundation.
    3. Efficient content creation: Your approach to creating monsters is a great example of efficient content creation. By using shared skeletons, animations, and models, you can quickly create a large number of monsters with minimal overhead. This approach also allows for easy iteration and addition of new animations or details later on.
    4. Prioritizing essentials: You're right that building 50 half-working monsters can be costly and clutter your bug list. By focusing on the essential features and systems first, you can ensure that your game's core mechanics are solid before adding more content. This approach also helps you avoid unnecessary complexity and makes it easier to test and iterate on individual components.
    5. Modular and iterative development: Your suggestion to create a single, more detailed monster model for testing and demo purposes is a great example of modular and iterative development. By focusing on a smaller, more manageable scope, you can test and refine individual components before scaling up to more complex content.

    To summarize, it seems like we're converging on a few key takeaways:

    • Identify and prioritize the hardest tech spikes and core systems first
    • Focus on efficient content creation using shared assets and modular design
    • Prioritize essential features and systems over non-essential content
    • Use iterative and modular development to test and refine individual components before scaling up

    I think this approach will serve you well in your game development journey!

  5. User

    LLM1 said "Creating 500 half-working prefabs can drown QA.", so why not create one prefab that change based on data instead ? The data could contain the mesh path, which base animation set to use, it's specific animations, the AI modules to use and some other datas and voila, no ? Basically have one big object type (here "Monster"), and one big "XML" (or other type of database) to contain all the different datas to initialize those objects.

  6. Assistant

    LLM1's concern about creating 500 half-working prefabs is valid, as it can indeed overwhelm QA and make it difficult to manage and test the game.

    Your proposed solution is an excellent approach to mitigate this issue. By creating a single, flexible prefab that can be configured using data, you can achieve several benefits:

    1. Reduced prefab clutter: With a single prefab, you eliminate the need to create and manage multiple prefabs, which can reduce clutter and make it easier to navigate your project.
    2. Improved scalability: Using data to configure the prefab allows you to easily add or remove features, animations, or AI modules without having to create new prefabs. This makes it easier to scale your game's content and complexity.
    3. Simplified QA: With a single prefab, QA can focus on testing the core functionality and configuration options, rather than having to test multiple prefabs.
    4. Increased flexibility: The data-driven approach enables you to create a wide range of variations using the same prefab, which can lead to a more diverse and engaging game world.
    5. Easier maintenance: If you need to make changes to the prefab or its configuration, you can do so in a single place, rather than having to update multiple prefabs.

    Using a data-driven approach, such as an XML file or a database, to store the configuration data for your monsters is a great way to separate the data from the code and make it easier to manage and update. This approach is commonly known as data-driven design or entity-component-system (ECS) architecture.

    In this approach, you would have a single "Monster" prefab that contains the core components, such as the mesh, animation controller, and AI modules. The configuration data, such as the mesh path, animation set, and AI modules, would be stored in a separate data file or database.

    When you create a new monster, you would simply create a new entry in the data file or database, specifying the configuration options for that particular monster. The game would then use this data to initialize the monster prefab, creating a unique instance with the specified characteristics.

    This approach can be applied to other game objects and systems as well, such as characters, items, environments, and more. By using a data-driven design, you can create a more flexible, scalable, and maintainable game architecture.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.