TI-Nspire Lua Editor: Play/Reset Script

Play with the script in the text box below, and then click the "run your code" button above.

platform.apilevel = '1.0'     
-- Lua Play/Reset Sampler
-- Steve Arnold January 2015
-- steve.arnold@ti.com

-- Section 1 (Lines 20 - ): Initial values, resize and paint

-- Section 2: 185: Play/Reset class
         --   340: Rectangle class
         
-- Section 3: 370. KeyBoard and mouse Controls

-- Section 4: 420. Menus

------------------------------------------------
local screen = platform.window
local w = screen:width()
local h = screen:height()
local grabx
local graby
local Offsetx
local Offsety
local width
local startX = 0
local startY = h/2
local step = 0.1*w
local Turn = 0

color = {
		navy = {50,50,211},
		blue = {0, 0, 255},
		dodgerblue = {30,144,255},
		green = {0, 255, 0},
		brown = {165,42,42},
		orange = {255,165,0},
		yellow = {255,255,0},
		red = {255, 0, 0},
		magenta = {255,0,255},
		white = {255, 255, 255},
        lightgray = {211,211,211},
        gray = {128,128,128},
		black = {0, 0, 0},
	}
	
	Colors = {
    		{50,50,211},
    		{0, 0, 255},
    		{30,144,255},
    		{0, 255, 0},
    		{165,42,42},
    		{255,165,0},
    		{255,255,0},
    		{255, 0, 0},
    		{255,0,255},
    		{255, 255, 255},
            {211,211,211},
            {128,128,128},
    		{0, 0, 0},
    	}
   
--------------------------------

function on.construction()
    w = screen:width() or 318
    h = screen:height() or 212
    
    on.resize()
    screen:invalidate()
end

function on.resize()

w = 800
	h = 600
	
        if not w or w <= 0 then w = 318 end
        if not h or h <=0 then h = 212 end

-- Play/Reset Controls

Offsetx = 0
	Offsety = 0
	width = w / 12.5
	startX = 0
    startY = h/2 - width
    Turn = 0
	
	timer.stop()
    pause = false

grabx = 0.825*w
	graby = 0.825*h

grabx = grabx < w and grabx or 0.8 * w
	graby = graby < h and graby or 0.01 * h

controls = PlayReset(grabx, graby, width, 0.2 * width, playActions)
    SteeringWheel = Steering(0.975*w - width, 0.025*h + width, 2*width, 0.975*w - width + 2*width*math.cos(Turn)/2, 0.025*h + width + width*math.sin(Turn)/2, 0.05*h, color.blue, Turn)
    mBot = Rectangle(startX + width, startY + width, 2*width, 2*width, "mBot", nil, black)

screen:invalidate()

end

function on.paint(gc)

gc:setColorRGB(unpack(color.lightgray))
	gc:fillRect(0,0,w,h)

--Control panel
	controls:paint(gc)
	SteeringWheel:paint(gc)
    mBot:paint(gc)

gc:setColorRGB(unpack(color.black))

fontSize = math.floor(w/52 + 0.5)
    fontSize = math.floor(fontSize)
    fontSize = fontSize > 6 and fontSize or 7
    gc:setFont("serif", "i", fontSize)

local str = "Try using the Play/Reset control panel"
    local sw = gc:getStringWidth(str)
    gc:drawString(str, 0.025*w, 0.75*h, "middle")

local str = "to start and pause the robot"
    local sw = gc:getStringWidth(str)
    gc:drawString(str, 0.025*w, 0.825*h, "middle")

local str = "Turn using the steering wheel at top right"
    local sw = gc:getStringWidth(str)
    gc:drawString(str, 0.025*w, 0.9*h, "middle")

end

---------------------------------------------------------------------------

-- Actions

function on.timer()

if mBot.x > w - 2*width then
                step = -1*step
                Turn = math.pi - Turn
         
         elseif mBot.x < 0 then
                step = -1*step  
                Turn = math.pi - Turn 
         end
        
        
         if mBot.y > h - width then
                Turn = 1*(math.pi - Turn)
        elseif mBot.y < 0 then
                Turn = 1*(math.pi - Turn)   
        end
        
        mBot.x = mBot.x + step
        mBot.y = mBot.y + step*(math.tan(-1*Turn))
        mBot.rotate = Turn             
                
        screen:invalidate()
end

function playActions()

pause = not pause
    if pause then timer.start(0.2) else timer.stop() end
    screen:invalidate()

end

function on.arrowKey(key)
	if key == "left" then
		startX = startX - step
	elseif key == "right" then
		startX = startX + step
	elseif key == "up" then
        Turn = Turn + math.pi/10
    elseif key == "down" then
         Turn = Turn - math.pi/10
	end

