Enfusion Engine

In the Enfusion Engine, I work mostly on Audio Editor & Audio Engine.
I have ownership over the signals editor, which works directly with audio to evaluate in-game values (such as material IDs) and do mathematical expression in node form on them.
I also make a variety of debugging tools and improve the user experience for modders and audio designers on a daily basis.

Arma Reforger

My work on Arma Reforger consists of a variety of things. I was responsible for most of the sound to gameplay connections, such as weapon interactions, vehicles, etc...
Amongst a lot of other things, My responsbilities include implementing music managing systems, new in-game debugging tools, a multiplayer synchronized radio system and working on interior detection.

Mythifood Adventure

Chef Pierre and his assistant Alain are cooks in a very sought-after tavern deep within a mythical forest. Together they are tasked with the difficult mission to provide your customers with the wildest and freshest meal you can procure. You must gather these ingredients from the mythically possessed food creatures that inhabit the areas around your tavern. The dynamic duo must venture out into the dangerous wilderness to chase, battle and search for the magical foodstuffs that have sprung to life due to a magical spell. But the fact that they are now alive, does not make them any less delicious. Brave chef Pierre and his assistant Alain are the only ones with the skill and knowledge to collect the ingredients to make the finest dishes on the continent.

Eggers

Eggers is made as a personal project and making use of the Twitch IRC interface. It was developed specifically as fan game for popular twitch streamer "Mizkif" and their audience.
Following topics are delved into with this project:

• Resolving interaction of a player base that is limited to Chat Commands and dealing with the large quantity of players (500+) by utilizing build-in physics and limited interactions.

• Experiencing the fluent workflow between C++ classes and Blueprints and how to properly utilize their potential.

• Using the Twitch API and Documentation to create IRC connections with the Twitch IRC Network.

• Parsing received client messages and sending out properly formatted messages to the client.

• Creating interactive interfaces with usage of UMG, Scrollboxes, resizeability,..

Check the progress on future & past updates here: Eggers - A Mizkif Twitch Game | Trello.

CODE SAMPLES

//Creating endpoint & listener socket
FIPv4Endpoint endPoint{FIPv4Address(127,0,0,1), 6667};
m_pListenerSocket = FTcpSocketBuilder(TEXT("TwitchListener")).AsReusable().BoundToEndpoint(endPoint).Listening(8);

//Set Buffer size
int32 newSize = 0;
m_pListenerSocket->SetReceiveBufferSize(2 * 1024 * 1024, newSize);

GetWorldTimerManager().SetTimer(m_TimerHandle, this, &APlayerRegisterer::SocketListener, 0.01f, true);

SendLogin();

void APlayerRegisterer::SendLogin()
{
//Create resolve info
const FResolveInfo* pResolveInfo{ISocketSubsystem::Get()->GetHostByName("irc.chat.twitch.tv")};

//Check if we got a resolving issue
if(pResolveInfo->GetErrorCode() != 0)
{
	UE_LOG(LogTemp, Warning, TEXT("ERROR: Couldn't resolve hostname."));
	return;
}

const FInternetAddr* address{&pResolveInfo->GetResolvedAddress()};

uint32 outIP{};
address->GetIp(outIP);

int32 port{6667};

TSharedRef addr{ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr()};
addr->SetIp(outIP);
addr->SetPort(port);

m_pListenerSocket = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream, TEXT("default"), false);

bool connected = m_pListenerSocket->Connect(*addr);
//Check if we are connected with the socket.
if(!connected)
{works that I've mostly
	UE_LOG(LogTemp, Warning, TEXT("ERROR: Failed to connect with socket."));
	//Close socket if it would be open.
	if(m_pListenerSocket)
	{
		m_pListenerSocket->Close();
	}

	return;
}

FString test = "PASS oauth:" + m_AuthKey;
SendString(TEXT("PASS oauth:" + m_AuthKey));
SendString(TEXT("NICK " + m_UserName));
SendString(TEXT("JOIN #" + m_StreamerName));

