The Nth Monitor

1:16 PM

@Mathias-Ettinger, I did a little change to the Die class regarding pretty printing

I changed in the upper_facesetting of face() to:

        if self.faces == 25:
            upper_face = self.pattern.format(*(eye_empty if roll < i else eye_full
                for i in [1, 21, 7, 23, 3, 17, 9, 15, 11, 19, 5, 13]))
        else:
            upper_face = self.pattern.format(*(eye_empty if roll < i else eye_full
                for i in range(1, self.limit, 2)))

And then ran print_dice_rolls(25, range(25), True), which produced the following output:

+-----------+  +-----------+  +-----------+  +-----------+
|           |  | o         |  | o         |  | o       o |
|           |  |           |  |           |  |           |
|     o     |  |           |  |     o     |  |           |
|           |  |           |  |           |  |           |
|           |  |         o |  |         o |  | o       o |
+-----------+  +-----------+  +-----------+  +-----------+

+-----------+  +-----------+  +-----------+  +-----------+
| o       o |  | o       o |  | o       o |  | o   o   o |
|           |  |           |  |           |  |           |
|     o     |  | o       o |  | o   o   o |  | o       o |
|           |  |           |  |           |  |           |
| o       o |  | o       o |  | o       o |  | o   o   o |
+-----------+  +-----------+  +-----------+  +-----------+

+-----------+  +-----------+  +-----------+  +-----------+
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
|           |  |   o       |  |   o       |  |   o   o   |
| o   o   o |  | o       o |  | o   o   o |  | o       o |
|           |  |       o   |  |       o   |  |   o   o   |
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
+-----------+  +-----------+  +-----------+  +-----------+

+-----------+  +-----------+  +-----------+  +-----------+
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
|   o   o   |  |   o   o   |  |   o   o   |  |   o o o   |
| o   o   o |  | o o   o o |  | o o o o o |  | o o   o o |
|   o   o   |  |   o   o   |  |   o   o   |  |   o o o   |
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
+-----------+  +-----------+  +-----------+  +-----------+

+-----------+  +-----------+  +-----------+  +-----------+
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
|   o o o   |  | o o o o   |  | o o o o   |  | o o o o o |
| o o o o o |  | o o   o o |  | o o o o o |  | o o   o o |
|   o o o   |  |   o o o o |  |   o o o o |  | o o o o o |
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
+-----------+  +-----------+  +-----------+  +-----------+

+-----------+  +-----------+  +-----------+  +-----------+
| o   o   o |  | o o o   o |  | o o o   o |  | o o o o o |
| o o o o o |  | o o o o o |  | o o o o o |  | o o o o o |
| o o o o o |  | o o   o o |  | o o o o o |  | o o   o o |
| o o o o o |  | o o o o o |  | o o o o o |  | o o o o o |
| o   o   o |  | o   o o o |  | o   o o o |  | o o o o o |
+-----------+  +-----------+  +-----------+  +-----------+

+-----------+
| o o o o o |
| o o o o o |
| o o o o o |
| o o o o o |
| o o o o o |
+-----------+

And this output I think is prettier than the ordinary output when just filling the range from 0 to limit. But whilst prettier, it is kind of harder to read as well...

