posted                       

code:

---

00000000000...
00+-A--B-+000..
00|

---

posted                       

code:

---

TIME:   1 + 2 + 3 + 4 + 1 + 2 + 3 + 4 + 
KICK:   x   x   x   x x x   x   x   x x
SNARE:  x     x     x   x     x     x

---

posted                       

code:

---

/ CritterBrain

// Try not to get too excited.

// A critter might be a 3D animal/monster/NPC in Rune Runners, or a ship/npc/obstacle in Drone Runners
// we'll maybe call the owner of the brain, the 'host'

// the goal is for this class to not really know anything about the game, though I do bake in some game
// parameters I am 'sure' I will always need.

// A CritterBrain is allocated to each critter.  It is used to record experiences into a memory blob (a VQ),
// and then to offer action suggestions based on memory and newest experience.

// The CritterBrain itself can contain multiple sub-brains, basically one per 'decision to be made' and
// in this way is similar to how neural networks drive cars (e.g. this network takes in all of reality and then
// puts out a single number, indicating how much to turn the steering wheel from its current position.)

// But I am not using neural networks.  At least not at this time.  Not at this level.

// The host decides which subbrains it needs, so CritterBrain just lets you allocate subbrains as you
// see fit.  Class VQ is the subbrain class.  It is my version of a VectorQuantizer, which can turn
// any experience vector into an element of a data structure (a list)

// reach row of the list (inside a VQ) contains a pattern experience n-tuple, and an output value
// if you just want to ask the VQ a question, it is "what is the output value you recommend, if I told
// you that my current sense experience is this n-tuple?"  (assume I don't know the right answer yet
// so there is no training from that yet), this just answers a static question, based on the brain's
// current training.

// the list is basically a list of EXAMPLEs for which the brain 'knows the answer'.  If you ask
// about an example it hasn't seen, at this level it will say "not sure, but here is a sort of average
// from some nearby experiences)

// in LEARNING mode (in particular, when a new baby brain is being fed its blended parent's brains
// with a little random evolution in it), then training experiences are fed into the brain.  Each
// VQ is configured with a max number of examples (or memories) that it can hold.  The first N
// experiences fill these slots.

// once all slots are full, new experiences are compared against existing ones (distance in n-space)
// and if one is found that is close enough, the new experience is folded into that one (and the weight
// of that memory is increased.  These memories accumulate mass, with repetition)

// when a memory is folded into a nearby one, they are both pulled towards each other, in n-space,
// commensurate with their mass (heavy one moves less).  The idea being if some experience clusters
// are sort of 'real', then these will migrate towards their true centers.  Otherwise, things will
// just be wandering around in brownian motion.

// if no existing memory is close enough to the new experience, then a new memory is formed, with mass = 1
// exactly at that spot in n-space.  But another memory must be removed.

// when looking to remove a memory, we actually are going to just merge it with its closest neighbor,
// so we look for the two closest (and/or lowest mass?) memories we have, and pool those into one.

// For purely fun's sake, I intend to make a visualizer (rectangle on screen somewhere) for the VQ which
// uses the output value (-1 to +1, continuous) for the X axis, and then some 'shadow' of the n-tuple
// for the Y axis (just to keep them from all being on top of each other).

// then draw some sort of colored circle at each memory's intersection in the square.  Mainly to
// just watch things in real time.  Ideally, the critter itself would be placed in a sensory
// test environment you could manipulate and then watch the memories shift, and see which one(s)
// are being recommended as actions given the current senses.

// Then, and this is what it is all leading up to

// you can perform BRAIN SURGERY on a living critter!  If you drop the critter somewhere you know
// it ought to turn left, and you see the glowing circle on the right side of the PET SCAN, you
// just touch it with your finger, and drag it to the left, until the critter starts turning the way
// you think it should!

// not an efficient way to program a brain, probably, but I am thinking of this for my game, FARMY
// where you raise animals, form them into armies, and have them fight the armies from other farms,
// competing for position on a huge game ladder, which itself is like terrain to be crossed.

