Just a reminder: if you like what you read here, you’ll love my new blog at http://magnao.com

It’s been a great 10 months and I’m moving up from WordPress hosting.

Thanks for reading and for commenting!

You can follow my new blog at magnao.

For those who are interested in running Linux, especially on an older PC, Xubuntu just might fit the bill. Its installation files fit on one disc and include a versatile window manager to boot. However, the basic install isn’t really capable of being a LAMP and FTP-enabled web server. This tutorial explains how to get there.

1. Get Xubuntu. Install it.
2. Open a terminal window and enter

   sudo tasksel install lamp-server

3. Provide the MySQL root password when prompted.
4. Open a terminal window and enter

   sudo apt-get install phpmyadmin

5. Then enter

   sudo apt-get install php5-gd

6. Enter the following into the terminal:

   sudo /etc/init.d/apache2 restart

7. Now, if you navigate to http://localhost/phpmyadmin, you should see the phpMyAdmin login screen
8. Next, let’s install an FTP server. In a terminal, type in

   sudo apt-get install proftpd gproftpd

9. Launch gproftpd. Add a user. Take out the following from /etc/proftpd/proftpd.conf:

   AllowOverwrite off

10. Activate the FTP server.
11. You’re done. Enjoy!

Questions, comments? Let me know.

This tutorial is written for anyone wishing to get started making maps in OpenArena or another ioquake3 game.

1. Get GtkRadiant.
2. Get openarena_gtkradiant.zip. Extract it into your GtkRadiant installation folder. If your OpenArena installation folder is not in C:\Program Files, open the GtkRadiant\games\oa.game file and change the enginepath_win32 variable to reflect the location of the installation folder.
3. Get Q3Map2Build and extract it to C:\q3map2build.
4. Launch C:\q3map2build\q3map2build.exe. Click Directory Options and set “Game executable” to your openarena.exe file, q3map2.exe location to q3map2.exe in your GtkRadiant folder, and bspc.exe location to bspc.exe in your GtkRadiant folder. Set BSP, VIS, LIGHT, and BSPC to Normal. Uncheck “Pause” under each item. Leave q3map2build open.
5. Launch GtkRadiant. When it prompts for a game, select OpenArena and uncheck “Show Global Preferences.”
6. Press P to bring up Preferences, go to Interface->Layout, and select the third layout option. Restart GtkRadiant afterwards. This will give you the old-fashioned Q3Radiant layout that is similar to major 3D applications.
7. In one of the non-camera viewports, click and drag out to form a rectangle. If the resulting prism is too short, drag up in another viewport to bring it up to the desired size. Press T to bring up the Texture Browser, double click on “base,” and open “base_wall.” Click on “concrete” and press T to close the browser. Then click the Hollow button (it’s the one before the button with the white cube, it looks like a square with a perforated square outline inside).
8. In the middle of this new hollow room, right click on the map and select “light.” Enter 850 for intensity, press Enter, and press Esc.
9. Above the floor of the room, right-click and select “info”->”info_player_start.” If the item isn’t in the room and above the floor, click and drag it to where it needs to be. Press Esc when done.
10. Repeat the above procedure and put another info_player_start entity in the map, away from the first one.
11. Right-click on the map again and insert a “weapon”->”weapon_shotgun.” Press Esc when done.
12. Save the map in your openarena\baseoa\maps folder as test.map.
13. Go back to q3map2build and click Refresh. “baseoa/maps/test.map” should show up in the “Maps” list. Select it and press Build. Check your maps folder afterwards. There should be four files (excluding test.bak): test.bsp, test.map, test.srf, and test.aas. If there aren’t four files, there’s a problem with the map and you should start over.
14. Launch OpenArena. Pull down the console with the ~ key. Type /sv_pure 0 and press Enter. Then, type /map test and press Enter.
15. You should spawn in a brightly lit room with a shotgun nearby. Pull down the console and type /addbot grunt 3, and press Enter. This should spawn a bot.
16. That’s it! For more about GtkRadiant operation, see GTKRadiant Tutorials and Q3Radiant tutorials. Enjoy!

Here’s a video companion to the tutorial:

I decided to make some maps for OpenArena (and learn GtkRadiant in the process), so here’s my first map, dubbed oax_dm1. It’s a simple space map with 5 spawn points, a teleporter, a platform with a lightning gun, a rocket launcher, armor, a bevy of health and armor shards, and a somewhat precarious layout.

As you can see, nothing special, but pretty fast gameplay. The bots don’t fare too well here, even after I accommodated the gaps between the platforms with their own mini-platforms, so it’s best played with other people. Get the pk3 here, put it in your baseoa folder, and launch it by pulling down the console (~ key) and typing “/map oax_dm1″. Enjoy!

If you want to start developing GTK+ applications with MinGW, but don’t know where to begin, here’s a simple tutorial.

1. Get MinGW and MSYS. Install MinGW first, followed by MSYS.
2. When MSYS asks about continuing post-install, say yes. When it asks for MinGW, say yes, and provide the install directory.
3. Get the GTK+ bundle. Extract it into your MinGW install directory.
4. Get the tutorial files and extract them into your development directory. (1) (2)
5. Launch MSYS, cd over to your development directory.
6. Type “make” and press Enter.
7. Presto! Launch the file either in MSYS (by typing “hello”) or in Windows Explorer.