if(m_TagsEnabled)
{
	//Enable tags
	SendString(TEXT("CAP REQ :twitch.tv/tags"));
}
}
					

void AStreamerSpectatePawn::FocusNext()
{
if(!m_Spawner->IsValidLowLevel())
	return;

TMap players = m_Spawner->GetPlayers();
TArray twitchPlayers;
players.GenerateValueArray(twitchPlayers);

if(twitchPlayers.Num() <= 0)
	return;

m_CurrentFocus++;
if(m_CurrentFocus > twitchplayers.Num() - 1 || m_CurrentFocus < 0)
{
	m_CurrentFocus = 0
}

m_Controller->SetViewTargetWithBlend(twitchPlayers[m_CurrentFocus], m_BlendTime);
m_pInGameHud->SetSpectatePlayer(twitchPlayers[m_CurrentFocus]->GetUserName(),twitchPlayers[m_CurrentFocus]->GetChatColor());
m_FocusedPlayer = twitchPlayers[m_CurrentFocus];
}
					

void AStreamerController::SwapMode()
{
//Checking if it's in game mode or spectator mode.
if(m_SpectateMode)
{
	PlayerState->SetIsSpectator(false);
	Possess(m_Pawn);
	ChangeState(NAME_Playing);
	ClientGotoState(NAME_Playing);

	m_SpectateMode = false;
}
else
{
	PlayerState->SetIsSpectator(true);
	ChangeState(NAME_Spectating);
	ClientGotoState(NAME_Spectating);
	m_SpectateMode = true;
}

m_pInGameHud->SetSpectatorMode(m_SpectateMode);
}
					

void ATwitchChatPlayer::Boost(int strength, const FVector& direction)
{
//Checking that the strenght can not be activated too high
if(strength > m_MaxBoostStrength)
{
	strength = m_MaxBoostStrength;
}
//Making sure that the strength does not go under 1
else if(strength <= 1)
{
	strength = 1;
}

//Getting the direction the egg is laying
FVector dir = m_pStaticMeshComp->GetUpVector();
if(direction != FVector::ZeroVector)
{
	dir = direction;
}

//Creating a force to use as impulse.
//Normalize Direction
dir.Normalize();
FVector force{dir * m_BaseBoostStrength * strength};

m_pCollisionComp->AddImpulse(force,NAME_None, true);
}
					

DEADBEAT

DEADBEAT was a group project made on Digital Arts And Entertainment.
I was responsible for following topics:

• BPM Handling (on-beat object reactivity, ...)

• Grid System & Trap spawning

• Trap Behaviour

CODE SAMPLES

void AGrid::GenerateGrid()
{
//Generate indices in X and Y position on the grid

//Clean-Up arrays
m_CellMap.Empty();
m_OpenCellMap.Empty();

//Fill Array with cells, each cell will have a 2D index as well.
for(int x = 0; x < m_Columns; ++x)
{
	for(int y = 0; y < m_Rows; ++y)
	{
		FCell cell{};
		cell.spawnPoint = GetWorldPosFromIndex(FVector2D{float(x),float(y)});
		m_CellMap.Add(FVector2D{float(x),float(y)}, cell);
	}
}	

m_OpenCellMap = m_CellMap;

m_pCollisionBox->SetBoxExtent(FVector{(m_TileSize*m_Rows) * 0.5f,(m_TileSize*m_Columns) * 0.5f, 20.f});
m_pCollisionBox->SetRelativeLocation(FVector{0.f,0.f,10.f});
}
						

//___INIT___
//Keeping the current time.
m_AudioStartTime = UGameplayStatics::GetAudioTimeSeconds(this->GetWorld());
//Setting the crotchet (Quarter Note)
m_Crotchet = 60/m_Bpm;

//___UPDATE___
if(!m_IsMusicPlaying)
{
	return;
}