// Anyway, so FARMY is a farm simulation, and will probably have some crops (to feed animals, and
// I was always thinking that was how I was going to control their DNA), but now I want to focus
// on breeding the animals with actual inheritance of brain (lamarckian!)

// But I also want some post-birth training.  Originally I was thinking: start with 2 parents (and
// maybe they get destroyed? hope not, but there is a flow issue) and you get a litter of up to, say, 10
// babies (no babies will die, but you will sell the ones that don't meet your needs).  You might
// choose to sell the parents if you don't like the babies.  Or remember that these two parents
// always make defective children together (but with other mates might do better.. maybe a log book :-)

// Once born, since the babies have random mutations as well as blended brains, we assume some will
// just be defective (much worse than their parents), so we put them through a series of tests (one
// per VQ) (you watch them as they are tested, and review the results).  The tests can be interactive
// with you introducing them to other animals from the farm in various roles (play-fighting, cooperative
// fighting )

// While in these training scenarios (I guess opening the pet scan for editing should probably
// pause the creature), the output values of the memories can be adjusted, based on success/failure
// of the individual test.  That could be done as much as you liked, and you would probably leave
// your animals inside these training pens for hours.

// CritterBrain handles the creation of a new brain, given two parent brains, a takesAfter ratio
// and a degreeOfMutation value.  The resltant brain is not guaranteed to be sane or smart

// because I like simple.  A CritterBrain will be limited to a finite number of VQs, say 10, and
// I will have a satic array of references to allocated VQs (null if not used) and the host will
// assign the index values 0-9 as bets meets their needs (I am thinking cross-species breeding
// here, with some ntuple values only set in some species, or some species have different
// needs than 'turn left'


import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;

public class CritterBrain
{
    private static final String TAG = CritterBrain.class.getSimpleName();

    public final static int MaxMemoryVQs = 16;          // the most sub brains you could ever have

    World mWorld = null;

    MemoryVQ [] mVQs = new MemoryVQ[ MaxMemoryVQs ];    // pre-allocate references (but all nulls)

    // constructor
    CritterBrain( World w ) {
        mWorld = w;
    }

    // add a new VQ with the given max number of memories, and each memory has the given number of facets (ntuple)
    // returns a reference to the newly created MemortVQ
    // memorySize is 'n' for the experience n-tuple.
    MemoryVQ addVQ(int vq, int maxMemories, int memorySize) {
        mVQs[ vq ] = new MemoryVQ( maxMemories, memorySize );
        return mVQs[ vq ];
    }

    //-----
    // these pass along to a specific MemoryVQ

    // include output value if you want to train this memory towards that value
    int addMemory(int vq, int[] memory, int output) {
        if( mVQs[ vq ] != null ) {
            return mVQs[ vq ].addMemory(memory, output);
        }
        return -1;  // failed
    }

    // no training occurs, just answers based on current memories
    double suggestValue( int vq, int[] memory ) {
        if( mVQs[ vq ] != null ) {
            return mVQs[ vq ].suggestValue( memory );
        }
        return -1;  // failed
    }

    // return value relates to the editing, I think
    // render the current VQ layout, for fun!

    int renderVQ(int vq, boolean editOK, Canvas c, Paint paint, Rect r ) {
        if( mVQs[ vq ] != null ) {
            return mVQs[ vq ].renderVQ(editOK, c, paint, r );
        }
        return -1;  // failed
    }

    // ------

    class MemoryVQ
    {
        int mMaxMemories = 0;
        int mMemorySize  = 0;
        int [][] mData    = null;
        double [] mValues = null;

        // constructor, make an empty VQ list
        MemoryVQ( int maxMemories, int memorySize ) {
            mMaxMemories = maxMemories;
            mMemorySize  = memorySize;
            mData        = new int[maxMemories][memorySize];       // full of zeros, they promise
            mValues      = new double[maxMemories];
        }

