Towards a Constructionist Serious Game Engine

International Conference on Computer Systems and Technologies - CompSysTech’16

Towards a Constructionist Serious Game Engine Adilson Vahldick, António José Mendes, Maria José Marcelino Abstract: Game developers have been using commercial game engines to create serious games. The development of serious game is a process that requires game and instructional design. Constructionist environments and games are becoming more popular in the last years because of the importance of Computational Thinking to develop problem solving skills. Despite this popularity, there is a lack of available game engines and frameworks to develop this kind of games. This paper proposes a game engine architecture to support the affordable development of constructionist games. The game engine specification describes components of game, instructional and constructionist elements as a low-level definition that facilitates direct implementation. A serious game built upon this specification and used by 96 students is also presented in this paper. This validation provided some future work ideas, as an editor tool, SDK and API. Key words: Serious Game, Game Engine, Game Architecture, Computer Programming Learning, Constructionist Games

INTRODUCTION Computers can improve learning when students see a concrete result of their computing efforts [1]. In a constructionist approach, students articulate their learning by constructing, exploring, manipulating and testing knowledge concepts into a microworld [2]. Playing is an important evolutionary biological function related to learning [3]. Computer games often include manipulation of elements in a microworld. Constructionist games bring central constructionist ideas (learner-directed exploration, personally meaningful constructions, emphasis on powerful ideas) to the video game design [4]. Complexity reduction and abstraction of real life situations promotes the game operationalization and the student learns by analysing the effects of her/his actions [5]. Computational Thinking (CT) takes an approach to problem solving, systems design and human behaviour understanding that draws on fundamental computing concepts [6]. In the last decade, CT environments and games are the materialization of constructionist approach to learning. They share the development of two core skills: procedural thinking and debugging. Thinking procedurally involves chunking problems into smaller bits and recognizing patterns that can be effectively repeated [1]. Debugging involves systematic attempts to adjust a procedure or a function in an effort to identify and correct “bugs” or errors that keep a system from running properly [7]. Game engines can help developers to save time and money, as they are extensible software that can be used as the foundation for many different games without major modification, including rules and meta-rules that create the game experience [8]. According to Cowan and Kapralos almost all serious game developers use commercial game engines suggesting that there is a lack of features in serious game engines [9]. A major challenge is the availability of resources to integrate programming tasks into existing game engines [10]. To fill this gap, our research aimed to identify essential elements of constructionist games and organize them as an extensible engine architecture. This paper describes this architecture and its use to build a CT game. This game was tested by two different undergraduate students groups. The paper is organized as follows: next two sections present the background of this research; fourth section describes the proposed game engine architecture; fifth section demonstrates an instantiation of this architecture; and the last section presents conclusions and future work. GAME-BASED LEARNING ENGINES Engines provide reusable components to speed up the game development. These components should help in animation and rendering, deal with game input (keyboard, mouse or physiological devices), multimedia, character manipulation, artificial intelligence, network and multiplayer, and game logic (levels, challenges, rewards, achievements)


