[AdamSpeight2008]

Challenge: Roll That Die!

Challenge:
So given a die, the Pitch, Roll and Yaw, output which dice face is on top and also produce the dice layout with correct orientations of all the faces.

• Implement the follow Shared Function on your Die
  

  Public Shared Function PRY(dieToUse As Die,
                   pitches As Integer,
                   rolls As Integer,
                   yaws As Integer) As Die
   ' ... '
  
  End Function
  
  

  
  
  
• Implement the following ReadOnly Property on your Die.
  Which reveals the value of the top-most face
  

  Public Read Only Propery Value() As Integer
  
  

  
  
  
• Override the ToString method to output the die in the follow format.
  
  

    B
   LTR
    F
    P
  
  

  
  B - Back
  L - Left
  T - Top
  R - Right
  F - Front
  P - Posterior
  
  An Example output of the canonical die starting arrangement.
  

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

  
  Output the dice is to be in the above style.
  
  
• Any die produced or used mustn't be changed or mutated.

Notes:

-Pitch is Pitching Forwards
+Pitch is Pitching Backwards
-Roll is Rolling to Left
+Roll is Rolling to Right
-Yaw is Anti-Clockwise
+Yaw is Clockwise

For Example ( Pitch=-1)

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

Notice thee orientation change of the left and right faces.

Scoring
Instead of the normal code scoring rules of the lowest number of non-whitespace characters.
This challenge will be judges by the number of lines in your Die and it supporting codes (excluding the framework of course).

Entrants

• Winner will be the entry with the lowest score be the Start of next Month ( April 2012).
  
• SourceCode must be in spoilered code tags.
  
  Spoiler

  
  

  
  
  
  
• If you like you can include a Zip-File of the project / executable.
  
• vb.net solutions (are the preferred programming language)

Now go have some fun thinking and coding you entry.

This post has been edited by AdamSpeight2008: 08 March 2012 - 06:42 AM

[AdamSpeight2008]

I'll kick of the entries with my non-optimal 187 lines.

Note: Write to use .net 3.5 Client Profile

Spoiler

Public Class Die
  Private _B, _L, _T, _R, _F, _P As DieFace
  Private Sub New(B As DieFace, L As DieFace, T As DieFace, R As DieFace, F As DieFace, P As DieFace)
    _B = B : _L = L : _T = T : _R = R : _F = F : _P = P
  End Sub
  Public ReadOnly Property B As DieFace
    Get
      Return _B
    End Get
  End Property
  Public ReadOnly Property L As DieFace
    Get
      Return _L
    End Get
  End Property
  Public ReadOnly Property T As DieFace
    Get
      Return _T
    End Get
  End Property
  Public ReadOnly Property R As DieFace
    Get
      Return _R
    End Get
  End Property
  Public ReadOnly Property F As DieFace
    Get
      Return _F
    End Get
  End Property
  Public ReadOnly Property P As DieFace
    Get
      Return _P
    End Get
  End Property
  Public ReadOnly Property Value As Integer
    Get
      Return _T.Value
    End Get
  End Property
  Public Function Pitch_F(ByVal d As Die) As Die
    Return New Die(d.T, d.L.RotateAC(), d.F, d.R.RotateCW(), d.P, d.B)/>
  End Function
  Public Function Pitch_B(ByVal d As Die) As Die
    Return New Die(d.P, d.L.RotateCW(), d.B, d.R.RotateAC(), d.T, d.F)
  End Function
  Public Function Roll_L(ByVal d As Die) As Die
    Return New Die(d.B.RotateCW(), d.T, d.R, d.P, d.F.RotateAC(), d.L)
  End Function
  Public Function Roll_R(ByVal d As Die) As Die
    Return New Die(d.B.RotateAC(), d.P, d.L, d.T, d.F.RotateAC(), d.R)
  End Function
  Public Function Yaw_CW(ByVal d As Die) As Die
    Return New Die(d.L, d.F, d.T.RotateCW(), d.B, d.R, d.P.RotateAC())
  End Function
  Public Function Yaw_AC(ByVal d As Die) As Die
    Return New Die(d.R, d.B, d.T.RotateAC(), d.F, d.L, d.P.RotateCW())
  End Function
  Public Shared Function CreateNew() As Die
    Return New Die(DieFace.GetDieFace(2), DieFace.GetDieFace(4), DieFace.GetDieFace(1), DieFace.GetDieFace(3), DieFace.GetDieFace(5), DieFace.GetDieFace(6))
  End Function
  Public Function Pitchs(ByVal times As Integer) As Die
    Dim cd As Die = Me
    Dim p = Math.Abs(times) Mod 4
    If times = 0 Then
      Return New Die(Me.B, Me.L, Me.T, Me.R, Me.F, Me.P)
    ElseIf times < 0 Then
      For i = 1 To p
        cd = Pitch_F(cd)
      Next
    Else
      For i = 1 To p
        cd = Pitch_B(cd)
      Next
    End If
    Return cd
  End Function
  Public Function Rolls(ByVal times As Integer) As Die
    Dim cd As Die = Me
    Dim p = Math.Abs(times) Mod 4
    If times = 0 Then
      cd = New Die(Me.B, Me.L, Me.T, Me.R, Me.F, Me.P)
    ElseIf times < 0 Then
      For i = 1 To p
        cd = Roll_L(cd)
      Next
    Else
      For i = 1 To p
        cd = Roll_R(cd)
      Next
    End If
    Return cd
  End Function
  Public Function Yaws(ByVal times As Integer) As Die
    Dim cd As Die = Me
    Dim p = Math.Abs(times) Mod 4
    If times = 0 Then
      cd = New Die(Me.B, Me.L, Me.T, Me.R, Me.F, Me.P)
    ElseIf times < 0 Then
      For i = 1 To p
        cd = Yaw_AC(cd)
      Next
    Else
      For i = 1 To p
        cd = Yaw_CW(cd)
      Next
    End If
    Return cd
  End Function
  Public Shared Function PRY(ByVal d As Die, pitches As Integer, rolls As Integer, yaws As Integer) As Die
    Return d.Pitchs(pitches).Rolls(rolls).Yaws(yaws)
  End Function
  Private Function TriChar(bs() As Boolean) As String
    Return bs.Aggregate(Of String)("", Function(p, c) p & If(c, "O", " "))
  End Function
  Public Overrides Function ToString() As String
    Return _
