问意外的标识符char[32]
EN

Stack Overflow用户

提问于 2019-06-13 01:40:27

回答 1查看 118关注 0票数 0

所以我在vs 2017中遇到了一个意外的标识符错误。错误列表表明这段代码是问题所在：

NETVAR("CBaseAttributableItem", "m_szCustomName", GetCustomName, char [32]);

char32部分是带红色下划线的部分。Thx EDIT:我还得到了

syntax error: '['

和

unexpected token(s) preceding '{'; skipping apparent function body

好吧，因为我不能在不输入im的情况下发布这么多代码，所以只需在这里解释一些东西，NETVAR用于获取游戏中变量的地址，例如用于修改或只是读取它们。如果你需要任何其他的定义，也请在评论中问我，因为这是一个语法错误，代码含义可能不是太多Idk，我有点新，所以我也使用Vs 2017与工具包v141和sdk 10.0.17763.0

#pragma once
#include "../../dependencies/math/math.hpp"
#include <array>
#include "collideable.hpp"
#include "client_class.hpp"
#include "../../dependencies/utilities/netvar_manager.hpp"
#include <string.h>

enum move_type {
    movetype_none = 0,
    movetype_isometric,
    movetype_walk,
    movetype_step,
    movetype_fly,
    movetype_flygravity,
    movetype_vphysics,
    movetype_push,
    movetype_noclip,
    movetype_ladder,
    movetype_observer,
    movetype_custom,
    movetype_last = movetype_custom,
    movetype_max_bits = 4,
    max_movetype
};

enum entity_flags {
    fl_onground = (1 << 0),
    fl_ducking = (1 << 1),
    fl_waterjump = (1 << 2),
    fl_ontrain = (1 << 3),
    fl_inrain = (1 << 4),
    fl_frozen = (1 << 5),
    fl_atcontrols = (1 << 6),
    fl_client = (1 << 7),
    fl_fakeclient = (1 << 8),
    fl_inwater = (1 << 9),
    fl_fly = (1 << 10),
    fl_swim = (1 << 11),
    fl_conveyor = (1 << 12),
    fl_npc = (1 << 13),
    fl_godmode = (1 << 14),
    fl_notarget = (1 << 15),
    fl_aimtarget = (1 << 16),
    fl_partialground = (1 << 17),
    fl_staticprop = (1 << 18),
    fl_graphed = (1 << 19),
    fl_grenade = (1 << 20),
    fl_stepmovement = (1 << 21),
    fl_donttouch = (1 << 22),
    fl_basevelocity = (1 << 23),
    fl_worldbrush = (1 << 24),
    fl_object = (1 << 25),
    fl_killme = (1 << 26),
    fl_onfire = (1 << 27),
    fl_dissolving = (1 << 28),
    fl_transragdoll = (1 << 29),
    fl_unblockable_by_player = (1 << 30)
};
enum item_definition_indexes {
    WEAPON_NONE = 0,
    WEAPON_DEAGLE,
    WEAPON_ELITE,
    WEAPON_FIVESEVEN,
    WEAPON_GLOCK,
    WEAPON_AK47 = 7,
    WEAPON_AUG,
    WEAPON_AWP,
    WEAPON_FAMAS,
    WEAPON_G3SG1,
    WEAPON_GALILAR = 13,
    WEAPON_M249,
    WEAPON_M4A1 = 16,
    WEAPON_MAC10,
    WEAPON_P90 = 19,
    WEAPON_MP5SD = 23,
    WEAPON_UMP45,
    WEAPON_XM1014,
    WEAPON_BIZON,
    WEAPON_MAG7,
    WEAPON_NEGEV,
    WEAPON_SAWEDOFF,
    WEAPON_TEC9,
    WEAPON_TASER,
    WEAPON_HKP2000,
    WEAPON_MP7,
    WEAPON_MP9,
    WEAPON_NOVA,
    WEAPON_P250,
    WEAPON_SHIELD,
    WEAPON_SCAR20,
    WEAPON_SG556,
    WEAPON_SSG08,
    WEAPON_KNIFEGG,
    WEAPON_KNIFE,
    WEAPON_FLASHBANG,
    WEAPON_HEGRENADE,
    WEAPON_SMOKEGRENADE,
    WEAPON_MOLOTOV,
    WEAPON_DECOY,
    WEAPON_INCGRENADE,
    WEAPON_C4,
    WEAPON_HEALTHSHOT = 57,
    WEAPON_KNIFE_T = 59,
    WEAPON_M4A1_SILENCER,
    WEAPON_USP_SILENCER,
    WEAPON_CZ75A = 63,
    WEAPON_REVOLVER,
    WEAPON_TAGRENADE = 68,
    WEAPON_FISTS,
    WEAPON_BREACHCHARGE,
    WEAPON_TABLET = 72,
    WEAPON_MELEE = 74,
    WEAPON_AXE,
    WEAPON_HAMMER,
    WEAPON_SPANNER = 78,
    WEAPON_KNIFE_GHOST = 80,
    WEAPON_FIREBOMB,
    WEAPON_DIVERSION,
    WEAPON_FRAG_GRENADE,
    WEAPON_SNOWBALL,
    WEAPON_BUMPMINE,
    WEAPON_BAYONET = 500,
    WEAPON_KNIFE_FLIP = 505,
    WEAPON_KNIFE_GUT,
    WEAPON_KNIFE_KARAMBIT,
    WEAPON_KNIFE_M9_BAYONET,
    WEAPON_KNIFE_TACTICAL,
    WEAPON_KNIFE_FALCHION = 512,
    WEAPON_KNIFE_SURVIVAL_BOWIE = 514,
    WEAPON_KNIFE_BUTTERFLY,
    WEAPON_KNIFE_PUSH,
    WEAPON_KNIFE_URSUS = 519,
    WEAPON_KNIFE_GYPSY_JACKKNIFE,
    WEAPON_KNIFE_STILETTO = 522,
    WEAPON_KNIFE_WIDOWMAKER
};

class entity_t {
public:
    void* animating() {
        return reinterpret_cast<void*>(uintptr_t(this) + 0x4);
    }
    void* networkable() {
        return reinterpret_cast<void*>(uintptr_t(this) + 0x8);
    }
    collideable_t* collideable() {
        using original_fn = collideable_t * (__thiscall*)(void*);
        return (*(original_fn**)this)[3](this);
    }
    c_client_class* client_class() {
        using original_fn = c_client_class * (__thiscall*)(void*);
        return (*(original_fn**)networkable())[2](networkable());
    }

    int index() {
        using original_fn = int(__thiscall*)(void*);
        return (*(original_fn**)networkable())[10](networkable());
    }
    bool is_player() {
        using original_fn = bool(__thiscall*)(entity_t*);
        return (*(original_fn**)this)[155](this);
    }
    bool is_weapon() {
        using original_fn = bool(__thiscall*)(entity_t*);
        return (*(original_fn**)this)[163](this);
    }
    vec3_t get_absolute_origin() {
        __asm {
            MOV ECX, this
            MOV EAX, DWORD PTR DS : [ECX]
            CALL DWORD PTR DS : [EAX + 0x28]
        }
    }
    bool setup_bones(matrix_t* out, int max_bones, int mask, float time) {
        if (!this) {
            return false;
        }

        using original_fn = bool(__thiscall*)(void*, matrix_t*, int, int, float);
        return (*(original_fn**)animating())[13](animating(), out, max_bones, mask, time);
    }
    model_t* model() {
        using original_fn = model_t * (__thiscall*)(void*);
        return (*(original_fn**)animating())[8](animating());
    }
    void update() {
        using original_fn = void(__thiscall*)(entity_t*);
        (*(original_fn**)this)[218](this);
    }
    int draw_model(int flags, uint8_t alpha) {
        using original_fn = int(__thiscall*)(void*, int, uint8_t);
        return (*(original_fn**)animating())[9](animating(), flags, alpha);
    }
    void set_angles(vec3_t angles) {
        using original_fn = void(__thiscall*)(void*, const vec3_t&);
        static original_fn set_angles_fn = (original_fn)((DWORD)utilities::pattern_scan(GetModuleHandleA("client_panorama.dll"), "55 8B EC 83 E4 F8 83 EC 64 53 56 57 8B F1"));
        set_angles_fn(this, angles);
    }
    void set_position(vec3_t position) {
        using original_fn = void(__thiscall*)(void*, const vec3_t&);
        static original_fn set_position_fn = (original_fn)((DWORD)utilities::pattern_scan(GetModuleHandleA("client_panorama.dll"), "55 8B EC 83 E4 F8 51 53 56 57 8B F1 E8"));
        set_position_fn(this, position);
    }
    vec3_t &get_world_space_center() {
        vec3_t vec_origin = origin();

        vec3_t min = this->collideable()->mins() + vec_origin;
        vec3_t max = this->collideable()->maxs() + vec_origin;

        vec3_t size = max - min;
        size /= 2.f;
        size += min;

        return size;
    }
    NETVAR("DT_CSPlayer", "m_fFlags", flags, int);
    OFFSET(bool, dormant, 0xED);
    NETVAR("DT_BaseEntity", "m_hOwnerEntity", owner_handle, unsigned long);
    NETVAR("DT_CSPlayer", "m_flSimulationTime", simulation_time, float);
    NETVAR("DT_BasePlayer", "m_vecOrigin", origin, vec3_t);
    NETVAR("DT_BasePlayer", "m_vecViewOffset[0]", view_offset, vec3_t);
    NETVAR("DT_CSPlayer", "m_iTeamNum", team, int);
    NETVAR("DT_BaseEntity", "m_bSpotted", spotted, bool);
};

class econ_view_item_t {
public:
    NETVAR("DT_ScriptCreatedItem", "m_bInitialized", is_initialized, bool);
    NETVAR("DT_ScriptCreatedItem", "m_iEntityLevel", entity_level, int);
    NETVAR("DT_ScriptCreatedItem", "m_iAccountID", account_id, int);
    NETVAR("DT_ScriptCreatedItem", "m_iItemIDLow", item_id_low, int);

};

class base_view_model : public entity_t {
public:
    NETVAR("DT_BaseViewModel", "m_nModelIndex", model_index, int);
    NETVAR("DT_BaseViewModel", "m_nViewModelIndex", view_model_index, int);
    NETVAR("DT_BaseViewModel", "m_hWeapon", m_hweapon, int);
    NETVAR("DT_BaseViewModel", "m_hOwner", m_howner, int);
};

class attributable_item_t : public entity_t {
public:
    NETVAR("DT_BaseViewModel", "m_nModelIndex", model_index, int);
    NETVAR("DT_BaseAttributableItem", "m_OriginalOwnerXuidLow", original_owner_xuid_low, int);
    NETVAR("DT_BaseAttributableItem", "m_OriginalOwnerXuidHigh", original_owner_xuid_high, int);
    NETVAR("DT_BaseAttributableItem", "m_szCustomName", fallback_name, char[32]);
    NETVAR("DT_BaseAttributableItem", "m_nFallbackStatTrak", fallback_stattrak, int);
    NETVAR("DT_BaseAttributableItem", "m_nFallbackPaintKit", fallback_paint_kit, int);
    NETVAR("DT_BaseAttributableItem", "m_nFallbackSeed", fallback_seed, int);
    NETVAR("DT_BaseAttributableItem", "m_iEntityQuality", entity_quality, int);
    NETVAR("DT_BaseAttributableItem", "m_flFallbackWear", fallback_wear, float);
    NETVAR("DT_BaseCombatWeapon", "m_hWeaponWorldModel", world_model_handle, unsigned long);
    NETVAR("DT_BaseAttributableItem", "m_iItemDefinitionIndex", item_definition_index, short);
    NETVAR("DT_BaseAttributableItem", "m_iItemIDHigh", item_id_high, int); //jakby crash to wez offset z hazedumpera

    econ_view_item_t& item() {
        return *(econ_view_item_t*)this;
    }
};

class weapon_t : public entity_t {
public:
    NETVAR("DT_BaseCombatWeapon", "m_flNextPrimaryAttack", next_primary_attack, float);
    NETVAR("DT_BaseCombatWeapon", "m_flNextSecondaryAttack", next_secondary_attack, float);
    NETVAR("DT_BaseCombatWeapon", "m_iClip1", clip1_count, int);
    NETVAR("DT_BaseCombatWeapon", "m_iClip2", clip2_count, int);
    NETVAR("DT_BaseCombatWeapon", "m_iPrimaryReserveAmmoCount", primary_reserve_ammo_acount, int);
    NETVAR("DT_WeaponCSBase", "m_flRecoilIndex", recoil_index, float);
    NETVAR("DT_WeaponCSBaseGun", "m_zoomLevel", zoom_level, float);
    NETVAR("DT_BaseAttributableItem", "m_iItemDefinitionIndex", item_definition_index, short);
    NETVAR("DT_BaseCombatWeapon", "m_iEntityQuality", entity_quality, int);

    float get_innacuracy() {
        using original_fn = float(__thiscall*)(void*);
        return (*(original_fn**)this)[476](this);
    }

    float get_spread() {
        using original_fn = float(__thiscall*)(void*);
        return (*(original_fn**)this)[446](this);
    }

    void update_accuracy_penalty() {
        using original_fn = void(__thiscall*)(void*);
        (*(original_fn**)this)[477](this);
    }
    weapon_info_t* get_weapon_data() {
        using original_fn = weapon_info_t * (__thiscall*)(void*);
        return (*(original_fn**)this)[454](this); //skinchanger crash
    }
};

class player_t : public entity_t {
private:
    template <typename T>
    T& read(uintptr_t offset) {
        return *reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(this) + offset);
    }

    template <typename T>
    void write(uintptr_t offset, T data) {
        *reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(this) + offset) = data;
    }

public:
    NETVAR("DT_BasePlayer", "m_hViewModel[0]", view_model, int); //tutaj
    NETVAR("DT_CSPlayer", "m_bHasDefuser", has_defuser, bool);
    NETVAR("DT_CSPlayer", "m_bGunGameImmunity", has_gun_game_immunity, bool);
    NETVAR("DT_CSPlayer", "m_iShotsFired", shots_fired, int);
    NETVAR("DT_CSPlayer", "m_angEyeAngles", eye_angles, vec3_t); //"DT_CSPlayer->m_angEyeAngles[0]");
    NETVAR("DT_CSPlayer", "m_ArmorValue", armor, int);
    NETVAR("DT_CSPlayer", "m_bHasHelmet", has_helmet, bool);
    NETVAR("DT_CSPlayer", "m_bIsScoped", is_scoped, bool);
    NETVAR("DT_CSPlayer", "m_bIsDefusing", is_defusing, bool);
    NETVAR("DT_CSPlayer", "m_iAccount", money, int);
    NETVAR("DT_CSPlayer", "m_flLowerBodyYawTarget", lower_body_yaw, float);
    NETVAR("DT_CSPlayer", "m_flNextAttack", next_attack, float);
    NETVAR("DT_CSPlayer", "m_flFlashDuration", flash_duration, float);
    NETVAR("DT_CSPlayer", "m_flFlashMaxAlpha", flash_alpha, float);
    NETVAR("DT_CSPlayer", "m_bHasNightVision", m_bHasNightVision, float);
    NETVAR("DT_CSPlayer", "m_bNightVisionOn", m_bNightVisionOn, float);
    NETVAR("DT_CSPlayer", "m_iHealth", health, int);
    NETVAR("DT_CSPlayer", "m_lifeState", life_state, int);
    NETVAR("DT_CSPlayer", "m_fFlags", flags, int);
    NETVAR("DT_BasePlayer", "m_viewPunchAngle", punch_angle, vec3_t);
    NETVAR("DT_BasePlayer", "m_aimPunchAngle", aim_punch_angle, vec3_t);
    NETVAR("DT_BasePlayer", "m_vecVelocity[0]", velocity, vec3_t);
    NETVAR("DT_BasePlayer", "m_flMaxspeed", max_speed, float);
    NETVAR("DT_BaseEntity", "m_flShadowCastDistance", m_flFOVTime, float);
    NETVAR("DT_BasePlayer", "m_hObserverTarget", observer_target, unsigned long);
    NETVAR("DT_BasePlayer", "m_nHitboxSet", hitbox_set, int);
    NETVAR("DT_CSPlayer", "m_flDuckAmount", duck_amount, float);
    NETVAR("DT_CSPlayer", "m_bHasHeavyArmor", has_heavy_armor, bool);
    NETVAR("DT_PlantedC4", "m_flC4Blow", c4_blow_time, float);
    NETVAR("DT_SmokeGrenadeProjectile", "m_nSmokeEffectTickBegin", smoke_grenade_tick_begin, int);
    NETVAR("DT_CSPlayer", "m_nTickBase", get_tick_base, int);

    weapon_t* active_weapon() {
        auto active_weapon = read<DWORD>(netvar_manager::get_net_var(netvar_manager::fnv::hash("DT_CSPlayer"), netvar_manager::fnv::hash("m_hActiveWeapon"))) & 0xFFF;
        return reinterpret_cast<weapon_t*>(interfaces::entity_list->get_client_entity(active_weapon));
    }

    bool has_c4() {
        static auto ret = reinterpret_cast<bool(__thiscall*)(void*)>(utilities::pattern_scan(GetModuleHandleA("client_panorama.dll"), "56 8B F1 85 F6 74 31"));
        return ret(this);
    }

    vec3_t get_eye_pos() {
        return origin() + view_offset(); //hazedumper
    }

    bool can_see_player_pos(player_t* player, const vec3_t& pos) {
        trace_t tr;
        ray_t ray;
        trace_filter filter;
        filter.skip = this;

        auto start = get_eye_pos();
        auto dir = (pos - start).normalized();

        ray.initialize(start, pos);
        interfaces::trace_ray->trace_ray(ray, MASK_SHOT | CONTENTS_GRATE, &filter, &tr);

        return tr.entity == player || tr.flFraction > 0.97f;
    }

    vec3_t get_bone_position(int bone) {
        matrix_t bone_matrices[128];
        if (setup_bones(bone_matrices, 128, 256, 0.0f))
            return vec3_t{ bone_matrices[bone][0][3], bone_matrices[bone][1][3], bone_matrices[bone][2][3] };
        else
            return vec3_t{ };
    }

    vec3_t get_hitbox_position(player_t* entity, int hitbox_id) {
        matrix_t bone_matrix[MAXSTUDIOBONES];

        if (entity->setup_bones(bone_matrix, MAXSTUDIOBONES, BONE_USED_BY_HITBOX, 0.0f)) {
            auto studio_model = interfaces::model_info->get_studio_model(entity->model());

            if (studio_model) {
                auto hitbox = studio_model->hitbox_set(0)->hitbox(hitbox_id);

                if (hitbox) {
                    auto min = vec3_t{}, max = vec3_t{};

                    math.transform_vector(hitbox->mins, bone_matrix[hitbox->bone], min);
                    math.transform_vector(hitbox->maxs, bone_matrix[hitbox->bone], max);

                    return vec3_t((min.x + max.x) * 0.5f, (min.y + max.y) * 0.5f, (min.z + max.z) * 0.5f);
                }
            }
        }
        return vec3_t{};
    }

    bool is_enemy() {
        static auto danger_zone = interfaces::console->get_convar("game_type");

        if (!is_in_local_team() || danger_zone->get_int() == 6)
            return true;
        else
            return false;
    }

    bool is_in_local_team() {
        return utilities::call_virtual<bool(__thiscall*)(void*)>(this, 92)(this);
    }

    bool is_alive() {
        return life_state() == 0;
    }

    bool is_moving() {
        if (this->velocity().length() > 0.1f)
            return true;

        return false;
    }

    bool is_in_air() {
        if (this->flags() & fl_onground)
            return false;

        return true;
    }

    bool is_flashed() {
        if (this->flash_duration() > 0.0f)
            return true;

        return false;
    }

    void update_client_side_animations() {
        using original_fn = void(__thiscall*)(void*);
        (*(original_fn**)this)[221](this);
    }

    vec3_t & abs_origin() {
        using original_fn = vec3_t & (__thiscall*)(void*);
        return (*(original_fn**)this)[10](this);;
    }
    vec3_t & abs_angles() {
        using original_fn = vec3_t & (__thiscall*)(void*);
        return (*(original_fn**)this)[11](this);;
    }
    int move_type() {
        return *reinterpret_cast<int*> (reinterpret_cast<uintptr_t>(this) + 0x25C); //hazedumper
    }
    vec3_t eye_pos() {
        vec3_t ret;
        utilities::call_virtual<void(__thiscall*)(void*, vec3_t&)>(this, 281)(this, ret); // this is the real eye pos
        return ret;
    }

    int* weapons() { //tu jesli skinchanger
        return reinterpret_cast<int*> (uintptr_t(this) + 0x2DF8);
    } 
};

带有netvar func的头文件：

#define NETVAR(table, prop, func_name, type) \
        type& func_name( ) { \
          static uintptr_t offset = 0; \
          if(!offset) \
          { offset = netvar_manager::get_net_var(netvar_manager::fnv::hash( table ), netvar_manager::fnv::hash( prop ) ); } \
          \
          return *reinterpret_cast< type* >( uintptr_t( this ) + offset ); \
        }

    #define NETVAR_PTR(table, prop, func_name, type) \
        type* func_name( ) { \
          static uintptr_t offset = 0; \
          if(!offset) \
          { offset = netvar_manager::get_net_var(netvar_manager::fnv::hash( table ), netvar_manager::fnv::hash( prop ) ); } \
          \
          return reinterpret_cast< type* >( uintptr_t( this ) + offset ); \
        }

    #define OFFSET(type, var, offset) \
        type& var() { \
            return *(type*)(uintptr_t(this) + offset); \
        } \

编辑2:我删除了32，它编译得很好，但是程序本身不能工作

visual-studio

c++11

回答 1

Stack Overflow用户

发布于 2019-06-13 03:26:10

因此，正如怀疑的那样，问题出在NETVAR的定义方式上：

type& func_name( ) { \

此行将尝试返回char[32]，它不是方法的有效返回类型。删除[32]也不能修复它，因为它丢失了您实际上需要指向变量的指针的事实，因为您想要返回的不是char，而是char*。您可以尝试使用NETVAR_PTR，它可能会工作并返回正确的值，但是您需要将char而不是char[32]传递给type参数。这将返回char*，您必须小心，不要写超过31个字符，并自己维护空结束符。

值得注意的是，这一切都非常依赖于ABI，如果破坏了这一点，不要感到惊讶，因为ABI不是Windows上最稳定的东西。

值得注意的是，一些清晰的模板编程可以使用类型特征来修复返回类型问题：

std::conditional_t<std::is_array_v<type>, std::decay_t<type>, type> func_name \

它的条件要么是一个指针，要么是最初传递的任何类型，这取决于它是否是一个数组。

票数 0

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/56567684

复制

相似问题

问意外的标识符char[32]
EN

回答 1

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问意外的标识符char[32]EN

回答 1

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问意外的标识符char[32]
EN