Course Rubric — Grid-Based Game Programming (OOP)

This course develops Object-Oriented Programming (OOP) and complementary programming paradigms through the design and implementation of Grid-Based Games (GBGs) using p5.js v2 and the book Grid-Based Game Programming: with p5.js-v2 and p5.quadrille.js.

(click two cells to select; s: swap; r: scramble; 0/1/2/3: level)

The course follows a progressive approach: from simple interactive sketches to grid-based strategies for structuring state and rules, and finally to object modeling and polymorphism.

Learning is organized through active, collaborative work, primarily in workshops. The instructor’s role is twofold: as an advisor, providing conceptual and technical guidance during development, and as an evaluator, assessing design decisions, coherence, and outcomes.

Group-Based Working Modality

All projects are developed in groups of 2 to 4 students, with at least two different disciplines.

Groups are self-managed and organize their workflow, decisions, and responsibilities autonomously.

Learning Objectives

Apply multi-paradigm programming coherently (imperative, declarative, functional, and object-oriented).
Design clear and maintainable object models for interactive systems.
Practice collaborative development through shared decision-making.
Strengthen oral communication (presentations) and written communication (reports).

Roles Within the Group

Roles are dynamic and self-managed. Typical roles include:

Implementation — coding, object models, logic, and system integration.
Coordination — task organization, synchronization, and responsibility distribution.
Documentation — reports, in-code comments, and clarity of explanations.

All students are expected to understand the full project, regardless of role emphasis.

Access and Submission Conditions

Submit all projects via either the p5.js Web Editor or a GitLab/GitHub Pages site.
Record your project URL in the shared spreadsheet using one of the following formats:
- https://editor.p5js.org/<login_unal>
- https://<username>.gitlab.io/<project> or https://<group>.gitlab.io/<project>
- https://<username>.github.io/<project> or https://<org>.github.io/<project>
For each project, create a project collection (project1, project2, project3) and include all games.
Each game must include a report:
- In the p5.js Web Editor: attach a .txt file (e.g., game1.txt)
- In Pages: the page itself acts as the report
Each report must briefly state:
- Goals (refined during workshops)
- Design decisions: game strategies implemented
- Outcomes and future work
- References to relevant JavaScript, p5.js, and p5.quadrille APIs
Reuse of code is allowed only if adapted and understood.
All sources must be acknowledged (report and code comments).
Course materials (GitLab) are restricted to academic use.

Use of AI Tools

AI use is discouraged. If used, it must be explicitly declared, and students are fully responsible for all submitted work.

Include the following in the report when applicable:

[ ] AI usage declaration
Tool(s): ______________
Purpose: ______________
Extent: ______________
Validation: ______________

Guidelines

Level	Usage	Example	Status
1	Conceptual queries	“What does `Array.some()` do?”	Permitted (with acknowledgment)
2	Debugging assistance	“Why does this function return `undefined`?”	Permitted (with acknowledgment)
3	Supervised generation	“Generate a function for X, I will review and adapt it”	Discouraged (requires validation and source traceability)
4	Extensive collaboration	“Build the full game / system for me”	Not permitted

Assessment Overview

Component	Duration	Weight
Project 1 — Interactive Graphics (p5.js)	4 weeks	20%
Project 2 — GBG Foundations	6 weeks	30%
Project 3 — Advanced GBG (OOP)	6 weeks	40%
Project 4* — Active Collaborative Learning	Throughout	10%
Total	16 weeks	100%

Project 1 — Interactive Graphics with p5.js v2 (20%)

Groups implement a partial GBG using plain p5.js v2 (no p5.quadrille.js), focusing on:

Sketch structure (setup(), draw()).
Event-driven interaction.
Explicit state management.
Clear separation between logic, interaction, and display.

This project establishes a baseline to be revisited once GBG strategies are introduced.

Project 2 — GBG Foundations: Structured Grid State (30%)

Groups implement one or more GBGs using explicit grid-based strategies, focusing on state organization as presented in the book’s GBG strategies.

Required choices include:

Aggregated state (aggregate layer) or layered boards (multi-layer grids).
One dynamic strategy: timelines (timelines) or cell effects (cell effects).

Project 3 — Advanced GBG: Objects and Polymorphism (40%)

Groups design a complete GBG or GBG-consistent system using:

Cell objects (cell objects) with encapsulated state and behavior.
Polymorphism (polymorphic cell objects) to express unified rules across heterogeneous entities.

Optional use of algebra (algebra) or bitboards (bitboards) strategies is welcome when conceptually justified.

Project 4* — Active Collaborative Learning (10%)

Groups demonstrate sustained, constructive participation throughout the semester, including:

Active participation during workshops.
Shared explanations of strategies or decisions.
Group presentations of prepared exercises and topics, following the course schedule.

This is a qualitative assessment of collective engagement.

Course Timeline

Weeks	Focus
1–4	Project 1 — Interactive Graphics
5–10	Project 2 — GBG Foundations
11–16	Project 3 — Advanced GBG

Project 4* spans the entire semester.

Notes

All course materials, including the book and associated resources, are © Jean Pierre Charalambos.
Access is granted exclusively for academic use within this course. Redistribution or public sharing is not permitted.
p5.js v2 and p5.quadrille.js (including their API documentation) are free software, distributed under their respective open-source licenses.