[kramesa]

Hi! I have this plugin:

PHP Code:

#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <csx>
#include <sqlx>
#include <engine>
#include <hamsandwich>

#pragma semicolon 1

const MaxSlots = 32;
const MaxSteamIdChars = 35;

enum _:DataTypes 
{
    _Data_Kills,
    _Data_Deaths,
    _Data_Headshots,
    _Data_Wins,
    _Data_Losses,
    _Data_Points,
    _Data_TotalDamage,
    _Data_BD,
    _Data_BP,
    _Data_Leaves
};

new PlayerData[MaxSlots + 1][DataTypes];

new SteamId[MaxSlots + 1][MaxSteamIdChars];

new MaxPlayers;

new Handle:SQLTuple;

new CvarPointsKill;
new CvarPointsHeadshot;
new CvarPointsWins;

new gTyping[33];
new ClientVotes[33];
new gReason[35];
new gVotes[2] = 0;
new gName[32];
new gTName[32];

new Uid;
new gUserID;
new gTempID;
new gVoteMenu;
new pCvarEnable;

public plugin_init() {    
    CvarPointsKill = register_cvar("points_kill", "2");
    CvarPointsHeadshot = register_cvar("points_headshot", "4");
    CvarPointsWins = register_cvar("points_win", "1");
    
    MaxPlayers = get_maxplayers();
    
    register_event("DeathMsg", "Event_DeathMsg", "a");
    
    register_event("SendAudio", "Event_SendAudio_TWin", "a", "2&%!MRAD_terwin");
    register_event("SendAudio", "Event_SendAudio_CTWin", "a", "2&%!MRAD_ctwin");
    
    RegisterHam(Ham_TakeDamage, "player", "FwdPlayerDamagePost", 1);
}

public plugin_cfg() {
    SQLTuple = SQL_MakeStdTuple(); 
    PrepareDatabase();
}

PrepareDatabase() {
    new Query[512];
    formatex(Query, charsmax(Query), "CREATE TABLE IF NOT EXISTS ranking (kills int(10), deaths int(10), headshots int(10), wins int(10), losses int(10), points int(10), total_damage int(10), bd int(10), bp int(10), leaves int(10), steamid varchar(35), name varchar(32), PRIMARY KEY(steamid))");
    
    SQL_ThreadQuery(SQLTuple, "QueryDefaultHandle", Query);
}

public QueryDefaultHandle(FailState, Handle:Query, Error[], ErrorCode, Data[], DataSize, Float:QueueTime) {
    switch(FailState) {
        case TQUERY_CONNECT_FAILED: {
            set_fail_state("SQL: Connection failed.");
        }
        case TQUERY_QUERY_FAILED: {
            log_amx("SQL: Query failed. Error: %s (%i)", Error, ErrorCode);
        }
    }
}

SaveData(const Client) {
    new Query[512];
    new ClientName[MaxSlots];
    new ClientNameSafe[MaxSlots];
    get_user_name(Client, ClientName, charsmax(ClientName));
    MakeStringSQLSafe(ClientName, ClientNameSafe, charsmax(ClientName));
    
    formatex(Query, charsmax(Query), "REPLACE INTO ranking (kills, deaths, headshots, wins, losses, points, total_damage, bd, bp, leaves, steamid, name) VALUES (%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, '%s', '%s')", 
    PlayerData[Client][_Data_Kills], 
    PlayerData[Client][_Data_Deaths], 
    PlayerData[Client][_Data_Headshots], 
    PlayerData[Client][_Data_Wins], 
    PlayerData[Client][_Data_Losses], 
    PlayerData[Client][_Data_Points], 
    PlayerData[Client][_Data_TotalDamage], 
    PlayerData[Client][_Data_BD], 
    PlayerData[Client][_Data_BP], 
    PlayerData[Client][_Data_Leaves], 
    SteamId[Client], 
    ClientNameSafe
    );
    
    SQL_ThreadQuery(SQLTuple, "QueryDefaultHandle", Query);
}

MakeStringSQLSafe(const Input[], Output[], Len)
{
    copy(Output, Len, Input );
    replace_all(Output, Len, "'", "*");
    replace_all(Output, Len, "^"", "*");
    replace_all(Output, Len, "`", "*");
    
    remove_quotes(Output);
}

LoadData(const Client) {
    new Query[512], Data[2];
    formatex( Query, charsmax(Query),
    "SELECT * FROM ranking WHERE steamid = '%s'",
    SteamId[Client]
    );
    
    Data[0] = Client;
    SQL_ThreadQuery(SQLTuple, "QueryLoadData", Query, Data, charsmax(Data));
}

public QueryLoadData(FailState, Handle:Query, Error[], ErrorCode, Data[], DataSize, Float:QueueTime) {
    switch(FailState) {
        case TQUERY_CONNECT_FAILED:
        {
            set_fail_state("SQL: Connection failed.");
        }
        case TQUERY_QUERY_FAILED: {
            log_amx("SQL: Query failed. Error: %s (%i)", Error, ErrorCode);
        }
        default: {
            SQL_GetResults(Query, Data);
        }
    }
}

SQL_GetResults(Handle:Query, const Data[]) {
    new Client = Data[0];
    
    if(SQL_NumResults(Query)) {
        for(new DataIndex = 0; DataIndex < DataTypes; DataIndex++) {
            PlayerData[Client][DataIndex] = SQL_ReadResult(Query, DataIndex);
        }
    }
}

public client_authorized(Client) {    
    get_user_authid(Client, SteamId[Client], charsmax(SteamId[]));
    
    DefaultVariables(Client);
    
    LoadData(Client);
    
    ClientVotes[Client] = 0;
}

public client_disconnect(Client) {
    PlayerData[Client][_Data_Leaves]++;
    
    SaveData(Client);
    
    DefaultVariables(Client);
    
    SteamId[Client][0] = 0;
}

DefaultVariables(const Client) {
    for(new DataIndex = 0; DataIndex < DataTypes; DataIndex++) {
        PlayerData[Client][DataIndex] = 0;
    }
}

public Event_DeathMsg() {
    new Attacker = read_data(1);
    new Victim = read_data(2);
    
    if((1 <= Attacker <= MaxPlayers) && (1 <= Victim <= MaxPlayers)&& (Victim != Attacker) && is_user_connected(Victim) && is_user_connected(Attacker)) {
        new Points   = get_pcvar_num(CvarPointsKill);
        new Headshot = read_data(3);
        
        if(Headshot) {
            Points += get_pcvar_num(CvarPointsHeadshot);
            
            PlayerData[Attacker][_Data_Headshots]++;
        }
        
        PlayerData[Attacker][_Data_Points] += Points;
        
        PlayerData[Attacker][_Data_Kills]++;
        PlayerData[Victim][_Data_Deaths]++;
    }
    else if(!Attacker) {
        PlayerData[Victim][_Data_Deaths]++;
    }
    SaveData(Victim);
    SaveData(Attacker);
}

public Event_SendAudio_TWin()
    TeamWin(CS_TEAM_T);

public Event_SendAudio_CTWin()
    TeamWin(CS_TEAM_CT);

TeamWin(CsTeams:winner) {
    new CsTeams:loser = CS_TEAM_SPECTATOR - winner;
    new Points = get_pcvar_num(CvarPointsWins);
    
    for( new Client = 1, CsTeams:team; Client <= MaxPlayers; Client++) {
        if(is_user_connected(Client)) {
            team = cs_get_user_team(Client);
            
            if(team == winner) {
                PlayerData[Client][_Data_Points] += Points;
                PlayerData[Client][_Data_Wins]++;
            }
            else if(team == loser) {
                PlayerData[Client][_Data_Losses]++;
            }
        }
        SaveData(Client);
    }
}

public FwdPlayerDamagePost(victim, inflictor, attacker, Float:damage, damageBits) {
    if(1 <= attacker <= MaxPlayers && victim != attacker) {
        PlayerData[attacker][_Data_TotalDamage] += floatround(floatmin(100.0, entity_get_float(victim, EV_FL_dmg_take)));
    }
}

public bomb_defused(Client) {
    PlayerData[Client][_Data_Points]++;
    PlayerData[Client][_Data_BD]++;
    SaveData(Client);
}

public bomb_planted(Client) {
    PlayerData[Client][_Data_Points]++;
    PlayerData[Client][_Data_BP]++;
    SaveData(Client);
}

public plugin_end()
    SQL_FreeHandle(SQLTuple); 


But, I can compile this! The compiler crash...

And, anyone can 'optmize' this code?

Thanks

EDIT: Sorry, wrong forum. Please, admin, move this forum to sug/req

[Arkshine]

Don't make line too long. You have 1 line way too long. Move the vars on a new line.

[Exolent[jNr]]

All you have to do is comment pieces out one at a time to figure out what's crashing the compiler.

Derp.

[kramesa]

Originally Posted by Arkshine Don't make line too long. You have 1 line way too long. Move the vars on a new line.

Ok, thanks!

But, I have problem! Some players have ranking reseted... I use reconnect features, have problem?

[Exolent[jNr]]

You are threading your SQL queries. This means that this scenario is possible:
1. Player connects
2. Query threaded to load player data
3. Player kills another player
4. Query threaded to save player data (with all empty data except 1 kill)
5. Load query finishes, player has full data in variables
6. Save query finishes, player has empty data except 1 kill in database

[kramesa]

Originally Posted by Exolent[jNr] You are threading your SQL queries. This means that this scenario is possible: 1. Player connects 2. Query threaded to load player data 3. Player kills another player 4. Query threaded to save player data (with all empty data except 1 kill) 5. Load query finishes, player has full data in variables 6. Save query finishes, player has empty data except 1 kill in database

Ok, but how can I fix this?

[Exolent[jNr]]

Don't save stats until the loading is done.

[kramesa]

Originally Posted by Exolent[jNr] Don't save stats until the loading is done.

And how I now when loading is done?

[Exolent[jNr]]

You already do:

PHP Code:

public QueryLoadData(FailState, Handle:Query, Error[], ErrorCode, Data[], DataSize, Float:QueueTime) { 


[kramesa]

Originally Posted by Exolent[jNr] You already do: PHP Code: public QueryLoadData(FailState, Handle:Query, Error[], ErrorCode, Data[], DataSize, Float:QueueTime) {

But you think the problem of reset rank is this?

And I really need use #pragma semicolon 1?

Thank you