I know they're poorly written, but they at least work :)

util = util or {}

pr = pr or {} -- Presets

pr.burn = function()
tpt.el.fire.flammable = 9999
tpt.el.plsm.flammable = 9999
tpt.el.lava.flammable = 9999
end

pr.allburn = function()
for k = 1, 145 do
if k ~= 11 and k ~= 130 then
local str = 'tpt.el.' .. string.gsub(string.lower(tpt.element(k)), '-', '') .. '.flammable=9999'
local f = io.open('allburn','w')
f:write(str)
f:close()
dofile('allburn')
end
end
end

bit.oldfromhex = function(str) --Do not use, I made a faster one
local str = tostring(str)
local num = 0
local cnum
for k = 1, #str do
local cstr = string.lower(string.sub(str, k, k))
if cstr == 'a' then cnum = 10
elseif cstr == 'b' then cnum = 11
elseif cstr == 'c' then cnum = 12
elseif cstr == 'd' then cnum = 13
elseif cstr == 'e' then cnum = 14
elseif cstr == 'f' then cnum = 15
elseif string.gsub(cstr, '%d', 'NUM') ~= 'NUM' then cnum = 0
else cnum = tonumber(cstr)
end
num = num + (cnum * 16 ^ (#str - k))
end
return num
end

bit.fromhex = function(str)
return tonumber(tostring(str))
end

util.test_func = function(func, iter, ...)
local ct = os.clock()
for k = 1, iter do
func(...)
end
local nt = os.clock()
return nt - ct
end

util.assert = function(errstr, ...)
if not errstr then return ... else return errstr end
end

util.argb = function(a, r, g, b)
return '0x' .. bit.tohex(a, 2) .. bit.tohex(r, 2) .. bit.tohex(g, 2) .. bit.tohex(b, 2)
end

util.propreplace = function(prop, old, nprop, new)
old = type(old) == 'string' and tpt.element(old) or old
new = type(new) == 'string' and tpt.element(new) or old
for x = 1, 610 do
for y = 1, 380 do
if tpt.get_property('type', x, y) ~= 0 then
if tpt.get_property(prop, x, y) == old then
tpt.set_property(nprop, new, x, y)
end
end
end
end
end

tpt.point = function(x, y, e, r, g, b, a)
if not e then e, r, g, b, a = 'dmnd', 255, 255, 255, 255 --Default to DMND
elseif not r then r, g, b, a = 255 --Default to white
elseif not a then a = 255 end --Default to opaque
local _, errstr --[[I use util.assert a lot...]] = tpt.create(x, y, e);
if r and g and b and a and not(errstr) then
local _, errstr = tpt.set_property('dcolor', util.argb(a, r, g, b), x, y)
end
return util.assert(errstr, true)
end

tpt.rect = function(x1, y1, x2, y2, e, r, g, b, a)
tpt.line(x1, y1, x1, y2, e, r, g, b, a)
tpt.line(x1, y2, x2, y2, e, r, g, b, a)
tpt.line(x2, y2, x2, y1, e, r, g, b, a)
tpt.line(x2, y1, x1, y1, e, r, g, b, a)
end

tpt.solidrect = function(x1, y1, x2, y2, e, r, g, b, a)
for x = x1, x2 do
for y = y1, y2 do
local _, errstr = tpt.point(x, y, e, r, g, b, a)
end
end
return util.assert(errstr, true)
end

tpt.line = function(x1, y1, x2, y2, e, r, g, b, a)
if x1 > x2 then x1, x2 = x2, x1 end --If the xcoords are in the wrong order, switch 'em
if y1 > y2 then y1, y2 = y2, y1 end
local xs = x2 - x1
local ys = y2 - y1
if xs >= ys then --Avoid unfinished line
for x = x1, x2 do
tpt.point(x, y1 + x * ys / xs, e, r, g, b, a)
end
else
for y = y1, y2 do
tpt.point(x1 + xs / ys, y, e, r, g, b, a)
end
end
end

tpt.ellipse = function(x1, y1, x2, y2, e, r, g, b, a) --Doesn't work yet!!
if x1 > x2 then x1, x2 = x2, x1 end
if y1 > y2 then y1, y2 = y2, y1 end
local w = (x2 - x1) / 2
local h = (y2 - y1) / 2
local mx = x2 - w
local my = y2 - h
for k = 0, 1000 do
tpt.line(mx + w * math.sin(k - .01), my + h * math.cos(k - .01), mx + w * math.sin(k), my + h * math.cos(k), e, r, g, b, a)
end
end

Sorry for not putting it in code tags, that never works well for me.

@boxmein: Thanks, I was going to do something like that but you seem to have just about covered it.