Spirograph for mIRC - By FenniC

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;       Spirograph           ;
;     Coded by: FenniC       ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Usage: To start Spirograph, right click a window and click Spirograph;
;                                                                      ;
; * To bring up the arm parameters, press "s" or "w"                   ;
;                                                                      ;
; * To generate a random drawing, press 1 through 6                    ;
;                                                                      ;
; * To start or stop drawing, press "d"                                ;
;                                                                      ;
; * To toggle the export label, press "L"                              ;
;                                                                      ;
; * To apply a sketch to the background, hold "shift" and click        ;
; where you would like to place your drawing                           ;
;                                                                      ;
; * To clear the drawing buffer, press "c"                             ;
;                                                                      ;
; * You can zoom in using the "up" and "down" arrows                   ;
;                                                                      ;
; * To take a screenshot of the drawing buffer, press Enter            ;
;                                                                      ;
; * To toggle the drawing arms, press "h"                              ;
;                                                                      ;
; * You can pan around the background by holding left click and        ;
; dragging the mouse                                                   ;
;                                                                      ;
; * Many more options can be found in the menu                         ;
;                                                                      ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;
; Input ;
;;;;;;;;;

alias Spirograph.PromptImport {
  if !$dialog(spiroImport) { dialog -dm spiroImport Import }
  else { did -f spiroImport 2 }
}

alias Spirograph.PromptExport {
  if !$dialog(spiroExport) { dialog -dm spiroExport Export }
  else { did -f spiroExport 2 }
}
on 1:keydown:@Spirograph:*: {

  if $keyChar == s || $keyChar == w {
    if (!$dialog(ArmParameters)) {
      var %x $dialog(ArmParameters,armp,@Spirograph)
    }
    else {
      did -f ArmParameters 1
    }
  }

  if $isalias(Spirograph.Gen $+ $keyChar) {
    if $hget(Spirograph,Drawing) {
      Spirograph.HandleDraw
    }
    Spirograph.Gen $+ $keyChar
    Spirograph.HandleDraw
  }
  ;Generate Random
  if $keyChar == r {
    Spirograph.Rand3 $hget(Spirograph,ArmCount)
    if $hget(Spirograph,Drawing) {
      Spirograph.HandleDraw
    }
    Spirograph.HandleDraw
  }

  ;Generate Structured Random
  else if $keyChar == t {
    Spirograph.Rand2 $hget(Spirograph,ArmCount)
    if $hget(Spirograph,Drawing) {
      Spirograph.HandleDraw
    }
    Spirograph.HandleDraw
  }

  ;Export current Drawing
  else if $keyChar == e {
    Spirograph.PromptExport
  }

  ;Bring up import dialog
  else if $keyChar == i {
    Spirograph.PromptImport
  }

  ;Start/stop drawing
  else if $keyChar == d {
    Spirograph.HandleDraw
  }

  ;Toggle Export label below drawing
  else if $keyChar == l {
    hadd -m Spirograph DrawLabel $iif($hget(Spirograph,DrawLabel),0,1)
  }

  ;Toggle arm drawing
  else if $keyChar == h {
    hadd -m Spirograph DrawArms $iif($hget(Spirograph,DrawArms),0,1)
  }
  ;Clear drawing buffer
  else if $keyChar == c {
    if $hget(Spirograph,Drawing) {
      Spirograph.HandleDraw
    }
    clear @SpirographDrawBuff
  }

  ;Zoom out (Down Arrow)
  else if $keyVal == 40 {
    return $Spirograph.Zoom(1)
  }

  ;Zoom in (Up Arrow)
  else if $keyVal == 38 {
    return $Spirograph.Zoom(0)
  }

  ;Save screenshot to mirc directory (Enter)
  else if $keyVal == 13 {
    var %z $ticks
    var %saveDir $mircdirSketches
    var %saveFile $+(Spirograph,-,%z,.jpg)
    var %savepath $+(%saveDir,\,%saveFile)
    var %w $hget(Spirograph,DrawBuff.w)
    var %h $calc($hget(Spirograph,DrawBuff.H) + ($hget(Spirograph,DrawLabel) * 30)) + 20
    while $window(@SpirographSaveBuff).h != %h {
      window -hp @SpirographSaveBuff -1 -1 %w %h
    }
    drawCopy -n @SpirographDrawBuff 0 0 %w %h @SpirographSaveBuff 0 0
    if !$exists(%saveDir) {
      mkdir $qt(%saveDir)
    }
    drawSave -b32q100 @SpirographSaveBuff $qt(%savePath)
    run mspaint.exe $qt(%savePath)
    window -c @SpirographSaveBuff
  }

  ;unhandled
  else {
  }
}


