Jump to content

  • Log In with Google      Sign In   
  • Create Account

Vilem Otte's Journal

Ludum Dare - Post Mortem

Posted by , 27 December 2016 - - - - - - · 1,068 views

If only making games was as easy as making custom PCBs

 

This Ludum Dare was a really interesting experience for both of us. We wanted to do LD36 already together, but one of us couldn’t, so we had to wait for a LD37.


Posted Image Posted Image

You can grab the game at: http://ludumdare.com/compo/ludum-dare-37/?action=preview&uid=8633
Theme

 

When planning a evening before, we really hoped for a “Small World” theme and were able to come up with an interesting game in matter of minutes. The other themes seemed lackluster, because they were often too limiting - and One Room was one of them.

 

When we woke up at Saturday morning and started discussing it, we didn’t know for like 3 hours what kind of game to make. There were several options (some of which actually appeared in LD as games - solving murder in one room, time traveling in one room, cleaning a room, ...), but we couldn’t think of anything that doesn’t need a good storyline. We just knew two things for sure - we DEFINITELY didn’t want to do a room escape game, and we wanted fancy 3D graphics.

 

After joking about stupid ideas, we somehow came to conclusion that conveyor belt game located in one factory hall could be quite nice and went to discuss details more and decided on our PCB factory game.

 

The development

 

The entire game was developed by two people -- one was focusing entirely on programming the game mechanics and logic and other one was doing mostly graphics, lightning and other visual things (he implemented Inverse Kinematics for a robotic hand from ground up!).


I guess it's angry and searching for something inside those crates?!
— Pavel Kouřil (@Pajka) December 10, 2016

In the first day, we managed to implemented conveyor belts, robotic hands and basic movable objects for the transporters. This was a good prototype, and the game already felt like a fun! So we knew we were on the right track.
The second day was dedicated to modeling rest of game objects and programming the rest of the game. At the end of these two days (around 4 am) we had a almost finished game. It still needed some polishing and changes, but it was playable from the beginning to the end.


This is what we managed to do over the weekend. Shame we have to work today, so there will be only small changes, (if any).
— Pavel Kouřil (@Pajka) December 12, 2016

To make the game totally complete, we really needed that third day - but we were all busy with our real lifes, meaning we couldn’t make much progress, apart from just a few bugfixes and polishing fixes. But we think we still managed to do quite a nice game over the course of these 3 days!
The Good

 

We really had fun when developing our One Room Factory and shared many laughs over TeamSpeak when developing the game - one can only wonder if the game would be even better if we didn’t have to work remotely, but could develop in one room together as some other teams did.
Also, since this was a first LD for one of our members (and first released game too!), we definitely learned quite a lot. Not only from the actual LD, but also from the feedback we’ve gotten. It was definitely an enjoyable and fun weekend!

 

The Bad

 

The HW requirements are quite demanding. Also, based on the comments so far, the game is quite difficult to understand; we did a basic tutorial, but because of time constraints (having to work on Monday AND being based in Central Europe cuts a lot of needed time due to timezone), we just didn’t have time for a proper tutorial.
Combine this with the complexity of the game (and players not being familiar to conveyor games), this game seems to hard to understand for some people. So, to fix this, we are releasing a video tutorial for people who would still want to play the game!
(Don't forget to turn on annotations)
The Future

 

Depending on how we do in the LD, we are considering to finish the game and release it - we are reading the feedback people give us in comments and it makes us really happy when people like the game! The most rewarding comments are from people who want to see the finished version (with a proper tutorial) - and it’s definitely possible it will happen! ;)
If you decide to check our game out, we will be happy for any feedback you will give us! If not, we are at least thankful you decided to read our post.
To try our game, you can do so here:
http://ludumdare.com/compo/ludum-dare-37/?action=preview&uid=86334
Vilem Otte & Pavel Kouřil




Compilers articles

Posted by , 28 September 2016 - - - - - - · 567 views
Compilers, VM, Articles

It's me, bugging around again.

 

I finally got back to work on my compilers-related series, while it is focused on people untouched by automatons, VMs and compilers in general (or more likely the ones that are using it, while not knowing what goes inside), I tried to keep code-base quite small (and still manageable and readable by average viewer).

 

