In my code I break out the various touch states (BEGAN, MOVING, ENDED) which is why the touched() method forwards calls to one of the following:

    touchesBegan(),  touchesMoved()  and   touchesEnded()

For my project I needed an onLongPress() method to be called every time the user touches and holds the screen for a given time. My code uses a global 'longPressDuration' which by default is set to 1/2 a second (0.5). This is the only variable that should be changed if you need longer or shorter long-press durations. All of the variables that begin with 2 underscores '__' are used internally and should not be changed as they're used to maintain the state of the long-press event detection logic.

Basically the algorithm works like this: when the user first touches the screen (touch.state == BEGAN), we store the current ElapsedTime so we can later check to see how long it's been since the user began touching the screen. If the user moves their finger, then the long-press is cancelled. Since the only method Codea calls regualrly is draw(), I placed all the logic for detecting a long press at the END of draw(). This code first checks to see if we've detected a touch BEGAN event. If so, and we've yet to detect a long-press then we check the current time with the stored time when the touch BEGAN. If this result is greater than the long-press hold time (longPressDuration) then we trigger the onLongPress() method. You might notice the extra flags & checking, these ensure that once the system has detected a long-press, it doesn't keep sending out the onLongPress() method on every draw() cycle.

Enough talk, here's the code. Share & enjoy

--[[ 
  LongPress Event Detection

  Sample code to detect when a user long-presses/touches the screen.

  Since Codea doesn't provide timers or multiple threads, long-press
  detection is done in the only method that's called regularly, the
  'draw()' method.

  Also, Once a long-press has been detected, no more movement of the touch
  will be forward (touch.state == MOVING or ENDED).  Only after the user
  releases their finger from the screen will the long-press be cleared and
  touches will begin to be recognized again.

]]--



-- ----------------------------------------------------------------------------------
-- GLOBALs
-- ----------------------------------------------------------------------------------

-- how long does it take before a long-press event is triggered.
longPressDuration = 0.5


-- Sensitivity of the touch movement in points.
-- The number of points a touch can move to still allow a long-press.
-- users tend to 'jiggle' their fingers when long-pressing the screen,
-- this helps to make a long-press more accurate.
longPressSensitivity = 10




-- !! THE FOLLOWING ARE USED FOR STATE MANAGEMENT AND DO NOT NEED TO BE MODIFIED
-- touch start time
__longPressStartTime = 0

-- did we detect a touch.state == BEGAN?
__longPressStarted = false

-- has a long-press been detected?
__longPressDetected = false


-- store the touch BEGAN location
-- these are used to calculate the distance between
-- the touch start and the longPressSensitivity value
__longPressTouchX = 0
__longPressTouchY = 0




-- ----------------------------------------------------------------------------------
-- draw()
-- ----------------------------------------------------------------------------------
function draw()
    
    -- <<< ADD YOUR DRAW CODE HERE >>>
    
    
    -- The following code goes AFTER all drawing is completed.
    -- Basically, if we've detected a BEGAN touch event and
    -- a long-press hasn't been detected yet, check how long it's
    -- been since the touch started.  If it's longer than the long-press
    -- duration then trigger a long-press event.
    if __longPressStarted then
        if not __longPressDetected then
            if (ElapsedTime - __longPressStartTime) > longPressDuration then
                __longPressDetected = true
                onLongPress()
            end
        end
    end
end



-- ----------------------------------------------------------------------------------
-- touched()
--
-- When the user touches the screen, this method processes the touch event
-- and routes the different touch types to their own method.  If a touch BEGAN
-- event is received, then setup a long-press/touch state.  If a MOVING touch
-- state is received, and the distance between the start of a long-press and
-- the current 'moving' touch is less than the long-press sensitivity then
-- ignore the MOVING touch, otherwise cancel the long-press and just trigger a
-- MOVING event. 

-- Once a long-press/touch has been detected, ALL future touch events are IGNORED
-- until the user removes their finger from the screen, which triggers an ENDED
-- touch state.  Once this happens, the long-press state is reset and touches
-- are enabled once again.
-- ----------------------------------------------------------------------------------
function touched(touch)
    if touch.state == BEGAN then
        __longPressStartTime = ElapsedTime
        __longPressStarted = true
        __longPressTouchX = touch.x
        __longPressTouchY = touch.y
        touchesBegan(touch)

    elseif touch.state == MOVING then
        if not __longPressDetected then
            -- has the touch moved outside of the long-press sensitivty range?
            if not distanceWithinRange(touch.x, touch.y, __longPressTouchX, __longPressTouchY, longPressSensitivity) then
                -- cancel the long-press state...
                __longPressStarted = false
                -- send a touchesMoved() event...
                touchesMoved(touch)
            end
        end    
    else
        -- This is for touch.state == ENDED 
        if not __longPressDetected then
            touchesEnded(touch)
        end
        
        -- clear the long-press flags
        __longPressDetected = false
        __longPressStarted = false
    end
end


-- ----------------------------------------------------------------------------------
-- distanceWithinRange()
--
-- Given 2 points calculate their distance for both X and Y.
-- If the distance of BOTH X and Y are less than distanceRange
-- then return 'true', otherwise return 'false'
--
-- Params:
--            p1x, p1y       First point to check
--            p2x, p2y       Second point to check
--            distanceRange  Minimum distance between p1 and p2 to check for
--
-- Return:
--            true        Distance between p1 AND p2 is less than or equal to'distanceRange'
--            false       Distance between p1 AND p2 is greater than 'distanceRange'
-- ----------------------------------------------------------------------------------
function distanceWithinRange(p1x, p1y, p2x, p2y, distanceRange)
    local result = false
    
    -- calculate the distance between p1 and p2
    local dx = math.abs(p2x-p1x)
    local dy = math.abs(p2y-p1y)
    
    -- if the distance between BOTH p1 and p2 is less than or equal todistanceRange
    -- then set result to 'true', otherwise result will be the default value
    -- of 'false'
    if dx 

Here is the code from the tutorial that I need in my program:

function setup()
    x = WIDTH/2
    y = HEIGHT/2
    bc = color(248, 250, 13, 255)
    tc = color(195, 17, 17, 255)
    c = bc
    inTouch = false
    dx = 0
    dy = 0
    r = 30
end

function draw()
    background(0, 0, 0, 255)
    fill(c)
    ellipse(x,y,r)
    if inTouch then
        x = tx
        y = ty
        c = tc
    else
        x = x +  dx
        y = y +  dy
        c = bc
    end
    if y > HEIGHT - r then
        dy = - dy
    end
    if y < r then
        dy = - dy
    end
    if x > WIDTH - r then
        dx = - dx
    end
    if x < r then
        dx = - dx
    end
end

function touched(touch)
    tx = touch.x
    ty = touch.y
    if touch.state == BEGAN then
        inTouch = true
        velocity = {}
    end
    if touch.state == MOVING then
        table.insert(velocity,1,vec2(touch.deltaX,touch.deltaY))
    end
    if touch.state == ENDED then
        dx = 0
        dy = 0
        n = 0
        for i = 1,10 do
            if velocity[i] then
                n = n + 1
            dx = dx + velocity[i].x
            dy = dy + velocity[i].y
            end
        end
        if n >0 then
        dx = dx / n
        dy = dy / n
        end
        inTouch = false
    end
end