//Check position of song
m_SongPos = float((UGameplayStatics::GetAudioTimeSeconds(this->GetWorld()) - m_AudioStartTime));
//If the position of the song is bigger than whatever the lastbeat amount was + a quarter note, we can assume there's a beat.
//This ensures us that there is no usage of frame dependancy --> No/Minimal latency.
if(m_SongPos > m_LastBeat + m_Crotchet)
{	
	//Adding a quarter note to the lastbeat value to keep track of beats
	m_LastBeat += m_Crotchet;	
}
						

bool ABeatHandler::CheckInRhythm()
{
	//Check the current input time
	m_InputTime = float((UGameplayStatics::GetAudioTimeSeconds(this->GetWorld()) - m_AudioStartTime));

	//Calculating the last beat and adding a 4th note (crotchet) to it.
	float totalBeat = m_LastBeat + m_Crotchet;

	//Check if within a certain offset from the beat -> ----[-----!BEAT!-----]----
	return(m_InputTime > totalBeat - m_InputOffset && m_InputTime < totalBeat + m_InputOffset )
}
						

Kribby AfterBlast

Kribby AfterBlast is a project made to simulate some of the main mechanics of Nintendo's Kirby's Blowout Blast.
The provided engine was based on DirectX 11. Some code was provided (usage of hlsl, ...), which was used as a foundation to build further on.
Researched topics:

• Toon Shader

• Post Processing

• Skybox Rendering

CODE SAMPLES

float4x4 gMatrixViewInverse : VIEWINVERSE;
float4x4 gView : VIEW;
float4x4 gWorld : WORLD;
float4x4 gWorldViewProj : WORLDVIEWPROJECTION; 
float3 gLightDirection = float3(-0.577f, -0.577f, -0.577f);

Texture2D gDiffuseMap;

//Ambient color
float4 gAmbientColor = (0.4, 0.4, 0.4, 1);

//Specular value + glossiness
float4 gSpecularColor = (0.6, 0.6, 0.6, 1);
float gGlossiness = 0.1;

//Rim Color, thresh hold & amount
float4 gRimColor = (1, 1, 1, 1);
float gRimAmount = 0.516;
float gRimThreshold = 0.8f;


SamplerState samLinear
{
	Filter = MIN_MAG_MIP_LINEAR;
	AddressU = Wrap;// or Mirror or Clamp or Border
	AddressV = Wrap;// or Mirror or Clamp or Border
};

RasterizerState Solid
{
	FillMode = SOLID;
	CullMode = FRONT;
};

BlendState DisableBlending
{
	BlendEnable[0] = FALSE;
};


struct VS_INPUT
{
	float3 pos : POSITION;
	float3 normal : NORMAL;
	float2 texCoord : TEXCOORD;
};

struct VS_OUTPUT
{
	float4 pos : SV_POSITION;
	float3 normal : NORMAL;
	float2 texCoord : TEXCOORD;
};

DepthStencilState EnableDepth
{
	DepthEnable = TRUE;
	DepthWriteMask = ALL;
};

RasterizerState NoCulling
{
	CullMode = NONE;
};

//--------------------------------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------------------------------
VS_OUTPUT VS(VS_INPUT input)
{
	VS_OUTPUT output;
	output.pos = mul ( float4(input.pos,1.0f), gWorldViewProj );
	output.normal = normalize(mul(input.normal, (float3x3)gWorld));
	output.texCoord = input.texCoord;
	return output;
}

