InfectedBytes

Published Entity Composer

Tue, 07 Sep 2021 19:04:00 +0000

Entity Composer

Game data management solution for designer and developers.

No more spreadsheets or direct json file editing, instead manage all your games data in a simple UI and export it to a format of your choice.

Website/Documentation

Download

Compose your Entities

Define your entities by simply adding components to them. Each component can consist of any number of fields, you can even define your own custom data types.

Create Items, Enemies, Spells, or anything else via a data driven design.

Homepage Migration

Fri, 14 Sep 2018 20:44:00 +0000

Homepage Migration

My previous homepage was using the Drupal CMS, which is of course very powerful, but actually much more than I actually need. Furthermore Drupal and it’s modules are a bit error prone and tend to have security issues. Of course these issues are typically fixed very fast, but it still is an inconvenience for me as a Drupal user.

Therefore I decided to switch to Jekyll. Instead of using a database, it takes the static content, renders markdown or liquid templates, and produces a complete, static website.
Because of this it simply can’t have a security hole. Additionally it doesn’t require php or mysql and is therefore super fast.

Missing blog posts

As you may have noticed, there are plenty of blog posts missing here. This is the case, because I’m too lazy to import them here. Yes, there are automatic importers, but they can’t fully import everything and I would have to manually correct the import errors.

Therefore I decided to only import the important posts (according to Google Analytics).

Published Coding Essentials

Thu, 26 Jan 2017 15:29:15 +0000

Coding Essentials

Unity is a great engine that makes use of the powerful Mono Project, which is an open source implementation of the .NET Framwork. But since Unity doesn’t use the latest version of it, some important things are missing, like a Restart method for the Stopwatch or the different Tuple classes. Therefore this package provides you with these missing pieces.
Furthermore this package provides you with several fundamental data structures and algorithms, that are important for modern game development with Unity. For example this package contains a serializable dictionary and priority queues. Some other features are:

FastList: fast and serializable list data structure + custom inspector
UnityDictionary: fast and serializable dictionary + custom inspector
Mutable and immutable tuple classes and structs
Several programming design patterns, like: Singleton and Observer
Different tree data structures:
- Binary tree
- Quadtree
- Octree
- …
HSV and HSL colors
Integer vectors
Large set of extension methods for faster development
… and much more

All in all this package contains over 100 fully documented classes with full source code.

Documentation

The source code of this package is fully documented, furthermore the complete API documentation can be found online: Coding Essentials Docs
The documentation also provides you with several articles for a quick start into game development.
AssetStore
Get it now from the Unity3d AssetStore: Coding Essentials
Leave a comment if you have any questions.

Project: InfinityPi #5 (Simple Test)

Sat, 30 Jul 2016 22:34:00 +0000

Portable Power

The parts for portable power are nothing special:

6600mAh LiPo
Adafruit PowerBoost 1000 Charger
Sparkfun LiPo Fuel Gauge

The LiPo has a voltage of 3.7V, but the Pi needs 5V. Therefore I use the Adafruit powerbooster, which will converts the output to 5V. Furthermore it has a load-sharing circuit built-in, which means that I can load the battery while it is in use. The gauge is not mandatory, but it is very useful, because with its help, the Pi can measure the voltage and display a warning if the power goes down.

Test Run

For a quick test, I just connected the LiPo with the Powerbooster, which in turn is connected to the pi. Furthermore I connected the demo gamepad from the last blog post to the pi. After a few seconds RetroPie is running and I can play some games with this little gamepad.

To be continued

This was just a little test of the most important components. Next time I will continue with the actual gamepad logic and a little PCB for the buttons.

Project: InfinityPi #4 (Joystick)

Sat, 30 Jul 2016 22:34:00 +0000

Wiring

This time it is important to use an Arduino with an ATmega32u4 chip, like the micro. For testing purposes I just use two joysticks and 8 buttons. The buttons are connected via a shift register, while the joysticks are connected directly to an analog pin. For more info on the shift register, take a look at InfinityPi #3 or Arduino ShiftIn.

The pload pin of the shift register is connected to pin 12 (gray wire). The clockEnablePin is connected to pin 10 (orange wire). The dataPin is connected to pin 9 (yellow wire) and the clockPin is connected to pin 11 (purple wire).
The x- and y-pins of the joysticks are connected to the A0 to A3 pins.

Joystick Library

