Experience as a Product

Examples

The Historic Method

The Ultimate Dangers of This

The Series

• Introduction
• Particle Container 1 - problems (this post)
• Particle Container 2 - implementation
• Generators & Emitters
• Updaters
• Renderer
• Tools Optimizations
• SIMD Optimizations
• Renderer Optimizations

Introduction

class Particle {
public:
    bool m_alive;
    Vec4d m_pos;
    Vec4d m_col;
    float time;
    // ... other fields
public:
    // ctors...

    void update(float deltaTime);
    void render();
};

std::vector<particle> particles;

// update function:
for (auto &p : particles)
    p.update(dt);

// rendering code:
for (auto &p : particles)
    p.render();    

1. Are we OK with SRP principle here?
2. What if we would like to add one field to the particle? Or have one particle system with pos/col and other with pos/col/rotations/size? Is our structure capable of such configuration?
3. What if we would like to implement a new update method? Should we implement it in some derived class?
4. Is the code efficient?

My answers:

1. It looks like SRP is violated here. The Particle class is responsible not only for holding the data but also performs updates, generations and rendering. Maybe it would be better to have one configurable class for storing the data, some other systems/modules for its update and another for rendering? I think that this option is much better designed.
2. Having the Particle class built that way we are blocked from the possibility to add new properties dynamically. The problem is that we use here an AoS (Array of Structs) pattern rather than SoA (Structure of Arrays). In SoA when you want to have one more particle property you simply create/add a new array.
3. As I mentioned in the first point: we are violating SRP so it is better to have a separate system for updates and rendering. For simple particle systems our original solution will work, but when you want some modularity/flexibility/usability then it will not be good.
4. There are at least three performance issues with the design:
   1. AoS pattern might hurt performance.
   2. In the update code for each particle we have not only the computation code, but also a (virtual) function call. We will not see almost any difference for 100 particles, but when we aim for 100k or more it will be visible for sure.
   3. The same problem goes for rendering. We cannot render each particle on its own, we need to batch them in a vertex buffer and make as few draw calls as possible.

Add/Remove Particles

void kill(particleID) { ?? }
void wake(particleID) { ?? }

First thing: Particle Pool

Second thing: Management

• Use an alive flag and in the for loop update/render only active particles.
  • this unfortunately causes another problem with rendering because there we need to have a continuous buffer of things to render. We cannot easily check if a particle is alive or not. To solve this we could, for instance, create another buffer and copy alive particles to it every time before rendering.
• Dynamically move killed particles to the end so that the front of the buffer contains only alive particles.

• When we update particles there is no need to check if it is alive. We update only the front of the buffer.
• No need to copy only alive particles to some other buffer

What's Next

Links

• Coding: AoS & SoA Explorations Part 1, Part 2 and Part 3 and Four

Level 0: Pedestrians and The City

Level 1: NPCs and The Cloud

Level 2: Characters and the Director

The Story Game

Conclusion

Article Update Log

Video Game Community Management

Advocates

Retention

• The Battlefield series which even won a social strategy award
• World of WarCraft
• League of Legends - which I think has one of the largest social platform communities ever?

Feedback

So What Does Investment Look Like?

• What's your offering? (example; share in-game rewards with any users who join your social platforms)
• Offer unique interesting content for your users - (League of Legends posts cartoons every Sunday. They understand their demographic enough to know comics are a perfect fit)
• Promise real-time news updates on important game information. This is so important! Your users should be coming to you for updates on your game.
• Having interesting contests run through your social platforms! Be creative - it's not hard (if it is for you, ask me and we'll come up with something)
• Is your game complex? Consider building and promoting a forum which allows for topic specific discussion.
• Development blogs help a community know how a game is changing and that it is continually being improved.

The Paradigm Shift

Media Influence

Sexism

Working Conditions

Conclusion

What I Learned from Bain's Redemption

Reactive or Proactive?

Indicators, Indicators, Indicators...

Balancing The Game

Conclusion

Bain's Redemption

Article Update Log

Article Update Log

Abstract

The Problem

// 
// Listing 1:
// ServiceContext.h
#pragma once

