SC2Mapster

Quote from Kestudy: Go

However have you the documention in an other support than there : http://www.sc2mapster.com/assets/galaxy-editor-beier Because it's annoying to move the screen on right and left to read the full sentences.

it depends on your resolution, font size and browser overall.

If you'r using Chrome i recommend Style Bot extension. With it you can display any site any way you want.

Thx, that was the police size, 10 is needed to avoid this problem, and then nothing forbids you to "zoom", usually it's CTRL + "+"

I'm reading it right now.

EDIT : But including this documentation inside the .zip wouldn't hurt though.

Quote from Kueken531: Go

Also, how do we invoke a delegate asynchronously?

void foo(){}
delegate void Bar();
Bar f=delegate<Bar>(foo);
Initializer{
    f.Invoke(); //synchronous invoke
    f.InvokeAsync(); //error
    InvokeAsync<f>(); //error
}

Well, right now, you don't. The .Invoke() is also different from the InvokeSync, since InvokeSync calls the method in a new trigger (which resets limitations on the amount of stuff you can do).

What you can do is this

void foo(){}
delegate void Bar();
Bar f=delegate<Bar>(foo);
Initializer{
    InvokeAsync<InvokeDelegate>(f);
}
void InvokeDelegate(Bar b)
{
    b.Invoke();
}

I might make this conversion implicit later, but right now, that would be how to do it.

Unhandled exception when doing right click -> insert constructor in a Dialog script.

How do we use custom imported pictures in the Dialog Designer?

Its hardly possible to make fullscreen dialogs with the dialog designer; you cannot see any UI borders or select multiple resolutions at all. Zoom would be nice, as well.

€ okay, so zoom is already there. However, for a fullscreen dialog (up to 2133x1200 UI units) you only see about 1/4 of it, the rest is cut off.

€€ thats, if you mark a dialog as Fullscreen, apparently, it just gets resized to something like 500;500

Bug with dialog items for the dialog designer: When trying to change min/max values for certain dialog items, you are only allowed to write fixed numbers in a,b format, instead of a.b. This , will be added to the output script, causing a syntax error.

Quote from Kueken531: Go

How do we use custom imported pictures in the Dialog Designer?

They should already be there, if you selected your map as the project map. If they aren't - could you restart the program and try again? Also, what format are they in?

/*
//*/
int foo;

Highlights the last line as comment, but it is included in the output script.

Suggestion: Add a "Save As" functionality, so we can quickly save a project under a new name (for backups etc). Currently, we need to copy the files manually.

I might have mentioned it already, but I would really like to have copy%paste support for the dialog designer. Either for just copy&pasting fields (you can copy most fields, but paste doesn't work that good. Try to paste a string in an image field), probably by just selecting the field instead of the actual text, similar to how it is possible in the Galaxy Editor for Data fields, and/or for entire dialogs or dialog items.

Calling return in an initializer does not only seem to end this initializer, but to end the entire initialization process.

@Kueken531: Go

Are you sure? I would like to see some code that has this behavior, since I can't seem to replicate it.

@SBeier: Go

You are right, it was an issue with my code. Sorry :)

I sent you some error reports, where the program threw errors at me for every letter I typed. I cannot seem to reproduce it, but it seemed to be related to the suggestion list.

Bug: Backup folders are not removed in a relocated project with a component list as input map.

I would like support for template panels in the Dialog Designer, as well as changing rotation.

Using enums as array indices is still bugged:

text[1] enumToTextArray;

Initializer {
	enumToTextArray[(int) Enum.ENUMVALUE] = "ENUMVALUE Description";
	
	FooBar* f = new FooBar();
	TriggerDebugOutput(1, f->asText(), true);
}

enum Enum {
	ENUMVALUE
}

class FooBar {
	Enum e = Enum.ENUMVALUE;
	
	text asText() {return enumToTextArray[(int) e];}
}

Results in

    string f;
    enumToTextArray[0] = StringToText("ENUMVALUE Description");
    f = CreateNewObject();
    DataTableSetByte(true, f + ".e", 0);
    TriggerDebugOutput(1, enumToTextArray[DataTableGetInt(true, f + ".e")], true);

