1

FINAL PROJECT REPORT

The Saboteur Card Game

in

UNITY 2D

Institution Affiliation

By

_________

Assignment Due Date

 2

0.1 ACKNOWLEDGEMENT

I would like to express my deep gratitude to Professor *** and Professor ***, my

research supervisors, for their patient guidance, enthusiastic encouragement, and useful critiques

of this research work. I would also like to thank Dr. *** for her advice and assistance in keeping

my progress on schedule. My thanks are also extended to Mr. *** for his help in doing the

saboteur card game project in my final year, to Ms ***, who helped me calculate the wind

pressure coefficient, and to Ms *** and Mr. *** for their support in the site measurement.

I would also like to extend my thanks to the technicians of the laboratory of the *** department

for their help in offering me the resources in running the program.

 3

0.2 ABSTRACT

Many games are created to make a computer adaptation of conventional games like

chess, go poker, and many more. The method is quicker with today's technologies and continues

to improve as time continues. This paper, therefore, describes an example game built in Unity,

which uses code to allow for the simple and cost-effective method of developing card games,

custom-made or taken from real life, to enable the lighting-fast progress in IT. This paper

describes the inspiration, the information used, and the success of the University's timeframe,

demonstrating my first indication of the outcome, the Saboteur card game. I start by describing

the key motivations, achievements, the values applied, and the result of this growth.
 4

0.3 TABLE OF CONTENTS

0.1 ACKNOWLEDGEMENT..................................................................................................................2

0.2 ABSTRACT..........................................................................................................................................3

0.3 TABLE OF CONTENTS....................................................................................................................4

1.0 INTRODUCTION.........................................................................................................................7

1.1 Motivation..................................................................................................................................7

1.2 Goals............................................................................................................................................7

2.0 BACKGROUND............................................................................................................................8

2.1 Unity 2D..........................................................................................................................................8

2.2 Saboteur..........................................................................................................................................8

2.3 Why Unity 2D.................................................................................................................................10

The idea of the game............................................................................................................................10

Features of the Game...........................................................................................................................11

Interactive User Interface...............................................................................................................11

Freedom of Control.........................................................................................................................11

3.0 RESEARCH.................................................................................................................................11

3.1 The Unity Interface..................................................................................................................12

Figure 3.1..........................................................................................................................................12

3.2 Unity Networking.....................................................................................................................14

 5

3.3 Unity Scripting.........................................................................................................................17

3.4 Unity UI....................................................................................................................................19

Figure 2.............................................................................................................................................19

4.0 DESIGN........................................................................................................................................20

4.1 PROJECT PLANNING..........................................................................................................20

Figure 4.1.1.......................................................................................................................................20

Figure 4.1.2.......................................................................................................................................21

4.2 METHODOLOGY..................................................................................................................21

4.2.1 Development Lifecycle............................................................................................................21

4.3 V-Model....................................................................................................................................22

5.0 RESULTS.....................................................................................................................................22

5.1 Graphic Design.........................................................................................................................23

5.2 Game Performance..................................................................................................................24

5.3 Game Engine............................................................................................................................24

5.3.1Graphics Rendering.................................................................................................................25

5.3.2 Input Handling........................................................................................................................25

5.3.3 Collision Detection..................................................................................................................26

5.4 Testing Phase............................................................................................................................26

5.5 Evaluation Phase......................................................................................................................26

5.6 Requirements Hardware and Software.................................................................................26

 6

5.6.1 Software................................................................................................................................27

5.6.2 Hardware..............................................................................................................................27

5.7 Reflection..................................................................................................................................27

6.0 CONCLUSION AND RECOMMENDATIONS.......................................................................28

7.0 REFERENCES............................................................................................................................30

8.0 APPENDICES..............................................................................................................................32
 7

1.0 INTRODUCTION

This chapter attempts to illustrate the inspiration behind creating this project and the aims to

be accomplished by the end of the project.

1.1 Motivation

My involvement in the video game industry and how I get to know the Unity engine,

object-oriented programming as a whole, and access network-oriented programming are the key

inspiration behind the development of this project. This project has been coded to allow quick re-