;;;;;;;;;;;;;;;;;;;;;;
; Gametime rendering ;
;;;;;;;;;;;;;;;;;;;;;;
alias Spirograph.renderScene {
  var %scale $hget(Spirograph,Scale)
  var %armCount $hget(Spirograph,ArmCount)
  var %x 1
  var %totalLength
  var %totalAngle
  while %x <= %armCount {
    var %armAngle $+ %x $hget(Spirograph,Arm $+ %x $+ Angle)
    var %totalAngle %totalAngle $round($calc(%armAngle [ $+ [ %x ] ] % 360),1)
    var %armLength $+ %x $hget(Spirograph,Arm $+ %x $+ Length)
    inc %totalLength %armLength [ $+ [ %x ] ]
    var %armSpeed $+ %x $hget(Spirograph,Arm $+ %x $+ Speed)
    inc %x
  }
  if $hget(Spirograph,HasInit) == 2 {
    if $hget(Spirograph,Drawing) {
      Spirograph.HandleDraw
      ;echo @Debug Total Sides: $hget(Spirograph,Sides)
    }
  }
  else if $hget(Spirograph,Drawing) && $hget(Spirograph,HasInit) == 1 {
    hinc -m Spirograph Sides
  }
  if (%totalAngle == $hget(Spirograph,startAngle) || $hget(Spirograph,Sides) == $hget(Spirograph,SideMax)) && $hget(Spirograph,Drawing) {
    if $hget(Spirograph,HasInit) == 1 {
      hinc -m Spirograph HasInit
    }
    else {
      hadd -m Spirograph HasInit 1
      hadd -m Spirograph Sides 0
    }
  }
  var %window.w $window(@Spirograph).w
  var %window.h $window(@Spirograph).h

  var %scorePadding.w 2
  var %scorePadding.h $hget(Spirograph,Scorepadding.H)

  var %template $hget(Spirograph,Template)
  var %fontSize 10

  ;var %boxCount %armCount * 2
  var %boxCount 4

  var %score.w $int($calc((%window.w - ((%boxCount + 1) * %scorePadding.w)) / %boxCount) )
  var %score.h $hget(Spirograph,Score.H)


  var %m.x $iif($hget(Spirograph,MouseLock),$hget(Spirograph,Mouse.X),$mouse.x)
  var %m.y $iif($hget(Spirograph,MouseLock),$hget(Spirograph,Mouse.Y),$mouse.y)

  if (%m.x != $null && %m.y != $null) {
    if $hget(Spirograph,Moving) {
      var %mouse.x $calc((%m.x - $hget(Spirograph,Mouse.X)) * %scale)
      var %mouse.y $calc((%m.y - $hget(Spirograph,Mouse.Y)) * %scale)

      var %newX $iif($calc($hget(Spirograph,Buffer.X) - %mouse.x) > 0,$v1,0)
      var %newY $iif($calc($hget(Spirograph,Buffer.Y) - %mouse.y) > 0,$v1,0)

      if %newX < $calc($window(@SpirographBuffer).w - 2 - $window(@Spirograph).w * %scale) {
        hadd -m Spirograph Buffer.X $v1
      }
      else {
        hadd -m Spirograph Buffer.X $v2
      }

      if %newY < $calc($window(@SpirographBuffer).h - 2 -  (($window(@Spirograph).h - %score.h - %scorePadding.h * 2) * %scale)) {
        hadd -m Spirograph Buffer.Y $v1
      }
      else {
        hadd -m Spirograph Buffer.Y $v2
      }
    }
    hadd -m Spirograph Mouse.X %m.x
    hadd -m Spirograph Mouse.Y %m.y
  }
  drawCopy -n @SpirographBuffer $hget(Spirograph,Buffer.X) $hget(Spirograph,Buffer.Y) $calc(%window.w * %scale) $calc((%window.h - (%score.h + %scorePadding.h * 2)) * %scale) @Spirograph 0 $calc(%score.h + %scorePadding.h * 2) %window.w $calc(%window.h - (%score.h + %scorePadding.h * 2))
  var %buff.w $hget(Spirograph,DrawBuff.W)
  var %buff.h $calc($hget(Spirograph,DrawBuff.H) + ($hget(Spirograph,DrawLabel) * $hget(Spirograph,DrawBuff.lh)))

  drawCopy -nt @SpirographDrawBuff $rgb(255,255,255) 0 0 %buff.w %buff.h @Spirograph $calc($iif(%m.x,$v1,$hget(Spirograph,Mouse.X)) - ($hget(Spirograph,DrawBuff.x) / %scale)) $calc($iif(%m.y,$v1,$hget(Spirograph,Mouse.Y))- ($hget(Spirograph,DrawBuff.Y) / %scale)) $calc(%buff.w / %scale) $calc(%buff.h / %scale)

  var %box.x %score.w + %scorePadding.w
  var %currBox.x %window.w - %box.x
  dec %currBox.x 10
  var %text.h $calc(%score.h / 2 + %scorePadding.h - ($height(T,Tahoma,%fontSize) / 2))

  var %boxColor $rgb(220,220,220)
  var %borderColor $rgb(100,100,100)
  var %textColor $rgb(0,0,0)

  var %x 1

  var %arm.x $iif(%m.x,$v1,$hget(Spirograph,Mouse.X))
  var %arm.y $iif(%m.y,$v1,$hget(Spirograph,Mouse.Y))

  var %mouse.x %arm.x
  var %mouse.y %arm.y

  var %degPerFrame $iif(%template,360 / %template,%armSpeed1)
  var %drawArms $hget(Spirograph,DrawArms)
  var %drawArm.X %arm.x
  var %drawArm.Y %arm.Y
  while %x <= %armCount {
    var %color $hget(Spirograph,Arm $+ %x $+ Color)
    var %color2 $hget(Spirograph,Arm $+ %x $+ Color2)
    var %lastX.X %drawArm.x
    var %lastX.Y %drawArm.y

    var %zzz $calc(%armSpeed [ $+ [ %x ] ] / %armSpeed1)

    var %armSin $cos(%armAngle [ $+ [ %x ] ]).deg
    var %armCos $sin(%armAngle [ $+ [ %x ] ]).deg

    var %arm.x $calc(%armSin * %armLength [ $+ [ %x ] ] + %arm.x)
    var %arm.y $calc(%armCos * %armLength [ $+ [ %x ] ] + %arm.y)

    var %diff.x %arm.x - %mouse.x
    var %diff.y %arm.y - %mouse.y

    if $hget(Spirograph,Arm $+ %x $+ Last.X) != $null {
      var %distanceRatio $sqrt($calc($abs(%diff.x) ^ 2 + $abs(%diff.y) ^ 2)) / %totalLength
      var %armColor $color2colorratio(%color,%color2,%distanceRatio)

    }
    else {
      var %armColor %color
    }

    var %drawArm.x $calc(%armSin * (%armLength [ $+ [ %x ] ] / %scale) + %drawArm.x)
    var %drawArm.y $calc(%armCos * (%armLength [ $+ [ %x ] ] / %scale) + %drawArm.y)
    hinc Spirograph Arm $+ %x $+ Angle $calc(%zzz * %degPerFrame)

    ;If Arm.Show == 1
    if $hget(Spirograph,Arm $+ %x $+ Show) && %drawArms {
      drawLine -nr @Spirograph %armColor 2 %lastX.X %lastX.Y %drawArm.x %drawArm.y
    }

    ;If Drawing && Arm.Draw == 1
    if $hget(Spirograph,Drawing) && $hget(Spirograph,Arm $+ %x $+ Draw) {
      if $hget(Spirograph,Arm $+ %x $+ Last.X) != $null {
        drawLine -nr @SpirographDrawBuff %armColor $hget(Spirograph,Arm $+ %x $+ Width) $calc($hget(Spirograph,DrawBuff.x) + $v1) $calc($hget(Spirograph,DrawBuff.y) + $hget(Spirograph,Arm $+ %x $+ Last.Y)) $calc($hget(Spirograph,DrawBuff.x) + %diff.x) $calc($hget(Spirograph,DrawBuff.y) + %diff.y)
      }
    }
    hadd -m Spirograph Arm $+ %x $+ Last.X %diff.x
    hadd -m Spirograph Arm $+ %x $+ Last.Y %diff.y

    inc %x
  }
  if %drawArms {
    drawDot -n @Spirograph 4 4 $calc(%drawArm.x + 2) $calc(%drawArm.y + 2)
  }
  drawRect -nf @Spirograph 0 1 0 0 %window.w $hget(Spirograph,scorePad)
  var %x %armCount

  Spirograph.DrawTextBox Spirograph %currBox.x %scorePadding.h %score.w %score.h %text.h %fontSize %boxColor %borderColor %textColor Template: $hget(Spirograph,Template)
  dec %currBox.x %box.x

  Spirograph.DrawTextBox Spirograph %currBox.x %scorePadding.h %score.w %score.h %text.h %fontSize %boxColor %borderColor %textColor Side Count: $hget(Spirograph,Sides)
  dec %currBox.x %box.x

  Spirograph.DrawTextBox Spirograph %currBox.x %scorePadding.h %score.w %score.h %text.h %fontSize %boxColor %borderColor %textColor Arm Count: %armCount
  dec %currBox.x %box.x

  Spirograph.DrawTextBox Spirograph %currBox.x %scorePadding.h %score.w %score.h %text.h %fontSize %boxColor %borderColor %textColor Status: $iif($hget(Spirograph,Drawing),Drawing,Stopped)
  dec %currBox.x %box.x

  drawDot @Spirograph
}


