Wednesday, September 30, 2009
Space Invaders flash
Space Invaders (スペースインベーダー) is an arcade video game designed by Tomohiro Nishikado, and released in 1978. It was originally manufactured and sold by Taito in Japan, and was later licensed for production in the United States by the Midway division of Bally. Space Invaders is one of the earliest shooting games and features two-dimensional graphics. The aim is to defeat waves of aliens with a laser cannon and earn as many points as possible. In designing the game, Nishikado drew inspiration from popular media: Breakout, The War of the Worlds, and Star Wars. To complete it, he had to design custom hardware and development tools.
Though simple by today's standards, it was one of the forerunners of modern video gaming and helped expand the video game industry from a novelty to a global industry. When first released, Space Invaders was very successful and popular. Following its release, the game caused a temporary shortage of 100-yen coins in Japan, and by 2007 had earned Taito US$500 million in revenue. Guinness World Records ranks it the top arcade game.
The game has been the inspiration for other video games, re-released on numerous platforms, and led to several sequels. The 1980 Atari 2600 version quadrupled the system's sales and became the first "killer app" for video game consoles. Space Invaders has been referenced and parodied in multiple television shows, and been a part of several video game and cultural exhibitions. The pixelated enemy alien has become a media icon representing video games as a whole.
source wikipedia
Sunday, September 27, 2009
Friday, September 25, 2009
Bethesda releashes the Elder Scrolls for Free
Bethesda is the company that made one of the most popular RPG series the Elder Scrolls. Now you can download for free the first two of these games the Arena and the legendary Daggerfall for free from the Bethesda's web site
http://www.elderscrolls.com/downloads/downloads_games.htm
http://www.elderscrolls.com/downloads/downloads_games.htm
 |
 |
