1879 lines
81 KiB
Java
1879 lines
81 KiB
Java
package mangavalk.tetris;
|
|
|
|
import android.app.Activity;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.BitmapFactory;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.media.MediaPlayer;
|
|
import android.os.Handler;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.TimerTask;
|
|
|
|
public class GamePlay extends GameStateInterface
|
|
{
|
|
// GameState.
|
|
protected int GameState = GS_STOPPED;
|
|
|
|
public GamePlay(Activity activity)
|
|
{
|
|
super(activity);
|
|
}
|
|
|
|
// Methods.
|
|
@Override
|
|
public void DrawFrame(Canvas canvas) {
|
|
DrawGameSpace(canvas);
|
|
}
|
|
|
|
@Override
|
|
public void onPause()
|
|
{
|
|
mp.pause();
|
|
|
|
SetGameState(GS_PAUSED, false);
|
|
}
|
|
|
|
@Override
|
|
public void SendMove(float x, float y, boolean pointerUp) {
|
|
int moveX = (int)((x / Width) * 90);
|
|
int moveY = (int)((y / Height) * 160);
|
|
|
|
if (!pointerUp)
|
|
{
|
|
if (GameState != GS_GAMEOVER)
|
|
{
|
|
if (moveX >= 28 && moveX <= 55 && moveY >= 143 && moveY <= 155) // Start
|
|
{
|
|
if (GameState == GS_PLAYING)
|
|
onPause();
|
|
else
|
|
{
|
|
mp.start();
|
|
SetGameState(GS_PLAYING, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GameState == GS_PLAYING)
|
|
{
|
|
InputsGamePlaying(x, y, pointerUp);
|
|
}
|
|
|
|
if (GameState == GS_GAMEOVER)
|
|
{
|
|
StartGame();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void SetGameState(int gameState, boolean isPostBack)
|
|
{
|
|
GameState = gameState;
|
|
|
|
switch(GameState)
|
|
{
|
|
case GS_RESUME:
|
|
{
|
|
Resume();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isPostBack)
|
|
canvasView.OnGameStateChanged(GameState);
|
|
}
|
|
|
|
// Set
|
|
@Override
|
|
public void SetCanvas(CanvasView _CanvasView)
|
|
{
|
|
canvasView = _CanvasView;
|
|
}
|
|
|
|
@Override
|
|
public void SetActivity(Activity _Activity)
|
|
{
|
|
activity = _Activity;
|
|
}
|
|
|
|
public void SetStartLevel(int StartLevel)
|
|
{
|
|
startLevel = StartLevel;
|
|
}
|
|
|
|
@Override
|
|
public void SetPayedVersion(boolean payedVersion)
|
|
{
|
|
PayedVersion = payedVersion;
|
|
}
|
|
|
|
// Get
|
|
@Override
|
|
public int GetGameState()
|
|
{
|
|
return GameState;
|
|
}
|
|
|
|
// Variabelen
|
|
|
|
// Block Array
|
|
int[][] blockArray = new int[][]{
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
// Draw Array
|
|
int[][] drawArray = new int[][]{
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
int[][][][] drawBlocks = new int[][][][]{
|
|
{
|
|
{
|
|
{0, 0, 0, 0},
|
|
{8, 9, 10, 11},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, 0}
|
|
},
|
|
{
|
|
{0, 0, 12, 0},
|
|
{0, 0, 13, 0},
|
|
{0, 0, 14, 0},
|
|
{0, 0, 15, 0}
|
|
},
|
|
{
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, 0},
|
|
{8, 9, 10, 11},
|
|
{0, 0, 0, 0}
|
|
},
|
|
{
|
|
{0, 12, 0, 0},
|
|
{0, 13, 0, 0},
|
|
{0, 14, 0, 0},
|
|
{0, 15, 0, 0}
|
|
}
|
|
},
|
|
{
|
|
{
|
|
{7, 0, 0, 0},
|
|
{7, 7, 7, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 7, 7, 0},
|
|
{0, 7, 0, 0},
|
|
{0, 7, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 0, 0, 0},
|
|
{7, 7, 7, 0},
|
|
{0, 0, 7, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 7, 0, 0},
|
|
{0, 7, 0, 0},
|
|
{7, 7, 0, 0},
|
|
{0, 0, 0, -1}
|
|
}
|
|
},
|
|
{
|
|
{
|
|
{0, 0, 6, 0},
|
|
{6, 6, 6, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 6, 0, 0},
|
|
{0, 6, 0, 0},
|
|
{0, 6, 6, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 0, 0, 0},
|
|
{6, 6, 6, 0},
|
|
{6, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{6, 6, 0, 0},
|
|
{0, 6, 0, 0},
|
|
{0, 6, 0, 0},
|
|
{0, 0, 0, -1}
|
|
}
|
|
},
|
|
{
|
|
{
|
|
{0, 1, 1, 0},
|
|
{0, 1, 1, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 1, 1, 0},
|
|
{0, 1, 1, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 1, 1, 0},
|
|
{0, 1, 1, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 1, 1, 0},
|
|
{0, 1, 1, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
}
|
|
},
|
|
{
|
|
{
|
|
{0, 3, 3, 0},
|
|
{3, 3, 0, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 3, 0, 0},
|
|
{0, 3, 3, 0},
|
|
{0, 0, 3, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 0, 0, 0},
|
|
{0, 3, 3, 0},
|
|
{3, 3, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{3, 0, 0, 0},
|
|
{3, 3, 0, 0},
|
|
{0, 3, 0, 0},
|
|
{0, 0, 0, -1}
|
|
}
|
|
},
|
|
{
|
|
{
|
|
{0, 2, 0, 0},
|
|
{2, 2, 2, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 2, 0, 0},
|
|
{0, 2, 2, 0},
|
|
{0, 2, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 0, 0, 0},
|
|
{2, 2, 2, 0},
|
|
{0, 2, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 2, 0, 0},
|
|
{2, 2, 0, 0},
|
|
{0, 2, 0, 0},
|
|
{0, 0, 0, -1}
|
|
}
|
|
},
|
|
{
|
|
{
|
|
{5, 5, 0, 0},
|
|
{0, 5, 5, 0},
|
|
{0, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 0, 5, 0},
|
|
{0, 5, 5, 0},
|
|
{0, 5, 0, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 0, 0, 0},
|
|
{5, 5, 0, 0},
|
|
{0, 5, 5, 0},
|
|
{0, 0, 0, -1}
|
|
},
|
|
{
|
|
{0, 5, 0, 0},
|
|
{5, 5, 0, 0},
|
|
{5, 0, 0, 0},
|
|
{0, 0, 0, -1}
|
|
}
|
|
}
|
|
};
|
|
|
|
int[] LevelSpeed = { 53, 49, 45, 41, 37, 33, 28, 22, 17, 11, 10, 9, 8, 7, 6, 6, 5, 5, 4, 4, 3};
|
|
|
|
// Parameters.
|
|
int GameSpaceLeft = 4;
|
|
int GameSpaceTop = 0;
|
|
int GameSpaceRight = 53;
|
|
int GameSpaceBottom = 115;
|
|
|
|
// Tetrmino.
|
|
int CurrentBlock = 0;
|
|
int CurrentBlockPossition = 0;
|
|
|
|
int NewBlock = 0;
|
|
int NewBlockPossition = 0;
|
|
|
|
// Sprites.
|
|
Bitmap bitmapl1, bitmapl2, bitmapt, bitmapb, bitmaps, bitmapz, bitmapi1, bitmapi2, bitmapi3, bitmapi4,
|
|
bitmapi1r, bitmapi2r, bitmapi3r, bitmapi4r, bitmapblockline, bitmapscore, bitmapcontroller, bitmapgameover;
|
|
|
|
Bitmap Font0, Font1, Font2, Font3, Font4, Font5, Font6, Font7, Font8, Font9;
|
|
|
|
// Audio.
|
|
MediaPlayer mp;
|
|
|
|
// Score.
|
|
int startLevel = 0;
|
|
int level = 0;
|
|
int lines = 0;
|
|
int score = 0;
|
|
|
|
// Add Settings.
|
|
boolean PayedVersion;
|
|
|
|
// Timer.
|
|
TimerTask MoveEvent = new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
GoDown();
|
|
}
|
|
};
|
|
|
|
private Handler handler = new Handler();
|
|
private Runnable runnable = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
level = ( (startLevel + lines)<=200 ? startLevel + (lines / 10) : 20 );
|
|
int newSpeed = (int)((1000 / 59.73) * LevelSpeed[level]);
|
|
handler.postDelayed(this, newSpeed);
|
|
GoDown();
|
|
}
|
|
};
|
|
|
|
// Inputs.
|
|
int OldInputTime=0;
|
|
|
|
// Methods.
|
|
private void StartGame()
|
|
{
|
|
// Clear.
|
|
for ( int i=0; i<blockArray.length; i++)
|
|
{
|
|
for ( int i2=0; i2<blockArray[i].length; i2++)
|
|
{
|
|
blockArray[i][i2] = 0;
|
|
}
|
|
}
|
|
for ( int i=0; i<drawArray.length; i++)
|
|
{
|
|
for ( int i2=0; i2<drawArray[i].length; i2++)
|
|
{
|
|
drawArray[i][i2] = 0;
|
|
}
|
|
}
|
|
// Initlialize.
|
|
level = 0;
|
|
lines = 0;
|
|
score = 0;
|
|
|
|
CheckTetriminoSpawnArray();
|
|
|
|
NewBlock = Tetrimino.get(0);
|
|
Tetrimino.remove(0);
|
|
NewBlockPossition = 0;
|
|
|
|
SpawnBlock();
|
|
|
|
// Audio
|
|
mp.setLooping(true);
|
|
mp.start();
|
|
|
|
SetGameState(GS_PLAYING, false);
|
|
|
|
handler.removeCallbacksAndMessages(null);
|
|
handler.postDelayed(runnable, 100);
|
|
}
|
|
|
|
// TODO game state
|
|
@Override
|
|
public void Load()
|
|
{
|
|
// Load Bitmap's.
|
|
LoadSprites();
|
|
|
|
LoadFont();
|
|
|
|
// Initlialize.
|
|
|
|
// Audio
|
|
mp = MediaPlayer.create(activity, R.raw.tetris_a);
|
|
}
|
|
|
|
@Override
|
|
public void Start()
|
|
{
|
|
StartGame();
|
|
}
|
|
|
|
private void LoadSprites()
|
|
{
|
|
bitmapl1 = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_l1);
|
|
|
|
bitmapl1 = Bitmap.createScaledBitmap(bitmapl1,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapl2 = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_l2);
|
|
|
|
bitmapl2 = Bitmap.createScaledBitmap(bitmapl2,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapt = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_t);
|
|
|
|
bitmapt = Bitmap.createScaledBitmap(bitmapt,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapb = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_b);
|
|
|
|
bitmapb = Bitmap.createScaledBitmap(bitmapb,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmaps = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_s);
|
|
|
|
bitmaps= Bitmap.createScaledBitmap(bitmaps,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapz = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_z);
|
|
|
|
bitmapz = Bitmap.createScaledBitmap(bitmapz,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi1 = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i1);
|
|
|
|
bitmapi1 = Bitmap.createScaledBitmap(bitmapi1,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi2 = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i2);
|
|
|
|
bitmapi2 = Bitmap.createScaledBitmap(bitmapi2,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi3 = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i3);
|
|
|
|
bitmapi3 = Bitmap.createScaledBitmap(bitmapi3,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi4 = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i4);
|
|
|
|
bitmapi4 = Bitmap.createScaledBitmap(bitmapi4,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi1r = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i1r);
|
|
|
|
bitmapi1r = Bitmap.createScaledBitmap(bitmapi1r,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi2r = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i2r);
|
|
|
|
bitmapi2r = Bitmap.createScaledBitmap(bitmapi2r,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi3r = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i3r);
|
|
|
|
bitmapi3r = Bitmap.createScaledBitmap(bitmapi3r,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
bitmapi4r = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_i4r);
|
|
|
|
bitmapi4r = Bitmap.createScaledBitmap(bitmapi4r,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 0.1f + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight))),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 0.1f + (map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom))), false);
|
|
|
|
|
|
bitmapblockline = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_blockline);
|
|
|
|
bitmapblockline = Bitmap.createScaledBitmap(bitmapblockline,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 4),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom-GameSpaceTop), false);
|
|
|
|
if (PayedVersion)
|
|
{
|
|
bitmapscore = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_score);
|
|
}
|
|
else
|
|
{
|
|
bitmapscore = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_freeversion);
|
|
}
|
|
|
|
bitmapscore = Bitmap.createScaledBitmap(bitmapscore,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 90-GameSpaceRight-4),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom-GameSpaceTop), false);
|
|
|
|
bitmapcontroller = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_controler);
|
|
|
|
bitmapcontroller = Bitmap.createScaledBitmap(bitmapcontroller,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 90),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, (160 - GameSpaceBottom)), false);
|
|
|
|
bitmapgameover = BitmapFactory.decodeResource(r,
|
|
R.drawable.sprite_gameover);
|
|
|
|
bitmapgameover = Bitmap.createScaledBitmap(bitmapgameover,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, (GameSpaceRight - GameSpaceLeft)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, (GameSpaceBottom - GameSpaceTop)), false);
|
|
}
|
|
|
|
private void LoadFont()
|
|
{
|
|
Font0 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f0);
|
|
|
|
Font0 = Bitmap.createScaledBitmap(Font0,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font1 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f1);
|
|
|
|
Font1 = Bitmap.createScaledBitmap(Font1,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font2 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f2);
|
|
|
|
Font2 = Bitmap.createScaledBitmap(Font2,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font3 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f3);
|
|
|
|
Font3 = Bitmap.createScaledBitmap(Font3,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font4 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f4);
|
|
|
|
Font4 = Bitmap.createScaledBitmap(Font4,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font5 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f5);
|
|
|
|
Font5 = Bitmap.createScaledBitmap(Font5,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font6 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f6);
|
|
|
|
Font6 = Bitmap.createScaledBitmap(Font6,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font7 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f7);
|
|
|
|
Font7 = Bitmap.createScaledBitmap(Font7,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font8 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f8);
|
|
|
|
Font8 = Bitmap.createScaledBitmap(Font8,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
|
|
Font9 = BitmapFactory.decodeResource(r,
|
|
R.drawable.f9);
|
|
|
|
Font9 = Bitmap.createScaledBitmap(Font9,
|
|
(int)GetRealPixelSize(DIP_W, dpWidth, 5),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, 6), false);
|
|
}
|
|
|
|
private void DrawGameSpace(Canvas canvas)
|
|
{
|
|
// Sides
|
|
canvas.drawBitmap(bitmapblockline, GetRealPixelSize(DIP_W, dpWidth, 0), GetRealPixelSize(DIP_H, dpHeight, GameSpaceTop), null);
|
|
canvas.drawBitmap(bitmapblockline, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight), GetRealPixelSize(DIP_H, dpHeight, GameSpaceTop), null);
|
|
|
|
canvas.drawBitmap(bitmapcontroller, GetRealPixelSize(DIP_W, dpWidth, 0), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom), null);
|
|
|
|
// Score
|
|
canvas.drawBitmap(bitmapscore, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4), GetRealPixelSize(DIP_H, dpHeight, GameSpaceTop), null);
|
|
|
|
if (PayedVersion)
|
|
{
|
|
DrawLines(canvas, lines);
|
|
DrawLevel(canvas, startLevel + level);
|
|
DrawScore(canvas, score);
|
|
|
|
// Next Coming Tetrimino.
|
|
|
|
ShowNextComingTetrimino(canvas);
|
|
}
|
|
|
|
for (int x=0; x<10; x++)
|
|
{
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
switch (drawArray[y][x] + (blockArray[y][x] >= 0 ? blockArray[y][x] : 0))
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
{
|
|
canvas.drawBitmap(bitmapb, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
canvas.drawBitmap(bitmapt, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
canvas.drawBitmap(bitmapz, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
canvas.drawBitmap(bitmaps, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
canvas.drawBitmap(bitmapl2, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
canvas.drawBitmap(bitmapl1, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
canvas.drawBitmap(bitmapi1, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
canvas.drawBitmap(bitmapi2, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
canvas.drawBitmap(bitmapi3, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 11:
|
|
{
|
|
canvas.drawBitmap(bitmapi4, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 12: // Rotated
|
|
{
|
|
canvas.drawBitmap(bitmapi1r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 13:
|
|
{
|
|
canvas.drawBitmap(bitmapi2r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 14:
|
|
{
|
|
canvas.drawBitmap(bitmapi3r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
case 15:
|
|
{
|
|
canvas.drawBitmap(bitmapi4r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 10, GameSpaceLeft, GameSpaceRight)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 18, GameSpaceTop, GameSpaceBottom)), null);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
|
|
Rect(canvas, map(y, 0, 18, GameSpaceTop, GameSpaceBottom), map(y+1, 0, 18, GameSpaceTop, GameSpaceBottom),
|
|
map(x, 0, 10, GameSpaceLeft, GameSpaceRight), map(x+1, 0, 10, GameSpaceLeft, GameSpaceRight),
|
|
Color.RED);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GameState == GS_GAMEOVER)
|
|
{
|
|
canvas.drawBitmap(bitmapgameover, (int)GetRealPixelSize(DIP_W, dpWidth, GameSpaceLeft),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, GameSpaceTop), null);
|
|
}
|
|
}
|
|
|
|
private void ShowNextComingTetrimino(Canvas canvas)
|
|
{
|
|
int top = 32;
|
|
|
|
for (int x=0; x<4; x++)
|
|
{
|
|
for (int y=0; y<4; y++)
|
|
{
|
|
switch(drawBlocks[NewBlock][NewBlockPossition][y][x])
|
|
{
|
|
case 1:
|
|
canvas.drawBitmap(bitmapb, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(bitmapt, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(bitmapz, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(bitmaps, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(bitmapl2, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(bitmapl1, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(bitmapi1, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(bitmapi2, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 10:
|
|
canvas.drawBitmap(bitmapi3, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 11:
|
|
canvas.drawBitmap(bitmapi4, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 12:
|
|
canvas.drawBitmap(bitmapi1r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 13:
|
|
canvas.drawBitmap(bitmapi2r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 14:
|
|
canvas.drawBitmap(bitmapi3r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
case 15:
|
|
canvas.drawBitmap(bitmapi4r, (int)GetRealPixelSize(DIP_W, dpWidth, map(x, 0, 4, GameSpaceRight + 4 + 9, GameSpaceRight + 4 + 9 + (map(1, 0, 10, GameSpaceLeft, GameSpaceRight) - map(0, 0, 10, GameSpaceLeft, GameSpaceRight)) * 4)),
|
|
(int)GetRealPixelSize(DIP_H, dpHeight, map(y, 0, 4, (GameSpaceBottom - top), (GameSpaceBottom - top) + ((map(1, 0, 18, GameSpaceTop, GameSpaceBottom) - map(0, 0, 18, GameSpaceTop, GameSpaceBottom)) * 4))), null);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawScore(Canvas canvas, int Score)
|
|
{
|
|
int height = 104-8;
|
|
switch ((Score / 100000) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6-5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch ((Score / 10000) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch ((Score / 1000) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch ((Score / 100) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch ((Score / 10) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch (Score % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void DrawLines(Canvas canvas, int Lines)
|
|
{
|
|
int height = 55-4;
|
|
switch ((Lines / 1000) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch ((Lines / 100) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch ((Lines / 10) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch (Lines % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void DrawLevel(Canvas canvas, int Level)
|
|
{
|
|
int height = 76-6;
|
|
switch ((Level / 10) % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
switch (Level % 10)
|
|
{
|
|
case 0:
|
|
canvas.drawBitmap(Font0, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 1:
|
|
canvas.drawBitmap(Font1, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 2:
|
|
canvas.drawBitmap(Font2, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 3:
|
|
canvas.drawBitmap(Font3, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 4:
|
|
canvas.drawBitmap(Font4, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 5:
|
|
canvas.drawBitmap(Font5, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 6:
|
|
canvas.drawBitmap(Font6, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 7:
|
|
canvas.drawBitmap(Font7, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 8:
|
|
canvas.drawBitmap(Font8, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
case 9:
|
|
canvas.drawBitmap(Font9, GetRealPixelSize(DIP_W, dpWidth, GameSpaceRight+4+6+5+5+5), GetRealPixelSize(DIP_H, dpHeight, GameSpaceBottom - height), null);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Input
|
|
public void sendMove(float x, float y, boolean Released)
|
|
{
|
|
int moveX = (int)((x / Width) * 90);
|
|
int moveY = (int)((y / Height) * 160);
|
|
|
|
if (!Released)
|
|
{
|
|
if (GameState != GS_GAMEOVER)
|
|
{
|
|
if (moveX >= 28 && moveX <= 55 && moveY >= 143 && moveY <= 155) // Start
|
|
{
|
|
if (GameState == GS_PLAYING)
|
|
onPause();
|
|
else
|
|
{
|
|
SetGameState(GS_RESUME, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GameState == GS_PLAYING)
|
|
{
|
|
InputsGamePlaying(x, y, Released);
|
|
}
|
|
|
|
if (GameState == GS_GAMEOVER)
|
|
{
|
|
StartGame();
|
|
}
|
|
}
|
|
|
|
private void Resume()
|
|
{
|
|
mp.start();
|
|
SetGameState(GS_PLAYING, false);
|
|
canvasView.postInvalidate();
|
|
}
|
|
|
|
private void InputsGamePlaying(float x, float y, boolean Released)
|
|
{
|
|
int moveX = (int)((x / Width) * 90);
|
|
int moveY = (int)((y / Height) * 160);
|
|
|
|
if (!Released)
|
|
{
|
|
if (moveX >= 1 && moveX <= 11 && moveY >= 122 && moveY <= 133) // Left
|
|
{
|
|
if(CanBlockGoLeft())
|
|
{
|
|
MoveBlockLeft();
|
|
canvasView.postInvalidate();
|
|
}
|
|
}
|
|
else if (moveX >= 55 && moveX <= 70 && moveY >= 122 && moveY <= 137) // Rotate Left
|
|
{
|
|
RotateBlockLeft();
|
|
canvasView.postInvalidate();
|
|
}
|
|
else if (moveX >= 74 && moveX <= 88 && moveY >= 115 && moveY <= 137) // Rotate Right
|
|
{
|
|
RotateBlockRight();
|
|
canvasView.postInvalidate();
|
|
}
|
|
else if (moveX >= 21 && moveX <= 33 && moveY >= 122 && moveY <= 133) // Right
|
|
{
|
|
if(CanBlockGoRight())
|
|
{
|
|
MoveBlockRight();
|
|
canvasView.postInvalidate();
|
|
}
|
|
}
|
|
}
|
|
if (moveX >= 11 && moveX <= 21 && moveY >= 133 && moveY <= 144) // Down
|
|
{
|
|
if (!Released)
|
|
{
|
|
// Soft Drop
|
|
if (CanBlockGoDown())
|
|
{
|
|
MoveBlockDown();
|
|
canvasView.postInvalidate();
|
|
}
|
|
OldInputTime = (int)System.currentTimeMillis();
|
|
}
|
|
else
|
|
{
|
|
int CurrentTime = (int)System.currentTimeMillis();
|
|
if ((CurrentTime - OldInputTime) >= 250)
|
|
{
|
|
// Hard Drop
|
|
while (CanBlockGoDown())
|
|
{
|
|
MoveBlockDown();
|
|
}
|
|
canvasView.postInvalidate();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Game Logic
|
|
private void GoDown()
|
|
{
|
|
if (GameState == GS_PLAYING)
|
|
{
|
|
/// Can the Block go down?
|
|
if (CanBlockGoDown())
|
|
{
|
|
MoveBlockDown();
|
|
canvasView.postInvalidate();
|
|
}
|
|
else
|
|
{
|
|
ParseBlockArrayToDrawArray();
|
|
|
|
CheckForCompletedRows();
|
|
|
|
//spawn new block
|
|
if (!SpawnBlock())
|
|
{
|
|
SetGameState(GS_GAMEOVER, false);
|
|
|
|
mp.stop();
|
|
canvasView.postInvalidate();
|
|
}
|
|
else
|
|
{
|
|
canvasView.postInvalidate();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean CanBlockGoDown()
|
|
{
|
|
//blockArray
|
|
for (int x=0; x<10; x++)
|
|
{
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
if (blockArray[y][x] != 0)
|
|
{
|
|
if (y + 1 == 18)
|
|
return false;
|
|
else if (drawArray[y+1][x] != 0)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean CanBlockGoLeft()
|
|
{
|
|
//blockArray
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
for (int x=1; x<10; x++)
|
|
{
|
|
if (blockArray[y][x] >= 1)
|
|
{
|
|
if (drawArray[y][x-1] != 0)
|
|
return false;
|
|
}
|
|
if (blockArray[y][0] >= 1)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean CanBlockGoRight()
|
|
{
|
|
//blockArray
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
for (int x=0; x<9; x++)
|
|
{
|
|
if (blockArray[y][x] >= 1)
|
|
{
|
|
if (drawArray[y][x+1] != 0)
|
|
return false;
|
|
}
|
|
if (blockArray[y][9] >= 1)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void MoveBlockDown()
|
|
{
|
|
for (int x=0; x<10; x++)
|
|
{
|
|
for (int y=17; y>0; y--)
|
|
{
|
|
blockArray[y][x] = blockArray[y-1][x];
|
|
blockArray[y-1][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MoveBlockLeft()
|
|
{
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
for (int x=1; x<10; x++)
|
|
{
|
|
blockArray[y][x-1] = blockArray[y][x];
|
|
blockArray[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MoveBlockRight()
|
|
{
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
for (int x=8; x>=0; x--)
|
|
{
|
|
blockArray[y][x+1] = blockArray[y][x];
|
|
blockArray[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RotateBlockRight()
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][3][3] != -1)
|
|
{
|
|
for (int y=0; y<18-3; y++)
|
|
{
|
|
for (int x=0; x<10-3; x++)
|
|
{
|
|
boolean foundPossition = true;
|
|
|
|
for (int i=0; i<4; i++)
|
|
{
|
|
for (int i2=0; i2<4; i2++)
|
|
{
|
|
if (!(blockArray[y+i][x+i2] == drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2]))
|
|
{
|
|
foundPossition = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (foundPossition)
|
|
{
|
|
if (CurrentBlockPossition < 3)
|
|
CurrentBlockPossition++;
|
|
else
|
|
CurrentBlockPossition = 0;
|
|
}
|
|
|
|
// Test for collision !!!
|
|
boolean Collision = false;
|
|
|
|
for (int i=0; i<4; i++)
|
|
{
|
|
for (int i2=0; i2<4; i2++)
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2] >= 1)
|
|
{
|
|
if (drawArray[y+i][x+i2] != 0)
|
|
{
|
|
Collision = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Collision)
|
|
{
|
|
if (foundPossition)
|
|
{
|
|
for (int i=0; i<4; i++)
|
|
{
|
|
for (int i2=0; i2<4; i2++)
|
|
{
|
|
blockArray[y+i][x+i2] = drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int y=0; y<18-2; y++)
|
|
{
|
|
for (int x=0; x<10-2; x++)
|
|
{
|
|
boolean foundPossition = true;
|
|
|
|
for (int i=0; i<3; i++)
|
|
{
|
|
for (int i2=0; i2<3; i2++)
|
|
{
|
|
if (!(blockArray[y+i][x+i2] == drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2]))
|
|
{
|
|
foundPossition = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (foundPossition)
|
|
{
|
|
if (CurrentBlockPossition < 3)
|
|
CurrentBlockPossition++;
|
|
else
|
|
CurrentBlockPossition = 0;
|
|
}
|
|
|
|
// Test for collision !!!
|
|
boolean Collision = false;
|
|
|
|
for (int i=0; i<3; i++)
|
|
{
|
|
for (int i2=0; i2<3; i2++)
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2] >= 1)
|
|
{
|
|
if (drawArray[y+i][x+i2] != 0)
|
|
{
|
|
Collision = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Collision)
|
|
{
|
|
if (foundPossition)
|
|
{
|
|
for (int i=0; i<3; i++)
|
|
{
|
|
for (int i2=0; i2<3; i2++)
|
|
{
|
|
blockArray[y+i][x+i2] = drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RotateBlockLeft()
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][3][3] != -1)
|
|
{
|
|
for (int y=0; y<18-3; y++)
|
|
{
|
|
for (int x=0; x<10-3; x++)
|
|
{
|
|
boolean foundPossition = true;
|
|
|
|
for (int i=0; i<4; i++)
|
|
{
|
|
for (int i2=0; i2<4; i2++)
|
|
{
|
|
if (!(blockArray[y+i][x+i2] == drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2]))
|
|
{
|
|
foundPossition = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test for collision !!!
|
|
boolean Collision = false;
|
|
|
|
if (foundPossition)
|
|
{
|
|
if (CurrentBlockPossition > 0)
|
|
CurrentBlockPossition--;
|
|
else
|
|
CurrentBlockPossition = 3;
|
|
}
|
|
|
|
for (int i=0; i<4; i++)
|
|
{
|
|
for (int i2=0; i2<4; i2++)
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2] != 0)
|
|
{
|
|
if (drawArray[y+i][x+i2] != 0)
|
|
{
|
|
Collision = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Collision)
|
|
{
|
|
if (foundPossition)
|
|
{
|
|
for (int i=0; i<4; i++)
|
|
{
|
|
for (int i2=0; i2<4; i2++)
|
|
{
|
|
blockArray[y+i][x+i2] = drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int y=0; y<18-2; y++)
|
|
{
|
|
for (int x=0; x<10-2; x++)
|
|
{
|
|
boolean foundPossition = true;
|
|
|
|
for (int i=0; i<3; i++)
|
|
{
|
|
for (int i2=0; i2<3; i2++)
|
|
{
|
|
if (!(blockArray[y+i][x+i2] == drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2]))
|
|
{
|
|
foundPossition = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test for collision !!!
|
|
boolean Collision = false;
|
|
|
|
if (foundPossition)
|
|
{
|
|
if (CurrentBlockPossition > 0)
|
|
CurrentBlockPossition--;
|
|
else
|
|
CurrentBlockPossition = 3;
|
|
}
|
|
|
|
for (int i=0; i<3; i++)
|
|
{
|
|
for (int i2=0; i2<3; i2++)
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2] != 0)
|
|
{
|
|
if (drawArray[y+i][x+i2] != 0)
|
|
{
|
|
Collision = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Collision)
|
|
{
|
|
if (foundPossition)
|
|
{
|
|
for (int i=0; i<3; i++)
|
|
{
|
|
for (int i2=0; i2<3; i2++)
|
|
{
|
|
blockArray[y+i][x+i2] = drawBlocks[CurrentBlock][CurrentBlockPossition][i][i2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ParseBlockArrayToDrawArray()
|
|
{
|
|
for (int x=0; x<10; x++)
|
|
{
|
|
for (int y=0; y<18; y++)
|
|
{
|
|
drawArray[y][x] += blockArray[y][x];
|
|
blockArray[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheckForCompletedRows()
|
|
{
|
|
int LinesCleared = 0;
|
|
//drawArray
|
|
for (int y=17; y>1; y--)
|
|
{
|
|
boolean isComplete = true;
|
|
|
|
for (int x=0; x<10; x++)
|
|
{
|
|
if (drawArray[y][x] == 0)
|
|
isComplete = false;
|
|
}
|
|
|
|
if (isComplete)
|
|
{
|
|
for (int i=y; i>1; i--)
|
|
for (int x=0; x<10; x++)
|
|
{
|
|
drawArray[i][x] = drawArray[i-1][x];
|
|
}
|
|
LinesCleared++;
|
|
lines++;
|
|
level = ( (startLevel + lines)<=200 ? startLevel + (lines / 10) : 20 );
|
|
y++;
|
|
}
|
|
}
|
|
// Do Score here
|
|
switch (LinesCleared)
|
|
{
|
|
case 1:
|
|
score += 40 * ( level + 1 );
|
|
break;
|
|
case 2:
|
|
score += 100 * ( level + 1 );
|
|
break;
|
|
case 3:
|
|
score += 300 * ( level + 1 );
|
|
break;
|
|
case 4:
|
|
score += 1200 * ( level + 1 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
ArrayList<Integer> Tetrimino;
|
|
private void CheckTetriminoSpawnArray()
|
|
{
|
|
// Pseudo random
|
|
if (Tetrimino == null || Tetrimino.size() <= 0)
|
|
{
|
|
Tetrimino = new ArrayList<Integer>();
|
|
do{
|
|
int newTetrimino = (int)(Math.random() * (7));
|
|
if (!Tetrimino.contains(newTetrimino))
|
|
Tetrimino.add(newTetrimino);
|
|
}while (Tetrimino.size() < 7);
|
|
}
|
|
}
|
|
|
|
private boolean SpawnBlock()
|
|
{
|
|
CheckTetriminoSpawnArray();
|
|
|
|
CurrentBlock = NewBlock;
|
|
CurrentBlockPossition = NewBlockPossition;
|
|
|
|
NewBlock = Tetrimino.get(0);
|
|
Tetrimino.remove(0);
|
|
NewBlockPossition = 0;
|
|
|
|
for (int x=0; x<4; x++)
|
|
{
|
|
for (int y=0; y<4; y++)
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][y][x] != 0)
|
|
if (drawArray[y][x+3] != 0)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (int x=0; x<4; x++)
|
|
{
|
|
for (int y=0; y<4; y++)
|
|
{
|
|
if (drawBlocks[CurrentBlock][CurrentBlockPossition][y][x] >= 0)
|
|
blockArray[y][x+3] = drawBlocks[CurrentBlock][CurrentBlockPossition][y][x];
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|