Discover Top Posts Tagged with #games programming

Popular Recent

Screaming and clawing at my eyes because I'm genuinely considering trying to learn how to code a computer game again due to a great idea

Maybe unlike at uni I won't have another depressive breakdown, and hey I don't think I can get any more trans than I am already

#games #computer games #video games #games programming #programming

I HAVE A MOCK INTERVIEW IN 20 MINS so have a summary of every game programming pattern except 6. You can find out more about them here, as that's what I'm summarising from

command

Putting an extra layer between the input and the execution that allows you to swap out what each input actually does at run time, it also means that the input doesn't call the execution directly meaning you can delay it. Most known for its use in undo and redoing actions.

flyweight

Pulling all common data from an object which will be displayed multiple times, loading it into memory once and referencing this data wherever it needs to be displayed on screen. Each instance of the object will hold its own unique parameters but will be far more lightweight. E.g. when displaying trees the model and basic data will be held as common data and only loaded once. but the position will be stored in the instance

Observer

Using events to decouple different systems in the game. A script sends out an event and any class which may need to know about it will add a listener with an attached function to implement if that event is called. Doesn't require classes to explicitly know each other, and the broadcasting class shooting off the event needs no knowledge of its listeners.

prototype

Creating a parent class with base virtual functions with the basic functionality for a given set of objects, then overriding those functions in its child classes for custom behaviour (if necessary). Means that a set of objects always has the same function names for another class to call on and reduces how much code is needed when child Classes do not need to override functions to their own implementation.

singleton

A class which can only have one instance and has global access to it. Is initialized at runtime and only if needed. However they're global, discourage concurrency and encourages coupling

State

Creating a set of states and transitions (finite state machine) with different functionalities and behaviours you can switch between when certain conditions are met. You can only be in one state at a time.

double buffer

Having two frame buffers, one displaying the current frame and another loading the next one. It then swaps the frames one in once it's fully loaded rather than writing over the current frame which can lead to rendering errors.

game loop

Functionality that loops so long as gameplay is active e.g. update or tick (called each frame), fixed update (called at a fixed interval 50 times a second)

update

All a game objects behaviour is kept within its own update rather than the main game loops update. The main game loop calls on these update functions each frame and then the object handles its own behaviour.

event queue

Storing requests in first in first out to prevent them being processed simultaneously. Allows for control over when certain actions happen.

type object

Instead of inheriting from a class directly, have two classes which reference each other, one which stores the objects base data that's similar across all objects (e.g. animal, pathfinding) and one which stores specific information and implementation (e.g. Breed) allows for creation of lots of different breeds just by changing parameters instead of creating new inherited children of animal

dirty flag

When primary data (e.g transform data) changes on an object it sets its flag to dirty which means it and it's child objects needs updating. Rather than redoing and updating calculations every frame when the data is the same as before.

#game dev #programming #games programming #gamedev #game development #codeblr #progblr

Progress update #1

The game i’m required to create for my assignment is an indie horror game in the style of games of the same genre from the PS1 era, as this is the current trend in indie games. I tried to think of games that I knew of from that era, the most popular one I could think of was resident evil. But I wanted to be a bit different. So the premise of my game is as follows: “Earth has been ravaged by a deadly disease following a meteor crash. The disease turns people into zombified alien-like creatures who devour anything that moves. In a last ditch effort to escape, a small team of survivors are launched into space to escape the virus and live the rest of their lives on a space station. You play as one of those survivors. One day you awaken to the deafening sound of a red alert siren. Immediately knowing something is wrong you investigate, only to find your worst fears have been realised. You didn’t escape the virus, because it’s on the ship with you. And the only escape is the cold blackness of space.You must fight to survive, as the final hope of the human race slowly begins to burn out” While I realise it’s cliche to have ‘zombies’ in my game, I felt this was the best choice as it means I can focus more on making the atmosphere work for the game, rather than having to come up with something completely new in a short amount of time. I felt that the space element gave it a little bit more of a modern feel while still keeping with the themes. I plan to use shaders to portray the look of a ps1 era game without needing to rely on bad looking assets, so the game will still look good.

#Progress update #University #Uni assignment blog #Games Programming #Video games creation #indie horror

Uni Games Programming Progress Blog Intro

For one of my assignments, i’m required to keep a community blog of my progress for a game i’m working on. So that’s what most of my posts will be. It’s basically why I made this account, but if you’re interested in following my progress with the game then this is the place to do it!

#University #Games Programming #Video games creation #Uni assignment blog

Winter Rush [December 2018]

Second game made with a team in Unity. Actually got time to test and polish it before releasing.

Link to the game: https://oleglo.itch.io/winter-rush

Lessons taken from the project:

- Make sure the artist has some kind of reference for the resolutions to use. Print them and give them to them.

- Paint + ScreenToGif does wonders when it comes to communicating with an artist. Much clearer than words.

- For the GameManager, take the time to make a small description at the start of the script that describes the structure of the file.

- Make sure the GameManager handles situations where there is accidently more than one GameManager in the game.

- For scripts that require a lot of references, make sure to create some kind of Init() function and a isInit boolean. This avoids a spam of errors if some references are missing. Makes it easier to handle errors.

- Organize your tilemap palette well. You’ll be shaving off half a second every time you need to switch tiles if the palette is well organized, which in the end will save you time.

- Create variables to work with that are updated each frame rather than checking values inside statements. This avoids unnecessary function calls and makes code more readable.

- Make people that don’t usually play games play your game (parents, grandparents, etc.) to see if it is accessible or not. Good way to check if the controls are explicit enough.

#games programming #student #unity

Bubble Gum [December 2018]

First game made on Unity in a team with another Games Prog + Games Art.

Link to the game: https://oleglo.itch.io/bubble-gum

Organization lessons taken from the project:

- Better stress management.

- Be mindful to keep things tidy, anything done in a messy manner is amplified ten times when working in a team.

- Modify file structure only after receiving acknowledgement from the rest of the team.

- Manage sounds with a specialized script.

- Push changes to main branch only after they are working properly and there aren’t any major bugs. No half-assed pushing.

- Separate game into different scenes when possible.

- READ UNITY DOCUMENTATION.

- Separate badly readable code into functions.

- If doing any kind of trigger and/or collision detection with tilemaps, use composite colliders. Makes AI coding thousands times easier.

- When possible, take the time to merge code with your colleagues and clean and explain the code before merging.

- If creating a WebGL build of the game, create a Standalone as well.

- Make sure the player sees the game’s controls before playing.

- BE A HEARTLESS BASTARD WITH YOUR GAME ART.

- Aim for a MVP: Minimal Viable Product.

- Use Debug.LogError() and similar to catch errors.

- Separate game physics from the rest and put it in FixedUpdate().