Alan Zucconi

Hi everyone! 👋 This is the fourth, and final part of the new tutorial dedicated to extending Unity into the fourth dimension. In this instalment, we will see different techniques to create various 4D objects, such as tesseracts, hyperspheres and 600-cells (the 4D equivalent of an icosahedron). All

Hi everyone! 👋 This is the third part of the new tutorial dedicated to extending Unity into the fourth dimension. In this instalment, we will tackle the most important issue: rendering 4D objects! The first three articles are now public, and the rest of the series is available on Early Access to al

Hi everyone! 👋 This is the second part of the new tutorial dedicated to extending Unity into the fourth dimension. In this instalment, we will start writing the code necessary to represent and manipulate 4D objects. The first two articles are now public, and the rest of the series is available on E

Hi everyone! 👋 It is with great pleasure that I can finally announce a new tutorial series! As you probably know by now, I like to write content that is a bit unexpected... and what is more unexpected than a complete tutorial to turn Unity 3D into Unity 4D? 😎 This series is dedicated to extending

Hi everyone! 👏 If you follow my work, you know that in the past I have talked extensively about video games and maps. This month I want to show you how you can create your very own interactive web-based map with Unity and LeafletJS. 🗺️ If you have a game and would like to create a zoomable slippy

Hi everyone! 👋 If you follow this blog, you should know by now that my not-so-healthy obsession for sorting algorithms. This is the preview of an article which talk about a somewhat forgotten sorting algorithm: the Sunrise sort. Unlike any other algorithm, it has the rather bizarre property of bein

Hi everyone! 👋 This is the C# script for the Sunrise sort, a sorting algorithm with the rather bizarre property of being fully unstable. You can read more on its article: Sunrise Sort: The Forgotten Sorting Algorithm. 🧔🏻

Hi everyone! 👋 Believe it or not, one of my most popular tutorials is the one about Enums, Flags & Bitwise Operators in C#. For this reason, I have decided to cover another tricky—yet very powerful—aspect of C#: functional programming. Following a recent poll on Twitter, a lot of people were keen o

Hi everyone! 👋 This is the second part of the tutorial on catenaries. The second, and final post, has finally been made public! Catenaries for Gamedev Part 1. The Mathematics of Catenary Part 2. Implementing Catenaries for Games Two Unity packages are available for this tutorial: The Standard packa

Hi everyone! 👋 After a few busy weeks teaching, I finally had some time to work and publish a new tutorial series! It covers a subject that many of you are familiar with: hanging wires, cables and chains! This new series covers the mathematics and implementation of catenaries, the mathematical obje

Hi everyone! This is the second part of the short series dedicated to floating-point arithmetic. After a lengthy introduction, this post shows how to go beyond the limitations of float, double and decimal types. Part 1. An Introduction to Floating-Point Arithmetic Part 2. Beyond Floating-Point in C#

Hi everyone! As a developer with a strong passion for gravity simulators, I often find myself in trouble due to the limited precision that languages such as C# offer. If you are a Unity developer, you probably know that most of Unity's back-end uses float variables, which have very limited precision

Hi everyone! The is the last part of the series dedicated to the study of epidemics: From an Outbreak to an Epidemic. In this post we will explore different techniques to simulate the spread of diseases through commuting. You can read the rest of the series here: Part 1. The Mathematics of Epidemics

Hi everyone! The is the second post for the series dedicated to the study of epidemics: Simulating Epidemics. As the title suggests, we will explore how to create SIR-like models in Unity, to simulate how a disease can spread in a community. You can read the rest of the series here: Part 1. The Math

Hi everyone! It is impossible to deny that the recent pandemics of COVID-19 has changed the world we live in. As a Science Communicator—one which family has been affected—I feel is important I take this opportunity to add my contribution to the current discourse. This new series will focus on unders

After a long journey about the Mathematics of Forward Kinematics and the geometrical details of gradient descent, we are ready to finally show a working implementation for the problem of inverse kinematics. This tutorial will show how it can be applied to a robotic arm, like the one in the image bel

If you are a game developers, you might be familiar with the concept of procedural animations. This post introduces Gradient Descent, which is one of the most popular minimisation algorithms among many programmers. This variant is designed to be compatible with Inverse Kinematics. That is the techni

This tutorial shows how to make the most out of coroutines in Unity. Introduction Part 1. Synchronous Waits Part 2. Asynchronous Coroutines Part 3. Synchronous Coroutines Part 4. Parallel Coroutines Conclusion This post is part of a series about coroutines. Part 1. Iterators in C#: yields, IEnumerab

Iterating over lists in C# is often done using for loops. This tutorial shows how the foreach construct can be coupled with the yield statement to create more elegant and safe code. Introduction Part 1. Implementation Part 2. The yield Statement Part 3. Limitations Conclusion As always, thank you fo

In a previous post, How To Integrate Arduino With Unity, we have shown how data can be sent and received through the serial port. The main problem encountered was dealing with the latency and the delays that communicating across different devices introduces. The solution proposed in that tutorial us