This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.
Quote from: eri0o on Tue 25/04/2023 17:49:29I kinda want to figure out a very simple actual game I can use this to add a bit motivation.
surface.DrawImage(info.X, info.Y, 1097, 10);
surface.DrawImage(0, 0, 1097, 10);
Quote from: eri0o on Sun 23/04/2023 23:13:05Hey, after applying this, would pursuing a refactor to port the script rewrite idea from Nick's branch much harder or the same difficulty?
Quote from: Crimson Wizard on Thu 13/10/2022 22:05:15One major reason this was written in the first place was because AGS compiled script assumes 32-bit pointer size, so it won't work with 64-bit systems. Couple of people have suggested to implement a virtual memory instead, and use virtual 32-bit addresses instead of the real ones, which might fix this issue.
I suppose this is what Nick Sonneveld started to write in one of his experimental branches few years ago.
Quote from: Crimson Wizard on Fri 24/09/2021 17:49:06Personally I would speculate that most games created with AGS so far may fit into 32-bit memory, and those which don't likely are overusing memory due to low optimization.
Quote from: Crimson Wizard on Fri 24/09/2021 17:49:06most of the mem is likely to be taken by resources (sprites, sounds), and these are not exposed into script VM, so not part of this address issue. What is left for VM addresses is: script variables and managed objects. Most managed objects are merely "wrappers" which contain ID of an actual object in the engine. So probably most managed script memory goes to: dynamic containers (arrays, etc), and dynamic sprites.
player.SayBubble(GetTranslation("original text goes here"));
void SayBubbleTra(this Character*, String message, GUI* bubbleGui)
{
this.SayBubble(GetTranslation(message), bubbleGui);
}
player.SayBubbleTra("original text goes here");
Quote from: Snarky on Fri 21/04/2023 17:33:28As for the rest, it depends on which character code is actually stored in the string at string manipulation time. If it is always LF, then things are simple and it is clear what to do.
Quote from: Snarky on Fri 21/04/2023 15:05:23One question: how will manual linebreaks made using "/n" appear in the reversed "RTL" string? As "/n", as "n/", or already converted to a newline code? (Actually, it might be best to optionally support all of these as well as the old ']', using some kind of configuration bit field.)
managed struct ListItem
{
ListItem* prev;
ListItem* next;
String name;
int data;
};
managed struct LinkedList
{
ListItem* first;
ListItem* last;
};
import ListItem* newItem(ListItem* add_after, String name, int data);
import void detachItem(ListItem* item);
import ListItem* findNthItem(ListItem* first, int n);
import void printItems(ListItem* first, ListBox* lb);
import ListItem* addItem(this LinkedList*, String name, int data);
import ListItem* remItem(this LinkedList*, ListItem* item);
import ListItem* remItemN(this LinkedList*, int index);
import void clear(this LinkedList*);
ListItem* newItem(ListItem* add_after, String name, int data)
{
ListItem* item = new ListItem;
item.name = name;
item.data = data;
if (add_after != null)
{
ListItem* next = add_after.next;
add_after.next = item;
item.prev = add_after;
if (next != null)
{
next.prev = item;
item.next = next;
}
}
return item;
}
void detachItem(ListItem* item)
{
if (item.prev != null)
item.prev.next = item.next;
if (item.next != null)
item.next.prev = item.prev;
item.next = null;
item.prev = null;
}
ListItem* findNthItem(ListItem* first, int n)
{
ListItem* item = first;
for (int i = 0; i < n; i++)
{
if (item.next == null)
return null;
item = item.next;
}
return item;
}
void printItems(ListItem* first, ListBox* lb)
{
lb.Clear();
if (first == null)
return;
ListItem* item = first;
do
{
lb.AddItem(String.Format("%s : %d", item.name, item.data));
item = item.next;
}
while (item != null);
}
ListItem* addItem(this LinkedList*, String name, int data)
{
ListItem* item = newItem(this.last, TextBox1.Text, Random(32000));
if (this.first == null)
this.first = item;
this.last = item;
return item;
}
ListItem* remItem(this LinkedList*, ListItem* item)
{
if (item == this.first)
this.first = item.next;
if (item == this.last)
this.last = item.prev;
detachItem(item);
return item;
}
ListItem* remItemN(this LinkedList*, int index)
{
ListItem* item = findNthItem(this.first, ListBox1.SelectedIndex);
if (item == null)
return null;
this.remItem(item);
return item;
}
void clear(this LinkedList*)
{
this.first = null;
this.last = null;
}
Quote from: eri0o on Tue 18/04/2023 22:27:49Not sure if it's because I am doing a lot of python recently, but the first result for garbage collection in Google for me was this: https://devguide.python.org/internals/garbage-collector/
Quote from: Crimson Wizard on Tue 18/04/2023 20:27:50If the script memory would have contained hints on the data types in it, we could know where are "dynamic object handles" among it.