use of the technology, a good forum for self-learning, and a simple port, as the main aim of this

project, like a smartphone device. With today's accelerated smartphone technology advances, the

concept of moving a PC-only video game onto a mobile device in almost no cost-efficient

manner can be overlooked.

The shortage of multiplayer card games on predominantly mobile platforms is another

key motive behind this, and more particularly behind the example game saboteur. Some card

games are still accessible on the PC, but their lack of smartphones provides a fantastic chance to

build anything not achieved previously.

1.2 Goals

In addition to the simple OOP knowledge as we were taught in the University, I want to

build games in Unity, fully connected, to enhance and improve the basic distribution system

skills we have been taught. I may have understood the concept of functioning in a clustered

environment where objects communicate and organize them appropriately with the networking

dimension, deciding which of them is transferred to customers to minimize networking traffic

and make for a relaxed gameplaying experience for multiplayer.

 8

By contrast, it contributes to the philosophy of video game production that you should

construct a video game correctly in order, in a less overwhelming fashion, to leave it available

and make it easier for the customer to play the game. The other goal is to provide a fully working

Saboteur card game, encoded so that it can be converted easily into a smartphone, fully

networked, and properly designed to meet the player's needs.

2.0 BACKGROUND

This chapter seeks to clarify what Unity is and briefly explain what Saboteur is and how it is

performed.

2.1 Unity 2D

Unity is an SDK primarily used to create video games by the production of IDE and

game engines. It makes a smooth creation phase by removing the pure elements such as

individual insertions of co-orders, the slope, the z-buffer, etc., by adding scenes, which are areas

where several game artifacts can be set players (assets) conveniently.

You may use files to navigate the game environment with either C# or Javascript. It's

near java, of which I already had university experience[ CITATION Ant191 \l 1033 ]. I choose

the previous one. Unity has become the main choice because of its simplification and versatility,

mostly because it is easy to use and utilizes smartphone video game development. There are

many other alternatives, including Unreal Engine or even OpenGL coding from scratch only.

2.2 Saboteur

Saboteur is a board card game in which the dwarves participate. They look for gold as

miners in the mine. Suddenly the axis of a pick swings down, and the lamp is shattered. He hit

the Saboteur. But which of the saboteurs are they?[ CITATION Ant191 \l 1033 ] Can you
 9

discover the money, or will the saboteurs' fierce acts first lead you? The player with the most

gold is the winner after three games. The players are allocated their task with the aid of Dwarf

Cards: either miner or Saboteur. The task is held hidden - only at the end of the round are shown.

 The Start Card and the three Goal Cards are all put on the table, and one card is placed

every seven cards away from the Start. The target cards are face-down. One of the target

cards contains gold, but nobody knows what.

 Cards inside for matches. In the turn of a player, he must do one thing or another: put a

Path Card in front of a player, play an Action Card, or move.

 The Route Cards are routes that lead to the Target Cards. You would play the Path Cards

next to a Path Card that's already played[ CITATION Cox571 \l 1033 ]. The directions on

the path card must complement that of the cards you already play, and you can not play

path cards on the hand.

 The miners attempt to create a continuous route from the Start Card to a Goal Card while

the saboteurs try to stop this. They do not attempt to be too blatant, though, until they are

discovered straight away.

 Action cards may be put, including yourself, in front of every player. Action Cards

enable players to support or impede each other and get details about the target cards.

 The round is finished if a player puts an on-gold Path Card. The miners have won and are

being awarded gold cards.

 The round is also finished if the gold is not attainable. The saboteurs prevailed and

received the gold pieces in this event.

 The next round starts after the Gold Cards are issued. The player with the most gold

pieces the champion will be after the three-round.

 10

2.3 Why Unity 2D

The first step in thinking of a game being developed isn't necessarily a 2D Game Engine.

It seemed like an excellent option at the time because flash somehow became synonymous with

smaller novice 2D platformers, and everyone involved with the project believed that they could

be the medium of choice at the time[ CITATION Dew182 \l 1033 ]. It took me a while to learn

that Unity was used for the prototype since Unity was the only engine with which all team

members had prior knowledge. It was presumably because everybody's experience with it has

been more in 3D before. It was about the first week of the project that someone from the team

said that the construction environment has already come to light. Couldn't all this in Unity be

easier?

It posed the question of the option of Unity was good. Unity is a 3D engine, and so it is

mostly 2.5D that can be 2D, which fakes 3D or 3D that fakes 2D by accident. When 2.5D is

referred to in this thesis, it refers to the above for explanation[ CITATION Dew182 \l 1033 ].

This implies that a 3D environment can be generated and is merely limited to a 2D plane,

especially a saboteur card game board. It comes with both benefits and drawbacks[ CITATION

Ant191 \l 1033 ]. One such thing would be that it is possibly impossible to refine the game and a

true 2D game from the downside. Since the benefits are much greater than the drawbacks, Unity

comes with a visual editor that significantly improves workflow. With the ability to combine 3D

effects in an otherwise 2D environment, some very nice saboteur game cards could be

developed.

The idea of the game

The game plays the dwarves. If they're gold diggers, they work in the mountains for

riches deeper and deeper, or they're saboteurs who attempt to position barriers in the way for the
 11

diggers. Each group's participants can help themselves, even though they can always only

imagine whom. If the gold diggers find a way to the treasure, they are properly awarded gold

nuggets, while saboteurs must leave bare. But if gold diggers lose, the bounty is reaped by

saboteurs. The tasks are revealed only when gold is divided—the player winning the most

nuggets after three games.

Features of the Game

Interactive User Interface

The user needs to view the home screen, open a new game, continue the previous game,

and have a settings tab[ CITATION Gib971 \l 1033 ]. The consumer should configure the

monitor and sound configuration in the settings tab.

Freedom of Control

For example, players will use a keyboard layout setup or Controller setup to select the

input system they want.

Procedural Generation

The player can discover hidden levels created entirely procedurally, i.e., levels that are

rendered more complicated iteratively.

3.0 RESEARCH

This chapter is designed to understand the various principles explored and developed during

the project and to explain each of them

 12

3.1 The Unity Interface

Figure 3.1

On the left, we have a hierarchy menu mentioned in the current scene in which we are all

game elements. From this, we can quickly note the blue and grey color of networked artifacts,

disabled objects, and parent and child objects, and there is an arrow on the latter. It is necessary

to manage children/parents, in particular, if artifacts may contain many attributes.

In the central section, we have the real scene view and the keys to help us handle the

scene in the grey region over the center and left side of the screenshot and three

tabs[ CITATION Dew182 \l 1033 ]. From this perspective, the consumer can see any item for his

scene and therefore conveniently reposition, measure, and rotate it as he desires. We will also see

the game via the game tab as the customer expects to see the final product.

The Inspector menu on the right displays every item attached to a selected gaming item,

for example, a rigid body, the physics collision box of the object, and most of all, the scripts
 13

attached to the object. Public variables such as their coordinates or any open values in the script

for each component can be viewed.

We have the console/project tabs at the bottom. The Project tab displays all currently

imported, used, or stored assets (including scripts) arranged in folders for the complete project.

The next to the Console tab displays debugging messages, mistakes, or warnings currently on the

picture. It is one of the key menus, so debugging is needed.

Unity generally works together with a variety of Game Objects to create a fascinating

scene. Certain game elements hold together a certain number of functions, including some of the

transition element that regulates the location[ CITATION Dew182 \l 1033 ], size and orientation

of the object within the scene;

Camera

It is the aspect that regulates the consumer's viewpoint. It can be switched between

spelling and prospecting, the latter favoring 3D applications. Besides, the view field (FOV) and

several advanced parameters such as cutting planes and an HDR toggle can also be adjusted.

2D/3D Object

It is like a part collection in a game instead of its own. They are built from a mesh

component to help you choose a mesh model shown on the screen, the renderer, to be used to

configure it. For example, it is capable of casting shades but also of using the material/texture.

Alternatively, a static portion of the body may also be introduced to grant physics for the object

if something needs to be 'realistic.'

Light
 14

In summary, this part brings light to the scene and maybe spatial, point or position,

shifting the shadow form from heavy, no, or soft shadows, changing the strength, and changing

the color of the light to list a few items.

All of the parts mentioned above can be set up in a prefab after being applied to a game

object, as required, and can then be instantiated using scripts.

3.2 Unity Networking

In this part, we want to clarify the ideas behind Unity networking and the information we

have collected. The central aspect is the Network Manager, which is a Unity convenience class.

It offers easy, optimized methods in which clients and servers start and stop, network scenes

management, and functions can be extended to incorporate network events managers, such as

when a client connects, disconnects, and so forth[ CITATION Grä901 \l 1033 ]. For easy usage,

customers are intended as network link artifacts that, for example, include their IP, objects they

own, and their state. Any major networking features are:

public override void OnServerConnect(NetworkConnectionconn)

It is called on the server whenever a client connects to the server and argues his

NetworkConnection object.

Use OnPlayerConnected for successful connections.

OnServerDisconnect/OnPlayerDisconnect for the exact opposite. public void OnClientConnect(

Networking.NetworkConnectionconn).

Along with these, Unity introduces some new concepts to the table, such as SyncVars,

Commands, and ClientRPCs , to name a few. [SyncVar]

 15

This is placed one line before a variable you would like to synchronize, such as the

number of cards in a deck. Whenever this variable is updated on the server, it is automatically

updated on all clients (and NOT the other way around).

A hook can be added, as such:[SyncVar(hook = "OnDeckSizeChange")] An example for

this is: [SyncVar(hook = "OnDeckSizeChange")] private int decksize;

It means that the function OnDeckSizeChange will be called when SyncVar updates

everyone. [Command] This is placed one line before a function, which will have to start with the

prefix "Cmd." e.g. [Command] void CmdTest()

It means that whenever the function is executed on the clients, Unity will execute the

function on the server. [ClientRpc]

It is placed one line before a function, which will have to start with the prefix "Rpc." e.g.

[ClientRpc] void RpcTest() As a result, the function, if executed from the server, will be

executed for all clients

This is called on the client whenever he connects to the server. public void

OnServerInitialized()

It is called on the server when it has been hosted. Public bool isServer / isClient Returns

true or false, depending on whether the client or the server called this.

Public override void OnStartClient() Called on the client after he is started. Public

override void OnStartLocalPlayer() Called on the client after the local player object has been set

up. This is executed after OnStartClient

 16

It should be noted that the Unity networking scheme uses the name UNET, and Unity 5.1

has been released. The creator must accept the pre-made class of Network Manager, which can

be expanded to override built-in interface functions in a script to enable a range of the above

functions to operate[ CITATION Grä901 \l 1033 ]. The user has the normal tasks to link and

reconnect to a server. But, this is already done with the Unity Network Manager UI, a

convenience class/script that can be added to any Game Object. The user can easily validate the

core components of a game with a basic, already installed UI. The network manager may even be

modified to load various scenes. At the same time, the consumer is offline or online, and, most

notably, it can set the prefabrications generated and allocated to each player when they link

successfully.

One of the most critical facets of the networking scheme is customer authority and how

the client interacts with the server. In general, Unity can define the items in which the local

player can communicate to shield him from future hacking[ CITATION Hoi111 \l 1033 ]. To

synchronize the server, each networking object must, in the first place, be allocated a component

of network identity. Ignoring this ensures that the object can be entirely customized for all

purposes. It also gives the local player authority a Choice that does not have to rely on the server

because the client has the literal authority over the server. Still, it is liable for everything that

happens to the object.

Besides, there is also an alternative server to guarantee that the entity is only spawned on

a server (and activated). If every step is to be coordinated on an item, the Transform Network

function should be attached[ CITATION Ant191 \l 1033 ]. This helps you adjust how quickly the

object location is transmitted to all clients through the NetworkSendRate option. Setting it to

zero is helpful for structures not to be modified after creation.

 17

It is also worth noting that through the Network Manager and the helper UI component,

we can host servers on the local machine easily, and through compilation of the  Game, we can

