Some JASS Tools

[Nestharus]

Ok... so while I've been doing the Resource manager (probably going to do a perl version for the web and a downloaded exe in c# and when the c# version is done, I'll put it up as an embedded exe on the site ^_^), I've been wanting to do some other tools for like... design.

Creating systems and what not is great, but I always want to make a system that's radically easy to use but radically fast, something like I tried with in Spawn, and I got to thinking that the only way to accomplish this was with an application, like a WYSIWYG editor for a system. You type in your stuff or w/e in the system and it generates the code, you know, like a Spell Editor.

I was looking at j4l's spell struct and I was thinking, this would be amazing as an application and the generated spells would actually be as efficient as possible, and from there people could like submit resource files for these editors, open them up in the editor, and easily edit the spell! : O.


Now the question is, what editors would be needed, or better yet, perhaps one global editor where you input the fields and what not, hmm?

Well, I believe that the basic editor would be something like Spawn was, except that the code it made would actually be as fast as possible and the interface would be 1000x easier, lol. From there, you have other things that build off of it following the concept that Spawn tried to do, so you have spell objects (like jesus4lyf's spell struct), combat objects, etc. All of these objects would in essence be a spawn object. I think spawn objects are as simple and dynamic as you can get : ).

You'd also have other types of objects, like Timer Objects (t32x?).

You'd also have managers (KT2 and some of the stuff I've done?)

The resource manager would also allow you to browse for files that are built from this.


So, what might be an example? Well, think of jesus4lyf's spell struct (it's so well designed and is just a great example for the idea of this application).

You can add various events of types, like onCast (you can have unlimited objects of each type, it'll just merge up all the code) and just type code into these objects. You can also add public method extensions and properties. When people open up your spell object or w/e, they can type their own code into the public methods (if they want to customize it or build off of it) and change around the properties, even add their own new properties to build off of yours. Everything that isn't public is not available. Everything about the object is kept private and secure unless you have access to it (owner, or did owner give you access).

To gain access to a resource, you need to be online for validation from the server : ), even if you've already been granted access (access may have been taken away).


Now, another thought is the generated code. For example, if I really wanted to keep it closed source (optional by author), I'd probably need a special decryption thing for JASS Helper to retrieve the code and put it in prior to code compilation. From there, I'd probably also need to add a thing to obfuscate the code after it's compiled into JASS.


So thoughts on this? WYSIWYG editors for systems, lol, making things uber easy to use and as fast as possible .

 

[Narks]

To gain access to a resource, you need to be online for validation from the server : ), even if you've already been granted access (access may have been taken away).

lolno

Now, another thought is the generated code. For example, if I really wanted to keep it closed source (optional by author), I'd probably need a special decryption thing for JASS Helper to retrieve the code and put it in prior to code compilation. From there, I'd probably also need to add a thing to obfuscate the code after it's compiled into JASS.

wtf, don't let people submit closed source things - it will end up in tears (and people would just open the map with an MPQ editor anyway). If they want to submit closed source they should just gtfo, seriously.


Either then that, it sounds like a good idea.



also wat is resauce managar

 

[Nestharus]

wtf, don't let people submit closed source things - it will end up in tears (and people would just open the map with an MPQ editor anyway). If they want to submit closed source they should just gtfo, seriously.

How can they get the code via an MPQ Editor???


....

It's impossible -.-. You'd have to have all features enabled and use the system entirely for 1. Next, you'd still get converted to JASS code with merged variables, so gl reading that. Finally, obfuscation, so all the functions will be like a, b, A, B, etc as well as the variables. Yeaaa... gl


Resource Manager-
http://www.thehelper.net/forums/showthread.php?t=141024

 

[Narks]

private resources would encourage elitism

and elitism is bad, that stuff completely rapes communities

EDIT: Also there should be an offline mode. Some people (ie. laptops) don't always have access to internets.

 

[Nestharus]

private resources would encourage elitism

and elitism is bad, that stuff completely rapes communities

EDIT: Also there should be an offline mode. Some people (ie. laptops) don't always have access to internets.

Saying if you want to get latest version of a resource or w/e via resource manager. You could always get the current version within your own library of resources o-o.

private resources would encourage elitism

and elitism is bad, that stuff completely rapes communities