;;;;;;;;;;;;;;;
; Draw
;;;;;;;;;;;;;;;;
; HUD Drawing  ;
;;;;;;;;;;;;;;;;
alias Spirograph.DrawTextBox {
  ;params <ID> <BOX.X> <BOX.Y> <BOX.W> <BOX.H> <TEXT.Y> <FONTSIZE> <BOX COLOR> <BORDER COLOR> <TEXT COLOR> <TEXT>
  var %id $1

  ;Draw Box
  drawrect -nrf @ $+ $1 $8 1 $2 $3 $4 $5

  ;Draw Border
  drawrect -nr @ $+ $1 $9 1 $2 $3 $4 $5

  ;Draw Text
  drawtext -norf @ $+ $1 $10 "Arial" $7 $calc($4 / 2 + $2 - ($width($11-,Tahoma,$7) / 2)) $6 $11-
}

;;;;;;;;;;;;;;;;;
; Square adding ;
;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Window/Hash initialization ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias Spirograph.InitGUI {
  ; Window Width
  ; NOTE: If windows prevents a window this size from being created, lower these numbers
  hadd -m Spirograph Alive 1
  if !$window(@SpirographBuffer) { var %flag 1 }

  var %windowWidth 4000
  var %windowHeight 3000
  while ($window(@SpirographBuffer).w != %windowWidth) {
    window -hp @SpirographBuffer -1 -1 %windowWidth %windowHeight
  }
  var %windowWidthb 1200
  var %windowHeights 1200
  while ($window(@SpirographDrawBuff).w != %windowWidthb) {
    window -hp @SpirographDrawBuff -1 -1 %windowWidthb %windowHeights
  }
  ;Score Padding
  var %scorePad 30

  var %board.x 0
  var %board.y %scorePad

  hadd -m Spirograph scorePad %scorePad

  hadd -m Spirograph board.x %board.x
  hadd -m Spirograph board.y %board.y

  var %armCount 4
  while %armCount {
    Spirograph.InitArm
    dec %armCount
  }

  Spirograph.Gen2

  hadd -m Spirograph Template 0
  hadd -m Spirograph Scale 1

  window -Bdp @Spirograph -1 -1 800 600

  hadd -m Spirograph Buffer.X $calc(%windowWidth / 2 - 800 / 2)
  hadd -m Spirograph Buffer.Y $calc(%windowHeight / 2 - 600 / 2)

  hadd -m Spirograph DrawBuff.X 0
  hadd -m Spirograph DrawBuff.Y 0
  hadd -m Spirograph DrawBuff.W 0
  hadd -m Spirograph DrawBuff.H 0

  hadd -m Spirograph Score.H 20
  hadd -m Spirograph ScorePadding.H 5

  hadd -m Spirograph BGColor $rgb(255,255,255)

  hadd -m Spirograph DrawArms 1
  var %m1 Welcome to Spirograph by FenniC!
  var %m3 Drag the mouse to pan through the background
  var %m2 To start drawing $+ $chr(44) press "d"
  var %m4 To apply the drawing to the background $+ $chr(44) hold shift and click where you would like it placed
  var %m5 To bring up the arm options $+ $chr(44) press "w" or "s"
  if %flag {
    drawtext -norf @SpirographBuffer 0 "Arial" 15 $calc($hget(Spirograph,Buffer.X) + ($window(@Spirograph).w / 2) - ($width(%m1,Arial,15) / 2)) $calc($hget(Spirograph,Buffer.Y) + 265) %m1
    drawtext -norf @SpirographBuffer 0 "Arial" 12 $calc($hget(Spirograph,Buffer.X) + ($window(@Spirograph).w / 2) - ($width(%m2,Arial,12) / 2)) $calc($hget(Spirograph,Buffer.Y) + 285) %m2
    drawtext -norf @SpirographBuffer 0 "Arial" 12 $calc($hget(Spirograph,Buffer.X) + ($window(@Spirograph).w / 2) - ($width(%m3,Arial,12) / 2)) $calc($hget(Spirograph,Buffer.Y) + 295) %m3
    drawtext -norf @SpirographBuffer 0 "Arial" 12 $calc($hget(Spirograph,Buffer.X) + ($window(@Spirograph).w / 2) - ($width(%m4,Arial,12) / 2)) $calc($hget(Spirograph,Buffer.Y) + 305) %m4
    drawtext -norf @SpirographBuffer 0 "Arial" 12 $calc($hget(Spirograph,Buffer.X) + ($window(@Spirograph).w / 2) - ($width(%m5,Arial,12) / 2)) $calc($hget(Spirograph,Buffer.Y) + 315) %m5
  }
  .timerSpirograph 0 0 Spirograph.renderScene
}

alias Spirograph.Clear {
  clear @SpirographBuffer
  drawFill -nrs @SpirographBuffer $hget(Spirograph,BGColor) $rgb(255,255,255) 0 0
}
;;;;;;;;;;;;;;;;;;;;;;
; Pre-game rendering ;
;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;
; Click alias ;
;;;;;;;;;;;;;;;
alias Spirograph.Click {
  if ($mouse.key & 4) {
    Spirograph.ApplyDraw
    if $hget(Spirograph,Drawing) {
      Spirograph.HandleDraw
    }
  }
  else {
    hadd -m Spirograph Moving 1
  }
}

