DeepAI
Log In Sign Up

NoteG: A Computational Notebook to Facilitate Rapid Game Prototyping

Game development-based approaches are increasingly used to design curricula that can engage students, as these can help them apply and practice learnt computer science concepts. However, it can become complex to develop a minimum working game or a prototype with the help of high-end game engines. Game prototyping is one of the most essential parts of the game design and development cycle as it allows developers to continuously test and improve their ideas. In recent years, computational notebooks have gained widespread popularity among developers. They can help run individual code snippets, visualize the output, consolidate the source code, and share live code easily. However, its use has not been explored in the field of game development and prototyping. In this paper, we propose NoteG, a computational notebook towards rapid game prototyping. We evaluated the tool with 18 novice game developers through a questionnaire-based user survey. A majority of the volunteers (66 found it easy to use and were of the opinion that it saves time. A few of the participants successfully extended the existing framework to implement new game mechanics within their prototypes.

READ FULL TEXT VIEW PDF

page 7

page 10

page 11

page 12

04/12/2020

Are Game Engines Software Frameworks? A Three-perspective Study

Game engines help developers create video games and avoid duplication of...
05/11/2019

GE852: A Dataset of 852 Game Engines

Game engines provide a platform for developers to build games with an in...
04/06/2019

Mek: Mechanics Prototyping Tool for 2D Tile-Based Turn-Based Deterministic Games

There are few digital tools to help designers create game mechanics. A g...
05/10/2022

How Game Jams and Hackathons Accelerate Design Processes

This dissertation presents three years of research on how design process...
08/29/2019

Introducing: The Game Jam License

Since their inception at the Indie Game Jam in 2002, a significant part ...
10/04/2020

Generating Gameplay-Relevant Art Assets with Transfer Learning

In game development, designing compelling visual assets that convey game...
08/13/2019

Evaluation of a Recommender System for Assisting Novice Game Designers

Game development is a complex task involving multiple disciplines and te...

1 Introduction

Gamification is being increasingly used in various domains ranging from skill identification in recruitment to building engaging course curricula in fields such as computer science, mathematics and biology (Obaid et al., 2020; Kasahara et al., 2019; Schulz et al., 2020; Lo and Hew, 2020; Siswati et al., 2021). Students often show a keen interest in gamified approaches, and hence they are being explored to enhance traditional programming education (Aycock et al., 2015). There have also been explorations into encouraging children to develop games on their own (Richard and Kafai, 2015). Game development based approaches have been found to be effective in promoting problem-solving skills among children (Chu and Hung, 2015). With more and more students being exposed to game development or even taking it up based on their own interests (Rahimi and Kim, 2019), there is a need for the inclusion of proper game design practices in these initial stages and tools to simplify the process.

Challenges in building a game that can implement the desired functionality are often attributed to the tools used and workflow involved (Zhu and Wang, 2019). There have been efforts that address this issue by shifting the focus to mobile-based game development, which is considered to be less complex so that students with limited experience are also able to create playable games (Kurkovsky, 2009).

Murphy-Hill et al. (Murphy-Hill et al., 2014) conducted a survey of 364 developers on how game development differs from other software development. Their results show that several strands of software engineering research and active practices can have a significant impact on game development. Smaller demo games may be a good starting point for novices to get into game development.

Software prototyping is a practice that is actively used in the domain of software development to reduce the number of design iterations required (Devadiga, 2017). Prototypes in commercial settings are helpful in obtaining a better idea about the requirements of a client, getting customer feedback and mitigating the risks involved with product development.

Prototyping is an important step in the game development process that allows exploration and experimentation during the learning stages. Rapid prototyping is an approach to prototyping that emphasizes the rapid development of ideas into functional prototypes to demonstrate or check the feasibility of a concept. This is usually an iterative approach and is extensively used in software development and hardware design (Müller et al., 2021; Günther et al., 2021). In software development, a prototype is considered a simulation or a model that allows one to experience the system (Warfel, 2009). In terms of game development, prototypes can take several forms, such as storyboards and sketches (Manker, 2011). In this paper, we use the word prototypes to refer to small playable versions of a game that may be used to demonstrate a key game mechanic.

Rapid prototyping is often used in game design to test game concepts and accompany game pitches (Bomström et al., 2020). Game-based learning and the introduction of game design into course content is another venue where prototyping has been found to be a crucial step (Zhang and Chen, 2021; Pirker et al., 2016). Game prototyping thus being a much more hands-on process than brainstorming, helps to test and improve ideas continuously (Gray et al., 2010)

. Shareable prototypes could help demonstrate ideas and improve collaboration in team projects. Further game prototyping can also help students gain important job skills like project management and effort estimation

(Pirker et al., 2016) which we feel might make it a good fit for inclusion in introductory courses.

Development groups can end up wasting time having to deal with heterogeneity and balancing all aspects of a game for an idea that might not be feasible (Blow, 2004). This might occur as novice game developers skip out on the prototyping stages for simplicity (Schaeffer and Palmgren, 2017). Game engine code which deals with defining the physics of the world within a game is often specific to the engine chosen and can often be confusing requiring repetitive tweaking and sound algorithmic knowledge to get components to work as desired (Blow, 2004). Considering the overhead involved for novice game developers to get used to a specific game engine, there may be perks to building a system that is much easier to modify for the purpose of building rapid prototypes (Hmeljak and Zhang, 2020b). NoteG which we propose in this paper is a computational notebook that works towards this goal and aims to simplify the process of rapid game prototyping.

Computational notebooks have emerged as good learning resources for programming tasks with hands-on demonstration capabilities (Rule et al., 2018). Even outside of traditional software engineering backgrounds, users have found computational notebooks to be useful making it a rapidly-emerging landscape. Some examples are shareable visualizations and executable code snippets accompanied by documentation that find use across academia and industry (Lau et al., 2020). The ability of computational notebooks to enable authoring live code and integrate step-wise output in a single document are a few of the reasons why they have become popular among developers and data scientists(Granger and Pérez, 2021). They also help in understanding concepts and their applications through the immediate execution of code snippets (Walden et al., 2013). Thus computational notebook-like environments may be used to assist prototyping by providing a simplified environment for developers and enabling sharing of live code that can be used to tweak and test parameters among collaborators.

Even though there are several works in the literature that try to simplify gamification or teach game development, our work differs in the following ways:

  • Uses a computational notebook based approach which makes it easy to test, demonstrate and collaborate on a project.

  • Attempts to reduce the overhead involved in developing a game such as learning to use a Game Engine in situations where the focus is more on the code involved.

  • For students with a keen interest in game development, this may help incorporate a practice of rapid prototyping.

In this paper, we demonstrate how live coding and cell-based execution can simplify game prototyping, which in turn may help novice programmers learn game development or can be used to engage students in computing courses. This approach is illustrated through a computational notebook called NoteG geared towards prototyping simple 2D role-playing games (RPG). We also evaluate the approach with 18 volunteers with overall positive response and a net promoter score of 66.

2 Related Work

Game development is a domain that is continuously evolving and has become increasingly complex over the years (Marklund et al., 2019). With the increasing technical complexity involved, there is often a high technical risk associated with game design decisions (Blow, 2004). The increasing divide between ease of use and game development speed using modern-day game engines (Hmeljak and Zhang, 2020a) can make it difficult for a beginner to develop a game. This is where Model Driven Game Development (MDGD) approaches have been used by developers to reduce development time with reusable artifacts (Reyno and Carsí Cubel, 2009; Marchisio et al., 2020; Baldassarre et al., 2021). One cannot predict how long it can take to build a new component or if it will be implemented in the final game. Consideration must also be given to how game components may interact with the rest of the system despite the technical feats involved (Blow, 2004). This drives the need for inclusion of game prototyping in the development cycle, where essentially one builds tiny experimental games iteratively, to validate and showcase the game ideas (Musil et al., 2010). Over the years, game jams 111https://globalgamejam.org/what-game-jam have gained popularity by facilitating prototyping and in turn, increasing engagement and sparking creativity towards disruptive game mechanics. Apart from its use in the industry, rapid game prototyping has also found use in improving the quality of games and areas of education that can make use of the development of games to teach or practice relevant concepts (Cooper and Longstreet, 2012; Mashuri and others, 2021).

2.1 Prototyping in Game Development and Education

Similar to software development, the adoption of rapid prototyping is actively involved in enhancing the game development cycle. Borg et al. describe how good game development practices have drawn from software engineering research (Borg et al., 2019) and emphasize the need to explore its impact on game development depending on the constraints. Prototyping though accepted as a core practice has been reported to be adopted only by a small fraction of the teams surveyed due to time constraints and sometimes has led to use of rapid prototyping (Borg et al., 2019). In the field of education, it has been applied in many forms such as game development electives for university students (Kletenik and Sturm, 2018), complementing the existing academic curriculum and for creating content that can engage students (Subramanian et al., 2020).

Apart from the use of educational games, the development of games has been explored as a fun way to learn systems analysis in the course designed by Nikunj Dalal in his article (Dalal, 2012) where he notes the use of high-level software that is much simpler to use than conventional game engines.

Simplified game engines with abstracted code may also help students get started with game design (Hmeljak and Zhang, 2020a). These have made the domain ever more accessible to students and instructors alike enabling their integration into courses and this has been reported to have an overall positive impact (Iosup and Epema, 2014). The use of such approaches may enable students to explore various game mechanics and may help in providing a better understanding of core game design elements.

J. Blow explains that overall project size and high domain-specific requirements are two roadblocks that may cause complexity in game development (Blow, 2004). Instead of focusing on simplifying game development, we wish to bring focus on making game prototyping more accessible to novices and enable developers to inculcate the habit of software prototyping. Perker et al. in their paper (Pirker et al., 2016) express how game prototyping helps in teaching various important skills such as project management, effort estimation, networking and even communication skills required by the industry.

Game prototyping encourages creative exploration of the domain and allows one to select the best idea from a set of alternatives based on technical feasibility and available resources at the moment. Rapid game prototyping has been explored not only in connecting academia and industry but also in controller design to explore how it can affect the social experience of video games

(Chatham et al., 2013) with the help of Arduinos. Iris Soute et al. developed Rapido a prototyping platform for outdoor games (Soute et al., 2017). They also explain how their tool enabled designers to focus on the core concepts and build prototypes without worrying about lower-level issues.

2.2 Use of Computational Notebooks

The idea of computational notebooks is based on literate programming which emphasizes the understandability of the code (Knuth, 1984) and that program logic be written in human-readable forms such as code snippets and macros. With the introduction of the Jupyter Notebook (Kluyver et al., 2016), computational notebooks have become quite popular and widely used by developers. It is a readable, reproducible and executable notebook that can be used for publishing code and generating results and visualization.

There have been a number of different ways in which computational notebooks have been employed. O’Hara et al. proposed a computational notebook to teach AI and introduced a new way of teaching and learning (O’Hara et al., 2015). Corno et al. (Corno et al., 2019) introduced a notebook for IoT development by executing notebook on top of the Docker Engine. Many other computational notebooks like GrapePress for Graph Transformations(Weber, 2021) and visJS2jupyter for visualizing mechanisms of biological processes (Rosenthal et al., 2018) have been proposed by researchers to help developers by providing interactive and user-friendly environments.

2.3 Prototyping

There have also been explorations into automation of game prototyping in 2D platform games through model-driven engineering (Reyno and Carsí Cubel, 2009). Reducing the overhead involved in developing a game using a user-friendly framework in this stage may help towards promoting the adoption of game prototyping among beginners. A more code-centred approach may also make it easier to integrate into learning environments for novice game developers who are more accustomed to programming. Rapid prototyping can also help students in making dynamic changes to a game by allowing for creative risks rather than technical, through mixing and matching components (Pirker et al., 2016). The use of such game prototypes could further promote analytical thinking and help in teaching design patterns for object-oriented programming and similar topics (Rule et al., 2018).

Rapid prototyping has also been proposed for applications such as web / mobile app development (Steinglass et al., 2017) to provide a learning environment for students to learn software engineering principles. Challenging tasks such as terrain generation which requires a large number of iterations have explored rapid prototyping and ways to support the same (Wang and Kurabayashi, 2020) but this involves sketches and landscapes. There have also been tools that directly aim to simplify the process of creating game mechanics, Volkovas et al. have proposed the use of a language for prototyping and compare it against prevailing techniques for 2D games (Volkovas et al., 2019).

We see that computational notebooks possess a lot of features that can help in creating rapid prototypes and that it has previously been successfully applied to create user-friendly and shareable code. However, to the best of our knowledge, despite its wide application in a number of domains the use of computational notebooks for enhancing and simplifying game prototyping for novice game developers has not been explored in the current literature.

3 Design and Development of NoteG

Figure 1: Workflow of building NoteG for Rapid Game Prototyping.

In this section, we describe the proposed approach, design decisions and development process of NoteG as shown in Fig. 1. The primary objectives of NoteG are:

  • Obtaining a simplified command-set, useful in developing multiple games without a steep learning curve.

  • Allow easy expansion or modification of the existing command-set for specific use cases.

  • Use a class-based programming paradigm with support for block-based systems (Kölling et al., 2015) to allow inheritance for future game objects and also to support hot-swapping at run-time.

  • Incorporate error management into the state manager so that any object that causes errors is removed from the test environment providing an error traceback to prevent crashes.

  • To support prototype development by enabling proper documentation, code folding and shareability.

Keeping in mind the aforementioned objectives and based on the feedback received during the process, we built NoteG. It is a computational notebook that serves as a basic foundation and can be invoked to begin the prototyping process. The following sections go into more detail about the key features of the current implementation and how it can be extended based on the user’s requirements.

3.1 Background Framework

NoteG has been built as a Jupyter Notebook222https://jupyter.org/. This is because its cell-based implementation allows the developer to break down the code into more readable blocks and hence makes it easier to work with. Jupyter Notebook is a common and popular tool that users may have already been exposed to. Another advantage to using it is the number of extensions it supports making it easier to add functionality such as block-based programming for beginners which we go over in the next section. Even though Python is not the fastest programming language, its simplified syntax helps in making it more accessible than C# and C++ which are used by popular game engines such as Unity 333https://unity.com/ and Unreal Engine444https://www.unrealengine.com respectively. To inherently support cross-platform development, NoteG uses PyGame555https://www.pygame.org/, which is a collection of modules designed to write video games. The top-level objects generated at run-time can be invoked later by a user to implement custom scenarios.

3.2 Structure and Functionality

Figure 2: Sample test scenes implemented in NoteG (a) RPG game setup (b) Dungeon with multiple rooms (c) Open world with enemies.
Figure 3: Loading assets from code blocks (left side) and getting started with a scene to work on (right side).
Functions Functionality
start_game(w,h,c) Starts a PyGame instance (only one at a given time) based on the given width, height and window colour. It also implements threading to add live support. This method handles the creation of a thread and starts the execution within it so that further execution is not blocked and other cells can be executed.
create_map(s) Takes path to an image for tiling the entire map. The codebase also implements another variant of this function to facilitate the creation of custom maps, this function takes a 2D array as a tilemap and sprites for the floor and walls as parameters as shown in Fig. 2(b).
create_player(name,sprite,x,y) Creates a player object with keyboard controls baked in. The Character class which acts as a parent to this object also adds support for collision detection and for the addition of public variables like position and health that can be modified on run-time.
add_trinket(trinket) Takes a Trinket() class object which could be a shape, sprite or an image and adds it to the scene with background checks to handle any errors that might occur later on as it is modified.
spawn_enemy(sprite,x,y) Adds an enemy based on logic implemented in Enemy() class. The update function can be redefined and parameters tweaked to test out various configurations, for example, one could run the A* algorithm on the tilemap for a better follow player logic 666http://theory.stanford.edu/~amitp/GameProgramming/AStarComparison.html. By default, the enemy follows and fires projectiles at the player.
callback_prob(function,p)

Defines a random callback function which is called with a probability of p with every update cycle. It can also be further extended to trigger events in the game.

game.refresh_scene() Enables the user to force the screen to reset to the base state with only the player and tile-map in case an error occurs which is not handled properly.
Table 1: API and functions implemented in NoteG that could be used to build a rapid game prototype.

In order to demonstrate how Jupyter Notebooks can be used to enhance game prototyping, we have implemented custom classes and functions in NoteG. Specific functionalities were selected so as to enable building a bare-bones RPG type game that can be used for testing. In order to select the functions that make up the current command-set we first built basic prototypes for a number of popular 2D games like The classic snake game and a few other pixel art games like Terraria. A few examples of simple scenes generated while using the notebook are shown in Fig. 2. Table 1 presents the API for the game engine wrapper which was used to generate these samples and its functionality.

Further direct object manipulation which is described in detail in Section 3.3 inherently allows for hot-swapping public variables and functions of all in-game objects. In case modifications to an object causes errors, the object is removed from the scene with a traceback error message to prevent crashing the entire game while prototyping. This task is performed by the error handler. A scene list keeps track of all objects in the scene and can be used in cases when reference to the object is not maintained. A number of utility functions can also be found in the codebase in addition to the ones described in Table 1. These help improve the user experience and give more control over the spawned components in the game. Using the hide() function allows the developer to hide a cell of the notebook from view to effectively fold the code before sharing. Beginners can also use block-based programming extensions like jigsaw777https://jupyter4edu.github.io/jupyter-edu-book/jupyter.html which may be invoked to get familiar with Python. Other than these there are also a few sprite-sheet management functions to facilitate cleaning and extracting images from image files. A few custom functions were also added for illustration purposes and have been described in documentation cells of the notebook.

3.3 Overview of Functions in NoteG

Functions in NoteG can be used for a wide genre of 2D games Fig. 2 shows a few examples of these. The code block for starting a scene with loaded assets888All assets used for illustration are obtained from https://opengameart.org/ can be seen in Fig. 3. We see that this contains the initial setup parameters required here the display window size is specified. Fig. 2(a) shows an RPG scenario with a plain texture repeated as the ground layer using the create_map() function. The other two screenshots depict a dungeon (Fig. 2(b)) as well as an open-world setup (Fig. 2(c)) respectively both of which have bounding walls and styled tiles defined using a 2D array that is passed as an optional argument while creating the map.

Once the game is started, the other required components can be added dynamically. Fig. 3 shows how the create_player() function can create a named player object for future reference. Passing different sprite sheets can change how the character looks, helper functions auto-configure the animation system and movement system for the player character.

Similarly, enemy characters can be added as shown in the last screenshot of Fig. 2(c), using the spawn_enemy() function which is a modification of the player function. By default, the enemy is configured to use the A* algorithm and hunt down the player but these parameters can be edited as per the user’s requirement. The object-oriented structure makes it easy to swap out any of the default logic with custom functions as shown in Fig. 4 and Fig. 5.

Fig. 4 illustrates how the properties of projectiles can be altered while the game is still running. Error handlers ensure that any changes that may cause the game to crash are dealt with by terminating only the problematic objects. Fig. 5 shows how game mechanics that didn’t exist in the base implementation of NoteG can be easily added by a user. Even users without much programming experience can do these using helper extensions that can be enabled in the Notebook before invoking the same. Existing classes and those provided by PyGame can also be modified as shown in Fig. 6 which implements collectables.

3.4 Live Execution and Perks

The use of computational notebooks for game prototyping allows for quick testing and cell-based execution. These cells allow one to write new code that can be executed independently. In the context of game prototyping, this allows us to add to the functionality of components that are already rendered at any point in the future. Further, notebooks also make it easy to document the code and make it readable to other developers.

Figure 4: Hot swapping properties of the bullet object to change from state 1 to 3 using NoteG while the game is running to demonstrate the use of live code in-game prototypes.
Figure 5: Tweaking behaviour by updating member functions to form a projectile shield as implemented by a volunteer in the user survey.

Even though features like hot-swapping which allows us to replace code without recompiling the full project already exist in popular game engines such as Unity. However many of the novice game developers who we interacted with were not aware of them which became apparent from our user survey (Section 4). An example of this is shown in Fig. 4. These also require the user to follow a particular paradigm so that their code can support the feature.

Getting used to such workflows which are directly available due to the class-based background implementations in NoteG may help make novice game developers aware and adopt these design practices when they switch to the development stage. Fig. 5 depicts one of the run-time modifications on the projectile class created by a volunteer in the user survey.

3.5 Modularity and Shareability

Figure 6: Adding a collectable type object by extending the Trinket class to demonstrate modularity and scope of expansion.

The current design of NoteG inherently introduces classes, objects and functions and how they can be used to build reusable components. Since NoteG is written as a wrapper on PyGame, developers can easily make and append modules to NoteG for implementing features that they commonly use. Some examples are splash screens and collectable objects which can be created as per the developer’s requirement. An example of how the Trinket class in NoteG can be extended to work as an in-game collectable at run-time with minimal code is shown in Fig. 6. New components can also be added programmatically while testing, like the ”enemy skeletons” as shown in Fig. 2(c).

Another feature that has led to the growth in popularity of notebooks in a wide variety of domains is the ease of shareability of live code (Wang et al., 2020). Collaboration is a key part of the game development cycle and can significantly impact the direction of the game (Whitson, 2018). Notebooks make it much easier than the traditional practices to share the prototypes with others who might not be very technically inclined but would like to retain the ability to test various situations in the game.

Game development is often a collaborative project. For this reason, game prototypes often have to be shared with other co-developers and reviewers. While sharing, packing game features as live code within a notebook can enable easy tweaking without any additional effort from the developer. This is essential in ensuring the simplicity of the review process.

4 Evaluation

In line with the literature currently available, NoteG has also been evaluated through a questionnaire-based user survey (Lu et al., 2014; Núñez-Valdez et al., 2017). The survey was targeted at novice game developers most of whom were at the high school and undergraduate levels. It should be noted that the participants were novice Python programmers with less than six months of experience in game development. It consisted of 11 questions 4 of which were aimed at gathering demographic information of the participants and the rest of the questions were 5 point Likert scale-based and aimed at understanding the perception of NoteG among the volunteers. The questionnaire asked volunteers about their awareness of hot-swapping like features in other game engines and their experience with game development and prototyping. We also enquired if they felt that using NoteG made game prototyping faster and collected feedback on implemented features. The full questionnaire and survey data can be found in the footnote999Survey Data: https://dataosf.page.link/NoteG.

The majority of the participants (55%) belonged to the 20-29 age group while the rest are 15-19 years old. Out of the 18 volunteers, 66.7% are male and 33.3% are female. 50% of the participants had prior experience with building games, whereas a majority of the rest are in the process of learning game development. Out of these, only 33.4% had exposure to game prototyping. All the volunteers were given detailed documentation of the command-set and explained about the working of NoteG, a tutorial on setting up Jupyter Notebook and getting started with the tool is also provided. Participants were asked to try out the tool on their own by building simple prototypes and sharing them with us. The 5-point Likert scale data from the user survey was recorded as shown in Fig. 7. Correlation analysis was conducted and since the Likert scale data is ordinal, we used Spearman correlation for finding the required correlation coefficients.

Figure 7: Results of user survey: the 5-point Likert Scale scores were converted into 3 brackets (High, Medium and Low).

Of the people who responded to the survey around 60% had prior exposure to game development while only 55% had a basic or decent understanding of game prototyping. From the survey responses, we found a significant moderate positive correlation (level of significance = 0.01) between a person’s level of exposure to game development and his/her level of understanding of game prototyping. Also, such a person is more aware of hot swapping and this correlation was positive and significant at a 0.05 level of significance. 66% of the respondents considered game prototyping using NoteG to be easy or very easy and 50% of those who are learning game development consider using NoteG for prototyping to be easy. Most of the respondents of the survey were of the opinion that using NoteG makes game prototyping less time-consuming.

55% of the respondents expressed that they are likely to use such computational notebooks in the future. Further, a majority of the users who have developed games before stated that they would use computational notebooks for game prototyping in their future projects. When it comes to recommending NoteG the response was positive with a net promoter score of 66 (assuming those responding as “moderately likely” and “highly likely” as promoters and the rest as detractors). It was observed that 50% or more respondents who are learning game development are highly likely to recommend NoteG to their peers.

5 Discussion and Future Work

The computational notebook NoteG is developed as an example of how such notebooks can be used for game prototyping which has not been explored in the current literature Another way to improve the current implementation would be by supporting a wider variety of games and by adding embeddable workflows that can help users to streamline the prototyping process through direct integrations with existing game engines.

Considering the popularity of computational notebooks among data scientists and machine learning practitioners, we plan on extending the scope of our work taking inspiration from toolkits like

Gym101010https://gym.openai.com/docs/ which helps to develop and compare ML algorithms. The ability of agents to interact with environments in Gym could be exploited to enable easy training and testing of Non-Player Character AI’s within the prototyping tool itself. This would take the tool closer to our ideal of enabling upcoming developers to dynamically introduce and test game object interactions at run-time with ease.

Python is well suited for making notebooks beginner-friendly however it is not the fastest programming language. This can become a limitation for complicated games that might require more resources and faster compilation. There is also scope for modifying the user interface of NoteG and the implemented command set. The flexibility offered in this regard could be used to tune the tool for specific use cases.

The evaluation could be further extended by including a wider demographic with varied levels of experience and performing a controlled study on the benefits of using this approach over other options for beginners. The reasons for which Notebooks became popular in the domain of data science could still hold true for game development and help make game development more accessible to practitioners in other domains. Future research would be required to improve upon the ways in which computational notebooks can aid game prototyping in more complex development workflows.

6 Conclusion

In this paper, we use computational notebooks as a tool to facilitate rapid game prototyping and propose NoteG for prototyping 2D games. It is an interactive run-time based environment where developers can edit and run code snippets to immediately observe the changes towards testing and tweaking game parameters. We explore how NoteG can be used to simplify the process of prototyping and simplify sharing live game code without a steep learning curve. This could be particularly useful in situations where game prototyping is used to teach computer science concepts and also to novice game developers who wish to learn to code. NoteG has cross-platform compatibility and supports hot swapping for variables, assets and in-game behaviours of game objects created through its API.

We plan to extend NoteG to support play-testing and prototyping of a larger variety of games in future iterations. This approach towards game prototyping aims to make it appealing to novice game developers, while also giving the user creative freedom and an ability to explore without worrying about the underlying technicalities and rather encouraging focus on the ideas and feasibility. The use of computational notebooks for rapid prototyping thus has its own merits and is an area that should be explored and tested further in different development environments.

Acknowledgment(s)

The authors would like to thank the student volunteers and those who shared the prototypes they developed using NoteG for their time and feedback, which was used to improve the base implementation.

Disclosure statement

No potential conflict of interest was reported by the authors.

Notes on contributor(s)

Noble Saji Mathews is a B.Tech student in the Department of Chemical Engineering at Indian Institute of Technology Tirupati. He has a keen interest in software engineering research and development dealing with Education Technology and Human Computer Interaction. His projects mostly deal with tools and visualizations that aid novice developers or seek to address key issues.

Sridhar Chimalakonda is an Assistant Professor in the Department of Computer Science & Engineering at IIT Tirupati, India. He received his PhD and MS by Research in Computer Science & Engineering from International Institute of Information Technology - Hyderabad, India. He leads the Research in Intelligent Software and Human Analytics (RISHA) Lab which primarily works in the area of Software Engineering, and specifically towards empirically and qualitatively assessing quality, reuse, architecture and evolution of a broad range of software systems (such as mobile, web, games and so on). He is passionate about the massive potential of technology for improving the quality of education and automation in educational technologies.

References

  • J. Aycock, E. Pitout, and S. Storteboom (2015) A game engine in pure python for cs1: design, experience, and limits. In Proceedings of the 2015 ACM Conference on Innovation and Technology in Computer Science Education, ITiCSE ’15, New York, NY, USA, pp. 93–98. External Links: ISBN 9781450334402, Link, Document Cited by: §1.
  • M. T. Baldassarre, D. Caivano, S. Romano, F. Cagnetta, V. Fernandez-Cervantes, and E. Stroulia (2021) PhyDSLK: a model-driven framework for generating exergames. Multimedia Tools and Applications, pp. 1–25. Cited by: §2.
  • J. Blow (2004) Game development: harder than you think: ten or twenty years ago it was all fun and games. now it’s blood, sweat, and code.. Queue 1 (10), pp. 28–37. External Links: ISSN 1542-7730, Link, Document Cited by: §1, §2.1, §2.
  • H. Bomström, M. Kelanti, J. Lappalainen, E. Annanperä, and K. Liukkunen (2020) Synchronizing game and ai design in pcg-based game prototypes. In International Conference on the Foundations of Digital Games, pp. 1–8. Cited by: §1.
  • M. Borg, V. Garousi, A. Mahmoud, T. Olsson, and O. Stålberg (2019) Video game development in a rush: a survey of the global game jam participants. IEEE Transactions on Games 12 (3), pp. 246–259. Cited by: §2.1.
  • A. Chatham, W. Walmink, and F. Mueller (2013) UnoJoy! a library for rapid video game prototyping using arduino. In CHI ’13 Extended Abstracts on Human Factors in Computing Systems, CHI EA ’13, New York, NY, USA, pp. 2787–2788. External Links: ISBN 9781450319522, Link, Document Cited by: §2.1.
  • H. Chu and C. Hung (2015) Effects of the digital game-development approach on elementary school students’ learning motivation, problem solving, and learning achievement. International Journal of Distance Education Technologies (IJDET) 13 (1), pp. 87–102. Cited by: §1.
  • K. M. Cooper and C. S. Longstreet (2012) Towards model-driven game engineering for serious educational games: tailored use cases for game requirements. In 2012 17th International Conference on Computer Games (CGAMES), pp. 208–212. Cited by: §2.
  • F. Corno, L. De Russis, and J. P. Sáenz (2019) Towards computational notebooks for iot development. In Extended Abstracts of the 2019 CHI Conference on Human Factors in Computing Systems, pp. LBW0154. Cited by: §2.2.
  • N. Dalal (2012) Teaching tip: using rapid game prototyping for exploring requirements discovery and modeling. Journal of Information Systems Education 23 (4), pp. 129. Cited by: §2.1.
  • N. M. Devadiga (2017) Tailoring architecture centric design method with rapid prototyping. In 2017 2nd International Conference on Communication and Electronics Systems (ICCES), Vol. , pp. 924–930. External Links: Document Cited by: §1.
  • B. Granger and F. Pérez (2021) Jupyter: thinking and storytelling with code and data. Authorea Preprints. Cited by: §1.
  • D. Gray, S. Brown, and J. Macanufo (2010) Gamestorming: a playbook for innovators, rulebreakers, and changemakers. ” O’Reilly Media, Inc.”. Cited by: §1.
  • S. Günther, F. Müller, F. Hübner, M. Mühlhäuser, and A. Matviienko (2021) ActuBoard: an open rapid prototyping platform to integrate hardware actuators in remote applications. In Companion of the 2021 ACM SIGCHI Symposium on Engineering Interactive Computing Systems, EICS ’21, New York, NY, USA, pp. 70–76. External Links: ISBN 9781450384490, Link, Document Cited by: §1.
  • D. (. Hmeljak and H. Zhang (2020a) Developing a computer graphics course with a game development engine. In Proceedings of the 2020 ACM Conference on Innovation and Technology in Computer Science Education, ITiCSE ’20, New York, NY, USA, pp. 75–81. External Links: ISBN 9781450368742, Link, Document Cited by: §2.1, §2.
  • D. Hmeljak and H. Zhang (2020b) Developing a computer graphics course with a game development engine. In Proceedings of the 2020 ACM Conference on Innovation and Technology in Computer Science Education, pp. 75–81. Cited by: §1.
  • A. Iosup and D. Epema (2014) An experience report on using gamification in technical higher education. New York, NY, USA. External Links: ISBN 9781450326056, Link, Document Cited by: §2.1.
  • R. Kasahara, K. Sakamoto, H. Washizaki, and Y. Fukazawa (2019) Applying gamification to motivate students to write high-quality code in programming assignments. In Proceedings of the 2019 ACM Conference on Innovation and Technology in Computer Science Education, ITiCSE ’19, New York, NY, USA, pp. 92–98. External Links: ISBN 9781450368957, Link, Document Cited by: §1.
  • D. Kletenik and D. Sturm (2018) Game development with a serious focus. In Proceedings of the 49th ACM Technical Symposium on Computer Science Education, SIGCSE ’18, New York, NY, USA, pp. 652–657. External Links: ISBN 9781450351034, Link, Document Cited by: §2.1.
  • T. Kluyver, B. Ragan-Kelley, F. Pérez, B. E. Granger, M. Bussonnier, J. Frederic, K. Kelley, J. B. Hamrick, J. Grout, S. Corlay, et al. (2016) Jupyter notebooks-a publishing format for reproducible computational workflows.. In ELPUB, pp. 87–90. Cited by: §2.2.
  • D. E. Knuth (1984) Literate programming. The Computer Journal 27 (2), pp. 97–111. Cited by: §2.2.
  • M. Kölling, N. C. Brown, and A. Altadmri (2015) Frame-based editing: easing the transition from blocks to text-based programming. In Proceedings of the Workshop in Primary and Secondary Computing Education, pp. 29–38. Cited by: 3rd item.
  • S. Kurkovsky (2009) Engaging students through mobile game development. SIGCSE Bull. 41 (1), pp. 44–48. External Links: ISSN 0097-8418, Link, Document Cited by: §1.
  • S. Lau, I. Drosos, J. M. Markel, and P. J. Guo (2020) The design space of computational notebooks: an analysis of 60 systems in academia and industry. In 2020 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC), pp. 1–11. Cited by: §1.
  • C. K. Lo and K. F. Hew (2020) A comparison of flipped learning with gamification, traditional learning, and online independent study: the effects on students’ mathematics achievement and cognitive engagement. Interactive Learning Environments 28 (4), pp. 464–481. Cited by: §1.
  • W. Lu, C. Sun, T. Bleeker, Y. You, S. Kitazawa, and E. Y. Do (2014) Sensorendipity: a real-time web-enabled smartphone sensor platform for idea generation and prototyping. In Proceedings of the Second International Symposium of Chinese CHI, Chinese CHI ’14, New York, NY, USA, pp. 11–18. External Links: ISBN 9781450328760, Link, Document Cited by: §4.
  • J. Manker (2011) Game prototyping–the negotiation of an idea. In DiGRA Conference: Think, Design, Play, pp. 14–17. Cited by: §1.
  • M. Marchisio, T. Margaria, and M. Sacchet (2020) Automatic formative assessment in computer science: guidance to model-driven design. In 2020 IEEE 44th Annual Computers, Software, and Applications Conference (COMPSAC), pp. 201–206. Cited by: §2.
  • B. B. Marklund, H. Engström, M. Hellkvist, and P. Backlund (2019) What empirically based research tells us about game development. The Computer Games Journal 8 (3-4), pp. 179–198. Cited by: §2.
  • C. Mashuri et al. (2021) Developing indonesian learning game applications for elementary school students using the prototyping method. Turkish Journal of Computer and Mathematics Education (TURCOMAT) 12 (4), pp. 918–928. Cited by: §2.
  • L. Müller, K. Pfeuffer, J. Gugenheimer, B. Pfleging, S. Prange, and F. Alt (2021) SpatialProto: exploring real-world motion captures for rapid prototyping of interactive mixed reality. In Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems, pp. 1–13. Cited by: §1.
  • E. Murphy-Hill, T. Zimmermann, and N. Nagappan (2014) Cowboys, ankle sprains, and keepers of quality: how is video game development different from software development?. In Proceedings of the 36th International Conference on Software Engineering, pp. 1–11. Cited by: §1.
  • J. Musil, A. Schweda, D. Winkler, and S. Biffl (2010) Synthesized essence: what game jams teach about prototyping of new software products. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 2, ICSE ’10, New York, NY, USA, pp. 183–186. External Links: ISBN 9781605587196, Link, Document Cited by: §2.
  • E. R. Núñez-Valdez, V. García-Díaz, J. M. C. Lovelle, Y. S. Achaerandio, and R. González-Crespo (2017) A model-driven approach to generate and deploy videogames on multiple platforms. Journal of Ambient Intelligence and Humanized Computing 8 (3), pp. 435–447. Cited by: §4.
  • K. O’Hara, D. Blank, and J. Marshall (2015) Computational notebooks for ai education. In The Twenty-Eighth International Flairs Conference, Cited by: §2.2.
  • I. Obaid, M. S. Farooq, and A. Abid (2020) Gamification for recruitment and job training: model, taxonomy, and challenges. IEEE Access 8, pp. 65164–65178. Cited by: §1.
  • J. Pirker, A. Kultima, and C. Gütl (2016) The value of game prototyping projects for students and industry. In Proceedings of the International Conference on Game Jams, Hackathons, and Game Creation Events, pp. 54–57. Cited by: §1, §2.1, §2.3.
  • F. B. Rahimi and B. Kim (2019) The role of interest-driven participatory game design: considering design literacy within a technology classroom. International Journal of Technology and Design Education 29 (2), pp. 387–404. Cited by: §1.
  • E. M. Reyno and J. Á. Carsí Cubel (2009) Automatic prototyping in model-driven game development. 7 (2). External Links: Link, Document Cited by: §2.3, §2.
  • G. T. Richard and Y. B. Kafai (2015) Making physical and digital games with e-textiles: a workshop for youth making responsive wearable games and controllers. In Proceedings of the 14th International Conference on Interaction Design and Children, IDC ’15, New York, NY, USA, pp. 399–402. External Links: ISBN 9781450335904, Link, Document Cited by: §1.
  • S. B. Rosenthal, J. Len, M. Webster, A. Gary, A. Birmingham, and K. M. Fisch (2018) Interactive network visualization in jupyter notebooks: visjs2jupyter. Bioinformatics 34 (1), pp. 126–128. Cited by: §2.2.
  • A. Rule, A. Tabard, and J. D. Hollan (2018) Exploration and explanation in computational notebooks. In Proceedings of the 2018 CHI Conference on Human Factors in Computing Systems, pp. 32. Cited by: §1, §2.3.
  • J. A. Schaeffer and M. Palmgren (2017) Visionary expectations and novice designers–prototyping in design education.. Design and Technology Education 22 (1), pp. n1. Cited by: §1.
  • R. Schulz, B. Smaradottir, A. Prinz, and T. Hara (2020) User-centered design of a scenario-based serious game: game-based teaching of future healthcare. IEEE Transactions on Games 12 (4), pp. 376–385. Cited by: §1.
  • B. H. Siswati, J. Prihatin, A. Damayanti, L. Nafisah, et al. (2021) Developing gamification based biology learning materials for senior high school students in industrial agricultural area in jember, indonesia. In Journal of Physics: Conference Series, Vol. 1839, pp. 012021. Cited by: §1.
  • I. Soute, T. Vacaretu, J. D. Wit, and P. Markopoulos (2017) Design and evaluation of rapido, a platform for rapid prototyping of interactive outdoor games. ACM Trans. Comput.-Hum. Interact. 24 (4). External Links: ISSN 1073-0516, Link, Document Cited by: §2.1.
  • A. Steinglass, B. Franke, and S. Filman (2017) App lab: a powerful javascript ide for rapid prototyping of small data-backed web applications. In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education, pp. 641–642. Cited by: §2.3.
  • K. Subramanian, E. Saule, and J. Payton (2020) Bringing real-world data, interactive games and visualizations into early cs courses. In Proceedings of the 51st ACM Technical Symposium on Computer Science Education, SIGCSE ’20, New York, NY, USA, pp. 1391. External Links: ISBN 9781450367936, Link, Document Cited by: §2.1.
  • R. Volkovas, M. Fairbank, J. R. Woodward, and S. Lucas (2019) Mek: mechanics prototyping tool for 2d tile-based turn-based deterministic games. In 2019 IEEE Conference on Games (CoG), pp. 1–8. Cited by: §2.3.
  • J. Walden, M. Doyle, R. Garns, and Z. Hart (2013) An informatics perspective on computational thinking. In Proceedings of the 18th ACM conference on Innovation and technology in computer science education, pp. 4–9. Cited by: §1.
  • J. Wang, L. Li, and A. Zeller (2020) Better code, better sharing: on the need of analyzing jupyter notebooks. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering: New Ideas and Emerging Results, pp. 53–56. Cited by: §3.5.
  • T. Wang and S. Kurabayashi (2020) Sketch2map: a game map design support system allowing quick hand sketch prototyping. In 2020 IEEE Conference on Games (CoG), pp. 596–599. Cited by: §2.3.
  • T. Z. Warfel (2009) Prototyping: a practitioner’s guide. Rosenfeld media. Cited by: §1.
  • J. H. Weber (2021) GrapePress-a computational notebook for graph transformations. In International Conference on Graph Transformation, pp. 294–302. Cited by: §2.2.
  • J. R. Whitson (2018) Voodoo software and boundary objects in game development: how developers collaborate and conflict with game engines and art tools. new media & society 20 (7), pp. 2315–2332. Cited by: §3.5.
  • Y. Zhang and J. Chen (2021) Using design thinking in educational game design: a case study of pre-service teacher experience. In International Conference on Blended Learning, pp. 253–263. Cited by: §1.
  • M. Zhu and A. I. Wang (2019) Model-driven game development: a literature review. ACM Comput. Surv. 52 (6). External Links: ISSN 0360-0300, Link, Document Cited by: §1.