<die>
    +---+
    |<%= TriChar(B.Dots(0)) %>|
    |<%= TriChar(B.Dots(1)) %>|
    |<%= TriChar(B.Dots(2)) %>|
+---+---+---+
|<%= TriChar(L.Dots(0)) %>|<%= TriChar(T.Dots(0)) %>|<%= TriChar(R.Dots(0)) %>|
|<%= TriChar(L.Dots(1)) %>|<%= TriChar(T.Dots(1)) %>|<%= TriChar(R.Dots(1)) %>|
|<%= TriChar(L.Dots(2)) %>|<%= TriChar(T.Dots(2)) %>|<%= TriChar(R.Dots(2)) %>|
+---+---+---+
    |<%= TriChar(F.Dots(0)) %>|
    |<%= TriChar(F.Dots(1)) %>|
    |<%= TriChar(F.Dots(2)) %>|
    +---+
    |<%= TriChar(P.Dots(0)) %>|
    |<%= TriChar(P.Dots(1)) %>|
    |<%= TriChar(P.Dots(2)) %>|
    +---+
</die>.Value
  End Function
  Public Class DieFace
    Private _Dots()() As Boolean = {({False, False, False}), ({False, False, False}), ({False, False, False})}
    Private _Value As Integer
    Public ReadOnly Property Value As Integer
      Get
        Return _Value
      End Get
    End Property
    Public Function Dots() As Boolean()()
      Return _Dots.ToArray()
    End Function
    Private Sub New(ByVal value As Integer, ByVal DotPattern()() As Boolean)
      _Value = value
      For x = 0 To 2
        For y = 0 To 2
          _Dots(y)(x) = DotPattern(y)(x)
        Next
      Next
    End Sub
    Public Function RotateAC() As DieFace
      Dim P()() As Boolean = {({False, False, False}), ({False, False, False}), ({False, False, False})}
      For x = 0 To 2
        For y = 0 To 2
          P(x)(y) = Me._Dots(y)(2 - x)
        Next
      Next
      Return New DieFace(Me.Value, P)
    End Function
    Public Function RotateCW() As DieFace
      Dim P()() As Boolean = {({False, False, False}), ({False, False, False}), ({False, False, False})}
      For x = 0 To 2
        For y = 0 To 2
          P(x)(y) = Me._Dots(2 - y)(x)
        Next
      Next
      Return New DieFace(Me.Value, P)
    End Function
    Public Shared Function GetDieFace(ByVal Value As Integer) As DieFace
      Select Case Value
        Case 1 : Return New DieFace(Value, {({False, False, False}), ({False, True, False}), ({False, False, False})})
        Case 2 : Return New DieFace(Value, {({True, False, False}), ({False, False, False}), ({False, False, True})})
        Case 3 : Return New DieFace(Value, {({True, False, False}), ({False, True, False}), ({False, False, True})})
        Case 4 : Return New DieFace(Value, {({True, False, True}), ({False, False, False}), ({True, False, True})})
        Case 5 : Return New DieFace(Value, {({True, False, True}), ({False, True, False}), ({True, False, True})})
        Case 6 : Return New DieFace(Value, {({True, False, True}), ({True, False, True}), ({True, False, True})})
        Case Else : Throw New ArgumentOutOfRangeException("Value", "0 < Value <= 6")
      End Select
    End Function
  End Class
End Class

An example of it in use.

Module Module1
  Private rnd As New Random
  Public Function GetRND() As Integer
    Return rnd.Next(Integer.MinValue, Integer.MaxValue)
  End Function
    Sub Main()
    Dim d = Die.CreateNew()
    Console.WriteLine(d)
    Console.WriteLine()
    Dim R = Die.PRY(d, GetRND, GetRND, GetRND)
    Console.WriteLine(R)
    Console.WriteLine("Value:= {0}", R.Value)
    Console.Read()
    End Sub

End Module

This post has been edited by AdamSpeight2008: 04 March 2012 - 09:25 PM

[cfoley]

Here is my entry:

Spoiler

Imports System.Text

