Ywmaa

Arduino Project with VR in Godot Engine

Mon, 17 Aug 2026 00:00:00 GMT

The topic of the elective was studying electronics: Arduino & electronic circuits and connecting them to a game engine.

My personal project was a co-op multiplayer game between a VR Player & an Arduino Controller player.

see the project showcase: <iframe width="560" height="315" src="https://www.youtube.com/embed/wEXuCHEjK7I?si=h_A4G9F655Ge9FGX" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

The Idea

The idea behind the project is to make a fun co-op game in Godot Engine, were two players are connected in one multiplayer session to do survival-tower-defense game, one player plays as a VR shooter and the other is the command center operator who is responsible for tactically fortifying the base and helping the player increase damage by matching the tesseract cube color with the enemies color, which will change the shooter player’s gun color to match the tesseract and so cause more damage and faster elimination of enemies.

The command center operator uses the connected Arduino-Board as their control keys/switches, and they only observe the game and control it through the controller board.

Appendix

<!--

-->

AR Project in Unity Engine

Sat, 01 Aug 2026 00:00:00 GMT

This is our semester 4 AR experience -made in unity- for the Geo-Naturpark Odenwald.

For visitors of Odenwald who are interested in local history & culture.

Quest Track

Is a mobile AR-app That guides their exploration of Odenwald By turning local folklore into a real-world, interactive puzzle quest In order to encourage mindful exploration & highlight the natural & cultural richness of Odenwald. As opposed to other AR-maps & -puzzle games, Quest Track grounds the experience within the local geography and culture of Odenwald.

<img src="/assets/images/P4ARProject/image4.png" alt="In-Game Odenwald Map" width="350" ><i> In-Game Odenwald Map</i></img> <img src="/assets/images/P4ARProject/tlTsuCfS.jpg" alt="AR Anamorphic Puzzle" width="350" ><i> AR Anamorphic Puzzle</i></img> <img src="/assets/images/P4ARProject/uJ4zHY5P.jpg" alt="AR Anamorphic Puzzle from correct perspective" width="350" ><i> AR Anamorphic Puzzle from correct perspective</i></img>

Techincal Basis:

notes and documentation of the technical background I worked on

Geopark Map GPS

The positioning of player location in the in-game map is calculated through mapping from (GPS to GPS locations) to (virtual map point to another virtual point) using custom written mapping functions in C# code. And the real player position is also calculated the same way with a reference central point in the virtual map, which acts as the point of reference or “origin point of the 2D axis”. The GPS data is received directly from Geospatial API.

Image Recognition

It was considered at some point for the project to use Image Recognition in AR to register and align the experience puzzles and games as a replacement for the Geospatial setup since Geospatial is prone to problems like: hard to calibrate outside urban spaces and requires GPS module in the device (which the Meta Quest doesn’t have). But after some research it was discovered that the Meta Quest doesn’t also support image recognition by default and the other option for it is to use a paid plugin that utilizes OpenCV, which wasn’t suitable for this project's resource limitations. Thus, the decision was made to move forward without utilizing Image recognition as it won’t add much compared to the Geospatial setup which the project already utilizes.

Cross-device Geospatial Anchor Sharing

At the very early stages of development there was this idea of making the android phone of the user share the geospatial anchors and current pose to the Meta Quest if they are on the same network (Wifi/Hotspot). And there are scripts which can do that in the project, yet it wasn’t utilized later, as the scope of the Meta Quest version of the app got scaled down in its development compared to the mobile phone to reduce development burden and reduce having to go through many workarounds just to make both experiences match, thus it was preferred to maintain focus on the app experience itself rather than perfect cross-platform symmetry, and design the experience on each platform (Mobile/Meta Quest) to be within the limits of the target platform.

Cross-device Geospatial Anchor Sharing

