hlmod.hu

szevasztok
több kérdésem is lenne ezzel a pluginnal kapcsolatban.
1. Ez működik?
2. Lecseréli a shoot hangokat is?
3. Megvan valakinek a fakemeta_stocks féle INC mert nekem nincs ilyen.

#include <amxmodx>
#include <fakemeta>
#include <fakemeta_stocks>


new const REPLACEMENTFILE[] = "addons/amxmodx/configs/sr.cfg";
new const WORKAROUNDKEYWORD[] = "-SUPPORT"; // Should not be confusable for a sound replacement line
const MAXENTRIES = 96;
const MAXPATHLENGTH = 191;


new const VERSION[]=  "1.2";


new i;
new precacheF;
new column1[MAXENTRIES][MAXPATHLENGTH+1];
new column2[MAXENTRIES][MAXPATHLENGTH+1];
new bool:plist[MAXENTRIES];
new bool:ncSEF = true;
new ds;
new replaced;
new bool:ignore;


public plugin_precache() {
   register_plugin("Sound replacements", VERSION, "Silencer")
   if(file_exists(REPLACEMENTFILE)) {
      new len = file_size(REPLACEMENTFILE, 1); // Amount of lines in file
      const arrays=4*MAXPATHLENGTH+4; // Much space for spaces and tabs between sound paths
      new line[arrays];
      new skipline;
      new workaround = MAXPATHLENGTH; // Workaround a false tag mismatch positive by the Pawn compiler
      ds = is_dedicated_server();
      if(!ds) {
         log_amx("[SR] Attention: Running a listenserver -> *.gcf-files are being used -> Cannot verify existence of sound files -> Invalid paths may cause the server to crash.");
      }
      new clipboard1[MAXPATHLENGTH+1];
      new clipboard2[MAXPATHLENGTH+1];
      new failures;
      new overmax;
      new file = fopen(REPLACEMENTFILE, "r");
      if(!file) {
         log_amx("[SR] Error: Cannot open Sound replacement file ^"%s^".", REPLACEMENTFILE);
         set_fail_state("Cannot open file");
      }
      for(i = 0; i < len-skipline; i++) {
         fgets(file, line, arrays-1);
         trim(line);
         if(contain(line, "//") == 0) { // skip comments
            i--; skipline++;
         } else if(equali(line, WORKAROUNDKEYWORD)) {
               ncSEF = false;
               i--; skipline++;
         } else if(strlen(line)) {
            new bool:multi
            new bool:fail
            parse(line, clipboard1, MAXPATHLENGTH+1, clipboard2, MAXPATHLENGTH+1);
            if(clipboard1[workaround] != 0) {
               log_amx("[SR] Warning: Origin sound file path in line %i of sound replacement file is longer than %i chars! Not using.", i+skipline+1, MAXPATHLENGTH);
               i--; skipline++; failures++; fail = true;
               clipboard1[MAXPATHLENGTH] = 0;
            } else if(clipboard2[workaround] != 0) {
               log_amx("[SR] Warning: Target sound file path in line %i of sound replacement file is longer than %i chars! Not using.", i+skipline+1, MAXPATHLENGTH);
               i--; skipline++; failures++; fail = true;
               clipboard2[MAXPATHLENGTH] = 0;
            } else if(equali(clipboard1, clipboard2)) {
               log_amx("[SR] Warning: Target and Origin sound file path in line %i of sound replacement file are the same! Not using.", i+skipline+1);
               i--; skipline++; failures++; fail = true;
            } else if(i > 0) {
               for(new m = 0; m < i; m++) {
                  if(equali(clipboard1, column1[m])) {
                     log_amx("[SR] Warning: Replacement for Target sound file path in line %i of sound replacement file already set! Not using.", i+skipline+1);
                     i--; skipline++; failures++;
                     multi = true; // fail = true; // Not needed, since multi is already true
                     break;
                  }
               }
            }
            if(!multi) {
               if(ds) { // HLDS does not use *.gcf-files, so do safety-checks
                  if(!file_exists(clipboard1)) {
                     log_amx("[SR] Warning: Origin sound file path in line %i of sound replacement file does not exist! Not using.", i+skipline+1);
                     i--; skipline++; failures++; fail = true;
                  } else if(!file_exists(clipboard2)) {
                     log_amx("[SR] Warning: Target sound file path in line %i of sound replacement file does not exist! Not using.", i+skipline+1);
                     i--; skipline++; failures++; fail = true;
                  }
               }
               if(!fail) {
                  if(i >= MAXENTRIES) {
                     i--; skipline++; overmax++;
                  } else {
                     
                     copy(column1[i], MAXPATHLENGTH, clipboard1);
                     copy(column2[i], MAXPATHLENGTH, clipboard2);
                  }
               }
            }
         } else {
            i--; skipline++;
         }
      }
      fclose(file);
      if(i > 0) {
         if(ncSEF) {
            log_amx("[SR] %i sound(s) will be replaced when used by the map...", i);
            precacheF = register_forward(FM_PrecacheSound, "sr_ps", 0);
         } else {
            log_amx("[SR] Attention: Using support for custom sound engines. The game may cost more resources and be closer to the sound precache limit.");
            for(new l = 0; l < i; l++) {
               EF_PrecacheSound(column2[l]);
               //plist[l] = true; // In this case, plist is not being used
               replaced++;
            }
            log_amx("[SR] %i sound(s) will be hooked up to be replaced when played.", i);
         }
         if(failures)
            log_amx("[SR] %i sound(s) will not be replaced because of errors in the configurations file.", failures)
         if(overmax)
            log_amx("[SR] %i sound(s) will not be replaced because the sound replacements limit of %i has been reached.", overmax, MAXENTRIES)
         if(!failures && !overmax)
            log_amx("[SR] Parsed sound replacement file flawlessly.")
         register_forward(FM_EmitSound, "sr_es", 0);
         register_forward(FM_EmitAmbientSound, "sr_eas", 0);
         register_forward(FM_BuildSoundMsg, "sr_bsm", 0);
      } else {
         log_amx("[SR] Error: Zero sounds replaced.");
         set_fail_state("Nothing to replace");
      }
   } else {
      log_amx("[SR] Error: Sound replacement file ^"%s^" not found.", REPLACEMENTFILE);
      set_fail_state("File not found");
   }
}

