Esdo's Gold Award and K-D-A system v1.2a

[Moderator]

12th Dec 2015
IcemanBo: Too long as NeedsFix. Rejected.

18:24, 9th Jul 2014
PurgeandFire: Review:
http://www.hiveworkshop.com/forums/2554140-post30.html

 

[deathismyfriend]

Hashtable array ? You should never use a hashtable array.

This needs to be reworked so it does not use a hashtable array.

It can be a good system but the hashtable arrays have to go.

 

[Kazeon]

It can be a good system but the hashtable arrays have to go.

it's indeed useful

so here is full review

Hidden

COMMING SOON

 

[esdo]

Hashtable array ? You should never use a hashtable array.

This needs to be reworked so it does not use a hashtable array.

It can be a good system but the hashtable arrays have to go.

Why? Leaking? Not efficient? Lag? Better Ways?

I see absolutely no way of reworking this to remove hashtable arrays - I would need a whole new system.

One possibility I had to chose from when creating this was using some method of double indexing, but i thought this was better. I've read somewhere that hashtables are 2x slower that indexing, but I didn't think that would matter when all my system do is some simple math.

 

[deathismyfriend]

You can only have 255 hashtables in your map so once 256 total hashtables are created this system will break.

Hashtables are also 4 to 8 times slower and they get slower with more info added.

Basic method of doing this with only one hashtable is to make it with an indexing hashtable method.
Basically you store everything you can in arrays and use the hashtable to load a key / index to which array you are storing the stuff for that unit.

 

[esdo]

You can only have 255 hashtables in your map so once 256 total hashtables are created this system will break.

Hashtables are also 4 to 8 times slower and they get slower with more info added.