also use another instance on the local machine to evaluate multiplayer circumstances.

3.3 Unity Scripting

Scripts in Unity, as defined in the previous chapter, are written in either C# or Javascript.

These are modules, which can be connected to game objects and, as a result, allow the developer

to control them in real-time, as the game is in development[ CITATION Kri191 \l 1033 ]. It uses

activities analogous to networking to monitor when to execute those orders. As such, interfaces

are given by Unity. Few essential ones are as follows, both of which are clientside:

void Start ()

Called just before any of the Update methods is called the first time. It is only called if

the inspector enables the script instance.

void Awake()

Called whenever the script instance is being loaded, without necessarily having it

enabled. Awake is always called before Start.

void Update()

Called every frame when the script is enabled.

void LateUpdate()

Called after every other Update execution, which makes it useful for ordering script

execution

void FixedUpdate()
 18

Called every fixed frame. As a general rule, this should be used for scripts manipulating

physics.

Unity also enforces complicated concepts like delegates in customized user-coded events

and their use in this. One easy way to explain them is to have a series of functions that can be

performed when calling a delegate, where various functions can be "stacked[ CITATION

Wac211 \l 1033 ]." This is powerful if you want to update the scoreboard whenever a player puts

a card down.

Aside from the delegates, we also have singletons, which are classes/objects called once

and strictly prevent instantiation again. This is very useful for classes, like the Network Manager

mentioned above, which must only exist once. With the "transform" component, each

GameObject can be formed by its position, angle, and scale. Vector3 is used in both positions

and scales, but quaternions are used for angles[ CITATION Wac211 \l 1033 ]. Fortunately,

conventional Euler angles can be easily converted into quaternions with unit functions.

Unity offers a "messaging" system to send string messages, along with their arguments,

to other objects to communicate to each other to activate their functions. Nothing happens if

there is no script available in the GameObject target unless SendMessageOptions are available.

RequireReceiver is truthful.

Unity can also easily cast rays, for example, to detect where the mouse has been clicked

on. The source, direction, and distance can be determined with the provided ray object that a ray

can travel and return the game object it has collided with or zero if it has hit nothing. Layers can

be tinkered to ignore specifically marked objects. However, this exceeds the scope of this

project.
 19

3.4 Unity UI

Unity offers an easy way for the user interface to be created via a "Canvas," a 2D panel

that allows the user to drag and drop components, including buttons, scrolling menus, text boxes,

images, etc. Scene View is the environment where the GameObjects, including cameras,

backgrounds, characters, monsters, and more, communicate with us. In this view, we can place

our game objects and turn them

Pictured above is the canvas, as viewed from Unity's scene view.

Figure 2

Each UI element can be handled by scripts, as intended, and the inspector on any press

can execute the public void functions inside the script.

 20

4.0 DESIGN

This chapter aims to clarify the strategy the project follows and the access control that was

agreed and followed during the project.

4.1 PROJECT PLANNING

This initiative follows the agile process concepts. A summary of what to do for the

remainder of the project was created with a gannet chart.

Figure 4.1.1

The original project schedule, which was prepared at the beginning of the year, is

presented above. At that time, the group has followed this roadmap, where the first line is linked

to Unity's constant study needs and functions[ CITATION Wij191 \l 1033 ]. The general concept

of how the project can advance is to actively study solidarity as creation continues, saving time

and further learning by experimentation.

Another helpful tool in my progress was the agile practice of task boards, which enabled

me to keep track of what needed to be completed, reworked, and ready and polished.
 21

Figure 4.1.2

4.2 METHODOLOGY

4.2.1 Development Lifecycle

The life cycle of this project corresponds to the creation of each PC saboteur card game

in Unity 2D. The method usually involves the creation of graphical and sound objects and their

use for Unity objects. Every object is evaluated in an independent setting that is normally an

empty Unity project. In the whole project, the object logic is then created, implemented, and

evaluated. When these phases have been completed, the proposal will be sent for testing and

input to various individuals[ CITATION Dew182 \l 1033 ]. The input received is included in the