public sr_ps(const szSample[]) {
   if(!ignore) {
      for(new j = 0; j < i; j++) {
         if(equali(szSample, column1[j])) {
            if(!plist[j]) { // Prevent double precaches
               ignore = true;
               EF_PrecacheSound(column2[j]);
               ignore = false;
               plist[j] = true;
               replaced++;
            }
            return FMRES_SUPERCEDE;
         }
      }
   }
   return FMRES_IGNORED;
}

public sr_es(ent, iChannel, const szSample[], Float:fVolume, Float:fAttenuation, iFlags, iPitch) {
   for(new j = 0; j < i; j++) {
      if(equali(szSample, column1[j])) {
         EF_EmitSound(ent, iChannel, column2[j], fVolume, fAttenuation, iFlags, iPitch);
         return FMRES_SUPERCEDE;
      }
   }
   return FMRES_IGNORED;
}

public sr_eas(ent, Float:fOrigin[3], const szSample[], Float:fVolume, Float:fAttenuation, iFlags, iPitch) {
   for(new j = 0; j < i; j++) {
      if(equali(szSample, column1[j])) {
         EF_EmitAmbientSound(ent, fOrigin, column2[j], fVolume, fAttenuation, iFlags, iPitch);
         return FMRES_SUPERCEDE;
      }
   }
   return FMRES_IGNORED;
}

public sr_bsm(ent, iChannel, const szSample[], Float:fVolume, Float:fAttenuation, iFlags, iPitch, iMsg_Dest, iMsg_Type, const Float:fOrigin[3], ent2) {
   for(new j = 0; j < i; j++) {
      if(equali(szSample, column1[j])) {
         EF_BuildSoundMSG(ent, iChannel, column2[j], fVolume, fAttenuation, iFlags, iPitch, iMsg_Dest, iMsg_Type, fOrigin, ent2);
         return FMRES_SUPERCEDE;
      }
   }
   return FMRES_IGNORED;
}

