About this portfolio

SEO

100 words

  • Unity
  • Multiplayer
  • LiveOps
  • C#

Leonardo Lycan is a Lead Game Developer specializing in Unity game development, multiplayer architecture, gameplay systems, LiveOps, and technical production. This portfolio brings together published projects, playable prototypes, product studies, and articles on game engineering, applied AI, Web3, onboarding, and digital experiences. The work combines team leadership, C# programming, service integration, performance optimization, and clear communication across design, art, and business. For projects, consulting, or collaboration, Leonardo takes a practical approach: understand the problem, build a robust solution, and turn complex requirements into memorable experiences for players and digital products with measurable, lasting impact for teams, audiences, and product goals.

Game jam · Local multiplayer

Four players. One borderless map. Powers that turn lag, desync and rewind into weapons. Built during a game jam, this chaotic local arena transforms the frustrations of unstable connections into deliberate gameplay mechanics, letting players weaponize packet loss, teleportation glitches and temporal manipulation.

  • 02days
  • 04players
  • edges
Explore the case
ClientDemerara Games
Period2016
RoleGameplay programming
PlatformsPC

The core rule

Small scope. Instant identity.

Left the screen.Entered the ambush.

The game's best idea moves to the center of the case: an endless arena where space, time and connection can be used against the other players.

  1. 01

    Continuous arena

    Cross one edge and reappear at the other. Escape and ambush become the same move.

  2. 02

    Lag as a power

    Delay, desync and rewind stop being connection faults and enter the fight.

  3. 03

    Couch chaos

    Up to four players share the screen, read the arena and sabotage one another's timeline.

01

Challenge

Create a chaotic local arena in roughly two days that stayed readable when space, time and connection stopped behaving normally.

02

Solution

Connect the map through its edges, then turn delay, desync, position and temporal rewind into confrontation tools.

03

Outcome

A game-jam title for up to four people built around one immediately readable rule: leaving the screen does not end the play, it opens another route.

Lag Warfare: No Reconnection

The arena does not end on screen

In Lag Warfare, crossing one edge makes the character reappear on the other side. Within seconds, that rule turns escape into a counterattack and pursuit into an ambush.

The connection enters the fight

Lag, desync and rewind are more than a visual theme. Characters manipulate position and time — including returning to an earlier state — to confuse or overtake their rivals.

One strong rule in two days

The game was built in approximately two days. Instead of hiding that limit, the case shows what a focused scope can do: one memorable rule, local matches for up to four people and emergent chaos from the first minute.

Inside Lag Warfare: No Reconnection

01

Risk

What could fail?

Create a chaotic local arena in roughly two days that stayed readable when space, time and connection stopped behaving normally.
02

Decision

What changed the direction?

Connect the map through its edges, then turn delay, desync, position and temporal rewind into confrontation tools.
03

System

What can the team reuse?

A foundation built with Unity, C#, Local Multiplayer, Game Jam to support iteration and delivery.
04

Outcome

What became better?

A game-jam title for up to four people built around one immediately readable rule: leaving the screen does not end the play, it opens another route.
Technologies

Unity · C# · Local Multiplayer · Game Jam

Links

Game Jolt ↗

Signal restored

A small map. A borderless idea.

A game-jam title for up to four people built around one immediately readable rule: leaving the screen does not end the play, it opens another route.