(For innocent bystanders, this is related to codereview.stackexchange.com/q/111337/78136

Similar output for the second line, which now resembles an ordinary die, but when using the simple range filling:

+-----------+  +-----------+  +-----------+  +-----------+
| o o       |  | o o o     |  | o o o     |  | o o o o   |
|           |  |           |  |           |  |           |
|     o     |  |           |  |     o     |  |           |
|           |  |           |  |           |  |           |
|       o o |  |     o o o |  |     o o o |  |   o o o o |
+-----------+  +-----------+  +-----------+  +-----------+

and for 17 through 20:

+-----------+  +-----------+  +-----------+  +-----------+
| o o o o o |  | o o o o o |  | o o o o o |  | o o o o o |
| o o o     |  | o o o o   |  | o o o o   |  | o o o o o |
|     o     |  |           |  |     o     |  |           |
|     o o o |  |   o o o o |  |   o o o o |  | o o o o o |
| o o o o o |  | o o o o o |  | o o o o o |  | o o o o o |
+-----------+  +-----------+  +-----------+  +-----------+

What do you think is easiest to understand, whilst still having a certain 'niceness' to it?

Zak

The first is much nicer, the second is much easier to understand, especially to understand at-a-glance

holroy

Hmm... But I do like the first one. "My precious..."

I could potentially add the number in the lower right corner when the die value increases.

+-----------+  +-----------+  +-----------+  +-----------+
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
|   o   o   |  |   o   o   |  |   o   o   |  |   o o o   |
| o   o   o |  | o o   o o |  | o o o o o |  | o o   o o |
|   o   o   |  |   o   o   |  |   o   o   |  |   o o o   |
| o   o   o |  | o   o   o |  | o   o   o |  | o   o   o |
+--------13-+  +--------14-+  +--------15-+  +--------16-+

But the real challenge would be to autogenerate the sequence of [1, 21, 7, 23, 3, 17, 9, 15, 11, 19, 5, 13] for an arbitrary dice size...

Mathias Ettinger

1:43 PM

I like the first one more too. But generating the sequence is the trickier part for a true infinitly-sizeable die, which is why I left it as an exercice for the trader ;)

holroy

HeHe... Chickening out?! :-D

I think it is kind of easy to fill in manually, but doing it algorithmic. Well, that is another story

Mathias Ettinger

Moreover, I have the feeling that the séquence might be dependant of the roll too

Something that can handle 6 and 8 equally beatifully for a 20-sided die is pretty hard to anticipate.

holroy

How so? The start of the sequence is filling corners, then left middle, top middle, switch to inner frame, and do the same (corners, left middle, top middle). And then finally doing the inbetween corners and middle points (first leftmost, and then rightmost).

Mathias Ettinger

(Damn auto-correct, it makes it really hard to type english sentences on this phone)

(To typeset blocks of code, I am supposed to be able to ait+enter in this chat box, right?)

holroy

For a dice with an even number along one side, one need to choose if one should go to the inner first, or having the left/right inbetween first. Hmmm... Does indeed sound like some work, but it would be cool if I got it as well...

I hit the "fixed font" button in my web browser. Not sure how to do a

... on a phone. Alt+Enter sent the text

Mathias Ettinger

1:52 PM

Let me find a computer, then.

holroy

Would love for you to take a look on it, at some time, when you have a computer at hand. No rush, though. I have to go out for a while, now....

Mathias Ettinger

+---------+ +---------+

Damn

Mast

@DanPantry You need to find out if the next job is going to improve your chances for the next job. Get some experience under your belt and the money will come.

holroy

@MathiasEttinger Interesting line... :-)

Dan Pantry

@Mast experience doesn't pay bills :)

A job that is a "good opportunity" means nothing if I can't afford to live while doing that job

Mast

2:00 PM

@DanPantry In the long run, it will.

@DanPantry True. Don't go too low.

Mathias Ettinger

+---------+  +---------+
| o     o |  | o     o |
|         |  |    o o  |
| o     o |  |         |
|         |  |   o o   |
| o     o |  | o     o |
+---------+  +---------+

Dan Pantry

@Mast Either way, looking at their website.. I'm not too impressed. visokio.com/omniscope

Mathias Ettinger

Close enought

Mast

@DanPantry Perhaps you should make it a The Workplace post.

Mathias Ettinger

So yeah, the point was for even-width dice

Dan Pantry

2:01 PM

@Mast It's not really that much of a dilemma, tbh. I'm not looking to leave my current job just yet. Itd have to be a real stand-out opportunity for me to consider it

Mathias Ettinger

It is really non-trivial to get a uniform distribution of eyes for every roll

Dan Pantry

I'm happy to do interviews & such but ay job offer would have to be pretty amazing for me to leave my current job. Right now, I may not be working in the tech I necessarily want to work in, but the lifestyle is more or less perfect.

I live a short distance from work, I can save a decent amount of money per month and still have money left over, the people are great, etc.

