ccbSetPhysicsVelocity

function move(node, speed, x, y, z) {
    // Create a new vector representing the direction of movement.
    // The vector is initialized with the specified x, y, z values, 
    // which determine the direction in which the object will move.
    let direction = new vector3d(x, y, z);
    // Normalizing ensures the vector has a length of 1 (unit vector),
    // which makes it independent of its initial magnitude.
    direction.normalize();
    // Scale the normalized direction vector by the given speed.
    // This adjusts the length of the vector to match the desired movement speed.
    direction.x *= speed;
    direction.y *= speed;
    direction.z *= speed;
    // Set the velocity of the physics-enabled node using CopperCube's function.
    // `node`: The target node to apply velocity to. This node must have a 
    // behavior "Object moved by physics engine."
    // Note: This function works only if physics simulation is enabled and available 
    // for the platform where the application is running.
    ccbSetPhysicsVelocity(node, direction.x, direction.y, direction.z);
}

function moveToTarget(node, speed, x, y, z) {
    // Get the absolute position of the node in the scene.
    let movingNodePos = ccbGetSceneNodeProperty(node, "PositionAbs");
    // Define the target position as a vector with the given x, y, and z coordinates.
    let targetPos = new vector3d(x, y, z);
    // Calculate the direction vector from the moving node to the target point.
    // The direction is the difference between the target position and the current position of the node.
    let direction = new vector3d(
        targetPos.x - movingNodePos.x, 
        targetPos.y - movingNodePos.y, 
        targetPos.z - movingNodePos.z
    );
    // Normalize the direction vector to ensure it has a unit length (magnitude = 1).
    direction.normalize();
    // Scale the direction vector by the speed to adjust the movement velocity.
    direction.x *= speed;
    direction.y *= speed;
    direction.z *= speed;
    // Apply the calculated velocity to the node using CopperCube's physics system.
    // The node will move towards the specified target point at the given speed.
    ccbSetPhysicsVelocity(node, direction.x, direction.y, direction.z);
}

function moveToTargetNode(node, speed, targetNode) {
    // Get the absolute position of the moving node in the scene.
    let movingNodePos = ccbGetSceneNodeProperty(node, "PositionAbs");
    // Get the absolute position of the target node in the scene.
    let targetNodePos = ccbGetSceneNodeProperty(targetNode, "PositionAbs");
    // Calculate the direction vector from the moving node to the target node.
    // The direction is the difference between the target node's position and the moving node's position.
    let velocity = new vector3d(
        targetNodePos.x - movingNodePos.x, 
        targetNodePos.y - movingNodePos.y, 
        targetNodePos.z - movingNodePos.z
    );
    // Normalize the direction vector to ensure it has a unit length (magnitude = 1).
    velocity.normalize();
    // Scale the direction vector by the speed to adjust the movement velocity.
    velocity.x *= speed;
    velocity.y *= speed;
    velocity.z *= speed;
    // Apply the calculated velocity to the moving node.
    // The moving node will approach the target node at the given speed.
    ccbSetPhysicsVelocity(node, velocity.x, velocity.y, velocity.z);
}

function moveByAngle(node, speed, angleX, angleY) {
    // Get the absolute position of the node in the scene.
    let nodePos = ccbGetSceneNodeProperty(node, "PositionAbs");
    // Calculate the target position based on the specified angles (angleX, angleY).
    // These angles are interpreted in degrees and converted to radians for trigonometric calculations.
    let targetPos = new vector3d(0, 0, 0);
    targetPos.x = 10 * Math.sin(angleY / 57.29) * Math.cos(angleX / 57.29);
    targetPos.z = 10 * Math.cos(angleY / 57.29) * Math.cos(angleX / 57.29);
    targetPos.y = -10 * Math.sin(angleX / 57.29);
    // Calculate the direction vector from the node to the target position.
    let velocity = new vector3d(
        targetPos.x - nodePos.x, 
        targetPos.y - nodePos.y, 
        targetPos.z - nodePos.z
    );
    // Normalize the direction vector to ensure it has a unit length (magnitude = 1).
    velocity.normalize();
    // Scale the direction vector by the speed to adjust the movement velocity.
    velocity.x *= speed;
    velocity.y *= speed;
    velocity.z *= speed;
    // Apply the calculated velocity to the physics-enabled node.
    // The node will move in the direction specified by the input angles at the given speed.
    ccbSetPhysicsVelocity(node, velocity.x, velocity.y, velocity.z);
}

function moveToPositionWithCollision(node, speed, targetX, targetY, targetZ) {
    // Get the current position of the node in the scene.
    let currentPosition = ccbGetSceneNodeProperty(node, "Position");
    // Cast a ray from the node's current position toward the target position.
    // If the ray intersects with a collision point, that point is returned.
    let rayCollider = ccbGetCollisionPointOfWorldWithLine(
        currentPosition.x, currentPosition.y, currentPosition.z,
        targetX, targetY, targetZ
    );
    // Determine the final position to move toward.
    // If a collision point is detected, use it as the final position.
    // Otherwise, use the original target position.
    let finalPosition = rayCollider ? rayCollider : new vector3d(targetX, targetY, targetZ);
    // Calculate the direction vector from the current position to the final position.
    let velocity = new vector3d(
        finalPosition.x - currentPosition.x,
        finalPosition.y - currentPosition.y,
        finalPosition.z - currentPosition.z
    );
    // Normalize the direction vector to ensure it has a unit length (magnitude = 1).
    velocity.normalize();
    // Scale the direction vector by the speed to adjust the movement velocity.
    velocity.x *= speed;
    velocity.y *= speed;
    velocity.z *= speed;
    // Apply the calculated velocity to the physics-enabled node.
    // The node will move toward the target position or stop at the collision point if one is detected.
    ccbSetPhysicsVelocity(node, velocity.x, velocity.y, velocity.z);
}