Will you be funding / buying my c# block engine if I port it to Unity3d?

Hi there guys, first of all I'm pretty a new unity guy. Great community! So I've just seen this topic and it was a pretty interesting read for me.

I've been working on a block engine called Voxeliq for over 6+ months (with some big breaking intervals) and it's somewhat in a state that's I'm proud of. The project started just for fun hacking to see If I could go for a simple minecraft-like engine/game. After a while I got lots of progress but still couldn't came with a gameplay idea which I could use within this kind of block engines. (and really I don't think world needs another minecraft clone in gameplay terms).

The Voxeliq Block Engine

• C# XNA 4.0 based as of right now - being ported to MonoGame.
• Dev-blog: http://www.voxeliq.org/page/blog/_/voxeliqengine/
• Youtube: http://www.youtube.com/voxeliq
• IndieDB project page: http://www.indiedb.com/engines/voxeliq
• tigsource topic: http://forums.tigsource.com/index.php?topic=23605.0
• gamedev.net topic: http://www.gamedev.net/topic/615739-voxeliq-engine-c-xna-40-voxel-engine-in-development/
• devmaster.net topic: http://devmaster.net/forums/topic/15574-voxeliq-engine-c-xna-40-voxel-engine-in-development/

So what I have is a block engine completely developed in C# XNA - which I've also started porting to monogame/develop3d (which basically is a XNA alternative that runs over OpenGL and can target macos, linux, iOS and Android).

As I couldn't really came with a good gameplay idea, I've started to think about re-shaping the project as an "block engine" and license it to third-parties - but the problem was XNA/Monogame combination restricting the idea of "engine" itself. So by chance I hit the above thread where someone offered the idea and got positive feedback which eventually made me evaluating the idea of porting it to Unity3D and asset store.

Videos

So before explaining more details, I'll be shooting a few videos of the engine itself to demonstrate what it's capable of;

Voxeliq Engine VII - Bloom Effect

• Video starts with ingame visual debuggers - you can skip to 0:30.
• In the video engine is set a view distance of 15 chunks in any direction, so the visible cached world size is (15*2+1)*(15*2+1) = 31 * 31 = 961 chunks - which means a total of ~31 million blocks.
• Average FPS in the video; ~120+.
• Average memory usage: ~200 mb.

Voxeliq Engine IX - Monogame Port

• A proof of concept video that shows Voxeliq Engine running over MonoGame (so over OpenGL) which is already featured on MonoGame project site itself.

Voxeliq Engine VIII - Speed Test Video

• A top-down speed test video, that all chunks are in view-range.
• Infinitive world support is clearly visible.
• 961 chunks and ~31 million blocks in view range which we move through the world and new chunks are calculated repeatedly.

Voxeliq Engine V - 11.2011

• Yet another proof of concept video back from November 2011
• Features infinitive world.
• Features basic block building tools.

Engine Capabilities

• Block textures support (even high-resolution textures!)
• Toggle-able infinitive world.
• Ambient occlusion.
• Fluid-fill sun-lighting.
• Day night lighting cycles.
• Optimized memory block storage system that uses jagged wrapped arrays. For detailed optimization discussion - check here. This is the basic reason why the engine is fast enough.
• Supports two different chunk ranges; view-range (chunks that get generated built immediatly) and cache-range (chunks that gets generated but waits to get in player's view-range before it's built). ie, this allow us a view range of 15 chunks each side where cache-range can be set to 20 chunks each side - those 5 chunks in outer rim will get generated (terrain generation) but will be waiting for to get in player range before getting lighting vertex building.
• Visual ingame chunk block debuggers.
• Chunks in Voxeliq Engine consists 16 x 16 x 128 blocks by default (though values are configurable).
• Perlin Simplex Noise based procedural world generation support.
• Basic biomes support.
• Built-in XML documentation.
• Basic pick-axe for building.
• Basic fly-camera and first-person camera samples.
• Basic fog-effects.
• Local-lights -- being worked.
• Texture-cracks -- being worked.
• Water blocks -- being worked.

Screenshots

Bloom effect


Monogame (OpenGL) Port


Visual in-game block chunk debuggers


Block building tools


Yet another ss


