System ItemGroup

[Sevion]

Igs- ItemGroup
The First ItemGroup Variable Type​

Current Version- v1.2

Requires-

Spoiler

(N/A)

Restrictions-

Spoiler

Max of 8190 items, but also a max of 1 itemgroup.
Default at 682 items with a max of 12 itemgroups.

News Count- 3

Overview

Spoiler

FAQ

Spoiler

What's the point of this?

Spoiler

There isn't an itemgroup variable type. So, I made one.

ItemGroup is very simple to use. The layout is as close to unit groups as I could get them.

To configure itemgroup, go into the ItemGroup library and look for:

private constant integer ARRAY_SIZE = 682

682 items is the default maximum. I don't see a point in setting it very high, as it quickly diminishes your maximum amount of itemgroups, and as I see it, 682 is plenty items at a time. Add more if you need to. In fact, 819/682.5 = 12, thus giving you one itemgroup per player with a maximum of 682.5 items. Since it's an integer, we round down to 682. That's plenty.

To create an itemgroup, simply call CreateItemGroup()

local itemgroup g = CreateItemGroup()

Now, add some items to it:

call ItemGroupEnumItemsInRect(g, GetWorldBounds(), null)

That will add all items in the map to the itemgroup.

Next, do stuff with it:

function do takes nothing returns nothing
    call RemoveItem(GetEnumItemGroupItem())
endfunction

function start takes nothing returns nothing
    local itemgroup g = CreateItemGroup()
    call ItemGroupEnumItemsInRect(g, GetWorldBounds(), null)
    call ForItemGroup(g, function do)
    call DestroyItemGroup(g)
endfunction

Let's look at some of the fuctions used in there:

.
GetEnumItemGroupItem()
1. Returns the enum; essentially the same as GetEnumItem for Igs.

ForItemGroup(g, function do)
2. Executes function do for all items in the itemgroup; essentially the same as ForGroup for Igs.

DestroyItemGroup(g)
3. Destroys the itemgroup; all members of the struct are nulled in the onDestroy method; essentially the same as DestroyGroup for Igs.

There are many other Enum functions but all are the same as their respective unit group counterparts.

They should be simple enough to figure out.

And that's all there is to Igs.

-News Section-

Spoiler

News 1

Spoiler

The first release of ItemGroup. Sadly, it doesn't use linked lists. Perhaps I will make a linked lists version some time later on.

News 2

Spoiler

Fixed some bugs in the code and removed O(n) searching on removal.

News 3

Spoiler

Added CountItemsInItemGroup and IsItemInItemGroup

-System Section-

Igs Code Area

Spoiler

