I like to run my Minecraft server from a cron job so that I can have a script check once a minute if it’s running (and restart if if necessary, without any manual intervention). But that makes it very tricky to send commands to the server console to automate the backup. What to do?
A colleague of mine suggested using the “screen” command (here’s an example of using screen to automate Minecraft backups), but I hit upon another solution that I like better: I use a simple script to read commands from a file and echo them, and I launch the Minecraft server by piping my command reader script to it.
Here’s the script I run as a cron job to keep my Minecraft server running:
# check if the server is running and store that info in a variable:
RUNNING=`ps -ef | grep minecraft_server | grep -v grep`
if [ -n "$RUNNING" ]; then
# log the fact that it is running:
date > running.txt
# relaunch sequence
# stop the command reader:
echo stop > cmdfile
# give the command reader time to stop:
# clear the command file, in case the command reader wasn't running:
truncate --size 0 cmdfile
# log the restart and try again:
date > restart.txt
/home/myusername/bin/commandReader.sh world | ./launchserver.sh
I save that script in my bin folder as keepMinecraftRunning.sh and add this line to my crontab (using crontab -e):
* * * * * /home/myusername/bin/keepMinecraftRunning.sh
And here’s the commandReader.sh script that sends commands to the Minecraft server:
# set what time to make the backup:
# make sure the command file exists:
while [ "$COMMAND" != "$STOP_CMD" ] ;
if [ -n "$COMMAND" ]; then
truncate --size 0 cmdfile ;
echo $COMMAND ;
# wait a few seconds before reading the command file again:
sleep 5 ;
# if it's backup time, make the backup:
CURR_TIME=`date +%H%M` ;
if [ "$CURR_TIME" = "$BACKUP_TIME" ] ; then
echo save-all ;
echo save-off ;
CURR_DATE=`date +%Y%m%d` ;
# $1 is the argument, which should be the name of your world (eg. "world")
# This makes a daily tar of your world, in a file like world_20121021.tar
tar cf $1_$CURR_DATE.tar $1 ;
echo save-on ;
# wait a minute to avoid saving twice:
sleep 60 ;
I save this script in my bin as commandReader.sh. Aside from making the backup, the script simply reads whatever is in the file “cmdfile” (created in the minecraft server directory), pipes the command to the minecraft server, and clears the file. So if I open any terminal on the machine running the server, I can simply send commands to my Minecraft server like so:
echo "time set 0" > /home/myusername/minecraft_server_folder/cmdfile
And echoing “stop” into the file stops both the Minecraft server and the command reader script.
In my minecraft server folder, I put a script called launchserver.sh. This can be just the standard launch command line (
java -Xmx1024M -Xms1024M -jar minecraft_server.jar nogui), but I found the server performs better if I use a script that calculates the appropriate amount of memory — see the script here.
Then — with the server taking care of itself — I can get back to the important business of building castles!
I’m usually more interested in implementing video games than in anaylzing video game design, but I think the success of Minecraft alongside the failure of Lego Universe provide a really interesting example.
First of all, I love Legos — they’ve been my favorite toy forever — and I have two little boys (ages 10 and 9) who also love Legos. Last year, when Lego first announced Lego Universe, I looked forward to trying it out. I figured that my kids were about the age where they’d be wanting to play online multiplayer video games soon, and rather than fight it, I might as well steer them towards more interesting ones. So we signed up for the free version, and played it a bit. It wasn’t addictive, but I didn’t expect it to be. I figured I’d probably sign up for the paid version at some point, but never quite got around to it.
Then one day my younger son was watching Lego videos on YouTube, and YouTube’s sidebar of related videos turned up a Minecraft video. My son watched it and was hooked. He spent so much time watching YouTube videos of people playing Minecraft that my husband figured it was ridiculous for him to watch the game so much and not play it, so he bought him a Minecraft account. And after watching my son play this game just a little, I knew I had to get myself an account, and one for my other son. And we have had a fantastic time playing together!! Here’s a video we made of us playing attack/defend the tower:
Right off the bat, I became wildly hooked on this game! It’s really unlike me, too, because I don’t normally play video games all that much — I certainly don’t generally spend hours on end playing a video game! But it hit me that a lot of what makes this game so much fun is kind of the same thing that makes it so much fun to play with Legos. Watch this video I made about strategies for constructing a defensive fortress, and see if you see what I mean:
Basically, you have the raw materials to build whatever you want, and the game is totally open-ended about what your objectives are. If you want to build the most amazing building/city/castle, you can. If you want to go around fighting monsters, you can — and you can figure out and build tricky traps for them if you like (but you don’t have to). If you want to go on a scripted, pre-set adventure, you can. Just go to YouTube and look for different Minecraft challenges — you can download different obstacle courses and adventure maps that other people have constructed. What’s more, if you want to script/construct an adventure for other people to play, you can! Just upload a video of it to YouTube when it’s done. (Minecraft makes it fun for users to share content.)
This is part of the same reason why Lego toys have such universal appeal. My kids like the story of the Ninjago universe, for example, and play stories of the characters that Lego invented for them. However, if you’d rather just use your own ideas to build something, you can. Here’s a tree-house I built a while ago:
The biggest additional appealing element that Minecraft has (but Lego doesn’t) is the three-dimensional environment made of blocks. Since virtual blocks are free, why not? And Minecraft has a really good algorithm for generating interesting landscapes and cave systems. I’ve found it’s actually kind of fun to simply wander around and explore the randomly-generated world. Another fun thing is that you have the choice of setting it to “creative mode” — where you can have an infinite number of any brick or item you need — or to “survival mode”, where there’s a bit of challenge involved in finding or making the blocks and items you want.
Playing the video game that got it right made it crystal clear what Lego Universe did wrong. In a nutshell, Lego Universe was way too scripted.
I watched/helped my son play Lego Universe, and we were given a set scene and a long series of trivial tasks to perform in order to advance through the game. The worst part was that they scripted what your character needs to “build”. I put “build” in quotes here, because, really, you just press a button and your mini-figure waves its little arms, and the item you need to build in this part of the script just appears. (I understand that the paid version was more open-ended, but I never saw it because we were kind of turned off by the free part.) Contrast this with Minecraft, where — using a handful of mechanical/electrical pieces — people build all sorts of different machines, from simple vending machines to entire, functioning computers! There are simple formulas you can build if you want to (like golems), but mostly the raw materials are pretty simple and open to possibilities.
When Lego Universe first shut down, they posted a video explaining what had happened. I think they’ve since taken it down (because I can’t find it anymore), but the striking part was that they’d started out with a more open-ended game, and did some focus groups, and some twelve or thirteen year old kids told them they’d rather have a more scripted game. So Lego came up with a rather generic evil universe storyline — of the same variety that every toy company uses to sell toys to boys ages five to fifteen. This shows the danger of trying to use focus groups for the original ideas of your product. Obviously twelve-year-old kids are going to tell you to just copy some other games that they like.
Normally this sort of story wouldn’t be surprising at all: a clever individual comes up with a brilliant idea that that giant, bureaucratic corporation couldn’t/didn’t think of. It just surprised me because Lego Group has generally done a very good job of staying ahead of the game in terms of good ideas. The Ninjago series is more interesting and fun than similar, competing toy lines like Bakugan and Beyblade. The surprise mini-figure packs at the toy store checkout counter are a fun impulse item — and something that other toy companies have since copied. They have a good mix of theme construction sets (like Star Wars and Harry Potter) along with sets that start you making your own story, like City and Castle. They have a huge number of simple pieces, and you can use the ideas from the sets to make interesting things out of them, or come up with your own construction ideas. Even their Advent Calendar had a bunch of clever ideas for making interesting items out of simple raw materials. Plus, they figured out that a good part of their customer base is actually adults — and they came up with a series of sets that are marketed to adults, like the elaborate London Tower Bridge.
In twenty-twenty hindsight, I think Lego’s biggest error was to leave too much of the planning of Lego Universe to their (very successful) video game department, instead of leveraging what people like about Lego toys. The video game department is successful largely because people love Lego’s iconic mini-figures, which make a fantastically easy-to-animate set of characters for video games. That’s great, but something that’s “Lego Universe” should feature more of Lego’s universal appeal. Since they intended their video game to be for kids and teens on the young end of online multi-player gaming, they were foolish not to take advantage of the fact that the parents (the ones with the wallets) often enjoy playing Legos with their kids — and make a game that’s fun for parents who like to build things.
I imagine that Lego will come out with a copycat game. They would be foolish not to. But I hope they get their ideas team in gear and add something really new to it themselves, and don’t just make a pale imitation of Minecraft.
As I said the other day, I started my space explorer game by trying out a bunch of different ways to animate the rocketship flying through space. (I’ve bundled all the source code and resources for the complete example — you can download it here.) I started by just creating a standard MIDlet using the javax.microedition.lcdui.game classes. Here’s what it looks like in the debugger:
In the image, I’ve set the debugger to show memory usage. In this case it’s “lcduispace” — the top process on the list. Next, I decided to try out the technique I described in my earlier post: use the same lcdui game implementation, but write each frame into an image buffer and transfer it from the MIDP Graphics implementation to RIM’s proprietary implementation to display it in a RIMlet. Here it is in the debugger: Read more »
When I first started programming for BlackBerry, one of the things that struck me as most odd was the two completely independent graphics APIs. For MIDlets, there’s javax.microedition.lcdui.Graphics, and for RIM’s own profile, there’s net.rim.device.api.ui.Graphics. The two versions are so similar to one another that — if you’re careful — you can write a game that can use either of the two graphics APIs interchangeably, just by swapping out the include statements (and using a different set of lifecycle classes). That’s what I illustrated in Chapter 3 of my book.
But I wondered: What if I want to use the javax.microedition.lcdui.game package? But I still want to take advantage of RIM’s proprietary UI component handling? Is that even possible? Note that you can’t just place an LCDUI Sprite onto a RIM Screen or use lcdui Images interchangeably with RIM Images. Yet, there’s nothing to stop you from instantiating many of the lcdui graphics-related classes in a RIMlet — either type of application has access to the whole API.
Through experimentation, I found that it’s quite possible to take a game that was written using lcdui game Layers and run it in a RIMlet. The trick is the following: Read more »
I’ve got some BlackBerry posts coming up, but first I’d like to say a few words about why I haven’t posted anything in six months. There are two reasons:
- I don’t like Windows OS. I’ll use it if I have to, but for my dev environment at home, I was just too tempted to clean the hard drive (once I’d finished my BlackBerry book), and replace the OS with Linux. Naturally, I told myself I’d set my BlackBerry dev environment back up on some other machine or in a virtual machine or something, and — since I love installing Windows so much — you can imagine that that task hasn’t come to the top of my “to do” list.
- I’m excited about my current job, and it’s something completely different: QA engineering for Dybuster.
Dybuster is a software suite that helps dyslexic kids learn to read. For the kids it’s a game. It works by giving the kids additional ways to learn words, using colors, tones, and 3D graphical representations:
Since I’ve been testing it, I can say that it has definitely improved my spelling in German. Of course I’m not Dyslexic.
And, fortunately, there’s an English version available too (including a free downloadable demo version).
So, my new book — written with co-author Andrew Davison — is done and ready to go!
Have a look at the book’s website to get an idea of what you’ll see:
- Chapter 1. Gaming on BlackBerry!
- Chapter 2. BlackBerry Application Basics
Why are there two types of BlackBerry Java applications? What are all those crazy files the compiler generated? And – most importantly – how do I get an application complied and running on my BlackBerry smartphone? Chapter 2 will answer all of these questions, plus help you set up a professional build with Ant.
- Chapter 3. Game Graphics and Events with MIDP and RIM Classes
Using the classic Maze game as an example, you’ll see exactly how the two types of BlackBerry Java applications differ. You get an in-depth look at how the lifecycle, events, and graphics work in both cases so you’ll be ready to develop whichever kind is best suited to your game’s needs.
- Chapter 4. Adding a Professional Look and Feel
Gorgeous graphics are critical for the game experience. To get your game’s visual theme pixel-perfect on every model, BlackBerry gives you the tools, and Chapter 4 explains how to use them.
- Chapter 5. Security and Selling Your Game
As much as you love games for their own sake, at the end of the day it’s nice to get paid. In Chapter 5 you’ll see how to sell your game on BlackBerry App World (or on your own site) – plus how to apply the cryptography APIs to implement licensing and Digital Rights Management.
- Chapter 6. Swingin’ Light Saber
With action, music, sound-effects, colliding game sprites, and even touch-screen input, Andrew shows you how to put it all together and develop a real game. Plus BlackBerry’s accelerometer lets you wield your saber like a true RIM-i Knight!
- Chapter 7. Play a Live Opponent with SMS
That classic, tiny packet of data sent by the Short Message Service is still a favorite with users and operators alike. And it’s all you need to play a trans-atlantic game of Checkers with a friend – chosen from your BlackBerry contact list!
- Chapter 8. Using Scalable Vector Graphics
2-D graphics are easy to master and allow you to create surprisingly impressive effects. Check out Chapter 8′s spinning spaceship video and learn the tricks to create it.
- Chapter 9. Creating Role-Playing Games on the Internet
Since Internet everywhere is BlackBerry’s strong point, it was practically born for Massively Multiplayer Online Role-Playing Games (MMORPGs)! Chapter 9 uses Twitter to create a virtual asteroid belt that you can explore and find real people in their own virtual ships.
- Chapter 10. Remotely Drive a (toy) Sports Car
What’s more fun than driving a remote controlled car? Driving one from your BlackBerry! Andrew illustrates Bluetooth programming in style.
- Chapter 11. Fox and Hounds
Here’s something your stationary game console can’t do: a real live game of hot pursuit – based on GPS!
- Chapter 12. Introducing 3D with JSR 239
Have a look at what the latest-and-greatest version 5 BlackBerry smartphones can do! Andrew explains 3-D graphics with OpenGL.
Also note: I have some “outtakes” — sample games and code that didn’t quite make it to the book but are nonetheless kind of interesting. I’ll be posting them here over the next few months.
When doing a software QA project, you have to be ready to set up and design tests in a variety of different programming (and scripting) languages — to best integrate the automated tests with the rest of the project. I’ve worked in C/C++, but I’m far from being an expert on the subject. So I can end up wasting time on points that would be extremely simple for an engineer who works in C or C++ every day. And since I wasted my time on this, I’m posting my notes so that you won’t have to do the same.
I recently added some tests to the automated build of a C++ project that uses Qt, which has a built-in unit testing framework: QTestLib. QTestLib seems reasonably well-designed in terms of features. There were just a couple of points I felt were missing from the tutorial, so I’m posting a few remarks for the sake of Q.A. engineers who need to dive straight into the Qt unit test framework. (Apologies in advance to C/C++ developers who will undoubtedly find these points laughably trivial…)
Done? OK, let’s get started. My #1 problem with the tutorial is that it explains how to create a stand-alone application that runs a single QTest class, but doesn’t explain how to create an application that will use QExec to run a series of QTest test suites. Like so many things in software engineering, it’s very simple (once you know the trick). And today I’m going to tell you the trick! Read more »
The first book in Apress’s Blackberry series appeared this past November: Beginning BlackBerry Development by Anthony Rizk. Naturally I picked up a copy because I was curious to see how his approach (and his book) compared to my upcoming book (Learn BlackBerry Games Development, written in cooperation with Andrew Davison). Fortunately, the two books cover quite different subject matter. I’d even say they’re complimentary. It turns out that there’s quite a lot to say about the BlackBerry platform because the application lifecycle/behavior/philosophy is very different from MIDP (even though you can run MIDlets on it), plus BlackBerry has a dedicated server-side network that you can program for. John M. Wargo — who reviewed Rizk’s book on Planet Lotus — says that his book on BlackBerry Development Fundamentals is also complementary with Rizk’s. (It kind of makes me wonder if there’s overlap between my book and John Wargo’s — but I doubt there’s much.)
Rizk’s book — being an intro book — doesn’t assume a high level of Java/programming knowledge. In Chapter 1, he warns the reader that “This book is not an introduction to object-oriented programming, or even to the Java language.” However, if you’ve taken one course in Java programming or have worked through an intro book on the subject, “Beginning BlackBerry Development” would be a fine next step. It covers all of the fundamentals of how to build and deploy a BlackBerry Java application, how the application lifecycle works, how to build a user-interface (and respond to user input), the differences among the four or more different types of data persistence on BlackBerry (and how to use them), the different types of BlackBerry network communications available, and how to program for the GPS.
They timed the book to come out in time for the holidays (as well as for a BlackBerry dev conference), and it’s true that the book would make a good gift for a technophile in your life who’s thinking of going into software engineering or for a software engineer in your life who has a BlackBerry and is thinking of maybe trying to sell an application on BlackBerry App World. (And if they like it — and want to take it to the next level with the techniques for making games on the BlackBerry — well, you can guess which book I’d recommend they try next. )
I downloaded and installed Inkscape in order to draw an animation to play with the Scalable Vector Graphics API. Inkscape was quite helpful for creating my game’s opening SVG animation (though it would have been more helpful if it could save the file in “SVG Tiny”…). What I didn’t expect was how helpful Inkscape is for drawing standard game sprites — drawn first in Scalable Vector Graphics format, then exported as PNG files!
I needed an rocket sprite for my “Space Explorer” game. Here’s what I came up with:
You can see that the four frames give a spinning effect. (The lower row gives the frame sequence for when the engines are turned on.) I’m more an engineer than an artist, but here’s how Inkscape and SVG made it easy for me to draw this: Read more »