Refactoring

Sprint Planning

Alpha Build

Professional teams schedule some time for code cleanup after each milestone so their code stays flexible and easy to work with. This project will give you some tips and general principles for this process, known as refactoring. With your vertical slice done and your code in good shape, this is where you’ll start down the road to alpha.

Writing Better Code

Course Introduction and Planning

Game Jams and Skilling Up

Set your goals and find your community

What is the Design Process? 

Scope

Constraints and Our Theme

Concentric Design

Why Prototype? 

Assets shouldn't be liabilities

The Stages of Game Development

Planning your project

CRC Cards

Your First Milestone: Vertical Slice

Why Agile?

Vertical Slice - Part Two

What is Playtesting?

How To Playtest

Sprint Plan

Review and Redesign

How to Release your Game

Alpha and Beyond

Bonus Content

In this project you will learn about what's ahead for you on your journey to finishing a game! You'll also get a chance to confirm that you have the right knowledge and skills to get the most out of the course, along with links to useful resources that will help you on your way. You will also learn how to equip yourself for your journey, and meet some of your fellow adventurers.

Goal Setting and Community Building

In this project you will learn about using a design process to take your idea from a broad concept into a finished, polished game, the concept of scope will help you achieve your goal of making a game, how constraints can help you create rules to keep you in scope,  and how to use the specific design process, concentric design.

The Design Process

In this project you will find out if your game idea is fun through Prototyping. You will also learn how to make a plan for assets you will use in your game – the sounds, images, models, animations and other resources that make up a game – to avoid nasty surprises later in development. 

Prototyping

In this project you will learn how to keep a sense of the big picture by dividing the game development process into stages and milestones, hit your first major milestone in the development of a game through creating a vertical slice, and learn two planning tools you can use to plot a course to a finished game. 

Milestones

Agile Development

Playtesting is more than just asking people if your game is fun. It's a structured process for collecting useful information about specific parts of your design. In this project you will learn why Playtesting helps you collect useful information on your design and how to execute the entire process. 

Playtesting

In this project you will learn how to release your game, what the next steps are after game release, and additional tips for getting to the end. 

Release your game

Lots of people start games, but it’s surprisingly hard to finish one. This course guides you through the process used by professional game makers to develop their ideas, keep their projects on track and deliver a complete, released game. 

Explore the Unity Asset Store for game toolkits and template assets that will help you quickly design and prototype your games. These resources can accelerate your development process and help you achieve your goal of releasing a polished game!

Design and Publish Your Original Game: Unity USC Games Unlocked

9b55604e-a261-5fd8-8493-39b602c55014:zx7pohSEomVRos4yXEqA7R

What is Refactoring and Why do I care?

Making Code More Legible by Renaming Variables

Intermediate Coding Techniques

Refactoring Examples

Assignment: Refactoring Plan

  Follow the correct instructions make  your code becomes more accessible to others and yourself when you revisit it. 

MATER2030

Se refactorizaron los script del proyecto el Equilibrista

Plan de refactorización

Agustin Dominguez

Refactored the player's script into their respective functions or tasks.

Refactoring of the Software Architecture

unity_ABBB8FB9151B27AEEBC3

this bad work but i hope you done better than me guys . 

idk but i know what you better than me 

safasfafsagj

One example of my splitting up a big class into smaller ones; which, through inheritance, can grant methods to multiple other classes.

Arcane_Creator

This is not the best example of "Refactoring", some functions could be broken down into smaller parts. 

kot88murmansk

Some points I detected at first sight, I'll continue checking the code for the next scenes

Some refactoring

yuviL

I work with Adventure Creator, so I don't work directly on the code. But I looked at all ActionsLists trying to make them more compact and rational.

Refactoring plan

Silvana Di Bella

What is Refactoring.mp4

Making Code More Legible by Renaming Variables.mp4

Professional teams schedule some time for code cleanup after each milestone so their code stays flexible and easy to work with. This tutorial will give you some tips and general principles for this process, known as refactoring.

With your vertical slice done and your code in good shape, this is where you’ll start down the road to alpha.

Unity + USC Games Unlocked

Games

Refactoring_Examples.zip

You can make your code flexible and clean at any level of scripting knowledge, but certain coding techniques and C# features make it easier to design a good architecture, particularly as your projects get larger. 

