Lagora's Indie Game Stuff

Luv Games, Luv Playing Games, Luv Making Games

[lagora-indie]

Proc.Edu.Ria: Reactive Update

Lately, at work, I used redux & react, and boy, is it cool !

So, I think I’ll push toward reactive programming for Proc.Edu.Ria. I’ve been rather bothered with how to maintain the codebase, along the various rules, stumbled upon some inconsistency with a part of rule_0 (which blocked me for rule_1). 

I must go forward quicker with the rules, but I can only do this without having to revisit rule_0 every time. And also a way to add features simply.

The redux way ensure my codebase will stay solid (because otherwise, nothing will work).

Next:

A proper way to edit variables

React stuff all the way

Rule 0 fixed once and for all (with unit testing and shit)

Rule 1 for connecting blocks made with rule_0

Find what rule_2 should be

A dynamic skybox

A cloudy sky ground

rule_0 blocks radiosity shaders

[lagora-indie]

Proc.Edu.Ria: wip

[lagora-indie]

Proc.Edu.Ria: W.I.P Skymap and shaders

I’m currently trying (and failing) to take a pause on Pro.Edu.Ria.

Making a bad skymap, but it will get better, as I intend to make it dynamic, related to a virtual time clock.

I should (and will) add a form to manipulate several variables (like debug, size, etc), a bloom shader, and a FPS camera.

[lagora-indie]

Proc.Edu.Ria: Ready for Rule 1 & Rules independence

Having done some heavy coding to have a clean project, I’m ready for rule_1 and some eye-candy stuff (shaders).

I was having some trouble with future rules, and yet, I’m confident saying that all rules should be independent.

That said, it only mean Rules should tend to create content, not deeply alter previous content. I’m not 100% sure that rule_9 will not be dependent to rule_8, but I really want to be able to have rules only based on the seed, and only the seed.

The seed

I use any string as a seed, hash it until I satisfy a hash size equal to size^3, or, if the hash is shorter, hash the hash to fill the void.

So, I should be able to apply any rule to any city block, using XYZ coordinate as offset to travel along the hash.

Stay tuned :) 

[lagora-indie]

Proc.Edu.Ria: 60fps :-)

As only the rule 0 was applied, performances were still atrociously poor. After a bit of code splitting, meshes merging, and maybe native ES6 support, I got to 60fps. The next features to come: - small interface for variables. - caching via database ? - daytime/nighttime pseudo emulation - rule 1: blocks connection/support ? Stay tuned :-)

[lagora-indie]

Proc.Edu.Ria: Rule 0 done (?)

After a lot of time spent on rule_0, it’s done. 

The blocks weren’t properly aligned, so I made a block-grid debug display.

And I add a pilar, because this city should float. Or maybe it should, I’m not sure with all the futurism and all.

Now, the rule_1: Blocks connexion. Like, how to go from one block to the other (on any axes), and how blocks can stay up where they are (with some structural help).

[lagora-indie]

Proc.Edu.Ria: Seduced by babylon.js

For what is my current use of Three.JS, I can tell it’s all but optimised. Mainly because I’m currently at rule_0 (volumetric/spatial density), involved with visual representation of blocks of various sizes. 

Yet, the performances are not here.

And after taking a look at what Babylon.js’s features are, I’m a bit tempted to use it. 

I will check it.

[lagora-indie]

Proc.Edu.Ria: I need a bondfire

I had to change the laptop I used, and spent some time off proceduria, yet, I needed to be fixed on some architectural “issues”. 

Well, issues is a big word, but to put it simply, I needed to break free from the client/server paradigm, which I did by switching to a node-webkit app.

Then, I needed (and still do need) to have a smooth data pipeline. And for that, I need a generic json data schema (for the whole rule_X description), and a fast data generation (maybe using Rx ?)

Lastly, I overall need to stop wasting time considering whatever could be the best solution for the rule, when I crave to move to the next one.

So be it.

[lagora-indie]

Proc.Edu.Ria: Databases

I come and go to many database solutions, because I'm not sure what I want to do. I currently switching from client/server to nodewebkit, so, I must generate all the data, and make them accessible through database query, mainly because making queries will be simpler later and I won't have to generate data on the fly. I tried some embedded, in memory, noSQL like databases, yet, feel unsatisfied by either the documentation, the fact that it was client only, or any other sort of trouble. Ultimately, I'll try any document oriented DB that allow event listening. It's a bit tricky, because when the program start, I don't yet know what the seed is, neither the volumetric density I want. So the current size and seed are fixed, but they won't always be.

[lagora-indie]

Proc.Edu.Ria: What it's not (for now)

Proc.Edu.Ria: What it's not (for now) [ ] A game: I have several ideas about what could be done in such a cool "level", gameplaywise, yet, right now it's all about procedural generation [ ] A cutting edge technology [ ] A game framework [ ] A well documented codebase [ ] An optimised engine for anything

[lagora-indie]

Proc.edu.ria : Nice blocks

After 2 hard days, the “rule 0″ is quite satisfying.

I added some lights & shadows, and intend to add several stuff, hereafter, the TODO list:

An “infinite” pilar that extend to the...bottom ? So the city block can be somewhat on top

A better data handling aka, using the several buffered methods webgl offer

As I do this in ES6, I should use an asynchronous method, so to generate the city on the fly

Keep track of horizontal surfaces, they’re going to be useful later on

Start thinking about what to put on horizontal surfaces, regarding their size

Maybe some “rule 0″ tweaking, or a “rule 1″, as for “rule 0″ correction : Should I keep all the cubes floating ? Or should I think of a way to attach them together ?

