Here is the obligatory tech details post:

Platform: Windows, XBOX 360 (future)
Graphics etc: XNA
Physics: JigLibX

The plan is to do this to work on this project when I need a break from everything else. I am already enjoying it because ‘research’ is fun, see pic below. My goal is to actually put this one out there as an XNA indie game. I promise I wont keep it locked away in my collection of fun stuff I have made for me to play around with. I am looking forward to playing this game myself and that is a good sign.

Research is fun!!

                          

I have started with a simple goal for now, model the crafts and locations to dynamically generate the Explorer I mission, not necessarily to real life spec. But to a decently realistic and good looking level of detail. To this end, I am working on modelling the Jupiter-C launch vehicle using correct dimensions weights etc. I will use this to create a pretty basic simulation in XNA and build on it adding stuff like the engine sounds I am also working on Here is a preview of some of the stuff I have coming

Audio:
The audio was created in Audacity using a high pressure cigarette lighter as the base sound, then I pretty much massaged it down a bit to get a nice roar. The start just uses reverb and amplitude changes to give the feeling of that initial surge at rocket startup. Pretty simple sounds to create so far. Kinda fun to be playing with audio again .
Engine Start
Engine Run

Images:

Jupiter-C RocketDyne Booster Tail Section

For fellow BARIS lovers, the game has been open-sourced and can be found here

                          

/*
 * Logger.h
 *
 *  Created on: Jan 4, 2009
 *      Author: Karl
 */
#include <iostream>
#include <fstream>
#include <string>
#include <time.h>

#ifndef LOGGER_H_
#define LOGGER_H_

class Logger {
public:
	static Logger* Instance();
	~Logger();

	//Logging Levels
	const static int LOG_LEVEL_NO_LOGGING = 0;
	const static int LOG_LEVEL_FATAL = 1;
	const static int LOG_LEVEL_SEVERE = 2;
	const static int LOG_LEVEL_WARNING = 3;
	const static int LOG_LEVEL_INFO = 4;
	const static int LOG_LEVEL_CONFIG = 5;
	const static int LOG_LEVEL_VERBOSE = 6;
	const static int LOG_LEVEL_VERY_VERBOSE = 7;

	//Logging Targets
	const static int LOG_TARGET_FILE = 1;
	const static int LOG_TARGET_STDOUT = 2;
	const static int LOG_TARGET_BOTH = 3;

	void SetLoggingLevel(int);

	void SetLoggingTarget(int);

	void Log(int, std::string);

protected:
	Logger();
	Logger(const Logger&);
	Logger& operator= (const Logger&);

private:
	std::ofstream file;
	static Logger* pinstance;
};

#endif /* LOGGER_H_ */

/*
 * Logger.cpp
 *
 *  Created on: Jan 4, 2009
 *      Author: Karl
 */

#include "Logger.h"

Logger* Logger::pinstance = 0;
int loggingLevel = 4;
int loggingTarget = 1;

Logger* Logger::Instance()
{
	if (pinstance == 0)
	{
		pinstance = new Logger;
	}
	return pinstance;
}

Logger::Logger()
{
	file.open ("logger.log");
	Log(LOG_LEVEL_INFO, "Log Opened");
}

Logger::~Logger()
{
	file.close();
}

void Logger::SetLoggingLevel(int logLevel)
{
	if ((logLevel >= LOG_LEVEL_NO_LOGGING) && (logLevel <= LOG_LEVEL_VERY_VERBOSE))
	{
		loggingLevel = logLevel;
	}
}

void Logger::SetLoggingTarget(int logTarget){
	if ((logTarget >= LOG_TARGET_FILE) && (logTarget <= LOG_TARGET_BOTH))
	{
		loggingTarget = logTarget;
	}
}

void Logger::Log(int logLevel, std::string logMsg)
{
	if (logLevel <= loggingLevel)
	{
		std::string msgToWrite;
		time_t rawtime;
		struct tm * timeinfo;

		time ( &rawtime );
		timeinfo = localtime ( &rawtime );
		msgToWrite += asctime(timeinfo);
		msgToWrite.erase(msgToWrite.end()-1,msgToWrite.end());
		msgToWrite += " - ";

		switch (logLevel) {

		case LOG_LEVEL_FATAL:
			msgToWrite += "FATAL - ";
			break;
		case LOG_LEVEL_SEVERE:
			msgToWrite += "SEVERE - ";
			break;
		case LOG_LEVEL_WARNING:
			msgToWrite += "WARNING - ";
			break;
		case LOG_LEVEL_INFO:
			msgToWrite += "INFO - ";
			break;
		case LOG_LEVEL_CONFIG:
			msgToWrite += "CONFIG - ";
			break;
		case LOG_LEVEL_VERBOSE:
			msgToWrite += "VERBOSE - ";
			break;
		case LOG_LEVEL_VERY_VERBOSE:
			msgToWrite += "VERY VERBOSE - ";
			break;
		default:
			msgToWrite += "UNKNOWN LEVEL - ";
			break;
		}

		msgToWrite += logMsg;
		msgToWrite += "\n";

		switch(loggingTarget){
		case LOG_TARGET_FILE:
			file << msgToWrite;
			break;
		case LOG_TARGET_STDOUT:
			std::cout << msgToWrite;
			break;
		case LOG_TARGET_BOTH:
			msgToWrite += "\n";
			file << msgToWrite;
			std::cout << msgToWrite;
			break;
		}
	file.flush();
	}

}

Example Usage:

Logger *logger = Logger::Instance();

.

.

.

logger->Log(logger->LOG_LEVEL_INFO, “Starting the Plugin”);