• Make a new 2D project file.
• Place your first object upon the canvas.
• Learn how to restore Unity's default workspace layout.
• Apply colors and alignment to your text object.

• Save your scene within the project.
• Create a panel for your store and control its relative size to its container.
• Add a "Buy" button to your store.
• Display a name and numeric counter for your store.

• Organize your game scripts and scenes into folders.
• Create a new "store" C# script.
• Edit your script within your integrated development environment (IDE), such as Visual Studio or MonoDevelop.
• Learn how the Start() and Update() functions fire.
• Initialize your first integer-type variable for counting your stores.
• Make a custom function for your "Buy" button that increments your StoreCount variable.
• Discover how to use the Debug object to monitor your variable values.
• Link your script to the panel and link your panel's button to the script's function.

• Illustrates how the "using" directive gives you access to built-in C# class for creating objects for your UI.
• Learn the preferred technique for converting numbers into strings.
• Link your UI to a public script variable.

• Designate float-type variables to hold currency amounts.
• Learn how to store whole numbers and decimals.
• Design our tycoon game so that the initial purchase price of each store may vary. (Unlike real life, in the game world, the cost of opening each new store should rise over the course of time; this helps to keep the game challenging!)
• Recalculate your player's current balance whenever a store is purchased.
• Limit purchases when the balance falls too low.

In this exercise course you are asked to attempt to tie the current balance of your company to the Unity UI interface. You will need to incorporate many of the skills you have learned so far. This is a great exercise for those who have some experience programming and are confident that the material up to this point has been easy.

A core part of Business Tycoon Simulations such as this one is the timer that determines when a store's income should be added to the current balance. Timers are also very valuable in many game designs so learning how to use them early on in useful.

In this lecture we move away a bit from adding additional features to the game and instead look at some important game design concepts and prepare our game design to allow multiple stores.

In this lecture we use our real game example to see how our objects (the store and the game manager) can communicate and share information with each other. You learn that public methods and public properties are accessible outside your class and inside the Unity editor while private methods and private properties can only be accessed internally.

In this lecture you complete the process of making the tycoon game capable of handling multiple stores. An important take away from the course up to this point is that we are using many of the standard Unity features that are easy to get started with. Your game is up and running and the core engine is in place. Now we can begin adding features and expanding the game design.

At this point in the course you have the foundation for a simple game. In this exercise you are to take what you have learned and built out six stores (or how many you wish) with various costs, timers, and profits on the sale.

One key feature in these idle Tycoon type games like ADVenture Capitalist is that you unlock managers so you don't have to click on the store over and over. The store timer will automatically restart on its own once you have a manager for a store. While we will wait to implement the user interface for automating the store we will go ahead and add the feature into our store class so we can more easily test our game play.

Up to this point our stores are a fixed cost. In Tycoon games like this it is often desirable to have each new store cost more than the previous store. In this lecture you learn how to integrate a powerful c# math library that lets you create a function for your Tycoon game that allows you to scale up your store costs. More importantly you will learn how to use this library so that you can apply it to your own game designs.

Now that we have improved our store cost calculations, let's show the player the cost of the next store in the buy button. Learn how to dynamically change the button text.

Add visual feedback in which you can change the buy button to be disabled and show different colors when the player doesn't have the money to purchase another store.

While this entire course focuses primarily on using Unity 3D's User Interface and introducing game design patterns we do at least want our stores to have a picture associated with each one of them.

Unity Prefabs allow you to create reusable objects within your Unity scenes. This video begins introducing you to prefabs and how they can be used in the editor. In a later lecture you will learn how to use these prefabs to programatically generate your stores from XML.

For our design we want to hide the stores until they are available. While this design is a bit different than ADVenture Capitalist it is common in many other Tycoon games in this genre.

In this lecture we introduce some overall improvements to gameplay and learn some additional C# scripting along the way.

We begin to decouple our stores dependencies with the game manager by introducing the Singleton pattern. A classic design pattern used to implement game managers to they are easily accessible to all of the other systems in your game.

As a beginning programmer it is easy to put together a game like this Tycoon clicker. However when you get into more challenging games with complex designs your beginning skills will make it difficult. This lecture will teach you how to separate out the user interface elements from the game the game manager. While this very simple example only addresses the current balance, the design principal will prepare you for a far more complex Store UI manager in future lectures.

One of the most important game development concepts is the ability to create events the various systems in your game can respond to. Instead of tightly coupled objects that are brittle and require much dependency using the Observer Design Pattern and Delegates and Events our User Interface can update itself when the game manager announces that the current balance has changed. This is a dramatic improvement over the previous design in which our game manager would have to know details about the user interface.

Each store has several UI components and like our game manager it is important to separate out our UI from our game logic. Because the store class has more complexity this lecture certainly will be more challenging to those who started this course as a beginner. For those who are already programmers this re-factoring exercise should prove enlightening and provide you with examples of how you can go about better designing your own games.

Breaking out the store UI from the store game logic required quite a few steps but it should have been very valuable for those who wish to create more complex games. It demonstrates how composition of your objects is important and that you want to avoid from the beginning if possible having your UI tied in tightly with game logic. Most importantly it demonstrates that it is never too late nor never too early to re-factor your design for future growth. Build, test, re-factor, test, build, re-factor, test, build. Always take time to go back and clean up your code and re-factor when you are working on complex game projects.

The design to this point uses up a lot of CPU cycles because the UI is refreshed in the update method of the game objects. In this lecture we make our code more efficient by moving code out of the Update method and using other techniques to update the user interface in the game.

