Deltarune (Chapter 3) script viewer

← back to main script listing

gml_Object_obj_event_manager_Create_0

(view raw script w/o annotations or w/e)

pad_index = -1;
trophies_enabled = false;
trophies_queue = [];
event_cooldown = 0;
_debug = -4;

init = function()
{
    init_trophies();
};

init_trophies = function()
{
    event_show_debug_message("*** init_trophies");
    if (!variable_global_exists("trophy_data"))
        global.trophy_data = [];
    if (!variable_global_exists("trophies"))
        global.trophies = [];
    for (var i = 0; i < 30; i++)
        global.trophy_data[array_length(global.trophy_data)] = get_trophy_by_id(i);
    if (os_type == os_ps4 || os_type == os_ps5)
    {
        psn_load_modules();
        psn_init_np_libs("", "", "");
    }
    if (scr_debugscr_debugfunction scr_debug()
{
    if (global.debug == 1)
        return 1;
}() && !global.is_console)
        scr_debug_load_trophiesscr_debug_load_trophiesfunction scr_debug_load_trophies()
{
}();
};

load_trophies = function(arg0)
{
    if (pad_index == arg0)
        exit;
    pad_index = arg0;
    show_debug_message("-- pad_index: " + string(pad_index));
    if (os_type == os_ps4 || os_type == os_ps5)
    {
        psn_init_trophy(pad_index);
        psn_get_trophy_unlock_state(pad_index);
    }
};

enable_trophies = function()
{
    trophies_enabled = true;
};

disable_trophies = function()
{
    trophies_enabled = false;
};

get_debug_obj = function()
{
    if (!instance_exists(_debug))
        _debug = instance_create(0, 0, obj_event_manager_debug);
    return _debug;
};

is_trophy_unlocked = function(arg0)
{
    var is_unlocked = false;
    for (var i = 0; i < array_length(global.trophies); i++)
    {
        if (global.trophies[i] != arg0)
            continue;
        event_show_debug_message("*** trophy ~1 is already unlocked", arg0);
        is_unlocked = true;
        break;
    }
    if (!is_unlocked)
    {
        for (var i = 0; i < array_length(trophies_queue); i++)
        {
            if (trophies_queue[i] != arg0)
                continue;
            event_show_debug_message("*** trophy ~1 is already queued", arg0);
            is_unlocked = true;
            break;
        }
    }
    return is_unlocked;
};

event_show_debug_message = function(arg0, arg1 = -1, arg2 = true)
{
    var _debug_message = arg0;
    var _debugger = get_debug_obj();
    with (_debugger)
        trophy_show_debug_message(_debug_message, arg1, arg2);
};

get_trophy_by_id = function(arg0)
{
    var _trophy = -4;
    for (var i = 0; i < array_length(global.trophy_data); i++)
    {
        if (global.trophy_data[i].index != arg0)
            continue;
        _trophy = global.trophy_data[i];
        break;
    }
    if (_trophy == -4)
        _trophy = new trophy(arg0);
    return _trophy;
};

can_unlock_trophy = function(arg0)
{
    var _trophy = get_trophy_by_id(arg0);
    var _threshold = _trophy.threshold;
    var _flags = _trophy.flags;
    var can_unlock = false;
    if (array_length(_flags) > 0)
    {
        for (var i = 0; i < array_length(_flags); i++)
        {
            var __flag = _flags[i];
            if (global.flag[__flag] >= _threshold)
            {
                can_unlock = true;
                break;
            }
        }
    }
    else
    {
        can_unlock = true;
    }
    return can_unlock;
};

unlock_trophy = function(arg0)
{
    global.trophies[array_length(global.trophies)] = arg0;
    if (os_type == os_ps4 || os_type == os_ps5)
        psn_unlock_trophy(pad_index, arg0);
    event_show_debug_message("*** trophy unlocked: ~1", arg0, false);
    if (scr_debugscr_debugfunction scr_debug()
{
    if (global.debug == 1)
        return 1;
}() && !global.is_console)
        scr_debug_save_trophiesscr_debug_save_trophiesfunction scr_debug_save_trophies()
{
}();
};