public plugin_init() {
   if(ncSEF) {
      unregister_forward(FM_PrecacheSound, precacheF, 0);
      log_amx("[SR] Out of %i sound files max., the necessary %i have been hooked up to be replaced when played.", i, replaced);
   }
}

1.Kell működjön,különben nem írták volna meg.
2.Shoot hangokat nem tudod lecserélni szerveren.
Idézem: "It won't work for client side sound effects."
3.www.google.hu

1.Pluginnal tudtom szerint nemlehet lecserelni
2.Hex-editor es atirod az alap filet

_________________
Idk. Csak ugy funbooo.

mi az a hex-editor?

Kár hogy ezek a binary szerkeztők szarrasem jók detector, mag keresni tudsz benne!

Miértne lehetne lecserélni a hangokat? Gondolj láncfűrészre vagy lángszóróra!

fakemeta_stocks:

/* FakeMeta stocks
*
* by the AMX Mod X Development Team
*
* This file is provided as is (no warranties).
*/

#if !defined _fakemeta_included
   #include <fakemeta>
#endif

#if defined _fakemeta_stocks_included
  #endinput
#endif
#define _fakemeta_stocks_included

// EngFuncs
stock EF_PrecacheModel(const string[])
   return engfunc(EngFunc_PrecacheModel, string);

stock EF_PrecacheSound(const string[])
   return engfunc(EngFunc_PrecacheSound, string);
stock EF_SetModel(const ID, const STRING[])
   return engfunc(EngFunc_SetModel, ID, STRING);
stock EF_ModelIndex(const STRING[])
   return engfunc(EngFunc_ModelIndex, STRING);
stock EF_ModelFrames(modelIndex)
   return engfunc(EngFunc_ModelFrames, modelIndex);

stock EF_SetSize(const ENTITY, const Float:MIN[3], const Float:MAX[3])
   return engfunc(EngFunc_SetSize, ENTITY, MIN, MAX);
stock EF_ChangeLevel(const S1[], const S2[])
   return engfunc(EngFunc_ChangeLevel, S1, S2);
stock EF_VecToYaw(const Float:VECTOR[3], &Float:returnValue)
   return engfunc(EngFunc_VecToYaw, VECTOR, returnValue);
stock EF_VecToAngles(const Float:VECTORIN[3], const Float:VECTOROUT[3])
   return engfunc(EngFunc_VecToAngles, VECTORIN, VECTOROUT);
stock EF_MoveToOrigin(const ENTITY, const Float:GOAL[3], const Float:DISTANCE, const MOVETYPE)
   return engfunc(EngFunc_MoveToOrigin, ENTITY, GOAL, DISTANCE, MOVETYPE);

stock EF_ChangeYaw(const ENTITY)
   return engfunc(EngFunc_ChangeYaw, ENTITY);
stock EF_ChangePitch(const ENTITY)
   return engfunc(EngFunc_ChangePitch, ENTITY);
stock EF_FindEntityByString(const STARTSEARCHAFTER, const FIELD[], const VALUE[])
   return engfunc(EngFunc_FindEntityByString, STARTSEARCHAFTER, FIELD, VALUE);
stock EF_GetEntityIllum(const ENTITY)
   return engfunc(EngFunc_GetEntityIllum, ENTITY);
stock EF_FindEntityInSphere(const STARTSEARCHAFTER, const Float:ORIGIN[3], Float:radius)
   return engfunc(EngFunc_FindEntityInSphere, STARTSEARCHAFTER, ORIGIN, radius);

stock EF_FindClientInPVS(const CLIENT)
   return engfunc(EngFunc_FindClientInPVS, CLIENT);
stock EF_EntitiesInPVS(const CLIENT)
   return engfunc(EngFunc_EntitiesInPVS, CLIENT);
stock EF_MakeVectors(const Float:VECTOR[3])
   return engfunc(EngFunc_MakeVectors, VECTOR);
stock EF_AngleVectors(const Float:VECTOR[3], Float:forward_[3], Float:right[3], Float:up[3])
   return engfunc(EngFunc_AngleVectors, VECTOR, forward_, right, up);