GameDevHQ’s series on intermediate coding skills for Unity 

Unity’s list of intermediate coding topics 

SigTrap: Unity Software Design- Inheritance and Composition

We created a Unity project showing detailed examples of the code cleanup discussed in the videos, as well as simple working examples of intermediate-level code structures like coroutines. Go to the Tutorial Materials at the top of this page and download the zipped folder to see the examples. 

It's time to tidy up your code so you're on a firm foundation for the rest of the project.

This assignment is about cleaning up code that you have already written. It serves two important purposes:

1. It will make your life easier as a developer for the rest of the project.

2. Going back through code and thinking about how to make it better is a key part of getting better at coding.

It’s never too early to refactor – you can rename variables, write comments and turn repetitive code into functions at any point. But this is a great moment in this project to step back and look at the structure of your code. You’ve been working on the project long enough to have run into some issues, but it’s not right before the final deadline when a refactoring would be risky.

On a pro team, you’d write up your refactoring tasks and put them in the sprint plan for that week. But this time, it's OK to just go through your code and fix issues as you find them rather than write them up as tasks. Prepare to spend 1-2 hours on this assignment as a separate block of work from your usual planning and development cycle.

Before you do anything else, back up your project! Close Unity, zip the entire project folder and put the zipped file somewhere safe, perhaps on a USB key or in Dropbox. It’s recommended to do this even if you’ve been using source control – you’re going to break your project while refactoring and you’ll want to have an easy way to un-break it. 

Take a few minutes to refresh your knowledge of how your code currently works. Open each of your script files, starting with the smaller ones. Can you tell what each line is doing? Are there places where you pasted in someone else’s code without fully understanding it? 

As you read, look for places you can make the code clearer. Think carefully about how you are actually using your variables, and whether you could rename them. If you’re using a hard-coded number, try to turn it into a variable. Go ahead and make these changes as you see them. 

If there’s a line or set of lines doing something complicated, put a comment above them briefly explaining what’s happening. If it’s three or more lines, consider moving them into a function so that you can give it a descriptive name. Go ahead and do this where appropriate. 

Keep an eye out for code that’s doing basically the same thing in several places. Think about how you might turn those repeated lines of code into a function, or consolidate them by using a variable instead of hard-coded values. Make a list of these places. 

Look at each of your classes again. For each one: 

1. Can you describe everything the class does in one short sentence or 3-4 bullet points? 

2. If so, go ahead and write those in a comment at the top of the class. 

Look for parts of this class that would fit better in another existing class. Write down or draw a sketch of what you would move and where it would go. 

Consider splitting the class into smaller classes. Sketch what that would look like. 

Think about the remaining features you’re going to build. Is your code ready? For example: 

If you’re planning to let the player restart a level, do you know what you’d need to reset (e.g. doors that have been opened) and what you’d need to remember (e.g. number of lives remaining)? 

If you’re planning to have several kinds of enemies, but so far you’ve only built one, what will be different between them? Does your code make any assumptions that are based on that one enemy, e.g. how much damage it does? 

Give some thought to how you would need to change your code to make these new features work. Often (though not always) you can accomplish this by adding new variables to your classes or adding new parameters to your functions. Write down notes or draw a sketch of new classes and/or how your existing code would need to be rearranged. 

When you’re done with the steps above, you will have a to-do list describing ways that you can improve your code. You don’t have to do everything on it! You’ve already done yourself a big favor by going through these steps. But there’s probably at least a couple of things you know you need to fix before going into the final weeks of the project. This is the right time to do it. 

This is also a great time to talk with your classmates about ways to improve your code. Explaining your code to someone else will help you to see it clearly and make smart adjustments. Besides, reading and understanding someone else’s code helps you get better at writing code yourself. 

Make a plan using the instructions above. For reference, there are Refactoring Examples provided in the Tutorial Materials.

Make a pdf showing your rough to-do items and any sketches you’ve drawn. Upload it for this assignment.

Refactoring

1. What is Refactoring and Why do I care?

2. Making Code More Legible by Renaming Variables

3. Intermediate Coding Techniques

4. Refactoring Examples

5. Assignment: Refactoring Plan

Your submission preview

Complete this Exercise