When I have more money saved up to fall back on, I would consider a change, but until that point it's probably not wise to do so

Mast

@DanPantry Just make sure you don't rust, you still want to have a job in 20 years.

And soliciting is never a bad idea, even if you don't want to go. Go fish for opportunities.

Dan Pantry

Yea, that's the thing. Even if I'm not looking to move I'm still doing interviews.

brushing up on your interview skills doesn't hurt and its good to know what companies are looking for.

holroy

@MathiasEttinger Maybe... But if you have even side, you could go for the diagonals first... Making the six and eight of that dice size to be:

+---------+  +---------+
| o     o |  | o     o |
|         |  |   o     |
| o     o |  | o     o |
|         |  |     o   |
| o     o |  | o     o |
+---------+  +---------+

And then ten would be:

+---------+
| o     o |
|   o o   |
| o     o |
|   o o   |
| o     o |
+---------+

I do believe it is feasible to get a sequence producing pretty nice faces, but I'm not sure about the algorithm

Mathias Ettinger

2:09 PM

I have the same feeling

But what about 15+ rolls on this 20-side die?

holroy

Hmm... I'm thinking on something utilising a matrix transformation of coordinates to an index, so that on could start of with "0,0 = 1", and then "0, width = 3", "height//2, 0 = 5", and for odd widths, something like "width//2+1, 0 = 7", before moving to inner frame...

Mathias Ettinger

I fear that at some point we would have to either have un unbalance in the full eyes or to have a sequence that depend of the roll too.

But well… The 8 roll is already unbalanced in your version and doesn't look so bad

holroy

+---------+  +---------+
| o     o |  | o c   o |
|   o o   |  | a o o b |
| o o o o |  | o o o o |
|   o o   |  | b o o a |
| o     o |  | o   c o |
+------12-+  +------18-+

where the a is first of the 'inbetweens', b is second, c is third, and then the empty space is the last to be filled...

Mathias Ettinger

+---------+  +---------+
| o     o |  | o     o |
|   o o   |  | a o o b |
| o ooo o |  | o ooo o |
|   o o   |  | b o o a |
| o     o |  | o     o |
+------13-+  +------17-+

holroy

You gotta have something unbalanced at some point in time... The question, if going doing this road, is how long you can keep up the symmetry

Mathias Ettinger

2:16 PM

Mmmh, not that bad too…

holroy

13 and 17 does look nice, as well

Mathias Ettinger

I don't think I can come up with something in the next few hours, but you can be sure that it will sit in my brain for quite some time.

2

holroy

Another thought was whether one needs to do this for every time one wants to print a face, but then it hit me that give that you have a Die instantation then this sequence could and should be generated in the __init__ method.

@MathiasEttinger Agreed!!!

I'll be happy to here from you, and if I find something myself, I'll post it related to the question (or chat)

Mathias Ettinger

2:35 PM

@holroy For a first improvement, I suggest `random.shuffle(range(1, self.limit, 2))` :D (well, not directly since `shuffle` changes the list in place). Pretty interesting results:

6-sided dice: [1, 2, 3, 4, 5, 6]
+-----+ +-----+ +-----+ +-----+ +-----+ +-----+
| | | o | | o | | o | | o | | o o |
| o | | | | o | | o o | | ooo | | o o |
| | | o | | o | | o | | o | | o o |
+-----+ +-----+ +-----+ +-----+ +-----+ +-----+

4-sided dice: [1, 2, 3, 4]

What happened to the formatting :'(

holroy

That looks terrible, but that is due to non-fixed font... :-D

or something similarily destructive....

Fun idea, though...

Mast

+-----+ +-----+ +-----+ +-----+ +-----+ +-----+
| | | o | | o | | o | | o | | o o |
| o | | | | o | | o o | | ooo | | o o |
| | | o | | o | | o | | o | | o o |
+-----+ +-----+ +-----+ +-----+ +-----+ +-----+

Fixed it's still a mess.

Mathias Ettinger

