# Pick Random Number Based on Preceding Number

**URL:** <https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558>\
**Category:** Coding Questions\
**Created:** [October 2, 2021, 6:18am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558 "2021-10-02T06:18:41Z")\
**Posts on this page:** 13\
**Page:** 1

<div class="post-metadata">

**Author:** ![alenmartel](https://avatars.discourse-cdn.com/v4/letter/a/c68b51/32.png) [@alenmartel](https://discourse.processing.org/u/alenmartel)\
**Post date:** [October 2, 2021, 6:18am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/1 "2021-10-02T06:18:41Z")

</div>

Good morning all;

I’m trying to write a random number generator that generates twelve different random numbers and displays them in a column. However, what random number can follow each other one is limited to certain numbers. For example, if the first random number is 6, then the second random number can only be 1, 2, 5, 6, 7, 10, or 11. If that second random number is 11, then the third random number can only be 6, 7, 10, 11, or 12. And, so on…

I can’t think of a way to write this outside of a series of nested if statements, which I understand is poor coding. I thought that a two-dimensional array would be the way to go but can’t think of how to reference the selected number in the array in the second iteration.

Edit: Thank you in advance and apologies if this is somewhere – I tried wording it in a way that I could find it in the forums but no luck!

---

<div class="post-metadata">

**Author:** ![hotfooted](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/hotfooted/32/3670_2.png) [@hotfooted](https://discourse.processing.org/u/hotfooted)\
**Post date:** [October 2, 2021, 6:53am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/2 "2021-10-02T06:53:24Z")

</div>

what is the rule which decides the values available after a number is chosen? i’m not following the logic. or is it just a set of predefined numbers?

if there is a rule it is much easier. if it is predefined you could have a nested array  
so if 0-n is chosen that is used as an index into the available numbers to chose something like

```auto
int[][] sequences;

void setup() {
  sequences = new int[10][];
  
  //build a random set of sequences as i don't have your list
  for(int i = 0; i < sequences.length; i++) {
    sequences[i] = new int[int(random(10))];
    for(int j = 0; j < sequences[i].length; j++) {
      sequences[i][j] = int(random(10));
    }
  }
  
  //do some random selections
  int lastSelected = int(random(sequences.length));
  println(lastSelected);
  for(int i = 0; i < 20; i++) {
    lastSelected = sequences[lastSelected][int(random(sequences[lastSelected].length))];
    println(lastSelected);
  }
}

```

---

<div class="post-metadata">

**Author:** ![alenmartel](https://avatars.discourse-cdn.com/v4/letter/a/c68b51/32.png) [@alenmartel](https://discourse.processing.org/u/alenmartel)\
**Post date:** [October 2, 2021, 6:58am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/3 "2021-10-02T06:58:23Z")

</div>

I suppose the list would help! So, I’m working off of a hexagonal grid. So, whatever the starting number, the second number can only be either the same number or a number of an adjacent hexagon, and so on. So, the rule isn’t so exact…

Image below.

![Screen Shot 2021-10-02 at 00.56.44](https://canada1.discourse-cdn.com/flex036/uploads/processingfoundation1/original/2X/8/8a7c14d2875da84a0deea3e55e9e32b2ea9a3cac.png)

---

<div class="post-metadata">

**Author:** ![hotfooted](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/hotfooted/32/3670_2.png) [@hotfooted](https://discourse.processing.org/u/hotfooted)\
**Post date:** [October 2, 2021, 7:07am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/4 "2021-10-02T07:07:45Z")

</div>

so if you know the index of the cell you are in which is the selected number you could just have an array of the offsets of the six surrounding hexagons.

[-1, +1, -4, +4, -5, +5]

select from that array randomly and add it to the current index

… at least at first look

edit: i guess the edges of the board/grid might be problematic but you could just add a few conditionals to account for that

---

<div class="post-metadata">

**Author:** ![GoToLoop](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/gotoloop/32/86_2.png) [@GoToLoop](https://discourse.processing.org/u/GoToLoop)\
**Post date:** [October 2, 2021, 10:47am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/5 "2021-10-02T10:47:40Z")

</div>

> [@hotfooted](#):
>
> … but you could just add a few conditionals to account for that.

He could use **constrain()** to keep the random value + offset within range 1 to 13:

> **[constrain() / Reference](https://processing.org/reference/constrain_.html)**
>
> Constrains a value to not exceed a maximum and minimum value.

Something like this:

```auto
static final byte[] OFFSETS = { 0, -1, 1, -4, 4, -5, 5 };
static final int LOWEST = 1, HIGHEST = 13;

static final boolean isValidNext(final int next, final int prev) {
  for (final byte offset : OFFSETS)
    if (next == constrain(prev + offset, LOWEST, HIGHEST)) return true;
  return false;
}

```

---

<div class="post-metadata">

**Author:** ![alenmartel](https://avatars.discourse-cdn.com/v4/letter/a/c68b51/32.png) [@alenmartel](https://discourse.processing.org/u/alenmartel)\
**Post date:** [October 2, 2021, 11:03am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/6 "2021-10-02T11:03:42Z")

</div>

This is probably the chunkiest way I could have done it. But, after your help and trying to remember my Processing after almost a year away from it (and only a few months at it at that time), it works as I need it to. Now that it’s working, I’ll read up how to clean this up but thank you for your help!

@GoToLoop I’ll take a look at your response to and see if I can shorten and clarify the code with that!

```auto
// Reproduction of a program by Francisco Sagasti (March 14, 1968 at PSU)
// Originally built on Fortran IV programming language on an IBM 360/65 (1MB RAM)
// ***USE***
// Program tells 12 dancers where to be in space based on a hexagonal floor plan
// Dancers are told where to move (or stay) each measure
// Dancers can do any movement, any effort, etc.
// This is more of a "spatial score" as per Sagasti

IntList hexagon = new IntList();
IntList factorn1 = new IntList(), factor1 = new IntList(), factor23 = new IntList(), factor4 = new IntList(), factorn4 = new IntList(), factor5 = new IntList(), factorn5 = new IntList(), factor678 = new IntList(), factor9 = new IntList(), factorn9 = new IntList(), factor10 = new IntList(), factorn10 = new IntList(), factor1112 = new IntList(), factor13 = new IntList(), factorn13 = new IntList();
int start, second, third, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh, twelfth;

int textSpacing = 35;
int fade = 145;

float r = PI/1.98;
int hexSize = 40, xLoc = 250, yLoc = 75, xSpacing = 69, ySpacing = 60;

String[] dancers = {"Dancer A", "Dancer B", "Dancer C", "Dancer D", "Dancer E", "Dancer F", "Dancer G", "Dancer H", "Dancer I", "Dancer J", "Dancer K", "Dancer L"};

Floor[] floor1 = new Floor[4];
Floor[] floor2 = new Floor[5];
Floor[] floor3 = new Floor[4];

void setup() {
  size(1280, 720);
  
  hexagon.append(1);
  hexagon.append(new int[] {-1, 2, 3, -4, 4, -5, 5, 6, 7, 8, -9, 9, -10, 10, 11, 12, -13, 13});
  factorn1.append(new int[] {0, +2, +6}); // can go to space 1 or 5
  factor1.append(new int[] {0, -2, +1, +4, +5}); // -2 goes to off SR space -1
  factor23.append(new int[] {0, -1, +1, +4, +5});
  factor4.append(new int[] {0, -8, -1, +4, +5}); // -4 goes to off SR space -4
  factorn4.append(new int[] {0, +8, +13}); //can go to space 4 or 9
  factor5.append(new int[] {0, -15, -10, -6, -4, +1, +5}); // moves to any off SL position
  factorn5.append(+10); // can only move to space 5
  factor678.append(new int[] {0, -1, -4, -5, +1, +4, +5});
  factor9.append(new int[] {0, -22, -18, -13, -5, -1, +4}); // moves to any off SR position
  factorn9.append(new int[] {0, +18}); // can only move to space 9
  factor10.append(new int[] {0, -20, -4, -5, +1});
  factorn10.append(new int[] {0, +15, +20}); // can only move to spaces 5 & 10
  factor1112.append(new int[] {0, -1, -4, -5, +1});
  factor13.append(new int[] {0, -26, -5, -4, -1});
  factorn13.append(new int[] {0, +22, +26});
  
  fill(0);
  for (int i = 0; i < 12; i++) {
    theScore();
    text(dancers[0+i], 120 + textSpacing * (i * 2.75), 300);
    text(start, 135 + textSpacing * (i * 2.75), 325);
    text(second, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 1);
    text(third, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 2);
    text(fourth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 3);
    text(fifth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 4);
    text(sixth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 5);
    text(seventh, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 6);
    text(eighth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 7);
    text(ninth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 8);
    text(tenth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 9);
    text(eleventh, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 10);
    text(twelfth, 135 + textSpacing * (i * 2.75), 325 + textSpacing * 11);
  }
  
  text("Measure", 30, 300);
  for (int i = 0; i < 12; i++) {
    text(i + 1, 30, 325 + textSpacing * i);
  }
  
  text("Downstage", 100 + xSpacing * 3 + 15, 20);
  text("Upstage", 100 + xSpacing * 3 + 20, yLoc + 60 + ySpacing * 2);
  text("Stage Right", 185 + 435, 140);
  text("Stage Left", 15 + 15, 140);
  
  noFill();
  stroke(0);
  
  // Downstage Row
  for (int x = xLoc; x < xLoc + xSpacing * 4; x += xSpacing) {
  pushMatrix();
  translate(x, yLoc);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  }
  
  // Spot -10
  stroke(fade);
  fill(fade);
  text("-10", xLoc - hexSize - 30 - 15, yLoc);
  noFill();
  pushMatrix();
  translate(xLoc - hexSize - 30, yLoc);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  
  // Spot -13
  stroke(fade);
  fill(fade);
  text("-13", xLoc + 1 + xSpacing * 4 - 15, yLoc);
  noFill();
  pushMatrix();
  translate(xLoc + 1 + xSpacing * 4, yLoc);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  
  stroke(0);
  // Midstage Row
  for (int x = xLoc - 34; x < xLoc + xSpacing * 4; x += xSpacing) {
  pushMatrix();
  translate(x, yLoc + ySpacing);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  }
  
  // Spot -5
  stroke(fade);
  fill(fade);
  text("-5", xLoc - hexSize -30 - 34 - 10, yLoc + ySpacing);
  noFill();  
  pushMatrix();
  translate(xLoc - hexSize - 30 - 34, yLoc + ySpacing);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  
  // Spot -9
  stroke(fade);
  fill(fade);
  text("-9", xLoc + 2 + 34 + xSpacing * 4 - 10, yLoc + ySpacing);
  noFill();    
  pushMatrix();
  translate(xLoc + 2 + 34 + xSpacing * 4, yLoc + ySpacing);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  // Upstage Row
  stroke(0);
  for (int x = xLoc; x < xLoc + xSpacing * 4; x += xSpacing) {
  pushMatrix();
  translate(x, yLoc + ySpacing * 2);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  }
  
  // Spot -1
  stroke(fade);
  fill(fade);
  text("-1", xLoc - hexSize - 30 - 10, yLoc + ySpacing * 2);
  noFill();    
  pushMatrix();
  translate(xLoc - hexSize - 30, yLoc + ySpacing * 2);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
  
  // Spot -4
  stroke(fade);
  fill(fade);
  text("-4", xLoc + 1 + xSpacing * 4 - 10, yLoc + ySpacing * 2);
  noFill();     
  pushMatrix();
  translate(xLoc + 1 + xSpacing * 4, yLoc + ySpacing * 2);
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  stroke(0);
  fill(0);
  for (int i = 0; i < floor1.length; i++) {
    floor1[i] = new Floor(i+1, (xLoc - 3) + xSpacing * i, yLoc + 3 + ySpacing * 2);
    floor3[i] = new Floor(i+10, (xLoc - 8) + xSpacing * i, yLoc + 3);
  }
  
  for (int i = 0; i < floor2.length; i++) {
    floor2[i] = new Floor(i+5, (xLoc - 34 - 3) + xSpacing * i, yLoc + 3 + ySpacing);
  }

  for (int i = 0; i < floor1.length; i++) {
    floor1[i].disFloor();
  }
  
   
  for (int i = 0; i < floor2.length; i++) {
    floor2[i].disFloor();
  }
  
   
  for (int i = 0; i < floor3.length; i++) {
    floor3[i].disFloor();
  }  
  
}

void draw() {
}

void polygon(float x, float y, float radius, int npoints) {
  float angle = TWO_PI / npoints;
  beginShape();
  for (float a = 0; a < TWO_PI; a += angle) {
    float sx = x + cos(a) * radius;
    float sy = y + sin(a) * radius;
    vertex(sx, sy);
  }
  endShape(CLOSE);
}

class Floor {
  int t, x, y;
  Floor(int t_, int x_, int y_) {
    t = t_;
    x = x_;
    y = y_;
  }
  void disFloor() {
    text(t, x, y);
  }
}

void theShuffle() {
  factorn1.shuffle();
  factor1.shuffle();
  factor23.shuffle();
  factor4.shuffle();
  factorn4.shuffle();
  factor5.shuffle();
  factorn5.shuffle();
  factor678.shuffle();
  factor9.shuffle();
  factorn9.shuffle();
  factor10.shuffle();
  factorn10.shuffle();
  factor1112.shuffle();
  factor13.shuffle();
  factorn13.shuffle();
}

void theScore() {
  // First Measure
  hexagon.shuffle();
  start = hexagon.get(0);
  
  // Second Measure
  theShuffle();
  switch(start) {
    case -1: second = start + factorn1.get(0); break;
    case 1: second = start + factor1.get(0); break;
    case 2: second = start + factor23.get(0); break;
    case 3: second = start + factor23.get(0); break;
    case 4: second = start + factor4.get(0); break;
    case -4: second = start + factorn4.get(0); break;
    case 5: second = start + factor5.get(0); break;
    case -5: second = start + factorn5.get(0); break;
    case 6: second = start + factor678.get(0); break;
    case 7: second = start + factor678.get(0); break;
    case 8: second = start + factor678.get(0); break;
    case 9: second = start + factor9.get(0); break;
    case -9: second = start + factorn9.get(0); break;
    case 10: second = start + factor10.get(0); break;
    case -10: second = start + factorn10.get(0); break;
    case 11: second = start + factor1112.get(0); break;
    case 12: second = start + factor1112.get(0); break;
    case 13: second = start + factor13.get(0); break;
    case -13: second = start + factorn13.get(0); break;
  }

  // Third Measure
  theShuffle();
  switch(second) {
    case -1: third = second + factorn1.get(0); break;
    case 1: third = second + factor1.get(0); break;
    case 2: third = second + factor23.get(0); break;
    case 3: third = second + factor23.get(0); break;
    case 4: third = second + factor4.get(0); break;
    case -4: third = second + factorn4.get(0); break;
    case 5: third = second + factor5.get(0); break;
    case -5: third = second + factorn5.get(0); break;
    case 6: third = second + factor678.get(0); break;
    case 7: third = second + factor678.get(0); break;
    case 8: third = second + factor678.get(0); break;
    case 9: third = second + factor9.get(0); break;
    case -9: third = second + factorn9.get(0); break;
    case 10: third = second + factor10.get(0); break;
    case -10: third = second + factorn10.get(0); break;
    case 11: third = second + factor1112.get(0); break;
    case 12: third = second + factor1112.get(0); break;
    case 13: third = second + factor13.get(0); break;
    case -13: third = second + factorn13.get(0); break;
  }
  
  // Fourth Measure
  theShuffle();
  switch(third) {
    case -1: fourth = third + factorn1.get(0); break;
    case 1: fourth = third + factor1.get(0); break;
    case 2: fourth = third + factor23.get(0); break;
    case 3: fourth = third + factor23.get(0); break;
    case 4: fourth = third + factor4.get(0); break;
    case -4: fourth = third + factorn4.get(0); break;
    case 5: fourth = third + factor5.get(0); break;
    case -5: fourth = third + factorn5.get(0); break;
    case 6: fourth = third + factor678.get(0); break;
    case 7: fourth = third + factor678.get(0); break;
    case 8: fourth = third + factor678.get(0); break;
    case 9: fourth = third + factor9.get(0); break;
    case -9: fourth = third + factorn9.get(0); break;
    case 10: fourth = third + factor10.get(0); break;
    case -10: fourth = third + factorn10.get(0); break;
    case 11: fourth = third + factor1112.get(0); break;
    case 12: fourth = third + factor1112.get(0); break;
    case 13: fourth = third + factor13.get(0); break;
    case -13: fourth = third + factorn13.get(0); break;
  }
  
  // Fifth Measure
  theShuffle();
  switch(fourth) {
    case -1: fifth = fourth + factorn1.get(0); break;
    case 1: fifth = fourth + factor1.get(0); break;
    case 2: fifth = fourth + factor23.get(0); break;
    case 3: fifth = fourth + factor23.get(0); break;
    case 4: fifth = fourth + factor4.get(0); break;
    case -4: fifth = fourth + factorn4.get(0); break;
    case 5: fifth = fourth + factor5.get(0); break;
    case -5: fifth = fourth + factorn5.get(0); break;
    case 6: fifth = fourth + factor678.get(0); break;
    case 7: fifth = fourth + factor678.get(0); break;
    case 8: fifth = fourth + factor678.get(0); break;
    case 9: fifth = fourth + factor9.get(0); break;
    case -9: fifth = fourth + factorn9.get(0); break;
    case 10: fifth = fourth + factor10.get(0); break;
    case -10: fifth = fourth + factorn10.get(0); break;
    case 11: fifth = fourth + factor1112.get(0); break;
    case 12: fifth = fourth + factor1112.get(0); break;
    case 13: fifth = fourth + factor13.get(0); break;
    case -13: fifth = fourth + factorn13.get(0); break;
  }
  
  // Sixth Measure
  theShuffle();
  switch(fifth) {
    case -1: sixth = fifth + factorn1.get(0); break;
    case 1: sixth = fifth + factor1.get(0); break;
    case 2: sixth = fifth + factor23.get(0); break;
    case 3: sixth = fifth + factor23.get(0); break;
    case 4: sixth = fifth + factor4.get(0); break;
    case -4: sixth = fifth + factorn4.get(0); break;
    case 5: sixth = fifth + factor5.get(0); break;
    case -5: sixth = fifth + factorn5.get(0); break;
    case 6: sixth = fifth + factor678.get(0); break;
    case 7: sixth = fifth + factor678.get(0); break;
    case 8: sixth = fifth + factor678.get(0); break;
    case 9: sixth = fifth + factor9.get(0); break;
    case -9: sixth = fifth + factorn9.get(0); break;
    case 10: sixth = fifth + factor10.get(0); break;
    case -10: sixth = fifth + factorn10.get(0); break;
    case 11: sixth = fifth + factor1112.get(0); break;
    case 12: sixth = fifth + factor1112.get(0); break;
    case 13: sixth = fifth + factor13.get(0); break;
    case -13: sixth = fifth + factorn13.get(0); break;
  }
  
  // Seventh Measure
  theShuffle();
  switch(sixth) {
    case -1: seventh = sixth + factorn1.get(0); break;
    case 1: seventh = sixth + factor1.get(0); break;
    case 2: seventh = sixth + factor23.get(0); break;
    case 3: seventh = sixth + factor23.get(0); break;
    case 4: seventh = sixth + factor4.get(0); break;
    case -4: seventh = sixth + factorn4.get(0); break;
    case 5: seventh = sixth + factor5.get(0); break;
    case -5: seventh = sixth + factorn5.get(0); break;
    case 6: seventh = sixth + factor678.get(0); break;
    case 7: seventh = sixth + factor678.get(0); break;
    case 8: seventh = sixth + factor678.get(0); break;
    case 9: seventh = sixth + factor9.get(0); break;
    case -9: seventh = sixth + factorn9.get(0); break;
    case 10: seventh = sixth + factor10.get(0); break;
    case -10: seventh = sixth + factorn10.get(0); break;
    case 11: seventh = sixth + factor1112.get(0); break;
    case 12: seventh = sixth + factor1112.get(0); break;
    case 13: seventh = sixth + factor13.get(0); break;
    case -13: seventh = sixth + factorn13.get(0); break;
  }
  
  // Eighth Measure
  theShuffle();
  switch(seventh) {
    case -1: eighth = seventh + factorn1.get(0); break;
    case 1: eighth = seventh + factor1.get(0); break;
    case 2: eighth = seventh + factor23.get(0); break;
    case 3: eighth = seventh + factor23.get(0); break;
    case 4: eighth = seventh + factor4.get(0); break;
    case -4: eighth = seventh + factorn4.get(0); break;
    case 5: eighth = seventh + factor5.get(0); break;
    case -5: eighth = seventh + factorn5.get(0); break;
    case 6: eighth = seventh + factor678.get(0); break;
    case 7: eighth = seventh + factor678.get(0); break;
    case 8: eighth = seventh + factor678.get(0); break;
    case 9: eighth = seventh + factor9.get(0); break;
    case -9: eighth = seventh + factorn9.get(0); break;
    case 10: eighth = seventh + factor10.get(0); break;
    case -10: eighth = seventh + factorn10.get(0); break;
    case 11: eighth = seventh + factor1112.get(0); break;
    case 12: eighth = seventh + factor1112.get(0); break;
    case 13: eighth = seventh + factor13.get(0); break;
    case -13: eighth = seventh + factorn13.get(0); break;
  }
  
  // Ninth Measure
  theShuffle();
  switch(eighth) {
    case -1: ninth = eighth + factorn1.get(0); break;
    case 1: ninth = eighth + factor1.get(0); break;
    case 2: ninth = eighth + factor23.get(0); break;
    case 3: ninth = eighth + factor23.get(0); break;
    case 4: ninth = eighth + factor4.get(0); break;
    case -4: ninth = eighth + factorn4.get(0); break;
    case 5: ninth = eighth + factor5.get(0); break;
    case -5: ninth = eighth + factorn5.get(0); break;
    case 6: ninth = eighth + factor678.get(0); break;
    case 7: ninth = eighth + factor678.get(0); break;
    case 8: ninth = eighth + factor678.get(0); break;
    case 9: ninth = eighth + factor9.get(0); break;
    case -9: ninth = eighth + factorn9.get(0); break;
    case 10: ninth = eighth + factor10.get(0); break;
    case -10: ninth = eighth + factorn10.get(0); break;
    case 11: ninth = eighth + factor1112.get(0); break;
    case 12: ninth = eighth + factor1112.get(0); break;
    case 13: ninth = eighth + factor13.get(0); break;
    case -13: ninth = eighth + factorn13.get(0); break;
  }
  
  // Tenth Measure
  theShuffle();
  switch(ninth) {
    case -1: tenth = ninth + factorn1.get(0); break;
    case 1: tenth = ninth + factor1.get(0); break;
    case 2: tenth = ninth + factor23.get(0); break;
    case 3: tenth = ninth + factor23.get(0); break;
    case 4: tenth = ninth + factor4.get(0); break;
    case -4: tenth = ninth + factorn4.get(0); break;
    case 5: tenth = ninth + factor5.get(0); break;
    case -5: tenth = ninth + factorn5.get(0); break;
    case 6: tenth = ninth + factor678.get(0); break;
    case 7: tenth = ninth + factor678.get(0); break;
    case 8: tenth = ninth + factor678.get(0); break;
    case 9: tenth = ninth + factor9.get(0); break;
    case -9: tenth = ninth + factorn9.get(0); break;
    case 10: tenth = ninth + factor10.get(0); break;
    case -10: tenth = ninth + factorn10.get(0); break;
    case 11: tenth = ninth + factor1112.get(0); break;
    case 12: tenth = ninth + factor1112.get(0); break;
    case 13: tenth = ninth + factor13.get(0); break;
    case -13: tenth = ninth + factorn13.get(0); break;
  }
  
  // Eleventh Measure
  theShuffle();
  switch(tenth) {
    case -1: eleventh = tenth + factorn1.get(0); break;
    case 1: eleventh = tenth + factor1.get(0); break;
    case 2: eleventh = tenth + factor23.get(0); break;
    case 3: eleventh = tenth + factor23.get(0); break;
    case 4: eleventh = tenth + factor4.get(0); break;
    case -4: eleventh = tenth + factorn4.get(0); break;
    case 5: eleventh = tenth + factor5.get(0); break;
    case -5: eleventh = tenth + factorn5.get(0); break;
    case 6: eleventh = tenth + factor678.get(0); break;
    case 7: eleventh = tenth + factor678.get(0); break;
    case 8: eleventh = tenth + factor678.get(0); break;
    case 9: eleventh = tenth + factor9.get(0); break;
    case -9: eleventh = tenth + factorn9.get(0); break;
    case 10: eleventh = tenth + factor10.get(0); break;
    case -10: eleventh = tenth + factorn10.get(0); break;
    case 11: eleventh = tenth + factor1112.get(0); break;
    case 12: eleventh = tenth + factor1112.get(0); break;
    case 13: eleventh = tenth + factor13.get(0); break;
    case -13: eleventh = tenth + factorn13.get(0); break;
  }
  
  // Twelfth Measure
  theShuffle();
  switch(eleventh) {
    case -1: twelfth = eleventh + factorn1.get(0); break;
    case 1: twelfth = eleventh + factor1.get(0); break;
    case 2: twelfth = eleventh + factor23.get(0); break;
    case 3: twelfth = eleventh + factor23.get(0); break;
    case 4: twelfth = eleventh + factor4.get(0); break;
    case -4: twelfth = eleventh + factorn4.get(0); break;
    case 5: twelfth = eleventh + factor5.get(0); break;
    case -5: twelfth = eleventh + factorn5.get(0); break;
    case 6: twelfth = eleventh + factor678.get(0); break;
    case 7: twelfth = eleventh + factor678.get(0); break;
    case 8: twelfth = eleventh + factor678.get(0); break;
    case 9: twelfth = eleventh + factor9.get(0); break;
    case -9: twelfth = eleventh + factorn9.get(0); break;
    case 10: twelfth = eleventh + factor10.get(0); break;
    case -10: twelfth = eleventh + factorn10.get(0); break;
    case 11: twelfth = eleventh + factor1112.get(0); break;
    case 12: twelfth = eleventh + factor1112.get(0); break;
    case 13: twelfth = eleventh + factor13.get(0); break;
    case -13: twelfth = eleventh + factorn13.get(0); break;
  }
}

```

---

<div class="post-metadata">

**Author:** ![GoToLoop](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/gotoloop/32/86_2.png) [@GoToLoop](https://discourse.processing.org/u/GoToLoop)\
**Post date:** [October 2, 2021, 11:51am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/7 "2021-10-02T11:51:46Z")

</div>

> [@alenmartel](#):
>
> I’ll take a look at your response to and see if I can shorten and clarify the code with that!

I believe we were too naïve to rely on offsets as a solution. 🥴

A possible approach is to explicitly have an array of valid _adjacents[]_ for each Hexagon _value_: 💡

```auto
// https://Discourse.Processing.org/t/
// pick-random-number-based-on-preceding-number/32558/7

// GoToLoop (2021/Oct/02)

static final byte[][] ADJACENTS = {
  { 2, 5, 6 }, // 1
  { 1, 3, 6, 7 }, // 2
  { 2, 4, 7, 8 }, // 3
  { 3, 8, 9 }, // 4
  { 1, 6, 10 }, // 5
  { 1, 2, 5, 7, 10, 11 }, // 6
  { 2, 3, 6, 8, 11, 12 }, // 7
  { 3, 4, 7, 9, 12, 13 }, // 8
  { 4, 8, 13 }, // 9
  { 5, 6, 11 }, // 10
  { 6, 7, 10, 12 }, // 11
  { 7, 8, 11, 13 }, // 12
  { 8, 9, 12 } // 13
};

final Hexagon[] hexagons = new Hexagon[ADJACENTS.length];

void setup() {
  createHexagons();
  printArray(hexagons);
  exit();
}

void createHexagons() {
  for (int i = 0; i < ADJACENTS.length; ++i)
    hexagons[i] = new Hexagon(i + 1, ADJACENTS[i]);
}

class Hexagon {
  int value;
  byte[] adjacents;

  Hexagon(final int val, final byte[] neighbors) {
    value = val;
    adjacents = neighbors;
  }

  boolean isNeighborOrSame(final int val) {
    return val == value? true : isNeighbor(val);
  }

  boolean isNeighbor(final int val) {
    for (final byte neighbor : adjacents) if (val == neighbor) return true;
    return false;
  }

  String toString() {
    return value + ": { " + join(str(adjacents), ", ") + " }";
  }
}

```

---

<div class="post-metadata">

**Author:** ![alenmartel](https://avatars.discourse-cdn.com/v4/letter/a/c68b51/32.png) [@alenmartel](https://discourse.processing.org/u/alenmartel)\
**Post date:** [October 2, 2021, 7:10pm UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/8 "2021-10-02T19:10:55Z")

</div>

Ah, wonderful.

Which documentation would be best to read through to understand how to access these values? For example, if the first number is 6, then how do I randomly pick one of its adjacents from the array?

---

<div class="post-metadata">

**Author:** ![jeremydouglass](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/jeremydouglass/32/20_2.png) [@jeremydouglass](https://discourse.processing.org/u/jeremydouglass)\
**Post date:** [October 3, 2021, 3:40am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/9 "2021-10-03T03:40:43Z")

</div>

> [@alenmartel](#):
>
> if the first number is 6, then how do I randomly pick one of its adjacents from the array?

1. select the list of available options from the array `byte[] options = ADJACENTS[6]`
2. select a random value from the available options: `byte newhex = options[(int)random(options.length)];`

In that line, if there are 6 options (0-5), random(options.length) produces a random number 0-4.999, then rounds it to 0, 1, 2, 3, 4, 5. It then looks up options[#] with that number, and returns the value.

Like this (my example uses int rather than byte):

```auto
// based on sketch by GoToLoop
// https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/7

int[][] ADJACENTS = {
  { 2, 5, 6 }, // 1
  { 1, 3, 6, 7 }, // 2
  { 2, 4, 7, 8 }, // 3
  { 3, 8, 9 }, // 4
  { 1, 6, 10 }, // 5
  { 1, 2, 5, 7, 10, 11 }, // 6
  { 2, 3, 6, 8, 11, 12 }, // 7
  { 3, 4, 7, 9, 12, 13 }, // 8
  { 4, 8, 13 }, // 9
  { 5, 6, 11 }, // 10
  { 6, 7, 10, 12 }, // 11
  { 7, 8, 11, 13 }, // 12
  { 8, 9, 12 }, // 13
};

int hex = 6;
int[] options = ADJACENTS[hex-1];
// pick a random new hex 100 times
for(int i=0; i<100; i++) {
  int newhex = options[(int)random(options.length)];
  print(newhex, " ");
}

```

---

<div class="post-metadata">

**Author:** ![alenmartel](https://avatars.discourse-cdn.com/v4/letter/a/c68b51/32.png) [@alenmartel](https://discourse.processing.org/u/alenmartel)\
**Post date:** [October 3, 2021, 6:23am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/10 "2021-10-03T06:23:36Z")

</div>

Well, I think the below is an improvement. I went from 500 lines of code to 200 lines and was able to add more to the canvas. I think this might be the best I can get with this at my level but as I keep learning, I hope I can find more efficient ways to code this interpretation of a '60s program!

Thanks all! @hotfooted @GoToLoop @jeremydouglass

```auto
IntList start = new IntList();
int ts = 35, txx = 135, txy = 325, fade = 145;
int hexSize = 40, xLoc = 250, yLoc = 75, xSpac = 69, ySpac = 60;
float txf = 2.75, r = PI/1.98;
String[] dancers = {"Dancer A", "Dancer B", "Dancer C", "Dancer D", "Dancer E", "Dancer F", "Dancer G", "Dancer H", "Dancer I", "Dancer J", "Dancer K", "Dancer L"};
int[][] ADJACENTS = {
  {0, 1, 5, 10}, // 0, Off Stage Left
  {0, 1, 2, 5, 6}, // 1
  {1, 2, 3, 6, 7}, //2
  {2, 3, 4, 7, 8}, //3
  {3, 4, 8, 9, 14}, //4
  {0, 1, 5, 6, 10}, //5
  {1, 2, 5, 6, 7, 10, 11}, //6
  {2, 3, 6, 7, 8, 11, 12}, //7
  {3, 4, 7, 8, 9, 12, 13}, //8
  {4, 8, 9, 13, 14}, //9
  {0, 5, 6, 10, 11}, //10
  {6, 7, 10, 11, 12}, //11
  {7, 8, 11, 12, 13}, //12
  {8, 9, 12, 13, 14}, //13
  {4, 9, 13, 14}, // 14, Off Stage Right
};

void setup() {
  size(1280, 720);
  background(255);

  spatialScore();
  onstageHex();
  offstageHex();
  hexagonText();
  otherText();
  instructions();
}

void spatialScore() {
  start.append(new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14});

  fill(0);
  for (int i = 0; i < 12; i++) {
    start.shuffle();
    int mes1 = start.get(0); // hexagon location for measure one
    int[] mes2get = ADJACENTS[mes1]; // retrieves number from previous measure to produce same or adjacent number for current measure
    int mes2 = mes2get[(int)random(mes2get.length)]; // hexagon location for measure two
    int[] mes3get = ADJACENTS[mes2]; // retrieves number from previous measure to produce same or adjacent number for current measure
    int mes3 = mes3get[(int)random(mes3get.length)]; // hexagon location for measure three and so on for the rest
    int[] mes4get = ADJACENTS[mes3];
    int mes4 = mes4get[(int)random(mes4get.length)];
    int[] mes5get = ADJACENTS[mes4];
    int mes5 = mes5get[(int)random(mes5get.length)];
    int[] mes6get = ADJACENTS[mes5];
    int mes6 = mes6get[(int)random(mes6get.length)];
    int[] mes7get = ADJACENTS[mes6];
    int mes7 = mes7get[(int)random(mes7get.length)];
    int[] mes8get = ADJACENTS[mes7];
    int mes8 = mes8get[(int)random(mes8get.length)];
    int[] mes9get = ADJACENTS[mes8];
    int mes9 = mes9get[(int)random(mes9get.length)];
    int[] mes10get = ADJACENTS[mes9];
    int mes10 = mes10get[(int)random(mes10get.length)];
    int[] mes11get = ADJACENTS[mes10];
    int mes11 = mes11get[(int)random(mes11get.length)];
    int[] mes12get = ADJACENTS[mes11];
    int mes12 = mes12get[(int)random(mes12get.length)];

    text(dancers[i], txx - 15 + ts * (i * txf), txy - 25);
    text(mes1, txx + ts * (i * txf), txy);
    text(mes2, txx + ts * (i * txf), txy + ts);
    text(mes3, txx + ts * (i * txf), txy + ts * 2);
    text(mes4, txx + ts * (i * txf), txy + ts * 3);
    text(mes5, txx + ts * (i * txf), txy + ts * 4);
    text(mes6, txx + ts * (i * txf), txy + ts * 5);
    text(mes7, txx + ts * (i * txf), txy + ts * 6);
    text(mes8, txx + ts * (i * txf), txy + ts * 7);
    text(mes9, txx + ts * (i * txf), txy + ts * 8);
    text(mes10, txx + ts * (i * txf), txy + ts * 9);
    text(mes11, txx + ts * (i * txf), txy + ts * 10);
    text(mes12, txx + ts * (i * txf), txy + ts * 11);
  }
}

void polygon(float x, float y, float radius, int npoints) {
  float angle = TWO_PI / npoints;
  beginShape();
  for (float a = 0; a < TWO_PI; a += angle) {
    float sx = x + cos(a) * radius;
    float sy = y + sin(a) * radius;
    vertex(sx, sy);
  }
  endShape(CLOSE);
}

void onstageHex() {
  noFill();
  for (int x = xLoc; x < xLoc + xSpac * 4; x += xSpac) { // Downstage Row of Hexagons
    pushMatrix();
    translate(x, yLoc);
    rotate(r);
    polygon(0, 0, hexSize, 6);
    popMatrix();
  }

  for (int x = xLoc - 34; x < xLoc + xSpac * 4; x += xSpac) { // Midstage Row of Hexagons
    pushMatrix();
    translate(x, yLoc + ySpac);
    rotate(r);
    polygon(0, 0, hexSize, 6);
    popMatrix();
  }

  for (int x = xLoc; x < xLoc + xSpac * 4; x += xSpac) { // Upstage Row of Hexagons
    pushMatrix();
    translate(x, yLoc + ySpac * 2);
    rotate(r);
    polygon(0, 0, hexSize, 6);
    popMatrix();
  }
}

void offstageHex() {
  stroke(fade);
  noFill();

  pushMatrix();
  translate(xLoc - hexSize - 30, yLoc); // Stage Left of 10
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  pushMatrix();
  translate(xLoc + 1 + xSpac * 4, yLoc); // Stage Right of 13
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  pushMatrix();
  translate(xLoc - hexSize - 64, yLoc + ySpac); // Stage Left of 5
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  pushMatrix();
  translate(xLoc + 36 + xSpac * 4, yLoc + ySpac); // Stage Right of 9
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  pushMatrix();
  translate(xLoc - hexSize - 30, yLoc + ySpac * 2); // Stage Left of 1
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();

  pushMatrix();
  translate(xLoc + 1 + xSpac * 4, yLoc + ySpac * 2); // Stage Right of 4
  rotate(r);
  polygon(0, 0, hexSize, 6);
  popMatrix();
}

void hexagonText() {
  fill(0);
  for (int i = 0; i < 4; i++) {
    text(i + 1, (xLoc - 3) + xSpac * i, yLoc + 3 + ySpac * 2);
    text(i + 10, (xLoc - 8) + xSpac * i, yLoc + 3);
  }

  for (int i = 0; i < 5; i++) {
    text(i + 5, (xLoc - 37) + xSpac * i, yLoc + 3 + ySpac);
  }

  fill(fade);
  text("0", xLoc - hexSize - 33, yLoc + 5); // Stage Left of 10
  text("14", xLoc + xSpac * 4 - 8, yLoc + 5); // Stage Right of 13
  text("0", xLoc - hexSize - 33 - 34, yLoc + ySpac + 5); // Stage Left of 5
  text("14", xLoc + 34 + xSpac * 4 - 8, yLoc + ySpac + 5); // Stage Right of 9
  text("0", xLoc - hexSize - 33, yLoc + ySpac * 2 + 5); // Stage Left of 1
  text("14", xLoc + xSpac * 4 - 8, yLoc + ySpac * 2 + 5); // Stage Right of 4
}

void otherText() {
  fill(0);
  text("Measure", 30, 300);
  for (int i = 0; i < 12; i++) {
    text(i + 1, 50, txy + ts * i);
  }

  text("Downstage", 115 + xSpac * 3, 20);
  text("Upstage", 120 + xSpac * 3, yLoc + 60 + ySpac * 2);
  text("Stage Right", 620, 140);
  text("Stage Left", 30, 140);
}

void instructions() {
  int x = width / 2 + 90;
  int y = 50;
  noFill();
  rect(x - 15, 0, x, y * 5.5);
  fill(0);
  line(x, y - 23, x + 140, y - 23);
  line(0, height / 2 - 55, width, height / 2 - 55);
  text("Credits and Instructions", x, y - 25);
  text("Reproduction of a program by Francisco Sagasti (March 14, 1968 at PSU.)", x, y);
  text("Originally coded using Fortran IV programming language and reinterpreted using\nProcessing 4.0b1 with the support of hotfooted, GoToLoop, and jeremydouglass.", x, y * 2);
  text("Hexagons labelled 1 to 13 represents a location onstage. O and 14 represent the offstage.", x, y * 3);
  text("Each dancer will occupy a hexagon as noted in their column. Each row represents a measure.", x, y * 4);
  text("Dancers can do any movement, interact with others in any way. This is a 'spatial score.'", x, y * 5);
}

```

---

<div class="post-metadata">

**Author:** ![hotfooted](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/hotfooted/32/3670_2.png) [@hotfooted](https://discourse.processing.org/u/hotfooted)\
**Post date:** [October 3, 2021, 6:24am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/11 "2021-10-03T06:24:48Z")

</div>

nice work. a very interesting program too. best of luck with it all 🙂

---

<div class="post-metadata">

**Author:** ![GoToLoop](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/gotoloop/32/86_2.png) [@GoToLoop](https://discourse.processing.org/u/GoToLoop)\
**Post date:** [October 3, 2021, 11:25am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/12 "2021-10-03T11:25:54Z")

</div>

> [@alenmartel](#):
>
> , I hope I can find more efficient ways to code this interpretation of a '60s program!

I’m assuming you were never exposed to the Object-Oriented Programming (OOP) paradigm, right?

> [@alenmartel](#):
>
> Which documentation would be best to read through to understand how to access these values?

I guess you’ve meant my `class` Hexagon, is it?

> **[class / Reference](https://processing.org/reference/class.html)**
>
> Keyword used to indicate the declaration of a class. A class is a composite of fields (data) and methods (functions that are a part of the class) which may be instantiated as objects. The first lette…

In Java we rely on the `.` dot access operator in order to access a member of a `class`:

> **[. (dot) / Reference](https://processing.org/reference/dot.html)**
>
> Provides access to an object's methods and data. An object is one instance of a class and may contain both methods (object functions) and data (object variables and constants), as specified in the cla…

Let’s say you wanna read the field _value_ from the Hexagon instance on index 4 of array _hexagons[]_:  
`println(hexagons[4].value);`  
The statement above will log the value 5.

Another example, reading the field array _adjacents[]_ from the Hexagon instance on index 8:  
`println(hexagons[8].adjacents);`

We’ll see the following values below logged:

```auto
[0] 4
[1] 8
[2] 13

```

For another way to understand OOP and classes read this article below:

> **[Processing 2.x and 3.x Forum](https://forum.processing.org/two/discussion/8081/from-several-arrays-to-classes.html)**
>
> Processing is an electronic sketchbook, a language and a worldwide community. This is its forum.

---

<div class="post-metadata">

**Author:** ![GoToLoop](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/gotoloop/32/86_2.png) [@GoToLoop](https://discourse.processing.org/u/GoToLoop)\
**Post date:** [October 3, 2021, 11:40am UTC](https://discourse.processing.org/t/pick-random-number-based-on-preceding-number/32558/13 "2021-10-03T11:40:56Z")

</div>

I did another example w/ 2 classes: Hexagon & Dancer:

https://OpenProcessing.org/sketch/1292231/embed/

The new `class` Dancer has a field named _floor_ which stores the current Hexagon it’s stepping in.

It has a method **randomMove()** which attempts to move into a **random()** Hexagon adjacent to its current 1 by invoking Hexagon::**isNeighborOrSame()** method in a _do/while ()_ loop until the random value is valid.

I hope you may understand how the interaction between those 2 classes work:

```auto
/**
 * Hexagon Dancers (v1.0.2)
 * GoToLoop (2021/Oct/03)
 *
 * https://Discourse.Processing.org/t/
 * pick-random-number-based-on-preceding-number/32558/13
 *
 * https://OpenProcessing.org/sketch/1292231
 */

static final byte[][] ADJACENTS = {
  { 2, 5, 6 }, // 1
  { 1, 3, 6, 7 }, // 2
  { 2, 4, 7, 8 }, // 3
  { 3, 8, 9 }, // 4
  { 1, 6, 10 }, // 5
  { 1, 2, 5, 7, 10, 11 }, // 6
  { 2, 3, 6, 8, 11, 12 }, // 7
  { 3, 4, 7, 9, 12, 13 }, // 8
  { 4, 8, 13 }, // 9
  { 5, 6, 11 }, // 10
  { 6, 7, 10, 12 }, // 11
  { 7, 8, 11, 13 }, // 12
  { 8, 9, 12 } // 13
};

final Hexagon[] hexagons = new Hexagon[ADJACENTS.length];

static final int DANCERS = 2, TXT_SIZE = 050, FPS = 1;
final Dancer[] dancers = new Dancer[DANCERS];

static final boolean JAVA = 1/2 != 1/2.;

void setup() {
  size(400, 300);
  frameRate(FPS);

  textSize(TXT_SIZE);
  textAlign(CENTER, CENTER);

  createHexagons();
  createDancers();

  if (JAVA) {
    printArray(hexagons);
    println();
    printArray(dancers);
    println();
  }
}

void draw() {
  background(0);
  for (final Dancer dancer : dancers) dancer.randomMove().display();

  print(dancers);
  println("\tFrame: " + frameCount);
}

void createHexagons() {
  for (int i = 0; i < ADJACENTS.length; ++i)
    hexagons[i] = new Hexagon(i + Hexagon.LOWEST, ADJACENTS[i]);
}

void createDancers() {
  final int w = width, h = height;
  final int dim = h >> 1, cy = h - dim >> 1, off = 30;
  final color red = #FF0000, blue = #0000FF, yellow = #FFFF00;

  int idx;

  idx = (int) random(ADJACENTS.length);
  dancers[0] = new Dancer(hexagons[idx], off, cy, dim, red, yellow);

  idx = (int) random(ADJACENTS.length);
  dancers[1] = new Dancer(hexagons[idx], w - dim - off, cy, dim, blue, yellow);
}

class Hexagon {
  static final int LOWEST = 1, HIGHEST = 13;

  int value;
  byte[] adjacents;

  Hexagon(final int val, final byte[] neighbors) {
    value = val;
    adjacents = neighbors;
  }

  boolean isNeighborOrSame(final int val) {
    return val == value? true : isNeighbor(val);
  }

  boolean isNeighbor(final int val) {
    for (final byte neighbor : adjacents) if (val == neighbor) return true;
    return false;
  }

  String toString() {
    return value + ": { " + join(str(adjacents), ", ") + " }";
  }
}

class Dancer {
  Hexagon floor;
  int x, y, dim;
  color floorColor, textColor;

  Dancer(
    final Hexagon tile, 
    final int px, final int py, final int diam, 
    final color squareColor, final color txtColor
    )
  {
    floor = tile;
    x = px;
    y = py;
    dim = diam;
    floorColor = squareColor;
    textColor = txtColor;
  }

  Dancer randomMove() {
    int val;

    //do val = (int) random(Hexagon.LOWEST, Hexagon.HIGHEST + 1);
    //while (!floor.isNeighborOrSame(val));

    while (!floor.isNeighborOrSame(
      val = (int) random(Hexagon.LOWEST, Hexagon.HIGHEST + 1)));

    floor = hexagons[val - Hexagon.LOWEST];

    return this;
  }

  Dancer display() {
    fill(floorColor);
    rect(x, y, dim, dim);

    fill(textColor);
    text(floor.value, x + dim/2, y + dim/2);

    return this;
  }

  String toString() {
    return "Floor: " + floor.value;
  }
}

```