Yeah My Biggest issue Comes from the fact that my friends ate Tech Savvy and will talk about the technical aspects of games, But I actually WRITE the code that makes things work, so when I get into Data Structures and Hierarchy's they go... Durrrrrr, whats an Object again?

my friends no longer want to hang with me because I talk about my game all the time.
...
So my Friends wont hang with me because they fear that ill bore them with technical stuff they don't care about.

How do you know this? Have they actually told you outright, or are you making assumptions? If this isn't coming directly from them, it might be productive to just ask, "Hey guys, is it totally lame when I talk about my game?" If they say no, then there's nothing to worry about. If yes, then hey, at least it's out in the open! And then you can talk about something else.

My Buddy told my girlfriend that "I dot really feel like hanging out with John, I'm kinda tired of hearing about his game."

Ive been working on a game for a little while now but Ive been thinking about giving up. not because I don't have the skills to develop it, but because my friends no longer want to hang with me because I talk about my game all the time.

Not only that but They enjoy playing games, they just play them and don't think about it. Because I design games, I automatically analyze the game, and try to understand the design choices made while playing it.

So my Friends wont hang with me because they fear that ill bore them with technical stuff they don't care about.

Anyone else know what I mean?

I'm following along converting this into x and Y only since im not using a cube I'm using a square. That should work right?

also I dont understand this part:

Code:

      int A = p[X  ]+Y, AA = p[A]+Z, AB = p[A+1]+Z,      // HASH COORDINATES OF
          B = p[X+1]+Y, BA = p[B]+Z, BB = p[B+1]+Z;      // THE 8 CUBE CORNERS,

My problem is im having a hard time reading the Implementation when it says:

X = (int)Math.floor(x) & 255;

first Ive never understood The Bitwise & operator. Seccond I figure it has something to do with him making the array 512 and copying 0-255 to 256-512... Im guessing that it means if the double x comes in as 289.7 first it will floor it to 290 then set it to 35 or something...

EDIT: hahaha Ok that's EXACTLY what he's doing I decided to just stick something in my update and test it.

so x and y can be any value BUT it will be turned into a value between 0-255....

now its just understanding grad fade and lerp

Best: thinking I have a cool Idea and starting to work on it.

Worst: programing then having someone tell me some complicated technique to make my implementation better and then getting lost in it for days on end, so i never finish.

wait your direction at the corners is horizontal, if i have a array of values how do I represent the corners?

Perlin noise works similarly, generating a value at regular grid intervals and interpolating over them, but instead of specifying the actual "height" value at each point, it specifies a gradient vector. This vector tell which direction the height increases relative to that grid point. So instead of interpolating between height values at each of the four corners, you interpolate between the height values derived from each of the gradients at the four corners.

I Know what your saying, I saw a picture before kinda looked like this:



Which I understand how it internally be able to Determine the heights for an infinite amount of points depending on the zoom

It's also interesting to note that for a single octave of Perlin noise, the height at each grid point is zero; only the values in between the points vary up or down.

OHHH see now I see it always reaches 0 because the heights stretch and bend in order to create the internal coordinates but the values of the corners are always 0.

My biggest issue now is:

Instead, you allocate a small array of pseudorandom values and use a hashing function on the input coordinates to determine which gradients are associated with each grid point. This drastically reduces memory usage and allows you to quickly generate a value at any location in 2D space.

I need an array of height values, which gets converted into tiles for the rendering. So if I take one section of 4 points I basically subdivide that one section into a 128x128
point array. and assuming the corners match the block next to it, the block next to it will blend seamlessly?

Im starting to see how Perlin noise is Different then my interpretation now.

to find the height of any point inside the square you use the 4 corners and their distance to the corners to see how they effect the point's height or something like that. and the improved noise function does it with a cube instead of a square.

0.0f to 0.4f water
0.4f to 0.45f beach
0.45f to 0.6f plains
0.6f to 0.8f light forest
0.6f to 0.8f dark forest



This is still using Perlin noise.

Ok After a while of searching I found the video that I wanted to post