It might make people appreciate other people's hard work more : \. I don't know how many people would opt for closed source, but I know with some of my stuff I'd want to ; ). Hell, donations could become appreciated because a lot of works goes into some of these resources o-o.

On the downside people couldn't give feedback on your coding, lol, but oh well. I prefer to hide my code in the background myself and to keep it all closed off ^_^.

 

[Renendaru]

On the downside people couldn't give feedback on your coding, lol, but oh well. I prefer to hide my code in the background myself and to keep it all closed off ^_^.

Just no. This is a HELPING forum, not a BRAGGING forum. If it is here, it needs to be open source.

 

[Nestharus]

Just no. This is a HELPING forum, not a BRAGGING forum. If it is here, it needs to be open source.

I still want to give people that option to keep their resources closed source if they want it like that.

I know I want some of my resources closed source : \, lol.


It wouldn't be about bragging about your closed resources, it'd just be like more professional. For example, if I wanted to release a top notch resource for people to use that was flawless etc and I wanted it closed source, I could ; ).


I might even do a donate option where you can link up your paypal account or something . I'm sure jesus4lyf would own that market, haha.

Maybe put in a system where you use resource points to get resources. Resource points can be earned by submitting resources that get approved (submitting to the community), or by donations them (supporting the community thru $$).

Yea, that sounds like a good idea ^_^.

From here, a % of this money can be funneled to the various modding sites to help keep up their servers. The rest goes to the authors ; ). Also a % goes to the person managing all of this : \.

Yea, seems fair and would be beneficial to everyone ^_^.

 

[Romek]

Any closed source resources would either be far too map specific, or crappily coded.

 

[Nestharus]

Any closed source resources would either be far too map specific, or crappily coded.

unless they're by jesus4lyf, lol : D


I'm sure it'll be fine Romek. I just want to provide people with a security option. People always want a security option and SC2 is going to provide it, so I'm going to try and provide one for wc3 ;o.

 

[Narks]

will break it for sc2

you honestly think Blizzard can do anything right?

 

[Jesus4Lyf]

I'm a little disturbed how many times I've been mentioned in something I'd like to have no part in. :thup:

Look, anything beyond a downloadable script which parses system codes on TH and downloads them to your computer, and checks for updates, is beyond what I'd be a fan of.
Anything with "closed source" WC3 mapping... wtf? :nuts:
:banghead:

Spoiler

It's impossible -.-. You'd have to have all features enabled and use the system entirely for 1. Next, you'd still get converted to JASS code with merged variables, so gl reading that. Finally, obfuscation, so all the functions will be like a, b, A, B, etc as well as the variables. Yeaaa... gl

I once modified an Optimized map. It was successful.

PS. I'm quite sure this is illegal (EULA) and hence would be banned here (making money off this mapping stuff).

 

[Nestharus]

Quote:Originally Posted by Nestharus
It's impossible -.-. You'd have to have all features enabled and use the system entirely for 1. Next, you'd still get converted to JASS code with merged variables, so gl reading that. Finally, obfuscation, so all the functions will be like a, b, A, B, etc as well as the variables. Yeaaa... gl

I once modified an Optimized map. It was successful.

Talking about getting all of the source : \... only the code you'd have enabled would be in the map and translating that code from obfuscated JASS to w/e language it's in to retrieve the source would be near impossible. Modifying it not the same as getting the source out of it ^_^.


Now, for the $$ stuff, I was thinking of that for maintaining everything. For example, hive workshop does donations ; ).

Now the software could legally be sold and what not, but not the resources, so the idea here would be community points or something who knows. The software would be free ;\ (otherwise nobody would use it, rofl)

Look, anything beyond a downloadable script which parses system codes on TH and downloads them to your computer, and checks for updates, is beyond what I'd be a fan of.

This wouldn't be a downloadable script but an exe, lol. It also wouldn't retrieve stuff from TH but it's own repository for various reasons, one of them being that TH's format is wrong for submitted resources on this so it wouldn't work out ; ).


I also still think providing an option for closed source is a good idea and that's a definite feature of all of this stuff.


Hmm... now developing the GUI to create these objects and so on... probably something similar to Visual Studio's GUI stuff ^_^.

 

[Vestras]

> Also a % goes to the person managing all of this : \.