Sunday, September 20, 2009
Ad sponsored games
Ad sponsored games refers to computer and video games that can be applyied for free but delivers advertising. According to wikipedia in 2005 in-game advertising reached at US the $56 million and it is estimated that will grow to $1.8 billion by the end of 2010. Advertisers see ad sponsored games as a way ro reach the male 18-34 demographic, who are the main stereotype of the games. Ok these is the marketing things that i do not care so much about. The fact is throuph the above approach of the game industry we have great games for free. I have found the free versions of "Rise and Fall: Civilizations at war" and "The Suffering"
Download Rise and Fall:Civilizations at war
Download The Suffering
Download Rise and Fall:Civilizations at war
Download The Suffering
Programming java applet games part 4 - The Game Menu
The next step for our game will be the implementation on the Game Menu. This is the place where a game gives to players the available options ie Start Game,Option, Exit etc. In our game we will have only two options a) Start Game, B) Show Keys. We do not have an Exit option becaouse we write an applet game and we don't need this.
To implement the menu we need to change the run method to run more than one different "game loops", one for eatch game state.
public void run() {
try {
boolean exit = false;
int menuOption = 0;
while ( true ) {
menuOption = getMenuOption();
if ( menuOption == 0 ) {
gamePlayLoop();
} else {
printKeys();
}
}
} catch ( InterruptedException ex ) {
Logger.getLogger( AsterpodsApplet.class.getName() ).log( Level.SEVERE, null, ex );
}
}
Let me explain the above code. The while statement changed to run forever because that we do not have an exit option. Then we define tree different game loops seperated in different methods.
a) int gerMenuOptions()
Contains the code to draw the game options and handle the user choices. The returned value is the user choice.
b)void gamePlayLoop()
the main game loop, it will contain all the action and it will be implemented later
c)void printKeys()
This method just prints key info
Now lets dig into this methods by starting with getMenuOptions
//the loop that will run while the player is on game menu
private int getMenuOption() throws InterruptedException {
long lastTime;
int retValue = 0;//this will contain the players choice
while ( true ) {
lastTime = System.currentTimeMillis();
drawMenu( retValue );
if ( this.up_pressed == true ) {
retValue = 0;
} else if( this.down_pressed == true ) {
retValue = 1;
} else if ( this.space_pressed ) { // if it is the space that pressed then the user made his choice
consumeTyped();
break;
}
consumeTyped();
repaint(); //rapaints the applet
lastTime = System.currentTimeMillis() - lastTime;
Thread.sleep( GAME_LOOP_MAX_TIME - lastTime );
}
return retValue;
}
getMenuOption uses the method
void drawMenu( int option );
to draw the menu Options on the screen and check the user input to return game choices and change the state of the game. The user choice will be returned with the press of the space key while the up and down arrows change the choice.This is implemented by this
if ( this.up_pressed == true ) {
retValue = 0;
} else if( this.down_pressed == true ) {
retValue = 1;
} else if ( this.space_pressed ) { // if it is the space that pressed then the user made his choice
consumeTyped();
break;
}
consumeTyped();
For this method except the up,down etc switches that i used in the previous tutorial to track user input i use extra switches up_presse, down_pressed etc. The difference between these switches is that the *_pressed versions will be used to track that the keys pressed once and we do not care if they are still pressed.
The method
void consumeTyped()
is used to clear the *_pressed switches.
I will go out of the getMenuOptions and i will go to printKeys without explain the drawLogo becouse i want to let this method for the end of this tutorial.
private void printKeys() throws InterruptedException {
long lastTime;
while ( true ) {
lastTime = System.currentTimeMillis();
drawKeys();
if ( this.space_pressed ) { // if it is the space that pressed then the user made his choice
consumeTyped();
break;
}
repaint(); //rapaints the applet
lastTime = System.currentTimeMillis() - lastTime;
Thread.sleep( GAME_LOOP_MAX_TIME - lastTime );
}
}
printKeys Method is identical to getMenuOptions with the difference that tracks only of the space key and calls the drawKeys to print the proper messages on the screen.
The interessting part of this part of the series is methods
void drawLogo(), void drawKeys() and void drawMenu( int retValue )
private void drawLogo() {
backBuffer.setColor( Color.black );
backBuffer.fillRect( 0, 0, WIDTH, HEIGHT );
color += nextInc;
if ( color > 255 ) {
color = 255;
nextInc *= -1;
} else if ( color < 100 ) {
color = 100;
nextInc *= -1;
}
//color = 250;
Color c = new Color( color, color, color );
backBuffer.setColor( c );
//prints logo on the center
String logo = "Asteroids - the rebirth";
int strLength = backBuffer.getFontMetrics().stringWidth( logo );
//the >> 1 is equals to /2
backBuffer.drawString( logo, (WIDTH - strLength) >> 1, 140 );
}
//prints the key controls for the game
private void drawKeys() {
drawLogo();
backBuffer.setColor( Color.WHITE );
String[] lines = new String[ 6 ];
lines[ 0] = "Press the Up arrow to accelerate";
lines[ 1] = "Press the Down arrow to decelerate";
lines[ 2] = "Press the Left arrow to turn left";
lines[ 3] = "Press the Right arrow to turn right";
lines[ 4] = "Press the Space to fire";
lines[ 5] = "Press the Escape to exit";
for ( int i = 0; i < lines.length; i++ ) {
int strLength = backBuffer.getFontMetrics().stringWidth( lines[i] );
backBuffer.drawString( lines[i], (WIDTH - strLength) >> 1, 170 + i * 15 );
}
String exitMessage = "Press space to go back";
int strLength = backBuffer.getFontMetrics().stringWidth( exitMessage );
backBuffer.drawString( exitMessage, (WIDTH - strLength) >> 1, 170 + lines.length * 15 + 30 );
}
private void drawMenu( int retValue ) {
//System.out.println( "ret " + retValue );
drawLogo();
backBuffer.setColor( Color.WHITE );
String start = "Start Game";
int charHeight = backBuffer.getFontMetrics().getHeight();
int strLength1 = backBuffer.getFontMetrics().stringWidth( start );
backBuffer.drawString( start, (WIDTH - strLength1) >> 1, 175);
String keys = "Show keys";
int strLength2 = backBuffer.getFontMetrics().stringWidth( keys );
backBuffer.drawString( keys, (WIDTH - strLength2) >> 1, 195 );
String space = "Press space to choose";
int strLength3 = backBuffer.getFontMetrics().stringWidth( space );
backBuffer.drawString( space, (WIDTH - strLength3) >> 1, 235 );
if( retValue == 0 ){
backBuffer.drawRoundRect( ( (WIDTH - strLength1) >> 1 ) - 5, 160, strLength1 + 10, charHeight + 6, 10, 10 );
} else {
backBuffer.drawRoundRect( ( (WIDTH - strLength2) >> 1 ) - 5, 180, strLength2 + 10, charHeight + 6, 10, 10 );
}
}
as you can see in everyone of these methods i use an object backBuffer to draw strings on the screen.
So what type is this object?
The answer is simple it is an instance of the class Graphics that as i mention in the privious tutorials is used to draw strings, shapes and images on the screen. Ok the decleration and initialization of the backBuffer are
private Graphics backBuffer;
Image offscreenImage;
private void createSecondBuffer() {
offscreenImage = this.createImage( WIDTH, HEIGHT );
backBuffer = offscreenImage.getGraphics(); }
When you want to print something on the screen you never print directly on the Graphics object that is passed as parameter on the paint method. If you do it you will get the flickerring effect.
What is this?
i will let wikipedia to explain
Flicker is visible fading between cycles displayed on video displays, especially the refresh interval on cathode ray tube (CRT) based computer screens. Flicker occurs on CRTs when they are driven at a low refresh rate, allowing the screen's phosphors to lose their excitation (afterglow) between sweeps of the electron gun.
If you want to see live what flicker is just write the above code without the use of backBuffer but rather than that print dirrectrly to applet's Graphics object. Flickering occurs when the screen refreshes the same time that the Graphics object gets updates. So to transpass this we make every update in a single step inside the print method
public void paint( Graphics g ) {
g.drawImage( offscreenImage, 0, 0, this );
}
This method is known as Double buffering and you must allways use it if you want to make a playable game.
I will close this article with the fade out/in effect. If you compile the code that i just wrote you will see the logo of the game to fade in and out. This effect is implemented by this
backBuffer.setColor( Color.black );
backBuffer.fillRect( 0, 0, WIDTH, HEIGHT );
color += nextInc;
if ( color > 255 ) {
color = 255;
nextInc *= -1;
} else if ( color < 100 ) {
color = 100;
nextInc *= -1;
}
//color = 250;
Color c = new Color( color, color, color );
backBuffer.setColor( c );
//prints logo on the center
String logo = "Asteroids - the rebirth";
int strLength = backBuffer.getFontMetrics().stringWidth( logo );
Ιτ uses the attribute color to calculate the color that will be used to draw the logo at the next frame. When the color become greater than 255 (is the upper value) it starts to decrease will it increase again whet it becomes less than 100. Finally the getFontMetrics().stringWidth( String param ) returns the width of a given string with the specific font on the screen.
Below is the complete code of the class AsterpodsApplet as it just updated
package games.applet.Asteroid;
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author alexm
*/
public class AsterpodsApplet extends Applet implements Runnable, KeyListener {
private static final int WIDTH = 640;
private static final int HEIGHT = 480;
private static final int GAME_LOOP_MAX_TIME = 50;
private Thread mainLoop;
private boolean gameOver = false;
//keyboard switches
private boolean up;
private boolean down;
private boolean left;
private boolean right;
private boolean space;
private boolean esc;
private boolean up_pressed;
private boolean down_pressed;
private boolean left_pressed;
private boolean right_pressed;
private boolean space_pressed;
private boolean esc_pressed;
//Back buffer components
private Graphics backBuffer;
Image offscreenImage;
@Override
public void init() {
mainLoop = new Thread( this );
up = false;
down = false;
left = false;
right = false;
space = false;
esc = false;
//create the back buffer
createSecondBuffer();
//enabling the key listening
addKeyListener( this );
}
//creates a second buffer to eliminate the flickering
private void createSecondBuffer() {
offscreenImage = this.createImage( WIDTH, HEIGHT );
backBuffer = offscreenImage.getGraphics();
}
@Override
public void start() {
mainLoop.start();
}
@Override
public void stop() {
gameOver = true;
}
@Override
public void update( Graphics g ) {
paint( g );
}
@Override
public void paint( Graphics g ) {
g.drawImage( offscreenImage, 0, 0, this );
}
public void run() {
try {
boolean exit = false;
int menuOption = 0;
while ( true ) {
menuOption = getMenuOption();
if ( menuOption == 0 ) {
gamePlayLoop();
} else {
printKeys();
}
}
} catch ( InterruptedException ex ) {
Logger.getLogger( AsterpodsApplet.class.getName() ).log( Level.SEVERE, null, ex );
}
}
//the loop that will run while the player is on game menu
private int getMenuOption() throws InterruptedException {
long lastTime;
int retValue = 0;//this will contain the players choice
while ( true ) {
lastTime = System.currentTimeMillis();
drawMenu( retValue );
if ( this.up_pressed == true ) {
retValue = 0;
} else if( this.down_pressed == true ) {
retValue = 1;
} else if ( this.space_pressed ) { // if it is the space that pressed then the user made his choice
consumeTyped();
break;
}
consumeTyped();
repaint(); //rapaints the applet
lastTime = System.currentTimeMillis() - lastTime;
Thread.sleep( GAME_LOOP_MAX_TIME - lastTime );
}
return retValue;
}
private void printKeys() throws InterruptedException {
long lastTime;
while ( true ) {
lastTime = System.currentTimeMillis();
drawKeys();
if ( this.space_pressed ) { // if it is the space that pressed then the user made his choice
consumeTyped();
break;
}
repaint(); //rapaints the applet
lastTime = System.currentTimeMillis() - lastTime;
Thread.sleep( GAME_LOOP_MAX_TIME - lastTime );
}
}
//this is used to make the fade effect
private int color = 100;
private int nextInc = 5;
private void drawLogo() {
backBuffer.setColor( Color.black );
backBuffer.fillRect( 0, 0, WIDTH, HEIGHT );
color += nextInc;
if ( color > 255 ) {
color = 255;
nextInc *= -1;
} else if ( color < 100 ) {
color = 100;
nextInc *= -1;
}
//color = 250;
Color c = new Color( color, color, color );
backBuffer.setColor( c );
//prints logo on the center
String logo = "Asteroids - the rebirth";
int strLength = backBuffer.getFontMetrics().stringWidth( logo );
//the >> 1 is equals to /2
backBuffer.drawString( logo, (WIDTH - strLength) >> 1, 140 );
}
//prints the key controls for the game
private void drawKeys() {
drawLogo();
backBuffer.setColor( Color.WHITE );
String[] lines = new String[ 6 ];
lines[ 0] = "Press the Up arrow to accelerate";
lines[ 1] = "Press the Down arrow to decelerate";
lines[ 2] = "Press the Left arrow to turn left";
lines[ 3] = "Press the Right arrow to turn right";
lines[ 4] = "Press the Space to fire";
lines[ 5] = "Press the Escape to exit";
for ( int i = 0; i < lines.length; i++ ) {
int strLength = backBuffer.getFontMetrics().stringWidth( lines[i] );
backBuffer.drawString( lines[i], (WIDTH - strLength) >> 1, 170 + i * 15 );
}
String exitMessage = "Press space to go back";
int strLength = backBuffer.getFontMetrics().stringWidth( exitMessage );
backBuffer.drawString( exitMessage, (WIDTH - strLength) >> 1, 170 + lines.length * 15 + 30 );
}
private void drawMenu( int retValue ) {
//System.out.println( "ret " + retValue );
drawLogo();
backBuffer.setColor( Color.WHITE );
String start = "Start Game";
int charHeight = backBuffer.getFontMetrics().getHeight();
int strLength1 = backBuffer.getFontMetrics().stringWidth( start );
backBuffer.drawString( start, (WIDTH - strLength1) >> 1, 175);
String keys = "Show keys";
int strLength2 = backBuffer.getFontMetrics().stringWidth( keys );
backBuffer.drawString( keys, (WIDTH - strLength2) >> 1, 195 );
String space = "Press space to choose";
int strLength3 = backBuffer.getFontMetrics().stringWidth( space );
backBuffer.drawString( space, (WIDTH - strLength3) >> 1, 235 );
if( retValue == 0 ){
backBuffer.drawRoundRect( ( (WIDTH - strLength1) >> 1 ) - 5, 160, strLength1 + 10, charHeight + 6, 10, 10 );
} else {
backBuffer.drawRoundRect( ( (WIDTH - strLength2) >> 1 ) - 5, 180, strLength2 + 10, charHeight + 6, 10, 10 );
}
}
//the loop that will run while the player fights the asteroids
private void gamePlayLoop() throws InterruptedException {
long lastTime;
while ( gameOver == false ) {
lastTime = System.currentTimeMillis();
checkUserInput();
runAI();
updateUser();
updateEnemies();
repaint(); //rapaints the applet
lastTime = System.currentTimeMillis() - lastTime;
Thread.sleep( GAME_LOOP_MAX_TIME - lastTime );
}
}
private void checkUserInput() {
throw new UnsupportedOperationException( "Not yet implemented" );
}
private void runAI() {
throw new UnsupportedOperationException( "Not yet implemented" );
}
private void updateUser() {
throw new UnsupportedOperationException( "Not yet implemented" );
}
private void updateEnemies() {
throw new UnsupportedOperationException( "Not yet implemented" );
}
private void consumeTyped() {
up_pressed = false;
down_pressed = false;
left_pressed = false;
right_pressed = false;
space_pressed = false;
esc_pressed = false;
}
public void keyTyped( KeyEvent e ) {
}
public void keyPressed( KeyEvent e ) {
System.out.println( "key pressed " + e.getKeyCode() );
if ( e.getKeyCode() == KeyEvent.VK_UP ) {
up = true;
up_pressed = true;
}
if ( e.getKeyCode() == KeyEvent.VK_DOWN ) {
down = true;
down_pressed = true;
}
if ( e.getKeyCode() == KeyEvent.VK_LEFT ) {
left = true;
left_pressed = true;
}
if ( e.getKeyCode() == KeyEvent.VK_RIGHT ) {
right = true;
right_pressed = true;
}
if ( e.getKeyCode() == KeyEvent.VK_SPACE ) {
space = true;
space_pressed = true;
}
if ( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
esc = true;
esc_pressed = true;
}
}
public void keyReleased( KeyEvent e ) {
System.out.println( "key releashed " + e.getKeyCode() );
if ( e.getKeyCode() == KeyEvent.VK_UP ) {
up = false;
}
if ( e.getKeyCode() == KeyEvent.VK_DOWN ) {
down = false;
}
if ( e.getKeyCode() == KeyEvent.VK_LEFT ) {
left = false;
}
if ( e.getKeyCode() == KeyEvent.VK_RIGHT ) {
right = false;
}
if ( e.getKeyCode() == KeyEvent.VK_SPACE ) {
space = false;
}
if ( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
esc = false;
}
}
}
Have a nice coding time
Saturday, September 19, 2009
Programming psp
i just make o copy of the psp-programming.com
http://www.psp-programming.com/tutorials/
Lesson 01
Setting up the Development Environment
Get the toolchain and PSPSDK up and running with CYGWIN.
This is the first installment in a series of tutorials focussed on getting a novice programmer well on his way to developing his own homebrew applications for the Sony Playstation Portable (PSP). If you are reading this, congratulations, you have hurdled one of the biggest obstacles for a programmer. Likely the most difficult thing about programming is getting started. Well, by starting to read this tutorial, you are well on your way.
The first step to creating your own program is getting your environment set up. This environment is how you will convert the source code you write into a compiled file formatted for execution on you PSP. We will be setting up two important tools on our system.
If, at any time in this tutorial series, you need help please head over to our forums and post a question. We are always happy to help a fellow programmer.
The first of these tools is called CYGWIN. It is basically a Linux emulator for windows. It will create a simulated Linux environment on your computer so that you can run native Linux applications. This may sound intimidating, but don't worry, it's very simple to use.
The second thing you'll need is the toolchain. This is the key to programming for the PSP. It will set up everything you need, from header files, to libraries, to the compiler itself, to the sample programs. Once you have this installed, you will be nearly ready to create your first program.
Now for the part we've all been waiting for: the installation.
The first step is to install CYGWIN. You can download the install file from the CYGWIN website here. After it has finished downloading, open up the executable. You will see a splash screen; click next. Now you will be asked what you want to do. Select the default option of "Install from Internet," and hit the next button. Now you will be prompted where you want to install CYGWIN. Change the install directory to "C:/cygwin" if it is not set as such already (where C: is your local hard drive). Leave the other options set to their defaults and hit next. Now you will be asked where you want to save the installation files. What you select here doesn't really matter, but I suggest putting them someplace where you will be able to find them and delete them after the installation is complete. Once you have selected a suitable location, click next. The next screen will ask about your network settings, if you don't use a proxy (or don't know what a proxy is), just click next on this screen. If it doesn't work, go back and try letting it use Internet Explorer's settings. Now you should be presented with a list of servers to download the installation files from. Any one of these will do, so select one, and then click on next. Now it will download the package list, this could take a few minutes, depending on your connection speed. Once it is done, scroll down to "devel" and click on where it says "default" so that it becomes "install." Then scroll down to "web," click the "+" next to it, scroll down and set "wget" to "install."
When you are finished, click next. CYGWIN will now download and install the selected packages. This will quite possibly take a while, so go watch a TV show or do some web surfing while you wait. After the install has finished, you are ready to install the toolchain.
Lesson 02
Setting up the Development Environment
The setup, creation, and execution or a "Hello World"
So, after reading Lesson 01, you have a working development environment in which to create your programs. Now what? Well, this is the part you've all been waiting for, your very first program for the PSP. This tutorial will explain the basics of the C programming language and build the foundation upon which you will build your kingd-- err... programs.
If, at any time in this tutorial, you need help please head over to our forums and post a question. We are always happy to help a fellow programmer.
We're going to create a folder hierarchy to organize our projects. Open up a CYGWIN bash shell, and type "mkdir projects" and then hit enter. This command ("mkdir") stands for "make directory" and it will create a directory, or folder, in your current operating directory. So now we have a new folder for all of our projects, navigate into it by typing "cd projects" and hitting enter. Now we are going to create another directory for this specific project. Type "mkdir helloworld" and hit enter. Now switch into the new directory with "cd helloworld."
The next step is to open up a text editor. It doesn't really matter what you open, it can be Notepad, Wordpad, whatever you want. I prefer using an editor that is dedicated to editting C/C++ source code because of the syntax highlighting options that are built in (I use Dev-C++), but honestly, it doesn't matter (so long as you know how to use it).
Now, create a new file and call it "main.c" in our "helloworld" directory. This is going to contain the source code for our program. For those of you who don't know what source code is (and I know there will be a few), the source code is what we write to create a program. It is written in a way that humans can understand. In most languages, the source needs to be converted to a format the computer (or in our case, the PSP) can understand. These are called compiled languages, and C and C++ fall into this category (the conversion is done by the compiler that we set up in Lesson 01). There are a few other programming languages that use what is called an interpreter to interpret the source code and send out machine code on the fly. These are called scripting languages (an example of a scripting language is PHP).
Alright, so we have a new file that is going to hold our source code. Now we need to start writing it. The first part of the program should contain comments to tell anyone reading our code what the aim of the program is, when it was written, and who the author is. Comments are lines of source code that are omitted from the compiled binary (or skipped by the interpretter in scripting languages). Comments are a very important part of your code, because when you (or someone else) come back to edit your source code later, you will not remember all of the intricacies of the program. So, you can leave yourself notes in the form of comments. Comments are signalled with the "//" and "/*" characters. Any time you see a "//" it means that the rest of the line will be a comment. A "/*" means that the compiler (or interpretter) will ignore your code until it reaches a "*/" signal. Comments signalled by the "/*" operator can span many lines, but comments signalled with "//" only comment out the rest of that line.
So, to start off our program, we are going to leave a comment at the top about what it does, when it was created, and who it was written by.
// Hello World - My First App for the PSP
/*
This program was created by (Your Name Here) on (Date Here)
It is a simple "Hello World" Application.
*/
The next portion of the program is where we tell the compiler which header files and which include files we are going to use in our program. Basically what the "#include" directive does is copy the code from the file you pass to it into the top of your program. This allows you to keep your program simple, while still using the advanced code that is already written for you. The include directive can include either header files that came with the compiler (or that you add to the compiler), or header files specific to the specific project that you are working on. The way that you discern which of these you are including is by whether you use "<>" to enclose the file or if you use quotes to do it. The less than and greater than signs include a file from the compiler's "include" directory, and the quotes include a file from the same directory as the file including them. We will be including two files in our program. The first is "pspkernel.h." This file will be included in every single program that you write for the PSP. It contains all of the code specific to your PSP. Your program will not work on the PSP if you do not include this file. The second file we are going to include is "pspdebug.h." This file contains several useful functions for debugging your programs, but specifically it includes the function that we are going to use to write text to the screen. So, add this code to your program:
#include
#include
Next we tell the PSP a little bit about the program. This isn't really that important, your program will compile without it, but it is always a good idea to keep it in (if only for forwards compatibility). The first attribute is the name of the program, but it's not really the name of the program that will appear (we'll change that later). The other values are other attributes (just leave it alone), major version, and minor version. We'll just leave all of these except for the name as the defaults. So, add the following line to your program:
PSP_MODULE_INFO("Hello World", 0, 1, 1);
Now we are going to set up the function that we will use to write to the screen. This step is optional, but it makes writing text based programs much easier. The basis behind this line is to change the function that is built into the PSP, called "pspDebugScreenPrintf" into something that's much easier to type. This function is used to write to the screen (which you will see later). What we are basically going to do here is rename "pspDebugScreenPrintf" to "printf." So every time we use "printf" from now on, the compiler will just treat it as if we have typed "pspDebugScreenPrintf." Here's how we'll do it; we'll define "printf" as "pspDebugScreenPrintf" like this:
#define printf pspDebugScreenPrintf
Lesson 03
A Programming Primer
A crash course in the basics of C programming for the PSP.
After reading Lesson 01 and Lesson 02, you should now have a development environment set up, and have compiled your first basic program for the PSP. Now it's time to move on to bigger and better things. A "hello world" application is fine and dandy, a great learning experience, but it doesn't do anything. That's what this tutorial is about. How to make your programs do things.
What you need to understand is that this tutorial is not meant to be the be all and end all of PSP programming. It is much less a "how to create a game" than it is a foot in the door. What you will gain here are the basic building blocks of PSP (and C) programming. You will need to rearrange and add to these blocks together to create your own, functional application.
Having read Lesson 02, or knowing how to set up a basic program is a prerequisite for this tutorial. We will not go through the process of setting up your program in this tutorial. So, to test the code that follows replace the line
printf("Hello World.");
from Lesson 02 except where otherwise noted. Since the other lines were just setup for our program, we need not go through what they do again.
The final product of this tutorial will be a program that counts upwards until the user presses a button or until the counter hits a predefined limit. This is the perfect application for this tutorial; it combines several core elements of C programming to create a simple, yet useful result without requiring many program-specific functions. Covered in this tutorial are: variables, if/then statements, loops, text formatting, and button input.
First off, we will need to add two more header includes. The first one is to give us a little more control over the screen (we need this for one of the functions we will be using later). The second file we will be including allows us to get button input. So to do add these two files (pspdisplay.h and pspctrl.h), we need to add these two lines right below our first two "#include" statements:
#include
#include
And that's all the extra setup we need. Now we'll move on to putting in the functional code. From here on, all code listed should go in your main function, replacing the "printf" statement from Lesson 02. The first thing we will do is declare the variables that we will use in our program. A variable declaration takes the following form:
//EXAMPLE (Psuedo Code)
//DO NOT ADD TO YOUR PROGRAM
type name=value;
The type is the data type of variable. Each data type can contain data (and only that data). For example, type "int" (meaning integer) can hold any non-decimal number from -32767 to 32767. A "float" is like an "int," but it can hold decimals. The "char" type can hold a letter. For our program, we will only use the built in type "int" and a PSP specific type called "SceCtrlData" which holds the button state of the PSP controls.
So, to declare the two variables that we are going to use, we insert the following two lines of code into our program (these should go where your "printf("Hello World.");" line was in Lesson 02; right after the line "SetupCallbacks();."
int counter = 0;
int i = 0;
SceCtrlData pad;
So now we have three variables that we can use. Two of type "int," named "counter" and "i," containing a value of zero for now. And one of type "SceCtrlData," named "pad," which is filled with junk at the moment (since we haven't yet initialized it). This is something to keep in mind when writing your own programs. If you declare a variable without initializing it (like our pad variable), it will not just be empty. It will contain the information that was previously in that chunk of memory. Declaring the variable just allocates a certain amount of memory space for the variable to be stored in. The initialization is what clears it out and allows us to use it. The reason that we haven't initialized "pad" at the same time that we declared it is because it wouldn't really make sense. Since it holds button input, you can't just initialize it by typing in a value. We'll initialize it later, before we use it for anything.
Now we're going to give the user some instructions. The way we do this is by using "printf" to output a statement to them. So put this after the variable declarations:
printf("Press [X] To Start the Timer");
Look familiar? Good. It's the same function we used to output "Hello World" in Lesson 02. So if you ran the program at this point, it would be just like the "hello world" application, except it would print out "Press [X] To Start the Timer" instead of "Hello World."
Now we need the program to wait until the user presses the [X] button before it does anything else. Now, this could be a very difficult, nearly impossible thing to do. Fortunately, we have something perfect for dealing with it. It's called a loop. Basically what it does is run through a block of code multiple times. There are different types of loops available to you (for loops, while loops, do while loops, etc), but this tutorial will only introduce two of those loops, the "while" loop and the "for" loop. How this loop works is that you give it a statement, and it will execute a block of code while that statement is true. For example, if you had a block of code that incremented a variable (starting with a value of zero) by one each time the loop was run, and the statement that you passed in the loop was "i<10" it would execute your code ten times, because on the eleventh time that it checked the value of the variable, it would be 10, which is not less than 10, so the statement would be false (man, this is a run on sentence if I've ever seen one). One other important concept that you will need to grasp is that "true" and "false" are synonymous with "1" and "0" respectively.
Phew. It's not so hard is it? I'm glad you agree (like how I just assume the answer to my rhetorical questions because you can't answer?). So let's move on to the second part of this tutorial.
Lesson 04
Simple Image Processing
A crash course on adding images to your applications.
Since Lesson 03 was released, I have been bombarded with e-mails, instant messages, phone calls, and even the occasional reader banging on my front door pleading with me to release another tutorial. Overwhelmingly they have requested a lesson on adding images to their programs. Well, you guys can finally stop all of that, because this long overdue article is finally here.
At this point, I'll assume that you already have CYGWIN and the PSP toolchain installed, understand how to compile source code into an EBOOT suitable for execution on the PSP, and have at least a basic understanding of the C programming language. If you don't meet these prerequisites, have no fear, read Lesson 01, Lesson 02, and Lesson 03, and then come back.
If it has been a while since you have updated your toolchain, you will need to do that since png.h is necessary for this tutorial and was not originally included in the PSP toolchain. Revisit Lesson 01 if you need a refresher on how to do that. I had to update before I was able to compile this program (if you already have CYGWIN installed, you can skip right to the step where you download the toolchain).
I would like to thank Psilocybeing for allowing me to use his example source code as a base for this tutorial. I had originally planned on using my own example code (adapted from Shine's original Snake game in C) to demonstrate, but that code is antiquated and unnecessarily complex. One major benefit of Psilocybeing's code is that all of the functions and datatypes are defined in external files, allowing you to more easily integrate the code into your own projects.
Before we do anything, we will need to install some new libraries from SVN. What's SVN you ask? Well, SVN is a version management system (it is shorthand for "subversion"). What we will be doing is grabbing some code from online to add more functionality to our compiler. The packages that we will need are zlib and libpng. zlib is a compression library and libpng allows us to work with PNG files (a type of image). To install these libraries, we will need to type the following things into a CYGWIN Bash Shell.
svn checkout svn://svn.pspdev.org/psp/trunk/zlib
"Checkout" is basically SVN's way of saying "download." This will download the zlib source into a folder called "zlib." It will take a minute, a bunch of stuff should scroll down the screen and you should be left back at the "$" for input.
So now we need to compile this new library, so we'll "cd" into the new folder.
cd zlib
We are now in the zlib folder, and are ready to compile. So, like any other thing that we want to compile, we just need to type
make
And voila, it compiles the library for us.
Now we need to put the resulting files into a place where the compiler can access them. So, we'll install them:
make install
And BAM! We've installed zlib. Now wasn't that simple?
Now for libpng. We just need to do the same thing, except we'll substitute "libpng" for "zlib."
cd ..
svn checkout svn://svn.pspdev.org/psp/trunk/libpng
cd libpng
make
make install
And there we are, ready to use PNG's in our program.
Now we'll just clean up those install files by deleting them. To delete things via a Linux shell (which is what CYGWIN emulates), you use the "rm" command. We don't only want to delete one file, though, we want to delete a whole folder and all of its contents, so we'll add the "-R" modifier to it to signify a recursive removal. Basically this just means we want to delete a folder and everything inside of that folder. We'll also use the "-f" modifier to force the deletion of write-protected files so that we don't have to hit "y" for each file we want to delete. So we'll "cd" back to the parent directory and remove both the "zlib" and "libpng" temporary folders that we just created.
rm -Rf zlib
rm -Rf libpng
Now that we have that out of the way, we are ready to start programming.
We'll move on to the second section of this tutorial to continue our program.
Lesson 05
Onwards and Upwards
More PSP Programming methods including overclocking, colors, and graphics based text.
Ok, so you've set up the development environment, written your first program, leaned some programming techniques, and dabbled in image programming, but what's next? Well, since you're on this page, I'll bet it comes as no surprise to you that it's Lesson 05! Here we will improve our programming skills (and by "we," I really mean "you") by learning about some more advanced concepts.
Advanced, though, is subjective. We are still forming the groundwork in C that you will build upon in truly advanced applications. By the end of this lesson, you should know how to "overclock" the PSP to its true speed of 333 MHz, be able to write text to the screen (graphic text, not the debug text we used before), and have an understanding of how colors work on the PSP.
The program that we are going to construct in this tutorial is a "backround changer." Basically, we are going to allow the user to select the color of the background, and we are going to change it accordingly, as well as display the components of that color on the screen.
First, some background. There is a wide misconception about "overclocking" the PSP. Because of preconceived notions, people associate "overclocking" with heat issues and broken hardware. There is a myth that "overclocking" the PSP is dangerous to the hardware. This is simply not the case with the PSP. The truth is that the PSP is underclocked when it ships from the factory. There are several theories for why Sony did this. One theory is that it drained battery life too quickly for Sony's liking (for us, that isn't much of a concern; spinning the UMD takes up far more battery power than loading off of the Memory Stick, so we already have a tremendous advantage in terms of battery life). Another theory is that Sony wanted developers to write streamlined code. And the third prevalent theory (and the most likely in my opinion) is that they want to allow developers to use the full speed at some point in the future to give a boost to games that will come out later. Anyway, the PSP normally runs at 222 MHz. If you need more power for your programs, "overclocking" is an option. The program we make here will not need the power per se, but I think it's a good place to introduce the concept.
So here we go, let's start out our program. You'll need to download another zip file for this lesson. You can get it here. You'll need to make a main.c file in the same folder as the files you extract from the zip file.
#include
#include
#include
#include
#include
#include "graphics.h"
Assuming you have completed the previous lessons, this isn't anything you haven't seen. The only thing that should look new to you is the "psppower.h" include. This file contains the functions we will use to change the PSP's clock speed.
On to some more familiar code:
PSP_MODULE_INFO("Background Changer", 0, 1, 1);
#define RGB(r, g, b) ((r)|((g)<<8)|((b)<<16))
Remember how in Lesson 02 we just glossed over this line without explaining what it really did? Well, I think it's time that you learn. The first parameter is your program identifier, so basically your program name. The second parameter allows you to pass attributes. For most of your programs you will just want to use a 0, but if you are making a kernel mode app, you will need to switch this to "0x1000". The third parameter is for the major version, the fourth is minor version. These are just meant to document the version number of your program.
Now the standard callbacks:
/* Exit callback */
int exit_callback(int arg1, int arg2, void *common) {
sceKernelExitGame();
return 0;
}
/* Callback thread */
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
/* Sets up the callback thread and returns its thread id */
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0) {
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
That concludes the set-up portion of this tutorial. Continue on to the second part of this tutorial. Onwards!
Lesson 06
Adding Sound
How to use libmad to play MP3 files in your programs.
This lesson was written by guest writer Stephen Merity (aka Smerity), so thanks to him for his great contribution.
First of all, thanks goes to John_K for porting libmad to the PSP and for developing PSPMediaCenter (which I used some of the code from). Also, a special thank you to seventoes, who posted a while back on PS2Dev.org asking for help with libmad with code that was so close to working!
This tutorial is a simple walkthrough concerning playing music in your programs. Sound FX and background music are two aspects that give an application a polished feeling, but they are often overlooked. Whether that is because a developer is rushing to get a release out of the door or whether it is because they simply don't know how to implement sound (or have any fitting music to to with their application) is unclear. Hopefully this tutorial will help some people get sound into their programs.
The first thing we are going to have to do is grab libmad from SVN. libmad is an MPEG audio decoder released under the GPL. It has been ported to the PSP by John_K.
To do this, open Cygwin, and type
svn checkout svn://svn.ps2dev.org/psp/trunk/libmad
You should see a long list of filenames scroll by as the package is downloaded.
Now we will switch into the libmad directory and compile the library:
cd libmad
make
The next bit is a little deviation from the routine we used to install our libraries in Lesson 04. Usually, you could type "make install" and it would automatically install the files to their appropriate directories. Unfortunately, libmad's install script appears to be broken at the moment. Not to worry though, we can install it manually ourselves.
cp -Rf ./include /usr/local/pspdev/psp/
cp -Rf ./lib/libmad.a /usr/local/pspdev/psp/lib
NOTE: There is a space between "./include" and "/usr..." and between "libmad.a" and "/usr..."
This will copy all of the files into their appropriate place. The "-Rf" tag stands for "Recursive" and "final" -- it will just make sure that you copy everything and that you won't get any permission errors (which some users have reported as a problem without these flags).
Next, download and extract some necessary files into a new project folder. Inside are two files, mp3player.c and mp3player.h which were obtained from John_K's PSPMediaCenter, I made some slight changes to the files as follows (you don't need to do anything with this, it's just in case you were wondering):
//DO NOT ADD THIS TO YOUR PROGRAM
//IT IS EXAMPLE CODE
mp3player.c
Line 76 - /* void void MP3setStubs to end of function */ - specific to stubs again, see mp3player.h
mp3player.h
Line 10 - #include "../../codec.h" - specific to PSPMediaCenter
Line 17 - void MP3setStubs(codecStubs * stubs); - specific to PSPMediaCenter
Other than that, it was very clean. John_K has done a great job in porting it.
Now, on to the fun part. Create main.c in your editor of choice, and begin with your comments:
// Mp3 Player Sample on PSP
// By *YOUR NAME HERE*
The next little section should be standard to you. The only new includes are the "pspaudio.h" and "pspaudiolib.h." These headers are needed for the audio-specific functions that we will use in our program.
#include
#include
#include
#include
#include
#include
#include "mp3player.h"
PSP_MODULE_INFO("Mp3 Player Example", 0, 1, 1);
#define printf pspDebugScreenPrintf
You will also see that we included one of the files that you downloaded, "mp3player.h" (make sure that it's in the same directory as our source file). We also defined printf and did our PSP_MODULE_INFO.
http://www.psp-programming.com/tutorials/
Lesson 01
Setting up the Development Environment
Get the toolchain and PSPSDK up and running with CYGWIN.
This is the first installment in a series of tutorials focussed on getting a novice programmer well on his way to developing his own homebrew applications for the Sony Playstation Portable (PSP). If you are reading this, congratulations, you have hurdled one of the biggest obstacles for a programmer. Likely the most difficult thing about programming is getting started. Well, by starting to read this tutorial, you are well on your way.
The first step to creating your own program is getting your environment set up. This environment is how you will convert the source code you write into a compiled file formatted for execution on you PSP. We will be setting up two important tools on our system.
If, at any time in this tutorial series, you need help please head over to our forums and post a question. We are always happy to help a fellow programmer.
The first of these tools is called CYGWIN. It is basically a Linux emulator for windows. It will create a simulated Linux environment on your computer so that you can run native Linux applications. This may sound intimidating, but don't worry, it's very simple to use.
The second thing you'll need is the toolchain. This is the key to programming for the PSP. It will set up everything you need, from header files, to libraries, to the compiler itself, to the sample programs. Once you have this installed, you will be nearly ready to create your first program.
Now for the part we've all been waiting for: the installation.
The first step is to install CYGWIN. You can download the install file from the CYGWIN website here. After it has finished downloading, open up the executable. You will see a splash screen; click next. Now you will be asked what you want to do. Select the default option of "Install from Internet," and hit the next button. Now you will be prompted where you want to install CYGWIN. Change the install directory to "C:/cygwin" if it is not set as such already (where C: is your local hard drive). Leave the other options set to their defaults and hit next. Now you will be asked where you want to save the installation files. What you select here doesn't really matter, but I suggest putting them someplace where you will be able to find them and delete them after the installation is complete. Once you have selected a suitable location, click next. The next screen will ask about your network settings, if you don't use a proxy (or don't know what a proxy is), just click next on this screen. If it doesn't work, go back and try letting it use Internet Explorer's settings. Now you should be presented with a list of servers to download the installation files from. Any one of these will do, so select one, and then click on next. Now it will download the package list, this could take a few minutes, depending on your connection speed. Once it is done, scroll down to "devel" and click on where it says "default" so that it becomes "install." Then scroll down to "web," click the "+" next to it, scroll down and set "wget" to "install."
When you are finished, click next. CYGWIN will now download and install the selected packages. This will quite possibly take a while, so go watch a TV show or do some web surfing while you wait. After the install has finished, you are ready to install the toolchain.
Lesson 02
Setting up the Development Environment
The setup, creation, and execution or a "Hello World"
So, after reading Lesson 01, you have a working development environment in which to create your programs. Now what? Well, this is the part you've all been waiting for, your very first program for the PSP. This tutorial will explain the basics of the C programming language and build the foundation upon which you will build your kingd-- err... programs.
If, at any time in this tutorial, you need help please head over to our forums and post a question. We are always happy to help a fellow programmer.
We're going to create a folder hierarchy to organize our projects. Open up a CYGWIN bash shell, and type "mkdir projects" and then hit enter. This command ("mkdir") stands for "make directory" and it will create a directory, or folder, in your current operating directory. So now we have a new folder for all of our projects, navigate into it by typing "cd projects" and hitting enter. Now we are going to create another directory for this specific project. Type "mkdir helloworld" and hit enter. Now switch into the new directory with "cd helloworld."
The next step is to open up a text editor. It doesn't really matter what you open, it can be Notepad, Wordpad, whatever you want. I prefer using an editor that is dedicated to editting C/C++ source code because of the syntax highlighting options that are built in (I use Dev-C++), but honestly, it doesn't matter (so long as you know how to use it).
Now, create a new file and call it "main.c" in our "helloworld" directory. This is going to contain the source code for our program. For those of you who don't know what source code is (and I know there will be a few), the source code is what we write to create a program. It is written in a way that humans can understand. In most languages, the source needs to be converted to a format the computer (or in our case, the PSP) can understand. These are called compiled languages, and C and C++ fall into this category (the conversion is done by the compiler that we set up in Lesson 01). There are a few other programming languages that use what is called an interpreter to interpret the source code and send out machine code on the fly. These are called scripting languages (an example of a scripting language is PHP).
Alright, so we have a new file that is going to hold our source code. Now we need to start writing it. The first part of the program should contain comments to tell anyone reading our code what the aim of the program is, when it was written, and who the author is. Comments are lines of source code that are omitted from the compiled binary (or skipped by the interpretter in scripting languages). Comments are a very important part of your code, because when you (or someone else) come back to edit your source code later, you will not remember all of the intricacies of the program. So, you can leave yourself notes in the form of comments. Comments are signalled with the "//" and "/*" characters. Any time you see a "//" it means that the rest of the line will be a comment. A "/*" means that the compiler (or interpretter) will ignore your code until it reaches a "*/" signal. Comments signalled by the "/*" operator can span many lines, but comments signalled with "//" only comment out the rest of that line.
So, to start off our program, we are going to leave a comment at the top about what it does, when it was created, and who it was written by.
// Hello World - My First App for the PSP
/*
This program was created by (Your Name Here) on (Date Here)
It is a simple "Hello World" Application.
*/
The next portion of the program is where we tell the compiler which header files and which include files we are going to use in our program. Basically what the "#include" directive does is copy the code from the file you pass to it into the top of your program. This allows you to keep your program simple, while still using the advanced code that is already written for you. The include directive can include either header files that came with the compiler (or that you add to the compiler), or header files specific to the specific project that you are working on. The way that you discern which of these you are including is by whether you use "<>" to enclose the file or if you use quotes to do it. The less than and greater than signs include a file from the compiler's "include" directory, and the quotes include a file from the same directory as the file including them. We will be including two files in our program. The first is "pspkernel.h." This file will be included in every single program that you write for the PSP. It contains all of the code specific to your PSP. Your program will not work on the PSP if you do not include this file. The second file we are going to include is "pspdebug.h." This file contains several useful functions for debugging your programs, but specifically it includes the function that we are going to use to write text to the screen. So, add this code to your program:
#include
#include
Next we tell the PSP a little bit about the program. This isn't really that important, your program will compile without it, but it is always a good idea to keep it in (if only for forwards compatibility). The first attribute is the name of the program, but it's not really the name of the program that will appear (we'll change that later). The other values are other attributes (just leave it alone), major version, and minor version. We'll just leave all of these except for the name as the defaults. So, add the following line to your program:
PSP_MODULE_INFO("Hello World", 0, 1, 1);
Now we are going to set up the function that we will use to write to the screen. This step is optional, but it makes writing text based programs much easier. The basis behind this line is to change the function that is built into the PSP, called "pspDebugScreenPrintf" into something that's much easier to type. This function is used to write to the screen (which you will see later). What we are basically going to do here is rename "pspDebugScreenPrintf" to "printf." So every time we use "printf" from now on, the compiler will just treat it as if we have typed "pspDebugScreenPrintf." Here's how we'll do it; we'll define "printf" as "pspDebugScreenPrintf" like this:
#define printf pspDebugScreenPrintf
Lesson 03
A Programming Primer
A crash course in the basics of C programming for the PSP.
After reading Lesson 01 and Lesson 02, you should now have a development environment set up, and have compiled your first basic program for the PSP. Now it's time to move on to bigger and better things. A "hello world" application is fine and dandy, a great learning experience, but it doesn't do anything. That's what this tutorial is about. How to make your programs do things.
What you need to understand is that this tutorial is not meant to be the be all and end all of PSP programming. It is much less a "how to create a game" than it is a foot in the door. What you will gain here are the basic building blocks of PSP (and C) programming. You will need to rearrange and add to these blocks together to create your own, functional application.
Having read Lesson 02, or knowing how to set up a basic program is a prerequisite for this tutorial. We will not go through the process of setting up your program in this tutorial. So, to test the code that follows replace the line
printf("Hello World.");
from Lesson 02 except where otherwise noted. Since the other lines were just setup for our program, we need not go through what they do again.
The final product of this tutorial will be a program that counts upwards until the user presses a button or until the counter hits a predefined limit. This is the perfect application for this tutorial; it combines several core elements of C programming to create a simple, yet useful result without requiring many program-specific functions. Covered in this tutorial are: variables, if/then statements, loops, text formatting, and button input.
First off, we will need to add two more header includes. The first one is to give us a little more control over the screen (we need this for one of the functions we will be using later). The second file we will be including allows us to get button input. So to do add these two files (pspdisplay.h and pspctrl.h), we need to add these two lines right below our first two "#include" statements:
#include
#include
And that's all the extra setup we need. Now we'll move on to putting in the functional code. From here on, all code listed should go in your main function, replacing the "printf" statement from Lesson 02. The first thing we will do is declare the variables that we will use in our program. A variable declaration takes the following form:
//EXAMPLE (Psuedo Code)
//DO NOT ADD TO YOUR PROGRAM
type name=value;
The type is the data type of variable. Each data type can contain data (and only that data). For example, type "int" (meaning integer) can hold any non-decimal number from -32767 to 32767. A "float" is like an "int," but it can hold decimals. The "char" type can hold a letter. For our program, we will only use the built in type "int" and a PSP specific type called "SceCtrlData" which holds the button state of the PSP controls.
So, to declare the two variables that we are going to use, we insert the following two lines of code into our program (these should go where your "printf("Hello World.");" line was in Lesson 02; right after the line "SetupCallbacks();."
int counter = 0;
int i = 0;
SceCtrlData pad;
So now we have three variables that we can use. Two of type "int," named "counter" and "i," containing a value of zero for now. And one of type "SceCtrlData," named "pad," which is filled with junk at the moment (since we haven't yet initialized it). This is something to keep in mind when writing your own programs. If you declare a variable without initializing it (like our pad variable), it will not just be empty. It will contain the information that was previously in that chunk of memory. Declaring the variable just allocates a certain amount of memory space for the variable to be stored in. The initialization is what clears it out and allows us to use it. The reason that we haven't initialized "pad" at the same time that we declared it is because it wouldn't really make sense. Since it holds button input, you can't just initialize it by typing in a value. We'll initialize it later, before we use it for anything.
Now we're going to give the user some instructions. The way we do this is by using "printf" to output a statement to them. So put this after the variable declarations:
printf("Press [X] To Start the Timer");
Look familiar? Good. It's the same function we used to output "Hello World" in Lesson 02. So if you ran the program at this point, it would be just like the "hello world" application, except it would print out "Press [X] To Start the Timer" instead of "Hello World."
Now we need the program to wait until the user presses the [X] button before it does anything else. Now, this could be a very difficult, nearly impossible thing to do. Fortunately, we have something perfect for dealing with it. It's called a loop. Basically what it does is run through a block of code multiple times. There are different types of loops available to you (for loops, while loops, do while loops, etc), but this tutorial will only introduce two of those loops, the "while" loop and the "for" loop. How this loop works is that you give it a statement, and it will execute a block of code while that statement is true. For example, if you had a block of code that incremented a variable (starting with a value of zero) by one each time the loop was run, and the statement that you passed in the loop was "i<10" it would execute your code ten times, because on the eleventh time that it checked the value of the variable, it would be 10, which is not less than 10, so the statement would be false (man, this is a run on sentence if I've ever seen one). One other important concept that you will need to grasp is that "true" and "false" are synonymous with "1" and "0" respectively.
Phew. It's not so hard is it? I'm glad you agree (like how I just assume the answer to my rhetorical questions because you can't answer?). So let's move on to the second part of this tutorial.
Lesson 04
Simple Image Processing
A crash course on adding images to your applications.
Since Lesson 03 was released, I have been bombarded with e-mails, instant messages, phone calls, and even the occasional reader banging on my front door pleading with me to release another tutorial. Overwhelmingly they have requested a lesson on adding images to their programs. Well, you guys can finally stop all of that, because this long overdue article is finally here.
At this point, I'll assume that you already have CYGWIN and the PSP toolchain installed, understand how to compile source code into an EBOOT suitable for execution on the PSP, and have at least a basic understanding of the C programming language. If you don't meet these prerequisites, have no fear, read Lesson 01, Lesson 02, and Lesson 03, and then come back.
If it has been a while since you have updated your toolchain, you will need to do that since png.h is necessary for this tutorial and was not originally included in the PSP toolchain. Revisit Lesson 01 if you need a refresher on how to do that. I had to update before I was able to compile this program (if you already have CYGWIN installed, you can skip right to the step where you download the toolchain).
I would like to thank Psilocybeing for allowing me to use his example source code as a base for this tutorial. I had originally planned on using my own example code (adapted from Shine's original Snake game in C) to demonstrate, but that code is antiquated and unnecessarily complex. One major benefit of Psilocybeing's code is that all of the functions and datatypes are defined in external files, allowing you to more easily integrate the code into your own projects.
Before we do anything, we will need to install some new libraries from SVN. What's SVN you ask? Well, SVN is a version management system (it is shorthand for "subversion"). What we will be doing is grabbing some code from online to add more functionality to our compiler. The packages that we will need are zlib and libpng. zlib is a compression library and libpng allows us to work with PNG files (a type of image). To install these libraries, we will need to type the following things into a CYGWIN Bash Shell.
svn checkout svn://svn.pspdev.org/psp/trunk/zlib
"Checkout" is basically SVN's way of saying "download." This will download the zlib source into a folder called "zlib." It will take a minute, a bunch of stuff should scroll down the screen and you should be left back at the "$" for input.
So now we need to compile this new library, so we'll "cd" into the new folder.
cd zlib
We are now in the zlib folder, and are ready to compile. So, like any other thing that we want to compile, we just need to type
make
And voila, it compiles the library for us.
Now we need to put the resulting files into a place where the compiler can access them. So, we'll install them:
make install
And BAM! We've installed zlib. Now wasn't that simple?
Now for libpng. We just need to do the same thing, except we'll substitute "libpng" for "zlib."
cd ..
svn checkout svn://svn.pspdev.org/psp/trunk/libpng
cd libpng
make
make install
And there we are, ready to use PNG's in our program.
Now we'll just clean up those install files by deleting them. To delete things via a Linux shell (which is what CYGWIN emulates), you use the "rm" command. We don't only want to delete one file, though, we want to delete a whole folder and all of its contents, so we'll add the "-R" modifier to it to signify a recursive removal. Basically this just means we want to delete a folder and everything inside of that folder. We'll also use the "-f" modifier to force the deletion of write-protected files so that we don't have to hit "y" for each file we want to delete. So we'll "cd" back to the parent directory and remove both the "zlib" and "libpng" temporary folders that we just created.
rm -Rf zlib
rm -Rf libpng
Now that we have that out of the way, we are ready to start programming.
We'll move on to the second section of this tutorial to continue our program.
Lesson 05
Onwards and Upwards
More PSP Programming methods including overclocking, colors, and graphics based text.
Ok, so you've set up the development environment, written your first program, leaned some programming techniques, and dabbled in image programming, but what's next? Well, since you're on this page, I'll bet it comes as no surprise to you that it's Lesson 05! Here we will improve our programming skills (and by "we," I really mean "you") by learning about some more advanced concepts.
Advanced, though, is subjective. We are still forming the groundwork in C that you will build upon in truly advanced applications. By the end of this lesson, you should know how to "overclock" the PSP to its true speed of 333 MHz, be able to write text to the screen (graphic text, not the debug text we used before), and have an understanding of how colors work on the PSP.
The program that we are going to construct in this tutorial is a "backround changer." Basically, we are going to allow the user to select the color of the background, and we are going to change it accordingly, as well as display the components of that color on the screen.
First, some background. There is a wide misconception about "overclocking" the PSP. Because of preconceived notions, people associate "overclocking" with heat issues and broken hardware. There is a myth that "overclocking" the PSP is dangerous to the hardware. This is simply not the case with the PSP. The truth is that the PSP is underclocked when it ships from the factory. There are several theories for why Sony did this. One theory is that it drained battery life too quickly for Sony's liking (for us, that isn't much of a concern; spinning the UMD takes up far more battery power than loading off of the Memory Stick, so we already have a tremendous advantage in terms of battery life). Another theory is that Sony wanted developers to write streamlined code. And the third prevalent theory (and the most likely in my opinion) is that they want to allow developers to use the full speed at some point in the future to give a boost to games that will come out later. Anyway, the PSP normally runs at 222 MHz. If you need more power for your programs, "overclocking" is an option. The program we make here will not need the power per se, but I think it's a good place to introduce the concept.
So here we go, let's start out our program. You'll need to download another zip file for this lesson. You can get it here. You'll need to make a main.c file in the same folder as the files you extract from the zip file.
#include
#include
#include
#include
#include
#include "graphics.h"
Assuming you have completed the previous lessons, this isn't anything you haven't seen. The only thing that should look new to you is the "psppower.h" include. This file contains the functions we will use to change the PSP's clock speed.
On to some more familiar code:
PSP_MODULE_INFO("Background Changer", 0, 1, 1);
#define RGB(r, g, b) ((r)|((g)<<8)|((b)<<16))
Remember how in Lesson 02 we just glossed over this line without explaining what it really did? Well, I think it's time that you learn. The first parameter is your program identifier, so basically your program name. The second parameter allows you to pass attributes. For most of your programs you will just want to use a 0, but if you are making a kernel mode app, you will need to switch this to "0x1000". The third parameter is for the major version, the fourth is minor version. These are just meant to document the version number of your program.
Now the standard callbacks:
/* Exit callback */
int exit_callback(int arg1, int arg2, void *common) {
sceKernelExitGame();
return 0;
}
/* Callback thread */
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
/* Sets up the callback thread and returns its thread id */
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0) {
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
That concludes the set-up portion of this tutorial. Continue on to the second part of this tutorial. Onwards!
Lesson 06
Adding Sound
How to use libmad to play MP3 files in your programs.
This lesson was written by guest writer Stephen Merity (aka Smerity), so thanks to him for his great contribution.
First of all, thanks goes to John_K for porting libmad to the PSP and for developing PSPMediaCenter (which I used some of the code from). Also, a special thank you to seventoes, who posted a while back on PS2Dev.org asking for help with libmad with code that was so close to working!
This tutorial is a simple walkthrough concerning playing music in your programs. Sound FX and background music are two aspects that give an application a polished feeling, but they are often overlooked. Whether that is because a developer is rushing to get a release out of the door or whether it is because they simply don't know how to implement sound (or have any fitting music to to with their application) is unclear. Hopefully this tutorial will help some people get sound into their programs.
The first thing we are going to have to do is grab libmad from SVN. libmad is an MPEG audio decoder released under the GPL. It has been ported to the PSP by John_K.
To do this, open Cygwin, and type
svn checkout svn://svn.ps2dev.org/psp/trunk/libmad
You should see a long list of filenames scroll by as the package is downloaded.
Now we will switch into the libmad directory and compile the library:
cd libmad
make
The next bit is a little deviation from the routine we used to install our libraries in Lesson 04. Usually, you could type "make install" and it would automatically install the files to their appropriate directories. Unfortunately, libmad's install script appears to be broken at the moment. Not to worry though, we can install it manually ourselves.
cp -Rf ./include /usr/local/pspdev/psp/
cp -Rf ./lib/libmad.a /usr/local/pspdev/psp/lib
NOTE: There is a space between "./include" and "/usr..." and between "libmad.a" and "/usr..."
This will copy all of the files into their appropriate place. The "-Rf" tag stands for "Recursive" and "final" -- it will just make sure that you copy everything and that you won't get any permission errors (which some users have reported as a problem without these flags).
Next, download and extract some necessary files into a new project folder. Inside are two files, mp3player.c and mp3player.h which were obtained from John_K's PSPMediaCenter, I made some slight changes to the files as follows (you don't need to do anything with this, it's just in case you were wondering):
//DO NOT ADD THIS TO YOUR PROGRAM
//IT IS EXAMPLE CODE
mp3player.c
Line 76 - /* void void MP3setStubs to end of function */ - specific to stubs again, see mp3player.h
mp3player.h
Line 10 - #include "../../codec.h" - specific to PSPMediaCenter
Line 17 - void MP3setStubs(codecStubs * stubs); - specific to PSPMediaCenter
Other than that, it was very clean. John_K has done a great job in porting it.
Now, on to the fun part. Create main.c in your editor of choice, and begin with your comments:
// Mp3 Player Sample on PSP
// By *YOUR NAME HERE*
The next little section should be standard to you. The only new includes are the "pspaudio.h" and "pspaudiolib.h." These headers are needed for the audio-specific functions that we will use in our program.
#include
#include
#include
#include
#include
#include
#include "mp3player.h"
PSP_MODULE_INFO("Mp3 Player Example", 0, 1, 1);
#define printf pspDebugScreenPrintf
You will also see that we included one of the files that you downloaded, "mp3player.h" (make sure that it's in the same directory as our source file). We also defined printf and did our PSP_MODULE_INFO.
Three Classic Games in one Flash
oom Heretic and Hexen all in one archive. Do i have to tell something more?
Click on the image to play
Click on the image to play
The web home of super mario
www.supermariobrothers.org is a Super Mario dedicated site with many new free versions of the game There you can download Mario Games, music themes , videos and play on line Java applet compilations of Mario. I am sure that will satisfy every gamer that has played Mario at 90s but also the younger ones. I mean come on, we are talking about great versions of the game that has sold more copies that everything else here
|
|
|
|
Tetris makes you smart; smarter than this headline, anyway
Yes it is true Tetris makes your brain grow
By Brenna Hillier - Thu Sep 3, 2009 11:02am
So lets get smarter
Tetris online
Tetris arcade
Tetris-3d
Sonic Tetris
We're gamers, and we like games. We don't need much convincing to get at 'em on a regular basis. Nevertheless, since we have to face the wider world of detractors, it's handy to be armed with a bastion of useful facts and figures with which to defend our chosen pastime. The latest study adding ammunition to your near punch-ups in the bar is that gaming not only improves your brain's efficiency but even increases the amount of brain you have to work with.
These bold claims have been made by the Mind Research Network, a multidisciplinary, cross-institution group of academics and researches devoted to probing the secrets of the human mind. Quite why they chose to carry out this plan by plonking a bunch of adolescent girls down in front of Tetris is a question for the ages (although funding from Tetris creators might explain at least half) but their methods certainly got results.
While the full results are yet to be published, preliminary reports through Wired detailed the use of MRI scans to examine the brain before and after a three-month period of solid Tetris play. The gaggle of giggling teenage girls gathered for this purpose had improved efficiency in some areas of the brain, while other areas had actually sprouted more grey matter, as evidenced by thicker cortexes - so gaming can apparently even improve the structure of your brain!
The potential application of this knowledge is quite significant; Dr. Richard Haier, one of the researchers involved in the project, commented that the study could:
... which could possibly mean that a few daily bouts of block-slotting could help stave off the mental effects of aging. There's plenty of anecdotal evidence that a lively mind is an excellent preventative against non-sickness related mental decline, but now we have some shiny new facts to back it up, we can justify adding DSis to our favourite relative's Christmas gift lists.
"... demonstrate that a player of Tetris does see lasting effects that generalize to other activity ..."
Of course, for every piece of evidence in the pro-gaming column the other side of the debate table seems able to find a contrary study - but we can bask in the brain-growing warmth for a little while anyway.
So lets get smarter
Tetris online
Tetris arcade
Tetris-3d
Sonic Tetris
Doom the browser game
I have some very good news, there is a new version of the incredible game DOOM for you. The game has been transfered to Flash platform and is ready to dominate your browser
Pang out 3d: An OpenGL mini Game with Source Code
I promise to write a tutorial based on this game soon
The following link contains the video game pang out 3d
click here to download
Have good coding time
Browser game: ai pengo
I have found another good java applet game game that you can play online
it is called ai pengo and it is hosted at http://www.rebas.se/creative/mywebgames.shtml
click here to play
it is called ai pengo and it is hosted at http://www.rebas.se/creative/mywebgames.shtml
click here to play
| Introduction AI Pengo is a distant relative of the 1982 arcade game Pengo, and a semi-sequel to the Amiga game Martinsoft Pengo from 1994. The game was written by Martin Rebas. How to play it You're a penguin in a maze made out of ice blocks, which you can push around. On each level, you'll be hunted by monsters that hatch from weird-looking eggs. The monsters start out very slow (a third of your speed), but become faster on later levels. To progress to the next stage, squash all the monsters by pushing ice blocks onto them. If you're not quick enough, the squashed ones will reappear! There are 36 levels. If you're one of the 99 best players, you get to write your name on the hiscore list! | Basic controls Move using the arrow keys. Push ice blocks with space. If the keys don't seem to work, try clicking the game once with the left mouse button. Other important keys On the title screen, use space to start, "h" to show hiscores, and "s" to read the story. While playing, you can pause the game with "p" and turn in-game music on or off with "m". There's an alternative "slippery-slidey" control mode, which you activate by pressing "k". Oh, and the "g" key has no function whatsoever in this game. | |
| System requirements AI Pengo was created on a 400MHz PC, and needs a reasonably fast computer to run properly. If AI Pengo doesn't start at all, it might be because your browser doesn't support Java, or because the internet connection is bad and the game can't load the required data. About AI Pengo I wrote this game to try out some ideas for Artificial Intelligence routines. I wanted to make a game where the enemies always did the smartest thing possible; where they worked in teams to get you, and where you'd have to think to avoid them. There is just one kind of enemy, but it uses every trick in the book to get you - even psychological tactics. From an aesthetic perspective, I've tried to make the monsters look like computer game enemies did in the early/mid-eighties; they're Bubble Bobble/Mr Do! enemy clones. The song "Sounds Like A Melody" from the excellent 1984 album Forever Young is used with permission from the band Alphaville. | ||
Friday, September 18, 2009
Sony: PS3 Failure Rate is 0.5%
The so-called red ring of death was a major issue for Microsoft immediately following the launch of the Xbox 360 console, with as many as 50 per cent of machines suffering from the issue. Sony has so far managed to escape similar hardware failure complaints, until now. A BBC 'watchdog' report which aired on television today suggested that the company has its own hardware reliability issues. Some console owners have complained about the 'Yellow light of death' failure on the PS3. In the BBC report, investigative journalists suggested that not only do a large number of consoles suffer from the problem, but that Sony 'refuses to fix' the problem if it manifests outside of the warranty period.
Sony vigorously disputes the claims made by the BBC. According to the company, Sony Computer Entertainment has run searches of its customer complaints database to identify the number of reports made to it regarding instances of system shutdown or failure in circumstances where the front panel yellow indicator is illuminated. The results show that of all PS3s sold in the UK to date, fewer than one half of one per cent of units have been reported as failing in circumstances where the yellow indicator is illuminated.
We're not sure who to believe in this case. On one hand, Sony appears to have made a very robust product, and we've yet to encounter any problems with our own PS3 units here in the United States. But on the other hand, the BBC is supposed to be a fairly trusted journalistic source (more reliable say, than Joe's Xbox fanboy blog).
Sony's warranty currently covers PS3 owners for one year after purchase.
In response to the "Red Ring" failures, Microsoft extended the warranty of the Xbox 360 console for up to three years to cover the problem under specific circumstances.
A first-generation PS3 unit displaying the yellow light of death.
Sony vigorously disputes the claims made by the BBC. According to the company, Sony Computer Entertainment has run searches of its customer complaints database to identify the number of reports made to it regarding instances of system shutdown or failure in circumstances where the front panel yellow indicator is illuminated. The results show that of all PS3s sold in the UK to date, fewer than one half of one per cent of units have been reported as failing in circumstances where the yellow indicator is illuminated.
We're not sure who to believe in this case. On one hand, Sony appears to have made a very robust product, and we've yet to encounter any problems with our own PS3 units here in the United States. But on the other hand, the BBC is supposed to be a fairly trusted journalistic source (more reliable say, than Joe's Xbox fanboy blog).
Sony's warranty currently covers PS3 owners for one year after purchase.
In response to the "Red Ring" failures, Microsoft extended the warranty of the Xbox 360 console for up to three years to cover the problem under specific circumstances.
A first-generation PS3 unit displaying the yellow light of death.Metal Gear Solid Peacewalker Demo at TGS
Production on Kojima's new entry in the Metal Gear Solid franchise must be progressing well. The auteur developer has announced that a playable demo of the cold-war espionage title will be given out to attendees at this year's Tokyo Game Show. The conference takes place between September 24th - 28th, and the last few days of the event are open to the public. Konami says that this demo is "exclusive" to the Japanese conference, but perhaps users will find a way to share the demo with those of us too broke to attend. Or, better yet, maybe Konami will release a public demo on the PSN so that we can all see what Kojima and his team have been up to. Right now we're not sure what will be in the demo, but we suspect that Kojima will want to show off the cooperative multiplayer system at the heart of the game.
In addition to hot games like Peacewalker, Kingdom Hearts and Gran Turismo PSP, we will be keeping a close eye on Sony this year. That's because the company says it is ready to take the lid off one of its Secret Games for the PS3. What could it be? Our money is on an RPG title of some sort, because those are always popular in Japan.
Metal Gear Solid: Peacewalker looks good so far.
In addition to hot games like Peacewalker, Kingdom Hearts and Gran Turismo PSP, we will be keeping a close eye on Sony this year. That's because the company says it is ready to take the lid off one of its Secret Games for the PS3. What could it be? Our money is on an RPG title of some sort, because those are always popular in Japan.
Metal Gear Solid: Peacewalker looks good so far.Play Virtual Reality Magic Cube on line
Virtual Reality Magic Cube is Rubik's Cube java applet version with 3d Graphics
http://www.npac.syr.edu/projects/java/magic/Magic.zip
http://www.npac.syr.edu/projects/java/magic/Magic.zip
Play Frozen Bubble on line
There is an applet version of the famous open source game Frozen Bouble
Press the up arrow to start the game and play
You can download it from
http://glenn.sanson.free.fr/v2/?select=fb:play
Press the up arrow to start the game and play
You can download it from
http://glenn.sanson.free.fr/v2/?select=fb:play
Thursday, September 17, 2009
Golem Quest Open Source J2me Game
Some years ago i had create a J2me game that i had not published and i decided to give it as Open Source software. So click here to download Golem Quest for mobile phones.
Golem Quest is an action game that players control a Golem and try to destroy towers. During the game you fight against mythical creatures like Elves, Magicians, Solars etc that will try to stop you.
Golem Quest is allmost completed, it is fully playable, there are 9 different levels and bugs free but there are some menu options that are not working. It is design to be played in mobile phones that support MIDP 2.0, with screen size 176x208 and above. You can download the rar and extract the netbeans project with the compiled game to test it, change it or just read some J2me source code
Subscribe to:
Posts (Atom)