DEV Community: Tom Van den Bon

CodeSim - A Game controlled by Code - DevLog - Part 2

Tom Van den Bon — Sun, 26 Jan 2020 18:17:38 +0000

Phew, a lot has changed since my last update around my CodeSim game. It's been a wonderful learning experience getting to grips with using Unity. My little experimental game has progressed quite a lot. Here are some of the more notable updates:

Graphics

I'm not much of a 3d graphic designer so I'm mostly dependent on existing assets for my game (at least for now). I originally used an asset that had models for vehicles and a town environment. The more I worked on the game, the more I realized that it doesn't really fit well for me.

I did some more searching and came across another set which fits better. I overhauled everything with the new assets and it looks great! Our main programmable vehicle is nou a catapult. It sounds a bit weird, but it has the advantage of turning it into a shooting catapult...but more on that later

Actions and Sensors

Obviously just programming our code vehicle to go forward and turn around is a good start, but it really gets old quickly. I've started to add more commands for "Sensors", this essentially is a command that gives data back but doesn't directly do anything to the code vehicle movements. The sensors I've added are:

Location - Returns our current grid X and Y position
GoalLocation - Returns the goal X and Y Position
FrontSensor - This tells us whether there is an obstacle in front of us
DirectionSensor - This tells us which direction we are pointing to

All these sensors would not necessarily be available from level 1 as they can be added as the levels increase.

Another big action that I added, is the ability to shoot! This allows us to put down "Breakable" objects that needs to be destroyed to be able to let our program reach the goal.

The new sensors and shooting action should make the levels a lot more fun and engaging.

Speaking of levels...

Level Editor

On my bigger issues was how annoying it was to setup a level in code. It worked fine for testing and developing, but once I needed more levels it became an essential requirement.

Originally I went with one of the popular ways that unity developers use (according to a bunch of YouTube videos) is to create a graphic with different colored pixels. When the level loads, it would go through each pixel in the graphic and then build the level.

For all intents and purposes, this worked, but it wasn't really much less work than actually coding in the level.

I decided to bite the bullet and figure out a way to make a level editor in the game that allows you to place objects easily. The end result is a simple top down view of the game world and you just click wherever you want to put down a piece. Pressing space-bar allows you to cycle through the pieces. You also use it to place the player position and the goal position (its smart enough to know that if you try to place to player positions, it will just update it)

At the moment there is only 1 level, but with the above changes done I can start focusing on more expanding the levels and doing more game play mechanics. My little tester (8 years) also have lots of ideas to improve it, but I love how quickly he caught on with writing simple python programs to control the game.

It's been a fun journey considering that I started with Unity for the first time over Xmas holidays. I try to add work on it for an hour here and there in the evenings. Still have lots of ideas so stay tuned for the next update. Also should have a test release with the next update as well so that everyone can play along!

Getting Started with the Odroid-GO and Arduino

Tom Van den Bon — Sun, 12 Jan 2020 13:47:04 +0000

Recently I've started doing more and more projects with the ESP32 module. The ESP32 is a low-cost, low-power system on a chip microcontroller with integrated Wi-Fi and dual-mode Bluetooth.

You get various development boards with an ESP32 module, but I always find myself hacking on a few buttons and a display every time I prototype something new. I have always considered the idea of creating a custom pcb with the ESP32 module, some buttons, display etc, but never gotten around to it. While looking for something else I came across the ODROID-GO, a special 10 year anniversary product sold by HardKernel.

It's essentially a game kit that you assemble (very easy, no soldering required) into your own little portable game console which looks a lot like the old Game Boy. It comes with emulator firmware that allows you to load some ROMS on an SD card to play all those all old retro games we love.

Where things get interesting is that it all runs on an ESP32 module. This means that we can load our own code on there which turns the game kit into a development board with some nice features. These features include a 2.4 inch screen, a couple of buttons and it's all powered by a rechargeable battery which makes it great for testing portable prototypes. The original designers have also added an expansion port that allows you to connect more peripherals. We now have a nicely packaged portable development board for the ESP32 module. Yay!!

Software Setup

To allow us to write some code for the Odroid-Go we need to setup some software.

The following software is required to be able to develop new firmware using Arduino

Arduino
ESP32 Board Support
ODROID-GO Arduino Library

Arduino

The Arduino IDE is our base sofware and everything builds on it from here. You can download a installer for your platform from the Arduino Website. This should be a fairly simple install and you will end up with something that looks like this:

ESP32 Board Support

Once your Arduino is up and running you need to add support for the ESP32 modules. This will install tools to allow you to compile your arduino program for any ESP32 development board/Module

First we need to add the following url to our Arduino preferences.

https://dl.espressif.com/dl/package_esp32_index.json

Click on File->Preferences to get the following window:

Click on the icon next to the Additional Board Manager URLs to bring up a new window and paste the link above into the textbox

You can now access the Boards Manager under Tools->Board: ...->Boards Manager and search for esp32. Simply select the package and click on install