stock EF_CreateEntity()
   return engfunc(EngFunc_CreateEntity);

stock EF_RemoveEntity(const ENTITY)
   return engfunc(EngFunc_RemoveEntity, ENTITY);
stock EF_CreateNamedEntity(const CLASSNAME)
   return engfunc(EngFunc_CreateNamedEntity, CLASSNAME);
stock EF_MakeStatic(const ENTITY)
   return engfunc(EngFunc_MakeStatic, ENTITY);
stock EF_EntIsOnFloor(const ENTITY)
   return engfunc(EngFunc_EntIsOnFloor, ENTITY);
stock EF_DropToFloor(const ENTITY)
   return engfunc(EngFunc_DropToFloor, ENTITY);

stock EF_WalkMove(const ENTITY, Float:yaw, Float:distance, iMode)
   return engfunc(EngFunc_WalkMove, ENTITY, yaw, distance, iMode);
stock EF_SetOrigin(const ENTITY, const Float:ORIGIN[3])
   return engfunc(EngFunc_SetOrigin, ENTITY, ORIGIN);
stock EF_EmitSound(const ENTITY, channel, const SAMPLE[], Float:volume, Float:attenuation, fFlags, pitch)
   return engfunc(EngFunc_EmitSound, ENTITY, channel, SAMPLE, volume, attenuation, fFlags, pitch);
stock EF_EmitAmbientSound(const ENTITY, Float:pos[3], const SAMPLE[], Float:volume, Float:attenuation, fFlags, pitch)
   return engfunc(EngFunc_EmitAmbientSound, ENTITY, pos, SAMPLE, volume, attenuation, fFlags, pitch);
stock EF_TraceLine(const Float:V1[3], const Float:V2[3], fNoMonsters, const ENT_TO_SKIP)
   return engfunc(EngFunc_TraceLine, V1, V2, fNoMonsters, ENT_TO_SKIP);

stock EF_TraceToss(const ENTITY, const ENTITY_TO_IGNORE)
   return engfunc(EngFunc_TraceToss, ENTITY, ENTITY_TO_IGNORE);
stock EF_TraceMonsterHull(const ENTITY, const Float:V1[3], const Float:V2[3], fNoMonsters, const ENTITY_TO_SKIP)
   return engfunc(EngFunc_TraceMonsterHull, ENTITY, V1, V2, fNoMonsters, ENTITY_TO_SKIP);
stock EF_TraceHull(const Float:V1[3], const Float:V2[3], fNoMonsters, hullNumber, const ENTITY_TO_SKIP)
   return engfunc(EngFunc_TraceHull, V1, V2, fNoMonsters, hullNumber, ENTITY_TO_SKIP);
stock EF_TraceModel(const Float:V1[3], const Float:V2[3], hullNumber, const ENTITY)
   return engfunc(EngFunc_TraceModel, V1, V2, hullNumber, ENTITY);
stock EF_TraceTexture(const TEXTURE_ENTITY, const Float:V1[3], const Float:V2[3])
   return engfunc(EngFunc_TraceTexture, TEXTURE_ENTITY, V1, V2);

stock EF_TraceSphere(const Float:V1[3], const Float:V2[3], fNoMonsters, Float:radius, const ENTITY_TO_SKIP)
   return engfunc(EngFunc_TraceSphere, V1, V2, fNoMonsters, radius, ENTITY_TO_SKIP);
stock EF_GetAimVector(const ENTITY, Float:speed, Float:returnVector[3])
   return engfunc(EngFunc_GetAimVector, ENTITY, speed, returnVector);
stock EF_ParticleEffect(const Float:ORIGIN[3], const Float:DIRECTION[3], Float:color, Float:count)
   return engfunc(EngFunc_ParticleEffect, ORIGIN, DIRECTION, color, count);
stock EF_LightStyle(style, val[])
   return engfunc(EngFunc_LightStyle, style, val);
stock EF_DecalIndex(const NAME[])
   return engfunc(EngFunc_DecalIndex, NAME);