queue_trophy = function(arg0)
{
    array_push(trophies_queue, arg0);
    event_show_debug_message("*** queued trophy: ~1", arg0, false);
};

reset_trophy = function(arg0)
{
    var _trophy = get_trophy_by_id(arg0);
    var _flags = _trophy.flags;
    if (array_length(_flags) > 0)
    {
        for (var i = 0; i < array_length(_flags); i++)
        {
            var __flag = _flags[i];
            global.flag[__flag] = 0;
            event_show_debug_message("*** reset trophy flag: " + string(__flag));
        }
    }
    var _adjusted_list = [];
    for (var i = 0; i < array_length(global.trophies); i++)
    {
        if (global.trophies[i] == arg0)
            continue;
        _adjusted_list[array_length(_adjusted_list)] = global.trophies[i];
    }
    global.trophies = _adjusted_list;
    var _adjusted_queue = [];
    for (var i = 0; i < array_length(trophies_queue); i++)
    {
        if (trophies_queue[i] == arg0)
            continue;
        _adjusted_queue[array_length(_adjusted_queue)] = trophies_queue[i];
    }
    trophies_queue = _adjusted_queue;
    event_show_debug_message("*** reset trophy: ~1", arg0, false);
    if (scr_debugscr_debugfunction scr_debug()
{
    if (global.debug == 1)
        return 1;
}() && !global.is_console)
        scr_debug_save_trophiesscr_debug_save_trophiesfunction scr_debug_save_trophies()
{
}();
};

reset_all_trophies = function()
{
    for (var i = 0; i < array_length(global.trophies); i++)
    {
        var _trophy = get_trophy_by_id(global.trophies[i]);
        var _flags = _trophy.flags;
        if (array_length(_flags) > 0)
        {
            for (var j = 0; j < array_length(_flags); j++)
            {
                var __flag = _flags[j];
                global.flag[__flag] = 0;
                event_show_debug_message("*** reset trophy flag: " + string(__flag));
            }
        }
    }
    global.trophies = [];
    trophies_queue = [];
    event_show_debug_message("*** reset all trophies");
    if (scr_debugscr_debugfunction scr_debug()
{
    if (global.debug == 1)
        return 1;
}() && !global.is_console)
        scr_debug_save_trophiesscr_debug_save_trophiesfunction scr_debug_save_trophies()
{
}();
};

trigger_event = function(arg0, arg1, arg2 = "n/a")
{
    switch (arg0)
    {
        case UnknownEnum.Value_0:
            if (trophies_enabled)
                validate_trophy(arg1, arg2);
            break;
        case UnknownEnum.Value_1:
            if (event_cooldown > 0)
                break;
            event_cooldown = 10;
            trigger_event(UnknownEnum.Value_0, UnknownEnum.Value_7, UnknownEnum.Value_936);
            break;
        case UnknownEnum.Value_2:
            post_activity(arg1);
            break;
        default:
            break;
    }
};

validate_trophy = function(arg0, arg1)
{
    var subtype = arg1;
    event_show_debug_message("*** validating trophy: ~1 | " + string(arg1), arg0);
    if (arg0 == UnknownEnum.Value_13)
    {
        if (!is_trophy_unlocked(UnknownEnum.Value_7))
            queue_trophy(UnknownEnum.Value_7);
    }
    if (is_trophy_unlocked(arg0))
        exit;
    if (subtype != "n/a")
    {
        global.flag[subtype] += 1;
        event_show_debug_message("*** increase trophy event flag: " + string(subtype) + " | " + string(global.flag[subtype]));
    }
    if (!can_unlock_trophy(arg0))
        exit;
    queue_trophy(arg0);
    if (scr_debugscr_debugfunction scr_debug()
{
    if (global.debug == 1)
        return 1;
}() && !global.is_console)
    {
        if ((array_length(global.trophies) + array_length(trophies_queue)) >= 29)
            queue_trophy(UnknownEnum.Value_0);
    }
};

