[BIG ANNOUNCEMENT]

BIG ANNOUNCEMENT

Development of The Ascender has been halted until further notice

This is due to two main reasons:
- A general lack of interest in the project, in light of what are (in my opinion) better ideas.
- Some game-crushing bugs that would require a huge restructuring of the entire project, setting it months behind schedule.

I may return to this project soon, but fixing it would require a lot of effort and time, and I think I'm just better off  restarting this project or starting on another project entirely.

I will see you all soon.

I think I've settled on a world generation algorithm that I'm happy with:











So here's how it works.
The world generated through a 3D Simplex Noise map with 3 octaves.

The first octave is general landscape
The second octave is landscape detail
The third octave is roughness

One thing I struggled with throughout making this world generator was having a "solid" bottom layer and a "non-solid" top layer (in other words, I struggled with immense caves within the ground and spotted floating islands in the sky). I simply set the "density" value (which is the rarity of a block generating) to start incrementing after Y = 60, and to be pretty much impossible after Y = 120. (Note: the world height is 160). I'll start on the dirt/grass generation soon, don't worry.
 

[carving]

So...I just got finished typing what should have been this blog post when the page decided to refresh itself, causing me to lose all of my precious typing work. Great.

Anyway, with the collision detection rewrite being (mostly) out of the way, I decided to spice up the otherwise quite boring and predictable terrain generation. Originally, the terrain was generated via a 2D simplex noise map with 2 octaves. This had the advantage of being fast, but the disadvantage of being boring. After reading this post from Notch's old blog, I switched the terrain generation to a 3D noise-based system. This was the immediate result:



A basic 3D simplex noise map generates a world of intricate caves as you can see here. I'll likely use this for the underground world's terrain generation. When I tweaked and added this to a flat and uninspiring 2D noisemap generation, I got some interesting results:



Adding another octave to the 3D octave generation results in more "realistic looking" stone structures:




This system has one fatal flaw: I have no idea how to remove the floating structures that are disconnected from the ground. I found that overhangs and interesting structures and mountains are often generated via a 3D noisemap that is carving a 2D noise-generated landscape. Here's an example of that happening with a 1D noise base and a 2D noise map.



The main issue with this is that the carvings that create the overhangs often look jarring and unnatural, however apparently linear interpolation helps to solve this problem. I'm going to be implementing a system where the base is 2D and the carvings are 3D.

Overall, world generation is fun.

Alright, so this project is not dead, JSYK. I've been having to redo the 3D camera to get raycasting to work, and as a result, I need to redo some of the movement and collision detection code.
 

Don't expect another update from me over the weekend, as I'll be away, but hopefully next week we'll see some more progress.

Aside from some inconsistences I need to fix and some general polish I need to add, collision detection has been finished!
Freaking finally. Not only that, but I also made the world 4x bigger.



And finally, I added some basic anti-aliasing, which helps to smooth out those sharp borders between blocks/chunks.

Hopefully now this devlog can start to get interesting. 

So...it's been a busy weekend. In fact, most of my weekends are busy weekends, so...sorry for not getting anything done. I still need to work out one last issue with slope collisions and then I'll be able to move on to wall collisions.

Slope collsions have been finished!! 

Just spent the morning tidying up player controls and movement so it's a lot smoother. Not can move strictly up and down on front slopes, but now you can move in all sorts of different directions  . I now also have collision for back slopes implemented as well. Hopefully I'll finish up slope collisions by tonight and maybe wall collisions by tommorow. Then, I'll be free of having to program collision detection! 

Finally some progress!



Bottom and front slope collision have been finished! 
Implementing collision for other slopes shouldn't be a problem, however wall collsions might be.

There's also a side effect of the collision code where you "leap" off the top of a slope. It's pretty fun actually, I'll probably keep it in the game as long as it isn't too unrealistic.

We'll just have to see how it goes.

Hello again.

Sorry I haven't posted in a little while, I have finals.
At any rate, this is more of a check-in post just to let you know that I'm still working on the collision detection code, and I have no idea how long it's going to be before it gets finished  .

Actually, I probably should say that I'm currently working on slope collision, and it's trying it's absolute hardest to not cooperate with me.

Sometimes, you run into some pretty tough bugs.

There are two types of these bugs.

The first type is exactly as you'd expect. Tough and in your face. Sometimes they require small rewrites. Sometimes they require entire classes to be remade. Sometimes they even require reevaluations of the entire project.