I'm totally new to Codea and until now I only learned markup languages. So I'm trying to get into lua and followed the tutorials in the wiki (wish there'd be more!). I'm trying to create a UI first, as I think it would be the most easy part. I fully understand the mesh concept, but am stuck with TouchEvents. Right now, I would like to initiate an action when pushing a button (actually rectangle meshes with texture).

Here's the code I've come up with:

supportedOrientations(LANDSCAPE_ANY)
-- Use this function to perform your initial setup
function setup()
    --Set the viewer to fullscreen
    displayMode( FULLSCREEN )

    c1 = color(31, 57, 84, 255)
    c2 = color(36, 115, 196, 255)

    by = 50
    ty = 100
    iw = 120
    i2w = 100
    ih = 30

    buttonframe = Frame(865, 50, WIDTH - 5, HEIGHT - 55)

    topbar = mesh()
    id1 = topbar:addRect(WIDTH/2,HEIGHT-ty/2, WIDTH,ty)
    topbar:setRectColor(id1, 218, 75, 75, 255)

    bottombar = mesh()
    bottombar.vertices = {vec2(0,0), vec2(WIDTH,0), vec2(0,by), vec2(0,by), vec2(WIDTH,by), vec2(WIDTH,0)}
    bottombar.colors = {c1, c1, c2, c2, c2, c1}

    menu_img = readImage("Cargo Bot:Menu Button")
    icone = mesh()
    icone.texture = menu_img
    icone:addRect(iw/2+20, by/2, iw, ih)
    icone:setRectTex(1,0,0,1,1)

    exit_img = readImage("Cargo Bot:Clear Button")
    ico_exit = mesh()
    ico_exit.texture = exit_img
    ico_exit:addRect(WIDTH - i2w/2 - 20, by/2, i2w, ih)
    ico_exit:setRectTex(1,0,0,1,1)
end

function touched(touch)
    sound(SOUND_HIT, 33733)
    if ico_exit:touched(touch) then
        close()
    end
end

-- This function gets called once every frame
function draw()
    -- This sets a dark background color 
    background(40, 40, 50)

    -- This sets the line thickness
    strokeWidth(5)

    -- Do your drawing here
    topbar:draw()
    bottombar:draw()
    icone:draw()
    ico_exit:draw()
end

Obviously, TouchEvents are not that easy! I understood that there are two methods discussed on this forum: physics with collide events and touch events depending on coordinates. The later seem to be not so resource friendly as I understood, if there are a lot of tappable shapes/buttons.

I would like to know what you think would be the best practice in my situation to handle touch events. And am I in the right direction for the UI design (using meshes, etc...).

Thanks a lot :)

    ScaledSprite = class()
    function ScaledSprite:init(mySprite,Ssize,x,y)
        self.pos = vec2(x,y)
        self.mySprite = mySprite
        self.Ssize = Ssize
        self.Sw,self.Sh = spriteSize(self.mySprite)
        self.action = nil
        self.selected = false
    end

    function ScaledSprite:draw()
        -- Codea does not automatically call this method
        factor = self.Ssize / 100
        sprite(self.mySprite,self.pos.x,self.pos.y,self.Sw * factor,self.Sh * factor)
    end

    function ScaledSprite:touched(touch)
        -- Codea does not automatically call this method
        if touch.state == MOVING then
           if (math.abs(self.pos.x - touch.x) <= (self.Sw/2)
           and math.abs(self.pos.y - touch.y) <= (self.Sh/2)) then
            if flying ~= "none" then
                self.selected = true
             else
                self.selected = false
            end
        elseif touch.state == ENDED then
            if self.selected == true and self.action then
                self.selected = false
                self.action()
            end
        end
    end

As I explained sometimes it gets the ENDED condition but sometimes it doesn't.

From Main this were I called the class action: (Fliying is a control variable to indicate that I hit symbol from the menu)

    if (flying == "P1") then
        if CurrentTouch.y > 680 then
            fixedy = 680
        elseif CurrentTouch.y < 100 then
            fixedy = 100
        else
            fixedy = CurrentTouch.y   
        end

        ssP1 = ScaledSprite("Dropbox:symbol-P1",symbSize * vsmFactor,CurrentTouch.x,fixedy)
        ssP1.action = function() btnSymbPRO1pressed() end

        ssP1:draw()
        dragging = true     

    end

