Thursday, February 11, 2016

2/11/16 Update - New map draw and room movement system

This is a 21x21 (bigmap preference) map using a new perlin based system for room icons and biomes.  It draws 4 times as fast as the old maps and looks a little cooler.  Icons subject to change!  In addition, the map drawing code was refactored to omit drawing ansi characters for blind users, or users with ANSI off, eliminating the potential for a map draw to time out.

We also moved to a single room movement system (thanks to a lot of help from the hellmoo admins), meaning we should be able to support much larger universes.  There is still a fair amount to do and we'll post updates as some of the new/overhauled features are completed!

Friday, January 22, 2016

Adding 2d Perlin Noise to Hellcore/LambdaMOO

Add to extensions.c:
  static int p[512];
  static int permutation[] = { 151,160,137,91,90,15,
  /* Function declarations */
  double fade(double t);
  double lerp(double t, double a, double b);
  double grad(int hash, double x, double y, double z);
  void init_noise();
  double pnoise(double x, double y, double z);
  void init_noise()
  int i;
  for(i = 0; i < 256 ; i++)
  p[256+i] = p[i] = permutation[i];
  double pnoise(double x, double y, double z)
  int X = (int)floor(x) & 255, /* FIND UNIT CUBE THAT */
  Y = (int)floor(y) & 255, /* CONTAINS POINT. */
  Z = (int)floor(z) & 255;
  x -= floor(x); /* FIND RELATIVE X,Y,Z */
  y -= floor(y); /* OF POINT IN CUBE. */
  z -= floor(z);
  double u = fade(x), /* COMPUTE FADE CURVES */
  v = fade(y), /* FOR EACH OF X,Y,Z. */
  w = fade(z);
  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, */
  return lerp(w,lerp(v,lerp(u, grad(p[AA ], x, y, z), /* AND ADD */
  grad(p[BA ], x-1, y, z)), /* BLENDED */
  lerp(u, grad(p[AB ], x, y-1, z), /* RESULTS */
  grad(p[BB ], x-1, y-1, z))), /* FROM 8 */
  lerp(v, lerp(u, grad(p[AA+1], x, y, z-1 ),/* CORNERS */
  grad(p[BA+1], x-1, y, z-1)), /* OF CUBE */
  lerp(u, grad(p[AB+1], x, y-1, z-1),
  grad(p[BB+1], x-1, y-1, z-1))));
  double fade(double t){ return t * t * t * (t * (t * 6 - 15) + 10); }
  double lerp(double t, double a, double b){ return a + t * (b - a); }
  double grad(int hash, double x, double y, double z)
  int h = hash & 15; /* CONVERT LO 4 BITS OF HASH CODE */
  double u = h < 8 ? x : y, /* INTO 12 GRADIENT DIRECTIONS. */
  v = h < 4 ? y : h==12||h==14 ? x : z;
  return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
  int noise2d(int x, int y, double scalex, double scaley, int size) {
  double xf = (double)x;
  double yf = (double)y;
  double sizef = (double)size;
  double noiseval = pnoise(xf/(sizef * scalex), yf/(sizef * scaley), 0.5);
  noiseval = sizef * ((noiseval + 1.0)/2.0);
  return (int)noiseval;
  int fbm2d(int x, int y, double scalex, double scaley, int size, int octaves)
  double xf = (double)x;
  double yf = (double)y;
  double sizef = (double)size;
  double noiseval = 0.0;
  int i;
  for(i = 1; i <= octaves; i++) {
  double n = pnoise(i * xf/(sizef * scalex), i * yf/(sizef * scaley), 0.5);
  n = sizef * ((n/2.0) + 0.5);
  noiseval = noiseval + n / (double)i;
  return (int)noiseval;
  static package bf_perlin_2d(Var arglist, Byte next, void *vdata, Objid progr)
  Var r;
  int x = (int)arglist.v.list[1].v.num;
  int y = (int)arglist.v.list[2].v.num;
  double alpha = *arglist.v.list[3].v.fnum;
  double beta = *arglist.v.list[4].v.fnum;
  int n = (int)arglist.v.list[5].v.num;
  int octaves = (int)arglist.v.list[6].v.num;
  r.v.num = (int)fbm2d(x, y, alpha, beta, n, octaves);
  r.type = TYPE_INT;
  return make_var_pack(r);

Add to void register_extensions() in extensions.c:
  register_function("perlin_2d", 6, 6, bf_perlin_2d, TYPE_INT,

How to use: you have a list of biomes or room types. You get a size from this and then call this function:
biomes = {"flatland","forest","mountain"};
size = length(biomes); px = 10; py = 33; alpha = 1.0; beta = 1.5; octaves = 1; index = perlin_2d(px, py, alpha, beta, size, octaves);

 alpha, and beta are floats that affect the jagged/smoothness of the generated area.  octaves runs the noise function multiple times - WARNING - if you have a set number, for instance when selecting a list of biomes, this will cause values to fall outside the range of the list you've created.  For instance using multiple octaves with the list of 3 biomes above would result in many values at x, y co-ordinates of 4-8.  If you're using the noise to set altitude, you may wish to use the octave setting.

If you want to generate an entire map you would call this function repeatedly over the size of your map. Or, more usefully, you call it when a specific co-ordinate is needed. As long as the input to perlin_2d is the same, the index return will always be the same.

Thursday, January 21, 2016

Wayfar 1444 2016 Status & Roadmap

Hawgpadre here with some thoughts and roadmap for the coming year.

Goals for 2016:

* bio engineering - the ability to harvest DNA and spines from wildlife to create your own tameable creatures
* overhaul of planet generation systems and increase from 4 solar systems to 20
* freak background - inspired by firefly, you have weird psychic powers and must remove them before law enforcement puts you into a containment facility
* there will be a galaxy and player reset, announced well in advance
* more options during character generation, including the ability to start with unique to background items and more paths to explore when creating a character
* starship improvements, including untamed solar systems for adventuring in
* general AI improvements and fixes
* more orbital and solar mechanics - from new solar objects for players to craft, to new options for boarding enemy ships or disabling them
* Terraforming!  A long planned feature that needs some of the infrastructure behind the planet generation updates.

Possibly but Unlikely Goals:
* sector defense/ alien invasions
* mushclient plugin for an MMO type gameplay experience

Lessons learned:
* for a MUD or MOO you MUST have a point man - someone responsible for the overall direction of the game, the maintenance and funding of the server, who is involved with every aspect of the game
* Player count expectations:  creating the game world and items should be fun for you.  Player counts can vary and you cannot pin your expectations on dozens or hundreds of players showing up to play your game.  Make the game fun and people will play it.

Sunday, November 29, 2015

Compiling Hellcore on a CentOS 64-bit System

It is good practice to create a seperate user to run the moo.  You can name it moo, or your own name, or your mother's name.  You should add this user to the wheel group, so it has access to the sudo command.

Move the hellcore.tar.gz to the home directory of your user.  Extract it into a subfolder, called moo or something.  Run this command:  tar -xvzf hellcore1104.tar.gz

This will unzip the hellcore.  Change directory to the src directory.

Now, setup your 64 bit system to actually be able to compile this beast:

sudo yum install bison
sudo yum -y install glibc.i686
sudo yum install libstdc++.i686
sudo yum install screen

In the src directory run these commands:
make clean

If you get no "exited with error" message at the end, success, you have won and can now retire.

To start the moo:

screen ./restart hellcore 7777
Now you can return to view the screen with screen -r.  If you need to emergency shutdown the MOO, you can resume the screen and press CTRL+C - this will immediately dump everything to hellcore.db.panic!  Handy!

Friday, November 6, 2015

Travel redesign!

You can now travel directly to planetary co-ordinates.  In addition, using the TRAVEL command with no argument will bring up a handy screen like this, with nearby shops, centers, and points of interest: