# Arrays and Classes in Game Development Let's build understanding from the ground up, then get into real game code. --- ## Part 1: Arrays — The Foundation An array is a fixed-size, contiguous block of memory holding elements of the same type. In games you use them constantly: tile maps, inventory slots, particle pools, waypoints, spawn tables. ### C# (Unity) — Arrays ```csharp using UnityEngine; public class ArrayBasics : MonoBehaviour { // Serialized arrays show up in the Inspector — huge for designers [SerializeField] private Transform[] patrolPoints; [SerializeField] private GameObject[] enemyPrefabs; // Fixed-size allocation private float[] cooldowns = new float[4]; // Literal initialization private int[] damageTable = { 5, 10, 20, 45, 100 }; // 2D rectangular array — great for grids private int[,] tileMap = new int[16, 16]; // Jagged array — rows of different lengths private int[][] levelWaves; void Start() { levelWaves = new int[3][]; levelWaves[0] = new int[] { 1, 1, 2 }; levelWaves[1] = new int[] { 2, 3, 3, 4 }; levelWaves[2] = new int[] { 5 }; // Iteration for (int i = 0; i < damageTable.Length; i++) Debug.Log($"Level {i} damage: {damageTable[i]}"); foreach (Transform p in patrolPoints) Debug.Log(p.position); // 2D iteration for (int y = 0; y < tileMap.GetLength(1); y++) for (int x = 0; x < tileMap.GetLength(0); x++) tileMap[x, y] = 0; } } ``` **Key gotchas in Unity:** - `array.Length` is a property, not a method. - Arrays are **reference types** — passing one to a method passes the reference; mutations are visible to the caller. - `List` when size changes; `array` when size is fixed (less GC pressure, better cache locality). - Avoid `GetComponents()` or `FindObjectsOfType()` in `Update()` — they allocate a new array every call. ### C++ (Godot) — Arrays C++ gives you several flavors, and choosing correctly matters: ```cpp #include #include #include // 1. C-style array — raw, fixed size, no bounds info int damage_table[5] = { 5, 10, 20, 45, 100 }; int count = sizeof(damage_table) / sizeof(damage_table[0]); // clunky // 2. std::array — modern fixed-size, zero overhead, knows its size std::array damages = { 5, 10, 20, 45, 100 }; size_t n = damages.size(); // clean int d = damages.at(2); // bounds-checked int d2 = damages[2]; // unchecked, faster // 3. std::vector — dynamic size, heap allocated std::vector cooldowns; cooldowns.reserve(64); // pre-allocate: avoids reallocation cooldowns.push_back(1.5f); // 4. Godot's Vector — engine's internal COW array godot::PackedVector3Array points; // for passing to/from GDScript // 5. TypedArray — exposed to the editor/GDScript godot::TypedArray waypoints; ``` **2D grids in C++:** ```cpp // Fixed dimensions — stack allocated, fastest int tile_map[16][16]; // Preferred: flatten to 1D for cache locality class TileGrid { static constexpr int WIDTH = 64; static constexpr int HEIGHT = 64; std::vector tiles; public: TileGrid() : tiles(WIDTH * HEIGHT, 0) {} int get(int x, int y) const { return tiles[y * WIDTH + x]; } void set(int x, int y, int v) { tiles[y * WIDTH + x] = v; } }; ``` Flattening is what real engines do. A `vector>` scatters rows across the heap, causing cache misses on every row change. --- ## Part 2: Classes — Organizing Game Logic ### C# (Unity) — Classes Unity has two distinct class categories, and confusing them is the #1 beginner mistake. **A. MonoBehaviour — components attached to GameObjects** ```csharp using UnityEngine; public class Health : MonoBehaviour { [SerializeField] private int maxHealth = 100; private int current; public int Current => current; // read-only property public bool IsDead => current <= 0; public event System.Action OnChanged; // (current, max) public event System.Action OnDied; void Awake() => current = maxHealth; public void TakeDamage(int amount) { if (IsDead) return; current = Mathf.Max(0, current - amount); OnChanged?.Invoke(current, maxHealth); if (IsDead) OnDied?.Invoke(); } public void Heal(int amount) { if (IsDead) return; current = Mathf.Min(maxHealth, current + amount); OnChanged?.Invoke(current, maxHealth); } } ``` You never call `new Health()`. Unity instantiates it via `AddComponent()` or by attaching in the editor. **B. Plain C# classes — pure data and logic, no GameObject needed** ```csharp using System; using System.Collections.Generic; using UnityEngine; [Serializable] public class InventoryItem { public string id; public string displayName; public Sprite icon; public int stackSize = 1; public int maxStack = 99; public bool CanStackWith(InventoryItem other) => other != null && other.id == id && stackSize < maxStack; } public class Inventory { private readonly InventoryItem[] slots; public int Capacity => slots.Length; public Inventory(int capacity) { slots = new InventoryItem[capacity]; // all null initially } public InventoryItem this[int index] => slots[index]; // indexer public bool TryAdd(InventoryItem item) { // First pass: try to stack for (int i = 0; i < slots.Length; i++) { if (slots[i] != null && slots[i].CanStackWith(item)) { slots[i].stackSize++; return true; } } // Second pass: find empty slot for (int i = 0; i < slots.Length; i++) { if (slots[i] == null) { slots[i] = item; return true; } } return false; // full } public bool RemoveAt(int index) { if (index < 0 || index >= slots.Length || slots[index] == null) return false; if (--slots[index].stackSize <= 0) slots[index] = null; return true; } } ``` **C. Inheritance and polymorphism** ```csharp using UnityEngine; public abstract class Enemy : MonoBehaviour { [SerializeField] protected float moveSpeed = 3f; [SerializeField] protected int damage = 10; protected Transform player; protected virtual void Start() { player = GameObject.FindWithTag("Player").transform; } void Update() => Behave(); protected abstract void Behave(); // must be implemented protected virtual void OnDeath() // may be overridden { Destroy(gameObject); } } public class Chaser : Enemy { protected override void Behave() { Vector3 dir = (player.position - transform.position).normalized; transform.position += dir * moveSpeed * Time.deltaTime; } } public class Shooter : Enemy { [SerializeField] private GameObject bulletPrefab; [SerializeField] private float fireRate = 1f; private float nextShot; protected override void Behave() { if (Time.time < nextShot) return; nextShot = Time.time + 1f / fireRate; Instantiate(bulletPrefab, transform.position, Quaternion.identity); } protected override void OnDeath() { // Explode on death, then base cleanup base.OnDeath(); } } ``` **D. ScriptableObject — shared data assets (Unity's superpower)** ```csharp using UnityEngine; [CreateAssetMenu(fileName = "WeaponData", menuName = "Game/Weapon")] public class WeaponData : ScriptableObject { public string weaponName; public int damage = 10; public float fireRate = 5f; public float range = 50f; public AudioClip fireSound; public GameObject muzzleFlash; } public class Weapon : MonoBehaviour { [SerializeField] private WeaponData data; // drag asset in Inspector private float nextFire; public void TryFire() { if (Time.time < nextFire) return; nextFire = Time.time + 1f / data.fireRate; if (Physics.Raycast(transform.position, transform.forward, out RaycastHit hit, data.range)) { hit.collider.GetComponent()?.TakeDamage(data.damage); } } } ``` One `WeaponData` asset can be referenced by hundreds of weapon instances — no duplication, tweakable without touching code. **E. struct vs class in C#** ```csharp // struct: value type, copied on assignment, lives on the stack (usually) public struct DamageInfo { public int amount; public Vector3 hitPoint; public GameObject source; } // class: reference type, heap allocated, GC-tracked public class DamageEvent { public int amount; public Vector3 hitPoint; } ``` Use `struct` for small, short-lived, immutable-ish data — avoids GC allocations in hot paths. Unity's `Vector3`, `Quaternion`, `Color` are all structs. --- ### C++ (Godot) — Classes **A. A GDExtension node class** ```cpp // health.h #pragma once #include #include namespace godot { class Health : public Node { GDCLASS(Health, Node) // registers with Godot's ClassDB private: int max_health = 100; int current = 100; protected: static void _bind_methods(); // exposes to editor/GDScript public: Health(); ~Health(); void _ready() override; void take_damage(int amount); void heal(int amount); void set_max_health(int p_max); int get_max_health() const; int get_current() const; bool is_dead() const; }; } ``` ```cpp // health.cpp #include "health.h" using namespace godot; void Health::_bind_methods() { ClassDB::bind_method(D_METHOD("take_damage", "amount"), &Health::take_damage); ClassDB::bind_method(D_METHOD("heal", "amount"), &Health::heal); ClassDB::bind_method(D_METHOD("get_current"), &Health::get_current); ClassDB::bind_method(D_METHOD("is_dead"), &Health::is_dead); ClassDB::bind_method(D_METHOD("set_max_health", "value"), &Health::set_max_health); ClassDB::bind_method(D_METHOD("get_max_health"), &Health::get_max_health); // Appears in the Inspector ADD_PROPERTY(PropertyInfo(Variant::INT, "max_health"), "set_max_health", "get_max_health"); // Signals — Godot's event system ADD_SIGNAL(MethodInfo("health_changed", PropertyInfo(Variant::INT, "current"), PropertyInfo(Variant::INT, "max"))); ADD_SIGNAL(MethodInfo("died")); } Health::Health() {} Health::~Health() {} void Health::_ready() { current = max_health; } void Health::take_damage(int amount) { if (is_dead()) return; current = Math::max(0, current - amount); emit_signal("health_changed", current, max_health); if (is_dead()) emit_signal("died"); } void Health::heal(int amount) { if (is_dead()) return; current = Math::min(max_health, current + amount); emit_signal("health_changed", current, max_health); } void Health::set_max_health(int p_max) { max_health = p_max; } int Health::get_max_health() const { return max_health; } int Health::get_current() const { return current; } bool Health::is_dead() const { return current <= 0; } ``` **B. Registration boilerplate** ```cpp // register_types.cpp #include "register_types.h" #include "health.h" #include "enemy.h" #include #include #include #include using namespace godot; void initialize_game_module(ModuleInitializationLevel p_level) { if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) return; ClassDB::register_class(); ClassDB::register_abstract_class(); ClassDB::register_class(); ClassDB::register_class(); } void uninitialize_game_module(ModuleInitializationLevel p_level) { if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) return; } extern "C" { GDExtensionBool GDE_EXPORT game_library_init( GDExtensionInterfaceGetProcAddress p_get_proc_address, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) { GDExtensionBinding::InitObject init_obj( p_get_proc_address, p_library, r_initialization); init_obj.register_initializer(initialize_game_module); init_obj.register_terminator(uninitialize_game_module); init_obj.set_minimum_library_initialization_level( MODULE_INITIALIZATION_LEVEL_SCENE); return init_obj.init(); } } ``` **C. Inheritance and virtual dispatch** ```cpp // enemy.h #pragma once #include #include namespace godot { class Enemy : public CharacterBody3D { GDCLASS(Enemy, CharacterBody3D) protected: static void _bind_methods(); float move_speed = 3.0f; int damage = 10; Node3D *player = nullptr; // raw pointer: Godot owns the node public: void _ready() override; void _physics_process(double delta) override; // Pure virtual: subclasses must implement virtual void behave(double delta) = 0; virtual void on_death(); void set_move_speed(float s) { move_speed = s; } float get_move_speed() const { return move_speed; } }; class Chaser : public Enemy { GDCLASS(Chaser, Enemy) protected: static void _bind_methods() {} public: void behave(double delta) override; }; class Shooter : public Enemy { GDCLASS(Shooter, Enemy) Ref bullet_scene; float fire_rate = 1.0f; double next_shot = 0.0; protected: static void _bind_methods(); public: void behave(double delta) override; void on_death() override; }; } ``` ```cpp // enemy.cpp #include "enemy.h" #include #include using namespace godot; void Enemy::_bind_methods() { ClassDB::bind_method(D_METHOD("set_move_speed", "s"), &Enemy::set_move_speed); ClassDB::bind_method(D_METHOD("get_move_speed"), &Enemy::get_move_speed); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "move_speed"), "set_move_speed", "get_move_speed"); } void Enemy::_ready() { if (Engine::get_singleton()->is_editor_hint()) return; player = get_node("/root/Main/Player"); } void Enemy::_physics_process(double delta) { if (Engine::get_singleton()->is_editor_hint()) return; behave(delta); // virtual dispatch to subclass move_and_slide(); } void Enemy::on_death() { queue_free(); // Godot's deferred deletion — never `delete` a Node } void Chaser::behave(double delta) { if (!player) return; Vector3 dir = (player->get_global_position() - get_global_position()).normalized(); set_velocity(dir * move_speed); } void Shooter::_bind_methods() { ClassDB::bind_method(D_METHOD("set_fire_rate", "r"), static_cast(nullptr)); // simplified } void Shooter::behave(double delta) { next_shot -= delta; if (next_shot > 0.0) return; next_shot = 1.0 / fire_rate; if (bullet_scene.is_valid()) { Node *bullet = bullet_scene->instantiate(); get_parent()->add_child(bullet); Node3D *b3d = Object::cast_to(bullet); if (b3d) b3d->set_global_position(get_global_position()); } } void Shooter::on_death() { // spawn explosion here... Enemy::on_death(); } ``` **D. Non-node classes — pure C++ game logic** Not everything needs to be a `Node`. Plain classes are faster and simpler: ```cpp // inventory.h #pragma once #include #include #include struct InventoryItem { std::string id; std::string display_name; int stack_size = 1; int max_stack = 99; bool can_stack_with(const InventoryItem &other) const { return other.id == id && stack_size < max_stack; } }; class Inventory { std::vector> slots; public: explicit Inventory(size_t capacity) : slots(capacity) {} size_t capacity() const { return slots.size(); } const std::optional& at(size_t i) const { return slots[i]; } bool try_add(const InventoryItem &item) { for (auto &slot : slots) { if (slot && slot->can_stack_with(item)) { slot->stack_size++; return true; } } for (auto &slot : slots) { if (!slot) { slot = item; return true; } } return false; } bool remove_at(size_t i) { if (i >= slots.size() || !slots[i]) return false; if (--slots[i]->stack_size <= 0) slots[i].reset(); return true; } }; ``` **E. Godot's `Resource` — the ScriptableObject equivalent** ```cpp // weapon_data.h #pragma once #include #include namespace godot { class WeaponData : public Resource { GDCLASS(WeaponData, Resource) String weapon_name = "Pistol"; int damage = 10; float fire_rate = 5.0f; float range = 50.0f; protected: static void _bind_methods(); public: void set_damage(int d) { damage = d; } int get_damage() const { return damage; } void set_fire_rate(float r) { fire_rate = r; } float get_fire_rate() const { return fire_rate; } void set_range(float r) { range = r; } float get_range() const { return range; } void set_weapon_name(const String &n) { weapon_name = n; } String get_weapon_name() const { return weapon_name; } }; } ``` ```cpp void WeaponData::_bind_methods() { ClassDB::bind_method(D_METHOD("set_damage", "v"), &WeaponData::set_damage); ClassDB::bind_method(D_METHOD("get_damage"), &WeaponData::get_damage); ADD_PROPERTY(PropertyInfo(Variant::INT, "damage"), "set_damage", "get_damage"); ClassDB::bind_method(D_METHOD("set_fire_rate", "v"), &WeaponData::set_fire_rate); ClassDB::bind_method(D_METHOD("get_fire_rate"), &WeaponData::get_fire_rate); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fire_rate"), "set_fire_rate", "get_fire_rate"); } ``` Used with `Ref` — a reference-counted smart pointer: ```cpp class Weapon : public Node3D { GDCLASS(Weapon, Node3D) Ref data; // auto-managed lifetime double next_fire = 0.0; public: void try_fire() { if (data.is_null() || next_fire > 0.0) return; next_fire = 1.0 / data->get_fire_rate(); // raycast using data->get_range(), data->get_damage() } }; ``` --- ## Part 3: Putting It Together — Object Pooling This is where arrays and classes combine into something genuinely important. Instantiating and destroying bullets every frame causes GC spikes (C#) or heap fragmentation (C++). Pools fix it. ### Unity / C# ```csharp using UnityEngine; public class Bullet : MonoBehaviour { public float speed = 30f; public float lifetime = 3f; private float age; private BulletPool owner; public void Launch(BulletPool pool, Vector3 pos, Vector3 dir) { owner = pool; transform.position = pos; transform.forward = dir; age = 0f; gameObject.SetActive(true); } void Update() { transform.position += transform.forward * speed * Time.deltaTime; age += Time.deltaTime; if (age >= lifetime) Recycle(); } void OnTriggerEnter(Collider other) { other.GetComponent()?.TakeDamage(10); Recycle(); } private void Recycle() { gameObject.SetActive(false); owner.Return(this); } } public class BulletPool : MonoBehaviour { [SerializeField] private Bullet prefab; [SerializeField] private int poolSize = 128; private Bullet[] pool; // the array private int[] freeStack; // indices of available bullets private int freeCount; void Awake() { pool = new Bullet[poolSize]; freeStack = new int[poolSize]; for (int i = 0; i < poolSize; i++) { pool[i] = Instantiate(prefab, transform); pool[i].gameObject.SetActive(false); freeStack[i] = i; } freeCount = poolSize; } public Bullet Get() { if (freeCount == 0) return null; // pool exhausted int index = freeStack[--freeCount]; return pool[index]; } public void Return(Bullet b) { for (int i = 0; i < pool.Length; i++) { if (pool[i] == b) { freeStack[freeCount++] = i; return; } } } public void Fire(Vector3 pos, Vector3 dir) { Bullet b = Get(); if (b != null) b.Launch(this, pos, dir); } } ``` *(The linear search in `Return` is a teaching simplification — store the index on the bullet itself in production.)* ### Godot / C++ — Data-Oriented Pool Here C++ lets you do something Unity can't easily: skip nodes entirely and manage bullets as flat arrays. This is enormously faster for thousands of entities. ```cpp // bullet_manager.h #pragma once #include #include #include namespace godot { class BulletManager : public Node3D { GDCLASS(BulletManager, Node3D) static constexpr int MAX_BULLETS = 4096; // Structure of Arrays — cache friendly std::vector positions; std::vector velocities; std::vector lifetimes; std::vector active; std::vector free_indices; int alive_count = 0; protected: static void _bind_methods(); public: BulletManager(); void _ready() override; void _physics_process(double delta) override; int spawn(const Vector3 &pos, const Vector3 &vel, float life); void despawn(int index); int get_alive_count() const { return alive_count; } }; } ``` ```cpp // bullet_manager.cpp #include "bullet_manager.h" using namespace godot; void BulletManager::_bind_methods() { ClassDB::bind_method(D_METHOD("spawn", "pos", "vel", "life"), &BulletManager::spawn); ClassDB::bind_method(D_METHOD("despawn", "index"), &BulletManager::despawn); ClassDB::bind_method(D_METHOD("get_alive_count"), &BulletManager::get_alive_count); } BulletManager::BulletManager() { positions.resize(MAX_BULLETS); velocities.resize(MAX_BULLETS); lifetimes.resize(MAX_BULLETS, 0.0f); active.resize(MAX_BULLETS, false); free_indices.reserve(MAX_BULLETS); // Push in reverse so we pop low indices first for (int i = MAX_BULLETS - 1; i >= 0; --i) free_indices.push_back(i); } void BulletManager::_ready() {} int BulletManager::spawn(const Vector3 &pos, const Vector3 &vel, float life) { if (free_indices.empty()) return -1; int idx = free_indices.back(); free_indices.pop_back(); positions[idx] = pos; velocities[idx] = vel; lifetimes[idx] = life; active[idx] = true; ++alive_count; return idx; } void BulletManager::despawn(int index) { if (index < 0 || index >= MAX_BULLETS || !active[index]) return; active[index] = false; free_indices.push_back(index); --alive_count; } void BulletManager::_physics_process(double delta) { const float dt = static_cast(delta); // Tight loop over contiguous memory — very fast for (int i = 0; i < MAX_BULLETS; ++i) { if (!active[i]) continue; positions[i] += velocities[i] * dt; lifetimes[i] -= dt; if (lifetimes[i] <= 0.0f) despawn(i); } } ``` Render these with a `MultiMeshInstance3D` — one draw call for all 4096 bullets. --- ## Part 4: Key Differences to Internalize | Concept | C# / Unity | C++ / Godot | |---|---|---| | Memory management | GC handles it; minimize allocations in `Update` | Manual/RAII; `queue_free()` for Nodes, `Ref` for Resources | | Fixed array | `T[]` | `std::array` or C array | | Dynamic array | `List` | `std::vector` | | Editor exposure | `[SerializeField]`, `public` | `_bind_methods()` + `ADD_PROPERTY` | | Data assets | `ScriptableObject` | `Resource` + `Ref` | | Events | `event Action`, `UnityEvent` | `ADD_SIGNAL` / `emit_signal` | | Abstract base | `abstract class`, `abstract void` | pure virtual `= 0` | | Null-safe call | `obj?.Method()` | `if (ptr) ptr->method();` | | Iteration | `foreach (var x in arr)` | `for (const auto &x : arr)` | | Value type | `struct` | any class/struct not on the heap | --- ## Practice Exercises 1. **Wave spawner (both engines):** Read a jagged array / `vector>` of enemy type IDs, spawn one wave per timer tick, advance when all enemies in the wave are dead. 2. **Grid pathfinding:** Build a flattened `int` grid, implement BFS to find a path, store the result as an array of `Vector2i` waypoints. 3. **Component refactor:** Take a 400-line "PlayerController" and split it into `Health`, `Movement`, `WeaponHolder`, `InputReader` classes that communicate via events/signals. 4. **Performance test:** In Godot, spawn 5,000 bullets as individual `Node3D`s, then as entries in the `BulletManager` above. Profile both. The gap will surprise you. Start with #3 — composition over inheritance is the single most valuable habit in game architecture, and it forces you to actually use both arrays (to hold references) and classes (to encapsulate behavior) meaningfully.

game programming test