// Dependencies
class Game;
class World;
class RenderService;
class ResourceService; 
class PathfindingService;
class PhysicsService;
class LogService;

// ServiceContext
// Provides access to a variety of objects
class ServiceContext {
public:
	Game* const game;
	World* const world;
	RenderService* const render;
	PathfindingService* const path;
	PhysicsService* const physics;
	AudioService* const audio;
	LogService* const log;
};

//
// Listing 2:
// Foobar.cpp

#include "Foobar.h"
#include "ServiceContext.h"
#include "PathService.h"
#include "LogService.h"


void Foobar::frobnicate( ServiceContext& ctx ) {
	if ( !condition() )
		return;
	
	current_path = ctx.path->evaluate(position, target->position);
	if ( !current_path )
		ctx->log("Warning","No path found!");
}

Figure 1: Recompilations needed when adding a service to the provider object

The Solution

// 
// Listing 3:
// ServiceContext.h
#pragma once

// Dependencies
struct ServiceContextImpl;

// ServiceContext
// Provides access to a variety of objects
class ServiceContext {
public: // Constructors
	ServiceContext( ServiceContextImpl& p );

public: // Methods
	template<typename T>
	T* get() const;

private: // Members
	ServiceContextImpl& impl;
};


//
//  ServiceContextImpl.h
#pragma once

// Dependencies
class Game;
class World;
class RenderService;
class ResourceService; 
class PathfindingService;
class PhysicsService;
class LogService;

// ServiceContextImpl
// Exposes the objects to ServiceContext
// Be sure to update ServiceContext.cpp whenever this definition changes!
struct ServiceContextImpl {
	Game* const game;
	World* const world;
	RenderService* const render;
	PathfindingService* const path;
	PhysicsService* const physics;
	AudioService* const audio;
	LogService* const log;
};

//
// Listing 4:
// ServiceContext.cpp

#include "ServiceContext.h"
#include "ServiceContextImpl.h"

ServiceContext::ServiceContext( ServiceContextImpl& p ) : impl(p) {
}

// Expose impl by providuing the specializations for ServiceContext::get
template<> 
Game* ServiceContext::get<Game>() { 
	return impl.game; 
}

// ... or use a macro
#define SERVICECONTEXT_GET( type, name )	\
	template<> \
	type* ServiceContext::get<type>() const { \
		return impl.name; \
	}

SERVICECONTEXT_GET( World, world );
SERVICECONTEXT_GET( RenderService, render );
SERVICECONTEXT_GET( PathfindingService, path );
SERVICECONTEXT_GET( PhysicsService, physics );
SERVICECONTEXT_GET( AudioService, audio );
SERVICECONTEXT_GET( LogService, log );

//
// Listing 5:
// Foobar.cpp
#pragma once

#include "Foobar.h"
#include "ServiceContext.h"
#include "PathService.h"
#include "LogService.h"


void Foobar::frobnicate( ServiceContext& ctx ) {
	if ( !condition() )
		return;
	
	current_path = ctx.get<PathService>()->evaluate(position, target->position);
	if ( !current_path )
		ctx.get<LogService>()->log("Warning","No path found!");
}

Figure 2: Adding new services to ServiceContextImpl now has minimal impact on ServiceContext's dependants

The Caveats

1. The solution hinges on the linker's support for "whole program optimization" and can inline the ServiceContext's get definitions at link-time. If this optimization is supported, then there is no additional cost to using this solution over the traditional approach. MSVC and GCC have support for this optimization.
2. It is assumed that ServiceContext is changed often during development, though usually during early development. It can be argued that such a complicated system is not needed after a few iterations of ServiceContext.
3. It is assumed that the compiling time greatly outweighs linking time. This solution may not be appropriate for larger projects.
4. The solution favors cleverness over readability. There is a increase in complexity with such a solution, and it could be argued that the complexity is not worth the marginal savings in compiling time. This solution may not be appropriate if the project has multiple developers.
5. The solution does not offer any advantage in Unity builds.

Conclusion

Article Update Log

Gameplay

Setting up the scene

