posted                       

code:

---

  right.x    right.y    right.z
  forward.x  forward.y  forward.z
  up.x       up.y       up.z

---

code:

---

   1   0   0    RIGHT    (pitch axis)
   0  .9  -.1   FORWARD  (roll axis)
   0   .1  .9    UP      (yaw axis)

---

code:

---

  x' = x*1 + y*0 + z*0
  y' = x*0 + y*1 + z*0
  z' = x*0 + y*0 + z*1

---

posted                       

I made 'radius functions' for cube, sphere, dome, cylinder, and cone. Then I started something to let starmaps create 'scenes out of objects' and place them anywhere they like on a planet. Lots of work remaining for that.

But I reached a point where I wanted to think about vegetation. Obviously I want 'fractal biodome' as it were, with appropriate things found in locations with specific altitudes, humidity, temp, etc (or under the sea). All interpreted as triangles of various colors.

And, for whatever reason, I want the biome to be synchronized between the players, so I ended up implementing my 'location' system.

When creating a planet, after the fractalization to get the height map (and some gunk like surface normals), I add ONE MILLION random locations

That still seems huge to me, of course, and that would be way too many if I had to render them all at the same time.

They are evenly distributed over my 256x256 array of terrain cells (spanning 8Km x 8Km, or 64 square kilometers of gaming area. Small for a planet, but pretty huge for a playground, I think/hope.).

So I have 65,536 total cells, and 16 locations per cell.

Once pre-computed, I can describe a location by its index 0 to a million (1024K), so in a packet, for example, I can say 'new monster at location 43' and not have to send long floating point values for accurate placement).

Of course, I mainly speak of stationary objects, like trees, bushes, little rocks and such, but I think it should also handle simple fauna hints.

Much like the WoS "monster circles" where a location might be used to say "this is the center of a region with a lot of green slime monsters".

Then, when you were standing around, it's easy for me to work out which cell you are in, then look at the 16 locations in that cell and see if any of them might like to spawn a monster.

So there is no monster until you approach, so no overhead simulating monsters that no one is interacting with). Is the idea.

But, to start, it's just random locations with a handful of metadata (XYZ, heading, id, material, height/width, ..) And when the planet is created I fill it up with random stuff.

Eventually, the random rules should come from the starmap "10% of all locations should be trees of id 15" and then id 15 is described elsewhere as to how it is rendered.

I made some test values to place my primitives here and there in a tree/bushlike pattern. And it's pretty successful. Not ahuge hit on frame rate (I only render 25 cells worth of trees total, and the Level of Detail stuff culls the less important ones, or reduces them to single triangles)

Here's an example -- the whole planet it covered with this stuff (which is, of course, boring in its lack of variety, so hopefully I can improve on that)



My plan (since I can't render all one million potential objects) is to convey the more distant vegetation through the use of dynamically computed 'forest canopies' (Basically wide low domes with foliage colors in a semi transparent texture)
---

Hmm, "Stick Figure Theatre" as part of "Byte-Sized Adventures"

I guess I could at least get some more domain names!

---

ANYWAY, circumstances conspire against my making much progress on this, but I was pleased to have done the location stuff, and it sort of unlocked some other issues (for example, resource collection for the starmap-driven crafting system)

--
Oh, I did have one other achievement: Fixed yet another hang when importing files (it's been hard to make something work with all versions of android, but since google is killing off all the old ones, it has simplified things a little).

--
This enabled me to get back into story writing and I updated my new starMap to reflect my current thoughts on the storyline. I'm being pretty mechanical about it:

* I make an outline in 'comments'

* it boils down to a linear story that is basically a set of quests

* I create a lua co-routine for each quest

* I just type those into the main script in the order I demand they be completed

(parallelism is not too hard, but it's easier for me to do linearly and worry about that later, if ever)

* I have an implementation for each quest, even if it does nothing at all.

* Then I can rework the story, adding/deleting these quests, and refining my comments to myself, and maybe sometime in this process, inspiration hits and a cool idea emerges that needs to be introduced earlier, and changes a character, and makes me happy.

* Then I can run the script at any time, and while it may do absolutely nothing, it doesn't crash. The code always executes (I mean, that's my mandate, never leave the code broken)

* THEN, when I feel like it, I can flesh out the individual quest implementations, and what I am doing right now is just adding dialog boxes of the characters saying what they need to say for that quest.

But not the code that would actually check if the player had achieved anything, just the text popups for "please kill the dragon" and "thank you for killing the dragon"

Then, when I run the map, it just spits out the entire storyline's dialog, one box after another. This turns out to make it easy to detect particularly boring and/or repetitive stuff, and so long as the editor is nearby, it doesn't take a lot of effort to make a change here or there in real time.

Then, I tell myself, After I have read through the story a zillion times and think it's OK and about the right length 'for a starmap', I go back and implement any missing infrastructure to support the challenges I want to place in front of the player.

For example, the logical thing for me to do next would be to send a message from the engine to the script at the moment the player's shell ship enters the atmosphere of the planet.

This would then give the starmap the chance to tell the engine all the 'tweak' values for this planet (fractal seed values for elevation and flora, for example) and any relevant instance data from the moderator.

And in reaction to that, the engine builds the world, clears the display, and you're on the planet, driving a critter.

Meanwhile, lua also gets to set a flag: "player is on the planet" and that first quest ("Get to the planet!") can check if the flag is set, and continue on to the next quest.

The structure of each quest is something like

code:

---

function = getToThePlanet( scene )
  while flagOnThePlanet == 0 do
     hints( "There is a cool planet",
            "The cool planet is around here",
            "Cool people land on it",
            "Have you forgotten about the cool planet?" )
     wait 1 -- pause one beat
  end
  obiwan:says( "Hey, I see you made it on planet!")
end

---