hlmod.hu

#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <csdm>

new D_PLUGIN[]   = "CSDM Main"
new D_ACCESS   = ADMIN_MAP

#define CSDM_OPTIONS_TOTAL      2

new bool:g_StripWeapons = true
new bool:g_RemoveBomb = true
new g_StayTime
new g_drop_fwd
new g_options[CSDM_OPTIONS_TOTAL]

//new g_MenuPages[33]
new g_MainMenu = -1

public plugin_natives()
{
   register_native("csdm_main_menu", "native_main_menu")
   register_native("csdm_set_mainoption", "__csdm_allow_option")
   register_native("csdm_fwd_drop", "__csdm_fwd_drop")
   register_library("csdm_main")
}

public native_main_menu(id, num)
{
   return g_MainMenu
}

public __csdm_allow_option(id, num)
{
   new option = get_param(1)
   
   if (option <= 0 || option >= CSDM_OPTIONS_TOTAL)
   {
      log_error(AMX_ERR_NATIVE, "Invalid option number: %d", option)
      return 0
   }
   
   g_options[option] = get_param(2)
   
   return 1
}

public __csdm_fwd_drop(id, num)
{
   new id = get_param(1)
   new wp = get_param(2)
   new name[32]
   
   get_string(3, name, 31)
   
   return run_drop(id, wp, name)   
}

public csdm_Init(const version[])
{
   if (version[0] == 0)
   {
      set_fail_state("CSDM failed to load.")
      return
   }
}

public csdm_CfgInit()
{   
   csdm_reg_cfg("settings", "read_cfg")
}

public plugin_init()
{
   register_plugin(D_PLUGIN, CSDM_VERSION, "CSDM Team")
   
   register_clcmd("say respawn", "say_respawn")
   register_clcmd("say /respawn", "say_respawn")
   
   register_concmd("csdm_enable", "csdm_enable", D_ACCESS, "Enables CSDM")
   register_concmd("csdm_disable", "csdm_disable", D_ACCESS, "Disables CSDM")
   register_concmd("csdm_ctrl", "csdm_ctrl", D_ACCESS, "")
   register_concmd("csdm_reload", "csdm_reload", D_ACCESS, "Reloads CSDM Config")
   register_clcmd("csdm_menu", "csdm_menu", ADMIN_MENU, "CSDM Menu")
   register_clcmd("drop", "hook_drop")
   
   register_concmd("csdm_cache", "cacheInfo", ADMIN_MAP, "Shows cache information")
   
   AddMenuItem("CSDM Menu", "csdm_menu", D_ACCESS, D_PLUGIN)
   g_MainMenu = menu_create("CSDM Menu", "use_csdm_menu")
   
   new callback = menu_makecallback("hook_item_display")
   menu_additem(g_MainMenu, "DM Be/DM Ki", "csdm_ctrl", D_ACCESS, callback)
   menu_additem(g_MainMenu, "DM config ujratoltese", "csdm_reload", D_ACCESS)
   
   g_drop_fwd = CreateMultiForward("csdm_HandleDrop", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL)
}

public cacheInfo(id, level, cid)
{
   if (!cmd_access(id, level, cid, 1))
      return PLUGIN_HANDLED
      
   new ar[6]
   csdm_cache(ar)
   
   console_print(id, "[CSDM] Free tasks: respawn=%d, findweapon=%d", ar[0], ar[5])
   console_print(id, "[CSDM] Weapon removal cache: %d total, %d live", ar[4], ar[3])
   console_print(id, "[CSDM] Live tasks: %d (%d free)", ar[2], ar[1])
   
   return PLUGIN_HANDLED
}

public hook_drop(id)
{
   if (!csdm_active())
   {
      return
   }
   
   if (!is_user_connected(id))
   {
      return
   }
   
   new wp, c, a, name[24]
   if (cs_get_user_shield(id))
   {
      //entirely different...
      wp = -1
      copy(name, 23, "weapon_shield")
   } else {
      if (read_argc() <= 1)
      {
         wp = get_user_weapon(id, c, a)
      } else {
         read_argv(1, name, 23)
         wp = getWepId(name)
      }
   }

   run_drop(id, wp, name)
}

run_drop(id, wp, const name[])
{
   new ret
   ExecuteForward(g_drop_fwd, ret, id, wp, 0)
   
   if (ret == CSDM_DROP_REMOVE)
   {
      new _name[24]
      if (name[0] == 0)
      {
         get_weaponname(wp, _name, 23)
      }
      csdm_remove_weapon(id, _name, 0, 1)
      return 1
   } else if (ret == CSDM_DROP_IGNORE) {
      return 0
   }
   
   if (g_StayTime > 20 || g_StayTime < 0)
   {
      return 0
   }
   
   if (wp)
   {
      remove_weapon(id, wp)
      return 1
   }
   
   return 0
}

public csdm_PostDeath(killer, victim, headshot, const weapon[])
{
   if (g_StayTime > 20 || g_StayTime < 0)
      return PLUGIN_CONTINUE

   new weapons[MAX_WEAPONS], num, name[24]
   new wp, slot, ret

   get_user_weapons(victim, weapons, num)

   for (new i=0; i<num; i++)
   {
      wp = weapons[i]
      slot = g_WeaponSlots[wp]

      ExecuteForward(g_drop_fwd, ret, victim, wp, 1)

      if (ret == CSDM_DROP_REMOVE)
      {
         get_weaponname(wp, name, 23)
         csdm_remove_weapon(victim, name, 0, 1)
      } else if (ret == CSDM_DROP_IGNORE) {
         continue
      } else {
         if (slot == SLOT_PRIMARY || slot == SLOT_SECONDARY || slot == SLOT_C4)
         {
            remove_weapon(victim, wp)
         }
      }
   }
   
   if (cs_get_user_shield(victim))
   {
      ExecuteForward(g_drop_fwd, ret, victim, -1, 1)
      if (ret == CSDM_DROP_REMOVE)
      {
         csdm_remove_weapon(victim, "weapon_shield", 0, 1)
      } else if (ret == CSDM_DROP_IGNORE) {
         /* do nothing */
      } else {
         remove_weapon(victim, -1)
      }
   }
   
   return PLUGIN_CONTINUE
}

public csdm_PreSpawn(player, bool:fake)
{
   //we'll just have to back out for now
   if (cs_get_user_shield(player))
   {
      return
   }
   new team = get_user_team(player)
   if (g_StripWeapons)
   {
      if (team == _TEAM_T)
      {
         if (cs_get_user_shield(player))
         {
            drop_with_shield(player, CSW_GLOCK18)
         } else {
            csdm_force_drop(player, "weapon_glock18")
         }
      } else if (team == _TEAM_CT) {
         if (cs_get_user_shield(player))
         {
            drop_with_shield(player, CSW_USP)
         } else {
            csdm_force_drop(player, "weapon_usp")
         }
      }
   }
   if (team == _TEAM_T)
   {
      if (g_RemoveBomb)
      {
         new weapons[MAX_WEAPONS], num
         get_user_weapons(player, weapons, num)
         for (new i=0; i<num; i++)
         {
            if (weapons[i] == CSW_C4)
            {
               if (cs_get_user_shield(player))
               {
                  drop_with_shield(player, CSW_C4)
               } else {
                  csdm_force_drop(player, "weapon_c4")
               }
               break
            }
         }
      }
   }
}

remove_weapon(id, wp)
{
   new name[24]
   
   if (wp == -1)
   {
      copy(name, 23, "weapon_shield")
   } else {
      get_weaponname(wp, name, 23)
   }

   if ((wp == CSW_C4) && g_RemoveBomb)
   {   
      csdm_remove_weapon(id, name, 0, 1)
   } else {
      if (wp != CSW_C4)
      {
         csdm_remove_weapon(id, name, g_StayTime, 1)
      }
   }
}