6-sided dice: [1, 2, 3, 4, 5, 6]
+-----+ +-----+ +-----+ +-----+ +-----+ +-----+
| | | o | | o | | o | | o | | o o |
| o | | | | o | | o o | | ooo | | o o |
| | | o | | o | | o | | o | | o o |
+-----+ +-----+ +-----+ +-----+ +-----+ +-----+

4-sided dice: [1, 2, 3, 4]
+-----+ +-----+ +-----+ +-----+
| | | | | | | * |
| * | | * * | | *** | | * * |
| | | | | | | * |
+-----+ +-----+ +-----+ +-----+

Grrr

6-sided dice: [1, 2, 3, 4, 5, 6]
+-----+  +-----+  +-----+  +-----+  +-----+  +-----+
|     |  | o   |  | o   |  | o   |  | o   |  | o o |
|  o  |  |     |  |  o  |  | o o |  | ooo |  | o o |
|     |  |   o |  |   o |  |   o |  |   o |  | o o |
+-----+  +-----+  +-----+  +-----+  +-----+  +-----+

4-sided dice: [1, 2, 3, 4]
+-----+  +-----+  +-----+  +-----+
|     |  |     |  |     |  |   * |
|  *  |  | * * |  | *** |  | * * |
|     |  |     |  |     |  | *   |
+-----+  +-----+  +-----+  +-----+

There we go

Pretty bad with “small” dice but fun enough for large ones.

holroy

I think maybe one of the next extension is to define eyes pattern: 'normal', 'pretty', 'random'.

What code changes did you need to get the random pattern?

Mathias Ettinger

In __init__ add, after self.limit = width * height: self.limit = range(1,self.limit,2); random.shuffle(self.limit)

And in face, use self.limit instead of range(1, self.limit, 2)

holroy

2:47 PM

HeHe... That is some funny patterns...

Mathias Ettinger

By the way, since I didn't pay attention to the Python-2.7 tag in the review, I should have used xrange instead of range in various places.

But for this change to work, you definitely need range in self.limit = range(1, self.limit, 2).

holroy

That one I know, but I think it doesn't matter that much when N is lower than a few hundred... Actually my timing tests indicate that generators, like xrange, is actually slower than list comprehension or lists in some cases...

Whilst waiting for you to tell me how you did it, I changed it within face()to:

    random_range = range(1, self.limit, 2)
    random.shuffle(random_range)

That gives an even better effect, as all the die faces change...

+---------+  +---------+  +---------+  +---------+  +---------+
|       o |  |   o o   |  | o o     |  |   o   o |  | o o   o |
| o       |  |         |  |   o   o |  | o   o   |  |     o   |
|   o o   |  | o  o  o |  |         |  |    o    |  | o     o |
|       o |  |         |  | o   o   |  |   o   o |  |   o     |
| o       |  |   o o   |  |     o o |  | o   o   |  | o   o o |
+---------+  +---------+  +---------+  +---------+  +---------+

That is from 6 through 10... :-)

But good luck reading the value out of it...

So now we have 'normal', 'pretty', 'random', 'all_random'...

Mathias Ettinger

And “pretty” left to be implemented…

holroy

where 'pretty' is only defined for 25-sided dices...

yeah...

Oooh... Pretty.... Added 'reversed' to it as well:

+---------+  +---------+  +---------+  +---------+  +---------+
|   o o o |  |   o o o |  |     o o |  | o o   o |  |   o   o |
| o o     |  | o   o   |  | o o   o |  |   o   o |  | o o o   |
|    o    |  |   o o   |  | o  o  o |  | o o o o |  | o ooo o |
|     o o |  |   o   o |  | o   o o |  | o   o   |  |   o o o |
| o o o   |  | o o o   |  | o o     |  | o   o o |  | o   o   |
+---------+  +---------+  +---------+  +---------+  +---------+

Mathias Ettinger

Reversed? I don't get it.

holroy

3:01 PM

Changed init to:

   random.shuffle(self.pattern_range)

elif pattern == 'reversed':
    self.pattern_range = reversed(self.pattern_range)