In this exercise you are asked to do some of your own re-factoring by changing variables from public to private.

In this lecture you learn how to create a simple XML document and load game data out of it so it can be utilized within the game setup.

NEW!!! - This is a new video added to the course that demonstrates how to create a layout grid for your store prefabs.

In this lecture you make a big leap in the game design going from stores that must be created manually in the Unity Editor and instead dynamically create the store prefabs from the data in the XML file. While this is a pretty simple example you can apply this to everything from loading rpg stats, maps, choose your own adventures... and pretty much any game elements. This is also an essential technique to making games in which users can easily make their own mods.

While most of our store data can be set right inside the store class, the store name needs to be updated in the text box at the top of the store interface.

Now that we are creating our store prefabs dynamically we must now load in our store image dynamically as well. Fortunately this short lecture will have you dynamically loading your pictures into the Unity UI in no time.

We still have additional data we need to load into our store from XML. This lecture gets the remaining elements of data we need into our store.

As many other objects in our game depend on the data that we are now loading dynamically, we use an event to notify the game manager that our data is loaded. This extends on what we have learned in previous lectures on using events and demonstrates how events can be used to effectively control the sequence of actions within your game design.

While we've completed loading our store data we now need to add the ability to load our starting balance from the XML file as well.

This exercise asks you to take what you have learned from loading data out of XML and create the ability to load the company name out of XML using similar techniques.

Our Load XML Data method grew quite large as we built out all the features it required. In this exercise you are asked to re-factor the method so it is more modular. Then the remaining part of the lecture is my attempt to re-factor the method. Please feel free to post your solutions to re-factoring this method in the discussion.

This lecture introduces you to the new bonus section that will show you how to improve the gameplay of our business sim by providing store upgrades that can be purchased. We begin by looking at the current design and understanding that many of the same mechanics for our manager upgrades will also apply to the store upgrades. This means we can use the same design patterns and techniques we used for unlocking managers for unlocking the upgrades.

We start in the lecture by focusing on the interface mechanisms that will open up the upgrades panel. Because the manager upgrades button, panel and list are so close in functionality we can quickly duplicate them to create a starting point for our upgrades.

Just like our managers, we must have prefabs that will be utilized for our upgrades. Using the manager prefab as a starting point we create a new upgrade prefab and slightly modify the appearance.

Now that we have our prefabs ready to load we need to modify the load game data script so it can create the new upgrade prefabs. Once again we copy the code we used for the manager upgrade and modify it so we can get our prefabs populating in the upgrade list.

To this point in this section we have primarily focused on the interface and the population of the upgrade items in the upgrade panel. Now that we have that functional we can tie it into our store and actually implement the upgrade.

This lecture we are forced to get a bit more creative with how we approach our design due to how the XML is imported. We make good progress at loading in an XML element and using it to create our upgrade prefab but the design breaks down when we have both a cost for the upgrade and a multiplier when the managers design only had the cost. While this lecture could have been edited to avoid a few minutes that were less than productive I have chosen to leave it unedited as I feel it is important for aspiring game developers to see real world game design decisions and learn how they are handled.

In this lecture we begin by looking at the XML we will use to define the store upgrades. This allows us to restructure XML loading methods so they can handle the new upgraded store design. While we still have a major design step ahead of us, this lecture takes us much closer to having our multiple store upgrade design implemented.

We have come a long way without creating the primary class that will represent our storeupgrade. It would have been a completely legitimate development decision to start by making this class first and working backwards towards the interface design. In fact if we were not building off the already functional manager mechanisms we probably would have taken that approach.

When the Upgrade button is clicked it is still wired into calling methods inside of our store class instead of our storeupgrade class. In this lecture we get the core mechanics of our multiple store upgrade in place.

JULY 2017 - Unity Business Tycoon Upgrade 2.0! Many new features

• Automatically saves your game
• Calculates profits while the game is not running (make money when away!)
• Screen to display profits while you were gone
• Scroll lists that work
• unlimited stores
• Improved performance with threading and coroutines
• Buy multiplier button for buying multiple stores at a time
• Optimized buy math and formulas (no loops)
• Earnings per second
• Support for big number descriptions up to 300+ power
• Generate Idle Game Data with procedurally generated stores, managers, and upgrades - INCLUDES CUSTOM INSPECTOR!
• Load and Save Game Template settings
• Improved Screen Layout
• Handle "Angel" investors or "Shareholders" "Transcendence" also known as NewGame+

Design and coding improvements

In this lecture we begin walking through some of the upgrades that have been made to the game manager. Specifically we begin with namespaces and we have included them throughout the project to better encapsulate our scripts and prevent them from conflicting with other modules or code you would bring into the project. Then we look at some basic uses of constants and how they are use much like variables... but cannot be changed at runtime.

Finally we look at how we can improve our overall design to protect the properties in our classes using setters & getters.

In this lecture we begin walking through some of the upgrades that have been made to the game manager. Specifically we begin with namespaces and we have included them throughout the project to better encapsulate our scripts and prevent them from conflicting with other modules or code you would bring into the project. Then we look at some basic uses of constants and how they are use much like variables... but cannot be changed at runtime.

Finally we look at how we can improve our overall design to protect the properties in our classes using setters & getters.

In this lecture we will review how we used a CSV file to store hundreds of big number descriptions and load it into an arraylist. We then use LINQ to find the correct description for a given value.