1. The character group of objects (from the character_model.blend file).
2. The environment group of objects (from the main_scene.blend file) - this group contains the static scene models and also their copies with the collision materials.
3. The baked animations character_idle_01_B4W_BAKED and character_run_B4W_BAKED (from the character_animation.blend file).

NOTE:
To link components from another file go to File -> Link and select the file. Then go to the corresponding datablock and select the components you wish. You can link anything you want - from a single animation to a whole scene.

Preparing the necessary files

1. The engine b4w.min.js
2. The addon for the engine app.js
3. The physics engine uranium.js

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <script type="text/javascript" src="b4w.min.js"></script>
    <script type="text/javascript" src="app.js"></script>
    <script type="text/javascript" src="game_example.js"></script>

    <style>
        body {
            margin: 0;
            padding: 0;
        }
    </style>

</head>
<body>
<div id="canvas3d"></div>
<body>
</html>

"use strict"

if (b4w.module_check("game_example_main"))
    throw "Failed to register module: game_example_main";

b4w.register("game_example_main", function(exports, require) {

var m_anim  = require("animation");
var m_app   = require("app");
var m_main  = require("main");
var m_data  = require("data");
var m_ctl   = require("controls");
var m_phy   = require("physics");
var m_cons  = require("constraints");
var m_scs   = require("scenes");
var m_trans = require("transform");
var m_cfg   = require("config");

var _character;
var _character_body;

var ROT_SPEED = 1.5;
var CAMERA_OFFSET = new Float32Array([0, 1.5, -4]);

exports.init = function() {
    m_app.init({
        canvas_container_id: "canvas3d",
        callback: init_cb,
        physics_enabled: true,
        alpha: false,
        physics_uranium_path: "uranium.js"
    });
}

function init_cb(canvas_elem, success) {

    if (!success) {
        console.log("b4w init failure");
        return;
    }

    m_app.enable_controls(canvas_elem);

    window.onresize = on_resize;
    on_resize();
    load();
}

function on_resize() {
    var w = window.innerWidth;
    var h = window.innerHeight;
    m_main.resize(w, h);
};

function load() {
    m_data.load("game_example.json", load_cb);
}

function load_cb(root) {

}

});

b4w.require("game_example_main").init();

Moving the character

function load_cb(root) {
    _character = m_scs.get_first_character();
    _character_body = m_scs.get_object_by_empty_name("character",
                                                     "character_body");

    setup_movement();
    setup_rotation();
    setup_jumping();

    m_anim.apply(_character_body, "character_idle_01");
    m_anim.play(_character_body);
    m_anim.set_behavior(_character_body, m_anim.AB_CYCLIC);
}

• animation.apply() - sets up animation by corresponding name,
• animation.play() - plays it back,
• animation.set_behaviour() - change animation behavior, in our case makes it cyclic.

NOTE:
Please note that skeletal animation should be applied to the character object which has an Armature modifier set up in Blender for it.

NOTE:
You can check out all the possible sensors in the corresponding section of the API documentation.

function setup_movement() {
    var key_w     = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
    var key_s     = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
    var key_up    = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
    var key_down  = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);

    var move_array = [
        key_w, key_up,
        key_s, key_down
    ];

    var forward_logic  = function(s){return (s[0] || s[1])};
    var backward_logic = function(s){return (s[2] || s[3])};

    function move_cb(obj, id, pulse) {
        if (pulse == 1) {
            switch(id) {
            case "FORWARD":
                var move_dir = 1;
                m_anim.apply(_character_body, "character_run");
                break;
            case "BACKWARD":
                var move_dir = -1;
                m_anim.apply(_character_body, "character_run");
                break;
            }
        } else {
            var move_dir = 0;
            m_anim.apply(_character_body, "character_idle_01");
        }

        m_phy.set_character_move_dir(obj, move_dir, 0);

        m_anim.play(_character_body);
        m_anim.set_behavior(_character_body, m_anim.AB_CYCLIC);
    };

    m_ctl.create_sensor_manifold(_character, "FORWARD", m_ctl.CT_TRIGGER,
        move_array, forward_logic, move_cb);
    m_ctl.create_sensor_manifold(_character, "BACKWARD", m_ctl.CT_TRIGGER,
        move_array, backward_logic, move_cb);
}