elif self.faces == 25:
    self.pattern_range = [1, 21, 7, 23, 3, 17, 9, 15, 11, 19, 5, 13]

self._all_random = pattern == 'all_random'

And in face():

if self._all_random:
    random.shuffle(self.pattern_range)

upper_face = self.pattern.format(*(eye_empty if roll < i else eye_full
    for i in self.pattern_range)) # range(1, self.limit, 2)))

So 'reversed' is the normal range, just reversed

Mathias Ettinger

Oh, ok

But reversed + random is not different than random

holroy

Nope... But pattern can only have one value (currently)

So reversed + random can't be done

hmmm... reversed worked when in face, but not in init for 6-sided dice

Mathias Ettinger

Oh, yeah, missed the indentation at first. And since reversed + random is pretty much the same than random, it doesn't makes sense to have more than one value for pattern.

holroy

My change to __init__ seem to miss start of it:

    self.pattern_range = list(range(1, self.limit, 2))

    if pattern == 'random':
        random.shuffle(self.pattern_range)

    elif pattern == 'reversed':
        self.pattern_range = reversed(self.pattern_range)

    elif self.faces == 25:
        self.pattern_range = [1, 21, 7, 23, 3, 17, 9, 15, 11, 19, 5, 13]

    self._all_random = pattern == 'all_random'

Mathias Ettinger

It does for me

6-sided dice: [1, 2, 3, 4, 5, 6]
+-----+  +-----+  +-----+  +-----+  +-----+  +-----+
|     |  |     |  |     |  |   o |  |   o |  | o o |
|  o  |  | o o |  | ooo |  | o o |  | ooo |  | o o |
|     |  |     |  |     |  | o   |  | o   |  | o o |
+-----+  +-----+  +-----+  +-----+  +-----+  +-----+

holroy

3:08 PM

Kind of neat?

Mathias Ettinger

I prefer the sorted one.

But taste varies.

holroy

The normal one is cleaner, but I kind of liked the patterns in the reversed one.

But now I really gotta go, before the shop closes!!

I'm way too easy to distract...

Mathias Ettinger

But still, we could add “odd-even” (kind of range(1, limit, 4) + range(3, limit, 4)) and a lot of others, we still have to figure out the “pretty” one ;)

holroy

Sounds cool...

Mathias Ettinger

6-sided dice: [1, 2, 3, 4, 5, 6]
+-----+  +-----+  +-----+  +-----+  +-----+  +-----+
|     |  | o   |  | o   |  | o   |  | o   |  | o o |
|  o  |  |     |  |  o  |  | o o |  | ooo |  | o o |
|     |  |   o |  |   o |  |   o |  |   o |  | o o |
+-----+  +-----+  +-----+  +-----+  +-----+  +-----+

4-sided dice: [1, 2, 3, 4]
+-----+  +-----+  +-----+  +-----+
|     |  | *   |  | *   |  | *   |
|  *  |  |     |  |  *  |  | * * |
|     |  |   * |  |   * |  |   * |
+-----+  +-----+  +-----+  +-----+

Better than I thought :)

holroy

3:15 PM

I especially liked the 12-sided one...

Mathias Ettinger

Yup, the greater values are pretty close to your pretty-25-side one

holroy

And the 49-sided seems interesting

Mathias Ettinger

I’ll try to dig into it. See you later, since you should already be gone ;)

Damn… There is something completly wrong with this 15-sided die.

holroy

Found the fault in my reversed version... It was the Python3 vs Python2... reversed(iterable) return an iterator, and it got exhausted on the second face to display... Have to use list(reversed(iterable))...

Mathias Ettinger

sorted(some_list, reverse=True)

more reliable

and can work with xrange too.

I don't quite get the difference in behaviour between Python 2 and Python 3 that can lead to the differences between what I posted in my answer and what I posted here for the 15-sided die.

(And is it just me or does the * have some problem of rendering in code mode on codereview?)

Mathias Ettinger

3:59 PM

Changed the sequence from [1, 21, 7, 23, 3, 17, 9, 15, 11, 19, 5, 13] to [1, 19, 7, 23, 3, 17, 9, 15, 11, 21, 5, 13] to try and get more diagonal symetries.