function trophy(arg0) constructor
{
    index = arg0;
    threshold = 0;
    flags = [];
    switch (arg0)
    {
        case UnknownEnum.Value_5:
            threshold = 4;
            flags = [UnknownEnum.Value_932, UnknownEnum.Value_933];
            break;
        case UnknownEnum.Value_6:
            threshold = 8;
            flags = [UnknownEnum.Value_934, UnknownEnum.Value_935];
            break;
        case UnknownEnum.Value_7:
            threshold = 14;
            flags = [UnknownEnum.Value_936];
            break;
        case UnknownEnum.Value_8:
            threshold = 22;
            flags = [UnknownEnum.Value_937, UnknownEnum.Value_938];
            break;
        case UnknownEnum.Value_23:
            threshold = 110;
            flags = [UnknownEnum.Value_939];
            break;
        default:
            break;
    }
}

get_consumer_trophy = function()
{
    switch (global.chapter)
    {
        case 1:
            return UnknownEnum.Value_9;
            break;
        case 2:
            return UnknownEnum.Value_10;
            break;
        case 3:
            return UnknownEnum.Value_11;
            break;
        case 4:
            return UnknownEnum.Value_12;
            break;
    }
};

has_pending_trophies = function()
{
    return array_length(trophies_queue) > 0;
};

resolve_trophies = function()
{
    if (!trophies_enabled)
        exit;
    for (var i = 0; i < array_length(trophies_queue); i++)
    {
        var _index = trophies_queue[i];
        unlock_trophy(_index);
    }
    trophies_queue = [];
};

post_activity = function(arg0)
{
    if (os_type != os_ps5)
        exit;
    var activity_id = "activity_ch" + string(global.chapter) + "_end";
    var activity_type = "";
    switch (arg0)
    {
        case UnknownEnum.Value_0:
            activity_type = "activityStart";
            break;
        case UnknownEnum.Value_1:
            activity_type = "activityEnd";
            break;
        default:
            break;
    }
    var uds_map = ds_map_create();
    ds_map_add(uds_map, "activityId", activity_id);
    if (arg0 == UnknownEnum.Value_1)
        ds_map_add(uds_map, "outcome", "completed");
    psn_post_uds_event(pad_index, activity_type, uds_map);
    ds_map_destroy(uds_map);
};

enum UnknownEnum
{
    Value_0,
    Value_1,
    Value_2,
    Value_5 = 5,
    Value_6,
    Value_7,
    Value_8,
    Value_9,
    Value_10,
    Value_11,
    Value_12,
    Value_13,
    Value_23 = 23,
    Value_932 = 932,
    Value_933,
    Value_934,
    Value_935,
    Value_936,
    Value_937,
    Value_938,
    Value_939
}

