Wanderer - Submission

[Chaosy]

Hidden

//! zinc
    library Wanderer {
 
        hashtable hash = InitHashtable();
 
        function Move(unit u) {
            integer id = GetHandleId(u);
            integer dist = GetRandomInt(500,1500);
            real angle = GetRandomReal(0, 360);
            real x = GetUnitX(u) + dist * Cos(angle * bj_DEGTORAD);
            real y = GetUnitY(u) + dist * Sin(angle * bj_DEGTORAD);
       
            SaveInteger(hash, id, 0, GetTerrainType(x, y));
       
            SaveReal(hash, id, 1, x);
            SaveReal(hash, id, 2, y);
       
            IssuePointOrder(u, "move", x, y);
            SetTerrainType(x, y, 'Nsnw', -1, 1, 0);
        }
   
        function GetDistance(real cx, real cy, real dx, real dy) -> real {
            real x = dx - cx;
            real y = dy - cy;
            return SquareRoot(x * x + y * y);
        }
   
        function GroupActions() {
            unit u = GetEnumUnit();
            integer id = GetHandleId(u);
            real x = LoadReal(hash, id, 1);
            real y = LoadReal(hash, id, 2);
            if(GetDistance(GetUnitX(u), GetUnitY(u), x, y) < 50) {
                SetTerrainType(x, y, LoadInteger(hash, id, 0), -1, 1, 0);
                //chosing to not clear the hashtable since the values gets replaced anyway
                Move(u);
            }
            u = null;
        }
   
        function onLoop() {
            group g = GetUnitsInRectMatching(bj_mapInitialPlayableArea, null);
            ForGroup(g, function GroupActions);
            DestroyGroup(g);
            g = null;
        }
 
        function onInit() {
            timer t = CreateTimer();
            TimerStart(t, 0.03, true, function onLoop);
            Move(CreateUnit(Player(0), 'hgry', 0, 0, 0));
            t = null;
        }
    }
//! endzinc

 

[IcemanBo]

This method using a group is a work around for the desired task; no group is needed at all, and hashtable can be used directly instead. Your way does also pick all other units, which is unwanted behaviour.

You don't have to, but I believe the mission can be solved with 2 functions, one init function that sets everything up, and one callback function.

 

[Chaosy]

The group is not needed, it is additional functionality.
My system would work for multiple units due the unit group.

 

[IcemanBo]

It would work wrongly with multiple units on map, that's why I don't want group enums; so it's a bigger way of doing, and finaly results in possibly also unwanted actions. In this mission hash should be used over group. : )

 

[Chaosy]

Dunno it worked fine for me what I used multiple units.

I could remove the group and make it only work for one unit if that's a requirement /shrug

 

[IcemanBo]

It's intended not to work or affect other units on map; the mission mentions only a gryphon. Don't interpret things too much. : )

 

[Chaosy]

//! zinc
    library Wanderer {
   
        hashtable hash = InitHashtable();
        unit toMove;
   
        function Move(unit u) {
            integer id = GetHandleId(u);
            integer dist = GetRandomInt(500,1500);
            real angle = GetRandomReal(0, 360);
            real x = GetUnitX(u) + dist * Cos(angle * bj_DEGTORAD);
            real y = GetUnitY(u) + dist * Sin(angle * bj_DEGTORAD);
           
            SaveInteger(hash, id, 0, GetTerrainType(x, y));
           
            SaveReal(hash, id, 1, x);
            SaveReal(hash, id, 2, y);
           
            IssuePointOrder(u, "move", x, y);
            SetTerrainType(x, y, 'Nsnw', -1, 1, 0);
        }
       
        function GetDistance(real cx, real cy, real dx, real dy) -> real {
            real x = dx - cx;
            real y = dy - cy;
            return SquareRoot(x * x + y * y);
        }
       
        function Actions() {
            integer id = GetHandleId(toMove);
            real x = LoadReal(hash, id, 1);
            real y = LoadReal(hash, id, 2);
            if(GetDistance(GetUnitX(toMove), GetUnitY(toMove), x, y) < 50) {
                SetTerrainType(x, y, LoadInteger(hash, id, 0), -1, 1, 0);
                //chosing to not clear the hashtable since the values gets replaced anyway
                Move(toMove);
            }
        }
   
        function onInit() {
            timer t = CreateTimer();
            TimerStart(t, 0.03, true, function Actions);
            toMove = CreateUnit(Player(0), 'hgry', 0, 0, 0);
            Move(toMove);
        }
    }
//! endzinc

 

[IcemanBo]

It doesn't match this part:

Global variabels other than the hashtable are not allowed.

^It's very intended, because hashtable power should be introduced instead. I believe the crash course does help, in case you're confused what I mean.

Logicaly there's nothing wrong with your distance calculation, but I want also point out that there exists a native function to check if a unit is in range of certain x/y coordinates.

Please attach demo, too, when you make updates, so it can be tested.

 

[Chaosy]

That is not a global.
By default it is a private member.

*being 'clever'*

edit:
Hm, actually the Zinc manual still calls it a global for some reason which is retarded because a private "global" is not global

Will have to update it because of that I suppose :-/

edit2:

//! zinc
    library Wanderer {
   
        hashtable hash = InitHashtable();
   
        function Move(unit u) {
            integer id = GetHandleId(u);
            integer dist = GetRandomInt(500,1500);
            real angle = GetRandomReal(0, 360);
            real x = GetUnitX(u) + dist * Cos(angle * bj_DEGTORAD);
            real y = GetUnitY(u) + dist * Sin(angle * bj_DEGTORAD);
           
            SaveInteger(hash, id, 0, GetTerrainType(x, y));
           
            SaveReal(hash, id, 1, x);
            SaveReal(hash, id, 2, y);
           
            IssuePointOrder(u, "move", x, y);
            SetTerrainType(x, y, 'Nsnw', -1, 1, 0);
        }
       
        function GetDistance(real cx, real cy, real dx, real dy) -> real {
            real x = dx - cx;
            real y = dy - cy;
            return SquareRoot(x * x + y * y);
        }
       
        function Actions() {
            unit u = LoadUnitHandle(hash, 0, 0);
            integer id = GetHandleId(u);
            real x = LoadReal(hash, id, 1);
            real y = LoadReal(hash, id, 2);
            if(GetDistance(GetUnitX(u), GetUnitY(u), x, y) < 50) {
                SetTerrainType(x, y, LoadInteger(hash, id, 0), -1, 1, 0);
                //chosing to not clear the hashtable since the values gets replaced anyway
                Move(u);
            }
            u = null;
        }
   
        function onInit() {
            timer t = CreateTimer();
            unit u = CreateUnit(Player(0), 'hgry', 0, 0, 0);
            TimerStart(t, 0.03, true, function Actions);
            SaveUnitHandle(hash, 0, 0, u);
            Move(u);
            u = null;
        }
    }
//! endzinc

 

[IcemanBo]

Public global is a global, private global is a global, too.
A global variable is a variable that is not limited to one function. : )

 

[Chaosy]

Well I changed the code anyway.
I really dislike using a hashtable that way, but what can I do lol.

Check last post

 

[IcemanBo]

This is not a good way of doing, because the sense of hashtables becomes useless and the used tequnique becomes not generaly applyable, as you use 2 constant keys, "0" and "0". I recommend to read the crash course, specified the: Variables Array, HandleId, Hashtable 1 & 2, Hashtable vs. Array, and Timers.

 

[Chaosy]

I can use multiple ways to save the unit into an hashtable.
1. Unit groups
2. raw values
3. timer as parent
4. trigger as parent
5. function pointers

Every single way follows the rules given damn it :<

//! zinc
    library Wanderer {
   
        hashtable hash = InitHashtable();
   
        function Move(unit u) {
            integer id = GetHandleId(u);
            integer dist = GetRandomInt(500,1500);
            real angle = GetRandomReal(0, 360);
            real x = GetUnitX(u) + dist * Cos(angle * bj_DEGTORAD);
            real y = GetUnitY(u) + dist * Sin(angle * bj_DEGTORAD);
           
            SaveInteger(hash, id, 0, GetTerrainType(x, y));
           
            SaveReal(hash, id, 1, x);
            SaveReal(hash, id, 2, y);
           
            IssuePointOrder(u, "move", x, y);
            SetTerrainType(x, y, 'Nsnw', -1, 1, 0);
        }
       
        function GetDistance(real cx, real cy, real dx, real dy) -> real {
            real x = dx - cx;
            real y = dy - cy;
            return SquareRoot(x * x + y * y);
        }
       
        function Actions() {
            unit u = LoadUnitHandle(hash, GetHandleId(GetExpiredTimer()), 0);
            integer id = GetHandleId(u);
            real x = LoadReal(hash, id, 1);
            real y = LoadReal(hash, id, 2);
            if(GetDistance(GetUnitX(u), GetUnitY(u), x, y) < 50) {
                SetTerrainType(x, y, LoadInteger(hash, id, 0), -1, 1, 0);
                //chosing to not clear the hashtable since the values gets replaced anyway
                Move(u);
            }
            u = null;
        }
   
        function onInit() {
            timer t = CreateTimer();
            unit u = CreateUnit(Player(0), 'hgry', 0, 0, 0);
            TimerStart(t, 0.03, true, function Actions);
            SaveUnitHandle(hash, GetHandleId(t), 0, u);
            Move(u);
            u = null;
        }
    }
//! endzinc

 

[IcemanBo]

It seems correct, but the logics is a bit mixed unnecessarily into multiple functions, which makes it less intuitive.

The sense of a function argument is to give explicit values to a function, which you must have.
The sense of a hashtable entry is that you have one entry key as implicit value, for example the timer handle-id in our situation, and we use this entry to get our concrete values, like the binded unit.
So, when we already use the hashtable powers, then it becomes unnecessary to require explicit arguments for our function call.

I would ask you to match this goal and to get rid off the extra "Move(unit u)" funtion, and rely on the implicit callback function which does all logics for the binded unit and also all for terrain change.

there exists a native function to check if a unit is in range of certain x/y coordinates.

Have you read this?

 

[Chaosy]

Doesn't that use locations?

 

[IcemanBo]

No.

 

[Chaosy]

function DistanceBetweenPoints takes location locA, location locB returns real
    local real dx = GetLocationX(locB) - GetLocationX(locA)
    local real dy = GetLocationY(locB) - GetLocationY(locA)
    return SquareRoot(dx * dx + dy * dy)
endfunction

Is the only one I know of.

 

[IcemanBo]

Anyways, it's minor point.

The other one is not soooo important, too, functional side, but it's more proper strucuture I believe, and so I would love to have it applied, still, not to get used to 'bad' habit.

 

[IcemanBo]

Hm due to this conversation Missions - Wanderer - Submission,
I maybe think it's acceptable, too, even I would prefer my suggestion. But you can keep it in mind for further missions probably.

Good job.