- Game Design.

- Level Design.

- Game Loops (Definition, Challenge, Rewards, ...).

- Systems (Sizes, Systemic design, ...).

- Player profiles (Bartle taxonomy).

- Player Immersion (Dominic Arsenault, Henry Jenkins, ...).

- Economic Design.

- Narrative Design.

- UX and Human Psychology.

- Game Feel (Juiciness, Polish, ...).

- QA.

- C++ and Blueprint Visual Scripting

- Organize the codebase on the C++ and Blueprint side (including other not BP assets)

- I usually apply a modular design to my workflows, scripts and actors/components to make the integrations and future changes as seamless as possible. This speeds up a lot the iterations

- Smart use of actor palettes, world materials, shortcuts for quick then detailed placement

- I make my UI features, code, design and prefabs modular as much as needed (and possible) to fit the current needs and any future changes. This improves the iteration speed when adding/removing UI menus/elements.

- Make all UI content decently readable so no users are lost in the menus and options.

- Think through all usages of our AIs before implementing a system.

- Good knowledge of AI Controllers, Behavior Trees, State Trees and their components.

- How networking works in UE.

- Implementation and use of the Epic Online Services (EOS) framework through the EOS SDK and UE plugins.

- Lightweight and safe replication with client prediction.

- Ability System Component.

- Attributes.

- Gameplay Abilities.

- Gameplay Effects.

- Proper debugging using Rider IDE.

- Using UE console commands (And creating new ones).

- UE asserts (check, ensure, ...).

- UE logging.

- UE draw debug (Engine defaults, custom show flag, component visualizer, ...).

> Focus system

- If a player looks a usable item and is close enough they will see an interactive UI.

- The UI displays the required action (press, hold) as well as the key (dynamicly fetched from the player input settings).

- The UI is different depending on external data (if required).

> Use system

- Use press and hold.

> Carry system

- Pick up item from source.

- Move around with item.

- Place item to target (with customizable rules).

- Update Instance Static Mesh Component meshs on new count.

> Inventory system

- Each inventory component is initialized using a Primary Data Asset. This asset defines the max slot amount and what items are added by default.

- Each inventory component owned a GameplayTag Container, allowing custom behaviors depending on possessed items and more

- Many features such as Add (and Pickup), Remove (and Drop), Move, Swap, Rearrange if slot/inventory full.

- Using Fast Array serialization the inventory data is correctly replicated between all clients and to the local player UI.

- Hotbar system, the player can freely assign any equipable item that they own to the hotbar. The player can scroll to select the item they want and use it.

> Equipment system

- Predefined equipment slots (head, body, ...)

- Many features such as Add (and Pickup), Remove (and Drop), Move, Swap with slot type filtering.

- Depending on equipped/unequipped equipment items various Gameplay Effects are added/removed to the owning player.

> Item system

- The items are shared between the inventory system, equipment system and other systems.

- For the items definition, I used Data Assets to be able to easily async load them at runtime

- For the items behaviors at runtime, I used instanced structs with Gameplay Abilities and Gameplay Effects (On Use, On Hold, On Equipped, ...)

- The construction menu and further interactions (select, placement, cancel, ...) all come from a usable item (see inventory system).

- Actions: Select building, preview placement, pre-place, confirm/cancel pre-placement. Those actions are replicated if the other players are close enough.

- Other options such as snapping to surface or other pre-placed/placed buildings.

- Machine system inspired by Satisfactory.

- Source machines: burners (burns fuel to make electricity).

- Target machines: constructors (consumes electricity to craft selected item receipt).

- Electric poles and cables (to connect machines).

- Each machine can hold 1 to 2 inventories (input and output). The player can interact with the machine to set its behavior/use the inventories.

> Multiplayer endless runner:

Dynamicly spawn level instances while the players are running forward.

> Multiplayer world time system:

Server authority time with client prediction. Various actors and other systems would bind to it to trigger various events at specific days, hours or minutes count.

> Multiplayer routine system:

Inspired from The Escapist, the routine system is a list of tasks assigned to all prisoners, each task has a time frame to complete it and a optional location to go to. Some special routines such as the job one required extra actions to compelte it.

> Multiplayer job system:

Inspired from The Escapist, the job system allows custom job types, coupled with interactions. For example: "Carry those 3 boxes from here to there".

- Using C# and Unity framework.

- Good organization and naming conventions.

- Always preferring the modular (not hardcoded) path.

- Used Unity legacy tools and Pro Builder plugin to make levels.

- I usually apply a modular design to my workflows, scripts and prefabs to make the integrations and future changes as seamless as possible. This speeds up a lot the iterations

- I make my UI features, code, design and prefabs modular as much as needed (and possible) to fit the current needs and any future changes. This improves the iteration speed when adding/removing UI menus/elements.

- Make all UI content decently readable so no users are lost in the menus and options.

- AI modularity for seamless iterations

- State machines with various behaviors

- For a solo school project I chosed to make an Endless Runner in less than 3 months.

- I made a CSV Reader to convert my google sheet values into weighted lists. Those lists were used at runtime by the level generator to determine what elements to spawn, at what distance, interval, height, etc

- This runtime level generator also handled background elements.

- To properly debug the generation, I used in various way Unity's Gizmo draw methods.

- This was also for the Endless Runner project. Since I was limited to the space bar, the goal was that depending on the player and level context, specific actions would occure when pressing/holding/releasing the space bar.

- So instead of having X default actions (go left, go right, jump, slide) that can be done anytime, I wanted to only allow jumping and sliding, and the other actions would only be available at specific distances to the trap.

- Since the player is constantly going forward, all the actions (Jumping, Sliding, Go Left, Go Right, Boost climing, Boost zipline, Vault) are using root "motion" animations, this means that the animation play rate and placement would be determined at runtime depending on the player position.

- For a brawler (combat) school project, we needed various states for our AIs, and most of those states were determined by data, such as the cooldows, recovery time, etc (See here)

- Our AIs had 4 main states:

- Idle: The AI doesn't do anything (Before the AI would move around randomly before the player goes inside the arena, but because of our design choices we removed that))

- Attacking: The AI would track the player while they are in the arena (using AI Nav Agent), once the player close anough it charges its attack and does a specific amoutn of damage if the player is in the damage zone (Each AI had a different damage shape).

- Recovering: After the attack sequence, the AI recovers for a specific amount of time. If nothing happens to the AI, it will eventually go back in attack mode.

- Pushed: If the AI is attacked by the player and hit, it's "pushed", meaning the AI would play an animation and fall on the ground, making it vulnerable. If an AI is pushed on another (that isn't pushed) it will push it, creating a chain reaction.

- All of those states are debuggable with a UI canvas and reflected with visual and sounds effect (player feedbacks).

- Frontend: HTML, CSS, JavaScript

- Backend: PHP, SQL

- Other tools: Mermaid, XAMPP

- Actions: Commit, pull, push, fetch, cherry-pick, rebase, merging, handling multiple versions on multiple branches, ...

- Tools: Git, Github, Gitlab, Diversion and Perforce.

- Video montage & derush using Premier Pro.

- FX: Simple or multi-layered visual and sound effects using After Effects.

- Music: Sync the effects and transitions seamlessly with the music and sound effects.