It looks like horizontal and vertical ones are more important for what is considered “pretty”

Mathias Ettinger

4:23 PM

@holroy What about this 49-sided sequence?

+---------------+  +---------------+  +---------------+
|               |  | o             |  | o             |
|               |  |               |  |               |
|               |  |               |  |               |
|       o       |  |               |  |       o       |
|               |  |               |  |               |
|               |  |               |  |               |
|               |  |             o |  |             o |
+---------------+  +---------------+  +---------------+

Or would you had filling the middle ring before the inner one?

Or even the middle ring before the outer one?

holroy

This is looking nice!

I was kinding of thinking middle ring before inner ring... That is to go from outside towards middle... Don't really know why...

@MathiasEttinger How did you do this one? Have you used some sort of circular equation?

It kind of hit me when seeing this, that possibly some variant over a circular equation translated into a matrix could be the way to go. But this really looked nice!

Mathias Ettinger

5:11 PM

@holroy Still at the pen and paper step. I'm trying to build a pattern before transforming it into code.

I used self.limit = [1,45,29,7,31,47,3,41,17,37,23,39,19,43,25,33,9,15,11,35,27,5,21,13]

holroy

5:28 PM

I see the pattern, but I need to think more on how to implement it. The corner, and middle part for starters are easy. Then we need to fill the fields inbetween (possibly in two rounds), and the first round of inbetween is to be closer to the general middle.

Changed the end of face() to display the roll number:

        # Mirror pattern string with changing middle to get a full face
        full_face =  upper_face + self.eyes[roll&1] + upper_face[::-1]

        # Add the roll number, if large enough die size
        if self._add_number:
           eyes = str(roll+1)
           full_face = full_face[:-2-len(eyes)] + eyes + full_face[-2:]

        return full_face

Mathias Ettinger

6:18 PM

@holroy Still adding possibilities while not improving the “pretty” pattern:

class Die:
    def __init__(self, faces_count, eyes='o ', corner='+'):
        """Compute statistics about places of eyes on a die face"""

        if len(eyes) != 2:
            raise ValueError('Excpected two choice for eye parameter')

        if faces_count < 1:
            raise ValueError('Strictly positive number of faces expected')

        if faces_count < 3:
            self.height =6
            self.width = 8
            self.face = self._coin
            return

        # Rest of the code

Which, without changing the rest of the code, can lead to

2-sided dice, zero-based: [0, 1, 0, 1, 1, 1, 0, 0]
   _____        _____        _____        _____        _____
  /     \      /     \      /     \      /     \      /     \
 /       \    /       \    /       \    /       \    /       \
|  Tails  |  |  Heads  |  |  Tails  |  |  Heads  |  |  Heads  |
 \       /    \       /    \       /    \       /    \       /
  \_____/      \_____/      \_____/      \_____/      \_____/
   _____        _____        _____
  /     \      /     \      /     \
 /       \    /       \    /       \

Joe Wallis

6:48 PM

Are you guys manually writing the pretty pattern?

Ethan Bierlein

8:22 PM

So... politics..

Ethan Bierlein

9:31 PM

/me is enjoying a heated debate with some flat earthers

holroy

10:47 PM

@JoeWallis The pretty pattern, yes!

Ethan Bierlein

Oh, hello!

Joe Wallis

Ah, I tried making one that pretty prints, it kinda does, but looks horrible, not as nice as yours...

holroy

Most of the prettiness(?) comes from the simple fact that the bottom part is the mirror of the top part. And then some more or less clever trickery with numbers. But some of these are nice! Please do contribute with new patterns, especially if you have an accompanying range to produce that pattern!

Hosch250

11:07 PM

@EthanBierlein They are probably giggling because you are actually taking them seriously.

Phrancis

@EthanBierlein You should do yourself a favor and just let them be idiots in their dark little corner of the internet

Ethan Bierlein

Nah. I actually find it quite fun constantly disproving every foolish statement of theirs. :P

Joe Wallis