Public Class Die
    Dim b, l, t, r, f, p As Face

    Public ReadOnly Property value As Integer
        Get
            Return t.D.Replace(" ", "").Length
        End Get
    End Property

    Public Sub New()
        b = New Face("O       O", "  O   O  ")
        l = New Face("O O   O O", "O O   O O")
        t = New Face("    O    ", "    O    ")
        r = New Face("O   O   O", "  O O O  ")
        f = New Face("O O O O O", "O O O O O")
        p = New Face("OOO   OOO", "O OO OO O")
    End Sub

    Public Sub New(ByVal D As Die, ByVal pit As Integer, ByVal rol As Integer, ByVal yaw As Integer)
        b = New Face(D.B)/>
        l = New Face(D.l)
        t = New Face(D.t)
        r = New Face(D.r)
        f = New Face(D.f)
        p = New Face(D.p)
        spin(pit, l, r, p, f, t, B)/>
        spin(rol, f, b, r, t, l, p)
        spin(yaw, t, p, b, l, f, r)
    End Sub

    Private Sub spin(ByVal n As Integer, ByVal top As Face, ByVal bot As Face, ByVal a As Face, ByVal b As Face, ByVal c As Face, ByVal d As Face)
        If n Mod 2 <> 0 Then
            top.flip()
            bot.flip()
        End If
        Dim face() = {a, b, c, d}
        Dim shiftD() = {a.D, b.D, c.D, d.D}
        Dim shiftX() = {a.X, b.X, c.X, d.X}
        For i = 0 To 3
            Dim s = (n + i) Mod 4
            If s < 0 Then s += 4
            face(i).D = shiftD(s)
            face(i).X = shiftX(s)
        Next
    End Sub

    Public Shared Function PRY(ByVal dieToUse As Die,
                 ByVal pitches As Integer,
                 ByVal rolls As Integer,
                 ByVal yaws As Integer) As Die
        Return New Die(dieToUse, pitches, rolls, yaws)
    End Function


    Public Overrides Function ToString() As String
        Dim lines(16) As StringBuilder
        For n = 0 To 16
            lines(n) = New StringBuilder("    +---+")
        Next
        For Each n In {4, 5, 6, 7, 8}
            lines(n).Clear.Append("+---+---+---+")
        Next
        For Each n In {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15}
            lines(n) = lines(n).Replace("+", "|")
        Next

        b.print(lines, 6, 2)
        l.print(lines, 2, 6)
        t.print(lines, 6, 6)
        r.print(lines, 10, 6)
        f.print(lines, 6, 10)
        p.print(lines, 6, 14)

        Dim result = New StringBuilder
        For Each ll In lines
            result.AppendLine(ll.ToString)
        Next
        Return result.ToString
    End Function

    Class Face
        Public D, X As String

        Sub New(ByVal a As String, ByVal b As String)
            D = a
            X = b
        End Sub

        Sub New(ByVal f As Face)
            D = f.D
            X = f.X
        End Sub

        Sub flip()
            Dim t = D
            D = X
            X = t
        End Sub

        Sub print(ByVal arr As StringBuilder(), ByVal x As Integer, ByVal y As Integer)
            Dim i = 0
            For dx = -1 To 1
                For dy = -1 To 1
                    arr(y + dy)(x + dx) = D(i)
                    i += 1
                Next
            Next
        End Sub

    End Class

End Class

It could have less characters. All my symbols could be one character long and I could do away with data types, etc. But I think I'll leave it at this.

Also, why is the PRY function shared? You are passing in a single instance of Die to act on. It would make more sense to make it an instance method.

[AdamSpeight2008]

Quote

Also, why is the PRY function shared?

My Challenge, my rules.

A really compact 44 Liner.

Spoiler

Public Class Die
  Private B, L, T, R, F, P As DieFace
  Private Tri As Func(Of Boolean(), String) = Function(r As Boolean()) String.Format("{0}{1}{2}", If(r(0), "*"c, " "c), If(r(1), "*"c, " "c), If(r(2), "*"c, " "c))
  Private Spin() As Func(Of Integer, Die) = {Function(times As Integer) PivotFN(times, Function(cd) cd.Spin(3)(times)), Function(times As Integer) PivotFN(times, Function(cd) cd.Spin(4)(times)), Function(times As Integer) PivotFN(times, Function(cd) cd.Spin(5)(times)), Function(dir As Integer) If(dir < 0, New Die(T, L.Turn(-1), F, R.Turn(+1), P, B)/>, New Die(P, L.Turn(+1), B, R.Turn(-1), T, F)), Function(dir As Integer) If(dir < 0, New Die(B.Turn(+1), T, R, P, F.Turn(-1), L), New Die(B.Turn(-1), P, L, T, F.Turn(+1), R)), Function(dir As Integer) If(dir < 0, New Die(R, B, T.Turn(-1), F, L, P.Turn(+1)), New Die(L, F, T.Turn(+1), B, R, P.Turn(-1)))}
  Private PivotFN As Func(Of Integer, Func(Of Die, Die), Die) = Function(times As Integer, act As Func(Of Die, Die)) If(times = 0, New Die(B, L, T, R, F, P), ApplyTo(Me, Math.Abs(times) Mod 4, act))
  Public Shared Function GetNew()
    Return New Die(DieFace.GetFace(2), DieFace.GetFace(4), DieFace.GetFace(1), DieFace.GetFace(3), DieFace.GetFace(5), DieFace.GetFace(6))
  End Function
  Private Sub New(B As DieFace, L As DieFace, T As DieFace, R As DieFace, F As DieFace, P As DieFace)
    Me.B = B : Me.L = L : Me.T = T : Me.R = R : Me.F = F : Me.P = P
  End Sub
  Public Overrides Function ToString() As String
    Return <dice>    +---+<%= Environment.NewLine %>    |<%= Tri(B.Dots(0)) %>|<%= Environment.NewLine %>    |<%= Tri(B.Dots(1)) %>|<%= Environment.NewLine %>    |<%= Tri(B.Dots(2)) %>|<%= Environment.NewLine %>+---+---+---+<%= Environment.NewLine %>|<%= Tri(L.Dots(0)) %>|<%= Tri(T.Dots(0)) %>|<%= Tri(R.Dots(0)) %>|<%= Environment.NewLine %>|<%= Tri(L.Dots(1)) %>|<%= Tri(T.Dots(1)) %>|<%= Tri(R.Dots(1)) %>|<%= Environment.NewLine %>|<%= Tri(L.Dots(2)) %>|<%= Tri(T.Dots(2)) %>|<%= Tri(R.Dots(2)) %>|<%= Environment.NewLine %>+---+---+---+<%= Environment.NewLine %>    |<%= Tri(F.Dots(0)) %>|<%= Environment.NewLine %>    |<%= Tri(F.Dots(1)) %>|<%= Environment.NewLine %>    |<%= Tri(F.Dots(2)) %>|<%= Environment.NewLine %>    +---+<%= Environment.NewLine %>    |<%= Tri(P.Dots(0)) %>|<%= Environment.NewLine %>    |<%= Tri(P.Dots(1)) %>|<%= Environment.NewLine %>    |<%= Tri(P.Dots(2)) %>|<%= Environment.NewLine %>    +---+<%= Environment.NewLine %></dice>.Value
  End Function
  Private Function ApplyTo(thisdie As Die, times As Integer, what As Func(Of Die, Die))
    Return If(times = 0, thisdie, ApplyTo(what(thisdie), times - 1, what))
  End Function
  Public Shared Function PRY(onDie As Die, pitches As Integer, rolls As Integer, yaws As Integer)
    Return onDie.Spin(0)(pitches).Spin(1)(rolls).Spin(2)(yaws)
  End Function
  Public Class DieFace
    Private _D()() As Boolean : Private _value As Integer
    Private Sub New(dots()() As Boolean, value As Integer)
      _D = dots : _value = value
    End Sub
    Public ReadOnly Property Value As Integer
      Get
        Return _value
      End Get
    End Property
    Public Function Dots(row) As Boolean()
      Return _D(row)
    End Function
    Public Function Turn(dir As Integer) As DieFace
      Return If(dir >= 0, New DieFace({({_D(2)(0), _D(1)(0), _D(0)(0)}), ({_D(2)(1), _D(1)(1), _D(0)(1)}), ({_D(2)(2), _D(1)(2), _D(0)(2)})}, Value), New DieFace({({_D(0)(2), _D(1)(2), _D(2)(2)}), ({_D(0)(1), _D(1)(1), _D(2)(1)}), ({_D(0)(0), _D(1)(0), _D(2)(0)})}, Value))
    End Function
    Public Shared Function GetFace(Value As Integer) As DieFace
      Select Case Value
        Case 1, 2, 3, 4, 5, 6 : Return New DieFace({({Value > 1, False, Value > 3}), ({Value = 6, (Value Mod 2) = 1, Value = 6}), ({Value > 3, False, Value > 1})}, Value)
        Case Else : Return Nothing
      End Select
    End Function
  End Class
