IRC log for #bzflag on 20070816

`00:03.38`	`Epyon`	`FINALLY`
`00:04.25`	`TD-Linux`	`Epyon, now add louman's trees`
`00:04.39`	`Epyon`	`o.O?`
`00:05.02`	`Epyon`	`Ah, no not yet :P`
`00:05.29`	`Epyon`	`I want the geometry definition files running first :P`
`00:05.52`	`*** join/#bzflag Theme97 (n=Theme97@about/essy/phpwriter/Theme97)`
`00:06.45`	`TD-Linux`	`then add louman's trees.`
`00:06.49`	`TD-Linux`	`Want me to make a fountain for yoU?`
`00:06.54`	`TD-Linux`	`and some objects?`
`00:07.01`	`TD-Linux`	`streetlamps, etc?`
`00:07.31`	`Epyon`	`Would be nice, but I don't know how much time I will have left for polish :)`
`00:07.51`	`TD-Linux`	`once you have geometry definition files, won't it be easy?`
`00:08.11`	`TD-Linux`	`I suppose that itself will take quite a while.`
`00:08.29`	`blast007`	`it can always be something for after the 20th ;)`
`00:08.46`	`Epyon`	`True :)`
`00:09.00`	`Epyon`	`Aaah, that's needed!`
`00:09.13`	`tannerld`	`Epyon: cupcakes come later`
`00:09.20`	`Epyon`	`:P`
`00:09.43`	`Epyon`	`Funny, all is well except that unistd.h`
`00:09.51`	`Epyon`	`once I cut it out it compiles o.O`
`00:10.46`	`Epyon`	`Funny thats a unix header`
`00:17.30`	`JeffM`	`well those won't work on nix`
`00:17.33`	`JeffM`	`on windows I mean`
`00:17.51`	`JeffM`	`what is this buffalow thing building for you anyway?`
`00:18.36`	`Epyon`	`JeffM, this seems a bug in the windows nix utils. You think it would be ok to workaroud it by supplying an empty "unistd.h" file?`
`00:18.49`	`JeffM`	`#def it`
`00:18.52`	`Epyon`	`A parser/lexer for the geometry`
`00:18.58`	`JeffM`	`#ifndef _WIN32`
`00:19.08`	`JeffM`	`windows has unix utils?`
`00:19.21`	`Epyon`	`JeffM, I can't I don't control the lexers output file`
`00:19.43`	`jude-`	`JeffM: yup`
`00:19.48`	`Epyon`	`Found it here : http://unxutils.sourceforge.net/`
`00:20.06`	`Epyon`	`The up side is that they are not dependent on cygwin`
`00:20.13`	`JeffM`	`eww`
`00:20.46`	`JeffM`	`what does this magic code need that windows does not have?`
`00:20.56`	`JeffM`	`and what does it do for you?`
`00:21.08`	`Epyon`	`What do you mean?`
`00:21.18`	`JeffM`	`what feature does this give you?`
`00:21.30`	`JeffM`	`and are all other features done?`
`00:21.44`	`Epyon`	`The ability to seperate the definition of the grammar that generates the buildings from the code.`
`00:21.58`	`JeffM`	`in enlish please`
`00:22.00`	`Epyon`	`see last post : http://bzflag.chaosforge.org/`
`00:22.02`	`JeffM`	`what does it let a end user do?`
`00:22.16`	`JeffM`	`scripting?`
`00:22.47`	`Epyon`	`Hmm, how can I easily explain that :/`
`00:23.02`	`JeffM`	`if you can't explain it, how are people suposed to use it ? :)`
`00:23.21`	`Epyon`	`It allows for a much more concise, readable, and simple way to define how buildings randomly "grow"`
`00:23.25`	`JeffM`	`I mean your not suposed to be making a world modeler`
`00:23.46`	`Epyon`	`Yep, but this is a form of a L-system :)`
`00:23.48`	`JeffM`	`so defining the paramaters`
`00:24.04`	`JeffM`	`a simple paramater list won't work?`
`00:24.10`	`Epyon`	`Nope.`
`00:24.24`	`Winny`	`dunno if it has been suggested, or if it even being done, but why not make the random map gen a plugin for BZWB?`
`00:24.47`	`Epyon`	`It's a formal grammar. Try typing that readably in a computer grammar :)`
`00:24.57`	`Epyon`	`computer program*`
`00:25.41`	`JeffM`	`so it can execute logic?`
`00:25.46`	`JeffM`	`like a script then`
`00:25.47`	`JeffM`	`right?`
`00:25.52`	`Epyon`	`Anyway the snippet there written is actually in the code now but using C++ instead of this grammar. It takes 80 lines and is completely unreadable.`
`00:25.58`	`Epyon`	`Right.`
`00:26.06`	`JeffM`	`then why not just use an existing script langauge`
`00:26.12`	`JeffM`	`why go thru ALL this crap to do your own`
`00:26.13`	`Epyon`	`SIGH`
`00:26.18`	`JeffM`	`bust out lua or python`
`00:26.41`	`Epyon`	`Do they treat programs like formal grammars? Nope.`
`00:26.46`	`JeffM`	`does your stuff have any advantage? other then seemingly being a pain inthe ass to implemnt`
`00:26.51`	`JeffM`	`Epyon, why is that important`
`00:26.57`	`JeffM`	`if you can GET the def done, who gives a crap`
`00:27.05`	`Epyon`	`It's... TADAAAA the way the academics do it ;]`
`00:27.15`	`JeffM`	`ok, then you fail`
`00:27.33`	`JeffM`	`you are in a production environment`
`00:27.35`	`JeffM`	`not school`
`00:27.37`	`JeffM`	`this is your JOB`
`00:27.52`	`Epyon`	`See any paper on procedural geometry generation.`
`00:27.54`	`JeffM`	`that text is basicly just another langauge someone has to learn`
`00:27.59`	`JeffM`	`Epyon, I don't care about papers`
`00:28.02`	`JeffM`	`I care about results`
`00:28.08`	`JeffM`	`this is the real world`
`00:28.13`	`Epyon`	`brlcad cares about the academic side ;]`
`00:28.27`	`JeffM`	`not to the detrement of real world useablitlty`
`00:28.41`	`JeffM`	`and cut out the smily crap this is seriouys`
`00:28.56`	`Epyon`	`Anyway, this is not a programing language anyway, this is string rewriting.`
`00:29.03`	`JeffM`	`honsely what useablilty features, from a real world end users does this give?`
`00:29.33`	`Epyon`	`The ability to most simply define other building growth methods.`
`00:29.53`	`JeffM`	`using some set of keywords/language that your making up?`
`00:30.10`	`JeffM`	`I mean that stuff in your post, looks like no language I know`
`00:30.57`	`Epyon`	`That's the whole point.`
`00:31.01`	`Epyon`	`It's not a language.`
`00:31.07`	`Epyon`	`Imagine more "a set of rules"`
`00:31.15`	`JeffM`	`its words I have to type to describe something`
`00:31.18`	`JeffM`	`that is a LANGUAGE`
`00:31.21`	`JeffM`	`in a general sense`
`00:31.26`	`JeffM`	`not a programing language`
`00:31.32`	`JeffM`	`I'm an end user, NOT a programer here`
`00:32.04`	`JeffM`	`no mater what, the words and formating you use, has to be learned`
`00:32.18`	`JeffM`	`and since your not basing it off anything else, it's something totaly new that has to be learned`
`00:32.23`	`Epyon`	`Okay, let me tell you that -- typing the same ruleset that would give the same effects in Lua or any other scripting language would give you a text 10 times as large with plenty of ifs and elses.`
`00:32.35`	`JeffM`	`but it could be done`
`00:32.38`	`JeffM`	`size maters not`
`00:32.44`	`Epyon`	`http://en.wikipedia.org/wiki/L-system <- this is basicly on what it's based.`
`00:32.46`	`JeffM`	`so your doing all this to be 'slick"`
`00:32.55`	`JeffM`	`and you can't explain wy`
`00:32.58`	`Epyon`	`Size will make them unreadable, and unmaintainable.`
`00:32.58`	`JeffM`	`I understand`
`00:33.04`	`JeffM`	`is ALL other features done?`
`00:33.22`	`Epyon`	`JeffM, have you read my timeline?`
`00:33.25`	`JeffM`	`no`
`00:33.32`	`JeffM`	`that is why I'm asking you`
`00:33.48`	`Epyon`	`I'm behind schedule, but this is a 1/2 of the rest`
`00:34.14`	`JeffM`	`would you be further along if you had used an existing langauge?`
`00:34.25`	`JeffM`	`even if it wouldn't have been as prety and slick?`
`00:34.29`	`Epyon`	`Anyway, once this is in place I can produce additional building styles in a tempo of say 5 per hour.`
`00:34.41`	`Epyon`	`No I would not.`
`00:35.02`	`JeffM`	`the application itself sould not/does not depend on data to input to it`
`00:35.06`	`Epyon`	`I would be working now on getting proper interface for the language set up :P`
`00:35.17`	`Epyon`	`Who said that?`
`00:35.24`	`JeffM`	`you were hired to write an app`
`00:35.31`	`JeffM`	`the app is to be used by people`
`00:35.38`	`JeffM`	`people can define more rules later`
`00:35.42`	`Epyon`	`So?`
`00:35.52`	`Epyon`	`So you tell me this :`
`00:35.59`	`JeffM`	`if the app is not done, then people can not use it`
`00:36.11`	`Epyon`	`Don't write a way for people to define more rules later. Hardcode more things inside.`
`00:36.14`	`JeffM`	`I just want to make sure your not puting off other features that need to get done.`
`00:36.32`	`JeffM`	`just so you can make some slick demo rules`
`00:36.34`	`Epyon`	`JeffM, this is THE feature that was to be done.`
`00:36.37`	`JeffM`	`ok`
`00:36.40`	`JeffM`	`good enogh then`
`00:37.24`	`Epyon`	`It's both in my Google application, as well as in my timeline, as well as what was discussed with brlcad before and during the program`
`00:37.36`	`JeffM`	`brlcad is not the only developer in the project`
`00:37.44`	`JeffM`	`we are suposed to treat you as a normal dev`
`00:37.53`	`JeffM`	`brlcad is not a god`
`00:38.11`	`Epyon`	`The purpose of this is to provide an easy and efficient way to write rules for procedural geometry. The APP not the DATA or EFFECTS.`
`00:38.22`	`JeffM`	`if your saying that the rest is done, and your doing parametric building defs from external sources, hey that's fine.`
`00:38.32`	`JeffM`	`Epyon, I understand that now`
`00:38.44`	`Epyon`	`If you think that I should be adding louman's trees instead then go ahead, tell me that.`
`00:38.55`	`JeffM`	`naw, leave that up to end users`
`00:39.13`	`JeffM`	`I just wanted to make sure you didn't have other outstanding issues like "oh make it save"`
`00:39.18`	`JeffM`	`or other core features`
`00:39.23`	`JeffM`	`if this is the last one, hey great`
`00:40.12`	`JeffM`	`I'm not convinced of the reasoning for making your own definition languge, but I'm not that competent on what other languages can do. it's a minor point`
`00:40.15`	`Epyon`	`It's not the last one actually, it's the primary one. I've been laying groundwork and writing methods for it up to now.`
`00:40.21`	`JeffM`	`just being able to define them paramatericly is good`
`00:40.34`	`JeffM`	`others can make other interfaces instead of your current system later if needed.`
`00:40.46`	`*** join/#bzflag QuantumBeep (n=QuantumB@doc-24-32-46-104.leesville.la.cebridge.net)`
`00:40.49`	`JeffM`	`well there are no other core features that are waiting right?`
`00:41.03`	`JeffM`	`like big ones`
`00:41.16`	`TD-Linux`	`trees`
`00:41.20`	`DTRemenak`	`this is kinda the core feature, JeffM...procedural map generation. as I understand it, he's defining his own grammar primarily in order to save himself time.`
`00:41.30`	`JeffM`	`DTRemenak, I get that`
`00:41.45`	`JeffM`	`that's why I say it's a minor point, and if need be, we can replace it later`
`00:41.52`	`JeffM`	`external rules are good`
`00:41.52`	`Epyon`	`There is but I don't know if I'll make it. It's the road network that is defined by... another L-system :PPPPP`
`00:42.17`	`JeffM`	`trees are just a rule to inssert a mesh`
`00:42.26`	`JeffM`	`so you need rules to get trees :)`
`00:42.29`	`DTRemenak`	`the stuff he has left basically depends on this stage anyway`
`00:42.35`	`JeffM`	`sounds like it`
`00:42.48`	`JeffM`	`what I don't like is the concept of including a "blank" file`
`00:43.05`	`JeffM`	`I mean so you used a tool to generate your parser, so edit it afterwords`
`00:43.06`	`Epyon`	`JeffM, try to understand me. I could raise the visual quality of the generated maps by 400% in one day. But that would be just more and more hacks. Instead of writing hacks I want to write a way to do it cleanly in one self-sufficient system. Isn't that logical?`
`00:43.11`	`JeffM`	`it jsut means your tool sucks :)`
`00:43.31`	`JeffM`	`Epyon, I' have said that having rules is good`
`00:43.42`	`JeffM`	`and I understand what your doing`
`00:43.42`	`Epyon`	`JeffM, sure. Bison and yacc sucks.`
`00:43.53`	`JeffM`	`I may not agree with your methods, but we can replace those later if need be`
`00:43.55`	`Epyon`	`Wierd that people use it anyway :P`
`00:43.59`	`DTRemenak`	`as for whether it's "the" right way to do it...well, I dunno, it's a bit beyond where I'm compotent. I think it's certainly the right direction.`
`00:44.36`	`JeffM`	`what I did not like is your insitance that acedemics is more important then real world useablitly. An aswer from you of "it's faster for me this way" makes a lot more sense then you harping about brclad.`
`00:45.16`	`DTRemenak`	`academics is what leads to real world usability. someone needs to TRY something before it's known whether it'll work IRL or not`
`00:45.16`	`Epyon`	`JeffM, sorry I got a little angry, but frankly, what you're now saying is equal to "I don't like your project for BZFlag, i think you should do another". All I have done up to date was to do this grammar now.`
`00:45.33`	`Epyon`	`DTRemenak, see my previous post on the blog xP`
`00:45.48`	`JeffM`	`Epyon, no like your prioject, I'm just questioning one of your small implementation choices`
`00:45.53`	`DTRemenak`	`Epyon: eep, haven't been keeping up on that`
`00:45.55`	`JeffM`	`people will question your implementations all the time`
`00:46.01`	`Epyon`	`small OMG.`
`00:46.16`	`Epyon`	`It's the core choice actually :P`
`00:46.19`	`JeffM`	`and if you can't explain it, then that makes it harder for otehrs to understand.`
`00:46.29`	`DTRemenak`	`people will question your core choices too :)`
`00:46.30`	`JeffM`	`remember you are part of a group`
`00:46.34`	`JeffM`	`indeed`
`00:46.45`	`JeffM`	`one day you will NOT be here to work on the code`
`00:47.03`	`JeffM`	`so it is common for other devs to try and understand the "why"`
`00:47.30`	`JeffM`	`I mean the maps your able to make parametricly are cool`
`00:47.43`	`JeffM`	`and trust me I know quite a bit about parmatric model definition ;)`
`00:47.48`	`JeffM`	`working with solds and stuff`
`00:48.32`	`JeffM`	`if you think banging on a yack and lex system is faster for you, fine`
`00:48.59`	`JeffM`	`I just hope it dosnt' end up being a hack itself`
`00:49.04`	`JeffM`	`and unmaintainable`
`00:49.16`	`JeffM`	`unmaintainable code tends to get ripped :)`
`00:49.21`	`Epyon`	`JeffM, those are the only tools that I know well that can be used to generate a parser. And you wouldn't want me to write a parser myself would you? :P`
`00:49.38`	`Epyon`	`THAT would be wasting time xP`
`00:49.42`	`JeffM`	`Epyon, like I said, you saying "it's faster for me" is a perfectly fine reason`
`00:49.46`	`JeffM`	`you just never said it like that`
`00:50.05`	`JeffM`	`I know speed is of the essence for you`
`00:52.28`	`Epyon`	`I actually started writing a rule parser, but once I realised that to extend the rule language somewhere in the future I will need to code in operator priority and the like, and that writing that parser will take me at least a 4-5 days, I reverted to using yacc lex. The only thing that I didn't know is the fact that the C++ version of yacc lex on windows works and is written a LOT worse than the TP Lex/Yacc used with FreePascal :P`
`00:52.45`	`DTRemenak`	`as far as maintainability goes, yacc and friends have the advantage of being well documented and pretty widely used in their field. granted, it's a small field, so they're something of niche tools.`
`00:53.13`	`DTRemenak`	`the gnu commandline tools almost universally suck on windows, Epyon`
`00:53.24`	`DTRemenak`	`that's one reason I wanted to make sure you could include`
`00:53.28`	`JeffM`	`Epyon, I care not about free pascal, mentioning it means nothing.`
`00:53.36`	`Epyon`	`DTRemenak, I didn't know that until I started to write C++ :P`
`00:54.01`	`jude-`	`heh--almost everything designed for UNIX sucks on Windoze`
`00:54.52`	`DTRemenak`	`...generated files for the other poor sobs on non-unixish systems`
`00:55.40`	`Epyon`	`I'll do that.`
`00:55.52`	`jude-`	`me too`
`00:56.24`	`Epyon`	`jude-, actually it hit me now -- what are you using to parse the bzw files?`
`00:56.30`	`jude-`	`my own code`
`00:56.33`	`JeffM`	`yeah just include the generated file, hack it up for windows.`
`00:56.37`	`JeffM`	`how often do you change it?`
`00:56.40`	`DTRemenak`	`yup, I know...if you would have said you couldn't, I'd have said "don't do it that way" :)`
`00:56.41`	`JeffM`	`when you add langauge stuff?`
`00:56.42`	`jude-`	`faster than dissecting BZFlag's parser`
`00:56.59`	`JeffM`	`bzflag's parser is wierd`
`00:56.59`	`Epyon`	`JeffM, currently I'm going to work a lot on changing it :P`
`00:57.13`	`JeffM`	`Epyon, and you develop on windows or nix?`
`00:57.23`	`Epyon`	`Windows :/`
`00:57.34`	`JeffM`	`hell get the soruce to the tool, mod it to put in the #def ;)`
`00:57.36`	`JeffM`	`that's probably faster`
`00:57.43`	`DTRemenak`	`bzflag's parser is really weird...that's the conclusion Mr.AC and I came to also :)`
`00:57.49`	`Epyon`	`Why would I be asking all those stupid VC questions`
`00:58.01`	`jude-`	`DTRemenak: I documented the interface for my BZWParser API on my blog if you're interested :)`
`00:58.04`	`*** join/#bzflag Constitution (n=Constitu@gateway.pct.civiltec.com)`
`00:58.09`	`JeffM`	`Epyon, didn't know if you had goten a nix install, and were just trying to be "nice" to windows users.`
`00:58.13`	`Epyon`	`JeffM, but that would mean that noone except me would be able to re-generate the lexer file :P`
`00:58.22`	`DTRemenak`	`you could be trying to build it on multiple systems, to ensure you had compatibility stuff down :)`
`00:58.31`	`Epyon`	`JeffM, I don't have time to be so nice xP`
`00:58.34`	`Constitution`	`Epyon: I g2g shortly, but I think you mentioned yesterday that changes are needed to the server?`
`00:58.36`	`JeffM`	`Epyon, document the chaes you make to the files :)`
`00:58.58`	`Epyon`	`Constitution, I would have implemented that already but I got into a flamewar with JeffM :P`
`00:59.00`	`JeffM`	`for a while there, I was the only one that could make fonts for BZ`
`00:59.11`	`DTRemenak`	`not too long`
`00:59.12`	`JeffM`	`Epyon, welcome to open source on the interent`
`00:59.22`	`Constitution`	`Epyon: okay, just wanted to make sure I didn't need to do something before I leave`
`00:59.36`	`JeffM`	`for this SOC, I'm playing the part of the gurmpy older developer`
`00:59.41`	`JeffM`	`every project has one`
`00:59.53`	`JeffM`	`at some point you should just shut them out :)`
`00:59.58`	`Epyon`	`Constitution, but probably the server wont be able to recompile the project after the next commit`
`00:59.59`	`DTRemenak`	`heh, playing the part huh... :P`
`01:00.06`	`JeffM`	`I take my parts seriously`
`01:00.12`	`JeffM`	`method acting, etc..`
`01:00.30`	`Epyon`	`Constitution, so you might freeze recompilation until someone makes a proper makefile that recompiles the lexer and yacc files.`
`01:00.45`	`Constitution`	`hmm, okay`
`01:01.33`	`Epyon`	`ping me tommorow, or day after so we can reenable it.`
`01:01.58`	`JeffM`	`DTRemenak, I think I found that post bug you had the other day :)`
`01:02.02`	`DTRemenak`	`sweet`
`01:02.08`	`Constitution`	`if it just won't compile, then the server won't have a problem`
`01:02.13`	`Constitution`	`it will continue to use the old binary`
`01:02.18`	`DTRemenak`	`what's the problem?`
`01:02.26`	`JeffM`	`thou shalt not put approach features for the next op into paths for this op's approach`
`01:02.33`	`DTRemenak`	`heh`
`01:02.43`	`JeffM`	`it was tacking on the first inter op feature for the NEXT op into the approach for this op :)`
`01:02.47`	`Epyon`	`Constitution, ah cool :D`
`01:02.55`	`DTRemenak`	`that would explain why it was noncontiguous :)`
`01:02.58`	`JeffM`	`yeah`
`01:03.09`	`JeffM`	`we used to tack them onto the end of this ops retract`
`01:03.23`	`Epyon`	`Constitution, then I will ping you in a while to ask you if it does compile :)`
`01:03.30`	`Constitution`	`okay, sounds good`
`01:03.37`	`JeffM`	`I was trying to put them on the next ops approach, but we haven't loaded that op yet :(`
`01:05.21`	`*** join/#bzflag bryjen (n=bryjen@2002:4cb1:b40f:0:0:0:0:1)`
`01:05.21`	`*** mode/#bzflag [+v bryjen] by ChanServ`
`01:08.25`	`*** join/#bzflag Tedius (n=Tedius@adsl-76-205-71-13.dsl.bcvloh.sbcglobal.net)`
`01:18.29`	`CIA-23`	`BZFlag: 03dtremenak * r14913 10/trunk/bzworkbench/ (include/windows/View.h windows/View.cpp): static members need to be initialized in the source file, not the header (haven't we been over this before? ;) )`
`01:18.59`	`CIA-23`	`BZFlag: 03dtremenak * r14914 10/trunk/bzworkbench/windows/eventHandlers/selectHandler.cpp: return a value, 'cause we theoretically get called.`
`01:22.20`	`JeffM`	`yay no more 8.5 bugs`
`01:22.35`	`JeffM`	`now to go decide what to call the Tangibility messages :)`
`01:22.50`	`JeffM`	`if this works, it should be prety damned cool :)`
`01:22.56`	`CIA-23`	`BZFlag: 03dtremenak * r14915 10/trunk/bzworkbench/MSVC/VC8/BZWorkbench.vcproj: add new files`
`01:23.06`	`JeffM`	`i'll let you do what is basicly doors for tanks`
`01:24.15`	`bryjen`	`~dict tangibility`
`01:24.55`	`JeffM`	`see it's a real word :)`
`01:25.02`	`DTRemenak`	`~dict 1 tangible`
`01:25.07`	`*** join/#bzflag Pimpi (n=frank@gondolin.pimpi.org)`
`01:25.10`	`JeffM`	`I think I can work it out so we can do material changes too`
`01:25.11`	`DTRemenak`	`bryjen: that help more?`
`01:25.19`	`bryjen`	`yes, and spelled correctly too ;)`
`01:25.20`	`JeffM`	`solidity`
`01:25.30`	`JeffM`	`yeah I spell checked it first :)`
`01:25.58`	`DTRemenak`	`yeah, for a bit he had "tangibility" (spellchecked) and "tangable" (not) :)`
`01:26.13`	`JeffM`	`just one function :)`
`01:26.33`	`JeffM`	`heh`
`01:29.12`	`jude-`	`DTRemenak: thanks for the additional vcproj files :)`
`01:29.31`	`DTRemenak`	`np`
`01:30.03`	`DTRemenak`	`should be back to actually building on windows now`
`01:30.31`	`DTRemenak`	`you've done a pretty good job at keeping it all portable`
`01:30.36`	`jude-`	`thanks :)`
`01:31.08`	`DTRemenak`	`heh, that thanks went the wrong direction :P`
`01:31.57`	`jude-`	`??`
`01:32.05`	`DTRemenak`	`I should be thanking you`
`01:32.12`	`CIA-23`	`BZFlag: 03chaos-dev * r14916 10/trunk/bzwgen/ (bzlgen.vcproj lexer.l parser.y): Fixed the parser to compile under VC`
`01:32.15`	`DTRemenak`	`portable code is a lot easier to deal with building on multiple platforms ;)`
`01:32.16`	`jude-`	`I'm thanking you for the complement :)`
`01:32.31`	`DTRemenak`	`ah. well, you're welcome :)`
`01:33.25`	`CIA-23`	`BZFlag: 03chaos-dev * r14917 10/trunk/bzwgen/rules/ (. test.set): Preliminary import.`
`01:33.29`	`jude-`	`btw, what does "G" mean in SVN?`
`01:33.36`	`DTRemenak`	`G?`
`01:33.40`	`DTRemenak`	`umm....no clue :)`
`01:33.43`	`jude-`	`"U" means updated, "A" means added, etc`
`01:33.46`	`DTRemenak`	`yeah`
`01:33.59`	`Epyon`	`Conflict?`
`01:34.04`	`DTRemenak`	`C`
`01:34.12`	`bryjen`	`svn help up says G = Merged`
`01:34.18`	`Epyon`	`I had a G somewhere too :P`
`01:34.44`	`jude-`	`that's it`
`01:34.50`	`jude-`	`thanks brygen :)`
`01:35.10`	`DTRemenak`	`UADRC are all pretty obvious. what do they use M for, that they couldn't use it for merge?`
`01:35.23`	`jude-`	`dunno`
`01:35.58`	`DTRemenak`	`gah, now I have to build osg again...release mode this time`
`01:36.13`	`*** join/#bzflag PeterBz (n=PeterBz@cpc2-derb1-0-0-cust324.lei3.cable.ntl.com)`
`01:37.07`	`blast007`	`;)`
`01:37.16`	`DTRemenak`	`I'm running out of chickens :S`
`01:37.35`	`blast007`	`Arise chicken! Arise!`
`01:37.56`	`jude-`	`make sure to hold the staff the right way :)`
`01:38.13`	`PeterBz`	`check out what happened to me today, ....`
`01:38.14`	`PeterBz`	`http://i187.photobucket.com/albums/x235/PETER_BZFlag/bzfi0182.png`
`01:38.54`	`delusional_`	`strange trivia I cant get out of my head... goats and octopii have rectangular pupils`
`01:41.19`	`jude-`	`PeterBz: put that link in the bugzilla :)`
`01:41.28`	`PeterBz`	`?`
`01:41.35`	`jude-`	`report a bug`
`01:42.02`	`*** join/#bzflag Tropican8 (i=user@unaffiliated/tropican8)`
`01:42.41`	`DTRemenak`	`just a too-deep burrow depth`
`01:42.42`	`DTRemenak`	`not a bug`
`01:44.51`	`delusional_`	`ummm, did someone say doors for tanks? JeffM perhaps? looking at the commit, it seems tanagability is a typo, I'm probably wrong though`
`01:45.11`	`JeffM`	`you are not wrong`
`01:45.31`	`delusional_`	`doors are a dream of mine`
`01:45.38`	`JeffM`	`they will not MOVE`
`01:45.41`	`JeffM`	`nothing rotating`
`01:45.48`	`JeffM`	`but basicly you can set drive thru on or off in realtime`
`01:46.01`	`delusional_`	`no swinging?`
`01:46.05`	`JeffM`	`nope`
`01:46.13`	`JeffM`	`can't have objects that rico shots, move`
`01:46.24`	`delusional_`	`well, thats twice today I got excellent news from this channel`
`01:46.38`	`JeffM`	`and you can't change shootthru dynamicly`
`01:46.41`	`JeffM`	`only drive thru`
`01:46.44`	`*** join/#bzflag VM12345 (n=VM@dhe-vpn-179-152.duhs.duke.edu)`
`01:46.46`	`delusional_`	`ah`
`01:47.13`	`blast007`	`that would make for fun mazes via a plugin ;)`
`01:47.15`	`JeffM`	`shots don't send out updates`
`01:47.32`	`JeffM`	`yeah if I can make it so you can change the material with a message, then you can make objects apear and disapear`
`01:47.37`	`JeffM`	`and do like force field doors`
`01:47.48`	`delusional_`	`there ya go!`
`01:47.49`	`JeffM`	`I'm also making it so you can specify teams for drive thru`
`01:47.59`	`delusional_`	`nice`
`01:48.05`	`JeffM`	`so make a door that is only passable by red`
`01:48.17`	`blast007`	`JeffM: trepan had some map where object materials were tied to custom BZDB variables`
`01:48.27`	`JeffM`	`yeah I'm sure he did`
`01:48.29`	`blast007`	`was a modified bzfs, of course`
`01:48.36`	`JeffM`	`this is a real message`
`01:48.41`	`JeffM`	`cus one var won't do it`
`01:48.45`	`DTRemenak`	`nasty hack too. don't blame him for not committing that one :)`
`01:48.58`	`JeffM`	`every solid world object now has an ID`
`01:48.58`	`blast007`	`yeah... from what I can tell, it must have had to resend the whole world database`
`01:49.13`	`JeffM`	`so we can use that ID in messages.`
`01:49.34`	`JeffM`	`assuming you don't have more then 65768 objects of any one type`
`01:49.35`	`blast007`	`JeffM: can the ID be specified in the map file itself?`
`01:49.37`	`JeffM`	`no`
`01:49.51`	`JeffM`	`but from the API you can get the ID for any named objcet`
`01:49.56`	`JeffM`	`so name it something special`
`01:49.59`	`blast007`	`ah, okay, that's fine`
`01:50.03`	`JeffM`	`then in the API get that ID, and go to town :)`
`01:50.15`	`PeterBz`	`just a suggestion, how about making it so only certain players can go through an object,`
`01:50.22`	`JeffM`	`BZF_API unsigned int bz_findWorldObject ( const char *name );`
`01:50.35`	`JeffM`	`PeterBz, I'm doing teams, if you didn' read it`
`01:50.50`	`JeffM`	`there is no logical reason to do per player`
`01:51.05`	`JeffM`	`too much to maintain for per player`
`01:51.22`	`*** part/#bzflag Tropican8 (i=user@unaffiliated/tropican8)`
`01:51.39`	`JeffM`	`mostly it's an excuse to have ServerIntangibilityManager.cxx :)`
`01:51.45`	`blast007`	`:)`
`01:51.54`	`delusional_`	`no "drive over this object to open door" object`
`01:52.06`	`delusional_`	`?`
`01:52.29`	`blast007`	`delusional_: plugins are what will be used to control the drivethrough stuff, so yes, you can`
`01:52.32`	`JeffM`	`that needs zones`
`01:52.34`	`blast007`	`just track player positions`
`01:52.42`	`delusional_`	`ok`
`01:52.55`	`JeffM`	`well yeah, you can do collision checks in plug-ins now`
`01:52.58`	`JeffM`	`but zones would be better`
`01:53.02`	`blast007`	`k`
`01:53.09`	`a_meteorite`	`checking zones would be awesome`
`01:53.19`	`JeffM`	`server size zones would not be too bad right now`
`01:53.20`	`a_meteorite`	`*if a tank is in a zone`
`01:53.28`	`JeffM`	`you'd want to have the client send a message too`
`01:53.37`	`JeffM`	`just to get the close edges and stuff`
`01:53.43`	`delusional_`	`yeah.. like one player sits on the zone, to open the door for another.`
`01:54.04`	`PeterBz`	`wasn't bzflag suposed to stay simple?`
`01:54.06`	`JeffM`	`you could do that with an object right now`
`01:54.22`	`JeffM`	`PeterBz, it's not a change to the rules, it lets map devs do more stuff`
`01:54.26`	`Epyon`	`JeffM, how do I pass a file in another dir to COSFile?`
`01:54.28`	`JeffM`	`it' still simple`
`01:54.37`	`JeffM`	`Epyon, what do you mean? do a copy?`
`01:54.48`	`JeffM`	`or change what file path it points to?`
`01:54.53`	`Epyon`	`no, what slashes to use :P`
`01:54.56`	`JeffM`	`unix`
`01:55.13`	`Epyon`	`"rules/test.set"?`
`01:55.13`	`JeffM`	`see wasn't that the better question? :)`
`01:55.18`	`JeffM`	`yeah /`
`01:55.19`	`JeffM`	`unix`
`01:55.22`	`Epyon`	`kk`
`01:55.26`	`Epyon`	`thanks`
`01:55.32`	`JeffM`	`it knows how to convert internaly based on the OS`
`01:56.02`	`Epyon`	`BTW, I can use that COSDir to get sequentialy all files in a given dir, right?`
`01:56.10`	`JeffM`	`yup`
`01:56.13`	`JeffM`	`on any OS :)`
`01:56.15`	`Epyon`	`Nice :D`
`01:56.15`	`a_meteorite`	`can't you technically use a forward slash instead of a back slash on windows?`
`01:56.26`	`JeffM`	`on some versions, yes`
`01:56.34`	`a_meteorite`	`ah`
`01:56.39`	`Epyon`	`I can use them here, and usualy I stick to them.`
`01:56.49`	`a_meteorite`	`tis easier for me, cause I'm used to nix :)`
`01:56.56`	`a_meteorite`	`always forget where the \ key is :D`
`01:57.11`	`Epyon`	`I'm used to Windows, but / looks tidier IMHO :P`
`01:57.28`	`Epyon`	`It's more optimistic going up then going down xP`
`01:58.20`	`a_meteorite`	`heh`
`02:00.52`	`Epyon`	`Great it parses :D`
`02:01.49`	`JeffM`	`is the plural of Tangibility, Tangibilities ?`
`02:02.24`	`CIA-23`	`BZFlag: 03chaos-dev * r14918 10/trunk/bzwgen/lexer.l: Added line number on error and the forgotten art to parse also negative numbers.`
`02:05.08`	`*** join/#bzflag VM1234 (n=VM@adsl-065-013-159-245.sip.rdu.bellsouth.net)`
`02:05.19`	`PeterBz`	`one thing I was interested to find out was, will you fix the mouse box, the top an bottem line of both the outer box and inerbox are one pixel to the right`
`02:05.20`	`delusional_`	`palpable, corporeal... the quality of being perceivable by touch`
`02:05.28`	`Epyon`	`JeffM, does GetNextFile also return the . and .. ?`
`02:05.47`	`JeffM`	`it should skip them`
`02:05.56`	`JeffM`	`they are not files`
`02:06.10`	`Epyon`	`On nix everything is a file -_-`
`02:06.30`	`JeffM`	`they are not files on all OSs`
`02:06.39`	`Epyon`	`Valid point :)`
`02:07.07`	`DTRemenak`	`they aren't even files on nix, they're just directory entries`
`02:21.39`	`CIA-23`	`BZFlag: 03JeffM2501 * r14919 10/trunk/bzflag/ (10 files in 2 dirs): send and use ServerIntangibilityManager when Tangibility is in question.`
`02:21.44`	`Epyon`	`JeffM, http://pastebin.ca/659059 do you see anything wrong here?`
`02:23.41`	`JeffM`	`you may need a / somewhere`
`02:23.43`	`JeffM`	`I don't recall`
`02:23.46`	`Epyon`	`yyin is NULL after this o.O`
`02:23.55`	`JeffM`	`let me check a use of it`
`02:24.00`	`JeffM`	`it's been a while :)`
`02:24.23`	`Epyon`	`It correctly gives the name but the file.GetFile() returns NULL :/`
`02:24.40`	`JeffM`	`oh you want the file pointer?`
`02:24.47`	`JeffM`	`like you want it to fopen it?`
`02:25.01`	`JeffM`	`usualy I use the class to do reads`
`02:25.13`	`Epyon`	`Yep I want to open it`
`02:25.31`	`JeffM`	`and you want a FILE* pointer?`
`02:25.49`	`JeffM`	`or do you want the contents of the file as a big ass string?`
`02:25.53`	`Epyon`	`Ok it worked :D`
`02:26.03`	`JeffM`	`the file was open elsewhere?`
`02:26.17`	`Epyon`	`I added file.Open("r"); before GetFile xP`
`02:26.43`	`Epyon`	`Stupid me, I do not know why assumed they were opened when returned :P`
`02:26.54`	`JeffM`	`yeah we need to know how to open them`
`02:26.58`	`JeffM`	`make sure you close it too`
`02:28.49`	`CIA-23`	`BZFlag: 03chaos-dev * r14920 10/trunk/bzwgen/bzwgen.cxx: bzwgen now scans the rules directory and parses all found files. Not that that does anything yet xP`
`02:29.06`	`Epyon`	`Yep I close them :)`
`02:29.38`	`Epyon`	`Ok, that's it for today, I'm tired and it's 4:40 in the morning. Time for a beer and to sleep.`
`02:31.26`	`bryjen`	`JeffM: should the "if (id = 0)" at the top of src/bzfs/bzfsAPI.cxx:bz_getWorldObjectByID() be a == ?`
`02:31.43`	`JeffM`	`yeah :)`
`02:32.28`	`Epyon`	`Aaah the mother of all C errors xP. It took me about half a year until I stopped doing that one on every other occasion xP`
`02:33.18`	`Epyon`	`Especialy because I used to write if (id = 0) all my life xP`
`02:44.55`	`CIA-23`	`BZFlag: 03bryjen * r14921 10/trunk/bzflag/src/bzfs/bzfsAPI.cxx: more equal`
`03:19.43`	`*** join/#bzflag PrezKennedy (n=Matt@74.86.45.130)`
`03:30.25`	`Epyon`	`There was a flamewar between me and JeffM if you mean that one xP`
`03:30.43`	`brlcad`	`i wouldn't call that a flamewar from what I've just read`
`03:31.12`	`Epyon`	`So what's your opinion on the topic? :)`
`03:31.21`	`brlcad`	`which one?`
`03:31.35`	`brlcad`	`i see a couple hours discussion`
`03:31.46`	`Epyon`	`The "useless usage of flex/yacc" one xP`
`03:32.02`	`Epyon`	`And "who needs grammars"`
`03:32.04`	`brlcad`	`i care about the academic side, but it does NOT (ever) trump the practical side (at least here)`
`03:33.06`	`Epyon`	`It's not the point, actually. I added it in the fever of discussion. I already learned the hard way that the academic results are not practical :P`
`03:33.45`	`brlcad`	`to play the devil's advocate, usage of a lexer/parser is not requisite to implementing what you needed -- there are many ways that would have been perfectly acceptible without the complexity that is introduced`
`03:34.14`	`brlcad`	`so i gather his question was more "why this approach"`
`03:34.57`	`brlcad`	`I had similar thoughts when I saw the commit, and I already knew what your goal is`
`03:37.47`	`brlcad`	`from the practical side, if the user needs to care about your particular new file format (ever), then the utility of the tool to the game is going to be greatly diminished -- the benefit/goal is the ability to generate detailed worlds automatically (with procedurally being the driving approach that's been sung to date)`
`03:38.30`	`Epyon`	`Yep, it can be done without it. It's just a question of http://pastebin.ca/659118 versus http://pastebin.ca/659123`
`03:38.33`	`brlcad`	`that is, a user says that they want an automatically generated world, and after a few parameters are provided, a world is available`
`03:39.35`	`Epyon`	`Actually I plan to provide as much data as possible for the generator, just it's a LOT easier, cleaner and faster to do it with a dedicated grammar than in C++`
`03:40.12`	`Epyon`	`So the "file format" from the users view may be considered as "code" that he wouldn't touch anyway.`
`03:42.11`	`brlcad`	`yes, this is true though the concerns extend to maintainers and other devs too`
`03:42.35`	`Epyon`	`Actually I didn't consider allowing the user to touch those files anyway :P. For the "user" there will be a "config" file (standard variables) that he will be able to tweak to his liking. He may think about the rulesets if he's bold enough but he will be able to achieve very different flavoured results through the config files alone`
`03:44.16`	`brlcad`	`the C++ is verbose, but it's frankly very simple to read and requires no new knowledge -- adding a custom syntax is brief but know someone has to understand the lexer/parser semantics in order to change/use it and the format is inherintly a subset of what you could do in a full fledged language`
`03:45.12`	`brlcad`	`I get the reasoning, the comments are more from the practical maintainability -- if you're going to make your own format then that is more responsibility on your part to document that format and how it's parsed/used`
`03:45.25`	`brlcad`	`and what all the limitations and usage scopes are`
`03:45.31`	`Epyon`	`Well to be honest I'm getting lost in that C++ one xP`
`03:45.39`	`*** join/#bzflag JeffM (n=JeffM@unaffiliated/jeffm)`
`03:46.12`	`Epyon`	`brlcad, you get my promise that you'll get full user-level documentation for the language :P`
`03:46.30`	`Epyon`	`Although not neccessarily before the 20th deadline :/`
`03:46.32`	`brlcad`	`i actually understand the C++ one right away, the condensed format leaves me with ton's of questions if I had to actually use it`
`03:47.33`	`JeffM`	`how's it hangin brlcad`
`03:47.34`	`Epyon`	`brlcad, actually it's quite simple once you stop thinking about it as a program and think as a grammar of consecutive operations, where the non-terminals are faces.`
`03:47.58`	`brlcad`	`JeffM: been better, headache and still recouperating from the two weeks of drunken debachery`
`03:50.04`	`brlcad`	`Epyon: that still doesn't tell me what the format requirements are, even seemingly trivialities like what the meaning of the : is, whether you can have whitespace around it, what's the arrow, are braces comments are are they labels, is it case sensitive, what are all the "operations" I have to choose from, etc etc`
`03:50.20`	`brlcad`	`of course each can be answered -- the point is that I have to ask at all`
`03:51.33`	`Epyon`	`The counterpoint is that once answered it is easy enough that someone without programming knowledge could tinker with it after reading a guide :P`
`03:51.45`	`brlcad`	`I'm not saying it's a bad thing, but that's where there's definitely a massive tradeoff going on for the practical side (and that didn't even get into the headaches of getting cross-platform lexer/parser generation working) to where it will just need to be stellar`
`03:53.02`	`brlcad`	`if someone was tinkering with it a lot, then there's where the tradeoff starts to pay off .. that, however, is not the case today so it seems on the surface to be added complexity for little overall gain`
`03:53.42`	`Epyon`	`Anyway, imagine that it's hidden from the user, and take a look at the immidate effects that it will give the day after tommorow, and then we can start talking about it from the dev side :P`
`03:53.43`	`brlcad`	`i'm not saying get rid of it, you already got it in there -- but had you not had a week to go, it would be serious consideration criteria`
`03:55.31`	`brlcad`	`i mean, i would have been way more inclined to something even less condense, but more familiar/common -- like in an existing language like python or tcl or perl even`
`03:55.33`	`Epyon`	`All i was doing up to date was to get that in finally. The mesh class is the set of tools that were needed for that, and the BuildZone class is just a test if the tools work. I planned that from the beggining so I feel kinda wierd when at the end someone tells me that "this idea is wrong" :/`
`03:55.53`	`JeffM`	`HAH, brlcad is thinking the same thing I was :)`
`03:56.10`	`brlcad`	`JeffM: just continuing your discussion from earlier, kinda in response to it`
`03:56.48`	`brlcad`	`Epyon: it's not the idea, it's the approach, which is all really just dev discussion`
`03:57.34`	`brlcad`	`should always be able to defend your ideas on their merits, not on preference or plans, even if it seems obvious to you :)`
`03:57.49`	`brlcad`	`others ideally will WANT to work with your code down the road`
`03:58.07`	`Epyon`	`brlcad, I studied a lot of those papers and despite that I was seriously dissapointed in the practical (mesh-perfect) usage of it, I understood why all the generators were given in "grammar-form". So I knew I had to do it that way. If done in python or lua, you'd just have the same C++ mess I've pasted you (and believe me, I did a lot already to make that C++ readable).,`
`03:59.20`	`Epyon`	`Well the plan is to make good-enough results so the people will want to understand them. Once they do, they'll see that it's the better way ;]`
`03:59.49`	`JeffM`	`ahh the church method`
`04:00.35`	`JeffM`	`Epyon, you forget that others will hit your code, if they don't like it, or can't use it, and still want to use your app, they'll just rip it out`
`04:00.47`	`JeffM`	`and slap a python shell on it ;)`
`04:01.03`	`Epyon`	`But on one thing I have to confess, and agree with JeffM that it's my guilt and fault. I used this project to put the academic ways into implementation, and I was more concerned in learning and using the current research results, then treating this as a job to be done :/`
`04:01.58`	`Epyon`	`JeffM, with 30 rules files, it would take a lot of wasted time to translate them xP`
`04:02.04`	`JeffM`	`j00 gotz 2 p4yz t3h billz!`
`04:02.18`	`brlcad`	`i don't quite believe that the c++ couldn't be more condensed, compared to the grammar -- there's a lot of simplification that was added to that grammar that you didn't carry over`
`04:02.23`	`JeffM`	`Epyon, it would not be wasted if more people moded them after :)`
`04:02.34`	`Epyon`	`But sure, if they want it, go ahead, I'd like to see the results :)`
`04:02.38`	`JeffM`	`remember in opensource, there is infinate time for refactoring :)`
`04:03.39`	`Epyon`	`brlcad, maybe. But implementing it I think the grammar way anyway.`
`04:03.45`	`brlcad`	`and that refactoring will happen by dozens of people other than you that have maybe 10% the invested knowledge you had when you wrote it (sometimes you get lucky and they learn more), but almost always for their specific purpose`
`04:04.16`	`JeffM`	`and maybe others are better at python then you think and to them the lenght isn't an issue`
`04:04.27`	`JeffM`	`some things make more sense when verbose`
`04:05.19`	`Epyon`	`Sure :P. But that's also the nature of open source, that the one that has the will to do something is also the one to make the decisions xP`
`04:05.31`	`brlcad`	`yeah, -- without knowing anything about either, I definitely understand that C++ with all its verbosity but not everything I need to know to use the grammar :)`
`04:05.50`	`brlcad`	`heh, not always`
`04:05.57`	`JeffM`	`Epyon, I make such a big point about it because we have SEEN this same thing happen`
`04:06.03`	`JeffM`	`look at stuff in our map`
`04:06.11`	`JeffM`	`it was made to be short and logical`
`04:06.16`	`JeffM`	`NOONE gets it`
`04:06.19`	`JeffM`	`and nooone uses it`
`04:06.26`	`Epyon`	`JeffM. it's not logical.`
`04:06.30`	`JeffM`	`to you`
`04:06.36`	`JeffM`	`it all makes sense to me`
`04:06.41`	`brlcad`	`decision making is definitely not just in the folks doing the work, it's also in the folks that have done the work -- investment of time and effort, meritocracy and consensus, etc`
`04:06.42`	`Epyon`	`Basically because not everything follows the same rules :/`
`04:06.47`	`JeffM`	`but not everyone knows what a normal is`
`04:06.50`	`Epyon`	`And the documentation is lacking :/`
`04:06.51`	`JeffM`	`or a UV coord`
`04:06.57`	`JeffM`	`even when it' documented`
`04:07.11`	`JeffM`	`but hey, once again, your in your defensive mode`
`04:07.18`	`JeffM`	`so there is no point in talking to you about it`
`04:07.24`	`blast007`	`activate phasers!`
`04:07.27`	`Epyon`	`Oh, that does make sense. What doesn't is the order in which commands are issued.`
`04:07.52`	`brlcad`	`i know what a normal is .. it's something not abnormal`
`04:07.58`	`JeffM`	`heh`
`04:07.58`	`Epyon`	`xP`
`04:08.21`	`Epyon`	`Anyway... okay, I'll put it this way --`
`04:09.39`	`Epyon`	`Trust me, that I know what I'm doing. If you'll decide the 20th that I didn't, then just check that "No" box in the survey, and you'll make a big point, that will probably make me think about it twice :P`
`04:09.43`	`brlcad`	`JeffM: you've been .. busy`
`04:09.54`	`Epyon`	`You won't loose anything anyway :P`
`04:10.07`	`brlcad`	`yes we will/would`
`04:10.09`	`JeffM`	`wow, man... you are not a team player at all are you?`
`04:10.17`	`*** join/#bzflag BenUrban (n=benurban@unaffiliated/benurban)`
`04:10.21`	`JeffM`	`good luck finding a job wit that attitude`
`04:10.25`	`Epyon`	`JeffM, point taken, I confess :(`
`04:10.36`	`JeffM`	`brlcad, yeah, I need you to go over the font manager changes`
`04:10.42`	`DTRemenak`	`Epyon: what are you doing up at this hour anyway? weren't you going to bed a few hours ago?`
`04:10.52`	`Epyon`	`Can't sleep.`
`04:11.04`	`brlcad`	`he's .. busy explaining his design :)`
`04:11.10`	`JeffM`	`Epyon, I guess we are just dump people not in college. we'll go back to our holes now and bask in the glory of your perfect code that can't even be commented on.`
`04:11.16`	`DTRemenak`	`I think he'd make more sense when he's more awake :)`
`04:11.49`	`Epyon`	`I've got DSPS :/`
`04:11.57`	`brlcad`	`~dsps`
`04:12.27`	`JeffM`	`brlcad, there were a number of bugs in the font stuff, stuff like using a full path for a font name`
`04:12.27`	`JeffM`	`so we'd only ever load the first font`
`04:12.27`	`Epyon`	`brlcad http://en.wikipedia.org/wiki/Delayed_sleep_phase_syndrome`
`04:12.27`	`JeffM`	`the reload was jacked`
`04:12.31`	`JeffM`	`I made it more like texture manager`
`04:12.44`	`JeffM`	`where on a context invalidation it just blows out all the GL fonts`
`04:12.52`	`JeffM`	`then remakes them next time they are used`
`04:12.52`	`brlcad`	`JeffM: I knew about the first font thing, though I suspected that was a problem just in the loader`
`04:13.00`	`JeffM`	`the loader was fine`
`04:13.04`	`JeffM`	`it was in the CALLS to the loader`
`04:13.05`	`Epyon`	`JeffM, your sarcasm was not in place considering the fact that I confessed that I had that problem.`
`04:13.25`	`JeffM`	`Epyon, sometimes things fall out of place, you gotta learn to deal with it`
`04:13.31`	`brlcad`	`hrm, that's what reload was supposed to do already`
`04:13.41`	`JeffM`	`no it was FORCING them all to be rebuilt`
`04:13.58`	`JeffM`	`basicly getGLFont had a failsafe`
`04:14.04`	`JeffM`	`that would return the first font it can't find it`
`04:14.23`	`JeffM`	`and we used getGLFont a lot to see if the font was in there allready`
`04:14.29`	`brlcad`	`right, forcing them in that they were actually removed and destructed`
`04:14.31`	`JeffM`	`if it wasn't it would STILL return a valid font`
`04:14.41`	`brlcad`	`a bit agressive, but I was leaving that as an exercise for later`
`04:14.41`	`JeffM`	`brlcad, you were rescanning the dir and everyitng`
`04:14.53`	`brlcad`	`yep`
`04:14.57`	`JeffM`	`all you had to do was kill the FTGL font`
`04:14.58`	`brlcad`	`context resets are rare :)`
`04:15.07`	`JeffM`	`the rest was allready automatic`
`04:15.08`	`brlcad`	`hmm, there were memory issues with that`
`04:15.21`	`JeffM`	`yeah cus your clear was wrong too :)`
`04:15.26`	`JeffM`	`it's all fixed now`
`04:15.26`	`Epyon`	`JeffM, it's not that I truly believe it's the "only holy way". It's more that I want to do it this way to see wether it is, or wether all those papers were wrong xP`
`04:15.35`	`brlcad`	`okay, i'll check it out`
`04:15.36`	`JeffM`	`also it can do both bitmap and texture fonts`
`04:15.45`	`brlcad`	`yeah, i like the bitmap fix -- good stuff`
`04:16.04`	`JeffM`	`Epyon, sure, so you push your "book" on everyone else. how is that not the same thing :)`
`04:16.22`	`JeffM`	`brlcad, I also added a var that will let it swap to bitmaps under a specific size`
`04:16.30`	`JeffM`	`so you can get non aliased small fonts`
`04:16.45`	`JeffM`	`and I reafirmed that ATI cards suck`
`04:16.45`	`Epyon`	`JeffM, the difference is that I'm not playing Pizzaro as you're trying to suggest xP`
`04:17.06`	`*** join/#bzflag tuxd00d (n=tuxinato@128.187.180.56)`
`04:17.48`	`JeffM`	`Epyon, it's mostly in how you describe it to people, you don't try to work it it out with them, you just push them off to external refs, try talking and working with people. You realy need to work on descirbing your ideas to real people. A great idea is crap if you can't explain it.`
`04:18.01`	`JeffM`	`just remember, your not alone.`
`04:18.13`	`Epyon`	`JeffM, the problem is with describing actually :P`
`04:18.23`	`JeffM`	`and that's not meaning in a "you can get help" it's in a "we have to deal with YOU'`
`04:18.47`	`JeffM`	`Epyon, mostly you seem to assume people know all the terms you use, when in fact many don't`
`04:18.58`	`Epyon`	`JeffM, I have problems with trying to include all that I think into single IRC sentences.`
`04:19.04`	`JeffM`	`and instead of describing it in laymans terms, you shuffle them off to a link`
`04:19.14`	`JeffM`	`now that said, you'll make a perfect college professor :)`
`04:19.26`	`brlcad`	`there's another way to do that too in freetype land (i.e. request a non-anti-aliased font) .. but that's not exposed through ftgl so it's good to just use bitmap`
`04:19.27`	`JeffM`	`Epyon, use more then one, they are cheap :)`
`04:19.31`	`Epyon`	`JeffM, laugh, but I want to be one xP`
`04:19.43`	`JeffM`	`welcome to the real world skip`
`04:19.47`	`JeffM`	`it's not all about what you want.`
`04:19.54`	`Epyon`	`But it's easier to prepare a lecture, then try to describe something on the fly xP`
`04:19.59`	`JeffM`	`THAT is why you eem pretentions`
`04:21.28`	`Epyon`	`eem?`
`04:21.34`	`brlcad`	`it's also not a matter of it being "right or wrong", it can work in variety of ways perfectly fine`
`04:22.05`	`brlcad`	`the way you've gone doesn't really have any technical dismerit -- it's almost entirely practical aspects that were being questioned/prodded`
`04:23.19`	`Epyon`	`I am a little touchy here I must admit, and reply too much on emotional basis, but you must try to understand, that it feels really ... irritating... when someone questions the absolute base under which you did a 2 month project, 5 days before it's due xP`
`04:23.36`	`JeffM`	`yeah it happens`
`04:23.45`	`Epyon`	`brlcad, well, practical aspects are the results, right? xP`
`04:23.47`	`JeffM`	`you spend ALL that time on it, you shoudl be able to defend it`
`04:24.25`	`brlcad`	`if my goal was to make an l-system, i'd certainly look at defining the grammar for it too -- it's when I begin to think about integrating that tool into other code, having it used by others, and having other non-technical requirements that I'd then consider way more heavily what the impact and implications of a particular design approach is (like whether I define that grammar myself or try to find something semi-standardized, or in a language`
`04:24.53`	`brlcad`	`actually NO .. the practical aspects are very much NOT the results`
`04:25.15`	`Epyon`	`And it is also my anger on the papers, that they didn't work out as I thought they would.`
`04:25.41`	`Epyon`	`This project was much experimental in nature anyway, so anything could happen, and I hope that you knew it too.`
`04:25.48`	`brlcad`	`the practical aspects are developer buy-in (the folks that you have to work with), build system integration, code longevity (documentation, complexity), language choices, etc`
`04:26.19`	`brlcad`	`maintainability aspects`
`04:26.26`	`Epyon`	`I never heard of using anything else then L-System generated trees, and block-built levels used in real computer games.`
`04:26.37`	`JeffM`	`wow, so basicly your saying that you coned us into paying you to just try something just for you`
`04:26.44`	`brlcad`	`if the code isn't maintainable by others, it dies with the first developer (whose interest will eventually change)`
`04:26.50`	`JeffM`	`the point was for YOU to work on OUR project`
`04:27.06`	`JeffM`	`and learn how to work as a team, within a project that is not yours.`
`04:27.18`	`Epyon`	`JeffM, just for clarity's sake, YOU don't pay ME xP`
`04:27.38`	`JeffM`	`effectively we do`
`04:27.44`	`JeffM`	`cus we can cause you NOT to be paid`
`04:28.01`	`Epyon`	`brlcad, here's something for the Final survey -- point that out`
`04:28.15`	`Epyon`	`"if the code isn't maintainable by others, it dies with the first developer (whoseinterest will eventually change)"`
`04:28.17`	`JeffM`	`I mean damn, you sound like the most selfish bastard I can thing of`
`04:28.36`	`Epyon`	`JeffM, thank you, that may be near the truth actually :/`
`04:28.52`	`Epyon`	`At least in terms of thinking about projects.`
`04:29.07`	`JeffM`	`brlcad, I highly recomend that this is mentioned as a detrement in his review`
`04:29.14`	`JeffM`	`I mean DAMN`
`04:29.53`	`JeffM`	`I'm about ready to ask you to remove my code from your stuff`
`04:29.54`	`Epyon`	`JeffM, calm down. As for now it's you who calls me names and generaly hits me in the face, while I calmly accept it.`
`04:30.01`	`a_meteorite`	`man, good thing I'm not getting reviewed by Jeff. mine would be stamped with "REJECTED, DAMN" and graded F`
`04:30.31`	`Epyon`	`JeffM, and you talk about me being selfish?`
`04:30.35`	`JeffM`	`no a_meteorite your not that selfish, your stuborn, but not that selfish`
`04:30.42`	`JeffM`	`Epyon, I said almost ;)`
`04:30.45`	`a_meteorite`	`:)`
`04:30.56`	`JeffM`	`Epyon, as it would be a reaction to how you seem to us`
`04:31.06`	`JeffM`	`but does it have SPORT utility? :)`
`04:31.37`	`Epyon`	`JeffM, I'm ready to write you a script for your IRC client that adds smiles at the end of all my texts, because you seem to take all of them waaaay to seriously :P`
`04:31.38`	`brlcad`	`certainly has low gas mileage`
`04:31.51`	`JeffM`	`you seem to be a smart guy, and oyu ahve the drive to get the code done, that's good. but yeah people skills`
`04:32.27`	`JeffM`	`heh, you put one after most lines anyway, they have lost there meaning with you ;)`
`04:32.48`	`Epyon`	`JeffM, maybe I should use them only for the most ironic ones then -_-`
`04:33.18`	`Epyon`	`Matter of habbit though. I usualy talk with an amount of cinism or irony.`
`04:33.50`	`JeffM`	`you can't expect text to convey that`
`04:34.04`	`JeffM`	`specialy with menomics that are so overused they become ignored.`
`04:34.13`	`Epyon`	`But, DAMN (my turn now), I DO take all you say seriously, even if sometimes I reply earlier than I take time to really think about it.`
`04:34.17`	`JeffM`	`and when people are atempting to have serious discussions, like about your project.`
`04:34.26`	`JeffM`	`I know you do`
`04:34.31`	`JeffM`	`that's very obvious`
`04:34.39`	`brlcad`	`Epyon: interesting, hadn't known it was called DSPS .. i've just always referred to it as how many hours I'm "out of sync"`
`04:34.47`	`brlcad`	`(which is presently about 7 hours)`
`04:35.16`	`JeffM`	`I liked the book that said jetlag was your soul trying to catch up, cus souls can't travel as fast as planes :)`
`04:35.17`	`Epyon`	`brlcad, I seem to have it really badly :/. It's 6:46 now, and I know, that I still wont sleep :/.`
`04:36.51`	`brlcad`	`well the counter to that is that you certainly wont sleep if you don't try :)`
`04:37.05`	`Epyon`	`JeffM, brlcad, but the general point is that now it's too late. The system was designed after a lot of pain of trying to model something that resembles the research that still produces proper meshes, and it's already more than 50% implemented. It would be a lot time wasted now not to implement it :/`
`04:37.24`	`*** join/#bzflag PrezKennedy (i=Matt@74.86.45.130)`
`04:37.36`	`JeffM`	`Epyon, I never asked you to change it, I started asking you why`
`04:37.42`	`Epyon`	`brlcad, if I try to go to sleep 1h earlier then when I get sleepy, I turn around in bed for 3 hours instead.`
`04:37.54`	`JeffM`	`just cus we question something dons't mean we hate it/ need it to change`
`04:38.07`	`JeffM`	`we wanted a discussion on it`
`04:38.21`	`brlcad`	`yeah, it's not to hear you justify it or get you to change it`
`04:38.43`	`Epyon`	`JeffM, I know. and I started to think because of that, how to make it either hidden, or as much "user-friendly" as possible, because I noticed that there is a hole here.`
`04:38.46`	`brlcad`	`it's to understand it, and have you interact on our comments (and to keep them in mind as you keep developing it)`
`04:38.48`	`JeffM`	`it's to talk about it, discuss the benificts of other systems to show why you picked yours.`
`04:39.49`	`Epyon`	`Damn, it's all that pressure because of the deadline that makes me more agressive -_-`
`04:40.20`	`JeffM`	`as I had said, if your first answer was "cus this is faster for me" I'd have been fine, right then`
`04:40.25`	`brlcad`	`yeah, but you can't rush to the deadline without discussion -- that's a constant with development activity`
`04:40.32`	`JeffM`	`as I think that is the primary reason your doing it`
`04:40.44`	`JeffM`	`it's the fastest way for you to get the features you want and get it done.`
`04:41.43`	`Epyon`	`"<Epyon> Actually I plan to provide as much data as possible for the generator, just it's a LOTeasier, cleaner and faster to do it with a dedicated grammar than in C++"`
`04:42.06`	`brlcad`	`sorry, that's a very different statement`
`04:42.19`	`JeffM`	`you threw other things in there`
`04:42.41`	`Epyon`	`This one was without smileys xP`
`04:43.23`	`JeffM`	`if I was doing it, and wanted to externalise that part, I'd make it load a C++ dll`
`04:43.28`	`JeffM`	`plugins baby :)`
`04:43.42`	`JeffM`	`thats' even faster then doing a parser ;)`
`04:43.52`	`*** join/#bzflag jude- (n=jude@c-68-84-206-92.hsd1.ar.comcast.net)`
`04:43.58`	`brlcad`	`I see that and it you saying the technical approach being taken is "better" .. which led into all of the warts of technical+practical merits, particularly when the practical is the driver here`
`04:44.28`	`brlcad`	`you chose it this way because it's more practical for YOU to get your deliverable, which is a good enough reason in itself`
`04:44.53`	`Epyon`	`brlcad, it's true though that I didn't give much thought that someone would want to understand it developing it further.`
`04:44.56`	`brlcad`	`if we talk about the bigger picture, though, that's where things are very different`
`04:45.14`	`Epyon`	`But it's true that no one ever pointed that out :/`
`04:45.36`	`brlcad`	`Epyon: hm, I recall having that discussion way way back even before coding began`
`04:45.49`	`brlcad`	`that was the point of all the submissions`
`04:45.55`	`JeffM`	`you didn't know that others were going to work on it later? that is the entire point of open source.`
`04:46.19`	`Epyon`	`brlcad, and the thing I most remembered from that discussion was that you liked the academic side of the project :)`
`04:46.31`	`JeffM`	`I mean if that's not going to happen, then the only reason to have source is cus, linux sucks at bins.`
`04:46.35`	`Epyon`	`I think we might have had a little misunderstanding :)`
`04:46.40`	`brlcad`	`if they happen to align with personal/academic/commercial goals, great -- but the driving goal has always been long-term integration with bzflag`
`04:46.44`	`*** join/#bzflag Constitution (n=Constitu@71-223-53-67.phnx.qwest.net)`
`04:46.51`	`JeffM`	`Epyon, change we in that statement to "me" and your on the right track.`
`04:47.06`	`brlcad`	`sure, I love the academic side of it, but that doesn't mean that was the only thing I liked or wanted :)`
`04:47.25`	`JeffM`	`and as I said a number of times, he isn't the only developer of bzflag.`
`04:47.31`	`Epyon`	`JeffM, rarely misunderstandings happen between one person xP`
`04:47.50`	`orthox`	`speak for yourself`
`04:47.55`	`JeffM`	`Epyon, I think he understood what he meant.`
`04:48.27`	`JeffM`	`you took his statements wrong, there were only 2 parties, one got it right :)`
`04:48.31`	`Epyon`	`JeffM, I also understood what I meant :P`
`04:48.49`	`JeffM`	`yeah we understood what you meant too`
`04:48.58`	`JeffM`	`and tried to tell you that you were wrong`
`04:49.06`	`Epyon`	`JeffM, now? :P`
`04:49.30`	`JeffM`	`how many times today did I tell you that brlcad cared more about maintainablity?`
`04:49.44`	`JeffM`	`or even the other times you've brought it up`
`04:49.50`	`Epyon`	`JeffM, if what you hear is "I made a lot of bad choices" then you probably can hear that.`
`04:50.01`	`JeffM`	`then you are wrong`
`04:50.21`	`JeffM`	`we never said you made bad choices`
`04:50.29`	`brlcad`	`now that's not entirely fair to say just "now" -- it may have been warped over the months, but even the wiki submission page has been very adament/explicit about the things we care about and that's been from the very beginning`
`04:50.29`	`Epyon`	`JeffM, the point is that it's too late to change most of those now, at least as far as the program now is concerned.`
`04:50.35`	`JeffM`	`ok, I'm done`
`04:50.38`	`JeffM`	`your not geting it`
`04:50.55`	`JeffM`	`sadly like many others, you only listen to yourself`
`04:51.01`	`JeffM`	`good luck on your project`
`04:51.02`	`Epyon`	`sigh`
`04:53.52`	`brlcad`	`Epyon: we're not asking you to change it, it's discussion, listening to the concerns, considering what can be done about them (or not), sharing ideas, taking other peoples suggestions to mind`
`04:53.52`	`Epyon`	`JeffM, on a more serious note : what did you expect from me anyway? That I say, "Ok, you're right I will dump the parser and do it to read Lua/Python"? I know it's not it. I understand the concern, and there's not much I can do right now about it, once I started it and in my situation. Only thing I can do is try to "talk you" into the fact that things might not turn out as bad as you're trying to envision.`
`04:54.10`	`JeffM`	`Epyon, nope`
`04:54.32`	`JeffM`	`don't worrry about it`
`04:54.38`	`brlcad`	`it's not about being right or wrong, you keep coming back to that and that is NOT the point at all`
`04:54.42`	`Epyon`	`brlcad, I know, but I'm feeling more and more hopeless, because of the fact that most of the good points you make, I don't have time to do right.`
`04:55.02`	`JeffM`	`brlcad, there was also a place where the font file names were being forced to lower case`
`04:55.21`	`Epyon`	`And that's the source of my frustration. That I can't do that perfect, so that everyone will be happy.`
`04:55.23`	`brlcad`	`you're right, you don't have time to know.. so just do what you can and keep the comments in mind while you keep at it, that's all -- there's really not much more to it`
`04:56.09`	`JeffM`	`Epyon, what you have yet to learn in life it seems is that there is no such thing as perfection.`
`04:56.34`	`Epyon`	`I wanted to do something that everyone would be happy about and I see I failed. And that is what makes me angry, not your comments.`
`04:56.43`	`brlcad`	`Epyon: for what it's worth, a lot of the discussion tonight has basically revolved around two of the "Acceptance Criteria" that you read and agreed to before starting`
`04:56.48`	`JeffM`	`there is no way to make everyone happy`
`04:56.54`	`jude-`	`Epyon: do you and you alone think it's good?`
`04:57.04`	`brlcad`	`namely the "Write maintainable code" and "Write complete code" that is listed at http://my.bzflag.org/w/Google_Summer_of_Code_Acceptance`
`04:57.15`	`Epyon`	`jude-, not bad, but not good.`
`04:57.53`	`brlcad`	`particularly for the lexer/parser, it probably falls under that sentance that says "that choice needs to be discussed and justified or otherwise mitigated as a concern"`
`04:58.15`	`brlcad`	`to which from what you've said, you're going to do what you can to mitigate it as a concern (by documenting it, making it easy to use, etc)`
`04:58.24`	`Epyon`	`brlcad, unfortunately, it's now I've learned that maintainable code is more than documenation and proper code guidelines :/`
`04:58.57`	`JeffM`	`learning is one of the goals of SoC :)`
`04:59.21`	`Epyon`	`JeffM, in term of that goal I'm a big winner -_-`
`05:00.43`	`JeffM`	`cool, so you'll take that instead of the money? :)`
`05:01.22`	`Epyon`	`JeffM, if the staff decides that I failed on the project, then that's what I'll accept.`
`05:01.40`	`Epyon`	`brlcad knows that I didn't come here because of the money.`
`05:01.58`	`blast007`	`Epyon: it was for the chicks, right?`
`05:01.59`	`JeffM`	`you made code, you won't fail`
`05:02.04`	`JeffM`	`and free beers`
`05:02.20`	`Epyon`	`JeffM was closer blast007 xP`
`05:02.26`	`blast007`	`hehe`
`05:02.41`	`Epyon`	`As for chicks, I'd rather lay low for now xP`
`05:02.42`	`JeffM`	`or was it bears`
`05:02.46`	`JeffM`	`I get those mixed up`
`05:03.27`	`Epyon`	`You can't get drunk with bears, can you xP`
`05:03.38`	`JeffM`	`you can`
`05:03.42`	`JeffM`	`you just have to be VERY Good`
`05:04.11`	`brlcad`	`mmm.. free bears`
`05:04.23`	`blast007`	`leash sold seperately`
`05:06.11`	`jude-`	`void where prohibited`
`05:07.42`	`brlcad`	`batteries included`
`05:07.53`	`JeffM`	`yay, they are sending me a new dimm for the O2 :)`
`05:07.54`	`Epyon`	`Anyway, JeffM, brlcad, I feel sorry if I offended any of you, it was not my intention.`
`05:08.14`	`JeffM`	`I didn't think it was your intent, that's what suprised me`
`05:08.23`	`JeffM`	`the line you kept going down.`
`05:08.27`	`brlcad`	`though I did cry when jeff didn't show up to the beer bash`
`05:08.39`	`Epyon`	`JeffM, ?`
`05:08.48`	`JeffM`	`I didn't get to do anything I wanted that weekend :(`
`05:09.00`	`JeffM`	`had to leave the lady friend early too :(`
`05:09.21`	`JeffM`	`Epyon, don't worry about it, difrent peopel see difrent things`
`05:09.28`	`JeffM`	`and text sucks for sending tone`
`05:09.50`	`JeffM`	`your app is indeed rather cool`
`05:10.23`	`JeffM`	`and i"m sure at some point i'll cram it into a plug-in and just turn the params into a python script ;)`
`05:10.38`	`JeffM`	`with hungarian notaiton :)`
`05:10.51`	`Epyon`	`Anyway, if I talk rashly and irrtated it's only because I am really stessed now. If you want to know, right after GSoC ends, between the 20th and 30th I need to write my Master thesis, that I havn't touched yet.`
`05:11.02`	`brlcad`	`yeah, the big when is when it's integrated into the server so it is just there for use (whether as plugin or direct)`
`05:11.21`	`JeffM`	`everything should be a plug-in :)`
`05:11.33`	`JeffM`	`gotta turn bzfs into a loose shell framework`
`05:11.34`	`jude-`	`Epyon: what's the topic?`
`05:11.51`	`Epyon`	`jude-, I'm working on that too xP`
`05:12.01`	`JeffM`	`"furby AI, seriously WTF"`
`05:12.08`	`jude-`	`rofl`
`05:12.09`	`L4m3r`	`JeffM: I've thought about that XD`
`05:12.15`	`L4m3r`	`modular BZFS`
`05:12.21`	`JeffM`	`it begs for it`
`05:12.22`	`brlcad`	`jude-: anyone run bzworkbench on mac os x yet?`
`05:12.27`	`*** join/#bzflag SimonFlavelle (n=psychosi@CPE-58-169-65-143.vic.bigpond.net.au)`
`05:12.37`	`JeffM`	`ship it wth a default plugin that loads the basics, then have the rest of the logic all modular :)`
`05:12.48`	`jude-`	`brlcad: I believe tannerld and ts have...the first ever screenie on mybzflag.net was from Mac OSX`
`05:12.56`	`JeffM`	`do it up lightwave style :)`
`05:13.23`	`jude-`	`IIRC, it was Darwin`
`05:13.27`	`Epyon`	`jude-, but as for now "Application of procedural generated geometry/buidlings in game environments" xP`
`05:13.50`	`jude-`	`hehe`
`05:13.54`	`JeffM`	`"in the begining.. there was diablo"`
`05:14.01`	`brlcad`	`jude-: ah, cool`
`05:14.27`	`jude-`	`should just work with the default gcc, automake, etc (but OSG and FLTK might need to be built from source)`
`05:14.42`	`Epyon`	`JeffM, no, the main point being "Why academic solutions fail in a game environment and how to correct that :P"`
`05:15.09`	`JeffM`	`"cus school ain't fun" :)`
`05:15.15`	`Epyon`	`And as for the beginning, roguelikes were earlier than diablo, not to mention that procedural generation saw it's real birth in Frontier :P`
`05:15.46`	`JeffM`	`I didn't say the birth, just in the begining :)`
`05:15.57`	`Epyon`	`The beginning was Rogue xP`
`05:17.22`	`brlcad`	`hmm.. now to get back to my original project that spawned the whole font manager work... or kick off a new fork with a different render engine`
`05:17.45`	`brlcad`	`adventure`
`05:17.48`	`JeffM`	`you'll replace the font manager if you do the second`
`05:17.51`	`Epyon`	`But the main point is that I actually managed to find the answer for my question on why the only procedural generation in modern games is trees and lego-style composition :P`
`05:18.07`	`brlcad`	`nah, I'd do what I could to keep it :)`
`05:18.15`	`jude-`	`brlcad: did you hear that the source code to adventure was found on an old back-up tape?`
`05:18.22`	`jude-`	`i.e. just recently?`
`05:18.34`	`brlcad`	`can't just ditch all that work -- and regardless, I don't think a new engine would be ready for a long while, and I'd pray we'd have releases before then`
`05:18.41`	`brlcad`	`jude-: yep`
`05:18.44`	`Epyon`	`adventure didn't have random elements afaik, but I might be wrong.`
`05:18.49`	`CIA-23`	`BZFlag: 03JeffM2501 * r14922 10/trunk/bzflag/src/bzfs/ (ServerIntangibilityManager.cxx ServerIntangibilityManager.h): use defines, not hardcoded inline values.`
`05:19.22`	`brlcad`	`Epyon: some of the same reasons you don't find 'real' AI in most games too, though that's slowly changing`
`05:19.33`	`CIA-23`	`BZFlag: 03JeffM2501 * r14923 10/trunk/bzflag/src/bzfs/bzfsAPI.cxx: use defines, not hardcoded inline values.`
`05:19.49`	`brlcad`	`wow`
`05:19.56`	`brlcad`	`~spell intangibility`
`05:20.20`	`JeffM`	`YES, I spell checked it`
`05:20.24`	`brlcad`	`hehe`
`05:20.25`	`JeffM`	`for the 100th time`
`05:20.45`	`brlcad`	`first time for me, I've been ill/away :)`
`05:20.46`	`JeffM`	`best singleton name EVER`
`05:23.38`	`brlcad`	`hm no docs`
`05:23.44`	`brlcad`	`so what does it actually do?`
`05:24.25`	`JeffM`	`manages the tangibility of world objects`
`05:24.33`	`brlcad`	`heh`
`05:24.38`	`brlcad`	`and that means..`
`05:24.42`	`JeffM`	`basicly, seting drivethru, dynamicly`
`05:24.44`	`JeffM`	`wiht a message`
`05:24.56`	`JeffM`	`forcefield doors`
`05:24.58`	`brlcad`	`with a message?`
`05:25.02`	`brlcad`	`message sent to whom?`
`05:25.07`	`JeffM`	`yon clients`
`05:25.25`	`brlcad`	`saying that the geometry changed or something?`
`05:25.47`	`brlcad`	`or the "tangibility" of the map changed`
`05:25.56`	`blast007`	`just changes the drivethrough setting of objects`
`05:26.07`	`blast007`	`it gives an ID to objects`
`05:26.15`	`brlcad`	`ah, so not a message to the user`
`05:26.15`	`JeffM`	`well no`
`05:26.22`	`JeffM`	`the manager dosn't do the IDs`
`05:26.23`	`brlcad`	`a notification`
`05:26.30`	`JeffM`	`that's part of Obstacle now`
`05:26.33`	`brlcad`	`sent out to clients to update their representation`
`05:26.40`	`JeffM`	`yeah`
`05:26.43`	`brlcad`	`got it`
`05:26.55`	`JeffM`	`the manager keeps a list of overriden objects`
`05:27.07`	`JeffM`	`and all tangability requests go thru the manager`
`05:27.15`	`JeffM`	`and it uses the base tangibility, or the overide`
`05:27.30`	`JeffM`	`this way when you save a map, you don't get the current state, you get the base map state`
`05:27.41`	`CIA-23`	`BZFlag: 03JeffM2501 * r14924 10/trunk/bzflag/ (4 files in 2 dirs): if the server can manage tangiblity, then so can the client with it's own ClientIntangibilityManager`
`05:27.58`	`brlcad`	`so is next a ServerDynamicGeometryManager? :)`
`05:28.08`	`JeffM`	`can't do that untill shots are done`
`05:28.28`	`JeffM`	`you can't dyamicly set shoot thru, just drive thru`
`05:28.59`	`JeffM`	`since it has sync issues, and they are lessened with drive thru due to the fact that tanks send out updates`
`05:29.16`	`JeffM`	`there will probably be a server defined material manager tho`
`05:29.25`	`JeffM`	`for overiding at least dynamic colors`
`05:29.52`	`JeffM`	`I also redid some of the API for dealing with world objects`
`05:30.03`	`JeffM`	`a plugin can now get a list of all the solid objects in the world`
`05:30.07`	`JeffM`	`and there AABBoxes`
`05:30.20`	`JeffM`	`as well as do cylindrical and box collsions`
`05:30.33`	`JeffM`	`so server side bots now can see where they are going :)`
`05:32.32`	`JeffM`	`or a plug-in could check for object collisions and use them as triggers`
`05:32.46`	`JeffM`	`damn I just had a game idea :)`
`05:33.04`	`JeffM`	`track the number of times people hit an object`
`05:33.29`	`JeffM`	`change it's color to red as it gets near "critical" then have it go drive thru and full alpha`
`05:33.36`	`brlcad`	`heh`
`05:33.44`	`JeffM`	`tho you'd ahve to pick if shots could go thru or not and leave it that way`
`05:33.48`	`Epyon`	`Ok, 7:44 I guess I'll manage sleep now. G'night all :)`
`05:33.53`	`brlcad`	`or actually have chunks of it fall off and then explode after that limit`
`05:33.55`	`JeffM`	`see yah`
`05:33.56`	`JeffM`	`have fun`
`05:34.04`	`JeffM`	`brlcad, they can't move`
`05:34.15`	`JeffM`	`they can change color, and then become drive thru`
`05:34.16`	`JeffM`	`that's it`
`05:34.25`	`brlcad`	`right, hence just adding new chunks and changing the texture or something :)`
`05:34.42`	`JeffM`	`I wasn't going to do a full texture swap`
`05:34.49`	`JeffM`	`just base color changes with dynamic color`
`05:34.49`	`brlcad`	`it should be easier to add new geometry than to change/move existing`
`05:34.59`	`JeffM`	`nope`
`05:35.06`	`JeffM`	`same problem`
`05:35.15`	`JeffM`	`shot strat uses the geo`
`05:35.19`	`JeffM`	`and it's all precomputed`
`05:35.35`	`JeffM`	`you'd have to have the server do the full strat`
`05:35.50`	`JeffM`	`then send you updates for all affected shots for each geo change, so all states are in sync`
`05:36.04`	`brlcad`	`all the more reason to add a render engine then, so scene nodes can be more readily modified`
`05:36.18`	`JeffM`	`it's not a sceen node thing`
`05:36.22`	`JeffM`	`it's the actual shot path`
`05:36.28`	`JeffM`	`and the fact that each client computes there own`
`05:36.32`	`JeffM`	`using there local geo`
`05:36.44`	`JeffM`	`graphicaly, it's cake to change the graphical look`
`05:37.11`	`brlcad`	`yes, but it could also re/precompute shot paths if/when new geometry is received`
`05:37.26`	`JeffM`	`they'd need to be time synced`
`05:37.42`	`JeffM`	`and thats what I say, have the server send out shot updates`
`05:37.46`	`JeffM`	`with the new geo`
`05:37.48`	`brlcad`	`and if the path was coming directly from a scene traversal as it progressed, that would be really easy to account for then`
`05:37.52`	`JeffM`	`right now we don't have a way to do that`
`05:38.11`	`JeffM`	`brlcad, assuming everyone uses the same location and time for computation ;)`
`05:38.22`	`brlcad`	`well yeah, I wasn't saying instead of shot updates, or that you wouldn't ahve to modify shots to get it to work :)`
`05:38.41`	`brlcad`	`just saying it would be cool feature to have :)`
`05:38.57`	`JeffM`	`you need some way to say "all the shots are HERE, at this time" then have everyone copute from that good state, after the geo is there.`
`05:39.02`	`JeffM`	`sure lots of things would be cool`
`05:39.11`	`JeffM`	`my point is it's not tied to engine`
`05:39.23`	`brlcad`	`shoot away at one of the bottom pillars in decks .. watch the whole thing come crashing down`
`05:39.28`	`brlcad`	`that'd be freaking awesome`
`05:39.39`	`JeffM`	`yeah you'd think so, but it gets old fast`
`05:39.54`	`JeffM`	`you have to work in some way to respawn it all`
`05:39.59`	`JeffM`	`we had that problem in treadmakrs`
`05:40.04`	`JeffM`	`fully deformable world`
`05:40.07`	`brlcad`	`yeah`
`05:40.10`	`JeffM`	`eventaly it becomes a mess`
`05:40.14`	`brlcad`	`don't want to end up with just a pile of rubble`
`05:40.22`	`JeffM`	`it works great in mission games`
`05:40.27`	`JeffM`	`timed games, and the like`
`05:40.29`	`JeffM`	`like assult`
`05:40.38`	`JeffM`	`then you reset when it's over`
`05:40.49`	`brlcad`	`yeah, even if you could just leave zones (or server-to-server portals..lobbies, connected maps)`
`05:41.06`	`brlcad`	`so when an area was empty, god puts it all back`
`05:41.55`	`JeffM`	`missions are better :)`
`05:42.46`	`orthox`	`Epyon: for procedural game world generation, the most advanced i've seen is debris and kkrieger, 177kb and 96k that blow away doom and maybe even quake1 http://212.202.219.162/home`
`05:43.26`	`brlcad`	`meh, that's a different game .. fun for some things but I wouldn't mind just travelling from "city to city" where each had their own local rules/gameplay`
`05:43.30`	`Epyon`	`orthox, seen both of them. But they're not games, even .kkrieger is more of a demo :P`
`05:43.35`	`brlcad`	`Epyon: go to bed`
`05:43.39`	`Epyon`	`O.o`
`05:43.56`	`brlcad`	`:)`
`05:43.58`	`orthox`	`ah, but you can shoot things in kkrieger`
`05:44.04`	`Epyon`	`brlcad, IceChat pinged my name :P`
`05:44.17`	`blast007`	`Epyon: turn off your speakers`
`05:44.21`	`orthox`	`heh`
`05:44.33`	`Epyon`	`orthox, catch you later for a chat :P`
`05:45.19`	`orthox`	`Epyon, i'll be here all night =)`
`05:47.26`	`CIA-23`	`BZFlag: 03blast007 * r14925 10/trunk/bzflag/src/game/PlayerInfo.cxx: For the first character of callsigns, reserve > for /msg >admin and /msg >team`
`05:49.24`	`Constitution`	`night jude-`
`06:10.11`	`*** join/#bzflag kc9foh (n=kc9foh@68-114-216-150.dhcp.mdsn.wi.charter.com)`
`06:16.39`	`*** join/#bzflag SimonFlavelle (n=psychosi@CPE-58-169-65-143.vic.bigpond.net.au)`
`06:18.30`	`blast007`	`hmm, think there's a flag in Jeff's bitmask stuff for tangibility`
`06:18.41`	`blast007`	`flaw*`
`06:20.14`	`blast007`	`for a bitmask, should it not be (in hex) 0, 2, 4, 8, 10, 20, etc?`
`08:05.52`	`*** join/#bzflag LongDon (n=LongDon@host-091-097-075-158.ewe-ip-backbone.de)`
`08:34.18`	`CIA-23`	`BZFlag: 03blast007 * r14926 10/trunk/bzflag/ (11 files in 4 dirs):`
`08:34.18`	`CIA-23`	`BZFlag: Convert MsgAllow to use a bitmask instead of two boolean values.`
`08:34.19`	`CIA-23`	`BZFlag: Separate the allows into shoot, jump, turn left, turn right, move forward, and move backward.`
`08:34.19`	`CIA-23`	`BZFlag: Bump protocol to 0052`
`08:38.52`	`brlcad`	`nifty`
`08:39.03`	`CIA-23`	`BZFlag: 03blast007 * r14927 10/trunk/bzflag/include/Obstacle.h:`
`08:39.03`	`CIA-23`	`BZFlag: s/INTAGIBLE/INTANGIBLE/`
`08:39.03`	`CIA-23`	`BZFlag: Correct the bitmask values for tangibility`
`08:41.43`	`*** join/#bzflag SuperBusinessman (n=chatzill@unaffiliated/davidhkmrpowers)`
`08:54.14`	`[dmp]`	`~dict tangibility`
`09:06.54`	`*** join/#bzflag Chestal (i=thilo@pdpc/supporter/active/Chestal)`
`09:06.54`	`*** mode/#bzflag [+o Chestal] by ChanServ`
`10:14.46`	`*** join/#bzflag PsycheTheGuy (n=psychosi@CPE-58-169-65-143.vic.bigpond.net.au)`
`11:01.25`	`*** join/#bzflag TASAIRES (n=XChat@84.121.168.94.dyn.user.ono.com)`
`11:17.33`	`*** join/#bzflag ahs3 (n=alvin@adsl-065-005-193-158.sip.rdu.bellsouth.net)`
`11:19.09`	`ahs3`	`hello`
`11:22.35`	`TASAIRES`	`ahs3, hello`
`11:43.36`	`*** join/#bzflag gsnedders (n=gsnedder@host86-145-188-203.range86-145.btcentralplus.com)`
`12:06.06`	`*** join/#bzflag Deepa\|AFK (i=deepa@abused.armchairs.be)`
`12:17.46`	`*** join/#bzflag Pommes_ (n=Pommes@about/essy/frenchy/Pommes)`
`12:35.34`	`*** join/#bzflag Thumper_ (n=Thumper@about/essy/coffeeAddict/Thumper)`
`12:41.52`	`*** join/#bzflag TASAIRES (n=XChat@84.121.168.94.dyn.user.ono.com)`
`13:21.03`	`*** join/#bzflag Tedius (n=Tedius@musictech.MUSC.CWRU.Edu)`
`13:54.48`	`*** join/#bzflag QuantumBeep (n=QuantumB@doc-24-32-46-104.leesville.la.cebridge.net)`
`13:57.42`	`*** join/#bzflag QBeep (n=QuantumB@doc-24-32-46-104.leesville.la.cebridge.net)`
`14:15.55`	`*** join/#bzflag Pommes (n=Pommes@about/essy/frenchy/Pommes)`
`14:24.43`	`*** join/#bzflag A_Heart_Attack (n=mattfp48@unaffiliated/aheartattack/x-000001)`
`14:56.29`	`*** join/#bzflag Jwir3 (n=Jwir3@c-66-41-249-30.hsd1.mn.comcast.net)`
`15:02.40`	`*** join/#bzflag delusional (n=delusion@pool-71-253-23-254.pitbpa.east.verizon.net)`
`15:09.14`	`*** join/#bzflag JeffM (n=JeffM@unaffiliated/jeffm)`
`15:11.20`	`blast007`	`JeffM: I made a change to the bitmask values for tangibility: http://bzflag.svn.sourceforge.net/viewvc/bzflag/trunk/bzflag/include/Obstacle.h?r1=14919&r2=14927`
`15:11.37`	`blast007`	`does that seem right?`
`15:14.24`	`JeffM`	`ahh yeah`
`15:14.28`	`JeffM`	`well I was just guessing :)`
`15:14.29`	`JeffM`	`thanks`
`15:14.39`	`JeffM`	`my bin to hex is weak :)`
`15:14.49`	`blast007`	`;)`
`15:14.57`	`JeffM`	`one bit per`
`15:15.23`	`blast007`	`I also finally got around to splitting the MsgAllow into finer control`
`15:15.32`	`JeffM`	`cool`
`15:15.34`	`blast007`	`it uses a bitmask`
`15:15.37`	`JeffM`	`what does it do now?`
`15:15.59`	`blast007`	`has a bit for shooting, jumping, turn left, turn right, move forward, and move backward`
`15:16.19`	`JeffM`	`nice`
`15:16.26`	`blast007`	`so eventually we can make badflags use that`
`15:16.35`	`JeffM`	`or zones )`
`15:16.41`	`blast007`	`:)`
`15:34.16`	`CIA-23`	`BZFlag: 03chaos-dev * r14928 10/trunk/bzwgen/bzwgen.cxx: More verbose messages and load failure reporting.`
`15:35.06`	`CIA-23`	`BZFlag: 03chaos-dev * r14929 10/trunk/bzwgen/ (15 files in 2 dirs): Textures moved to media directory to provide some order in the project.`
`15:39.48`	`blast007`	`JeffM: map sending seems to be broken for larger map files (I was trying with Louman's Metropolis, which was about 140KB iirc)`
`15:39.57`	`blast007`	`worked with just a random map though`
`15:40.36`	`*** join/#bzflag TD-Linux (n=TD-Linux@about/essy/indecisive/TD-Linux)`
`15:41.16`	`*** join/#bzflag bier_ (n=bier@p54A5288F.dip0.t-ipconnect.de)`
`15:42.17`	`JeffM`	`yeah probably is`
`15:43.50`	`*** join/#bzflag Deepa (n=deepa@wrongplanet/deepa)`
`15:46.21`	`Epyon`	`Wow, if I said something bad about VCEE now it's a time to say something good :)`
`15:52.07`	`CIA-23`	`BZFlag: 03chaos-dev * r14930 10/trunk/bzwgen/ (Token.cxx Token.h bzlgen.vcproj bzwgen.cxx): Removed obsolete files (the abandoned lexer), added proper build rules to the Flex/Bison system, and cleaned up the project file from unused files.`
`15:54.32`	`*** join/#bzflag DTRemenak (i=DTRemena@about/essy/CrazyCoder/DTRemenak)`
`15:54.33`	`*** mode/#bzflag [+v DTRemenak] by ChanServ`
`16:00.26`	`JeffM`	`blast007, does it just hang? or does it give a bad MD5?`
`16:01.13`	`blast007`	`hangs`
`16:05.35`	`JeffM`	`hmmm`
`16:05.47`	`JeffM`	`what is the max size for a TCP packet?`
`16:07.36`	`*** join/#bzflag JBdiGriz (n=jbdigriz@209-203-68-2.static.twtelecom.net)`
`16:07.36`	`*** mode/#bzflag [+o JBdiGriz] by ChanServ`
`16:10.13`	`blast007`	`JeffM: that's controlled by the operating system's MTU`
`16:10.40`	`blast007`	`http://www.dslreports.com/faq/695`
`16:10.41`	`*** join/#bzflag LongDon (n=LongDon@host-091-097-072-058.ewe-ip-backbone.de)`
`16:10.45`	`JeffM`	`what kinda sizes are they usualy?`
`16:10.52`	`JeffM`	`something in K or in bytes?`
`16:13.10`	`JeffM`	`the link errors for me`
`16:13.27`	`blast007`	`bytes`
`16:13.31`	`*** join/#bzflag Erroneous (n=dtremena@67-131-219-2.dia.static.qwest.net)`
`16:13.34`	`blast007`	`http://en.wikipedia.org/wiki/Maximum_transmission_unit`
`16:14.19`	`JeffM`	`ahh`
`16:14.33`	`JeffM`	`ok so we are doing 1024 +4 per packet`
`16:14.41`	`JeffM`	`that's proably about as big as we can get`
`16:15.10`	`blast007`	`my XP SP2 system has an MTU of 1472`
`16:16.10`	`JeffM`	`k, so I can't send out biger packets`
`16:16.12`	`blast007`	`the MTU includes all the headers on the packet as well`
`16:16.33`	`JeffM`	`you using your server?`
`16:16.37`	`JeffM`	`or a remote one?`
`16:16.47`	`blast007`	`remote one that is mine`
`16:16.54`	`blast007`	`so, "yes"`
`16:16.58`	`JeffM`	`so you can view debug output?`
`16:17.01`	`blast007`	`yup`
`16:17.22`	`JeffM`	`I'll add some log lines to both client and server and we can see where it hangs`
`16:19.15`	`blast007`	`Player [1] removed at 2007-08-16 10:15:10: send queue too big`
`16:19.28`	`JeffM`	`ohhhhhh`
`16:19.31`	`JeffM`	`ok`
`16:19.38`	`JeffM`	`so it can't fire them out fast enough`
`16:19.48`	`JeffM`	`set _WorldChunksPerUpdate to like 5`
`16:19.56`	`blast007`	`k`
`16:20.07`	`JeffM`	`it's trying to do like 50 per shot now`
`16:20.09`	`JeffM`	`so 50k`
`16:20.41`	`blast007`	`hmm, bzflag seems to make two connections to the server`
`16:20.46`	`blast007`	`is that normal?`
`16:21.03`	`JeffM`	`no`
`16:21.06`	`JeffM`	`it should only do one`
`16:21.36`	`blast007`	`Player [0] accept() from 68.185.190.140 on 5`
`16:21.36`	`blast007`	`snip`
`16:21.36`	`blast007`	`Player [1] accept() from 68.185.190.140 on 6`
`16:21.58`	`blast007`	`but let me test again, maybe it was from the MD5 error`
`16:22.16`	`JeffM`	`yeah you have to clear your cache when the world fails do download`
`16:22.37`	`JeffM`	`found that out a lot when I was redoing it`
`16:22.53`	`JeffM`	`if we have to we can go back to the old method, it's just slow. I was trying to speed up the transfer`
`16:23.05`	`blast007`	`it removes the file just fine`
`16:23.24`	`blast007`	`and then on a reconnect, it tries to join and download the map`
`16:23.32`	`JeffM`	`maybe I'll make it send out a count with each update, and then have the server request more then it gets like 10 or something.`
`16:24.29`	`CIA-23`	`BZFlag: 03JeffM2501 * r14931 10/trunk/bzflag/src/bzfs/bzfs.cxx: logging at levels 3 and 4 for sending out the world chunks`
`16:27.41`	`JeffM`	`unless anyone can think of a faster way of sending out the world?`
`16:27.49`	`JeffM`	`it's allready Gziped`
`16:28.02`	`JeffM`	`the old way was slow beause it only sent 1 k every flag time.`
`16:29.36`	`*** join/#bzflag Suspect (n=Suspect@68-114-71-106.dhcp.plt.ny.charter.com)`
`16:29.50`	`JeffM`	`oh oh oh`
`16:29.54`	`JeffM`	`I think I know what it may be`
`16:30.50`	`Epyon`	`Hmm, will atof() handle whole numbers correctly? ("4", "20" as opposed to "20.0")`
`16:31.01`	`JeffM`	`yeah`
`16:31.10`	`Epyon`	`thanks`
`16:31.43`	`blast007`	`JeffM: it's working with _WorldChunksPerUpdate set to 5, but REAAAALY slow`
`16:31.52`	`CIA-23`	`BZFlag: 03JeffM2501 * r14932 10/trunk/bzflag/src/bzflag/playing.cxx:`
`16:31.52`	`CIA-23`	`BZFlag: increment the world pointer when we get a message, it's VERY important to do that so the unpack works.`
`16:31.52`	`CIA-23`	`BZFlag: add logging at level 2`
`16:31.55`	`JeffM`	`blast007, I don't think it'll finish :)`
`16:32.02`	`blast007`	`yeah...it didn't`
`16:34.56`	`Epyon`	`Anyone running linux willing to check my project and update the makefile?`
`16:35.47`	`TD-Linux`	`I will, if you give me the svn checkout command :)`
`16:37.09`	`Epyon`	`one moment`
`16:37.43`	`TD-Linux`	`got it`
`16:38.12`	`TD-Linux`	`-O0?`
`16:38.14`	`Epyon`	`try first to compile it by hand`
`16:38.30`	`TD-Linux`	`by hand? that coudl take ages :P`
`16:38.32`	`Epyon`	`one moment`
`16:38.44`	`TD-Linux`	`oh nvm`
`16:38.49`	`TD-Linux`	`not that many files, can do :)`
`16:38.55`	`blast007`	`JeffM: it's sitting at "1% complete/153 kb remaining"`
`16:39.06`	`TD-Linux`	`-I../bzflag/include`
`16:39.12`	`TD-Linux`	`you're lucky that worked :P`
`16:39.26`	`Epyon`	`flex -o$(InputName).cxx $(InputFileName)`
`16:39.26`	`Epyon`	`bison -d -o$(InputName).cxx $(InputFileName)`
`16:39.42`	`Epyon`	`those are for the .l and .y file respectively.`
`16:40.01`	`JeffM`	`yeah, use that change blast007 and run the server wtih 3 d's or more and the client with 2 d's or more`
`16:40.05`	`Epyon`	`InputName is base name, InputFilename is basename + ext`
`16:40.10`	`TD-Linux`	`do you want those in the makefile?`
`16:40.23`	`Epyon`	`TD-Linux, if it runs then yes.`
`16:40.32`	`blast007`	`JeffM: should I leave _WorldChunksPerUpdate at 5?`
`16:40.36`	`Epyon`	`You won't be able to compile it if not :P`
`16:40.46`	`Epyon`	`It needs the generated files.`
`16:41.01`	`Epyon`	`If this fails, I'll commit the resulting files too.`
`16:41.12`	`JeffM`	`blast007, you can try a larger value`
`16:41.22`	`blast007`	`I took out the set, and it dropped me again`
`16:41.29`	`blast007`	`"send queue too big"`
`16:41.53`	`TD-Linux`	`Epyon, it worked`
`16:41.59`	`JeffM`	`try like 20ish`
`16:42.00`	`TD-Linux`	`but what about parser.cxx.h?`
`16:42.09`	`*** join/#bzflag bier_ (n=bier@p54A52BF5.dip0.t-ipconnect.de)`
`16:42.21`	`*** join/#bzflag gsnedders (n=gsnedder@host86-145-188-203.range86-145.btcentralplus.com)`
`16:42.54`	`Epyon`	`TD-Linux, parser.cxx and parser.cxx.h are both generated from that bison command (the -d switch generates the additional .h file)`
`16:43.11`	`TD-Linux`	`aah I missed the -d`
`16:43.29`	`Epyon`	`It's... quite important :P`
`16:43.41`	`TD-Linux`	`I got a parser.hxx !`
`16:43.50`	`Epyon`	`O.o`
`16:44.02`	`Epyon`	`Okay, one moment.`
`16:47.47`	`blast007`	`JeffM: 20 was too high yet, it dropped me`
`16:48.05`	`blast007`	`I set it to 5, and I'm getting bursts of 5KB every few seconds`
`16:48.19`	`blast007`	`averaging to 1.7KB/sec`
`16:48.21`	`JeffM`	`ok`
`16:48.27`	`JeffM`	`lets see if it finishes`
`16:48.37`	`blast007`	`nope... Error on MD5`
`16:48.40`	`JeffM`	`I talked to Erroneous about it and we ahve an idea`
`16:48.42`	`JeffM`	`damn...`
`16:49.12`	`JeffM`	`yeah it may be`
`16:49.15`	`JeffM`	`it's just more work`
`16:49.28`	`JeffM`	`I'd want to put it back to the way it used to be before`
`16:49.57`	`JeffM`	`then just make it send out the game server name as a URL if one was not specified`
`16:50.10`	`Erroneous`	`or you could thread it and run tight little loops for sends`
`16:50.12`	`JeffM`	`heck I can do that as a plugin`
`16:50.31`	`JeffM`	`we have loops I can use now, I just need to make them smart`
`16:50.39`	`JeffM`	`I like the idea of sending till the buffer is full`
`16:50.43`	`Erroneous`	`we have a big slow loop`
`16:51.11`	`JeffM`	`so put it back the way it was then and make a "fastmap" plugin that does it with http?`
`16:51.20`	`Epyon`	`TD-Linux, darn, there's no cmdline option to control the output of the .h file :/. Rename it via the Makefile, or do a #define when including?`
`16:51.29`	`Epyon`	`#define -> #ifdef`
`16:52.03`	`Erroneous`	`smarter is better, sure. I still think we'll run out though...particularly if the loop is doing something like, oh, spawning somebody, in the meantime.`
`16:52.04`	`JeffM`	`ok, then plug-in method`
`16:52.11`	`JeffM`	`that sound good?`
`16:52.21`	`JeffM`	`means no client mods ether :)`
`16:52.27`	`Erroneous`	`not sure why it needs to be a plugin, but sure`
`16:52.52`	`JeffM`	`a plug-in just so we can test it out and have a backup :)`
`16:53.01`	`JeffM`	`if it works in all cases, we can move it in`
`16:53.08`	`Erroneous`	`ok`
`16:53.11`	`JeffM`	`for maps under a k compressed size, our current method is fastest`
`16:53.20`	`Erroneous`	`true`
`16:53.33`	`JeffM`	`ok, I'll put the old code back :)`
`16:54.08`	`CIA-23`	`BZFlag: 03chaos-dev * r14933 10/trunk/bzwgen/Rule.h: Rule class stub.`
`16:54.13`	`*** join/#bzflag Hannibal_bzf (n=aaronsal@unaffiliated/hannibal)`
`16:54.42`	`CIA-23`	`BZFlag: 03chaos-dev * r14934 10/trunk/bzwgen/ (bzlgen.vcproj lexer.l parser.y): char* and float support for the lexer/parser.`
`16:54.50`	`TD-Linux`	`Epyon, I'm not an expert on makefiles... but I can try :P`
`16:55.02`	`*** join/#bzflag bier_ (n=bier@p54A52BF5.dip0.t-ipconnect.de)`
`16:55.07`	`TD-Linux`	`at least, I don't quite understand this makefile`
`16:55.09`	`Epyon`	`TD-Linux, I'm wondering what the more "clear" way would be.`
`16:55.24`	`Epyon`	`TD-Linux, ask brlcad about it, I didn't write it :P`
`16:56.02`	`Epyon`	`TD-Linux, so shall I add conditional inclusion for the parser.cxx.h file?`
`16:56.09`	`TD-Linux`	`sure :P`
`16:56.13`	`TD-Linux`	`hmm`
`16:56.21`	`Erroneous`	`should probably move to an autotools system, if you're relying on stuff like yacc`
`16:56.33`	`TD-Linux`	`that would be a good idea, I think :)`
`16:56.47`	`Epyon`	`Erroneous, I have no experience with that :/`
`16:56.53`	`TD-Linux`	`I've made an autotools system before`
`16:57.03`	`Erroneous`	`Epyon: I wouldn't expect you personally to do it :)`
`16:57.11`	`TD-Linux`	`should I try?`
`16:57.34`	`Epyon`	`TD-Linux, first test if it compiles :P`
`16:57.50`	`Epyon`	`(by renaming the hxx file manualy to cxx.h)`
`16:58.02`	`Erroneous`	`cxx.h?`
`16:58.22`	`Epyon`	`Erroneous, that's the wierd thing that the windows bison outputs xP`
`16:58.22`	`TD-Linux`	`I find that odd too :P`
`16:58.46`	`Erroneous`	`that is bizzarre`
`16:59.02`	`TD-Linux`	`COSDir::COSDir(char const*)'
`16:59.05`	`TD-Linux`	`what file is that in?`
`16:59.20`	`Erroneous`	`osfile`
`16:59.47`	`Epyon`	`What should I add after #ifdef to check wether it's a windows system?`
`17:00.26`	`TD-Linux`	`I added several things to the makefile`
`17:00.29`	`Erroneous`	`WIN32 or _WIN32`
`17:00.36`	`JeffM`	`_WIN32`
`17:00.40`	`Epyon`	`TD-Linux, use the OSFile in the project not the ones in the bzflag source tree`
`17:00.45`	`Erroneous`	`both should be defined on reasonable systems`
`17:00.47`	`TD-Linux`	`hah`
`17:00.50`	`TD-Linux`	`guess why it errors?`
`17:00.52`	`TD-Linux`	`TextUtils.h:19: warning: ignoring #pragma warning`
`17:01.04`	`Epyon`	`Same goes for TextUtils`
`17:01.08`	`TD-Linux`	`and then it says treating warning as errors`
`17:01.11`	`Erroneous`	`pragmas should be inside #ifdef _MSC_VER`
`17:01.23`	`Epyon`	`Erroneous, okay I'll fix that.`
`17:01.39`	`Erroneous`	`same with other visual-studio-specific stuff`
`17:02.03`	`TD-Linux`	`TextUtils.h:366: error: extra ‘;’`
`17:02.38`	`CIA-23`	`BZFlag: 03JeffM2501 * r14935 10/trunk/bzflag/src/ (7 files in 3 dirs):`
`17:02.38`	`CIA-23`	`BZFlag: put the map loader back to the old slow method for now.`
`17:02.38`	`CIA-23`	`BZFlag: new fast map loading will be prototyped with a plug-in using HTTP.`
`17:02.54`	`JeffM`	`blast007, give that a whirl, client and server`
`17:03.08`	`JeffM`	`puts it back to the old way`
`17:03.29`	`Epyon`	`TD-Linux, whaaat? o.O`
`17:03.55`	`Epyon`	`TD-Linux, check if there's some odd character there, if so, delete it and commit that file.`
`17:04.09`	`TD-Linux`	`I don't have commit access.`
`17:04.24`	`TD-Linux`	`it's just an extra ;, I removed it and it all compiles fine`
`17:04.32`	`Epyon`	`ah, ok :)`
`17:04.35`	`TD-Linux`	`but it doesn't link, /me needs to link in the library`
`17:04.46`	`Epyon`	`Which one?`
`17:04.51`	`*** join/#bzflag QuantumBeep (n=QuantumB@doc-24-32-46-104.leesville.la.cebridge.net)`
`17:05.06`	`TD-Linux`	`what are the yy functions?`
`17:05.07`	`TD-Linux`	`bison?`
`17:05.13`	`Epyon`	`yep`
`17:05.54`	`Epyon`	`link with the lexer (if yylex) or parser (if other) object file`
`17:07.27`	`CIA-23`	`BZFlag: 03chaos-dev * r14936 10/trunk/bzwgen/TextUtils.h: Removed an extra ;`
`17:09.31`	`JeffM`	`what does an HTTP header look like?`
`17:10.36`	`CIA-23`	`BZFlag: 03chaos-dev * r14937 10/trunk/bzwgen/ (bzwgen.cxx lexer.l): Added conditionals to properly include either parser.hxx or parser.cxx.h`
`17:12.08`	`brlcad`	`JeffM: curl --head http://bzflag.bz`
`17:12.24`	`JeffM`	`thanks`
`17:13.02`	`brlcad`	`try a few more for variety, like http://google.com`
`17:13.19`	`JeffM`	`the request starts with get`
`17:13.21`	`JeffM`	`that's allI need`
`17:13.37`	`brlcad`	`ah, you mean the requesters header`
`17:13.47`	`JeffM`	`I just need the first part of the request to know it's HTTP so I can pass it off to tinyHTTP`
`17:13.47`	`JeffM`	`yeah`
`17:14.01`	`CIA-23`	`BZFlag: 03chaos-dev * r14938 10/trunk/bzwgen/ (OSFile.cpp TextUtils.cpp TextUtils.h commandArgs.cpp): Put #pragma warning disable statements into #ifdef _MSC_VER conditionals`
`17:14.59`	`JeffM`	`bahh. need a new event :)`
`17:15.03`	`JeffM`	`world finalised`
`17:20.06`	`Epyon`	`TD-Linux, what's the version of your bison?`
`17:20.16`	`Epyon`	`Um, that sounded funny :P`
`17:29.45`	`*** join/#bzflag gsnedders (n=gsnedder@host86-145-188-203.range86-145.btcentralplus.com)`
`17:33.46`	`TD-Linux`	`Epyon, might be gone soon`
`17:34.09`	`Epyon`	`TD-Linux, how far did you managed to get?`
`17:34.46`	`TD-Linux`	`hthere's an extra ; in TextUtils.cpp`
`17:34.57`	`Epyon`	`what line?`
`17:35.08`	`TD-Linux`	`same place`
`17:35.10`	`TD-Linux`	`bottom`
`17:35.34`	`TD-Linux`	`it works!`
`17:36.04`	`Epyon`	`BTW I found a more recent version of Win32 bison and it also generates hxx :D`
`17:36.12`	`Epyon`	`GREAT :D`
`17:36.16`	`TD-Linux`	`http://pastebin.ca/659962`
`17:36.29`	`TD-Linux`	`is the Makefile`
`17:36.33`	`TD-Linux`	`it doesn't do bison or flex yet`
`17:36.34`	`Epyon`	`Does it show parse errors when run?`
`17:36.39`	`TD-Linux`	`yes.`
`17:36.43`	`TD-Linux`	`wait`
`17:36.44`	`TD-Linux`	`no`
`17:36.52`	`TD-Linux`	`add the -Werror back in to the flags`
`17:37.13`	`TD-Linux`	`CFLAGS = -g -O0 -Wall -Werror -pedantic -ansi`
`17:37.26`	`Epyon`	`I mean, while running the program does it write Loading xxx... done. or ..failed!`
`17:37.51`	`TD-Linux`	`...failed!`
`17:38.10`	`TD-Linux`	`[thomas@localhost bzwgen]$ ./bzwgen`
`17:38.11`	`TD-Linux`	`input in flex scanner failed`
`17:38.11`	`TD-Linux`	`Loading rules/.svn... [thomas@localhost bzwgen]$`
`17:39.01`	`Epyon`	`is CPPFLAGS = -I../bzflag/include really needed?`
`17:39.37`	`Epyon`	`aaaah, it tries to load .svn lol!`
`17:40.39`	`CIA-23`	`BZFlag: 03chaos-dev * r14939 10/trunk/bzwgen/ (bzwgen.cxx lexer.l): Upgraded version of bison, it does generate hxx files now, so conditionals are unnecessary`
`17:41.26`	`CIA-23`	`BZFlag: 03chaos-dev * r14940 10/trunk/bzwgen/Makefile: Updated Makefile (thanks TD-Linux), doesn't include the rules for bison and yacc, anyone?\`
`17:41.59`	`TD-Linux`	`I can hack them in quick if you want`
`17:42.05`	`TD-Linux`	`let me do that...`
`17:42.20`	`Epyon`	`kk`
`17:44.03`	`CIA-23`	`BZFlag: 03chaos-dev * r14941 10/trunk/bzwgen/TextUtils.cpp: Yet Another Semicolon Too Far (TM)`
`17:44.13`	`daxxar`	`Semicolons RULE.`
`17:45.07`	`TD-Linux`	`I added them`
`17:45.30`	`TD-Linux`	`Epyon, http://pastebin.ca/659968`
`17:45.37`	`TD-Linux`	`but now there are warnings from lexer.cxx`
`17:45.44`	`TD-Linux`	`I must have missed them before`
`17:46.50`	`CIA-23`	`BZFlag: 03chaos-dev * r14942 10/trunk/bzwgen/bzlgen.vcproj: Updated project file with the hxx`
`17:48.04`	`CIA-23`	`BZFlag: 03chaos-dev * r14943 10/trunk/bzwgen/Makefile: Updated the Makefile with the flex/bison rules (TD-Linux)`
`17:48.56`	`daxxar`	`Someone changed playing.cxx / LocalPlayer (?) so botplaying.cxx stopped compiling. Bad testing!`
`17:49.28`	`CIA-23`	`BZFlag: 03JeffM2501 * r14944 10/trunk/bzflag/include/WorldEventManager.h: utility function to call an event from just the data, since it has it's type.`
`17:50.09`	`CIA-23`	`BZFlag: 03chaos-dev * r14945 10/trunk/bzwgen/bzwgen.cxx: Fixed the directory parsing in search of set files. It won't try to parse .svn now xP`
`17:50.25`	`daxxar`	`blast007: r14926 broke bzrobots`
`17:50.26`	`Epyon`	`TD-Linux, can you now try to do a clean checkout and run the makefile?`
`17:50.41`	`CIA-23`	`BZFlag: 03JeffM2501 * r14946 10/trunk/bzflag/ (include/bzfsAPI.h src/bzfs/bzfs.cxx):`
`17:50.41`	`CIA-23`	`BZFlag: constructor change for basic events.`
`17:50.41`	`CIA-23`	`BZFlag: add bz_eWorldFinalized event that is called when the world is completly loaded.`
`17:50.42`	`Epyon`	`And then tell me what the first lines of the output are?`
`17:52.27`	`JeffM`	`Erroneous, what was the URL for that tiny HTTP?`
`17:52.47`	`Erroneous`	`http://tols17.oulu.fi/~ttarvain/`
`17:52.54`	`JeffM`	`thanks`
`17:55.20`	`brlcad`	`that is pretty tiny`
`17:57.28`	`TD-Linux`	`still some warnings from lexer.cxx`
`17:57.41`	`*** join/#bzflag Pommes_ (n=Pommes@about/essy/frenchy/Pommes)`
`17:58.03`	`Epyon`	`TD-Linux, I know, but does it run and report "Loading xxx... done"?`
`17:58.31`	`TD-Linux`	`Loading rules/test.set... syntax error at line 2`
`17:58.31`	`TD-Linux`	`failed!`
`17:58.31`	`TD-Linux`	`Initializing...`
`17:58.31`	`TD-Linux`	`done.`
`17:58.31`	`TD-Linux`	`Parsing options...`
`17:58.32`	`TD-Linux`	`done.`
`17:58.34`	`TD-Linux`	`Generating...`
`17:58.36`	`TD-Linux`	`some numbers...`
`17:58.40`	`TD-Linux`	`Done.`
`17:59.10`	`TD-Linux`	`I got a test.bzw!`
`17:59.15`	`Epyon`	`hmm syntax error :/`
`17:59.42`	`*** join/#bzflag delusional_ (n=delusion@pool-151-201-120-153.pitt.east.verizon.net)`
`18:00.06`	`TD-Linux`	`bzfs hangs on the test.bzw`
`18:00.14`	`Epyon`	`TD-Linux, I know :)`
`18:00.14`	`TD-Linux`	`no`
`18:00.18`	`TD-Linux`	`it's doing _something_`
`18:00.22`	`TD-Linux`	`but my computer is slow :/`
`18:00.38`	`Epyon`	`You need trunk bzfs to run it`
`18:00.42`	`TD-Linux`	`oh`
`18:00.58`	`TD-Linux`	`I'll have to wait until I buy my new laptop then`
`18:01.00`	`Epyon`	`JeffM found an error with the matrefs`
`18:01.04`	`TD-Linux`	`so I can run bzflag on it`
`18:01.24`	`Epyon`	`That syntax error I don't like though.`
`18:01.25`	`TD-Linux`	`right now I can run bzflag on a windows machine, but compiling is a pain :/`
`18:01.39`	`Epyon`	`What are your bison and flex versions?`
`18:02.00`	`daxxar`	`TD-Linux: You want trunk bzflag for win32?`
`18:03.50`	`CIA-23`	`BZFlag: 03daxxar * r14947 10/trunk/bzflag/src/ (bzflag/playing.cxx bzrobots/botplaying.cxx):`
`18:03.50`	`CIA-23`	`BZFlag: Fixed compilation of bzrobots (broken in r14926).`
`18:03.50`	`CIA-23`	`BZFlag: Re-added statusmessages about forbidden / allowed movement. (removed in r14926)`
`18:04.53`	`CIA-23`	`BZFlag: 03chaos-dev * r14948 10/trunk/bzwgen/ (Makefile lexer.l): Removed -Werror from the makefile until I find a way to fix that generated lexer`
`18:05.38`	`Epyon`	`Does g++ have something like the MSC #pragma disable warning?`
`18:07.22`	`brlcad`	`there are not really any g++ warnings that you should be needing to suppress`
`18:07.45`	`Epyon`	`Oh and another one -- does windows or unix have double character linebreaks?`
`18:07.51`	`daxxar`	`Hrm`
`18:07.53`	`daxxar`	`This is annoying.`
`18:07.58`	`TD-Linux`	`windows`
`18:08.03`	`Epyon`	`I guess windows, and that's where the parser is cutting out...`
`18:08.09`	`TD-Linux`	`:/`
`18:08.15`	`daxxar`	`Epyon: Windows has \r\n`
`18:08.22`	`TD-Linux`	`detect just \n`
`18:08.27`	`TD-Linux`	`and throw away the \r`
`18:08.33`	`Epyon`	`TD-Linux, can you convert \r\n to \n in the file?`
`18:08.39`	`TD-Linux`	`yes`
`18:08.39`	`brlcad`	`you really should be able to compile cleanly with -Wall -Werror -- the msvc pragmas are for msvc compatibility issues and other nuances usually`
`18:08.45`	`Epyon`	`TD-Linux, do that`
`18:09.03`	`daxxar`	`The SWIG (python) bindinsg pull in the requests-definition, and they have ::process-code which pulls in RCReplies, and RCReplies pull in libGame.`
`18:09.03`	`Epyon`	`TD-Linux, what is the warning you get?`
`18:09.18`	`daxxar`	`So if I want to be able to load the module, I need to pull in heckalot of deps.`
`18:09.26`	`Epyon`	`brlcad, the problem is that the warning comes from the generated code parts that I have no control over :/`
`18:09.33`	`daxxar`	`(or conditionally compile RCRequests.cxx for the SWIG bindings)`
`18:09.35`	`TD-Linux`	`lexer.cxx: In function ‘int yy_get_next_buffer()’:`
`18:09.35`	`TD-Linux`	`lexer.cxx:1055: warning: comparison between signed and unsigned integer expressions`
`18:09.35`	`TD-Linux`	`lexer.cxx: At global scope:`
`18:09.35`	`TD-Linux`	`lexer.cxx:1146: warning: ‘void yyunput(int, char*)’ defined but not used`
`18:09.48`	`JeffM`	`Erroneous, tinyHttp looks to be nix only`
`18:09.50`	`JeffM`	`:(`
`18:09.51`	`Epyon`	`yyunput?`
`18:10.08`	`TD-Linux`	`Epyon, it works now.`
`18:10.19`	`Epyon`	`Okay, those two I have no control over :/`
`18:10.28`	`TD-Linux`	`dos2unix :D`
`18:10.33`	`Erroneous`	`JeffM: ah. well, that was just my first thought...guess you could look for a small cross-platform http server`
`18:10.34`	`brlcad`	`i believe you're missing some decls`
`18:10.50`	`JeffM`	`Erroneous, how nasty is the http get protocoll?`
`18:10.57`	`Epyon`	`TD-Linux, one last test, and you're free :)`
`18:10.57`	`TD-Linux`	`it's super easy`
`18:10.57`	`Erroneous`	`not too bad`
`18:11.14`	`Erroneous`	`the advantage of an existing implementation is that you don't have to think as much :)`
`18:11.16`	`TD-Linux`	`Epyon, ok...`
`18:11.17`	`JeffM`	`wonder if I can just yank that part from tinyHTTP`
`18:11.37`	`brlcad`	`Epyon: there are ways to quell those warnings iirc, I've seen them before`
`18:11.55`	`Epyon`	`brlcad, I have no clue how, however :/`
`18:11.57`	`brlcad`	`it's part of the integration and portability headaches that I referred to too`
`18:12.22`	`Epyon`	`TD-Linux, do a clean checkout again. All should work.`
`18:12.31`	`Epyon`	`Wait!`
`18:13.02`	`TD-Linux`	`waiting.`
`18:13.21`	`CIA-23`	`BZFlag: 03chaos-dev * r14949 10/trunk/bzwgen/lexer.l: //r treated as whitespase for nix compatibility`
`18:13.30`	`Epyon`	`Now :)`
`18:15.09`	`TD-Linux`	`JeffM, you can do HTTP with telnet`
`18:15.16`	`TD-Linux`	`telnet google.com 80`
`18:15.21`	`TD-Linux`	`then`
`18:15.29`	`TD-Linux`	`GET /index.html HTTP/1.0`
`18:15.33`	`TD-Linux`	`push enter twice`
`18:15.37`	`JeffM`	`I know`
`18:15.42`	`JeffM`	`that dosn't help me`
`18:18.28`	`brlcad`	`Epyon: try to quell the warnings, you might have to do some ugly trickery, but they should all be quellable -- e.g. in the yyunput case you can just call yyunput somewhere in unreachable code (like after an exit() call)`
`18:19.11`	`Epyon`	`TD-Linux, and paste me the line that the yy_get_next... warning is generated (apparently lexer.cxx is different size on win and on linux)`
`18:19.35`	`Epyon`	`brlcad, I got rid of that yyunput warning cleanly.`
`18:19.47`	`Epyon`	`It's the other one that is a PITA.`
`18:19.58`	`brlcad`	`they're all pita'sses :)`
`18:20.16`	`Epyon`	`TD-Linux, ping?`
`18:20.44`	`TD-Linux`	`g2g soon....`
`18:21.30`	`Epyon`	`Did you manage to compile and run it cleanly now?`
`18:21.34`	`TD-Linux`	`/* Read in more data. */`
`18:21.34`	`TD-Linux`	`YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),`
`18:21.34`	`TD-Linux`	`(yy_n_chars), num_to_read );`
`18:21.40`	`Epyon`	`(without converting the test set?)`
`18:21.40`	`TD-Linux`	`Epyon, not without warnings`
`18:21.50`	`TD-Linux`	`but yes, it worked without converting the test set.`
`18:21.55`	`Epyon`	`Great :D`
`18:22.24`	`Epyon`	`Okay, thanks for your help, I'll try to fix that warning now. (only those two are reported?)`
`18:22.31`	`TD-Linux`	`yup only those two`
`18:22.46`	`TD-Linux`	`going to get school schedule...`
`18:22.48`	`Epyon`	`One is killed. I'm trying the other one now o.O`
`18:24.27`	`Epyon`	`Hmm, brlcad, I can fix that warning but at the cost of pasting in 12 additional lines of code that people will wonder about WTF they are here...`
`18:26.25`	`CIA-23`	`BZFlag: 03JeffM2501 * r14950 10/trunk/bzflag/ (include/bzfsAPI.h src/bzfs/bzfsAPI.cxx): API functions to get the actual data for the compressed world and it's size.`
`18:29.13`	`Epyon`	`Comparision between char and int triggers a warning?`
`18:30.53`	`brlcad`	`JeffM: at 300 lines it shouldn't be too hard to add support..`
`18:31.16`	`JeffM`	`brlcad, what is 300 lines?`
`18:31.38`	`JeffM`	`oh I've grabed the 10 lines I need allready :)`
`18:32.25`	`blast007`	`daxxar: whoopsie, sorry about that ;)`
`18:33.13`	`CIA-23`	`BZFlag: 03chaos-dev * r14951 10/trunk/bzwgen/ (Makefile bzlgen.vcproj lexer.l): A couple of hacks to get rid of the GCC warnings`
`18:33.31`	`Epyon`	`TD-Linux, there should be no warnings now.`
`18:33.40`	`Epyon`	`Constitution, ping?`
`18:33.41`	`daxxar`	`blast007: ;-)`
`18:34.13`	`Epyon`	`Okay, I'm off to get food, be back in 10-20 minutes`
`18:38.21`	`blast007`	`JeffM: I'll test out the changes after work today`
`18:38.27`	`JeffM`	`k`
`18:42.06`	`brlcad`	`~Epyon++`
`18:52.15`	`CIA-23`	`BZFlag: 03daxxar * r14952 10/trunk/bzflag/ (12 files in 4 dirs):`
`18:52.15`	`CIA-23`	`BZFlag: Added bzrobot.i, the SWIG interface file.`
`18:52.15`	`CIA-23`	`BZFlag: Added makerules to build python bindings. (make bzrobot.la)`
`18:52.15`	`CIA-23`	`BZFlag: Updated configure.ac for new --enable-bzrobots-python - this builds PythonLoader and the Python SWIG bindings.`
`18:52.15`	`CIA-23`	`BZFlag: svn:ignore generated files.`
`18:52.17`	`CIA-23`	`BZFlag: Separated request#process to RCRequests_Process.cxx & RCRequests_ProcessSWIG.cxx (nasty, but it enables me to compile python bindings without a bunch of deps).`
`18:52.22`	`CIA-23`	`BZFlag: TestRobot.py now actually creates a robot! (But this isn't used properly yet)`
`18:53.06`	`daxxar`	`There, just wanted to get that into SVN before I hit the shower, and then get beeping wasted. ;-)`
`18:53.37`	`tannerld`	`oooo`
`18:54.09`	`daxxar`	`The Python interpreter doesn't actually do anything with what def create(): returns from TestRobot.py`
`18:54.23`	`daxxar`	`I need to do some SWIG magic to convert it to a BZAdvancedRobot, and then it should work. :-)`
`18:54.31`	`daxxar`	`I'll prolly do it tomorrow`
`18:58.55`	`brlcad`	`cool`
`19:01.40`	`brlcad`	`great conditional support too`
`19:02.37`	`Deepa`	`bzrobot?`
`19:08.32`	`daxxar`	`brlcad: Thanks. :-)`
`19:11.00`	`daxxar`	`I also removed all deps on python-config, since it AFAIK is a third-party util`
`19:11.10`	`daxxar`	`(i.e. not a part of the core python distrib)`
`19:11.32`	`brlcad`	`ah, good to know`
`19:12.00`	`brlcad`	`rarely can rely on -config scripts regardless, usually have to account for 'some' system that has lib without a *-config`
`19:12.57`	`daxxar`	`I haven't tested how it behaves on a non-python system (with --enable-bzrobots-python it should fail during ./configure), but it compiles cleanly without --enable-bzrobots-python`
`19:23.14`	`daxxar`	`Anyway!`
`19:23.22`	`daxxar`	`Heading out to enjoy some fine weather, company and beer!`
`19:24.07`	`Epyon`	`How can I cleanly pass a char* to a func that requires string& ?`
`19:24.34`	`brlcad`	`Epyon: take the reference before the call`
`19:24.44`	`Epyon`	`e.g?`
`19:24.59`	`brlcad`	`std::string foo = std::string(mychar); func(foo);`
`19:25.18`	`Epyon`	`ah, ok. That's the cleanest way?`
`19:25.43`	`Epyon`	`Why can't I do foo(std::string(mychar)) instead?`
`19:25.57`	`Epyon`	`func(`
`19:26.28`	`brlcad`	`because you can't take a reference to a temporary`
`19:26.32`	`TD-Linux`	`it takes forever to make any money in trukz :(`
`19:26.33`	`brlcad`	`at least not reliably`
`19:26.36`	`TD-Linux`	`oops`
`19:26.38`	`TD-Linux`	`wrong channel`
`19:32.34`	`Epyon`	`Ok, WTF?? : error : 'std' : is not a class or namespace name`
`19:33.18`	`brlcad`	`missing a header perhaps`
`19:33.30`	`Epyon`	`I have <string> in`
`19:35.06`	`Constitution`	`Epyon: pong`
`19:35.33`	`Epyon`	`Constitution, try compiling bzwgen now, it should be ok now.`
`19:35.50`	`Epyon`	`There's also a change -- the textures are in their own directory now (media)`
`19:35.58`	`Constitution`	`ah, okay`
`19:36.24`	`Epyon`	`Constitution, you're on linux right?`
`19:36.28`	`Constitution`	`yes`
`19:36.37`	`Epyon`	`so you should have bison and yacc.`
`19:36.43`	`Constitution`	`heh, "make: bison: Command not found"`
`19:36.44`	`Epyon`	`err, flex`
`19:36.56`	`Epyon`	`lol o.O`
`19:37.02`	`Constitution`	`hehe`
`19:37.08`	`Epyon`	`apt-get something xP`
`19:37.19`	`Epyon`	`and check if you have flex`
`19:37.38`	`Constitution`	`I need to go to work in a few minutes... can we work on this further in about an hour?`
`19:37.47`	`Epyon`	`No problem :)`
`19:37.55`	`Constitution`	`okay`
`20:03.05`	`*** join/#bzflag TD-Linux (n=TD-Linux@about/essy/indecisive/TD-Linux)`
`20:26.22`	`*** join/#bzflag jude- (n=jude@c-68-84-206-92.hsd1.ar.comcast.net)`
`20:26.28`	`jude-`	`hello all`
`20:26.35`	`jude-`	`~Epyon++`
`20:26.39`	`jude-`	`~daxxar++`
`20:26.44`	`jude-`	`~JeffM++`
`20:26.46`	`jude-`	`DTremenak++`
`20:26.52`	`jude-`	`~DTRemenak++`
`20:27.36`	`tannerld`	`hi jude-`
`20:28.04`	`Epyon`	`Sorry xP`
`20:28.14`	`jude-`	`nothing to apologize about`
`20:28.25`	`jude-`	`it's a GOOD thing :)`
`20:28.40`	`jude-`	`lots of commits ==> better BZFlag game :)`
`20:29.37`	`JeffM`	`not always`
`20:29.42`	`JeffM`	`I often break things :)`
`20:30.24`	`blast007`	`JeffM: nah, I broke stuff this time ;)`
`20:30.38`	`jude-`	`JeffM: you're karma increase was for spelling "intangibility" correctly, then :)`
`20:30.41`	`blast007`	`killed daxxar's poor bots`
`20:31.05`	`Epyon`	`Is there something bad about having Class pointers in unions?`
`20:31.05`	`tannerld`	`jude-: lol`
`20:31.20`	`jude-`	`Epyon: not that I'm aware of`
`20:31.30`	`jude-`	`a pointer is a pointer is a pointer :)`
`20:31.37`	`Epyon`	`error C2143: syntax error : missing ';' before '*'`
`20:31.38`	`jude-`	`still 4 bytes (or 8 on 64-bit systems)`
`20:32.04`	`jude-`	`Epyon: check your #include's and your declarations`
`20:32.15`	`Epyon`	`in typedef union YYSTYPE { ProductVector *pv; } YYSTYPE;`
`20:32.38`	`jude-`	`hmmm...`
`20:33.10`	`jude-`	`try removing the first "YYSTYPE"`
`20:33.20`	`jude-`	`also, did you include the header that defines the ProductVector interface?`
`20:33.26`	`Epyon`	`no difference`
`20:33.28`	`Epyon`	`Yes`
`20:33.45`	`jude-`	`...and you're sure there aren't any #ifdef's in that header that would prevent it's declaration?`
`20:34.04`	`Epyon`	`Nope, MSC highlights those :/`
`20:35.38`	`jude-`	`...cause that code (replacing ProductVector with one of my classes) works for me so far`
`20:35.56`	`jude-`	`which makes me think it's an include error`
`20:36.00`	`jude-`	`try this:`
`20:36.01`	`*** join/#bzflag Constitution (n=Constitu@gateway.pct.civiltec.com)`
`20:36.26`	`jude-`	`"class ProductVector; typedef union YYSTYPE { ProductVector* pv; } YYSTYPE; #include "ProductVector.h" "`
`20:36.51`	`jude-`	`i.e. declare ProductVector, but include the interface AFTER the definition of the union`
`20:37.28`	`Epyon`	`No difference`
`20:38.12`	`jude-`	`correction: you're code worked without the first "YYSTYPE"`
`20:38.32`	`jude-`	`i.e. typedef union { ProductVector* pv; } YYSTYPE;`
`20:38.56`	`brlcad`	`just like structs -- can't name the union the same as the typedef`
`20:39.07`	`brlcad`	`and probably don't want anonymous structs/unions`
`20:39.22`	`brlcad`	`but not a big deal`
`20:39.39`	`jude-`	`i.e. replace the first occurrance of "YYSTYPE" with "_YYSTYPE" or something like that`
`20:40.04`	`brlcad`	`yeah, it doesn't really matter what, just gives the compiler something to work with`
`20:41.27`	`*** join/#bzflag tannerld1 (n=tanner@adsl-068-209-251-067.sip.asm.bellsouth.net)`
`20:46.12`	`Constitution`	`Epyon: installing bison and flex worked, but I'm getting a warning: lexer.cxx:1155: warning: ?void yyunput(int, char*)? defined but not used`
`20:46.32`	`Constitution`	`and warnings are being treated as errors`
`20:52.27`	`Epyon`	`But it's not defined ;(`
`20:52.46`	`Epyon`	`Constitution, do you have the lastest revision?`
`20:54.02`	`Constitution`	`yes`
`20:54.51`	`Constitution`	oh wait... I forgot to "make clean"... now it says: "make: *** No rule to make target `OSFile.cpp', needed by `bzwgen'. Stop."
`20:55.36`	`Constitution`	`this sounds really weird... but is it possible that "make clean" is deleting TextUtils.cpp, commandArgs.cpp, and OSFile.cpp?`
`20:56.07`	`Epyon`	`giggles`
`20:56.12`	`Epyon`	`Yep, possible.`
`20:56.41`	`Epyon`	`I'm gonna fix that.`
`21:00.57`	`*** join/#bzflag a_meteorite (n=a_meteor@unaffiliated/ameteorite/x-000000001)`
`21:01.26`	`jude-`	`Epyon: did you get it to compile?`
`21:02.32`	`*** join/#bzflag BenUrban (n=benurban@unaffiliated/benurban)`
`21:02.48`	`tannerld1`	`heh`
`21:03.00`	`Epyon`	`Now I get syntax error : missing ';' before ':' :/`
`21:03.06`	`Epyon`	`What the hell :/`
`21:03.10`	`Epyon`	`In a switch statement`
`21:03.42`	`Epyon`	`OMG`
`21:03.49`	`Epyon`	`OMG OMG OMG`
`21:03.53`	`A_Heart_Attack`	`...`
`21:03.59`	`Epyon`	`The stupidest error ever :D`
`21:04.36`	`jude-`	`don't explode, Epyon; it can't be that bad`
`21:04.50`	`jude-`	`lol`
`21:05.04`	`a_meteorite`	`Pascal... eeek...`
`21:05.32`	`jude-`	`indeed`
`21:05.41`	`Epyon`	`FreePascal FTW ;]`
`21:05.45`	`jude-`	`Delphi, maybe. Pascal, no`
`21:05.54`	`Epyon`	`FreePascal > Delphi`
`21:06.07`	`jude-`	`Delphi is OO`
`21:06.12`	`Epyon`	`Delphi not portable, FreePascal/Lazarus is :)`
`21:06.44`	`jude-`	`at least, not yet`
`21:07.29`	`jude-`	`wait--Kylix is a delphi compiler for *nix`
`21:07.41`	`CIA-23`	`BZFlag: 03chaos-dev * r14953 10/trunk/bzwgen/ (7 files): Product/Products/RuleSet initial stubs implemented and recognized.`
`21:08.12`	`Epyon`	`But Kylix and Delphi are incompatible. Freepascal is compatible with both, and adds a lot more compatible targets.`
`21:08.24`	`Epyon`	`"Write once, compile everywhere xP"`
`21:08.44`	`jude-`	`sounds like C++`
`21:09.13`	`Epyon`	`jude-, including the GUI.`
`21:09.23`	`jude-`	`pascal has a built-in GUI?`
`21:10.18`	`Epyon`	`jude-, Lazarus provides a architecture on which you build your GUI, and it's compiled to WinAPI on windows, GTK on Linux, Carbon on OSX, and a few others including WinCE`
`21:10.21`	`Constitution`	`Epyon: RuleSet.h:34:30: error: no newline at end of file ;-)`
`21:10.58`	`CIA-23`	`BZFlag: 03chaos-dev * r14954 10/trunk/bzwgen/RuleSet.h: Ummm, a lost newline... :/`
`21:11.14`	`Epyon`	`Constitution, I'm fixing that cpp stuff right now`
`21:11.18`	`Constitution`	`okay`
`21:11.33`	`jude-`	`sounds like Swing in Java, only less consistent`
`21:12.04`	`Constitution`	`also, the original warning about yyunput() defined but not used is still showing its face`
`21:12.32`	`Epyon`	`jude-, http://www.kanzelsberger.com/pixel/?page_id=5`
`21:13.00`	`Epyon`	`One program, native interface on every system :P`
`21:15.18`	`jude-`	`right`
`21:15.34`	`Epyon`	`Constitution, try removing the CPPFLAGS = -I../bzflag/include line from the Makefile and see if it compiles...`
`21:15.50`	`Epyon`	`Because I think it's unneccesary`
`21:17.38`	`CIA-23`	`BZFlag: 03chaos-dev * r14955 10/trunk/bzwgen/ (7 files): Renamed the GPLib files to cxx to provide consistency and not to confuse the poor Makefile.`
`21:18.28`	`Epyon`	`Constitution, now make clean then build and tell me exactly what warning you're getting`
`21:19.48`	`*** join/#bzflag Blue_Eyes (i=Blue@host245-229.pool212171.interbusiness.it)`
`21:21.27`	`jude-`	`~Epyon++`
`21:21.28`	`jude-`	`a lot`
`21:21.34`	`Constitution`	`Epyon: looks like the files are safe, and it compiled when I got rid of -Werror`
`21:21.52`	`Epyon`	`Where's the warning?`
`21:21.58`	`Constitution`	`lexer.cxx:1158: warning: ?void yyunput(int, char*)? defined but not used`
`21:22.48`	`Epyon`	`Constitution, can you paste me that line? bison works a little different there :)`
`21:23.06`	`Epyon`	`Best, pastebin me +/- 10 lines`
`21:24.27`	`Constitution`	`hm, okay`
`21:25.35`	`Constitution`	`http://bzflag.pastebin.ca/660275`
`21:25.56`	`Constitution`	`line 13 = line 1158 in the source`
`21:26.42`	`Epyon`	`Hmm any idea how I can easily make it "used"?`
`21:28.10`	`Epyon`	`Hmm, maybe adding its declaration before would help?`
`21:28.18`	`Constitution`	`comment it out until you use it?`
`21:28.43`	`Epyon`	`Constitution, can't, I don't even have it - it was generated by bison :p`
`21:28.49`	`Constitution`	`oh`
`21:29.56`	`Epyon`	`Constitution, try editing .y and removing the YY_NO_UNPUT define`
`21:30.17`	`Epyon`	`Sorry, the lexer.l`
`21:31.01`	`Constitution`	`still throws the warning`
`21:31.21`	`Epyon`	`Darn, I don't have the file so how I can fix it :/`
`21:31.40`	`Constitution`	`install linux in vmware ;-)`
`21:32.05`	`*** join/#bzflag bryjen (n=bryjen@63.147.94.149)`
`21:32.05`	`*** mode/#bzflag [+v bryjen] by ChanServ`
`21:32.06`	`Epyon`	`Sure that I have the time :/`
`21:32.31`	`jude-`	`use QEMU then`
`21:32.46`	`Constitution`	`Epyon: can you use a unix shell?`
`21:33.05`	`Constitution`	`I can just give you an account on my server`
`21:33.17`	`Epyon`	`one sec`
`21:33.43`	`Constitution`	`although a local solution would still make more sense IMHO`
`21:34.06`	`Epyon`	`try adding "void yyunput(int, char*);" in parser.y right under int yylex();`
`21:34.08`	`jude-`	`download Knoppix`
`21:35.34`	`Constitution`	`still warns`
`21:36.23`	`Epyon`	`Lol, I found a revision with that fix for another problem :P`
`21:39.38`	`bryjen`	`~bzpastebin`
`21:39.39`	`ibot`	`well, bzpastebin is http://pastebin.bzflag.bz a place to put large chunks of text to not flood a channel`
`21:44.22`	`brlcad`	`Epyon, yeah, just actually use it (hence why I mentioned that trick earlier) ;)`
`21:46.08`	`Epyon`	`brlcad, how can I "use" it without using it?`
`21:46.15`	`brlcad`	`bison has changed massively over the years, and isn't even the only parser that will likely be used by folks compiling`
`21:46.54`	`brlcad`	`do you have an error rule perhaps that aborts/exits?`
`21:47.25`	`Epyon`	`yep`
`21:47.37`	`brlcad`	`then call it after the exit`
`21:47.49`	`brlcad`	`yyunput(' ');`
`21:48.00`	`bryjen`	`http://pastebin.bzflag.bz/d51f67271`
`21:48.29`	`brlcad`	`with a note that it's just a hack to quell the warning`
`21:49.13`	`brlcad`	`bryjen: the header probably doesn't need a reference`
`21:49.35`	`brlcad`	`it's a reference to temp issue`
`21:50.19`	`brlcad`	`header says it's expecting a reference, and it probably is being passed one directly, so you either have to set it to a var so it can get the reference or make the interface not require a reference in the first palce`
`21:51.00`	`Epyon`	`brlcad, then I'd have a warning about unreachable code :P`
`21:51.19`	`*** join/#bzflag Winny (n=KyleVE@CPE0016b6de59f3-CM000f9fac8236.cpe.net.cable.rogers.com)`
`21:51.37`	`brlcad`	`it doesn't know it's unreachable`
`21:52.20`	`brlcad`	`and conceivably isn't necessarily unreachable with the right run-time bindings`
`21:52.44`	`brlcad`	`having it after a func call that is defined to not return is different than having it in an if (0) block`
`21:55.56`	`Constitution`	`brlcad: regarding worldEventManager, is the issue that it's being passed the return value of a function, and not a variable itself?`
`21:56.25`	`brlcad`	`that would be`
`21:59.01`	`brlcad`	`if the interface expects a reference, it can't take a reference to a temporary which includes return values from functions or defining vars in the function parameter list (e.g. foo(std::string("blah")) where foo() expects a std::string& is NFG, bad)`
`21:59.54`	`CIA-23`	`BZFlag: 03chaos-dev * r14956 10/trunk/bzwgen/lexer.l: Ugly fix for the last GCC warning.`
`22:00.09`	`Constitution`	`is there any advantage to using a reference rather than a pointer in this case?`
`22:00.23`	`Epyon`	`Constitution, try again plz.`
`22:00.25`	`Constitution`	`ok`
`22:01.56`	`Constitution`	`Epyon: compiles cleanly`
`22:02.03`	`Epyon`	`Yaaaay :D`
`22:02.07`	`brlcad`	`oops`
`22:02.14`	`Epyon`	`~Constitution++`
`22:02.24`	`Constitution`	`~Epyon++`
`22:02.29`	`Constitution`	`it was all you, buddy :-)`
`22:02.49`	`Epyon`	`Well, you were my eyes here xP`
`22:03.39`	`CIA-23`	`BZFlag: 03brlcad * r14957 10/trunk/bzwgen/lexer.l: try this instead to quell yyunput warning?`
`22:04.04`	`brlcad`	`does that also work?`
`22:04.21`	`bryjen`	`~brlcad++`
`22:04.59`	`bryjen`	`but now i remeber why i disabled bzrobots...`
`22:05.00`	`brlcad`	`bryjen: so did you make it a non-ref or save it to a var?`
`22:05.05`	`Epyon`	`LOL, a lot better and cleaner :D`
`22:05.28`	`Epyon`	`~brlcad++`
`22:06.03`	`brlcad`	`did it work? I didn't test it`
`22:06.04`	`bryjen`	`saved it to a var. iirc the event data can be changed (not so in this case, but others) so the functions may actually need refs`
`22:06.15`	`brlcad`	`ah, ok`
`22:06.16`	`Epyon`	`brlcad, worked for me. Constitution?`
`22:06.33`	`jude-`	`off-topic, but could someone direct me to the code in BZFlag that handles shear transformations defined by the BZW spec?`
`22:06.43`	`brlcad`	`bah.. sourceforge now only lets you upload one file at a time`
`22:06.46`	`Constitution`	`Epyon: compiles fine`
`22:06.59`	`brlcad`	`jude-: how the hell is that off-topic? :)`
`22:07.07`	`jude-`	`it's not about Epyon's code compiling`
`22:07.11`	`brlcad`	`heh`
`22:07.28`	`brlcad`	`"bzflag code" is always on topic :)`
`22:07.40`	`jude-`	`seriously, though--I've tried everything to get BZWB to mimic BZFlag's shear transformations, but no luck :(`
`22:08.23`	`brlcad`	`sushi:~/BZ/bzflag/src/bzfs morrison$ grep shear *`
`22:08.32`	`CIA-23`	`BZFlag: 03chaos-dev * r14958 10/trunk/bzwgen/ (Operation.h bzlgen.vcproj lexer.l parser.y): Operation stubs added.`
`22:10.58`	`CIA-23`	`BZFlag: 03bryjen * r14959 10/trunk/bzflag/configure.ac: fix configure with bzrobots disabled`
`22:11.29`	`jude-`	`woo! found it`
`22:11.51`	`jude-`	`is BZFlag's mesh transformation row-major or column-major?`
`22:13.13`	`CIA-23`	`BZFlag: 03bryjen * r14960 10/trunk/bzflag/src/bzfs/bzfs.cxx: stash this return value in a var to pass to the outer function`
`22:13.51`	`Constitution`	`~bryjen++`
`22:14.48`	`CIA-23`	`BZFlag: 03bryjen * r14961 10/trunk/bzflag/src/3D/FontManager.cxx: comment out unused param`
`22:15.51`	`Epyon`	`I'm going to the nightshop to buy a beer for latenight, be back in half an hour.`
`22:17.07`	`jude-`	`...that would be column-major`
`22:20.33`	`jude-`	`cool! it works now!`
`22:20.37`	`jude-`	`thanks brlcad!`
`22:20.49`	`TD-Linux`	`column-major`
`22:20.56`	`TD-Linux`	`oh, I see you beat me reading the backlog`
`22:21.00`	`brlcad`	`hm?`
`22:21.03`	`brlcad`	`what'd I do?`
`22:21.17`	`TD-Linux`	`<brlcad> sushi:~/BZ/bzflag/src/bzfs morrison$ grep shear *`
`22:21.20`	`brlcad`	`oh, shearing`
`22:21.31`	`jude-`	`I wasn't aware that BZFlag's matrix transformation code would be stored in a separate file`
`22:22.17`	`Winny`	`jerry spinger: had big TV show, but little brain`
`22:22.49`	`jude-`	`...and?`
`22:22.54`	`brlcad`	`and pockets stuffed with cash`
`22:23.17`	`Winny`	`sorry, was my random spew of the day`
`22:23.34`	`jude-`	`here's mine: Today is Debian's 14th birthday`
`22:24.00`	`Winny`	`woot`
`22:24.50`	`jude-`	`we're celebrating tonight at the local LUG`
`22:25.18`	`TD-Linux`	`do you celebrate for ubuntu's birthday?`
`22:25.22`	`jude-`	`nah`
`22:25.32`	`TD-Linux`	`hmm, a real LUG then :)`
`22:25.38`	`jude-`	`lol`
`22:26.23`	`brlcad`	`jude-: so I presume the lead, took you to libgame's shear() func?`
`22:26.26`	`*** part/#bzflag LongDon (n=LongDon@host-091-097-072-058.ewe-ip-backbone.de)`
`22:26.36`	`brlcad`	`s/,//`
`22:26.53`	`jude-`	`it took me to the MeshTransform.cxx file, which showed how to create a shear matrix`
`22:27.08`	`brlcad`	`okay, good :)`
`22:27.18`	`jude-`	`it works quite well`
`22:27.26`	`brlcad`	`when all else fails, follow the white rabbit`
`22:27.36`	`jude-`	`indeed`
`22:30.27`	`jude-`	`*know`
`22:33.19`	`PrezKennedy`	`he doesn't`
`22:33.20`	`PrezKennedy`	`haha`
`22:34.13`	`jude-`	`I figured`
`22:39.52`	`Epyon`	`Duh, I go away for a while and suddenly everyone but me is on the red pill :/`
`22:40.21`	`jude-`	`lol`
`22:41.48`	`*** join/#bzflag spldart (n=troublem@c-98-197-19-35.hsd1.tx.comcast.net)`
`22:42.00`	`Epyon`	`Is there an easy way to delete all mebers of a vector?`
`22:42.15`	`Epyon`	`when the vector is vector <Foo*> ?`
`22:42.27`	`jude-`	`foo.clear()`
`22:42.42`	`jude-`	`(foo being the name of the vector)`
`22:43.25`	`Epyon`	`Foo is a class. Will foo.clear() call all Foos destructors?`
`22:43.38`	`jude-`	`to the extent of my knowledge, yes`
`22:44.13`	`jude-`	`vector bar<Foo*>; bar.erase(); // calls all of the destructors`
`22:44.26`	`Epyon`	`Is clear automatically called when bar is out of scope?`
`22:44.38`	`jude-`	`no, bar's destructor is called`
`22:44.46`	`jude-`	`which, in turn, destructs all the Foo's`
`22:44.51`	`jude-`	`wait`
`22:44.53`	`jude-`	`strike that`
`22:44.58`	`Epyon`	`No, that would be stupid.`
`22:45.04`	`jude-`	`it destroys the POINTERs to Foo`
`22:45.12`	`Epyon`	`clear also?`
`22:45.16`	`jude-`	`right`
`22:45.28`	`Epyon`	`That was my point. How can you easily destroy all Foos?`
`22:45.42`	`L4m3r`	`use a loop?`
`22:45.47`	`jude-`	`for( vector<Foo>::iterator i = bar.begin(); i != bar.end(); i++ ) { delete i; *i = NULL; }`
`22:45.54`	`Epyon`	`L4m3r, no cleaner way? :/`
`22:46.00`	`L4m3r`	`one of the pitfalls of using pointers ;)`
`22:46.07`	`Epyon`	`What if I have a map?`
`22:46.11`	`jude-`	`use smart pointers if you don't want a loop :P`
`22:46.14`	`L4m3r`	`jude-: you forgot the erase`
`22:46.20`	`Erroneous`	`std::vector<Foo*>::iterator itr; for (itr = bar.begin(); itr != bar.end(); ++itr) delete itr;`
`22:46.30`	`jude-`	`++itr?`
`22:46.40`	`Erroneous`	`++itr is faster than itr++ (no temp copy)`
`22:46.46`	`Erroneous`	`good habit to get into ;)`
`22:46.52`	`jude-`	`L4m3r: is that necessarily as long as you don't try to deref the pointers again?`
`22:46.54`	`Epyon`	`What about the map?`
`22:46.59`	`Erroneous`	`same for map`
`22:47.01`	`Erroneous`	`use an iterator`
`22:47.14`	`jude-`	`only, do " delete i->second; "`
`22:47.16`	`Epyon`	`kk`
`22:47.18`	`Erroneous`	`right`
`22:47.26`	`L4m3r`	`jude-: oh, of course not... but I'm guessing that if you want to destroy all foos, then you probably want to empty the vector`
`22:47.37`	`Epyon`	`jude- ??`
`22:47.54`	`jude-`	`i->first is the first generic class in the map, i->second is the second generic class`
`22:48.00`	`Erroneous`	`std::map<int, Foo*>::iterator itr; for (itr = bar.begin(); itr != bar.end(); ++itr) delete itr->second;`
`22:48.06`	`jude-`	`right`
`22:48.06`	`L4m3r`	`Epyon: std::map::iterator points to an object called std::pair`
`22:48.06`	`Epyon`	`ah, ok`
`22:48.13`	`Epyon`	`kk`
`22:48.25`	`L4m3r`	`yeah, so you deref the key and data separately`
`22:48.55`	`*** join/#bzflag moonpix (n=username@201.66.236.64)`
`22:49.52`	`jude-`	`Epyon: the deref operators (* and ->) are overloaded in iterators such that it allows the programmer to access the data in the collection, rather than the iterator itself`
`22:50.20`	`Epyon`	`typedef std::map <std::string, Rule> RuleMap; <- is thos ok, or should the string be also `
`22:50.36`	`jude-`	`that works`
`22:50.43`	`jude-`	`but it doesn't necessarily have to be a pointer to a string`
`22:51.04`	`jude-`	`the std::map class has built-in comparison methods for std::strings`
`22:52.23`	`jude-`	`(IIRC)`
`22:54.34`	`*** join/#bzflag bier_ (n=bier@p54A50D47.dip0.t-ipconnect.de)`
`22:55.40`	`Epyon`	`hmm at delete itr; I get error C2440: 'delete' : cannot convert from 'ProductVectIter' to 'void *'`
`22:55.57`	`Epyon`	`shouldnt it be (*itr)?`
`22:56.01`	`jude-`	`yup`
`22:56.18`	`Epyon`	`Erroneous made an Error :P`
`22:57.20`	`jude-`	`where?`
`22:57.28`	`jude-`	`oh`
`22:57.32`	`jude-`	`indeed, he did`
`22:59.41`	`CIA-23`	`BZFlag: 03chaos-dev * r14962 10/trunk/bzwgen/GridGenerator.cxx: Removed unneccesary debug message.`
`23:02.58`	`CIA-23`	`BZFlag: 03chaos-dev * r14963 10/trunk/bzwgen/ (Mesh.cxx Mesh.h): Addec proper destructor.`
`23:06.40`	`CIA-23`	`BZFlag: 03chaos-dev * r14964 10/trunk/bzwgen/GridMap.cxx: Added proper destructor.`
`23:10.09`	`CIA-23`	`BZFlag: 03chaos-dev * r14965 10/trunk/bzwgen/ (Product.h Rule.h RuleSet.h parser.y): Proper destructors for Rules and RuleSets,integration of Rules into rulesets in the grammar.`
`23:10.57`	`Erroneous`	`hey, I got it right the second time :P`
`23:11.32`	`Epyon`	`Erroneous :P`
`23:19.39`	`*** mode/#bzflag [+v Erroneous] by ChanServ`
`23:22.57`	`CIA-23`	`BZFlag: 03chaos-dev * r14966 10/trunk/bzwgen/ (Operation.h Product.h parser.y): Products now include Operations, have proper destructors and are read properly by the parser.`
`23:27.48`	`Epyon`	`Hmm how can I get rand() to give me a random float in the 0..1 range...`
`23:28.34`	`jude-`	`rand() / RAND_MAX ?`
`23:28.50`	`Epyon`	`Hmm, might work`
`23:28.52`	`jude-`	`(float)(rand()) / (float)(RAND_MAX)`
`23:30.14`	`AAA_awright`	`jude-: http://us3.php.net/manual/en/function.lcg-value.php`
`23:32.54`	`CIA-23`	`BZFlag: 03judecn * r14967 10/trunk/bzworkbench/ (24 files in 13 dirs):`
`23:32.54`	`CIA-23`	`BZFlag: Mostly usability enhancements here...made the Rotator 3D cursor a bit more intuitive, made it so that selected objects`
`23:32.54`	`CIA-23`	`BZFlag: show their local, transformed axes when selected IN ADDITION to the 3D cursor, FINALLY got the "shear" transformation`
`23:32.54`	`CIA-23`	`BZFlag: to work properly, fixed up some transformation issues in bz2object during world saves, added the ability to link`
`23:32.58`	`CIA-23`	`BZFlag: teleporters (doesn't yet show up graphically yet, but they can be saved), and made some fixes in "material".`
`23:34.12`	`jude-`	`AAA_awright: rand() in C++ returns an int value between 0 and RAND_MAX`
`23:34.34`	`AAA_awright`	`headdesk C!`
`23:34.41`	`jude-`	`lol`
`23:35.08`	`AAA_awright`	`I... uh.. er... (this is embarrassing)... Had to prove a point?`
`23:35.18`	`jude-`	`hey, it works that way in PHP :)`
`23:35.25`	`jude-`	`no one's questioning that :)`
`23:35.55`	`CIA-23`	`BZFlag: 03JeffM2501 * r14968 10/trunk/bzflag/ (include/bzfsAPI.h src/bzfs/bzfsAPI.cxx): add bz_getNonPlayerConnectionOutboundPacketCount to get the number of outbound messages`
`23:36.01`	`AAA_awright`	`The syntax is exactly the same (except variables start with $, a brilliant idea in my opinion)`
`23:36.11`	`Epyon`	`foo->end(); is the last element, or the element after yje last?`
`23:36.23`	`jude-`	`Epyon: iterator?`
`23:36.37`	`jude-`	`foo->end() ==> element AFTER the last`
`23:36.45`	`Epyon`	`JeffM, talk about looooong names :P`
`23:36.47`	`jude-`	`(don't try to deref foo->end())`
`23:36.54`	`Epyon`	`jude-, okay, thanks :D`
`23:37.02`	`JeffM`	`it's descriptive :)`
`23:37.20`	`Epyon`	`JeffM, can't disagree with that xP`
`23:37.42`	`spldart`	`I believe we have a cheat running around the servers... WG and SW @ the same time... lookout server pwners`
`23:39.57`	`CIA-23`	`BZFlag: 03JeffM2501 * r14969 10/trunk/bzflag/plugins/ (8 files in 2 dirs): first shot at an HTTP based map transfer plug-in to speed up world loading by not using a push based protocol.`
`23:43.35`	`Constitution`	`autogen.sh fails on my machine: http://bzflag.pastebin.ca/660420`
`23:46.38`	`CIA-23`	`BZFlag: 03chaos-dev * r14970 10/trunk/bzwgen/ (Product.h Rule.h): Random product choosing for Rules`
`23:47.18`	`CIA-23`	`BZFlag: 03judecn * r14971 10/trunk/bzworkbench/objects/bz2object.cpp: Shear the object BEFORE spinning it; update the object's attitude as well as it's spin transformations when parsing.`
`23:47.52`	`Epyon`	`judecn, you got some bzworkbench screenies?`
`23:47.54`	`JeffM`	`what content type should a map be?`
`23:48.00`	`jude-`	`Epyon: check my blog :)`
`23:48.07`	`jude-`	`bzworkbench.wordpress.com`
`23:48.10`	`Epyon`	`~jude-`
`23:48.11`	`ibot`	`rumour has it, jude- is an all around great guy who's working on BZWorkbench as his Google Summer of Code project for BZFlag. see also #bzflag or http://bzworkbench.wordpress.com/`
`23:49.26`	`Epyon`	`~jude-++`
`23:49.31`	`jude-`	`:)`
`23:49.34`	`jude-`	`~Epyon++`
`23:49.41`	`Epyon`	`xD`
`23:50.44`	`Epyon`	`Well since a week there havn't been any visual changes. That will change tommorow :D`
`23:51.00`	`Epyon`	`BTW, do you have mesh support?`
`23:51.03`	`jude-`	`ooooo`
`23:51.03`	`jude-`	`~Epyon++`
`23:51.06`	`jude-`	`not even close`
`23:51.26`	`Epyon`	`Darn, I wanted to see if it could handle my maps :P`
`23:52.02`	`jude-`	`fortunately, I'm working on making it easier for other developers to add support for BZW objects, because chances are I won't get to them all myself :/`
`23:53.00`	`CIA-23`	`BZFlag: 03JeffM2501 * r14972 10/trunk/bzflag/plugins/fastmap/fastmap.cpp: send out the HTTP responce headers when sending back a map.`
`23:53.02`	`jude-`	`(after all, final review is in 4 days :o)`
`23:54.49`	`CIA-23`	`BZFlag: 03judecn * r14973 10/trunk/bzworkbench/dialogs/MainMenu.cpp:`
`23:54.49`	`CIA-23`	`BZFlag: Disabled the automatic generation of the red wall material for cones (proof-of-concept time is over; time to add`
`23:54.49`	`CIA-23`	`BZFlag: the dialogs that allow users to create and apply materials :) )`
`23:56.17`	`Erroneous`	`JeffM: application/octet-stream is probably best`
`23:56.59`	`JeffM`	`ahh I did application/binary`
`23:57.30`	`JeffM`	`tinyhttp only did text/HTML`
`23:57.45`	`CIA-23`	`BZFlag: 03JeffM2501 * r14974 10/trunk/bzflag/plugins/fastmap/fastmap.cpp: octet-stream not binary`
`23:57.46`	`Erroneous`	`yeah, which are maps are certainly not ;)`
`23:57.48`	`brlcad`	`Constitution: that's something for daxxar to sort out :)`
`23:57.50`	`JeffM`	`pl`
`23:58.16`	`JeffM`	`well it's untested, but all the features are in it :)`
`23:58.24`	`Constitution`	`brlcad: okay, but in the meantime the entire build process is broken :-\`
`23:58.27`	`JeffM`	`HTTP server in a plug-in :)`
`23:59.15`	`JeffM`	`Erroneous, how would you think about a dir that was auto scanned for plug-ins and loaded at launch?`

Generated by irclog2html.pl Modified by Tim Riker to work with infobot.