Quake

Pros of DOOM

• Simpler codebase, easier to understand for beginners
• More iconic and recognizable game, potentially attracting more contributors
• Faster rendering engine, suitable for lower-end hardware

Cons of DOOM

• Limited 3D capabilities compared to Quake's full 3D engine
• Less advanced networking code for multiplayer functionality
• Older technology, may require more work to modernize

Code Comparison

DOOM (main game loop):

void D_DoomLoop (void)
{
    while (1)
    {
        // Frame syncronous IO operations
        I_StartFrame ();

        // Process one or more tics
        TryRunTics ();

        // Move positional sounds
        S_UpdateSounds (players[consoleplayer].mo);

        // Update display, next frame
        D_Display ();
    }
}

Quake (main game loop):

void Host_Frame (float time)
{
    if (setjmp (host_abortserver) )
        return;            // something bad happened, or the server disconnected

    // keep the random time dependent
    rand ();

    // decide the simulation time
    if (!Host_FilterTime (time))
        return;            // don't run too fast, or packets will flood out

    // get new key events
    Sys_SendKeyEvents ();

    // allow mice or other external controllers to add commands
    IN_Commands ();

    // process console commands
    Cbuf_Execute ();

    // if running the server locally, make intentions now
    if (sv.active)
        CL_SendCmd ();

    //-------------------
    //
    // server operations
    //
    //-------------------

    // check for commands typed to the host
    Host_GetConsoleCommands ();

    if (sv.active)
        Host_ServerFrame ();

    //-------------------
    //
    // client operations
    //
    //-------------------

    // if running the server remotely, send intentions now after
    // the incoming messages have been read
    if (!sv.active)
        CL_SendCmd ();

    host_time += host_frametime;

    // fetch results from server
    if (cls.state == ca_connected)
    {
        CL_ReadFromServer ();
    }

    // update video
    if (host_speeds.value)
        time1 = Sys_FloatTime ();

    SCR_UpdateScreen ();

    if (host_speeds.value)
        time2 = Sys_FloatTime ();

    // update audio
    if (cls.signon == SIGNONS)
    {
        S_Update (r_origin, vpn, vright, vup);
        CL_DecayLights ();
    }
    else
        S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);

    CDAudio_Update();

    if (host_speeds.value)
    {
        pass1 = (time1 - time3)*1000;
        time3 = Sys_FloatTime ();
        pass2 = (time2 - time1)*1000;
        pass3 = (time3 - time2)*1000;
        Con_Printf ("%3i tot %3i server %3i gfx %3i snd\n",
                    pass1+pass2+pass3, pass1, pass2, pass3);
    }

    host_framecount++;
}

The DOOM main loop is simpler and more straightforward, while Quake's loop is more complex, handling additional features like network play and 3D graphics.

Pros of Half-Life

• More extensive codebase with a wider range of features and gameplay elements
• Better organized project structure, making it easier to navigate and understand
• More recent updates and active community contributions

Cons of Half-Life

• Larger codebase may be more challenging to understand and modify for beginners
• Less focus on core engine functionality, as it builds upon the Quake engine
• More complex build process and dependencies

Code Comparison

Half-Life (player movement):

void CBasePlayer::PlayerRun( void )
{
    if ( ( m_nButtons & IN_FORWARD ) && !( m_nButtons & IN_BACK ) )
    {
        pev->velocity = pev->velocity + gpGlobals->v_forward * sv_accelerate.value;
    }
}

Quake (player movement):

void SV_WalkMove (edict_t *ent)
{
    if (ent->v.movetype == MOVETYPE_NOCLIP)
    {
        SV_FlyMove (ent, frametime, NULL);
        return;
    }
}

The Half-Life code shows more detailed player movement handling, while Quake's implementation is more straightforward. Half-Life's approach allows for finer control and more complex movement mechanics.

Pros of vkQuake

• Utilizes Vulkan API for improved performance and modern graphics capabilities
• Supports higher resolutions and widescreen displays
• Includes enhanced lighting and particle effects

Cons of vkQuake

• May have compatibility issues with older hardware
• Potentially more complex codebase due to Vulkan implementation
• Smaller community and less frequent updates compared to the original Quake

Code Comparison

Quake (OpenGL rendering):

void GL_BeginRendering (int *x, int *y, int *width, int *height)
{
    extern cvar_t gl_clear;

    *x = *y = 0;
    *width = glwidth;
    *height = glheight;

    GL_SetCanvas (CANVAS_DEFAULT);

    glViewport (glx, gly, glwidth, glheight);
}

vkQuake (Vulkan rendering):

void R_BeginFrame (void)
{
    VID_BeginFrame ();

    r_framecount++;

    // clear the z-buffer and stencil-buffer
    VkClearAttachment clear_attachments[2];
    clear_attachments[0].aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
    clear_attachments[0].clearValue.depthStencil.depth = 1.0f;
    clear_attachments[0].clearValue.depthStencil.stencil = 0;
}