[JASS] Destructable -EVENT_ATTACKED-

[pred1980]

Hi hivers,

i have destructables which players can destroy but for one team it should not be possible. I want to check if a destructable is attacked... I can't find a solution for it.

Any Ideas?

 

[Wietlol]

The only way to interact with destructables is with abilities.

 

[pred1980]

Can u explain it please or give and short example?

 

[Wietlol]

Make an ability based of Channel or Eat Tree or stuff like that and you will be able to cast it on destructables.
With channel there is one problem that the destructables have to be selectable to be targeted.

In any case, that is the only way how you can use events for when a unit interacts with a destructable.
You would have to replace the attacks with customized spells to make it look the same and then destroy the destructable with triggers.

Another method would be to not use destructables and use units (probably buildings) to replace them.

 

[pred1980]

ok, thank you!

 

[Bribe]

Anyone know why the "harvest" order is what's used on these destructable checkers? It doesn't allow you to detect a barrel, for example. Why not simply have the harvest ability on the unit but order it to attack?

 

[WaterKnight]

Peons can attack trees without harvesting lumber.

 

[Bribe]

Exactly, which is why I think the attack order should be used so you can destroy things like barrels with it.

 

[Avahor]

use function GetOrderTargetDestructable() in conjuntion with the event EVENT_PLAYER_UNIT_ISSUED_TARGET_ORDER.

wierd trigger sample:

function TCondition takes nothing returns boolean
 return GetDestructableTypeId(GetOrderTargetDestructable())==YOUR_DESTRUCTABLE_TYPE_ID
//Also you can check GetOrderTargetDestructable()==YOUR_DESTRUCTABLE
endfunction

function TActions takes nothing returns nothing
   local unit u = GetTriggerUnit()
   local destructable d = GetOrderTargetDestructable()

  if (condition) then //Code to check if unit is allowed to attack the destructable if not then 
     call IssueInmediateOrder (u,"stop")
  endif

 set u = null //clean local var
 set d = null

endfunction


function InitAttackedDestructableTrigger takes nothing returns nothing
 local trigger DestructableTrigger = CreateTrigger( )
 local integer index = 0

 loop
  exitwhen index> bj_MAX_PLAYER_SLOTS
   call TriggerRegisterPlayerUnitEvent(DestructableTrigger, Player(index),EVENT_PLAYER_UNIT_ISSUED_TARGET_ORDER, null )
  set index = index + 1
 endloop 
 
 call TriggerAddCondition(DestructableTrigger, Condition(function TCondition))
 call TriggerAddAction(DestructableTrigger, function TActions)

 set DestructableTrigger = null //local var clean
endfunction

There could have better ways to attach actions to a destructable, but this one is very usefull for me. I hope It helps you.
edit: I posted another response. fixed now - Forget to add triggeractions to DestructableTrigger (fixed)
So another usefull function is GetTriggerDestructable()

 

[pred1980]

WOW, thx Avahor. I'll test it later I hope it works

 

[Bribe]

Will flame strike and other destructable-killing spells be an issue in your map?

 

[pred1980]

Nope. I just have these gravestones which the players can destroy. Not more.

@Avahor: It works perfectly! Thx a lot!!!!

 

[Dr Super Good]

Another solution is to make them units and disable allied targeting.

 

[pred1980]

@Avahor:

This didn't work:

call IssueImmediateOrder(u,"stop")

You have to add a line before:

call TriggerSleepAction(0.0)
call IssueImmediateOrder(u,"stop")

Best Reg.

 

[WaterKnight]

call IssuePointOrder(u, "move", GetUnitX(u) + Cos(GetUnitFacing(u) * bj_DEGTORAD), GetUnitY(u) + Sin(GetUnitFacing(u) * bj_DEGTORAD))

 

[Bribe]

Or pause the unit, order it to stop, then unpause it.

 

[Dr Super Good]

call TriggerSleepAction(0.0)