Fog Effect Off


Same Area - Fog Effect On

​

The Unity3d port idea

Will you be buying this?
So I'll be putting a poll up within the topic too see your feedback and based on them I'll be going with this. I'd like to hear you guys If you are interested in buying this engine for your next blocky-world game project and the amount you can pay for it. I'll be putting price ranges in the poll.

Will you be funding this?
Another point I'd like to hear about is if you guys are interested in funding this engine project over http://8bitfunding.com/ or similar sites (though I can't go for kickstarter.com as I'm out of US) -- where I'll be putting perks.

 

:: Reserved for future posts ::

 

Check this list of features (from another thread):

1) A world made from blocks (fake cubes/"voxels")
(2) Dynamic calculated lighting (advanced: with ambient occlusion)
(3) Basic terrain generation algorithms. Ability to plug in new generation methods, including non-heightmap-based ones
(4) No terrain decorations, no special 3d models, plain old minecraft style world
(5) Option for generating fixed size (advanced: infinite world terrains)
(6) Mechanics: digging and block building. Methods for programmatically simulate those operations
(7) Items and blocks should have a 8bit id type
(8) Items and blocks' textures should be 16^2 or 32^2 in size
(9) Dynamic texture atlases generation based on the blocks used in the world. Max atlas size should be 1024^2
(10) Support for water blocks

(10) Advanced: Light sources like torches
(11) Advanced: Support for read/write world game data. Separate world save file generation from actual save operation
(12) Advanced: Fluids (like water) calculations
(13) Advanced: Drop/pick items mechanics
(14) Advanced: Light sources like torches
(15) Advanced: HUD similar to minecraft, where the user can change between various blocks and items/tools available

(16) No need for crafting mechanics
(17) No need for world environment elements (like day/night cycle, rain etc)

Non-functional requirements (quality aspects):

(18) Optimized for performance, not necessarily for space. So it should be fast, really fast because...
(19) Runnable on web and mobile (at least iOS). For mobile, tradeoffs should be documented or configurable.
(20) C# code
(21) Code should be clean, well organized and documented
(22) Project documentation describing how to use it

 

And, by the way, I would easily pay $500 for it!
But hurry up, today we are adapting the (incomplete) open source engine from sourceforge. But we are not interested on doing such thing, we want to focus on our game. I bet there is a lot of guys like me facing this same dilemma.

 

Can you link that other thread please? Is it a similar block engine for unity3d or a game developed?

 

I wouldn't pay more then 20$ for this, theres already a free one out there.

 

I've just checked free one's code a bit (it that's this; http://minepackage.svn.sourceforge.net/ - if not I'm not aware of any other free one - can you link please?) and uses multidimensional arrays for storage which I can say will suck in performance-wise when you go for a big world. Check this for details;

• http://www.voxeliq.org/page/blog/_/voxeliqengine/optimizing-the-engine-i-r175
• https://github.com/raistlinthewiz/dotnet-array-perf-tests (my array performance tests)

 

http://forum.unity3d.com/threads/126244-Cubic-Engine

But development seems stalled...

 

@Rya

Good luck with the free one then.

A good block engine takes time to develop, test and polish. If you pay peanuts you get monkeys.

http://idioms.thefreedictionary.com/If+you+pay+peanuts,+you+get+monkeys

 

Everything takes time to develop, test and polish. A cube engine doesn't make you special.

 

I have no immediate plans for a game featuring this type of engine, but for a low price range ($50-99) it would be worth picking up just to see what would come out of playing around with it.

 

Okay, just got what you mean here (by finding the actual thread) - these are specifically your requirements. I'll be going over them one by one to demonstrate what voxeliq is capable of now.