        // omit output unless you also want to train the memory
        // mainly this is expected to merge the new memory into the existing one (if any match)
        // but will add a new one as needed, up to the max allowed
        int addMemory( int[] memory, int output ) {
            int memIndex = findClosestMemory( memory );
            if( memIndex < 0 ) {
                memIndex = mergeClosestMemories( memory );
            }
            if( memIndex > 0) {
                // now drive this index towards new memory
                double weight = 1;      // brand new memory is weight 1
                mergeMemoryIntoExistingIndex( memIndex, memory, output, weight );

                // consider adjusting the valuie
                if( output != 0 ) {
                    mValues[ memIndex ] = output;         // just override it
                } else {
                    double oldValue = mValues[ memIndex ];
                    if( oldValue == 0 ) {
                        // never been set, randomize it?  (-1 to +1)
                        mValues[ memIndex ] = (mWorld.RNG.nextDouble() * 2) -1;
                    }
                }
            }
            // I guess I should return the memory index we folded into
            return memIndex;
        }

        double suggestValue( int[] memory ) {
            int index = findClosestMemory( memory );
            if( index >= 0 ) {
                return mValues[ index ];
            }
            return 0;       // no suggestion?  no change?
        }

        int [] mMem = null;     // convenient reference

        int findClosestMemory( int[] memory ) {
            int i;
            int bestIndex = -1;
            double bestDistance = 1E29;    // goal: a really big number, bigger than any real distance
            for( i = 0; i< mMaxMemories; i++ ) {
                mMem = mData[ i ];  // mMem[0] is first data element of memory
                double distance = distanceBetweenMemories(mMem, memory);
                if( distance < bestDistance ) {
                    bestDistance = distance;
                    bestIndex = i;
                }
            }
            return bestIndex;
        }

        double distanceBetweenMemories( int [] mem1, int [] mem2 ) {
            double distance = 0;
            int i;
            for( i=0; i<mMemorySize; i++ ) {
                // I assume the host only gives me normalized values so
                // the per-column importance is set.
                int diff = mem1[i] - mem2[i];
                distance += (diff * diff);  // this is allowed to be huge, but always positive
            }
            return distance;
        }

        // finds two closest memories
        // merges them into one
        // copies new memory on top of the released one
        // and returns its index
        int mergeClosestMemories( int [] memory ) {
            // find the closest two memories
            double bestDistance = 1E29;
            int besti = -1;
            int bestj = -1;
            int i,j;
            for(i = 0; i < mMaxMemories; i++ ) {
                for( j = i+1; j< mMaxMemories; j++ ) {
                    double distance = distanceBetweenMemories( mData[i], mData[j] );
                    if( distance < bestDistance ) {
                        besti = i;
                        bestj = j;
                    }
                }
            }
            // if we found a pair, merge them (so long as I know both masses, I think
            // I can do them in either order, but I will 'keep' i and 'lose' j
            if( besti >= 0 && bestj >= 0 ) {
                // merge j into i
                double output = 0;  // would this ever be used?
                double weight = 1;  // real weight to come
                mergeMemoryIntoExistingIndex( i, mData[bestj], output, weight );
                return bestj;   // the one we don't need anymore, should I null it out?
            }
            return -1;  // didn't do it
        }

        // given the memIndex of an existing memory, and the int[] of a 'new' memory,
        // merge the new into the old (moving the old as needed, based on weight)
        void mergeMemoryIntoExistingIndex( int memIndex, int[] memory, double output, double weightNew )
        {
            mMem = mData[ memIndex ];  // destination (only thing that changes)
            double weightOld = 1;          // existing memIndex weight
            double totalWeight = weightNew + weightOld;

            int i;
            for( i=0; i<mMemorySize; i++ ) {
                mMem[ i ] = (int)(((mMem[i] * weightOld) + (memory[i] * weightNew ))  / totalWeight);
            }
            // don't forget output changes?  for now, keep the dest value
            // and weight changes
        }

        // render the VQ, and if editOK, let them drag the individual
        // memories to new values.
        int renderVQ( boolean editOK, Canvas c, Paint paint, Rect r )
        {
            return -1;
        }

    } // end of class MemoryVQ




} // end of class CritterBrain

---

posted                       

I now use the fractal height map to define where the ground is (as opposed to just being eye candy), so now the critters finally know were the dirt is and can stand on it instead of randomly standing above and below it