//--------------------------------------------------------------------------------------
// Pixel Shader
// The implementation of this Toon shader is heavily based on the following article https://roystan.net/articles/toon-shader.html
// Some adjustments were made to compensate with the simplicity of the scene.
//--------------------------------------------------------------------------------------
float4 PS(VS_OUTPUT input) : SV_TARGET
{
	//The shader makes use of a very simple blinn-phong material

	//Get the normal
	float3 normal = normalize(input.normal);
	//Most likely using view inverse will yield more accurate results
	//However, during experimenting, using the non inversed version will result in more fake texture depth.
	//Which is preffered considering the camera angle,...
	float3 viewDir = { gView[2][0], gView[2][1], gView[2][2] };

	//calculate the illumination from the directional light
	float NdotL = dot(gLightDirection, normal);

	//Specular reflection calculation
	float3 halfVector = normalize(gLightDirection + viewDir);
	float NdotH = dot(normal, halfVector);
	float specularIntensity = pow(NdotH * 0.1f, gGlossiness * gGlossiness);
	float specularIntensitySmooth = smoothstep(0.005, 0.01, specularIntensity);
	float4 specular = specularIntensitySmooth * gSpecularColor;

	//simple light to turn things down in brightness
	float4 light = { 0.5f, 0.5f, 0.5f, 0.5f };

	// Calculate rim light
	float rimDot = 1 - dot(viewDir, normal);
	float rimIntensity = rimDot * pow(NdotL, gRimThreshold);
	rimIntensity = smoothstep(gRimAmount - 0.01, gRimAmount + 0.01, rimIntensity);
	float4 rim = rimIntensity * gRimColor;

	//Sample our texture
	float4 diffuseColor = gDiffuseMap.Sample( samLinear,input.texCoord );

	//set the alpha value to 1
	diffuseColor.a = 1.f;
	//full calculation
	return (gAmbientColor + specular + rim) * diffuseColor * light ;
}