alias Spirograph.UClick {
  if ($hget(Spirograph,Drawing) == 1) {
    hadd -m Spirograph Drawing 0
    hdel -m Spirograph Last.X
    hdel -m Spirograph Last.Y
  }
  hadd -m Spirograph Moving 0
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;            Mouse Events           ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
menu @Spirograph {
  sclick: Spirograph.Click
  uclick: Spirograph.UClick
}
menu @Spirograph {
  Arm Parameters: {
    ;if $hget(Spirograph,Drawing) { Spirograph.HandleDraw }
    if (!$dialog(ArmParameters)) {
      var %x $dialog(ArmParameters,armp,@Spirograph)
    }
    else {
      did -f ArmParameters 1
    }
  }
}
alias Spirograph.SetTemplate {
  if $1 != $null {
    hadd -m Spirograph Template $1
  }
  if $hget(Spirograph,Drawing) { Spirograph.HandleDraw }
  var %x $hget(Spirograph,ArmCount)
  while %x {
    hadd -m Spirograph Arm $+ %x $+ Angle 90
    dec %x
  }
}

menu @Spirograph {
  Import Sketch: Spirograph.PromptImport
  Export Sketch: Spirograph.PromptExport
  Calculate Ratios: DegToSide
  Clear Scene: Spirograph.Clear
  Change Background: {
    if !$dialog(geoBg) { dialog -dm geoBg bgcolor }
    else {
      did -f geoBg 2
    }
  }
}
menu @Spirograph {
  .Drawing Sides
  ..Set Custom: Spirograph.SetTemplate $Input(Enter the number of sides for the template,eo,Template Sides)
  ..Set 0: Spirograph.SetTemplate 0
  ..Set 2: Spirograph.SetTemplate 2
  ..Set 3: Spirograph.SetTemplate 3
  ..Set 4: Spirograph.SetTemplate 4
  ..Set 5: Spirograph.SetTemplate 5
  ..Set 6: Spirograph.SetTemplate 6
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;            Closing Events           ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on 1:close:@Spirograph: {
  if $hget(Spirograph) { hfree Spirograph }
  if ($window(@SpirographBuffer)) window -c @Spirographbuffer
  .timerSpirograph off
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; General Spirograph Functions ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias Spirograph.InitDrawing {
  if $hget(Spirograph,Drawing) {
    Spirograph.HandleDraw
  }
  clear @SpirographDrawBuff
  var %x $hget(Spirograph,ArmCount)
  while %x {
    hadd -m Spirograph Arm $+ %x $+ Angle $hget(Spirograph,Arm $+ %x $+ StartAngle))
    dec %x
  }
  Spirograph.HandleDraw
}

alias Spirograph.initArm {
  hinc -m Spirograph ArmCount

  var %armCount $hget(Spirograph,ArmCount)

  hadd -m Spirograph $+(Arm,%armCount,Length) 50
  hadd -m Spirograph $+(Arm,%armCount,Speed) 0
  hadd -m Spirograph $+(Arm,%armCount,Width) 1
  hadd -m Spirograph $+(Arm,%armCount,StartAngle) 90
  hadd -m Spirograph $+(Arm,%armCount,Color) $r(0,$rgb(255,255,255))
  hadd -m Spirograph $+(Arm,%armCount,Color2) $r(0,$rgb(255,255,255))
  hadd -m Spirograph $+(Arm,%armCount,Draw) 1
  hadd -m Spirograph $+(Arm,%armCount,Show) 1
  hadd -m Spirograph $+(Arm,$calc(%armCount - 1),Draw) 0
}
alias Color2ColorRatio {
  var %color1 $rgb($1)
  var %color2 $rgb($2)
  var %color2Ratio $3
  var %color1Ratio 1 - $3

  var %red $calc($token(%color1,1,44) * %color1Ratio + $token(%color2,1,44) * %color2Ratio)
  var %green $calc($token(%color1,2,44) * %color1Ratio + $token(%color2,2,44) * %color2Ratio)
  var %blue $calc($token(%color1,3,44) * %color1Ratio + $token(%color2,3,44) * %color2Ratio)

  return $rgb(%red,%green,%blue)
}

alias Spirograph.HandleDraw {
  hadd -m Spirograph Drawing $iif($hget(Spirograph,Drawing),0,2)
  if !$hget(Spirograph,Drawing) {
    var %x $hget(Spirograph,ArmCount)
    while %x {
      hdel -m Spirograph Arm $+ %x $+ Last.X
      hdel -m Spirograph Arm $+ %x $+ Last.Y
      dec %x
    }
  }
  else {
    var %x $hget(Spirograph,ArmCount),%y,%z
    while %x {
      hdel -m Spirograph Arm $+ %x $+ Last.X
      hdel -m Spirograph Arm $+ %x $+ Last.Y
      inc %y $hget(Spirograph,Arm $+ %x $+ Length)
      var %z $round($calc($hget(Spirograph,Arm $+ %x $+ Angle) % 360),1) %z
      dec %x
    }
    clear @SpirographDrawBuff

    hadd -m Spirograph StartAngle %z
    hadd -m Spirograph HasInit 0

    var %w $calc(%y * 2),%h %w
    var %export $Spirograph.export
    var %x $wrap(%export,Arial,12,$calc(%w - 50),0)
    var %h2 $calc(%h + (%x * $height(%export,Arial,12)))
    ;if $width(%export,Arial,12) > %w { var %w $width(%export,Arial,12) }
    while %x {
      var %txt $wrap(%export,Arial,12,$calc(%w - 50),%x)
      drawtext -norf @SpirographDrawBuff 0 "Arial" 12 $calc((%w / 2) - ($width(%txt,Arial,12) / 2)) $calc(%h + $height(%txt,Arial,12) * (%x - 1)) %txt
      dec %x
    }

    ;drawtext -norf @SpirographDrawBuff 0 "Arial" 12 $calc((%w / 2) - ($width(%export,Arial,12) / 2)) %h %export
    hadd -m Spirograph DrawBuff.x $calc(%w / 2)
    hadd -m Spirograph DrawBuff.y $calc(%h / 2)
    hadd -m Spirograph DrawBuff.w %w
    hadd -m Spirograph DrawBuff.h %h
    hadd -m Spirograph DrawBuff.lh $calc(%h2 - %h)
  }
}

alias Spirograph.ApplyDraw {
  var %scale $hget(Spirograph,Scale)
  var %base.x $calc($hget(Spirograph,Buffer.X) + ($mouse.x * %scale) - $hget(Spirograph,DrawBuff.X))
  var %base.Y $calc($hget(Spirograph,Buffer.Y) + (($mouse.y - $hget(Spirograph,Score.H) - $hget(Spirograph,Scorepadding.H) * 2) * %scale) - $hget(Spirograph,DrawBuff.Y))
  drawCopy -nt @SpirographDrawBuff $rgb(255,255,255) 0 0 $hget(Spirograph,DrawBuff.W) $calc($hget(Spirograph,DrawBuff.H) + ($hget(Spirograph,DrawLabel) * $hget(Spirograph,DrawBuff.lh))) @SpirographBuffer %base.x %base.y
  ;drawCopy -n @SpirographDrawBuff 0 0 $hget(Spirograph,DrawBuff.W) $calc($hget(Spirograph,DrawBuff.H) + ($hget(Spirograph,DrawLabel) * 20)) @SpirographBuffer %base.x %base.y

}

alias Spirograph.Zoom {
  var %zoomRatio 0.125
  if $1 {
    hinc -m Spirograph Scale %zoomRatio

    var %newX $iif($calc($hget(Spirograph,Buffer.X) - $window(@Spirograph).w * (%zoomRatio / 2)) > 0,$v1,0)
    var %newY $iif($calc($hget(Spirograph,Buffer.Y) - (($window(@Spirograph).h - $hget(Spirograph,Score.h) - $hget(Spirograph,ScorePadding.h) * 2) * (%zoomRatio / 2))) > 0,$v1,0)

    if %newX > $calc($window(@SpirographBuffer).w - 2 - ($window(@Spirograph).w  * $hget(Spirograph,Scale))) $&
      || %newY > $calc($window(@SpirographBuffer).h - 2 - (($window(@Spirograph).h - $hget(Spirograph,Score.h) - $hget(Spirograph,Scorepadding.h) * 2) * $hget(Spirograph,Scale))) {
      hdec -m Spirograph Scale %zoomRatio
    }
    else {
      hadd -m Spirograph Buffer.X %newX
      hadd -m Spirograph Buffer.Y %newY
    }
  }
  else {
    if $hget(Spirograph,Scale) > %zoomRatio {
      var %newX $iif($calc($hget(Spirograph,Buffer.X) + $window(@Spirograph).w * (%zoomRatio / 2)) > 0,$v1,0)
      var %newY $iif($calc($hget(Spirograph,Buffer.Y) + (($window(@Spirograph).h - $hget(Spirograph,Score.h) - $hget(Spirograph,ScorePadding.h) * 2) * (%zoomRatio / 2))) > 0,$v1,0)

      hdec -m Spirograph Scale %zoomRatio
      hadd -m Spirograph Buffer.X %newX
      hadd -m Spirograph Buffer.Y %newY
    }
  }
}

;;;;;;;;;;;;;;;;
;    Random    ;
;;;;;;;;;;;;;;;;
alias Spirograph.Rand2 {
  hdel -m Spirograph SideMax
  hdel -m Spirograph Last.X
  hdel -m Spirograph Last.Y
  hadd -m Spirograph ArmCount $1
  hadd -m Spirograph Color $r(0,16777215)
  hadd -m Spirograph Color2 $r(0,16777215)
  var %x $1,%y,%z
  while %x {
    hadd -m Spirograph Arm $+ %x $+ Speed $calc(360 / $iif($r(0,2),$r(2,30),(2 * $r(1,5) - 1) / 2) * $iif($r(0,1),1,-1))
    hinc -m Spirograph Arm $+ %x $+ Speed $iif($r(0,1),0.5,0)
    hadd -m Spirograph Arm $+ %x $+ Length $r(50,125)
    hadd -m Spirograph Arm $+ %x $+ Angle 90
    dec %x
  }
}
alias Spirograph.Rand3 {
  hdel -m Spirograph SideMax
  hdel -m Spirograph Last.X
  hdel -m Spirograph Last.Y
  var %x $1
  var %y,%z
  while %x {
    hadd -m Spirograph Arm $+ %x $+ Speed $calc($r(0,1000) - 500)
    hadd -m Spirograph Arm $+ %x $+ Length $r(50,125)
    hadd -m Spirograph Arm $+ %x $+ Angle 90
    dec %x
  }
  hadd -m Spirograph Color $r(0,16777215)
  hadd -m Spirograph Color2 $r(0,16777215)
  hadd -m Spirograph ArmCount $1
}

alias Spirograph.Gen2 {
  if $hget(Spirograph,Drawing) { Spirograph.HandleDraw }
  hdel -m Spirograph Last.X
  hdel -m Spirograph Last.Y
  tokenize 32 $1-
  var %x $hget(Spirograph,ArmCount),%y %x
  var %sideCount $iif($1,$1,$r(1500,6000))
  if $calc(%sideCount % 2) { dec %sideCount }
  var %flutterSides $iif(%sideCount > 1500,$iif(%sideCount > 3000,8,6),4)
  var %speed $calc(360 / (%sideCount / (360 / %flutterSides)))

  var %length $r(5,12)

  hadd Spirograph Arm $+ %x $+ Speed $calc((%speed + 180) * $iif($r(0,1),1,-1))
  hadd Spirograph Arm $+ %x $+ Length $r(22,28)
  hadd Spirograph Arm $+ %x $+ Angle 90

  dec %x

  hadd -m Spirograph Arm $+ %x $+ Speed %speed
  hadd -m Spirograph Arm $+ %x $+ Length %length
  hadd -m Spirograph Arm $+ %x $+ Angle 90

  dec %x
  dec %y 2
  Spirograph.GenDefault %sideCount %x $2-
}

alias Spirograph.Gen5 {
  var %m $r(2,4)
  return $Spirograph.Gen1($calc($r(1,80) + (1 / $r(10,15) / %m))).sm [ $+ [ %m ] ]
}
alias Spirograph.Gen1 {
  tokenize 32 $1-
  var %y $hget(Spirograph,ArmCount),%x 1,%z
  while %x <= %y {
    var %r $iif($ [ $+ [ $calc(%x + 1) ] ] != $null,$v1,$int($calc($r(4,104) / 4)))
    ;var %r $iif($ [ $+ [ $calc(%x + 1) ] ],$v1,$r(4,180))
    var %tn $v1
    var %r $iif($regex($prop,/(m)+(\d+)/),$calc(%r + (1 / $iif($regml(2),$v1,2))),%r)

    if !%tn {
      var %r $calc(%r * ($r(0,1) * 2 - 1))
    }
    var %z %z %r
    inc %x
  }
  Spirograph.GenDefault $iif($1,$1,$calc($r(20,50) + (1 / $r(8,20)))) %y %z
}
alias Spirograph.Gen6 {
  var %m $r(4,6)
  return $Spirograph.Gen1($calc($r(1,80) + (1 / $r(10,15) / %m))).sm [ $+ [ %m ] ]
}
alias Spirograph.Gen4 {
  return $Spirograph.Gen3($calc($r(36,130) + (1 / $r(6,12))))
  ;return $Spirograph.Gen3($r(36,130))
}
alias Spirograph.Gen3 {
  if $hget(Spirograph,Drawing) { Spirograph.HandleDraw }
  hdel -m Spirograph Last.X
  hdel -m Spirograph Last.Y
  tokenize 32 $1-
  var %flutterSides 6
  var %x $hget(Spirograph,ArmCount),%y %x
  var %sideCount $iif($1,$1,$r(36,2000))
  var %speed $calc(360 / (%sideCount / (360 / %flutterSides)))

  var %length $r(10,15)

  hadd -m Spirograph Arm $+ %x $+ Speed %speed
  hadd -m Spirograph Arm $+ %x $+ Length %length
  hadd -m Spirograph Arm $+ %x $+ Angle 90

  dec %x
  dec %y

  if t isin $prop {
    hadd -m Spirograph Arm $+ %x $+ Length $r(15,40)
    hadd -m Spirograph Arm $+ %x $+ Speed $calc((360 / %sideCount ) / $r(11,22))
    dec %x
    dec %y
  }

  Spirograph.GenDefault %sideCount %x $2-
}

alias Spirograph.GenDefault {
  tokenize 32 $1-
  var %maxLength 400,%minLength 50
  var %sideCount $1,%x $2,%y %x
  tokenize 32 $3-
  while %x {
    var %rand $iif($ [ $+ [ %x ] ] != $null,$v1,$int($calc($r(11,121) / 11)))
    if $v1 == $null {
      var %rand $calc(%rand * ($r(0,1) * 2 - 1)))
    }
    var %k $calc(360 / (%sideCount / %rand)) %k
    hadd -m Spirograph Arm $+ %x $+ Length $r($int($calc((%maxLength / %y) / 3)),$calc(%maxLength / %y))
    hadd -m Spirograph Arm $+ %x $+ Speed $calc(360 / (%sideCount / %rand))

    hadd -m Spirograph Arm $+ %x $+ Angle 90
    dec %x
  }
  var %y $hget(Spirograph,ArmCount),%x %y,%z
  while %y {
    var %a $hget(Spirograph,Arm $+ %y $+ Speed)
    var %z $round($calc(%sideCount / (360 / %a)),4) %z
    var %k %a %k
    dec %y
  }
  hadd -m Spirograph SideMax $round($iif(%sideCount != $int(%sideCount),$calc($v1 / ($v1 % 1)),$v1),0)
  if $window(@Debug) {
    echo @Debug Sides: %sideCount - Ratios: %z - Speeds: %k - Tube: $iif(%tube,Yes,No)
    ; clipboard $RotatixEnc(%sideCount,%z)
  }
}
alias DegToSide {
  var %x $hget(Spirograph,ArmCount),%z
  while %x {
    var %z $hget(Spirograph,Arm $+ %x $+ Speed) %z
    dec %x
  }
  tokenize 32 %z
  var %sideCount $lcm($regsubex($1-,/(\d+\.*\d*)/g,$calc(360 / \1)))
  var %armRatio $regsubex($1-,/(\d+\.*\d*)/g,$round($calc(%sideCount / (360 / \1)),1))
  if !$dialog(GeoESides) { dialog -dm geoESides export }
  else { did -f geoESides 2 }
  did -a geoESides 2 Side Count: %sideCount - Ratios: %armRatio - Speeds: $1-
}
alias Lcm {
  var %maxIter 5000
  tokenize 32 $sorttok($1-,32,n)
  var %tolerance 0.5
  while (($abs($calc($token($1,1,58) - $token($token($1-,-1,32),1,58))) > %tolerance) || ($calc($round($token($1,1,58),2) % 1))) && %maxIter > 0   {
    tokenize 32 $sorttok($+($abs($calc($replace($1,:,+))),:,$iif($token($1,2,58),$v1,$abs($1))) $2-,32,n)
    dec %maxIter
  }
  return $round($iif(%maxIter > 0,$token($1,1,58),360),0)
}
dialog bgcolor {
  title "Background Color"
  size -1 -1 119 26
  option dbu
  icon 1, 5 6 15 15
  edit "FFFFFF", 2, 25 12 50 10
  text "Background Color:", 3, 25 4 52 8
  button "Change Color", 4, 79 4 37 18
}

dialog armp {
  title "Arm Options"
  size -1 -1 236 252
  option dbu
  list 1, 1 17 59 209, size extsel vsbar
  check "Draw Selected Arms", 2, 68 25 62 10
  check "Show Selected Arms", 3, 68 13 60 10
  button "Set All To This Value", 4, 168 10 54 12
  button "Set All To This Value", 7, 168 24 54 12
  box "Display Options", 8, 64 2 170 38
  box "Arm Colors", 9, 64 42 171 65
  icon 10, 68 58 15 15
  edit "FFFFFF", 11, 86 62 50 11
  box "Arm Parameters", 12, 64 107 171 90
  icon 13, 68 83 15 15
  edit "FFFFFF", 14, 86 88 50 10
  text "Color I:", 15, 87 54 25 8
  text "Color II:", 16, 87 80 25 8
  text "Length:", 17, 68 122 19 8, right
  edit "", 18, 86 121 50 10
  text "Width:", 19, 70 136 17 8, right
  edit "", 20, 86 135 50 10
  text "Speed:", 21, 69 164 18 8, right
  text "Angle:", 22, 69 178 18 8, right
  button "Set All To This Value", 23, 168 60 54 12
  button "Set All To This Value", 24, 168 86 54 12
  button "Set All To This Value", 25, 168 120 54 12
  button "Set All To This Value", 26, 168 134 54 12
  text "Arms:", 27, 8 7 15 8
  button "+", 28, 44 7 7 7
  button "-", 29, 28 7 7 7
  button "Accept", 30, 2 230 58 19
  edit "", 31, 86 163 50 10
  edit "", 32, 86 177 50 10
  button "Set All To This Value", 33, 168 161 54 12
  button "Set All To This Value", 34, 168 175 54 12
  box "Random", 35, 64 197 171 54
  combo 36, 86 208 50 58, size vsbar drop
  text "Type:", 37, 69 210 17 8, right
  button "Generate", 38, 168 212 54 28
  edit "", 5, 86 222 50 10
  edit "", 6, 86 235 50 10, autohs
  text "Sides:", 39, 62 223 25 8, right
  text "Params:", 40, 62 236 25 8, right
}

dialog export {
  title "Export Drawing"
  size -1 -1 236 62
  option dbu
  text "Your Export Has been printed below:", 1, 67 4 97 8, center
  edit "", 2, 5 17 228 29, read multi vsbar
  button "Copy", 3, 100 48 37 12
}

dialog import {
  title "Import Drawing"
  size -1 -1 236 62
  option dbu
  text "Enter string to import:", 1, 67 4 97 8, center
  edit "", 2, 5 17 228 29, multi vsbar
  button "Import", 3, 100 48 37 12
}

on 1:dialog:geoBg:init:0: {
  Spirograph.Dialog.BGEdit
}
on 1:dialog:geoBg:edit:2 {
  Spirograph.Dialog.BGEdit
}
on 1:dialog:geoBg:sclick:4: {
  if $regex($did($dname,2),/([0-9A-Fa-f]{6})/) {
    var %oldc $hget(Spirograph,BGColor)
    hadd -m Spirograph BGColor $base($regml(1),16,10)
    drawFill -nrs @SpirographBuffer $base($regml(1),16,10) %oldc 0 0
  }
  dialog -c $dname
}
alias Spirograph.Dialog.BGEdit {
  var %id $iif($1,$1,$did)
  if $regex($did($dname,2),/([0-9A-Fa-f]{6})/) {
    window -hp @Armc -1 -1 200 200
    drawrect -nrf @Armc $base($regml(1),16,10) 1 0 0 $window(@Armc).w $window(@Armc).h
    drawsave -b32 @Armc Armc.bmp
    window -c @Armc
    did -g $dname 1 Armc.bmp
  }
}


on 1:dialog:spiroExport:init:0: { did -a $dname 2 $Spirograph.export }
on 1:dialog:geoE*:sclick:3: {
  var %x $did($dname,2).lines,%z
  while %x {
    var %z $did($dname,2,%x) $+ %z
    dec %x
  }
  clipboard %z
  dialog -c $dname
}

on 1:dialog:spiroImport:sclick:3: {
  var %x $did($dname,2).lines,%z
  while %x {
    var %z $did($dname,2,%x) $+ %z
    dec %x
  }
  Spirograph.Import %z
  dialog -c $dname
  Spirograph.InitDrawing
}
;;;;;;;;;;;;;;;;;;;;;
;    Dialog Init    ;
;;;;;;;;;;;;;;;;;;;;;
on 1:dialog:arm*:init:0: {
  if $window(@Armc) { clear @Armc }
  else {  window -hp @Armc -1 -1 200 200 }
  drawsave -b32 @Armc Armc.bmp
  window -c @Armc
  did -g $dname 10 Armc.bmp
  did -g $dname 13 Armc.bmp

  var %x $hget(Spirograph,ArmCount),%y 1
  while %y <= %x {
    did -a $dname 1 %y
    inc %y
  }
  did -c $dname 1 1
  if %x > 0 {
    Spirograph.Dialog.ArmSelect 1
  }
  var %x 1
  while $isalias(Spirograph.Gen $+ %x) {
    did -a $dname 36 Gen $+ %x
    inc %x
  }
  did -c $dname 36 1
  did -o $dname 5 1 $hget(Spirograph,RandSides)
  did -o $dname 6 1 $hget(Spirograph,RandParams)
  hadd -m Spirograph MouseLock 1
  hadd -m Spirograph Mouse.X $calc($window(@Spirograph).w / 2)
  hadd -m Spirograph Mouse.Y $calc(($window(@Spirograph).h - $hget(Spirograph,ScorePadding) * 2 - $hget(Spirograph,Score.h)) / 2)
}
on 1:dialog:arm*:close:0: {  hadd -m Spirograph MouseLock 0 | Spirograph.InitDrawing }
on 1:dialog:arm*:sclick:2-3: { Spirograph.Dialog.ChangeDisplay |  Spirograph.InitDrawing }
on 1:dialog:arm*:edit:11,14: { Spirograph.Dialog.ColorEdit |  Spirograph.InitDrawing }
on 1:dialog:arm*:sclick:1: { Spirograph.Dialog.ArmSelect }
on 1:dialog:arm*:edit:18,20,31,32: { Spirograph.Dialog.ArmEdit | Spirograph.InitDrawing }
on 1:dialog:arm*:edit:5,6: { Spirograph.Dialog.RandEdit }
on 1:dialog:arm*:sclick:25,26,33,34,23,24,4,7: { Spirograph.Dialog.SetAll |  Spirograph.InitDrawing }
on 1:dialog:arm*:sclick:28-29: { Spirograph.Dialog.ChangeArm |  Spirograph.InitDrawing }
on 1:dialog:arm*:sclick:38: { Spirograph.Dialog.GenRand |  Spirograph.InitDrawing }
on 1:dialog:arm*:sclick:30: {
  dialog -c $dname
  hadd -m Spirograph MouseLock 0
  Spirograph.InitDrawing
}
alias Spirograph.Dialog.RandEdit {
  hadd -m Spirograph RandSides $did($dname,5)
  hadd -m Spirograph RandParams $did($dname,6)
}
alias Spirograph.Dialog.GenRand {
  Spirograph. $+ $did($dname,36).seltext $did($dname,5) $did($dname,6)
  Spirograph.Dialog.ArmSelect
  Spirograph.InitDrawing
}
alias Spirograph.Dialog.ChangeDisplay {
  var %state $did($dname,$did).state
  if $did == 3 {
    Spirograph.Dialog.ModifyVar Show %state 1
  }
  else {
    Spirograph.Dialog.ModifyVar Draw %state 1
  }
}
alias Spirograph.Dialog.ChangeArm {
  var %id $iif($1,$1,$did)
  if %id == 28 {
    Spirograph.InitArm
    did -a $dname 1 $hget(Spirograph,ArmCount)
    did -c $dname 1 $hget(Spirograph,ArmCount)
    Spirograph.Dialog.ArmSelect $hget(Spirograph,ArmCount)

  }
  else if $hget(Spirograph,ArmCount) > 1 {
    hdec -m Spirograph ArmCount
    hadd -m Spirograph Arm $+ $calc($v1 - 1) $+ Draw 1
    hdel -w Spirograph Arm $+ $v1 $+ *
    did -d $dname 1 $v1
    did -c $dname 1 $hget(Spirograph,ArmCount)
    Spirograph.Dialog.ArmSelect $hget(Spirograph,ArmCount)
  }

}
alias Spirograph.Dialog.SetAll {
  var %id $iif($1,$1,$did)
  goto %id 0
  :4
  Spirograph.Dialog.ModifyVar Show $did($dname,3).state
  return
  :7
  Spirograph.Dialog.ModifyVar Draw $did($dname,2).state
  return
  :23
  Spirograph.Dialog.ModifyVar Color $calc($base($did($dname,11),16,10))
  return
  :24
  Spirograph.Dialog.ModifyVar Color2 $calc($base($did($dname,14),16,10))
  return
  :25
  Spirograph.Dialog.ModifyVar Length $calc($did($dname,18))
  return
  :26
  Spirograph.Dialog.ModifyVar Width $calc($did($dname,20))
  return
  :33
  Spirograph.Dialog.ModifyVar Speed $calc($did($dname,31))
  return
  :34
  Spirograph.Dialog.ModifyVar StartAngle $calc($did($dname,32))
  return
  :%id
  :0
  return
}
alias Spirograph.Dialog.ArmEdit {
  var %id $iif($1,$1,$did),%val $calc($did($dname,%id))
  goto %id 0
  :18
  Spirograph.Dialog.ModifyVar Length %val 1
  return
  :20
  Spirograph.Dialog.ModifyVar Width %val 1
  return
  :31
  Spirograph.Dialog.ModifyVar Speed %val 1
  return
  :32
  Spirograph.Dialog.ModifyVar StartAngle %val 1
  return
  :%id
  :0
  return
}
alias Spirograph.Dialog.ArmSelect {
  var %select $iif($1,$1,$did($dname,1,$did($dname,1,0).sel).sel)

  did -o $dname 11 1 $base($hget(Spirograph,Arm $+ %select $+ Color),10,16,6)
  did -o $dname 14 1 $base($hget(Spirograph,Arm $+ %select $+ Color2),10,16,6)

  did -o $dname 18 1 $hget(Spirograph,Arm $+ %select $+ Length)
  did -o $dname 20 1 $hget(Spirograph,Arm $+ %select $+ Width)

  did -o $dname 31 1 $hget(Spirograph,Arm $+ %select $+ Speed)
  did -o $dname 32 1 $hget(Spirograph,Arm $+ %select $+ StartAngle)

  did $iif($hget(Spirograph,Arm $+ %select $+ Draw),-c,-u) $dname 2
  did $iif($hget(Spirograph,Arm $+ %select $+ Show),-c,-u) $dname 3

  Spirograph.Dialog.ColorEdit 11
  Spirograph.Dialog.ColorEdit 14
}

alias Spirograph.Dialog.ColorEdit {
  var %id $iif($1,$1,$did)
  if $regex($did(%id),/([0-9A-Fa-f]{6})/) {
    window -hp @Armc -1 -1 200 200
    drawrect -nrf @Armc $base($regml(1),16,10) 1 0 0 $window(@Armc).w $window(@Armc).h
    drawsave -b32 @Armc Armc.bmp
    window -c @Armc
    if %id == 11 {
      did -g $dname 10 Armc.bmp
    }
    else {
      did -g $dname 13 Armc.bmp
    }
  }
  if (!$1) {
    Spirograph.Dialog.ModifyVar $iif(%id == 11,Color,Color2) $calc($base($regml(1),16,10)) 1
  }
}

alias Spirograph.Dialog.ModifyVar {
  var %var $1,%val $2,%select $3
  var %x $iif(%select,$did($dname,1,0).sel,$hget(Spirograph,ArmCount))
  while %x {
    hadd -m Spirograph $+(Arm,$iif(%select,$did($dname,1,%x).sel,%x),%var) %val
    dec %x
  }
  if %var == speed {
    hdel -m Spirograph SideMax
  }
}

alias Spirograph.Export {
  var %x $hget(Spirograph,ArmCount)
  while %x {
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ StartAngle),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Speed),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Length),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Width),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Color),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Color2),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Show),$v1,0)
    var %y %y $iif($hget(Spirograph,Arm $+ %x $+ Draw),$v1,0)
    var %z $+(%y,:,%z)
    var %y
    dec %x
  }
  bset -t &Data 1 $+(%z,;,$iif($hget(Spirograph,Template),$v1,0),;,$iif($hget(Spirograph,RandSides),$v1,0),;,$hget(Spirograph,RandParams))
  var %x $compress(&Data,b)
  var %x $encode(&Data,bm)
  var %output $bvar(&Data,1-).text
  return %output
}