Action function that's is called after the touch ENDED is detected

    function btnSymbPRO1pressed()
            iSymbol = iSymbol + 1
            flying = "none"
            dragging = false
            aSx[iSymbol] = CurrentTouch.x
            aSy[iSymbol] = CurrentTouch.y
            fw, fh = spriteSize("Dropbox:symbol-P1")
            aSw[iSymbol] = fw * (symbSize / 100) * vsmFactor
            aSh[iSymbol] = fh * (symbSize / 100) * vsmFactor
    end

function setup()
    touches = {}
    showKeyboard()
end

function draw()
    background(0, 0, 0, 255)
    enchanceRecording(CurrentTouch.x, CurrentTouch.y,1)
end

function enchanceRecording(gravx,gravy,shoingkeyboard)
    local buffer = keyboardBuffer()
    local _, gravh = textSize(Gravity.x)
    if isRecording() then
        font("HelveticaNeue")
        fill(179, 179, 179, 127)
        stroke(255, 255, 255, 127)
        strokeWidth(3)
        for k,touch in pairs(touches) do
            ellipse(touch.x, touch.y, 100, 100)
        end
        if shoingkeyboard == 1 then
            if buffer == nil then buffer = " " end
            textWrapWidth(WIDTH)
            if WIDTH == 1024 and HEIGHT == 768 or WIDTH == 750 and HEIGHT == 768 then
                rect(0,0,WIDTH,HEIGHT/2-30)
                fill(255, 0, 0, 255)
                text("Typed text:".. buffer,WIDTH/2,(HEIGHT/2-30)/2)
            elseif WIDTH == 768 and HEIGHT == 1024 or WIDTH == 494 and HEIGHT == 1024 then
                rect(0,0,WIDTH,HEIGHT/3-75)
                fill(255, 0, 0, 255)
                text("Typed text:".. buffer,WIDTH/2,(HEIGHT/3-75)/2)
            end
            fill(30, 255, 0, 255)
            text("Gravity X: ".. Gravity.x,gravx,gravy)
            text("Gravity Y: ".. Gravity.y,gravx,gravy-gravh)
            text("Gravity Z: ".. Gravity.z,gravx,gravy-gravh*2)
            text("User Acceleration X: ".. UserAcceleration.x,gravx,gravy-gravh*4)
            text("User Acceleration Y: ".. UserAcceleration.y,gravx,gravy-gravh*5)
            text("User Acceleration Z: ".. UserAcceleration.z,gravx,gravy-gravh*6)
        end
    end 
end


function touched(touch)
    if touch.state == ENDED then
        touches[touch.id] = nil
    else
        touches[touch.id] = touch
    end
end

That turns out like this:

If the video doesn't work, click here.

Here is the link.

What's left to do? This:
1. Get rid of all the unnecessary numbers in the user acceleration and gravity.
2. And a few other small things I don't feel like listing right now.
Have fun!

if physics.raycast(touch.x,rx) and physics.raycast(touch.y, ry) then
print("c = "..(math.pi *  (rx + 250)))
end

I put that near the beginning of my touched function and im kicked out of codea as soon as I touch the screen.

function Button:touched(touch)
    if self.tapped then
           print("Tapped Button")
     else
           print("Tapped Elsewhere")
end
end

At first, I had A, B, C and P set up as vec2, but that didn't work, so I Googled some more and I think I need to use vec3. Because I'm translating my matrix when I draw the triangle, I'm trying to add the position to the vertices as well.

These are new concepts for me. I would be grateful for any assistance. I'd also be happy if there was some method I've overlooked that can do this simply.

function Pyramid:init(x, y)
    self.position = vec2(x, y)
    self.mesh = mesh()
    self.mesh.vertices = {vec2(0, 0), vec2(100, 0), vec2(50, 100)}
    self.size = SMALL
    self.color = GREEN
    self.selected = false
end