I use the joystick library (version 2) from MHeironimus. It is a nice little library that allows your Arduino to be recognized as a gamepad/joystick. The library can be found here: ArduinoJoystickLibrary. At the moment of writing the library is only in a beta state, but it works well. If the library is installed and included, you have to instantiate an instance of the Joystick_ class (the underscore is not a typo). After calling the begin function of this instance in your setup function, everything is ready to go. You can set your axis values by calling the setXAxis, setYAxis, … methods with a value between 0 and 1023 as a parameter. In order to press or release a button you could call setButton(idx, value) with a value of 0 or 1.

The basic code for my test gamepad is super easy:

#include <ShiftIn.h>
#include <Joystick.h>
ShiftIn<1> shift; // use one shift register
Joystick_ joystick;
void setup() {
  Serial.begin(9600);
  shift.begin(12, 10, 9, 11); // set pins of the shift register
  joystick.begin(); // init joystick
}

void loop() {
  // analogRead will read the axis value (0-1023)
  // set*Axis will set the axis value and automatically sends the change
  joystick.setXAxis(analogRead(A0));
  joystick.setYAxis(analogRead(A1));
  joystick.setRxAxis(analogRead(A2));
  joystick.setRyAxis(analogRead(A3));
  
  if (shift.update()) {
    for (int i = 0; i < shift.getDataWidth(); i++)
      joystick.setButton(i, shift.state(i)); // just press or release the button
  }
  delay(10);
}

After uploading this sktech to your Arduino, it will be recognized as a gamepad. Just go to your system control panel and take a look at the connected devices (on Windows 10, you could just open the menu and type “devices”). And there you will find this sweet icon:

Now go to the controller settings and play a bit around:

To be continued

So basically we now have all gamepad parts together. The next big step awaits us: We have to build a small PCB for our buttons and we must of course implement the actual gamepad logic.
Furthermore it is time to think a bit about the triggers…

Project: InfinityPi #3 (analog IO)

Thu, 28 Jul 2016 19:23:00 +0000

Pro Micro

The Arduino Micro ist super useful and small, but it’s maybe not the best choice if you want to embedded it in a project, because 20€ is not that cheap. I searched a bit around and found a nice little alternative. The “Pro Micro Module Board” is similar to an “Pro Mini”, but with the nice ATmega32u4 on board, therefore you can use it as an input device for your computer. It is compatible to an Arduino Leonardo/Micro, but with less IO pins. It only has 12 digital pins and four analog pins, but in most cases this will be enough and if not, you could extend it with some ICs. I bought a 3 pieces bundle from Amazon for just 15€, so one piece costs only a quarter of a micro, much better :)

It is also a way smaller than the micro, which is very nice for an embedded project. Here is a little comparison to the micro:

You program it just like an Arduino Leonardo/Micro, in fact you will tell your Arduino IDE that it is a Leonardo board (Menu > Tools > Board > Arduino Leonardo).

Analog Input Multiplexer

Let’s go back to the gamepad. The ultimate goal is to implement a full featured gamepad. That means that we need six analog inputs, two for each thumbstick and one for each trigger. So if we would use a normal micro, then everything is fine, because it has enough pins. In the case of the cheaper version, we only have four pins. So we either drop two analog inputs (obviously the triggers) or we use an input multiplexer. Let’s take a look at the multiplexer:

Analog Multiplexer/Demultiplexer 4051

A (de)multiplexer enables you to expand your in- or output pins of your Arduino. The 4051 is able to do both, you could either use it as a multiplexer or as a demultiplexer. We will only look at the input multiplexer.
You have to connect three digital pins to this chip and one analog pin. The pins s0, s1 and s2 are used to select one of the eight pins, you can then read the corresponding value from your analog input. Each of the three pins is basically a single bit of a 3 bit long number. So in order to select the third analog input, you set s0 and s1 to HIGH and s2 to LOW.
For testing purposes I connected two “normal” joysticks and two PSP joysticks to this chip:

You may have noticed that there are three pins connected to GND. The outer most one ist just the normal GND pin. The next one is the Vee pin, the negative supply pin. You could connect a negative voltage to this pin, which enables this chip to accept analog values in the range of Vee to Vcc. The Arduino cannot handle a negative supply, therefore we just connect it to GND in order to limit the range to 0-Vcc. The next pin is the “enable input” pin. If this pin is grounded, the chip will be used as a multiplexer, otherwise it will be used as a demultiplexer.

