\chapter{Introduction}
% \chapter{Introducere}
\label{cap:Introducere}
This paper describes the making of a game engine, a piece of software that is the base of represents the base of a video game, where changes are seen in real time, without restart, and that is thought to be componential from start, in order to reuse as much as possible and to make the base engine easy to understand. The main reason that a new game engine is needed and the old ones cannot be used for this is the fact that they offer limited support for plugins, or they cannot do as much as they should.

\section{Context}

The video game industry has been in a continuous growth, thus the need for software tools that can speed up the production of games. Currently on average games take from one to three years to complete.

The video game industry employs a wide range of people, such as:visual artists, sound artists, motion capture models, programmers, and testers. There are also different higher roles, such as manager, gameplay director, story writer, director, which need to have a bigger picture of the game.
Currently, much of the big companies have their own tools for the different needs of every employee, and usually they integrate well. The main problem, however, is the updating of the video game, which is reinstalling the game or downloading some extra assets for it, at some times. This can be challenging, especially when changes are made very often, and people need to stay in sync and know at all times what features does the game have and how does it play like.

\section{Motivation}
% \section{Motivație}
The motivation of the game engine is given by the limitations of the current techniques. That is, the delay in the update from programmers to testers/artists/managers.
The game engine is useful in the case of development phase as well as production phase.
\subsection{Development Phase}
For this, the engine reduces the time needed for the programming team to give the binaries, that is the compiled game, to the rest of the team and as well to transfer it to the testing machines. In this way, the testing machines don't need to compile anything, and can run tests continuously.
\subsection{Production Phase}
In production, the game engine can update itself while running, thus not needing to restart the game. This is useful for the user, because the game can update itself with the user not even noticing, maybe fixing bugs or adding content. In case of content adding, a notification can be added to the game to inform the user of the changes.
\section{Proposed Method}
% \section{Metoda abordată / propusă}
The proposed method saves the current state of the game, updates the classes that changes, which should be thought of as components and then reloads it's old state. In this way, the game continues to work normally, with a small reload, depending on the size of the change. If the change involves all the files in the game, then it would seem like a full game restart. If not, and that is what usually happens, the change will be of only a small amount of objects, and the delay unnoticeable, that is, if the software architecture is decoupled enough.

\section{Report's Structure}
% \section{Structura lucrării}
Chapter~\ref{cap:obiective-specificatii} presents the main objectives that the project tries to solve, which include the real time code recompiling, the componential architecture and the cross platform feature of the game engine.

Chapter~\ref{cap:studiu-bibliografic} enumerates and presents the bibliographic study that was done on this area, which include current state of the art methods that are in the same domain or are related to the described method.

Chapter~\ref{cap:fund-teoretice} presents theoretical background needed to understand about the basics of a game engine and what should one include. This chapter also describes the basics of a componential architecture and just in time compilation.

Chapter~\ref{cap:analiza-si-proiectare} presents the project in detail and how it works. It does not offer a specific implementation, only a guideline of how it was thought of before it was implemented.

Chapter~\ref{cap:implementare} presents actual technologies used and explains in detail specifics about the implementation of the project.

Chapter~\ref{cap:rezultate} presents how the project was compared and tested against other existing game engines. It also explains how the system was evaluated.

Chapter~\ref{cap:user-manual} presents the steps needed to install the game engine, create a simple game using it, as well as extending the functionalities of the game engine by creating plugins for it.

Chapter~\ref{cap:concluzii} summarizes the contributions and presents possible continuations.