The scripts operate on a simple logic: 1 – The sender script only exists on the phone, once Geopose is grabbed from the Geospatial Plugin in Unity, it formats it in a string format, then sends it using UDP as bytes.

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-03 03-55-26.png" alt=" Geospatial sent data payload" width="350" ><i> Geospatial sent data payload</i></img>

2 – On the receiver’s end they keep listening to the same UDP port and once new bytes are received, they are decoded and written into a GeoPose custom class that mainly hosts information of Geospatial Pose.

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-03 03-57-22.png" alt="Geospatial Pose Receiver" width="350" ><i>Geospatial Pose Receiver</i></img>

Meta Quest Version

The Meta Quest version of the app is a scaled down experience, the Quest version serves as an introductory/tutorial for the experience that can be used at home/stationary space, where only one puzzle gets spawned which is the rubik-like map puzzle around the player/user and they can have a trial of the puzzle. it doesn’t use any GPS data or things which the Quest doesn’t support, it only utilizes the regular Unity AR Foundation backend for the Quest.

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-03 19-07-12.png" alt="Meta Quest Version" width="350" ><i>Meta Quest Version</i></img>

Map Location Tracking

Map tracking utilizes Geospatial-Data that are already stored and given in a Geospatial-Pose and then that is fed into the map location mapping from GPS to Virtual Map functions as mentioned before: “The GPS in the Virtual Map is calculated through mapping from GPS to GPS locations to Virtual map point to another virtual point from custom written mapping functions in C# Code..."

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-05 03-04-24.png" alt="Map Tracking Logic Detail" width="350" ><i>Map Tracking Logic Detail</i></img>

Each point in the 3D reconstructed virtual map has its own script (LocationMarker.cs) that includes data about its real longitude & latitude which is used to remap the GPS data from real life to that local coordinates and smaller size/distances. So these data are also used and fed into the remapping functions along with the GPS data.

Screenshot Feature

With the help of GitHub - yasirkula/UnityNativeGallery, yasirkula/UnityNativeShare custom Unity plugins, the project includes the feature to take internal screenshot of the AR Framebuffer excluding the App-UI, or share a screenshot to social media with the native function available in android so the app behaves like a native android app.

There are 3 main scripts that handle the interface to the custom plugins which are:

ARObjectScreenshotCapture.cs : responsible for rendering the AR Camera only and has a function that can save that framebuffer with specified name, it is the central hook to the screenshot Unity plugin.
PuzzleScreenshotManager.cs : responsible for hooking puzzle success event (hooked to the PuzzleEventManager.cs) and triggers an automatic screenshot of the solved puzzle that stores that special screenshot to show it later on the Geopark in-game map, to be the unique gallery of achievements for each user.
ARScreenshotShareAndroid.cs : responsible for capturing the AR scene only (via ARObjectScreenshotCapture), then opens the native Android share menu with the captured image attached (via the custom android native share plugin).

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-05 03-15-29.png" alt="ARObjectScreenshotCapture.cs" width="350" ><i>ARObjectScreenshotCapture.cs</i></img>

As shown, each script has a single responsibility and communicates with the other script/s to achieve the desired behaviour:

User wants a screenshot only → trigger screenshot button → trigger CaptureScreenshot() in ARObjectScreenshotCapture.cs.
User solves the puzzle → puzzle solved event trigger → PuzzleScreenshotManager.cs listens to event trigger → trigger CaptureScreenshot() in ARObjectScreenshotCapture.cs with unique local image name to be shown later in the in-game map.
User wants to share the current screen view → trigger share button → trigger ARScreenshotShareAndroid.cs → trigger CaptureScreenshot() in ARObjectScreenshotCapture.cs → triggers OnScreenshotSaved event → triggers HandleScreenshotSaved in ARScreenshotShareAndroid.cs which uses the provided image path to share to different applications.

Coroutine Queue System