NOW granted that this uses the Diamond Square algorithm, I this is essentially what I'm looking to be able to do. but I figured that Perlin noise would get me a better overall result.

Ok that makes sense, Now I just have to figure out how to insert the offset.... and yeah i'm trying to make it infinite. I didn't quite think ahead since I was learning.


In case anyone is interested Here is the Code itself:

Code:

public class DungeonGenerator {
Random r;
int x;
int y;

public DungeonGenerator(int seed, int sx, int sy){
x = sx;
y = sy;
r = new Random(seed);
}

public float[][] generateWhiteNoise(int width, int height){
float[][] whiteNoiseArray = new float[width][height];

for (int i = 0; i <= whiteNoiseArray.length-1; i++)
   {
       for (int j = 0; j <= whiteNoiseArray[0].length-1; j++)
       {
           whiteNoiseArray[i][j] = (float)r.nextFloat();
       }
   }

return whiteNoiseArray;
}



public float[][] generateSmoothNoise(float[][] baseNoise, int octave)
{
  int width = baseNoise.length;
  int height = baseNoise[0].length;

  float[][] smoothNoise = new float[width][height];

  int samplePeriod = 1 << octave; // calculates 2 ^ k
  float sampleFrequency = 1.0f / samplePeriod;

  for (int i = 0; i < width; i++)
  {
     //calculate the horizontal sampling indices
     int sample_i0 = (i / samplePeriod) * samplePeriod;
     int sample_i1 = (sample_i0 + samplePeriod) % width; //wrap around
     float horizontal_blend = (i - sample_i0) * sampleFrequency;

     for (int j = 0; j < height; j++)
     {
        //calculate the vertical sampling indices
        int sample_j0 = (j / samplePeriod) * samplePeriod;
        int sample_j1 = (sample_j0 + samplePeriod) % height; //wrap around
        float vertical_blend = (j - sample_j0) * sampleFrequency;

        //blend the top two corners
        float top = Interpolate(baseNoise[sample_i0][sample_j0],
           baseNoise[sample_i1][sample_j0], horizontal_blend);

        //blend the bottom two corners
        float bottom = Interpolate(baseNoise[sample_i0][sample_j1],
           baseNoise[sample_i1][sample_j1], horizontal_blend);

        //final blend
        smoothNoise[i][j] = Interpolate(top, bottom, vertical_blend);
     }
  }

  return smoothNoise;
}


float Interpolate(float x0, float x1, float alpha)
{
  return x0 * (1 - alpha) + alpha * x1;
}


float[][] GeneratePerlinNoise(float[][] baseNoise, int octaveCount)
{
  int width = baseNoise.length;
  int height = baseNoise[0].length;

  float[][][] smoothNoise = new float[octaveCount][][]; //an array of 2D arrays containing

  float persistance = 0.5f;

  //generate smooth noise
  for (int i = 0; i < octaveCount; i++)
  {
      smoothNoise[i] = generateSmoothNoise(baseNoise, i);
  }

   float[][] perlinNoise = new float[width][height];
   float amplitude = 1.0f;
   float totalAmplitude = 0.0f;

   //blend noise together
   for (int octave = octaveCount - 1; octave >= 0; octave--)
   {
      amplitude *= persistance;
      totalAmplitude += amplitude;

      for (int i = 0; i < width; i++)
      {
         for (int j = 0; j < height; j++)
         {
            perlinNoise[i][j] += smoothNoise[octave][i][j] * amplitude;
         }
      }
   }

  //normalisation
  for (int i = 0; i < width; i++)
  {
     for (int j = 0; j < height; j++)
     {
        perlinNoise[i][j] /= totalAmplitude;
     }
  }

  return perlinNoise;
}
}

Im attempting to make Land Masses based on Height maps. but in small 256x256 blocks which im doing but when I try to tile them I either get:


Or I get this

I am working on a Perlin noise function. Where would I implement tiling into the function?  im guessing X and y have to affect the Seed value. but im not sure if thats all I need to do, or do I have to give the new map the edges of the ones next to it in order to tile...