The funny thing around this is, that I've never actually worked on any big compiler (like GCC or such). So the series might give a look of someone who tried to understand how it works and how to do it, with formal languages and automatons theory in head (or at least whatever stayed there after university). While doing the compiler by myself as a form of education and challenge, I realized how little of this is covered in general - and that a lot of people don't fully understand what goes on behind the scenes - which motivated me to learn about compilers and languages more in theory and write at least a few-article series to introduce others into this problematic (and possibly help them avoid a lot of troubles I've hit while making my first compiler).

 

Actually the original final version of the compiler (even before I started working on articles) was able to compile something like this:

int test(int* x)
{
    x[0] = *x * 2;
    return -1;
}

int mult(int** x)
{
    int* y = x[0];
    y[0] = x[0][0] * 5;
    return -1;
}

int main()
{
    int z[3] = {1, 2, 3};
    int x = 7;
    int y = test(&x);
    y = mult(&z);
    while (x > 0)
    {
        y = y * 2;
	x = x - 1;
    }
    return z[0];
}

Into an assembly like this:
.data
.text
test:
	mov eax, 0
	push eax
	mov ebx, [ebp+0]
	mov eax, ebx
	mov eax, [eax]
	push eax
	mov eax, 2
	pop ebx
	mul eax, ebx
	pop ebx
	mov edx, 4
	mul ebx, edx
	mov edx, [ebp+0]
	mov [ebx+edx], eax
	mov eax, 1
	neg eax
	pop ebx
	push eax
	mov eax, 1
	add ebx, eax
	mov eip, ebx
mult:
	mov eax, 0
	mov ebx, 4
	mul eax, ebx
	mov ebx, [ebp+0]
	mov eax, [eax+ebx]
	mov [ebp+8], eax
	add esp, 4
	mov eax, 0
	push eax
	mov eax, 0
	mov ebx, 4
	mul eax, ebx
	mov ebx, [ebp+0]
	mov eax, [eax+ebx]
	mov ebx, eax
	mov eax, 0
	mul eax, 4
	mov eax, [ebx+eax]
	push eax
	mov eax, 5
	pop ebx
	mul eax, ebx
	pop ebx
	mov edx, 4
	mul ebx, edx
	mov edx, [ebp+8]
	mov [ebx+edx], eax
	mov eax, 1
	neg eax
	sub esp, 4
	pop ebx
	push eax
	mov eax, 1
	add ebx, eax
	mov eip, ebx
main:
	mov eax, esp
	add eax, 4
	mov [ebp+4], eax
	add esp, 4
	mov eax, 1
	push eax
	mov eax, 2
	push eax
	mov eax, 3
	push eax
	mov eax, 7
	mov [ebp+20], eax
	add esp, 4
	push ebp
	mov ecx, esp
	mov ebx, [ebp+20]
	mov eax, ebx
	mov eax, edx
	push eax
	mov ebp, ecx
	push eip
	call test
	pop eax
	sub esp, 4
	mov esp, ebp
	pop ebp
	mov [ebp+24], eax
	add esp, 4
	push ebp
	mov ecx, esp
	mov ebx, [ebp+4]
	mov eax, ebx
	mov eax, edx
	push eax
	mov ebp, ecx
	push eip
	call mult
	pop eax
	sub esp, 4
	mov esp, ebp
	pop ebp
	mov [ebp+24], eax
L0:
	mov ebx, [ebp+20]
	mov eax, ebx
	push eax
	mov eax, 0
	pop ebx
	sub eax, ebx
	neg eax
jle L1
	mov ebx, [ebp+24]
	mov eax, ebx
	push eax
	mov eax, 2
	pop ebx
	mul eax, ebx
	mov [ebp+24], eax
	mov ebx, [ebp+20]
	mov eax, ebx
	push eax
	mov eax, 1
	pop ebx
	sub eax, ebx
	neg eax
	mov [ebp+20], eax
	jmp L0
L1:
	mov eax, 0
	mov ebx, 4
	mul eax, ebx
	mov ebx, [ebp+4]
	mov eax, [eax+ebx]
	sub esp, 24
	pop ebx
	push eax
	mov eax, 1
	add ebx, eax
	mov eip, ebx
__start:
	push ebp
	mov ebp, esp
	push eip
	call main
	pop eax
	sub esp, 0
	mov esp, ebp
	pop ebp

While it was structured as procedural-based compilers it wasn't good enough to be presented. So for article purposes I tried to re-work everything in better structure from scratch. Not covering just practical implementation, but hitting a theory from time to time.

 

At that point I realized what all I want to put in the article(s):

  • Arithmetic math operations on integers
  • Arithmetic math on pointers and their reference/dereference operators
  • Variables and arrays
  • Standard control constructs (if, do-while, while, for)
  • Function calling (e.g. define and use a call convention)
  • Interaction with host application (the one running VM)
  • More types - shorts, bytes and floats (and of course variable promotion)
So far, the articles are still somewhere in the middle, slowly getting finished. Although I'm already planning what is going to be next, but let's keep that for next entry.




Dead... or?

Posted by , 19 September 2016 - - - - - - · 799 views

I noticed on myself that my activity on forums dropped to almost zero over the last two years, it was quite high before that (gradually dropping while I was working on my diploma), well... I finished it, and started doing more business and less game development, less (non-job related) graphics development, etc.

 

So I slowly got to the stage where I noticed that I'm starting to be separated from game development, which lead me to a point where I realized I don't want to live a life without making games. Since that point I did two entries to last 2 Ludum Dare competitions ... even though I love making tools, fine tuning my game engine source (which I have actually never used for game), etc. ... I used Unity for that. Anyways - a game is a game.

 

Nevertheless, to keep myself connected to game development I decided to start doing a journal here, regarding my development ideas, thoughts, post mortem articles and maybe even some progress from time to time. And most importantly, code and articles!







January 2017 »

S M T W T F S
1234567
891011121314
151617181920 21
22232425262728
293031    

Recent Entries

Recent Comments