The CoroutineQueue.cs script adds the possibility to queue coroutines as it isn’t available by default in Unity API. It takes coroutines with assigned keys as parameters in the Enqueue function and splits each queue in their own group if they have matching keys in their own queue data structure. Allowing both parallel queues and sequential queues. This helped with the Narration System as it can queue narration one after the other easily while waiting for the previous narration to finish or be skipped/moved forward to start executing the next narration (execution writes the subtitles and executes the audio). But the system is not limited to narration as it can be utilized for general usage of coroutine queues.

The script also allows checking for status of a queue or current running ones or forcefully skipping the current running coroutine in a specific queue key to the next coroutine along with its children coroutine (a child coroutine is a coroutine executed within the coroutine). This helped with the skip narration functionality.

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-03 03-54-41.png" alt="Skipping function of the CoroutineQueue-Class" width="350" ><i>Skipping function of the CoroutineQueue-Class</i></img>

Final Refactor & Event System

At the latest stages of the project development when it was necessary to start polishing the experience both visually and internally. A lot of refactoring happened, redesigning how the PuzzleManager.cs handles the events and puzzle solving states and hooks into other systems like the guidance system, narration events or VFX triggering.

It had to be refactored to be single-responsibility to follow the philosophy of how OOP (Object Oriented Programming) should be written. And thus more scripts were made to accompany the puzzle manager script such as: PuzzleEventManager.cs , PuzzleNarrationController.cs each are now with single-responsibility, and the latter was used to trigger global events with puzzle success or puzzle spawned/disabled events. and more UnityEvents were specifically added to the PuzzleManager.cs itself to allow local events to happen on the puzzle prefab itself and not in the global scene view (important for easy VFX and SFX triggering), which got used later by the VFX Designer from the Unity Inspector without having to add any extra code.

<img src="/assets/images/P4ARProject/Screenshot from 2026-08-05 02-56-00.png" alt="Event System Excerpt" width="350" ><i>Event System Excerpt</i></img>

Appendix

VR Project in Unity Engine

Sun, 01 Feb 2026 00:00:00 GMT

This is our semester 3 trailer for proposed VR experience -made in unity- for the Naturmuseum Senckenberg waterbear creature exhibit.

project trailer:

Appendix

The music composition I made for the project (the one you hear in the trailer)

Laser Gun VFX I made

The Liquid Nitrogen Cup I modeled and textured from scratch in Blender

XRay effect with Stencil Buffer Shaders in unity

Linux commands I use regularly

Mon, 06 Apr 2026 00:00:00 GMT

Commands I use on a regular basis in Linux

cd

cd means "Change Directory"

usage

obvious, change directory

syntax

cd $PATH

example

cd ~/Documents/

:::tip if you write "cd" without path, it will take you to home directory :::

ls

list files and directories

syntax

ls $PATH

example

ls ~/Documents/

or just write it without any path to execute it on current location

ls

:::tip ls -la is a useful command to list all files and directories including hidden ones. :::

mv

move file or directory

syntax

mv PATH NEW_PATH

example

mv file.txt ~/Documents/file.txt

mv directory/ ~/Documents/new_directory_location/

:::tip or can be also used to rename a file or folder

mv file.txt new_file.txt :::

rm

remove file or directory

syntax

rm $PATH

example

rm file.txt

rm directory/

sudo rm -rf

even though it's dangerous, it's useful, especially when I want to delete a directory recursively and ignore all permissions.

please don't use it without thinking twice or on root to not destroy your system.

cp

copy file or directory

syntax

cp PATH NEW_PATH

example

cp file.txt ~/Documents/file.txt

cp directory/ ~/Documents/new_directory_location/

pkill

terminates a program with closest name

pkill program_name

history | grep "command_name"

I use it a lot to find commands I've used before. specifically when I want a long command but can't remember all of its components.

ffmpeg

ffmpeg is a powerful tool for video and audio processing.

it is not a packaged command, you need to install it separately.

examples

ffmpeg -i input.mp4 -vf scale=-1:720 output.mp4

ffmpeg -i input.mp4 -vf scale=-1:720 -c:a copy output.mp4

