View difference between Paste ID: ihYDUd7s and LGNUpDzz

--- Analogue Clock
+-- side of the computer that the monitor is attached to
--- (c) Ramdor 2013
+local monitor = peripheral.wrap("back")
--- v1.6
+
---
+local nClockRad = 18
--- changes
+
--- v1.6 - added non filled face option (bFaceFilled = true  ... is the default)
+
--- v1.5 - now uses computercraft paintutils line, re-worked circle code, auto find monitor
+
--- v1.4 - colours added and some loop derps fixed
+
--- v1.3 - added resize/auto scale and 0.5 textsize
+
---        to double the effective resolution
+
--- v1.2 - changed timer code
+
--- v1.1 - tidy up
+
--- v1.0 - initial release
+print("Orologio fatto da Mr.Alko99 2013")
---
+print("Premi 'Q' per spegnere.")
--- You may edit/copy/redistribute/whatever this
+
--- code in any way.  Just a credit listing this
+term.setBackgroundColor(colors.black)
--- pastebin link (pastebin.com/LGNUpDzz) will be fine :)
+
--- Have fun, I did :)
+
 -- some variables
--- see  http://www.youtube.com/watch?v=RrgOIGW0C-s   for some more info
+
 local m = 0 -- parsed minute
 local nOldHX = -1
 local nOldHY = -1
 local nOldMX = -1
 local nOldMY = -1
-local bFaceFilled = true
+
 local function plot(s,x,y)
--- coloured clocks anyone?
+
-local nBackColour = colors.blue
+
-local nFaceColour = colors.white
+
-local nHandColour = colors.blue
+
-local nTickColour = colors.lightBlue
+local function approx(v)
   if(v>=0) then
--- find the monitor and set it up
+    return math.floor(v+0.5)
-local monitor = nil
+  else
-local i,side
+    return math.ceil(v+0.5)
-for i, side in pairs(rs.getSides()) do
+
-  if peripheral.getType(side) == "monitor" then
+
-    monitor = peripheral.wrap(side)
+
-    break
+local function line(x0, y0, x1, y1)
   if x0==x1 and y0==y1 then
     return false
-if monitor==nil then
+
-  print("NO MONITOR FOUND")
+
-  print("Please attach a monitor and try again.")
+  if x0==x1 then
-  return
+    if y0>y1 then
       inc=-1
     else
--- calculate scaling
+      inc=1
-monitor.setTextScale(0.5)
+
 
--- hackish fix to enable large monitor arrays enough time to initialise?
+    for y=y0,y1,inc do
-os.sleep(1)
+      plot(".",x0,y)
     end
-local mw,mh = monitor.getSize()
+
-mw = mw / (15/10) -- 15x10 is w,h of 0.5 scale single monitor
+    return true
-local minSize = (math.min(mw,mh) / 2) - 2
+
 
   if y0==y1 then
--- or you can use minSize which attempts to fit
+    if x0>x1 then
--- to monitor size automatically
+      inc=-1
-local nClockRad = minSize
+
       inc=1
     end
 
     for x=x0,x1,inc do
-print("Clock by Ramdor (c) 2013")
+      plot(".",x,y0)
-print("Press 'Q' to terminate.")
+
 
-term.setBackgroundColor(nBackColour)
+    return true
   end
 
   if x0~=x1 and y0~=y1 then
     m=(y1-y0)/(x1-x0)
 
     if m<1 and m>-1 then
       n=y0-m*x0
       if x0>x1 then
         inc=-1
       else
         inc=1
       end
 
       for x=x0,x1,inc do
         y=m*x+n
         y=approx(y)
         plot(".",x,y)
       end
       return true
     else
       m=(x1-x0)/(y1-y0)
       n=x0-m*y0
       if y0>y1 then
-  local nOutRadius = nClockRad-2
+        inc=-1
       else
         inc=1
       end
 
       for y=y0,y1,inc do
         x=m*y+n
         x=approx(x)
         plot(".",x,y)
       end
       return true
     end
   end
 end