stock EF_PointContents(const Float:VECTOR[3])
   return engfunc(EngFunc_PointContents, VECTOR);
stock EF_FreeEntPrivateData(const ENTITY)
   return engfunc(EngFunc_FreeEntPrivateData, ENTITY);
stock EF_SzFromIndex(iString)
   return engfunc(EngFunc_SzFromIndex, iString);
stock EF_AllocString(const STRING[])
   return engfunc(EngFunc_AllocString, STRING);
stock EF_RegUserMsg(const NAME[], iSize)
   return engfunc(EngFunc_RegUserMsg, NAME, iSize);

stock EF_AnimationAutomove(const ENTITY, Float:flTime)
   return engfunc(EngFunc_AnimationAutomove, ENTITY, flTime);
stock EF_GetBonePosition(const ENTITY, iBone, Float:origin[3], Float:angles[3])
   return engfunc(EngFunc_GetBonePosition, ENTITY, iBone, origin, angles);
stock EF_GetAttachment(const ENTITY, iAttachment, Float:origin[3], Float:angles[3])
   return engfunc(EngFunc_GetAttachment, ENTITY, iAttachment, origin, angles);
stock EF_SetView(const CLIENT, const VIEW_ENTITY)
   return engfunc(EngFunc_SetView, CLIENT, VIEW_ENTITY);
stock EF_Time(&Float:returnValue)
   return engfunc(EngFunc_Time, returnValue);

stock EF_CrosshairAngle(const CLIENT, Float:pitch, Float:yaw)
   return engfunc(EngFunc_CrosshairAngle, CLIENT, pitch, yaw);
stock EF_FadeClientVolume(const ENTITY, fadePercent, fadeOutSeconds, holdTime, fadeInSeconds)
   return engfunc(EngFunc_FadeClientVolume, ENTITY, fadePercent, fadeOutSeconds, holdTime, fadeInSeconds);
stock EF_SetClientMaxspeed(const ENTITY, Float:newMaxspeed)
   return engfunc(EngFunc_SetClientMaxspeed, ENTITY, newMaxspeed);
stock EF_CreateFakeClient(const NETNAME[])
   return engfunc(EngFunc_CreateFakeClient, NETNAME);
stock EF_RunPlayerMove(const FAKECLIENT, const Float:VIEWANGLES[3], Float:forwardmove, Float:sidemove, Float:upmove, buttons, impulse, msec)
   return engfunc(EngFunc_RunPlayerMove, FAKECLIENT, VIEWANGLES, forwardmove, sidemove, upmove, buttons, impulse, msec);

stock EF_NumberOfEntities()
   return engfunc(EngFunc_NumberOfEntities);
stock EF_StaticDecal(const Float:ORIGIN[3], decalIndex, entityIndex, modelIndex)
   return engfunc(EngFunc_StaticDecal, ORIGIN, decalIndex, entityIndex, modelIndex);
stock EF_PrecacheGeneric(const STRING[])
   return engfunc(EngFunc_PrecacheGeneric, STRING);
stock EF_BuildSoundMSG(const ENTITY, channel, const SAMPLE[], Float:volume, Float:attenuation, fFlags, pitch, msg_dest, msg_type, const Float:ORIGIN[3], const ED)
   return engfunc(EngFunc_BuildSoundMsg, ENTITY, channel, SAMPLE, volume, attenuation, fFlags, pitch, msg_dest, msg_type, ORIGIN, ED);
stock EF_GetPhysicsKeyValue(const CLIENT, const KEY[])
   return engfunc(EngFunc_GetPhysicsKeyValue, CLIENT, KEY);

stock EF_SetPhysicsKeyValue(const CLIENT, const KEY[], const VALUE[])
   return engfunc(EngFunc_SetPhysicsKeyValue, CLIENT, KEY, VALUE);
stock EF_GetPhysicsInfoString(const CLIENT, returnString[], maxLength)
   return engfunc(EngFunc_GetPhysicsInfoString, CLIENT, returnString, maxLength);
stock EF_PrecacheEvent(type, const STRING[])
   return engfunc(EngFunc_PrecacheEvent, type, STRING);