management. In practice, most game engines are tuned to a particular content style, for instance, adventure [11], real-time strategy [12] and scenario based [13] games. Furthermore, serious game engines add features to provide the content, perform assessments and give feedback. Some engines are developed for specific contexts, as journalism [14], sustainability education and conservation [15], safety management [16] and computer programming [17, 18]. In [17], the authors built a learning engine extending an open source 3D engine. Torrente et al. [18] present learning elements (set of actions and structures, ie., the commands available to create the program) and an interpreter layer that translates the program to the set of actions and structures. Engines with built-in features that create specific types of games usually have more pedagogical value and facilitate educators use [11]. Ahmad et al. [19] reviewed six frameworks and models to develop serious games and found deficiencies on how to use them for development and testing. These models are high-level specifications, which identify requirements and features that should be present in serious games. Game engines attempt to provide standard solutions for game programming problems without prescribing particular rules or settings for a game [20], but making these solutions available through APIs. Conclusions of Ahmad et al. [19] confirm observations made by Cowan and Kapralos [9]: research must provide more concrete tools to foster serious game engines development and adoption. CONSTRUCTIONIST DIGITAL GAMES A microworld is a “space” with assumptions and constraints that gives a context for the learner to construct his/her knowledge through experimentation [1]. Students learn by exploring and building in this world, and the effects of these actions reflect what is correct or wrong in their beliefs. Learning results from active practice. Constructionist games meet two design principles: their tools must be expressive and in-game goals should encourage exploration [21]. The size of commands, or building blocks, should allow the player to express ideas and strategies that are meaningful in the learning context: not too large that the game becomes too easy, but not too small to avoid tedious or too difficult tasks. Games can reward players for a variety of discovered or invented ideas, not limiting them to a single or a small set of winning strategies. Construction activities can take many forms, but it is important that the resulting artefacts are identifiable and useful. Moreover, the interaction and feedback loop typical to develop CT [22] is suited to any constructionist game: (1) learners design, run and debug a solution, (2) game performs actions based on the solution submitted, and (3) game gives feedback to the learner. This iterative and interactive cycle provides powerful possibilities for the learners to try and retry their beliefs, and improve their knowledge concepts. Figure 1 exemplifies two constructionist (and CT) games with different approaches on how to construct the solution.

(a) Fig 1. Constructionist Games: (a) code.org (b) Formula T Racing

(b)


First, code.org (Fig 1a) adopts Blocks-Based Programming (BBP) as Scratch and Alice. BBP is a programming approach where programs are created using only a mouse and by snapping together blocks into a Lego-type form [23]. In Formula T Racing (Fig 1b) [7] players “drive-by-paint”. Each colour corresponds to a particular velocity, and the player paints the road to adjust the car velocity. THEORETICAL CONSTRUCTIONIST SERIOUS GAME ENGINE The Constructionist Serious Game Engine (CSGE) proposed in this paper aims to represent the essential components (game, instructional and constructionist) and their relation to create games that promote learning of a domain through a constructionist approach following the principles described in the two previous sections. Figure 2 shows the components that compose the CSGE architecture and how they collaborate. There are three external elements integrated with CSGE: (1) Student, who interacts with the game through the User Interface (UI); (2) Learner Model, that stores the student profile: missions finished, points rewarded, time and attempts spent to finish each mission, learning style, etc.; and (3) Domain Model, that stores the learning content, course sequence and learning tasks (missions). The diagram adopts four visual notations to represent each component type and their relations. Lines represent connections between components as events. Rectangles represent the activities that perform actions after receiving an input event. Ellipses symbolize the data generated by an activity and accessed or changed by others. Double rounded rectangles represent the UI. This specification does not define which is the UI technology (web, mobile, graphical, etc.) and the solution representation model (text, blocks, flowchart, etc.).

Fig 2. Constructionist Serious Game Engine Architecture.