next cycle and begins with the graphical and artifacts revision. To interpret the content and

obtain a greater understanding and historical reconstruction, the experience of users and other

stakeholders in the framework was taken up and relevant data from the documentation listed and

to compile checklist.
 22

4.3 V-Model

It stands for a model of verification and validation. As, V-shaped life-cycle is a sequential

processing course, as does the waterfall model. Before starting the next process, each phase must

be complete. I used V-Model as one of the frameworks for software creation. In parallel to the

appropriate stage of production in the V-model, testing of the product is expected. The V-model

is one of the most costly and time-intensive models, however[ CITATION Hoi111 \l 1033 ]. This

arrangement helped in the development of the card game full of workflows means excellent

quality management. The test procedures used in the project are suitable. The card evaluation

ensured the game features were working prior to beta testing. No other experiments were

considered to be as rigorous as a pc evaluation in the saboteur game.

5.0 RESULTS

This chapter is intended to illustrate what has been done in this project before the submission

stage and develop this project.

 23

5.1 Graphic Design

One of the most important elements when creating the graphical aspects of the project

was to export SVG images properly and then import them into Unity without losing any quality.

Unity can pixel the image if you upload an image of very low resolution, such as 64 by 64 pixels,

and display it to a suitable size. In contrast, Unity produces objects such as an Upsize Downsizer

for display while using a large image, for example, 4096 by 4096 pixels, as the filters that are

used are rendered quick but not exact[ CITATION Kri191 \l 1033 ]. That's why I've done a lot of

experiments for images in various sizes and discovered that the best-looked images are

approximately 512 by 512 pixels.

2D games are often made using orthographic cameras. This means that rendered will look

like in Photoshop and GIMP in the game. The graphs are drawn and measured in pixels in 2D

screen space. This is valid with both my graphics and GUIs. But it poses an intriguing dilemma,

which is either unresolved or accepted today[ CITATION Dew182 \l 1033 ]. The problem is this:

if your pixel locations and dimensions of your graphs are set, they depend on the resolution.

From the interface, look at a different resolution, such as 1920, if you build a button- and

widget interface placed within an 800 by 600-pixel area? What are the various resolutions to

display the GUI 800 by 600px? These questions illustrate the issue which is particularly apparent

today as games are designed for a wide range of platforms[ CITATION Wac211 \l 1033 ], which

means that the games must "look right" over a wider spectrum of resolutions to reach broader

markets effectively.

One approach to this problem is only to scale the initial graphs in order to match some

resolution on the structure. While this approach is working and is often used, it will never be a

suitable solution if anyone is actually interested in supporting the largest available resolutions
 24

and is shown graphics of the highest quality[ CITATION Wac211 \l 1033 ]. This is because it

does not understand the possible variations between resolutions in aspect ratio. If the GUI for

800 by 600px is not universally sized in order to meet the resolution of 1920 by 1080px, the

graphics will not only look higher, but they will also be more extensive than they are.

5.2 Game Performance

Since this is a basic Unity 2D game, it is critical that there is no significant loss of

performance in a variety of hardware[ CITATION Wij191 \l 1033 ]. In general, success in games

is calculated by the frequency rate of the images on a screen in frames per second (fps). This is

known as a frame rate which is optimal for 60 fps in play. At this point, the saboteur card feels

seamless and sensitive.

V-sync is another significant game output element. It syncs the frames sent to the display

by the GPU with the screen refresh rate and restricts them to its highest value of 60Hz in most

displays. This choice disables the actual production of the game, and the larger, the better.

Users normally want it to be available, though, so objects like screen tweaking can

otherwise appear on the screen. All tests were performed using MSI Afterburner, which offers

comprehensive knowledge and game performance statistics. Testing was performed on various

operating systems, such as Windows (7, 8, and 10) and Linux versions (Ubuntu and Debian). In

this way, it is worth noting that there was exactly the same consistency for all operating systems.

5.3 Game Engine

As discussed earlier, a game engine is a piece of game production software. The three

subsystems of my game engine are Rendering, handling, and collision detection of graphics.
 25

5.3.1Graphics Rendering

