What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

CryENGINE Game Programming with C++, C#, and Lua

Chapter 1. Introduction and Setup

CryENGINE is known as one of the most extensible engines available due to its ability to portray a vast variety of impressive visuals and gameplay. This makes it an invaluable tool at the hand of a programmer, where the only limit is one's creativity.

In this chapter, we will cover the following topics:

Installing Visual Studio Express 2012 for Windows Desktop
Downloading the CryENGINE sample installation or using a custom engine install
Registering an account at http://www.crydev.net, the official CryENGINE development portal
Compiling a stripped-down CryGame library
Attaching and utilizing the debugger

Using a custom or newer CryENGINE installation

This section helps out the readers who choose to use custom or newer builds of the engine. If you are unsure of this process, we recommend reading the Downloading the book's CryENGINE sample installation section in this chapter.

Verifying that the build is functional

Before starting, you should verify that your version of CryENGINE is functional so that you can use it for running and creating code based on this book's chapters.

Note

Note that if you are using an older or newer version of the engine, certain chapters may provide examples and information on changed systems. Keep this in mind, and refer to the sample mentioned previously for the optimal learning experience.

A good way to check this is by starting the Editor and Launcher applications and checking whether the engine behaves as expected.

Integrating CryMono (C# support)

If you're interested in using the sample code and chapter contents written with C# in mind, you'll need to integrate the third-party CryMono plugin into your CryENGINE installation.

Note

Note that CryMono is integrated by default in the sample we created specifically for this book.

To begin integrating CryMono, open the Code folder present in the engine root folder. We'll be placing the source files here, inside a subfolder called CryMono/.

To download the source code, visit https://github.com/inkdev/CryMono and click on Download Zip (or Clone in Desktop if you prefer using your Git revision control client).

Once downloaded, copy the contents into the Code/CryMono folder we mentioned earlier. If the folder does not exist, create it first.

When the files have been successfully moved, your folder structure should look similar to this:

Compiling the CryMono project

Now that we have the CryMono source code, we'll need to compile it.

To start, open Code/CryMono/Solutions/CryMono.sln using Visual Studio.

Note

Make sure to use CryMono.sln and not CryMono Full.sln. The latter is only used when you need to rebuild the entire Mono runtime, which ships precompiled with the CryMono repository.

Before we compile, we'll need to modify the engine's SSystemGlobalEnvironment struct (this is exposed using the global gEnv pointer).

To do so, open ISystem.h in the Code/CryEngine/CryCommon/ folder. Find the struct's definition by searching for the struct SSystemGlobalEnvironment.

Then add the following code to the very end of the struct's members and functions:

struct IMonoScriptSystem*
  pMonoScriptSystem;

Note

Modifying interfaces is not recommended if you do not have full engine source, as other engine modules have been compiled with the default interfaces in mind. However, appending to the end of this struct is mostly harmless.

Once done, open up the instance of Visual Studio where you opened CryMono.sln and start compiling.

Note

The automated post-build step in the project should automatically move the compiled files to your build's Bin32 folder following a successful compilation pass.

To verify that CryMono was compiled successfully, search for CryMono.dll in your Bin32 folder.

Loading and initializing CryMono via the CryGame.dll library

Now that we have the CryMono binaries present in our Bin32 folder, we'll just have to load it during game startup. This is done via the CryGame project, via the CGameStartup class.

To start, open your CryEngine or CryGame solution file (.sln) present in Code/Solutions/.

Including the CryMono interface folder

Before we modify the game startup code, we'll need to tell the compiler where to find the CryMono interfaces.

Start by right-clicking on the CryGame project in Visual Studio's Solution Explorer and select Properties. This should bring up the following CryGame Property Pages window:

Now, click on C/C++ and select General. This will bring up a screen of general compiler settings, which we'll use to add an additional include folder as shown in the following screenshot:

Now all we have to do is add ..\..\CryMono\MonoDll\Headers to the Additional Include Directories menu. This will tell the compiler to search CryMono's Headers folder when the #include macro is used, allowing us to find the CryMono C++ interfaces.

Initializing CryMono at start up

Open GameStartup.h in the CryGame project and add the following to the bottom of the class declaration:

static HMODULE
m_cryMonoDll;

Then open GameStartup.cpp and add the following before the CGameStartup constructor:

HMODULE CGameStartup::m_cryMonoDll = 0;

Now navigate to the CGameStartup destructor and add the following code:

if(m_cryMonoDll)
{
  CryFreeLibrary(m_cryMonoDll);
  m_cryMonoDll = 0;
}

Now navigate to the CGameStartup::Init function declaration, and add the following prior to the REGISTER_COMMAND("g_loadMod", RequestLoadMod,VF_NULL,""); snippet:

m_cryMonoDll = CryLoadLibrary("CryMono.dll");
if(!m_cryMonoDll)
{
  CryFatalError("Could not locate CryMono DLL! %i", GetLastError());
  return false;
}

auto InitMonoFunc = (IMonoScriptSystem::TEntryFunction)CryGetProcAddress(m_cryMonoDll, "InitCryMono");
if(!InitMonoFunc)
{
  CryFatalError("Specified CryMono DLL is not valid!");
  return false;
}

InitMonoFunc(gEnv->pSystem, m_pFramework);

Now all we have to do is compile CryGame in order to have CryMono loaded and initialized at startup.

Registering flow nodes

Due to a recent change in the flow system, flow nodes have to be registered at a certain point during game startup. To make sure that our C# nodes are registered, we'll need to call IMonoScriptSysetm::RegisterFlownodes from IGame::RegisterGameFlowNodes.

To do this, open Game.cpp and add the following inside the CGame::RegisterGameFlowNodes function:

GetMonoScriptSystem()->RegisterFlownodes();

Now, after compiling, all managed flow nodes should appear in the Flowgraph Editor.

Running the sample application

Before we get started with building the game project, we'll go through the basics of the default CryENGINE applications.

Note

All executables are contained inside either the Bin32 or Bin64 folders, depending on the build architecture. However, our sample only includes a Bin32 folder to keep things simple and the build repository small in size.

Editor

This is the main application that developers will use. The Editor serves as the direct interface to the engine, used for all kinds of developer-specific tasks such as level design and character setup.

The Editor supports WYSIWYP (What You See Is What You Play) functionality, which allows developers to preview the game by hitting the shortcut Ctrl + G, or by navigating to the Game menu, and choosing Switch to Game.

Starting the Editor

Open the main sample folder, and navigate to the Bin32 folder. Once there, start Editor.exe.

When the Editor has finished loading, you will be greeted by the Sandbox interface, which can be used to create most visual aspects of the game (excluding models and textures).

To create a new level, open the File menu, and select the New option. This should present you with the New Level message box. Simply specify your level name and click on OK, and the Editor will create and load your empty level.

To load an existing level, open the File menu, and select the Open option. This presents you with the Open Level message box. Select your level and click on Open to have your level loaded.

Launcher

This is the application seen by the end user. Upon startup, the Launcher displays the game's main menu, along with different options allowing users to load levels and configure the game.

The Launcher's game context is commonly referred to as Pure game mode.

Starting the Launcher

Open the main sample folder, and navigate into the Bin32 folder. Once there, start Launcher.exe.

When you've started the application, you'll be greeted with the default main menu. This interface allows the user to load levels and alter game settings such as visuals and controls.

The Launcher is preferable over the Editor when you want to play the game as the end user would. Another benefit is the quick startup time.

Dedicated server

The dedicated server is used to start up a multiplayer server for other clients to connect to. The dedicated server does not initialize a renderer, and instead functions as a console application.

Compiling the CryGame project (C++)

The CryENGINE Free SDK ships with complete source access to the game logic library, CryGame.dll. This dynamic library is responsible for the main part of game features, as well as the initial game startup process.

Note

A library is a collection of existing classes and functions that can be integrated into other projects. In Windows, the most common form of library is a Dynamic Link Library , or DLL , which uses the .dll file extension.

To start off, open the main sample folder, and navigate to Code/Solutions/, in which a Visual Studio solution file named CE Game Programming Sample.sln should be present. Double-click on the file and Visual Studio should start up, displaying the included projects (see the following breakdown).

Note

A solution is a structure for organizing projects in Visual Studio. The solution contains information on projects in a text-based .sln file, as well as a .suo file (user-specific options).

To build the project, simply press F7 or right-click on the CryGame project in the Solution Explorer and select Build.

What just happened?

You just compiled CryGame.dll, which should now be present in the binary folder. (Bin32 for 32-bit compilation, Bin64 for 64-bit). Launching the sample application will now load the .dll file containing the source code you compiled.

The CE Game Programming Sample solution breakdown

The solution includes the following three projects, one of which compiles to a .dll file.

CryGame

The CryGame project includes the underlying game logic used by the engine. This compiles to CryGame.dll.

CryAction

The CryAction project includes partial source to CryAction.dll, which is responsible for a large number of systems, such as actors, UI Graphs, and game objects. This project does not compile to a .dll file, but is instead only used for interface access.

CryCommon

The CryCommon project is a helper containing all shared CryENGINE interfaces. If there is a subsystem you want access to, look for its exposed interface in here.

The CryENGINE folder structure

See the following table for an explanation of the CryENGINE folder structure:

Folder name	Description
`Bin32`	Contains all 32-bit executables and libraries used by the engine.
`Bin64`	Contains all 64-bit executables and libraries used by the engine.
`Editor`	Editor configuration folder, contains common editor helpers, styles, and more.
`Engine`	Used as a central folder for assets used by the engine itself, not any particular game. Shaders and configuration files are stored here.
`Game`	Each game contains a game folder, which includes all its assets, scripts, levels, and so on. Does not have to be named "Game", but is dependent on the value of the `sys_game_folder` console variable.
`Localization`	Contains localization assets such as localized sounds and text for each language.

PAK files

The engine ships with the CryPak module, allowing for the storage of game content files in compressed or uncompressed archives. The archives use the .pak file extension.

When game content is requested, the CryPak system will query through all found .pak files in order to find the file.

File query priority

The PAK system prioritizes the files found in the loose folder structure over those in PAK, except when the engine was compiled in RELEASE mode. When that is the case, the file stored in a PAK system is preferred over the loose one.

If the file exists in multiple .pak archives, the one with the most recent filesystem creation date is used.

Attaching the debugger

Visual Studio allows you to attach the Debugger to your application. This allows you to use functionalities such as breakpoints; letting you stop at a specific line in your C++ source code, and step through the program execution.

To start debugging, open CE Game Programming Sample.sln and press F5, or click on the green play icon on the Visual Studio toolbar. If a No debug symbols could be found for Editor.exe message box appears, simply click on OK.

What just happened?

The CryENGINE Sandbox editor should now have started, with the Visual Studio Debugger attached. We can now place breakpoints in code, and watch program execution pause when that specific line of code is executed.

Key benefits

Dive into the various CryENGINE subsystems to quickly learn how to master the engine

Create your very own game using C++, C#, or Lua in CryENGINE

Understand the structure and design of the engine

Description

CryENGINE is a complete 3D game development solution that can run on multiple platforms. It is orientated around giving intuitive tools to the developer. A variety of interactive video games can be created using CryENGINE. CryENGINE is one of the most beginner-friendly engines out there to learn. If you are interested in diving into the various systems and understanding their workings in a way that is easily understood, then this book is for you. This book provides you with the knowledge to tame the powerful but hard-to-master CryENGINE. CryENGINE Game Programming with C++, C#, and Lua dives into the various systems and explains their workings in a way that can be easily understood by developers of all levels. It provides knowledge on the engine along with step-by-step exercises and detailed information on the backend implementation of the subsystems, giving you an excellent foundation to build upon when developing your own CryENGINE games. Written by developers with years of CryENGINE experience, this book breaks down the common confusion that encompasses the CryENGINE engine code, guiding you through a series of chapters aimed towards giving you the ability to create your own games in a rapid yet productive fashion. You will learn everything you need to know in order to create your own CryENGINE-powered games as well as detailed information on how to use the engine to your advantage. By teaching systems such as audio, particle effects, rendering, AI, networking, and more, we'll be exposing the most inner parts of CryENGINE that commonly confuse programmers. If you want to quickly gain the knowledge required to create your own CryENGINE game title, then this book is for you.

What you will learn

Make and modify Flowgraph nodes to give your visual scripting a clear advantage

Utilize custom entities, from simple physicalized objects to complex weather simulation managers

Control the flow of the game in real-time by creating game rules and modes

Create custom actors, in order to create unique elements controllable by human players

Use the Artificial Intelligence system to your advantage with custom AI units

Design custom User Interfaces to give your player a way to navigate the game s menus and HUDs

Implement multiplayer and networking elements for your game, allowing several players to share the experience with each other

Master game physics and how to create your own physicalized objects that can interact with the game world

Understand the process of using and manipulating the CryENGINE renderer to your advantage, including custom shader authoring

Bring your game to life by introducing effects such as particles and sound

Debug and profile your game code to get the most out of the computers running your game

Implement stock GameDll systems such as vehicles and weapons

What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

CryENGINE Game Programming with C++, C#, and Lua

NZ$71.99

CryENGINE 3 Game Development: Beginner's Guide

NZ$80.99

NZ$80.99

Total NZ$ 233.97

Filter reviews by

All

Amazon verified reviews

Evgeny Adamenkov Mar 09, 2016

As of today, this is the only book about CryEngine that is useful for programmers, rather than designers.

Amazon Verified review

Ross Rothenstine Feb 05, 2014

Having been a part of the CryDev community for a while, using the SDK and tools for personal and college projects, I can safely say this book would have help me out a lot when I first started.The book covers the portions of programming needed to get a game up and running. Entities, Flow Nodes, Actors, Game Rules, and UI development to say a few portions.While the book is aimed at novices to CryEngine, I would recommend a C++ background before picking up this book.

Brian Feb 28, 2014

Very informative, and helps you get into the nitty gritty of the engine.It goes into enough detail to understand how the engine handles everything. With the help of this book I was able to enter a competition for getting an art asset in the game engine. I got into the finals, which is awesome.I would highly recommend the book.

Nick Feb 07, 2014

Both authors, Filip Lundgren (developer for CryMono) and Ruan Pearce-Authers (currently working for Crytek GmbH), have a strong background in working with CryEngine. The book gives a lot of insight into the programming side of the engine, which is mostly missing from the documentation; it’s a great reference for using CryEngine’s subsystems from a programmer’s point of view.The content itself is based on CryEngine 3.5.4, which is one of the latest iterations as of February 2014. There’s also a companion project which is already set up to use CryMono and includes all the code written throughout the chapters. I had some issues running it out of the box but seasoned programmers will have no trouble tackling those problems.The book starts by explaining the building blocks for making your game – how to script your game visually using CryEngine’s flowgraph system and how to create your own custom flow-nodes. It then expands on customizing the entities and game rules in your application. Halfway through the book you’ll already know how to create your level, spawn your actors, control the player camera and add triggers that execute the game logic. This is done in a “learn by example” fashion, which is my personal favorite, especially when the examples are clear and concise as is the case.The second half of the book is dedicated to the major subsystems in the engine – Artificial Intelligence, User Interface, Networking, Physics, Graphics and Sound. At just shy of 300 pages, you can’t expect to gain in-depth knowledge of every little detail in those subsystems from reading the book, but it does give you a comprehensive overview that will get you started. One thing that I did not like was that instead of the example driven style used so far, the book becomes more of a reference in this part, with only one practical example for all the subsystems (namely, “Dynamic alpha testing for vegetation”). The subsystems part of the book does give you a lot of useful information summed up, but I feel that having a few samples would add more value.The last chapter is dedicated to debugging and profiling, covering common ways of detecting and fixing problems in CryEngine.Overall, it’s a great resource for both beginners and intermediate users of CryEngine, although advanced knowledge in general programming is required to understand what’s going on under the hood. That’s why I wouldn't recommend it for novice programmers as they will probably be left frustrated. If you have coding experience and you’re a newcomer to CryEngine who doesn't want to spend hours and hours looking for information, then this book is for you. If you’re already into CryEngine and you find yourself lacking a concise guide for its subsystems it’s worth the read as well.

Tim Jan 26, 2014

Overall, this book is a fount of knowledge regarding programming for CryEngine. The authors examples are both functional and useful. However, this book is clearly for people that have an intermediate coding knowledge. Additionally, it is incredibly helpful to have a working knowledge of the CryEngine SDK before starting this book. I will wholeheartedly admit that my personal knowledge of CryEngine is not the best and that did cause me a few issues in understanding certain things being discussed. If anyone is looking at this book to teach them CryEngine from scratch, there are much better references out there for the complete beginner.There are many subjects, particularly the C++ portions of the book, that help to explain things where the online documentation for the CryEngine SDK is lacking. As such, this book is going to go into my reference library and without a doubt get filled bookmarks and plenty of notes. Though it is impossible to fit all the knowledge of CryEngine into a single volume, this book definitely points the reader in the right direction regarding a good amount of subsystems that CryEngine has to offer a developer. Additionally, the discussion of C# and Lua on top of C++ really shows the freedom that CryEngine can give you.There are some minor issues with some of code that is in the book, but as I said before, familiarity with programming is a must and that knowledge will lead you to easily track down those problems. Formatting of code in ebooks always seems to leave a bit to be desired and there were occasions that I had to look at the code multiple times to get everything right.As I mentioned previously, I would only recommend this book to people with a working knowledge of both CryEngine and generally programming. It is well worth the read for those that need to expand an already existing knowledge base of the game engine.

CryENGINE Game Programming with C++, C#, and Lua: For developers wanting to create 3D games, CryENGINE offers the intuitive route to success and this book is the complete guide to using it. Learn to use sophisticated tools and build super-real, super-addictive games.

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Compiling the CryMono project

Loading and initializing CryMono via the CryGame.dll library

Including the CryMono interface folder

Initializing CryMono at start up

Registering flow nodes

Starting the Editor

Starting the Launcher

CryGame

CryAction

CryCommon

File query priority

Attaching the debugger

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs