Creating a User-Centered Serious Game for Learning Singly, Circular, and Doubly Linked Lists ^†

Abstract

Programming education, particularly abstract concepts such as dynamic memory allocation and pointer manipulation in Data Structures and Algorithms (DSA), poses significant cognitive challenges for novice computer science and software engineering students. Traditional pedagogical approaches often struggle to bridge the gap between theoretical memory representations and practical code implementation, leading to difficulties in conceptualization and reduced student engagement. Although serious games have been increasingly adopted to support programming education, existing solutions rarely provide an integrated and progressive learning environment encompassing singly, circular, and doubly linked lists. This article presents Tahuantindata, a serious game designed to support the teaching of dynamic data structures through an interactive and culturally grounded learning environment. The game was developed through the integration of the user-centered iPlus methodology and the Scrum agile framework, enabling the systematic translation of pedagogical requirements into iterative software increments. To reduce the abstraction associated with pointer-based structures, the game employs Andean agricultural metaphors, representing nodes as crop plots, pointers as irrigation canals, and null references as dry wells. The development process incorporated a progressive formative evaluation involving 13 undergraduate software engineering students. The same participants evaluated three successive releases of the game throughout the development lifecycle, providing iterative feedback that guided usability and gameplay refinements. Usability was assessed using the 21-item Serious Games Usability (SGU) questionnaire. The results showed a progressive improvement in player experience across releases, with the final version achieving a SUS-equivalent score of 91.58% (Grade A+), corresponding to a “Best Imaginable” usability rating. Additionally, to measure pedagogical effectiveness, a quasi-experimental study was conducted comparing students who practiced with Tahuantindata ($n=13$) against a control group under traditional instruction ($n=20$). The experimental group achieved a significantly higher exam score ($M=5.59/7.00$, $SD=0.66$) compared to the control group ($M=4.02/7.00$, $SD=1.62$; $t\left(27.1\right)=3.87$, $p<0.001$, Cohen’s $d=1.18$), demonstrating that the serious game substantially enhances the conceptualization and learning outcomes of dynamic memory structures.

1. Introduction and Related Work

Computer Science Education has increasingly incorporated educational technologies and game-based learning approaches to address the challenges associated with teaching abstract computational concepts [1,2]. Among these concepts, dynamic memory allocation and pointer manipulation remain particularly difficult for novice programmers because they require students to reason about invisible memory structures, references, and relationships that cannot be directly observed during program execution. These difficulties often hinder the development of accurate mental models and negatively impact student engagement and confidence when learning Data Structures and Algorithms (DSA).

Serious games have emerged as a promising strategy for transforming abstract computational concepts into interactive and meaningful learning experiences. Previous studies have demonstrated the potential of game-based approaches to increase motivation, engagement, and conceptual exploration in programming education [1,2]. However, the design of educational games for dynamic data structures remains challenging due to the need to represent invisible computational processes through intuitive and pedagogically meaningful interactions.

To contextualize this research, this section reviews the literature from three complementary perspectives: (1) visualization and metaphor-based approaches for programming education, (2) serious games designed for linked-list learning, and (3) gamification and usability frameworks used in educational game development and evaluation.

1.1. Visualization and Metaphors in Programming Education

One of the primary barriers in teaching programming foundations, particularly dynamic memory allocation and pointer behavior, is their inherently abstract and invisible nature [3]. Students frequently struggle to construct accurate mental models of memory layouts, memory addresses, and pointer dereferencing processes because these operations occur internally within the computer system and are not directly observable [3,4]. Consequently, traditional instructional approaches often fail to provide immediate and tangible representations of these concepts, increasing cognitive load and generating learning difficulties [1].

To address this challenge, researchers have explored visualization techniques and metaphor-based representations that transform abstract computational processes into more concrete and intuitive experiences. Karapinar et al. [3], for example, developed a path-finding serious game that allows students to visualize memory cells and pointer relationships through interactive navigation mechanics. Similarly, Setiawan et al. [5] applied design-thinking principles to develop educational games that facilitate the visualization of complex network topologies through simplified graphical representations.

The use of visual metaphors and analogical representations has been reported as an effective strategy for reducing abstraction and supporting the construction of mental models [4,6]. By connecting unfamiliar computational concepts with familiar real-world elements, metaphor-based environments can facilitate conceptual interpretation before students engage with the underlying programming syntax and implementation details. Consequently, visualization and metaphor design have become important components in the development of educational tools for programming and data structure instruction.

1.2. Serious Games for Linked List Learning

Linked lists are foundational dynamic data structures, yet their manipulation algorithms (such as insertion, traversal, and deletion) are notoriously difficult for novice programmers to comprehend [7,8]. Over the years, several serious games have been developed specifically to teach these structures. Rao et al. [4] proposed BlockList, a drag-and-drop game that uses puzzle block patterns as analogies for linked list nodes, reporting that 84.88% of users improved their conceptual understanding. Zhang et al. [7] developed Space Traveler, an instructional module inspired by the classic snake game, where players practice singly linked list insertion and deletion by navigating an astronaut through space.