function Pyramid:hit(touch)
    local pos = vec3(self.position.x, self.position.y, 0)
    local A = vec3(self.mesh.vertices[1].x, self.mesh.vertices[1].y, 0) + pos
    local B = vec3(self.mesh.vertices[2].x, self.mesh.vertices[2].y, 0) + pos
    local C = vec3(self.mesh.vertices[3].x, self.mesh.vertices[3].y, 0) + pos
    local P = vec3(touch.x, touch.y, 0)
    
    local v0 = C - A
    local v1 = B - A
    local v2 = P - A
        
    local dot00 = v0:dot(v0)
    local dot01 = v0:dot(v1)
    local dot02 = v0:dot(v2)
    local dot11 = v1:dot(v1)
    local dot12 = v1:dot(v2)
    
    local invDenom = 1 / (dot00 * dot11 - dot01 * dot01)
    local u = (dot11 * dot02 - dot01 * dot12) * invDenom
    local v = (dot00 * dot12 - dot01 * dot02) * invDenom
    
    return (u >= 0) and (v >= 0) and (u + v < 1)
end

So far this is my code, it is simple but Im not sure how to get the image to go after the touch ha been removed.

function touch()
    
    if touch.state == ENDED then touching = false
    else touching = true
    end
end

function setup()
    
    
end

function draw()
    background(0, 0, 0, 255)
    fill(127, 122, 132, 255)
    ellipse( CurrentTouch.x, CurrentTouch.y, 15)
    if touching == true then draw = ellipse( CurrentTouch.x, CurrentTouch.y, 15)
    end
    
end

Thanks for your help

So first any ideas about this or a better way.

Second, it would probably be sufficient to just hide the data if there are no current touches on the screen. Is there a way to determine this? The CurrentTouch always has a value even if there are no touches going on.

Thanks for any ideas.

-- #Main

--displayMode(FULLSCREEN)
supportedOrientations(CurrentOrientation)

-- Use this function to perform your initial setup
function setup()
    m = Mine()
end

-- This function gets called once every frame
function draw()
    -- This sets a dark background color 
    background(142, 88, 38, 255)
    mineTouch()
    -- Do your drawing here
    m:draw()
   
    
end

function mineTouch()
    if CurrentTouch.state == BEGAN and MOVING then
       if CurrentTouch.x < WIDTH then -- if touching inside the screen
        if CurrentTouch.y < HEIGHT then
            -- move the sprite position towards the current touch
            m.pos = m.pos + vec2(CurrentTouch.x,CurrentTouch.y)
            end
        end
    end
    if CurrentTouch.state == ENDED then
     -- stop the sprite at its location
        m.pos = m.pos
    end
end

-- #Mine

Mine = class()

function Mine:init(x)
    -- you can accept and set parameters here
    self.pos = vec2(WIDTH/2, HEIGHT/2)
end

function Mine:draw()
    -- Codea does not automatically call this method
    sprite("Tyrian Remastered:Mine Spiked Huge",self.pos.x,self.pos.y)
end

function Mine:touched(touch)
    -- Codea does not automatically call this method
end

I don't want the sprite to "jump" to the CurrentTouch. I want it to be drawn every frame moving towards the CurrentTouch. Thanks.

background(0, 208, 255, 255)
font("Copperplate")
fill(255, 0, 6, 255)
fontSize(75)
text("Play Now!", WIDTH/2, HEIGHT/3)