What should a cube be (regarding it’s size): A building ? Shops ? Hangar ? I will start to think about some props...

More updates later :)

[lagora-indie]

Proc.edu.ria : Less ugly little blocks

Changing colors, and adding half and quarter blocks.

The code is not optimised at all, and as the “cubic” size is small, the generation is still long. I will find a way to generate it in an async method (maybe generate on the fly).

This still has a little bug that is annoying: Some half/quarter sub blocks are on the same location to some full blocks. I’ll either find a way to decimate them, or fix it 

[lagora-indie]

Proc.edu.ria : Big ugly blocks

Currently, I’m working on what I call ‘rule 0′, for spacial volume density.

Behind the big words, it’s simply to check if a block must be here or not, fully or partially and which part.

As I base my generation on a hexadecimal format, I had to make a lot of tests for the “rule 0″ to be consistent. Right now, it’s all about block "occlusion” (what part to we want to occlude), so it became pretty simple: 

0x0: no occlusion, so the block is full width, height, and depth

0x1 to 0x8 (8 values): quarter sub block aka half sized on all axis, and some rules based on this range, to decide how to position it (from bottom to top, clockwise)

0x9 to 0xe (6 values): half block, splitted by axis  

0xf: full occlusion, so no block at all

Doing this, I’ve spotter that 0x0 and 0xf are pretty interchangeable, considering either we want to occlude (mask a block, so 0x0 mean no occlusion => full block) or carve (amount of sub block carving, so 0x0 means no sub block => full block). In the eand, it doesn’t matter at all (except for code readability).

More update later :)

[lagora-indie]

Project_Z: update (26/03)

Interactables are near completion: A tile position is used to define the interactable location, with up to 4 activation positions. I use this to make some interactables activables only from ‘down’ (below). Example: A computer, usable only when in front.

Later, I could be interested in various interactables utilisation, regarding the direction they’re accessed. Example: The same computer, usable from front, unscrew and open from back.

I used a provided rectangles intersection method to check for overlap between the player “interactable zone” and a given interactable hotzone. I also reduced the surface of the hotzones, because for 1 pixel worth, the overlapping was true, allowing to interact even when not really in front of the interactable.

As a topdown view, the rectangle representing the player bounds was centered, when it should be near the feet.

I still have to display a nice contextual bubble, for the player to know how to interact with the interactable (with which key).

Stay tuned...

[lagora-indie]

VR experiences 2

How first VR “games” will really be VR “experiences” 

Well, full disclosure, except for a google cardbox, I don’t own any VR kit. So feel free to consider my opinion as total pessimistic bullshit.

yet

As many studio, big or small, are working on what to bring to those screens, I kinda feel a bit perplex on the whole subject.

We know how to “be” in VR, how to see things. And the interaction is getting also done, with gamepad-like wands.

I want to use my hands in VR, not a gamepad

This year is the year 3 big companies are releasing consumer grade products. With inexpensive plastic companions devices. Made with the intent to be sold, for an affordable price, and thus, well conceived for the current ideas abotu what VR games sould be. So right now, it’s the first generation of VR for consumers.

So, what about the VR experiences ?

It will be cheaper to make environments, than it cost to make game. Even when those environments will be deeply detailed. VR seems to not be the right medium for linear experiences. Maybe VR will be a really good medium for crime solving small experiences, sold like mobile games (cheap). Get it for 3/5 $/€, spend a few hours to solve the crime. 

Every week/month, a new case.

So, no games ?

That not what I meant. Of course, there’s games. But not all games will be good in VR. Some seems better candidates, if we trust EA or Ubisoft, because as for stereoscopic 3D, it will be more eye-candy and shit. But will it be more interesting ? I don’t think so.

999/Virtue The Last Reward (or any escape room game), any point & clic. All those games are pretty static in their gameplay (opposite of a FPS if you will), and are really good candidates for VR: You have to look for clues, so it’s only natural to remove the “cursor” abstraction, and have the room/level around the player. You take your time to find something, you don’t have to jump over anything.

More on this, later

[lagora-indie]

Project_Z: update (22/03)

Currently trying to implement a system for interactable object: The main idea is to declare interactable object and the mere position the player must be to interact with the object.

I’m not 100% sure right now if I only want interactables, triggerables, or if the activation hotzone must touch the object. May be later, I’ll prefer remote hotzone for a given object, but I don’t see why right now.

Anyway, an empty pixel serve gracefully as a debug sprite that is not ugly AF: You can stretch it and it’s white, so I can play with opacity (and may be color ?).

The overlap method doesn’t trigger anything yet (and that is strange), but I will implement a temporary overlap filler for the time being.

Once the interactable system is ok, I will have a nice contextual pop-up to indicate what action is possible, and perform said action. Mainly, display a dialogue box. 

And no, right now, dialogue boxes are not a thing, but next on my todo list.

Stay tuned :)

[lagora-indie]

proc.edu.r.ai

Recently, I’ve wanted to make a procedural city, and started thinking about how divide space, have a good repartition for building size, etc. Yet, after further searches, I’ve found all that have been done on this matter, and feel a bit overwhelmed.

Not wanting to pull a thread that could be longer than I though, I somewhat put it for later. But boy, does this bite itch a lot !

So, I’m still interested, but not by the idea of making a complete city. Rather a really dense and really limited city block.

Dense as to offer a lot of details, and limited, to offer me constraints.

There’s gameplay ideas behind all that, mind you. And the biggest contraints of them all being that it have to be fully procedural: May be a bit like No Man’s Sky, but to an extremely limited scope.

I will keep study this ideas and keep you informed.