Furthermore, the game La Petite Fée Cosmo [9] explored the concept of productive failure (PF) in a 2D bridge-building puzzle, encouraging students to experiment with linked list functionalities in various configurations. To teach dynamic structures, Rajeev and Sharma [10] evaluated Game Theme-based Instructional (GTI) modules, utilizing a four-dimensional framework to sustain student motivation. While these games successfully demonstrate singly linked list operations [8], a critical gap persists: none of these existing tools offer an integrated narrative or a progressive technical curriculum that transitions smoothly from singly to circular and doubly linked lists within a unified, interactive environment.

1.3. Gamification Frameworks and Usability Evaluation

Recent research has shifted toward establishing structured, reusable gamification frameworks to maintain student commitment [2,11]. Frameworks such as the FGPE (Framework for Gamified Programming Education) [12,13] aim to standardize gamified exercises, providing automated assessment alongside gamification layers. Personalized gamification approaches also emphasize that a student’s motivation is highly correlated with their specific player type (such as HEXAD typologies), where achievers benefit from leaderboards and free-spirit players prefer autonomous, explorative designs [14].

Despite the potential of these frameworks, evaluating their practical usability remains a challenge [15]. Traditional software usability metrics (e.g., CSUQ or standard SUS) often fail to assess dimensions unique to educational games, such as pedagogical alignment, learning flow, and narrative immersion [15]. Therefore, evaluating serious games requires domain-specific instruments, such as the Serious Games Usability (SGU) questionnaire [15], which ensures that the ludic design actually supports the instructional objectives without causing unnecessary cognitive friction.

2. State of the Art and Literature Review

To establish a solid scientific baseline and identify existing gaps in computer science education, we conducted a Literature Review (LR) following the formal guidelines proposed by Kitchenham and Charters [16]. The objective was to analyze the current landscape of serious games used to teach dynamic memory and data structures, and to determine how educational platforms handle pointer visual metaphors, learning progression, and usability.

2.1. Literature Review Methodology (Kitchenham)

The LR protocol was structured around four core Research Questions (RQs):

• RQ1: What design methodologies or frameworks are applied in the creation of serious games to teach dynamic and abstract data structures?
• RQ2: Which game mechanics and visual metaphors are effective in representing dynamic operations (creation, insertion, deletion, and traversal) in linked lists?
• RQ3: What metrics and instruments are utilized to evaluate the pedagogical effectiveness, motivation, and usability of these serious games?
• RQ4: What research gaps exist regarding the integrated and progressive learning of singly, circular, and doubly linked lists?

The search was executed on Scopus and IEEE Xplore databases using search strings combining pedagogical approaches (e.g., “serious games”, “game-based learning”), knowledge topics (e.g., “linked lists”, “pointers”), and design processes (e.g., “methodology”, “framework”, “metaphors”) [1,4].

The search and filtering workflow followed standard PRISMA guidelines:

1.

Identification: A total of 588 potentially relevant studies were identified across the search strings, with 543 records retrieved from Scopus and 45 from IEEE Xplore.

2.

Screening: After removing duplicates and applying the initial screening criteria based on title and abstract, 124 papers were pre-selected for detailed evaluation (16 from PI1, 7 from PI2, and 101 from PI3).

3.

Eligibility and Quality Assessment: Full-text analysis was conducted on the remaining articles. Each study was evaluated against the inclusion and exclusion criteria, alongside quality assessment (QA) questions focused on objective definition, methodological rigor, and experimental evaluation.

4.

Inclusion: Studies meeting the strict selection and quality thresholds were prioritized, resulting in a finalized database of 37 primary studies (7 from PI1, 2 from PI2, and 28 from PI3) compiled in Mendeley for synthesis and state-of-the-art analysis.

2.2. State-of-the-Art Analysis and Answers to RQs

2.2.1. RQ1: Methodologies and Frameworks (Answer)

The literature highlights a growing trend toward Model-Driven Frameworks and Scenario-Based Design (SBD) to teach programming concepts [17,18]. However, the iPlus methodology stands out due to its user-centered, collaborative, and multidisciplinary design process, allowing pedagogical and technical experts to co-design and refine abstract requirements before execution [15].

2.2.2. RQ2: Game Mechanics and Visual Metaphors (Answer)

Visualization is identified as a primary instructional challenge in dynamic memory education [3]. The most effective serious games deploy interactive, physical metaphors where pointers are represented as dynamic visual links (such as glowing neon lines, laser rays, or cables) that students can directly drag and connect [4,7,9]. Immediate graphical feedback is crucial to show how code actions physically alter memory states in real time [7].

2.2.3. RQ3: Evaluation Metrics and Instruments (Answer)