-    paintutils.drawLine(xi,yi,x,y,nTickColour)
+
 -- the clock face ticks
 local function ticks(nW,nH)
   local nIndex
   local x
--- by working out a quarter of the points
+
--- then drawing lines from oposite quarter
+
--- results in much faster circle code
+
   local nInRadius = nClockRad-(nClockRad/4)
   local nOutRadius = nClockRad-1
 
   local nxOutRad = nOutRadius + (nOutRadius/2)
   local nyOutRad = nOutRadius
-  local nyRad = nRadius
+
   local nyInRad = nInRadius
 
   for nIndex=0,359,(360/12) do
-  local points = {}
+
-  local xy
+    term.setBackgroundColor(colors.black)
-  local n = 1
+
     x = nW + math.sin(math.rad(nIndex)) * nxOutRad
-  for nIndex=0,89 do
+
-    x = math.sin(math.rad(nIndex)) * nxRad
+
-    y = math.cos(math.rad(nIndex)) * nyRad
+
-    x = math.floor(x)
+
-    y = math.floor(y)
+
     line(xi,yi,x,y)
-    -- only store positions if they are different from last time
+
 end
-      xy = {}
+
-      xy[1] = x
+
-      xy[2] = y
+-- which is essentially a line from
-      points[n] = xy
+-- centre to all points on the circle
 -- in character terms.  Who cares about
-      if y~=nOldY or not bFaceFilled then
+-- overlap ;)
-        n=n+1
+
   local nIndex
   local x
   local y
   local nxRad = nRadius + (nRadius/2)
   local nyRad = nRadius
   local nOldX = -1
   local nOldY = -1
-  -- plot the circle
+
-  for nIndex=1,#points do
+  for nIndex=0,359 do
-    x = points[nIndex][1]
+    x = nW + math.sin(math.rad(nIndex)) * nxRad
-    y = points[nIndex][2]
+    y = nH + math.cos(math.rad(nIndex)) * nyRad
 
-    if bFaceFilled then
+    -- the circle
-      paintutils.drawLine(nW-x,nH+y,nW+x,nH+y,nFaceColour)
+    -- only do it if the positions are different from last time
-      paintutils.drawLine(nW-x,nH-y,nW+x,nH-y,nFaceColour)
+    -- speeds things up a bit
     if x~=nOldX or y~=nOldY then
-      paintutils.drawPixel(nW-x,nH+y,nFaceColour)
+      term.setTextColor(colors.white)
-      paintutils.drawPixel(nW+x,nH+y,nFaceColour)
+      term.setBackgroundColor(colors.white)
-      paintutils.drawPixel(nW-x,nH-y,nFaceColour)
+
-      paintutils.drawPixel(nW+x,nH-y,nFaceColour)
+      line(nW,nH,x,y)
 
       nOldX = x
       nOldY = y
     end
   end
 end
 
 -- parse the time into H and M
 -- these are stored globally in h and m
 local function parseTime()
   local t = os.time()
   local sT = textutils.formatTime(t, true)
 
   local n = string.find(sT, ":")
 
   if(n>0) then
     h = tonumber(string.sub(sT,1,n-1))
     m = tonumber(string.sub(sT,n+1))
   end
 end
 
 -- plot minute hand
-  local nTmpColour
+
 -- then draws the new one
 local function plotM(nW,nH,nX,nY)
   if(nOldMX==nX and nOldMY==nY) then
     return
   end
 
   -- remove previous by drawing it again
   -- in the face colour.  Also remove the
   -- hand tag
-    if bFaceFilled then
+
-      nTmpColour = nFaceColour
+    term.setTextColor(colors.white)
     term.setBackgroundColor(colors.white)
-      nTmpColour = nBackColour
+    line(nW,nH,nOldMX,nOldMY)
 