Yes, voxeliq engine uses self generated, lightened and built blocks (and chunk's). Even better you can move this block/chunk building pipeline to off-thread (or threads) so render-thread doesn't get effected. Here's current chunk states so you can get a better idea of this block/chunk building pipeline.

Code (csharp):

1. namespace VoxeliqStudios.Voxeliq.Chunks
2. {
3.     /// <summary>
4.     /// The chunk state.
5.     /// </summary>
6.     public enum ChunkState
7.     {
8.         /// <summary>
9.         /// Chunk awaits initial generation.
10.         /// </summary>
11.         AwaitingGenerate,
12.  
13.         /// <summary>
14.         /// Chunk is being generated.
15.         /// </summary>
16.         Generating,
17.  
18.         /// <summary>
19.         /// Chunk awaits initial lighting.
20.         /// </summary>
21.         AwaitingLighting,
22.  
23.         /// <summary>
24.         /// Chunk is being lightened.
25.         /// </summary>
26.         Lighting,
27.  
28.         /// <summary>
29.         /// Chunk awaits initial build.
30.         /// </summary>
31.         AwaitingBuild,
32.  
33.         /// <summary>
34.         /// Chunk is being built.
35.         /// </summary>
36.         Building,
37.  
38.         /// <summary>
39.         /// Chunk is all clean and ready for rendering.
40.         /// </summary>
41.         Ready,
42.  
43.         /// <summary>
44.         /// Chunks awaits a new relighting,.
45.         /// </summary>
46.         AwaitingRelighting,
47.  
48.         /// <summary>
49.         /// Chunks awaits a rebuild.
50.         /// </summary>
51.         AwaitingRebuild,
52.  
53.         /// <summary>
54.         /// Chunk awaits for removal.
55.         /// </summary>
56.         AwaitingRemoval
57.     }
58. }

Yes, voxeliq supports dynamically calculated lighting with ambient occlusion. It uses fluid-fill for sun-lighting.

Yes, we've terrain generation API there (TerrainGenerator) which gets a chunk as a parameter and generated the terrain for it procedurally (using Perlin Simplex Noise). Even better you can extend this with your own terrain generation classes. Here's a very basic flat-debug terrain class that extends the API which will render a flat terrain.

Code (csharp):

1. /*
2.  * Copyright (C) 2011-2012 Volumetric Studios
3.  *
4.  */
5.  
6. using VoxeliqStudios.Voxeliq.Blocks;
7. using VoxeliqStudios.Voxeliq.Chunks.Generators.Biomes;
8.  
9. namespace VoxeliqStudios.Voxeliq.Chunks.Generators.Terrain
10. {
11.     /// <summary>
12.     /// Flat terrain that can be used for debugging purposes.
13.     /// </summary>
14.     public sealed class FlatDebugTerrain : BiomedTerrain
15.     {
16.         private const byte DirtHeight = 1;
17.  
18.         public FlatDebugTerrain(BiomeGenerator biomeGenerator)
19.             : base(biomeGenerator)
20.         { }
21.  
22.         protected override void GenerateBlocks(Chunk chunk, int worldPositionX, int worldPositionZ)
23.         {
24.             var offset = BlockStorage.BlockIndexByWorldPosition(worldPositionX, worldPositionZ);
25.  
26.             for (int y = Chunk.MaxHeightIndexInBlocks; y >= 0; y--)
27.             {
28.                 if (y >= DirtHeight)
29.                     BlockStorage.Blocks[offset + y] = new Block(BlockType.None);
30.                 else
31.                     BlockStorage.Blocks[offset + y] = new Block(BlockType.Dirt);
32.             }
33.  
34.             chunk.HighestSolidBlockOffset = DirtHeight - 1;
35.             chunk.LowestEmptyBlockOffset = 0;
36.  
37.             // apply the biome generator on x-z column.
38.             this.BiomeGenerator.ApplyBiome(chunk, DirtHeight - 1, offset + DirtHeight - 1, worldPositionX + this.Seed, worldPositionZ);
39.         }    
40.     }
41. }

Notes:

• Voxeliq Engine will be only processing chunks partially (highest solid block to lowest empty block range) for speed. Anything above highest solid block is air and can be skipped. Similarly anything below lowest empty block is not visible thanks to that neighboring block face.
• Yet again Voxeliq Engines handles block storage arrays specially. Instead of using multidimensional arrays, it goes for jagged / wrapped arrays, which as in the above code, looping through y will make sure all sequential memory access will be ongoing.

Yes, voxeliq engine exactly fits the definition.

Yes, we've toggle-able procedurally generated infinitive world support.

Here's a very basic shovel implementation;

Code (csharp):

1.  
2.         public override void Use()
3.         {
4.             if (!_player.AimedSolidBlock.HasValue)
5.                 return;
6.  
7.             this._chunkCache.SetBlockAt(_player.AimedSolidBlock.Value.Position, Block.Empty);
8.         }
9.  
10.         public override void SecondaryUse()
11.         {
12.             if (!_player.AimedEmptyBlock.HasValue || _player.AimedEmptyBlock.Value.Position == new Vector3Int(_player.Position + new Vector3(0f, -0.5f, 0f)))
13.                 return;
14.  
15.             this._chunkCache.SetBlockAt(_player.AimedEmptyBlock.Value.Position, new Block(BlockType.Iron));
16.         }

Blocks in voxeliq engine are byte structs and actually 8bit is not enough with all the meta-info (like block-type, sun and RGB lighting values)

Yes, Voxeliq Engine supports 16*16 or 32*32 block textures or even high resolution ones.

Yes it supports, texture atlases for blocks.

Started to work on this.

Local light sources are already being worked on.

Being worked on and yes you can move file save operation to an off-thread.

I guess you ask for a fluid-fill water implementation there. Though it's isn't in yet, as we already use fluid-fill algorith with sun lighting, this is possible.

Not supported.

Same with 10?

We don't have a HUD in yet, but possible.

This is already out of scope for a "block engine" and I guess should be implemented by game itself.

Voxeliq Engine actually supports day/night cycles within the core. And we also plan to support blocky sky clouds.

Yep Voxeliq Engine already targets performance optimization and got them in for the most part.

I'm not sure on web but mobile platforms are viable targets for the project.

Yes, it's all C# code.

We already have some XML documentation -- we can eventually get a nice documentation.

Samples are planned to be included.

 

Spectacular engine. It seems a lot of work had gone in it. The speed seems amazing also.

Anyway, most of the things that probably took a while to get done with are done in a snap in Unity, even from people who had never written a line of code before. That goes for basically all the visuals.

The generation, storage and documentation seem nice though.

Anyway If I were to make such a game I would pay say 50 bucks tops for the ported version.

Check out the engine capabilities. You will be able to expand this to an extent which would take months in XNA, in a matter of weeks in Unity.

There are some peeps on the forums that are developing an Unity to XNA export, if that works I could only suggest you move your whole development to Unity.

 

Thanks

Yeah, although I'm new to unity, lately have been playing with it lot to see it's capabilities and given that the time put on voxeliq engine for portability (xna/monogame), Unity3d offers alot!

I actually think to go for a native port of the project and continue with that the extend the capabilities. I really can't imagine the amount of old-school game possibilities with this. I've just started downloading minepackage to get a basic idea how they implemented things.

 

Great feature set!!! Sooooo....



hehehe

 

oh any links on this please? would like to check them.

 

https://github.com/fehaar/FFWD/wiki

 

thanks, will be checking that.

 

Any news?

 

I really didn't evaluated this idea yet as I didn't get any attention at all.

 

Looks really good, If I had the money for it (what's the main problem right now), I would definitly buy it! But since this is only a hobby yet, I can't afford it really

 

Well I mean there are quite some nice block engines around here in the forum. You should checkout the minecraft thread (I don't have a link but should be easy to find). Additionally what worries me is that you don't seem to optimize polygon counts ^^. Maybe you should add more features before you think of selling.

Makes me wonder at what time I will be done with my minecraft engine LOL, just too many things to be done.

 

I feel like anything I could do that was centered around blocks would be considered a minecraft rip off.

 

Release it. Looks really nice. Hopefully it has a build-tool.

 

Whats intresting is you would make more money from 3 guys willing to pay 300 than the other 10 guys willing to pay 50+

 

Then, by that logic, everyone should sell everything for ten million dollars...

One sale, and you're set!

By the way, to the OP, nice work, but not something I'm currently interested in.
But just as an impartial observer, I'd set the price somewhere in the neighborhood of 100-200, based on the amount of work and features.

IMHO, your feature list passed the 50 dollar range a while back.

 

I may be interested depending on how efficient it is.

 

Great. keep it on the lower end of $99-$200. Cya on the release