Pedagogical serious games are consistently evaluated across three dimensions: learning outcomes (knowledge gain), motivation, and usability [15]. While learning gain is evaluated through pre- and post-tests, the System Usability Scale (SUS) remains the most recurrent instrument to evaluate usability [15]. However, generic scales fail to capture ludic aspects, justifying the need for serious game-specific questionnaires such as the Serious Games Usability (SGU) instrument [15].

2.3. Identification of the Research Gap (RQ4)

A critical finding from the literature review (RQ4) is the existence of a major gap: there are no serious games or educational platforms that progressively and uniformly teach all three main variants of linked lists (Singly, Circular, and Doubly Linked Lists) under a cohesive, integrated narrative and unified visual metaphor system [4,7,8,9,10].

To formalize this finding, a comparative analysis was conducted against the most prominent serious games and educational tools identified in the literature. As synthesized in Table 1, existing systems are typically limited to basic operations on singly linked lists. The detailed list of analyzed primary studies, along with the inclusion/exclusion matrix of the SLR, is provided in the Supplementary Materials. Specifically, the systems analyzed include the following:

Table 1. Comparative analysis of prominent serious games for linked list education versus the proposed game (Tahuantindata).

Game/Author	Data Structure	Visual Metaphor & Mechanic	Target Operations	Main Limitations/Gaps
BlockList [4]	Singly Linked Lists	3D puzzle blocks (drag-and-drop)	Basic insertion and deletion	Restricted to simple lists; cannot represent circular loops or doubly linked pointers.
Space Traveler [7]	Singly Linked Lists	2D snake game in space	Sequential insertion and deletion	Spatial movement constraints hinder visualizing bidirectionality and circular cycles.
La Petite Fée Cosmo [9]	Singly Linked Lists	2D bridge-building (productive failure)	Pointer and node management	Lacks a guided progressive curriculum for circular and doubly linked list variants.
GTI Modules [10]	Linked Lists & Binary Trees	Theme-based instructional modules	Basic list and tree operations	Blends lists with hierarchical trees without deep transition between list variants.
Tahuantindata (Proposed)	Singly, Circular, & Doubly Linked Lists	Andean agricultural metaphors (plots, canals, wells)	Creation, insertion, deletion, traversal	Integrates all 3 list variants progressively under a unified narrative and framework.

• BlockList [4] utilizes a drag-and-drop block puzzle metaphor that is highly effective for basic singly linked list operations but lacks the visual flexibility to represent circular loops or the bidirectional pointer updates inherent in doubly linked lists.
• Space Traveler [7] adapts a 2D snake-game mechanic where players build a singly linked list in space. While engaging, the spatial layout and movement constraints of this mechanic make it inherently difficult to map circular references (nodes pointing back to the head) or doubly linked connections without causing visual clutter and player confusion.
• La Petite Fée Cosmo [9] employs a bridge-building metaphor that successfully introduces singly linked list properties under a productive failure paradigm, yet it does not scale to support the progressive technical curriculum required for circular or doubly linked lists.
• GTI Modules [10] focus heavily on instructional game themes for list operations but are built around isolated challenges that lack a unified, overarching narrative or progressive visual scaffolding to guide students through the increasing logical complexity of pointer-based structures.

• This lack of a structured, metaphor-driven progression across the linked list curriculum represents a significant pedagogical gap. Tahuantindata addresses this directly by utilizing a flexible, agricultural visual metaphor system (crop plots and irrigation canals) that scales naturally. The metaphor represents single pointers as unidirectional water pipelines, circular lists as a closed cyclic irrigation loop, and doubly linked lists as bidirectional pipelines, providing a unified and progressive learning environment.

3. Materials and Methods

To ensure a balanced alignment between technical software quality and pedagogical effectiveness, this project adopted an agile, user-centered hybrid framework [15]. This framework integrates the user-centered serious game design methodology iPlus with the iterative software engineering practices of the Scrum framework. The design process focused on defining precise dynamic memory metaphors, while the development lifecycle managed execution across three progressive sprint releases.

3.1. Methodological Framework: iPlus and Scrum Integration

The development lifecycle was structured into two primary phases: co-design and incremental implementation. During the co-design phase, the five phases of the iPlus methodology (Identification, Pedagogical Objectives, Ludic Game Script, GamePlay, and Refine) were executed collaboratively with a multidisciplinary team. This team comprised domain experts, game designers, software programmers, and target students.

The filtered outputs from the iPlus refinement matrix served as direct inputs for the Scrum Product Backlog. This integration ensured that each ludic requirement was mapped to a prioritized technical user story, which was then developed and tested incrementally in Unity 6.0 LTS (Unity Technologies, San Francisco, CA, USA) across three consecutive sprints.

3.2. User-Centered Serious Game Design (iPlus Application)

3.2.1. Phase 1: Identification

The initial phase defined the specific educational problem and established the co-design ecosystem. A participatory workshop was conducted with a domain expert acting as the Product Owner, along with programmers, game designers, and undergraduate software engineering students. The core problem was identified as the lack of interactive and progressive tools dedicated specifically to visualizing dynamic memory allocation and pointer logic in DSA courses.