Sh*t. =(((

How do you suggest I rework my system? Because like i said, I have no friggin idea how to "rework" the system, only how to make a brand new one.

 

[deathismyfriend]

Give me a few minutes and I will update this with a good description of how to do something like what you are trying to achieve.

Basic method of doing this with only one hashtable is to make it with an indexing hashtable method.
Basically you store everything you can in arrays and use the hashtable to load a key / index to which array you are storing the stuff for that unit.
Hashtable will be called HASHTABLE

So for example unit 1 (attacking unit) attacks unit 2(damaged unit). To make it easy handle id of unit 1 is 1000 and for unit 2 it is 2000. The index counter will be called hashIndexCount

Then you store info like this.
hashIndexCount = (hashIndexCount + 1)
Save hashIndexCount as 0 of 1000 in HASHTABLE
// The above will store the index identifier in the hashtable.
// Next we store the unit that is doing the attacking into the hashtable.
// So we need a max integer to determine how many units have attacked that unit. Call it NumOfUnitsThatAttacked[]. It is also an array.
// we also need a temp boolean.
Set TempBoolean = true
Loop For each tempInt from 0 to NumOfUnitsThatAttacked[ hashIndexCount]
// This is to check if that unit has attacked before.
// To store the units that attacked before we need an integer array. I'll call it AttackingUnitIDs
If 2000 == AttackingUnitIDs[ tempInt] // If this is true then the unit is already in there and you need to increase the amount of damage it did.
then
increase damage with damage that was done.
Set TempBoolean = false
else
// After the loop we check the boolean.
If TempBoolean == true
then
// create new instance for the attacking unit.
// First we increase the counter that keeps count of how many units have attacked that one unit.
NumOfUnitsThatAttacked[ hashIndexCount] = (NumOfUnitsThatAttacked[ hashIndexCount] + 1)
// Then we store the new unit with all info needed into arrays that deal with the units damage.
Set damage.

The above is just the basics.

To do counters efficiently add an integer array or a real array your choice. ( I prefer real arrays). Name it TimeAttackResets. ( Your 20 second time )
First you need a trigger that runs every .03 seconds Every .03 seconds add it to a GameTime real variable.
In the ITE where you check for the units id type you need to check if the GameTime is greater than TimeAttackResets is. If it is then you remove that unit since his delay between attacks time will be to long.
You then de-index that unit. If you need a better explanation on how to do integer timers then I can try to explain it better.

 

[esdo]

I'm having a hard time understanding this - could you explain it better?

Is it that you are suggesting to keep track of each damage instance? Like if unit A attacks unit B, index ++. If unit A attacks C, Index ++. That way the maximum num. of instances would be 8192 ( or something like that ).

Anyway - wouldn't it be FAR easier to do this in vJass? I think I'm gonna give it a try.

 

[deathismyfriend]

I'm having a hard time understanding this - could you explain it better?

Is it that you are suggesting to keep track of each damage instance? Like if unit A attacks unit B, index ++. If unit A attacks C, Index ++. That way the maximum num. of instances would be 8192 ( or something like that ).

Anyway - wouldn't it be FAR easier to do this in vJass? I think I'm gonna give it a try.

What I am doing above is basically making structs that would hold all of the info.

You have to know how much damage the unit did to tell how much gold it should get.

 

[esdo]

What I am doing above is basically making structs that would hold all of the info.

You have to know how much damage the unit did to tell how much gold it should get.

Okay, so, what I would need to do is create one damage instance ( like a registry, something that increases the Max Index ) every time a unit is attacked, similarly to when the Index of a MUI ability is increased when some unit casts it?

Problem is that there would be a cap at 8192 attacks. Right?

 

[deathismyfriend]

Okay, so, what I would need to do is create one damage instance ( like a registry, something that increases the Max Index ) every time a unit is attacked, similarly to when the Index of a MUI ability is increased when some unit casts it?

Problem is that there would be a cap at 8192 attacks. Right?

I gave you the trigger to register attacks and store damage that units have done.

Also this allows up to 8192 instances of units getting attacked. Not 8192 attacks.

 

[esdo]

yeah okay, got it. I already started remaking the system.

But hey, is it really necessary? I mean... is there any map with more than 255 units?

 

[deathismyfriend]

255 units yes way more. But the main problem is a lot of those maps use several systems. Each of them may be made with a hashtable.

 

[esdo]

255 units yes way more. But the main problem is a lot of those maps use several systems. Each of them may be made with a hashtable.

uhm yeah, good point, forgot bout' that.

 

[Kazeon]

I don't get the point of using arrayed hashtable, this can be simply done with one hashtable

• If (All Conditions are True) then do (Then Actions) else do (Else Actions)
• If - Conditions
• Bounty_KilledUnit Equal to Bounty_DamagedUnit[Bounty_LoopInteger]

you dont need to do that check if you store unit handle into hashtable..

and final suggestion is, use vJass! use Table and any problem about hashtable is fixed although it's just suggestion

 

[deathismyfriend]

and final suggestion is, use vJass! use Table and any problem about hashtable is fixed although it's just suggestion

Table is not needed. However structs would make this slightly easier but not much. I gave him a way to make structs in GUI in my above post.

 

[IcemanBo]

Table is not needed. However structs would make this slightly easier but not much. I gave him a way to make structs in GUI in my above post.

What you suggested has nothing todo with structs imao. How you would work with structs with using GUI?

 

[deathismyfriend]

What you suggested has nothing todo with structs imao. How you would work with structs with using GUI?

What I said above creates a struct to be used. Structs are simple an integer array.

The this.unit is the same as unit[ this]
So if this = 1 it would be the same as unit[ 1]

Structs in Vjass use this same method. It is just better syntax in vJass. Also the indexing they use is a little better than indexed arrays. They also have a way to stop crashes since it simply doesn't let you create a new struct if you cannot.

 

[esdo]

I'm still learning vJass.

Spell updated - added some real nice features... And fixed the hash problem.

 

[deathismyfriend]

You still use hashtable arrays...

 

[esdo]

You still use hashtable arrays...

Uh?

I don't have a single hashtable in my map.

 

[deathismyfriend]

Uh?

I don't have a single hashtable in my map.

I posted before the spell description was updated.

I'll check out the system when I can.

Edit:
This should use a hashtable for lookup purposes. It is very slow looking through all of the instances. This will eventually hit the op-limit.
The method I provided to you above will never hit op-limit. Only limit it can hit is the 8192 limit but that means that there has to be 8192 units being attacked before it breaks. It also does not need the loop trigger.
It only needs three triggers. The config trigger. A trigger that fires when unit is damaged. And a trigger that fires when unit dies.


If you need help making the system I described above feel free to ask. I will help. If not I may make the system when I can.

 

[esdo]

No problem - i think i know what I forgot:

instead of loop trigger, compare damage time woth game time

and

store the indexes into an hashtable at the unit's handle ID

right?

 

[deathismyfriend]

Yes after that it will work a lot better. Also you need to get rid of the looping trigger.

 

[esdo]

I'll need better explanation.

I tried to apply what you suggested but, even tho i kinda get the idea, idk how to implement it.

 

[deathismyfriend]

Can you show me what you have tried ?

 

[GywGod133]

Player Group Leak...

 

[Kazeon]

store the indexes into an hashtable at the unit's handle ID

here is my idea:

• set UnitHandle = GetHandleId(caster)
• Hashtable - Save real (your timer) as (UnitHandle) child key (1)
• Hashtable - Save real (damage given) as (UnitHandle) child key (2)
• --- Then just do the same thing to save any variable using unit's handle ID as index ---
• --- But remember to always use different child key for each data ---

so when you need it: (when damage event as example)

• Event - DamageEvent equal to 1.00
• Condition -
• Action -
  • set UnitHandle = GetHandleId(DamageSource)
  • --- Then save the damage given ---
  • Hashtable - Save real ((Load real (UnitHandle) child key (2)) + DamageAmount) as (UnitHandle) child key (2)

yeah, something like that, I'm sorry I write it manually
I'm pretty sure you will understand if you read it carefully

it's a good update and maybe acceptable at this state, I haven't look further, but using hashtable is just faster and easier

 

[deathismyfriend]

here is my idea:

• set UnitHandle = GetHandleId(caster)
• Hashtable - Save real (your timer) as (UnitHandle) child key (1)
• Hashtable - Save real (damage given) as (UnitHandle) child key (2)
• --- Then just do the same thing to save any variable using unit's handle ID as index ---
• --- But remember to always use different child key for each data ---

so when you need it: (when damage event as example)

• Event - DamageEvent equal to 1.00
• Condition -
• Action -
  • set UnitHandle = GetHandleId(DamageSource)
  • --- Then save the damage given ---
  • Hashtable - Save real ((Load real (UnitHandle) child key (2)) + DamageAmount) as (UnitHandle) child key (2)

The problem with the way you have written is the lookup for when the unit dies to see who gets the bounty for killing that unit. You would have to search through everything to see which units get bounty.

 

[PurgeandFire]

Review:

• You've improved it quite a bit since you first submitted it. Nice job!
• I really like the idea and the implementation.
• You should add an option of whether to display the floating text (a boolean configurable).
• Remove the "Game - Display" messages, such as "New Damage Instance!". If you want to keep the one telling the bounty received, that is fine, but make it a configurable of whether to display it.
• There could be some improvement by using a hashtable. As deathismyfriend said, looping through all the damage instances is pretty heavy. By using a hashtable, you could store each damage instance under the keys of the source and target. That way, you can just load their index from the hashtable rather than looping through all the instances.
  
  Here is your current implementation:
  
  Code

  • AwardGoldStore
    • Events
      • Game - DamageEvent becomes Equal to 1.00
    • Conditions
      • ((Owner of DamageEventSource) is an ally of (Owner of DamageEventTarget)) Equal to False
    • Actions
      • Set AwardGold_HasChecker = False
      • For each (Integer AwardGold_LoopInteger) from 1 to AwardGold_Index, do (Actions)
        • Loop - Actions
          • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
            • If - Conditions
              • DamageEventTarget Equal to AwardGold_Target[AwardGold_LoopInteger]
              • DamageEventSource Equal to AwardGold_Source[AwardGold_LoopInteger]
            • Then - Actions
              • Set AwardGold_HasChecker = True
              • Set AwardGold_Amount[AwardGold_LoopInteger] = (AwardGold_Amount[AwardGold_LoopInteger] + DamageEventAmount)
              • Set AwardGold_Period[AwardGold_LoopInteger] = AwardGold_ResetTimer
            • Else - Actions
      • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
        • If - Conditions
          • AwardGold_HasChecker Equal to False
        • Then - Actions
          • Set AwardGold_Index = (AwardGold_Index + 1)
          • Set AwardGold_Target[AwardGold_Index] = DamageEventTarget
          • Set AwardGold_Source[AwardGold_Index] = DamageEventSource
          • Set AwardGold_Amount[AwardGold_Index] = DamageEventAmount
          • Set AwardGold_Period[AwardGold_Index] = AwardGold_ResetTimer
          • Game - Display to (All players) the text: New damage instance!
        • Else - Actions
      • Game - Display to (All players) the text: ((Name of DamageEventSource) + ( dealt + ((String(DamageEventAmount, 0, 0)) + ( damage to + ((Name of DamageEventTarget) + .)))))
  With a hashtable, it could look something like this:
  
  Code

  • AwardGoldStore
    • Events
      • Game - DamageEvent becomes Equal to 1.00
    • Conditions
      • ((Owner of DamageEventSource) is an ally of (Owner of DamageEventTarget)) Equal to False
    • Actions
      • Set AwardGold_HasChecker = False
      • Set AwardGold_LoopInteger = (Load (Key DamageEventTarget) of (Key DamageEventSource) in AwardGold_Hash)
      • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
        • If - Conditions
          • (AwardGold_LoopInteger) Not Equal to 0
        • Then - Actions
          • Set AwardGold_HasChecker = True
          • Set AwardGold_Amount[AwardGold_LoopInteger] = (AwardGold_Amount[AwardGold_LoopInteger] + DamageEventAmount)
          • Set AwardGold_Period[AwardGold_LoopInteger] = AwardGold_ResetTimer
        • Else - Actions
      • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
        • If - Conditions
          • AwardGold_HasChecker Equal to False
        • Then - Actions
          • Set AwardGold_Index = (AwardGold_Index + 1)
          • Set AwardGold_Target[AwardGold_Index] = DamageEventTarget
          • Set AwardGold_Source[AwardGold_Index] = DamageEventSource
          • Set AwardGold_Amount[AwardGold_Index] = DamageEventAmount
          • Set AwardGold_Period[AwardGold_Index] = AwardGold_ResetTimer
          • Hashtable - Save AwardGold_Index as (Key DamageEventTarget) of (Key DamageEventSource) in AwardGold_Hash
          • Game - Display to (All players) the text: New damage instance!
        • Else - Actions
      • Game - Display to (All players) the text: ((Name of DamageEventSource) + ( dealt + ((String(DamageEventAmount, 0, 0)) + ( damage to + ((Name of DamageEventTarget) + .)))))
  And that would be a lot more efficient. That was freehand, so it might not work/be exact, but that should paint a basic picture of what it would look like. Of course, when you decrease AwardGold_Index, you would also remove the data from the hashtable. It would require a bit of work, but it would really help make this a solid system.

Otherwise, nice job. Just make a few updates and it should be approvable. The last update (about the hashtable) isn't required, but it could bump up the rating, and I highly recommend it.