1.4b Computational Methods

Computational Thinking is all about how you tackle and issue and you solve the issue that is faced ahead of you and how you went about fixing that issue and improving the thing you're working on. It is a way of thinking, and making problems be turned into an algorithm that you can more easily tackle and figure out solutions to. Using computational methods allows me to be more efficient in my coding and be able to create a useful solution to a problem, and this is why I will be using them in my project for the following features:

• Computational methods allow for saving systems which allow for me to be able to accurately and quickly fetch where the player has saved and their progress.

• the game is able to pick up the key inputs and translate that into movement in game which is essential for the player to interact with the game.

• The game needs to have a graphic element to it so that the player is able to properly see what is happening and react to what is going on. This will also need the implementation of physics such as acceleration for things to move and react realistically.

Thinking Abstractly and Visualisation

Abstraction is the act of simplifiying a problem into its core components and removing any unnecessary details. Thinking abstractly is essential for the development of a game as it means that you are able to properly implement the game's core mechanics and features without being distracted by other problems, which makes the gameplay more enjoyable and improves the playability. The key ideas that I will use abstraction to focus on is:

• Puzzles and obstacles in game as these will require a focused and logical way to get past them, and allowing them to have a sense of purpose and placement in the map. This will also apply to enemies, which will have set routese and patrols or certain engagement ranges so that the player is able to react accordingly.

• The graphics of the game do not need to be cutting edge, as this doesn't particularly help with the development of the core featues, and a vector art style will be plenty for the scope of the project.

• There needs to be a clear and sensible main menu and pause menu as this will allow the player to easily navigate the menu and inform them. A fancy looking menu doesn't add much to the experience of the use and would distract from the core features of the game which is the key focus for the game.

Thinking Ahead

Thinking ahead is the act of planning out the nessecary preconditions and is an essential step in visualising what the game will look like ahead of time, and formulating an idea of what step you'll need to take in order to get there. This is an must as whilst you're coding you tend to forget about the thing you are trying to make and you need to take a step back to see what you've done and what you need to do next, and this helps to plan out your development.

For this project I need to keep a detailed plan of what featues I need to implement and how I should go about doing that. This helps to get an idea of what code I need to be able to implement these features efficiently and without excess code, which helps to have organised and well built code that is easy to debug if nessecary in the future.

For example I can do this to help with the implementation of the control system which needs to be simple and intuitive for the user which can be helped by design how it will work in advance so that it is well designed, and doesn't confuse the user by using the controls. It may also help the user if they are able to customise the controls or how sensitive they are, as this would allow them to feel more comfortable playing the game.

Thinking Procedurally and Decomposition

Decomposition is the process of breaking down a task into all of it's different sub processes which helps with finding an efficient solution to a problem and helps to reduce the time to find a solution too. This helps because it means that your code can be well designed and structured and also helps if you want to refactor code for different parts of the code, which helps to debug and work out different solutions to a problem.

In my game I will have to focus on each task separately, making sure to refer back to my success criteria as this will help me layout my code and make sure that I'm implementing the features that I need and removing any that are unnecessary and don't add to the core features of the game. Using this will help me not loose focus on my key features, and ensure that I implement all features well and in time for the end of the project.

Thinking Logically

Thinking logically is the process of deciding where certain actions need to happen and what conditions those need to be under to affect the outcome. Logical thinking is all about how the game design allows you to determine the key decision points in the game and to think about how the current game state will affect decisions later on.

• The game needs to monitor itself to find when the player has changed to a different planet or finished the game.

• The enemies will have a certain patrol path or radius in which they attack that needs to be made so that they attack the player.

• The program needs to save the player's progress at suitable times, such as when they switch planets or when they pause for example.

• When a user presses a key, the game needs to react appropriately such as pressing D to go right, or the left arrow key to go left.

Thinking Concurrently

Thinking concurrently is about identifying what parts of the game can be run simultaneously. This gives the illusion of the game running many processes at the same time, but they are just processing each frame. This is important as it allows me to decide which processes can be calculated in each frame in a game and give the illusion of concurrency. For this to I need to:

• Have the game display each refreshed movement of the player.

• The position of the player in relation to the enemies needs to determined each frame, and this includes when other enemies are moving.

• When moving planets the background needs to move similarly so that it gives the illusion of movement.

Today, many game engines help with concurrent executions, with the inclusion of a n update function, which is called in each frame. I can do this similarly with Phaser.js, and it helps to have multiple functions be called linearly whilst the user sees everything happening concurrently.