End Class

This post has been edited by AdamSpeight2008: 07 March 2012 - 08:12 PM

[cfoley]

Are we going by number of lines now? This one has 36 (30 if you take out the blank lines). I'm pretty pleased with the line count because there are only 24 possible orientations for the dice. Not the nicest code I've ever written, but that wasn't the point of the challenge.

I'm also sure you could use some of your VB magic and reduce my line count even further. My method lst() can probably go, but I couldn't work out how to create a list and call a method on it in one line.

Spoiler

Public Class D6
    Dim b, l, t, r, f, p

    Public ReadOnly Property value As Integer
        Get
            Return t.Replace(" ", "").Length / 2
        End Get
    End Property

    Public Sub New(Optional ByVal bb = "O       O  O   O  ", Optional ByVal ll = "O O   O OO O   O O", Optional ByVal tt = "    O        O    ", Optional ByVal rr = "O   O   O  O O O  ", Optional ByVal ff = "O O O O OO O O O O", Optional ByVal pp = "OOO   OOOO OO OO O")
        b = bb : l = ll : t = tt : r = rr : f = ff : p = pp
    End Sub

    Public Shared Function PRY(ByVal D As D6, ByVal pit As Integer, ByVal rol As Integer, ByVal yaw As Integer) As D6
        Dim pos = Function(x) x + (4 * x * (x < 0)), rev = Function(x) StrReverse(x)
        If pos(pit) > 0 Then Return PRY(New D6(D.p, rev(D.l), D.b, rev(D.r), D.t, D.f), pos(pit) - 1, pos(rol), pos(yaw))
        If pos(rol) > 0 Then Return PRY(New D6(rev(D.B)/>, D.p, D.l, D.t, rev(D.f), D.r), 0, pos(rol) - 1, pos(yaw))
        If pos(yaw) > 0 Then Return PRY(New D6(D.l, D.f, rev(D.t), D.b, D.r, rev(D.p)), 0, 0, pos(yaw) - 1)
        Return D
    End Function

    Public Overrides Function ToString() As String
        Dim lines(17)() As Char
        Dim dx = {0, 0, 0, 1, 1, 1, 2, 2, 2}, dy = {0, 1, 2, 0, 1, 2, 0, 1, 2}
        lst(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16).ForEach(New Action(Of Integer)(Sub(x) lines(x) = "    |---|"))
        lst(4, 5, 6, 7, 8).ForEach(New Action(Of Integer)(Sub(x) lines(x) = "|---|---|---|"))
        lst(0, 4, 8, 12, 16).ForEach(New Action(Of Integer)(Sub(x) lines(x) = New String(lines(x)).Replace("|", "+")))
        lst(0, 1, 2, 3, 4, 5).ForEach(New Action(Of Integer)(Sub(i) lst(0, 1, 2, 3, 4, 5, 6, 7, 8).ForEach(New Action(Of Integer)(Sub(j) lines(lst(1, 5, 5, 5, 9, 13)(i) + dy(j))(lst(5, 1, 5, 9, 5, 5)(i) + dx(j)) = lst(b, l, t, r, f, p)(i)(j)))))
        Return lines.Aggregate(Function(acc, line) acc & vbNewLine & New String(line))
    End Function

    Function lst(Of T)(ByVal ParamArray items() As T) As List(Of T)
        Return New List(Of T)(items)
    End Function

End Class

[AdamSpeight2008]

cfoley: Didn't you read the scoring rules in the first post?

First sub 30 Lines. (My head hurts, cos it has been a pain to debug.)

Spoiler

26 Lines.