class Mux {
private:
        const byte sensor;
        const byte s0;
        const byte s1;
        const byte s2;
public:
        Mux(byte s, byte a, byte b, byte c) : sensor(s), s0(a), s1(b), s2(c) {
                pinMode(s0, OUTPUT);
                pinMode(s1, OUTPUT);
                pinMode(s2, OUTPUT);
        }
        int read(byte i) {
                digitalWrite(s0, bitRead(i, 0));
                digitalWrite(s1, bitRead(i, 1));
                digitalWrite(s2, bitRead(i, 2));
                return analogRead(sensor);
        }
};
Mux mux(A0, 8, 9, 10);

void setup() {
        Serial.begin(9600);
}

void loop() {
        // show all 8 sensor readings
        for (byte i = 0; i < 8; i++) {
                Serial.print(mux.read(i));
                Serial.print(" ");
        }
        Serial.println();
        delay(250);
}

Of course there is no need to put it in an extra class, but I like it more this way, because it looks better and now you could also put it into a separate library.
The code itself is straight forward, before I read the analog input, I just select the correct pin via the s0 to s2 pins.

Looking at the Serial monitor, we can now see the ranges of the two different joystick types:

Joystick Axis	min	center	max
Joystick X	0	512	1023
Joystick Y	0	512	1023
PSP X	146	482	859
PSP Y	142	487	840

As you can see, the PSP joystick is a bit crappy. Therefore I hope to have enough space for the bigger one on my InfinityPi.

To be continued

Next we will check out the actual Joystick behavior and we will make a first test gamepad that can be used by any computer.

Project: InfinityPi #2 (digital IO)

Tue, 26 Jul 2016 21:39:00 +0000

Arduino Leonardo/Micro

First of all the Arduino Micro is basically just an Arduino Leonardo in a much smaller form factor. They both have 20 digital IO pins of which 7 can be used as PWM outputs and 12 as analog inputs. But what makes them “better” than other Arduino boards? Why do I want to use an Arduino Micro?
One nice thing is the small form factor. But the most important part is that the Micro is based on the ATmega32u4 microcontroller, which has built-in USB communication. This allows the Micro to appear as a mouse, keyboard or joystick to a connected computer! Therefore I don’t have to write any complex device driver. It will just work, without any hassle :)

The parts

Ideally the integrated gamepad should have all buttons and axes of a normal, modern gamepad, like the famous XBox360 controller.
Therefore it should have:

2 thumbsticks, each one consisting of an x and y axis
2 analog triggers
1 hat switch (or POV or D-Pad)
10 buttons (ABXY, Start, Back, LB, RB, LS, RS)

Okey, the 10 buttons and the hat switch are easy, I could just use ordinary push buttons for those, nothing special.
The triggers are something special. I haven’t found a real solution yet. Of course I could just use normal buttons, but I really, really want to have them analog (like real triggers), but that’s not an easy task. I will try to solve this problem and I will keep you up to date.
The thumbsticks are easy again, but there I have different options:

Joystick

Basically a real thumbstick, with each axis going from 0 to 1023. Furthermore it also has a push button, just like the XBox thumbsticks. So it has a nice range, good automatic centering and a pushbutton! Really nice, but there is a little downside. It is kind of big for a portable gaming station.

PSP Joystick

This is a replacement part for a PSP. Of course the size is much better for a portable gaming station, but it doesn’t have a pushbutton :(
Furthermore its range is a bit small, it goes from about 160 to 820. The automatic centering is really bad, the centered state goes from 490 to 540, so even if you don’t touch it, it might be a bit beneath the real center.

Which one?

Actually I would love to use the real thumbstick, because its range is better, the centering is better, …. everything is better, except that it is a way bigger than the tiny PSP joystick. At the moment I am a bit undecided, but I tend to use the real joystick. Maybe I will later decide to use the PSP version, but we will see this later.
And here a little comparison of the dimensions:

Left one: 38mm * 38mm * 34mm
Right one: 19mm * 19mm * 9mm

Not enough pins!

You may have noticed that this setup would consume all Arduino pins (14 buttons + 6 analog axis). So there’s no way to add any more buttons or any outputs. That’s really bad, because I’d like to add a switch button for different modes, like a normal gamepad mode and a keyboard mode, in which I could control the mouse via a thumbstick.
Luckily the solution is really simple (and cheap). I just use shift registers. A single shift register has 8 digital inputs, while itself only uses 4 of your Arduino pins. Furthermore you can daisy-chain several of them by still only consuming the same 4 pins as before. Therefore I can use 16 buttons with only 4 pins, awesome :)
There are several shift registers out there, I used the 74HC165 and I also wrote a little library for it:

Test wiring

For testing the shift registers I build a little test setup with my Arduino Uno and used my library.

The example code is super simple:

#include <ShiftIn.h>
// Init ShiftIn instance with two chips.
// The number in brackets defines the number of daisy-chained 74HC165 chips
// So if you are using only one chip, you would write: ShiftIn<1> shift;
ShiftIn<2> shift;

void setup() {
  Serial.begin(9600);
  // declare pins: pLoadPin, clockEnablePin, dataPin, clockPin
  shift.begin(8, 9, 11, 12);
}

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print( shift.state(i) ); // get state of button i
  Serial.println();
}

void loop() {
  if(shift.update()) // read in all values. returns true if any button has changed
    displayValues();
  delay(1);
}

Whenever I press or release a button, the state of every buttons is send via Serial.print.

And here the real world example with small buttons:

To be continued

In the next post I will write more about the analog axes and I will show you another microcontroller that is also based on the Atmega32u4, but that is even smaller than the Arduino micro. See you next time :)

Project: InfinityPi (Portable RetroPi) #1

Tue, 26 Jul 2016 20:15:00 +0000

The Vision

As most of you already know, the Raspberry Pi is a super tiny single-board computer. In the current version (Raspberry Pi 3 Model B) it has a 1.2 GHz quad-core ARM CPU with 1 GB RAM. Of course this is not much compared to a normal PC, but it is just enough for a nice little emulation station. So I decided to build a portable one.
My plan so far is to add a nice little LCD on top of the pi and to add a full set of gamepad inputs. Just like most modern gamepads, it should support two thumbsticks, all the buttons and ideally also two triggers. The Pi itself can’t handle analog inputs, but my plan is to use an Arduino with an ATmega32u4 chip. It does not only support analog inputs, but furthermore it can be recognized as an HID device, therefore I could use it as real a gamepad, without any GPIO hacks!

Of course I will also need some portable power…a lot of power, because gaming is very power hungry. I think I will use a few lithium polymer batteries, hopefully they will power my pi for several hours. In order to charge the battery while it is in use, I have to add some load sharing logic, but for now I will focus on the input.

Last but not least I have to model and 3D print a nice case. That’s a bit tricky, because I don’t actually know how robust the material will be. But this is also a step far, far away in the future, because I can only start this step when I have finished all the other tasks.

Which LCD?

I first wanted to use a 3.5 inch TFT from Adafruit, with a resolution of 480320 pixels, but then I encountered a problem. First of all, yes the resolution is really that small, but that’s not the problem. The problem with this display is, that it is only connected to the GPIO pins of the Raspberry Pi and it therefore sends each pxel, one after another to the screen. Because of this, it totally bypasses the GPU! And that’s especially bad for gaming, because it is one of the most important components for games.
Yes, there is a way to overcome this issue. You could pretend to render to your HDMI screen, but instead of really sending your image to the HDMI screen, you just copy the framebuffer and send it over GPIO to your LCD.This way you get hardware acceleration, but copying the framebuffer costs additional time and sending the data over GPIO is also really slow. Therefore Adafruit recommends the smaller version of the screen, with only 320240 pixels. But that’s a way too small!
So what now? I decided to use an even bigger screen, with a resolution of 800*480! The nice thing about this screen is, that it is connected via HDMI and therefore I don’t have any of the problems above! The downside is that this screen is much bigger (5 inch), so the complete system will be a bit bigger… But hey, why not?

I found a cheap one on Amazon, which is even cheaper than the 3.5 inch screen :)
And here it is:

SD Card

Of course you also need a micro SD card. Because we want to add many, many games, the sd card should be really big, at least 16 GB, better more. I only had 8 GB cards of normal size, but the Raspberry Pi 3 needs micro SD cards, so I had to buy a new one. I was really amazed to see how cheap SD cards are. A few years ago I bought my last SD card with 8 GB storage for about 30€ and now a 64 GB one costs about 20€, nice :)
If you buy a card with more than 32 GB, it is typically formatted with exFat and not with FAT32. Unfortunately Windows don’t give you the option to format it with FAT32 in the format dialog. Instead you have to use a third party tool or you have to format the sd card via the console. I chose the later option, but the third party tool might be easier. After that you can copy NOOBS or berryboot on the sd card. Of course you could also skip this whole step and flash your OS image directly on the card. That’s up to you.

