Die4Ever

I did my full playthrough on my PC, but after this update I did try it in on the Quest 3's little processor and it was quite impressive for a battery powered device!

The Steam news page has more notes about the update in general

https://store.steampowered.com/news/app/2456960/view/3714966246914903590

Wow they forgot to put The 7th Guest at #1 (or the new VR remake) 😡

Strong list though, and we did get an honorable mention under Scratches

My controllers updated today, anyone know if that fixes these issues? I've never tried a Quest 2 myself and haven't gotten a chance to try the update today anyways

Yeah rendering is fixed here https://github.com/LemmyNet/lemmy/issues/3828

The update should be releasing soon

the title formatting is fixed in v0.19.0 coming soon

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

What you are talking about seems to the problem of the RSS bots, which I also dislike.

Really I dislike any post where the OP isn't willing to respond to their notification that they have a comment in their post.

I guess your thing requires linking your Reddit account to it? I'm not sure if I want to risk it currently, I would actually be kinda annoyed if my Reddit account got banned or something.

I agree with most of your comment but IDK about the end part. Bots haven't seemed to be working at all, most people hate them. Luckily there's a setting to hide all bot posts but most people don't know that option exists in their settings.

I think the problem with bot posts is that they can put more content in than the human community can sustain. If we don't have enough humans to vote on all these posts and comment on them, then adding more posts into the pile makes the problem worse, it's artificial. If humans were actually interested in the content then they would've posted it themself. The OP is someone that put themself out there for engagement, it's an offer to socialize with someone. The next person to see the post knows there's at least 1 other person willing to talk about this, because there's always at least the OP.

Instead of bots we're probably better off just doing our part to make more posts and comments.

Also we probably need to kick some habits from Reddit, like we're used to not doing self promotion, or being afraid of a community being mostly compromised of your own posts. Also another Reddit habit I think is only posting in specific communities but here if the community is too specific then it won't have many subscribers, so we should be crossposting to the more general communities too.

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.

To your last bullet point, Lemmy posts actually already are visible on Mastodon

A user https://mastodon.gamedev.place/@[email protected]

A community https://mastodon.gamedev.place/@[email protected]

And a Mastodon user can post to Lemmy by mentioning the community

ScummVM has expanded way past just SCUMM engine. T7G is Groovie engine, and future Trilobyte games used Groovie 2 engine which ScummVM also supports now.

Check out the list of engines https://github.com/scummvm/scummvm/tree/master/engines

ScummVM also has a very good wiki https://wiki.scummvm.org/index.php?title=Groovie

If you're trying to play any old adventure game or point and click, definitely check ScummVM first https://www.scummvm.org/compatibility/

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)

This game was really great if you're a fan of the original, or even if you've never played it

We have a community for the 7th Guest series of games and Trilobyte (the developers)

[email protected]

https://lemmy.mods4ever.com/c/stauf_mansion