commit a67dccf08719d55513410a26f447532330fb5f18 Author: Leszek Koltunski Date: Sat Jul 16 11:47:50 2022 +0200 Init commit of the new version with refreshed UI diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..5a7c7fc --- /dev/null +++ b/build.gradle @@ -0,0 +1,25 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. +buildscript { + repositories { + google() + mavenCentral() + } + dependencies { + classpath "com.android.tools.build:gradle:4.2.2" + + // NOTE: Do not place your application dependencies here; they belong + // in the individual module build.gradle files + } +} + +allprojects { + repositories { + google() + mavenCentral() + jcenter() // Warning: this repository is going to shut down soon + } +} + +task clean(type: Delete) { + delete rootProject.buildDir +} \ No newline at end of file diff --git a/distorted-sokoban/build.gradle b/distorted-sokoban/build.gradle new file mode 100644 index 0000000..1629bb9 --- /dev/null +++ b/distorted-sokoban/build.gradle @@ -0,0 +1,19 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion 31 + buildToolsVersion "30.0.3" + + defaultConfig { + applicationId "com.threedcell.sokoban" + minSdkVersion 7 + targetSdkVersion 31 + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt' + } + } +} diff --git a/distorted-sokoban/src/main/AndroidManifest.xml b/distorted-sokoban/src/main/AndroidManifest.xml new file mode 100644 index 0000000..cbe87e6 --- /dev/null +++ b/distorted-sokoban/src/main/AndroidManifest.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/Sokoban.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/Sokoban.java new file mode 100644 index 0000000..2dc5dfe --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/Sokoban.java @@ -0,0 +1,99 @@ +package com.threedcell.sokoban; + +import android.app.Activity; +import android.content.Intent; +import android.os.Bundle; +import android.util.Log; + +/////////////////////////////////////////////////////////////////// + +public class Sokoban extends Activity +{ + private static final String TAG_SPLASH = "SokobanSplash"; + public static final boolean DEBUG = false; + private int sleepTime=2000; + + private class SplashThread extends Thread + { + private boolean bootup=true; + + public void run() + { + int milis=0; + + while(bootup) + { + try + { + milis+=100; + Thread.sleep(100); + } + catch( InterruptedException ex) {} + } + + if( milis entry : settings.getAll().entrySet()) + { + Object val = entry.getValue(); + + if( val!=null ) + { + key = entry.getKey(); + + try + { + num = Integer.valueOf(key).intValue(); + sett= String.valueOf(val); + + switch(num) + { + case 1 : username = sett; break; + case 2 : veriname = sett; break; + case 3 : hash = Integer.valueOf(sett).intValue(); break; + case 4 : numrunnings = Integer.valueOf(sett).intValue(); break; + case 5 : numplayings = Integer.valueOf(sett).intValue(); break; + case 6 : uniqueid = Integer.valueOf(sett).intValue(); break; + case 7 : scrollpos = Integer.valueOf(sett).intValue(); break; + default: recoverLevel(num,sett); break; + } + } + catch( Exception ex ) + { + Log.e(TAG_DB, "error retrieving preference "+String.valueOf(val)+" :"+ex.toString()); + } + } + } + } + +/////////////////////////////////////////////////////////////////// + + private void recoverLevel(int id, String value) + { + int begin=0,end=0,lvlNum; + String tmp; + + //Log.d(TAG_DB, "recovering level "+id+" :"+value); + + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "error recovering level! value: "+value); + return; + } + + tmp = value.substring(begin,end); + lvlNum = Integer.valueOf(tmp).intValue(); + + recoverLevelData(id,lvlNum,end,value); + } + +/////////////////////////////////////////////////////////////////// + + private void recoverLevelData(int id, int num, int begin, String value) + { + int end; + String tmp; + SokobanLevel sl; + int intrinsic = INVALID; + int mytime = INVALID; + int mymoves = INVALID; + int worldtime = INVALID; + int worldmoves = INVALID; + String worldname = ""; + String worldcountry= ""; + boolean submitted = false; + + // recover intrinsic num + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "1 error recovering builtin level, value: "+value); + return; + } + + try + { + tmp = value.substring( begin+1,end); + intrinsic = Integer.valueOf(tmp).intValue(); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "1: "+ex1.toString()); } + + begin = end; + + // recover mytime + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "1 error recovering builtin level, value: "+value); + return; + } + + try + { + tmp = value.substring( begin+1,end); + mytime = Integer.valueOf(tmp).intValue(); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "1: "+ex1.toString()); } + + begin = end; + + // recover mymoves + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "2 error recovering builtin level, value: "+value); + return; + } + + try + { + tmp = value.substring( begin+1,end); + mymoves = Integer.valueOf(tmp).intValue(); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "2: "+ex1.toString()); } + + begin = end; + + // recover worldtime + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "3 error recovering builtin level, value: "+value); + return; + } + + try + { + tmp = value.substring( begin+1,end); + worldtime = Integer.valueOf(tmp).intValue(); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "3: "+ex1.toString()); } + + begin = end; + + // recover worldmoves + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "4 error recovering builtin level, value: "+value); + return; + } + + try + { + tmp = value.substring( begin+1,end); + worldmoves = Integer.valueOf(tmp).intValue(); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "4: "+ex1.toString()); } + + begin = end; + + // recover worldname + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "5 error recovering builtin level, value: "+value); + return; + } + + try + { + worldname = value.substring( begin+1,end); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "5: "+ex1.toString()); } + + begin = end; + + // recover worldcountry + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "6 error recovering builtin level, value: "+value); + return; + } + + try + { + worldcountry = value.substring( begin+1,end); + } + catch(Exception ex1 ) {Log.e(TAG_DB,"6: "+ex1.toString()); } + + begin = end; + + // recover submitted + end = value.indexOf(" ", begin+1); + + if( end<0 ) + { + Log.e(TAG_DB, "7 error recovering builtin level, value: "+value); + return; + } + + try + { + tmp = value.substring( begin+1,end); + submitted = (Integer.valueOf(tmp).intValue()==1 ? true:false); + } + catch(Exception ex1 ) {Log.e(TAG_DB, "7: "+ex1.toString()); } + + begin = end; + + if( num=BUILTIN_LEVELS ) + { + tmp+=level.getAuthor()+" "+level.getCountry()+" "+level.getCols()+" "+level.encodeLevel()+" "; + } + + editor.putString(String.valueOf(level.getRecordId()), tmp); + + //Log.d(TAG_DB, "saving level "+i+" record id:"+level.getRecordId()+": "+tmp); + + } + } + + return true; + } + +/////////////////////////////////////////////////////////////////// + + public static void init(Activity act) + { + rms = new SokobanDatabase((Context)act); + } + +/////////////////////////////////////////////////////////////////// + + private static int computeHash() + { + + final int MODULO = 227; + int ret = 0; + SokobanLevel sl; + + for(int i=0; ; i++) + { + sl = SokobanLevels.getLevel(i); + if( sl==null ) break; + + ret += sl.getMyMoves(); + ret += 2*sl.getMyTime(); + } + + int length = veriname==null ? 0 : veriname.length(); + + for(int i=0;i moves = new Vector(); + + private SokobanRecordInfo[] recordList; + private SokobanRecordInfo recordMine; + + private static byte[][] validateScratch; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public SokobanLevel(Context context, int width,int height, int gap) + { + submitted = false; + author = null; + country = null; + cImg = null; + recordMine= new SokobanRecordInfo(); + + movableC = new byte[MAX_PACKS+1][2]; + movableS = new byte[MAX_PACKS+1][2]; + + strAuthor = context.getString(R.string.author); + strLevel = context.getString(R.string.level); + strYourBest = context.getString(R.string.yourbest); + strWorldsBest = context.getString(R.string.worldsbest); + + mPaint.setAntiAlias(true); + mPaint.setStyle(Style.FILL); + + allocate(width,height,gap); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public SokobanLevel(String a, String c, int mm, int mt, SokobanRecordInfo w, boolean sb, int cols, String position ) + { + submitted= sb; + + author = a; + country= c; + + recordMine = new SokobanRecordInfo(mm,mt,SokobanDatabase.getName(),SokobanDatabase.getCountry()); + + cutAuthor(); + + cImg = (author==null ? null:SokobanLevels.getInstance().getFlag(c)); + + recordList = new SokobanRecordInfo[mMaxRecords]; + for(int i=0; ilen0 ) + { + int l = author.length(); + + while( l>=2 && len1+len2>len0 ) + { + l--; + author = author.substring(0,l); + len1 = mPaint.measureText(author); + } + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void drop(int stuff) + { + int row = movableC[0][1]; + int col = movableC[0][0]; + + switch(stuff) + { + case WALL: cells[row][col] = WALL; + removePacksFrom(row,col); + break; + case EMPT: cells[row][col] = EMPT; + removePacksFrom(row,col); + break; + case DEST: cells[row][col] = DEST; + break; + case PACK: if( mPacks0 ) + { + marked=0; + + for(int row=0; row0 && validateScratch[row-1][col]==2 ) || + ( row+10 && validateScratch[row][col-1]==2 ) || + ( col+10); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void decodeLevel(int cols, String position) + { + int tmp; + mPacks=0; + + try + { + mCols = cols; + mRows = position.length()/cols; + + cells = new byte[mRows][mCols]; + + for(int row=0; row=0 && allWalls; col--) + { + for(int row=0; row=0 && allWalls; row--) + { + for(int col=0; col=0 && num=0 && allWalls; col--) + { + for(int row=0; row=0 && p0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean withdraw() + { + int size = moves.size(); + + if( size>0 ) + { + Move m = (Move)moves.lastElement(); + int index = (int)m.index; + moves.removeElementAt(size-1); + + switch(m.move) + { + case DIR_W: movableC[0][0]++; if( index>0 ) movableC[index][0]++; break; + case DIR_E: movableC[0][0]--; if( index>0 ) movableC[index][0]--; break; + case DIR_N: movableC[0][1]++; if( index>0 ) movableC[index][1]++; break; + case DIR_S: movableC[0][1]--; if( index>0 ) movableC[index][1]--; break; + } + return true; + } + + return false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean isSolved() + { + for(int i=1; i<=mPacks; i++) + { + if( cells[movableC[i][1]][movableC[i][0]]!=DEST ) return false; + } + + return true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int hasPack(int row, int col) + { + for(int i=1; i<=mPacks; i++) + { + if( movableC[i][0]==col && movableC[i][1]==row ) return i; + } + + return 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int retDir(int dx, int dy) + { + if( dx>=dy ) return (dx>=-dy ? DIR_W:DIR_S); + else return (dx>=-dy ? DIR_N:DIR_E); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean movePlayerFreely(int dx, int dy) + { + switch( retDir(dx,dy) ) + { + case DIR_W: if( movableC[0][0]>0 ) { movableC[0][0]--; movableS[0][0]--; return true; } + return false; + case DIR_E: if( movableC[0][0]+10 ) { movableC[0][1]--; movableS[0][1]--; return true; } + return false; + case DIR_S: if( movableC[0][1]+10 && cells[row-1][col]!=WALL ) + { + pack = hasPack(row-1,col); + + if( pack==0 ) + { + movableC[0][1]--; + moves.addElement( new Move(pack, DIR_N) ); + return true; + } + else if( row>1 && cells[row-2][col]!=WALL && hasPack(row-2,col)==0 ) + { + movableC[pack][1]--; + movableC[0][1]--; + moves.addElement( new Move(pack, DIR_N) ); + return true; + } + } + break; + case DIR_S: if( row+10 && cells[row][col-1]!=WALL ) + { + pack = hasPack(row,col-1); + + if( pack==0 ) + { + movableC[0][0]--; + moves.addElement( new Move(pack, DIR_W) ); + return true; + } + else if( col>1 && cells[row][col-2]!=WALL && hasPack(row,col-2)==0 ) + { + movableC[pack][0]--; + movableC[0][0]--; + moves.addElement( new Move(pack, DIR_W) ); + return true; + } + } + break; + case DIR_E: if( col+1=0 ) + { + drawSmall(SokobanLevelBuffer.lC[buff]); + SokobanLevelBuffer.setLBuffered(buff, numLevel); + } + // Log.e("Level", "renderRecords: drawSmall: level "+numLevel+" to bank "+buff); + } + if( buff>=0 ) c.drawBitmap( SokobanLevelBuffer.lB[buff], mGapO+mGapI, y, null); + + buff= SokobanLevelBuffer.isRBuffered(numLevel); + + if( buff<0 ) + { + buff = SokobanLevelBuffer.whereR(numLevel); + + if( buff>=0 ) + { + drawRecords(SokobanLevelBuffer.rC[buff]); + SokobanLevelBuffer.setRBuffered(buff, numLevel); + } + // Log.e("Level", "renderRecords: drawRecords: level "+numLevel+" to bank "+buff); + } + if( buff>=0 ) c.drawBitmap( SokobanLevelBuffer.rB[buff], mGapO+2*mGapI+smallSize-2, y, null); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void renderSmall(Canvas c, int y1, boolean clicked) + { + if( mShowing==SHOWING_RECO ) + { + mShowing = SHOWING_MINE; + SokobanLevelBuffer.invalidateAllR(); + } + c.drawBitmap( clicked ? SokobanLevels.bkgClicked:SokobanLevels.bkgUnClick, 0, y1, null); + + int buff, y = y1+mGapO/2+mGapI; + + buff= SokobanLevelBuffer.isLBuffered(numLevel); + + if( buff<0 ) + { + buff = SokobanLevelBuffer.whereL(numLevel); + + if( buff>=0 ) + { + drawSmall(SokobanLevelBuffer.lC[buff]); + SokobanLevelBuffer.setLBuffered(buff, numLevel); + } + // Log.e("Level", "renderSmall: drawSmall: level "+numLevel+" to bank "+buff); + } + if( buff>=0 ) c.drawBitmap( SokobanLevelBuffer.lB[buff], mGapO+mGapI, y, null); + + buff= SokobanLevelBuffer.isRBuffered(numLevel); + + if( buff<0 ) + { + buff = SokobanLevelBuffer.whereR(numLevel); + + if( buff>=0 ) + { + drawMine(SokobanLevelBuffer.rC[buff]); + SokobanLevelBuffer.setRBuffered(buff, numLevel); + } + // Log.e("Level", "renderSmall: drawMine: level "+numLevel+" to bank "+buff); + } + if( buff>=0 ) c.drawBitmap( SokobanLevelBuffer.rB[buff], mGapO+2*mGapI+smallSize-2, y, null); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void drawMine(Canvas c) + { + int m = SokobanLevels.levelInfoW/2; + int h = (int)(SokobanLevels.levelInfoH*0.4); + + mPaint.setColor(SokobanLevels.COLOR_BLACK); + mPaint.setTextSize(h); + mPaint.setTextAlign(Align.CENTER); + + c.drawBitmap( SokobanLevels.levelInfo, 0, 0 , null); + c.drawBitmap( SokobanLevels.levelInfo, 0, (SokobanLevels.levelInfoH+mGapI), null); + c.drawBitmap( SokobanLevels.levelInfo, 0, 2*(SokobanLevels.levelInfoH+mGapI), null); + + if( author==null ) + { + c.drawText(strLevel+" "+numLevel, m, SokobanLevels.levelInfoH/2+h/3, mPaint); + } + else + { + int h1 = 2+ SokobanLevels.levelInfoH/4+h/3; + int h2 =-2+3*SokobanLevels.levelInfoH/4+h/3; + int x1 = SokobanLevels.levelInfoW-3*mGapI/2-SokobanLevels.FLAG_W; + + c.drawText(strLevel+" "+numLevel, m, h1, mPaint); + mPaint.setTextAlign(Align.LEFT); + c.drawText(strAuthor, mGapI-2, h2+1, mPaint); + mPaint.setTextAlign(Align.RIGHT); + c.drawText(author , x1 , h2+1 , mPaint); + c.drawBitmap(cImg , x1+mGapI/2+2, h2-SokobanRecordInfo.mCorr , null); + mPaint.setTextSize(h); + } + + mPaint.setTextAlign(Align.CENTER); + c.drawText(strYourBest , m, 2+ (SokobanLevels.levelInfoH+mGapI)+ SokobanLevels.levelInfoH/4+h/3 ,mPaint ); + recordMine.draw( 0, -2+(SokobanLevels.levelInfoH+mGapI)+ 3*SokobanLevels.levelInfoH/4+h/3, c); + c.drawText(strWorldsBest, m, 2+2*(SokobanLevels.levelInfoH+mGapI)+ SokobanLevels.levelInfoH/4+h/3 ,mPaint ); + + if( recordList[0]!=null ) + recordList[0].draw( 0, -2+2*(SokobanLevels.levelInfoH+mGapI)+ 3*SokobanLevels.levelInfoH/4+h/3, c); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void drawRecords(Canvas c) + { + int h = (int)(SokobanLevels.levelInfoH*0.4); + int y=(h+mGapI/2); + + mPaint.setColor(SokobanLevels.COLOR_BLACK); + mPaint.setTextSize(h); + mPaint.setTextAlign(Align.CENTER); + + c.drawBitmap( SokobanLevels.levelBig, 0, 0, null); + c.drawText(strLevel+" "+numLevel, SokobanLevels.levelBigW/2, y, mPaint); + + for(int i=0; i=0 && dRow< +SokobanLevels.sDrawnY && dCol>=0 && dCol< +SokobanLevels.sDrawnX ) + { + cellx = SokobanLevels.sMargin+dCol*SokobanLevels.sCell; + celly = SokobanLevels.sMargin+dRow*SokobanLevels.sCell; + + if( i==0 ) + c.drawBitmap( SokobanLevels.playSmall , cellx,celly, null); + else if( cells[tmpRow][tmpCol]==DEST ) + c.drawBitmap( SokobanLevels.dpckSmall , cellx,celly, null); + else + c.drawBitmap( SokobanLevels.packSmall , cellx,celly, null); + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void renderBig(Canvas c, int x, int y) + { + boolean isBig = (mRows>SokobanLevels.bDrawnY1); + + int drawnX, drawnY, gapX, gapY, bCell; + + if( isBig ) + { + drawnX = SokobanLevels.bDrawnX2; + drawnY = SokobanLevels.bDrawnY2; + gapX = SokobanLevels.gapX2; + gapY = SokobanLevels.gapY2; + bCell = SokobanLevels.bCell2; + } + else + { + drawnX = SokobanLevels.bDrawnX1; + drawnY = SokobanLevels.bDrawnY1; + gapX = SokobanLevels.gapX1; + gapY = SokobanLevels.gapY1; + bCell = SokobanLevels.bCell1; + } + + int i,tmpCol, tmpRow, dCol, dRow; + int v = drawnY-mRows; + int h = drawnX-mCols; + int cellx, celly; + + int vgap = v<0 ? 0 :v/2; + int hgap = h<0 ? 0 :h/2; + int varr = v<0 ?-(v/2): 0; + int harr = h<0 ?-(h/2): 0; + int vlen = v<0 ? drawnY:mRows; + int hlen = h<0 ? drawnX:mCols; + + mPaint.setColor(COLOR_BACK); + c.drawRect(x,y-5, x+sWidth, y+sHeight+5, mPaint); + mPaint.setColor(COLOR_GRID); + + celly = y+gapY; + + for( i=0; i<=drawnY; i++ ) + { + c.drawRect(0, celly, sWidth, celly+SokobanLevels.bMargin , mPaint); + celly+=bCell; + } + + cellx = x+gapX; + + for( i=0; i<=drawnX; i++ ) + { + c.drawRect(cellx, y-5, cellx+SokobanLevels.bMargin,y+sHeight+5, mPaint); + cellx+=bCell; + } + + for(int row=varr; row=0 && dRow< drawnY && dCol>=0 && dCol< drawnX ) + { + cellx = SokobanLevels.bMargin+x+gapX+dCol*bCell; + celly = SokobanLevels.bMargin+y+gapY+dRow*bCell; + + if( i==0 ) + c.drawBitmap( isBig ? SokobanLevels.playBig2 : SokobanLevels.playBig1 ,cellx,celly, null); + else if( cells[tmpRow][tmpCol]==DEST ) + c.drawBitmap( isBig ? SokobanLevels.dpckBig2 : SokobanLevels.dpckBig1 ,cellx,celly, null); + else + c.drawBitmap( isBig ? SokobanLevels.packBig2 : SokobanLevels.packBig1 ,cellx,celly, null); + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// end of SokobanLevel class + } \ No newline at end of file diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanLevelBuffer.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanLevelBuffer.java new file mode 100644 index 0000000..84084c5 --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanLevelBuffer.java @@ -0,0 +1,157 @@ +package com.threedcell.sokoban; + +import android.graphics.Bitmap; +import android.graphics.Canvas; + +import android.util.Log; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class SokobanLevelBuffer + { + public static int INVALID = -1; + + private static int numBuffers; + private static int levelHeight; + private static int scrHeight; + + private static int[] lD; + private static int[] rD; + + public static Canvas[] lC; + public static Canvas[] rC; + public static Bitmap[] lB; + public static Bitmap[] rB; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public SokobanLevelBuffer(int lh, int sh) + { + int tmp1 = (sh-SokobanLevels.mGap); + int tmp2 = tmp1/lh; + + numBuffers = (tmp2*lh == tmp1 ? tmp2+1:tmp2+2); + + lB = new Bitmap[numBuffers]; + rB = new Bitmap[numBuffers]; + lD = new int[numBuffers]; + rD = new int[numBuffers]; + lC = new Canvas[numBuffers]; + rC = new Canvas[numBuffers]; + + allocate(lh,sh); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + + public static void allocate(int lh,int sh) + { + levelHeight= lh; + scrHeight = sh; + + for(int i=0; iend ) return i; + + Log.e("Buffer", "whereL lvl="+lvl+" beg="+beg+" end="+end+" returning -1"); + + return INVALID; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int whereR(int lvl) + { + int scrollPos = SokobanLevels.getScroll(); + + int beg = 1+Math.max( scrollPos/levelHeight, 0); + int end = 1+(scrollPos+scrHeight-SokobanLevels.mGap)/levelHeight; + + for(int i=0; iend ) return i; + + Log.e("Buffer", "whereR lvl="+lvl+" beg="+beg+" end="+end+" returning -1"); + + return INVALID; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// end of SokobanLevelBuffer class + } \ No newline at end of file diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanLevels.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanLevels.java new file mode 100644 index 0000000..3340612 --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanLevels.java @@ -0,0 +1,1152 @@ +package com.threedcell.sokoban; + +import android.graphics.Canvas; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Paint; +import android.graphics.Region; +import android.graphics.Paint.Style; +import android.graphics.drawable.NinePatchDrawable; + +import android.app.Activity; +import android.content.Context; +import android.content.res.Resources; + +import android.util.Log; +import android.util.DisplayMetrics; + +import java.util.Vector; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class SokobanLevels + { + private static final String TAG_LEVELS = "SokobanLevels"; + + public static final int COLOR_GREEN = 0xff6a7900; + public static final int COLOR_BLACK = 0xff000000; + public static final int COLOR_WHITE = 0xffffffff; + public static final int COLOR_GRAY = 0xff999999; + private static final int COLOR_EMPT = 0xaaffffff; + + private static final int SAMPLE_SIZE = 5; + private static final double SPRING_CONST = 1.8; + private static final int MAX_SPRING_SPEED= 8; + private static final int MIN_CLICK_DIST = 8; + private static final int PLAY_MIN_DIST = 20; + + public static final int FLAG_H = 15; + public static final int FLAG_W = 22; + + public static Bitmap emptyBig1 , packBig1, destBig1, dpckBig1, playBig1; + public static Bitmap emptyBig2 , packBig2, destBig2, dpckBig2, playBig2; + public static Bitmap backgroundSmall, destSmall, emptySmall, packSmall, playSmall, dpckSmall; + public static Bitmap bkgClicked, bkgUnClick; + public static Bitmap levelBig, levelInfo; + + private int levelHeight; + + public static int mGap; + private int amountDrag = -1; + + private static boolean mVertical; + private static SokobanTimer timer =null; + private static SokobanLevels levels; + private boolean mSpringing = false; + private boolean canMove = false; + private int cX, cY; + private static int mNumLevels, clickedLevel=-1; + private static int currLevel; + private static int mScrollPos; + private double mScrollSpeed; + private static Vector mLevels; + private Paint mPaint; + private double sample[]; + private int samplePtr; + private boolean mDragging = false; + private static int currTime; + private static int currMoves; + private static boolean timerRunning=false; + + public static int levelInfoH, levelInfoW, sCell ,levelBigH ,levelBigW ,bCell1 ,bCell2, backSmallH, backSmallW; + public static int sMargin, bMargin; + public static int bDrawnX1, bDrawnY1, bDrawnX2, bDrawnY2, sDrawnX, sDrawnY; + public static int mGapO, mGapI; + public static int gapX1, gapY1, gapX2, gapY2; + + private static Resources res; + private static SokobanLevel created; + private static int scrWidth, scrHeight; + public static SokobanLevelBuffer slBuffer; + + static class Flag + { + public Bitmap flag; + public String name; + + Flag() + { + flag = null; + name = null; + } + Flag(String n) + { + name = n; + + try + { + int resID = res.getIdentifier(name, "drawable", "com.threedcell.sokoban"); + flag = BitmapFactory.decodeResource(res, resID!=0 ? resID:R.drawable.unk); + } + catch( Exception ex ) + { + flag=null; + } + } + } + + private static Vector mFlags; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private SokobanLevels(Context context) + { + mNumLevels = 0; + mScrollPos = 0; + mScrollSpeed=0; + + res = context.getResources(); + + mVertical = (scrWidth<=scrHeight); + mGap = scrHeight/6; + levelHeight = (scrHeight-mGap)/3; + + if( levelHeight<120 ) levelHeight = 120; + if( levelHeight>260 ) levelHeight = 260; + + sample = new double[SAMPLE_SIZE]; + samplePtr = -1; + + cX = -(MIN_CLICK_DIST+1); + cY = -(MIN_CLICK_DIST+1); + + mPaint = new Paint(); + mPaint.setStyle(Style.FILL); + + mLevels = new Vector(); + mFlags = new Vector(); + + createImages(); + + created = new SokobanLevel(context,scrWidth,scrHeight,mGap); + slBuffer= new SokobanLevelBuffer(levelHeight,scrHeight); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void init(Activity act) + { + if( scrWidth<=0 || scrHeight<=0 ) + { + DisplayMetrics dm = new DisplayMetrics(); + act.getWindowManager().getDefaultDisplay().getMetrics(dm); + + scrWidth = Math.min(dm.widthPixels,dm.heightPixels); + scrHeight= Math.max(dm.widthPixels,dm.heightPixels); + } + + levels = new SokobanLevels((Context)act); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void createImages() + { + NinePatchDrawable play,pack,dpck,levl, dpck_small, pack_small, dialog, dlgred; + Canvas c; + + try + { + play = (NinePatchDrawable)res.getDrawable(R.drawable.play); + pack = (NinePatchDrawable)res.getDrawable(R.drawable.pack); + dpck = (NinePatchDrawable)res.getDrawable(R.drawable.dpck); + levl = (NinePatchDrawable)res.getDrawable(R.drawable.level_info); + + pack_small = (NinePatchDrawable)res.getDrawable(R.drawable.pack_small); + dpck_small = (NinePatchDrawable)res.getDrawable(R.drawable.dpck_small); + + dialog = (NinePatchDrawable)res.getDrawable(R.drawable.dialog); + dlgred = (NinePatchDrawable)res.getDrawable(R.drawable.dialog_clicked); + + } + catch( Exception ex ) { Log.e(TAG_LEVELS, "Failed to create 9Patches!"); return; } + + mGapO = scrHeight/80; + mGapI = scrHeight/80; + sDrawnX = 10; + sDrawnY = 10; + + bDrawnX1= 12; + bDrawnY1= (scrHeight-mGap)/(scrWidth/bDrawnX1); + bDrawnY2= 18; + bDrawnX2= scrWidth/((scrHeight-mGap)/bDrawnY2); + + sCell = (levelHeight-mGapO-2*mGapI)/sDrawnX; + bCell1 = scrWidth/bDrawnX1; + bCell2 = (scrHeight-mGap)/bDrawnY2; + + sMargin = sCell /10; + bMargin = bCell1/12; + + if( sMargin<=0 ) sMargin=1; + if( bMargin<=0 ) bMargin=1; + + int sCross1 = (int)(sCell *0.42); + int sCross2 = (int)(sCell *0.38); + int bCross11 = (int)(bCell1*0.42); + int bCross21 = (int)(bCell1*0.38); + int bCross12 = (int)(bCell2*0.42); + int bCross22 = (int)(bCell2*0.38); + + int sS = sCell - sMargin; + int bS1 = bCell1 - bMargin; + int bS2 = bCell2 - bMargin; + + int fB1 = bCell1/8; + int fB2 = bCell2/8; + int fS = sCell /8; + + if( fB1<=0 ) fB1=1; + if( fB2<=0 ) fB2=1; + if( fS <=0 ) fS =1; + + backSmallW = sDrawnX*sCell + sMargin; + backSmallH = sDrawnY*sCell + sMargin; + + mGapI = (levelHeight-mGapO-backSmallH)/2; + + levelInfoH = (backSmallH-2*mGapI)/3; + levelInfoW = scrWidth-2*mGapO-3*mGapI-backSmallW+2; + levelBigH = backSmallH; + levelBigW = scrWidth-2*mGapO-3*mGapI-backSmallW+2; + + gapX1= (scrWidth -bDrawnX1*bCell1-bMargin)/2; + gapY1= (scrHeight-mGap-bDrawnY1*bCell1-bMargin)/2; + + gapX2= (scrWidth -bDrawnX2*bCell2-bMargin)/2; + gapY2= (scrHeight-mGap-bDrawnY2*bCell2-bMargin)/2; + + bkgClicked = Bitmap.createBitmap(scrWidth,levelHeight, Bitmap.Config.ARGB_8888 ); + bkgUnClick = Bitmap.createBitmap(scrWidth,levelHeight, Bitmap.Config.ARGB_8888 ); + + backgroundSmall = Bitmap.createBitmap(backSmallW,backSmallH, Bitmap.Config.ARGB_8888); + + levelInfo = Bitmap.createBitmap(levelInfoW,levelInfoH, Bitmap.Config.ARGB_8888); + levelBig = Bitmap.createBitmap(levelBigW ,levelBigH , Bitmap.Config.ARGB_8888); + + emptySmall= Bitmap.createBitmap(sS ,sS , Bitmap.Config.ARGB_8888); + packSmall = Bitmap.createBitmap(sS ,sS , Bitmap.Config.ARGB_8888); + destSmall = Bitmap.createBitmap(sS ,sS , Bitmap.Config.ARGB_8888); + dpckSmall = Bitmap.createBitmap(sS ,sS , Bitmap.Config.ARGB_8888); + playSmall = Bitmap.createBitmap(sS ,sS , Bitmap.Config.ARGB_8888); + + emptyBig1 = Bitmap.createBitmap(bS1,bS1, Bitmap.Config.ARGB_8888); + packBig1 = Bitmap.createBitmap(bS1,bS1, Bitmap.Config.ARGB_8888); + destBig1 = Bitmap.createBitmap(bS1,bS1, Bitmap.Config.ARGB_8888); + dpckBig1 = Bitmap.createBitmap(bS1,bS1, Bitmap.Config.ARGB_8888); + playBig1 = Bitmap.createBitmap(bS1,bS1, Bitmap.Config.ARGB_8888); + + emptyBig2 = Bitmap.createBitmap(bS2,bS2, Bitmap.Config.ARGB_8888); + packBig2 = Bitmap.createBitmap(bS2,bS2, Bitmap.Config.ARGB_8888); + destBig2 = Bitmap.createBitmap(bS2,bS2, Bitmap.Config.ARGB_8888); + dpckBig2 = Bitmap.createBitmap(bS2,bS2, Bitmap.Config.ARGB_8888); + playBig2 = Bitmap.createBitmap(bS2,bS2, Bitmap.Config.ARGB_8888); + + // bkgClicked + c = new Canvas(bkgClicked); + mPaint.setColor(COLOR_BLACK); + c.drawRect(0,0, scrWidth, levelHeight, mPaint); + dlgred.setBounds(mGapO, mGapO/2, scrWidth-mGapO, levelHeight-mGapO/2); + dlgred.draw(c); + + // bkgUnClick + c = new Canvas(bkgUnClick); + mPaint.setColor(COLOR_BLACK); + c.drawRect(0,0, scrWidth, levelHeight, mPaint); + dialog.setBounds(mGapO, mGapO/2, scrWidth-mGapO, levelHeight-mGapO/2); + dialog.draw(c); + + // backgroundSmall + c = new Canvas(backgroundSmall); + mPaint.setColor(SokobanLevel.COLOR_BACK); + c.drawRect(0,0, backSmallW, backSmallH, mPaint); + mPaint.setColor(SokobanLevel.COLOR_GRID); + + for( int i=0; i<=sDrawnY; i++ ) c.drawRect(0, i*sCell, backSmallW, i*sCell+sMargin , mPaint); + for( int i=0; i<=sDrawnX; i++ ) c.drawRect(i*sCell, 0, i*sCell+sMargin, backSmallH , mPaint); + + // levelInfo + c = new Canvas(levelInfo); + levelInfo.eraseColor(0); + levl.setBounds(0,0,levelInfoW,levelInfoH); + levl.draw(c); + + // levelBig + c = new Canvas(levelBig); + levelBig.eraseColor(0); + levl.setBounds(0,0,levelBigW,levelBigH); + levl.draw(c); + + //emptySmall + emptySmall.eraseColor(COLOR_EMPT); + + //packSmall + c = new Canvas(packSmall); + packSmall.eraseColor(0); + + pack_small.setBounds( fS, fS, sS-fS, sS-fS ); + pack_small.draw(c); + + //destSmall + c = new Canvas(destSmall); + destSmall.eraseColor(COLOR_EMPT); + + mPaint.setColor(SokobanLevel.COLOR_CRES); + c.drawRect( sCross2, sCross2, sS-sCross2, sS-sCross2 ,mPaint); + c.drawRect( fS, sCross1, sS-fS, sS-sCross1 ,mPaint); + c.drawRect( sCross1, fS, sS-sCross1, sS-fS ,mPaint); + + //dpckSmall + c = new Canvas(dpckSmall); + dpckSmall.eraseColor(0); + + dpck_small.setBounds( fS, fS, sS-fS, sS-fS ); + dpck_small.draw(c); + + //playSmall + c = new Canvas(playSmall); + playSmall.eraseColor(0); + + play.setBounds( fS, fS, sS-fS, sS-fS ); + play.draw(c); + + //emptyBig1 + emptyBig1.eraseColor(COLOR_EMPT); + + //emptyBig2 + emptyBig2.eraseColor(COLOR_EMPT); + + //packBig1 + c = new Canvas(packBig1); + packBig1.eraseColor(0); + + pack.setBounds( fB1, fB1, bS1-fB1, bS1-fB1 ); + pack.draw(c); + + //packBig2 + c = new Canvas(packBig2); + packBig2.eraseColor(0); + + pack.setBounds( fB2, fB2, bS2-fB2, bS2-fB2 ); + pack.draw(c); + + //destBig1 + c = new Canvas(destBig1); + destBig1.eraseColor(COLOR_EMPT); + + mPaint.setColor(SokobanLevel.COLOR_CRES); + c.drawRect( bCross21, bCross21, bS1-bCross21, bS1-bCross21 ,mPaint); + c.drawRect( fB1, bCross11, bS1-fB1, bS1-bCross11 ,mPaint); + c.drawRect( bCross11, fB1, bS1-bCross11, bS1-fB1 ,mPaint); + + //destBig2 + c = new Canvas(destBig2); + destBig2.eraseColor(COLOR_EMPT); + + mPaint.setColor(SokobanLevel.COLOR_CRES); + c.drawRect( bCross22, bCross22, bS2-bCross22, bS2-bCross22 ,mPaint); + c.drawRect( fB2, bCross12, bS2-fB2, bS2-bCross12 ,mPaint); + c.drawRect( bCross12, fB2, bS2-bCross12, bS2-fB2 ,mPaint); + + //dpckBig1 + c = new Canvas(dpckBig1); + dpckBig1.eraseColor(0); + + dpck.setBounds( fB1, fB1, bS1-fB1, bS1-fB1 ); + dpck.draw(c); + + //dpckBig2 + c = new Canvas(dpckBig2); + dpckBig2.eraseColor(0); + + dpck.setBounds( fB2, fB2, bS2-fB2, bS2-fB2 ); + dpck.draw(c); + + //playBig1 + c = new Canvas(playBig1); + playBig1.eraseColor(0); + + play.setBounds( fB1, fB1, bS1-fB1, bS1-fB1 ); + play.draw(c); + + //playBig2 + c = new Canvas(playBig2); + playBig2.eraseColor(0); + + play.setBounds( fB2, fB2, bS2-fB2, bS2-fB2 ); + play.draw(c); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static SokobanLevels getInstance() + { + return levels; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static SokobanLevel getLevel(int i) + { + if( i>=0 && i200 ) levelHeight = 200; + + createImages(); + SokobanLevelBuffer.allocate(levelHeight,scrHeight); + created.allocate(scrWidth,scrHeight,mGap); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void scrollToEnd() + { + if( mVertical ) mScrollPos=mNumLevels*levelHeight-(scrHeight-mGap); + else mScrollPos=mNumLevels*levelHeight-scrWidth; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void setScroll(int s) + { + mScrollPos = s; + + if( mScrollPos<0 ) mScrollPos = 0; + + if( mVertical ) + { + if( mScrollPos> mNumLevels*levelHeight-(scrHeight-mGap) ) + mScrollPos=mNumLevels*levelHeight-(scrHeight-mGap); + } + else + { + if( mScrollPos>mNumLevels*levelHeight-scrWidth ) + mScrollPos=mNumLevels*levelHeight-scrWidth; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getScroll() + { + return mScrollPos; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void scroll() + { + mScrollPos+=mScrollSpeed; + + if( mVertical ) + { + if( mScrollPos<0 ) + { + mSpringing = true; + mScrollSpeed+=SPRING_CONST; + if( mScrollSpeed<-MAX_SPRING_SPEED ) mScrollSpeed=-MAX_SPRING_SPEED; + } + else if( mScrollPos> mNumLevels*levelHeight-(scrHeight-mGap)) + { + mSpringing = true; + mScrollSpeed-=SPRING_CONST; + if( mScrollSpeed> MAX_SPRING_SPEED ) mScrollSpeed= MAX_SPRING_SPEED; + } + else + { + if( mSpringing ) + { + if( mScrollPos 1 ) mScrollSpeed-=1; + else if( mScrollSpeed<-1 ) mScrollSpeed+=1; + else mScrollSpeed=0; + } + } + } + else + { + if( mScrollPos<0 ) + { + mSpringing = true; + mScrollSpeed+=SPRING_CONST; + if( mScrollSpeed<-MAX_SPRING_SPEED ) mScrollSpeed=-MAX_SPRING_SPEED; + } + else if( mScrollPos> mNumLevels*levelHeight-scrWidth ) + { + mSpringing = true; + mScrollSpeed-=SPRING_CONST; + if( mScrollSpeed> MAX_SPRING_SPEED ) mScrollSpeed= MAX_SPRING_SPEED; + } + else + { + if( mSpringing ) + { + if( mScrollPos 1 ) mScrollSpeed-=1; + else if( mScrollSpeed<-1 ) mScrollSpeed+=1; + else mScrollSpeed=0; + } + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getNumLevels() + { + return mNumLevels; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getIntrinsic() + { + SokobanLevel sl= getLevel(mNumLevels-1); + + if( sl!=null ) return sl.getIntrinsicNum(); + + return -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void addLevel(SokobanLevel l, int num) + { + mLevels.addElement(l); + mNumLevels++; + l.setNum(mNumLevels); + l.setIntrinsicNum(num); + l.setRecordId(num+SokobanDatabase.BEGIN_LEVELS); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void insertLevel(SokobanLevel l, int pos,int intrinsic, int recordid) + { + if( pos>=mNumLevels ) + { + for(int i=mNumLevels; i<=pos; i++) + { + mLevels.addElement(null); + } + + mNumLevels = pos+1; + } + + mLevels.setElementAt(l, pos); + l.setNum(pos+1); + l.setIntrinsicNum(intrinsic); + l.setRecordId(recordid); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void render(int state, Canvas c) + { + if( state==SokobanCanvas.STATE_MAIN || + state==SokobanCanvas.STATE_MENU || + state==SokobanCanvas.STATE_DOWN || + state==SokobanCanvas.STATE_DOWL || + state==SokobanCanvas.STATE_FAID || + state==SokobanCanvas.STATE_FAIE || + state==SokobanCanvas.STATE_SUCE || + state==SokobanCanvas.STATE_SUCD || + state==SokobanCanvas.STATE_HELP ) + { + if( (mScrollSpeed!=0 || mSpringing) && !mDragging ) + { + scroll(); + SokobanCanvas.setRepaint(); + } + + int beg = Math.max(mScrollPos/levelHeight, 0); + int end = Math.min(( mVertical ? (mScrollPos+scrHeight-mGap):(mScrollPos+scrWidth) )/levelHeight, mNumLevels-1); + int height = mVertical ? (mGap/2-mScrollPos+(beg-1)*levelHeight):((beg-1)*levelHeight-mScrollPos); + int begHeight = height+levelHeight; + + mPaint.setColor(COLOR_BLACK); + c.drawRect(0, scrHeight-mGap/2-mGapO, scrWidth,scrHeight-mGap/2+7, mPaint); + + try + { + c.clipRect(0, mGap/2, scrWidth, scrHeight-mGap/2+6, Region.Op.REPLACE); + + for(int i=beg; i<=end; i++) + { + SokobanLevel sl = (SokobanLevel)mLevels.elementAt(i); + height+=levelHeight; + + if( sl!=null && height+mGap/2+mGapOmGap/2-5 ) + { + c.drawRect(0, mGap/2-5, scrWidth,begHeight, mPaint); + } + if( height+levelHeight=mNumLevels ? mNumLevels-1:ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getCurrLevel() + { + return currLevel; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getCurrTime() + { + return currTime; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int getCurrMoves() + { + return currMoves; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void setTime(int t) + { + currTime = t; + if( currTime%100==0 ) SokobanCanvas.getMenu().updatePlayState(); + SokobanCanvas.setRepaint(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void rollbackCreated() + { + created.rollback(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void rollback() + { + SokobanLevel sl; + + try + { + sl = (SokobanLevel)mLevels.elementAt(currLevel); + } + catch( ArrayIndexOutOfBoundsException aiofb ) { System.out.println("rollback: level out of bounds??"); return; } + + currMoves = 0; + sl.rollback(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void withdrawCreated() + { + created.withdraw(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void withdraw() + { + SokobanLevel sl; + + try + { + sl = (SokobanLevel)mLevels.elementAt(currLevel); + } + catch( ArrayIndexOutOfBoundsException aiofb ) { System.out.println("withdraw: level out of bounds??"); return; } + + if( sl.withdraw() ) currMoves--; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void resetCreated() + { + created.resetCreated(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void drop(int stuff) + { + created.drop(stuff); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static int validate() + { + return created.validate(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean canWithdrawCreated() + { + return created.canWithdraw(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean canWithdraw() + { + SokobanLevel sl; + + try + { + sl = (SokobanLevel)mLevels.elementAt(currLevel); + } + catch( ArrayIndexOutOfBoundsException aiofb ) { System.out.println("withdraw: level out of bounds??"); return false; } + + return sl.canWithdraw(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void click(int state,int x,int y) + { + if( yscrHeight-mGap/2 ) { clickedLevel=-1; return; } + + cX = x; + cY = y; + mDragging = true; + + if( state==SokobanCanvas.STATE_MAIN || state==SokobanCanvas.STATE_SUCD ) + { + amountDrag = mVertical ? y:x; + if( mScrollSpeed<=1 && mScrollSpeed>=-1 ) clickedLevel = retClickedLevel(x,y); + else clickedLevel = -1; + samplePtr =-1; + for(int i=0; iscrHeight-mGap/2 ) { clickedLevel=-1; mDragging=false; return; } + + int dx = cX-x; + int dy = cY-y; + mDragging = false; + + if( state==SokobanCanvas.STATE_MAIN || state==SokobanCanvas.STATE_SUCD ) + { + if( state==SokobanCanvas.STATE_MAIN && clickedLevel>=0 && dx*dx+dy*dy<=MIN_CLICK_DIST*MIN_CLICK_DIST) + { + SokobanDatabase.incNumPlayings(); + currLevel = clickedLevel; + currMoves = 0; + SokobanCanvas.getMenu().enterPlayState(currLevel); + SokobanCanvas.setRepaint(); + } + + clickedLevel = -1; + cX = -(MIN_CLICK_DIST+1); + cY = -(MIN_CLICK_DIST+1); + amountDrag = -1; + + mScrollSpeed=0; + for(int i=0; iscrHeight-mGap/2 ) { clickedLevel=-1; return; } + + int dx = cX-x; + int dy = cY-y; + + if( state==SokobanCanvas.STATE_MAIN || state==SokobanCanvas.STATE_SUCD ) + { + int nDrag = mVertical ? y:x; + + if( mSpringing==false ) mScrollSpeed = amountDrag-nDrag; + amountDrag = nDrag; + + scroll(); + + if( samplePtr<0 ) + { + samplePtr=0; + for(int i=0; i=SAMPLE_SIZE ) samplePtr=0; + sample[samplePtr] = mScrollSpeed; + } + + if( dx*dx+dy*dy>MIN_CLICK_DIST*MIN_CLICK_DIST) + { + clickedLevel= -1; + } + } + else if( state==SokobanCanvas.STATE_PLAY ) + { + movePlayer(dx,dy); + } + else if( state==SokobanCanvas.STATE_CRES ) + { + movePlayerCreated(dx,dy); + } + else if( state==SokobanCanvas.STATE_CREA ) + { + movePlayerFreely(dx,dy); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void setSubmitted(int lvl) + { + SokobanLevel sl; + + if( lvl>=0 ) + { + sl = getLevel(lvl); + if( sl!=null ) sl.setSubmitted(true); + } + else + { + for(int i=0; ; i++) + { + sl = getLevel(i); + if( sl==null ) break; + sl.setSubmitted(true); + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public SokobanLevel getCreated() + { + return created; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void fillLevelInfo(int lvl, int moves, int time, int place, String name, String country) + { + SokobanLevel sl = getLevel(lvl); + if( sl!=null ) + { + if( place==0 ) + { + SokobanRecordInfo wr = sl.getRecordInfo(0); + + if( wr==null ) sl.setDirty(); + else + { + int wm = wr.getMove(); + if( moves=0 ) + SokobanLevels.getInstance().startTimer(runningTime); + } + +/////////////////////////////////////////////////////////////////// + + private void initCanvas() + { + rrc = SokobanCanvas.getCanvas(this); + + if( rrc!=null ) + { + ViewGroup vg = (ViewGroup)(rrc.getParent()); + if( vg!=null ) vg.removeView(rrc); + setContentView(rrc); + SokobanCanvas.setActivity(this); + } + else setContentView(R.layout.error); + } + +/////////////////////////////////////////////////////////////////// +// end of file +} diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanMenu.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanMenu.java new file mode 100644 index 0000000..f0093c5 --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanMenu.java @@ -0,0 +1,1256 @@ +package com.threedcell.sokoban; + +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Color; +import android.graphics.Paint; +import android.graphics.Canvas; +import android.graphics.Paint.Align; +import android.graphics.Paint.Style; +import android.graphics.drawable.NinePatchDrawable; +import android.graphics.Rect; + +import android.content.Context; +import android.content.res.Resources; + +//import android.util.Log; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public final class SokobanMenu implements TouchKeyboard.VirtualKeyboardListener + { + //private static final String TAG_MENU = "SokobanMenu"; + + private static final int SOFT_NOT = 0; + private static final int SOFT_LEF = 1; + private static final int SOFT_RIG = 2; + private static final int SOFT_LEL = 3; + private static final int SOFT_LER = 4; + + public static final int ACTION_NONE = 0; + public static final int ACTION_SUBL = 1; + public static final int ACTION_SUBR = 2; + + private static final int GAP=20; + + private static String strHelptxt, strEmail, strLevel, strNewr, strSubm, strMoves, strSeconds; + private static String strSolved, strName, strOptions, strSolveNL, strSubmitNL, strFirst, strChoose; + private static String strSubmitted, strSuccessfully, strOk, strBack, strExit, strYes, strNo, strRecords; + private static String strDone, strSubmit, strSolve, strAbort, strDownloaded, strHelp, strFailed; + private static String strFTS, strIAT, strTagain, strSubmitting, strNoper, strTun, strLeaderboard; + private static String strNtaken, strCname, strDlevels, strDownloading, strCNL, strFTD; + private static String strNewLevels, strNewLevel, strNoNewLevels, strDownloaded2; + private static String strSolveIt, strYWL, strOTS, strUL, strIncorrect; + private static String strPNTS, strOAES, strPA, strID, strNCF, strLISA, strNOCD, strNETN, strODS; + + private static SokobanCanvas mCanvas; + + private int scrWidth; + private int scrHeight; + public static int lFontH,mFontH,hFontH,sFontH; + + private static NinePatchDrawable mDialog, mDlgRed, mButtonClicked, mButtUnClicked; + private Bitmap mRollBlack, mRollGray, mBackBlack, mBackGray, mMaskBackground=null; + private Paint mPaint; + + private int menuItem = -1; + private int dialogX,dialogY0,dialogY1,dialogY2,dialogY3,dialogM; + private TouchKeyboard tkb = null; + private static int nameChangeAction =ACTION_NONE; + private SokobanStringBlock blockHelptext; + + private int softkeyState = SOFT_NOT; + private int comeBackState=SokobanCanvas.STATE_MAIN; + private int numDownloaded; + private int upperSoftkeyState; + private int createdLevelError; + + private String levelNumStr; + private boolean fontSmall; + private int maxStrLen; + private static Resources res; + private int mRollH, mRollW, mBackH, mBackW; + private static boolean mEmailClicked; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public SokobanMenu(Context context, SokobanCanvas c) + { + mCanvas = c; + scrWidth = mCanvas.getScrWidth(); + scrHeight= mCanvas.getScrHeight(); + + res = context.getResources(); + + try + { + mDialog = (NinePatchDrawable)res.getDrawable(R.drawable.dialog); + mDlgRed = (NinePatchDrawable)res.getDrawable(R.drawable.dialog_clicked); + mButtonClicked = (NinePatchDrawable)res.getDrawable(R.drawable.btn_clicked); + mButtUnClicked = (NinePatchDrawable)res.getDrawable(R.drawable.btn_unclicked); + + mBackBlack = BitmapFactory.decodeResource(res, R.drawable.back_black); + mBackGray = BitmapFactory.decodeResource(res, R.drawable.back_gray); + mRollBlack = BitmapFactory.decodeResource(res, R.drawable.roll_black); + mRollGray = BitmapFactory.decodeResource(res, R.drawable.roll_gray); + } + catch( Exception ex ) {} + + mEmailClicked = false; + + mPaint = new Paint(); + mPaint.setAntiAlias(true); + mPaint.setStyle(Style.FILL); + + mRollH = mRollBlack.getHeight()/2; + mRollW = mRollBlack.getWidth()/2; + mBackH = mBackBlack.getHeight()/2; + mBackW = mBackBlack.getWidth()/2; + + if( mRollH > SokobanLevels.mGap/4 - 5 ) + { + float f = ((float)(SokobanLevels.mGap/4 - 5))/mRollH; + + mRollW = (int)(f*mRollW); + mRollH = (int)(f*mRollH); + mBackW = (int)(f*mBackW); + mBackH = (int)(f*mBackH); + + mRollBlack = Bitmap.createScaledBitmap(mRollBlack, 2*mRollW, 2*mRollH, true); + mRollGray = Bitmap.createScaledBitmap(mRollGray , 2*mRollW, 2*mRollH, true); + mBackBlack = Bitmap.createScaledBitmap(mBackBlack, 2*mBackW, 2*mBackH, true); + mBackGray = Bitmap.createScaledBitmap(mBackGray , 2*mBackW, 2*mBackH, true); + } + + strEmail = context.getString(R.string.questions)+" "+context.getString(R.string.email); + strHelptxt = context.getString(R.string.helptxt); + strLevel = context.getString(R.string.level)+" "; + strNewr = context.getString(R.string.newr); + strSubm = context.getString(R.string.subm); + strMoves = " "+context.getString(R.string.moves); + strSeconds = " "+context.getString(R.string.seconds ); + strSolved = context.getString(R.string.solved); + strName = context.getString(R.string.app_name); + strOptions = context.getString(R.string.options); + strSolveNL = context.getString(R.string.solvenl); + strSubmitNL = context.getString(R.string.submitnl); + strFirst = context.getString(R.string.first); + strChoose = context.getString(R.string.choose); + strSubmitted = context.getString(R.string.submitted); + strSuccessfully = context.getString(R.string.successfully); + strOk = context.getString(R.string.ok); + strBack = context.getString(R.string.back); + strYes = context.getString(R.string.yes); + strNo = context.getString(R.string.no); + strExit = context.getString(R.string.exit); + strDone = context.getString(R.string.done); + strSolve = context.getString(R.string.solve); + strSubmit = context.getString(R.string.submit); + strAbort = context.getString(R.string.abort); + strDownloaded = context.getString(R.string.downloaded); + strHelp = context.getString(R.string.help); + strRecords = context.getString(R.string.records); + strFTS = context.getString(R.string.fts); + strIAT = context.getString(R.string.iat); + strTagain = context.getString(R.string.tagain); + strNoper = context.getString(R.string.noper); + strSubmitting = context.getString(R.string.submitting); + strTun = context.getString(R.string.tun); + strLeaderboard = context.getString(R.string.leaderboard); + strFailed = context.getString(R.string.failed); + strDlevels = context.getString(R.string.dlevels); + strCname = context.getString(R.string.cname); + strNtaken = context.getString(R.string.ntaken); + strDownloading = context.getString(R.string.downloading); + strCNL = context.getString(R.string.cnl); + strFTD = context.getString(R.string.ftd); + strNewLevels = context.getString(R.string.newlevels); + strNewLevel = context.getString(R.string.newlevel); + strNoNewLevels = context.getString(R.string.nonewlevels); + strDownloaded2 = context.getString(R.string.downloaded2); + strSolveIt = context.getString(R.string.solveit); + strYWL = context.getString(R.string.ywl); + strOTS = context.getString(R.string.ots); + strUL = context.getString(R.string.ul); + strIncorrect = context.getString(R.string.incorrect); + strPNTS = context.getString(R.string.pnts); + strOAES = context.getString(R.string.oaes); + strPA = context.getString(R.string.pa); + strID = context.getString(R.string.id); + strNCF = context.getString(R.string.ncf); + strLISA = context.getString(R.string.lisa); + strLISA = context.getString(R.string.lisa); + strNOCD = context.getString(R.string.nocd); + strNETN = context.getString(R.string.netn); + strODS = context.getString(R.string.ods); + + setUpDialogSizeAndFonts(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void setUpDialogSizeAndFonts() + { + if( scrWidth<=240 ) + { + lFontH = 32; + mFontH = 24; + hFontH = 20; + sFontH = 14; + dialogX = scrWidth-10; + } + else if( scrWidth<=320 ) + { + lFontH = 38; + mFontH = 30; + hFontH = 24; + sFontH = 18; + dialogX = scrWidth-20; + } + else if( scrWidth<=360 ) + { + lFontH = 42; + mFontH = 32; + hFontH = 28; + sFontH = 20; + dialogX = scrWidth-30; + } + else if( scrWidth<=480 ) + { + lFontH = 50; + mFontH = 40; + hFontH = 34; + sFontH = 28; + dialogX = scrWidth-50; + } + else + { + lFontH = 70; + mFontH = 50; + hFontH = 40; + sFontH = 30; + dialogX = 480; + } + + dialogM = dialogX/16; + dialogY0= 3*scrHeight/4; + dialogY1= 4*mFontH; + dialogY2= 4*mFontH+3*GAP + 60; + dialogY3= 6*mFontH; + + if( dialogY0 > 400 ) dialogY0= 400; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void enterPlayState(int levelNum) + { + levelNumStr=strLevel+(levelNum+1); + mPaint.setTextSize(3*SokobanLevels.mGap/8); + maxStrLen=scrWidth-30-(int)mPaint.measureText(levelNumStr); + fontSmall=false; + + SokobanCanvas.setState(SokobanCanvas.STATE_PLAY); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void updatePlayState() + { + String tmp= SokobanLevels.getCurrMoves()+"m "+SokobanLevels.getCurrTime()+"s"; + mPaint.setTextSize(3*SokobanLevels.mGap/8); + if( mPaint.measureText(tmp)>maxStrLen ) fontSmall=true; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void setScrDimensions(int w, int h) + { + if( scrWidth!=w || scrHeight!=h ) + { + scrWidth = w; + scrHeight= h; + setUpDialogSizeAndFonts(); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void comeBackTo(int state) + { + comeBackState = state; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void setAction(int action) + { + nameChangeAction = action; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static Resources getResources() + { + return res; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void setPointerState(int state,int x,int y,boolean pressed) + { + if( pressed ) + { + softkeyState = retSoftkey(state,x,y); + SokobanCanvas.setRepaint(); + + if( state==SokobanCanvas.STATE_CREA && y<=SokobanLevels.mGap/2 ) + { + upperSoftkeyState = 1+(x/(scrWidth/5)); + } + } + + if( state==SokobanCanvas.STATE_MENU ) + { + if( x>=(scrWidth-dialogX)/2 && x<=(scrWidth+dialogX)/2 ) + { + menuItem = -1+(y+3*(mFontH+GAP)-(scrHeight+GAP)/2)/(mFontH+GAP); + } + } + else if( state==SokobanCanvas.STATE_HELP ) + { + int len=scrWidth-10; + int gap=scrWidth/48; + if(len>500) len=500; + + if( x>=(scrWidth-len)/2+gap && y>=(scrHeight-dialogY0)/2+gap && + x<=(scrWidth+len)/2-gap && y<=(scrHeight-dialogY0)/2+2*gap+sFontH+mFontH ) + { + mEmailClicked = true; + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void tryPress(int state,int x,int y) + { + if( softkeyState!=SOFT_NOT ) + { + if( y>= scrHeight-SokobanLevels.mGap/2 ) + { + switch(softkeyState) + { + case SOFT_LEF: lefSoftkey(state); break; + case SOFT_RIG: rigSoftkey(state); break; + case SOFT_LEL: lelSoftkey(state); break; + case SOFT_LER: lerSoftkey(state); break; + } + } + + softkeyState = SOFT_NOT; + SokobanCanvas.setRepaint(); + } + + if( state==SokobanCanvas.STATE_CREA ) + { + switch( upperSoftkeyState ) + { + case 1: SokobanLevels.drop(SokobanLevel.WALL); break; + case 2: SokobanLevels.drop(SokobanLevel.EMPT); break; + case 3: SokobanLevels.drop(SokobanLevel.PACK); break; + case 4: SokobanLevels.drop(SokobanLevel.DEST); break; + case 5: SokobanLevels.resetCreated(); break; + } + upperSoftkeyState=0; + } + else if( state==SokobanCanvas.STATE_MENU ) + { + SokobanRecords sr; + + switch(menuItem) + { + case 0: sr = mCanvas.getRecords(); + if( sr.isDirtyRecords() ) + { + mCanvas.getRecords().downloadRecords(); + SokobanCanvas.setState(SokobanCanvas.STATE_DOWN); + } + else + SokobanCanvas.setState(SokobanCanvas.STATE_SUCD); + break; + case 1: SokobanCanvas.setState(SokobanCanvas.STATE_CREA); break; + case 2: mCanvas.getRecords().downloadLevels(); + SokobanCanvas.setState(SokobanCanvas.STATE_DOWL); + break; + case 3: SokobanCanvas.setState(SokobanCanvas.STATE_HELP); break; + } + + menuItem = -1; + } + else if( state==SokobanCanvas.STATE_HELP ) + { + int len=scrWidth-10; + int gap=scrWidth/48; + if(len>500) len=500; + + if( x>=(scrWidth-len)/2+gap && y>=(scrHeight-dialogY0)/2+gap && mEmailClicked && + x<=(scrWidth+len)/2-gap && y<=(scrHeight-dialogY0)/2+gap+sFontH+mFontH ) + { + mCanvas.sendMail(); + } + mEmailClicked = false; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void lefSoftkey(int state) + { + switch(state) + { + case SokobanCanvas.STATE_NEWR: if( mCanvas.getRecords().submitRecord(SokobanLevels.getCurrLevel()) ) + SokobanCanvas.setState(SokobanCanvas.STATE_SUBM); + else + { + nameChangeAction = ACTION_SUBR; + SokobanCanvas.setState(SokobanCanvas.STATE_NAME); + } + break; + case SokobanCanvas.STATE_NAME: + case SokobanCanvas.STATE_EXIS: changeName(); + SokobanCanvas.setState(SokobanCanvas.STATE_SUBM); + break; + case SokobanCanvas.STATE_MAIN: SokobanCanvas.setState(SokobanCanvas.STATE_MENU); + break; + case SokobanCanvas.STATE_CREA: createdLevelError = SokobanLevels.validate(); + SokobanCanvas.setState(SokobanCanvas.STATE_CRED); + break; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void rigSoftkey(int state) + { + switch(state) + { + case SokobanCanvas.STATE_MAIN: mCanvas.getActivity().finish(); + break; + case SokobanCanvas.STATE_DOWL: + case SokobanCanvas.STATE_DOWN: mCanvas.getRecords().abortNetworkTransaction(); + SokobanCanvas.setState(SokobanCanvas.STATE_MENU); + break; + case SokobanCanvas.STATE_SUBM: mCanvas.getRecords().abortNetworkTransaction(); + case SokobanCanvas.STATE_FAIL: + case SokobanCanvas.STATE_RECO: + case SokobanCanvas.STATE_NEWR: + case SokobanCanvas.STATE_TIME: + case SokobanCanvas.STATE_PLAY: SokobanLevels.getInstance().rollback(); + SokobanLevels.getInstance().resetCurrTime(); + SokobanCanvas.setState(SokobanCanvas.STATE_MAIN); + break; + case SokobanCanvas.STATE_CRES: SokobanLevels.getInstance().rollbackCreated(); + SokobanCanvas.setState(SokobanCanvas.STATE_CREA); + break; + case SokobanCanvas.STATE_SECU: SokobanLevels.getInstance().rollback(); + SokobanLevels.getInstance().resetCurrTime(); + SokobanCanvas.setState(comeBackState); + break; + case SokobanCanvas.STATE_SUCE: + case SokobanCanvas.STATE_MENU: SokobanCanvas.setState(SokobanCanvas.STATE_MAIN); + break; + case SokobanCanvas.STATE_FAID: + case SokobanCanvas.STATE_SUCD: + case SokobanCanvas.STATE_FAIE: + case SokobanCanvas.STATE_CREA: SokobanCanvas.setState(SokobanCanvas.STATE_MENU); + break; + case SokobanCanvas.STATE_CRED: if( createdLevelError==0 ) + SokobanCanvas.setState(SokobanCanvas.STATE_CRES); + else + SokobanCanvas.setState(SokobanCanvas.STATE_CREA); + break; + case SokobanCanvas.STATE_SUBC: SokobanLevel c = SokobanLevels.getInstance().getCreated(); + if( mCanvas.getRecords().submitLevel(c.getCols(),c.encodeLevel()) ) + SokobanCanvas.setState(SokobanCanvas.STATE_SUBM); + else + { + nameChangeAction = ACTION_SUBL; + SokobanCanvas.setState(SokobanCanvas.STATE_NAME); + } + break; + case SokobanCanvas.STATE_HELP: if( SokobanDatabase.getNumRunnings()==0 ) + SokobanCanvas.setState(SokobanCanvas.STATE_MAIN); + else + SokobanCanvas.setState(SokobanCanvas.STATE_MENU); + break; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void lelSoftkey(int state) + { + if( state==SokobanCanvas.STATE_PLAY ) + { + SokobanLevels.getInstance().rollback(); + } + else if( state==SokobanCanvas.STATE_CRES ) + { + SokobanLevels.getInstance().rollbackCreated(); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void lerSoftkey(int state) + { + if( state==SokobanCanvas.STATE_PLAY ) + { + SokobanLevels.getInstance().withdraw(); + } + else if( state==SokobanCanvas.STATE_CRES ) + { + SokobanLevels.getInstance().withdrawCreated(); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void downloadRecordsReady() + { + SokobanLevelBuffer.invalidateAllR(); + SokobanCanvas.setState(SokobanCanvas.STATE_SUCD); + SokobanCanvas.setRepaint(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void downloadLevelsReady(int num) + { + numDownloaded = num; + if( num>0 ) SokobanLevels.getInstance().scrollToEnd(); + SokobanCanvas.setState(SokobanCanvas.STATE_SUCE); + SokobanCanvas.setRepaint(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void render(int state, Canvas c) + { + switch(state) + { + case SokobanCanvas.STATE_NEWR: renderNewR(c); break; + case SokobanCanvas.STATE_TIME: renderTime(c); break; + case SokobanCanvas.STATE_RECO: renderReco(c); break; + case SokobanCanvas.STATE_NAME: renderName(c); break; + case SokobanCanvas.STATE_FAIL: renderFail(c); break; + case SokobanCanvas.STATE_EXIS: renderExis(c); break; + case SokobanCanvas.STATE_SUBM: renderSubm(c); break; + case SokobanCanvas.STATE_SECU: renderSecu(c); break; + case SokobanCanvas.STATE_MENU: renderMenu(c); break; + case SokobanCanvas.STATE_DOWN: + case SokobanCanvas.STATE_DOWL: renderDown(c); break; + case SokobanCanvas.STATE_HELP: renderHelp(c); break; + case SokobanCanvas.STATE_FAID: + case SokobanCanvas.STATE_FAIE: renderFaid(c); break; + case SokobanCanvas.STATE_SUCE: renderSuce(c); break; + case SokobanCanvas.STATE_CRED: renderCred(c); break; + case SokobanCanvas.STATE_SUBC: renderSubc(c); break; + } + + if( state!=SokobanCanvas.STATE_CREA && + state!=SokobanCanvas.STATE_CRED ) renderUpperPane(state,c); + else renderCreatedPane(c); + + renderLowerPane(state,c); + renderSoftkeyCaptions(state,c); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// private part + + private void renderNewR( Canvas c ) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY3)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY3)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strNewr, scrWidth/2, scrHeight/2 - 3*mFontH/2, mPaint); + c.drawText(strSubm, scrWidth/2, scrHeight/2 + 5*mFontH/2, mPaint); + + int seconds = SokobanLevels.getCurrTime(); + int moves = SokobanLevels.getCurrMoves(); + + mPaint.setFakeBoldText(true); + + c.drawText(moves+strMoves , scrWidth/2, scrHeight/2 , mPaint); + c.drawText(seconds+strSeconds, scrWidth/2, scrHeight/2+mFontH, mPaint); + + mPaint.setFakeBoldText(false); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderTime(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strSolved, scrWidth/2, scrHeight/2 - mFontH/2 -2,mPaint); + + int seconds = SokobanLevels.getCurrTime(); + int moves = SokobanLevels.getCurrMoves(); + + mPaint.setFakeBoldText(true); + + c.drawText(moves+strMoves , scrWidth/2, scrHeight/2+ mFontH/2 +2,mPaint); + c.drawText(seconds+strSeconds, scrWidth/2, scrHeight/2+3*mFontH/2 +2,mPaint); + + mPaint.setFakeBoldText(false); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderName(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strFirst , scrWidth/2, scrHeight/2 ,mPaint); + c.drawText(strChoose , scrWidth/2, scrHeight/2 +mFontH ,mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderReco(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strSubmitted , scrWidth/2, scrHeight/2 ,mPaint); + c.drawText(strSuccessfully, scrWidth/2, scrHeight/2 +mFontH ,mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderFail(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strFTS, scrWidth/2, scrHeight/2 + mFontH/2, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderExis(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText( "'"+SokobanDatabase.getName()+"'", scrWidth/2, scrHeight/2 - mFontH/2, mPaint); + c.drawText( strIAT , scrWidth/2, scrHeight/2 + mFontH/2, mPaint); + c.drawText( strTagain , scrWidth/2, scrHeight/2 + 3*mFontH/2, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderSubm(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strSubmitting+"...", scrWidth/2, scrHeight/2 + mFontH/2, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderSecu(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strNoper, scrWidth/2, scrHeight/2 , mPaint); + c.drawText(strTun , scrWidth/2, scrHeight/2 + mFontH, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderMenu(Canvas c) + { + int h = mFontH+GAP; + int h2= scrHeight/2 -h/2 +mFontH/3; + + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY2)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY2)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + if( menuItem>=0 && menuItem<=3 ) + { + drawHighlight( (scrWidth-dialogX)/2+dialogM,scrHeight/2+(menuItem-2)*h,(scrWidth+dialogX)/2-dialogM, scrHeight/2+(menuItem-1)*h, true, c); + } + + c.drawText(strLeaderboard, scrWidth/2, h2- h, mPaint); + c.drawText(strCNL , scrWidth/2, h2 , mPaint); + c.drawText(strDlevels , scrWidth/2, h2+ h, mPaint); + c.drawText(strHelp , scrWidth/2, h2+2*h, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderDown(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText( strDownloading , scrWidth/2, (scrHeight+mFontH)/2, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderHelp(Canvas c) + { + maskBackground(c); + int len = scrWidth-10; + int gap = scrWidth/48; + + if( len>500 ) len=500; + + drawDialog( (scrWidth-len)/2,(scrHeight-dialogY0)/2, (scrWidth+len)/2, (scrHeight+dialogY0)/2, false,c ); + + drawHighlight((scrWidth-len)/2+gap,(scrHeight-dialogY0)/2+gap, (scrWidth+len)/2-gap, (scrHeight-dialogY0)/2+2*gap+sFontH+mFontH, mEmailClicked,c); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText( strName+" v."+SokobanCanvas.mVersionStr, scrWidth/2, (scrHeight-dialogY0)/2+gap+mFontH, mPaint); + mPaint.setTextSize(sFontH); + c.drawText( strEmail, scrWidth/2, (scrHeight-dialogY0)/2+gap+mFontH+sFontH, mPaint); + + if( blockHelptext==null ) + { + int helpHeight = dialogY0-3*gap-mFontH-sFontH; + blockHelptext = new SokobanStringBlock( strHelptxt, helpHeight, len-2*gap); + } + blockHelptext.draw(c,(scrWidth-len)/2+gap,(scrHeight-dialogY0)/2+mFontH+sFontH+2*gap, SokobanCanvas.COLOR_BLACK); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderFaid(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText( strFTD, scrWidth/2, (scrHeight+mFontH)/2, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderSuce(Canvas c) + { + maskBackground(c); + + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY1)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY1)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + if( numDownloaded>1 ) + { + c.drawText(strDownloaded , scrWidth/2, scrHeight/2 , mPaint); + c.drawText(numDownloaded+" "+strNewLevels, scrWidth/2, scrHeight/2+mFontH, mPaint); + } + else if( numDownloaded==1 ) + { + c.drawText(strDownloaded , scrWidth/2, scrHeight/2 , mPaint); + c.drawText(strNewLevel , scrWidth/2, scrHeight/2 +mFontH, mPaint); + } + else + { + c.drawText(strNoNewLevels, scrWidth/2, scrHeight/2 , mPaint); + c.drawText(strDownloaded2, scrWidth/2, scrHeight/2 +mFontH, mPaint); + } + } + + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderSubc(Canvas c) + { + maskBackground(c); + + + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderCred(Canvas c) + { + maskBackground(c); + + if( createdLevelError==0 ) + { + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY3)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY3)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strSolveIt, scrWidth/2, scrHeight/2- 2*mFontH +SokobanLevels.mGapO, mPaint ); + c.drawText(strYWL , scrWidth/2, scrHeight/2+ mFontH/2-SokobanLevels.mGapO, mPaint ); + c.drawText(strOTS , scrWidth/2, scrHeight/2+ 3*mFontH/2-SokobanLevels.mGapO, mPaint ); + c.drawText(strUL , scrWidth/2, scrHeight/2+ 5*mFontH/2-SokobanLevels.mGapO, mPaint ); + } + else + { + drawDialog( (scrWidth-dialogX)/2,(scrHeight-dialogY3)/2, (scrWidth+dialogX)/2, (scrHeight+dialogY3)/2, false,c ); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(mFontH); + mPaint.setTextAlign(Align.CENTER); + + c.drawText(strIncorrect, scrWidth/2, (scrHeight-dialogY3+3*mFontH)/2, mPaint); + + mPaint.setTextSize(hFontH); + + switch( createdLevelError ) + { + case -1: + case -2: c.drawText(strPNTS , scrWidth/2, scrHeight/2+ mFontH/2, mPaint ); + c.drawText(strOAES , scrWidth/2, scrHeight/2+3*mFontH/2, mPaint ); + break; + case -3: c.drawText(strPA , scrWidth/2, scrHeight/2+ mFontH/2, mPaint ); + c.drawText(strID , scrWidth/2, scrHeight/2+3*mFontH/2, mPaint ); + break; + case -4: c.drawText(strNCF , scrWidth/2, scrHeight/2+ mFontH , mPaint ); + break; + case -5: c.drawText(strLISA , scrWidth/2, scrHeight/2+ mFontH , mPaint ); + break; + default: c.drawText(strNOCD , scrWidth/2, scrHeight/2 , mPaint ); + c.drawText(strNETN , scrWidth/2, scrHeight/2+ mFontH , mPaint ); + c.drawText(strODS , scrWidth/2, scrHeight/2+2*mFontH , mPaint ); + break; + } + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void maskBackground(Canvas c) + { + if( mMaskBackground==null ) + { + try + { + mMaskBackground = BitmapFactory.decodeResource(res, R.drawable.mask); + } + catch(Exception ex) { return; } + } + if( mMaskBackground!=null ) + { + int mh = mMaskBackground.getHeight(); + int mw = mMaskBackground.getWidth(); + + int h = (scrHeight-1)/mh; + int w = (scrWidth -1)/mw; + + for(int i=0; i<=h; i++) + for(int j=0; j<=w; j++ ) + c.drawBitmap(mMaskBackground, j*mw, i*mh, null); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int retSoftkey(int state, int x,int y) + { + if ( y>=scrHeight-SokobanLevels.mGap/2 ) + { + if( x>scrWidth/2 ) return SOFT_RIG; + if( state!=SokobanCanvas.STATE_PLAY && + state!=SokobanCanvas.STATE_CRES ) return SOFT_LEF; + + return x>scrWidth/4 ? SOFT_LER:SOFT_LEL; + } + + return SOFT_NOT; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderUpperPane(int state, Canvas c) + { + drawDialog(0,0,scrWidth, SokobanLevels.mGap/2, false, c); + + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(3*SokobanLevels.mGap/8); + mPaint.setTextAlign(Align.CENTER); + + int hei = 3*SokobanLevels.mGap/8; + + switch(state) + { + case SokobanCanvas.STATE_MAIN: c.drawText(strName , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_MENU: c.drawText(strOptions , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_PLAY: mPaint.setTextAlign(Align.LEFT); + c.drawText(levelNumStr, 12,hei,mPaint ); + if( fontSmall ) + { + mPaint.setTextSize(SokobanLevels.mGap/4); + hei = SokobanLevels.mGap/3; + } + mPaint.setTextAlign(Align.RIGHT); + c.drawText(SokobanLevels.getCurrMoves()+"m "+SokobanLevels.getCurrTime()+"s", scrWidth-12,hei, mPaint); + break; + case SokobanCanvas.STATE_CRES: c.drawText(strSolveNL , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_SUBC: c.drawText(strSubmitNL, scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_NEWR: + case SokobanCanvas.STATE_TIME: c.drawText(strSolved , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_RECO: c.drawText(strSubmitted , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_NAME: c.drawText(strCname , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_FAID: + case SokobanCanvas.STATE_FAIE: + case SokobanCanvas.STATE_FAIL: c.drawText(strFailed , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_EXIS: c.drawText(strNtaken , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_SUBM: c.drawText(strSubmitting , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_SECU: c.drawText(strNoper , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_DOWN: c.drawText(strLeaderboard, scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_DOWL: c.drawText(strDlevels , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_HELP: c.drawText(strHelp , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_SUCD: c.drawText(strRecords , scrWidth/2, hei, mPaint); + break; + case SokobanCanvas.STATE_SUCE: c.drawText(strDownloaded , scrWidth/2, hei, mPaint); + break; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderCreatedPane(Canvas c) + { + int len = scrWidth/5; + int l2 = SokobanLevels.bCell1/2 - SokobanLevels.bMargin; + int h2 = SokobanLevels.mGap/4- l2; + int h = SokobanLevels.packBig1.getHeight(); + int h1 = (int)(0.32f*SokobanLevels.mGap); + + drawHighlight(0*len, 0, len, SokobanLevels.mGap/2, upperSoftkeyState==1, c); + drawHighlight(1*len, 0, 2*len, SokobanLevels.mGap/2, upperSoftkeyState==2, c); + drawHighlight(2*len, 0, 3*len, SokobanLevels.mGap/2, upperSoftkeyState==3, c); + drawHighlight(3*len, 0, 4*len, SokobanLevels.mGap/2, upperSoftkeyState==4, c); + drawHighlight(4*len, 0, 5*len, SokobanLevels.mGap/2, upperSoftkeyState==5, c); + + mPaint.setColor(SokobanCanvas.COLOR_WHITE); + + if( h1 >= h ) + { + c.drawBitmap(SokobanLevels.playBig1, len/2-l2, h2, mPaint); + c.drawRect(3*len/2- l2, h2, 3*len/2+l2, h2+2*l2, mPaint); + c.drawBitmap(SokobanLevels.packBig1, 5*len/2- l2, h2, mPaint); + c.drawBitmap(SokobanLevels.destBig1, 7*len/2- l2, h2, mPaint); + } + else + { + Rect src = new Rect(); + Rect dst = new Rect(); + + int off= (h-h1)/2; + + src.top = off; + src.left = off; + src.bottom = h-off; + src.right = h-off; + + dst.top = SokobanLevels.mGap/4 - h1/2; + dst.bottom = SokobanLevels.mGap/4 + h1/2; + + dst.left = len/2 - h1/2; + dst.right = len/2 + h1/2; + c.drawBitmap(SokobanLevels.playBig1, src, dst, mPaint); + + c.drawRect(3*len/2- h1/2, dst.top, 3*len/2+h1/2, dst.bottom, mPaint); + + dst.left = 5*len/2 - h1/2; + dst.right = 5*len/2 + h1/2; + c.drawBitmap(SokobanLevels.packBig1, src, dst, mPaint); + + dst.left = 7*len/2 - h1/2; + dst.right = 7*len/2 + h1/2; + c.drawBitmap(SokobanLevels.destBig1, src, dst, mPaint); + } + + c.drawBitmap(mRollBlack, 9*len/2- mRollW, SokobanLevels.mGap/4-mRollH, mPaint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderLowerPane(int state, Canvas c) + { + boolean leftFocused = false; + boolean rightFocused= false; + boolean lelFocused = false; + boolean lerFocused = false; + + if( softkeyState==SOFT_RIG ) + { + if( state==SokobanCanvas.STATE_MAIN || + state==SokobanCanvas.STATE_PLAY || + state==SokobanCanvas.STATE_FAIL || + state==SokobanCanvas.STATE_RECO || + state==SokobanCanvas.STATE_SECU || + state==SokobanCanvas.STATE_MENU || + state==SokobanCanvas.STATE_NEWR || + state==SokobanCanvas.STATE_SUBM || + state==SokobanCanvas.STATE_DOWN || + state==SokobanCanvas.STATE_CREA || + state==SokobanCanvas.STATE_CRED || + state==SokobanCanvas.STATE_CRES || + state==SokobanCanvas.STATE_SUBC || + state==SokobanCanvas.STATE_DOWL || + state==SokobanCanvas.STATE_HELP || + state==SokobanCanvas.STATE_SUCD || + state==SokobanCanvas.STATE_SUCE || + state==SokobanCanvas.STATE_FAID || + state==SokobanCanvas.STATE_FAIE || + state==SokobanCanvas.STATE_TIME ) rightFocused = true; + } + else if ( softkeyState==SOFT_LEF ) + { + if( state==SokobanCanvas.STATE_MAIN || + state==SokobanCanvas.STATE_NEWR || + state==SokobanCanvas.STATE_EXIS || + state==SokobanCanvas.STATE_CREA || + state==SokobanCanvas.STATE_NAME ) leftFocused = true; + } + else if ( softkeyState==SOFT_LEL ) + { + if( state==SokobanCanvas.STATE_PLAY && SokobanLevels.getInstance().canWithdraw() ==true ) lelFocused=true; + if( state==SokobanCanvas.STATE_CRES && SokobanLevels.getInstance().canWithdrawCreated()==true ) lelFocused=true; + } + else if ( softkeyState==SOFT_LER ) + { + if( state==SokobanCanvas.STATE_PLAY && SokobanLevels.getInstance().canWithdraw() ==true ) lerFocused=true; + if( state==SokobanCanvas.STATE_CRES && SokobanLevels.getInstance().canWithdrawCreated()==true ) lerFocused=true; + } + + if( state!=SokobanCanvas.STATE_PLAY && state!=SokobanCanvas.STATE_CRES ) + { + drawHighlight( 0, scrHeight-SokobanLevels.mGap/2, scrWidth/2, scrHeight, leftFocused, c); + } + else + { + mPaint.setColor(0xff000000); + mPaint.setStyle(Style.FILL); + c.drawRect(scrWidth/4-5, scrHeight-10, scrWidth/4+5, scrHeight, mPaint); + drawHighlight( 0, scrHeight-SokobanLevels.mGap/2, scrWidth/4, scrHeight, lelFocused, c); + drawHighlight(scrWidth/4, scrHeight-SokobanLevels.mGap/2, scrWidth/2, scrHeight, lerFocused, c); + } + + drawHighlight(scrWidth/2, scrHeight-SokobanLevels.mGap/2, scrWidth, scrHeight, rightFocused, c); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void renderSoftkeyCaptions(int state, Canvas c) + { + mPaint.setColor(SokobanCanvas.COLOR_BLACK); + mPaint.setTextSize(3*SokobanLevels.mGap/8); + mPaint.setTextAlign(Align.CENTER); + + String tmp=""; + int hei = scrHeight-SokobanLevels.mGap/8; + + switch(state) + { + case SokobanCanvas.STATE_DOWN: + case SokobanCanvas.STATE_DOWL: + case SokobanCanvas.STATE_SUBM: tmp= strAbort; break; + case SokobanCanvas.STATE_PLAY: + case SokobanCanvas.STATE_TIME: + case SokobanCanvas.STATE_FAIL: + case SokobanCanvas.STATE_SECU: + case SokobanCanvas.STATE_CREA: + case SokobanCanvas.STATE_HELP: + case SokobanCanvas.STATE_RECO: + case SokobanCanvas.STATE_FAID: + case SokobanCanvas.STATE_FAIE: + case SokobanCanvas.STATE_SUCD: + case SokobanCanvas.STATE_CRES: + case SokobanCanvas.STATE_MENU: tmp= strBack ; break; + case SokobanCanvas.STATE_MAIN: tmp= strExit ; break; + case SokobanCanvas.STATE_SUCE: tmp= strOk ; break; + case SokobanCanvas.STATE_CRED: tmp= (createdLevelError==0 ? strSolve:strBack); break; + case SokobanCanvas.STATE_SUBC: tmp= strSubmit; break; + case SokobanCanvas.STATE_NEWR: tmp= strNo ; break; + } + c.drawText( tmp,3*scrWidth/4,hei, mPaint); + tmp =""; + + switch(state) + { + case SokobanCanvas.STATE_CREA: tmp= strDone ; break; + case SokobanCanvas.STATE_EXIS: + case SokobanCanvas.STATE_NAME: tmp= strOk ; break; + case SokobanCanvas.STATE_MAIN: tmp= strOptions ; break; + case SokobanCanvas.STATE_NEWR: tmp= strYes ; break; + case SokobanCanvas.STATE_CRES: boolean isBlack1 = SokobanLevels.getInstance().canWithdrawCreated(); + c.drawBitmap(isBlack1?mRollBlack:mRollGray, scrWidth/8-mRollW, scrHeight-SokobanLevels.mGap/4-mRollH, mPaint); + c.drawBitmap(isBlack1?mBackBlack:mBackGray,3*scrWidth/8-mBackW, scrHeight-SokobanLevels.mGap/4-mBackH, mPaint); + break; + case SokobanCanvas.STATE_PLAY: boolean isBlack2 = SokobanLevels.getInstance().canWithdraw(); + c.drawBitmap(isBlack2?mRollBlack:mRollGray, scrWidth/8-mRollW, scrHeight-SokobanLevels.mGap/4-mRollH, mPaint); + c.drawBitmap(isBlack2?mBackBlack:mBackGray,3*scrWidth/8-mBackW, scrHeight-SokobanLevels.mGap/4-mBackH, mPaint); + break; + } + c.drawText(tmp ,scrWidth/4, hei, mPaint ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void drawDialog(int x1, int y1, int x2, int y2, boolean clicked, Canvas c) + { + if( clicked ) + { + mDlgRed.setBounds(x1, y1, x2, y2); + mDlgRed.draw(c); + } + else + { + mDialog.setBounds(x1, y1, x2, y2); + mDialog.draw(c); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void drawHighlight(int x1, int y1, int x2, int y2, boolean clicked, Canvas c) + { + if( clicked ) + { + mButtonClicked.setBounds(x1, y1, x2, y2); + mButtonClicked.draw(c); + } + else + { + mButtUnClicked.setBounds(x1, y1, x2, y2); + mButtUnClicked.draw(c); + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void changeName() + { + if( tkb==null ) + { + tkb = new TouchKeyboard( mCanvas.getActivity().getApplicationContext(), scrWidth, scrHeight); + tkb.setTextFieldBkgColor(0xFFE0DBCA); + tkb.setTextFieldBorderColor(0xFF040477); + tkb.setTextFieldFontColor(0xFF0033CC); + tkb.setBackgroundColor(Color.BLACK); + tkb.setVirtualKeyboardListener(this); + tkb.resetKeyBoard(); + tkb.setMaxSize(10); + tkb.setMinSize(1); + } + + tkb.setText(SokobanDatabase.getName()); + mCanvas.getActivity().setContentView(tkb); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void okPressed(String text) + { + SokobanDatabase.setName(text); + SokobanLevels.getInstance().updateMyRecords(text); + mCanvas.getActivity().setContentView(mCanvas); + SokobanCanvas.setRepaint(); + + if( nameChangeAction==ACTION_SUBR ) + { + mCanvas.getRecords().submitRecord(SokobanLevels.getCurrLevel()); + } + if( nameChangeAction==ACTION_SUBL ) + { + SokobanLevel c = SokobanLevels.getInstance().getCreated(); + mCanvas.getRecords().submitLevel(c.getCols(),c.encodeLevel()); + } + + nameChangeAction = ACTION_NONE; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// end of SokobanMenu class +} \ No newline at end of file diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanRecordInfo.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanRecordInfo.java new file mode 100644 index 0000000..6112712 --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanRecordInfo.java @@ -0,0 +1,171 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Leszek Koltunski, 2011-04-09 +// +package com.threedcell.sokoban; + +import android.graphics.Bitmap; +import android.graphics.Paint; +import android.graphics.Canvas; +import android.graphics.Paint.Align; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class SokobanRecordInfo +{ +private static int mFontSize; +public static int mCorr; + +private int move; +private int time; +private String name, cutname, country, movetime; +private Bitmap img; +private static Paint mPaint; +private boolean mine; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +SokobanRecordInfo() + { + mFontSize = (int)(SokobanLevels.levelInfoH*0.4); + mCorr = 1+ mFontSize/3 + SokobanLevels.FLAG_H/2; + mPaint = new Paint(); + mPaint.setAntiAlias(true); + mPaint.setTextSize(mFontSize); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +SokobanRecordInfo(int m, int t, String n, String c) + { + set(m,t,n,c); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public void set(int m, int t, String n, String c) + { + move = m; + time = t; + name = n; + country = c; + movetime = movelen0 ) + { + int l = name.length(); + + while( l>=2 && len1+len2>len0 ) + { + l--; + cutname = name.substring(0,l); + len1 = mPaint.measureText(cutname); + } + } + else cutname = null; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// end of SokobanRecordInfo +} \ No newline at end of file diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanRecords.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanRecords.java new file mode 100644 index 0000000..27dc4e5 --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanRecords.java @@ -0,0 +1,679 @@ +package com.threedcell.sokoban; + +import java.io.IOException; +import java.io.InputStream; +import java.io.BufferedInputStream; +import java.io.UnsupportedEncodingException; +import java.net.HttpURLConnection; +import java.net.URL; + +import android.util.Log; + +/////////////////////////////////////////////////////////////////// + +public class SokobanRecords implements Runnable +{ + private static final String TAG_RECORDS = "SokobanRecords"; + + public static final int MAX_PLACES = 9; + public static final int DOWNLOADR = 0; + public static final int DOWNLOADL = 1; + public static final int SUBMITR = 2; + public static final int SUBMITL = 3; + public static final int IDLE = 4; + + private static final int MAX_SUBMIT = 10; + + private static boolean mRunning; + private static boolean mDirtyRecords; + private static Thread mNetworkThrd = null; + private static int mode; + + private static int lv; + private static int mCols; + + private static final String URL = "http://koltunski.pl/sokoban/cgi-bin"; + private static String iso = null; + private String name,veri; + private String mLevel; + + private static SokobanLevels mLevels=null; + + private static final String[] hex = { + "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07", + "%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f", + "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17", + "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f", + "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27", + "%28", "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f", + "%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37", + "%38", "%39", "%3a", "%3b", "%3c", "%3d", "%3e", "%3f", + "%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47", + "%48", "%49", "%4a", "%4b", "%4c", "%4d", "%4e", "%4f", + "%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57", + "%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e", "%5f", + "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67", + "%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f", + "%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77", + "%78", "%79", "%7a", "%7b", "%7c", "%7d", "%7e", "%7f", + "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87", + "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f", + "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97", + "%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f", + "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7", + "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af", + "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7", + "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf", + "%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7", + "%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf", + "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", + "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df", + "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7", + "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef", + "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7", + "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff" + }; + +/////////////////////////////////////////////////////////////////// + + public SokobanRecords() + { + mRunning = false; + mDirtyRecords= true; + mode = IDLE; + } + +/////////////////////////////////////////////////////////////////// + + public static void setLevels(SokobanLevels sl) + { + mLevels = sl; + } + +/////////////////////////////////////////////////////////////////// + + private boolean start() + { + if( !mRunning ) + { + mRunning = true; + mNetworkThrd = new Thread(this); + mNetworkThrd.start(); + + return true; + } + + return false; + } + +/////////////////////////////////////////////////////////////////// + + public void run() + { + try + { + String message=""; + int run = SokobanDatabase.getNumRunnings(); + + if(mode==SUBMITR) + { + int hash = computeSubmitHash(name,veri,getSMSC(),lv,run); + message=URL+"/submitr.cgi"; + message+=("?l="+generateLevelsList(lv)); + message+=("&m="+generateMovesList(lv)); + message+=("&t="+generateTimesList(lv)); + message+=("&v="+URLencode(veri)); + message+=("&n="+URLencode(name)); + message+=("&s="+URLencode(getSMSC())); + message+=("&h="+hash); + message+=("&r="+run); + message+=("&p="+SokobanDatabase.getNumPlayings()); + message+=("&i="+SokobanDatabase.getId()); + message+=("&e="+SokobanCanvas.mVersionStr+"a"); + } + else if(mode==DOWNLOADR) + { + message=URL+"/downloadr.cgi"; + message+="?n="+URLencode(veri); + message+="&r="+run; + message+="&e="+SokobanCanvas.mVersionStr+"a"; + } + else if(mode==SUBMITL ) + { + message=URL+"/submitl.cgi"; + message+="?n="+URLencode(name); + message+="&l="+(SokobanLevels.getIntrinsic()-(SokobanDatabase.BUILTIN_LEVELS-1)); + message+="&s="+URLencode(getSMSC()); + message+="&w="+(mLevel.length()/mCols); + message+="&c="+mCols; + message+="&p="+mLevel; + message+="&r="+run; + message+="&e="+SokobanCanvas.mVersionStr+"a"; + } + else if(mode==DOWNLOADL) + { + message=URL+"/downloadl.cgi"; + message+="?n="+URLencode(name); + message+="&l="+(SokobanLevels.getIntrinsic()-(SokobanDatabase.BUILTIN_LEVELS-1)); + message+="&x="+SokobanLevels.bDrawnX1; //12 x + message+="&y="+SokobanLevels.bDrawnY2; //18 + message+="&r="+run; + message+="&e="+SokobanCanvas.mVersionStr+"a"; + } + + String data = download(message); + + if(mode==SUBMITR) + { + parseResponse(data); + fillData(data); + } + else if(mode==DOWNLOADR) + { + fillData(data); + SokobanCanvas.getMenu().downloadRecordsReady(); + } + else if(mode==SUBMITL) + { + int numDownloaded = getResponseNum(data); + fillLevelsData(data); + SokobanCanvas.getMenu().downloadLevelsReady(numDownloaded); + SokobanLevels.getInstance().rollbackCreated(); + } + else if(mode==DOWNLOADL) + { + int numDownloaded = getResponseNum(data); + fillLevelsData(data); + SokobanCanvas.getMenu().downloadLevelsReady(numDownloaded); + } + } + catch( IOException ioe ) + { + if( mode==SUBMITR ) SokobanCanvas.setState(SokobanCanvas.STATE_FAIL); + if( mode==SUBMITL ) SokobanCanvas.setState(SokobanCanvas.STATE_FAIC); + if( mode==DOWNLOADR) SokobanCanvas.setState(SokobanCanvas.STATE_FAID); + if( mode==DOWNLOADL) SokobanCanvas.setState(SokobanCanvas.STATE_FAIE); + SokobanCanvas.setRepaint(); + } + catch( SecurityException ioe ) + { + SokobanCanvas.setState(SokobanCanvas.STATE_SECU); + SokobanCanvas.getMenu().comeBackTo( mode==SUBMITR ? SokobanCanvas.STATE_PLAY:SokobanCanvas.STATE_MAIN); + SokobanCanvas.setRepaint(); + } + + mRunning = false; + mode = IDLE; + } + +/////////////////////////////////////////////////////////////////// + + private String getSMSC() + { + if( iso==null) iso = SokobanCanvas.getIso(); + return iso; + } + + +/////////////////////////////////////////////////////////////////// + + private int getResponseNum(String data) + { + int newline = data.indexOf('\n',1); + if( newline<0 ) newline = data.length(); + + int ret=-1; + + try + { + ret= Integer.parseInt(data.substring(0, newline)); + } + catch(NumberFormatException nfe) + { + Log.e(TAG_RECORDS, "exception trying to parse "+data); + } + + return ret; + } + +/////////////////////////////////////////////////////////////////// + + private void parseResponse(String data) + { + int responseNum = getResponseNum(data); + + switch(responseNum) + { + case 0: SokobanCanvas.setState(SokobanCanvas.STATE_RECO);// success + SokobanDatabase.setVeri(name); + submitLevelsList(lv); + break; + case -2: SokobanMenu.setAction(SokobanMenu.ACTION_SUBR); + SokobanCanvas.setState(SokobanCanvas.STATE_EXIS);// name exists + break; + case -3: // wrong hash + default: SokobanCanvas.setState(SokobanCanvas.STATE_FAIL);// other error + } + + SokobanCanvas.setRepaint(); + } + +/////////////////////////////////////////////////////////////////// + + private int computeSubmitHash(String n, String v, String s, int lvl, int r) + { + byte[] raw; + int ret=0; + + try { raw = n.getBytes("UTF-8"); } + catch(UnsupportedEncodingException ex) { raw = n.getBytes( ); } + + for(int i=0;is5 && s5>s4 & s4>s3 && s3>s2 && s2>s1 && s1>0 ) + { + try + { + int level= Integer.valueOf( row.substring( 0,s1) ).intValue(); + String n = row.substring(s1+1,s2); + String c = row.substring(s2+1,s3); + // int rows = Integer.valueOf( row.substring(s3+1,s4) ).intValue(); + int cols = Integer.valueOf( row.substring(s4+1,s5) ).intValue(); + String p = row.substring(s5+1,s6); + + SokobanLevel sl = new SokobanLevel(n,c,SokobanDatabase.INVALID, SokobanDatabase.INVALID,null,false,cols,p); + mLevels.addLevel(sl, SokobanDatabase.BUILTIN_LEVELS+level-1); + sl.setDirty(); + } + catch( Exception ex ) { System.out.println("Exception trying to fillLevelsRow: "+ex.toString()); } + } + } + +/////////////////////////////////////////////////////////////////// + + private void fillData( String data ) + { + int len = data.length(); + int begin=-1 ,end = -1; + + while( begins5 && s5>s4 & s4>s3 && s3>s2 && s2>s1 && s1>0 ) + { + try + { + int l = Integer.valueOf( row.substring( 0,s1) ).intValue(); + int m = Integer.valueOf( row.substring(s1+1,s2) ).intValue(); + int t = Integer.valueOf( row.substring(s2+1,s3) ).intValue(); + int p = Integer.valueOf( row.substring(s3+1,s4) ).intValue(); + String n = row.substring(s4+1,s5); + String c = row.substring(s5+1,s6); + + mLevels.fillLevelInfo(l,m,t,p,n,c); + } + catch( Exception ex ) { Log.e(TAG_RECORDS, "Exception trying to fillRow: "+ex.toString()); } + } + } + +/////////////////////////////////////////////////////////////////// + + public void downloadLevels() + { + mode = DOWNLOADL; + name = SokobanDatabase.getName(); + start(); + } + +/////////////////////////////////////////////////////////////////// + + public void downloadRecords() + { + if( mDirtyRecords==true ) + { + mode = DOWNLOADR; + name = SokobanDatabase.getName(); + veri = SokobanDatabase.getVeri(); + start(); + } + } + +/////////////////////////////////////////////////////////////////// + + public boolean submitRecord(int lvl) + { + name = SokobanDatabase.getName(); + if( name==null || name.length()==0 ) return false; + veri = SokobanDatabase.getVeri(); + mode = SUBMITR; + lv = lvl; + + start(); + return true; + } + +/////////////////////////////////////////////////////////////////// + + public boolean submitLevel(int cols, String level) + { + name = SokobanDatabase.getName(); + if( name==null || name.length()==0 ) return false; + veri = SokobanDatabase.getVeri(); + mode = SUBMITL; + mCols = cols; + mLevel= level; + + start(); + return true; + } + +/////////////////////////////////////////////////////////////////// + + public void abortNetworkTransaction() + { + mRunning = false; + } + +/////////////////////////////////////////////////////////////////// + + public boolean isDirtyRecords() + { + return mDirtyRecords; + } + +/////////////////////////////////////////////////////////////////// + + public void setDirty() + { + mDirtyRecords=true; + } + +/////////////////////////////////////////////////////////////////// + + private static String URLencode(String s) + { + if( s==null ) return ""; + + StringBuffer sbuf = new StringBuffer(); + int len = s.length(); + + for (int i = 0; i < len; i++) + { + int ch = s.charAt(i); + + if ('A' <= ch && ch <= 'Z') sbuf.append((char)ch); + else if ('a' <= ch && ch <= 'z') sbuf.append((char)ch); + else if ('0' <= ch && ch <= '9') sbuf.append((char)ch); + else if (ch == ' ' ) sbuf.append('+'); + else if (ch == '-' || ch == '_' + || ch == '.' || ch == '!' + || ch == '~' || ch == '*' + || ch == '\'' || ch == '(' + || ch == ')' ) sbuf.append((char)ch); + else if (ch <= 0x007f) sbuf.append(hex[ch]); + else if (ch <= 0x07FF) + { + sbuf.append(hex[0xc0 | (ch >> 6)]); + sbuf.append(hex[0x80 | (ch & 0x3F)]); + } + else + { + sbuf.append(hex[0xe0 | (ch >> 12)]); + sbuf.append(hex[0x80 | ((ch >> 6) & 0x3F)]); + sbuf.append(hex[0x80 | (ch & 0x3F)]); + } + } + + return sbuf.toString(); + } + +/////////////////////////////////////////////////////////////////// + + private static void submitLevelsList(int lvl) + { + int num=0; + SokobanLevel sl = SokobanLevels.getLevel(lvl); + if( sl!=null ) + { + sl.setSubmitted(true); + sl.setDirty(); + } + + for(int i=0; num=0 && end=0 ) + { + if( str.charAt(begin) == '\n' ) begin++; + + if( end>begin ) + { + tmp = str.substring(begin,end); + + if( end0 ? (float)(length-mPaint.measureText(str))/numspaces : 0); + String tmp; + int begin,end=0; + + while( end0 ) ret++; + else break; + } + + return ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private int getLine(String text, int fontHeight, int begin, int width) + { + int nearestSpace = text.indexOf(' ' , begin+1); + int nearestNewline = text.indexOf('\n', begin+1); + int len=0; + + mPaint.setTextSize(fontHeight); + + if( nearestNewline>=0 && nearestNewline=width ) return nearestSpace+1; + + int lastSpace = nearestSpace; + + while( len=0 && nearestNewline=0 && end=0 ) + { + if( str.charAt(begin) == '\n' ) begin++; + y += (begin==end ? trySize/2 : trySize); + begin = end; + } + } + + return y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// end of RRStringBlock +} diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanTimer.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanTimer.java new file mode 100644 index 0000000..8fc8f1a --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/SokobanTimer.java @@ -0,0 +1,92 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// +// Leszek Koltunski, 2011-04-09 +// +package com.threedcell.sokoban; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class SokobanTimer implements Runnable + { + private static boolean mRunning; + private static Thread mTimerThrd = null; + private static SokobanTimer timer = null; + + private int runningTime; + private long startTime; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private SokobanTimer() + { + mRunning = false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void init() + { + timer = new SokobanTimer(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static SokobanTimer getInstance() + { + return timer; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean start(int time) + { + if( !mRunning && time>=0 ) + { + mRunning = true; + mTimerThrd = new Thread(this); + mTimerThrd.start(); + + runningTime = time/10; + startTime = System.currentTimeMillis() - 100*time; + + return true; + } + + return false; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public int stop() + { + if( mRunning ) + { + mRunning = false; + return (int)(System.currentTimeMillis()-startTime)/100; + } + + return -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public void run() + { + while( mRunning ) + { + try { Thread.sleep(997); } + catch(InterruptedException ie) {} + + runningTime++; + + if( runningTime%10 ==0 ) + runningTime = (int)(System.currentTimeMillis()-startTime)/1000; + + if( mRunning ) SokobanLevels.setTime(runningTime); + } + mTimerThrd = null; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// end of SokobanTimer class + } \ No newline at end of file diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/TextFieldArea.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/TextFieldArea.java new file mode 100644 index 0000000..6978fed --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/TextFieldArea.java @@ -0,0 +1,144 @@ +package com.threedcell.sokoban; + +import android.graphics.Canvas; +import android.graphics.Paint; +import android.graphics.Paint.Style; + +/////////////////////////////////////////////////////////////////// + +public class TextFieldArea + { + //private static final String TAG_TEXT = "RRText"; + + private StringBuffer text; + + private int textFieldBkgColor = 0xFFEEEEEE; + private int textFieldBorderColor = 0xFF000000; + private int textFieldFontColor = 0xFF000000; + + private int maxSize = -1; + private int strLen; + private Paint mPaint; + +/////////////////////////////////////////////////////////////////// + + public TextFieldArea() + { + text = new StringBuffer(); + strLen = 0; + mPaint = new Paint(); + mPaint.setAntiAlias(true); + } + +/////////////////////////////////////////////////////////////////// + + public void deleteLastChar() + { + if (strLen > 0) + { + text.deleteCharAt(strLen-1); + strLen--; + } + } + +/////////////////////////////////////////////////////////////////// + + public void insertNewChar(char aChar) + { + if ( ((maxSize > 0) && (text.length() < maxSize)) || (maxSize < 0)) + { + if (aChar != 0) + { + text.insert(strLen, aChar); + strLen++; + } + } + } + +/////////////////////////////////////////////////////////////////// + + public String getText() + { + return text.toString(); + } + +/////////////////////////////////////////////////////////////////// + + public void setText(String newText) + { + text = null; + text = new StringBuffer(newText); + strLen = newText.length(); + } + +/////////////////////////////////////////////////////////////////// + + public void clearTextField() + { + text = null; + text = new StringBuffer(); + strLen = 0; + } + +/////////////////////////////////////////////////////////////////// + + public void paint( Canvas canvas, int left, int top, int right, int bottom) + { + int fontH = (int)((bottom-top)*0.7); + + mPaint.setColor(textFieldBkgColor); + mPaint.setStyle(Style.FILL); + canvas.drawRect(left, top, right, bottom, mPaint); + mPaint.setColor(textFieldBorderColor); + mPaint.setStyle(Style.STROKE); + canvas.drawRect(left, top, right, bottom, mPaint); + mPaint.setColor(textFieldFontColor); + mPaint.setTextSize(fontH); + + String t = text.toString(); + + while( mPaint.measureText(t) > right-left-(bottom-top)/2 ) + { + mPaint.setTextSize(--fontH); + } + + canvas.drawText( t, left+(bottom-top)/4, (bottom+top+fontH)/2-fontH/8, mPaint); + } + +//////////////////////////////////////////////////////////////////////////////// + + public void setTextFieldBkgColor(int textFieldBkgColor) + { + this.textFieldBkgColor = textFieldBkgColor; + } + +//////////////////////////////////////////////////////////////////////////////// + + public void setTextFieldBorderColor(int textFieldBorderColor) + { + this.textFieldBorderColor = textFieldBorderColor; + } + +//////////////////////////////////////////////////////////////////////////////// + + public void setTextFieldFontColor(int textFieldFontColor) + { + this.textFieldFontColor = textFieldFontColor; + } + +//////////////////////////////////////////////////////////////////////////////// + + public int getMaxSize() + { + return maxSize; + } + +//////////////////////////////////////////////////////////////////////////////// + + public void setMaxSize(int maxSize) + { + this.maxSize = maxSize; + } +//////////////////////////////////////////////////////////////////////////////// +// end of TextFieldArea +} diff --git a/distorted-sokoban/src/main/java/com/threedcell/sokoban/TouchKeyboard.java b/distorted-sokoban/src/main/java/com/threedcell/sokoban/TouchKeyboard.java new file mode 100644 index 0000000..c464d0a --- /dev/null +++ b/distorted-sokoban/src/main/java/com/threedcell/sokoban/TouchKeyboard.java @@ -0,0 +1,459 @@ +package com.threedcell.sokoban; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Canvas; +import android.graphics.Paint; +import android.graphics.Paint.Align; +import android.graphics.Paint.Style; +import android.graphics.drawable.NinePatchDrawable; + +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.View; + +//import android.util.Log; + +//////////////////////////////////////////////////////////////////////////////// + +public class TouchKeyboard extends View + { + //private static final String TAG_KEYBOARD = "RubikKeyboard"; + + private static final int MARGIN = 2; + private static final int WMARGIN = 8; + private static final int BUTTON_NONE = -4; + private static final int BUTTON_OK = -3; + private static final int BUTTON_BKSP = -2; + private static final int BUTTON_CAPS = -1; + + private int currPressed; + + private TextFieldArea textField; + private Paint mPaint; + private NinePatchDrawable keyBlue, keyRed, keyWhite; + private Bitmap ok, bksp, caps; + + private int bmpSize; + + char[][] lowerCaseL = + { {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'}, + {'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r'}, + {'s', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'}, + {'1', '2', '3', '4', '5', '6', '7', '8', '9'} + }; + + char[][] upperCaseL = + { {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'}, + {'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R'}, + {'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0'}, + {'1', '2', '3', '4', '5', '6', '7', '8', '9'} + }; + + char[][] lowerCaseP = + { {'a', 'b', 'c', 'd', 'e', 'f'}, + {'g', 'h', 'i', 'j', 'k', 'l'}, + {'m', 'n', 'o', 'p', 'q', 'r'}, + {'s', 't', 'u', 'v', 'w', 'x'}, + {'y', 'z', '0', '1', '2', '3'}, + {'4', '5', '6', '7', '8', '9'} + }; + + char[][] upperCaseP = + { {'A', 'B', 'C', 'D', 'E', 'F'}, + {'G', 'H', 'I', 'J', 'K', 'L'}, + {'M', 'N', 'O', 'P', 'Q', 'R'}, + {'S', 'T', 'U', 'V', 'W', 'X'}, + {'Y', 'Z', '0', '1', '2', '3'}, + {'4', '5', '6', '7', '8', '9'} + }; + + private int width, height; + + private int textFieldWidth; + private int textFieldHeight; + private int textTopLeftX; + private int textTopLeftY; + private int keyWidth, keyHeight; + private int sKeyWidth, sKeyHeight; + + private VirtualKeyboardListener invoker; + + private int charH; + + private int backgroundColor = 0xffffffff; + private int buttonsColor = 0xff000000; + + private boolean uppercase; + private int minSize=0; + + public interface VirtualKeyboardListener + { + void okPressed(String string); + } + +//////////////////////////////////////////////////////////////////////////////// + + public TouchKeyboard(Context context, int scrWid, int scrHei) + { + super(context); + mPaint = new Paint(); + mPaint.setAntiAlias(true); + + currPressed = BUTTON_NONE; + width = scrWid; + height= scrHei; + + Resources res = context.getResources(); + + keyBlue = (NinePatchDrawable)res.getDrawable(R.drawable.keys_blue); + keyRed = (NinePatchDrawable)res.getDrawable(R.drawable.keys_red); + keyWhite= (NinePatchDrawable)res.getDrawable(R.drawable.keys_white); + + ok = BitmapFactory.decodeResource(res, R.drawable.ok ); + bksp= BitmapFactory.decodeResource(res, R.drawable.bksp); + caps= BitmapFactory.decodeResource(res, R.drawable.caps); + + if( width<=height ) + { + sKeyWidth = width/3; + sKeyHeight= width/5; + keyWidth = width/6; + keyHeight = (height-2*sKeyHeight)/6; + + textFieldHeight = height-sKeyHeight-6*keyHeight; + textFieldWidth = width; + textTopLeftX = 0; + textTopLeftY = sKeyHeight; + } + else + { + sKeyWidth = sKeyHeight = keyHeight = height/5; + keyWidth = (width+1)/9; + + textFieldHeight= sKeyHeight; + textFieldWidth = width-3*sKeyWidth; + textTopLeftX = sKeyWidth; + textTopLeftY = 0; + } + + bmpSize = ok.getHeight(); + + if( bmpSize> 0.8*sKeyHeight ) + { + bmpSize = (int)(0.8*sKeyHeight); + ok = Bitmap.createScaledBitmap(ok , bmpSize, bmpSize, true); + bksp = Bitmap.createScaledBitmap(bksp, bmpSize, bmpSize, true); + caps = Bitmap.createScaledBitmap(caps, bmpSize, bmpSize, true); + } + + textField = new TextFieldArea(); + charH= (int)(keyHeight*0.7); + uppercase = true; + } + +//////////////////////////////////////////////////////////////////////////////// + + public void resetKeyBoard() + { + textField.clearTextField(); + invalidate(); + } + +//////////////////////////////////////////////////////////////////////////////// + + protected void onDraw(Canvas c) + { + mPaint.setColor(backgroundColor); + mPaint.setStyle(Style.FILL); + mPaint.setTextSize(charH); + mPaint.setTextAlign(Align.CENTER); + + c.drawRect(0, 0, width, height, mPaint); + + mPaint.setColor(buttonsColor); + + textField.paint( c, textTopLeftX+1, textTopLeftY+MARGIN/2+1, textTopLeftX+textFieldWidth-1, textTopLeftY+textFieldHeight-MARGIN/2-1); + + if( currPressed==BUTTON_OK ) + { + keyRed.setBounds( MARGIN/2, MARGIN/2, sKeyWidth-MARGIN/2, sKeyHeight-MARGIN/2); + keyRed.draw(c); + } + else + { + keyBlue.setBounds( MARGIN/2, MARGIN/2,sKeyWidth-MARGIN/2, sKeyHeight-MARGIN/2); + keyBlue.draw(c); + } + + if( currPressed==BUTTON_BKSP ) + { + keyRed.setBounds( width-2*sKeyWidth+MARGIN/2, MARGIN/2, width-sKeyWidth-MARGIN/2,sKeyHeight-MARGIN/2); + keyRed.draw(c); + } + else + { + keyBlue.setBounds(width-2*sKeyWidth+MARGIN/2, MARGIN/2, width-sKeyWidth-MARGIN/2,sKeyHeight-MARGIN/2); + keyBlue.draw(c); + } + + if( currPressed==BUTTON_CAPS ) + { + keyRed.setBounds( width-sKeyWidth+MARGIN/2, MARGIN/2, width-MARGIN/2,sKeyHeight-MARGIN/2); + keyRed.draw(c); + } + else + { + keyBlue.setBounds(width-sKeyWidth+MARGIN/2, MARGIN/2, width-MARGIN/2,sKeyHeight-MARGIN/2); + keyBlue.draw(c); + } + + c.drawBitmap(ok , MARGIN/2+sKeyWidth/2-bmpSize/2, MARGIN/2+sKeyHeight/2-bmpSize/2, mPaint); + c.drawBitmap(bksp, width-2*sKeyWidth+MARGIN/2+sKeyWidth/2-bmpSize/2, MARGIN/2+sKeyHeight/2-bmpSize/2, mPaint); + c.drawBitmap(caps, width- sKeyWidth+MARGIN/2+sKeyWidth/2-bmpSize/2, MARGIN/2+sKeyHeight/2-bmpSize/2, mPaint); + + int hei = (width<=height ? textFieldHeight+sKeyHeight : textFieldHeight); + int numCol = (width<=height ? lowerCaseP[0].length : lowerCaseL[0].length); + int numRow = (width<=height ? lowerCaseP.length : lowerCaseL.length); + + for(int j=0; j=0 && y=sKeyHeight+textFieldHeight && y<=height ) + { + currPressed = (int)((y-sKeyHeight-textFieldHeight)/keyHeight)*lowerCaseP[0].length + x/keyWidth; + } + } + else + { + if( y>=0 && y=width-2*sKeyWidth && x<=width-sKeyWidth ) currPressed = BUTTON_BKSP; + else if( x>=width- sKeyWidth && x<=width ) currPressed = BUTTON_CAPS; + else currPressed = BUTTON_NONE; + } + else if( y>=textFieldHeight && y<=height) + { + currPressed = (int)((y-textFieldHeight)/keyHeight)*lowerCaseL[0].length + x/keyWidth; + } + } + } + +//////////////////////////////////////////////////////////////////////////////// + + private void buttonReleased() + { + if( currPressed==BUTTON_OK ) okButtonAction(); + else if( currPressed==BUTTON_BKSP ) bkspButtonAction(); + else if( currPressed==BUTTON_CAPS ) capsButtonAction(); + else if( currPressed>=0 ) charAreaAction(currPressed); + + currPressed = BUTTON_NONE; + } + +//////////////////////////////////////////////////////////////////////////////// + + @Override public boolean onKeyDown(int keyCode, KeyEvent event) + { + if( currPressed!=BUTTON_NONE ) return false; + /* + switch( keyCode ) + { + case Keypad.KEY_ALT : + case Keypad.KEY_SHIFT_RIGHT: + case Keypad.KEY_SHIFT_LEFT : currPressed= BUTTON_CAPS; invalidate(); break; + case Keypad.KEY_ENTER : currPressed= BUTTON_OK ; invalidate(); break; + case Keypad.KEY_DELETE : + case Keypad.KEY_BACKSPACE : currPressed= BUTTON_BKSP; invalidate(); break; + } + + if( key>='A' && key<='Z' ) { currPressed = key-'A' ; invalidate(); } + if( key>='a' && key<='z' ) { currPressed = key-'a' ; invalidate(); } + if( key>='0' && key<='9' ) { currPressed = 'z'-'a'+1+key-'0'; invalidate(); } + */ + return true; + } + +//////////////////////////////////////////////////////////////////////////////// + + @Override public boolean onKeyUp(int keyCode, KeyEvent event) + { + buttonReleased(); + return true; + } + +//////////////////////////////////////////////////////////////////////////////// + + private void capsButtonAction() + { + uppercase = !uppercase; + } + +//////////////////////////////////////////////////////////////////////////////// + + private void okButtonAction() + { + if ( invoker != null ) + { + String text = textField.getText(); + + if( text.length()>= minSize ) + invoker.okPressed(text); + } + } + +//////////////////////////////////////////////////////////////////////////////// + + private void bkspButtonAction() + { + textField.deleteLastChar(); + } + +//////////////////////////////////////////////////////////////////////////////// + + private void charAreaAction(int pressed) + { + int numCol = (width + + + diff --git a/distorted-sokoban/src/main/res/layout/grb.xml b/distorted-sokoban/src/main/res/layout/grb.xml new file mode 100644 index 0000000..b8f528a --- /dev/null +++ b/distorted-sokoban/src/main/res/layout/grb.xml @@ -0,0 +1,15 @@ + + + + diff --git a/distorted-sokoban/src/main/res/layout/splash.xml b/distorted-sokoban/src/main/res/layout/splash.xml new file mode 100644 index 0000000..18b6464 --- /dev/null +++ b/distorted-sokoban/src/main/res/layout/splash.xml @@ -0,0 +1,24 @@ + + + + + diff --git a/distorted-sokoban/src/main/res/values-ko/strings.xml b/distorted-sokoban/src/main/res/values-ko/strings.xml new file mode 100644 index 0000000..3796e9e --- /dev/null +++ b/distorted-sokoban/src/main/res/values-ko/strings.xml @@ -0,0 +1,70 @@ + + + 1 + Sokoban + ThreeDCell presents + 실행 에러!! + sokoban@koltunski.pl + 레벨 + 개발자: + 질문하기? + 베스트 스코어: + 세계 베스트 스코어: + 노란사각형의 상자를 파란색으로 표시된 곳으로 이동시키는 게임입니다. 상자를 밀수만 있고 당길 수는 없습니다.\n\n레벨을 만들 수도 있습니다. (옵션 -> 새로운 레벨 만들기) 그리고 다른사람이 만든 레벨을 플레이 할 수 있습니다. 즐거운 시간되세요! + 새 기록 + 온라인 등록? + 이동 + 초 + 완료 + 옵션 + 새 레벨 하기 + 새레벨 등록하기 + 먼저 + 이름을 선택하세요 + 등록됨 + 성공적으로 + Ok + 뒤로 + 예 + 아니오 + 나가기 + 완료 + 풀기 + 등록 + 나가기 + 다운로드 + 다운로드... + 도움말 + 기록 + 실패하였습니다 + 이미 존재합니다 + 다시 시도 해주세요 + 등록 + 이용권한이 없습니다 + 네트워크 사용에 + 명예의 전당 + 실패 + 레벨 다운로드 + 이름이 존재합니다 + 이름을 선택하세요 + 새 레벨 만들기 + 다운로드 실패 + 새 레벨 + 1개의 새 레벨 + 새로운 레벨 없음 + 다운로드됨 + 이제 풀어보세요 + (다른사람이 + 먼저 풀지 못한 레벨을 + 등록하세요) + 레벨 불일치: + 플레이어는 + 빈 자리에 위치해야 합니다 + 플레이 지역에 + 접속할 수 없습니다 + 찾을 수 없습니다 + 레벨이 이미 완료되었습니다 + 숫자가 + 일치하지 않습니다 + 스퀘어를 확인하세요 + diff --git a/distorted-sokoban/src/main/res/values/strings.xml b/distorted-sokoban/src/main/res/values/strings.xml new file mode 100644 index 0000000..cbe97d6 --- /dev/null +++ b/distorted-sokoban/src/main/res/values/strings.xml @@ -0,0 +1,70 @@ + + + 0 + Sokoban + ThreeDCell presents + Startup error!! + sokoban@koltunski.pl + Level + Author: + Questions? + Your best: + World\'s best: + Your goal is to move all the crates (yellow squares) to destination squares (marked with blue crosses). You can only push a crate, never pull it.\n\nYou can also create your own levels (go to Options -> Create New Level) and download levels created by others. Enjoy! + New Record + Submit it online? + moves + seconds + solved + Options + Solve New Level + Submit New Level + First you have to + choose your name + Submitted + successfully + Ok + Back + Yes + No + Exit + Done + Solve + Submit + Abort + Downloaded + Downloading... + Help + Records + Failed to submit + is already taken + Try again + Submitting + No permission + to use network + Leaderboard + Failed + Download Levels + Name taken + Choose name + Create New Level + Failed To Download + new levels + 1 new level + No new levels + downloaded + Now please solve it + (You wouldn\'t like + others to submit + unsolvable levels?) + Level incorrect: + Player needs to stand + on an empty square + Playing area + is disconnected + No crates found + Level is solved already + Number of crates does + not equal the number + of destination squares + diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..6826e61 --- /dev/null +++ b/gradle.properties @@ -0,0 +1,17 @@ +# Project-wide Gradle settings. +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app"s APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..81dc0dc --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Sat Jul 16 11:19:43 CEST 2022 +distributionBase=GRADLE_USER_HOME +distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip +distributionPath=wrapper/dists +zipStorePath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 0000000..ad1304a --- /dev/null +++ b/settings.gradle @@ -0,0 +1,2 @@ +rootProject.name = "Magic Sokoban" +include ':distorted-sokoban'