To be continued

That’s all for now, I will continue the next days with a few words on the input system and the wiring + programming.
Thanks for reading :)

Arduino ShiftIn

Sun, 24 Jul 2016 22:56:15 +0000

Shift Register 74HC165

The 74HC165 is an 8-bit serial-in shift register. It uses only 4 Arduino pins, while itself can read in from 8 digital pins. If the parallel load pin (PL) is LOW, the data is read from the A to H pins in parallel. When PL is HIGH, the Q pin is set to the value of the first bit. Each time you change the value from your clock pin from LOW to HIGH, the next bit is send to the Q pin. Therefore you can read in all 8 bits sequentially. Furthermore you can daisy-chain several shift registers, while still using only 4 Arduino pins!
The data sheet can be found here: SN74HC165

ShiftIn Library

In order to simplify the usage of shift registers, I wrote a small library that handles the communication between the Arduino and the shift register. It is hosted on Github.

Usage:

#include <ShiftIn.h>
// Init ShiftIn instance with one chip.
// The number in brackets defines the number of daisy-chained 74HC165 chips
// So if you are using two chips, you would write: ShiftIn<2> shift;
ShiftIn<1> shift;

void setup() {
  Serial.begin(9600);
  // declare pins: pLoadPin, clockEnablePin, dataPin, clockPin
  shift.begin(8, 9, 11, 12);
}

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print( shift.state(i) ); // get state of button i
  Serial.println();
}

void loop() {
  if(shift.update()) // read in all values. returns true if any button has changed
    displayValues();
  delay(1);
}

Easy, isn’t it?

Of course you also need to wire up your board with some buttons:

Now you can press those nice buttons and you will see their states via your serial monitor.

More shift registers

If you want to daisy-chain some shift registers, you only have to change a single number in your code. You have to change
ShiftIn<1> shift;
to
ShiftIn<2> shift;
The second shift register is connected the same way as the first one. the only difference is the Q pin, instead of connecting it to your data pin, you connect it to the SER pin of your first register. If you plan to add more registers, you will connect the third Q pin to the SER pin of the second register, the fourth Q to the third SER, and so…
The breadboard layout for two registers will now look like this:

Thanks for reading!

I hope this little blog entry was useful to you! Have fun with my library :)

Published Unified Input Manager

Sat, 19 Mar 2016 15:47:15 +0000

Unified Input Manager (CarbonInput)

CarbonInput is a simple extension for better gamepad management in Unity. Unity itself already provides a simple input facility for gamepads. It is based on defining the buttons and axes beforehand and uses them at runtime by their name.

float axis = Input.GetAxis("Horizontal");
bool fire = Input.GetButton("Fire1");

The input system works, but there are at least two problems with it:

String handling is error prone. It might happen that one accidentally writes "Fire 1" instead of "Fire1".
Gamepads are not standardized. The right thumbstick of a PS3 controller uses axis 3 and 5, while a XBox360 Controller uses axis 3 and 4.

CarbonInput defines a new Input System, which will try to recognize the used controller in order to use the correct mapping. You don’t have to define any axis, CarbonInput is doing that for you and you can access the correct buttons directly:

// X axis of right thumbstick, automatically mapped to the correct Unity axis
float axis = GamePad.GetAxis(CAxis.RX);
// A-Button on XBox360 controller, Cross on PS3 controller
bool jump = GamePad.GetButton(CButton.A);

TouchInput

CarbonInput comes with an own touch input system. On systems like mobile devices, you often don’t have a gamepad connected, therefor you have to use touch controls. You can use thumbsticks as well as normal buttons. Both are available in different styles, like a dark and a light style. Instead of using a generic button without a label, you could also use the predefined A, B, X and Y buttons. Of course you could also use your own images.

CarbonInput will handle any TouchInput the same way as any normal gamepad, so you don’t have to change your code. Just drop a Thumbstick or Button prefab into your scene and you’re done.

AssetStore

Get it now from the Unity3d AssetStore: Unified Input Manager
Leave a comment if you have any questions.