This subsystem handles all programming that gives the gaming visuals, including

initialization and release of the graphical device's machine resources. It offers 2D geometric

primitives rendering services, including point, line, point list, line/strip, and mesh. You will load

into the game an external 2D model encoded in .x format. 2D artifacts are also made by this

subsystem, such as color-keyed bitmaps and fonts[ CITATION Ant191 \l 1033 ]. This subsystem

also manages other non-renderable graphical elements, including the camera, light, and

materials.

Two standard graphical APIs are available: DirectX and OpenGL. For the Windows

platform, DirectX is only for the cross-platform OpenGL. The DirectX is a decent alternative

because the game is played on a Windows board. The consistency and programming friendliness

of both APIs are widely discussed. DirectX is actually worse than OpenGL in the past. The gap

in output was reduced as DirectX improved[ CITATION Ant191 \l 1033 ]. The efficiency of the

two APIs is about the same as the new release of DirectX 8. The DirectX 8 API was additionally

revamped to merge DirectDraw and Direct3D in DirectGraphics. The API is, therefore, simpler

than in previous releases. In addition, certain valuable utility features, including loading meshes

into the file format software, contribute to the DirectX API's programmer friendliness.

DirectGraphics for DirectX 8.0a is also chosen in this project as the graphics kit

5.3.2 Input Handling

Services for quick registration responses to the player feedback are included in this

subsystem. This subsystem involves the initialization and release of machine resources obtained

from the input device in the same way as the Graphics Rendering subsystem. DirectInput of
 26

DirectX 8.0a is used to enforce this subsystem as the input handling API[ CITATION Kri191 \l

1033 ].

5.3.3 Collision Detection

This subsystem offers services to search for a collision between two objects.

5.4 Testing Phase

The software errors are found in this process, and the program is debugged. The deployment

process actually goes into this phase. When a component is complete, stubs or drivers are used to

validate the component to check if it performs (unit test). When all the modules have been

completed, they are checked to see if they interact properly (integration-test). They are evaluated

in a lower-level way, i.e., first, and then the entire machine is tested.

As the game code is a part of the network and the game engine component, it is important to

ensure that all components are working before the game code is tested. Furthermore, the

graphical component is checked in the game engine before testing the input and collision parts

since the input and collision component answers are viewed with the graphics component.

5.5 Evaluation Phase

The game is posted for download on the web after testing and debugging. A homepage will

also be built to allow players to comment on graphic quality, gameplay, speed, and ease of

control after downloading and installing the saboteur game into their individual PCs. The

assessment process is one month long. During this time, the players' feedback will be

continuously checked, and our game versions improved.

 27

5.6 Requirements Hardware and Software

The lists of the hardware and software we use to complete the project are as follows. CS

System provides most of the things mentioned, with the exception of the 2D Graphics Display

Card Accelerated. CS System continues to verify that a display card can be supplied.

5.6.1 Software

 GIMP

 Unity 2D

 Microsoft Visual C++ 6.0

 Network Protocol: TCP/IP (Winsock 2.0)

 Graphics Package: DirectGraphics of DirectX 8.0a

 Programming Language: C++

5.6.2 Hardware

 Accelerated 2D Graphics Display Card

 LAN Support

 A standard 102-key Keyboard

 A Display Monitor

 200MB hard disk space

 128MB RAM

 Intel Pentium III 550MHz

5.7 Reflection

When I look at how the project went, I see no key features that seem practically incomplete.

Nothing has gone in vain, however. Through this project, my expertise in Unity 2D game
 28

development has become essential. To comply with the final specifications, I shall concentrate in

the future on developing and re-designing the game

6.0 CONCLUSION AND RECOMMENDATIONS

The key goal of the project was to design and build a 2D pc card saboteur game and to

understand how much of it works. To this end, the various graphical elements of pc-games have

been built so that I can learn how to use Unity 2D applications easily to produce the desired

effects. Each design was completed more quickly and easier than the previous design in this way.

Similarly, by mixing audio technologies, in particular audacity and Bfxr, I have learned how to

design basic yet necessary sound effects.