Public Class Die
  Protected Friend _F As List(Of Tuple(Of Integer, Boolean, String, String))
  Public Sub New()
    Me.New({New Tuple(Of Integer, Boolean, String, String)(2, False, "|*  ||   ||  *|", "|  *||   ||*  |"), New Tuple(Of Integer, Boolean, String, String)(4, False, "|* *||   ||* *|", "|* *||   ||* *|"), New Tuple(Of Integer, Boolean, String, String)(1, False, "|   || * ||   |", "|   || * ||   |"), New Tuple(Of Integer, Boolean, String, String)(3, False, "|*  || * ||  *|", "|  *|| * ||*  |"), New Tuple(Of Integer, Boolean, String, String)(5, False, "|* *|| * ||* *|", "|* *|| * ||* *|"), New Tuple(Of Integer, Boolean, String, String)(6, False, "|* *||* *||* *|", "|***||   ||***|")})
  End Sub
  Private Sub New(f As IEnumerable(Of Tuple(Of Integer, Boolean, String, String)))
    _F = New List(Of Tuple(Of Integer, Boolean, String, String))(f)
  End Sub
  Public Shared Function PRY(dd As Die, Pitchs As Integer, Rolls As Integer, Yaws As Integer) As Die
    Dim pfn = Function(d As Die, p As Integer) New Die(Choose(Math.Sign(p) + 2, {d._F(2), New Tuple(Of Integer, Boolean, String, String)(d._F(1).Item1, Not d._F(1).Item2, d._F(1).Item3, d._F(1).Item4), d._F(4), New Tuple(Of Integer, Boolean, String, String)(d._F(3).Item1, Not d._F(3).Item2, d._F(3).Item3, d._F(3).Item4), d._F(5), d._F(0)}, {d._F(0), d._F(1), d._F(2), d._F(3), d._F(4), d._F(5)}, {d._F(5), New Tuple(Of Integer, Boolean, String, String)(d._F(1).Item1, Not d._F(1).Item2, d._F(1).Item3, d._F(1).Item4), d._F(0), New Tuple(Of Integer, Boolean, String, String)(d._F(3).Item1, Not d._F(3).Item2, d._F(3).Item3, d._F(3).Item4), d._F(2), d._F(4)}))
    Dim rfn = Function(d As Die, p As Integer) New Die(Choose(Math.Sign(p) + 2, {New Tuple(Of Integer, Boolean, String, String)(d._F(0).Item1, Not d._F(0).Item2, d._F(0).Item3, d._F(0).Item4), d._F(2), d._F(3), d._F(5), New Tuple(Of Integer, Boolean, String, String)(d._F(4).Item1, Not d._F(4).Item2, d._F(4).Item3, d._F(4).Item4), d._F(1)}, {d._F(0), d._F(1), d._F(2), d._F(3), d._F(4), d._F(5)}, {New Tuple(Of Integer, Boolean, String, String)(d._F(0).Item1, Not d._F(0).Item2, d._F(0).Item3, d._F(0).Item4), d._F(5), d._F(1), d._F(2), New Tuple(Of Integer, Boolean, String, String)(d._F(4).Item1, Not d._F(4).Item2, d._F(4).Item3, d._F(4).Item4), d._F(5)}))
    Dim yfn = Function(d As Die, p As Integer) New Die(Choose(Math.Sign(p) + 2, {d._F(3), d._F(0), New Tuple(Of Integer, Boolean, String, String)(d._F(2).Item1, Not d._F(2).Item2, d._F(2).Item3, d._F(2).Item4), d._F(4), d._F(1), New Tuple(Of Integer, Boolean, String, String)(d._F(5).Item1, Not d._F(5).Item2, d._F(5).Item3, d._F(5).Item4)}, {d._F(0), d._F(1), d._F(2), d._F(3), d._F(4), d._F(5)}, {d._F(1), d._F(4), New Tuple(Of Integer, Boolean, String, String)(d._F(2).Item1, Not d._F(2).Item2, d._F(2).Item3, d._F(2).Item4), d._F(0), d._F(3), New Tuple(Of Integer, Boolean, String, String)(d._F(5).Item1, Not d._F(5).Item2, d._F(5).Item3, d._F(5).Item4)}))
    Dim rep = Function(d As Die, reps As Integer, fn As Func(Of Die, Integer, Die)) As Die
                reps = reps Mod 4 : While reps <> 0 : d = fn(d, reps) : reps -= Math.Sign(reps) : End While : Return d
              End Function
    Return rep(rep(rep(dd, Pitchs, pfn), Rolls, rfn), Yaws, yfn)
  End Function
  Public ReadOnly Property Value As Integer
    Get
      Return _F(2).Item1
    End Get
  End Property
  Public Overrides Function ToString() As String
    Return <die>!4+---+!4<%= If(_F(0).Item2, _F(0).Item4, _F(0).Item3).Substring(0, 5) %>!4<%= If(_F(0).Item2, _F(0).Item4, _F(0).Item3).Substring(5, 5) %>!4<%= If(_F(0).Item2, _F(0).Item4, _F(0).Item3).Substring(10, 5) %>!+---+---+---+!<%= If(_F(1).Item2, _F(1).Item4, _F(1).Item3).Substring(0, 5) %><%= If(_F(2).Item2, _F(2).Item4, _F(2).Item3).Substring(1, 4) %><%= If(_F(3).Item2, _F(3).Item4, _F(3).Item3).Substring(1, 4) %>!<%= If(_F(1).Item2, _F(1).Item4, _F(1).Item3).Substring(5, 5) %><%= If(_F(2).Item2, _F(2).Item4, _F(2).Item3).Substring(6, 4) %><%= If(_F(3).Item2, _F(3).Item4, _F(3).Item3).Substring(6, 4) %>!<%= If(_F(1).Item2, _F(1).Item4, _F(1).Item3).Substring(10, 5) %><%= If(_F(2).Item2, _F(2).Item4, _F(2).Item3).Substring(11, 4) %><%= If(_F(3).Item2, _F(3).Item4, _F(3).Item3).Substring(11, 4) %>!+---+---+---+!4<%= If(_F(4).Item2, _F(4).Item4, _F(4).Item3).Substring(0, 5) %>!4<%= If(_F(4).Item2, _F(4).Item4, _F(4).Item3).Substring(5, 5) %>!4<%= If(_F(4).Item2, _F(4).Item4, _F(4).Item3).Substring(10, 5) %>!4+---+!4<%= If(_F(5).Item2, _F(5).Item4, _F(5).Item3).Substring(0, 5) %>!4<%= If(_F(5).Item2, _F(5).Item4, _F(5).Item3).Substring(5, 5) %>!4<%= If(_F(5).Item2, _F(5).Item4, _F(5).Item3).Substring(10, 5) %>!4+---+</die>.Value.Replace("4", "    ").Replace("!", Environment.NewLine)
  End Function