1	`pad_index = -1;`
2	`trophies_enabled = false;`
3	`trophies_queue = [];`
4	`event_cooldown = 0;`
5	`_debug = -4;`
6
7	`init = function()`
8	`{`
9	`init_trophies();`
10	`};`
11
12	`init_trophies = function()`
13	`{`
14	`event_show_debug_message("*** init_trophies");`
15	`if (!variable_global_exists("trophy_data"))`
16	`global.trophy_data = [];`
17	`if (!variable_global_exists("trophies"))`
18	`global.trophies = [];`
19	`for (var i = 0; i < 30; i++)`
20	`global.trophy_data[array_length(global.trophy_data)] = get_trophy_by_id(i);`
21	`if (os_type == os_ps4 \|\| os_type == os_ps5)`
22	`{`
23	`psn_load_modules();`
24	`psn_init_np_libs("", "", "");`
25	`}`
26	`if ( scr_debugscr_debug function scr_debug() { if (global.debug == 1) return 1; } () && !global.is_console)`
27	`scr_debug_load_trophiesscr_debug_load_trophies function scr_debug_load_trophies() { } ();`
28	`};`
29
30	`load_trophies = function(arg0)`
31	`{`
32	`if (pad_index == arg0)`
33	`exit;`
34	`pad_index = arg0;`
35	`show_debug_message("-- pad_index: " + string(pad_index));`
36	`if (os_type == os_ps4 \|\| os_type == os_ps5)`
37	`{`
38	`psn_init_trophy(pad_index);`
39	`psn_get_trophy_unlock_state(pad_index);`
40	`}`
41	`};`
42
43	`enable_trophies = function()`
44	`{`
45	`trophies_enabled = true;`
46	`};`
47
48	`disable_trophies = function()`
49	`{`
50	`trophies_enabled = false;`
51	`};`
52
53	`get_debug_obj = function()`
54	`{`
55	`if (!instance_exists(_debug))`
56	`_debug = instance_create(0, 0, obj_event_manager_debug);`
57	`return _debug;`
58	`};`
59
60	`is_trophy_unlocked = function(arg0)`
61	`{`
62	`var is_unlocked = false;`
63	`for (var i = 0; i < array_length(global.trophies); i++)`
64	`{`
65	`if (global.trophies[i] != arg0)`
66	`continue;`
67	`event_show_debug_message("*** trophy ~1 is already unlocked", arg0);`
68	`is_unlocked = true;`
69	`break;`
70	`}`
71	`if (!is_unlocked)`
72	`{`
73	`for (var i = 0; i < array_length(trophies_queue); i++)`
74	`{`
75	`if (trophies_queue[i] != arg0)`
76	`continue;`
77	`event_show_debug_message("*** trophy ~1 is already queued", arg0);`
78	`is_unlocked = true;`
79	`break;`
80	`}`
81	`}`
82	`return is_unlocked;`
83	`};`
84
85	`event_show_debug_message = function(arg0, arg1 = -1, arg2 = true)`
86	`{`
87	`var _debug_message = arg0;`
88	`var _debugger = get_debug_obj();`
89	`with (_debugger)`
90	`trophy_show_debug_message(_debug_message, arg1, arg2);`
91	`};`
92
93	`get_trophy_by_id = function(arg0)`
94	`{`
95	`var _trophy = -4;`
96	`for (var i = 0; i < array_length(global.trophy_data); i++)`
97	`{`
98	`if (global.trophy_data[i].index != arg0)`
99	`continue;`
100	`_trophy = global.trophy_data[i];`
101	`break;`
102	`}`
103	`if (_trophy == -4)`
104	`_trophy = new trophy(arg0);`
105	`return _trophy;`
106	`};`
107
108	`can_unlock_trophy = function(arg0)`
109	`{`
110	`var _trophy = get_trophy_by_id(arg0);`
111	`var _threshold = _trophy.threshold;`
112	`var _flags = _trophy.flags;`
113	`var can_unlock = false;`
114	`if (array_length(_flags) > 0)`
115	`{`
116	`for (var i = 0; i < array_length(_flags); i++)`
117	`{`
118	`var __flag = _flags[i];`
119	`if (global.flag[__flag] >= _threshold)`
120	`{`
121	`can_unlock = true;`
122	`break;`
123	`}`
124	`}`
125	`}`
126	`else`
127	`{`
128	`can_unlock = true;`
129	`}`
130	`return can_unlock;`
131	`};`
132
133	`unlock_trophy = function(arg0)`
134	`{`
135	`global.trophies[array_length(global.trophies)] = arg0;`
136	`if (os_type == os_ps4 \|\| os_type == os_ps5)`
137	`psn_unlock_trophy(pad_index, arg0);`
138	`event_show_debug_message("*** trophy unlocked: ~1", arg0, false);`
139	`if ( scr_debugscr_debug function scr_debug() { if (global.debug == 1) return 1; } () && !global.is_console)`
140	`scr_debug_save_trophiesscr_debug_save_trophies function scr_debug_save_trophies() { } ();`
141	`};`
142
143	`queue_trophy = function(arg0)`
144	`{`
145	`array_push(trophies_queue, arg0);`
146	`event_show_debug_message("*** queued trophy: ~1", arg0, false);`
147	`};`
148
149	`reset_trophy = function(arg0)`
150	`{`
151	`var _trophy = get_trophy_by_id(arg0);`
152	`var _flags = _trophy.flags;`
153	`if (array_length(_flags) > 0)`
154	`{`
155	`for (var i = 0; i < array_length(_flags); i++)`
156	`{`
157	`var __flag = _flags[i];`
158	`global.flag[__flag] = 0;`
159	`event_show_debug_message("*** reset trophy flag: " + string(__flag));`
160	`}`
161	`}`
162	`var _adjusted_list = [];`
163	`for (var i = 0; i < array_length(global.trophies); i++)`
164	`{`
165	`if (global.trophies[i] == arg0)`
166	`continue;`
167	`_adjusted_list[array_length(_adjusted_list)] = global.trophies[i];`
168	`}`
169	`global.trophies = _adjusted_list;`
170	`var _adjusted_queue = [];`
171	`for (var i = 0; i < array_length(trophies_queue); i++)`
172	`{`
173	`if (trophies_queue[i] == arg0)`
174	`continue;`
175	`_adjusted_queue[array_length(_adjusted_queue)] = trophies_queue[i];`
176	`}`
177	`trophies_queue = _adjusted_queue;`
178	`event_show_debug_message("*** reset trophy: ~1", arg0, false);`
179	`if ( scr_debugscr_debug function scr_debug() { if (global.debug == 1) return 1; } () && !global.is_console)`
180	`scr_debug_save_trophiesscr_debug_save_trophies function scr_debug_save_trophies() { } ();`
181	`};`
182
183	`reset_all_trophies = function()`
184	`{`
185	`for (var i = 0; i < array_length(global.trophies); i++)`
186	`{`
187	`var _trophy = get_trophy_by_id(global.trophies[i]);`
188	`var _flags = _trophy.flags;`
189	`if (array_length(_flags) > 0)`
190	`{`
191	`for (var j = 0; j < array_length(_flags); j++)`
192	`{`
193	`var __flag = _flags[j];`
194	`global.flag[__flag] = 0;`
195	`event_show_debug_message("*** reset trophy flag: " + string(__flag));`
196	`}`
197	`}`
198	`}`
199	`global.trophies = [];`
200	`trophies_queue = [];`
201	`event_show_debug_message("*** reset all trophies");`
202	`if ( scr_debugscr_debug function scr_debug() { if (global.debug == 1) return 1; } () && !global.is_console)`
203	`scr_debug_save_trophiesscr_debug_save_trophies function scr_debug_save_trophies() { } ();`
204	`};`
205
206	`trigger_event = function(arg0, arg1, arg2 = "n/a")`
207	`{`
208	`switch (arg0)`
209	`{`
210	`case UnknownEnum.Value_0:`
211	`if (trophies_enabled)`
212	`validate_trophy(arg1, arg2);`
213	`break;`
214	`case UnknownEnum.Value_1:`
215	`if (event_cooldown > 0)`
216	`break;`
217	`event_cooldown = 10;`
218	`trigger_event(UnknownEnum.Value_0, UnknownEnum.Value_7, UnknownEnum.Value_936);`
219	`break;`
220	`case UnknownEnum.Value_2:`
221	`post_activity(arg1);`
222	`break;`
223	`default:`
224	`break;`
225	`}`
226	`};`
227
228	`validate_trophy = function(arg0, arg1)`
229	`{`
230	`var subtype = arg1;`
231	`event_show_debug_message("*** validating trophy: ~1 \| " + string(arg1), arg0);`
232	`if (arg0 == UnknownEnum.Value_13)`
233	`{`
234	`if (!is_trophy_unlocked(UnknownEnum.Value_7))`
235	`queue_trophy(UnknownEnum.Value_7);`
236	`}`
237	`if (is_trophy_unlocked(arg0))`
238	`exit;`
239	`if (subtype != "n/a")`
240	`{`
241	`global.flag[subtype] += 1;`
242	`event_show_debug_message("*** increase trophy event flag: " + string(subtype) + " \| " + string(global.flag[subtype]));`
243	`}`
244	`if (!can_unlock_trophy(arg0))`
245	`exit;`
246	`queue_trophy(arg0);`
247	`if ( scr_debugscr_debug function scr_debug() { if (global.debug == 1) return 1; } () && !global.is_console)`
248	`{`
249	`if ((array_length(global.trophies) + array_length(trophies_queue)) >= 29)`
250	`queue_trophy(UnknownEnum.Value_0);`
251	`}`
252	`};`
253
254	`function trophy(arg0) constructor`
255	`{`
256	`index = arg0;`
257	`threshold = 0;`
258	`flags = [];`
259	`switch (arg0)`
260	`{`
261	`case UnknownEnum.Value_5:`
262	`threshold = 4;`
263	`flags = [UnknownEnum.Value_932, UnknownEnum.Value_933];`
264	`break;`
265	`case UnknownEnum.Value_6:`
266	`threshold = 8;`
267	`flags = [UnknownEnum.Value_934, UnknownEnum.Value_935];`
268	`break;`
269	`case UnknownEnum.Value_7:`
270	`threshold = 14;`
271	`flags = [UnknownEnum.Value_936];`
272	`break;`
273	`case UnknownEnum.Value_8:`
274	`threshold = 22;`
275	`flags = [UnknownEnum.Value_937, UnknownEnum.Value_938];`
276	`break;`
277	`case UnknownEnum.Value_23:`
278	`threshold = 110;`
279	`flags = [UnknownEnum.Value_939];`
280	`break;`
281	`default:`
282	`break;`
283	`}`
284	`}`
285
286	`get_consumer_trophy = function()`
287	`{`
288	`switch (global.chapter)`
289	`{`
290	`case 1:`
291	`return UnknownEnum.Value_9;`
292	`break;`
293	`case 2:`
294	`return UnknownEnum.Value_10;`
295	`break;`
296	`case 3:`
297	`return UnknownEnum.Value_11;`
298	`break;`
299	`case 4:`
300	`return UnknownEnum.Value_12;`
301	`break;`
302	`}`
303	`};`
304
305	`has_pending_trophies = function()`
306	`{`
307	`return array_length(trophies_queue) > 0;`
308	`};`
309
310	`resolve_trophies = function()`
311	`{`
312	`if (!trophies_enabled)`
313	`exit;`
314	`for (var i = 0; i < array_length(trophies_queue); i++)`
315	`{`
316	`var _index = trophies_queue[i];`
317	`unlock_trophy(_index);`
318	`}`
319	`trophies_queue = [];`
320	`};`
321
322	`post_activity = function(arg0)`
323	`{`
324	`if (os_type != os_ps5)`
325	`exit;`
326	`var activity_id = "activity_ch" + string(global.chapter) + "_end";`
327	`var activity_type = "";`
328	`switch (arg0)`
329	`{`
330	`case UnknownEnum.Value_0:`
331	`activity_type = "activityStart";`
332	`break;`
333	`case UnknownEnum.Value_1:`
334	`activity_type = "activityEnd";`
335	`break;`
336	`default:`
337	`break;`
338	`}`
339	`var uds_map = ds_map_create();`
340	`ds_map_add(uds_map, "activityId", activity_id);`
341	`if (arg0 == UnknownEnum.Value_1)`
342	`ds_map_add(uds_map, "outcome", "completed");`
343	`psn_post_uds_event(pad_index, activity_type, uds_map);`
344	`ds_map_destroy(uds_map);`
345	`};`
346
347	`enum UnknownEnum`
348	`{`
349	`Value_0,`
350	`Value_1,`
351	`Value_2,`
352	`Value_5 = 5,`
353	`Value_6,`
354	`Value_7,`
355	`Value_8,`
356	`Value_9,`
357	`Value_10,`
358	`Value_11,`
359	`Value_12,`
360	`Value_13,`
361	`Value_23 = 23,`
362	`Value_932 = 932,`
363	`Value_933,`
364	`Value_934,`
365	`Value_935,`
366	`Value_936,`
367	`Value_937,`
368	`Value_938,`
369	`Value_939`
370	`}`