Developer of Deus Ex Randomizer, StarCraft 2 Randomizer, RollerCoaster Tycoon Randomizer, Build Engine Randomizer, and Groovie 2 in ScummVM
For these discussions I think it would be good to link relevant communities.
I don’t think there’s a community just for Monkey Island, but there is !adventuregames@lemm.ee
I played the first Monkey Island as a kid with my family and still love these games. Great humor, puzzles, and music. #1 is probably still my favorite, all of them are great except maybe #4 I still need to play (now that it works in ScummVM it’s a lot better with modern computers). #2 is probably the hardest game in the series. Tales of Monkey Island is maybe the easiest but still good. Return to Monkey Island was also very good.
here’s a good video essay https://www.youtube.com/watch?v=rxOKEsBx4NU Ross’s Game Dungeon: Deus Ex
and https://www.youtube.com/watch?v=bgJazjz9ZsA Deus Ex: Human Revolution is FINE, And Here’s Why
I would suggest against GMDX for a first time playthrough, it changes A LOT. From the aesthetics, to the gameplay, to the sounds, the mood, the feel of the game, and the viable approaches in each level, there’s so much that’s changed it just isn’t the same game anymore.
You’re much better off with the Vanilla Fixer tool, Transcended, or Zero Rando (I’m the dev). You could also use Revision and toggle every setting to vanilla, but make sure you also disable the HDTP models, and disable Shifter and Biomod too, and definitely set the maps to vanilla.
Did you try these searches while logged in or anonymously? Lemmy (and probably other platforms) don’t allow searches for remote objects unless you’re logged in, this prevents abuse of server resources. The fact that you’re getting replies and you can see them and reply to them means it’s probably all working fine.
in v0.19.0 Lemmy will automatically delete entries over 7 days old
https://github.com/LemmyNet/lemmy/issues/4113
https://github.com/LemmyNet/lemmy/commit/cb01427dcff14b3d88e30220695fc97978786a9a
currently it waits 3 months before deleting
in v0.19.0 you could try disabling pictrs caching https://github.com/LemmyNet/lemmy/commit/1d23df37d86cc5cb6d7d9efaaf4360ecc9a9796f
cache_external_link_previews: false
I don’t think that will clear the existing cache though
Texture healing works by finding each pair of adjacent characters where one wants more space, and one has too much. Narrow characters are swapped for ones that cede some of their whitespace, and wider characters are swapped for ones that extend to the very edge of their box. This swapping is powered by an OpenType feature called “contextual alternates,” which is widely supported by both operating systems and browser engines.
Contextual alternates are normally used for certain scripts, like Arabic, where the shape of each glyph depends on the surrounding glyphs. And they are also used for cursive handwriting fonts where the stroke of the “pen” might have different connection points across letters. Texture healing is a novel application of this technology to code.
basically fonts were already capable of using alternate versions of characters based on their nearby characters, so they used that for these fonts to allow for seemingly-dynamic sizing/spacing
another funny optimization I made was we were setting up a big Perl project for Docker. The automated tests were very slow because each test was doing includes which was searching many include paths and if you’re using Docker on Windows or Mac then I/O stuff can be slow. So we made the docker init script create a single master lib folder and have it make symlinks to the actual files, perl then only had the default include path and this master folder, gave us like 2x or 3x speed boost on running the test suite.
ok maybe not my biggest or cleanest optimization, but an interesting one
I made the WCS Predictor for StarCraft 2 eSports, which would simulate the whole year of tournaments to figure out the chances for each player qualifying for the world championship (the top 16 players by WCS Points), and it would also show the events that would help/hurt the players. It was a big monte carlo simulation that would run millions of iterations. (My memory is fuzzy here because this was 2013 to 2014)
Originally I did a data-based approach where each Tournament object had a vector of Round objects (like round of 32, or semifinals, etc) which had a vector of Match objects (like Soulkey vs Innovation, or a 4 player group). The Round class had a property for best_of (best of 3, best of 5, etc). This was really inflexible cause I couldn’t properly simulate complex tournament formats that didn’t fit my data, and it required a lot of if statements that could cause branch prediction misses.
A tournament definition looked something like this:
Round ro32("ro32");
ro32.best_of=3;
ro32.points_for_3rd=150+25;
ro32.points_for_4th=100+25;
Match ro32GroupA;
ro32.matches.push_back(ro32GroupA);
ro32.matches.push_back(ro32GroupB);
ro32.matches.push_back(ro32GroupC);
ro32.matches.push_back(ro32GroupD);
ro32.matches.push_back(ro32GroupE);
ro32.matches.push_back(ro32GroupF);
ro32.matches.push_back(ro32GroupG);
ro32.matches.push_back(ro32GroupH);
GSL.rounds.push_back( ro32 );
When I rewrote it for the following year, I ditched the data-driven approach to try to get more efficiency and flexibility, but I definitely didn’t want virtual functions either, so I decided to use templates instead and a custom class for each tournament. Now creating a tournament looked like this:
template
class Round : public RoundBase
{
public:
MatchType matches[num_matches];
// ... more stuff ...
};
class CodeSBase : public TournamentBase
{
public:
Round<32, SwissGroup, 8, RandomAdvancement<16, 16>, true > ro32;
Round<16, SwissGroup, 4, A1vsB2<8, 8>, true > ro16;
Round<8, SingleMatch, 4, StraightAdvancement<4, 4>, true > quarterfinals;
Round<4, SingleMatch, 2, StraightAdvancement<2, 2>, true > semifinals;
Round<2, SingleMatch, 1, StraightAdvancement<1, 1>, true > finals;
void init(vector &prev_matches, vector &upcoming_matches)
{
quarterfinals.best_of = 5;
semifinals.best_of = 7;
finals.best_of = 7;
ro32.points_for_placing[3] = 100;
ro32.points_for_placing[2] = 150;
ro16.points_for_placing[3] = 300;
ro16.points_for_placing[2] = 400;
quarterfinals.points_for_placing[1] = 600;
semifinals.points_for_placing[1] = 900;
finals.points_for_placing[1] = 1250;
finals.points_for_placing[0] = 2000;
finals.match_placing_to_tournament_placing[0] = 1;
}
void predict(Simulation &sim, array &top8, array &bottom24, array &finalists, Rand64 &rng)
{
RandomAdvancement<16, 16> Ro32toRo16;
A1vsB2<8, 8> Ro16toRo8;
StraightAdvancement<4, 4> Ro8toRo4;
StraightAdvancement<2, 2> Ro4toRo2;
StraightAdvancement<1, 1> finalsadv;
ro32.predict(sim, t_id, Ro32toRo16, rng);
ro16.AcceptAdvancements(Ro32toRo16.advancing_players);
ro16.predict(sim, t_id, Ro16toRo8, rng);
quarterfinals.AcceptAdvancements(Ro16toRo8.advancing_players);
quarterfinals.predict(sim, t_id, Ro8toRo4, rng);
semifinals.AcceptAdvancements(Ro8toRo4.advancing_players);
semifinals.predict(sim, t_id, Ro4toRo2, rng);
finals.AcceptAdvancements(Ro4toRo2.advancing_players);
finals.predict(sim, t_id, finalsadv, rng);
top8 = Ro16toRo8.advancing_players;
for (uint i = 0; i<8; i++) {
bottom24[i] = Ro32toRo16.falling_players[i * 2];
bottom24[i + 8] = Ro32toRo16.falling_players[i * 2 + 1];
bottom24[i + 16] = Ro16toRo8.falling_players[i];
}
finalists[0] = finalsadv.advancing_players[0];
finalists[1] = finalsadv.falling_players[0];
}
All data had very good locality using arrays instead of vectors, everything could be inlined and branch predicted and prefecthed, complex tournament formats could be built even properly handling high placements from one tournament granting you seeding into a different tournament. I think I gained like 3x to 5x speedboost from this alone, I also made it multithreaded and work in batches which improved performance further, which allowed me to get updated results more quickly and with a higher number of samples. I also made it so it could output the results and then keep processing more batches of samples to refine the numbers from there. I wouldn’t normally suggest these kinds of optimizations but it’s a very unusual program to have such a wide hotloop
The website is gone, but here’s a working archive of it (which I didn’t know existed until writing this post, I thought there were only broken archives)
home page: https://web.archive.org/web/20150822091605/http://sc2.4ever.tv:80/
a tournament page: https://web.archive.org/web/20160323082041/http://sc2.4ever.tv/?page=tournament&tid=27
a player’s page: https://web.archive.org/web/20161129233856/http://sc2.4ever.tv/?pid=73
a general checkup page: https://web.archive.org/web/20161130055346/http://sc2.4ever.tv/?page=checkup
a page for players who must win tournaments to qualify: https://web.archive.org/web/20161129235740/http://sc2.4ever.tv/?page=must_wins
page showing the simulations history: https://web.archive.org/web/20161130055230/http://sc2.4ever.tv/?page=simulations
FAQ page: https://web.archive.org/web/20160323073344/http://sc2.4ever.tv/?page=faq
the fantasy league WCS Wars: https://web.archive.org/web/20161130055233/http://sc2.4ever.tv/?page=gamehome
my WCS Wars user page https://web.archive.org/web/20160704040152/http://sc2.4ever.tv/?page=user&uid=1
ok this is really niche, but The 7th Guest series (with The 11th Hour, and The 13th Doll, of course the upcoming VR game, and maybe some other related games like Clandestiny and Tender Loving Care)
!stauf_mansion@lemmy.mods4ever.com
and the Deus Ex series !deus_ex@lemmy.ml
also some communities for my mods for games (like Deus Ex Randomizer) https://lemmy.mods4ever.com/communities
this video is 5 years old already, impressive https://youtu.be/DeTQBiKzmYc
They should’ve figured out a way to communicate that the Series S will last until next gen, but the Series X would get more cross-gen games when next gen launches
Or they should’ve known that RAM is hard to scale on and they could’ve included an extra 2GB or so in the Series S lol
But I’m actually a believer that BG3 could be made to run on XSS even with split screen, it’s just gonna take more work and reduced graphics maybe audio quality too, and smarter data streaming from the SSD
Image https://mander.xyz/pictrs/image/2b35c653-2e34-4896-bbed-775c2197b005.png