public hook_item_display(player, menu, item)
{
   new paccess, command[24], call
   
   menu_item_getinfo(menu, item, paccess, command, 23, _, 0, call)
   
   if (equali(command, "csdm_ctrl"))
   {
      if (!csdm_active())
      {
         menu_item_setname(menu, item, "DM Be")
      } else {
         menu_item_setname(menu, item, "DM Ki")
      }
   }
}

public read_cfg(readAction, line[], section[])
{
   if (readAction == CFG_READ)
   {
      new setting[24], sign[3], value[32];

      parse(line, setting, 23, sign, 2, value, 31);
      
      if (equali(setting, "strip_weapons"))
      {
         g_StripWeapons = str_to_num(value) ? true : false
      } else if (equali(setting, "weapons_stay")) {
         g_StayTime = str_to_num(value)
      } else if (equali(setting, "spawnmode")) {
         new var = csdm_setstyle(value)
         if (var)
         {
            log_amx("CSDM spawn mode set to %s", value)
         } else {
            log_amx("CSDM spawn mode %s not found", value)
         }
      } else if (equali(setting, "remove_bomb")) {
         g_RemoveBomb = str_to_num(value) ? true : false
      } else if (equali(setting, "enabled")) {
         csdm_set_active(str_to_num(value))
      } else if (equali(setting, "spawn_wait_time")) {
         csdm_set_spawnwait(str_to_float(value))
      }
   }
}

public csdm_reload(id, level, cid)
{
   if (!cmd_access(id, level, cid, 1))
      return PLUGIN_HANDLED
      
   new file[33] = ""
   if (read_argc() >= 2)
   {
      read_argv(1, file, 32)
   }
      
   if (csdm_reload_cfg(file))
   {
      client_print(id, print_chat, "[CSDM] Deathmatch config ujratoltve.")
   } else {
      client_print(id, print_chat, "[CSDM] nem lehet ujratolteni a csdm.cfg-t.")
   }
      
   return PLUGIN_HANDLED
}

public csdm_menu(id, level, cid)
{
   if (!cmd_access(id, level, cid, 1))
      return PLUGIN_HANDLED
   
   menu_display(id, g_MainMenu, 0)
   
   return PLUGIN_HANDLED
}

public csdm_ctrl(id, level, cid)
{
   if (!cmd_access(id, level, cid, 1))
      return PLUGIN_HANDLED
   
   csdm_set_active( csdm_active() ? 0 : 1 )
   client_print(id, print_chat, "CSDM Deathmatch mod fut,Magyarositotta,Expert_IMI")
   
   return PLUGIN_HANDLED
}

public use_csdm_menu(id, menu, item)
{
   if (item < 0)
      return PLUGIN_CONTINUE
   
   new command[24], paccess, call
   if (!menu_item_getinfo(g_MainMenu, item, paccess, command, 23, _, 0, call))
   {
      log_amx("Error: csdm_menu_item() failed (menu %d) (page %d) (item %d)", g_MainMenu, 0, item)
      return PLUGIN_HANDLED
   }
   if (paccess && !(get_user_flags(id) & paccess))
   {
      client_print(id, print_chat, "Nem engedelyezett ez a menu opciok.")
      return PLUGIN_HANDLED
   }
   
   client_cmd(id, command)
   
   return PLUGIN_HANDLED
}

public csdm_enable(id, level, cid)
{
   if (!cmd_access(id, level, cid, 1))
      return PLUGIN_HANDLED

   csdm_set_active(1)
   client_print(id, print_chat, "CSDM Deathmatch mod bekapcsolva.")
   
   return PLUGIN_HANDLED   
}

public csdm_disable(id, level, cid)
{
   if (!cmd_access(id, level, cid, 1))
      return PLUGIN_HANDLED

   csdm_set_active(0)
   client_print(id, print_chat, "CSDM Deathmach mod kikapcsolva.")
   
   return PLUGIN_HANDLED   
}

