How to Organize & Style your Code in Roblox Development (and when to use OOP)

Introduction to Developing Games on Roblox

In this section, the speaker introduces the topic of developing games on Roblox and highlights the freedom and flexibility offered by the Roblox Studio game engine. The importance of finding the right mix of code organization and structure is emphasized.

Getting Started with Game Development on Roblox

• Developing games on Roblox provides a lot of freedom in terms of game design and coding.

• The Roblox Studio game engine allows for creative expression and customization.

• Finding the correct balance between code organization, safety, and functionality is crucial for creating successful games.

Organizing and Structuring Projects

This section focuses on organizing and structuring projects effectively. The speaker shares their opinions on how things should be structured in code, including best practices, style guides, capitalization, naming conventions, readability, organization, and overall improvement.

Best Practices for Code Organization

• Properly organizing projects can make them more readable, organized, and easier to work with.

• Following style guides for capitalization and naming conventions can improve code consistency.

• Implementing best practices can enhance collaboration among team members working on a project.

Placing Scripts in the Right Locations

This section discusses where to place scripts within a project. Different scenarios are considered based on whether it's a standalone model or an entire game being developed.

Choosing Script Locations

• For standalone models that will be shared or sold individually, scripts can be placed within the model itself.

• Roblox now allows running client scripts outside specific folders like character scripts or starter player scripts.

• For complete games, it is recommended to restrict scripts to server script service and starter character/starter player scripts.

• Avoid placing scripts in starter GUI unless dealing with complex GUIs.

Starting Scripting and Coding

This section focuses on starting the scripting process and provides insights into effective coding practices. The speaker emphasizes the concept of "you aren't going to need it" and the importance of refactoring code as the project evolves.

Effective Scripting Approach

• Start by creating a script in server script service.

• Embrace the philosophy of "you aren't going to need it" to avoid overcomplicating initial scripts.

• Only program what is needed at the moment, knowing that ideas and requirements may change during game development.

• Refactor code as necessary, even though it takes time, to improve structure and functionality.

Learning from Past Projects

This section highlights the value of learning from past projects and experiences. The speaker shares an example of a previous game where poor code organization led to challenges.

Importance of Learning from Experience

• Refactoring code is essential for improving future projects based on lessons learned.

• A previous game's example demonstrates how poor code organization can lead to long scripts that are difficult to manage.

• Making multiple projects helps in understanding project needs better and improves decision-making when coding.

These notes provide an overview of key points discussed in the transcript. For more detailed information, please refer to the original transcript.

Setting up Code Structure

In this section, the speaker discusses the importance of setting up code structure and being open to making changes. Refactoring code is encouraged to improve its robustness and ease of work.

Importance of Refactoring Code

• Refactoring code allows for a more solid and robust code base.

• It is important to be open to changing the code structure if it is not working as expected.

• Fail fast approach - learn from mistakes and fix them quickly.

Learn from SpaceX's Approach

• SpaceX follows a similar approach with rockets, making many rockets quickly and waiting for them to explode to identify issues and make improvements.

• Avoid elaborate designs that take a lot of time like NASA's Space Launch System.

Keeping Code Simple

• Start with simple functions instead of immediately creating object-oriented classes.

• Only create classes when multiple situations or save states are involved.

Picking Script Placement and Complexity

This section focuses on choosing script placement and avoiding overcomplicating things before starting. The speaker emphasizes simplicity in coding.

Script Placement

• Choose where your script goes based on its purpose and functionality.

Avoid Overcomplicating at the Beginning

• Keep things simple when starting out.

• If only a single function is needed, there is no need to create an object-oriented class.

Extending Functionality with Classes

• When the functionality expands into multiple situations or requires save state management, it becomes necessary to use classes.

• Use classes when there is a need for cooldowns, save states, or other complex features.

Creating a Teleporter Class

This section covers the process of creating a teleporter class using Lua scripting language. The speaker explains the importance of organizing code into modules and keeping classes in separate scripts.

Organizing Code with Modules

• Use modules to keep related functions or classes together.

• Each module should contain only one class to maintain code organization and logic.

Creating a Teleporter Class

• Start by creating a blank table for the teleporter.

• Set the metatable to "teleporter" for indexing purposes.

• Add functions such as "new" and "destroy" within the teleporter class.

Benefits of Separate Scripts

• Keeping classes in separate scripts helps maintain small total script size and logical code organization.

• Avoid mixing everything together, which can lead to confusion and disorganization.

Instance Creation and Field Naming Convention

This section focuses on instance creation in Lua scripting language and naming conventions for fields or properties within a class.

Instance Creation

• Create a new instance of the class using self or any other variable name.

• Return the instance at the end of the function.

