Keeping Score

Overview

Time to bring it all together. You’ll write a complete red-cube run that drives, squares up, stacks cubes, and docks the pallet — using every major tool in your library. But this run does something new: it keeps its own score. After each point-scoring maneuver, the program adds the points to a running total and prints a report of what it just did and where the score stands. By the end, your robot narrates its own competition run.

By the end of this activity you will be able to:

• Use an int variable to accumulate a running score.
• Print a status report with printf after each maneuver.
• Combine your whole library into one complete scored run.
• Read the real Botball point values for the maneuvers you complete.

Phase 1 — Concept: A Variable That Remembers

int score = 0;        // start with no points
score = score + 9;    // add 9 --- score is now 9
score = score + 11;   // add 11 --- score is now 20

Explain what score = score + 9; does. Why does the variable need to “remember” its old value to work?

Phase 2 — Concept: Reporting With printf

printf("Stacked first red cube. Score: %d\n", score);

What does the %d do inside a printf? Why is printing a report after each maneuver useful during a competition run?

Phase 3 — The Real Point Values

These are the actual Botball points for the maneuvers in your run. Each maneuver’s difficulty maps to a score — harder tasks are worth more.

If your robot completed only the first two stacks but failed to dock, what would the score be? Show your addition.

Phase 4 — Plan the Run

Before coding, map your run as a list of actions and the points each scores. Think through the whole path: find the wall to reset, square up, drive and turn to the cubes, stack them, then move the pallet to the dock. Mark which library function does each step.

You don’t need to score on every line — driving and turning set up the scoring maneuvers. Mark points only on the lines that actually score.

Phase 5 — Build: The Scored Run

Now write it. Start score at 0. Follow the do → score → report rhythm: run the maneuver with your library functions, add the points, then printf the report. The skeleton below shows the structure and the scoring/reporting lines — you fill in the driving, turning, and stacking from your Phase 4 plan.

// Unit 4, Big Idea 4: Keeping Score
// Name: _______________________   Date: ___________

#include <kipr/wombat.h>

#include <yourname.h>     // your full library

int main()
{
	enable_servo(0);
	enable_servo(1);

	int score = 0;                          // running total starts at zero
	printf("Run started. Score: %d\n", score);

	// --- Reset to a known position ---
	back_until_pressed();                   // back into the wall to reset
	square_up();                            // straighten against the line

	// --- Drive/turn to the cubes (your plan) ---
	// Drive(...)  Turn(...)  as needed

	// --- SCORE: first small red cube on the large cube ---
	// move_arm(...) / move_claw(...) to make the stack
	score = score + 9;                      // difficulty 5 = 9 points
	printf("Stacked first red cube. Score: %d\n", score);

	// --- SCORE: second small red cube ---
	// reposition + move_arm / move_claw
	score = score + 11;                     // difficulty 6 = 11 points
	printf("Stacked second red cube. Score: %d\n", score);

	// --- SCORE: dock the pallet ---
	// Drive / Turn the pallet onto the dock
	score = score + 11;                     // difficulty 6 = 11 points
	printf("Pallet on the dock. Score: %d\n", score);

	// --- SCORE: cube still on top when docked ---
	score = score + 9;                      // difficulty 5 = 9 points
	printf("Cube held on top. Final score: %d\n", score);

	return 0;
}

Phase 6 — Run It and Read the Report

Run your program and watch the console. A perfect run prints a growing score, ending at 40. Here’s what a clean run looks like:

> Run started. Score: 0
> Stacked first red cube. Score: 9
> Stacked second red cube. Score: 20
> Pallet on the dock. Score: 31
> Cube held on top. Final score: 40

Your Run Log

What final score did your run reach? If it was below 40, which maneuver fell short, and how did the printed report help you find it?

Phase 7 — Connect & Reflect

Your robot didn’t just act — it kept track of its own progress and reported it. That’s everywhere in real systems. A delivery robot logs each package dropped; a game tracks your score; a fitness band counts your steps and tells you the total. Keeping a running state and reporting it is how machines stay accountable — to their users and to the people debugging them. The printed log you built is exactly the kind of record engineers rely on to see what a system actually did, step by step.

Complete the reflection on your own.

1. How does an accumulating variable like score “remember” a running total as the program runs?

2. Why is printing a report after each maneuver helpful when something in the run goes wrong?

3. This run used your whole library. Name two functions you called and what each contributed to the run.

4. Complete in 2–3 sentences: “Intelligent systems track their own state and report what they have done. This means a well-built robot can tell you…”

Extension Challenges

Finished early? Try one or more of these.

Extension A — Use the Turn Return Value

• Your Turn returns 1 for success. Only add points if a maneuver’s setup turn succeeded. How would you use the return value to protect your score?

Extension B — A Scoring Function

• Write a helper like score_points(int current, int add) that adds points and prints the report in one call. Why might that be cleaner than repeating the two lines?

Extension C — Count Maneuvers Too

• Add a second accumulating variable that counts how many maneuvers you completed. Print both score and count at the end.

Extension D — Time It

• A real run has a time limit. How could you report points-per-second, or warn if the run is taking too long? Sketch the idea.

Extension E — One Combined Message

• Right now your score report prints as several separate printf lines. Use sprintf to build one combined summary string — for example, your score and maneuver count in a single sentence — before printing it in one call.
• What’s one advantage of building one complete string before printing, instead of printing pieces as you go?