Image https://mander.xyz/pictrs/image/2b35c653-2e34-4896-bbed-775c2197b005.png

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.

Zelda: Minish Cap, and Castlevania are my favorites

I haven’t played many JRPGs, but I’ll say Grandia 2. I liked the way the timers worked, and the cancels. Also positioning always adds depth to combat.

Panzer Dragoon Saga was pretty cool too, with the circular movement.

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 feel the same way about the prequels, but I think the original game is the best game ever made.

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.

Oh that’s really dumb

Maybe they should’ve rushed it instead of delaying it lol

I’m a big fan of their The Walking Dead games. For a long time I thought the final season would never be finished, but I think it was like a couple years later and it was bought out and finished, and miraculously it was actually good too.

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.

@einat2346@lemmy.today actually dbzer0 doesn’t have access to your IP address, only lemmy.today sees it

for everyone else it’s the instance that your account lives on

https://github.com/LemmyNet/lemmy/issues/4406

oh btw 3rd party apps aren’t working with 0.19.0 yet, because of changes to the authentication API

Well now you can use :0.19.0-rc.5 :)

it’s in alpha currently, but you could still run it

I think you might have to use the :dev tag to get this update, a bit risky to stay on that tag though, maybe wait for the next docker image of an alpha release

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

yes you’re right, also that config flag was renamed to cache_external_link_previews

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

inertia is very strong apparently

I setup Gogs once like 6 years ago or something lol, I remember it being pretty easy and it is nice. Although if Gitea is more actively maintained then it’s probably worth giving that a shot first.

Zombies Ate My Neighbors – Wide Mode

Simply increases the playfield area on screen from 256×224 to 320×224. Seems to be compatible with other patches.

so simple, but probably a good improvement for co-op play

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

Contributing to ScummVM, they can be pretty strict but it’s good

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)

Which is part of why we should want all the popular social sites to be federated, so that holding the userbase doesn’t create an insurmountable monopoly and you can easily move to a better alternative without leaving your friends and content behind

Yeah I need to start doing this more lol

https://youtu.be/o97uNzbBfis?si=YZ1BewzBvjK6S_KM

Hell yeah, The 7th Guest! I was a little kid when we got this game and the family used to play together trying to solve the puzzles, good times. Gave me nightmares lol.

Btw we have !stauf_mansion@lemmy.mods4ever.com

Many years ago I ran my own Gogs and it was pretty good, would recommend

I’ve got a few more for you that I forgot earlier

Point and click adventure games !adventuregames@lemm.ee

Doom !doom@lemmy.sdf.org

RollerCoaster Tycoon !rct@lemmy.world

StarCraft !starcraft@lemmy.world

Haha yeah you got me! You added the correct ones though, thanks

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

Monkey Island

work in progress

https://github.com/LemmyNet/lemmy/pull/3897

Maybe, but Lemmy has sorting options that Reddit didn’t, like Active and New Comments, so maybe we need to reevaluate megathreads for Lemmy

I thought it would leave comments on individual lines of code with feedback and code quality, but seems like it just summarizes what the pull request changes

the summary stuff would be better if it was per file instead of overall

It’s cool for small and easily testable functions like sorting, but to refactor large amounts of code? No thanks. Would be great if it could leave comments on my pull request though.

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