End Class

This post has been edited by AdamSpeight2008: 07 March 2012 - 08:45 PM

[cfoley]

Yes, I read them but you are posting line count instead of character count with your code. And in particular:

Me.B = B : Me.L = L : Me.T = T : Me.R = R : Me.F = F : Me.P = P

This is more characters than simply having 6 lines, which led me to believe you were driving for lines rather than characters.

My question about the shared method was a serious one. I would consider it an antipattern as far as OO goes, but I know your style is more functional than mine (probably because I use Java so much). I was wondering if there were some functional delights I was missing out on, or if there was something else about the language that makes it a good idea.

[AdamSpeight2008]

Quote

My question about the shared method was a serious one.

I'm not a big fan of having publicly accessible constructors, for your objects.
I prefer having a public shared creator function.

Shared Public Function CreateNew(arg_0 ... arg_N) As T
' Arg checking
' If an arg is a error then throw some exception type.
End Function

As throwing exceptions in a constructor is a big no-no for me.

Yeah, it could easily be an instance method.
I'm off the idea;-
Does the method manipulate some of internal state.
No then make it shared and pass in an instance.
Think how instance methods does Enumerable have?
I think it makes the instance of an Object have a smaller memory footprint.

Quote

I was wondering if there were some functional delights I was missing out on, or if there was something else about the language that makes it a good idea.

You not side effecting objects, since you can only deal with the parameter arguments passed in.

[modi123_1]

Bah.. I got it down to 37 lines of code I am mostly not annoyed by looking at nor too embarassed by.

Spoiler

Public Class Die
    Private _Sides = {{{" ", " ", " "}, {" ", "O", " "}, {" ", " ", " "}}, {{"O", " ", " "}, {" ", " ", " "}, {" ", " ", "O"}}, {{"O", " ", " "}, {" ", "O", " "}, {" ", " ", "O"}}, {{"O", " ", "O"}, {" ", " ", " "}, {"O", " ", "O"}}, {{"O", " ", "O"}, {" ", "O", " "}, {"O", " ", "O"}}, {{"O", " ", "O"}, {"O", " ", "O"}, {"O", " ", "O"}}}
    Private lFaceOrder() As Int32 = {1, 3, 0, 2, 4, 5}
    Dim directionOrder() = {({2, 4, 5, 0}), ({0, 5, 4, 2}), ({2, 3, 5, 1}), ({1, 5, 3, 2}), ({0, 1, 4, 3}), ({3, 4, 1, 0})} '-- pf, pb, rl, rr, yc, ycc
    Public ReadOnly Property Value As Integer
        Get
            Return lFaceOrder(2)
        End Get
    End Property
    Public Shared Function PRY(dieToUse As Die, pitches As Integer, rolls As Integer, yaws As Integer) As Die
        dieToUse.DoAll(1, Math.Abs(pitches), pitches < 0)
        dieToUse.DoAll(2, Math.Abs(rolls), rolls < 0)
        dieToUse.DoAll(3, Math.Abs(yaws), yaws < 0)
        Return dieToUse
    End Function
    Private Sub DoAll(ByVal type As Int32, ByVal times As Int32, ByVal isNeg As Boolean)
        If times > 0 Then
            Select Case type
                Case 1 : If isNeg Then Awesome(directionOrder(0)) Else Awesome(directionOrder(1))
                Case 2 : If isNeg Then Awesome(directionOrder(2)) Else Awesome(directionOrder(3))
                Case 3 : If isNeg Then Awesome(directionOrder(4)) Else Awesome(directionOrder(5))
            End Select
            times -= 1
            DoAll(type, times, isNeg)
        End If
    End Sub
    Private Sub Awesome(ByVal moveOrder() As Int32)
        Dim lValue As Int32 = lFaceOrder(moveOrder(0))
        lFaceOrder(moveOrder(0)) = lFaceOrder(moveOrder(1))
        lFaceOrder(moveOrder(1)) = lFaceOrder(moveOrder(2))
        lFaceOrder(moveOrder(2)) = lFaceOrder(moveOrder(3))
        lFaceOrder(moveOrder(3)) = lValue
    End Sub
    Public Overrides Function ToString() As String       
        Return String.Format("    +---+" + Environment.NewLine + "    |{0}{1}{2}|{3}    |{4}{5}{6}|{7}    |{8}{9}{10}|{11}+---+---+---+{12}|{13}{14}{15}|{16}{17}{18}|{19}{20}{21}|{22}|{23}{24}{25}|{26}{27}{28}|{29}{30}{31}|{32}|{33}{34}{35}|{36}{37}{38}|{39}{40}{41}|{42}+---+---+---+{43}    |{44}{45}{46}|{47}    |{48}{49}{50}|{51}    |{52}{53}{54}|{55}    +---+{56}    |{57}{58}{59}|{60}    |{61}{62}{63}|{64}    |{65}{66}{67}|{68}    +---+{69}", _Sides(lFaceOrder(0), 0, 0), _Sides(lFaceOrder(0), 0, 1), _Sides(lFaceOrder(0), 0, 2), Environment.NewLine, _Sides(lFaceOrder(0), 1, 0), _Sides(lFaceOrder(0), 1, 1), _Sides(lFaceOrder(0), 1, 2), Environment.NewLine, _Sides(lFaceOrder(0), 2, 0), _Sides(lFaceOrder(0), 2, 1), _Sides(lFaceOrder(0), 2, 2), Environment.NewLine, Environment.NewLine, _Sides(lFaceOrder(1), 0, 0), _Sides(lFaceOrder(1), 0, 1), _Sides(lFaceOrder(1), 0, 2), _Sides(lFaceOrder(2), 0, 0), _Sides(lFaceOrder(2), 0, 1), _Sides(lFaceOrder(2), 0, 2), _Sides(lFaceOrder(3), 0, 0), _Sides(lFaceOrder(3), 0, 1), _Sides(lFaceOrder(3), 0, 2), Environment.NewLine, _Sides(lFaceOrder(1), 1, 0), _Sides(lFaceOrder(1), 1, 1), _Sides(lFaceOrder(1), 1, 2), _Sides(lFaceOrder(2), 1, 0), _Sides(lFaceOrder(2), 1, 1), _Sides(lFaceOrder(2), 1, 2), _Sides(lFaceOrder(3), 1, 0), _Sides(lFaceOrder(3), 1, 1), _Sides(lFaceOrder(3), 1, 2), Environment.NewLine, _Sides(lFaceOrder(1), 2, 0), _Sides(lFaceOrder(1), 2, 1), _Sides(lFaceOrder(1), 2, 2), _Sides(lFaceOrder(2), 2, 0), _Sides(lFaceOrder(2), 2, 1), _Sides(lFaceOrder(2), 2, 2), _Sides(lFaceOrder(3), 2, 0), _Sides(lFaceOrder(3), 2, 1), _Sides(lFaceOrder(3), 2, 2), Environment.NewLine, Environment.NewLine, _Sides(lFaceOrder(4), 0, 0), _Sides(lFaceOrder(4), 0, 1), _Sides(lFaceOrder(4), 0, 2), Environment.NewLine, _Sides(lFaceOrder(4), 1, 0), _Sides(lFaceOrder(4), 1, 1), _Sides(lFaceOrder(4), 1, 2), Environment.NewLine, _Sides(lFaceOrder(4), 2, 0), _Sides(lFaceOrder(4), 2, 1), _Sides(lFaceOrder(4), 2, 2), Environment.NewLine, Environment.NewLine, _Sides(lFaceOrder(5), 0, 0), _Sides(lFaceOrder(5), 0, 1), _Sides(lFaceOrder(5), 0, 2), Environment.NewLine, _Sides(lFaceOrder(5), 1, 0), _Sides(lFaceOrder(5), 1, 1), _Sides(lFaceOrder(5), 1, 2), Environment.NewLine, _Sides(lFaceOrder(5), 2, 0), _Sides(lFaceOrder(5), 2, 1), _Sides(lFaceOrder(5), 2, 2), Environment.NewLine, Environment.NewLine)
    End Function
