[vJass] Инфицированной кабан

//////////////////////////////////////Globals with important values////////////////////////////////////////

scope SwineFlu

globals
  // The interval all units get checkes of bein infected / reinfected, higher values will increse the possible spread speed
  private real TimerPeriod = 0.5

  //your passive Swine Flu spell the hero must have
  private integer SwineFluSpell = 'A000'

  //The effect spell which is casted on enemys and causes their pain
  private integer SwineFluSpellEffect = 'A002'

  //The id of a dummy used to cast the spell above when a unit gets infected/ reinfected
  private integer CastDummyID = 'h002'

  //The buff an infected uni got of the effect spell
  private integer SwineFluBuffCode = 'B000'

  //The order id of the effect spell
  private string EffectOrderID = "unholyfrenzy"

  // Do not change the following
  private group Infected = CreateGroup()
  private group g = CreateGroup()
  private timer t = CreateTimer()
  private boolexpr filter = null
endglobals

///////////////////////////////////Defining most relevant Values////////////////////////////////////////////////

//Defines how long an infection will last without any reinfactions
private function DurationPerLevel takes integer level returns integer
  return 2 + level
endfunction

//Defines the infection range of the hero spreading the flu
private constant function InfectionRange takes real level returns real
  return 175 + 25 * level
endfunction

//Defines the infection range of an infected unit
private constant function InfectedInfectionRange takes real level returns real
  return 175 + 25 * level
endfunction

//Defines the chance per interval to infect a unit with the hero
private constant function InfectionChance takes real level returns real
  return 0.2+0.15*level
endfunction

//Defines the chance per interval of an infected unit to infect another
private constant function InfectedInfectionChance takes real level returns real
  return 0.12
endfunction

//The conditions a unit can be infected
private function InfectCondition takes unit a, player p returns boolean
  return not(IsUnitType(a, UNIT_TYPE_MECHANICAL)) and not(IsUnitType(a, UNIT_TYPE_MAGIC_IMMUNE)) and (GetWidgetLife(a) > 0) and IsPlayerEnemy(GetOwningPlayer(a),p) // The condition if a unit is infected
endfunction

  //The condition if trigger should run (refers to the event : EVENT_PLAYER_HERO_SKILL)
private function RunCondition takes nothing returns boolean
  return (GetUnitAbilityLevel(GetTriggerUnit(),SwineFluSpell) != 0)
endfunction

//////////////////////////////////Main Struckt//Do not change//////////////////////////////////////////////

private struct Infection
  static integer Index = 0
  static Infection array Data
  integer left
  unit u = null
  player p
  integer level
  static method create takes nothing returns Infection
  local Infection data = Infection.allocate()
  set Infection.Data[Infection.Index] = data
  set Infection.Index = Infection.Index + 1
  return data
  endmethod
endstruct

////////////////////////////////Main script// Do not edit unless you understand it////////////////////////////////

private function AddSwineFlu takes unit target, integer level, player a returns nothing
  local unit dummy = CreateUnit(a,CastDummyID,GetUnitX(target),GetUnitY(target),0)
  call UnitAddAbility(dummy,SwineFluSpellEffect)
  call SetUnitAbilityLevel(dummy,SwineFluSpellEffect,level)
  call UnitApplyTimedLife(dummy, 'BTLF', 0.75)
  call IssueTargetOrder( dummy, EffectOrderID,target)
  set dummy = null
endfunction

private function GetStructOfUnit takes unit u returns integer
  local Infection data
  local integer i = 0
  loop
  exitwhen i >= Infection.Index
  set data = Infection.Data[i]
if data.u == u then
  return i
  endif
  set i = i +1
  endloop
  return 0
endfunction

private constant function NullFilter takes nothing returns boolean
  return true
endfunction