conversion from mkv to mp4

ffmpeg -i input.mkv -c copy output.mp4

My Notes from CS50 AI

Mon, 06 Apr 2026 00:00:00 GMT

Personal Notes of the CS50 AI course

Search

Agent: entity perceives its environment and acts upon that environment

State: config of the agent and its environment

Actions: choices that can be made in a state

ACTIONS(s) returns the set of actions that can be executed in state s

transition model: description of what state results from performing any applicable action in any state

RESULT(s, a) returns the state resulting from performing action a in state s

state space: the set of all states reachable from the inital state by any sequence of actions (sometimes we use a Graph to represent the state space)

goal test: way to determine whether a given state is a goal state

path cost: numerical cost associated with a given path

Search Problems: init state, actions, transition model, goal test, path cost function

Solution: sequence of actions that leads to the goal state

Optimal Solution: the solution with the lowest path cost

Node: data structure that keeps track of: a state, a parent, an action, a path cost (from init to node).

Normal/Classic Search

Search ALGOS: (most examples are in traversing a maze)

Frontier:
- Depth-First Search (uses a stack) DFS
- Breadth-First Search (uses a queue) BFS

Informed search: search startegy that uses problem-specific knowledge to find solutions more efficiently

Greedy Best-First search: search algo that expands the node is closest to the goal, esitmated by a heuristic function h(n)

A* Search: search algo that expands the node with lowest value of g(n) + h(n)

g(n) = cost to reach node

h(n) = estimated cost to goal

this algo is the optimal under these conditions:

h(n) is admissible (never overestimates the true cost) and
h(n) is consistent (for every node n and successor n' with step cost c, h(n) <= h(n') + c)

Adversarial Search:

like playing a game against opponent (tic tac toe, )

Minimax:

MAX: (X) aims to maximize score
MIN: (O) aims to minimize score

S0: init state

Player/s: returns which player to move in state s

ACTIONS(s) returns the set of actions that can be executed in state s

RESULT(s, a) returns the state resulting from performing action a in state s

TERMINAL(s): checks if state s is a terminal state (game over)

UTILITY(s): final numerical value for the terminal state s (score of the state)

The algo process: Given a state s:

MAX picks action a in ACTIONS(s) that produces the highest value of MIN-VALUE(RESULT(s, a))
MIN picks action a in ACTIONS(s) that produces the lowest value of MAX-VALUE(RESULT(s, a))

function MAX-VALUE(state):
	if TERMINAL(state):
		return UTILITY(state)
	v = -∞
	for action in ACTIONS(state):
		v = MAX(v, MIN-VALUE(RESULT(state, action)))
	return v

function MIN-VALUE(state):
	if TERMINAL(state):
		return UTILITY(state)
	v = ∞
	for action in ACTIONS(state):
		v = MIN(v, MAX-VALUE(RESULT(state, action)))
	return v

Alpha-Beta Pruning: I can ignore the rest of the nodes of already there is a choice for the other player that is less than we have already to optimize the minimax algo

Depth-Limited Minimax: after certain number of moves I won't consider extra ones, this algo is important for complex games like Chess that got billions of possibilites that cannot be calculated in a reasonable time

evaluation function: function that estimates the expected utility of the game from a given state (the better this function is in estimating, the more intelligent the AI is)

Knowledge

knowledge-based agents: agents that reason by operating on internal representations of knowledge

Sentence: an assertion about the world in a knowledge representation language

Propositional Logic, Proposition Symbols: P & Q, Truth Tables are the essential way to represent logic and deductions for AI

Model: assignment of truth value to every propositional symbol (a "possible world")

Knowledge base: a set of sentences known by a knowledge-based agent

Entailment: $\alpha \vdash \beta$ in every model in which sentence $\alpha$ is true, sentence $\beta$ is also true

Inference: the process of deriving new sentences from old ones

KB is knowledge base Inference Algo: does $KB \vdash \alpha$ ?