screen:invalidate()
end

---------------------------------------------------------------------------

PlayReset = class()

function PlayReset:init(x, y, width, height, actions)
	self.x = x
	self.y = y
	self.width = width
	self.height = height
	self.actions = actions
	
end

function PlayReset:contains(x, y)
	local sw = self.width
	local sh = self.height
	return x >= self.x and x <= self.x + 2*sw and
			y >= self.y and y <= self.y + 1.2*sw
end

function PlayReset:paint(gc)

w, h = 800, 600

gc:setPen("thin", "smooth")
    gc:setColorRGB(unpack(color.gray))
    gc:fillRect(self.x, self.y, 2*self.width, 0.2*self.width)
    gc:setColorRGB(unpack(color.black))
    gc:drawRect(self.x, self.y, 2*self.width, 0.2*self.width)

local x = self.x
	local y = self.y + 0.2*self.width
	local iw = self.width
	local ih = self.width
    
    	local border  = {
		x , y + ih*.1, --start
		x + iw*.1, y, -- top left /
		x + 1.9*iw, y, -- top -
		x+ 2*iw, y + ih*.1, -- top right \
		x + 2*iw ,y + .9*ih,--right |
		x + 1.9*iw , y + ih, -- botttom /
		x + iw*.1, y + ih, --bottom -
		x, y + .9*ih, --bottom \
		x , y + ih*.1, -- bottom |
	}
	gc:setColorRGB(unpack(color.white))
	gc:fillPolygon(border)
	gc:setColorRGB(0,0,0)
	gc:setPen("thin", "smooth")
	gc:drawPolyLine(border)

gc:setColorRGB(unpack(color.blue))
		gc:fillRect (x + 2*iw*.1, y+ ih*.1, .2*iw ,.8*ih )          
		gc:fillPolygon({
			x + .9*iw, y+ ih*.1,
			x + .9*iw, y+.9*ih,
			x + .4*iw, y+ih/2,
			x + .9*iw, y+ ih*.1,
			})            
		gc:setColorRGB(0,0,0)
		gc:drawRect (x + iw*.2, y+ ih*.1, .2*iw ,.8*ih  ) 
		gc:drawPolyLine({
			x + .9*iw, y+ ih*.1,
			x + .9*iw, y+.9*ih,
			x + .4*iw, y+ih/2,
			x + .9*iw, y+ ih*.1,
			})
		
    	if not pause then
		gc:setColorRGB(unpack(color.green))
		gc:fillPolygon({
			x + iw*1.2, y+ ih*.1,
			x + 1.8*iw, y+ih/2,
			x+ih*1.2, y+.9*ih,
			})
		
		gc:setColorRGB(0,0,0)
		gc:drawPolyLine({
			x + iw*1.2, y+ ih*.1,
			x + 1.8*iw, y+ih/2,
			x+ih*1.2, y+.9*ih,
			x + iw*1.2, y+ ih*.1,
			})

else
		gc:setColorRGB(unpack(color.blue))
		gc:fillRect (x + iw*1.6, y+ ih*.1, .3*iw ,.8*ih ) 
		gc:fillRect (x + iw*1.2, y+ ih*.1, .3*iw ,.8*ih ) 
		gc:setColorRGB(0,0,0)
		gc:drawRect (x + iw*1.6, y+ ih/10, .3*iw ,.8*ih ) 
		gc:drawRect (x + iw*1.2, y+ ih*.1, .3*iw ,.8*ih )

end
end

function PlayReset:mouseDown(x, y)

if self:contains(x, y) then
	    self.selected = true
	    	
	    grabx = self.x
        graby = self.y

end

screen:invalidate()

end

function PlayReset:mouseUp(x, y)

if self:contains(x, y) then
	    
 	    if y > self.y + 0.2*self.width then
             if x > self.x + self.width then
        	    playActions()
             else
               on.escapeKey()
             end
         end
		self.selected = false		
	   end

screen:invalidate()
end

function PlayReset:mouseMove(x, y)

w = 800
    h = 600
    
	if self.selected then
	if x > 0 and x < w - self.width and y > 0 and y < h - self.height then
        self.x = x
        self.y = y
		Offsetx = self.x - x
		Offsety = self.y - y
	    	
	    grabx = self.x + Offsetx
        graby = self.y + Offsety
    end
    end

screen:invalidate()
end

---------------------------------------------------------------------------

Rectangle = class()

function Rectangle:init(x, y, width, height, name, image, color, visible)
	self.x		= x
	self.y		= y
	self.width	= width or 20
	self.height	= height or 20
	self.color = color
	self.name = name
	self.image = image
	self.rotate = Turn
	self.selected = false
	self.visible = visible
end