Lol, sorry, but IMO this is greedy and you wouldn't be able to do this. Nobody that makes maps for free would give money to one that has made a tool for money which does the same as what they can just go to a website to do.

I'm also making a massive app, I've also thought about taking money for it (my app actually is being created, not just being an idea, no offense), but I have, each time, figured out that it can't be done, atleast not getting very much money.

 

[Nestharus]

it's not about making a profit... it actually costs money to maintain these servers.....


It's about people putting into it so that it can be around -.-.

% goes to person managing -> money to pay for servers
% goes to the various sites -> money to pay for servers
% goes to authors -> to either say thank you for submitting this resource or so they can put that money back in to further benefit everything else ><.


And the idea of doing points-
you get points whenever you put something into the community (be it money, help, resources, or w/e else)

So really there doesn't even have to be money involved.. it's just if you can be active, that's perfect as it helps out. If you can't, then you can help support via $$ to help pay for all of it -.-.

At the mere mention of money everyone goes OMG IT'S THE END OF THE WORLD!! GET THE LITTLE GUY!!

 | KILL   | KILL                HELP!
\|\      \|\                   O.O
/\       /\                   -/\-


    PLEASE HELP!!               KILL   |           KILL    |
O.O                                   /|/                 /|/
 -/\-                                  /\                  /\

For the sake of the little guy everyone please calm down!

 

[Narks]

ads

done

 

[Nestharus]

Since I have a reputation for never finishing anything, here's the current code of the parser for JASS ^_-.

No, it's not done yet, but it's just about done : ).

#!/usr/local/bin/perl
use Cwd;

#constants
########################################################
use constant SPLIT => '><'; #for splitting up XHTML tags, also used for finding them
use constant KEYWORD_FILE => 'keywords.data'; #this file stores the keywords
use constant COLOR_FILE => 'tags.data'; #this file stores color XHTML tags
use constant CATEGORY_FILE => 'categories.data'; #stores categories
use constant JASS_INI_FILE => 'jass.data'; #the jass ini file.
use constant COMMENTS => '!!'; #signifies a comment area, start or end
use constant NEW_CATEGORY => '^^'; #signifies a new category
use constant XHTML_TAG => '><'; #signifies an XHTML tag
use constant PROCESS_TYPE => 0; #processType category for keywords
use constant TAG_TYPE => 1; #tagType category for keywords
use constant SPLIT_HASH => '^!-!^'; #used for splitting up key value pairs in hash files

#fields
########################################################
my %hCategories; #hashtable categories
my @categories; #stores categories which determines how a keyword is processed
my %keywords; #stores pointers to XHTML tags and categories using keywords as keys
my @revKeywords; #reversed keywords, but only does categories
my @tags; #stores the XHTML tags
my %processing; #stores perl routines for processing keywords based on the process type

#processing
########################################################
my $comment = 0; #determines whether comments are on or off
my @mappedStrings;

#index
sub isInString($) {
        my $charOpen = 0;
        my $lastOpen = @mappedStrings;
        my $index;
        foreach $index (@mappedStrings) {
                if ($charOpen && $index > $_[0] && $lastOpen < $_[0]) {#see if char is open and if the index is in between last and current
                        return 1;
                }#if
                $lastOpen = $index;
                $charOpen = !$charOpen;
        }#foreach
        return 0;
}#isInstring