Procrastinating on a tilepicker(blah blah assets). Improving the player sprite instead.

It's amazing how much "action" you can pack into what isn't animated at all - the player doesn't have a walk cycle, just stand and jump, and yet it feels lively as long as you don't spend your time walking. Maybe I should just have him slide everywhere...

Give the character those Heely shoes then it will make sense.

Finally Sitting down to figure out Perlin noise, since Midpoint displacement is failing me...

Do you need something that creates a polygon node list based on a image? Or a tool like the Line tool in Gimp that creates a node list.

by the way I love the lighting this game looks wicked cool!

I wish I could do stuff like this, Guess it comes with time.

re-writing my Noise map generator to work "on the fly" in groups of 128x128. I'm just having a durr moment on how to start.

Thanks for all the advice! This has always been an issue, I never really thought through.

I am now working on implementing all these suggestions. The Fixed Delta is already fixed. in fact my Library has a .setMaxLogicUpdate(int interval)- "Set the maximum amount of time in milliseconds that can passed into the update method." Meaning that setting it to 1000 would make 1s my max interval. I'm thinking about what my max should be, that article uses 1/60th of a second.

Next is Pause which will help Hiccups by zeroing delta and resume updating when delta returns to a reasonable number.

Also Should I play with .setMinimumLogicUpdates(int interval)?? Should I have a minimum? So it sacrifices framerate on slower machines for logic?

I started to write a Platformer a while back, tried to use some actual physics with some simulated superhuman legs(robot actually) but my physics used deltaTime. which was great cause if the game hiccuped then the jump would still happen with a decreased frame rate... but by tying it to the delta I had a innate issue. if the game stalled for even 2 seconds. the player would fall through the platform because delta would Cause the next frame to make the player fall further then the Bottom of the platform. since I relied on collision with the Platform to make the player stop.

I thought in my new game I wouldn't have that issue. and I was Horribly wrong. The other day I was testing some Collision with walls. I had something happen, I think I switched windows real quick to check something and on resume it took a bit to start back up and I walked CLEAR through the wall and into the next room. since the New position was like x = x+xVelocity*(dTime/1000) it said the new position was like +400 and wall collision never happened

How Might someone avoid this issue?

Still Disappointed I cant get this working in eclipse... Installing Visual Studio now.

I've ALMOST got it working with mingw.

Wait what does eclipse use to compile C++?

GCC as I recall though I had the choice of a few including mingw. I'm just having issues setting up the build path. C++ is all new to me so I figure its expected.

Ive been trying, but tiling is not working right and I can only generate one dimensional arrays. that end up looking like:

Code:

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------X-X------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXX--------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------X-XXXXXXXXXXXXXXXXXX------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXXXXXXXXXXXXXXX-----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXX------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX-----------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------XXX-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX-----XX------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX-XXXXXXX---------------------XXX----------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX------XXXX--------XXXXX--------------XXXXXX-------
-------------------------------------------------------------------------------------------------------------------------------------------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX-XXXXXXXXXXXXX-XXXXXXXX-----XXXXX-XXXXXXXXXXXX-X-
------------------------------------------------------------------------------------------------------------X-----------------------------------------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX---XXXXXXXXXXXXXXXXXXXXXX
-------------------------------------------------------------------------------------------------X---------XXXXXX-------XXXXXX---------------XXX--XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-------------------------------------------------------------------------------XX-------------XXXXXX--X--XXXXXXXXXX----XXXXXXXXX--X-----XX-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
----------------------------------------------------------------------XX-XXXXXXXXX-XX-------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-----------------------------------------------------------X--XX-XXXXXXXXXXXXXXXXXXXXX-----XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
----------------------------------------------X----------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX---XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
---------------------------------------------XXX------XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
----------------------------XXXX----------X-XXXXXXX-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
--------------XX------X---XXXXXXXXX-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
---XXX-XXXXXXXXXX--X-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

this gets me to where I want partially but getting it to work in 2D and then getting it to tile is my problem