The basic idea is that you move a line around the screen using two fingers (it's best to play with two hands to get the best view of the screen), and avoid obstacles for as long as you can. Take one hit, remove either finger, or make the line too short, and it's game over.

There are a number of power ups (would've liked to add more, but ran out of time):

• Slowdown (slows down all obstacles for 10 seconds)
• Shield (allows you to take a hit and keep playing)
• Zapper (lets you destroy obstacles for 10 seconds, for extra points)

Here's a YouTube video showing it in action: http://www.youtube.com/watch?v=ih6IE2bZOQI

I'll post code soon. I also want to extend and separate out the Tween class I started to put together for this. It basically allows you to pass the name of a property, a starting value, a finishing value, and a timespan, and will then animate the property between the provided value for you. Hopefully other people will find it useful! I also created a starfield backdrop - I know there was a discussion abut that sort of thing on here the other day.

im new to this forum, and have played with Codea for only a few days now. Im trying to make a simple touch-controller class to decide the direction of movement in a game.

My approach is to divied the whole screen into four triangles. when the touch position is within the upper triangle, i set a variable "up" to true, similar for left, right and down..

To determine which triangle has been touched i decided to go with the physics api because of the nice collision checks.

However, the check works only when the game is freshly started. After a few seconds the collision checks start failing. Im already printing the triangles to check if they somehow move automagically, but everything seems ok.

It would be nice if someone can give any hint, thanks in advance.

here's the code of the controller class:

Controller = class()

function Controller:init()
    
    self.ptTopLeft = vec2(0, HEIGHT)
    self.ptTopRight = vec2(WIDTH, HEIGHT)
    self.ptBtLeft = vec2(0,0)
    self.ptBtRight = vec2(WIDTH, 0)
    self.ptCenter = vec2(WIDTH/2, HEIGHT/2)
    
    self.areaTop = physics.body(POLYGON, unpack({self.ptTopLeft, self.ptTopRight, self.ptCenter}))
    self.areaBottom = physics.body(POLYGON, unpack({self.ptBtLeft, self.ptBtRight, self.ptCenter}))
    self.areaLeft = physics.body(POLYGON, unpack({self.ptBtLeft, self.ptTopLeft, self.ptCenter}))
    self.areaRight = physics.body(POLYGON, unpack({self.ptBtRight, self.ptTopRight, self.ptCenter}))
    
    self.left = false
    self.right = false
    self.up = false
    self.down = false
    
    --local poly = physics.body(POLYGON, unpack(points))
    
end

function Controller:touched(touch)
    local touchVec
    touchVec = vec2(touch.x, touch.y)
    print(touch.state)
    if(touch.state == ENDED) then 
        self.up = false
        self.down = false
        self.left = false
        self.right = false
    elseif (self.areaTop:testPoint(touchVec) == true) then
        self.up = true
    elseif (self.areaBottom:testPoint(touchVec) == true) then
        self.down = true
    elseif (self.areaLeft:testPoint(touchVec) == true) then
        self.left = true
    elseif (self.areaRight:testPoint(touchVec) == true) then
        self.right = true
    end
end 

function Controller:draw()
    drawBody(self.areaRight)
    drawBody(self.areaLeft)
end

function drawBody(body)
    pushStyle()
    stroke(255, 0, 0, 255)
    strokeWidth(7)
    local points = body.points
        for j = 1,#points do
            a = points[j]
            b = points[(j % #points)+1]
            line(a.x, a.y, b.x, b.y)
        end
    popStyle()
end

It works great for drawing BUT, the elements and sub-elements of the UI are heavily dependent on passing around a touch element and letting each piece respond appropriately. And I can't seem to translate touch.

Even if I copy CurrentTouch into another touch instance, it won't let me alter the values of x and y.

Is there any way out of this short of breaking down touch into it's values and passing them all individually?

It actually doesn't do biochar ... Yet

I have to think of oxygen detection and better heat detection

http://ipad41001.posterous.com/biochar-app-via-codea-which-is-on-sale-now

App

http://ipad41001.posterous.com/biochar-app-003

For example, if user want to give an object a user controlled (default) rotation capability, s/he could simple enable it by calling i.e. circle:gestureRotation = true, or rect:gesturePosition = true to enable (default) user controlled movement capability, or poly:gestureZoom = true to enable (default) user controlled resize capability, etc. To override the default behavior, user could override the function that is used for the gesture callback. These APIs could save Codea's users coding time for basic/default gestures for object manipulation. Great for quick game prototyping.

What do you think? :)

Demostrates a way to implement a pinch zoom gesture and how to shuffle touch information around.