안 드 로 이 드 플랫폼 기반 퍼 즐 게임 실현

수요 설명
퍼 즐 은 퍼 즐 류 의 전형 적 인 게임 이다.본 게임 은 선배 들 의 경험 을 배 웠 다.전체적으로 보면 그림 을 자 르 는 도구 로 자 르 고 사용자 의 손가락 이 미 끄 러 지 는 사건 을 감청 했다.사용자 가 어 지 러 운 그림 에 대해 일정한 시간 안에 조합 하여 원래 의 모습 으로 회복 하면 성공 적 으로 관문 을 통과 했다.게임 의 서로 다른 관문 에 따라 그림 을 동적 으로 절단 합 니 다.유 저 는 임의로 두 장의 그림 을 교환 할 수 있 습 니 다.잘 라 낸 모든 그림 을 옮 겨 다 니 며 사용자 가 선택 한 그림 을 교체 할 수 있 습 니 다.
그 중의 주요 기능 은 다음 과 같다.
4.567917.동태 적 으로 그림 을 필요 한 부분 으로 절단 합 니 다

유저 가 임의로 클릭 한 두 장의 그림 은 정확하게 교환 할 수 있 습 니 다

4.567917.그림 을 교환 하 는 애니메이션 전환 효 과 를 실현 합 니 다4.567917.통관 논 리 를 실현 한다게임 시간 논리 적 통 제 를 실현 하 다게임 종료 와 일시 정지.
2.주요 기능 분석
퍼 즐 게임 개발 과정 에서 실현 되 는 주요 기능;사용자 에 게 사용 할 수 있 도록 제공 하고 구체 적 인 기능 분석 은 다음 과 같다.
1.절편 도 구 를 작성 합 니 다.퍼 즐 게임 은 완전한 그림 을 준비 해 야 하기 때문에 직관 적 으로 볼 때 우 리 는 매번 하나의 완전한 그림 을 분할 할 수 없습니다.만약 에 3*3 이 라면 9 조각,4*4 를 16 부 로 나 누 어야 합 니 다.이렇게 해서 가 져 온 그림 자원 의 큰 혼란 은 후기 유지 에 불리 합 니 다.그 다음 에 Andorid 는 특정한 그림 에 대한 컷 팅 도 구 를 실현 하 는 구체 적 인 방법 을 제공 했다.들 어 오 는 매개 변수 에 따라 그림 을 필요 한 행렬 로 나 누고 각 조각의 너비 와 높이 를 설정 했다.두 개의 for 순환 을 이용 하여 컷 팅 을 진행 합 니 다.각 그림 의 크기 위치 와 각 그림 의 블록 번호 아래 에 Index 를 표시 합 니 다.
2.사용자 정의 용기:상대 적 인 레이아웃 파일 을 사용자 정의 하여 절 단 된 그림 을 저장 하고 그림 사이 의 간격 을 설정 하 며 그림 의 상하 좌우 관 계 를 확인 합 니 다.그림 과 용기 의 안쪽 거 리 를 설정 합 니 다.
3.이미지 교환 실현:손가락 의 감청 사건 을 실현 하고 선택 한 두 장의 그림 을 위치 변환 합 니 다.
4.이미지 교환 을 실현 하 는 애니메이션 효과:구조 애니메이션 층,애니메이션 설정,감청 애니메이션
5.게임 통과 논리 실현:성공 적 인 판단,관문 의 반전.
6.게임 시간 논리 실현:게임 시간의 업데이트,그리고 Handler 의 끊 임 없 는 리 셋,시간 초과 후 게임 상태의 처리,그리고 성공 적 으로 관문 을 통과 한 후에 게임 시간의 변경.
7.게임 의 종료 와 일시 정지:사용자 가 홈 페이지 로 돌아 갈 때 게임 은 일시 정지 할 수 있 고 사용자 가 게임 으로 돌아 갈 때 게임 은 다시 시작 할 수 있 습 니 다.
개요 설계
1.**컷 팅 도구 류**ImagePiece 와 ImageSplitterUtil.그 중에서 ImagePiece 는 Bitmap 그림 의 블록 번호 와 각 그림 의 위치 에 속성 을 기본 으로 설정 합 니 다.컷 팅 도구 류 ImageSplitterUtil 에서 컷 팅 방법 splitImage 를 제공 합 니 다.들 어 오 는 Bitmap 그림 을 Piece*Piece 블록 으로 나 누고 각 폭 을 설정 하여 분할 한 그림 을 List 에 넣 습 니 다.
2.사용자 정의 뷰:GamePintuLayout.java 에서 사용 하 는 주요 도 구 는 다음 과 같 습 니 다.
단위 변환:들 어 오 는 수 치 를 단위 로 3PX 로 변환 하여 화면 을 식별 할 수 있 습 니 다.