Model Checking:

To Determine if $KB \vdash \alpha$:
- Enumerate all possible models.
- if in every model where $KB$ is true, $\alpha$ is true, then $KB$ entails $\alpha$

Inference rules:

Modus Ponens, De Morgan's Law, And elimination, implication elimination, Double Negation elimination, bi-conditional elimination, Distributive Property

Theorem Proving

works a bit like search problems

State: config of the agent and its knowledge base

Actions: inference rules

ACTIONS(s) returns the set of actions that can be executed in state s

transition model: new knowledge base after inference

RESULT(s, a) returns the state resulting from performing action a in state s

state space: the set of all states reachable from the inital state by any sequence of actions (sometimes we use a Graph to represent the state space)

goal test: way to determine whether a given state is a goal state (check statement we are trying to prove)

path cost: number of steps in proof

Theorem Proving: init state, actions, transition model, goal test, path cost function

Conversion To CNF (Conjuctive Normal Form)

disjunction: literals connected with $\lor$ conjunction: literals connected with $\land$

clause: a disjunction of literals

Conjuctive Normal Form: logical sentence that is a conjuction of clauses e.g. $(A \lor B \lor C) \land (D \lor \neg E) \land (F \lor G)$

Steps to Convert to CNF

Eliminate biconditonals
- turn $(\alpha \leftrightarrow \beta)$ into $(\alpha \rightarrow \beta) \land (\beta \rightarrow \alpha)$
Eliminate implications
- turn $(\alpha \rightarrow \beta)$ into $\neg \alpha \lor \beta$
Move $\neg$ inwards using De Morgan's Laws
- e.g. turn $\neg(\alpha \land \beta)$ into $\neg \alpha \lor \neg \beta$
Use distributive law to distribute $\lor$ wherever possible

Inference by Resolution

To Determine if $KB \vdash \alpha$:
- Check if ($KB \land \neg \alpha$) is a contradiction
  - if so, then $KB \vdash \alpha$
  - Otherwise, no entailment
To Determine if $KB \vdash \alpha$:
- Convert ($KB \land \neg \alpha$) to CNF (Conjuctive Normal Form)
- Keep checking to see if we can use resolution to produce a new clause
  - if ever we produce the empty clause (contradiction in computer represented as false), then we have a contradiction, and $KB \vdash \alpha$
  - Otherwise, if we can't add new clauses, no entailment.

First-Order Logic

Constant Symbols (Names, Objects, etc), Predicate Symbols (Classes) (Person, House, BelongsTo)

Universal Quantification: $\forall x$ Existential Quantification: $\exists x$ and so on of Quantifications

Probability

Possible World: $\omega$ Probability of a possible world: $P(\omega)$

1 = Certain 0 = Impossible

$0 \leq P(\omega) \leq 1$

The sum of all possible worlds $\omega$ in the set of all worlds $\Omega$ is 1 $\sum_{\omega \in \Omega} P(\omega) = 1$

unconditional probability

degree of belief in a proposition in the absence of any other evidence.

conditional probability

degree of belief in a proposition given some evidence that has already been revealed

the probability of "a" given "b" $P(a|b)$

to know the probability of a given b, we take the probability of both and divide it by the probability of the second (b) to get rid of its own probability that happens when (a) doesn't

$P(a|b) = \frac{P(a \land b)}{P(b)}$

random variable

a variable in probability theory with a domain of possible values it can take on can be encoded as an array to distribute the probabilities

Probability Distribution

$P(Flight = on time) = 0.6$

$P(Flight = delayed) = 0.3$

$P(Flight = cancelled) = 0.1$

or as a vector/array

$P(Flight) = <0.6, 0.3, 0.1>$

independence

the knowledge that one event occurs doesn't affect the probability of the other event

then $P(b|a) = P(b)$ because (b) is independent of (a) anyways

$P(a \land b) = P(a)P(b|a) = P(a)P(b)$

