Welcome to the Java Programming Forums


The professional, friendly Java community. 21,500 members and growing!


The Java Programming Forums are a community of Java programmers from all around the World. Our members have a wide range of skills and they all have one thing in common: A passion to learn and code Java. We invite beginner Java programmers right through to Java professionals to post here and share your knowledge. Become a part of the community, help others, expand your knowledge of Java and enjoy talking with like minded people. Registration is quick and best of all free. We look forward to meeting you.


>> REGISTER NOW TO START POSTING


Members have full access to the forums. Advertisements are removed for registered users.

Results 1 to 13 of 13

Thread: Tetris Mobile Game is not Running

  1. #1
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Tetris Mobile Game is not Running

    tetris.rar
     import java.io.*;
    import java.io.*;
    import java.util.Random;
     
    import javax.microedition.lcdui.*;
    import javax.microedition.midlet.*;
    import javax.microedition.rms.*;
     
    import tetris.model.TetrisBoard;
    import tetris.model.TetrisPiece;
    import tetris.ui.TetrisCanvas;
     
    /**
     * Maintains game state.  Handles input.
     */
    public class TetrisMidlet extends MIDlet implements CommandListener {
     
    	private TetrisCanvas gameCanvas;		// canvas on which the game is painted	
     
    	private TetrisBoard board;				// holds the game state
    	private TetrisPiece activePiece;		// holds the state of the active piece
     
    	private int score;						// the current game score
    	private int level;						// the current level
    	private int lineCount;					// the current number of lines cleared
    	private int nextPieceType;				// the next piece
    	private int tickSpeed;					// the speed in milliseconds between drops
     
    	private int hiScore;					// the current hi score
    	private RecordStore tetrisStore;		// the RecordStore holding the hi score
    	private int hiScoreRecordId;			// the record id in the RecordStore of the hi score
     
    	private boolean[] completedRows;		// array of booleans indicating the rows that have been cleared
    											// store as an instance variable so we reuse without reallocating
     
    	private Random rand;					// generates pseudo random numbers to choose the next piece
     
    	private Command exitCommand;			// Command to exit the app
    	private Command pauseCommand;			// Command to pause the app
    	private Command resumeCommand;			// Command to resume the app after a pause
     
    	private int gameState = TetrisConstants.UNINITIALIZED;	// mark as unitialized at first, can check in startApp to see if init necessary
     
    	private DropThread dropThread;			// the thread that drops the active piece one row per tick
     
    	/**
    	 * Start the app.
    	 * @see MIDlet#startApp()
    	 */
    	protected void startApp() throws MIDletStateChangeException {
    		if(TetrisConstants.UNINITIALIZED == this.gameState) {
    			// game is just starting up, need to initialize
    			this.init();
    		} else if(TetrisConstants.RUNNING_STATE == this.gameState) {
    			// game is resuming from an external suspend
    			// this puts it in the internal pause state
    			this.resumeGame();
    		} else {
    			// resumed from the title screen, just repaint
    			this.gameCanvas.reset();
    		}
     
    		Display.getDisplay(this).setCurrent(this.gameCanvas);
    	}
     
    	/**
    	 * Suspend the app.
    	 * @see MIDlet#pauseApp()
    	 */
    	protected void pauseApp() {
    		// put the game in its internal paused state before suspending the app
    		if(TetrisConstants.RUNNING_STATE == this.gameState) {
    			this.pauseGame();
    		}
    	}
     
    	/**
    	 * Exit.
    	 * @see MIDlet#destroyApp(boolean)
    	 */
    	protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {
    		if(null != this.tetrisStore) {
    			// write out the hi score before exitting
    			this.writeAndCloseHiScore(this.hiScore);
    		}
    	}
     
    	/**
    	 * Initalization on app startup.
    	 */
    	private void init() {
    		this.board = new TetrisBoard();
    		this.gameCanvas = new TetrisCanvas(this);
     
    		this.activePiece = new TetrisPiece();		
    		this.completedRows = new boolean[TetrisConstants.HEIGHT];
    		this.hiScore = this.openAndReadHiScore();	// get currently saved hi score from rms
    		this.nextPieceType = TetrisConstants.UNINITIALIZED;
     
    		this.rand = new Random();
     
    		// setup exit/pause/resume commands
    		this.setupCommands();
    		this.gameCanvas.addCommand(this.exitCommand);
     
    		// put the app in a state to show the title screen
    		this.setGameState(TetrisConstants.TITLE_STATE);
    	}
     
    	/**
    	 * Set up the game state so that a new game is started.
    	 * @param level the initial level at which to start the game
    	 */
    	private void startNewGame(int level) {
    		this.gameCanvas.addCommand(this.pauseCommand);	// during running, pause command should be available
     
    		this.score = 0;
    		this.lineCount = 0;
    		this.level = level;
    		this.nextPieceType = this.getRandomPieceType();
    		this.tickSpeed = this.getInitialTickSpeed(this.level);
     
    		this.board.clearBoard();
    		this.tryAddNewPiece();
     
    		this.setGameState(TetrisConstants.RUNNING_STATE);
     
    		this.runDropThread();
    	}
     
    	/**
    	 * Put the app in an end game state.  Should redisplay the title screen.
    	 */
    	private void endGame() {
    		// no commands needed, don't need to pause when not playing
    		this.gameCanvas.removeCommand(this.pauseCommand);
     
    		this.hiScore = Math.max(this.hiScore, this.score);		// set hi score if current score is higher
    		this.nextPieceType = TetrisConstants.UNINITIALIZED;
    		this.setGameState(TetrisConstants.TITLE_STATE);							// show the title screen
     
    		this.dropThread.stopThread();
    		this.dropThread = null;		// will have to replace it anyway, might as well gc as soon as possible
    	}
     
    	/**
    	 * Put the game into a paused state during running.
    	 */
    	private void pauseGame() {
    		// replace the pause command with a resume command
    		this.gameCanvas.removeCommand(this.pauseCommand);
    		this.gameCanvas.addCommand(this.resumeCommand);
     
    		// put in paused state and stop dropping
    		this.setGameState(TetrisConstants.PAUSED_STATE);
    		this.dropThread.stopThread();
    	}
     
    	/**
    	 * Resume the game from a paused state.
    	 */
    	private void resumeGame() {
    		// replace the resume command with a pause command
    		this.gameCanvas.removeCommand(this.resumeCommand);
    		this.gameCanvas.addCommand(this.pauseCommand);
     
    		// put in running state and resume dropping
    		this.setGameState(TetrisConstants.RUNNING_STATE);
    		this.runDropThread();
    	}
     
    	/**
    	 * Run the drop thread.  In MIDP 1.0 it doesn't seem possible to restart a thread.
    	 * Instead just create a new one and start it.
    	 */
    	private void runDropThread() {
    		this.dropThread = new DropThread(this);
    		this.dropThread.start();
    	}
     
    	/**
    	 * Set the initial tick speed according to the given level.
    	 * 
    	 * @param level the initial level
    	 * @return the initial tick speed
    	 */
    	private int getInitialTickSpeed(int level) {
    		int initialTickSpeed = TetrisConstants.BASE_SPEED;
     
    		// multiply by fraction for each level
    		for(int i = 0; i < level; i++) {
    			initialTickSpeed = (initialTickSpeed * TetrisConstants.SPEED_INCREASE_NUMERATOR) / TetrisConstants.SPEED_INCREASE_DENOMINATOR;
    		}
     
    		return initialTickSpeed;
    	}
     
    	/**
    	 * The MIDlet handles the key input.
    	 * This is called by the Canvas' listening keyPressed.
    	 * 
    	 * @param keyCode the keyCode from Canvas' keyPressed
    	 */
    	public void keyPressed(int keyCode) {
    		if(TetrisConstants.RUNNING_STATE == this.gameState) {
    			// if the app is in a running state, then we want the game actions
     
    			keyCode = this.gameCanvas.getGameAction(keyCode);	
     
    			if(Canvas.DOWN == keyCode) {
    				this.tryMoveDown();
    			} else if(Canvas.UP == keyCode) {
    				this.tryRotateLeft();
    			} else if(Canvas.LEFT == keyCode) {
    				this.tryMoveLeft();
    			} else if(Canvas.RIGHT == keyCode) {
    				this.tryMoveRight();
    			} else if(Canvas.FIRE == keyCode) {
    				this.quickDrop();
    			}
    		} else if(TetrisConstants.TITLE_STATE == this.gameState) {
    			// if we're at the title screen, get the level number from input
     
    			if(Canvas.KEY_NUM0 <= keyCode && Canvas.KEY_NUM9 >= keyCode) {
    				int level = keyCode - Canvas.KEY_NUM0;	
    				this.startNewGame(level);
    			}
    		}	
    	}
     
    	/**
    	 * Quick drop the active piece as far as it will go
    	 */
    	private synchronized void quickDrop() {
    		int dropScore = 0;	// 1 point for each line dropped
    		while(this.tryMoveDown()) {
    			dropScore++;
    		}
     
    		this.score += dropScore;
     
    		if(null != this.dropThread) {
    			// if the piece has been quick dropped, then the piece has been instantly dropped to the bottom.
    			// since the new piece is immediately added, it will drop a row at the end of the current tick.
    			// we specify to skip the next tick, the player gets the remainder of the current tick, plus
    			// the whole next tick before the piece drops a row.
    			this.dropThread.skipNextTick();
    		}
    	}
     
    	/**
    	 * Set the active piece as a new piece and choose the next piece
    	 * 
    	 * @return the active piece, updated as a new piece
    	 */
    	private TetrisPiece newPiece() {
    		int pieceType = this.nextPieceType;
    		this.nextPieceType = this.getRandomPieceType();
     
    		TetrisPiece activePiece = this.getActivePiece();
    		activePiece.setAsNewPiece(pieceType, TetrisConstants.START_X, TetrisConstants.START_Y);	
     
    		return activePiece;
    	}
     
    	/**
    	 * @return a pseudo random piece type
    	 */
    	private int getRandomPieceType() {
    		// MIDP 1.0 doesn't have Random.nextInt(int n)
    		// this is a bad substitute, but good enough for us...
    		return Math.abs(rand.nextInt() % TetrisConstants.NUM_PIECE_TYPES) + 1;
    	}
     
    	/**
    	 * Clear the completed rows from the board.
    	 * Wipes the filled rows and drops the rows above them.
    	 * 
    	 * @param piece the piece in its final position
    	 * @return number of rows cleared
    	 */
    	private int clearCompletedRows(TetrisPiece piece) {
    		TetrisBoard board = this.getBoard();
     
    		// check each row that the piece includes, see if completed
    		for(int i = 0; i < TetrisConstants.FOUR_BLOCKS; i++) {
    			int rowY = piece.getBlockY(i);
     
    			// mark rows completed that are filled
    			if(board.checkRowCompleted(rowY)) {
    				this.markRowCompleted(rowY, true);
    			}
    		}
     
    		int numClearedRows = 0;
    		for(int y = TetrisConstants.HEIGHT - 1; y >= 0; y--) { // iterate from bottom up
    			// each row should be dropped the current tally of completed rows
    			if(numClearedRows > 0) {
    				board.dropRow(y, numClearedRows);
    			}
     
    			if(this.isRowCompleted(y)) {
    				numClearedRows++;
    				this.markRowCompleted(y, false);	// reset for next time
    			}
    		}
     
    		// clear the top number of rows completed, these are new empty rows
    		for(int i = 0; i < numClearedRows; i++) {
    			board.clearRow(i);
    		}
     
    		return numClearedRows;
    	}
     
    	/**
    	 * Mark a row as completed, a setter accessor to the completedRows.
    	 * We use the instance completedRows to reuse the array without reallocating.
    	 * 
    	 * @param row the index of the row, lower indices at the top of the board
    	 * @param isCompleted true if the row is completed false otherwise
    	 */
    	private void markRowCompleted(int row, boolean isCompleted) {
    		this.completedRows[row] = isCompleted;
    	}
     
    	/**
    	 * Check if a row is completed, a getter accessor to the completedRows.
    	 * @param row the index of the row, lower indices at the top of the board
    	 * @return true if the row is completed false otherwise.
    	 */
    	private boolean isRowCompleted(int row) {
    		return this.completedRows[row];
    	}
     
    	/**
    	 * Update the game state to reflect the completed rows (adjust score, etc).
    	 * @param completedRows the number of completed rows
    	 */
    	private void updateRowState(int completedRows) {
    		this.lineCount += completedRows;	// increment the line count
     
    		// formula for scores is (ROW_SCORE * level) + ROW_SCORE
    		if(1 == completedRows) {
    			this.score += (this.level * TetrisConstants.ONE_ROW_SCORE) + TetrisConstants.ONE_ROW_SCORE;
    		} else if(2 == completedRows) {
    			this.score += (this.level * TetrisConstants.TWO_ROW_SCORE) + TetrisConstants.TWO_ROW_SCORE;
    		} else if(3 == completedRows) {
    			this.score += (this.level * TetrisConstants.THREE_ROW_SCORE) + TetrisConstants.THREE_ROW_SCORE;
    		} else if(4 == completedRows) {
    			this.score += (this.level *TetrisConstants. FOUR_ROW_SCORE) + TetrisConstants.FOUR_ROW_SCORE;
    		}
     
    		// integer division gets the level
    		int level = this.lineCount / TetrisConstants.LEVEL_UNIT;
    		if(level > this.level) {
    			this.level = level;
     
    			// level increase, adjust tick speed
    			this.tickSpeed = (this.tickSpeed * TetrisConstants.SPEED_INCREASE_NUMERATOR) / TetrisConstants.SPEED_INCREASE_DENOMINATOR;
    		}
    	}
     
    	/**
    	 * Try to add a new piece.  Check that there is room on the board.
    	 * If we can't add the piece, the game is over.
    	 * 
    	 * @return true if the piece was added, false if couldn't add and the game is over.
    	 */
    	private synchronized boolean tryAddNewPiece() {
    		TetrisPiece newPiece = this.newPiece();		// reset the active piece
    		TetrisBoard board = this.getBoard();
    		if(board.canAddNewPiece(newPiece)) {
    			board.addNewPiece(newPiece);
     
    			// added successfully
    			return true;
    		}
     
    		// no room to add, game over
    		this.endGame();
    		return false;
    	}
     
    	/**
    	 * Try to move the current piece down one row.
    	 * If we can't drop the piece any more, we try to add a new one.
    	 * 
    	 * @return true if the piece was dropped, false otherwise
    	 */
    	private synchronized boolean tryMoveDown() {
    		TetrisPiece activePiece = this.getActivePiece();
    		TetrisBoard board = this.getBoard();
     
    		if(board.canMoveDown(activePiece)) {
    			board.moveDown(activePiece);
    			this.gameCanvas.repaint();
     
    			// piece moved down
    			return true;
    		}
     
    		// couldn't move down
    		board.lockPiece(activePiece);
    		int numClearedRows = this.clearCompletedRows(activePiece);
    		this.updateRowState(numClearedRows);
    		this.tryAddNewPiece();
    		this.gameCanvas.repaint();
     
    		return false;
    	}
     
    	/**
    	 * Try to move the current piece left.
    	 * 
    	 * @return true if we could move the piece left, false if couldn't
    	 */
    	private synchronized boolean tryMoveLeft() {
    		if(this.getBoard().canMoveLeft(this.getActivePiece())) {
    			this.board.moveLeft(this.getActivePiece());
    			this.gameCanvas.repaint();
     
    			// piece moved left
    			return true;
    		}
     
    		// couldn't move left
    		return false;
    	}
     
    	/**
    	 * Try to move the current piece right.
    	 * 
    	 * @return true if we could move the piece right, false if couldn't
    	 */
    	private synchronized boolean tryMoveRight() {
    		if(this.getBoard().canMoveRight(this.getActivePiece())) {
    			this.board.moveRight(this.getActivePiece());
    			this.gameCanvas.repaint();
     
    			// piece moved right
    			return true;
    		}
     
    		// couldn't move right
    		return false;
    	}
     
    	/**
    	 * Try to rotate the piece left (counter-clockwise)
    	 * 
    	 * @return true if we could rotate left, false if couldn't
    	 */
    	private synchronized boolean tryRotateLeft() {
    		if(this.getBoard().canRotateLeft(this.getActivePiece())) {
    			this.board.rotateLeft(this.getActivePiece());
    			this.gameCanvas.repaint();
     
    			// rotated left
    			return true;
    		}
     
    		// couldn't rotate
    		return false;
    	}
     
    	/**
    	 * Try to rotate the piece right (clockwise)
    	 *
    	 * @return true if we could rotate right, false if couldn't
    	 */
    	private synchronized boolean tryRotateRight() {
    		if(this.getBoard().canRotateRight(this.getActivePiece())) {
    			this.board.rotateRight(this.getActivePiece());
    			this.gameCanvas.repaint();
     
    			// rotated right
    			return true;
    		}
     
    		// couldn't rotate
    		return false;
    	}
     
    	/**
    	 * Handle commands.  Implementation for CommandListener.
    	 * 
    	 * @param c the Command input
    	 * @param d the originating Displayable, not needed, since we only have the Canvass
    	 */
    	public void commandAction(Command c, Displayable d) {
    		if(c == this.exitCommand) {
    			try {
    				// on exit just destroy the app
    				this.destroyApp(true);
    				this.notifyDestroyed();
    			} catch(MIDletStateChangeException msce) {
    				// unconditional
    			}
    		} else if(c == this.pauseCommand) {
    			this.pauseGame();
    		} else if(c == this.resumeCommand) {
    			this.resumeGame();
    		}
    	}
     
    	/**
    	 * Setup the commands.
    	 * Once they're set up, add and remove pause/resume depending on the state.
    	 */
    	private void setupCommands() {
    		this.exitCommand = new Command("exit", Command.EXIT, 1);
    		this.pauseCommand = new Command("pause", Command.ITEM, 1);
    		this.resumeCommand = new Command("resume", Command.ITEM, 1);
     
    		this.gameCanvas.setCommandListener(this);
    	}
     
    	/**
    	 * Drop thread periodically calls this method.
    	 * We try to move down the active piece on each tick.
    	 */
    	public void tick() {
    		this.tryMoveDown();
    	}
     
    	/**
    	 * @return the board state object
    	 */
    	public TetrisBoard getBoard() {
    		return this.board;
    	}
     
    	/**
    	 * @return the active piece state object
    	 */
    	public TetrisPiece getActivePiece() {
    		return this.activePiece;
    	}
     
    	/**
    	 * @return the current game score
    	 */
    	public int getScore() {
    		return this.score;
    	}
     
    	/**
    	 * @return the current hi score
    	 */
    	public int getHiScore() {
    		return this.hiScore;
    	}
     
    	/**
    	 * @return the current line count
    	 */
    	public int getLineCount() {
    		return this.lineCount;
    	}
     
    	/**
    	 * @return the current level
    	 */
    	public int getLevel() {
    		return this.level;
    	}
     
    	/**
    	 * @return the upcoming piece once the current piece is dropped
    	 */
    	public int getNextPieceType() {
    		return this.nextPieceType;
    	}
     
    	/**
    	 * @return the current time between ticks (milliseconds)
    	 */
    	public int getTickSpeed() {
    		return this.tickSpeed;
    	}
     
    	/**
    	 * @return the current game state, should be a constant defined in the constants file
    	 */
    	public int getGameState() {
    		return this.gameState;
    	}
     
    	/**
    	 * Set the game state.
    	 * Additionally resets the canvas so it will repaint one-time painting.
    	 * 
    	 * @param gameState the new game state
    	 */
    	public void setGameState(int gameState) {
    		this.gameState = gameState;
     
    		if(null != this.gameCanvas) {
    			this.gameCanvas.reset();
    			this.gameCanvas.repaint();
    		}
    	}
     
    	/**
    	 * Open the record store and try to read a hi score out of it.
    	 * 
    	 * @return the hi score persisted in rms
    	 */
    	private int openAndReadHiScore() {
    		int hiScore = 0;
     
    		try {
    			this.tetrisStore = RecordStore.openRecordStore(TetrisConstants.TETRIS_RECORD_STORE, true);
    			if(this.tetrisStore.getNumRecords() > 0) {
    				// should be only one record, the hi score
     
    				RecordEnumeration recordEnum = this.tetrisStore.enumerateRecords(null, null, false);
    				this.hiScoreRecordId = recordEnum.nextRecordId();
    				byte[] hiScoreBytes = this.tetrisStore.getRecord(this.hiScoreRecordId);
     
    				// wrap the bytes in a DataInputStream so we can readInt
    				ByteArrayInputStream byteIn = new ByteArrayInputStream(hiScoreBytes);
    				DataInputStream dataIn = new DataInputStream(byteIn);
     
    				hiScore = dataIn.readInt();
     
    				// don't think this is necessary
    				dataIn.close();
    				byteIn.close();
    			}
    		} catch(Exception e) {
    			// nothing we can do, hiScore remains 0
    		}
     
    		return hiScore;
    	}
     
    	/**
    	 * Try to write the current hi score to the record store and close it.
    	 * 
    	 * @param score the current hi score
    	 */
    	private void writeAndCloseHiScore(int score) {
    		try {
    			// use DataOutputStream so we can writeInt
    			ByteArrayOutputStream byteOut = new ByteArrayOutputStream(4);	// a single int, should be 4 bytes
    			DataOutputStream dataOut = new DataOutputStream(byteOut);
    			dataOut.writeInt(this.hiScore);
     
    			// get the bytes for the int
    			byte[] hiScoreBytes = byteOut.toByteArray();
     
    			if(this.tetrisStore.getNumRecords() == 0) {
    				// no previously stored record, created a new one
    				this.tetrisStore.addRecord(hiScoreBytes, 0, hiScoreBytes.length);
    			} else {
    				// overwrite the existing hi score record
    				this.tetrisStore.setRecord(this.hiScoreRecordId, hiScoreBytes, 0, hiScoreBytes.length);
    			}
     
    			this.tetrisStore.closeRecordStore();
     
    			dataOut.close();
    			byteOut.close();
     
    		} catch(Exception e) {
     
    		}
    	}
    }
    I dont know whats wrong with this,it compiles but it doesnt have anything to run.Please help me.(this is not mine).Below is the whole game source.I hope you'll help me with this.Thanks
    Last edited by HacKofDeatH; February 4th, 2012 at 03:02 AM.


  2. #2
    Think of me.... Mr.777's Avatar
    Join Date
    Mar 2011
    Location
    Pakistan
    Posts
    1,136
    My Mood
    Grumpy
    Thanks
    20
    Thanked 82 Times in 78 Posts
    Blog Entries
    1

    Default Re: Tetris Mobile Game is not Running

    This post has been cross posted somewhere here at the forums. And i already replied to this post. Though cross posting is allowed but you must still refer everyone about the other similar posts.

  3. #3
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    i tried to debug this,but it doesnt have any errors..and in the phone,it only contains "Select one to launch".im still confused..

  4. #4
    Think of me.... Mr.777's Avatar
    Join Date
    Mar 2011
    Location
    Pakistan
    Posts
    1,136
    My Mood
    Grumpy
    Thanks
    20
    Thanked 82 Times in 78 Posts
    Blog Entries
    1

    Default Re: Tetris Mobile Game is not Running

    Quote Originally Posted by HacKofDeatH View Post
    i tried to debug this,but it doesnt have any errors..and in the phone,it only contains "Select one to launch".im still confused..
    Why did you start a new thread instead of discussing your problems over there?
    Debugging is never to see if there are any errors are not. Debugging can also be used to understand the flow of program/application.

  5. #5
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    Quote Originally Posted by Mr.777 View Post
    Why did you start a new thread instead of discussing your problems over there?
    Debugging is never to see if there are any errors are not. Debugging can also be used to understand the flow of program/application.
    I've post a new thread coz' i am eager to get some answers to my problem.Sorry if i'm too much noob here in forums.Have you tried my program?.If you please,try it and re-modify it if you want,it'll be a lot of help to me.Thanks in advance.

  6. #6
    Think of me.... Mr.777's Avatar
    Join Date
    Mar 2011
    Location
    Pakistan
    Posts
    1,136
    My Mood
    Grumpy
    Thanks
    20
    Thanked 82 Times in 78 Posts
    Blog Entries
    1

    Default Re: Tetris Mobile Game is not Running

    I've post a new thread coz' i am eager to get some answers to my problem.Sorry if i'm too much noob here in forums.
    That's why Forums Rules are. One must go through those rules to know about.
    Have you tried my program?
    No, i didn't find the need to.
    If you please,try it and re-modify it if you want,it'll be a lot of help to me
    Why should i re-modify it? Why don't you give it a try and if you get stuck, let us know and we might be able to help you.
    Good Luck.

  7. #7
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    Quote Originally Posted by Mr.777 View Post
    Why don't you give it a try and if you get stuck, let us know and we might be able to help you.
    Good Luck.
    Now I'm really stuck in this.I made some changes,but it still doesn't work.It keeps on running without errors,unfortunately it doesn't do anything.Please help me,and if you have some idea, please let me know. I'll thank you always.

  8. #8
    Think of me.... Mr.777's Avatar
    Join Date
    Mar 2011
    Location
    Pakistan
    Posts
    1,136
    My Mood
    Grumpy
    Thanks
    20
    Thanked 82 Times in 78 Posts
    Blog Entries
    1

    Default Re: Tetris Mobile Game is not Running

    Okay fine. I will help you in running all this. But not exactly i will do all for you.
    So, now tell me what
    import tetris.model.TetrisBoard;
    import tetris.model.TetrisPiece;
    import tetris.ui.TetrisCanvas;
    these imports are? Where do they exist?

  9. #9
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    Very big THANKS. Those imports are (own defined imports)
    -import tetris.ui.TetrisCanvas;
    *Handles all of the UI and painting for the app.
    * Delegates input to the Midlet instance itself.
    * Makes an effort to adjust itself to the available screen dimensions.
    * Also makes an effort to repaint only what is necessary.
    * Uses manual double buffering if the Canvas doesn't automatically double buffer.
    -import tetris.model.TetrisBoard;
    * Defines the state of the grid of blocks.
    * Has logic for manipulating supplied pieces' state on the board.
    * Whenever the board adjusts its state to reflect that a piece has changed,
    * it should also ensure that the piece's state is updated as well.
    -import tetris.model.TetrisPiece;
    * An instance of this defines the active piece that is being dropped.
    * Rather than instantiating a new one all the time, we use the same object and just reset its type and blocks.
    * Using a single instance saves in heap operations. This is really fairly negligible, so may consider
    * refactoring with an abstract parent and concrete implementations for each piece type.
    * This would allow custom rotating behavior, like two position rotating for I, S, and Z types, and no rotating for O.
    * Note that this class has no knowledge of the board. Anything updating the piece state will also want to
    * adjust the board. The adjusting logic can adjust the piece, and then examine the results to see how to
    * adjust the board, however.

  10. #10
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    Quote Originally Posted by Mr.777 View Post
    Where do they exist?
    I don't understand what you really mean by that. It exist in different packages,but it's still in the same source file.

  11. #11
    Think of me.... Mr.777's Avatar
    Join Date
    Mar 2011
    Location
    Pakistan
    Posts
    1,136
    My Mood
    Grumpy
    Thanks
    20
    Thanked 82 Times in 78 Posts
    Blog Entries
    1

    Default Re: Tetris Mobile Game is not Running

    Quote Originally Posted by HacKofDeatH View Post
    I don't understand what you really mean by that. It exist in different packages,but it's still in the same source file.
    Check the source again. It's saying Page not Found.

  12. #12
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    Quote Originally Posted by Mr.777 View Post
    Check the source again. It's saying Page not Found.
    Oh, the attached file? I'll re-attach it again. Im sorry for the late feedback.
    By the way,here's the download link of my file.
    http://www.mediafire.com/?42e9re9muiebu1w
    Last edited by HacKofDeatH; February 4th, 2012 at 03:08 AM.

  13. #13
    Junior Member
    Join Date
    Oct 2011
    Posts
    15
    My Mood
    Nerdy
    Thanks
    1
    Thanked 0 Times in 0 Posts

    Default Re: Tetris Mobile Game is not Running

    Any updates??Please help me with this.

Similar Threads

  1. Mobile Game Development Classes
    By skj.kamal in forum Java ME (Mobile Edition)
    Replies: 3
    Last Post: August 16th, 2012, 05:12 AM
  2. Tetris Mobile Game is not running.
    By HacKofDeatH in forum What's Wrong With My Code?
    Replies: 2
    Last Post: January 30th, 2012, 09:52 AM
  3. After an introduction to 'mobile game development'
    By epic in forum Android Development
    Replies: 2
    Last Post: November 30th, 2010, 01:01 PM
  4. hey - Mobile phone drinking game
    By pazzy in forum Java ME (Mobile Edition)
    Replies: 9
    Last Post: August 4th, 2009, 10:41 AM
  5. [SOLVED] How to start writing java mobile application?
    By Kok in forum Java ME (Mobile Edition)
    Replies: 15
    Last Post: July 30th, 2009, 02:52 AM