The Mission Selection shows the accomplished and available missions. It retrieves this information from the Mission Sequence component. According to the user choice, it starts the Mission Construction passing it a Mission Configuration. The Mission Sequence loads the learning sequence from the Domain Model to identify the mission order. It also verifies the missions already accomplished by the student, retrieving that information from the Learner Model, and calculates which missions are available to play. The Mission Configuration represents each available mission containing all the information about it: explanation of learning content and mission description; rules, constraints and goals definition; world and its objects configuration; and so on. The Mission Construction is responsible to initialize the game world. It creates the Game Objects and initializes the components Feedback, Goals, Explanation, Reward and Solution Editor. The Solution Editor allows the user to create her/his solutions. When the user decides to test (run or debug) a solution, the Transformation component converts the solution representation to an internal structure (Solution Elements) manageable by the Game Loop and starts the attempt. The Game Loop is responsible to iterate the Solution Elements that change the state of the Game Objects and update the Animation area. The Game Objects refer to the elements that compose the mission challenges, which are changed by the student. The Animation is an area where the student can verify how the solution changes the game environment. The Goals component has the responsibility to verify if objectives are met. Solution Elements and Game Objects have registered Goals components. When something changes in these components, they inform the corresponding Goals component. The task of this component is to compare the constraints in the Solution Elements and the states of the Game Objects with what is defined in the Mission Configuration. If the attempt is successful (met all objectives), Game Loop informs the Reward and Achievements components. The Reward component scores points, experience, coins or other kind of rewards and updates the Learner Model. When Mission Construction initializes the Reward component, it provides the rules to calculate these rewards. The Achievements component verifies awards not specific to a mission, but generic to the whole game. For instance, an award because the player finished the three last missions in less than five attempts. It retrieves data from the Learner and Domain Models. If the user wins some award, it updates the Learner Model. The Feedback component is responsible to provide hints and help to the student in two moments: while she/he is developing the solution and when a solution fails during execution. The Editor has this component registered as listener. During the solution creation the component can recommend actions and commands if the student is idle or in trouble. When a proposed solution does not solve the mission this component can give some suggestions to fix the problem. The Feedback Viewer shows the feedback content. This content takes into consideration the mission specific characteristics provided by the Mission Construction, the Learner Model and the Domain Model. The Explanation component provides explanations about the learning content, describes the mission’s tasks and gives some support to mission understanding (from the textual description) and to the identification of available information to start its solution. The Explanation Viewer displays this information. Mission Sequence, Feedback, Explanation, Mission Configuration constitute the CSGE learning components. These components can also add adaptation mechanisms to personalize teaching and increasing or decreasing the difficulty level based on learning styles, initial levels of knowledge and previous student progress.


CSGE IN ACTION NoBug’s Snack Bar is a serious game to support learning and practice of CT basic concepts. In this game, the player controls an attendant of a snack bar. Customers require some combination of food and drinks, and the attendant must go to places where they are prepared, fetch and serve them. The mission ends when the player meets all requests. The attendant behaviour is programmed using the BBP approach. Figure 3 shows the game’s interface. The animation area (on the left) shows the mission situation and the attendant behaviour controlled by the player solution. The central area allows the construction of the mission solution. The player can run or debug her/his code. If she/he debugs, then the game shows the list of variables (at the right side of the figure) and runs one block at a time after each click of the debug button.

Fig 3. Game interface.

The game runs on web browsers and Figure 4 illustrates its Client-Server architecture. Client-side is implemented with JavaScript and HTML5, and Server-side with Java technologies. Client-side layer interacts with the server-side through a UserControl class using AJAX technology.

Fig 4. Game Architecture.

Almost all components of CSGE are localized in the client-side layer. The solution editor was developed using the free and open source project Blockly [24]. Any need to retrieve and update the Learner and Domain models (for instance from the Reward and Feedback components) is done through AJAX communication. The components Mission Sequence and Achievements are implemented in the server-side because they do not need to update UI components, have more database accesses and their control logic is not needed in the client-side. To reduce the network traffic, only the selected mission is transported to the client-side, as the Mission Configuration component.


Missions are mapped using the Extensible Markup Language (XML) format. Each mission includes: learning content and task description (Explanation); rules that define when a hint is displayed and the solution in natural language (Feedback); initial blocks and commands available to create the solution (Solution Editor); configuration of customers and their wishes (Game Objects); and objectives, game constraints and points (Goals and Reward). The code below illustrates how the rules of hints looks like. The rule activates when the attempt finished with an error and the fail happened in a command block called Deliver. This hint gives some clues to understand why the deliver did not work.

The code bellow exemplifies how goals are defined. The game verifies if the attendant delivered the order to the customer positioned in place 2 on the counter. deliver