#line
sub mapStrings($) {
        @mappedStrings = ();
        my $charOpen = 0;
        my $openChar; #the current open char
        my @splitString = split(//, $_[0]);
        my $index = 0;
        foreach (@splitString) {
                if (exists($keywords{$_}) && $keywords{$_}[PROCESS_TYPE] == $hCategory{'STRING'}) {#see if current char is a string process type
                        if (!$charOpen) {#check for open char
                                push @mappedStrings, $index;
                                $charOpen = 1;
                                $openChar = $_;
                        }#if
                        elsif ($openChar eq $_) {#attempt to close char
                                push @mappedStrings, $index;
                                $charOpen = 0;
                        }#elsif
                }#if
                $index++;
        }#foreach
}#mapString

#curLine, processedLine
$processing{'COMMENT'} = sub($$) {
        if ($comment) {
        }
        else {
        }
        #if ($key =~ m/\/\*/ && $processText =~ m/\/\*/) {
#       #        $processText = $tags[$colors{$key}-2].$processText;
#       #}
#       #elsif ($key =~ m/\*\// && $processText =~ m/\*\//) {
#       #        $processText = $processText.$tags[$colors{$key}-1];
#       #}
#       #elsif ($key =~ m/\/{2,}\!{0}/ && $processText =~ m/\/{2,}\!{0}/) {
#       #        $processText = $tags[$colors{$key}-2].$processText.$tags[$colors{$key}-1];
#       #}
        return $_[1];
};
$processing{'CONTINUE'} = sub($$) {
        if (!$comment) {
                foreach (@{$revKeywords[$hCategories{'CONTINUE'}]}) {
                        if (index($_[0], $_) == length($_[0])-3) {#see if a continue char is last on the line
                                $_[1] =~ s/(\Q$_\E)/$tags[$keywords{$_}[${\(TAG_TYPE)}]]$1$tags[$keywords{$_}[${\(TAG_TYPE)}]+1]/;
                                return $_[1];
                        }
                }
        }
        return $_[1];
};
$processing{'PREPROCESSOR'} = sub($$) {
};
$processing{'STRING'} = sub($$) {
};
$processing{'SEPERATOR'} = sub($$) {
};
$processing{'OPERATOR'} = sub($$) {
};
$processing{'FORMAT'} = sub($$) {
};
$processing{'KEYWORD'} = sub($$) {
};
$processing{'FUNCTION'} = sub($$) {
};

#Retrieve Data
########################################################
#Retrieve data sets up colors and keywords if the data files are not present.
#It can also force load if the first argument passed into the script does not have a file extension.
########################################################
#check to see if initialization hasn't been done yet or if there is a forced initialization
my $forceIni = 0;
if (defined(@ARGV) && $ARGV[0] !~ /\./) {#check for forced ini and remove it from args
        my $forceIni = 1;
        shift @ARGV;
}#if
if (!-e CATEGORY_FILE || $forceIni) {#initialization
        #open the jass ini file and process it
        open JASS_DATA_FILE, "<", JASS_INI_FILE or die $!;
                my $isCommented = 0; #determines whether a section is commented or not
                while (<JASS_DATA_FILE>) {
                        if (/^\Q${\(COMMENTS)}\E/) {
                                $isCommented = !$isCommented;
                        }#if
                        elsif (!$isCommented) {#only do stuff if the lines aren't commented out
                                if (/^\Q${\(NEW_CATEGORY)}/) {#new category
                                        chomp($_ = substr($_, 2)); #cut off the double tag
                                        $hCategories{$_} = @categories;
                                        push @categories, $_;
                                }#if
                                elsif (/\Q${\(XHTML_TAG)}\E/) {#XHTML
                                        chomp(@_ = split(/\Q${\(XHTML_TAG)}\E/));
                                        $_[0].=">"; #first tag
                                        $_[1] = "<".$_[1]; #second tag
                                        push @tags, @_;
                                }#elsif
                                else {#keyword
                                        chomp $_;
                                        $keywords{$_}[PROCESS_TYPE] = @categories-1; #latest category
                                        $keywords{$_}[TAG_TYPE] = @tags-2;
                                        push @{$revKeywords[@categories-1]}, $_;
                                }#else
                        }#elsif
                }#while
        close JASS_DATA_FILE;
        #store all the data into files for faster processing
        my $key;
        open KEYWORDS, ">", KEYWORD_FILE or die $!;
                foreach $key  (keys %keywords) {
                        print KEYWORDS $key.SPLIT_HASH.'0'.SPLIT_HASH.$keywords{$key}[0]."\n";
                        print KEYWORDS $key.SPLIT_HASH.'1'.SPLIT_HASH.$keywords{$key}[1]."\n";
                }#foreach
        close KEYWORDS;
        open CATEGORIES, ">", CATEGORY_FILE or die $!;
                foreach (@categories) {
                        print CATEGORIES $_."\n";
                }
        close CATEGORIES;
        open COLORS, ">", COLOR_FILE or die $!;
                foreach (@tags) {
                        print COLORS $_."\n";
                }
        close COLORS;
}#if
else {#initialization has already been done so retrieve data from files
        my $curCategory;
        open KEYWORDS, "<", KEYWORD_FILE or die $!;
                my @keywordValues;
                while(<KEYWORDS>) {
                        #0- keyword
                        #1- type (category, tag)
                        #2- type id (category id, tag id)
                        chomp (@keywordValues = split(/\Q${\(SPLIT_HASH)}\E/));
                        $keywords{$keywordValues[0]}[$keywordValues[1]] = $keywordValues[2];
                        if ($keywordValues[1] eq PROCESS_TYPE) {
                                push @{$revKeywords[$keywordValues[2]]}, $keywordValues[0];
                        }#if
                }#while
        close KEYWORDS;
        open CATEGORIES, "<", CATEGORY_FILE or die $!;
                chomp (@categories = <CATEGORIES>);
                for ($curCategory = @categories-1; $curCategory != -1; $curCategory--) {
                        $hCategory{$categories[$curCategory]} = $curCategory;
                }
        close CATEGORIES;
        open COLORS, "<", COLOR_FILE or die $!;
                chomp (@tags = <COLORS>);
        close COLORS;
}#else
########################################################


#Process JASS Files
########################################################
#Go through each JASS file in argument and process them into XHTML files
########################################################
my $fileName; #stores xhtml file name
my $curLine; #the current line, not processed
my $curKey; #the current keyword
my $processedLine; #stores a processed line, meaning XHTML
foreach (@ARGV) {
        open JASS_FILE, "<", $_ or die $!;
                s/\..+/\.html/; #replace file extension with html
                open XHTML_FILE, ">", $_ or die $!;
                        while ($curLine = <JASS_FILE>) {
                                $processedLine = $curLine;
                                mapStrings($curLine);
                                foreach $curKey (keys %processing) {
                                        $processedLine = $processing{$curKey}($curLine, $processedLine);
                                }
                                print $processedLine;
                        }#while
                close XHTML_FILE;
        close JASS_FILE;
}#foreach

#sub ProcessFiles() {
#        my $fileName;
#        my $processText;
#        my $jassOn = 0;
#        my $indent = 0;
#        my $comment = 0;
#        my $key;
#        foreach $filename (@files)
#        {
#                open JASS_FILE, "<$filename" or die $!;
#                $filename =~ m/(.+)\.j/g;
#                open JASS_FILE_PROCESSED, ">$1.html" or die $!;
#                print JASS_FILE_PROCESSED '
#                <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
#
#                <html xmlns="http://www.w3.org/1999/xhtml">
#
#                <head>';
#                print JASS_FILE_PROCESSED "       <title>$1</title>";
#                print JASS_FILE_PROCESSED '</head>
#
#                <body><p>'."\n\t";
#                while (defined($processText = <JASS_FILE>)) {
#                        if ($filename =~ /(\.j)/ || $jassOn)
#                        {
#                                foreach $key (keys %colors) {
#                                        if (!$comment && $key eq '/*') {
#                                                $processText =~ s/(\/\*)/$tags[$colors{$key}-2]$1/;
#                                                $comment = 1;
#                                        }
#                                        if ($key =~ m/\/{2,}(?!!)/ && !$comment && $processText =~ m/\/{2,}(?!!)/) {
#                                                $processText = $tags[$colors{$key}-2].$processText.$tags[$colors{$key}-1];
#                                        }
#                                        if (!$comment) {
#                                                $processText =~ s/\b(\Q$key\E)\b/$tags[$colors{$key}-2]$1$tags[$colors{$key}-1]/;
#                                        }
#                                        if ($comment && $key =~ m/\*\//) {
#                                                $processText =~ s/(\*\/)/$1$tags[$colors{$key}-1]/;
#                                                $comment = 0;
#                                        }
#                                        if ($key =~ m/[\Q+\E]/) {
#                                                $processText =~ s/(\Q$key\E)/$tags[$colors{$key}-2]$1$tags[$colors{$key}-1]/;
#                                        }
#                                        #$processText =~ s/\b($key)\b/$tags[$colors{$key}-2]$1$tags[$colors{$key}-1]/;
#                                        #if (($key =~ m/[\Q\/*![](){}:^%\E]{1}/)) {# || $key =~ m/[\Q=+-&|\E]{2}/) && $processText =~ m/(?!>)[\Q=+-\/*&|![](){}:^%\E](?!<)/) {
#                                                #$processText =~ s/(?!>)
#                                                #$processText =~ s/(?!>)([\Q\/*![](){}:^%\E]){1}(?!<)/$tags[$colors{$key}-2]$1$tags[$colors{$key}-1]/;
#                                        #}
#                                        #$processText
#                                        #if ($key =~ m/\/\*/ && $processText =~ m/\/\*/) {
#                                        #        $processText = $tags[$colors{$key}-2].$processText;
#                                        #}
#                                        #elsif ($key =~ m/\*\// && $processText =~ m/\*\//) {
#                                        #        $processText = $processText.$tags[$colors{$key}-1];
#                                        #}
#                                        #elsif ($key =~ m/\/{2,}\!{0}/ && $processText =~ m/\/{2,}\!{0}/) {
#                                        #        $processText = $tags[$colors{$key}-2].$processText.$tags[$colors{$key}-1];
#                                        #}
#                                        #if ($processText =~ $key) {
#                                                #print $key;
#                                                #
#                                        #}
#                                        ##elsif ($key =~ m/\/\*/g) {
#                                        #        $processText = $tags[$colors{$key}-2].$processText;
#                                        #}
#                                        #elsif ($key eq "//") {
#                                        #        $processText = $tags[$colors{$key}-2].$processText.$tags[$colors{$key}-1];
#                                        #}
#                                        #elsif ($key =~ m/[0-9?[+-=]]([+-\/*=&|!][0-9])/g) {
#                                        #        print $1;
#                                        #        #@splitting = split(m/$1/g, $processText);
#                                        #        $processText = $splitting[0].$tags[$colors{$key}-2].$1.$tags[$colors{$key}-1].$splitting[1];
#                                        #}
#                                        #
#                                }
#                        }
#                        if ($processText =~ m/\[jass\]/g) {
#                                $jassOn = 1;
#                        }
#                        elsif ($processText =~ m/\[\/jass\]/g) {
#                                $jassOn = 0;
#                        }
#                        #$processText =~ s/\s{2}/&nbsp&nbsp&nbsp&nbsp;/g;
#                        #$processText =~ s/\t/&nbsp&nbsp&nbsp&nbsp;/g;
#                        print $processText;
#                        print JASS_FILE_PROCESSED "$processText<br />";
#                }
#                print JASS_FILE_PROCESSED '</p></body>
#
#                </html>';
#                close JASS_FILE_PROCESSED;
#                close JASS_FILE;
#        }
#}

 

[Lyerae]

Sorry for asking a question with a (probably) obvious answer, but what language is that written in?

 

[Nestharus]

http://www.perl.org/ : D


And as can be seen, all I have to do now is the actual processing of the lines. All the data setup, initialization, etc is finally done ^_^. The ini file is done too using my own extremely simple setup-

!!
This ini file does syntax highlighting and what have you.

Syntax Coloring goes in the order specified by the file. You can use whatever keywords and names you want ^_^

Default Order-
COMMENT
CONTINUE
PREPROCESSOR
STRING
SEPERATOR
OPERATOR
FORMAT
KEYWORD
FUNCTION
!!

^^COMMENT
<span style="color: green"></span>
/*
*/
//
##
^^CONTINUE
<span style="color: teal"></span>
\

etc

ini file is 3248 lines long. As can be seen, if you want to add in special new processes, you have to actually code it in the background. New types of tags also have to be coded in the background ><. Plain old wrapped around tags that don't require anything special can just be inserted into ini and it'll work (given that you force start initialization).


At the moment it runs through cmd, but I'll be modifying it for use on the site with documentation editor. It's the first start to everything else, the first step and first requirement : ). The site will probably be written in mostly PERL and the application will be written in c#.

I plan on the application (c# stuff) being done around June.


Oh yes... a question

Would you like me to automatically format text and just require every line to end in a semi-colon? In this way you could do something like this if you wanted-

hello (
    arg1,
    arg2,
    arg3,
    arg4,
    arg5,
    arg6,
    arg7
);

or w/e rather than using a million \. Btw, the idea behind \ is it escapes the \n, lol. Cheesy, I know ><.

 

[azareus]

Well then you have to use a million commas?

 

[Nestharus]

You have to use a million commas either way...