//     
mMargin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
 3, getResources().getDisplayMetrics());

/*          */
 private int min(int... params) {
 int min = params[0];
 for (int param : params) {
  if (param < min)
  min = param;
 }
 return min;
 }

3.그림 난 서 의 실현:

//   sort        
Collections.sort(mItemBitmaps, new Comparator<ImagePiece>() {
  public int compare(ImagePiece a, ImagePiece b) {
  return Math.random() > 0.5 ? 1 : -1;
  }
 });

4.그림 의 교환:감청 이벤트 에서 사용자 가 두 장의 그림 을 선택 하면 그림 을 교환 하고 첫 번 째 로 선택 한 그림 을 스타일 로 설정 합 니 다.사용자 가 그림 한 장 을 반복 클릭 하면 그림 의 선택 상 태 를 제거 합 니 다.그림 에 설 정 된 태 그 를 통 해 Id 를 찾 은 다음 Bitmap 그림 의 index 를 찾 아 교환 과 동시에 태 그 를 교환 합 니 다.

String firstTag = (String) mFirst.getTag();
String secondTag = (String) mSecond.getTag();
mFirst.setImageBitmap(secondBitmap);
mSecond.setImageBitmap(firstBitmap);
mFirst.setTag(secondTag);
mSecond.setTag(firstTag);

5.이미지 애니메이션 전환:구조 애니메이션 층,mAnimLayout 와 addView 를 한 다음 에 exchangeView 에서 먼저 애니메이션 층 을 구성 하고 두 개의 ImageView 를 복사 하여 두 개의 ImageView 에 애니메이션 을 설정 하고 애니메이션 의 시작 을 감청 하 며 원래 의 View 를 숨 기 고 끝 난 후에 그림 을 교환 하여 그림 을 표시 하고 애니메이션 층 을 제거 합 니 다.
6.인 터 페 이 스 를 통 해 관문 을 리 셋 한다.관문 의 진급,시간 제어,게임 종료 인 터 페 이 스 를 실현 한다.또한 Handler 를 이용 하여 UI 를 업데이트 하고 nextLevel 방법 에서 이전의 View 레이아웃 을 제거 하고 애니메이션 층 을 비 워 두 고 mColumn++를 추가 한 다음 initBitmap()를 초기 화하 여 그림 의 너비 와 높이 를 다시 자 르 고 InitItem()을 설정 합 니 다.

public interface GamePintuListener {
 void nextLevel(int nextLevel);
 void timechanged(int currentTime);
 void gameover();
 }

public GamePintuListener mListener;
 /*
 *       
 */
public void setOnGamePintuListener(GamePintuListener mListener) {
 this.mListener = mListener;
 }

7.현재 레벨 에 따라 게임 시간 설정:mTime=(int)Math.pow(2,level)*60;더 나 아가 우리 핸들 러.mHandler.sendEmptyMessageDelayed(TIME_CHANGED,1000)시간 동 태 를 1 로 줄 입 니 다.
8.게임 일시 정지 시작:
mHandler.removeMessages(TIME_CHANGED);
게임 을 다시 시작 하 는 것 은 mHandler.sendEmpty Message(TIMECHANGED);
4.시스템 실현
도구 종류:

ImagePiece.java

ImageSplitterUtil.java

사용자 정의 용기:

GamePintuLayout.java

ImagePiece.java

package com.example.utils;
import android.graphics.Bitmap;
public class ImagePiece {

 private int index;//      
 private Bitmap bitmap;//       

 public ImagePiece()
 {
 }

 public ImagePiece(int index, Bitmap bitmap) {
 this.index = index;
 this.bitmap = bitmap;
 }

 public int getIndex() {
 return index;
 }

 public void setIndex(int index) {
 this.index = index;
 }

 public Bitmap getBitmap() {
 return bitmap;
 }

 public void setBitmap(Bitmap bitmap) {
 this.bitmap = bitmap;
 }

 public String toString() {
 return "ImagePiece [index=" + index + ", bitmap=" + bitmap + "]";
 }
}

ImageSplitterUtil.java

//ImageSplitterUtil.java
package com.example.utils;

import java.util.ArrayList;
import java.util.List;

import android.graphics.Bitmap;

public class ImageSplitterUtil {
 /*
 *   Bitmap  Piece*piece ，  List<ImagePiece>
 */
 public static List<ImagePiece> splitImage(Bitmap bitmap, int piece) {
 List<ImagePiece> imagePieces = new ArrayList<ImagePiece>();

 int width = bitmap.getWidth();
 int height = bitmap.getHeight();

 //       
 int pieceWidth = Math.min(width, height) / piece;

 for (int i = 0; i < piece; i++)//  
 {
  for (int j = 0; j < piece; j++)//  
  {
  ImagePiece imagePiece = new ImagePiece();
  imagePiece.setIndex(j + i * piece);

  int x = j * pieceWidth;
  int y = i * pieceWidth;
  imagePiece.setBitmap(Bitmap.createBitmap(bitmap, x, y,
   pieceWidth, pieceWidth));
  imagePieces.add(imagePiece);
  }
 }

 return imagePieces;
 }
}

GamePintuLayout.java

package com.example.game_pintu.view;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.os.Handler;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.TranslateAnimation;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.Toast;

import com.example.game_pintu.R;
import com.example.utils.ImagePiece;
import com.example.utils.ImageSplitterUtil;

public class GamePintuLayout extends RelativeLayout implements OnClickListener {

 private int mColumn = 3;
 /*
 *      
 */
 private int mPadding;
 /*
 *          （  ）dp
 */
 private int mMargin = 3;

 private ImageView[] mGamePintuItems;
 private int mItemWidth;

 /*
 *      
 */
 private Bitmap mBitmap;

 private List<ImagePiece> mItemBitmaps;
 private boolean once;
 /*
 *        
 */
 private int mWidth;
 private boolean isGameSuccess;
 private boolean isGameOver;

 public interface GamePintuListener {
 void nextLevel(int nextLevel);

 void timechanged(int currentTime);

 void gameover();
 }

 public GamePintuListener mListener;

 /*
 *       
 */
 public void setOnGamePintuListener(GamePintuListener mListener) {
 this.mListener = mListener;
 }

 private int level = 1;
 private static final int TIME_CHANGED = 0x110;
 private static final int NEXT_LEVEL = 0x111;

 private Handler mHandler = new Handler() {
 public void handleMessage(android.os.Message msg) {
  switch (msg.what) {
  case TIME_CHANGED:
  if(isGameSuccess||isGameOver||isPause)
   return;

  if(mListener !=null)
  {
   mListener.timechanged(mTime);
   if(mTime ==0)
   {
   isGameOver = true;
   mListener.gameover();
   return;
   }
  }
  mTime--;
  mHandler.sendEmptyMessageDelayed(TIME_CHANGED, 1000);

  break;
  case NEXT_LEVEL:
  level = level + 1;
  if (mListener != null) {
   mListener.nextLevel(level);
  } else {
   nextLevel();
  }
  break;

  default:
  break;
  }
 };
 };

