Leatherman Draw

line := func(x1, y1, x2, y2 float64, c color.Color) {
	m := (y2 - y1) / (x2 - x1)
	// y = m*x + b
	// y - m*x = b
	// b = y - m*x
	b := y1 - m*x1
	// keep reading, the use of l is so silly
	l := math.Sqrt(math.Pow(x2-x1, 2) + math.Pow(y2-y1, 2))
	if m == math.Inf(1) || m == math.Inf(-1) { // checked for Inf instead of just seeing if y1 == y2
		start, end := y1, y2
		if start > end {
			start, end = end, start
		}
		for y := start; y <= end; y += l / 1000 { // frew why are there always 1000 steps?
			img.Set(int(math.Round(x1)), int(math.Round(y)), c)
		}
	} else {
		start, end := x1, x2
		if start > end {
			start, end = end, start
		}

		for x := start; x <= end; x += l / 1000 { // yet another thousand, for reasons
			y := m*x + b // this is sane, but not great
			img.Set(int(math.Round(x)), int(math.Round(y)), c)
		}
	}
}

line := func(x1, y1, x2, y2 float64, c color.Color) {
	// special case horizontal and vertical lines for better performance
	if math.Round(x1) == math.Round(x2) {
		for y := y1; y < y2; y++ {
			img.Set(int(math.Round(x1)), int(math.Round(y)), c)
		}
		return
	} else if math.Round(y1) == math.Round(y2) {
		for x := x1; x < x2; x++ {
			img.Set(int(math.Round(x)), int(math.Round(y1)), c)
		}
		return
	}

	m := (y2 - y1) / (x2 - x1)

	// depending on the slope, use x or y for dependent variable.
	// This is really important!  If you get this wrong you get
	// really weird graphs.  I'll include a screenshot below and describe
	// why.
	if m >= -1 && m <= 1 {
		y := y1
		start, end := x1, x2
		if start > end {
			start, end = end, start
			y = y2
		}

		// b is gone; we just start at the start
		for x := start; x <= end; x++ {
			img.Set(int(math.Round(x)), int(math.Round(y)), c)
			// Instead of recalculating for each run, just add the
			// slope!  Possibly more rounding errors but way, way
			// faster.
			y += m
		}
	} else {
		// see above comments, basically the same here.
		m1 := (x2 - x1) / (y2 - y1)
		x := x1
		start, end := y1, y2
		if start > end {
			start, end = end, start
			x = x2
		}

		for y := start; y <= end; y++ {
			img.Set(int(math.Round(x)), int(math.Round(y)), c)
			x += m1
		}

	}
}

L.SetGlobal("circ", L.NewFunction(func(L *lua.LState) int {
	x := int(L.CheckNumber(1))
	y := int(L.CheckNumber(2))
	r := float64(L.CheckNumber(3))
	border := checkColor(L, 4)
	fill := checkColor(L, 5)

	// I am doing over a thousand iterations for a circle with a radius of 20.  Not great!
	for t := 0.0; t < 2*math.Pi*r; t += 0.1 /* uhh */ {
		xt := r*math.Cos(t) + float64(x)
		yt := r*math.Sin(t) + float64(y)

		// drawing lines from the center out makes some sense
		// but ends up leaving gaps here and there
		line(float64(x), float64(y), xt, yt, fill)
		img.Set(int(math.Round(xt)), int(math.Round(yt)), border)
	}
	return 0
}))

L.SetGlobal("circ", L.NewFunction(func(L *lua.LState) int {
	xc := int(L.CheckNumber(1))
	yc := int(L.CheckNumber(2))
	r := float64(L.CheckNumber(3))

	border := checkColor(L, 4)
	fill := checkColor(L, 5)

	for x := int(-r); x <= int(r); x++ {
		for y := int(-r); y <= int(r); y++ {
			if x*x+y*y <= int(r*r) { // check if inside cirlce, rather than drawing a line
				img.Set(x+xc, y+yc, fill)
			}
		}
	}

	// improve with http://weber.itn.liu.se/~stegu/circle/circlealgorithm.pdf
	for t := 0.0; t < 2*math.Pi; t += 1 / r {
		xt := r*math.Cos(t) + float64(xc)
		yt := r*math.Sin(t) + float64(yc)

		img.Set(int(math.Round(xt)), int(math.Round(yt)), border)
	}

	return 0
}))

debugDraw := func(string, image.Image) error { return nil }
cleanup = func() error { return nil }

if d := os.Getenv("LM_DEBUG_DRAW"); d != "" {
	dgif := &gif.GIF{}
	shouldDebug := regexp.MustCompile(d)
	e, err := os.Create("debug.log")
	if err != nil {
		panic(err)
	}

	debugDraw = func(name string, img image.Image) error {
		if !shouldDebug.MatchString(name) {
			return nil
		}

		fmt.Fprintln(e, name)
		frame := image.NewPaletted(img.Bounds(), palette)
		draw.Over.Draw(frame, img.Bounds(), img, image.Point{})
		dgif.Image = append(dgif.Image, frame)
		dgif.Delay = append(dgif.Delay, 1) // 10ms, minimum delay
		return nil
	}
	cleanup = func() error {
		defer e.Close()
		f, err := os.Create("debug.gif")
		if err != nil {
			return err
		}
		defer f.Close()

		if err := gif.EncodeAll(f, dgif); err != nil {
			return err
		}

		return nil
	}
}

for t = 0, 64, 0.01 do
   set(64+sin(t)*t, 64+cos(t)*t, rgb(255, t*5, 0))
end

require "math"
for x = 0, 128 do
  for y = 0, 128 do
     color = math.random()
     set(x, y, rgb(color, color, color))
  end
end

require "math"
for x = 0, 128 do
  for y = 0, 128 do
     set(x, y, rgb(math.random(), math.random(), math.random()))
  end
end

require "math"
for x = 0, 128 do
  for y = 0, 128 do
     r = 255*x/128*math.random()
     g = x/128*255*math.random()
     b = 255*math.random()
     set(x, y, rgb(r, g, b))
  end
end

rect(0, 0, 128, 128, black, black)
for t = 0, 64, 0.01 do
   x = 64+sin(t)*cos(t)*t
   y = 64+sin(t)*t
   set(x, y, rgb(255, x/128*255, y/128*255))
end