Okay, so my change was incorrectly reverted by User:Expack3 despite being obvious and trivial to verify - along with other users reporting the same issue with no resolution either. The actual source is from a warez distribution, and following it only works if you follow both steps in their file (because it doesn't apply the crack directly), and something like this would have been handled under Wikipedia using their WP:SNOW policy.

We'll start with a version of the CD checking function, decompiled by Snowman:

void** fun_10033700() {
    int32_t eax1;
    void** v2;
    void** edi3;
    void* esp4;
    int32_t esi5;
    int32_t edi6;
    void** v7;
    int32_t eax8;
    void* esp9;
    void*** esp10;
    void** v11;
    void*** esp12;
    void** v13;
    void** v14;
    void*** esp15;
    void** v16;
    void* esp17;
    void** v18;
    void** v19;
    int32_t eax20;
    void** ecx21;
    void** eax22;
    void** v23;
    void* esp24;
    void** ecx25;
    void** v26;
    void* esp27;
    void** eax28;
    void** v29;
    void* esp30;
    void** v31;
    void* esp32;
    signed char al33;
    int32_t v34;
    int32_t v35;

    eax1 = g1006d894;
    v2 = edi3;
    if (eax1) {
        return 0x1006d898;
    }
    SetErrorMode();
    esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 0x258 - 4 - 4 - 4 - 4 + 4);
    esi5 = GetDriveTypeA;
    edi6 = GetVolumeInformationA;
    g1006d894 = 1;
    do {
        v7 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 8);
        eax8 = reinterpret_cast<int32_t>(esi5());
        esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp4) - 4 - 4 + 4);
        if (eax8 != 5) 
            continue;
        esp9 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp4) - 4);
        esp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(esp9) - 4);
        v11 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 0x15c);
        esp12 = esp10 - 4;
        v13 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp9) + 24);
        v14 = reinterpret_cast<void**>(esp10 + 24);
        esp15 = esp12 - 4 - 4;
        v16 = reinterpret_cast<void**>(esp12 + 24);
        esp17 = reinterpret_cast<void*>(esp15 - 4);
        v18 = reinterpret_cast<void**>(esp15 + 0x6c);
        v19 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp17) + 32);
        eax20 = reinterpret_cast<int32_t>(edi6());
        esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp17) - 4 - 4 - 4 + 4);
        if (!eax20) 
            goto addr_100337e6_6;
        ecx21 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 88);
        eax22 = fun_100412c0(ecx21, ecx21, "HERETIC_II", v19, v18, 0x104, v16, v14, v13, ecx21, ecx21, "HERETIC_II", v19, v18, 0x104, v16, v14, v13);
        esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp4) - 4 - 4 - 4 + 4 + 8);
        if (eax22) 
            goto addr_100337e6_6;
        v23 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 8);
        fun_10040994(0x1006d898, "%ssetup", v23, v19, v18, 0x104, v16, 0x1006d898, "%ssetup", v23, v19, v18, 0x104, v16);
        esp24 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp4) - 4 - 4 - 4 - 4 + 4);
        ecx25 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp24) + 36);
        v26 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp24) + 20);
        fun_10040994(ecx25, "%ssetup/setup.bmp", v26, 0x1006d898, "%ssetup", v23, v19, ecx25, "%ssetup/setup.bmp", v26, 0x1006d898, "%ssetup", v23, v19);
        esp27 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp24) - 4 - 4 - 4 - 4 + 4);
        eax28 = fun_10040981(ecx25, reinterpret_cast<int32_t>(esp27) + 48, "r", ecx25, "%ssetup/setup.bmp", v26, 0x1006d898, "%ssetup", v23, v19, v18, 0x104, v16, v14, v13, v11, 0x104);
        esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp27) - 4 - 4 - 4 + 4 + 32);
        if (eax28) 
            break;
        addr_100337e6_6:
        v29 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 8);
        fun_10040994(0x1006d898, "%sheretic2/setup", v29, v19, v18, 0x104, v16, 0x1006d898, "%sheretic2/setup", v29, v19, v18, 0x104, v16);
        esp30 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp4) - 4 - 4 - 4 - 4 + 4);
        ecx25 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp30) + 20);
        v31 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp30) + 36);
        fun_10040994(v31, "%sheretic2/setup/base/sound/music/10-l.wav", ecx25, 0x1006d898, "%sheretic2/setup", v29, v19, v31, "%sheretic2/setup/base/sound/music/10-l.wav", ecx25, 0x1006d898, "%sheretic2/setup", v29, v19);
        esp32 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp30) - 4 - 4 - 4 - 4 + 4);
        eax28 = fun_10040981(ecx25, reinterpret_cast<int32_t>(esp32) + 48, "r", v31, "%sheretic2/setup/base/sound/music/10-l.wav", ecx25, 0x1006d898, "%sheretic2/setup", v29, v19, v18, 0x104, v16, v14, v13, v11, 0x104);
        esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp32) - 4 - 4 - 4 + 4 + 32);
        if (eax28) 
            break;
        al33 = reinterpret_cast<signed char>(*reinterpret_cast<signed char*>(&v2) + 1);
        *reinterpret_cast<signed char*>(&v2) = al33;
    } while (al33 <= 0x7a);
    goto addr_10033836_10;
    fun_100408d3(ecx25, eax28, v19, v18, 0x104, v16, v14, v13, v11, 0x104, v7, 1, v2, 0x5c3a63);
    goto v34;
    addr_10033836_10:
    g1006d898 = 0;
    goto v35;
}

Here, no mention of this cd_nocd console variable. Look at it long enough, and you see that it checks each drive to determine if it's a CD, that it has the right label, and has specific files.

This copy protection function is called from a helper function:

void** fun_10033870(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void** a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void** a32, void** a33, void** a34, void** a35, void** a36, void** a37, void** a38, void** a39, void** a40, void** a41, void** a42, void** a43, void** a44, void** a45, void** a46, void** a47, void** a48, void** a49, void** a50, void** a51, void** a52, void** a53, void** a54, void** a55, void** a56, void** a57, void** a58, void** a59, void** a60, void** a61, void** a62, void** a63, void** a64, void** a65, void** a66, void** a67, void** a68, void** a69, void** a70, void** a71, void** a72, void** a73, void** a74, void** a75, void** a76, void** a77, void** a78, void** a79, void** a80, void** a81, void** a82, void** a83, void** a84, void** a85, void** a86, void** a87, void** a88, void** a89, void** a90, void** a91, void** a92, void** a93, void** a94) {
    void** eax95;
    int32_t eax96;
    void** eax97;
    void** ecx98;
    void** eax99;

    eax95 = fun_10033700();
    if (!*reinterpret_cast<void***>(eax95)) {
        eax96 = fun_10033860();
        if (!eax96) {
            eax97 = g10168110;
            ecx98 = *reinterpret_cast<void***>(eax97 + 4);
            eax95 = Sys_Error(ecx98, ecx98, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76, a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a90, a91, a92, a93, a94);
        } else {
            eax99 = Com_DPrintf(ecx, "Copy protection failed !\n", __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74, a75, a76, a77, a78, a79, a80, a81, a82, a83, a84, a85, a86, a87, a88);
            return eax99;
        }
    }
    return eax95;
}

This function only checks two variables, both of which are set by the copy-protection function above.

This is in turn called by the map console command:

uint32_t fun_1002da40(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void** a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void** a32, void** a33, void** a34, void** a35, void** a36, void** a37, void** a38, void** a39, void** a40, void** a41, void** a42, void** a43, void** a44, void** a45, void** a46, void** a47, void** a48, void** a49, void** a50, void** a51, void** a52, void** a53, void** a54, void** a55, void** a56, void** a57, void** a58, void** a59, void** a60, void** a61, void** a62, void** a63, void** a64, void** a65, void** a66, void** a67, void** a68, void** a69, void** a70, void** a71, void** a72, void** a73, void** a74) {
    void** esp75;
    void** v76;
    void** esi77;
    void** esi78;
    void** v79;
    void** edi80;
    int32_t edi81;
    void* esp82;
    void** ecx83;
    void** v84;
    void** v85;
    void** v86;
    void** v87;
    void** v88;
    void** v89;
    void** v90;
    void** v91;
    void** v92;
    void** v93;
    void** v94;
    void** v95;
    void** v96;
    void** v97;
    void** v98;
    void** v99;
    void** eax100;
    void* esp101;
    void** v102;
    void** ecx103;
    void** v104;
    void** v105;
    void** v106;
    void** v107;
    void** v108;
    void** v109;
    void** v110;
    void** v111;
    void** v112;
    void** v113;
    void** v114;
    void** v115;
    void** v116;
    void** v117;
    void** v118;
    void** v119;
    void** eax120;
    void** edi121;
    uint32_t ecx122;
    void** ecx123;
    void** v124;
    void** v125;
    void** v126;
    void** v127;
    void** eax128;
    uint32_t eax129;
    int16_t ax130;
    int16_t fpu_status_word131;
    void** v132;
    void** v133;
    void** v134;
    void** v135;
    void** v136;
    void** v137;
    void** v138;
    void** v139;
    void** v140;
    void** v141;
    void** v142;
    void** v143;
    void** v144;
    void** v145;
    void** v146;
    void** v147;

    esp75 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 64);
    v76 = esi77;
    esi78 = a1;
    v79 = edi80;
    edi81 = Com_sprintf;
    edi81(esp75, 64, "maps/%s.bsp", esi78);
    esp82 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp75 - 4) - 4 - 4 - 4 - 4 - 4 - 4 + 4);
    ecx83 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp82) + 24);
    eax100 = FS_LoadFile(ecx83, ecx83, 0, esp75, 64, "maps/%s.bsp", esi78, v79, v76, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53);
    if (reinterpret_cast<signed char>(eax100) < reinterpret_cast<signed char>(0)) {
        esp101 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp82) - 4 - 4 - 4 + 4 + 24 - 4 - 4);
        v102 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp101) + 16);
        edi81(v102, 64, "demos/%s", esi78);
        ecx103 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp101) - 4 - 4 - 4 + 4 + 24);
        eax120 = FS_LoadFile(ecx103, ecx103, 0, v102, 64, "demos/%s", esi78, v79, v76, v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53);
        if (reinterpret_cast<signed char>(eax120) < reinterpret_cast<signed char>(0)) {
            edi121 = esi78;
            ecx122 = 0xffffffff;
            do {
                if (!ecx122) 
                    break;
                --ecx122;
                ++edi121;
                ++esi78;
            } while (*reinterpret_cast<void***>(edi121));
            ecx123 = reinterpret_cast<void**>(~ecx122 - 1);
            eax128 = fun_100412c0(ecx123, reinterpret_cast<unsigned char>(ecx123) + reinterpret_cast<unsigned char>(esi78) + 0xfffffffc, ".smk", v79, v76, v124, v125, v126, v127);
            eax129 = -reinterpret_cast<unsigned char>(eax128);
            return eax129 - (eax129 + reinterpret_cast<uint1_t>(eax129 < eax129 + reinterpret_cast<uint1_t>(!!eax128))) + 1;
        } else {
            return 1;
        }
    } else {
        __asm__("fld dword [edx+0x14]");
        __asm__("fcomp dword [0x1004f320]");
        ax130 = fpu_status_word131;
        if (*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax130) + 1) & 64) {
            fun_10033870(ecx83, v79, v76, v132, v133, v134, v135, v136, v137, v138, v139, v140, v141, v142, v143, v144, v145, v146, v147, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a60, a61, a62, a63, a64, a65, a66, a67, a68, a69, a70, a71, a72, a73, a74);
        }
        return 1;
    }
}

At the bottom - that section is on a successful map load, which calls the copy protection helper function. Absolutely

Additionally, there's the old classic method of installing the game normally - even that warez distribution sourcing the statement includes a non-cracked copy of quake2.dll - and checking on whether or not it works.

Topic on Talk:Heretic II