 private boolean isTimeEnabled = false;
 private int mTime;
 /*
 *         
 */
 public void setTimeEnabled(boolean isTimeEnabled) {
 this.isTimeEnabled = isTimeEnabled;
 }

 public GamePintuLayout(Context context) {
 this(context, null);
 }

 public GamePintuLayout(Context context, AttributeSet attrs) {
 this(context, attrs, 0);

 }

 public GamePintuLayout(Context context, AttributeSet attrs, int defStyle) {
 super(context, attrs, defStyle);
 init();
 }

 private void init() {
 /*
  *      3--px
  */
 mMargin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
  3, getResources().getDisplayMetrics());
 mPadding = min(getPaddingLeft(), getPaddingRight(), getPaddingTop(),
  getPaddingBottom());

 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
 //         
 mWidth = Math.min(getMeasuredHeight(), getMeasuredWidth());

 if (!once) {
  //     ，    
  initBitmap();
  //   ImageView(Item)     
  initItem();

  //        
  checkTimeEnable();

  once = true;
 }
 setMeasuredDimension(mWidth, mWidth);
 }

 private void checkTimeEnable() {
 if(isTimeEnabled){
  //          
  contTimeBaseLevel();
  mHandler.sendEmptyMessage(TIME_CHANGED);
 }
 }

 private void contTimeBaseLevel() {
 mTime = (int)Math.pow(2, level)*60;
 }

 //     ，    
 private void initBitmap() {
 // TODO Auto-generated method stub
 if (mBitmap == null) {
  mBitmap = BitmapFactory.decodeResource(getResources(),
   R.drawable.image1);

 }
 mItemBitmaps = ImageSplitterUtil.splitImage(mBitmap, mColumn);
 //   sort        
 Collections.sort(mItemBitmaps, new Comparator<ImagePiece>() {
  public int compare(ImagePiece a, ImagePiece b) {
  return Math.random() > 0.5 ? 1 : -1;
  }
 });
 }

 //   ImageView(Item)     
 private void initItem() {
 mItemWidth = (mWidth - mPadding * 2 - mMargin * (mColumn - 1))
  / mColumn;
 mGamePintuItems = new ImageView[mColumn * mColumn];

 //   Item,   Rule;
 for (int i = 0; i < mGamePintuItems.length; i++) {
  ImageView item = new ImageView(getContext());
  item.setOnClickListener(this);

  item.setImageBitmap(mItemBitmaps.get(i).getBitmap());

  mGamePintuItems[i] = item;
  item.setId(i + 1);
  // item tag   index

  item.setTag(i + "_" + mItemBitmaps.get(i).getIndex());

  RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(
   mItemWidth, mItemWidth);

  //   item     ，  RightMargin
  //       
  if ((i + 1) % mColumn != 0) {
  lp.rightMargin = mMargin;
  }
  //      
  if (i % mColumn != 0) {
  lp.addRule(RelativeLayout.RIGHT_OF,
   mGamePintuItems[i - 1].getId());
  }
  //        ，  TopMargin and rule
  if ((i + 1) > mColumn) {
  lp.topMargin = mMargin;
  lp.addRule(RelativeLayout.BELOW,
   mGamePintuItems[i - mColumn].getId());
  }
  addView(item, lp);

 }
 }
 public void restart()
 {
 isGameOver = false;
 mColumn--;
 nextLevel();
 }
 private boolean isPause;
 public void pause()
 {
 isPause = true;
 mHandler.removeMessages(TIME_CHANGED);
 }
 public void resume()
 {
 if(isPause)
 {
  isPause = false;
  mHandler.sendEmptyMessage(TIME_CHANGED);
 }
 }
 public void nextLevel() {
 this.removeAllViews();
 mAnimLayout = null;
 mColumn++;
 isGameSuccess = false;
 checkTimeEnable();
 initBitmap();
 initItem();
 }

 /*
 *           
 */
 private int min(int... params) {
 int min = params[0];
 for (int param : params) {
  if (param < min)
  min = param;
 }
 return min;
 }

 private ImageView mFirst;
 private ImageView mSecond;

 public void onClick(View v) {

 if (isAniming)
  return;

 //        Item
 if (mFirst == v) {
  mFirst.setColorFilter(null);
  mFirst = null;
  return;
 }
 if (mFirst == null) {
  mFirst = (ImageView) v;
  mFirst.setColorFilter(Color.parseColor("#55FF0000"));
 } else {
  mSecond = (ImageView) v;
  //      Item
  exchangeView();
 }
 }

 /*
 *    
 */
 private RelativeLayout mAnimLayout;
 private boolean isAniming;

 /*
 *   Item
 */
 private void exchangeView() {
 mFirst.setColorFilter(null);
 //      
 setUpAnimLayout();

 ImageView first = new ImageView(getContext());
 final Bitmap firstBitmap = mItemBitmaps.get(
  getImageIdByTag((String) mFirst.getTag())).getBitmap();
 first.setImageBitmap(firstBitmap);
 LayoutParams lp = new LayoutParams(mItemWidth, mItemWidth);
 lp.leftMargin = mFirst.getLeft() - mPadding;
 lp.topMargin = mFirst.getTop() - mPadding;
 first.setLayoutParams(lp);
 mAnimLayout.addView(first);

 ImageView second = new ImageView(getContext());
 final Bitmap secondBitmap = mItemBitmaps.get(
  getImageIdByTag((String) mSecond.getTag())).getBitmap();
 second.setImageBitmap(secondBitmap);
 LayoutParams lp2 = new LayoutParams(mItemWidth, mItemWidth);
 lp2.leftMargin = mSecond.getLeft() - mPadding;
 lp2.topMargin = mSecond.getTop() - mPadding;
 second.setLayoutParams(lp2);
 mAnimLayout.addView(second);

 //     
 TranslateAnimation anim = new TranslateAnimation(0, mSecond.getLeft()
  - mFirst.getLeft(), 0, mSecond.getTop() - mFirst.getTop());
 anim.setDuration(300);
 anim.setFillAfter(true);
 first.startAnimation(anim);

 TranslateAnimation animSecond = new TranslateAnimation(0,
  -mSecond.getLeft() + mFirst.getLeft(), 0, -mSecond.getTop()
   + mFirst.getTop());
 animSecond.setDuration(300);
 animSecond.setFillAfter(true);
 second.startAnimation(animSecond);

 //     
 anim.setAnimationListener(new AnimationListener() {

  @Override
  public void onAnimationStart(Animation animation) {
  mFirst.setVisibility(View.INVISIBLE);
  mSecond.setVisibility(View.INVISIBLE);

  isAniming = true;
  }

  @Override
  public void onAnimationRepeat(Animation animation) {

  }

  @Override
  public void onAnimationEnd(Animation animation) {
  String firstTag = (String) mFirst.getTag();
  String secondTag = (String) mSecond.getTag();

  mFirst.setImageBitmap(secondBitmap);
  mSecond.setImageBitmap(firstBitmap);

  mFirst.setTag(secondTag);
  mSecond.setTag(firstTag);

  mFirst.setVisibility(View.VISIBLE);
  mSecond.setVisibility(View.VISIBLE);

  mFirst = mSecond = null;
  //           
  checkSuccess();
  isAniming = false;
  }

 });

 }

 private void checkSuccess() {
 boolean isSuccess = true;
 for (int i = 0; i < mGamePintuItems.length; i++) {
  ImageView imageView = mGamePintuItems[i];
  if (getImageIndexByTag((String) imageView.getTag()) != i) {
  isSuccess = false;
  }
 }
 if (isSuccess) {
  isGameSuccess = true;
  mHandler.removeMessages(TIME_CHANGED);

  Toast.makeText(getContext(), "Success, level up!",
   Toast.LENGTH_LONG).show();
  mHandler.sendEmptyMessage(NEXT_LEVEL);
 }
 }

 public int getImageIdByTag(String tag) {
 String[] split = tag.split("_");
 return Integer.parseInt(split[0]);
 }

 public int getImageIndexByTag(String tag) {
 String[] split = tag.split("_");
 return Integer.parseInt(split[1]);
 }

 /**
 *         
 */
 private void setUpAnimLayout() {
 if (mAnimLayout == null) {
  mAnimLayout = new RelativeLayout(getContext());
  addView(mAnimLayout);
 } else {
  mAnimLayout.removeAllViews();
 }
 }

}