The second type is the one that isn't in your face, the one you can't see the source of. The one that leaves your head scratching for hours only to find out that was something as simple and stupid as the freaking SPAWN POSITION OF THE PLAYER BEING A PERFECT INTEGER  .

Anyways, coding is fun.

Well, I'm stumped  .

While writing the collision code, I was originally checking every voxel of every chunk to see if the player was intersecting
with it. This had an obvious disadvantage: the game's FPS was decreased from about 1500 f/s to 30 f/s. So that method was out of the question.

Now I have a better solution: only check the voxels that lie within the chunk that the player is currently within. So I start out by looping through the chunks to see which one the player is in. Once that's done, I loop though all of the voxels within the chunk the the player is in, to see which one the player is colliding with. But that's where the problem lies: It has no problem detecting the chunk that the player is within, but when comes to the voxels themselves...well...nothing's really being picked up  .

Hopefully I'll have this one figured out before the day ends.

So what's next, programming the collision system?

Yup.

Me and collision detection have had a long and complicated relationship, so here's hoping everything goes well.

Ladies and gentlemen, it is done!



Not only did I finish slopes, but I added another octave to the 2D simplex noise plane that generates the world, giving the landscape a bit more detail.

The "mystery holes" and the random floating slopes turned out to be linked all to one thing.

Each voxel has 3 values: a 3D vector for it's position, an integer for it's ID (block type), and another integer for it's model type (cube, slope, etc.)

I never bothered initalizing the model value, as I thought it would defualt to 0 (which is the value I use for CUBE models),
and I would just set the model value to whatever it needed to be.

So, apparently all I needed to do to fix the error was initialize the model value to the CUBE value (which is 0) .
I figure that problem wasn't about how the game logic handled this, but rather how it was handled in memory.

Regardless, it means I can finally move on to new slopes!

Here's a screenshot of slopes so far (front and back slopes only):


I, once again, ran into some weird and unusual bugs while creating these slopes:

- Chunk Y-borders were not getting any slopes, this was an easy fix.
- For some reason, back-facing slopes were spawning in mid-air and at random places in the world. I "fixed" this by checking whether or not a slope had ground underneath or above it (as slopes were spawning underground as well). This is likely temporary.
- "Mystery holes":


Not entirely sure what is causing them, though I don't think I've seen them spawn anywhere other than voxels next to adjacent slopes, so that's a start.

Anyway, hopefully I'll get around to implementing left and right facing slopes as well today.

Well you have the ideas down, I'd just like to see a few of these themes and biomes implemented to actually discuss them =P

Thanks for the feedback . Anyway, it will likely be a little while I'm even going to focus on any of these ideas, but they were mainly just plans for the future. Hopefully I'll be able to finish slopes today (assuming I don't run into any stupid bugs), and maybe get started on collision detection.

So, while I work to get slopes implemented, I've been pondering how I'm going to implement the world generator, and several world mechanics (structures, biomes, landscapes, etc). This will be the first post actually discussing gameplay mechanics like this, so if anyone happens to be reading this, please leave some feedback.

Here's the diagram I have so far:



First of all, I should probably explain the unlocks.
I said in the title of this devlog that The Ascender was a 3D Survival Sandbox + Tower Defense combination, and those unlocks specifically have to do with the TD side of things. Waves in The Ascender work exactly as they do in other TD games: defend yourself and the "beacon" from hordes of enemies (I'll explain what the "beacon" is later on).

That being said, the types specifically have to do with the geometry of the world:

- Normal: one continent surrounded by ocean and maybe a few islands
- Archipelago: several islands within a vast ocean
- Sky: floating islands, I have some amazing ideas for this one
- Underground: vast underground caves under an ocean, with maybe a few islands

The themes have to do with the climate/set-pieces (or structures) of each world:

- Normal: a diverse amount of biomes and structures
- Frozen: a wintery landscape and nordic-themed structures
- Inferno: a dry, fiery and fierce landscape filled with explosive architecture
- Dark: an eternally dark world lit only by bioluminessent creatures

Sizes are self-explanatory.
This leaves you with a total of 16 choices for the world generation (not counting sizes/seed).

I hope to get all of these implemented, and I already have extensive plands for some of these world types.
Regardless, I hope you found this post interesting. I should get back to work now.

Looks alright so far, I find it interesting you decided to program the text renderer first.

Didn't get too much done today, unfortunately  .

Currently debating whether to fully implement slopes now or wait until I finish collision detection (both of which are going to be nightmare to program). Not sure there's much else to say though, but hopefully I'll make more progress as the week progresses.