Help!

[Icy]

May i know what is GUI,MUI,JASS and vJass and their main different.

If i wish to learn Jass/vJass? how do i start? what program do i need?

 

[Bogrim]

GUI means Graphical User Interface. It refers to the trigger editor's interface for creating triggers. It is not so much of a language as it is a template form of JASS, as every event, condition and action you can choose are just templates for much larger codes.

MUI means Multi-Unit Instanceable and it is not a language but a design form for a trigger. It describes whether or not the trigger can handle more than one instance of the trigger running, such as several units casting a triggered spell. Creating MUI triggers require knowledge and understanding of how variable data works and often uses methods such as local variables, indexers and Hashtables to save the instance data.

JASS is Blizzard's coding language. When you convert a trigger to Custom Text, the code language you see is JASS. Unlike GUI, JASS is not limited to just templates, which makes the trigger form far less limited and allows you to change pretty much everything.

vJASS is an improved form of JASS which can only be used through a custom editor called "NewGen" (New Generation World Editor). The difference between vJASS and JASS is that vJASS is better to work with, for example by adding colors to your codes so you have an easier time reading your written text. I'm sure there are more differences but since I don't actually use either I can't give you an in-depth explanation.

 

[Aedes]

I'm used to JASS. .. Haven't explored vJASS yet.

 

[Ashlebede]

for example by adding colors to your codes so you have an easier time reading your written text

That doesn't have anything to do with vJass. Syntax highlighters existed a long time before Vexorian even considered creating vJass. And JassHelper (vJass compiler) doesn't necessarily have to be used with NewGen. Therefore, vJass doesn't highlight anything, it's just a different language.

Adding to Bogrim's post :

vJass is Jass to which an extensions was added. What it does is it simplifies the syntax ; vJass code can allow things that aren't allowed in plain Jass and then convert them to Jass by changing the map's script upon compilation.

An example is global variables. There can be only one place with global variables in Jass, and it is at the beginning of the map script, which means it is (virtually) uneditable, since the map script is re-written upon saving the map in the World Editor.

What JassHelper does is it takes every place where you wrote global variables and puts them at the top of the map script every time the map is saved. What was unallowed syntax before is legal with vJass. Of course, there's not only global variables. vJass also allows scopes, structs, libraries...

Spoiler

For instance, this is a comparison of vJass compiled and uncompiled code :

//vJass
scope foobar initializer init
        function interface FUNCTION_INTERFACE takes unit u, trigger t returns integer
        
    private function foo takes unit u, trigger t returns integer
        return GetHandleId(u)
    endfunction
    
    private function bar takes unit u, trigger t returns integer
        return GetHandleId(t)
    endfunction

    private function init takes nothing returns nothing
        local FUNCTION_INTERFACE foo_interface = foo
        local FUNCTION_INTERFACE bar_interface = bar
    endfunction
endscope

Will become :

globals
//JASSHelper struct globals:
trigger array st___prototype3
integer f__result_integer
unit f__arg_unit1
trigger f__arg_trigger1

endglobals

function sc___prototype3_execute takes integer i,unit a1,trigger a2 returns nothing
    set f__arg_unit1=a1
    set f__arg_trigger1=a2

    call TriggerExecute(st___prototype3<i>)
endfunction
function sc___prototype3_evaluate takes integer i,unit a1,trigger a2 returns integer
    set f__arg_unit1=a1
    set f__arg_trigger1=a2

    call TriggerEvaluate(st___prototype3<i>)
 return f__result_integer
endfunction

// scope foobar begins
//processed:         function interface FUNCTION_INTERFACE takes unit u, trigger t returns integer
        
    function foobar___foo takes unit u,trigger t returns integer
        return GetHandleId(u)
    endfunction
    
    function foobar___bar takes unit u,trigger t returns integer
        return GetHandleId(t)
    endfunction

    function foobar___init takes nothing returns nothing
        local integer foo_interface= (1)
        local integer bar_interface= (2)
    endfunction
// scope foobar ends

//Struct method generated initializers/callers:
function sa___prototype3_foobar___foo takes nothing returns boolean
    set f__result_integer=foobar___foo(f__arg_unit1,f__arg_trigger1)
    return true
endfunction
function sa___prototype3_foobar___bar takes nothing returns boolean
    set f__result_integer=foobar___bar(f__arg_unit1,f__arg_trigger1)
    return true
endfunction

function jasshelper__initstructs22017840 takes nothing returns nothing
    set st___prototype3[1]=CreateTrigger()
    call TriggerAddAction(st___prototype3[1],function sa___prototype3_foobar___foo)
    call TriggerAddCondition(st___prototype3[1],Condition(function sa___prototype3_foobar___foo))
    set st___prototype3[2]=CreateTrigger()
    call TriggerAddAction(st___prototype3[2],function sa___prototype3_foobar___bar)
    call TriggerAddCondition(st___prototype3[2],Condition(function sa___prototype3_foobar___bar))


endfunction</i></i>

This code can be rather scary ; that's why we say vJass is really an extension to Jass. These things could've been done almost the same way (a more efficient way, in this case) using Jass, but vJass is just easier to read. There are many things, still, which are simply easier to read and not less efficient.

Usually, people learn Jass before they learn vJass. Although vJass is more simple than "plain" Jass, it still uses the same general concepts which are easier to learn without the somewhat-complex concepts there are in vJass. Jass is just easier to learn, since there are many complex features in vJass.

My personal favourite is plain Jass, but vJass does increase script efficiency. However, I do prefer plain Jass (in a rather masochistic way). I find vJass generates unneeded trash, although it is only a personal opinion.