Save as byte <-> load as int

Some interesting tidbits from the alpha 1.5 patch:

Quote:

- Added support for passing structure, array, and function references as function parameters

So there are going to be function references. I Guess this replaces the delegates. I would also be interested to know if the structs are passed by value or by reference when used as parameters (maybe pointers from the beta make a return?). They could make array-based classes/structs more efficient.

The results of my reference tests.

int  aFuncInterface(int a);
int  aFunc(int a)   { return a; }
int  bFunc(int a)   { return a*2; }
bool cFunc(int a)   { return true; }
int  dFunc(fixed a) { return FixedToInt(a*3); }
    
void RefTest_Func ()
{
    funcref<aFuncInterface> someFunction = aFunc;
    
    someFunction = bFunc;
  //someFunction = cFunc; type error
  //someFunction = dFunc; type error
    
    someFunction(1);
}
    
typedef funcref<aFuncInterface> int_return_intRef;
    
void RefTest_TypeDefFunc ()
{
    int_return_intRef someFunction = bFunc;
    
    someFunction = aFunc;
    
    someFunction(1);
}
    
void RefTest_FuncArray ()
{
    int_return_intRef[2] someFunction;
    
    someFunction[0] = aFunc;
    someFunction[1] = bFunc;
    
    someFunction[0](1);
    someFunction[1](1);
}
    
int_return_intRef RefTest_FuncReturn ()
{
    return bFunc;
}
    
struct aStruct { int a; string b; };
aStruct aGlobalStruct;
struct bStruct { int a; string b; };
bStruct bGlobalStruct;
    
void RefTest_Struct ()
{
    aStruct aLocalStruct;
    structref<aStruct> someStruct = aLocalStruct;
    
    someStruct = aGlobalStruct;
  //someStruct = bGlobalStruct; bulk copy error
}
    
typedef structref<aStruct> aStructRef;
    
void RefTest_TypeDefStruct ()
{
    aStruct aLocalStruct;
    aStructRef someStruct = aLocalStruct;
    
    someStruct = aGlobalStruct;
}
    
void RefTest_StructArray ()
{
    aStruct aLocalStruct;
    aStructRef[2] someStruct;
    
    someStruct[0] = aLocalStruct;
    someStruct[1] = aGlobalStruct;
}
    
struct funcStruct { int_return_intRef method; };
typedef structref<funcStruct> funcStructRef;
    
void RefTest_StructMethod ()
{
    funcStruct aLocalStruct;
    funcStructRef someStruct;
    
    someStruct.method = bFunc;
    
    someStruct.method(1);
}
    
void RefTest_Parameters (structref<funcStruct> a, funcref<aFuncInterface> b)
{
    funcStructRef someStruct = a;
    
    someStruct.method = b;
    
    someStruct.method(1);
}
    
void RefTest_ParametersWithTypedef (funcStructRef a, int_return_intRef b)
{
    RefTest_Parameters(a,b);
}

Cool, Thanks. The function references really look like a 1:1 replacement for delegates (they even have a similar syntax..). Btw is there some kind of null check for function references?

The struct references look kind of meh. The <> syntax is pretty verbose and typedef'ing every struct seems like double the work. I think I like the galaxy++ classes and pointers more.

Hmm. can't find much info in this.. Any eta on these features?

Does structref<int> work? How about structref<int[2]>? Or myStructVar = myStructRefVar?

I assume the last one will result in bulk copy error since you still can't assign one struct to another.

Null reference comparison requires a comparison to a reference var of the same type; null will throw a type error.

bool TestFuncInterface ();
typedef funcref<TestFuncInterface> TestFunc;
    
bool TestRefIsNull (TestFunc func)
{
    TestFunc nullFunc;
    return (func==nullFunc);
}

Yeah, Beier, your examples are invalid syntax.

Also, important to note, is that while function references can be used with complete abandon in global and local scopes, structref can only exist in a function's scope; struct references can be parameters or local variables, but can't be returned, can't be in structs or global vars, so the possibility of genuine constructors are completely out the window.

EDIT: One more caveat; functions used to define the funcref interface must return a non-void type.