amxmodx/dlls/esforces/esfmod/esf_anim.cpp

700 lines
13 KiB
C++
Raw Normal View History

#include <extdll.h>
#include <meta_api.h>
#include <eiface.h>
#include <edict.h>
#include "esforces.h"
//use direction enums
// 0 = any
static cell AMX_NATIVE_CALL esf_is_swooping(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
int dir = params[2];
if (!dir)
{
if (anim >= 36 && anim <= 41)
return 1;
} else if (dir == Direction_Up) {
if (anim == 36)
return 1;
} else if (dir == Direction_Down) {
if (anim == 37)
return 1;
} else if (dir == Direction_Left) {
if (anim == 38)
return 1;
} else if (dir == Direction_Right) {
if (anim == 39)
return 1;
} else if (dir == Direction_Forward) {
if (anim == 40)
return 1;
} else if (dir == Direction_Backward) {
if (anim == 41)
return 1;
}
return 0;
}
static cell AMX_NATIVE_CALL esf_is_prepunch(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim >= 121 || anim <= 124)
return 1;
if (anim == 209)
return 1;
return 0;
}
2005-07-10 04:45:42 +04:00
static cell AMX_NATIVE_CALL esf_in_stance(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 126)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_stunned(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 127)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_grappling(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 128)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_crushed(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 208)
return 1;
return 0;
}
//player, combo, [attacked = 0]
static cell AMX_NATIVE_CALL esf_in_combo(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (params[2] == 1)
{
if (params[3])
{
if (pEdict->v.sequence == 213)
return 1;
} else {
if (pEdict->v.sequence == 212)
return 1;
}
} else if (params[2] == 2) {
if (params[3])
{
if (pEdict->v.sequence == 215)
return 1;
} else {
if (pEdict->v.sequence == 214)
return 1;
}
}
return 0;
}
static cell AMX_NATIVE_CALL esf_is_advmeleeing(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim > 128 && anim < 153)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_advmeleed(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim > 152 && anim < 201)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_in_advmelee(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim > 120 && anim < 216)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_blocking(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim <= 42 && anim >= 46)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_kicking(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim <= 47 && anim >= 51)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_kicked(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
//only evens
if (anim >= 52 && anim <= 62 && (anim % 2 == 0))
return 1;
return 0;
}
//1 = kicked
//2 = tumbling
//3 = laying
//4 = thrown to ground
static cell AMX_NATIVE_CALL esf_is_recovered(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
int mode = params[2];
if (mode == 1)
{
//only odds
if (anim >= 53 && anim <= 63 && (anim % 2 == 1))
return 1;
} else if (mode == 2) {
if (anim == 65 || anim == 67 || anim == 69 || anim == 71)
return 1;
return 0;
} else if (mode == 3) {
if (anim == 73 || anim == 75)
return 1;
} else if (mode == 4) {
if (anim >= 105 && anim <= 109)
return 1;
}
return 0;
}
static cell AMX_NATIVE_CALL esf_is_flying(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim >= 26 && anim <= 34)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_tumbling(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 64 || anim == 66 || anim == 68 || anim == 70)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_lying(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 72 || anim == 74)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_has_died(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim >= 76 && anim <= 84)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_has_dragonball(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 92)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_threw_dragonball(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 93 || anim == 94)
return 1;
return 0;
}
//1 = kiblast
//2 = generic beam
static cell AMX_NATIVE_CALL esf_is_shooting(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (params[2] == 1)
{
if (anim == 95 || anim == 96)
return 1;
} else if (params[2] == 2) {
if (anim == 98 || anim == 99)
return 1;
}
return 0;
}
static cell AMX_NATIVE_CALL esf_transforming(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 101 || anim == 102)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_transform_done(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 103)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_groundthrown(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 104)
return 1;
return 0;
}
//for get_shotstate and get_attack
//1 = kamehameha
//2 = spiritbomb
//3 = galletgun
//4 = finalflash
//5 = renzoku
//6 = kametorpedo
//7 = generic beam
//8 = throw
static cell AMX_NATIVE_CALL esf_get_shotstate(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
int cls = pEdict->v.playerclass;
int attack = params[2];
if (attack == Attack_Kamehameha)
{
if ( (cls == Character_Goku || cls == Character_Gohan))
{
if (anim == 110)
return ESF_CHARGING;
if (anim == 111)
return ESF_CONTROLLING;
}
if (cls == Character_Cell)
{
if (anim == 112)
return ESF_CHARGING;
if (anim == 113)
return ESF_CONTROLLING;
}
} else if (attack == Attack_SpiritBomb) {
if (anim == 112 || anim == 114)
return ESF_CHARGING;
if (anim == 113 || anim == 115)
return ESF_SHOT;
} else if (attack == Attack_GalletGun) {
if (cls == Character_Vegeta)
{
if (anim == 111)
return ESF_CHARGING;
if (anim == 112)
return ESF_CONTROLLING;
}
if (cls == Character_Cell)
{
if (anim == 110)
return ESF_CHARGING;
if (anim == 111)
return ESF_CONTROLLING;
}
} else if (attack == Attack_FinalFlash) {
if (cls == Character_Krillin)
{
if (anim == 119 || anim == 120)
return ESF_SHOT;
}
if (cls == Character_Cell)
{
if (anim == 114 || anim == 115)
return ESF_SHOT;
}
if (anim == 113)
return ESF_CHARGING;
if (anim == 114)
return ESF_CONTROLLING;
} else if (attack == Attack_Renzoku) {
if (anim == 115)
return ESF_CHARGING;
if (anim >= 116 && anim <= 118)
return ESF_SHOOTING;
} else if (attack == Attack_Kametorpedo) {
if (anim == 116)
return ESF_CHARGING;
if (anim == 118)
return ESF_SHOT;
} else if (attack == Attack_GenericBeam) {
if (anim == 97)
return ESF_CHARGING;
} else if (attack == Attack_Throw) {
if (anim == 201 || anim == 203 || anim == 204)
return ESF_CHARGING;
}
return 0;
}
//experimental since animation states overlap not all weapons can be returned
static cell AMX_NATIVE_CALL esf_get_attack(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
int cls = pEdict->v.playerclass;
if ( (cls == Character_Goku || cls == Character_Gohan) )
{
if (anim == 110 || anim == 111)
return Attack_Kamehameha;
} else if (cls == Character_Cell) {
if (anim == 112 || anim == 113)
return Attack_Kamehameha;
if (anim == 110 || anim == 111)
return Attack_GalletGun;
if (anim == 114 || anim == 115)
return Attack_FinalFlash;
} else if (cls == Character_Vegeta) {
if (anim == 111 || anim == 112)
return Attack_GalletGun;
} else if (cls == Character_Krillin) {
if (anim == 119 || anim == 120)
return Attack_FinalFlash;
}
if (anim == 97)
return Attack_GenericBeam;
if (anim == 201 || anim == 203 || anim == 204)
return Attack_Throw;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_swung(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 202 || anim == 206)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_grabbedwall(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 13 ||
anim == 15 ||
anim == 17 ||
anim == 19)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_walljumped(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim == 14 ||
anim == 16 ||
anim == 18 ||
anim == 20)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_in_water(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim >= 21 && anim <= 23)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_powering(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim >= 24 && anim <= 27)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_idle(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
int anim = pEdict->v.sequence;
if (anim <=2)
return 1;
return 0;
}
static cell AMX_NATIVE_CALL esf_is_beamjumping(AMX *amx, cell *params)
{
int index = params[1];
CHECKPLAYER(index);
edict_t *pEdict = INDEXENT(index);
if (pEdict->v.sequence == 100)
return 1;
return 0;
}
AMX_NATIVE_INFO g_AnimationNatives[] = {
{"esf_is_swooping", esf_is_swooping},
{"esf_is_prepunch", esf_is_prepunch},
2005-07-10 04:45:42 +04:00
{"esf_in_stance", esf_in_stance},
{"esf_is_stunned", esf_is_stunned},
{"esf_is_grappling", esf_is_grappling},
{"esf_is_crushed", esf_is_crushed},
{"esf_in_combo", esf_in_combo},
{"esf_is_advmeleeing", esf_is_advmeleeing},
{"esf_is_advmeleed", esf_is_advmeleed},
{"esf_in_advmelee", esf_in_advmelee},
{"esf_is_blocking", esf_is_blocking},
{"esf_is_kicking", esf_is_kicking},
{"esf_is_kicked", esf_is_kicked},
{"esf_is_recovered", esf_is_recovered},
{"esf_is_flying", esf_is_flying},
{"esf_is_tumbling", esf_is_tumbling},
{"esf_is_lying", esf_is_lying},
{"esf_has_died", esf_has_died},
{"esf_has_dragonball", esf_has_dragonball},
{"esf_threw_dragonball", esf_threw_dragonball},
{"esf_is_shooting", esf_is_shooting},
{"esf_transforming", esf_transforming},
{"esf_transform_done", esf_transform_done},
{"esf_groundthrown", esf_groundthrown},
{"esf_get_shotstate", esf_get_shotstate},
{"esf_get_attack", esf_get_attack},
{"esf_is_swung", esf_is_swung},
{"esf_grabbedwall", esf_grabbedwall},
{"esf_walljumped", esf_walljumped},
{"esf_in_water", esf_in_water},
{"esf_is_powering", esf_is_powering},
{"esf_is_idle", esf_is_idle},
{"esf_is_beamjumping", esf_is_beamjumping},
{NULL, NULL},
};