//--------------------------------------------------------------------------------------
// Technique
//--------------------------------------------------------------------------------------
technique11 Default
{
pass P0
{
	SetRasterizerState(NoCulling);
	SetDepthStencilState(EnableDepth, 0);
	SetBlendState(DisableBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
	SetVertexShader( CompileShader( vs_4_0, VS() ) );
	SetGeometryShader( NULL );
	SetPixelShader( CompileShader( ps_4_0, PS() ) );
}
}

float grainfix(float2 st)
{
	return frac(sin(dot(st.xy, float2(17.0f, 180.f))) * 2500.f);
}
							
//PIXEL SHADER - GRAIN EFFECT
//------------
float4 PS(PS_INPUT input) : SV_Target
{
	float2 uv = input.TexCoord.xy;

	//make noise based on the UV's
	float grain = grainfix(uv);
	float3 grainPlate = float3(grain, grain, grain);

	float4 color = gTexture.Sample(samPoint, uv);

	float3 final = lerp(color.rgb, grainPlate, 0.1f);

	return float4(final, 1.f);
}

//PIXEL SHADER - PIXELATION EFFECT
//------------
float4 PS(PS_INPUT input) : SV_Target
{
	//get dimensions
	float width = 0.f;
	float height = 0.f;
	gTexture.GetDimensions(width, height);

	float4 color;

		float dx = gPixelW * (1. / width);
		float dy = gPixelH * (1. / height);
		float2 coord = float2(dx * floor(input.TexCoord.x / dx), dy * floor(input.TexCoord.y / dy));
		//get sample
		color = gTexture.Sample(samPoint, coord);

	return float4(color.rgb, 1.f);
}

//=============================================================================
//// Shader uses position and texture
//=============================================================================
SamplerState samPoint
{
	Filter = MIN_MAG_MIP_POINT;
	AddressU = Mirror;
	AddressV = Mirror;
};
Texture2D gTexture;
Texture2D gLUT;

#define MAXCOLOR 15.0
#define COLORS 16.0

float gContribution = 1.f;

/// Create Depth Stencil State (ENABLE DEPTH WRITING)
DepthStencilState depthStencilState
{
	DepthEnable = TRUE;
	DepthWriteMask = ALL;
};
/// Create Rasterizer State (Backface culling) 
RasterizerState backCulling
{
	CullMode = BACK;
};

BlendState DisableBlending
{
	BlendEnable[0] = FALSE;
};


float4x4 gMatrixViewInverse : VIEWINVERSE;
float4x4 gView : VIEW;

//IN/OUT STRUCTS
//--------------
struct VS_INPUT
{
	float3 Position : POSITION;
	float2 TexCoord : TEXCOORD0;
};

struct PS_INPUT
{
	float4 Position : SV_POSITION;
	float2 TexCoord : TEXCOORD1;
};


//VERTEX SHADER
//-------------
PS_INPUT VS(VS_INPUT input)
{
	PS_INPUT output = (PS_INPUT) 0;
	// Set the Position
	output.Position = float4(input.Position, 1.0f);
	// Set the TexCoord
	output.TexCoord = input.TexCoord;

	return output;
}


//PIXEL SHADER
//Helpfull source that was used: https://defold.com/tutorials/grading/
//------------
float4 PS(PS_INPUT input) : SV_Target
{
	//get dimensions
	float width = 0.f;
	float height = 0.f;
	gTexture.GetDimensions(width, height);

	//get sample
	float4 color = gTexture.Sample(samPoint, input.TexCoord.xy);
	float cell = floor(color.b * MAXCOLOR); 

	float cellL = floor(cell); 
	float cellH = ceil(cell);

	float halfX = 0.5 / width;
	float halfY = 0.5 / height;

	float rOffset = halfY + color.r / COLORS * (MAXCOLOR / COLORS);
	float gOffset = halfY + color.g * (MAXCOLOR / COLORS);


	float2 lutPosL = float2(cellL / COLORS + rOffset, gOffset);
	float2 lutPosH = float2(cellH / COLORS + rOffset, gOffset);

	float4 gradedColorL = gLUT.Sample(samPoint, lutPosL);
	float4 gradedColorH = gLUT.Sample(samPoint, lutPosH);


	float4 gradedColor = lerp(gradedColorL, gradedColorH, frac(cell));

	float4 finalColor = lerp(color, gradedColor, gContribution);



	return float4(finalColor);
}


//TECHNIQUE
//---------
technique11 ColorGrading
{
pass P0
{
	// Set states...
	SetRasterizerState(backCulling);
	SetDepthStencilState(depthStencilState, 0);
	SetBlendState(DisableBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
	SetVertexShader(CompileShader(vs_4_0, VS()));
	SetGeometryShader(NULL);
	SetPixelShader(CompileShader(ps_4_0, PS()));
}
}

Soul Reliant

Soul Reliant is a souls-like (Action Adventure) prototype project based on 2 keywords: Population & Depend. You can swap between 2 characters, which both have their unique "abilities".
The combat was based on souls-like combat: with rolls and sword-combos.

The bigger character must help the smaller character to climb on high walls, the smaller character can go under things the bigger can't.
The goal is to defeat all enemies in a certain area, then proceed to the next area.

Controller Compatible.

Beyond Vendavour

Beyond Vendavour is a platformer prototype project based on 2 keywords: Veil & Constraint.
You play as a character that can open a veil and use this to reduce it's downwards velocity.
You can do in air-boosts, praying at an altar will put a save state, "Karma Drive" is used as stamina.

Main platformer mechanics such as jumping, wall jumping, wall sliding,... is all implemented in this prototype.
The goal is to gather all crystals and get to the end of each level.

Controller Compatible.

CODE SAMPLES

private void OnTriggerStay(Collider other)
{
	if (other.gameObject == _player)
	{
		_playerScript.OnPlatform = true;
		_playerScript.PlatformBottom = _bottom.position;

		//calculating haptics based on the "Percentage" the player is from the platform.
		float hapticAmount = Mathf.Lerp(0f, 0.5f,(_collider.size.y - _bottom.localPosition.y)/(_player.transform.position.y - _bottom.position.y - _bottom.localPosition.y));
		if (Gamepad.current != null)
		{
			Gamepad.current.SetMotorSpeeds(hapticAmount, hapticAmount);
		}
	}
}
						

private void DoJump()
{
	if (!_gameManager.GamePaused)
	{
		//if player collides with wall, has drive left, and if its a different wall than the wall jumped on before (before floor collision) wall jump
		if (_wallCollision && _karmaDrive.CurrentDrive >= _karmaDrive.WallJumpCost && Vector3.Distance(_wallNormal, _prevWallNormal) > 0.001f)
		{
			if (_prevWallNormal != Vector3.zero)
			{
				//Check if the wall normal is different from the previous one.
				if (_wallNormal == -(_prevWallNormal))
				{
					_audioManager.Play("WallJump");
					_velocity += _wallNormal * _wallJumpSpeed;
					_velocity.y = _wallJumpHeight;
					_wallCollision = false;
					_jumpsLeft = 0;
					_karmaDrive.CurrentDrive -= _karmaDrive.WallJumpCost;
					//Store the previous wall normal to make sure a player can't wall hop.
					_prevWallNormal = _wallNormal;
				}
			}
			else
			{
				//If there's no previous wall normal , allow any normal wall jump.
				_audioManager.Play("WallJump");
				_velocity += _wallNormal * _wallJumpSpeed;
				_velocity.y = _wallJumpHeight;
				_wallCollision = false;
				_jumpsLeft = 0;
				_karmaDrive.CurrentDrive -= _karmaDrive.WallJumpCost;
				_prevWallNormal = _wallNormal;
			}
		}
		// If player has jumps left apply velocity.
		else if (_jumpsLeft > 0 && !_praying)
		{
			_audioManager.Play("Jump");
			_velocity.y = _jumpHeight;
			_jumpsLeft -= 1;
			_grounded = false;
		}
		//veil Dash
		else if (!_grounded && _veilActivated && _karmaDrive.CurrentDrive >= _veilDashCost)
		{
			_velocity += _charController.transform.forward * _veilDashSpeed;
			_karmaDrive.CurrentDrive -= _veilDashCost;
			_audioManager.Play("Dash");

			//if there is a gamepad connected.
			if (Gamepad.current != null)
			{
				//haptic
				Gamepad.current.SetMotorSpeeds(0.3f, 0.3f);
				_hapticEnabled = true;
			}

		}
	}
}
						

public class ThirdPersonCamera : MonoBehaviour
{
	private PlayerInputActions _cameraAction;

	[Header("Requirements")]
	[SerializeField]
	private Transform _target = null;
	[SerializeField]
	private Vector3 _offset = new Vector3(0f, 0f, 0f);

	private float _heading = 0;
	private float _tilt = 15;
	private float _playerHeight = 1;
	private float _rotationSens = 50f;

	private float _zoomSpeed = 20f;

	[SerializeField]
	private float _minZoom = 5f;
	[SerializeField]
	private float _maxZoom = 15f;

	private float _currentZoom = 10f;
	private Vector3 _targetOffset = Vector3.zero;

	//collision
	[SerializeField]
	private bool _collisionDebug = false;
	private float _collisionOffset = 0.35f;
	private float _adjustedDistance = 0f;
	[SerializeField]
	private LayerMask _collisionMask = 0;
	private Ray camRay;
	private RaycastHit camRayHit;

	private Transform _obstruction = null;
	private GameObject[] walls = null;
	private GameObject[] grounds = null;    
	void Awake()
	{
		walls = GameObject.FindGameObjectsWithTag("Wall");
		grounds = GameObject.FindGameObjectsWithTag("Ground");
		_obstruction = _target;
		//Locking cursor in the screen and making it invisible
		Cursor.visible = false;
		Cursor.lockState = CursorLockMode.Locked;

		_cameraAction = new PlayerInputActions();
		_cameraAction.CameraControls.CameraMovement.performed += AdjustRotationSpeed;
	}
	private void AdjustRotationSpeed(InputAction.CallbackContext context)
	{
		//Check if user is turning with controller, adjust speed based on this.
		//(there are better ways than this but currently a rough implementation
		//Debug.Log(context.control.name);

		if(context.control.device != InputSystem.GetDevice("Mouse"))
		{
				_rotationSens = 200f;
		}
		else
		{
				_rotationSens = 25f;
		}
	}
	private void OnEnable()
	{
		_cameraAction.CameraControls.CameraMovement.Enable();
		_cameraAction.CameraControls.CameraZoom.Enable();
	}

	private void OnDisable()
	{
		_cameraAction.CameraControls.CameraMovement.Disable();
		_cameraAction.CameraControls.CameraZoom.Disable();
	}

	//called after the update, necassary for camera since player could've moved in the other updates.
	void LateUpdate()
	{
		if(_target != null && !FindObjectOfType().GameEnded)
		{
			CameraMovement();
		}
	}
	void CameraMovement()
	{
		_targetOffset = _target.position + Vector3.up * _playerHeight;

		//Clamp mouse scroll wheel values
		float zoomValue = Mathf.Clamp(_cameraAction.CameraControls.CameraZoom.ReadValue(), -5f, 5f); ;

		_currentZoom -= zoomValue * Time.deltaTime * _zoomSpeed;
		_currentZoom = Mathf.Clamp(_currentZoom, _minZoom, _maxZoom);

		//getting the yaw on y axis
		_heading += _cameraAction.CameraControls.CameraMovement.ReadValue().x * Time.deltaTime * _rotationSens;

		//getting the pitch based on X axis mouse
		_tilt -= _cameraAction.CameraControls.CameraMovement.ReadValue().y * Time.deltaTime * _rotationSens;
		_tilt = Mathf.Clamp(_tilt, -80f, 80f);
		//transform the camera rotation to match these 2 variables.
		transform.rotation = Quaternion.Euler(_tilt, _heading, 0);
		CameraCollision();

		Vector3 desiredPos = _targetOffset - transform.forward * _adjustedDistance;

		transform.position = desiredPos;
	}

	void CameraCollision()
	{
		float camDistance = _currentZoom + _collisionOffset;

		camRay.origin = _targetOffset;
		camRay.direction = Vector3.Normalize(transform.position - _targetOffset);

		if(Physics.Raycast(camRay, out camRayHit, camDistance, _collisionMask))
		{
			_adjustedDistance = Vector3.Distance(camRay.origin, camRayHit.point) - _collisionOffset;
		}
		else
		{
			_adjustedDistance = _currentZoom;
		}

		if(_collisionDebug)
		{
			Debug.DrawLine(camRay.origin, camRay.origin + camRay.direction * _adjustedDistance, Color.red);
		}
	}
}
						

Engine & Bubble Bobble

Creating a custom-made engine and making Bubble Bobble as a proof of use for the engine. The CruptEngine uses an Entity Component System based on Austin Morlan's.

• Uses FMOD Core API.

• Uses the SDL Library as core.

• Uses the a Tile Parser to create maps (TmxLite) and parse them in Tiled.

• Uses an Entity Component System based on Austin Morlan's.

• Uses the observer pattern we can easily give a list of delegates in this engine. This list of delegates will receive a signal component. Containing certain data needed.

• Uses a command pattern for inputs, we can easily make new functionality and bind it to certain keyboard & controller buttons.

CODE SAMPLES

//Source & Inspiration: https://austinmorlan.com/posts/entity_component_system
crupt::EntityManager::EntityManager()
	: m_NrOfLivingEntities{}
{
	//Constructor Initializes queue with entity ids
	for(Entity e = 0; e < Max_Entities; ++e)
	{
		m_AvailableEntities.push(e);
	}
}

Entity crupt::EntityManager::CreateEntity()
{
	//Making sure that we are not going above a certain amount of entities, determined by Max_Entitites
	if(m_NrOfLivingEntities >= Max_Entities)
	{
		throw std::exception("EntityManager::CreateEntity - [ERROR] Maximum amount of Entities reached");
	}

		//We take the first idea that was pushed (eg. 0) by taking the front of the queue.
		//We then remove it from the available entities to ensure no other entity can take the same ID
		Entity id = m_AvailableEntities.front();
		m_AvailableEntities.pop();
		//Increase number of entities that are currently living
		++m_NrOfLivingEntities;
		//returning the id of the acquired entity to use.
		return id;
	}

void crupt::EntityManager::DestroyEntity(Entity entity)
{
	//Check if entity is not available due to the fatc that its bigger than the max allowed of entities.
	if(entity >= Max_Entities)
	{
		throw std::exception("EntityManager::DestroyEntity - [ERROR] Entity is out of reach");
	}

	//Reset the full signature of the given entity (clearing all components) (resets all bits to false)
	m_Signatures[entity].reset();

	//Add the new available ID to the end of the queue since now it can be used again.
	m_AvailableEntities.push(entity);

	//decrease number of living entities
	--m_NrOfLivingEntities;
}

void crupt::EntityManager::SetSignature(Entity entity, Signature signature)
{
	if(entity >= Max_Entities)
		throw std::exception("EntityManager::SetSignature - [ERROR] Entity is out of reach");

	//Add the signature to the array of signatures for this Entity.
	m_Signatures[entity] = signature;
}

Signature crupt::EntityManager::GetSignature(Entity entity) const
{
	if(entity >= Max_Entities)
		throw std::exception("EntityManager::SetSignature - [ERROR] Entity is out of reach");

	//returning the signature of the passed entity ID.
	return m_Signatures[entity];
}
							

namespace crupt
{
	class SystemManager : public Singleton
	{
	public:
		~SystemManager()
		{
			////Remove all the system objects
			for (std::pair pair : m_Systems)
			{
				delete pair.second;
				pair.second = nullptr;
			}
		}
		template
		T* RegisterSystem()
		{
			//Get the name of the system that has to be registered
			const char* typeName{typeid(T).name()};

			//Check if system is already registered
			if(m_Systems.find(typeName) != m_Systems.end())
				throw std::exception("SystemManager::RegisterSystem() - [ERROR] System is already registered!");

			//Create a new system of the given type, add this pointer to the system map
			T* system{new T()};
			m_Systems.insert({typeName, system});
			//return the pointer to use
			return system;
		}
		template
		void SetSignature(Signature signature)
		{
			//Get the name of the system
			const char* typeName{typeid(T).name()};

			//Check if system excists/is registered
			if(m_Systems.find(typeName) == m_Systems.end())
				throw std::exception("SystemManager::SetSignature - [ERROR] System could not be found! (Did you register it?)");

			//Set signature for the system
			m_Signatures.insert({typeName, signature});
		}

		template
		Signature GetSignature(Signature)
		{
			//Get the name of the system
			const char* typeName{typeid(T).name()};

			//Check if system excists/is registered
			if(m_Systems.find(typeName) == m_Systems.end())
				throw std::exception("SystemManager::GetSignature - [ERROR] System could not be found! (Did you register it?)");

			//Get signature for the system
			return m_Signatures.at({typeName});
		}

		template
		T* GetSystem()
		{
			//Get the name of the system
			const char* typeName{typeid(T).name()};

			std::unordered_map::iterator it = m_Systems.find(typeName);
			//Check if system excists/is registered
			if(it == m_Systems.end())
				throw std::exception("SystemManager::GetSystem - [ERROR] System could not be found! (Did you register it?)");

			T* system = reinterpret_cast((*it).second);
			//Return the system
			return system;
		}

		void EntityDestroyed(Entity entity)
		{
			//remove a given entity from all the systems.
			for (const std::pair& systemPair : m_Systems)
			{
				System* system{systemPair.second};
				system->m_Entities.erase(entity);
			}
		}
		void EntitySignatureChanged(Entity entity, Signature entitySignature)
		{
			//We have to notify	every system that the signature of the entity has changed.
			for (std::pair systemPair : m_Systems)
			{
				//get the needed data
				const char* type{systemPair.first};
				System* system{systemPair.second};
				Signature& systemSignature{m_Signatures[type]};

				//Check if the entity signature matches the system signature
				if((entitySignature & systemSignature) == systemSignature)
				{
					//If thats the case, add it to the set
					system->m_Entities.insert(entity);
				}
				else
				{
					//Entity signature does match the system signature, erase it from the entities set
					system->m_Entities.erase(entity);
				}
			}
		}
		SystemManager() = default;
	private:

		//Map from a system/name string to a signature
		std::unordered_map m_Signatures;

		//Map from system string/name to a system pointer
		std::unordered_map m_Systems;
	};
}