dxpower/fastboi

A lightweight and simple C++20 game engine written over SDL2. It implements a basic component model and event system.

The first version of the Fastboi game engine is complete with version 0.1.0 "Sea Turtle"!

Fastboi is a small and lightweight Entity-Component engine. Gameobject's can store components, through which Start() and Update() functions are called.

Note: tests and documentation are currently incomplete.

The current features are:

• Compile-time components with no inheritance! Start() and Update() functions are automatically detected and called.
• Simple rendering: There are several rendering functions provided out of the box, as well as several Renderer components such as SpriteRenderer, WireframeRenderer, and more.
• Easy convex collision detection: You can add any Shape class to your Transform, define your convex vertices, and Fastboi will automatically throw it into the collision calculation soup.
• Type safe collisions layers: You can mask how objects collide using the CollisionMask and it's type safe CollisionLayer enum. Many of these calculates are resolved at compile time!
• Worry-free duplication: Smart Gameobject references GORef allow duplication via the component's copy constructor, and the GORef will automatically be updated!
• Type safe degrees/radians: With the magic of C++20, you can now do 3.14_rad + 50_deg and not worry about conversion at all.
• Easy key/mouse listeners: There are multiple listeners provided that allow you to have RAII-guarded listening capabilities for player input.
• Nano Signals and Slots: A very lightweight and easy to use signals and slots implementation is included and core to Fastboi.
• SoLoud Sound: A fire-and-forget sound library extended with a Speaker component that provides multiple panning functionalities to move sound all over the screen.

Included in the box is a remake of the first level of Atari Adventure.

Fastboi consists of multiple core components:

• Transform to store information about position, rotation, size, and vertices
• Rigidbody to store information about positional and rotational velocity, acceleration, and drag
• Collider to receive collision events, mask layers, and dispatch events to listeners
• Renderer an abstract class that allows you to create custom renderers
• Speaker for easy access to sound for Gameobjects, and provides several panning functionalities.

Some example code on creating a Gameobject via an instantiation function.

// A component to be added to Bullet
struct BulletHit {
     GORef go; // Stores a reference to the parent Gameobject
     ColorComp* color{};
     int damage;

     // The first argument of GORef&& go is optional. This is automatically detected.
     BulletHit(GORef&& go, int damage) : go(std::move(go)), damage(damage) { }

     // Called at the beginning of the first tick BulletHit is active
     void Start() {
          color = &go().GetComponent<ColorComp>();
          *color = startingColor;

          // Set our Hit function to listen for collisions
          go().GetComponent<Collider>().collisionSignal.connect<&BulletHit::Hit>(this);
     }

     void Update() {
          // Shift the color every tick
          color.r += 5;
          color.g += 2;
          color.b -= 3;
     }

     // Called when this gameobject collides with something
     void Hit(CollisionEvent& e) {
          if (e.type == CollisionEvent::BEGIN && e.HasComponent<Player>()) {
               e.GetComponent<Player>().Damage(this->damage);

               Destroy(go());
          }
     }
}

void SuperBullet(Gameobject& go, const Position& pos, const Vecf& dir) {
     constexpr float velocity = 500.f;

     go.AddComponent<Transform>(pos, Size(100.f, 50.f), 0_deg);
     go.AddComponent<ColorComp>(200, 10, 50, 255);
     go.AddComponent<WireframeRenderer>(RenderData(RenderOrder::PARTICLES));

     go.AddComponent<BulletHit>(20); // Add our custom BulletHit component with a damage of 20

     // Set the bullet's collider to to be a part of the Particles collision layer,
     // and to only collide with colliders in the Player layer
     go.AddComponent<Collider>(CollisionLayer::PARTICLES).Include(CollisionLayer::Player);
}

// And to create an instance of SuperBullet
Gameobject& bullet = Instantiate<SuperBullet>(Position(500.f, 600.f), Vecf(2,1).normalized());

However, many premade components are provided for ease of use and development. Provided components:

• BoxColorRenderer
• SpriteRenderer
• RepeatRenderer
• WireframeRenderer
• RectUI, UITexture
• ColorComp
• Spritesheet
• ChangeObserver

Also in the repository (For now), is a test game called "Slowboi." This is merely to demonstrate some of the basic capabilities. It is rather rudimentary and has no actual gameplay, but that will be added to over time.

#Required libraries/DLLs: SDL: (SDL2main, SDL2, SDL2_image)..lib in lib/ (.a for Linux/Mac builds) (SDL2, SDL2_image, libjpeg-9, libpng16-16, libtiff-5, libwepb-7, zlib1).dll when running the final executable

The following dependencies have been incorporated into the project: CacheLineSize (for allocator optimizations) https://github.com/NickStrupat/CacheLineSize (header/src file) Catch2 (Testing suite) https://github.com/catchorg/Catch2 (header files) cute_c2 (GJK/EPA collision implementation) https://github.com/RandyGaul/cute_headers (header file) Nano (Slots/Signals implementation) https://github.com/NoAvailableAlias/nano-signal-slot (header file) SDL2 (Window management, rendering, input) https://github.com/lohedges/aabbcc (dynamic linking) SoLoud (Sound) https://sol.gfxile.net/soloud/ (static linking)

fastboi's Issues

Proper renderer creation on Linux

When initializing on Linux, the window already has a renderer available. Has to do with unnecessary creation of a window surface.

Texture invalidation when created in side thread before first Render call

Some time between the creation of a texture in the init of the engine, and the accessing of the texture in the Rendering thread, the texture's SDL_Texture pointer gets set to nullptr.

First fullscreen toggle takes several seconds, and resolution is not scaled

Possibly an SDL bug.

The first time when entering fullscreen, the screen will flicker several times. When it finally enters fullscreen after multiple seconds, it will not be in the native resolution. Successive fullscreen toggles are instantaneous and have the correct resolution.

Infinite Loop in AABB tree rebalancing

Probably in the tree rebalancing, needs more investigation

Crash when Instantiating in Start()

Unknown crash due to duplicating the Brick

Needs more investigation

Linux is completely wack

Graphical bugs and disappearing and crashing on adventure when built for Linux

Using Scancodes instead of Keycodes

This makes the engine non-portable for multiple keyboard layouts

Crash related to deleting gameobject and an ending collision

When a gameobject is deleted, it will crash if it is currently in a colliding state with another gameobject. This is because the collider has "vanished" from existence, causing the extant collider to attempt to fire a CollisionEvent::END event, causing a dereference of a deleted gameobject.

CMake configurable warnings

ie, don't hardcode them into the build file so that other compilers can easily be used

Fix UB of CollisionMask::inclusions, should be underlying type

Affected line

According to the standard, ORing two CollisionLayer's and saving the result into another CollisionLayer is UB because the result is not in the range of the enum (the range has holes in it).