Distorted Sokoban

package org.distorted.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<SokobanLevel> 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", "org.distorted.sokoban");

          flag = BitmapFactory.decodeResource(res, resID!=0 ? resID:R.drawable.unk);  	

          }

        catch( Exception ex )

          {

          flag=null;

          }

        }

  }

  private static Vector<Flag> 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 && i<mNumLevels ) return (SokobanLevel)mLevels.elementAt(i);

      return null;

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public Bitmap getFlag(String s)

  {

      if( s==null ) return null;

      int size = mFlags.size();

      Flag tmp;

      for(int i=0; i<size; i++)

        {

        tmp = (Flag)mFlags.elementAt(i);

        if( tmp.name.equals(s) ) return tmp.flag;

        }

      tmp = new Flag(s);

      mFlags.addElement(tmp);

      return tmp.flag;

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void updateMyRecords(String n)

  {

      SokobanLevel sl;

      int move;

      for(int i=0; i<mNumLevels; i++)

        {

        sl = (SokobanLevel)mLevels.elementAt(i);

        if( sl==null ) continue;

        move = sl.getMyMoves();

        if( move<SokobanDatabase.INVALID ) sl.setName(n);

        }

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void resetCurrTime()

  {

      stopTimer();

      currTime = 0;

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void setScrDimensions(int w, int h)

  {

	  if( scrWidth!=w || scrHeight!=h )

        {

		Log.e(TAG_LEVELS, "Correcting SokobanLevels images!");  

        scrWidth    = w;

        scrHeight   = h;

        mVertical   = (w<=h);

        levelHeight = (h-mGap)/3;

        if( levelHeight<120 ) levelHeight = 120;

        if( levelHeight>200 ) 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<mScrollSpeed ) mScrollPos = 0;

            else mScrollPos = mNumLevels*levelHeight-(scrHeight-mGap);

            mSpringing = false;

            mScrollSpeed = 0;

            }

          else

            {

        	     if( mScrollSpeed> 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<mScrollSpeed ) mScrollPos = 0;

            else mScrollPos = mNumLevels*levelHeight-scrWidth;

            mSpringing = false;

            mScrollSpeed = 0;

            }

          else

            {

        	     if( mScrollSpeed> 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.INTERSECT);

          for(int i=beg; i<=end; i++)

            {

            SokobanLevel sl = (SokobanLevel)mLevels.elementAt(i);

            height+=levelHeight;

            if( sl!=null && height+mGap/2+mGapO<scrHeight)

              {

              if( state!=SokobanCanvas.STATE_SUCD )

                sl.renderSmall(  c, height, i==clickedLevel);

              else

                sl.renderRecords(c, height );

              }

            }

          c.clipRect(0, 0, scrWidth, scrHeight, Region.Op.INTERSECT);

          }

        catch( ArrayIndexOutOfBoundsException aiofb ) { System.out.println("render1: level out of bounds??"); }

        if( begHeight>mGap/2-5 )

          {

          c.drawRect(0, mGap/2-5, scrWidth,begHeight, mPaint);

          }

        if( height+levelHeight<scrHeight-mGap/2-mGapO )

          {

          c.drawRect(0, height+levelHeight, scrWidth, scrHeight-mGap/2-mGapO, mPaint);

          }

        }

      else if( state==SokobanCanvas.STATE_PLAY ||

               state==SokobanCanvas.STATE_TIME ||

               state==SokobanCanvas.STATE_NEWR ||

               state==SokobanCanvas.STATE_NAME ||

               state==SokobanCanvas.STATE_EXIS ||

               state==SokobanCanvas.STATE_FAIL ||

               state==SokobanCanvas.STATE_RECO ||

               state==SokobanCanvas.STATE_SECU ||

               state==SokobanCanvas.STATE_SUBM  )

        {

        SokobanLevel sl;

        try

          {

          sl = (SokobanLevel)mLevels.elementAt(currLevel);

          }

        catch( ArrayIndexOutOfBoundsException aiofb ) { System.out.println("render2: level out of bounds??"); return; }

        sl.renderBig(c,0,mGap/2  );

        }

      else if( state==SokobanCanvas.STATE_CREA ||

               state==SokobanCanvas.STATE_CRED ||

               state==SokobanCanvas.STATE_CRES ||

               state==SokobanCanvas.STATE_SUBC  )

        {

        created.renderBig(c,0,mGap/2  );

        mPaint.setColor(COLOR_BLACK);

        c.drawRect(0, 0, scrWidth, 7, mPaint);

        }

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int stopTimer()

    {

    timerRunning = false;

    return timer!=null ? timer.stop() : -2;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void startTimer(int time)

    {

    currTime = time/10;

    timerRunning= true;

    timer = SokobanTimer.getInstance();

    timer.start(time);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int retClickedLevel(int x, int y)

  {

    int ret;

    if( mVertical ) ret =(y+mScrollPos-mGap/2)/levelHeight;

    else            ret =(x+mScrollPos       )/levelHeight;

    return ret>=mNumLevels ? mNumLevels-1:ret;

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static int getCurrLevel()

  {

    return currLevel;

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static int getCurrTime()

  {  

    return currTime;

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static int getCurrMoves()

  {

    return currMoves;

  }