function Callback takes nothing returns nothing
  local Infection data
  local integer i = 0
  local integer ii = 0
  local integer level = 0
  local unit b
  local unit a
  local real x
  local real y
  local real c
  local integer max = Infection.Index
  loop //looping through all structs
  exitwhen i >= max
  set data = Infection.Data[i]
  set a = data.u
  if (GetWidgetLife(a) > 0) and (data.left != 0) then //buff gets removed + struct destroey if the unit is dead or its infection timer expires
  if data.left != -1 then
  set data.left = data.left-1 // decreases infection timer , -1 means its forever (in this case for your hero)
  endif
  set level = data.level
  set x = GetUnitX(a)
  set y = GetUnitY(a)
  if GetOwningPlayer(a) == data.p then
  call GroupEnumUnitsInRange(g, x, y,InfectionRange(I2R(data.level)), filter)
  else
  call GroupEnumUnitsInRange(g, x, y,InfectedInfectionRange(I2R(data.level)), filter)
  endif
  call GroupRemoveUnit(g,a)
  loop //looping through all units in range
  set b = FirstOfGroup(g)
  exitwhen b == null
  call GroupRemoveUnit(g,b)
  set ii = GetStructOfUnit(b)
  set c = GetRandomReal(0.00,1.00)
  if ((c < InfectionChance(data.level) and GetOwningPlayer(a) == data.p) or (c < InfectedInfectionChance(data.level) and GetOwningPlayer(a) != data.p)) and InfectCondition(b,data.p) == true and ((Infection.Data[ii].left != -1) or not(IsUnitInGroup(b,Infected)))then
  if not(IsUnitInGroup(b,Infected)) then
  //Infecting the target
  call GroupAddUnit(Infected,b)
  call AddSwineFlu(b,data.level,data.p)
  call Infection.create()
  set Infection.Data[Infection.Index-1].u = b
  set Infection.Data[Infection.Index-1].p = data.p
  set Infection.Data[Infection.Index-1].level = data.level
  set Infection.Data[Infection.Index-1].left = R2I(I2R(DurationPerLevel(data.level))/TimerPeriod)
  else
  //Reinfecting the target
  if Infection.Data[ii].level < data.level then
  set Infection.Data[ii].level = data.level
  set Infection.Data[ii].p = data.p
  call AddSwineFlu(b,data.level,data.p)
  set Infection.Data[ii].left = R2I(I2R(DurationPerLevel(data.level))/TimerPeriod)
  else
  set Infection.Data[ii].left = R2I(I2R(DurationPerLevel(data.level))/TimerPeriod)
  endif
  endif
  endif
  endloop
  else
  //detroying struct + removing buff
  call UnitRemoveAbility(data.u, SwineFluBuffCode)
  call GroupRemoveUnit(Infected,data.u)
  set data.u = null
  set data.p = null
  call Infection.destroy(data)
  set ii = i
  loop
  exitwhen ii == Infection.Index
  set Infection.Data[ii] = Infection.Data[ii+1]
  set ii = ii + 1
  endloop
set i = i -1
  set Infection.Index = Infection.Index - 1
  set max = max - 1
  endif
  set i = i + 1
  set ii = 0
  set level = 0
  endloop
  set a = null
  set b = null
endfunction

function Swine_Flu_Actions takes nothing returns nothing
  local integer i
  local unit u = GetTriggerUnit()
  if IsUnitInGroup(u,Infected) then
  //modifing the current struct if the unit had Swineflue before
  set i = GetStructOfUnit(u)
  set Infection.Data[i].p = GetOwningPlayer(u)
  set Infection.Data[i].level = GetUnitAbilityLevel(u,SwineFluSpell)
  else
  //creating the struct and adding the hero
  call GroupAddUnit(Infected,u)
  call Infection.create()
set Infection.Data[Infection.Index-1].u = u
  set Infection.Data[Infection.Index-1].left = -1
  set Infection.Data[Infection.Index-1].p = GetOwningPlayer(u)
  set Infection.Data[Infection.Index-1].level = GetUnitAbilityLevel(u,SwineFluSpell)
  if Infection.Data[Infection.Index-1].Index == 1 then
  call TimerStart(t, TimerPeriod, true, function Callback)
  endif
  endif
  set u = null
endfunction

//===========================================================================
function InitTrig_Swine_Flu takes nothing returns nothing
  local integer index
  local boolexpr cond = Condition( function RunCondition )
  set filter = Filter(function NullFilter)
  set gg_trg_Swine_Flu = CreateTrigger( )
  set index = 0
  loop
  call TriggerRegisterPlayerUnitEvent(gg_trg_Swine_Flu, Player(index),EVENT_PLAYER_HERO_SKILL, filter)
  set index = index + 1
  exitwhen index == bj_MAX_PLAYER_SLOTS
  endloop
  call TriggerAddCondition( gg_trg_Swine_Flu, cond )
  call TriggerAddAction( gg_trg_Swine_Flu, function Swine_Flu_Actions )
  set cond = null
endfunction

endscope