dependence

the knowledge that one event occurs affects the probability of the other event

Bayes' Rule

:::note $\because$ $P(a \land b) = P(b)P(a|b)$

$P(a \land b) = P(a)P(b|a)$

$\therefore$ $P(b)P(a|b) = P(a)P(b|a)$

$\therefore$

$P(b|a) = \frac{P(b) P(a | b)}{P(a)}$ ::: knowing P(a | b) we can calculate P(b | a)

knowing P(visible effect | unknown cause) we can calculate P(unknown cause | visible effect)

knowing P(medical test result | disease) we can calculate P(disease | medical test result)

Joint Probability

$P(a|b) = \frac{P(a \land b)}{P(b)} = \alpha P(a \land b)$

$\alpha = \frac{1}{P(b)}$

the conditional probability of (a) given (b) is proportional to a factor $\alpha$ multiplied by the joint probability of (a) and (b) $P(a \land b)$

Probability Rules

Negation

$P(\neg a) = 1 - P(a)$

Inclusion-Exclusion

$P(a \lor b) = P(a) + P(b) - P(a \land b)$

Marginalization

$P(a) = P(a \land b) + P(a \land \neg b)$

$P( X = x_{i}) = \sum_{j} P(X = x_{i} \land Y = y_{j})$

Conditioning

$P(a) = P(a|b)P(b) + P(a| \neg b)P(\neg b)$

$P( X = x_{i}) = \sum_{j} P(X = x_{i} | Y = y_{j})P( Y = y_{j})$

Probability Models

Bayesian Network

data structure that represents the dependencies among random variables.

Directed Graph
Each node represents a random variable
arrow from X to Y means X is a parent of Y
each node X has probability distribution $P(X | Parents(X))$

Ywmaa

Arduino Project with VR in Godot Engine

The Idea

Appendix

AR Project in Unity Engine

Techincal Basis:

Geopark Map GPS

Image Recognition

Cross-device Geospatial Anchor Sharing

Cross-device Geospatial Anchor Sharing

Meta Quest Version

Map Location Tracking

Screenshot Feature

Coroutine Queue System

Final Refactor & Event System

Appendix

Links

VR Project in Unity Engine

project trailer:

Appendix

The music composition I made for the project (the one you hear in the trailer)

Laser Gun VFX I made

The Liquid Nitrogen Cup I modeled and textured from scratch in Blender

XRay effect with Stencil Buffer Shaders in unity

Linux commands I use regularly

cd

usage

syntax

example

ls

syntax

example

mv

syntax

example

rm

syntax

example

sudo rm -rf

cp

syntax

example

pkill

history | grep "command_name"

ffmpeg

examples

My Notes from CS50 AI

Search

Normal/Classic Search

Adversarial Search:

Knowledge

Inference rules:

Theorem Proving

Conversion To CNF (Conjuctive Normal Form)

Inference by Resolution

First-Order Logic

Probability

unconditional probability

conditional probability

$P(a|b) = \frac{P(a \land b)}{P(b)}$

random variable

independence

$P(a \land b) = P(a)P(b|a) = P(a)P(b)$

dependence

Bayes' Rule

Joint Probability

$P(a|b) = \frac{P(a \land b)}{P(b)} = \alpha P(a \land b)$

$\alpha = \frac{1}{P(b)}$

Probability Rules

Negation

$P(\neg a) = 1 - P(a)$

Inclusion-Exclusion

$P(a \lor b) = P(a) + P(b) - P(a \land b)$

Marginalization

$P(a) = P(a \land b) + P(a \land \neg b)$

$P( X = x_{i}) = \sum_{j} P(X = x_{i} \land Y = y_{j})$

Conditioning

$P(a) = P(a|b)P(b) + P(a| \neg b)P(\neg b)$

$P( X = x_{i}) = \sum_{j} P(X = x_{i} | Y = y_{j})P( Y = y_{j})$

Probability Models