#pragma semicolon 1
#pragma ctrlchar '\'

#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <xs>
#include <fun>

#define PLUGIN "LightSword"
#define VERSION "0.1"
#define AUTHOR "D-AIRY"

#define IsPlayer(%1) (1 <= %1 <= g_MaxPlayers)


#define SPRITE_HUD "sprites/weapon_lightsword.spr"
#define SPRITE_HUD_TXT "sprites/weapon_lightsword.txt"

#define W_MODEL "models/lightsword/w_lightsword.mdl"
// #define V_MODEL "models/lightsword/v_lightsword.mdl"
// #define P_MODEL "models/lightsword/p_lightsword.mdl"
new const V_MODEL[][] = 
{
   "models/lightsword/v_lightsword_r.mdl",
   "models/lightsword/v_lightsword_g.mdl",
   "models/lightsword/v_lightsword_b.mdl",
   "models/lightsword/v_lightsword_y.mdl"
};

new const
SPRITE_BLOOD[] = "sprites/blood.spr",
SPRITE_BLOOD2[] = "sprites/bloodspray.spr";

new m_iBlood[2];

new const P_MODEL[][] = 
{
   "models/lightsword/p_lightsword_r.mdl",
   "models/lightsword/p_lightsword_g.mdl",
   "models/lightsword/p_lightsword_b.mdl",
   "models/lightsword/p_lightsword_y.mdl"
};

new g_dPlayerColor[32];

new const
m_pPlayer = 28,
extraoffset_weapon = 4;

new g_MaxPlayers;

new bool:g_bAnim[32];

enum
{
   LS_ANIM_IDLE_ON = 0,
   LS_ANIM_ON,
   LS_ANIM_OFF,
   LS_ANIM_DRAW,
   LS_ANIM_STAB,
   LS_ANIM_STAB_MISS,
   LS_ANIM_MIDSLASH1,
   LS_ANIM_MIDSLASH2,
   LS_ANIM_MIDSLASH3,
   LS_ANIM_IDLE_OFF,
   LS_ANIM_SLASH_OFF
}

new const soundSlash[][]={
   "weapons/sfsword_midslash1.wav",
   "weapons/sfsword_midslash2.wav",
   "weapons/sfsword_midslash3.wav"
};

new const soundHit[][]={
   "weapons/sfsword_hit1.wav",
   "weapons/sfsword_hit2.wav"
};

new const soundWall[][]={
   "weapons/sfsword_wall1.wav",
   "weapons/sfsword_wall2.wav"
};

new const soundOn[] = "weapons/sfsword_on.wav";

new const soundIdle[] = "weapons/sfsword_idle.wav";

new const
m_iDefaultAmmo = 44;

new Float:gfPLS[32];

new bool:g_bEnabled = false;
new bool:g_bEnabledF = false;

public plugin_init() 
{
   if(!g_bEnabledF)
   {
      g_bEnabled = engfunc(EngFunc_FindEntityByString, -1, "targetname", "weapon_lightsword") ? true : false;
      g_bEnabledF = true;
   }
   g_bEnabled = true;
   register_plugin(PLUGIN, VERSION, AUTHOR);
   register_cvar("lightsword_version", VERSION, FCVAR_SPONLY | FCVAR_SERVER | FCVAR_UNLOGGED);
   
   // if(g_bEnabled)
   // {
      
      new ent = -1;
      // if(g_bEnabled)
      // {
         while((ent = find_ent_by_class(ent, "weapon_hornetgun")))
         {
            // remove_entity(ent);
         }
      // }
      new iEnt;
      // ent = -1;
      while((ent = engfunc(EngFunc_FindEntityByString, ent, "targetname", "weapon_lightsword")))
      {
         new name[32];
         pev(ent, pev_targetname, name, charsmax(name));
         // server_print("#%s", name);
         server_print("[LightSword]: Found");
         // set_pev(ent, pev_classname, "weapon_hornetgun");
         iEnt = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "weapon_hornetgun"));
         dllfunc(DLLFunc_Spawn, iEnt);
         new Float:origin;
         pev(ent, pev_origin, origin);
         set_pev(iEnt, pev_origin, origin);
         remove_entity(ent);
      }
      
      RegisterHam(Ham_Item_AddToPlayer, "weapon_hornetgun", "LS_addtoplayer");
      RegisterHam(Ham_Item_AddDuplicate, "weapon_hornetgun", "LS_addtoplayer");
      RegisterHam(Ham_Item_Deploy, "weapon_hornetgun", "LS_deploy", 1);
      RegisterHam(Ham_Item_PostFrame, "weapon_hornetgun", "LS_postframe");
      RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_hornetgun", "LS_PA");
      RegisterHam(Ham_Weapon_SecondaryAttack, "weapon_hornetgun", "LS_SA");
      
      register_forward(FM_UpdateClientData, "UpdateClientData_Post", 1);
      
      register_message(get_user_msgid("WeaponList"), "Message_WeaponList");
      register_clcmd("weapon_lightsword", "LS_cmd");
   // }
   g_MaxPlayers = get_maxplayers();
}

public client_disconnect(id)
{
   // if(g_bEnabled)
   // {
      
   // }
}

public plugin_precache()
{
   // if(!g_bEnabledF)
   // {
      // g_bEnabled = engfunc(EngFunc_FindEntityByString, -1, "targetname", "weapon_portalgun");
      // g_bEnabledF = true;
   // }
   // if(g_bEnabled)
   // {
      RegisterHam(Ham_Spawn, "weapon_hornetgun", "LS_spawn", 1);
      
      precache_generic(SPRITE_HUD_TXT);
      precache_generic(SPRITE_HUD);
         
      for(new i = 0; i < sizeof(soundHit); i++)
      {
         precache_sound(soundHit[i]);
      }
      
      m_iBlood[0] = precache_model(SPRITE_BLOOD);
      m_iBlood[1] = precache_model(SPRITE_BLOOD2);
      
      for(new i = 0; i < sizeof(soundSlash); i++)
      {
         precache_sound(soundSlash[i]);
      }
      
      for(new i = 0; i < sizeof(soundWall); i++)
      {
         precache_sound(soundWall[i]);
      }
      
      precache_sound(soundOn);
      precache_sound(soundIdle);
      precache_model(W_MODEL);
      // precache_model(P_MODEL);
      // precache_model(V_MODEL);
      for(new i = 0; i < sizeof(P_MODEL); i++)
      {
         precache_model(P_MODEL[i]);
      }
      
      for(new i = 0; i < sizeof(V_MODEL); i++)
      {
         precache_model(V_MODEL[i]);
      }
   // }
}

public plugin_cfg()
{
   if (!is_running("valve") && !is_running("ag"))
      set_fail_state("Fail");
}

public Message_WeaponList(msg_id, msg_dest, msg_entity)
{
   if (get_msg_arg_int(8) == HLW_HORNETGUN)
   {
      set_msg_arg_string(1, "weapon_lightsword");
   }
}