@holroy My bad I meant algorithm. Not an adaption... If you want to see it (And say how bad it is it's here: codereview.stackexchange.com/q/111445/42401)

holroy

@JoeWallis Interesting... Will look in on that one, but not tonight! You could print a larger sample here?

Joe Wallis

Sure

Here's where the pattern starts to deviate

 +-----+ +-----+ +-----+ +-----+ +-----+
 |     | |O    | |O    | |O   O| |O   O|
 |     | |     | |     | |     | |     |
 |  O  | |     | |  O  | |     | |  O  |
 |     | |     | |     | |     | |     |
 |     | |    O| |    O| |O   O| |O   O|
 +-----+ +-----+ +-----+ +-----+ +-----+
 +-----+ +-----+ +-----+ +-----+ +-----+
 |O   O| |O   O| |O O O| |O O O| |O O O|
 |     | |     | |     | |     | |O    |
 |O   O| |O O O| |O   O| |O O O| |O   O|
 |     | |     | |     | |     | |    O|
 |O   O| |O   O| |O O O| |O O O| |O O O|

holroy

11:28 PM

Why is the second different from the first? The second seems to do something along the lines which we are looking for. That is doing the outer ring first, and then continueing with the ring inside of it... In the prettiest example so far, we do the 1-8 on the outer ring, then continue with 8 + (1 through 8) on the inner ring, and then we kind of loose it and have to fill in the blanks...

This is the start of the 1-8 on inner ring...

Your second version does 1 - 6 on outer ring, then 1 to 4 on inner ring, and then changes to outer ring again? And here is a difference, that in the pattern me and Matthias has made (with exception of the 'all random') we always use the same pattern so when displaying a higher roll, it is always based on a previous lower roll plus a few extra eyes.

Or put another way, when doing the 7, it is the 6 pattern plus the 7th eye. And the 25 is the 24 pattern plus the 25th eye. (With a slight exception for the blinking center eye, that is). (So it could be said stated that 26 is the 24 pattern plus the 26th eye pair). Don't know if that makes sense, but the higher roll is based on pattern of lower rolls.

Joe Wallis

The second is a different algorithm, I _really_ dislike how I implemented it...
I couldn't find a way to do what you are doing, I tried, but it looked horrible, so I went 4 looks nice enough...

As for the 26 is the 24 plus two eyes, I tried to get that but, my brain stopped working, I got a massive headache and couldn't think, so I'm taking a break...

The rings, do the exact thing that you're thinking. But my spread function is _really_ bad...

holroy

@JoeWallis We've got a defined pattern, and then using different ranges based on [r < odd numbers] we get the different faces. The prettiest patterns have the range hard coded, whilst the other are various alternations on the ranges.

I know what I'm thinking, I'm just having troubles realising it. (Somewhat) Easy to explain, but hard to program... That is one of the reasons your code/patterns look interesting as you've seem to have grasped some of the ring concept.

Joe Wallis

11:46 PM

The ring concept is fine, it's my spread. My algorithm is bad, for example it builds up on the outer ring, and then dumps it in an inner ring. I couldn't figure a way to have it so it wouldn't do that...

holroy

I'll look into it, and see if I understand it.

Kind of fascinating how intriguing this problem turned out to be... (At least for some of us... :-) )

I think we've left the OP of the original poster somewhere behind there... Hmmm... I gotta give him a good review in due time also...

Joe Wallis

Yeah, the bad bit is SpreadDice. I really like this problem, getting it to become infinite is hard...

So `_spread_amount` is the algoritm that says there are x in ring 1, y in ring 2.
And due to a terrible implmentation it does the ugly jumps:

+-----++-----+
|O O O||O O O|
|OO O || OOO |
|O O O||OO OO|
| O OO|| OOO |
|O O O||O O O|
+-----++-----+

holroy

I'm contemplating on part of the ring theory and mixing it with our ranges. That is to use the outer ring for the first 4 numbers in the range to get the (matching 1-8), and then continue with the inner ring for first 4 numbers, and then continue through the rings, before going out again halfing the remaining rings one bye one until the range is complete...

Transcript for