public say_respawn(id)
{
   if (g_options[CSDM_OPTION_SAYRESPAWN] == CSDM_SET_DISABLED)
   {
      client_print(id, print_chat, "[CSDM] Parancs letiltva")
      return PLUGIN_HANDLED
   }
   
   if (!is_user_alive(id) && csdm_active())
   {
      new team = get_user_team(id)
      if (team == _TEAM_T || team == _TEAM_CT)
      {
         csdm_respawn(id)
      }
   }
   
   return PLUGIN_CONTINUE
}

#include <amxmodx>
#define ARIXR_VERSION "0.3"

new cRound, cvar_rounds, cvar_time, cvar_notice, cvar_message, cvar_message_color, cvar_hud, cvar_hud_color, cvar_sound, cvar_restart, hudsync, counter
new prefix[] = "ARIXR"

/*START - From colorchat.inc by Numb */
enum Color {
   NORMAL = 1,
   GREEN,
   TEAM_COLOR,
   GREY,
   RED,
   BLUE,
}

new TeamName[][] = {
   "",
   "TERRORIST",
   "CT",
   "SPECTATOR"
}
/*END - From colorchat.inc by Numb */

public plugin_init() {
    register_plugin("Auto Restart In X Round", ARIXR_VERSION, "He3aBuCuM")
    register_logevent("roundStart", 2, "1=Round_Start")
    cvar_rounds = register_cvar("amx_restart_round", "2")
    cvar_time = register_cvar("amx_restart_time", "10.0")
    cvar_notice = register_cvar("amx_restart_notice", "3")
    cvar_message = register_cvar("amx_restart_message", "That's the %round% round!Restarting...")
    cvar_message_color = register_cvar("amx_restart_message_color", "4")
    cvar_hud = register_cvar("amx_restart_hud", "%seconds% seconds until restart!")
    cvar_hud_color = register_cvar("amx_restart_hud_color", "0 255 0")
    cvar_sound = register_cvar("amx_restart_sound", "1")
    cvar_restart = get_cvar_pointer("sv_restart")
    register_cvar("arixr_version", ARIXR_VERSION, FCVAR_SERVER | FCVAR_SPONLY)
    hudsync = CreateHudSyncObj()
}

public roundStart() {
    new rounds = get_pcvar_num(cvar_rounds)
    cRound++

    if(cRound == rounds) {
        switch(get_pcvar_num(cvar_notice)) {
            case 0: set_task(get_pcvar_float(cvar_time), "restartRound", 123457)
            case 1: {
                set_task(get_pcvar_float(cvar_time), "show_chat_message", 123458)
                set_task(get_pcvar_float(cvar_time), "restartRound", 123457)
            }
            case 2: {
                set_task(1.0, "hudTimer", 123456, _, _, "a", get_pcvar_num(cvar_time))
                set_task(get_pcvar_float(cvar_time), "restartRound", 123457)
            }
            case 3: {
                set_task(1.0, "hudTimer", 123456, _, _, "a", get_pcvar_num(cvar_time))
                set_task(get_pcvar_float(cvar_time), "restartRound", 123457)
                set_task(get_pcvar_float(cvar_time), "show_chat_message", 123458)
            }
            default: set_task(get_pcvar_float(cvar_time), "restartRound", 123457)
        }

        if(get_pcvar_num(cvar_sound))
            set_task(1.0, "spkSound", 123456, _, _, "a", get_pcvar_num(cvar_time))
    }

    return PLUGIN_CONTINUE
}

public show_chat_message() {
    if(get_playersnum(1) == 0)
        return PLUGIN_HANDLED

    new message[190], rounds[10]
    get_pcvar_string(cvar_message, message, charsmax(message))
    format(rounds, charsmax(rounds), "%d", cRound)

    replace_all(message, charsmax(message), "%round%", rounds)

    switch(get_pcvar_num(cvar_message_color)) {
        case 1: ColorChat(0, GREEN, "[%s] %s", prefix, message)
        case 2: ColorChat(0, RED, "[%s] %s", prefix, message)
        case 3: ColorChat(0, GREY, "[%s] %s", prefix, message)
        case 4: ColorChat(0, BLUE, "[%s] %s", prefix, message)
        case 5: ColorChat(0, NORMAL, "[%s] %s", prefix, message)
        case 6: ColorChat(0, TEAM_COLOR, "[%s] %s", prefix, message)
        default: ColorChat(0, NORMAL, "[%s] %s", prefix, message)
    }

    return PLUGIN_CONTINUE
}

