IRC logs for #openttd on OFTC at 2024-08-07
⏴ go to previous day
00:06:02 *** wallabra has joined #openttd
00:58:47 <ltnazz> talltyler: thank you! ill look into it
01:39:00 *** Wormnest has quit IRC (Quit: Leaving)
02:14:29 *** gnu_jj_ has quit IRC (Ping timeout: 480 seconds)
02:42:15 *** D-HUND has quit IRC (Ping timeout: 480 seconds)
04:43:51 <DorpsGek> - Update: Translations from eints (by translators)
07:00:48 <truebrain> And a retry will fail too
07:00:57 <truebrain> So no nightly today it seems 🙂
07:01:05 <truebrain> I am sure there will be one tomorrow!
07:38:33 *** XYZ_ has quit IRC (Remote host closed the connection)
08:02:13 *** Wolf01 has quit IRC (Quit: Once again the world is quick to bury me.)
08:06:16 *** mindlesstux has joined #openttd
08:34:12 *** gelignite has joined #openttd
09:11:45 *** desq has quit IRC (Remote host closed the connection)
10:22:17 *** Flygon has quit IRC (Quit: A toaster's basically a soldering iron designed to toast bread)
10:41:28 *** mindlesstux has quit IRC (Ping timeout: 480 seconds)
10:45:02 *** mindlesstux has joined #openttd
11:29:42 <LordAro> i'm not entirely clear why the annotation check is failing
11:38:47 <_glx_> Oh it's because outdated actions
12:02:58 *** XYZ has quit IRC (Ping timeout: 480 seconds)
13:06:09 *** nielsm has quit IRC (Ping timeout: 480 seconds)
13:48:26 *** virtualrandomnumber has joined #openttd
13:48:55 *** virtualrandomnumber has quit IRC ()
14:24:20 *** gelignite has quit IRC (Quit: Stay safe!)
14:41:46 <_jgr_> That stuff should really be binned, like trigraphs eventually was
16:13:12 <truebrain> Please remove that link.. my eyes ... it hurts ....
16:54:04 *** gwyd4016 has joined #openttd
16:54:04 <gwyd4016> Is there a repo for nforenum?
16:54:20 <gwyd4016> I could have a go at updating for the new properties in that
16:54:59 <gwyd4016> Whenever it comes across and unknown property in an action 0, it gives up parsing for errors in the rest of the sprite
16:55:27 <gwyd4016> So adding 1C/1D/1E would be cool
16:56:26 *** HerzogDeXtEr has joined #openttd
16:58:43 <peter1139> Not to mention the hideous code style.
16:58:56 <LordAro> and just the hideous code in general
16:59:35 <gwyd4016> Time to go make it worse 😌
17:06:54 <FLHerne> gwyd4016: if you find a way to make it worse you should send that to The Daily WTF
17:28:28 *** johnfranklin has joined #openttd
17:28:28 <johnfranklin> GBP exchange rate is decreasing, UK is upsetting, hmm
17:28:51 *** michi_cc[d] has joined #openttd
17:28:51 <michi_cc[d]> gwyd4016: Small hint: nforenum has a mechanism to read the prop definitions from an external file somwhere in your home dir. You need to delete them otherwise you'll wonder why your changes just won't work.
17:32:51 <andythenorth> should I keep playing my game?
17:33:30 <andythenorth> allows for much longer play with the same save
17:34:04 <andythenorth> in 1x wallclock factor, I'd get about 20 hours
17:56:23 <johnfranklin> It uses real playing time in the wallclock mode?
18:00:50 <andythenorth> for the save filename yes
18:01:04 <andythenorth> I'm playing at 1/3
19:00:47 *** qwebirc29196 has joined #openttd
19:01:11 *** qwebirc29196 has quit IRC ()
19:54:27 *** Wormnest has joined #openttd
20:03:14 *** XYZ_ has quit IRC (Ping timeout: 480 seconds)
20:34:23 <andythenorth> ran out of varaction 2 IDs again
20:42:27 <andythenorth> instead of spanning concurrent IDs across the whole grf it would recurse upwards, checking for specific IDs
20:42:45 <andythenorth> but that is fairly horrible
20:42:46 <_glx_> most likely you have too many not yet used varact2
20:43:08 <andythenorth> it's just the randomised vehicles thing
20:43:08 <_glx_> defined way before their actual use
20:43:53 <andythenorth> the varact2 chain for a 'randomised' vehicle might be trying to chain to the varact2 that is the graphics handler for one of n vehicles
20:44:15 <andythenorth> when n gets too large, or the vehicles are spread out in the file, concurrent varact2 IDs are exhausted
20:44:43 <andythenorth> big switch with results spanning many other vehicles
20:45:05 <andythenorth> I kind of think 'random from selection' might be a valid OpenTTD feature
20:45:12 <_glx_> you can often convert a big switch into many smaller ones
20:45:44 <_jgr_> That tends to make the simultaneous ID problem worse ratehr than better
20:45:51 <andythenorth> this could be sharded into lots of switches checking single IDs
20:45:59 <andythenorth> and hope that nml can make better use of the IDs
20:46:44 <gwyd4016> I think NML doesn't do much to improve allocations of varact2 IDs
20:46:48 <_glx_> I think nml does its best in the area, 256 concurrent IDs is a hard limit, and it's affected by a lot
20:47:05 <gwyd4016> I once had a grf I was modifying
20:47:26 <gwyd4016> And I was able to put it around 50-60 over the allowable varact2 ID limit
20:47:46 <gwyd4016> With manual refactoring I could get it a decent way under
20:48:09 <_glx_> nml doesn't reorder switches
20:48:24 <_glx_> because it's expensive to do
20:48:41 <gwyd4016> This was a case similar to the randomised vehicle, using arbitrary consist reversal meaning some engine switches spanned basically the whole grf
20:48:45 <peter1139> Expensive to compile or expensive to run?
20:48:49 <gwyd4016> Yeah and just complicated
20:49:24 <_glx_> you need to write a dependency chain, and that can be very slow
20:49:34 <_glx_> especially on huge files
20:49:57 <_jgr_> The limit tends to encourage duplication of switches instead, which creates bloat problems
20:50:10 <andythenorth> I already reorganise the vehicle locations in the file to group them adjacent, to the extent possible
20:50:19 <andythenorth> there's a compile step to do that
20:50:25 <_glx_> I once tried to detect duplicated varact2, but it was dead slow
20:50:37 <andythenorth> but some vehicles are candidates for more than one randomised wagon group
20:50:44 <andythenorth> so inevitably it's untidy
20:51:10 <andythenorth> `nmlc info: Concurrent spritegroups: 244/256 ("generated/iron-horse.nml", line 586127)` was the last count before I ran out 😛
20:51:21 <andythenorth> I think it's a sign that Horse is 'done'
20:51:32 <andythenorth> I've found all the limits 😛
20:51:39 <_glx_> well 244 concurrent varact2 for a single vehicle ?
20:51:59 <andythenorth> 244 for the entire grf
20:52:14 <gwyd4016> 256, you get 0xFF IDs to use "at once"
20:52:15 <andythenorth> there's a lot of procedure use, and that exhausts varact2
20:52:38 <_glx_> yup procedures are nice but eat IDs
20:52:57 <andythenorth> hmm, maybe I could write an entry point to all procedures
20:53:07 <andythenorth> and use a parameter to decide which procedure I want
20:53:13 <gwyd4016> Fewer switches overall, but eats up concurrent IDs
20:53:17 <andythenorth> maybe nml will see the rest as local not global
20:53:36 <gwyd4016> I did something like this
20:53:56 <_glx_> yeah if you have a single procedure dispatching to others should limit the lifespan of IDs
20:53:59 <gwyd4016> So long as the only reference to the individual procedures is in the one entry point
20:54:10 <andythenorth> I'm not sure how to pass the other parameters though
20:54:17 <andythenorth> maybe I can pack them all into registers
20:54:39 <peter1139> Who knew that we'd need a calling convention...
20:54:46 <gwyd4016> Or just have n+1 parameters
20:54:56 <andythenorth> I'd need to reserve a block of registers for this
20:55:13 <_glx_> well you can manually fill some temps
20:55:26 <_glx_> that's what nml does on procedure call
20:56:02 <_jgr_> It'd be a bit ugly to do it manually as you'd lose all the ergonomics of them looking like function calls in NML
20:56:07 <gwyd4016> That's all the parameters in a procedure are doing? Setting temp registers? Cool
20:56:31 <_glx_> setting temps and taking care of used ones
20:56:46 <andythenorth> _jgr_: well they'd be all calls to a single dispatcher procedure
20:56:53 <andythenorth> so that could take the params and put them in storage
20:57:01 <gwyd4016> I'm pretty sure you can just pass through the parameters
20:57:09 <andythenorth> they 'd just lose the names along the way in the nml
20:57:13 <_glx_> yeah you can pass through
20:57:23 <andythenorth> they'd be parameter_1...parameter_16
20:57:38 <andythenorth> I don't know how many procedures are in Horse
20:58:20 <_glx_> maybe you could group procedures with the similar parameters
20:58:50 <andythenorth> alternately I reimplement 'randomised wagons'
20:59:04 <_jgr_> The simultaneous limit is something that would be easy to fix when (if?) GRFv9 comes round
20:59:20 <_glx_> yeah v9 and increase the IDs 🙂
20:59:38 <andythenorth> currently the 'randomised wagon' has candidates [A, B, C, D, E] etc
21:00:01 <andythenorth> and A, B, C, D, E are actual buyable vehicles present in the grf, with their graphics varact 2 chain
21:00:13 *** HerzogDeXtEr has quit IRC (Read error: Connection reset by peer)
21:00:16 <andythenorth> and the 'randomised wagon' chains to the varact 2 for one of A...E
21:00:31 <andythenorth> which reduces grf size, but requires very many concurrent varact 2
21:00:57 <andythenorth> I could instead give the 'randomised wagon' a full graphics chain of its own
21:01:16 <andythenorth> with all the realsprites, recolour sprites, random weathering etc
21:01:34 <andythenorth> it's quite bloat on graphics switches
21:01:43 <gwyd4016> Option b is just stop adding stuff
21:01:48 <gwyd4016> Option c is a part 2 file
21:02:09 <_glx_> I think main issue with your randomised wagons is there might be unconcerned vehicles in between
21:02:11 <_jgr_> A part 2 file doesn't really help when the problem is concurrent switches not total ones
21:02:15 <gwyd4016> "please insert disc 2"
21:02:20 <andythenorth> those were the days
21:04:04 <gwyd4016> _jgr_: It's basically the same as just repeating the whole varact2 chain
21:04:32 <_jgr_> You can do that already without needing to make it two GRFs
21:04:48 <gwyd4016> Yeah but now you can sell the DLC
21:04:50 <_jgr_> That is effectively the status quo with copy paste templating
21:05:03 <_glx_> and with templated generation it's easy to do
21:05:07 <andythenorth> I can't chain varact 2 across to another grf? 😛
21:05:28 <gwyd4016> You only get 16 grf list concurrent varact2s
21:06:35 <gwyd4016> Honestly the case I would love to be able to chain varact2s across GRFs is to override a single callback for another GRF's train
21:07:15 <_glx_> btw knowing the length of the generated nml for iron-horse, nmlc does a very good job regarding concurrent action2 🙂
21:07:38 <andythenorth> (1) stop adding randomised vehicles to Horse
21:07:38 <andythenorth> (2) split Horse to 2 grfs (wagons and engines?)
21:07:38 <andythenorth> (3) add randomised vehicles feature to OpenTTD
21:07:38 <andythenorth> (4) increase concurrent varact2 limit?
21:08:15 <_glx_> 4 is not too hard, but requires a new GRF version
21:08:59 <_glx_> and if we do a new version we need to decide other things to change 🙂
21:09:46 *** locosage has joined #openttd
21:09:46 <locosage> 1 extra byte for all the horse switches
21:09:51 <locosage> imagine the size bloat 🤭
21:09:55 <_jgr_> GRF steering group? Big meetings in fancy hotels in a different city each time? 🙂
21:09:56 <gwyd4016> andythenorth: chatgpt tube map
21:10:30 <andythenorth> _jgr_: branded fleeces?
21:10:37 <_glx_> no need for an extra byte, just make it an extended byte
21:10:54 <_glx_> so 0 to FE are still small in size
21:11:38 <locosage> yeah, but extended byte is 2 extra if you get over the limit
21:14:44 *** keikoz has quit IRC (Ping timeout: 480 seconds)
21:15:29 *** reldred has joined #openttd
21:15:29 <reldred> He’ll never be done with horse at this rate!
21:17:43 <peter1139> I also already have a patch for more than 256 spritegroups.
21:18:03 <andythenorth> reldred: how many randomised boxcars do you want in Moose? 🙂
21:18:08 <peter1139> I used a std::unordered_map though, because someone doing setid = 65535 without defining anything else is always possible :p
21:19:37 <_glx_> if only original action2 spec didn't allow FF 🙂
21:20:04 <peter1139> Also means no manual vector allocation is needed.
21:27:37 <andythenorth> when was the last grf version bump? 😛
21:38:58 <andythenorth> probably a bit soon to do it again
21:39:47 <peter1139> GRFv9 ... the XML format.
21:40:09 <peter1139> (Because XML is nicely ancient and awkward and basically obsolete these days...)
21:45:05 *** tokai|noir has joined #openttd
21:45:05 *** ChanServ sets mode: +v tokai|noir
21:51:03 <peter1139> yaml with json and xml blobs?
21:51:58 *** tokai has quit IRC (Ping timeout: 480 seconds)
21:52:46 <andythenorth> what about embedding grf as a configured and tuned LLM?
21:52:51 <andythenorth> then it hallucinates vehicles
22:05:05 <andythenorth> How could we randomise vehicles at purchase time?
22:07:15 *** bigyihsuan has joined #openttd
continue to next day ⏵