I developed a program based on the game Saboteur for the Master Course Multi-Agent

Systems. The program aims to use faiths to play the game. I choose the game Saboteur because

players don't know the position of each other in the game. One must understand how to trust and

what other players believe. On that basis, they have to know which cards they play, who they

trust, and who they do not trust.

However, most of the time, these rivals are novices. They are merely amusing themselves.

Can they know how to approach a project in the most efficient manner possible? They don't, of

course! There are training programs for project administrators, but none for project saboteurs.

The saboteurs must act as they see fit; there is little support for amateur saboteurs who want to

advance to the level of true professionals

With respect to the PC-Game of the saboteur card, all the game logic and artifacts have been

developed and implemented with Unity and its 2D toolset. In consequence, the video game
 29

consists of one level that can be played with several different objects and obstacles. This is the

part I liked the most because I like to program and construct game logic.

In order to learn a lot more about game design and creation with various Enemies and Boss

logic, I found myself an enjoyable challenge. In addition, I learned several fascinating things

about making a colorblindness game and found a way to enjoy the game. On the other hand, the

video game obtained can be played on various operating systems and even on dated computers

has very good results. Besides, any new game consoles can effectively be ported.

Finally, I like to point out that much of the work carried out during this project has been

learned since I have very little familiarity with the making of pc games. Without the full range of

games, I'd created really basic video games and have never built any sound effects or graphics

for them.
 30

7.0 REFERENCES

Antonius, R., Lukas, S., & Lohanda, L. A. (2019, August). Trust-Based Heuristics Approach on

Saboteur Board Game Decision Making. In 2019 2nd International Conference of

Intelligent Robotic and Control Engineering (IRCE) (pp. 160-164). IEEE.

Cox, A. L. (1957). The Saboteur Story. Records of the Columbia Historical Society, Washington,

DC, 57, 16-25.

Dewi Wijaya, V. (2018). Perancangaan Visual dan Aset Board Game dengan Tema Berhemat

Berjudul MARIMAT (Doctoral dissertation, Universitas Multimedia Nusantara).

Gibbons, R. (1997). An introduction to applicable game theory. Journal of Economic

Perspectives, 11(1), 127-149.

Grädel, E. (1990). Domino games and complexity. SIAM Journal on Computing, 19(5), 787-804.

Hoivik, J. (2011, October). Make IT a Game: Educational Virtualization of Imprinted Cultural

Heritage. In E-Learn: World Conference on E-Learning in Corporate, Government,

Healthcare, and Higher Education (pp. 204-208). Association for the Advancement of

Computing in Education (AACE).

Krisnadi, D., & Lukas, S. (2016, October). Saboteur game modeling using means-ends analysis.

In 2016 International Conference on Informatics and Computing (ICIC) (pp. 319-324).

IEEE.

Krisnadi, D., Lukas, S., Logan, L. D., Bachtiar, N. F., & Lohanda, L. A. (2019, October).

Decision System Modelling for" Saboteur" using Heuristics and Means-Ends Analysis.
 31

In Proceedings of the 2019 3rd International Conference on Advances in Artificial

Intelligence (pp. 178-182).

Strode, A. A Board Game As A Teaching Tool In A Pedagogically Psychological Perspective.

Wachs, J., & Vedres, B. (2021). Does Crowdfunding Foster Innovation? Evidence from the

Board Game Industry. arXiv preprint arXiv:2101.02683.

Wijaya, V. D. (2019). Perancangaan Visual dan Aset Board Game dengan Tema Berhemat

Berjudul MARIMAT (Doctoral dissertation, Universitas Multimedia Nusantara).

 32

8.0 APPENDICES

Here you can find our code, as well as some results and an executable. The variables used in

the executable are: Saboteurs begin undercover and may reveal themselves throughout the game;

depth two beliefs are used, and the negative shift intensity is set to 5.

Keep in mind that this decision-maker may be the true Saboteur!

As a result, it's past time to investigate the root of the project's failure. Leave the apparent

excuses (insufficient budget, insufficient resources) at the door and focus on the human interest.

It would result in fresh perspectives and a promising future.