MainActivity.java

package com.example.game_pintu;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.os.Bundle;
import android.widget.TextView;

import com.example.game_pintu.view.GamePintuLayout;
import com.example.game_pintu.view.GamePintuLayout.GamePintuListener;

public class MainActivity extends Activity {

 private GamePintuLayout mGamePintuLayout;
 private TextView mLevel;
 private TextView mTime;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 mTime = (TextView) findViewById(R.id.id_time);
 mLevel = (TextView) findViewById(R.id.id_level);
 mGamePintuLayout = (GamePintuLayout) findViewById(R.id.id_gamepintu);
 mGamePintuLayout.setTimeEnabled(true);
 mGamePintuLayout.setOnGamePintuListener(new GamePintuListener() {

  @Override
  public void timechanged(int currentTime) {
  mTime.setText("" + currentTime);
  }

  @Override
  public void nextLevel(final int nextLevel) {
  new AlertDialog.Builder(MainActivity.this)
   .setTitle("GAME INFO").setMessage("LEVEL UP!!!")
   .setPositiveButton("NEXT LEVEL", new OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog,
     int which) {
    mGamePintuLayout.nextLevel();
    mLevel.setText("" + nextLevel);
    }

   }).show();
  }

  @Override
  public void gameover() {
  new AlertDialog.Builder(MainActivity.this)
   .setTitle("GAME INFO").setMessage("GAME OVER!!!")
   .setPositiveButton("RESTART", new OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog,
     int which) {
    // mGamePintuLayout.nextLevel();
    mGamePintuLayout.restart();
    }

   }).setNegativeButton("QUIT", new OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog,
     int which) {
    finish();
    }
   }).show();
  }
 });
 }
 @Override
 protected void onPause() {
 super.onPause();
 mGamePintuLayout.pause();
 }
 @Override
 protected void onResume() {
 super.onResume();
 mGamePintuLayout.resume();
 }
}

activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 xmlns:tools="http://schemas.android.com/tools"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 tools:context="${relativePackage}.${activityClass}" >

 <com.example.game_pintu.view.GamePintuLayout
 android:id="@+id/id_gamepintu"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent"
 android:layout_centerInParent="true"
 android:padding="3dp" />

 <RelativeLayout
 android:layout_width="fill_parent"
 android:layout_height="wrap_content"
 android:layout_above="@id/id_gamepintu" >

 <TextView
  android:id="@+id/id_level"
  android:layout_width="40dp"
  android:layout_height="40dp"
  android:background="@drawable/textbg"
  android:gravity="center"
  android:padding="4dp"
  android:text="1"
  android:textColor="#EA7821"
  android:textSize="10sp"
  android:textStyle="bold" />

 <TextView
  android:id="@+id/id_time"
  android:layout_width="40dp"
  android:layout_height="40dp"
  android:layout_alignParentRight="true"
  android:background="@drawable/textbg"
  android:gravity="center"
  android:padding="4dp"
  android:text="50"
  android:textColor="#EA7821"
  android:textSize="10sp"
  android:textStyle="bold" />
 </RelativeLayout>
</RelativeLayout>

in drawable new textbg.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
 android:shape="oval" >
 <stroke
 android:width="2px"
 android:color="#1579DB"
 />
 <solid android:color="#B4CDE6"/>
</shape>

테스트
게임 시작

성공 하 다.

성공 진급

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.