End Class

general usage:

        Dim foo As New Die
        Console.WriteLine(foo.ToString)
        Console.WriteLine(" ")
        foo = Die.PRY(foo, -1, 0, 0)
        Console.WriteLine(foo.ToString)
        Console.WriteLine(" ")

This post has been edited by AdamSpeight2008: 09 March 2012 - 07:49 AM
Reason for edit:: name change on tostring (Adam: Added Overrides Keyword)

[AdamSpeight2008]

Managed to squeeze out another 5 lines of code.

Spoiler

21 Lines .

Public Class Die
  Protected Friend _F As List(Of Tuple(Of Integer, Boolean, String, String))
  Public Sub New()
    Me.New({New Tuple(Of Integer, Boolean, String, String)(2, False, "|*  ||   ||  *|", "|  *||   ||*  |"), New Tuple(Of Integer, Boolean, String, String)(4, False, "|* *||   ||* *|", "|* *||   ||* *|"), New Tuple(Of Integer, Boolean, String, String)(1, False, "|   || * ||   |", "|   || * ||   |"), New Tuple(Of Integer, Boolean, String, String)(3, False, "|*  || * ||  *|", "|  *|| * ||*  |"), New Tuple(Of Integer, Boolean, String, String)(5, False, "|* *|| * ||* *|", "|* *|| * ||* *|"), New Tuple(Of Integer, Boolean, String, String)(6, False, "|* *||* *||* *|", "|***||   ||***|")})
  End Sub
  Private Sub New(f As IEnumerable(Of Tuple(Of Integer, Boolean, String, String)))
    _F = New List(Of Tuple(Of Integer, Boolean, String, String))(f)
  End Sub
  Public Shared Function PRY(dd As Die, Pitchs As Integer, Rolls As Integer, Yaws As Integer) As Die
    Dim rep As Func(Of Die, Integer, Func(Of Die, Integer, Die), Die) = Function(d As Die, reps As Integer, fn As Func(Of Die, Integer, Die)) If((reps Mod 4) = 0, d, rep(fn(d, reps Mod 4), ((reps Mod 4) - Math.Sign(reps)), fn))
    Return rep(rep(rep(dd, Pitchs, (Function(d As Die, p As Integer) New Die(Choose(Math.Sign(p) + 2, {d._F(2), New Tuple(Of Integer, Boolean, String, String)(d._F(1).Item1, Not d._F(1).Item2, d._F(1).Item3, d._F(1).Item4), d._F(4), New Tuple(Of Integer, Boolean, String, String)(d._F(3).Item1, Not d._F(3).Item2, d._F(3).Item3, d._F(3).Item4), d._F(5), d._F(0)}, {d._F(0), d._F(1), d._F(2), d._F(3), d._F(4), d._F(5)}, {d._F(5), New Tuple(Of Integer, Boolean, String, String)(d._F(1).Item1, Not d._F(1).Item2, d._F(1).Item3, d._F(1).Item4), d._F(0), New Tuple(Of Integer, Boolean, String, String)(d._F(3).Item1, Not d._F(3).Item2, d._F(3).Item3, d._F(3).Item4), d._F(2), d._F(4)})))), Rolls, (Function(d As Die, p As Integer) New Die(Choose(Math.Sign(p) + 2, {New Tuple(Of Integer, Boolean, String, String)(d._F(0).Item1, Not d._F(0).Item2, d._F(0).Item3, d._F(0).Item4), d._F(2), d._F(3), d._F(5), New Tuple(Of Integer, Boolean, String, String)(d._F(4).Item1, Not d._F(4).Item2, d._F(4).Item3, d._F(4).Item4), d._F(1)}, {d._F(0), d._F(1), d._F(2), d._F(3), d._F(4), d._F(5)}, {New Tuple(Of Integer, Boolean, String, String)(d._F(0).Item1, Not d._F(0).Item2, d._F(0).Item3, d._F(0).Item4), d._F(5), d._F(1), d._F(2), New Tuple(Of Integer, Boolean, String, String)(d._F(4).Item1, Not d._F(4).Item2, d._F(4).Item3, d._F(4).Item4), d._F(5)})))), Yaws, (Function(d As Die, p As Integer) New Die(Choose(Math.Sign(p) + 2, {d._F(3), d._F(0), New Tuple(Of Integer, Boolean, String, String)(d._F(2).Item1, Not d._F(2).Item2, d._F(2).Item3, d._F(2).Item4), d._F(4), d._F(1), New Tuple(Of Integer, Boolean, String, String)(d._F(5).Item1, Not d._F(5).Item2, d._F(5).Item3, d._F(5).Item4)}, {d._F(0), d._F(1), d._F(2), d._F(3), d._F(4), d._F(5)}, {d._F(1), d._F(4), New Tuple(Of Integer, Boolean, String, String)(d._F(2).Item1, Not d._F(2).Item2, d._F(2).Item3, d._F(2).Item4), d._F(0), d._F(3), New Tuple(Of Integer, Boolean, String, String)(d._F(5).Item1, Not d._F(5).Item2, d._F(5).Item3, d._F(5).Item4)}))))
  End Function
  Public ReadOnly Property Value As Integer
    Get
      Return _F(2).Item1
    End Get
  End Property
  Public Overrides Function ToString() As String
    Return <die>!4+---+!4<%= If(_F(0).Item2, _F(0).Item4, _F(0).Item3).Substring(0, 5) %>!4<%= If(_F(0).Item2, _F(0).Item4, _F(0).Item3).Substring(5, 5) %>!4<%= If(_F(0).Item2, _F(0).Item4, _F(0).Item3).Substring(10, 5) %>!+---+---+---+!<%= If(_F(1).Item2, _F(1).Item4, _F(1).Item3).Substring(0, 5) %><%= If(_F(2).Item2, _F(2).Item4, _F(2).Item3).Substring(1, 4) %><%= If(_F(3).Item2, _F(3).Item4, _F(3).Item3).Substring(1, 4) %>!<%= If(_F(1).Item2, _F(1).Item4, _F(1).Item3).Substring(5, 5) %><%= If(_F(2).Item2, _F(2).Item4, _F(2).Item3).Substring(6, 4) %><%= If(_F(3).Item2, _F(3).Item4, _F(3).Item3).Substring(6, 4) %>!<%= If(_F(1).Item2, _F(1).Item4, _F(1).Item3).Substring(10, 5) %><%= If(_F(2).Item2, _F(2).Item4, _F(2).Item3).Substring(11, 4) %><%= If(_F(3).Item2, _F(3).Item4, _F(3).Item3).Substring(11, 4) %>!+---+---+---+!4<%= If(_F(4).Item2, _F(4).Item4, _F(4).Item3).Substring(0, 5) %>!4<%= If(_F(4).Item2, _F(4).Item4, _F(4).Item3).Substring(5, 5) %>!4<%= If(_F(4).Item2, _F(4).Item4, _F(4).Item3).Substring(10, 5) %>!4+---+!4<%= If(_F(5).Item2, _F(5).Item4, _F(5).Item3).Substring(0, 5) %>!4<%= If(_F(5).Item2, _F(5).Item4, _F(5).Item3).Substring(5, 5) %>!4<%= If(_F(5).Item2, _F(5).Item4, _F(5).Item3).Substring(10, 5) %>!4+---+</die>.Value.Replace("4", "    ").Replace("!", Environment.NewLine)
  End Function