public hudTimer() {
    if(get_playersnum(1) == 0)
        return PLUGIN_HANDLED

    counter++
    new hud[190], rounds[10], seconds[10], red, green, blue
    get_pcvar_string(cvar_hud, hud, charsmax(hud))
    format(rounds, charsmax(rounds), "%d", cRound)
    format(seconds, charsmax(seconds), "%d", get_pcvar_num(cvar_time) - counter)
    get_hud_color(red, green, blue)

    replace_all(hud, charsmax(hud), "%round%", rounds)
    replace_all(hud, charsmax(hud), "%seconds%", seconds)
    replace_all(hud, charsmax(hud), "/n", "^n")

    set_hudmessage(red, green, blue, 0.05, 0.60, 0, 0.01, 1.0, 0.0, 0.0, -1)
    ShowSyncHudMsg(0, hudsync, hud)

    return PLUGIN_CONTINUE
}

public spkSound() {
    if(get_playersnum(1) == 0)
        return PLUGIN_HANDLED

    new sound[32]
    num_to_word(get_pcvar_num(cvar_time) - counter, sound, charsmax(sound))
    client_cmd(0, "spk ^"vox/%s^"", sound)

    return PLUGIN_CONTINUE
}

public restartRound()
    set_pcvar_num(cvar_restart, 2)

get_hud_color(&r, &g, &b) {
    new color[20]
    static red[5], green[5], blue[5]
    get_pcvar_string(cvar_hud_color, color, charsmax(color))
    parse(color, red, charsmax(red), green, charsmax(green), blue, charsmax(blue))

    r = str_to_num(red)
    g = str_to_num(green)
    b = str_to_num(blue)
}

/*START - From colorchat.inc by Numb */
ColorChat(id, Color:type, const msg[], {Float, Sql, Result,_}:...) {
   new message[256]

   switch(type) {
      case NORMAL: message[0] = 0x01
      case GREEN: message[0] = 0x04
      default: message[0] = 0x03
   }

   vformat(message[1], 251, msg, 4)

   message[192] = '^0'

   new team, ColorChange, index, MSG_Type

   if(id) {
      MSG_Type = MSG_ONE
      index = id
   } else {
      index = FindPlayer()
      MSG_Type = MSG_ALL
   }

   team = get_user_team(index)
   ColorChange = ColorSelection(index, MSG_Type, type)

   ShowColorMessage(index, MSG_Type, message)

   if(ColorChange)
      Team_Info(index, MSG_Type, TeamName[team])
}

ShowColorMessage(id, type, message[]) {
   static bool:saytext_used
   static get_user_msgid_saytext

   if(!saytext_used) {
      get_user_msgid_saytext = get_user_msgid("SayText")
      saytext_used = true
   }

   message_begin(type, get_user_msgid_saytext, _, id)
   write_byte(id)
   write_string(message)
   message_end()
}

Team_Info(id, type, team[]) {
   static bool:teaminfo_used
   static get_user_msgid_teaminfo

   if(!teaminfo_used) {
      get_user_msgid_teaminfo = get_user_msgid("TeamInfo")
      teaminfo_used = true
   }

   message_begin(type, get_user_msgid_teaminfo, _, id)
   write_byte(id)
   write_string(team)
   message_end()

   return 1
}

ColorSelection(index, type, Color:Type) {
   switch(Type) {
      case RED: return Team_Info(index, type, TeamName[1])
      case BLUE: return Team_Info(index, type, TeamName[2])
      case GREY: return Team_Info(index, type, TeamName[0])
   }

   return 0
}

FindPlayer() {
   new i = -1

   while(i <= get_maxplayers()) {
      if(is_user_connected(++i))
         return i
   }

   return -1
}
/*END - From colorchat.inc by Numb */