stock EF_PlaybackEvent(flags, const INVOKER, eventindex, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iparam1, iparam2, bparam1, bparam2)
   return engfunc(EngFunc_PlaybackEvent, flags, INVOKER, eventindex, delay, origin, angles, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2);
stock EF_CheckVisibility(const ENTITY, set)
   return engfunc(EngFunc_CheckVisibility, ENTITY, set);

stock EF_GetCurrentPlayer()
   return engfunc(EngFunc_GetCurrentPlayer);
stock EF_CanSkipPlayer(const PLAYER)
   return engfunc(EngFunc_CanSkipPlayer, PLAYER);
stock EF_SetGroupMask(mask, op)
   return engfunc(EngFunc_SetGroupMask, mask, op);
stock EF_GetClientListening(receiver, sender)
   return engfunc(EngFunc_GetClientListening, receiver, sender);
stock EF_SetClientListening(receiver, sender, bool:listen)
   return engfunc(EngFunc_SetClientListening, receiver, sender, listen);

stock EF_MessageBegin(msg_dest, msg_type, const Float:ORIGIN[3], const ED)
   return engfunc(EngFunc_MessageBegin, msg_dest, msg_type, ORIGIN, ED);
stock EF_WriteCoord(Float:value)
   return engfunc(EngFunc_WriteCoord, value);
stock EF_WriteAngle(Float:value)
   return engfunc(EngFunc_WriteAngle, value);
stock EF_InfoKeyValue(const INFOBUFFER, const KEY[], returnValue[], maxLength)
   return engfunc(EngFunc_InfoKeyValue, INFOBUFFER, KEY, returnValue, maxLength);
stock EF_SetKeyValue(const INFOBUFFER, const KEY[], const VALUE[])
   return engfunc(EngFunc_SetKeyValue, INFOBUFFER, KEY, VALUE);

stock EF_SetClientKeyValue(const ID, const INFOBUFFER, const KEY[], const VALUE[])
   return engfunc(EngFunc_SetClientKeyValue, ID, INFOBUFFER, KEY, VALUE);

stock EF_CreateInstBaseline(CLASSNAME, baseline)
   return engfunc(EngFunc_CreateInstBaseline, CLASSNAME, baseline);

// Returns pointer to info buffer that can be used with the INFOBUFFER param
// of EF_InfoKeyValue, EF_SetKeyValue, and EF_SetClientKeyValue
stock EF_GetInfoKeyBuffer(const ENTITY)
   return engfunc(EngFunc_GetInfoKeyBuffer, ENTITY);
stock EF_ClientPrintf(const ENTITY, const printType, const MESSAGE[])
   return engfunc(EngFunc_ClientPrintf, ENTITY, printType, MESSAGE);
stock EF_ServerPrint(const MESSAGE[])
   return engfunc(EngFunc_ServerPrint, MESSAGE);

// DLLFuncs
stock DF_GameInit()
   return dllfunc(DLLFunc_GameInit);
stock DF_Spawn(const ENTITY)
   return dllfunc(DLLFunc_Spawn, ENTITY);
stock DF_Think(const ENTITY)
   return dllfunc(DLLFunc_Think, ENTITY);
stock DF_Use(const ENT_Used, const ENT_User)
   return dllfunc(DLLFunc_Use, ENT_Used, ENT_User);
stock DF_Touch(const ENT_Touched, const ENT_Toucher)
   return dllfunc(DLLFunc_Touch, ENT_Touched, ENT_Toucher);

stock DF_Blocked(const ENT_Blocked, const ENT_Other)
   return dllfunc(DLLFunc_Blocked, ENT_Blocked, ENT_Other);
stock DF_SetAbsBox(const ENTITY)
   return dllfunc(DLLFunc_SetAbsBox, ENTITY);
stock DF_ClientConnect(const ENTITY, const NAME[], const ADDRESS[], RejectReason[128])
   return dllfunc(DLLFunc_ClientConnect, ENTITY, NAME, ADDRESS, RejectReason);
stock DF_ClientDisconnect(const ENTITY)
   return dllfunc(DLLFunc_ClientDisconnect, ENTITY);