End Class

That function PRY is looking a little fat at 2 lines, I can wonder it can be made into a single line. Yeah! Recursion?!

[AdamSpeight2008]

modi123_1: Just a minor error (but I'll forgive you), of not overriding the .ToString method.

Dim foo As New Die
Console.WriteLine(foo.ToString) ' <-- This returns the type name, which is why we need to override it.
Console.WriteLine(" ")
foo = Die.PRY(foo, -1, 0, 0)
Console.WriteLine(foo.ToSt1ring) ' <-- This returns the die as a string.
Console.WriteLine(" ")

I do like idea of a function taking in 70 parameters.

This post has been edited by AdamSpeight2008: 09 March 2012 - 07:46 AM

[modi123_1]

Ah yeah.. Totally the same thing.

There.. fixed it.. sheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeesh.

[AdamSpeight2008]

modi123_1: On a closer inspection it's a Failure. It modifies the Die being passed in.

  Sub Main()
    Dim foo As New Die
    Console.WriteLine(foo.ToString)
    Console.WriteLine(" ")
    Dim foo2 = Die.PRY(foo, -1, 0, 0)
    Console.WriteLine(foo2.ToString)
    Console.WriteLine(" ")
    Console.WriteLine(foo.ToString)
    Console.WriteLine(" ")

  End Sub

This post has been edited by AdamSpeight2008: 09 March 2012 - 08:05 AM

[modi123_1]

You mean live 5? Wasn't that the point of that shared function?

[AdamSpeight2008]

Quote

4. Any die produced or used mustn't be changed or mutated.

So this means it has to be immutable. (Just like the type String)

The Die being pass in is the initial orientation of die.
The output should is what orientation that die will be in after the various changes in orientation.

This post has been edited by AdamSpeight2008: 09 March 2012 - 08:21 AM