function Rectangle:contains(x, y)
	local sw = self.width
	local sh = self.height
	return x >= self.x - sw/2 and x <= self.x + sw/2 and
	       y >= self.y - sh/2 and y <= self.y + sh/2
end

function Rectangle:paint(gc)

local cx = self.x
    local cy = self.y
    local turn = self.rotate
    
    if self.visible ~= false then
	gc:setColorRGB(unpack(color.gray))
	
	if self.image then
	local im = image.copy(self.image, self.width, self.height)

if self.name == "mBot" then im = image.rotate(im, Turn*180/math.pi) end
	
	gc:drawImage(im, self.x - self.width / 2, self.y - self.height / 2)
	
	else

if self.name == 'mBot' then
               gc:setPen("thin", "smooth")
           -- frame   
           
           local frame = {cx - self.width/2, cy - self.height/2,
                             cx + self.width/2, cy - self.height/2,
                             cx + self.width/2, cy + self.height/2,
                             cx - self.width/2, cy + self.height/2,
                             cx - self.width/2, cy - self.height/2}

local rotateVertices = rotatePoly(cx, cy, frame, -turn)
 
               gc:setColorRGB(unpack(color.dodgerblue))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)
           
           -- eyes

local eyeLeft = {self.x + self.width*0.4, self.y - self.height*0.4,
                            self.x + self.width*0.4 + 0.05*h, self.y - self.height*0.4,
                            self.x + self.width*0.4 + 0.05*h, self.y - self.height*0.4 + 0.05*w,
                            self.x + self.width*0.4, self.y - self.height*0.4 + 0.05*w,
                            self.x + self.width*0.4, self.y - self.height*0.4
                            }
           local rotateVertices = rotatePoly(cx, cy, eyeLeft, -turn)

gc:setColorRGB(unpack(color.white))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)

local eyeRight = {self.x + self.width*0.4, self.y + self.height*0.1,
                            self.x + self.width*0.4 + 0.05*h, self.y + self.height*0.1,
                            self.x + self.width*0.4 + 0.05*h, self.y + self.height*0.1 + 0.05*w,
                            self.x + self.width*0.4, self.y + self.height*0.1 + 0.05*w,
                            self.x + self.width*0.4, self.y + self.height*0.1
                            }
           local rotateVertices = rotatePoly(cx, cy, eyeRight, -turn)

gc:setColorRGB(unpack(color.white))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)
           
           
          
           -- wheels

local wheelBL = {self.x - self.width*0.4, self.y - self.height*0.6,
                            self.x - self.width*0.4 + 0.05*w, self.y - self.height*0.6,
                            self.x - self.width*0.4 + 0.05*w, self.y - self.height*0.6 + 0.05*h,
                            self.x - self.width*0.4, self.y - self.height*0.6 + 0.05*h,
                            self.x - self.width*0.4, self.y - self.height*0.6
                            }
           local rotateVertices = rotatePoly(cx, cy, wheelBL, -turn)

gc:setColorRGB(unpack(color.gray))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)

local wheelFL = {self.x + self.width*0.1, self.y - self.height*0.6,
                            self.x + self.width*0.1 + 0.05*w, self.y - self.height*0.6,
                            self.x + self.width*0.1 + 0.05*w, self.y - self.height*0.6 + 0.05*h,
                            self.x + self.width*0.1, self.y - self.height*0.6 + 0.05*h,
                            self.x + self.width*0.1, self.y - self.height*0.6
                            }
           local rotateVertices = rotatePoly(cx, cy, wheelFL, -turn)

gc:setColorRGB(unpack(color.gray))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)

local wheelBR = {self.x - self.width*0.4, self.y + self.height*0.4,
                            self.x - self.width*0.4 + 0.05*w, self.y + self.height*0.4,
                            self.x - self.width*0.4 + 0.05*w, self.y + self.height*0.4 + 0.05*h,
                            self.x - self.width*0.4, self.y + self.height*0.4 + 0.05*h,
                            self.x - self.width*0.4, self.y + self.height*0.4
                            }
           local rotateVertices = rotatePoly(cx, cy, wheelBR, -turn)

gc:setColorRGB(unpack(color.gray))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)

local wheelFR = {self.x + self.width*0.1, self.y + self.height*0.4,
                            self.x + self.width*0.1 + 0.05*w, self.y + self.height*0.4,
                            self.x + self.width*0.1 + 0.05*w, self.y + self.height*0.4 + 0.05*h,
                            self.x + self.width*0.1, self.y + self.height*0.4 + 0.05*h,
                            self.x + self.width*0.1, self.y + self.height*0.4
                            }
           local rotateVertices = rotatePoly(cx, cy, wheelFR, -turn)