Does not work either. That is a 0.1+ delay.

 

[Wietlol]

There are two ways to do this... and neither are really working 100% glitchless.

One way which already has been said is to pause the unit, order it and unpause it, which basically has a weird result.
Or you add a very small delay, which is also mentioned before... however in a not really nice way.

In the second way, you would have to create a new timer, store the unit and order on the timer, start the timer and order the unit when the timer expires... this is a pain to do every single time and you will 100% forget something now and then.

However, I prefer that way and have written a nice thing that makes me be able to delay the order of the 3 most used IssueOrder functions.
It uses TimerUtils and a small library that I wrote that makes a unique index for it.
(How I make a new index in that library is discussable and I should have made that in textmacros so you can have one for each thing that you desire but who the hell cares.)

JASS Code

library TimerIndex uses TimerUtils
//*********************************************************************
//* TimerIndex 1.0
//* ----------
//*
//*  This library creates a unique index for the TimerData of timerUtils.
//*  A timer that is created with an index must also be released as an indexed timer.
//*
    
    globals
        integer udg_NextTimerIndex = 0
        boolean array udg_TimerIndex_Occupied
    endglobals
    
    function ReleaseIndexedTimer takes timer t returns nothing
        set udg_TimerIndex_Occupied[GetTimerData(t)] = false
        call ReleaseTimer(t)
    endfunction
    function NewIndexedTimer takes nothing returns timer
        loop
            set udg_NextTimerIndex = udg_NextTimerIndex + 1
            if udg_NextTimerIndex > 8190 then
                set udg_NextTimerIndex = 1
            endif
            
            exitwhen not udg_TimerIndex_Occupied[udg_NextTimerIndex]
        endloop
        
        set udg_TimerIndex_Occupied[udg_NextTimerIndex] = true
        return NewTimerEx(udg_NextTimerIndex)
    endfunction
    
endlibrary

library DelayedOrder uses TimerIndex
    
    globals
        
        unit array      udg_DelayedOrder_WhichUnit
        integer array   udg_DelayedOrder_OrderId
        real array      udg_DelayedOrder_TargetPoint_X
        real array      udg_DelayedOrder_TargetPoint_Y
        widget array    udg_DelayedOrder_TargetWidget
        
    endglobals
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    function IssueImmediateOrderByIdCallback takes nothing returns nothing
        local timer t = GetExpiredTimer()
        local integer id = GetTimerData(t)
        call ReleaseIndexedTimer(t)
        
        call IssueImmediateOrderById(udg_DelayedOrder_WhichUnit[id], udg_DelayedOrder_OrderId[id])
        set udg_DelayedOrder_WhichUnit[id] = null
        set udg_DelayedOrder_OrderId[id] = 0
    endfunction
    function IssueImmediateOrderByIdDelayed takes unit whichUnit, integer order, real delay returns nothing
        local timer t = NewIndexedTimer()
        local integer id = GetTimerData(t)
        
        set udg_DelayedOrder_WhichUnit[id] = whichUnit
        set udg_DelayedOrder_OrderId[id] = order
        
        call TimerStart(t, delay, false, function IssueImmediateOrderByIdCallback)
        set t = null
    endfunction
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    function IssuePointOrderByIdCallback takes nothing returns nothing
        local timer t = GetExpiredTimer()
        local integer id = GetTimerData(t)
        call ReleaseIndexedTimer(t)
        
        call IssuePointOrderById(udg_DelayedOrder_WhichUnit[id], udg_DelayedOrder_OrderId[id], udg_DelayedOrder_TargetPoint_X[id], udg_DelayedOrder_TargetPoint_Y[id])
        set udg_DelayedOrder_WhichUnit[id] = null
        set udg_DelayedOrder_OrderId[id] = 0
        set udg_DelayedOrder_TargetPoint_X[id] = 0.
        set udg_DelayedOrder_TargetPoint_Y[id] = 0.
    endfunction
    function IssuePointOrderByIdDelayed takes unit whichUnit, integer order, real x, real y, real delay returns nothing
        local timer t = NewIndexedTimer()
        local integer id = GetTimerData(t)
        
        set udg_DelayedOrder_WhichUnit[id] = whichUnit
        set udg_DelayedOrder_OrderId[id] = order
        set udg_DelayedOrder_TargetPoint_X[id] = x
        set udg_DelayedOrder_TargetPoint_Y[id] = y
        
        call TimerStart(t, delay, false, function IssuePointOrderByIdCallback)
        set t = null
    endfunction
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    function IssueTargetOrderByIdCallback takes nothing returns nothing
        local timer t = GetExpiredTimer()
        local integer id = GetTimerData(t)
        call ReleaseIndexedTimer(t)
        
        call IssueTargetOrderById(udg_DelayedOrder_WhichUnit[id], udg_DelayedOrder_OrderId[id], udg_DelayedOrder_TargetWidget[id])
        set udg_DelayedOrder_WhichUnit[id] = null
        set udg_DelayedOrder_OrderId[id] = 0
        set udg_DelayedOrder_TargetWidget[id] = null
    endfunction
    function IssueTargetOrderByIdDelayed takes unit whichUnit, integer order, widget targetWidget, real delay returns nothing
        local timer t = NewIndexedTimer()
        local integer id = GetTimerData(t)
        
        set udg_DelayedOrder_WhichUnit[id] = whichUnit
        set udg_DelayedOrder_OrderId[id] = order
        set udg_DelayedOrder_TargetWidget[id] = targetWidget
        
        call TimerStart(t, delay, false, function IssueTargetOrderByIdCallback)
        set t = null
    endfunction
    