function(s) { return (s[0] || s[1]) }

m_phy.set_character_move_dir(obj, move_dir, 0);

Turning the character

function setup_rotation() {
    var key_a     = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
    var key_d     = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
    var key_left  = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
    var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);

    var elapsed_sensor = m_ctl.create_elapsed_sensor();

    var rotate_array = [
        key_a, key_left,
        key_d, key_right,
        elapsed_sensor
    ];

    var left_logic  = function(s){return (s[0] || s[1])};
    var right_logic = function(s){return (s[2] || s[3])};

    function rotate_cb(obj, id, pulse) {

        var elapsed = m_ctl.get_sensor_value(obj, "LEFT", 4);

        if (pulse == 1) {
            switch(id) {
            case "LEFT":
                m_phy.character_rotation_inc(obj, elapsed * ROT_SPEED, 0);
                break;
            case "RIGHT":
                m_phy.character_rotation_inc(obj, -elapsed * ROT_SPEED, 0);
                break;
            }
        }
    }

    m_ctl.create_sensor_manifold(_character, "LEFT", m_ctl.CT_CONTINUOUS,
        rotate_array, left_logic, rotate_cb);
    m_ctl.create_sensor_manifold(_character, "RIGHT", m_ctl.CT_CONTINUOUS,
        rotate_array, right_logic, rotate_cb);
}

m_phy.character_rotation_inc(obj, elapsed * ROT_SPEED, 0)

Character jumping

function setup_jumping() {
    var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);

    var jump_cb = function(obj, id, pulse) {
        if (pulse == 1) {
            m_phy.character_jump(obj);
        }
    }

    m_ctl.create_sensor_manifold(_character, "JUMP", m_ctl.CT_TRIGGER, 
        [key_space], function(s){return s[0]}, jump_cb);
}

m_phy.character_jump(obj)

Moving the camera

function setup_camera() {
    var camera = m_scs.get_active_camera();
    m_cons.append_semi_soft_cam(camera, _character, CAMERA_OFFSET);
}

The First Campaign

One of the main game posters

Demolition Lander screenshot for Kickstarter campaign

The end of previous paragraph separated from the beginning of the next one

Demolition Lander Kickstarter presentation

First campaign infographics: collected funds


First campaign infographics: video views

The Second Campaign

Screenshot

Second campaign infographics: collected funds


Second campaign infographics: video views

Results

New Welcome Screen

Placement Tools

Figure 1: The Select and Place tool lets you place the selected object by moving it over the surface of the other scene objects. Image courtesy of Autodesk

Working with Point Cloud Datasets

Quad Chamfer

Figure 2: The new Quad Chamfer settings results in smoother objects when applied to edges. Image courtesy of Autodesk

Using the ShaderFX Editor

Figure 3: Shaders created in the ShaderFX Editor can be viewed directly in the viewports. Image courtesy of Autodesk

Layer Explorer

Populate Improvements

Small Changes with Big Rewards

Figure 4: Enabling mental ray within an ActiveShade window lets you interact with the scene in real-time. Image courtesy of Autodesk

Summary

Article Update Log

Megabte Softworks OpenGL 3.3+ Tutorials

List of tutorials so far

Conclusion

Article Update Log

Concerns

Potential Abuse

Summary

Graphical content style

Location elements

• the character's action area: 5 platforms on which the main game action takes place;
• the background environment, the role of which will be performed by less-detailed ash-colored rocks;
• lava covering most of the scene surface.

1. env_stuff.blend - the file with the scene's environment elements which the character is going to move on;
2. character_model.blend - the file containing the character's geometry, materials and armature;
3. character_animation.blend - the file which has the character's group of objects and animation (including the baked one) linked to it;
4. main_scene.blend - the scene which has the environment elements from other files linked to it. It also contains the lava model, collision geometry and the lighting settings;
5. example2.blend - the main file, which has the scene elements and the character linked to it (in the future more game elements will be added here).

Making the geometry of the central islands

