This is a 3D scene, you can interact with it!

Lately I saw some web 3D experiences made by Vicente Lucendo that really caught my eye. I also watched his talk about how he makes his experiences, which I very much recommend:

I have been hearing about Three.js for a long time, but there has always some reasons for me to look the other way: there isn’t a popular editor (at least that I know of), the whole web setup is complicated, JavaScript looks like an untrustworthy language, and the fact that getting into this requires a whole set of skills that I don’t know if I can transfer from working with game engines.

However, every time I’ve looked at one of those 3D web pages and how it just loads beautifully, no matter the device, really pulls me towards trying it out myself. Would I just ignore my concerns and go through this rabbit hole?

Well yes, of course I did.

First, I wanted to explore how could I use my current setup to host this. Because I’m using WordPress, I looked into plugins that let you run Three.js from within it. However, the best I got was a plugin that let you embed a canvas into a post or a page, but it just shoved it under the WordPress content, so it would never look right.

So I decided to just drop this approach and just try to get it working outside of WordPress, by uploading it directly to my hosting’s file system. For this, I followed the setup in the Three.js webpage and installed everything locally. To do so, I just opened a folder with VS Code and just pasted the commands and added the required index.html and main.js files.

However, there’s some stuff that they doesn’t tell you. For instance, the command npx vite will just execute the project locally, but to deploy it, you will need to build it . For me the concept of building a web page was completely new. So, I had to do a couple of things to achieve this. First, add the build command to the package.json file:

{
  "dependencies": {
    "three": "^0.180.0"
  },
  "devDependencies": {
    "vite": "^7.1.8"
  },
  "name": "test1",
  "version": "1.0.0",
  "description": "this is a threejs test",
  "main": "index.html",
  "scripts": {
    "build": "vite build",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "daniFM",
  "license": "ISC"
}

{
  "dependencies": {
    "three": "^0.180.0"
  },
  "devDependencies": {
    "vite": "^7.1.8"
  },
  "name": "test1",
  "version": "1.0.0",
  "description": "this is a threejs test",
  "main": "index.html",
  "scripts": {
    "build": "vite build",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "daniFM",
  "license": "ISC"
}

Later on, I ran into some issues with the paths, so the fix was to add this other file to the root.

import { defineConfig } from 'vite';

export default defineConfig({
    // Ensure the base is set to './' for relative paths
    base: './',

    build: {
        // Output directory for built files
        outDir: './dist',

        // Directory where static assets will be placed
        assetsDir: 'assets',

        // Optional: Control how URLs are generated
        rollupOptions: {
            output: {
                manualChunks: {},
            },
        },
    },
});

import { defineConfig } from 'vite';

export default defineConfig({
    // Ensure the base is set to './' for relative paths
    base: './',

    build: {
        // Output directory for built files
        outDir: './dist',

        // Directory where static assets will be placed
        assetsDir: 'assets',

        // Optional: Control how URLs are generated
        rollupOptions: {
            output: {
                manualChunks: {},
            },
        },
    },
});

And that was it (for now). I could now build by running

npm run build

npm run build

Now, I want this to be deployed to my site without much hassle, so I opted for using GIT. That way I also forced myself to use version control. To achieve this, I used a feature in my hosting that allows to point to a git repo. In my case, I’m using Hostinger. In Settings->Advanced->GIT it has some options to configure SSH for a repo and pull it to a folder within my webpage’s folder structure. To finish to make it automatic, I added a webhook to my repo in GitLab, so every time I push to the main branch, it pulls automatically.

And that was all the setup! Now I have a dedicate page to it, while also being able to insert it wherever I want with iframes.

GLTF and Lighting

Another topic I investigated was how to load my own meshes. Turns out Three.js supports GLTF. This is a format I really like, because it supports almost everything: meshes, materials, textures, animation, etc. And can pack whole scenes in a single file, so it’s super convenient to just export any of my scenes from Blender and add it here. Of course, it will not export the procedural textures/materials. But it’s good enough for now, I’ll come back for that later. To do this, I followed the code in this example, removing the Draco compression stuff, which I don’t use.

In this scene, I also tried to bring real time shadows. The configuration is a bit of a hassle, since you need to input all the parameters by hand. Here’s an example of the setup for a single directional light.

// ...

// Enable shadows
renderer.shadowMap.enabled = true;
renderer.shadowMap.type = THREE.PCFShadowMap;

// Create light
const color = 0xFFFFFF;
const intensity = 10;
const light = new THREE.DirectionalLight(color, intensity);
light.position.set(-304, 605, 211);
light.target.position.set(0, 0, 0);
light.castShadow = true;
light.shadow.camera.top = 500;
light.shadow.camera.bottom = - 500;
light.shadow.camera.left = - 500;
light.shadow.camera.right = 500;
light.shadow.camera.near = 1;
light.shadow.camera.far = 10000;
light.shadow.normalBias = 1;
// light.shadow.bias = -0.0002;
// light.shadow.radius = 8;
light.shadow.mapSize.width = SHADOW_MAP_WIDTH;
light.shadow.mapSize.height = SHADOW_MAP_HEIGHT;
scene.add(light);
scene.add(light.target);

// ...

//Set properties of objects
model.traverse(function (object)
{
    if (object.isMesh) object.castShadow = true;
    if (object.isMesh) object.receiveShadow = true;
});

// ...

// ...

// Enable shadows
renderer.shadowMap.enabled = true;
renderer.shadowMap.type = THREE.PCFShadowMap;

// Create light
const color = 0xFFFFFF;
const intensity = 10;
const light = new THREE.DirectionalLight(color, intensity);
light.position.set(-304, 605, 211);
light.target.position.set(0, 0, 0);
light.castShadow = true;
light.shadow.camera.top = 500;
light.shadow.camera.bottom = - 500;
light.shadow.camera.left = - 500;
light.shadow.camera.right = 500;
light.shadow.camera.near = 1;
light.shadow.camera.far = 10000;
light.shadow.normalBias = 1;
// light.shadow.bias = -0.0002;
// light.shadow.radius = 8;
light.shadow.mapSize.width = SHADOW_MAP_WIDTH;
light.shadow.mapSize.height = SHADOW_MAP_HEIGHT;
scene.add(light);
scene.add(light.target);

// ...

//Set properties of objects
model.traverse(function (object)
{
    if (object.isMesh) object.castShadow = true;
    if (object.isMesh) object.receiveShadow = true;
});

// ...

And that’s it for now! Now I have a whole new sink to throw my free time into. I hope with this new setup, I’ll be able to experiment with more things like:

• Code shaders!
• Make procedural meshes!
• Make games with it (this actually looks like it’s going to be extremely tedious)

I’ve been spending a little more than a month exploring product design with my new 3D printer. So this is a dump post of everything I’ve been creating with it, instead of making shaders or gamedev during this time.

It’s refreshing having to take care of different parameters compared to game development. For example having to take into account different materials, physical properties, printability, or handling/usability. On the other hand, I’ve found some similarities with gamedev, for example, the fact that it’s an iterative process and you need to learn from your mistakes.

After printing a few popular online models, and getting a hang of the printer and slicer software, I started designing my first object: a charger base for my smartwatch. I wanted it to not just hold the watch, but also serve as a storage for the cable when it’s not in use. Here you can appreciate what I mean when I say designing this stuff is iterative.

This are not even all of the tests I made. Figuring out the right dimensions, thickness and shapes was challenging. Plus there were other unforeseeable nuances, like, notice the horizontal lines on the rightmost object? They popped up because the horizontal cross section of the sphere is variable, and the printer needed needed to change from 2 to 3 walls. Changing to a variable thickness setting fixed the issue.

By the way, one of the most useful things I’ve printed was this caliper. It is unexpectedly accurate and functional. It allowed me, for example, to measure the charger socket of the watch base accurately.

The next thing I designed myself was this box for my D&D dice. I based off the design of another online model. But heavily adapted it to fit my smaller printer, and ended up re-making the whole model. I also fit magnets into this one to keep the lid shut. It was interesting making the hinges work in print-in-place, as I had to make sure the tolerances were just right and I didn’t use a bridge that could “collapse” and make the pieces stick to each other.

Speaking of D&D, I also printed some figurines for the campaign I’m playing. They were challenging to print, because lowering the layer height to make them more detailed also risked the emergence of other issues like stringing or melting.

I’ve printed some other things and learned a bunch with each print.

Right now, I’m exploring to combine my knowledge of Blender’s Geometry Nodes with all this. I created nodes for making holes or hooks for my Skadis panel.

Right now, I’m working on this other geom nodes to make clocks parametrically. While doing this, I also found some very useful geom nodes to make text meshes. Take a look at the article.

And that’s all for now! But I don’t think my 3D print fever is over. I’ll probably design some clocks and lamps next. I want to try selling some stuff and I think there’s market for those kinds of objects.

This post is directed at entry level and junior profiles, who might be equally motivated and confused about getting a tech artist job. I want to give my personal opinion and advice, while taking into account how other companies use “technical art”.

What is Technical Art

Taking into account all the different information at my disposal, I will approximate a kind of universal average of what a technical artist is supposed to do. Be warned, this probably would accommodate only a small percentage of all the cases, but it’ll still be useful to get an overview. The responsibilities of this universal average would consist of:

• Building tools and establishing consistent workflows for each of the art teams in the studio. Find new ways for artists to deliver higher quality work with less effort.
• Improving the art pipeline (how the assets get into the engine). Usually custom exporters, asset processing, version control, etc.
• Give constant support to all the users of said pipelines & workflows.
• Make or help making shaders. Shaders are a shared responsibility between tech artists and graphics engineers. If there are none in the studio, the tech artist will need to make all the shaders, while if there are, the tech artist will probably just focus on making the outlier shaders (for special use cases, like VFX).
• Optimization: LODs, profiling, etc.
• Facilitate communication between Art and Programming teams.

I’ve also found the tech art position varies a lot depending on whether the studio uses Unreal Engine or not. More often than not, in an Unreal Engine powered studio, tech artists focus more on the artistic part, and sometimes contribute to making final art for the games. In my case, we use a custom engine, and my responsibilities are more centered in the technical part.

What skills can get you a tech art job

The single skill that did it for me a few years ago was Maxscript. It is a scripting language used to make 3DsMax tools. I didn’t have professional experience with it, but just having studied it in university was enough for passing the technical test in the selection process.

However, if you’re starting now and have no knowledge of Maxscript, I don’t recommend you to waste time on it. Python would be a way better option. It’s supported in 3DsMax, and in other tools like Blender and Houdini, which are gaining a lot of traction, even surpassing 3DsMax in the recent years.

But arguably, an even more importan thing to have is a broad set of skills, that cover from coding to almost all of the 3D pipeline. For my current position, they wanted someone to give support with tools and pipeline improvements to all the 3D art teams. My lack of animation knowledge wasn’t a problem, as they already had a couple of technical animators, which will be the case in most bigger studios.

Right after these, shader knowledge would be the next more important skill. You will be asked to write or modify shaders in the technical interview, and you need to be prepared to adapt to different languages: GLSL, HLSL, ShaderLab. This depends on the tech the company uses. At least, you should be able to implement with code different blending algorithms¹, basic lighting² and vertex displacement.

Procedural modeling can also be a huge advantage for you in this field. Most teams will be interested in procedural or semi-procedural solutions to alleviate some work from the 3D artists. In my case, I started learning this by playing around with Blender’s Geometry Nodes, and this skill was pretty useful when later on we decided to start making procedural tools in Houdini, which would have been way more intimidating to learn without the Geometry Nodes knowledge. If you want to jump into Houdini directly because it caught your attention, online tutorials are not going to help I’m afraid. I recommend you do yourself a favor and sign to a paid course.

Ok, but what can you actually do to learn and showcase these?

Here are some examples of projects you can add to your portfolio. These will cover the main skills mentioned above, and will make you learn along the way. Make sure to pick projects that motivate you, it will make the trip easier, and it will show in the results.

Exporter helper tool

This can be actually very helpful for you in the future, and will show that you can tackle making tools. Bonus points if you make a simple UI for it. I recommend doing it in Python for Blender. Focus on what would be actually helpful for you and your preferred engine/other tools you use.

• https://www.youtube.com/watch?v=H5aY9wcbX3c
• https://robertshenton.co.za/blog/blender-batch-export/
• https://www.youtube.com/watch?v=YAweJ9S__-k

Consider sharing your script and getting people to use it and give you feedback.

Procedural modeling projects

Go to Blender, open the Geometry Nodes tab and start playing. If you don’t know what this is about, look for any simple introductory tutorial, follow along and adapt the result to your liking. And if you don’t have any ideas, you can make buildings, roads, anything that normally has patterns and would be a pain to 3D model in the traditional way.

Make sure to document the process and showcase it in your portfolio.

Dioramas

These can act as a vertical slice to show off your knowledge of the 3D art pipeline, and serve as an expositor for your shaders and VFX. Also, if you can take advantage of your other tools and Geometry Nodes, it would be ideal. You can keep dioramas in Blender, or better yet, put them in your preferred game engine and finish the visuals there.

If you’re looking for inspiration, you can take a look in https://sketchfab.com/ to get ideas and/or styles to replicate.

Extra: you need to care about soft skills

Soft skills are specially important in technical art. You will need to communicate with lots of different people from different teams, understand what they need, and make sure that what you do suits their needs.

You will also need to sell your job, and be able to convince higher ups to change tech and invest in licenses.

As an introvert, this GDC talk helped me a lot: The Calm in the Storm: An Introvert’s Guide to Success

Afterword

I made this post after reading Nina Klos’, which inspired me to add my own point of view. There are many other experiences out there, so don’t stop looking for more insights about this.

Footnotes

1. See examples in:
   – Unity: https://elringus.com/blend-modes-in-unity/
   – Godot: https://godotshaders.com/snippet/blending-modes/
   – GLSL: https://github.com/jamieowen/glsl-blend ︎
2. For example the Phong lighting: https://learnopengl.com/Lighting/Basic-Lighting ︎

The theme of the jam was “Credit”. After discarding some ideas about movies credits and bank loans, we decided to just make any game which would accommodate the mechanic idea we had: reloading by real-life inserting coins (or credits) in a machine. And this is what I want to focus on telling you about here.

Because of my previous experience in Malagajam 18 – Bernochyl, I was no longer scared of making physical devices to interact with games. Also, Javi already had some experience using his new 3D printer. So I designed a box with a coin slot that would also hold a pc mouse. The coin would activate the mouse’s laser, and that’s how the game would know a coin was inserted.

The original idea was to put the mouse on top and, when inserting the coin, it would slide just under it, activating the mouse’s sensor through a hole. However, because I had to eyeball all the measures, the gap between the sensor and the coin’s path was too large for it to detect it at all.

Despite this drawback, we were lucky to find another solution that didn’t require to change the already printed design. We dismantled our old mouse and attached its internals to the inside of the box (it wouldn’t have fit otherwise). The coin would trigger the mouse with its face, instead of the edge, while passing right along the sensor.

With this solved, I joined the rest of the devs to continue making the actual game. The idea that came up was a tower defense game in which the player, a cook, would move around the field and build traps for the critters, that would try to eat his cake. The player would also need to get close to the defense towers to reload each with magic, by inserting coins into the coin machine.

Here’s the trailer we made for the game, where hopefully you can better appreciate the mechanics:

Props to our artists Belu and Alberto, who created the fantastic artwork and worked seamlessly despite having met for the first time in the event.

In the technical side, we didn’t do anything (else) too crazy. I just want to highlight a couple of things. First, that we used Unity’s pool system package, that allowed us to create object pools for enemies, projectiles and traps very easily. And second, the use of DoTween to make lots of stretch, squish and bounce animations, which added a lot of quality to the game and didn’t require almost any effort to set up. Just with a couple of lines of code, we made some simple yet effective animations for the characters, here’s an example:

        float phase = 0.15f;

        spritePivot.DOScaleY(1.2f, phase)
            .SetLoops(-1, LoopType.Yoyo)
            .SetEase(Ease.OutSine)
            .Play();

        yield return new WaitForSeconds(phase/2);

        spritePivot.DOScaleX(1.1f, phase)
            .SetLoops(-1, LoopType.Yoyo)
            .SetEase(Ease.OutSine)
            .Play();

        float rotationAmount = 15;
        spritePivot.localRotation = Quaternion.Euler(0, 0, rotationAmount);
        spritePivot.DOLocalRotate(new Vector3(0,0,-rotationAmount), phase)
            .SetLoops(-1, LoopType.Yoyo)
            .SetEase(Ease.InOutSine)
            .Play();

Overall, it was such a great experience working with the team, and I’m super happy with the result. They were just excellent to hang around with, and I think you will be able to feel this with the vibes of the game. We even won a mention to the most original game of the jam!

You can give the game a try, even though it’s not the same experience as if you played in the jam with the coin machine.

My team and I already had some ideas on how we wanted to approach the jam this time. We loved an alternative control game from the previous edition: https://culoextremo.itch.io/caja, and we wanted to try experimenting and doing some alternative control game too.

So a couple of weeks prior, I purchased an Arduino board plus a sensor kit, and started learning about it, basically from zero. I found about Tinkercad, and started coding some basic examples with help of online tutorials.

You can find these, along with the code, in my profile: https://www.tinkercad.com/users/518JwInpQLt?type=circuits

I had the intuition that having something simple like that at hand was more than enough to add a cool twist to any game we would think about. And I was very lucky to receive the parts just one day prior to the jam!

The day came and the team of four drove to the Polo Digital. This time we rented an apartment right next to the premises, which improved the experience greatly. After the theme was announced: “de mal en peor”, we ran towards the closest bar, as we’ve been doing previous times, looking for inspiration. And indeed it came. We had the most hilarious interaction with an Ukrainian man selling lottery tickets. We chatted about work culture and communism, but when that was over, we decided to the game should be about what Ukraine is most famous for: Chernobyl.

We thought it would perfectly fit the theme, and we could make a control panel with all of the weird inputs we brought. As Javi also brought along some USB buttons, knobs and keypads.

We also came right away with the main mechanic. Gameloft, who was sponsoring the event, provided hand fans to all participants. And using the ultrasonic distance sensor connected to the Arduino and to the game, we thought that the most important task of the game would be blowing air with the fan to lower the reactor’s core temperature.

We also had the idea of using the gyroscope of a mobile phone, strap it to an office chair, and track the movement to rotate the in-game camera. Sadly, the tech we used for this, Unity Remote, made the game incompatible with the rest of our key-mapped inputs, so we ended up discarding the idea. Of course, Unity Remote intended use is debugging mobile apps via cable, but other alternatives are harder to implement, and we almost got away with it anyway.

After making some mini-games and some Simpsons memes, we had the game: Bernochyl.

As you can appreciate in the trailer, we build a cardboard panel with all the inputs hidden underneath. The player would pay attention to the alerts displayed in the screen, and interact with each mini-game to help keep the reactor’s temperature at bay.

Even if the mobile phone mechanic didn’t work out, I’m really proud about the alternative. Suggested by Santi, we built a dynamic camera system with Cinemachine. It worked by setting several static virtual cameras, pointing towards the different mini-game panels. And a simple manager changed the camera priority towards the current mini-game being interacted. It was a modest yet elegant design, which added a plus to the game’s quality with very little implementation effort.

The 3D look was also incredible. We were so lucky to count with Paco in the team, who would make all the 3D art and make sure everything worked perfectly in the engine.

We were also very lucky to be offered help by the in-house music studio team to make the music and SFX, which were phenomenal. And also, a neighbor group lent us their 3D printer to print the small appliances we connected to our Xbox controller joysticks.

After much balancing with Javi, we got to the end result, which I think was quite compelling. When the time for trying out games came, and even some time before that, we were visited by lots of people who had a great time. We also had a great time watching them play, as each person used a different and hilarious technique to wave the fan while trying to coordinate their other hand. They wanted to repeat their runs, recommended it to their friends, compete against each other… It was a blast!

Later that evening, we won the “Best Design” award!

You can find the game in itch.io:

This is more like inked style rather than a oil painting pointillism style.

After playing around for a while I found that I would need to make a decision between either:

• Have a gradient with points of varying size
• Keep the points size constant but have a discrete number of shade layers

In the end I decided to go for the second option, as I think keeping the point size constant was a must to keep the style. The layers are not too noticeable, but the issue here was to get dark enough values. The four layer setup could only get so dark as the middle value I wanted to achieve. Finally I solved this with a “mesh” layer that simulates drawing short strokes with a thicker pen.

Here is the end result:

Now to the breakout

The points layer is just a Voronoi noise with a remap that allows to change the resulting points thickness.

I also made it so the pattern could be animated every few frames by playing with the texture coordinates.

The blue value is a “#frame“ attribute. And the “Value“ input it is just a random number I set outside the group to make sure the points do not overlap.

Then it is just a matter of defining the layers size with raps and mixing everything with multiply operations.

I also made a “mesh layer“ the only difference here is that I set the Voronoi to “distance to edge“ mode.

The outline is made with a simple grease pencil setup:

Notes

There is a couple of details I am still not really happy with, but I could not get a way to fix.

1. In a very close up look, you can perceive some hard cuts in the layering

2. I really could not find a way to reproduce this wavy pattern in the dots layout. I tried doing some math in the vector input of the Voronoi noise with a wave texture, but that would also stretch the dots and completely break the effect.

Even if the final result is not perfect, I think it is enough to sell the effect when you look at the whole picture.

• Improving the work pipeline of several teams in the studio: Environment, Characters, Animation, Vehicles, VFX and Level Design. By creating and improving 3DSMax tools, scripting in the game engine and Python.
• Facilitating bidirectional communication between art and technical teams.
• Creating shaders for new effects and improved visuals.

Another game jam game made in 48h. The theme of the jam was “Unnecessarily Complicated”.

My team was composed of another programmer, two artists and one designer. The idea behind the game was to make the input overly complicated by isolating each of the controls and assigning them to a different player.

You can try the game here.

We made a video for the game’s presentation in the jam:

This is a local multiplayer fighting game in which you will have to write words that contains the root word given. You will damage your opponent each time you write words successfully and with each word-strike.

“No sueltes mi mano” is a simple physics puzzle game about love and compromise. It can be played in the browser here.

D&D Map Sketcher is available for free in itch.io.

Seeing the potential this could have, I focused on building the community and setting a development Patreon to be able to further support the development.

D&D Map Sketcher has been featured in articles in Rock Paper Shotgun and 80LV.

In this project, I worked as a generalist game developer focused on Unity3D:

– Gameplay
– Optimization
– Graphics and VFX
– Tools
– Physics
– Services

In order to play you have to move the camera (Drag Right Click) to look around, the only way of interacting with your surroundings its via your gaze

“A glance at a bar, those eyes, a spark between you two that could set in motion a whole lot of new things…

… This is an experimental game which tries to reproduce the sensations surrounding that precious moment.”

Play the game here.

Virtual Rhythm is a VR game about a monkey’s birthday party where you play loads of rhythm-based minigames, enjoying the music in a tropical paradise.

With Virtual Rhythm we aim to develop a Video Game that uses rhythm and music as the core for many and diverse minigames, giving a funny and lighthearted experience in which music, mechanics and art are combined into a colourful and cheerful way, with several difficulty levels, attracting that way the more infant public that just want to have a good time and the more hardcore players that search getting top scores.

In this project, I have been in charge of the producer and programmer roles.

During the development of Virtual Rhythm, we have attended to several events, such as Reboot Develop in Croatia and Guerrilla Games Festival in Madrid. And we are planning to showcase it in further events around Europe.

Try it out here.

It uses a 3-layer feed-forward neural network. The network is provided with initial training values and gets better each time it crashes. It receives the distance from the walls to the car from three raycasts and produces a combination of “turn” and “thrust” values, which are then used to control the ship.

I also took the opportunity to experiment with shaders. I use custom shaders for:

• Skybox
• Terrain (geometry shader)
• Coins. Hologram effect
• Trail. I create the mesh dynamically and then add a particle premultiply shader, that in combination with the post-processing creates that flaring effect.
• Post-processing with Unity’s post-processing stack

You can try the prototype here.

The game is a slow-paced platformer with puzzles. We were a group of nine developers: three designers, three artists and three programmers. We aimed to have a complete level by the end of the year and, although we had to cut some features, we got to make it just in time.

The game features a hook mechanic, which was my main focus during the development. It’s procedurally created each time the player throws the hook, using joints to tie the different sections together and provide a realistic behaviour. Other tasks I did during the development were the player movement and animations; some puzzle mechanics, and some of the visual effects.

You can download and try the game here.

You can access the paper on the explanation of the programming of the game, some highlights of the code I wrote and an investigation paper I did on shaders in Unity here.

The game of the jam was to mix two different genres together. With that is mind, we decided to make a combination of a 2D action sidescroller and a Life-simulator clicker. The story would be about a hero, who has the duty to overcome the Immortal Evil. During the game, the hero ages, so her stats start to go lower and lower until she can barely hold her sword. Unless the player realises the secret ending, the boss will eventually kill him.

The game was made in Game Maker and exported to Windows and HTML5.

You can play the game here:

https://danifm.itch.io/proelium

Contributors:

• José Martín

• Alejandro Moralo

As by that time I had almost four years of experience with the engine and even some months of professional experience, I decided to share my knowledge among the wannabe programmers that wished to attend. The class was imparted in Spanish, as any other class in ESNE. Because the students in ESNE have to make a project at the end of the semester, I thought that having an alternative to Unity (that they don’t know how to use well yet) and Construct (which is not very useful to learn) would be very useful for them.

Before the class, I had prepared a presentation and worked on the example I was going to make.

In the class, I made a quick introduction to the basics of programming a game with a game engine, explained the components and specifics of Game Maker 2 and made an interactive example with the students.

In the end, it turned out pretty well, and the students felt like it was a good use of their time and had learned well these basics, which would have been more difficult to achieve doing so by their own.

You can download the slides here.

The banner for the class was designed by me as well.

Kairos finished in the top 5, from 115 entries.

We had two weeks to develop a game that fitted the “meta” theme. In the end, we came up with the idea of a Greek emperor, who would win an achievement every time he makes a decision. The idea would be to give these trophies as much importance as possible, for later they would be removed from the emperor if he decides to give them away in exchange for his immortality.

The game is made in Game Maker and exported to Windows and HTML5.

You can play the game here:

https://danifm.itch.io/kairos

Gameplays:

(min 23:33)

Contributors:

• José Martín
• Alejandro Moralo

With this premise, we came out with the idea of making an investigation game in which the player could not see, hear or interact with the pieces of evidence directly. To do so, he would have to get rid of all the interferences that were around the murder scene and, with a video editing tool – like, process all the corrupted pieces of information, resulting in a video file that he then has to put in order. After that, the result should be a video of the murder scene but, depending on how the player orders the files, there could be multiple endings.

To add an extra experimental feature, the whole game was controlled using a synthesizer controller. This made the user interaction be another challenge, apart from the game itself.

We divided the game in different puzzles, being the first one a hidden shadow puzzle, where the player had to move the light and the camera to get the correct silhouettes, made by some abstract sculptures, on the wall. Then the player would have to find and collect some videos and sounds which were spread all over the room, having to get rid of the glitches that hid them first. After all this, the player would have the murder scene in hos UI, so he would have to put it in order and play the preview. We decided to leave the ending open for the player to make the final guess.

About the programming, the game was made in Unity, with a special plugin for the controller. It was quite a simple game to make, however, it was a challenge to work with multiple cameras and a complex UI system.

WARENA is a strategy game, for two players in which each player has to control three units that can change their stats during the game, and try to destroy the three enemy units. The game is played using smartphones, a physical board and physical cards. The players have to look through their phone’s camera to the board, where the units will appear on the screen. All the interaction with the board and the units is made using the touchscreen of the phones.

The technology we used is the Unity engine, together with a plugin called Vuforia. The game features local network connection with a lobby system, so connecting with friends in the same room is really easy.

The repository of the project is closed, but you can download the master branch here.

I also did a blog during the development of the game. You can see it here.

The idea for Temple of ages was to make a dungeon crawler with procedural-generated levels and rooms. Heavily inspired in “The Binding of Isaac”, but focusing on melee attack mechanics.

The story, as the theme of the game was required to be about prehistory, was about a child from an ancient South American tribe who is selected as a sacrifice and gets enclosed in a pyramid.

When the deadline met, we got the core mechanics working and a pre-designed first level. We did not get time to make the procedural algorithms for the level and room creation, though.

Mad Tribes is a strategy and unit-management game with a combat system based in flanking the enemy units with your units. The game featured effect card mechanics as well.

Here a link to the instructions in Spanish.