After this has been installed you will now be able to select from a variety of ESP32 development boards

ODROID-GO Arduino Library

The last step is simply to install an arduino library from HardKernel that gives us access to easy functions to use in our Arduino scripts specifically related to the ODROID-GO. This includes options to write to the LCD, detect when buttons have been pressed, etc.

https://github.com/hardkernel/ODROID-GO

The final download is the github repository at the link above. You can either clone the repo or just download a zip of it. You want to place the contents in your Arduino libraries folder. On a windows installation this would mostly be in your Documents->Arduino->libraries folder

If your Arduino IDE was open during this process then please restart it now. If all goes well then you should have ODROID-GO examples under you File->Examples menus in Arduino

Testing

If all goes well you should now be completely setup to compile code and upload it to the ODROID-GO

You can now plugin in your ODROID-GO into a usb port. Give it a few seconds to install any drivers it might need to (if using Windows).

To test load the Hello_World sketch from the ODROID-GO examples and select the ODROID ESP32 board from the boards menu (Under *Tools->Board..). Make sure the port is pointing to the new serial port that enumerated when you plugged in your ODROID-GO

Click on the Compile and Upload Button (The arrow next to the checkmark). The can take a few seconds when you compile for the first time, but subsequent times will be faster (depending on the changes you make).

If all goes well then you should now see the Hello World demo on your ODROID-GO!

Go ahead and try out the various examples and have fun!!

CodeSim - A Game controlled by Code - DevLog - Part 1

Tom Van den Bon — Fri, 03 Jan 2020 11:14:43 +0000

Game Concept

I love games in which you can code. Be it something simple as a pseudo language or a game that has a lua interpreter embedded into it. A nice example is Colobot. I spent many hours on it.

Recently I starting playing with Unity with the idea of using it for a couple of work projects. Not so much games, but rather interesting interfaces to production equipment. While learning how to use Unity I got the idea that I can easily make my own game that uses code to control it. Thus the concept of CodeSim (temporary name) started.

The basic concept is that you control a object, player, etc in the game using an outside program. The program that controls the game needs to be separate from the game/simulation itself. This allows the player to use his preferred programming language and environment.

I started with this simple example of how you would control the vehicle in CodeSim:

import sys
import codevehicle

codevehicle.ConnectVehicle()
codevehicle.Reset()

try:
    codevehicle.TurnLeft()
    codevehicle.MoveForward(3)
    codevehicle.TurnRight()
    codevehicle.MoveForward(15)
    codevehicle.TurnRight()
    codevehicle.MoveForward(2)
except Exception as e:
    print("Program Failed, Reason: " + str(e))

print("Done")

The core concept is basically similar to Logo

Very basic of-course, but if the underlying game engine could be controlled this way then you can start creating all kinds of fun things/challenges in the game.

Required Game Features

A simple game world with a robot/vehicle controlled by the player
Some kind of api interface that is simple enough that almost every language can talk to it
Real time update of the world as the program runs with a goal to reach, or indicating failure

I'm sure there will be many more features in the future, but for the concept to work I had to have atleast those 3 items

Game World

Unity makes it pretty easy to create a gameworld, I decided on a 3d game world that is simple and I found some nice 3d assets to use in this proof of concept.

Our vehicle started out with simple 3d model of a car and some c# scripts that gave us functions to move it in a turtle like fashion, ie (MoveForward, TurnLeft, etc)

For the first couple of tests I made a basic "end goal" gameobject and some obstacles it needs to avoid.

Game API

To allow our player to control the vehicle in the game we need to create an api of sorts. I decided that sockets are the way to go. When our game starts up it listens on port 13000 on the localhost and waits for any incoming connections. Our current list of commands are:

MoveForward(amount of units to move)
- move the vehicle forward and specify the amount of units to move
TurnLeft
- makes a 90 degree turn to the left
TurnRight
- makes a 90 degree turn to the right
Reset
- Reset the vehicle to starting point

These commands are sent in plaintext to the socket server in the game. To move the vehicle forward 50 units we send the following text

forward,50

The game will respond with one of the following:

OK             # command successfully executed
COMPLETED      # goal block reached (ie. end of level)
DISABLED       # vehicle collided against something and is disabled (required reset)

A simple command set, implemented in a simple way, but enough to test the concept

Watch your program run!

As a first test I implemented a simple python module that will send the commands to the socket server. Using Visual Studio Code is very simple to run the program and see the results in the game:

When your vehicle hits an obstacle it will go in disabled state and need to be reset again before you can send more commands to it:

Successfully reaching the end goal looks something like this:

And with that we have a working proof of concept of a game that can be controlled from your own code outside the game. This is nothing group breaking and other similar games exist. But this a fun way for me to learn to use unity :)

Next Steps

With the basic core working I'm keen to expand on it further. For the next update I'm planning on creating some proper levels and add some more interactions. Maybe a radar that lets you detect obstacles, or action buttons you can drive over the make things happen.

Let me know in the comments if you have other ideas that would work nicely with this concept.