For the Math, I basically have a grid of points (some number of rows and columns) that is stretched over the full visible sheet of the world (a km or two maybe)

So, starting with your XYZ location, where we are going to find the elevation of the terrain that contains the 2D point XY (and that elevation will become the desired landing spot for the critter)

I cover the world with triangles by using two triangles per grid square. For esthetic reasons, I alternate the diagonal between squares.

I first map your XY to the row,column you are 'inside'

I keep track of your 'partial position' within that square.

I then consider the diagonal for that square and 'which side of it you are on'

this then gives me four cases to deal with, where the triangle is in the upper left, upper right, lower left, or lower right. of the square

Pretend you have this:

code:

---

A----------x---B
|\         *   y
|   \          |
|      \       |
|         \    |
|            \ |
C--------------D

---

code:

---

float groundLevelAtPoint( float [] fl, int oPoint )
    {
        if( mArenaData == null ) {
            return SeaLevel;
        }

        // get the coords
        float x = fl[ oPoint + 0 ];
        float y = fl[ oPoint + 1 ];     // positive is 'north' which is opposite of terrain cell col.ro
        float z = fl[ oPoint + 2 ];     // in case want to 'fall down to terrain' and have multiple terrain levels

        float cellSideMeters = mapSideMeters / (terrainCols-1 );

        float fCol = (x + mapSideMeters/2f) / cellSideMeters;
        float fRow =  ((-y * cellSideMeters * 2f) / mapSideMeters) + (terrainCols-1)/2;

        int row = (int) fRow;
        int col = (int) fCol;

        float innerX = fCol - col;  // just the percenter within each
        float innerY = fRow - row;

        // if I am outside the map, returmn deep ocean
        if( row<0 || col<0 || row > terrainRows-1 || col > terrainCols-1 ) {
            return -100f;
        }

        // get the height info for these grid points
        int iCell = ((row * terrainCols) + col);        // (row, col) is point A (top left of terrain cell)
        int oCell =  iCell * 4;                         // 4 floats per point
        int right = 4;    // 4 floats to the right
        int down = 4 * terrainCols;
        float hA = terrainVerts3D[ oCell + 2 ];                     // A: top left, the Z component
        float hB = terrainVerts3D[ oCell + 2 + right ];             // B: one to the right
        float hC = terrainVerts3D[ oCell + 2 + down ];              // C: one below A
        float hD = terrainVerts3D[ oCell + 2 + down + right ];      // D: down one, and one to the right
        // basically, we linearly interpolate along the 'fold' line to find the
        // height of our shadow on the fole, then use iY to scale between that and the
        //

        float h = SeaLevel; // return value
        if( ((row&1)^(col&1)) == 0 ) {
            // A-x-------B
            // y *    /  |
            // |    /    |
            // |  /   *  y
            // C------x--D
            if( innerX + innerY < 1f) {
                // top left triangle
                float hHorizontal = hA + innerX *(hB - hA);
                float diagonal    = hC + innerX *(hB - hC);
                h = hHorizontal + innerY * (diagonal - hHorizontal );
            } else {
                // bottom right triangle
                innerY = 1 - innerY;    // other diagonal
                float hHorizontal = hC + innerX *(hD - hC);
                float diagonal    = hC + innerX *(hB - hC);
                h = hHorizontal + innerY * (diagonal - hHorizontal );
            }
        } else {
            // A------x--B
            // | \    *  y
            // |    \    |
            // y *     \ |
            // C-x-------D
            if( innerX < innerY ) {
                // lower left triangle
                innerY = 1f - innerY;    // other diagonal
                float hHorizontal = hC + innerX *(hD - hC);
                float diagonal    = hA + innerX *(hD - hA);
                h = hHorizontal + innerY * (diagonal - hHorizontal );
            } else {
                // uper right triangle
                float hHorizontal = hA + innerX *(hB - hA);
                float diagonal    = hA + innerX *(hD - hA);
                h = hHorizontal + innerY * (diagonal - hHorizontal );
            }
        }
        return h;
    }

---