mirror of
https://github.com/alliedmodders/amxmodx.git
synced 2024-10-17 15:56:52 +03:00
362 lines
8.8 KiB
C++
Executable File
362 lines
8.8 KiB
C++
Executable File
/*
|
|
* TSX
|
|
* Copyright (c) 2004 Lukasz Wlasinski
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* In addition, as a special exception, the author gives permission to
|
|
* link the code of this program with the Half-Life Game Engine ("HL
|
|
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
|
|
* L.L.C ("Valve"). You must obey the GNU General Public License in all
|
|
* respects for all of the code used other than the HL Engine and MODs
|
|
* from Valve. If you modify this file, you may extend this exception
|
|
* to your version of the file, but you are not obligated to do so. If
|
|
* you do not wish to do so, delete this exception statement from your
|
|
* version.
|
|
*
|
|
*/
|
|
|
|
#include "amxxmodule.h"
|
|
#include "CRank.h"
|
|
#include "tsx.h"
|
|
|
|
// *****************************************************
|
|
// class Stats
|
|
// *****************************************************
|
|
Stats::Stats(){
|
|
hits = shots = damage = hs = tks = kills = deaths = 0;
|
|
memset( bodyHits , 0 ,sizeof( bodyHits ) );
|
|
}
|
|
void Stats::commit(Stats* a){
|
|
hits += a->hits;
|
|
shots += a->shots;
|
|
damage += a->damage;
|
|
hs += a->hs;
|
|
tks += a->tks;
|
|
kills += a->kills;
|
|
deaths += a->deaths;
|
|
for(int i = 1; i < 8; ++i)
|
|
bodyHits[i] += a->bodyHits[i];
|
|
}
|
|
|
|
// *****************************************************
|
|
// class RankSystem
|
|
// *****************************************************
|
|
RankSystem::RankStats::RankStats( const char* uu, const char* nn, RankSystem* pp ) {
|
|
name = 0;
|
|
namelen = 0;
|
|
unique = 0;
|
|
uniquelen = 0;
|
|
score = 0;
|
|
parent = pp;
|
|
id = ++parent->rankNum;
|
|
next = prev = 0;
|
|
setName( nn );
|
|
setUnique( uu );
|
|
}
|
|
RankSystem::RankStats::~RankStats() {
|
|
delete[] name;
|
|
delete[] unique;
|
|
--parent->rankNum;
|
|
}
|
|
void RankSystem::RankStats::setName( const char* nn ) {
|
|
delete[] name;
|
|
namelen = strlen(nn) + 1;
|
|
name = new char[namelen];
|
|
if ( name )
|
|
strcpy( name , nn );
|
|
else
|
|
namelen = 0;
|
|
}
|
|
void RankSystem::RankStats::setUnique( const char* nn ) {
|
|
delete[] unique;
|
|
uniquelen = strlen(nn) + 1;
|
|
unique = new char[uniquelen];
|
|
if ( unique )
|
|
strcpy( unique , nn );
|
|
else
|
|
uniquelen = 0;
|
|
}
|
|
|
|
RankSystem::RankSystem() {
|
|
head = 0;
|
|
tail = 0;
|
|
rankNum = 0;
|
|
calc.code = 0;
|
|
}
|
|
|
|
RankSystem::~RankSystem() {
|
|
clear();
|
|
}
|
|
|
|
void RankSystem::put_before( RankStats* a, RankStats* ptr ){
|
|
a->next = ptr;
|
|
if ( ptr ){
|
|
a->prev = ptr->prev;
|
|
ptr->prev = a;
|
|
}
|
|
else{
|
|
a->prev = head;
|
|
head = a;
|
|
}
|
|
if ( a->prev ) a->prev->next = a;
|
|
else tail = a;
|
|
}
|
|
void RankSystem::put_after( RankStats* a, RankStats* ptr ) {
|
|
a->prev = ptr;
|
|
if ( ptr ){
|
|
a->next = ptr->next;
|
|
ptr->next = a;
|
|
}
|
|
else{
|
|
a->next = tail;
|
|
tail = a;
|
|
}
|
|
if ( a->next ) a->next->prev = a;
|
|
else head = a;
|
|
}
|
|
|
|
void RankSystem::unlink( RankStats* ptr ){
|
|
if (ptr->prev) ptr->prev->next = ptr->next;
|
|
else tail = ptr->next;
|
|
if (ptr->next) ptr->next->prev = ptr->prev;
|
|
else head = ptr->prev;
|
|
}
|
|
|
|
void RankSystem::clear(){
|
|
while( tail ){
|
|
head = tail->next;
|
|
delete tail;
|
|
tail = head;
|
|
}
|
|
}
|
|
|
|
bool RankSystem::loadCalc(const char* filename, char* error)
|
|
{
|
|
if ((MF_LoadAmxScript(&calc.amx,&calc.code,filename,error,0)!=AMX_ERR_NONE)||
|
|
(MF_AmxAllot(&calc.amx, 8 , &calc.amxAddr1, &calc.physAddr1)!=AMX_ERR_NONE)||
|
|
(MF_AmxAllot(&calc.amx, 8 , &calc.amxAddr2, &calc.physAddr2)!=AMX_ERR_NONE)||
|
|
(MF_AmxFindPublic(&calc.amx,"get_score",&calc.func)!=AMX_ERR_NONE)){
|
|
MF_PrintSrvConsole("Couldn't load plugin (file \"%s\")",filename);
|
|
MF_UnloadAmxScript(&calc.amx, &calc.code);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
void RankSystem::unloadCalc()
|
|
{
|
|
MF_UnloadAmxScript(&calc.amx , &calc.code);
|
|
}
|
|
|
|
RankSystem::RankStats* RankSystem::findEntryInRank(const char* unique, const char* name, bool isip)
|
|
{
|
|
RankStats* a = head;
|
|
|
|
if (isip) // IP lookups need to strip the port from already saved instances.
|
|
{ // Otherwise the stats file would be essentially reset.
|
|
|
|
// The IP passed does not contain the port any more for unique
|
|
size_t iplen = strlen(unique);
|
|
|
|
|
|
while ( a )
|
|
{
|
|
const char* targetUnique = a->getUnique();
|
|
if ( strncmp( targetUnique, unique, iplen) == 0 )
|
|
{
|
|
// It mostly matches, make sure this isn't a false match
|
|
// eg: checking 4.2.2.2 would match 4.2.2.24 here.
|
|
|
|
// Get the next character stored in targetUnique
|
|
char c = targetUnique[iplen];
|
|
|
|
// If c is either a colon or end of line, then this
|
|
// is a valid match.
|
|
if (c == ':' ||
|
|
c == '\0')
|
|
{
|
|
// Yes, this is a match.
|
|
return a;
|
|
}
|
|
// Any other case was a false match.
|
|
a = a->prev;
|
|
}
|
|
}
|
|
}
|
|
else // No special case
|
|
{
|
|
while ( a )
|
|
{
|
|
if ( strcmp( a->getUnique() ,unique ) == 0 )
|
|
return a;
|
|
|
|
a = a->prev;
|
|
}
|
|
}
|
|
a = new RankStats( unique ,name,this );
|
|
if ( a == 0 ) return 0;
|
|
put_after( a , 0 );
|
|
return a;
|
|
}
|
|
|
|
void RankSystem::updatePos( RankStats* rr , Stats* s )
|
|
{
|
|
rr->addStats( s );
|
|
|
|
if ( calc.code ) {
|
|
calc.physAddr1[0] = rr->kills;
|
|
calc.physAddr1[1] = rr->deaths;
|
|
calc.physAddr1[2] = rr->hs;
|
|
calc.physAddr1[3] = rr->tks;
|
|
calc.physAddr1[4] = rr->shots;
|
|
calc.physAddr1[5] = rr->hits;
|
|
calc.physAddr1[6] = rr->damage;
|
|
for(int i = 1; i < 8; ++i)
|
|
calc.physAddr2[i] = rr->bodyHits[i];
|
|
cell result = 0;
|
|
int err;
|
|
MF_AmxPush(&calc.amx, calc.amxAddr2);
|
|
MF_AmxPush(&calc.amx, calc.amxAddr1);
|
|
if ((err = MF_AmxExec(&calc.amx, &result, calc.func)) != AMX_ERR_NONE)
|
|
MF_Log("Run time error %d on line (plugin \"%s\")", err, LOCALINFO("csstats_score"));
|
|
rr->score = result;
|
|
}
|
|
else rr->score = rr->kills - rr->deaths;
|
|
|
|
RankStats* aa = rr->next;
|
|
while ( aa && (aa->score <= rr->score) ) { // try to nominate
|
|
rr->goUp();
|
|
aa->goDown();
|
|
aa = aa->next; // go to next rank
|
|
}
|
|
if ( aa != rr->next )
|
|
{
|
|
unlink( rr );
|
|
put_before( rr, aa );
|
|
}
|
|
else
|
|
{
|
|
aa = rr->prev;
|
|
while ( aa && (aa->score > rr->score) ) { // go down
|
|
rr->goDown();
|
|
aa->goUp();
|
|
aa = aa->prev; // go to prev rank
|
|
}
|
|
if ( aa != rr->prev ){
|
|
unlink( rr );
|
|
put_after( rr, aa );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Who put these backwards...
|
|
*/
|
|
#define TRYREAD(t_var, t_num, t_size, t_file) \
|
|
if (fread(t_var, t_size, t_num, t_file) != static_cast<size_t>(t_num)) { \
|
|
break; \
|
|
}
|
|
|
|
void RankSystem::loadRank(const char* filename)
|
|
{
|
|
FILE *bfp = fopen(filename , "rb");
|
|
|
|
if (!bfp)
|
|
{
|
|
MF_Log("Could not load stats file: %s", filename);
|
|
return;
|
|
}
|
|
|
|
short int i = 0;
|
|
if (fread(&i, sizeof(short int), 1, bfp) != 1)
|
|
{
|
|
fclose(bfp);
|
|
return;
|
|
}
|
|
|
|
if (i == RANK_VERSION)
|
|
{
|
|
Stats d;
|
|
char unique[64], name[64];
|
|
if (fread(&i, sizeof(short int), 1, bfp) != 1)
|
|
{
|
|
fclose(bfp);
|
|
return;
|
|
}
|
|
|
|
while(i && !feof(bfp))
|
|
{
|
|
TRYREAD(name, i, sizeof(char), bfp);
|
|
TRYREAD(&i, 1, sizeof(short int), bfp);
|
|
TRYREAD(unique, i, sizeof(char), bfp);
|
|
TRYREAD(&d.tks, 1, sizeof(int), bfp);
|
|
TRYREAD(&d.damage, 1, sizeof(int), bfp);
|
|
TRYREAD(&d.deaths, 1, sizeof(int), bfp);
|
|
TRYREAD(&d.kills, 1, sizeof(int), bfp);
|
|
TRYREAD(&d.shots, 1, sizeof(int), bfp);
|
|
TRYREAD(&d.hits, 1, sizeof(int), bfp);
|
|
TRYREAD(&d.hs, 1, sizeof(int), bfp);
|
|
TRYREAD(d.bodyHits, 1, sizeof(d.bodyHits), bfp);
|
|
TRYREAD(&i, 1, sizeof(short int), bfp);
|
|
|
|
RankSystem::RankStats* a = findEntryInRank( unique , name );
|
|
if ( a ) a->updatePosition( &d );
|
|
}
|
|
}
|
|
|
|
fclose(bfp);
|
|
}
|
|
|
|
void RankSystem::saveRank( const char* filename )
|
|
{
|
|
FILE *bfp = fopen(filename, "wb");
|
|
|
|
if ( !bfp ) return;
|
|
|
|
short int i = RANK_VERSION;
|
|
|
|
fwrite(&i, 1, sizeof(short int) , bfp);
|
|
|
|
RankSystem::iterator a = front();
|
|
|
|
while ( a )
|
|
{
|
|
if ( (*a).score != (1<<31) ) // score must be different than mincell
|
|
{
|
|
fwrite( &(*a).namelen , 1, sizeof(short int), bfp);
|
|
fwrite( (*a).name , (*a).namelen , sizeof(char) , bfp);
|
|
fwrite( &(*a).uniquelen , 1, sizeof(short int), bfp);
|
|
fwrite( (*a).unique , (*a).uniquelen , sizeof(char) , bfp);
|
|
fwrite( &(*a).kills, 1, sizeof(int), bfp);
|
|
fwrite( &(*a).deaths, 1, sizeof(int), bfp);
|
|
fwrite( &(*a).hs, 1, sizeof(int), bfp);
|
|
fwrite( &(*a).tks, 1, sizeof(int), bfp);
|
|
fwrite( &(*a).damage, 1, sizeof(int), bfp);
|
|
fwrite( &(*a).hits, 1, sizeof(int), bfp);
|
|
fwrite( &(*a).shots, 1, sizeof(int), bfp);
|
|
fwrite( (*a).bodyHits, 1, sizeof((*a).bodyHits), bfp);
|
|
}
|
|
|
|
--a;
|
|
}
|
|
|
|
i = 0;
|
|
fwrite( &i , 1, sizeof(short int), bfp); // null terminator
|
|
|
|
fclose(bfp);
|
|
}
|