-    paintutils.drawLine(nW,nH,nOldMX,nOldMY,nTmpColour)
+
       plot(".",nOldMX,nOldMY)
     end
   end
 
   nOldMX = nX
   nOldMY = nY
 
   term.setTextColor(colors.black)
   term.setBackgroundColor(colors.black)
-  paintutils.drawLine(nW,nH,nX,nY,nHandColour)
+  line(nW,nH,nX,nY)
 
   -- draw the centre O
   term.setTextColor(colors.black)
   term.setBackgroundColor(colors.lightGray)
   plot("O",nW,nH)
 
   if(bShowMinuteChar) then
     -- draw the minute hand tag
     term.setTextColor(colors.black)
     term.setBackgroundColor(colors.lightGray)
     plot("M",nX,nY)
   end
 end
 
 -- plot hour hand
 -- it removes the previous hour hand
-  local nTmpColour
+
 local function plotH(nW,nH,nX,nY)
   if(nOldHX==nX and nOldHY==nY) then
     return
   end
 
   -- remove previous by drawing it again
   -- in the face colour.  Also remove the
   -- hand tag
-    if bFaceFilled then
+
-      nTmpColour = nFaceColour
+    term.setTextColor(colors.white)
     term.setBackgroundColor(colors.white)
-      nTmpColour = nBackColour
+    line(nW,nH,nOldHX,nOldHY)
 
-    paintutils.drawLine(nW,nH,nOldHX,nOldHY,nTmpColour)
+
       plot(".",nOldHX,nOldHY)
     end
   end
 
   nOldHX = nX
   nOldHY = nY
 
   term.setTextColor(colors.black)
   term.setBackgroundColor(colors.black)
-  paintutils.drawLine(nW,nH,nX,nY,nHandColour)
+  line(nW,nH,nX,nY)
 
   if(bShowHourChar) then
     -- draw the hour hand tag
     term.setTextColor(colors.black)
     term.setBackgroundColor(colors.lightGray)
     plot("H",nX,nY)
   end
 end
 
 local fH
 local fM
 local fXH
 local fYH
 local fXM
 local fYM
 local nyMRadius = nClockRad - (nClockRad / 4)
 local nyHRadius = nClockRad - (nClockRad / 2)
 
 local nxMRadius = nyMRadius + (nyMRadius / 2)
 local nxHRadius = nyHRadius + (nyHRadius / 2)
 local nW, nH = term.getSize()
 
 nW = (nW / 2)+1
 nH = (nH / 2)+1
 
 -- plot the circle
 face(nW,nH,nClockRad + 1)
 
 local bRunning = true
 local nTimer
 nTimer = os.startTimer(0.25) -- the timer interval to update the clock
 
 while(bRunning) do
   parseTime()
 
   fH = (((h % 12)/12) + (m/60/12)) * 360
   fM = (m/60) * 360
 
   -- shift by half a circle
   fH = fH + 180
   fM = fM + 180
 
   fXH = math.sin(math.rad(-fH))
   fYH = math.cos(math.rad(fH))
   fXM = math.sin(math.rad(-fM))
   fYM = math.cos(math.rad(fM))
 
   plotH(nW,nH,  nW + fXH * nxHRadius, nH + fYH * nyHRadius)
   plotM(nW,nH, nW + fXM * nxMRadius, nH + fYM * nyMRadius)
 
   -- draw the ticks on
   ticks(nW,nH)
 
   local event, param1 = os.pullEvent()
 
   while (not (event=="timer" and param1==nTimer) and event~="char") do
     event, param1 = os.pullEvent()
   end
 
   if(event=="char") then
      if(param1=="q" or param1=="Q") then
        bRunning=false
      end
   elseif(event=="timer" and param1==nTimer) then
      -- timer timed out, lets start again
      nTimer = os.startTimer(0.25)
   end
 end
 
 term.restore()
 print("Ended.")