alias Spirograph.Import {
  bset -t &Data 1 $1-
  var %x $decode(&Data,bm)
  var %x $decompress(&Data,bm)
  var %x $token($bvar(&Data,1-).text,1,59)
  var %template $token($bvar(&Data,1-).text,2,59)
  var %sides $token($bvar(&Data,1-).text,3,59)
  var %params $token($bvar(&Data,1-).text,4,59)
  var %y 1
  if ($dialog(ArmParameters)) dialog -c ArmParameters
  if $hget(Spirograph,Drawing) { Spirograph.HandleDraw }
  while $token(%x,%y,58) != $null {
    tokenize 32 $v1
    hadd -m Spirograph Arm $+ %y $+ StartAngle $1
    hadd -m Spirograph Arm $+ %y $+ Speed $2
    hadd -m Spirograph Arm $+ %y $+ Length $3
    hadd -m Spirograph Arm $+ %y $+ Width $4
    hadd -m Spirograph Arm $+ %y $+ Color $5
    hadd -m Spirograph Arm $+ %y $+ Color2 $6
    hadd -m Spirograph Arm $+ %y $+ Show $7
    hadd -m Spirograph Arm $+ %y $+ Draw $8
    hadd -m Spirograph Arm $+ %y $+ Angle $1
    hdel -m Spirograph Arm $+ %y $+ Last.X
    hdel -m Spirograph Arm $+ %y $+ Last.Y
    inc %y
  }
  hadd -m Spirograph RandSides $iif(%sides,$v1,0)
  hadd -m Spirograph RandParams %params
  dec %y
  hadd -m Spirograph ArmCount %y
  hadd -m Spirograph Template %template
  Spirograph.HandleDraw
}