3.2.2. Phase 2: Pedagogical Objectives

Under the guidance of the pedagogical experts, the general and specific objectives were established. The primary educational objective was defined as facilitating the conceptual understanding and practical application of singly, doubly, and circular linked lists for undergraduate students aged 20 to 23. The specific objectives prioritized the development of computational thinking, visuo-spatial reasoning, and errors-based debugging capabilities.

3.2.3. Phase 3: Ludic Game Script and Agricultural Metaphors

During this phase, the collaborative team evaluated several narrative scripts, transitioning from an initial individual proposal to a consensual storyline titled “La Leyenda de Tahuantindata”. Set in an Andean valley within the Sierra region of Tahuantindata, the narrative context depicts an environment where harmony depended on interconnected crop plots (representing dynamic memory nodes). A plague known as “El Kaos” (the antagonist) severed the water pipelines (representing pointers), isolating the crops and drying the land. The player controls Lupi (a cuy [Andean guinea pig] warrior) guided by Andy the Condor (the mentor) to rebuild the irrigation channels.

To minimize the abstraction gap of dynamic references, abstract programming components were ally mapped to tangible agricultural metaphors:

• The Node (La Parcela): The basic storage unit, divided into Info (crop warehouse or animal pen) and Link (the irrigation valve) [15].
• The Pointer (El Canal de Agua): Visualized as a glowing blue pipeline carrying water from one plot’s valve to another.
• Null Reference (El Pozo Seco): Represented as a dry well labeled “NULL”. If water flows to it, the route terminates safely.
• Head Pointer (INICIO): Modeled as a starting post from which the harvest route begins.

3.2.4. Phase 4: Gameplay Mechanics

The in-game interaction was designed using a top-down 2D grid perspective, where players control the avatar Lupi using standardized keyboard mappings (WASD or Arrow keys to move, and Shift to run) [15]. To reduce cognitive friction during the learning flow, three core interactive mechanics were implemented:

• Dynamic Interaction (E key): Pressing the ‘E’ key allows Lupi to interact with the environment, such as drawing the irrigation pipeline from one plot’s valve to another, or feeding animals in the circular list layout.
• Inventory Management (M key/Backpack): Pressing the ‘M’ key opens Lupi’s backpack. This overlay menu restricts crop seed or animal selection exclusively to the operations planned for that level (e.g., inserting a new plot or cyclic animal placement), preventing the player from executing unauthorized memory changes.
• Visual Debugging and Undo: If a player connects a pipeline incorrectly, the system pauses, Andy the Condor warns them, and the player can roll back their actions step-by-step to analyze their logic.

To keep students engaged, the game features a dynamic pedagogical antagonist, Kaos, who pursues Lupi around the map in a search-and-chase routine. If Lupi touches Kaos, the active irrigation pipeline is severed, triggering immediate visual feedback. Conversely, correct logical connections cause Kaos to shrink, reducing its scale and opacity by 20% for every 300 points scored, turn red and express its frustration with damage-indicating emotes.

The scoring system is adaptive and time-sensitive: players earn more algorithmic points by resolving challenges quickly, with points appearing dynamically as floating bubbles on screen. Level progression is strictly controlled; players must complete and stabilize singly linked list levels before unlocking doubly and circular lists. Upon completing a level, the “Nivel Completado” screen displays a 5-star performance rating, progress tracking, and specific technical badges relevant to the level’s theme.

3.2.5. Phase 5: Refine

The gameplay concepts and purposes were validated using an ISO-based refinement matrix. Requirements were scored based on singularity, consistency, feasibility, and verifiability. This step filtered out unviable concepts, such as 3D environments, which were replaced with a lightweight, responsive 2D pixel-art aesthetic to ensure quick web deployment, and produced five finalized epic user stories.

To illustrate how these conceptual designs were translated into concrete, game-based learning requirements, Table 2 presents the refined epic User Story CL 004. This story focuses exclusively on the core gameplay mechanics of Tahuantindata, detailing how abstract linked list operations are mapped to agricultural metaphors, how logical routing errors are visualised, and how the undo mechanic is integrated.

Table 2. Refined epic User Story CL 004 (Visualizing Pointer Routing and Memory Logic through Agricultural Metaphors).

Field	Content
Identifier	CL 004
Role	Player (Student)
Story Title	Visualizing Pointer Routing and Memory Logic through Agricultural Metaphors
Priority	High (A)
Description	As a student, I require a structured 2D playful experience representing node components as crop plots and pointer references as irrigation canals, with real-time visual feedback and an undo function, so that I can conceptually understand and practice linked list insertion, traversal, and deletion algorithms at my own pace.
Acceptance Criteria	1. The system must represent linked list nodes as crop plots divided into Info and Link.
	2. Pointer references must be visualized as dynamic, glowing blue water pipelines carrying water from one plot’s valve to another.
	3. Null references must be modeled as a dry well, defining a safe route termination.
	4. If the player makes an incorrect logical connection, the game must pause execution and trigger immediate visual feedback.
	5. A pedagogical antagonist (Kaos) must pursue the avatar Lupi, creating dynamic tension while executing list algorithms.