/*System Information
===================================================================
Name: ItemGroup
Version: 1.2
Author: Sevion
Helpers: Flare

Description: ItemGroup Variable Type

Requirements: None

Usage:
------------------------------------------------------------------
local itemgroup g = CreateItemGroup()
call ItemGroupEnumItemsInRect(g, gg_rct_Region_000, null)
call ForItemGroup(g, function DoStuff)
call DestroyItemGroup(g)

Function List:
-CreateItemGroup()
-DestroyItemGroup()
-ItemGroupAddItem(itemgroup, item)
-ItemGroupRemoveItem(itemgroup, item)
-ItemGroupAddItemGroup(itemgroup, itemgroup)
-ItemGroupClear(itemgroup)
-ForItemGroup(itemgroup, code)
-CountItemsInItemGroup(itemgroup)
-IsItemInItemGroup(itemgroup)
-ItemGroupEnumItemsInRect(itemgroup, rect, boolexpr)
-ItemGroupEnumItemsInRectCount(itemgroup, rect, boolexpr, integer)
-ItemGroupEnumItemsInRange(itemgroup, real, real, real, boolexpr)
-ItemGroupEnumItemsInRangeCounted(itemgroup, real, real, real, boolexpr, integer)
-ItemGroupEnumItemsOfPlayer(itemgroup, player, boolexpr)
-ItemGroupEnumItemsOfType(itemgroup, integer, boolexpr)
-ItemGroupEnumItemsOfTypeCount(itemgroup, integer, boolexpr, integer)
-ItemGroupEnumItemsInRect(itemgroup, rect, boolexpr)
-ItemGroupEnumItemsInRect(itemgroup, rect, boolexpr)
-ItemGroupPickRandomItem(itemgroup)

Configuration:
-------------------------------------------------------------------
-Set ARRAY_SIZE to whatever you wish. The smaller it is, the fewer
-items you can have in an itemgroup. The larger, the fewer itemgroups
-you can have at one time.
===================================================================*/
library ItemGroup initializer Ini
    globals
        private constant integer ARRAY_SIZE = 682
    endglobals
    
    struct itemgroup
        item array items[ARRAY_SIZE]
        integer total = 0
        
        method onDestroy takes nothing returns nothing
            local integer i = .total
            loop
                exitwhen i == 0
                set .items<i> = null
                set i = i - 1
            endloop
            set .total = 0
        endmethod
    endstruct
    
    globals
        private real temp_x
        private real temp_y
        private rect temp_rect
        private real temp_radius
        private integer temp_count
        private integer temp_typeid
        private player temp_playerid
        private boolexpr temp_filter
        private itemgroup temp_itemgroup
        private integer temp_current_count
        private item enumitem
        private trigger t = CreateTrigger()
        private hashtable hasht = null
        private rect worldbounds
        public real trig = 0.
    endglobals
    
    function ItemGroupAddItem takes itemgroup g, item i returns nothing
        set g.total = g.total + 1
        set g.items[g.total] = i
        call SaveInteger (hasht, GetHandleId(i), g, g.total)
    endfunction
    
    function ItemGroupRemoveItem takes itemgroup g, item itm returns nothing
      local integer id = GetHandleId (itm)
      local integer id2 = GetHandleId (g.items[g.total])
      local integer index = LoadInteger (hasht, id, g)
      if HaveSavedInteger (hasht, id, g) then
        set g.items[index] = g.items[g.total]
        call RemoveSavedInteger (hasht, id, g)
        call RemoveSavedInteger (hasht, id2, g)
        call SaveInteger (hasht, id2, g, index)
        set g.total = g.total - 1
      endif
    endfunction
    
    private function EnumOfType takes nothing returns nothing
        if GetItemTypeId(GetEnumItem()) == temp_typeid then
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
        endif
    endfunction
    
    private function EnumOfTypeCount takes nothing returns nothing
        if GetItemTypeId(GetEnumItem()) == temp_typeid then
            if temp_current_count &gt; temp_count then
                return
            endif
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
        endif
    endfunction
    
    private function EnumOfPlayer takes nothing returns nothing
        if GetItemPlayer(GetEnumItem()) == temp_playerid then
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
        endif
    endfunction
    
    private function EnumInRect takes nothing returns nothing
        local real x = GetItemX(GetEnumItem())
        local real y = GetItemY(GetEnumItem())
        if x &gt;= GetRectMinX(temp_rect) and x &lt;= GetRectMaxX(temp_rect) and y &gt;= GetRectMinY(temp_rect) and y &lt;= GetRectMaxY(temp_rect) then
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
        endif
    endfunction
    
    private function EnumInRectCount takes nothing returns nothing
        local real x = GetItemX(GetEnumItem())
        local real y = GetItemY(GetEnumItem())
        if x &gt;= GetRectMinX(temp_rect) and x &lt;= GetRectMaxX(temp_rect) and y &gt;= GetRectMinY(temp_rect) and y &lt;= GetRectMaxY(temp_rect) then
            if temp_current_count &gt; temp_count then
                return
            endif
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
            set temp_current_count = temp_current_count + 1
        endif
    endfunction
    
    private function EnumInRange takes nothing returns nothing
        local real x = GetItemX(GetEnumItem()) - temp_x
        local real y = GetItemY(GetEnumItem()) - temp_y
        if SquareRoot(x*x+y*y) &lt;= temp_radius then
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
        endif
    endfunction
    
    private function EnumInRangeCount takes nothing returns nothing
        local real x = GetItemX(GetEnumItem()) - temp_x
        local real y = GetItemY(GetEnumItem()) - temp_y
        if SquareRoot(x*x+y*y) &lt;= temp_radius then
            if temp_current_count &gt; temp_count then
                return
            endif
            call ItemGroupAddItem(temp_itemgroup, GetEnumItem())
            set temp_current_count = temp_current_count + 1
        endif
    endfunction
    
    function ItemGroupEnumItemsInRange takes itemgroup g, real x, real y, real radius, boolexpr filter returns nothing
        set temp_x = x
        set temp_y = y
        set temp_radius = radius
        set temp_itemgroup = g
        call EnumItemsInRect(worldbounds, filter, function EnumInRange)
    endfunction
    
    function ItemGroupEnumItemsInRangeCounted takes itemgroup g, real x, real y, real radius, boolexpr filter, integer count returns nothing
        set temp_x = x
        set temp_y = y
        set temp_count = count
        set temp_radius = radius
        set temp_itemgroup = g
        set temp_current_count = 0
        call EnumItemsInRect(worldbounds, filter, function EnumInRangeCount)
    endfunction
    
    function ItemGroupEnumItemsInRect takes itemgroup g, rect r, boolexpr filter returns nothing
        set temp_rect = r
        set temp_itemgroup = g
        call EnumItemsInRect(worldbounds, filter, function EnumInRect)
    endfunction
    
    function ItemGroupEnumItemsInRectCounted takes itemgroup g, rect r, boolexpr filter, integer count returns nothing
        set temp_rect = r
        set temp_count = count
        set temp_itemgroup = g
        set temp_current_count = 0
        call EnumItemsInRect(worldbounds, filter, function EnumInRectCount)
    endfunction
    
    function ItemGroupEnumItemsOfPlayer takes itemgroup g, player playerid, boolexpr filter returns nothing
        set temp_playerid = playerid
        set temp_itemgroup = g
        call EnumItemsInRect(worldbounds, filter, function EnumOfPlayer)
    endfunction
    
    function ItemGroupEnumItemsOfType takes itemgroup g, integer typeid, boolexpr filter returns nothing
        set temp_typeid = typeid
        set temp_itemgroup = g
        call EnumItemsInRect(worldbounds, filter, function EnumOfType)
    endfunction
    
    function ItemGroupEnumItemsOfTypeCount takes itemgroup g, integer typeid, boolexpr filter, integer count returns nothing
        set temp_count = count
        set temp_typeid = typeid
        set temp_itemgroup = g
        set temp_current_count = 0
        call EnumItemsInRect(worldbounds, filter, function EnumOfType)
    endfunction
    
    function ItemGroupClear takes itemgroup g returns nothing
        local integer i = g.total
        loop
            exitwhen i == 0
            set g.items<i> = null
            set i = i - 1
        endloop
    endfunction
    
    function ItemGroupAddItemGroup takes itemgroup g1, itemgroup g2 returns nothing
        local integer i = g2.total
        loop
            exitwhen i ==0 or g1.total == 100
            call ItemGroupAddItem(g1, g2.items<i>)
            set i = i - 1
        endloop
    endfunction
    
    function GetEnumItemGroupItem takes nothing returns item
        return enumitem
    endfunction
    
    function CountItemsInItemGroup takes itemgroup g returns integer
        return g.total
    endfunction
    
    function IsItemInItemGroup takes itemgroup g, item it returns boolean
        local integer i = g.total
        loop
            exitwhen i == 0
            if g.items<i> == it then
                return true
            endif
            set i = i + 1
        endloop
        return false
    endfunction
    
    function ForItemGroup takes itemgroup g, code callback returns nothing
        local integer i = g.total
        loop
            exitwhen i == 0
            set enumitem = g.items<i>
            call TriggerAddAction(t, callback)
            set trig = 1.
            set trig = 0.
            call TriggerClearActions(t)
            set i = i - 1
        endloop
        set enumitem = null
    endfunction
    
    function ItemGroupPickRandomItem takes itemgroup g returns item
        return g.items[GetRandomInt(1, g.total)]
    endfunction
    
    function DestroyItemGroup takes itemgroup g returns nothing
        call g.destroy()
    endfunction
    
    function CreateItemGroup takes nothing returns itemgroup
        if hasht == null then
            set hasht = InitHashtable()
        endif
        return itemgroup.create()
    endfunction
    
    private function Ini takes nothing returns nothing
        call TriggerRegisterVariableEvent(t, &quot;ItemGroup_trig&quot;, GREATER_THAN, 0.)
        set worldbounds = GetWorldBounds()
    endfunction
endlibrary
</i></i></i></i></i>

[/spoiler]

 

[quraji]

LOL, I just noticed this after submitting HandleGroup! Hilarious!!

Anyways, neat code..but does it do other handles?

I suppose you've got those enum functions over me >.<

 

[Igor_Z]

Can Unit-Type group be made too?

 

[Flare]

    struct itemgroup
        item array items[ARRAY_SIZE]
        integer total = 0
        
        method onDestroy takes nothing returns nothing
            local integer i = [B]total[/B]
            loop
                exitwhen i == 0
                set items[i] = null
                set i = i - 1
            endloop
            set [B]total[/B] = 0
        [B]endfunction[/B]
    endstruct

1) Shouldn't those total's be .total? I can't see any globals outside the struct named total
2) Does endfunction work with a method declaration? I'm fairly sure that JASSHelper catches that as an error

EDIT: Ye, JASSHelper catches the endfunction here

struct test
  method mymethod takes nothing returns nothing
  endfunction
endstruct

as an Unexpected 'endfunction'.

Also, for your RemoveItem, you could avoid the O(n) search, and store the item's appropriate array index in a hashtable or gamecache e.g.

//When adding to a group, and once you've incremented .total
call SaveInteger (myHashTable, GetHandleId (myItem), myItemGroup, total)

That way, when removing your item, you simply have to do