alias Spirograph.ExportRotatix {
  var %color $rgb(15,15,15)
  var %bgColor 0
  var %glowColor $rgb(255,255,255)
  var %glowStrength 2
  var %glowBlurX 6
  var %glowBlurY 6
  var %glowAlpha 40
  var %y $hget(Spirograph,ArmCount),%x 1
  bset -t &Data 1 $+($chr(40),%bgColor)
  var %arm1Speed $hget(Spirograph,Arm1Speed)

  while %x <= %y {
    var %template $iif($hget(Spirograph,Template),360 / $v1,%arm1speed)
    var %armSpeed $calc(($hget(Spirograph,Arm $+ %x $+ Speed) / %arm1Speed) * %template)
    bset -t &Data $calc($bvar(&Data,0) + 1) $+($chr(40),$iif(%x == %y,d,0),v_,%armSpeed,_,%color,_,$hget(Spirograph,Arm $+ %x $+ Length),_1_0,%glowColor,_,%glowAlpha,_,%glowBlurX,_,%glowBlurY,_,%glowStrength,_0_0_) $+ %str
    inc %x
  }
  bset &Data $calc($bvar(&Data,0) + 1) 41 13 13
  var %x $compress(&Data,b)
  var %z $encode(&Data,mb)
  return &Data
}