Note:  It's not recommended to apply modifiers (using the Apply button). Enable the Apply Modifiers checkbox in the object settings on the Blend4Web panel instead; as a result the modifiers will be applied to the geometry automatically on export.

Texturing the central islands

Creating the background rocks

Optimizing the location elements

Note:  The Texture Atlas addon can be activated in Blender's settings under the Addons tab (UV category)

Note:  It's not necessary to follow the same scale for all elements. It's recommended to allow more space for foreground elements (the islands).

Note:  In order to save video memory, the specular map was packed into the alpha channel of the diffuse texture. As a result we got only one file.

Setting up the material

Object settings

Physics

Conclusion

Initial concepts for a Feeding Time logo.

Even more logo concepts. They're important!

Our final logo.

Initial sketches for the app icon.

Final icon iterations for Feeding Time.

Our initial clerk was actually a babushka with some not-so-kindly variations.

People were quite appalled by the rapscallion animals when the clerk was played by a kindly grandma.

The clerk as he appears over two pause menus, a bonus game in which the player gets a low score, and a bonus game in which the player gets a high score.

The official Feeding Time website complete with our logo, title-screen stall and background, a happy clerk, and a bunch of dressed up animals.

Article Update Log

It All Starts with Spreadsheets

Depth 1 - 10 GS(gnome seconds)
Depth 2 - 21 GS (31 GS total)
Depth 5 - 61 GS (171 GS total)
Depth 10 - 155 GS (742 GS total)
Depth 20 - 505 GS (4000 GS total)

The Bones

angular.module('gnomoreHeroesApp', ['ngCookies'])
    .controller('GameController', ['$scope', '$interval', '$cookieStore', function ($scope, $interval, $cookieStore) {

        const UNAVAILABLE = 0;
        const AVAILABLE = 1;
        const COMPLETE = 2;

        $scope.gamedata =
        {
            gnomes: 2, space: 0, mushrooms: 0, stone: 0, underpants: 0, research: 0,
            miners: 0, farmers: 0, thieves: 0, researchers: 0, builders: 0,
            mining_points: 0, farming_points: 0, thieving_points: 0,
            totalGnomes: 2, totalSpace: 1, dug: 0.0, depth: 1, hardness: 1,
            minerBonus: 1, farmerBonus: 1, thiefBonus: 10, stoneBonus: 25, builderBonus: 1, researchBonus: 1,
            cost: 10.0,
            buildings: { huts: 0, houses: 0, houseVisible: false, houseResearched: false, villages: 0, villageVisible: false, villageResearched: false, towns: 0, townVisible: false, townResearched: false, cities: 0, cityVisible: false, castles: 0, castleVisible: false },
            researchStates: [{ id: 1, value: AVAILABLE }, { id: 2, value: AVAILABLE }, { id: 4, value: AVAILABLE }, { id: 5, value: AVAILABLE }]
        };
    }]);