public LS_cmd(id)
{
   engclient_cmd(id, "weapon_hornetgun");
   // server_print("LS_cmd");
   
   new Float:fOrigin[3];
   pev(id, pev_origin, fOrigin);
   // set_pev(id, pev_viewmodel2, V_MODEL[g_dPlayerColor[id]]);
   // set_pev(id, pev_weaponmodel2, P_MODEL[g_dPlayerColor[id]]);
   // server_print("LS_cmd %d\n", g_dPlayerColor[id]);
   engfunc(EngFunc_EmitAmbientSound, 0, fOrigin, soundOn, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
   // set_task(0.1, "animOn", id);
   // set_animation(id, LS_ANIM_ON);
   return(PLUGIN_HANDLED);
}

/* public animOn(id)
{
   set_animation(id, LS_ANIM_ON);
} */

public UpdateClientData_Post(id, sendweapons, CD_Handle)
{
   if (!is_user_alive(id) || get_user_weapon(id) != HLW_HORNETGUN)
   {
      return(FMRES_IGNORED);
   }

   set_cd(CD_Handle, CD_ID, 0);
   return(FMRES_HANDLED);
}

public LS_spawn(ent)
{
   engfunc(EngFunc_SetModel, ent, W_MODEL);
   return(HAM_IGNORED);
}

public LS_addtoplayer(ent)
{
   if(pev_valid(ent))
   {
      set_pdata_int(ent, m_iDefaultAmmo, 8, extraoffset_weapon);
   }
   // new id = get_pdata_cbase(ent, m_pPlayer, extraoffset_weapon);
   // g_dPlayerColor[id] = random_num(0, 3);
   
   // server_print("LS_addtoplayer %d, %d, %d, %d\n", id, /* g_dPlayerColor[id] */0, ent, id);
   return(HAM_IGNORED);
}

public LS_deploy(ent)
{
   new id = get_pdata_cbase(ent, m_pPlayer, extraoffset_weapon);
   
   set_pev(id, pev_viewmodel2, V_MODEL[g_dPlayerColor[id]]);
   set_pev(id, pev_weaponmodel2, P_MODEL[g_dPlayerColor[id]]);
   UTIL_PlayWeaponAnimation(id, 5);
   
   return(HAM_IGNORED);
}

public LS_postframe(ent)
{
   return(HAM_IGNORED);
}

public client_putinserver(id)
{
   g_bAnim[id] = false;
   g_dPlayerColor[id] = random_num(0, 3);
}

public setAnimFasle(id)
{
   g_bAnim[id] = false;
}

public LS_PA(ent)
{
   new id = get_pdata_cbase(ent, m_pPlayer, extraoffset_weapon);
   if(g_bAnim[id])
   {
      return(HAM_SUPERCEDE);
   }
   g_bAnim[id] = true;
   set_task(1.0, "setAnimFasle", id);
   set_animation(id, random_num(LS_ANIM_MIDSLASH1,LS_ANIM_MIDSLASH3));
   new Float:fOrigin[3];
   pev(id, pev_origin, fOrigin);
   engfunc(EngFunc_EmitAmbientSound, 0, fOrigin, soundSlash[random(sizeof(soundSlash))], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
   Attack(id, 1);
   return(HAM_SUPERCEDE);
}

public LS_SA(ent)
{
   new id = get_pdata_cbase(ent, m_pPlayer, extraoffset_weapon);
   if(g_bAnim[id])
   {
      return(HAM_SUPERCEDE);
   }
   g_bAnim[id] = true;
   set_task(1.0, "setAnimFasle", id);
   // create_shot_portal(id, 1);
   set_animation(id, LS_ANIM_STAB);
   new Float:fOrigin[3];
   pev(id, pev_origin, fOrigin);
   engfunc(EngFunc_EmitAmbientSound, 0, fOrigin, soundHit[random(sizeof(soundHit))], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
   Attack(id, 2);
   return(HAM_SUPERCEDE);
}

public Attack(id, type)
{
   new Float:origin[3];
   // GetGunPosition(id, origin);
   pev(id, pev_origin, origin);
   new Float:origin2[3];
   new ent = -1;
   new Float:dmg;
   new Float:vAngle[3];
   new Float:vAngle2[3];
   // pev(id, pev_v_angle, vAngle);
   velocity_by_aim(id, 500, vAngle);
   new Float:cos;
   // new Float:dis;
   // server_print("My: %f %f %f\n", vAngle[0], vAngle[1], vAngle[2]);
   while((ent = engfunc(EngFunc_FindEntityInSphere, ent, origin, 100.0)))
   {
      if(/* (IsPlayer(ent) || is_user_bot(ent)) &&  */ent != id)
      {
         pev(ent, pev_origin, origin2);
         // dmg = type == 1 ? random_float(25.0, 40.0) : random_float(40.0, 60.0);
         // dmg = type == 1 ? random_float(75.0, 100.0) : random_float(80.0, 110.0);
         if(!is_wall_between_points(origin, origin2, id))
         {
            new ent;
            new entid;
            get_user_aiming(id, entid, ent, 48);
            if(entid)
            {
               new szClassName[64];
               pev(entid, pev_classname, szClassName, charsmax(szClassName));
               if(equali(szClassName, "func_breakable") || equali(szClassName, "func_pushable") || equali(szClassName, "monster_satchel"))
               {
                  force_use(id,entid);
                  fake_touch(entid,id);
               }
            }
            
            dmg = type == 1 ? 1500.0 : 3000.0;
            // pev(id, pev_v_angle, vAngle2);
            // server_print("O1: %f %f %f\n", origin[0], origin[1], origin[2]);
            // server_print("O2: %f %f %f\n", origin2[0], origin2[1], origin2[2]);
            vAngle2[0] = origin2[0] - origin[0];
            vAngle2[1] = origin2[2] - origin[2];
            vAngle2[2] = origin2[1] - origin[1];
            // server_print("Vic: %f %f %f\n%f", vAngle2[0], vAngle2[1], vAngle2[2], origin2[0] - origin[0]);
            cos = (vAngle[0] * vAngle2[0] + vAngle[1] * vAngle2[1] + vAngle[2] * vAngle2[2])/(floatsqroot(vAngle[0] * vAngle[0] + vAngle[1] * vAngle[1] + vAngle[2] * vAngle[2]) * floatsqroot(vAngle2[0] * vAngle2[0] + vAngle2[1] * vAngle2[1] + vAngle2[2] * vAngle2[2]));
            cos = cos < 0.0 ? 0.0 : cos;
            
            // dis = (100.0 - floatsqroot(((origin[0] - origin2[0]) * (origin[0] - origin2[0])) + ((origin[1] - origin2[1]) * (origin[1] - origin2[1])) + ((origin[2] - origin2[2]) * (origin[2] - origin2[2])))) / 100.0;
            
            dmg = dmg * cos;
            // server_print("My: %f %f %f\n", vAngle[0], vAngle[1], vAngle[2]);
            
            // server_print("%d %f %f, %f\n", ent, dmg, cos, dis);
            UTIL_MakeBlood({0.0, 0.0, -1.0}, dmg, ent);
            ExecuteHamB(Ham_TakeDamage, ent, id, id, dmg, DMG_ENERGYBEAM);
         }
      }
   }
}

set_animation(id, anim)
{
   set_pev(id, pev_weaponanim, anim);
   
   message_begin(MSG_ONE, SVC_WEAPONANIM, {0, 0, 0}, id);
   write_byte(anim);
   write_byte(pev(id, pev_body));
   message_end();
}

stock is_wall_between_points(Float:start[3], Float:end[3], ignore_ent)
{
   static ptr;
   ptr = create_tr2();

   engfunc(EngFunc_TraceLine, start, end, IGNORE_MONSTERS, ignore_ent, ptr);
   
   static Float:EndPos[3];
   get_tr2(ptr, TR_vecEndPos, EndPos);

   free_tr2(ptr);
   return(floatround(get_distance_f(end, EndPos)));
}

stock GetGunPosition(const player, Float:origin[3])
{
   new Float:viewOfs[3];
   
   pev(player, pev_origin, origin);
   pev(player, pev_view_ofs, viewOfs);
    
   xs_vec_add(origin, viewOfs, origin);
}

stock VecNormilize(Float: in[3], Float: out[3])
{
   new Float:vlen = vector_length(in);
   vlen = 1/vlen;
   
   out[0] *= vlen;
   out[1] *= vlen;
   out[2] *= vlen;
}

stock UTIL_PlayWeaponAnimation(const Player, const Sequence)
{
   set_pev(Player, pev_weaponanim, Sequence);
   
   message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = Player);
   write_byte(Sequence);
   write_byte(pev(Player, pev_body));
   message_end();
}

stock UTIL_MakeBlood(const Float:vTraceEnd[3], const Float:Damage, const hitEnt) 
{
   new bloodColor = ExecuteHam(Ham_BloodColor, hitEnt);
   if (bloodColor == -1) return;

   new amount = floatround(Damage); amount *= 2;

   message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
   write_byte(TE_BLOODSPRITE);
   engfunc(EngFunc_WriteCoord, vTraceEnd[0]);
   engfunc(EngFunc_WriteCoord, vTraceEnd[1]);
   engfunc(EngFunc_WriteCoord, vTraceEnd[2]);
   write_short(m_iBlood[1]);
   write_short(m_iBlood[0]);
   write_byte(bloodColor);
   write_byte(min(max(3, amount/10), 16));
   message_end();
}


stock UTIL_RadiusDamage(Float:vecSrc[3], iInflictor, iAttacker=0, Float:flDamage, Float:flRadius=0.0, iClassIgnore = 0, bitsDamageType)
{
   new pEntity = FM_NULLENT;
   new tr = create_tr2();
   new Float:flAdjustedDamage, Float:falloff;
   new Float:vecSpot[3];

   if ( flRadius )
   {
      falloff = flDamage / flRadius;
   }
   else
   {
      falloff = 1.0;
   }

   new bool: bInWater = (engfunc(EngFunc_PointContents, vecSrc) == CONTENTS_WATER);

   vecSrc[2] += 1.0; // in case grenade is lying on the ground

   if ( !iAttacker )
   {
      iAttacker = iInflictor;
   }

   // iterate on all entities in the vicinity.
   new Float:flTakeDamage, Float:flFraction, Float:vecEndPos[3], Float:vecViewOfs[3];
   while ((pEntity = engfunc(EngFunc_FindEntityInSphere, pEntity, vecSrc, flRadius)) )
   {
      if(!is_visible(pEntity, iInflictor))
      {
         continue;
      }
      
      pev(pEntity, pev_takedamage, flTakeDamage);
      if ( flTakeDamage != DAMAGE_NO )
      {
         if ( iClassIgnore != 0 && ExecuteHamB(Ham_Classify, pEntity) == iClassIgnore )
         {
            continue;
         }

         if( bInWater )
         {
            if( !pev(pEntity, pev_waterlevel) )
            {
               continue;
            }
         }
         else if( pev(pEntity, pev_waterlevel) == 3 )
         {
            continue;
         }

         pev(pEntity, pev_origin, vecSpot);
         if( ExecuteHamB(Ham_IsPlayer, pEntity) )
         {
            pev(pEntity, pev_view_ofs, vecViewOfs);
            xs_vec_add(vecSpot, vecViewOfs, vecSpot);
         }

         engfunc(EngFunc_TraceLine, vecSrc, vecSpot, false, iInflictor, tr );         
         get_tr2(tr, TR_flFraction, flFraction);
         
         if ( flFraction == 1.0 || get_tr2(tr, TR_pHit) == pEntity )
         {
            if (get_tr2(tr, TR_StartSolid))
            {
               flFraction = 0.0;
               flAdjustedDamage = flDamage;
            }
            else
            {
               get_tr2(tr, TR_vecEndPos, vecEndPos);
               xs_vec_sub(vecSrc, vecEndPos, vecEndPos);
               flAdjustedDamage = vector_length(vecEndPos) * falloff;
               flAdjustedDamage = flDamage - flAdjustedDamage;
            }

            if ( flAdjustedDamage < 0.0 )
            {
               flAdjustedDamage = 0.0;
            }
         
            if (flFraction != 1.0)
            {
               switch( get_tr2(tr, TR_iHitgroup) )
               {
                  case HIT_HEAD:
                  {
                     flAdjustedDamage *= 4.0;
                  }
                  case HIT_STOMACH:
                  {
                     flAdjustedDamage *= 1.25;
                  }
                  case HIT_LEFTLEG, HIT_RIGHTLEG:
                  {
                     flAdjustedDamage *= 0.75;
                  }
               }
            }
            
            UTIL_MakeBlood(vecSpot, flAdjustedDamage, pEntity); 
            ExecuteHamB(Ham_TakeDamage, pEntity, iInflictor, iAttacker, flAdjustedDamage, bitsDamageType);
         }
      }
   }
   
   free_tr2(tr);
}