Trigame Fluffle Personality JS Guide

This page is a plain-English guide to the personality JavaScript files used by the Trigame fluffle. It is meant as a practical “master key” so you can tweak rabbits yourself without having to rediscover what every setting does.

1. Basic file shape

(function(){
  const register = window.RustyPersonalities && window.RustyPersonalities.register;
  if(!register) return;

  register({
    level: 5,
    id: "hare_brained",
    label: "Hare-Brained",

    filterActions(ctx){
      ...
    },

    scoreAction(ctx){
      let score = 0;
      ...
      return score;
    }
  });
})();

2. Top-level fields

3. The two main tuning methods

3a. filterActions(ctx)

Use this when you want a rabbit to behave in a very strong, rule-like way.

filterActions(ctx){
  const tileActions = ctx.actions.filter(a => a.type === 'tile');
  if(!tileActions.length) return ctx.actions;

  if(ctx.phase === 0 && ctx.tileCount <= 10) return tileActions;
  if(ctx.phase === 1 && ctx.tileCount <= 6) return tileActions;

  return ctx.actions;
}

That example means: “if tiles exist, and we are early enough in the turn / game, consider only tile moves.”

3b. scoreAction(ctx)

This adds or subtracts points from candidate moves.

scoreAction(ctx){
  let score = 0;

  if(ctx.action.type === 'tile'){
    score += 140;
  }

  if(ctx.action.type === 'token'){
    score -= 10;
  }

  return score;
}

The engine compares scores across moves. Higher usually wins.

4. The most important ctx values

5. Common helper functions you can call from ctx

6. What score numbers mean

There is no universal magic number, but these are good rough meanings:

7. Practical tuning patterns

Make a rabbit more tile-happy

if(ctx.action.type === 'tile'){
  score += ctx.tileCount <= 2 ? 120 : 60;
}
if(ctx.action.type === 'token'){
  if(ctx.tileCount <= 4) score -= 20;
}

Make a rabbit like connected growth

if(ctx.action.type === 'tile'){
  score += (ctx.adjacentPlacedCount(ctx.action.move) || 0) * 20;
}

Make a rabbit love local clusters

if(ctx.action.type === 'tile'){
  score += ctx.ownTokenCountNearCell(ctx.seat, ctx.action.move) * 26;
}
if(ctx.action.type === 'token'){
  const cell = ctx.action.move.cell || null;
  if(cell) score += ctx.ownTokenCountNearCell(ctx.seat, cell) * 18;
}

Make a rabbit prefer future options

if(ctx.action.type === 'tile'){
  score += ctx.withTempTileForSeat(
    ctx.action.move,
    ctx.seat,
    ()=> Math.min(24, (ctx.openSocketMoves(true).length || 0) * 0.24)
  ) || 0;
}

Make a rabbit delay tokening

if(ctx.action.type === 'token'){
  if(ctx.tileCount <= 5) score -= 10;
}

8. Safe value ranges for common knobs

9. Warnings and gotchas

• Do not tune from one match. Use batches and tournaments.
• Multi-player results are messy. Player B can easily determine whether A or C wins.
• Duplicated personalities skew tests. Two Warrens in one match do not tell the same story as one Warren.
• Small-board habits are hard to break. Sometimes a rabbit needs hard filtering, not just score nudges.
• Replace bonuses are touchy. Over-rewarding replacement tiles can create odd behavior.
• Temporary-board helpers are powerful. They are great, but piling too many of them together can make a rabbit overfit to one kind of move.

10. Suggested workflow for editing rabbits

1. Change only one rabbit at a time.
2. Change only one main idea at a time:
   • more tiles
   • more local clustering
   • better token cash-in
   • more blocking
3. Run a small tournament.
4. Read both:
   • who won
   • how the board actually behaved
5. If needed, rename or reorder rabbits only after behavior is stable.

11. Simple personality recipes

12. Final advice

But the most interesting fluffle is not one where every rabbit uses the same trick. Let some rabbits cause the mess, and let others exploit it.