Experiments with GPT-4 for FTC Teams

User

ChatGPT

User

ChatGPT

User

ChatGPT

User

ChatGPT

User

ChatGPT

Ingesting the DPRG 6 Can Rules

User

ChatGPT

1. The objective of the competition is to autonomously collect six soda cans within a given time limit (initially 5 minutes, may be adjusted by the contest director).
2. The playing field is a 7 ft by 10 ft rectangular area with two starting zones (each 18 inches deep and 35 inches wide) centered on the short edges of the field.
3. The walls of the playing field are 4 inches high.
4. The six soda cans are randomly placed on the playing field, with each can being at least 12 inches from the walls and at least 12 inches from the starting zone edges.
5. The robot must begin in one of the starting zones and must be no larger than 12 inches in any dimension.
6. The robot must be fully autonomous, which means no remote control, no tether, and no external navigation aids (e.g., GPS).
7. The robot can use any type of sensor or actuator, but it cannot damage the field, cans, or other robots.
8. The robot must not use any method that significantly alters the appearance of the field, such as covering the field with a sheet.
9. If two or more robots are competing simultaneously, they must not intentionally interfere with each other.
10. Each robot gets three chances to run. The best run is used for scoring purposes.
11. The robot's score is determined by the number of cans collected and the time taken. Each can collected is worth 100 points. The robot with the highest score wins.

User

ChatGPT

User

ChatGPT

User

ChatGPT

User

ChatGPT

User

ChatGPT

User

ChatGPT

 
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.List;

public class CanDetector {
    static class Can {
        Point2D.Double position;
        double heading;

        public Can(Point2D.Double position, double heading) {
            this.position = position;
            this.heading = heading;
        }
    }

    public static List detectCans(Robot robot, Webcam webcam, double distanceThreshold, double angleThreshold) {
        List uniqueCans = new ArrayList<>();

        for (int heading = 0; heading < 360; heading++) {
            // Rotate robot and capture frame
            robot.rotate(1);
            Frame frame = webcam.captureFrame();

            // Process frame and detect cans
            List detectedCans = processFrame(frame, robot, heading);

            for (Can newCan : detectedCans) {
                boolean isDuplicate = false;

                for (Can existingCan : uniqueCans) {
                    double distance = newCan.position.distance(existingCan.position);
                    double angleDifference = Math.abs(newCan.heading - existingCan.heading);

                    if (distance < distanceThreshold && angleDifference < angleThreshold) {
                        isDuplicate = true;
                        break;
                    }
                }

                if (!isDuplicate) {
                    uniqueCans.add(newCan);
                }
            }
        }

        return uniqueCans;
    }

    private static List processFrame(Frame frame, Robot robot, int heading) {
        // Implement your OpenCV vision pipeline here to detect cans, their size, and orientation.
        // Calculate the distance and position of each detected can using the robot's heading.
        // Return the list of detected cans.

        List detectedCans = new ArrayList<>();
        // ... your processing code here ...
        return detectedCans;
    }
}

User

ChatGPT

User

ChatGPT

User

Commentary

ChatGPT

User

ChatGPT

Commentary

User

ChatGPT

Commentary

User

ChatGPT

User

ChatGPT

 
import java.awt.Point;
import java.util.*;

public class AStar {
    private static final int GRID_SIZE = 3; // 3-inch grid cells

    public static void main(String[] args) {
        // Example: A* path from start to goal in a 10x7 ft playing field
        Point start = new Point(42, 11);
        Point goal = new Point(42, 101);
        List cans = Arrays.asList(new Point(47, 40), new Point(60, 70), new Point(25, 87),
                new Point(58, 95), new Point(30, 50), new Point(70, 20));

        List path = findPath(start, goal, cans);
        System.out.println(path);
    }

    public static List findPath(Point start, Point goal, List cans) {
        Set closedSet = new HashSet<>();
        Set openSet = new HashSet<>();
        openSet.add(start);

        Map cameFrom = new HashMap<>();

        Map gScore = new HashMap<>();
        gScore.put(start, 0.0);

        Map fScore = new HashMap<>();
        fScore.put(start, heuristic(start, goal));

        while (!openSet.isEmpty()) {
            Point current = lowestFScore(openSet, fScore);
            if (current.equals(goal)) {
                return reconstructPath(cameFrom, current);
            }

            openSet.remove(current);
            closedSet.add(current);

            for (Point neighbor : getNeighbors(current, cans)) {
                if (closedSet.contains(neighbor)) {
                    continue;
                }

                double tentativeGScore = gScore.getOrDefault(current, Double.MAX_VALUE) + GRID_SIZE;

                if (!openSet.contains(neighbor)) {
                    openSet.add(neighbor);
                } else if (tentativeGScore >= gScore.getOrDefault(neighbor, Double.MAX_VALUE)) {
                    continue;
                }

                cameFrom.put(neighbor, current);
                gScore.put(neighbor, tentativeGScore);
                fScore.put(neighbor, tentativeGScore + heuristic(neighbor, goal));
            }
        }

        return null; // Path not found
    }

    private static List reconstructPath(Map cameFrom, Point current) {
        List path = new ArrayList<>();
        path.add(current);
        while (cameFrom.containsKey(current)) {
            current = cameFrom.get(current);
            path.add(current);
        }
        Collections.reverse(path);
        return path;
    }

    private static Point lowestFScore(Set openSet, Map fScore) {
        Point lowest = null;
        for (Point point : openSet) {
            if (lowest == null || fScore.get(point) < fScore.get(lowest)) {
                lowest = point;
            }
        }
        return lowest;
    }

    private static List getNeighbors(Point current, List cans) {
        List neighbors = new ArrayList<>();
        for (int dx = -GRID_SIZE; dx <= GRID_SIZE; dx += GRID_SIZE) {
            for (int dy = -GRID_SIZE; dy <= GRID_SIZE; dy += GRID_SIZE) {
                if (dx == 0 && dy == 0) {
                    continue;
                }
                Point neighbor = new Point(current.x + dx, current.y + dy);
                if (isValid(neighbor, cans)) {
                    neighbors.add(neighbor);
                }
            }
        }
        return neighbors;

    

Commentary