alias GenRand {
  var %id $ticks
  var %x $1
  tokenize 32 $2-
  var %file Export $+ %id $+ .txt
  .fopen -no %id %file
  while %x {
    var %rand $ [ $+ [ $r(1,$0) ] ]
    var %armCount $r(18,27)
    hadd -m Spirograph ArmCount %armcount
    echo -a Generating Image with $+(,%armCount,) arms using: %rand
    %rand
    Spirograph.ExportRotatix
    .fwrite -bn %id &Data
    .fwrite -n %id $crlf
    ;echo -a Wrote $qt($bvar(&Data,0)) bytes
    bunset &Data
    dec %x
  }
  run %file
  .fclose %id
}

alias rotatixEnc {
  tokenize 32 $1-
  var %str 360 / (sideCount / (key - (((floor(x / (2^(b*(n-1)))) / (2^b)) - floor(floor(x / (2^(b*(n-1)))) / (2^b))) * (2^b))))
  var %bits 8
  var %key $calc(2^ (%bits - 1) - 1)
  var %sideCount $1
  tokenize 32 $2-
  var %x 1,%y
  while %x <= $0 {
    var %deg $ [ $+ [ %x ] ] % %key
    var %offset $calc((%key - %deg) * 2^(%bits * (%x - 1)))
    inc %y %offset
    inc %x
  }
  return $replace(%str,x,%y,key,%key,sideCount,%sideCount,b,%bits)
}

;;;;;;;;
; Menu ;
;;;;;;;;

menu * {
  -
  Spirograph: /Spirograph.InitGui
  }