J-Space.dk

I’ve been fooling around with C# in my little spare time over the fast few weeks – this time the XNA framework.

What I like is the easily set up projects and the very few lines of code needed to set something up. However, the serious drawbacks are the possible platforms (primarily Windows and Xbox 360) and the broad focus. Optimally, I’d love to fool around with something of similar simplicity, but focused on 2D with both font and primitive drawing.

So now I’ve spent collectively two nights trying to compile ClanLib. I haven’t actually worked with the core C family of languages for several years (perpetual fear of pointers being a prime antagonist), and I’d forgotten how terrible it is working with headers and libs when coming from a world where a single DLL file seemingly contains everything you need from function definitions to code (both .NET and VB6 work with a simple referencing system). So, hoping for a similarly simple compiling solution found in Linux (./configure && make && echo “I’m happy!”) I sat down with the Visual Studio-oriented ClanLib Windows binaries. Almost instant failure. A few header errors were quickly solved (I’m not a complete düche), but the linker just went haywire in my face, regardless of using pre-compiled static libs or attempting to compile ClanLib myself. I tried searching Google for a few tips and found myself revolving around changing up a few project parameters to make the stuff cling. It half worked.

And then it struck me.

I run a x64 Windows system and one thing I hardly ever consider is the target platform I build for. VS supports both x64 and x86 compiling, but not against one another. I was felled by one of the dumbest errors in the book: not checking basics.

Anyway, ClanLib’s up and running, examples compile with nary a warning and I’m ready to start funning. However, the amount of code needed to set up a basic window seems to have gone up by a factor of ∞ to the power of Π.

Well, too tired to check it out now. Bath, bed, b-weekend…

Spending the weekend with a laptop without the necessary Python distro and modules, I’ve kept myself at work with a console-based approach to the visitation project. The shell simulation still lies as an excellent basis and has no problems running as a small self-contained command vessel. Right now I’m taking a break whilst looking at different approaches to option parsing. I think I’ve mentioned earlier that the OptionParser module in Python suits very well in principle, but I’ve discovered several innate implementation choices that makes it a bad choice for direct inclusion. One of the primary difficulties is the fact that if a user passes bad parameters to the parse, it will alert the user directly of the error (a formatting issue related to the rest of the script) and exit Python execution (a massive error, as it should continue running internally, allowing the user to attempt another call without having to call the superscript once more).

I could make a subclass, but there are so many unknown variables I’m afraid of handling with it, that I might just as well make my own implementation, albeit far simpler in structure (not much is required, really).

Well, back to work. Coheed and Cambria running in the background. Not bad.

After messing around with MySQLdb for Python for a night and a half, trying to figure out what I was doing wrong since I couldn’t connect to the remote server, I started wondering why “‘localhost” worked while running the script on the remote server and “<server-ip>” didn’t. Well, hardly for me to know, but it seems the default configuration of MySQL on some systems restrict connections to local ones.

Imagine that.

With that fixed I’ve come upon a couple of IDE’s I’ll put to the test. A current conundrum is laziness. I’m not in the mood to sit down with squared paper and calculate the intricate details of a perfected GUI design. I like the notion of wxPython’s FlexGridSizer which I’ll mess around with. I haven’t found a proper GUI designer I could easily get into (wxGlade seems like a hassle to work with, the Python-specific IDE’s each use some annoyingly specific bindings and IronPython can’t directly imported C extension modules), so I’ll go with that for the time being. Well, either that or implement it entirely through the functioning console. This hurts my head as well, though. I’ve never made a full-blown text app, and I’m not liable to complete the CLI any time soon.

Work is progressing smoothly, money is being saved as I garner more achievements in old games (working up a few New Game plus saves in Mass Effect, finishing off the last in Mirror’s Edge, Arkham Asylum and Fallout 3), and everything is just… so smooth.

Except for an annoying case of sinusitis. Then again, of all the bitter things that could hit me, I’ll take this as a blessing

Take care.

~T

Nothing’s really happened, but I felt the need to post something empty.

Watched a couple of 80′s action and sci-fi movies, the kind of movies I’d watch with deep fascination and a fantastical mindset as a child. I can still relate. Watching certain scenes, the visual impressions and sound effects bring certain fleeting moments of my childhood back to me. Short, static jolts of emotion shoot into my synapses, giving me lapses into times that were… and seeing these phrases makes me come to the conclusion that I was one screwed up kid.

Been messing around with the conf files of my web server (lighttpd) – finally made it eat the conf file for homestead.dk – the subdomain wiki now has a global function across all domains on the server.

Things on the board right now: fakeCLI/fakeOS/fake-whatever-but-it-simulates-bash, a targetting addon for WoW, a few short novellas flying around my brain and a start-up dream of a small dev community of authors for custom SC2 maps. I’ve seen videos of the level of customisation available (beat ‘em ups, top-down shooters, FPS’es)… now I just need to see RPG mechanics put into it. Project Storyteller under way.

Stevie! I’m idling in the old channel if you want to pop by. #Anachronox @ Freenode lives. Idling in a range of other channels, too, logging…

ADDED: Uh! I also want to fiddle with the DokuWiki plugin API – have an idea for an extremely simple and cute image insertion addon.

Learned about Python decorators today. Now my head hurts.

Seemed for a while I had finally found a programming language that wasn’t capable of blowing my cranial arteries, sending my neurons to a screeching halt all the while the very fabric of my soul attempted to escape the now-ravaged innards of my mind. Then decorators come along. So far I’ve come to the conclusion that they’re either overrated, unnecessary or meant for a train of thought not even Daedalus would attempt to achieve. In all cases I hope they aren’t what I’ll be needing when dynamically introducing new commands to fakeCLI (with the current design, this should not be the case).

Good news, as well. After fighting against Trac for about a fortnight I’ve stumbled upon the holy grail of my desires. Fossil. It contains exactly what I need (versioning, Wiki, tickets), with the amount of trouble I can handle (compile, install, host) and the perfect amount of targeted users (less than a shitload). Perfect. It should be running on this host, http://www.j-space.dk:8080/, right now. I’ve solved the issues I had with a proper system here, I think. I’ll still need to streamline local cloning and syncing, but that’s a non-issue, I’m sure.

Anyway, Boondock Saints running in repeat, Tellus/T-Chip crashing. Have a good one.

I’ve been hung up on work the past few days – or rather, I’ve been out of town and my netbook’s busted so the only Linux box I’ve had on hand was my iPhone (and I hate typing code on the small keyboard).

I’ve been thinking about how to implement an extensible model for calling applications. The design is painfully simple for Python (the called file in the virtual file system contains a function reference that gets called – done, and the proggy will have some form of access to the underlying virtual system), but I’d like to make a few considerations as to how to implement this further on a more flashier platform – say for example SDL (C/C++) or GameStudio (C#/VB.NET). The references to functions aren’t as straight forward, and to some degree the called functions must have something they can refer to or make callbacks at to make sure they have an outlet for output.

Anyway, just a few random thoughts while gaming E.V.O. on a SNES emulator for the PSP, reading Bearing an Hourglass.

Lowering the bar and setting more decent standards, I’m writing a Command-line simulation in Python.

Goals are input, argument seperation, virtual file system calls resulting in either application calls or error messages.

While function pointers are simple to implement in Python (yay!), it seems like a greater challenge on how to populate a list (in this case, for example, a virtual directory of executable “files”) dynamically. Can Python loop through a series of modules, analyse their contents generically, and add their classes or functions to a list dynamically? Probably yes, easy – not so likely.