The solution building blocks are transformed in JavaScript code. So, the solution can be run by the browser, avoiding the time spent by compilers and interpreters in serverside, and avoiding the transport of data between client and server. The engine was used to create two game versions that were used in two tests involving university level introductory programming students. The first involved 60 Design and Multimedia students in a Portuguese university and the second included 36 Software Engineering students in a Brazilian university. In both cases, the students used the game for about two months. Each group adopted a different course sequence (Figure 5 – each level is represented by a circle), according to the teachers’ preferences. In the first experiment, the 55 missions were divided in 5 sequential levels (Fig 5a). In the second experiment, the 73 missions available were divided in 12 levels (Fig 5b). In figure 5b, white levels correspond to the basic and mandatory missions. Light grey are enhancement levels and dark grey mastering levels. Both structures were created with the same engine, showing that it provides a flexible way to represent and interpret the course sequence and the learning tasks definition.

Fig 5. Course sequence in (a) Portugal and (b) Brazil evaluation.

DISCUSSION AND FUTURE WORK Game engines give practical features to save time and costs in game development. With the advent of CT/constructionist environments and games, we are proposing a set of components and organizing them as a game engine. The architecture proposed deals with game engines, instructional concerns and constructionist tasks, following the interaction feedback loop to develop CT skills. A serious game was built using this architecture. The engine separates the logic control from the learning content. This resulted in a flexible engine that allows the definition of the course sequence and learning tasks (missions) according to the teacher needs and preferences, as demonstrated in the two experiments described above. We did not add adaptation mechanisms to the game, but the model considers that possibility.


The experiments demonstrated the use of this architecture for programming learning games. However, other learning contexts in different areas could also be created using CSGE, as long they use a constructionist approach. As future work we plan to create level editors (course sequence and learning tasks), SDK and API’s to allow others to reuse our engine and extend it to allow the creation of mods (modifications of the original game). ACKNOWLEDGMENT AV acknowledges the doctoral scholarship supported by CNPq/CAPES – Programa Ciência sem Fronteiras – CsF (6392-13-0) and authorized retirement by UDESC (688/13). We also want to thank the students that played the game and their teachers that allowed us to try it with them. REFERENCES [1] Papert, S. Mindstorms: Children, computers, and powerful ideas. New York: Basic Books, Inc., 1980. [2] Laurillard, D., Charlton, P., Craft, B., Dimakopoulos, D., Ljubojevic, D., Magoulas, G., Masterman, E., Pujadas, R., Whitley, E.A. and Whittlestone, K. "A constructionist learning environment for teachers to model learning designs". Journal of Computer Assisted Learning. Vol. 29 (1), pp. 15–30. 2013. [3] Prensky, M. Digital game-based learning. New York: McGraw-Hill, 2001. [4] Weintrop, D. and Wilensky, U. "Situating programming abstractions in a constructionist video game". Informatics in Education. Vol. 13 (2), pp. 307–321. 2014. [5] Kapp, K.M. The gamification of learning and instruction: Game-based methods and strategies for training and education. San Francisco, CA: Pfeiffer, 2012. [6] Wing, J.M. "Computational thinking and thinking about computing". Philosophical Transactions of The Royal Society A. Vol. 366 (July), pp. 3717–3725. 2008. [7] Holbert, N. and Wilensky, U. "Formula Tracing: Designing a game for kinematic exploration and computational thinking". Proceedings of the 7th Annual GLS 2011. [8] Gregory, J. Game Engine Architecture. A K Peters, 2009. [9] Cowan, B. and Kapralos, B. "A survey of frameworks and game engines for serious game development". Proceedings of the IEEE 14th International Conference on Advanced Learning Technologies. : pp. 662–664. 2014. [10] Eagle, M. and Barnes, T. "Experimental evaluation of an educational game for improved learning in introductory computing". Proceedings of the 40th ACM Technical Symposium on Computer Science Education. Chattanooga, TN: pp. 321–325. 2009. [11] Moreno-Ger, P., Burgos, D., Martínez-Ortiz, I., Sierra, J.L. and FernándezManjón, B. "Educational game design for online education". Computers in Human Behavior. Vol. 24 (6), pp. 2530–2540. 2008. [12] Ponsen, M.J.V., Lee-Urban, S., Muñoz-Avila, H., Aha, D.W. and Molineaux, M. "Stratagus: An open-source game engine for research in real-time strategy games". Proceedings of the Reasoning, Representation, and Learning in Computer Games. : pp. 78–83. 2005. [13] Westera, W., Nadolski, R.J., Hummel, H.G.K. and Wopereis, I.G.J.H. "Serious games for higher education: A framework for reducing design complexity". Journal of Computer Assisted Learning. Vol. 24 (5), pp. 420–432. 2008. [14] Hatfield, D. and Shaffer, D.W. "Press play: Designing an epistemic game engine for journalism". Proceedings of the 7th International Conference on Learning Sciences. : pp. 236–242. 2006. [15] Lee, G.E., Xu, Y., Brewer, R.S. and Johnson, P.M. "Makahiki: An open source game engine for sustainability education and conservation". Proceedings of the International Conferences on Education Technologies and Sustainability. : pp. 7–11. 2014.