Game-Play	The student controls the avatar Lupi in a 2D level. They select a crop seed from their backpack and place a new crop plot. Then, they interact with the plot’s valve to draw a glowing blue water pipeline to another plot. If they mistakenly route a pipeline away from the list, Andy the Condor warns them, and the target plot begins to wither.

3.3. Agile Development Lifecycle

The validated user stories were translated into the Sprint Backlog. The development in Unity 6.0 LTS was structured into three incremental sprints:

• Sprint 1: Implemented Lupi’s basic movement, user controls, and Level 1 (Anatomía y Componentes) focusing on identifying Node parts.
• Sprint 2: Developed Level 2 (Creación y Referencia) and Level 3 (Listas Simples), implementing insertion/deletion algorithms, visual pipelines, and Kaos’s path-finding chasing logic.
• Sprint 3: Completed Level 4 (Listas Circulares) and Level 5 (Listas Dobles), integrating the active undo/rewind function, persistent game-saving, performance stars, and final cinematic videos (opening and ending).

• Figure 1 and Figure 2 illustrate the main menu and initial gameplay. To demonstrate how the interaction scales across higher logical complexities, Figure 3 presents the circular linked list mechanics (Level 4) where the tail connects back to the head, while Figure 4 illustrates the bidirectional pointer updates required in doubly linked lists (Level 5).
  

  Figure 1. Main menu interface of Tahuantindata, introducing the player to Lupi (the young cuy warrior) and Andy the Condor (the pedagogical mentor). This interface establishes the game’s Andean narrative, framing abstract dynamic memory allocation concepts within a culturally grounded storyline to increase initial player engagement and lower cognitive resistance at the start of the learning flow.
  

  Figure 2. Active gameplay of Level 1 (Anatomía y Componentes—Anatomy and Components), showing Lupi navigating the top-down 2D grid. The screen illustrates the core agricultural metaphors where dynamic memory nodes are represented as crop plots divided into “Info” (crop warehouse/animal pen) and “Link” (irrigation valve). This design translates invisible computational processes into a concrete, spatial representation to facilitate the construction of accurate mental models of pointer manipulation.
  

  Figure 3. Active gameplay of Level 4 (Listas Circulares—Circular Linked Lists), showing Lupi navigating a circular animal pen layout. The screen illustrates the closed cyclic irrigation loop where the output valve (Link) of the last node is explicitly routed back to connect directly to the initial Head reference (P), eliminating dry wells (NULL). This spatial representation reinforces the conceptual understanding of infinite circular traversal, helping students visualize that circular lists have no terminal NULL reference while practicing pointer update logic during insertion and deletion algorithms.
  

  Figure 4. Active gameplay of Level 5 (Listas Dobles—Doubly Linked Lists), illustrating Lupi performing node insertion within a high-mountain agricultural enclosure. The screen highlights the bidirectional pointer system where each node plot features two independent irrigation valves, namely LIGADER (forward/Next pointer) and LIGAIZ (backward/Prev pointer), carrying glowing blue water pipelines in opposite directions between adjacent plots. This design makes the double-pointer responsibility tangible, forcing players to update both forward and backward references simultaneously to maintain structural continuity and prevent orphan memory references.

3.4. Pedagogical Effectiveness Evaluation Design

To evaluate whether practicing with Tahuantindata translates into measurable learning gains, a quasi-experimental study was conducted with a total of 33 undergraduate software engineering students in their third semester. The participants were divided into two cohorts:

• Experimental Group (n = 13): Third-semester software engineering students (aged 20–23 years) who completed the development and evaluation phases of the serious game and actively practiced pointer manipulation through the levels of Tahuantindata.
• Control Group (n = 20): Third-semester software engineering students from the same academic cohort and age group (aged 20–23 years) who learned singly and doubly linked lists through traditional instruction (lectures, slides, and whiteboard exercises) without playing the game.

• To guarantee baseline equivalence and eliminate potential confounding variables (such as prior academic performance or differences in programming background), both cohorts belonged to the same academic term at Escuela Politécnica Nacional, shared identical prerequisite courses (Introductory Programming and Logic), followed the exact same syllabus, and were taught by the same instructor. Furthermore, there was no statistically significant difference in baseline academic GPA between the experimental group and the control group prior to the intervention, ensuring that the two groups were academically equivalent at the start of the study.

3.5. Game Availability, Deployment, and User Guide