gc:setColorRGB(unpack(color.gray))
               gc:fillPolygon(rotateVertices)
               gc:setColorRGB(unpack(color.black))
               gc:drawPolyLine(rotateVertices)

else
           
           			gc:fillRect(self.x - self.width / 2, self.y - self.height / 2, self.width, self.height)
           			if self.selected then
                           gc:setPen("medium","smooth")
                           gc:setColorRGB(unpack(color.black))
                       else
                           gc:setPen("thin","smooth")
                           gc:setColorRGB(unpack(color.gray))            
                       end
                           gc:drawRect(self.x - self.width / 2, self.y - self.height / 2, self.width, self.height)

end

end
	end
end

---------------------------------------------

Steering = class()

function Steering:init(cx, cy, cradius, x, y, radius, color, rotate)

self.cx		= cx
    self.cy		= cy
    self.cradius = cradius or 20
    self.width = cradius
    self.height = cradius

self.x		= x
	self.y		= y
	self.radius	= radius or 5
	self.color = color
	self.rotate = math.abs(rotate)
	self.selected = false
end

function Steering:contains(x, y)

local r = self.cradius + self.radius
    local d = math.sqrt((self.cx - x)^2 + (self.cy - y)^2)
    return d <= r
    
end

function rotatePoly(cx, cy, polygon, turn)
    local poly = {}
    local dist = 0
    local angl = 0

for p = 1, #polygon, 2 do
        if polygon[p] and polygon[p+1] then
                dist = math.sqrt((cx - polygon[p])^2 + (cy - polygon[p+1])^2)
                angl = math.atan2((polygon[p+1]-cy), (polygon[p]-cx))
                table.insert(poly, cx + dist*math.cos(angl + turn))
                table.insert(poly, cy + dist*math.sin(angl + turn))
        end
    end

return poly
end

function Steering:paint(gc)

local cx = self.cx
    local cy = self.cy
    local cradius = self.cradius
    local x = self.x
    local y = self.y
    local radius = self.radius
    local rotate = self.rotate
    local TurnD = Turn*math.pi/180
    
    local vertices = {cx, cy,
                      x - radius/4, y}
    
    gc:setPen("thick", "smooth")

gc:setColorRGB(unpack(color.blue))

gc:drawArc(cx - cradius/2, cy - cradius/2, cradius, cradius, TurnD, 360)

gc:setColorRGB(unpack(color.white))
    gc:fillArc(x - radius/2, y - radius/2, radius, radius, 0, 360)
    gc:setColorRGB(unpack(color.gray))
    gc:drawArc(x - radius/2, y - radius/2, radius, radius, 0, 360)

end

-------------------------

-- Mouse and KeyBoard controls

function on.escapeKey()
	on.resize()
	screen:invalidate()
end

function on.enterKey()
	playActions()
	screen:invalidate()
end

function on.tabKey()
    image_switch = not image_switch
    screen:invalidate()
end

function on.mouseDown(x, y)

if controls:contains(x, y) then
        controls:mouseDown(x, y)
	end

if SteeringWheel:contains(x, y) then
        SteeringWheel.selected = true
    end

screen:invalidate()

end

function on.mouseUp(x, y)

if controls:contains(x, y) then
        controls:mouseUp(x, y)
	end

if SteeringWheel.selected then
        SteeringWheel.rotate = math.atan2((y - SteeringWheel.cy),(x - SteeringWheel.cx))
        Turn = -1*SteeringWheel.rotate
        mBot.rotate = Turn             
        SteeringWheel.x = SteeringWheel.cx + SteeringWheel.cradius*math.cos(-1*Turn)/2
        SteeringWheel.y = SteeringWheel.cy + SteeringWheel.cradius*math.sin(-1*Turn)/2
        SteeringWheel.selected = false
    end

screen:invalidate()
end

function on.mouseMove(x, y)

if controls.selected then
        controls:mouseMove(x, y)
	end

if SteeringWheel.selected then
        SteeringWheel.rotate = math.atan2((y - SteeringWheel.cy),(x - SteeringWheel.cx))
        Turn = -1*SteeringWheel.rotate
        mBot.rotate = Turn 
        SteeringWheel.x = SteeringWheel.cx + SteeringWheel.cradius*math.cos(-1*Turn)/2
        SteeringWheel.y = SteeringWheel.cy + SteeringWheel.cradius*math.sin(-1*Turn)/2
    end

screen:invalidate()
end

-------------------------------------------------------------------------------------

Click "run your code!" to get started.

You can copy and paste the script (or type your own) into the lower text box and then click "run your code!" After that, explore and experiment!

Home ← TI-Nspire Authoring ← Lua Scripting HQ ← Lua and JavaScript ← Scripting Tutorial - Lesson 29: Play/Reset Script