This paper describes and analyses the phases of development of a Student Simulator game application. The study analyses various game types employed in computer science education. Based on a SWOT analysis, the authors justify using simulators and combined gaming applications. Several basic requirements for a Student Simulator game are identified, such as a 3D interface, multiple game locations, manipulation of object models (computers, operating systems, programming languages), and the registration and rating of players. A matrix of game elements that meets the requirements for the Student Simulator has been created. Following a comparative analysis, Godot, Blender, and Firebase were selected as development tools. The authors describe their experience in developing the Student Simulator game. The design process of this game emphasises the incorporation of game elements with both testing and code-writing tasks involving the manipulation of computer hardware. The paper includes some fragments of the game workspace and application code. Further improvements to the game are indicated.
In today’s world, where new technologies are created, and old ones are improved, the demand for IT
specialists is constantly growing. That is why educational games are used increasingly in the educational
process. Teachers of various disciplines use games in both desktop and computer formats. The design
and development of such games are becoming increasingly relevant due to the possibility of engaging
students in active learning. Educational games provide an interactive and engaging experience that
can capture learners’ attention and keep them interested. The integration of game elements such as
challenges, rewards and feedback increases learners’ motivation to learn and retain learning content
compared to traditional methods. Games encourage active participation and develop critical thinking,
problem-solving and decision-making skills. Unlike passive learning, educational games engage learners
in activities that require application and analysis, which is crucial for deep learning. In addition, modern
learning games can be designed to adapt to learners’ pace, style and needs. This personalised approach
helps to accommodate diferent learning abilities, ensuring that every learner can develop efectively.
Learning games can help to develop 21st century skills such as collaboration, communication, creativity
and technological literacy, which are essential in today’s digital world. By simulating real-life scenarios,
games prepare learners for future challenges innovatively and practically. The use of educational
games contributes to the development of digital literacy and technological competencies, which are an
integral part of modern education and are essential for navigating the digital age. With the rapid growth
of the gaming industry, users are ofered more and more game applications for learning theoretical
knowledge and skills, especially in computer science. Today, there are many types of games, such
as simulation games, puzzle-based learning games, language learning games, strategy and planning
games, and role-playing educational games. Videnovik et al. [
Games
Strengths Weaknesses Opportunities Threats 4. Encourages long- 4. Less focus on actual 4. Incorporation of 4. Dificulty in keepterm planning skills coding skills real-world case stud- ing content current ies 5. Helps understand 5. Complex learning 5. Development of 5. Potential lack of trade-ofs in system path team-based scenarios technical depth design 1. Excellent for teach- 1. Limited focus on 1. Integration with 1. Risk of stereotyping ing software develop- technical skills real code review pro- tech roles ment roles cesses 2. Develops collabora- 2. High production 2. Teaching soft skills 2. Dificulty in maintion and communica- costs for tech roles taining relevance tion skills 3. Good for learning 3. Dificult to create debugging scenarios realistic scenarios
As seen from table 1, each type of educational game has advantages and disadvantages. They should
be applied according to the field of computer science. The authors of the studies believe that simulations
are the most suitable genre for teaching computer science. The main factors supporting this thesis are
engagement [
Firstly, the use of games in the educational process can motivate students to engage with the subject matter and facilitate a deeper understanding of the discipline. Additionally, the Student Simulator enables users to immerse themselves in the experience of student life, which can serve as an efective tool for showcasing educational institutions to prospective applicants and illustrating the educational process. This platform allows educators to conduct interactive lessons, where students can not only learn theoretical concepts but also apply them through specially designed mini-games.
The teacher’s ability to add and modify tasks ensures a wide range of engaging and unique challenges. The game’s immediate feedback mechanism will alert students to incorrect actions and, when necessary, provide guidance on how to correct their mistakes. The inherent feature of progressively increasing dificulty in most games will promote incremental learning, starting with basic tasks and advancing to more complex projects. This approach to education guarantees a smooth and thorough transition from student to competent professional.
Although there are many of-the-shelf solutions on the Internet, the problem of creating new gaming applications remains relevant. Our article aims to create a simulation game to study computer science disciplines. To do this, we need to solve the following tasks:
Before developing the Student Simulator game, we analysed similar projects that have gained an audience among simulators and gaming platforms for learning. The analogues include MHRD, TIS-100, Shenzhen I/O, Minecraft Education Edition, CyberStart, and Classcraft, which ofer game simulations of various areas of computer science.
MHRD is a hardware design game where players go from building basic logic gates to creating a
fully functional processor using the Hardware Description Language (HDL) [
Shenzhen I/O is a similar simulator to TIS-100. However, it focuses on hardware engineering and embedded systems programming. Players design circuits and write code for various electronic devices.
Classcraft is not an accurate simulation game. However, it is a modern platform that turns learning into
a role-playing game. Students complete tasks, improve their characters, earn points for achievements,
and receive virtual penalties for mistakes [
Minecraft Educational Edition is an educational version of Minecraft’s popular video game, designed
specifically for educational purposes. Using this tool, it is possible to create educational environments
and tasks for students of diferent ages and levels of learning. Educational Minecraft aims to promote
collaboration and cooperation between players by creating shared virtual environments where they can
work together on projects and tasks. The game provides many opportunities for creative expression
and imagination. Users can create their worlds, objects and structures using a variety of blocks and
tools. Within the game, you can create educational tasks and scenarios that help players learn various
subjects, such as mathematics, computer science, history and others [
Given that combining diferent types of games when teaching computer science is advisable, quiz
elements can be incorporated into the designed simulation game. Currently, one of the most famous
platforms for creating quizzes is Kahoot! [
When designing a training simulator, we understand that teams of many specialists, such as storytellers, modellers, designers, programmers, QA engineers, and others, are currently working on creating such games. Moreover, they have been working for a long time. Nevertheless, we organised a project to design and develop the Student Simulator game. The work was carried out within the framework of the joint research laboratory ‘Digital Educational Innovations’, which was created in cooperation with Ternopil Volodymyr Hnatiuk National Pedagogical University and Institute for Digitalisation of Education of the National Academy of Educational Sciences of Ukraine.
The project methodology was used to implement the tasks. The article’s authors and students
studying under the Game Project Engineering programme at Ternopil Volodymyr Hnatiuk National
Pedagogical University led and executed the project. Designing a simulation game involves reducing
this complex reality to a simpler model [
• The symbolism of elements. Some real-life objects are presented in the new model in a new form.
We tried to organise the game development workflow following the study by Peters and Westelaken
[
The first phase involved drafting the terms of reference. The game’s goal was to engage the user
in learning the basics of a computer system by simulating a student’s actions moving through several
classrooms that can be thought of as online laboratories [
Events
Roles
Rules
Mechanics
Rewards Mandatory Knowledge Grade conductauthorisation retention me-ing Assignment chanics Academic hondeadlines Test-taking ors Academic in-mini-quizzes Special certifitegrity policies Study effective-cations ness system and Programming. The specification of the game as a simulator was finally defined, and what it should be at the end of the project was determined. The following requirements for the end application were specified: • It should be a desktop game in the simulation genre. • Several locations (rooms) of the game should be implemented, including a quest room, a room for learning the PandaOS, and a room for manipulating a prototype computer system unit. • The application should have a system for registering gamers. • The safe and eficient storage of user data and their progress and achievements must be implemented.
During the system analysis phase, the actor (student), its relationships with the surrounding objects and the factors influencing the player’s actions were identified. The surrounding objects are walls, doors between rooms, windows, computers, tablets, etc.
The game design phase involves the transformation of the system analysis into gameplay. It consists of several steps, such as clarifying the game components through abstraction, creating a game element matrix, and choosing a game format. The game element matrix provides a structured basis for the student simulator by mapping the main system components to game elements (table 2).
The next step was to summarise the data from the matrix, including removing (crossing out) those elements that were not feasible in this project. As a result, it becomes clear what information should be included in the game scenario and what roles and actions should be highlighted. After that, a game model was developed (figure 3), which combined all the game locations and identified possible player actions.
The next phase was the development of the simulation game. The concepts and ideas were implemented in the programme code. The game was tested, which led to bug fixes. Teachers were also tested to determine how the functionality corresponded to the game’s defined characteristics.
Before creating a Student Simulator, the necessary tools for design and development have been identified.
To solve this problem, we analysed scientific publications [
• Opportunities. Availability of tools to create the functionality we need.
The main game engines we considered were Godot, Unity, and Unreal Engine.
Unreal Engine is a powerful game engine that creates AAA games and projects with high
graphical requirements. Its unique Blueprints system makes it possible to create complex logic without
programming, making it easier for beginners to get started. In addition, the engine supports C++ to
solve the most complicated technical problems. The Unreal Engine is known for its photorealistic
graphics capabilities, which makes it ideal for cinematic-quality projects. However, significant technical
resources are required to work efectively with the engine, including modern, powerful computers and
a high team expertise. It is free of charge if the annual income is less than $1,000,000. This engine is
great for teams with enough experience, time, and resources to implement large projects [
Unity is a versatile and popular engine among developers of all levels. It supports both 2D and
3D graphics. Its licensing system allows you to use the engine for free if your annual income is less
than $200,000. Thanks to an extensive database of training materials, Unity provides an easy start for
beginners and rapid further development. A large marketplace of resources greatly simplifies game
work, allowing developers to use ready-made models, textures, shaders, and even mechanics. However,
when working on massive projects, there can be problems with scene organisation and performance
optimisation, which require additional eforts from developers [
Godot has proven to be a convenient and powerful tool for indie developers and small studios. It’s
completely free, which minimizes the cost of licenses or royalties, and the open-source code allows you
to customize the engine to meet the specific needs of your project. Godot provides developers with
tools for creating 2D and 3D games like Unity. Due to its low system resource requirements, it suits
teams with low-power systems. However, it should be borne in mind that Godot may be limited in
implementing complex graphical efects or large 3D projects. Nevertheless, its intuitive interface and
native GDScript programming language (similar to Python) make it ideal for beginners or those who
want to get started quickly [
Therefore, at the fifth step of the project, a matrix for selecting a game engine was created based on the previously defined criteria (table 3).
Based on our analysis of the advantages and disadvantages of game engines, we concluded that Godot is the most suitable for our project, as it is entirely free, does not require significant system resources, is easy to use, and provides a wide range of tools for playing various simulations.
Other tools needed for the project are programs for creating and editing 3D graphics. Among them,
were compared Blender and Autodesk 3ds MAX [
Autodesk 3ds MAX is a full-featured professional 3D graphics editor. It is a paid software with a fairly high price, namely a $235 per month subscription cost for one user. The requirements for computer resources are high, especially when working on complex scenes. Our team has minimal skills with this tool, but not enough for our project. This creates the need for additional time to learn the interface and functionality. 3ds Max is a powerful editor and can provide tools for all our 3D graphics needs, such as modelling, texturing, and animation.
Blender is a software package that works with three-dimensional graphics. Blender is completely free and open source, which makes it more attractive to small teams and indie developers. It demonstrates high performance even on average computers. Although it requires powerful hardware to work with large scenes, optimization allows you to work comfortably with the correct settings. Our team’s experience with Blender was insuficient, just like with Autodesk 3ds MAX. Blender ofers various capabilities: modelling, animation, sculpting, material creation, and rendering. An active user community also provides numerous add-ons and plug-ins to extend the program’s functionality. A matrix was also built to select a tool for working with 3D graphics (table 4).
At the end of the analysis, we concluded that Blender, due to its accessibility, low system requirements compared to Autodesk 3ds Max, and comprehensive functionality that met our needs, was the best choice for developing graphics for our project.
Before starting development, choosing a cloud service to store user data was essential [
Backendless is focused on creating a backend for applications and games with minimal code writing. Its key features include.
• Codeless logic creation is suitable for quick implementation of simple projects; • Real-time support, notification system, and data synchronisation; • Visual database editor makes it easy to work with data; • Cloud or local deployment, flexibility in choosing the environment.
For Godot, Backendless ofers convenient REST APIs for integration. Its advantages include easy setup and powerful tools for sending push notifications.
Supabase is an open-source platform that provides developers convenient tools for creating applications with a PostgreSQL backend. The main advantages of gaming projects are: • PostgreSQL as a database that supports complex SQL queries and stores data in a structured form. • Real-time via WebSocket for data synchronisation between clients. • Authentication with support for OAuth, Magic Links, and others. • Extensibility through features and the ability to deploy your own server.
Supabase integrates well with Godot via the REST API or WebSocket, which provides a convenient data exchange setup. Its main advantages are low cost, open source, and the possibility of self-hosting.
Firebase is an application development platform from Google that provides a wide range of tools for backend development. The main features that attract the attention of game developers include: • Realtime database, which allows you to update data instantly. • Firestore is a more modern, flexible NoSQL database for scalable applications. • Authentication with support for social networks, email, and passwords. • Cloud functions for writing server logic.
• Analytics to track user activity.
Firebase is ideal for projects that require scalability, real-time, and integration with other Google services. However, its disadvantages are high costs when the project grows, the limitations of the free plan, and dependence on Google’s infrastructure.
Based on this analysis, we concluded that Firebase is the best choice for our project. Its advantages in working with data, ease of integration with Godot via HTTP requests or custom add-ons, and scalability make it easy to adapt the project to future changes. However, Supabase is also a promising alternative, and Backendless can be a choice for simple games with minimal backend requirements.
In the 3rd and 4th phases of development, our team paid considerable attention to the study of scientific literature and technical documentation. The primary sources were scientific articles on developing educational games and technical manuals of Godot, Firebase, and other tools used. Additionally, we turned to developer forums such as Stack Overflow to get practical advice and find solutions to problems we had dificulty with. Conducting such research helped us to clearly define the tasks we were facing and choose the most appropriate tools to solve them. This, in turn, enabled us to understand better existing methodologies and approaches to developing such game projects.
Designing the game structure included using UML diagrams to visualise the main components and their interaction (figure 2). We also created flowcharts to detail the program logic. Use cases were described in detail for each module, which helped us to better think through the functionality and ensure convenience for end users.
To write the code for our project, we chose the GDScript programming language, which is part of the Godot game engine. This choice was made due to its high performance and ease of use when developing gaming applications. Using GDScript also ensured fast prototyping and eficient work with various aspects of the game.
The tests were performed manually, as manual testing is faster and less resource-intensive than developing and setting up automated tests. This allowed us to quickly identify and fix bugs, ensuring the game’s high quality. In addition, we also conducted tests on real users, which allowed us to get feedback on the immersiveness of the game project.
To develop a game product to be released, one of the most important elements is planning resources and product design. To keep the development going at the right pace, it is necessary to distribute tasks among developers and establish constant communication between them. Therefore, game developers used the GitHub platform. It allowed us to store the project in the cloud and synchronize the work between developers. Also, thanks to the associated GitHub Projects resource, we distributed tasks for implementing the game’s functionality and creating assets across the team. We also tracked the efectiveness of their implementation with further retrospectives of the implemented tasks to improve cooperation with each other.
The design and development phases of the Student Simulator game can be divided into several main steps such as • Pre-production (steps 4-7). At this stage, the design and idea of the game were developed, the design document and matrices were written, resources were estimated, a work schedule was drawn up, and the first game prototypes were created. • Production (step 8). This stage characterizes the primary and least active development process when all design aspects are agreed upon. The team works on the main parts of the game, such as programming the main game elements, creating content such as 3D models, music, and levels, testing the finished parts of the game, and integrating them all into a complete product. • Beta testing (step 9). At this stage, most of the game was ready, and the main focus was on finding and fixing various bugs and performance issues, as well as polishing the visual appearance of the 3D graphics and user interface (UI). • Release (step 10). This is the stage at which the game is fully ready for publication with access through the oficial website of the game.
These modules are implemented as follows in the published version of the game.
• The main player. It allows you to move around locations in the first person in the role of a student; • Interaction system. It provides the player with interaction with the environment using the camera.
Location system. It dynamically loads locations and changes them for the player. • Virtual operating system. It is an in-game operating system that allows you to run applications and games inside the program and view information about the player. • Visual programming language. It was created specifically for the Student Simulator project and can be considered as a model of natural programming languages. • Authorization system. It allows you to create user accounts and store user data. • Rating system. The module stores and displays users’ rating points.
• The task system. It allows you to perform interactive tests at diferent levels to get points.
To implement the possibility of movement, a particular physical object was created whose movement needs to be configured using code. With the help of keyboard input, we get the direction of movement and then call a particular built-in function that makes this object move, taking into account physics and the environment. This is how the main player was implemented in the listing 1.
To see the world through the eyes of the player, a virtual camera was attached to him, which followed him everywhere (figure 4). To change the rotation of this camera when the mouse is moved, we wrote a function that receives the diference in the cursor position of this and the previous frame and assigns these values to the camera rotation.
To make the game more immersive and increase the player’s connection with the environment, we created a system that allows him to interact with objects he points the camera at by pressing a unique key. To implement this mechanic, we added a beam to the camera that receives the first object it crashes into and checks whether interaction with it is possible (figure 5). If the player is looking at such an object and presses the interaction key, the interactive object will call a function and respond to the interaction (figure 6).
The game’s locations, which take place in university classrooms, were divided into separate scenes. This was done to optimise the use of computing resources and increase the modularity of the project. To move between them, we developed the function that dynamically loads and unloads rooms from memory without changing the player’s state (listing 2).
Listing 2: Function to change the current room f u n c change_room ( s c e n e _ p a t h : S t r i n g ) −> v o i d : _ p l a y e r . h i d e ( ) _ c u r r e n t _ r o o m . h i d e ( ) _ c u r r e n t _ r o o m . q u e u e _ f r e e ( ) _ c u r r e n t _ r o o m = l o a d ( s c e n e _ p a t h ) . i n s t a n t i a t e ( ) a d d _ c h i l d ( _ c u r r e n t _ r o o m ) _ c u r r e n t _ r o o m . p o s i t i o n = V e c t o r 3 . ZERO _ p l a y e r . g l o b a l _ p o s i t i o n = _ c u r r e n t _ r o o m . g e t _ p l a y e r _ s t a r t _ g l o b a l _ p o s i t i o n ( ) v a r p l a y e r _ c a m e r a : Camera3D =
_ p l a y e r . main_camera p l a y e r _ c a m e r a . s e t _ c a m e r a _ r o t a t i o n
( _ c u r r e n t _ r o o m . g e t _ p l a y e r _ s t a r t _ g l o b a l _ r o t a t i o n ( ) ) _ p l a y e r . show ( )
When creating the authorisation system, we used Firebase tools such as authentication to implement the authorisation system and Firestore to store user data. We used the Godot Firebase addon to simplify the interaction between Godot and Firebase. Authentication in Student Simulator works as follows: the user enters the required data, email and password. Since these are the primary data for authorisation, they are stored in the Authentication tool. To store other data, a file with an individual and unique name for each player is created in the player_stats collection in the Firestore (figure 7).
User registration requires filling out a form, including entering a nickname, choosing a role (teacher or student), and entering an email address and password (figure 8). After registration/login on a particular device, user data is stored locally and used automatically the next time the game is launched.
An example of a method for sending user data to the server is the _send_account_data() function (listing 3), which sends data during registration. The principle of operation is as follows: first, the user is verified, then the data from the completed form is collected and arranged, and finally sent to the server.
1 :
r o l e = " Teac her " v a r d a t a : D i c t i o n a r y = { " nickname " : nickname , " r o l e " : r o l e , " a v a i l a b l e _ l e s s o n s " : { " 1 " : [ " 1 " ] }
The virtual operating system implemented in the project is called PandaOS. It is a virtual operating system designed to provide an interactive user experience. It is based on a design of visual ‘Control’ nodes. The PandaOS interface displays visual elements similar to those in the Windows operating system (figures 9 and 10). This includes windows, buttons, icons and other controls, allowing users without additional knowledge to use it using familiar interfaces.
The critical function of PandaOS is to act as a bridge between the 3D game world and mini-games implemented as separate applications or games for this operating system. This allows seamless minigame integration into the main gameplay, providing users additional features and entertainment. In addition to the basic features, PandaOS ofers several additional options for customising the system. Users can change the background and colour scheme of the system to suit their preferences. The system also has a clock that displays real-time and date, which adds even more realism and ease of use. In Student Simulator, one of the mini-games ofered is the Bamboo+ application, where you can easily acquire basic programming skills using the Bamboo+ visual programming language of the same name.
The program can be divided into 5 main blocks such as (figure 11 and 12) • Top bar for programme management; • Right menu of lessons for selection of available lessons; • Left ‘theoretical’ panel contains theory for the current lesson (article with images); • Area for building an algorithm; • Console is the area of data output using the print function block.
The lesson theory, available units for work and correct answers for checking are loaded into the lesson from the local JSON database. Data on which lessons are available to the user and the lesson’s progress are stored in the Firestore database.
Each block of the Bamboo+ programming language is a separate scene with its script and functionality. When you click on the ‘Run’ button, the program execution starts. The code is read gradually from top to bottom. Each block contains a run_block function executed when the queue reaches its block (listing 4).
Listing 4: An example of calling the run_block function (initialising a variable) f u n c r u n _ b l o c k ( ) : v a r a u t h = F i r e b a s e . Auth . a u t h i f a u t h . l o c a l i d :
v a r c o l l e c t i o n : F i r e s t o r e C o l l e c t i o n = F i r e b a s e . F i r e s t o r e . c o l l e c t i o n ( COLLECTION_ID ) v a r nickname = %N i c k n a m e L i n e E d i t . t e x t v a r r o l e _ i d = % R o l e S e l e c t i o n E d i t . s e l e c t e d v a r r o l e match r o l e _ i d : 0 : 1 : r o l e = " T e a c h e r " v a r d a t a : D i c t i o n a r y = { " nickname " : nickname , " r o l e " : r o l e , " a v a i l a b l e _ l e s s o n s " : { " 1 " : [ " 1 " ] } The following blocks are implemented for programming in Bamboo+: • Variable initialisation. Bamboo+ is strictly typed and supports such data types as integers, floats, strings, and booleans.
• Reassignment variable. • Function initialisation. • Call function. • Construction ‘if’ and ‘if-else’ for branching. • ‘While’ is a loop until the specified logical expression is true. • ‘For’ is a loop with a local variable whose value starts from 0 and goes up to the specified value.
The loop stops when the local variable becomes equal to the specified values.
• ‘Print’ is a function that outputs data to the console.
Another interactive mini-game was a test system using 3D models of tablets. For this purpose, we developed a scene with a tablet and an interaction system (figure 13). The objects themselves are hidden in diferent locations in visible and not-so-visible places. When the player finds one, he/she can pick it up and then a tablet window will appear with a question he/she has to solve.
Players are awarded rating points for completing various tasks and passing mini-games. This will create healthy competition and encourage users to learn more to gain the top spot. Standard Godot control nodes were used to build scenes displaying the best players (figure 14). The Firebase Firestore tool was used for saving the data. The data is stored in the rating file as ‘key’: ‘value’.
The ability to improve the Student Simulator game opens up broad prospects for further development.
One of the critical areas could be the introduction of artificial intelligence to adapt the learning process to
the individual needs of each student [
The integration of the game with popular learning management systems, such as Moodle or
Blackboard, is in demand among teachers [
An essential task of implementing the simulator is determining its efectiveness criteria and indicators.
To accomplish this task, teachers should be involved as experts. A survey of students to assess the advantages and disadvantages of the developed game application is another promising area for further research.
The results of this study show that its primary objectives were met. We analysed. Modern approaches to designing, creating, and using simulator games were explored. On this basis, the sequence of game development was clarified, a matrix of its objects was made, and a model was designed. As a result of the comparative analysis, we have grounded and selected the main tools for development: Godot as a game engine, Blender as software for creating 3D graphics and Firebase as a cloud service for data storage. The chosen set of tools should consider the needs of graphic development, interaction and ease of use. The author’s experience in creating the game was systematised, and its critical development points were described.
The development of 3D games, such as Student Simulator, requires the collaboration of various specialists. In our case, it was organised as a project whose participants acted as storytellers, designers, programmers, modellers, and testers. This approach encouraged teamwork and healthy competition among developers. The created Student Simulator has a modular structure at the level of locations and objects with which the player interacts. These objects are the PandaOS virtual operating system and the Bamboo+ visual programming language, which add new levels of interactivity and learning opportunities. The project participants created a website to promote the game. However, the project has prospects for further improvement, mainly through implementing AI and expanding multiplayer functions.
Acknowledgments: We want to express our sincere gratitude to all the students of the CS-46 (KN-46) group of Ternopil Volodymyr Hnatiuk National Pedagogical University, who are not the authors of this paper but were participants in the project and put a lot of efort into creating the Student Simulator game. Among them are Maksym Bazyvoliak, Honcharuk Maksym, Ivan Hrytsai, Vitaliy Melnychuk, Vladyslav Serpevskyi, Ivan Shovag, and Andriy Yasinskyi. Declaration on Generative AI: The authors have not employed any Generative AI tools.