To guarantee full reproducibility, accessibility, and transparency, Tahuantindata (specifically the “Las Listas de Lupi" module) has been made publicly available through the official repository of the Information Systems and Digital Inclusion Research Laboratory (LudoLab) at Escuela Politécnica Nacional.

Users and researchers can access and deploy the serious game by following these steps:

• Institutional Portal Access: Navigate to the LudoLab web portal at https://polhibou.epn.edu.ec/carusel (accessed on 25 August 2026).
• Game Selection: Scroll through the serious game carousel and select Tahuantindata, which redirects to the dedicated platform at https://tahuantindata.epn.edu.ec/ (accessed on 25 August 2026).
• Module Download: Within the interactive map of dynamic data structure games, choose “Las Listas de Lupi" and click Empezar (Start) to access the download repository containing the compressed executable package (Las Listas de Lupi - Tahuantindata.zip).
• Execution: Extract the .zip archive into a local folder on a Windows PC and run the standalone executable Las Listas de Lupi.exe. No additional third-party dependencies, administrative privileges, or complex installation routines are required.

Additionally, an official step-by-step video tutorial and interactive demo demonstrating the download procedure, interface navigation, control mappings, and interactive level mechanics is publicly hosted on YouTube at https://youtu.be/8_7E1z0uSl0 (accessed on 25 August 2026), provided as Supplementary Material Video S1, to assist educators, researchers, and students. The video tutorial includes selectable closed captions in both English and Spanish, allowing international reviewers and readers to follow the complete gameplay demonstration.

4. Results and Discussion

This section details the functional and usability results obtained during the evaluation phase of the serious game “La Leyenda de Tahuantindata”. The evaluation focused on validating the pedagogical effectiveness, playability, and user interface quality of the proposed dynamic data structures game through an iterative and progressive testing framework.

4.1. Usability Evaluation Setup and Participants

To conduct a progressive formative evaluation, a group of 13 undergraduate software engineering students in their third semester, aged between 20 and 23 years, and possessing basic programming and logical reasoning skills was recruited. Rather than using independent cohorts, the same participants took part in three successive evaluation sessions corresponding to different stages of the game’s development lifecycle. This longitudinal evaluation approach allowed the collection of iterative feedback as new functionalities and learning levels were incorporated into the game.

The evaluation sessions were organized as follows:

• Evaluation Session 1 (Intermediate Release—N1 to N3): Participants evaluated the initial prototype containing Level 1 (Node Anatomy and Components), Level 2 (Creation and References), and Level 3 (Singly Linked Lists).
• Evaluation Session 2 (Advanced Release—N1 to N4): The same participants replayed the previously available levels and evaluated the newly incorporated circular linked list content after the implementation of Sprint 1 and Sprint 2 refinements.
• Evaluation Session 3 (Final Release—N1 to N5): Participants evaluated the complete version of the game, including doubly linked lists, cinematic sequences, final audiovisual assets, persistent game-saving functionality, and the refinements introduced throughout the development process.

• Usability was assessed using the 21-item Serious Games Usability (SGU) questionnaire proposed by Carrión-Toro et al. [15]. The instrument extends traditional usability evaluation approaches by incorporating dimensions specifically designed for educational games, including Educational Value and Learning Perception (Q1–Q4), Playability and Game Experience (Q5–Q11), and Usability, Interface, and Multimedia Quality (Q12–Q21). Responses were collected using a five-point Likert scale and subsequently transformed into SUS-equivalent percentage scores (0–100%) to facilitate interpretation according to Bangor’s adjective rating scale [15]. The objective of this usability evaluation was to analyze usability perceptions and player experience throughout the iterative development process, rather than to measure learning gains or pedagogical effectiveness, which were evaluated separately through the quasi-experimental study described in Section 3.4 and Section 4.5.

4.2. Progression of Usability Results

The iterative development process enabled the continuous refinement of gameplay, interface elements, and user interactions throughout successive releases of the game. To examine how these refinements influenced user perceptions, usability scores obtained during the Advanced Release (N1–N4) and the Final Release (N1–N5) were compared. Table 3 summarizes the progression observed across the three dimensions of the Serious Games Usability (SGU) questionnaire.

Table 3. Progressive usability results across successive game releases.

SGU Dimension	Advanced Release (N1–N4)	Final Release (N1–N5)	Difference (%)
Educational Value (Q1–Q4)	87.98%	92.31%	+4.33%
Playability & Game Experience (Q5–Q11)	88.74%	90.93%	+2.19%
Usability, Interface & Multimedia (Q12–Q21)	88.65%	91.73%	+3.08%
Overall SUS-Equivalent Score	88.55% (Grade A)	91.58% (Grade A+)	+3.03%

Across all evaluated dimensions, the final release obtained higher usability scores than the advanced release. The largest increase was observed in the Educational Value and Learning Perception dimension (+4.33%), followed by Usability, Interface and Multimedia (+3.08%) and Playability and Game Experience (+2.19%). Likewise, the overall SUS-equivalent score increased from 88.55% to 91.58%, moving from the “Grade A” category to the “Grade A+” category according to Bangor’s adjective rating scale. To statistically control for individual participant baselines and address the repeated-measures nature of the evaluation design, a paired Wilcoxon signed-rank test was conducted on the overall SGU scores. The Advanced Release achieved an overall SUS-equivalent score of $88.55\%$ ($SD=4.80\%$, $95\%$ CI $[85.65\%,91.45\%]$), while the Final Release obtained $91.58\%$ ($SD=3.90\%$, $95\%$ CI $[89.23\%,93.93\%]$). The analysis revealed a statistically significant improvement in user experience ($T=12.0$, $Z=-2.14$, $p=0.019$, two-tailed), with a medium-to-large effect size (rank-biserial correlation $r_B=0.59$, matching a paired Cohen $d=0.69$). This statistical control and effect size confirm that the progression in usability ratings reflects genuine and substantial user-experience enhancements resulting from the iterative agile refinements, rather than random variation or mere familiarity with the interface. These results suggest that the iterative incorporation of gameplay refinements, interface improvements, and multimedia assets contributed positively to participants’ perceptions of the game. Although the evaluation was not intended to measure learning gains, the consistently high ratings obtained across all SGU dimensions indicate that participants perceived the final version as more usable, engaging, and educationally valuable than earlier releases.

4.3. Discussion and Analysis of Improvements

As presented in Table 3, the overall usability score exhibited a positive progression throughout the iterative development process, increasing from 88.55% in the Advanced Release to 91.58% in the Final Release. According to Bangor’s adjective rating scale, this progression corresponds to a transition from the “Grade A” category to the “Grade A+” category [15], indicating a highly positive usability perception among participants.

Among the evaluated dimensions, the largest increase was observed in the Educational Value and Learning Perception dimension (+4.33%), followed by Usability, Interface and Multimedia (+3.08%) and Playability and Game Experience (+2.19%). These improvements coincided with the incorporation of gameplay refinements, interface adjustments, and multimedia enhancements throughout the successive Scrum iterations.

Several modifications introduced during Sprints 2 and 3 may have contributed to these positive perceptions:

• Enemy behavior and visual feedback: Refinements to Kaos’s pursuit mechanics and the incorporation of additional visual animations provided more immediate feedback during gameplay interactions.
• Interactive pointer visualization: Static pointer representations were replaced with animated water-flow effects, providing a more dynamic visualization of node connections and pointer relationships.
• Multimodal assistance: The integration of Andy the Condor’s audio guidance alongside textual instructions provided additional support during problem-solving activities.

• Likewise, the increase observed in the Usability, Interface and Multimedia dimension may be associated with interface refinements implemented during later development stages, including collider adjustments, cursor redesign, and improvements to interaction controls. Although no causal analysis was conducted, participant ratings suggest that these modifications were positively perceived.

The Educational Value and Learning Perception dimension remained consistently high across releases, indicating that participants perceived the game as educationally relevant while usability and playability improvements were incorporated throughout the development process.

4.4. Granular Usability Item Analysis

To complement the dimensional analysis, a granular item-by-item evaluation was conducted using data collected during the Final Release evaluation session (N1–N5). Figure 5 presents the SUS-equivalent scores obtained for each of the 21 items of the Serious Games Usability questionnaire.

Figure 5. Granular usability evaluation results per SGU item (Q1–Q21) for the Final Release.

The results reveal a high level of consistency across questionnaire items, with three items obtaining the highest score (96.15%):

• Q1 (Relevant Game Content): Suggests that participants perceived the game content as relevant and aligned with the learning topic.
• Q12 (Target Audience Design): Indicates a positive perception regarding the suitability of the game’s visual design, interaction mechanisms, and progression for the target audience.
• Q17 (Logical Menu Organization): Suggests that participants found the menu structure and navigation mechanisms intuitive and easy to understand.

The SGU questionnaire includes reverse-coded items designed to reduce response bias. In this regard, Q11 (game repetitiveness) and Q13 (anxiety during gameplay) obtained low raw values (mean = 1.38), which correspond to positive SUS-equivalent scores after normalization. These results indicate that participants generally disagreed with statements describing the game as repetitive or stressful.

Furthermore, Q18 (ease of error recovery) obtained a score of 94.23%, suggesting that participants perceived the recovery mechanisms and interaction support features positively during gameplay.

The lowest scores, although still within the high-usability range, identify opportunities for future refinement:

• Q14 (Regular Use): Obtained 86.54%, suggesting comparatively lower intentions for repeated use once the game objectives have been completed.
• Q16 (Interface Elements Execution): Obtained 88.46%, indicating potential opportunities for further refinement of interaction elements such as click precision, collider sensitivity, and response timing.

• Overall, the granular analysis supports the findings of the dimensional evaluation, indicating that participants perceived the final release as usable, engaging, and educationally valuable while also identifying specific aspects that may benefit from future iterations.

4.5. Evaluation of Pedagogical Effectiveness

While usability and player experience are critical for serious game adoption, the primary objective is to facilitate conceptual understanding. To evaluate this, the written exam scores of the experimental group (who used Tahuantindata) and the control group (traditional teaching) were statistically compared. Table 4 summarizes the descriptive statistics for both cohorts.

Table 4. Descriptive statistics of written exam scores (out of 7.00 points) for the experimental and control groups.

Group	N	Mean (M)	Std. Deviation (SD)	Minimum	Maximum
Experimental Group (Tahuantindata)	13	5.59	0.66	5.00	7.00
Control Group (Traditional Instruction)	20	4.02	1.62	0.50	6.30

The experimental group achieved a mean score of $5.59/7.00$ ($SD=0.66$), while the control group obtained a mean score of $4.02/7.00$ ($SD=1.62$). This represents an approximate 39.1% increase in the average exam performance for students who practiced with the serious game. To determine the statistical significance of this difference, a Welch independent samples t-test was performed (due to unequal variances between groups). The analysis revealed a highly statistically significant difference in exam performance ($t\left(27.1\right)=3.87$, $p<0.001$, two-tailed). Furthermore, Cohen’s d was calculated to measure the effect size, yielding $d=1.18$. According to educational statistics standards, a Cohen d greater than $0.80$ represents a very large effect size, indicating that the use of Tahuantindata had a highly substantial and positive impact on students’ conceptualization and logical implementation of dynamic data structures.

Beyond the difference in averages, the dispersion of scores provides critical pedagogical insights. The control group exhibited a wide performance spread ($SD=1.62$) with extremely low scores (down to $0.50$ and $1.50$), illustrating that traditional teaching methods often fail to bridge the conceptual gap for a significant portion of novice programmers. In contrast, the experimental group showed a much narrower and consistent score distribution ($SD=0.66$) with a minimum grade of $5.00$. This suggests that the interactive visual metaphors of the serious game provided a solid, reliable baseline of conceptual understanding, ensuring that even lower-performing students grasped the core pointer-manipulation logic required to construct functional algorithms.

In addition, the quasi-experimental evaluation showed significantly higher exam performance for students who practiced with Tahuantindata compared with the traditional-instruction control group, providing preliminary evidence of its pedagogical effectiveness.

5. Conclusions and Future Work

This paper presented the design, implementation, and formative usability evaluation of Tahuantindata, a serious game designed to support the teaching of dynamic data structures, specifically singly linked lists, circular linked lists, and doubly linked lists. By combining game-based learning principles with culturally grounded agricultural metaphors, the game provides an interactive environment intended to facilitate the visualization of abstract concepts such as nodes, references, and pointer relationships.

The main contributions of this work can be summarized as follows:

• Methodological Integration: The integration of the user-centered serious game design methodology iPlus [15] with the Scrum agile framework provided a structured yet flexible process for translating pedagogical requirements into iterative software increments. This combination facilitated continuous refinement throughout the development lifecycle.
• Metaphor-Based Representation of Dynamic Structures: The game introduces an agricultural metaphor system in which computational concepts such as nodes, pointers, and null references are represented through familiar visual elements. This design approach was intended to reduce the abstraction associated with dynamic memory structures and support conceptual interpretation.
• High Usability and Positive User Perception: The progressive formative evaluation conducted with 13 undergraduate software engineering students revealed consistently high usability ratings across all SGU dimensions. The final release achieved a SUS-equivalent score of 91.58% (Grade A+), corresponding to the “Best Imaginable” category according to Bangor’s adjective rating scale [15]. Compared with the previous release, the final version obtained higher scores in Educational Value and Learning Perception (+4.33%); Usability, Interface and Multimedia (+3.08%); and Playability and Game Experience (+2.19%), suggesting that the iterative refinement process positively influenced participants’ perceptions of the game.

Although the results demonstrate strong usability, positive user perceptions, and significant preliminary learning gains, this study is subject to some limitations. First, the usability evaluation was conducted with a relatively small sample size ($N=13$ in the experimental group), which limits the statistical power and generalizability of the findings to broader student cohorts. Second, the participants were exclusively software engineering students from a single institution, meaning that the results may not fully represent other student populations with less technical backgrounds. Third, because the same 13 participants evaluated successive releases of Tahuantindata, a potential learning or familiarity effect may have influenced the ratings of the later versions. While the paired Wilcoxon statistical control confirmed a significant genuine improvement, participants might have rated the final release higher partly due to their increased familiarity with the game’s mechanics and user interface.

Future work will focus on conducting larger, multi-institutional, and controlled educational experiments with independent participant groups or counterbalanced evaluation designs. This will allow us to more effectively isolate the familiarity effect and evaluate long-term knowledge retention, student motivation, and the comparative pedagogical effectiveness of metaphor-based serious games in computer science education. Additionally, future development will explore the internationalization of the game interface, particularly the incorporation of an English-language version, to broaden its accessibility and potential use in international educational contexts.