Yes, it till still work, but you really _should_ get used to the new way of using arrays.
I have overcrossed the night and new day...
I think they are from UK so right now over there is 6pm
function foo() constructor {
x = 0;
}
function bar() {
x = 0;
}constructor foo() {
}That is a torture...
I think so，you should consider the inherition..
No. As far as I am aware the project conversion does not carry anything like that over.
Make a post in the beta forums about this and see if something is being done or if there is a manual way to do it (there probably is but I don't know it).
Are old-style 2D arrays automatically converted to new-style 2D arrays (or rather, array of arrays) or is this something that needs to be manually done when importing a pre-2.3 project?
function foo( value ) constructor {
this.value = value;
}Are you implying
self has that same behavior for you? Because adding this:function T1(x) constructor {
self.x = x;
}
function T2(x) constructor {
x = x;
}
show_debug_message("T1: " + string(new T1(123)));
show_debug_message("T2: " + string(new T2(123)));T1: { }
T2: { }
oneStruct = anotherStruct, is that a copy or a reference? I assume there's also no OOP style inheritance, since nothing's been said about it.
I believe it's all pass by value. I don't think much of anything in GMS has been pass by reference. Which makes sense given how everything is structured.
/// @func foo( value )
/// @param value
function foo( _value ) constructor {
value = _value;
}Ok, so to make copies of a struct one has to use
new ...which makes sense. But is a problem if you want to clone its current contents. I wonder if structs get copied when passed to functions(scripts) like arrays do.
Just out of curiosity, for old projects where I use a ton of arrays and will continue to do so, can I just mix both array styles?
I am aware of that, just that for my particular experiment that is not really what I want. I ended up doing something like:
function v1() {}
function v2() {}
function v3() {}
function Enum() constructor {
_values = undefined;
_names = undefined;
_length = undefined;
}
function make_enum() {
var e = new Enum();
e._values = array_create(argument_count);
e._names = array_create(argument_count);
e._length = argument_count;
for (var i = 0; i < argument_count; i++) {
var value = argument[i], name = script_get_name(value);
e._values[i] = value;
e._names[i] = name;
variable_struct_set(e, name, value);
}
return e;
}
show_debug_message(make_enum(v1, v2, v3));function v1() {}
function v2() {}
function v3() {}
function Enum() constructor {
_values = array_create(argument_count);
_names = array_create(argument_count);
_length = argument_count;
for (var i = 0; i < argument_count; i++) {
var value = argument[i], name = script_get_name(value);
_values[i] = value;
_names[i] = name;
variable_struct_set(this, name, value);
}
}
show_debug_message(new Enum(v1, v2, v3));{ _values : [ 100003,100004,100005 ], _names : [ "v1","v2","v3" ], _length : 3, v1 : 100003, v2 : 100004, v3 : 100005 }
s1 = { a: "Lorem", b: "ipsum" };
show_debug_message(s1);
s2 = s1;
s2.a = "Hello";
s2.b = "world";
show_debug_message(s1); // note that I output the original struct{ a : "Lorem", b : "ipsum" }
{ a : "Hello", b : "world" }Foo = function (_content) constructor {
content = _content;
static fluentPrint = function () {
show_debug_message(content);
return this;
}
}
createFoo = function (_content) {
var instance = new Foo(_content);
instance.this = instance;
return instance;
}
createFoo("bar")
.fluentPrint()
.fluentPrint();
createFoo("baz")
.fluentPrint()
.fluentPrint()
.fluentPrint();function Child constructor {
_owner = undefined;
}
function Owner constructor {
static addChild = function(child) {
child._owner = self;
}
}
var _child = new Child();
var _owner = new Owner();
_owner.addChild(_child);self refere to the Owner instance? does it work as thisself use id ...does structures have id? they might!function Number(_n) constructor {
n = _n;
static add = function() { n+= 1; return self; }
}
number = new Number(10);
number.add().add();number = new Number(10);
(number.add()).add();
When did you get yours and what was your ticket number?I got mine. This is the perfect beginning to my weekend.
I did too somehow. I don't really see why they're keeping it so limited when we've been waiting for a year, got pushed a month from what I can tell due to this Covid thing and then if you happened to have been working at the time the announcement was made feel like the train left the station before I could get a chance to buy the ticket when they were made available even though that train left the following day and could pull additional cars very easily. To be honest they need to have a lot more people testing it than just the few that it seemed like it went out to.
Still no working link for the know issues? Have you PMed Nocturne?
They allowed over a hundred people today! If they keep on this rhythm, you'll be in in no time!they are based in the UK... the timezone is the same as mine here it is 10pm... they closed the office 5 hours ago
my ticket is 169190-ish... and I didn't get the email either.. so they are just above 169144 and below 169190
only Monday now... I'm gonna cry thy the corner of my room!
I just wanted to say that they not doing same.
function foo() constructor {a = 1;};
function bar() {b = 2;};
function foobar() {return {c: 3}};
a = new foo();
b = new bar();
c = foobar(); // without "new"
d = {d: 4}; // regular structfoo = function( x, y ) {
return x + y;
}
foo()function foo( x, y ) {
return x + y;
}
foo()
They wish to report on helpdesk forum (link attached in email). This one with ds_maps looks like worth reporting, and I can confirm that it won't work without using some temp var.
I think this behaviour is because constant functions are constant, and variable functions are variable. Functions defined with name will permanently bind that name to this function. When you assign function to a variable, however, you have no guarantee that variable won't change.
foo = function(x, y) {
return x + y;
}
foo = function() {
show_debug_message("whatever");
}
foo();What's fun, if you use JSDOC, then GMS seems to treat it as constant function, and even detects number of arguments, so writing /// @func foo() or /// @func foo(a,b,d,c,whatever) will still show number of arguments that you put in function, not in JSDOC....
