Queations on library/scope and locals.

[Zalinian]

I'm trying to use jass to make some trigger based spells. I need to use local variables so that they can be multi-instanced. However, a local can only be used in a single function, and my spells span over several functions. Is there a way to make variables local to a set of functions? Is this how library/scopes work? I'm using custom text on the trigger, so I have the addtrigger, and triggerconditions functions and such.
If someone could give a small explanation of how this all fits in and possibly a small or semi-complex example (I learn best from dissecting others' code) I would greatly appreciate it.

 

[Lyerae]

Libraries work by sending all of the contents of it to the map header when saving.
So something like:

library myLibrary
     globals
          //globals
     endglobals
     function DoStuff takes nothing returns nothing
          // do stuff
     endfunction
     // more functions
endlibrary

That'll all be in the map header when saved. It helps make it more organized.
Scopes kinda do the same thing, but a function can only be used in the scope it was declared in. So:

scope myScope
     function myFunct takes nothing returns nothing
          // do stuff
     endfunction
     function mySecondFunct takes nothing returns nothing
          call myFunct() // works, because myFunct is in the same scope
     endfunction
endscope
function myThirdFunction takes nothing returns nothing
     call myFunct() // does not work, since "myThirdFunction" is not in the same scope as "myFunct"
endfunction

As for "locals in other triggers", I think you'll want a struct. I can't really tell you too much about a struct, becuase I'm still trying to learn about them myself.

 

[Zalinian]

I mainly just need to know how to make variables able to be referred to in multiple functions, but local in a way to allow multi-instancing.

Edit: I read up a bit on structs, and that may be where I need to head, but I'm not sure.

My custom abilities are very complex and use several different variables of data and multiple functions. I just need to make it multi-instance for when multiple people play the same type of hero.

 

[Lyerae]

I can't really tell you much about structs. I don't know them very well... I can't find any really good documentation on them (other than the JassHelper manual).

But as far as I know, you have to tell the function that it uses the struct, or else it can't access its data, and multiple functions can use a struct, and that's what makes it so good. But then again, that's all I know.

Multi-instance should work with locals though, according to what I know. Have you tested it with locals?
If itllwork with locals, there is no need to complicate things with structs.

 

[Flare]

Scopes kinda do the same thing, but a function can only be used in the scope it was declared in.

Noooooo. Private syntax prevents code from being accessed from outside its enclosing structure (be it a struct, scope, or library). The example you have shown works.

However, if you had prefixed function myFunc takes nothing returns nothing with private, then you are unable to call the function from outside the scope


As regards structs, a simple analogy would be that they are like boxes. Sure, you could handle X different objects individually but, if you need to carry them around (i.e. transferring the objects, or your data, between functions), a box does make it much simpler since you are capable of carrying all your objects, at once, without any fuss.

But, that's being very simple about it. A struct itself is an enclosing structure like a scope or library which is capable of containing dynamic variable members (each struct instance will get an instance of each dynamic member) and static variable members (which, in a nutshell, are non-arrayed global variables).

Structs can also contain methods which are the same as functions, other than the manner in which they are called - there's dynamic methods which (naturally) take a struct instance as an argument, and static methods which don't naturally take a struct instance as an argument.

Now, some code

struct Test //declaring our struct, and naming the enclosure
  real x //dynamic variable member
  static integer InstanceCount = 0//static variable member
  
  method UpdateX takes real newVal returns nothing //dynamic method
    set this.x = newVal //'this' is the name of the struct instance parameter that dynamic methods take
  endmethod

  static method DisplayTotalInstances takes nothing returns nothing
    call BJDebugMsg ("Total instance number: " + I2S (Test.InstanceCount))
  endmethod
endstruct

function TestFunc takes nothing returns nothing
  local Test data = Test.create ()
//a struct instance variable is declared like any other data type
//the .create () method is another example of a static method
//all structs possess this method, and it can be overridden by the end-user by declaring your own static create method

  call data.UpdateX (5.)
//dynamic methods are called by prefixing the method name with the struct instance's variable name, and a period

  call BJDebugMsg ("x is " + R2S (data.x))
//dynamic variable members are referenced in a similar way

  set Test.InstanceCount = Test.InstanceCount + 1
//static variable members are referenced by prefixing the variable name with the struct's name
//i.e. the name given to the whole struct enclosure, not just the instance and a period

  call Test.DisplayTotalInstances ()
//static methods would be called in a similar way to dynamic methods,
//but you prefix the method name with the struct enclosure's name, like a static variable
endfunction

Hopefully that will be of help to you (be sure to ask if anything is unclear, I may not have elaborated on everything )

 

[Zalinian]

So, I've read and heard about scopes, libraries, and structs. Can anyone give some details on the advantages/disadvantages on the mentioned? The ability I'm working on has some variables for data that are local to each instance triggered, but must be accessible by all of the functions used to make the ability(ie: I need something that's half way between global and local).

Edit: Don't get me wrong, the info both of you have posted was helpful and I'm sure whatever knowledge isn't relevant to what I'm trying to do will be useful to me for future coding.

Now that I'm home, I'll try some tests to see if I can accomplish this task.


Edit: After reworking some of my code into a struct setup, I conducted several tests and the results were perfect. Theres still more to do but your suggestion(both of you) on using structs has worked like a charm so far. Tomorrow I'll work on the rest.
Thank you very much for the input. +rep.