endlibrary

The basic difference is that you change
IssueImmediateOrderById
into
IssueImmediateOrderByIdDelayed
(You add "Delayed" to the function call.)

and
(myUnit, myOrder)
into
(myUnit, myOrder, 12.34)
(You add a real variable at the end defining the duration of the timer. This is recommended to not use a value below 0.)

Be aware that this uses the integer value of your order.
To convert the string to the integer, you use OrderId("stop") (where stop is your order string).

You can however just write another snippet that takes all order strings that you want to have as integer variables and generate their values at map initialization.
This is something that I use often.

OrderIds

globals
    
    integer ORDER_STOP
    integer ORDER_ATTACK
    integer ORDER_MOVE
    integer ORDER_SMART
    
endglobals

//===========================================================================
function InitTrig_OrderIds takes nothing returns nothing
    
    set ORDER_STOP = OrderId("stop")
    set ORDER_ATTACK = OrderId("attack")
    set ORDER_MOVE = OrderId("move")
    set ORDER_SMART = OrderId("smart")
    
endfunction

Ofcourse, you can add your own stuff in here.
(Be aware that you don't break OP limit with these things so having a timer started at init and set the orders when that timer expires will help a lot... however, be sure that you initialize them before you try to use them.)

One last thing though... "Post Quick Reply"... Quick my ass.

 

[pred1980]

Does not work either. That is a 0.1+ delay.

Strange, here is works. The Hero stop attacking the gravestones and thats what i want. I'll try the pause on/off mentioned by bribe... Anyway one of them are ok for me.

 

[Wietlol]

DSG means that you get a slightly delay which is in some cases enough to complete the order which is kind of not what you want...
Or when you try to move the unit, he will still move for 0.15 seconds every time you right click... which means that if you spamm it, your unit will just walk "normally".

 

[pred1980]

So, what is the best solution for it? What i did or the pause or the move?

 

[Wietlol]

Not what you did.
The best solution is either the pause and unpause or what I uploaded.

My method is basically the same as yours except it has "no" delay... however it has no GUI support.

 

[pred1980]

ok, so i'll change to the pause/unpause version.