procedural_walking_spider.fcs

on Play
{
    const global float SEGMENTS_PER_LEG = 3
    const global float POINTS_PER_LEG = SEGMENTS_PER_LEG + 1
    const global float NUMB_LEGS = 4
    const global float TOTAL_POINTS = POINTS_PER_LEG * NUMB_LEGS

    const global float BODY_HEIGHT = 1.6

    // dist when not moving
    const global float RELOCATE_LIMB_DIST_BASE = .3
    // dist when moving at max speed + RELOCATE_LIMB_DIST_BASE
    const global float RELOCATE_LIMB_DIST = .7

    const global float MOVE_SPEED = 0.075

    const global float LIMB_INTERPOLATION_SPEED = 0.2
    const global float LIMB_INTERPOLATION_SPEED_INV = 1 - LIMB_INTERPOLATION_SPEED
    const global float BODY_INTERPOLATION_SPEED = 0.15
    const global float BODY_INTERPOLATION_SPEED_INV = 1 - BODY_INTERPOLATION_SPEED

    const global float CAN_MOVE_AFTER = 15
    const global float CAN_MOVE_AFTER_ADJACENT = 10 // !!! MUST BE SMALLER THAN CAN_MOVE_AFTER !!!

#highlight
    global obj body = getBlockById(BLOCK_STONE_BLOCK)
    obj segmentPrefab = null // rod on the z axis, without collision
#endhighlight
    
    global vec3 bodyPos = vec3(0, BODY_HEIGHT, 0)

    const float legOff = 0.32
    global array<vec3> legOffs =
    [
        vec3(legOff, 0, legOff),
        vec3(legOff, 0, -legOff),
        vec3(-legOff, 0, -legOff),
        vec3(-legOff, 0, legOff)
    ]
    global array<vec3> legDirs =
    [
        normalize(vec3( 1, 0,  1)),
        normalize(vec3( 1, 0, -1)),
        normalize(vec3(-1, 0, -1)),
        normalize(vec3(-1, 0,  1))
    ]
    global array<obj> legSegments
    global array<float> legMoveStart
    global array<float> lengths
    global array<vec3> points
    global array<vec3> targetPoints
    global array<vec3> legCastHits
    global array<vec3> legTargets

    global float currentSpeed

    // create segment objects
    on Loop(null, NUMB_LEGS, out inline float li)
    {
        inline float sOff = li * SEGMENTS_PER_LEG
        inline float pOff = li * POINTS_PER_LEG

        on Loop(null, SEGMENTS_PER_LEG, out inline float _i)
        {
            inline float i = sOff + _i

            segmentPrefab.clone(out inline obj segment)
            legSegments.set(i, segment)
            lengths.set(_i + pOff, 1)
        }
    }
}

// move
joystick(out vec3 joyDir, JOYSTICK_TYPE_XZ)
joyDir *= MOVE_SPEED
bodyPos += joyDir

currentSpeed = dist(null, joyDir)
inspect(currentSpeed)

updateLegs()

// body y pos
float bodyY = 0

on Loop(null, NUMB_LEGS, out inline float i)
{
    bodyY += legCastHits.get(i).y
}

bodyY /= NUMB_LEGS

bodyY += BODY_HEIGHT

bodyPos.y = bodyY * BODY_INTERPOLATION_SPEED + bodyPos.y * BODY_INTERPOLATION_SPEED_INV

func updateLegs()
{
    inline float currentFrame = getCurrentFrame()

    on Loop(0, NUMB_LEGS, out inline float i)
    {
        vec3 rayPos = bodyPos + legDirs.get(i) * 1.5
        raycast(rayPos + vec3(0, 2, 0), rayPos - vec3(0, 10, 0), out _, out vec3 hitPos, out _)

        legCastHits.set(i, hitPos)

        inline vec3 currentTarget = legTargets.get(i)

        if (dist(hitPos, currentTarget) >= RELOCATE_LIMB_DIST_BASE + (currentSpeed / MOVE_SPEED) * RELOCATE_LIMB_DIST && checkCanMove(i))
        {
            setPtrValue(currentTarget, hitPos)
            legMoveStart.set(i, currentFrame)
        }

        fabric(i, currentTarget)
    }

    body.setPos(bodyPos)

    if (currentFrame == 0)
    {
        // set points to targetPoints
        on Loop(null, TOTAL_POINTS, out inline float i)
        {
            points.set(i, targetPoints.get(i))
        }
    }
    else
    {
        // interpolate points to targetPoints
        on Loop(null, TOTAL_POINTS, out inline float i)
        {
            points.set(i, targetPoints.get(i) * LIMB_INTERPOLATION_SPEED + points.get(i) * LIMB_INTERPOLATION_SPEED_INV)
        }
    }

    // set segment object positions
    on Loop(null, NUMB_LEGS, out inline float li)
    {
        inline float sOff = li * SEGMENTS_PER_LEG
        inline float pOff = li * POINTS_PER_LEG

        on Loop(null, SEGMENTS_PER_LEG, out inline float _i)
        {
            inline float i = _i + pOff
            inline float nextI = i + 1

            inline vec3 point = points.get(i)
            inline vec3 nextPoint = points.get(nextI)

            legSegments.get(_i + sOff).setPos((point + nextPoint) / 2, lookRotation(nextPoint - point, vec3(0, 1, 0)))
        }
    }
}

// based on https://youtu.be/Hc9x1e85L0w?si=SR8pjkoIZcdPxRKN
func fabric(float limb, vec3 target)
{
    inline float off = limb * POINTS_PER_LEG

    // set first point
    targetPoints.set(off, bodyPos + legOffs.get(limb))

    // "lock" rotation to only 1 axis
    on Loop(1, SEGMENTS_PER_LEG, out inline float _i)
    {
        inline float i = _i + off
        inline float prevIndex = i - 1

        targetPoints.set(i, targetPoints.get(prevIndex) + vec3(0, 1, 0) * lengths.get(prevIndex))        
    }

    // 10 iterations
    on Loop(0, 10, out _)
    {
        // set last point to target
        targetPoints.set(off + SEGMENTS_PER_LEG, target)

        // loop backwards
        on Loop(POINTS_PER_LEG - 2, -1, out inline float _i)
        {
            inline float i = _i + off
            inline float nextIndex = i + 1

            inline vec3 point = targetPoints.get(i)
            inline vec3 nextPoint = targetPoints.get(nextIndex)

            vec3 move = normalize(point - nextPoint) * lengths.get(i)

            targetPoints.set(i, nextPoint + move)
        }

        // set first point
        targetPoints.set(off, bodyPos + legOffs.get(limb))

        // loop forwards
        on Loop(0, SEGMENTS_PER_LEG, out inline float _i)
        {  
            inline float i = _i + off
            inline float nextIndex = i + 1

            inline vec3 point = targetPoints.get(i)
            inline vec3 nextPoint = targetPoints.get(nextIndex)

            inline vec3 move = normalize(nextPoint - point) * lengths.get(i)

            targetPoints.set(nextIndex, point + move)
        }
    }
}

inline func bool checkCanMove(float leg)
{
    inline float currentFrame = getCurrentFrame()
    inline float canMoveTime = currentFrame - CAN_MOVE_AFTER_ADJACENT

    return legMoveStart.get((leg + 1) % NUMB_LEGS) < canMoveTime && 
        legMoveStart.get(((leg - 1) % NUMB_LEGS + NUMB_LEGS) % NUMB_LEGS) < canMoveTime &&
        legMoveStart.get(leg) < currentFrame - CAN_MOVE_AFTER
}