stock DF_ClientKill(const ENTITY)
   return dllfunc(DLLFunc_ClientKill, ENTITY);

stock DF_ClientPutInServer(const ENTITY)
   return dllfunc(DLLFunc_ClientPutInServer, ENTITY);
stock DF_ClientCommand(const ENTITY)
   return dllfunc(DLLFunc_ClientCommand, ENTITY);
stock DF_ServerDeactivate()
   return dllfunc(DLLFunc_ServerDeactivate);
stock DF_PlayerPreThink(const ENTITY)
   return dllfunc(DLLFunc_PlayerPreThink, ENTITY);
stock DF_PlayerPostThink(const ENTITY)
   return dllfunc(DLLFunc_PlayerPostThink, ENTITY);

stock DF_StartFrame()
   return dllfunc(DLLFunc_StartFrame);
stock DF_ParmsNewLevel()
   return dllfunc(DLLFunc_ParmsNewLevel);
stock DF_ParmsChangeLevel()
   return dllfunc(DLLFunc_ParmsChangeLevel);
stock DF_GetGameDescription()
   return dllfunc(DLLFunc_GetGameDescription);
stock DF_SpectatorConnect(const ENTITY)
   return dllfunc(DLLFunc_SpectatorConnect, ENTITY);

stock DF_SpectatorDisconnect(const ENTITY)
   return dllfunc(DLLFunc_SpectatorDisconnect, ENTITY);
stock DF_SpectatorThink(const ENTITY)
   return dllfunc(DLLFunc_SpectatorThink, ENTITY);
stock DF_Sys_Error(const ERROR_STRING[])
   return dllfunc(DLLFunc_Sys_Error, ERROR_STRING);
stock DF_PM_FindTextureType(name[])
   return dllfunc(DLLFunc_PM_FindTextureType, name);
stock DF_RegisterEncoders()
   return dllfunc(DLLFunc_RegisterEncoders);

stock DF_GetHullBounds(hullnumber, Float:mins[3], Float:maxs[3])
   return dllfunc(DLLFunc_GetHullBounds, hullnumber, mins, maxs);
stock DF_CreateInstBaselines()
   return dllfunc(DLLFunc_CreateInstBaselines);
stock DF_pfnAllowLagCompensation()
   return dllfunc(DLLFunc_pfnAllowLagCompensation);
stock DF_MetaFunc_CallGameEntity(const STRING[], const ENTITY)
   return dllfunc(MetaFunc_CallGameEntity, STRING, ENTITY);
stock DF_ClientUserInfoChanged(const IDPLAYER)
   return dllfunc(DLLFunc_ClientUserInfoChanged, IDPLAYER);
   
stock DF_UpdateClientData(const ENTITY, sendweapons, const cd/* = 0*/)
   return dllfunc(DLLFunc_UpdateClientData, ENTITY, sendweapons, cd);
stock DF_AddToFullPack(const STATE/* = 0*/, e, ENT, HOST, hostflags, player, set)
   return dllfunc(DLLFunc_AddToFullPack, STATE, e, ENT, HOST, hostflags, player, set);
stock DF_CmdStart(const PLAYER, const CMD/* = 0*/, randomSeed)
   return dllfunc(DLLFunc_CmdStart, PLAYER, CMD, randomSeed);
stock DF_CmdEnd(const PLAYER)
   return dllfunc(DLLFunc_CmdEnd, PLAYER);
stock DF_CreateBaseline(PLAYER, eIndex, baseline, playerModelIndex, Float:playerMins[3], Float:playerMaxs[3])
   return dllfunc(DLLFunc_CreateBaseline, PLAYER, eIndex, baseline, playerModelIndex, playerMins, playerMaxs);

_________________
http://www.easyrankup.eu

kiki, az még mindig nem lecserélés: Felüldefiniálod, de akkor a viselkedését is meg kell határoznod, ergo a te eképzelésed alapján meg kell oldania, hogy ugyanúgy hordjon szét a fegyver, ugyanazon animációk játszódjanak le stbstb... De az már NEM hang(ok) lecserélése...

_________________

I'm back