Field Naming Convention

• Use Pascal case (capitalizing each word) for field names, e.g., cooldownTime.

• Follow consistent naming conventions for both fields and functions within a class.

Private Variables and Naming Conventions

In this section, the speaker discusses the use of private variables and naming conventions in Lua programming.

Private Variables

• Private variables are used when you don't want other scripts to access them.

• Conventionally, private variables are named with an underscore (_) followed by camel case (e.g., _privateVariable).

• This naming convention helps indicate that the variable is not meant to be accessed by outside scripts.

Naming Conventions for Functions

• Functions that are meant to be private and perform specific tasks can be named using camel case (e.g., _privateFunction).

• Instead of creating separate private functions within an init function, it is recommended to use comments within the init function to explain different blocks of code.

• Splitting up functions into multiple smaller functions should only be done if a functionality is used more than once or if indentation becomes too complex.

Code Readability and Comments

• When commenting code, focus on explaining why something is being done rather than what the code does.

• Use long blocks of comments to provide reasoning and explanations for your code.

• If your code is self-explanatory and you're working on a personal project, you may not need excessive comments.

Writing Intuitive and Readable Code

This section emphasizes the importance of writing intuitive and readable code through meaningful names and proper commenting practices.

Writing Intuitive Code

• Focus on making your code intuitive and readable for yourself and others who may work with it.

• Commenting should explain why certain actions are taken rather than simply describing what the code does.

Avoid Unnecessary Function Splitting

• Only split functions into separate blocks if they are used more than once or if indentation becomes unmanageable.

• It's not necessary to mimic conventions from other languages like Java when working with Lua.

• Keeping everything within an init function is acceptable as long as the code remains readable.

Balancing Code Perfection and Project Completion

• Strive to release a functional game rather than obsessing over perfect code.

• Finishing a project is more important than achieving perfection, as a perfect project that is never released serves no purpose.

• Focus on getting the job done, even if the code is not flawless.

Importance of Comments and Project Completion

This section highlights the importance of comments in code and emphasizes the significance of completing projects.

The Role of Comments

• Comments should provide reasoning and explanations for your code rather than stating what the code does.

• Writing meaningful comments helps others understand your thought process and intentions behind certain actions.

Self-explanatory Code

• If you're working on a personal project and your code is self-explanatory, excessive commenting may not be necessary.

• However, in most cases, comments are essential for understanding complex logic or functionality.

Prioritizing Project Completion

• Completing a project and releasing a game should be the primary goal.

• Spending too much time striving for perfect code can hinder progress and delay project completion.

• It's crucial to find a balance between writing clean, readable code and ensuring timely delivery.

New Section

In this section, the speaker discusses the downsides of using a certain module or service in higher-level controllers. They also mention other efforts like Matter ECS (Entity Component System) that can help organize game structures.

Downsides of Using a Single Module/Service

• The creator acknowledges that using a single module or service, similar to singletons, can have drawbacks.

• Accessing one module or service at a higher level or controller is considered bad practice.

Other Efforts for Game Structure Organization

• Matter ECS (Entity Component System) is recommended as an alternative approach.

• Entity Component Systems have been widely used and proven successful in game development.

• Unity, for example, utilizes entity component systems extensively.

• Exploring Matter ECS and similar approaches can assist in organizing game structures effectively.

New Section

This section highlights the power of Luau and how it allows developers to make their own decisions. However, it also mentions the potential challenge of analysis paralysis when faced with too many options.

Power and Flexibility of Luau

• Luau is a powerful language that provides developers with significant control over decision-making.

• It enables customization and personalization in game development.

Analysis Paralysis

• The abundance of choices in Luau can lead to analysis paralysis.

• Developers may struggle to determine the best approach due to numerous possibilities.

New Section

Here, the speaker emphasizes simplicity and efficiency in game development while recommending avoiding overcomplicating things.

Simplifying Game Development

• Focus on finding the simplest way to create your game.

• Overcomplicating things does not necessarily enhance productivity or efficiency.

Getting Games Out

• Prioritize completing and releasing games rather than getting caught up in unnecessary complexities.

• Efficiency and productivity are crucial for successful game development.

New Section

The speaker concludes the video by providing additional resources and encouraging viewers to use the information as a baseline for their own development journey.

Additional Resources

• The video description contains various links for further reference.

• A recommended video discussing the drawbacks of certain programming practices is mentioned.

• While not endorsing everything in the recommended video, it offers valuable insights worth exploring.

Personal Opinion

• The speaker acknowledges that the information shared is based on personal experience and opinion.

• Viewers are encouraged to provide feedback and share their perspectives, which may influence or expand upon the speaker's understanding.