angular.module('gnomoreHeroesApp', ['ngCookies'])
    .controller('GameController', ['$scope', '$interval', '$cookieStore', function ($scope, $interval, $cookieStore) {

$scope, which allows us to bind objects and methods in the controller to HTML view.
$interval, which lets us create methods that are triggered based on a timer.
$cookieStore, which lets us read and write cookie information.

$scope.buildings =
        {
            hut: { space: 1, mushrooms: 1, buildcost: 10, description: "A hollowed out mushroom." },
            house: { space: 0, mushrooms: 3, buildcost: 30, description: "A lovely two story mushroom house." },
            village: { space: 0, mushrooms: 30, stone: 10, buildcost: 300, description: "The first step in rebuilding the gnomish civilization." },
            town: { space: 0, mushrooms: 200, stone: 50, buildcost: 600, description: "A growing community." },
            city: { space: 0, mushrooms: 1000, stone: 100, buildcost: 900, description: "Only the best gnomes can afford to live here." },
            castle: { space: 2, mushrooms: 5000, stone: 500, buildcost: 6000, description: "Triumph of gnomish engineering." }
        };

The Body

<HTML ng-app="gnomoreHeroesApp">
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.0-beta.15/angular.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.0-beta.15/angular-cookies.min.js"></script>
  <script src="js/controller.js"></script>

<body ng-controller="GameController">

<div>
        <span><label>Gnomes:</label> {{gamedata.gnomes}}/{{gamedata.totalGnomes}}</span>
        <span><label>Free Space:</label> {{gamedata.space}}</span>
        <span><label>Mushrooms:</label> {{gamedata.mushrooms}}</span>
        <span><label>Stone:</label> {{gamedata.stone}}</span>
        <span><label>Underpants!!!:</label> {{gamedata.underpants}}</span>
        <span><label>Research:</label> {{gamedata.research}}</span>
        <span><label>Depth:</label> {{gamedata.depth}}</span>
    </div>

<span class="top-gap">{{miningRate()}}/sec</span>

$scope.miningRate = function () {
            return (($scope.gamedata.miners * $scope.gamedata.minerBonus) / ($scope.gamedata.cost * $scope.gamedata.depth * $scope.gamedata.hardness)).toFixed(3);
        }

<div class="research-list">
                <div class="research-item " ng-repeat="item in research" ng-click="buyResearch(item.id)"
                     ng-show="isResearchAvailable(item.id)" ng-class="{'buyable-true' : gamedata.research >= item.cost, 'buyable-false' : gamedata.research < item.cost}">
                    <label class="research-name">{{item.name}}</label>
                    <strong class="research-cost">{{item.cost}}</strong>
                    <br />
                    <em class="research-text">{{item.description}}</em>

                </div>
            </div>

The Guts

var timer = $interval(function () {
            var cost = $scope.gamedata.cost;
            $scope.gamedata.mining_points += $scope.gamedata.miners * $scope.gamedata.minerBonus;
            $scope.gamedata.farming_points += $scope.gamedata.farmers * $scope.gamedata.farmerBonus;
            $scope.gamedata.thieving_points += $scope.gamedata.thieves;
            $scope.gamedata.research += $scope.gamedata.researchers * $scope.gamedata.researchBonus;


            while ($scope.gamedata.mining_points >= cost * $scope.gamedata.hardness) {
                $scope.gamedata.dug++;
                $scope.gamedata.mining_points -= cost;
                if ($scope.gamedata.dug >= $scope.gamedata.depth) {
                    $scope.gamedata.space++;
                    $scope.gamedata.dug = 0;
                    $scope.gamedata.depth++;
                    $scope.gamedata.hardness *= 1.05;

                }

                var rnd = Math.floor((Math.random() * 100) + 1);

                if (rnd <= $scope.gamedata.stoneBonus) {
                    $scope.gamedata.stone++;
                }
            }

            while ($scope.gamedata.farming_points >= cost) {
                $scope.gamedata.farming_points -= cost;
                $scope.gamedata.mushrooms++;
            }


        }, 1000, 0);

$scope.$on('$destroy', function () {
            // Make sure that the interval nis destroyed too
            if (angular.isDefined(timer)) {
                $interval.cancel(timer);
                timer = undefined;
            }

            if (angular.isDefined(autoSaveTimer)) {
                $interval.cancel(autoSaveTimer);
                autoSaveTimer = undefined;
            }
        });

var autoSaveTimer = $interval(function () {
            $cookieStore.put('version', 1);
            $cookieStore.put('gamedata', $scope.gamedata);

        }, 60000, 0);

var init = function () {

            if($cookieStore.get('version')==1)
                {
                $scope.gamedata = $cookieStore.get('gamedata');
                }

        }

        init();

Conclusion

Article Update Log

Bifrost Simulation

Figure 1: Bifrost makes it possible to create amazing liquid effects.

XGen Particles

Figure 2: The XGen system is great for adding a variety of plants to the current scene.

Bullet Physics

ShaderFX Editor

Viewport Improvements

Figure 3: Viewport 2.0 supports particles and makes it easy to tweak effects to get the right look without having to render the scene. Image courtesy of Autodesk

Texture and Shrinkwrap Deformers

OpenSubDiv Support

Modeling Improvements

UV Updates

Figure 4: The Distortion shader quickly shows which UVs are stretched and compressed. Image courtesy of Autodesk

Character Skinning

Summary