Log for #openttd on 12th January 2014:
Times are UTC Toggle Colours
00:00:32  <JVassie> all done
00:14:46  <JVassie> damn NML is easy to use :x
00:18:13  <Eddi|zuHause> well you could just install nml and make the grf yourself
00:18:18  <JVassie> I did
00:18:29  <JVassie> I thought there would be more to it than there was
00:18:43  <Eddi|zuHause> there rarely is
00:18:50  <Eddi|zuHause> depends on how good the instructions are
00:18:54  *** Devroush [] has quit []
00:19:00  <JVassie> Well, it took quite a lot of fiddling to get M4 set up and working correctly :P
00:19:13  <Eddi|zuHause> of if they are made for someone with lower or higher experience than you have
00:20:08  <JVassie> How can I upload the grf to BaNaNaS?
00:20:16  <JVassie> can't see any obvious links on the bananas site
00:20:33  <JVassie> (yes I'm signed in)
00:20:41  <Eddi|zuHause> you need to create a manager account
00:20:57  <JVassie> ahh
00:21:00  <JVassie> right you are
00:21:01  <JVassie> thanks
00:21:12  <frosch123> <- just there
00:21:28  *** Stimrol [] has quit [Quit: ZNC -]
00:21:33  <JVassie> got it ta
00:22:18  <JVassie> what would be a sensible minimum ottd version for a town name grf?
00:22:44  <Eddi|zuHause> any >= 1.0 i suppose
00:22:53  <frosch123> town name support is older than bananas support
00:23:00  <frosch123> but your nml grf will require ottd 1.2
00:23:13  <JVassie> ok np
00:23:15  <JVassie> 1.2.0 it is
00:23:31  <Eddi|zuHause> oh right, nml creates grfv8
00:23:40  <Eddi|zuHause> i always forget that :)
00:24:21  <frosch123> damn, someone knows a grf that disables itself with a proper action b message?
00:24:56  <frosch123> ah, "canadian" is always a good try
00:25:06  <Eddi|zuHause> tried the dbset on arctic/tropic?
00:25:18  <frosch123> yes, but it only disables, without message
00:25:22  <frosch123> probably too old :p
00:25:33  <Eddi|zuHause> the ecs extension without base?
00:25:37  *** Stimrol [] has joined #openttd
00:25:54  <Eddi|zuHause> i'm pretty sure i have seen actionB in that code
00:26:13  <frosch123> yeah, it complains about missing ecs
00:26:20  *** valhallasw [] has quit [Ping timeout: 480 seconds]
00:34:15  *** Stimrol [] has quit [Quit: ZNC -]
00:37:06  *** skyem123 [] has quit [Quit: Leaving]
00:37:35  *** JVassie [] has quit []
00:39:10  *** DarkAce-Z is now known as DarkAceZ
00:44:41  *** Elukka [] has joined #openttd
00:56:33  *** Djohaal [~Djohaal@] has joined #openttd
01:03:21  *** KritiK [] has quit [Quit: Leaving]
01:10:30  *** DarkAceZ [] has quit [Ping timeout: 480 seconds]
01:14:08  <Wolf01> 'night
01:14:12  *** Wolf01 [] has quit [Quit: Once again the world is quick to bury me.]
01:15:51  *** frosch123 [] has quit [Quit: be yourself, except: if you have the opportunity to be a unicorn, then be a unicorn]
01:17:14  *** DarkAceZ [] has joined #openttd
01:19:28  *** Stimrol [] has joined #openttd
01:29:17  *** DarkAce-Z [] has joined #openttd
01:33:01  *** DarkAceZ [] has quit [Read error: Operation timed out]
01:35:51  *** DarkAce-Z is now known as DarkAceZ
01:41:14  *** roadt_ [~roadt@] has joined #openttd
01:48:30  *** Aristide [] has quit [Remote host closed the connection]
01:55:36  *** gelignite_ [] has joined #openttd
02:02:55  *** gelignite [] has quit [Ping timeout: 480 seconds]
02:09:53  *** Stimrol [] has quit [Quit: ZNC -]
02:15:17  *** Stimrol [] has joined #openttd
02:15:35  *** namad7 [] has joined #openttd
02:17:36  *** yorick [] has quit [Remote host closed the connection]
02:17:55  *** namad8 [] has quit [Ping timeout: 480 seconds]
02:19:30  *** glx [] has quit [Quit: Bye]
02:44:10  *** HerzogDeXtEr1 [] has joined #openttd
02:51:21  *** HerzogDeXtEr [] has quit [Ping timeout: 480 seconds]
03:24:44  *** gelignite_ [] has quit [Quit:]
03:59:06  *** DDR [] has quit [Read error: Connection reset by peer]
03:59:28  *** DDR [] has joined #openttd
04:02:45  *** qwebirc33855 [] has joined #openttd
04:02:49  *** qwebirc33855 [] has quit []
04:03:28  *** GriffinOneTwo [] has joined #openttd
04:43:47  *** xT2 [] has joined #openttd
04:47:46  *** ST2 [~ST2@] has quit [Ping timeout: 480 seconds]
04:58:14  *** Superuser [] has quit [Quit: Hi, I'm a quit message virus. Please replace your old line with this line and help me take over the world of IRC.]
05:12:50  *** Djohaal [~Djohaal@] has quit [Read error: Connection reset by peer]
05:38:39  *** Super_Random [] has quit [Read error: Connection reset by peer]
05:56:01  *** Eddi|zuHause [] has quit []
05:56:16  *** Eddi|zuHause [] has joined #openttd
06:20:15  *** Supercheese [~Superchee@] has quit [Ping timeout: 480 seconds]
06:22:41  *** Pereba [~UserNick@] has quit [Quit: AdiIRC - custom made irc client. []]
06:53:09  *** bdavenport [] has quit [Quit: ZNC -]
06:53:33  *** bdavenport [] has joined #openttd
07:25:09  *** Flygon [] has quit [Read error: Connection reset by peer]
07:26:29  *** andythenorth [] has joined #openttd
07:27:59  *** Flygon [] has joined #openttd
07:39:01  <andythenorth> moin
07:57:40  *** roadt_ [~roadt@] has quit [Ping timeout: 480 seconds]
08:04:07  <andythenorth> is it weird to enforce that the value of a parameter argument has to be a two-tuple?
08:04:18  <andythenorth> even if the second value is optional
08:04:25  <andythenorth> eg. foo = ('bar',)
08:04:38  <andythenorth> or foo=('bar', 'ham')
08:07:22  <andythenorth> foo = ('bar', None)
08:07:50  <andythenorth> ? ^ it's a pattern I see in some 3rd party libraries I use
08:08:15  <andythenorth> be explicit about the second param, rather than just assuming that it can be missing
08:08:22  <andythenorth> or I could just use a list :P
08:11:12  *** roadt_ [~roadt@] has joined #openttd
08:21:25  <Flygon> Well, this's annoying
08:21:34  <Flygon> Rail vehicle stops right in front of depot...
08:21:43  <Flygon> Departs and loads passengers..
08:21:49  <Flygon> ...then reverses away from compatible depot
08:21:52  <Flygon> During autorenew
08:21:53  <Flygon> <_>
08:22:30  <andythenorth> depot routing is shafted
08:22:33  <andythenorth> has been for ages
08:22:50  <Flygon> So...
08:23:08  <Flygon> The psudorandom nature of if vehicles will actually go into a depot is... er, well
08:23:10  <Flygon> Known?
08:23:13  <Flygon> Sorry, I had bad words
08:23:31  *** Progman [] has joined #openttd
08:23:39  *** sla_ro|master [slamaster@] has joined #openttd
08:24:47  <andythenorth> it's known that you need to use 'go to depot' orders
08:24:56  <andythenorth> or track construction that forces depot visits
08:25:44  <Flygon> Hmm
08:25:47  <Flygon> Well
08:25:48  <Flygon> Alright
08:25:49  <Flygon> Thanks
08:25:49  <Flygon> x.x
08:27:04  <andythenorth> you could file a bug
08:27:12  <andythenorth>
08:27:33  <Flygon> Eh
08:27:38  <Flygon> It's a known issue
08:27:41  <Flygon> Filing a bug'd be rude
08:27:46  <andythenorth> I don't know if there's a ticket for it
08:27:48  <andythenorth> I'll search
08:27:53  <Flygon> Alright
08:28:35  <andythenorth> can't see one
08:28:51  <Flygon> Alright
08:28:56  <Flygon> I'll have to formulate good wording, then
08:29:03  <Flygon> I've never been good at explaining myself
08:29:07  <Flygon> It comes out in buffy speak
08:48:19  <andythenorth> hmm, I could also have a configuration object
08:48:28  <andythenorth> which is a bit too frameworky, but would work :P
08:56:32  <Flygon> Sorry for the delay
08:56:35  <Flygon> Too frameworky?
08:59:51  * andythenorth thinking aloud
09:00:13  <Flygon> x3
09:00:19  <Flygon> And I'm too curious :p
09:00:24  <Flygon> It's actually kind of annoying
09:00:28  <Flygon> PC devving is alien to me
09:00:42  <Flygon> But see people talking about working with machines such as the Mega Drive? I get the jist of it
09:00:52  <Flygon> My brain is like all dsandaskjdnjkdsaklaaaaarfarble
09:02:06  *** Japa [~Japa@] has joined #openttd
09:02:10  <andythenorth> it's just words moving other words around tbh
09:02:31  <andythenorth> do stuff to thing
09:02:55  <Flygon> So basically
09:03:09  <Flygon> You want to avoid frameworks to avoid adding clutter upon clutter to make something work?
09:03:32  <andythenorth> kind of
09:03:48  <andythenorth> the more layers in the code, the more places you have to go read and the code to see what it does
09:04:12  <andythenorth> but it can also add massive simplicity
09:04:57  <andythenorth> I am not a programmer though
09:05:03  <andythenorth> I just write code
09:07:51  <Flygon> More of a programmer than I!
09:08:42  *** adf88 [] has quit [Quit: adf88]
09:09:54  *** Pensacola [] has joined #openttd
09:10:59  *** Pensacola [] has quit [Remote host closed the connection]
09:14:49  *** Aristide [] has joined #openttd
09:14:58  *** Pensacola [] has joined #openttd
09:20:53  *** LSky [] has joined #openttd
09:23:33  *** Alberth [~hat@2001:980:272e:1:be5f:f4ff:feac:e11] has joined #openttd
09:23:36  *** mode/#openttd [+o Alberth] by ChanServ
09:24:11  <Alberth> moin
09:24:49  *** andythenorth [] has quit [Quit: andythenorth]
09:25:01  *** LSky` [] has quit [Ping timeout: 480 seconds]
09:31:52  *** andythenorth [] has joined #openttd
09:37:02  <andythenorth> lo Alberth
09:37:53  <Alberth> zeph is playing at mars, it seems :)
09:40:16  <andythenorth> o_O
09:41:42  <Flygon> That moment where you realize you're boned... because you built a railway line with stations in tight spots, with shorter than usual platforms
09:41:46  <Flygon> And now the cities are gigantic...
09:44:04  <andythenorth> meh
09:45:18  <andythenorth> I can write some code which is clunky but terse, and complies with JFDI
09:45:40  *** Japa [~Japa@] has quit [Read error: Connection timed out]
09:45:54  <andythenorth> or some that is clunky and longer, and move obvious what it does, but a bit over-abstracted for not enough benefit
09:46:14  <andythenorth> or I can do it 'properly', modifying > 40 files, adding a new interface, but failing JFDI
09:46:38  <andythenorth> this is the bit of coding I find hardest :(
09:51:31  <Alberth> project that large, or do you have too many files?
09:52:15  <andythenorth> I think it's an acceptable number
09:52:32  <andythenorth> there is 1 .py file per locomotive
09:52:40  <andythenorth> and 1 .py file for each wagon type
09:52:51  <andythenorth> which is clean and easy to work with
09:53:04  <Alberth> sounds java-ish :)
09:53:47  <andythenorth> I would think of it mostly like configuration data
09:53:55  <andythenorth> it's not class defs or anything
09:53:57  <Alberth> :)
09:56:26  <andythenorth> I am going to think about something else to see if the answer appears :P
09:56:36  <andythenorth> it's not even a hard problem, nor interesting
09:56:45  *** HerzogDeXtEr1 [] has quit [Quit: Leaving.]
09:58:49  <andythenorth> you know it's getting silly when the best answer seems to be 'dump a function into'
09:59:12  <Alberth> :)
09:59:53  <andythenorth> should be renamed ''
09:59:58  <Rubidium> nah, dumping it in utils is bad. If it is good enough for utils, then it's good enough for the PSL ;)
10:00:00  <andythenorth> every project seems to have one
10:00:01  <Alberth> I never seem to have utils like files, but perhaps I hide them in more specific files
10:00:16  <andythenorth> :)
10:00:16  *** Progman [] has quit [Remote host closed the connection]
10:00:29  <andythenorth>
10:00:43  <Rubidium> with a @author <not me>
10:00:56  <Alberth> :)
10:08:29  * andythenorth finds a solution, makes my skin crawl with 'ugh' but JFDI and stop wasting this channel's bandwidth eh?
10:08:34  <andythenorth> this is not a comp-sci exam :P
10:16:22  *** oskari89 [] has joined #openttd
10:22:47  <Rubidium> such things are merely a tiny sliver of the whole curriculum
10:33:23  *** ST2 [~ST2@] has joined #openttd
10:34:01  <Aristide> xD
10:34:04  <Aristide> So fun
10:34:47  <Aristide> So, this picture is old, because 81 line has been replaced by C17 bus line in August 2011
10:36:35  *** andythenorth [] has quit [Quit: andythenorth]
10:37:58  *** andythenorth [] has joined #openttd
10:40:28  *** xT2 [] has quit [Ping timeout: 480 seconds]
10:40:49  <__ln__>
10:50:10  <Alberth> lol
11:01:46  *** valhallasw [] has joined #openttd
11:06:00  <andythenorth> hmm
11:06:11  <andythenorth> is it wrong to call a factory directly with params?
11:06:25  <andythenorth> all the python factory examples I can find are passing factories around as args to some other function
11:06:43  <andythenorth> I want to treat it as a callable GraphicsProcessorFactory(processor_name, {options})
11:10:22  <andythenorth> rather than blah_blah_blah(factory=GraphicsProcessorFactory) or whatever
11:10:26  <andythenorth> I don't really understand the examples tbh
11:11:34  <andythenorth> nvm :)
11:11:37  <andythenorth> biab
11:11:39  *** andythenorth [] has left #openttd []
11:12:33  *** fjb [] has quit [Ping timeout: 480 seconds]
11:18:48  *** frosch123 [] has joined #openttd
11:19:23  *** skyem123 [] has joined #openttd
11:19:38  *** Pensacola [] has quit [Remote host closed the connection]
11:38:17  *** Japa [~Japa@] has joined #openttd
11:56:57  *** Devroush [] has joined #openttd
12:01:36  *** Taede [] has quit [Ping timeout: 480 seconds]
12:01:40  *** Superuser [] has joined #openttd
12:12:05  *** KritiK [] has joined #openttd
12:14:37  <Flygon> fml
12:14:41  <Flygon> OpenTTD just randomly froze
12:14:50  <Flygon> ...and then it unfroze
12:14:52  <Flygon> That was weird
12:32:39  <Superuser>
12:33:05  *** tokai|mdlx [] has joined #openttd
12:34:25  *** gelignite [] has joined #openttd
12:37:31  <Alberth> without further information there is nothing we can do :)
12:38:14  <Alberth> maybe it wanted to access the disk, but it was turned off, so it needed starting up first?
12:39:05  *** tokai|noir [] has quit [Ping timeout: 480 seconds]
12:46:19  <planetmaker> bye till tomorrow or much later
13:03:49  <Virtual> IRC description :
13:08:58  <Eddi|zuHause> that is really old...
13:09:03  <Virtual> new for me
13:09:28  <Virtual> thats the beauty of the interweb
13:16:19  *** yorick [] has joined #openttd
13:24:40  *** Wolf01 [] has joined #openttd
13:24:49  <Wolf01> hi hi
13:27:36  <Alberth> o/
13:38:20  *** Aristide [] has quit [Ping timeout: 480 seconds]
13:45:49  *** Elukka [] has quit [Ping timeout: 480 seconds]
14:15:02  *** retro|cz [] has joined #openttd
15:06:03  *** Japa [~Japa@] has quit [Read error: Connection reset by peer]
15:09:51  *** Japa [~Japa@] has joined #openttd
15:26:49  *** yorick [] has quit [Remote host closed the connection]
15:26:57  *** andythenorth [] has joined #openttd
15:31:03  *** yorick [] has joined #openttd
15:33:33  <andythenorth> hmm, usually the random rambling of c2 wiki is the best place I can learn about patterns (or programming in general)
15:33:40  <andythenorth> but for factories, c2 leaves me none the wiser
15:33:50  <andythenorth> except that there is a big divided between love and hate for them
15:33:54  <andythenorth> divide *
15:36:04  *** eviltoaster [] has joined #openttd
15:36:12  <Rubidium> andythenorth: in OpenTTD loves factories
15:36:30  <andythenorth> I have made lots of OpenTTD factories
15:36:35  <andythenorth> I must be a pattern master
15:36:43  <andythenorth> where is that Java monks cartoon? o_O
15:36:52  <Rubidium> hmm... I shouldn't try to rewrite a sentence when already half way through but not looking at the begin anymore
15:41:05  <andythenorth>
15:43:52  * Rubidium can only partly agree with that
15:44:40  <Rubidium> XML, singletons and AWK are generally bad, especially the .getInstance().<many funcs> kind where the functions could just be static
15:44:57  <Rubidium> threads and regular expressions aren't bad by definition
15:45:12  <andythenorth>
15:45:17  <Xaroth|Work> that depends on the implementation
15:45:46  <Xaroth|Work> but I hate the whole FactoryFactory crap that java does ;|
15:48:42  <Rubidium> though, using threads manually for performance reasons is usually bad; if you can write it so it can use a thread pool, then you don't need to do the boring thread management and things are much nicer
15:49:50  *** valhallasw [] has quit [Remote host closed the connection]
15:51:47  *** valhallasw [] has joined #openttd
15:52:24  <Rubidium> ;)
15:54:23  *** andythenorth [] has quit [Quit: andythenorth]
16:19:06  *** andythenorth [] has joined #openttd
16:43:22  <Eddi|zuHause> that second story basically says "you learn from your mistakes"?
16:46:43  *** DDR [] has quit [Read error: Connection reset by peer]
16:47:19  *** DDR [] has joined #openttd
16:51:14  <Eddi|zuHause>
16:52:28  <__ln__> a fair question
17:08:41  *** andythenorth [] has left #openttd []
17:28:12  <Alberth> bit stupid not to use the data of a cray in such a case :p
17:37:25  *** taede [] has joined #openttd
17:39:46  *** andythenorth [] has joined #openttd
17:45:01  <DorpsGek> Commit by fonsinchen :: r26236 trunk/src/economy.cpp (2014-01-12 17:44:55 UTC)
17:45:02  <DorpsGek> -Fix: Don't overreserve after autorefit, but do reserve mail for aircraft
17:47:04  *** Aristide [] has joined #openttd
17:48:52  <andythenorth> so if I call HamSandwichFactory() what would I get back?  A new factory object? Or an instance of the object the factory makes?
17:49:03  <andythenorth> the python factory pattern examples are not clear
17:49:11  <andythenorth> almost as though they were winging it :P
17:49:22  <Kjetil_> you should get som kind of HamSandwich
17:49:28  *** Kjetil_ is now known as Kjetil
17:49:57  <andythenorth> at least one example shows my getting a new factory
17:50:08  <andythenorth> which I then call factory.make_sandwich(vars) on
17:50:08  <Kjetil> Then it should be a factoryfactory
17:50:26  <andythenorth> the example above doesn't seem anything special
17:50:31  <andythenorth> nor worth naming as a pattern
17:50:39  <andythenorth> it's just a class :P
17:51:06  <Alberth> assuming it's a class, I'd expect a factory object
17:51:44  <andythenorth> yeah
17:51:46  <andythenorth> me too
17:51:49  <Alberth> but I don't think there is universal agreement on these things, just define something and use it accordingly
17:51:58  <andythenorth> I am going to avoid the word factory
17:52:03  <andythenorth> and just code what I need :P
17:52:35  <Eddi|zuHause> <andythenorth> so if I call HamSandwichFactory() what would I get back?  A new factory object? Or an instance of the object the factory makes? <-- depends on whether you have an abstract factory or a concrete factory
17:52:52  <andythenorth> oic :)
17:52:56  <Alberth> unless you code for the general public, just do what feels right for you :)
17:52:58  <andythenorth> which gives me which?
17:53:11  <andythenorth> Alberth: I hate not knowing :(
17:53:18  <andythenorth> if I'm going to do it wrong, I might as well know why :P
17:53:40  <Eddi|zuHause> the abstract factory makes factories, the concrete factory makes objects
17:54:03  <andythenorth> and do I have to care if factory is a class, or just some method somewhere?
17:54:10  <andythenorth> does it matter in any way at all?
17:54:46  <Alberth> sounds like implementation details to me, although a class gives you storage of the past
17:55:05  <Alberth> which would be useful for factories as object
17:55:36  <Alberth> if you don't need storage, I don't understand why you'd use a factory, tbh
17:55:44  <Eddi|zuHause> a concrete factory works perfectly fine as a function
17:56:21  * Alberth will not speak about abstract base classes of concrete factories :p
17:56:50  <andythenorth> Alberth: I could just have called this 'get_a_graphics_processor(name, options={})'
17:56:57  <andythenorth> and not worried about factories :)
17:57:19  <Eddi|zuHause> well that basically is a factory :)
17:57:50  <Eddi|zuHause> (or the simplest form thereof)
17:58:37  <andythenorth> I guess the significant thing is I'm not doing 'import from GraphicsProcessors import type1, type2, type3' etc
17:58:46  <andythenorth> and then 'foo = type3(options)'
17:59:33  <DorpsGek> Commit by frosch :: r26237 /trunk/src (3 files in 2 dirs) (2014-01-12 17:59:27 UTC)
17:59:34  <DorpsGek> -Cleanup: Remove unused SCC_STRING_ID.
17:59:49  <DorpsGek> Commit by frosch :: r26238 /trunk/src (strings.cpp strings_func.h) (2014-01-12 17:59:43 UTC)
17:59:50  <DorpsGek> -Codechange: Use StringParameters::GetDataLeft to check for left space in the param array.
18:00:08  <DorpsGek> Commit by frosch :: r26239 /trunk/src (3 files) (2014-01-12 18:00:02 UTC)
18:00:09  <DorpsGek> -Fix: Check that there is space left in the string parameter array, before pushing NewGRF parameters to it.
18:00:25  <DorpsGek> Commit by frosch :: r26240 /trunk/src (6 files) (2014-01-12 18:00:19 UTC)
18:00:26  <DorpsGek> -Codechange: Pass the GRFFile to GetErrorMessageFromLocationCallbackResult instead of the GRFID.
18:00:45  <DorpsGek> Commit by frosch :: r26241 /trunk/src (11 files) (2014-01-12 18:00:39 UTC)
18:00:46  <DorpsGek> -Codechange: Remember the GRFFile which filled the TextRefStack in the TextRefStack.
18:01:01  <DorpsGek> Commit by frosch :: r26242 /trunk/src (newgrf_text.cpp strings.cpp) (2014-01-12 18:00:55 UTC)
18:01:02  <DorpsGek> -Codechange: Use GRFFile that filled the TextRefStack to translate StringIDs from the TextRefStack, instead of passing stuff via global vars.
18:01:23  <DorpsGek> Commit by frosch :: r26243 /trunk/src (3 files) (2014-01-12 18:01:16 UTC)
18:01:24  <DorpsGek> -Cleanup: Move TTDPStringIDToOTTDStringIDMapping to newgrf.cpp, it's only used there.
18:01:39  <DorpsGek> Commit by frosch :: r26244 /trunk/src (newgrf_text.cpp table/control_codes.h) (2014-01-12 18:01:33 UTC)
18:01:40  <DorpsGek> -Feature: [NewGRF] Add StringCodes 9A 1B, 9A 1C and 9A 1D to display amounts of cargo.
18:01:57  <DorpsGek> Commit by frosch :: r26245 trunk/src/newgrf.cpp (2014-01-12 18:01:50 UTC)
18:01:58  <DorpsGek> -Codechange: No need for a map, if a vector suffices.
18:02:43  <andythenorth> time for a FIRS update? o_O
18:07:04  *** Alberth [~hat@2001:980:272e:1:be5f:f4ff:feac:e11] has left #openttd []
18:08:46  <frosch123> wiki, nforenum, nml, ... the list is long :p
18:14:11  <Eddi|zuHause> andythenorth: the thing with factories is, you can add as many layers of indirection as you want, but you should only use as many layers of indirection as you need
18:15:07  *** andythenorth [] has quit [Quit: andythenorth]
18:16:14  <Eddi|zuHause> frosch123: why not turn the text stack into an actual stack?
18:16:37  <frosch123> because it is no stack
18:16:58  <frosch123> try to do plurals and cases with a real stack :p
18:18:29  <Eddi|zuHause> i've never actually looked at that code
18:19:38  <Eddi|zuHause> frosch123: anyway, the point was: why is there a limit, when it could just be dynamically extended if necessary
18:20:02  *** andythenorth [] has joined #openttd
18:20:13  <frosch123> to prevent people from playing excel
18:20:29  *** triad [] has joined #openttd
18:20:40  <frosch123> [19:08] <frosch123> wiki, nforenum, nml, ... the list is long :p <- ah, i missed eints
18:27:50  <frosch123> oh man, nforenum is such a hack...
18:32:04  *** triad [] has quit [Quit: Konversation terminated!]
18:38:15  <frosch123> how do string parameters in nml actually work?
18:40:12  <frosch123> <- that seems to fill the stack completely manually
18:44:05  *** roadt_ [~roadt@] has quit [Ping timeout: 480 seconds]
18:45:18  <DorpsGek> Commit by translators :: r26246 trunk/src/lang/danish.txt (2014-01-12 18:45:11 UTC)
18:45:19  <DorpsGek> -Update from WebTranslator v3.0:
18:45:20  <DorpsGek> danish - 4 changes by Hatsen
18:45:45  <Eddi|zuHause> frosch123: i think automatic stack stuff was never implemented
18:46:22  <Eddi|zuHause> strings can get parameters, but only ones that can be statically evaluated
18:46:44  <Eddi|zuHause> "string(STR_X, param1, param2, ...)"
18:49:13  *** Progman [] has joined #openttd
18:51:05  *** andythenorth [] has quit [Quit: andythenorth]
18:51:15  <Eddi|zuHause> and again i think part of the problem is that the stack isn't actually a stack, making things needlessly complicated
18:52:02  <frosch123> i thought the problem is that humans are just bad at reading hex
18:52:51  <frosch123> that's why they come up with all this crap like making computers use decimal numbers, or ordering digits from highest signifance to lowest
18:52:52  <Eddi|zuHause> no, that's the motivation for NML's existance in the first place :p
18:56:40  <frosch123> hmm, i see 5 bools in a row
18:56:45  <frosch123> what could be their meaning :p
19:04:43  <frosch123> yay, done
19:04:56  <frosch123> the length of the grf tool chain is getting so silly :p
19:06:31  <Eddi|zuHause> google->python->cpp->nmlc->awk->grfcodec->nforenum?
19:06:52  <Eddi|zuHause> err, switch last two
19:07:17  <Eddi|zuHause> i haven't yet used eints or musa
19:07:19  <frosch123> i just mean the amount of projects i had to touch to add new string codes
19:07:24  *** andythenorth [] has joined #openttd
19:07:53  <Eddi|zuHause> frosch123: turn the grf specs into XML!
19:08:03  <frosch123> to add another tool? :p
19:08:18  <andythenorth> frosch123: <- that is doing debug output, it intentionally uses the stack manually
19:08:20  <andythenorth> :)
19:08:21  <Rubidium> xkcd XYZ, right?
19:08:22  <Eddi|zuHause> (as in, grfcodec, nforenum and nml build themselves out of this XML file)
19:08:44  <Rubidium> does grfcodec need changes?
19:09:03  <Eddi|zuHause> i hope not :)
19:09:05  <frosch123> if it does, i missed them :p
19:09:14  <Rubidium> i.e. I'd say only transitively because it contains nforenum
19:09:49  <andythenorth> it doesn't help having two supported compile options :P
19:09:57  <andythenorth> one of them involving two separate tools
19:10:28  <Eddi|zuHause> <-- can Set/GetBit be overloaded for uint8[]?
19:11:06  <frosch123> if you make an endian-safe definition of what it shall do :p
19:11:35  <Eddi|zuHause> same thing as these macros
19:11:43  <Eddi|zuHause> and uint8 should not be affected by endianness
19:12:49  <frosch123> how about using std::vector<bool> :p
19:13:01  <frosch123> i thought you were all about dynamic sizing
19:14:27  <Eddi|zuHause> yeah, i think that's what it needs :p
19:14:52  <Eddi|zuHause> people wanted to resize the map midgame for years anyway :)
19:17:15  <Eddi|zuHause> but i don't suppose templates can act differently when a type is a pointer/array or not?
19:18:13  <frosch123> you can if you make stuff references
19:18:37  <frosch123> well, maybe not in this cae
19:18:38  <Rubidium> you can make a special instantiation, can't you?
19:18:51  <frosch123> anyway, std::vector has a specialisation for bool
19:18:54  <Eddi|zuHause> Rubidium: but the code needs to be different
19:19:04  <Eddi|zuHause> Rubidium: like a template-case
19:20:25  <frosch123> Eddi|zuHause: that's called "template specialisation"
19:20:44  <Eddi|zuHause> i've never really worked with templates
19:20:47  <andythenorth> hmm no alberth
19:26:11  <Rubidium> not that I can quickly get it working though :(
19:32:31  <Eddi|zuHause> "Unfortunately it is also limited by the low Martian gravity, and test tracks have shown trains which attempt to accelerate quickly tend to launch off the track!" <-- that is probably nonsense, as the same force that magnetically lifts the train up from the ground will also pull it down, once it passes some point
19:41:03  *** valhallasw [] has quit [Quit: leaving]
19:50:41  *** tommerry11 [] has joined #openttd
19:53:21  *** DDR [] has quit [Read error: Connection reset by peer]
19:53:46  *** DDR [] has joined #openttd
19:54:10  *** montalvo [] has joined #openttd
19:58:00  <George> Hello
19:58:17  <George> Is there any devzone admin available?
19:58:19  <George> Membership #6722
20:01:38  *** GriffinOneTwo [] has quit [Quit: Page closed]
20:06:03  *** valhallasw [] has joined #openttd
20:16:57  *** DarkAce-Z [] has joined #openttd
20:20:40  *** DarkAceZ [] has quit [Ping timeout: 480 seconds]
20:26:12  *** glx [] has joined #openttd
20:26:15  *** mode/#openttd [+v glx] by ChanServ
20:32:35  *** oskari89 [] has quit []
20:50:56  <andythenorth> ho ho
20:51:03  <andythenorth> finally a factory method example I understand :)
20:51:15  * andythenorth has fallen in a rabbit hole
20:53:21  <andythenorth> this actually made 100% sense
20:53:54  *** Djohaal [~Djohaal@] has joined #openttd
21:03:19  <Xaroth|Work> that first part alone makes no sense to me :(
21:04:02  <Xaroth|Work> seriously, iterating over __subclasses__ and then using the name to do a switch to turn that name into a class again?
21:04:09  <Xaroth|Work> use the bloody class that __subclasses__ returns :|
21:04:52  <Xaroth|Work> shapes = [random.choice(Shape.__subclasses__())() for x in range(n)]
21:07:57  <andythenorth> what remains puzzling in all the examples I've found is why factories are created as classes
21:08:17  <andythenorth> none of them seem to do anything that requires anything more than a method
21:08:20  <Xaroth|Work> Factories are something for languages like Java and C#
21:08:56  <andythenorth> hmm, some of the factory classes offer methods themselves, which makes sense
21:09:52  *** valhallasw [] has quit [Read error: Connection reset by peer]
21:13:09  *** skyem123 [] has quit [Quit: Leaving]
21:14:53  *** valhallasw [] has joined #openttd
21:24:35  <andythenorth> I dunno, why not just subclass stuff?
21:31:26  *** tommerry11 [] has quit [Ping timeout: 480 seconds]
21:34:44  <Wolf01> 'night
21:34:48  *** Wolf01 [] has quit [Quit: Once again the world is quick to bury me.]
21:36:47  <Xaroth|Work> andythenorth: the whole Factory design doesn't really apply to python tbqfh
21:37:12  <andythenorth> I am sticking to "if you don't understand it, you don't need it" :P
21:37:36  <andythenorth> I'm just going to make a class that wraps whatever other class I need
21:37:46  <andythenorth> will work fine, and I understand it
21:37:49  <Xaroth|Work> what do you need? :P
21:39:02  <Xaroth|Work> thats usually where most people tend to go wrong
21:39:07  <Xaroth|Work> they don't really know what they -need-
21:39:14  <Xaroth|Work> and go for the 'ooh shiney' approach
21:39:21  <Xaroth|Work> and end up with a badly implemented <system here>
21:39:28  <andythenorth> I need to create an object (which will be one of n types of GraphicsProcessor), but without having to import the type to my vehicle file, which is basically just configuration data, and doesn't want to know about too many things that live in other modules
21:39:32  *** HerzogDeXtEr [] has joined #openttd
21:39:53  <andythenorth> so I have now created an intermediary object which sorts that out
21:40:07  <andythenorth> and does all the 'knowing about the other module' stuff
21:40:20  <andythenorth> it's not a factory :P
21:40:26  <Xaroth|Work> why do you want an object, without importing it?
21:41:14  <andythenorth> that is a good question
21:41:17  <andythenorth> which I can't answer
21:41:24  <Xaroth|Work> (i.e. why don't you want to import it?)
21:41:37  <andythenorth> lazy
21:42:06  * Xaroth|Work shrugs
21:42:17  <Xaroth|Work> can't fix that :P
21:42:17  <andythenorth> means if the object creation interface changes, I have to go deal with that in ~40 .py files
21:42:34  *** DDR [] has quit [Read error: Operation timed out]
21:42:41  <Xaroth|Work> why would object creation interface change?
21:42:47  <andythenorth> because stuff does
21:42:50  <andythenorth> mistakes
21:42:54  <andythenorth> errors of judgement
21:43:37  <Xaroth|Work> yeh but that usually happens before you get to a large codebase.. else it's a refractor, at which point you'll want to look over those 40 files anyhow to make sure what you change doesn't fuck them over
21:43:47  <Xaroth|Work> (plus, a search+replace can do a lot of things as well)
21:45:12  <andythenorth> also it just seems ugly to 'import GraphicsProcessorMakeBodyRedExtendLoadStatesToMatchRefittableCargosChangeCompanyColourToSecondCompanyColour'
21:45:31  <Xaroth|Work> why not use mixins?
21:45:59  <andythenorth> I could, but now every vehicle is also importing the mixins
21:46:10  <Xaroth|Work> import the module, not every class directlly?
21:46:18  <andythenorth> things that are supposed to act like (quite smart) configuration files start to know too much
21:46:22  <Xaroth|Work> from X import Y,Z,A,B vs import X; X.A
21:47:20  <andythenorth> I don't have any justification basically
21:47:34  <andythenorth> I am going to end up with a mess of nasty string names, instead of a mess of nasty module names
21:47:43  *** Pereba [~UserNick@] has joined #openttd
21:47:50  <andythenorth> and with a bit much abstraction between the first calls, and the final result
21:53:35  *** adf88 [] has joined #openttd
21:54:47  <Eddi|zuHause> <andythenorth> none of them seem to do anything that requires anything more than a method <-- if you have a class, you can do things like make a list of all objects created and stuff
21:54:57  <andythenorth> ah :)
21:54:59  <andythenorth> history :)
21:55:14  <andythenorth> so you could also enforce object reuse if you wanted?
21:55:15  <Eddi|zuHause> but yes, in the simple cases a function may be enough
21:55:22  <Eddi|zuHause> yes
21:56:18  <andythenorth> thanks
21:56:43  <Eddi|zuHause> also, you might want to instantiate several factories (like one for each thread)
21:57:32  <Xaroth|Work> Eddi|zuHause: i see nothing that you can't do without factories in python :P
21:57:56  <Eddi|zuHause> Xaroth|Work: then you really haven't seen a lot of things :p
21:58:11  <Xaroth|Work> I've seen enough things
22:06:53  *** DarkAce-Z [] has quit [Ping timeout: 480 seconds]
22:09:31  *** DarkAce-Z [] has joined #openttd
22:12:34  *** DDR [] has joined #openttd
22:14:10  *** taede [] has quit [Remote host closed the connection]
22:17:39  *** DarkAce-Z [] has quit [Ping timeout: 480 seconds]
22:18:13  *** andythenorth [] has left #openttd []
22:22:06  *** sla_ro|master [slamaster@] has quit []
22:40:00  *** frosch123 [] has quit [Quit: be yourself, except: if you have the opportunity to be a unicorn, then be a unicorn]
22:53:07  *** gelignite [] has quit [Quit:]
22:56:48  *** valhallasw [] has quit [Ping timeout: 480 seconds]
23:33:47  *** adf88 [] has quit [Quit: adf88]
23:36:12  *** Supercheese [~Superchee@] has joined #openttd
23:37:06  *** Devroush [] has quit []

Powered by YARRSTE version: svn-trunk