function ItemGroupRemoveItem takes itemgroup g, item itm returns nothing
  local integer id = GetHandleId (itm)
  local integer id2 = GetHandleId (g.items[g.total])
  local integer index = LoadInteger (myHashTable, id, g)
  if HaveSavedInteger (myHashTable, id, g) then
    set g.items[index] = g.items[g.total]
    call RemoveSavedInteger (myHashTable, id, g)
    call RemoveSavedInteger (myHashTable, id2, g)
    call SaveInteger (myHashTable, id2, g, index)
    set g.total = g.total - 1
  endif
endfunction

which would remove the necessity for that RefreshItems function (since you should be just moving the item at the top of the array down to the newly available array slot, rather than pushing every single item above the free slot down

EDIT: Forgot to clear the array reference for the indexes that were cleared, and update the index for the item moving down the array

 

[quraji]

Including what Flare said (although his solution for the O(n) search won't work ), this also will cause an error:

    struct itemgroup
        item array items[ARRAY_SIZE]
        integer total = 0
        
        method onDestroy takes nothing returns nothing
            local integer i = total
            loop
                exitwhen i == 0
                set items<i> = null  // should be .items<i>
                set i = i - 1
            endloop
            set total = 0
        endfunction
    endstruct
</i></i>

Sev, did you even try to compile this?
Now that I've stopped laughing about my posting a group system right after you...I notice that your code isn't as 'neat' as I first said. Come on Sev, you can do better!

 

[Flare]

although his solution for the O(n) search won't work

Care to elaborate?

 

[quraji]

Care to elaborate?

You're a punk, you know that? Everyone can see that "Edited by Flare"

Why are you in stealth mode, by the way?

 

[Flare]

    function ItemGroupPickRandomItem takes itemgroup g returns nothing
        call ItemGroupEnumItemsInRect(g, GetWorldBounds(), Filter(function Random))
        if g.total == 0 then
            call ItemGroupPickRandomItem(g)
        endif
    endfunction

Oh gawd... what in the world possessed you to do that? You could've enumerated the items then done

return g.items[GetRandomInt (0, g.total)]

The way you've gone and done it, there's no guarantee an item will ever be returned.

Also, as regards how that function works, it really should return a unit from the given group, rather than giving you a random item anywhere on the map.

Finally...
1) If the group already has at least 1 item in it when you call ItemGroupPickRandomItem, there's a chance that no item will be picked (since the chances of getting a single specific number when returning a random number between 1 and 100 will be 1%) and if no item is returned, the recursion won't take place because g.total would already be greater than 0 (due to the fact that the taken group already had items in it)

2) GetWorldBounds leaks... either set it to a global and use the global throughout the code, or use bj_mapInitialPlayableArea

 

[Jesus4Lyf]

A group snippet that doesn't use linked lists?

Why... <_<

 

[GetTriggerUnit-]

How did you created a new local type?

 

[Larcenist]

He didn't? It's a struct (which would've been quite obvious with a single glance at the code).

 

[GetTriggerUnit-]

I looked at it. I just didn't know that you could do use this that way...
I usually only use the struct name with
local <structname> d = <structname>.create()

 

[Romek]

Graveyarded.

And what's with the Nestharus style post?

 

[Sevion]

>Compiling

Yes, I did complile this. Though, the latest JassHelper (J) doesn't like me. It gives me I/O error 105 whenever I try to run it.

I have to use clijasshelper which doesn't show errors. I thought I fixed that total to .total o_o' I saw it and fixed it somewhere.

Bleh, my contacts are giving me trouble too. I can barely read the posts o_o'


Keep it mind, I wrote this system at 12 AM o_o'

I was tired ;p

 

[DrEvil]

So write them at 10am ? ( When your not knackered... )
Makes sense ?

 

[Sevion]

No ;o Cleeezzz and Ren pulled me into a Last Stand game -_-' (We won cuz my haxxorz bounce ;o)

That caused me to burn about an hour and a half >_>

Edit: Whoops. My fail contacts made me miss Igor's post.

Yes, we can make Unit-Type groups. Just would be a struct [extending array/with an integer array member].

Yeh, using the latest clijasshelper is annoying. It's a real bugger finding stuff like:

        call SaveInteger (hasht id2, g, index)

Notice the missing , between hasht and id2. That was getting me for about 15 minutes until I spotted it -_-'

(The only way I can test for errors is to test map and see if it loads o_o'

 

[GetTriggerUnit-]

Why graveyard this?

 

[Sevion]

Read up on the stuff.

I'm fixing it right now

Edit, when I fixed the bug in the Overview pointed out by Flare, I highlighted units and typed units. <-- Failure.

Edit, ;o Now that I think about it, Link Lists aren't all that complicated. And here I thought they were. o_o'

 

[cleeezzz]

its actually useful when i needed something like this half a year ago.

(i created items in a secret region and picked a random one)

 

[Sevion]

Bump