Notes: (1) The -mwindows flag hides the console window. The console window will never show when the app is launched from MSYS, so always launch from Explorer if you’re planning on releasing your work. (2) The makefile is already set up for multiple sources, so all you have to do is add .c files, separated by spaces to the SRC directive, and the rest will take care of itself. Enjoy!

“Complex” and “complicated” seem to be practically identical words. Both imply some sort of innate progress, some elevation above “simple” and “banal.” The words do differ, however. A lamp is complex, but it’s not complicated. A clock is complex, but not very complicated. A contract with a bank, however, is complicated, even though it might not be very complex. Red tape, bureaucracy, and inefficiency are symptoms of complicated systems. Computers to this day strive to become less complicated and more complex.

Think about it: does a plot in a book or a movie ever seem more complex or complicated to you? You might say that a “good” plot seems complex: it’s cohesive and there are developments across many levels that all mesh together properly. On the other hand, you might deem a “bad” plot complicated: there are too many uncertainties and deus ex machinas that mar an already ill-conceived story line. “Complicated,” then, seems more to describe solutions achieved in two dimensions, while “complex” seems to describe solutions achieved in three dimensions.

Think about relationships: under what circumstances would you call your relationship with someone “complex” or “complicated?” Here’s my take on it: a complex relationship is one where friendship, business, and networking all work on many levels, each turning a blind side to the others whenever necessary. A complicated relationship, on the other hand, seems to be one where friendship, business, or networking can barely subsist, marred with perennial conflicts, disagreements, and differences. A complicated relationship seems to be doomed to eventual dissolution. Try to describe a complex relationship. You might confidently describe all the various levels of the relationship and how they interact with each other. Try to describe a complicated relationship. Can you confidently describe all the various levels and their interactions? To me, it seems like a complicated relationship would have more to hide from the general public. A complex relationship is strong and while its strength is apparent to the general public, its inner workings are not.

It seems that a complicated system is an inevitable result of early growth. No good system ever comes about without being at least somewhat complicated. It may overshoot or undershoot its mark in certain objectives and may have to compensate for its initial failings by impromptu solutions. However, if a complicated system does not eventually revamp itself into a complex system, it will die off. Complexity is all about abstraction and interoperability. We as human beings are very complex, at least biologically (our personalities seem to rarely rise above complication). I posit that this is because we are very well abstracted and can reasonably well interoperate with one another. We’ve invented commonalities among ourselves because we are interoperable, like languages and sciences, and money.

What’s more impressive, though, is that our invented commonalities can interoperate with one another. A British professor can relate to an American lawyer when the stock they’d both purchased goes down in value. Their common dismay at these equally bad news results in equal drops in their portfolios. That’s complexity at work: abstracting away idiosyncrasies in order to make the result as portable as possible. Now think of this scenario again and try to see where the complicated part is in all of this. I bet you anything, the reason for the price drop in the stock has a very complicated nature. A long sequence of errs based on faulty information and emotional responses is the usual culprit when it comes to markets. It’s a good thing, then, that no lasting complex system exists for failure. Is such a thing even conceivable?

If you have a PHP application with a few include files, chances are you don’t want your users to navigate to them, by mistake or otherwise. So here’s a tiny script that checks if a user is looking at the include file by itself and redirects them to the proper place:

if(preg_match(“/includename/”,$_SERVER['PHP_SELF'])){
header(“Location:properlocation.php”);}

You don’t need to put \.php after includename, either, which makes this work on aliased extensions. A note: this is an adequate solution only for files that don’t contain sensitive data (such as passwords) that can’t be put in a directory above root. Enjoy!

The official Squirrel site provides source, but not an executable. If you don’t have time to compile or just want to get started using Squirrel right away, I’ve compiled the Squirrel interpreter for Windows and added the official samples for a quick test, along with the official docs. Run it with “sq filename.nut” to interpret a file, “sq -c filename.nut” to pre-compile a script, or just “sq” for an interactive prompt. You can get the file here: squirrel2.2.zip. Enjoy!

Here’s a simple tutorial that will show you how to run a Mono GTK-Sharp application under both Mono and the .NET framework. The general documentation leaves some parts out, so here’s a concise guide to getting that first application ready. This tutorial was written using Mono 1.2.6 with Gtk# 1.0/2.10 and .NET framework 1.0/1.1/2.0.

1. Get Mono, install with Gtk#
2. Get gtkgac1.0_2.10.zip, unpack in the latest .NET directory with gacutil.exe (on my system, it’s C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322) so that there is a gtkgac folder in the directory
3. Run gtk_gac1.0.bat and gtk_gac2.0.bat
4. Run gacutil in the .NET directory (to avoid running the Mono gacutil) like so: gacutil /l gtk-sharp. Two assemblies should appear, 1.0 and 2.10
5. Download hellogtk.cs into your development directory.
6. Compile with the following command: mcs -pkg:gtk-sharp-2.0 hellogtk.cs
   • To remove the console window, add the -target:winexe flag
7. Run with (.NET) hellogtk and with (Mono) mono hellogtk.exe
8. You’re done!