[16] Park, C.S. and Kim, H.J. "A framework for construction safety management and visualization system". Automation in Construction. Vol. 33 (April), pp. 95–103. 2013. [17] Shabalina, O., Vorobkalov, P., Kataev, A. and Tarasenko, A. Educational games for learning programming languages. Methodologies and Tools of the Modern (e)Learning. Institute of Information Theories and Applications. pp. 79–83. 2008. [18] Torrente, J., Manero, B. and Fernández-Manjón, B. "A game engine to learn computer science languages". Proceedings of the IEEE Frontiers in Education Conference. : pp. 765–771. 2014. [19] Ahmad, M., Rahim, L.A. and Arshad, N.I. "A review of educational games design frameworks: An analysis from software engineering". Proceedings of the International Conference on Computer and Information Sciences. : pp. 1–6. 2014. [20] Smith, A.M., Nelson, M.J. and Mateas, M. "LUDOCORE: A logical game engine for modeling videogames". Proceedings of the IEEE Conference on Computational Intelligence and Games. : pp. 91–98. 2010. [21] Weintrop, D., Holbert, N., Wilensky, U. and Horn, M. "Redefining Constructionist Video Games: Marrying Constructionism and Video Game Design". Proceedings of the Constructionism 2012. : pp. 645–649. 2012. [22] Kazimoglu, C., Kiernan, M., Bacon, L. and Mackinnon, L. Understanding computational thinking before programming: Developed guidelines for the design of games to learn introductory programming through game-play. Developments in Current GameBased Learning Design and Development. P. Felicia, ed. IGI Global. [23] Weintrop, D. and Wilensky, U. "To block or not to block , that is the question : Students’ perceptions of blocks-based programming". Proceedings of the ACM SIGCHI Interaction Design and Children. Medford, MA: pp. 199–208. June 2015. [24] Fraser, N. "Ten Things We ’ ve Learned from Blockly". Proceedings of the IEEE Blocks and Beyond Workshop. : pp. 49–50. 2015. ABOUT THE AUTHORS Adj. Prof. Adilson Vahldick, MSc, CISUC and Department of Software Engineering, University of Santa Catarina State, Phone: +351 239 790000, Е-mail: [email protected]. Assoc. Prof. António José Mendes, PhD, CISUC – Department of Informatics Engineering, University of Coimbra, Phone: +351 239 790000, Е-mail: [email protected]. Assist. Prof. Maria José Marcelino, PhD, CISUC – Department of Informatics Engineering, University of Coimbra, Phone: +351 239 790000, Е-mail: [email protected].