Add-Game-Activity

app/build.gradle

@@ -1,8 +1,6 @@
 
 plugins {
     id 'com.android.application'
-    id 'kotlin-android'
-    id 'kotlin-android-extensions'
 
 }
 
@@ -74,7 +72,7 @@ dependencies {
     implementation 'com.sdsmdg.harjot:rotatingtext:1.0.2'
     implementation 'ch.halcyon:squareprogressbar:1.6.4'
     implementation 'com.github.chrisbanes:PhotoView:2.0.0'
-    implementation 'com.quickbirdstudios:opencv:4.5.2'
+//    implementation 'com.quickbirdstudios:opencv:4.5.2'
     implementation 'com.jakewharton.timber:timber:5.0.1'
     implementation 'com.itextpdf:itext7-core:7.1.8'
     implementation 'com.etebarian:meow-bottom-navigation:1.2.0'

app/release/output-metadata.json

@@ -0,0 +1,20 @@
+{
+  "version": 3,
+  "artifactType": {
+    "type": "APK",
+    "kind": "Directory"
+  },
+  "applicationId": "com.echo.colorize",
+  "variantName": "release",
+  "elements": [
+    {
+      "type": "SINGLE",
+      "filters": [],
+      "attributes": [],
+      "versionCode": 1,
+      "versionName": "1.0",
+      "outputFile": "app-release.apk"
+    }
+  ],
+  "elementType": "File"
+}

app/src/main/AndroidManifest.xml

@@ -8,6 +8,7 @@
     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"></uses-permission>
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.VIBRATE"></uses-permission>
     <uses-feature android:name="android.hardware.camera" android:required="true" />
 
 
@@ -57,6 +58,15 @@
             android:label="@string/app_name"
             android:theme="@style/Theme.MyApplication.NoActionBar">
         </activity>
+        <activity
+            android:name="com.echo.colorizeit.myganme.GameActivity"
+            android:exported="true"
+            android:label="@string/app_name"
+            android:theme="@style/Theme.MyApplication.NoActionBar"
+            android:screenOrientation="landscape"
+            android:configChanges="keyboardHidden|orientation">>
+
+        </activity>
         <meta-data
             android:name="preloaded_fonts"
             android:resource="@array/preloaded_fonts" />

app/src/main/java/com/echo/colorizeit/MainActivity.java

@@ -16,6 +16,7 @@ import com.example.myapplication.R;
 import com.echo.colorizeit.ui.a_image_upload_activity.ImageUploadViewActivity;
 import com.google.android.material.snackbar.Snackbar;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.navigation.NavController;
 import androidx.navigation.Navigation;
@@ -25,7 +26,6 @@ import androidx.appcompat.app.AppCompatActivity;
 
 import com.example.myapplication.databinding.ActivityMainBinding;
 
-import org.opencv.android.OpenCVLoader;
 
 import java.io.File;
 import java.io.FileOutputStream;
@@ -45,10 +45,10 @@ public class MainActivity extends AppCompatActivity {
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         makeFullScreen();
-        if (!OpenCVLoader.initDebug())
-            Log.e("OpenCv", "Unable to load OpenCV");
-        else
-            Log.d("OpenCv", "OpenCV loaded");
+//        if (!OpenCVLoader.initDebug())
+//            Log.e("OpenCv", "Unable to load OpenCV");
+//        else
+//            Log.d("OpenCv", "OpenCV loaded");
         binding = ActivityMainBinding.inflate(getLayoutInflater());
         setContentView(binding.getRoot());
         setSupportActionBar(binding.appBarMain.toolbar);
@@ -98,6 +98,7 @@ public class MainActivity extends AppCompatActivity {
 
 
 
+
 //        DrawerLayout drawer = binding.drawerLayout;
 //        NavigationView navigationView = binding.navView;
 //        // Passing each menu ID as a set of Ids because each

app/src/main/java/com/echo/colorizeit/myganme/Bird.java

@@ -0,0 +1,29 @@
+package com.echo.colorizeit.myganme;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+
+import com.example.myapplication.R;
+
+public class Bird extends RectHittableObject{
+    private Bitmap bird;
+    public Bird(int x, int y, int width, int height, Context context) {
+        super(x, y, width, height, context);
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        if(bird== null)
+            bird = BitmapFactory.decodeResource(getContext().getResources(), R.mipmap.bird2);
+        canvas.drawBitmap(bird, null, getBorder_rect(), null);
+
+    }
+
+    @Override
+    public Boolean checkHit(Rect rect) {
+        return false;
+    }
+}

app/src/main/java/com/echo/colorizeit/myganme/Box.java

@@ -0,0 +1,30 @@
+package com.echo.colorizeit.myganme;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+
+import com.example.myapplication.R;
+
+public class Box extends RectHittableObject {
+    private Bitmap obstacle;
+
+    public Box(int x, int y, int width, int height, Context context) {
+        super(x, y, width, height, context);
+
+
+    }
+
+
+    @Override
+    public void draw(Canvas canvas) {
+//        canvas.drawRect(getBorderRect(), getDefault_paint());
+
+        if(obstacle== null)
+            obstacle = BitmapFactory.decodeResource(getContext().getResources(), R.mipmap.obstacle);
+        canvas.drawBitmap(obstacle, null, getBorder_rect(), null);
+
+    }
+
+}

app/src/main/java/com/echo/colorizeit/myganme/Cloud.java

@@ -0,0 +1,29 @@
+package com.echo.colorizeit.myganme;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+
+import com.example.myapplication.R;
+
+public class Cloud extends RectHittableObject{
+    private Bitmap cloud;
+    public Cloud(int x, int y, int width, int height, Context context) {
+        super(x, y, width, height, context);
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+
+        if(cloud== null)
+            cloud = BitmapFactory.decodeResource(getContext().getResources(), R.mipmap.cloud);
+        canvas.drawBitmap(cloud, null, getBorder_rect(), null);
+
+    }
+    @Override
+    public Boolean checkHit(Rect rect) {
+        return false;
+    }
+}

app/src/main/java/com/echo/colorizeit/myganme/Drawable.java

@@ -0,0 +1,7 @@
+package com.echo.colorizeit.myganme;
+
+import android.graphics.Canvas;
+
+public interface Drawable {
+    void draw(Canvas canvas);
+}

app/src/main/java/com/echo/colorizeit/myganme/GameActivity.java

@@ -0,0 +1,45 @@
+package com.echo.colorizeit.myganme;
+
+import android.os.Bundle;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+public class GameActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        makeFullScreen();
+        super.onCreate(savedInstanceState);
+        GameView gameView = new GameView(this);
+//        getSupportActionBar().hide();
+        setContentView(gameView);
+//        gameView.setOnClickListener(new View.OnClickListener() {
+//            @Override
+//            public void onClick(View v) {
+//                Scene.player.startMoveUpY(6400);
+//            }
+//        });
+        gameView.setOnTouchListener(new View.OnTouchListener() {
+            @Override
+            public boolean onTouch(View v, MotionEvent event) {
+                Scene.player.startMoveUpY(6400);
+                return false;
+            }
+        });
+    }
+    public void makeFullScreen() {
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        finish();
+
+    }
+}

app/src/main/java/com/echo/colorizeit/myganme/GameView.java

@@ -0,0 +1,151 @@
+package com.echo.colorizeit.myganme;
+
+import static android.content.Context.VIBRATOR_SERVICE;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.os.Vibrator;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+
+public class GameView extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private SurfaceHolder holder;
+    private Boolean isDrawing;
+    private Canvas canvas;
+    private Paint string_paint;
+    private Paint string_paint1;
+    public static final int FPS = 100;
+    public static final int minDrawTime = 1000 / FPS;
+    private Scene scene;
+    public static Context context;
+    private ArrayList<Integer> FPS_data = new ArrayList<>();
+    private float mean_fps = 0;
+    private Boolean isHit = false;
+
+
+    public GameView(Context context) {
+        super(context);
+        this.context = context;
+        init();
+
+    }
+
+    private void init() {
+        holder = getHolder();//得到SurfaceHolder对象
+        holder.addCallback(this);//注册SurfaceHolder
+        setFocusable(true);
+        setFocusableInTouchMode(true);
+        this.setKeepScreenOn(true);//保持屏幕长亮
+        //画笔
+        string_paint = new Paint();
+        string_paint.setColor(Color.BLACK);
+        string_paint.setTextSize(50);
+
+        string_paint1 = new Paint();
+        string_paint1.setColor(Color.BLACK);
+        string_paint1.setTextSize(250);
+
+    }
+
+    @Override
+    public void surfaceCreated(@NonNull SurfaceHolder holder) {
+        isDrawing = true;
+        new Thread(this).start();
+        int ScreenWidth = Math.abs(holder.getSurfaceFrame().right - holder.getSurfaceFrame().left);
+        int ScreenHeight = Math.abs(holder.getSurfaceFrame().top - holder.getSurfaceFrame().bottom);
+        scene = new Scene(ScreenWidth, ScreenHeight);
+        Scene.init_game_object(context);
+        Scene.startMove();
+
+    }
+
+    @Override
+    public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
+    }
+
+    @Override
+    public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+        isDrawing = false;
+        canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
+        Scene.end();
+    }
+
+    @Override
+    public void run() {
+        Log.d("Draw Thread", "Draw Start");
+        long last_end = System.currentTimeMillis();
+        long last_start = System.currentTimeMillis();
+        while (isDrawing) {
+            long start = System.currentTimeMillis();
+            drawing(last_start, last_end);
+            long end = System.currentTimeMillis();
+            while (end - start < minDrawTime) {
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                end = System.currentTimeMillis();
+            }
+            last_end = end;
+            last_start = start;
+        }
+    }
+
+    private void drawing(long start, long end) {
+        try {
+            canvas = holder.lockCanvas();
+            if (canvas != null) {
+                canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
+                canvas.drawColor(Color.WHITE, PorterDuff.Mode.ADD);
+                int real_FPS = (int) (1000 / ((end - start) == 0 ? 1 : (end - start)));
+                FPS_data.add(real_FPS);
+                if (FPS_data.size() >= 5) {
+                    int sum = 0;
+                    for (int i : FPS_data) {
+                        sum += i;
+                    }
+                    mean_fps = sum / FPS_data.size();
+                    FPS_data.clear();
+                }
+                canvas.drawText("FPS: " + String.valueOf(mean_fps), 50, 50, string_paint);
+                canvas.drawText("Distance: " + String.valueOf((int) (Scene.distance / 100)), 450, 50, string_paint);
+                for (RectHittableObject o : Scene.rectHittableObjects) {
+                    o.draw(canvas);
+                    if (!o.equals(Scene.player))
+                        if (o.checkHit(Scene.player.getBorderRect())) {
+                            isHit = true;
+                            break;
+                        }
+                }
+                for (Drawable o : Scene.staticObject) {
+                    o.draw(canvas);
+                }
+                if(isHit){
+                    System.out.println("HIT!!!!!!!!!!!!!!!!");
+                    canvas.drawText("Game Over !" , (int) (Scene.screenWidth * 0.2), Scene.screenHeight/2, string_paint1);
+                    final Vibrator vibrator=(Vibrator)context.getSystemService(VIBRATOR_SERVICE);
+                    if(vibrator.hasVibrator())
+                        vibrator.vibrate(300);
+                    isHit = false;
+                    Scene.end();
+                    Scene.init_game_object(context);
+                    Scene.startMove();
+
+                }
+            }
+        } finally {
+            if (canvas != null) {
+                holder.unlockCanvasAndPost(canvas);
+            }
+        }
+    }
+}

app/src/main/java/com/echo/colorizeit/myganme/Ground.java

@@ -0,0 +1,24 @@
+package com.echo.colorizeit.myganme;
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+
+public class Ground implements Drawable{
+    private Paint paint;
+    public Ground() {
+        paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
+        paint.setStrokeWidth(10f);
+        paint.setColor(Color.GRAY);
+
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setStrokeJoin(Paint.Join.ROUND);
+        paint.setStrokeCap(Paint.Cap.ROUND);
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        canvas.drawLine(0,Scene.groundY, Scene.screenWidth, Scene.groundY, paint);
+    }
+
+}

app/src/main/java/com/echo/colorizeit/myganme/Hittable.java

@@ -0,0 +1,11 @@
+package com.echo.colorizeit.myganme;
+
+import android.graphics.Point;
+import android.graphics.Rect;
+
+public interface Hittable {
+    Rect getBorderRect();
+    Boolean checkHit(Rect rect);
+    Boolean checkHit(int left, int top, int right, int bottom);
+    Boolean checkHit(Point left_up, Point left_bottom, Point right_up, Point right_bottom);
+}

app/src/main/java/com/echo/colorizeit/myganme/Movable.java

@@ -0,0 +1,10 @@
+package com.echo.colorizeit.myganme;
+
+public interface Movable {
+    void setLocation(int x, int y);
+    void moveX(int distance);
+    void moveY(int distance);
+    void startMoveLeftX(int speed);
+    void startMoveUpY(int speed);
+    void startMoveXY(int speedX, int speedY);
+}

app/src/main/java/com/echo/colorizeit/myganme/Player.java

@@ -0,0 +1,83 @@
+package com.echo.colorizeit.myganme;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+
+import com.example.myapplication.R;
+
+public class Player extends RectHittableObject {
+    public static final int playerWidth = 150;
+    public static final int playerHeight= 150;
+    public static final float g = 9.8f;
+    private static Thread thread;
+    private static Boolean isJumping = false;
+    private Bitmap player_image;
+
+
+    public Player(int x, int y, int width, int height, Context context) {
+        super(x, y, width, height, context);
+
+    }
+
+    @Override
+    public void startMoveUpY(int speed) {
+        if(!isJumping) {
+            isJumping = true;
+            long start_time = System.currentTimeMillis();
+            thread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    double h = 0;
+                    long t = 0;
+                    while (h >= 0) {
+                        long start = System.currentTimeMillis();
+                        long current_time = System.currentTimeMillis();
+                        t = (current_time - start_time);
+                        h = (speed * t - 0.5 * g * t * t) / 10000;
+                        setLocation(getX(), (int) (Scene.groundY - Player.playerHeight - h));
+                        long end = System.currentTimeMillis();
+                        while (end - start < GameView.minDrawTime) {
+                            try {
+                                Thread.sleep(1);
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                            }
+                            end = System.currentTimeMillis();
+                        }
+                    }
+                    setLocation(getX(), Scene.groundY - Player.playerHeight);
+                    System.out.println(getBorder_rect());
+                    isJumping = false;
+
+                }
+            });
+            thread.start();
+        }
+    }
+
+    @Override
+    public void startMoveLeftX(int speed) {
+        //stop x move
+    }
+
+    @Override
+    public void setX(int x) {
+
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+
+        Paint paint = getDefault_paint();
+        paint.setColor(Color.BLUE);
+//        canvas.drawRect(getBorderRect(), paint);
+        if(player_image==null)
+            player_image = BitmapFactory.decodeResource(getContext().getResources(), R.mipmap.player);
+        canvas.drawBitmap(player_image,null,getBorder_rect(),null);
+    }
+
+}

app/src/main/java/com/echo/colorizeit/myganme/RectHittableObject.java

@@ -0,0 +1,305 @@
+package com.echo.colorizeit.myganme;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Point;
+import android.graphics.Rect;
+
+public abstract class RectHittableObject implements Hittable, Movable, Drawable {
+    private int x;
+    private int y;
+    private int width;
+    private int height;
+    private Point left_up;
+    private Point left_bottom;
+    private Point right_up;
+    private Point right_bottom;
+    private Rect border_rect;
+    private Boolean moveStarted = false;
+    private Paint default_paint;
+    private Context context;
+    private Thread thread;
+    private Boolean blocking = false;
+
+
+    public RectHittableObject(int x, int y, int width, int height, Context context) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.context = context;
+        left_up = new Point(x, y);
+        left_bottom = new Point(x, y + height);
+        right_up = new Point(x + width, y);
+        right_bottom = new Point(x + width, y + height);
+        border_rect = new Rect(x, y, x + width, y + height);
+
+        default_paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
+        default_paint.setStrokeWidth(10f);
+        default_paint.setColor(Color.parseColor("#FF4081"));
+        default_paint.setStyle(Paint.Style.STROKE);
+        default_paint.setStrokeJoin(Paint.Join.ROUND);
+        default_paint.setStrokeCap(Paint.Cap.ROUND);
+    }
+
+    public RectHittableObject(Point left_up, Point left_bottom, Point right_up, Point right_bottom, Context context) {
+        this.left_up = left_up;
+        this.left_bottom = left_bottom;
+        this.right_up = right_up;
+        this.right_bottom = right_bottom;
+        this.context = context;
+        x = left_up.x;
+        y = left_up.y;
+        width = Math.abs(left_up.x - right_up.x);
+        height = Math.abs(left_up.y - left_bottom.y);
+        border_rect = new Rect(x, y, x + width, y + height);
+
+        default_paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
+        default_paint.setStrokeWidth(10f);
+        default_paint.setColor(Color.parseColor("#FF4081"));
+        default_paint.setStyle(Paint.Style.STROKE);
+        default_paint.setStrokeJoin(Paint.Join.ROUND);
+        default_paint.setStrokeCap(Paint.Cap.ROUND);
+    }
+
+    public Context getContext() {
+        return context;
+    }
+
+    public void setContext(Context context) {
+        this.context = context;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public void setWidth(int width) {
+        this.width = width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public void setHeight(int height) {
+        this.height = height;
+    }
+
+    public Point getLeft_up() {
+        return left_up;
+    }
+
+    public void setLeft_up(Point left_up) {
+        this.left_up = left_up;
+    }
+
+    public Point getLeft_bottom() {
+        return left_bottom;
+    }
+
+    public void setLeft_bottom(Point left_bottom) {
+        this.left_bottom = left_bottom;
+    }
+
+    public Point getRight_up() {
+        return right_up;
+    }
+
+    public void setRight_up(Point right_up) {
+        this.right_up = right_up;
+    }
+
+    public Point getRight_bottom() {
+        return right_bottom;
+    }
+
+    public void setRight_bottom(Point right_bottom) {
+        this.right_bottom = right_bottom;
+    }
+
+    public Rect getBorder_rect() {
+        return border_rect;
+    }
+
+    public void setBorder_rect(Rect border_rect) {
+        this.border_rect = border_rect;
+    }
+
+    public void setMoveStarted(Boolean moveStarted) {
+        this.moveStarted = moveStarted;
+    }
+
+    public Paint getDefault_paint() {
+        return default_paint;
+    }
+
+    public void setDefault_paint(Paint default_paint) {
+        this.default_paint = default_paint;
+    }
+
+    @Override
+    public Rect getBorderRect() {
+        return border_rect;
+    }
+
+    @Override
+    public Boolean checkHit(Rect rect) {
+        return getBorderRect().intersect(rect);
+    }
+
+    @Override
+    public Boolean checkHit(int left, int top, int right, int bottom) {
+        return getBorderRect().intersect(new Rect(left, top, right, bottom));
+    }
+
+    @Override
+    public Boolean checkHit(Point left_up, Point left_bottom, Point right_up, Point right_bottom) {
+        return getBorderRect().intersect(new Rect(left_up.x, left_up.y, right_up.x, right_bottom.y));
+    }
+
+    @Override
+    public void setLocation(int x, int y) {
+        this.x = x;
+        this.y = y;
+        left_up = new Point(x, y);
+        left_bottom = new Point(x, y + height);
+        right_up = new Point(x + width, y);
+        right_bottom = new Point(x + width, y + height);
+        border_rect = new Rect(x, y, x + width, y + height);
+    }
+
+    @Override
+    public void moveX(int distance) {
+        this.x = this.x + distance;
+        left_up = new Point(x, y);
+        left_bottom = new Point(x, y + height);
+        right_up = new Point(x + width, y);
+        right_bottom = new Point(x + width, y + height);
+        border_rect = new Rect(x, y, x + width, y + height);
+    }
+
+    @Override
+    public void moveY(int distance) {
+        this.y = this.y + distance;
+        left_up = new Point(x, y);
+        left_bottom = new Point(x, y + height);
+        right_up = new Point(x + width, y);
+        right_bottom = new Point(x + width, y + height);
+        border_rect = new Rect(x, y, x + width, y + height);
+    }
+
+    @Override
+    public void startMoveLeftX(int speed) {
+        thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (x > 0 - Scene.screenWidth && x < Scene.screenWidth && Scene.running) {
+                    long start = System.currentTimeMillis();
+                    x = x - speed / GameView.FPS;
+                    setLocation(x, y);
+                    long end = System.currentTimeMillis();
+                    while (end - start < GameView.minDrawTime) {
+                        try {
+                            Thread.sleep(1);
+                        } catch (InterruptedException e) {
+                            //e.printStackTrace();
+                        }
+                        end = System.currentTimeMillis();
+                    }
+                }
+            }
+        });
+        thread.start();
+        moveStarted = true;
+    }
+
+    @Override
+    public void startMoveUpY(int speed) {
+        thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (y > 0 - Scene.screenHeight && y < Scene.screenHeight && Scene.running) {
+                    long start = System.currentTimeMillis();
+                    y = y - speed / GameView.FPS;
+                    setLocation(x, y);
+                    long end = System.currentTimeMillis();
+                    while (end - start < GameView.minDrawTime) {
+                        try {
+                            Thread.sleep(1);
+                        } catch (InterruptedException e) {
+                            //e.printStackTrace();
+                        }
+                        end = System.currentTimeMillis();
+                    }
+                }
+            }
+        });
+        thread.start();
+        moveStarted = true;
+    }
+
+    @Override
+    public void startMoveXY(int speedX, int speedY) {
+        thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while ((y > 0 - Scene.screenHeight || x > 0 - Scene.screenWidth) && (y < Scene.screenHeight || x < Scene.screenWidth)) {
+                    long start = System.currentTimeMillis();
+                    y = y - speedY / GameView.FPS;
+                    x = x - speedX / GameView.FPS;
+                    setLocation(x, y);
+                    long end = System.currentTimeMillis();
+                    while (end - start < GameView.minDrawTime) {
+                        try {
+                            Thread.sleep(1);
+                        } catch (InterruptedException e) {
+                            //e.printStackTrace();
+                        }
+                        end = System.currentTimeMillis();
+                    }
+                }
+            }
+        });
+        thread.start();
+        moveStarted = true;
+    }
+
+    public Boolean getMoveStarted() {
+        return moveStarted;
+    }
+
+
+    public Thread getThread() {
+        return thread;
+    }
+
+    public void setThread(Thread thread) {
+        this.thread = thread;
+    }
+
+    public Boolean getBlocking() {
+        return blocking;
+    }
+
+    public void setBlocking(Boolean blocking) {
+        this.blocking = blocking;
+    }
+}

app/src/main/java/com/echo/colorizeit/myganme/Scene.java

@@ -0,0 +1,106 @@
+package com.echo.colorizeit.myganme;
+
+import android.content.Context;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class Scene {
+    private static int speed = 420;
+    public static int distance = 0; //from right of the screen
+    public static int screenWidth;
+    public static int screenHeight;
+    public static int groundY;
+    public static ArrayList<Drawable> staticObject = new ArrayList<>();
+    public static ArrayList<RectHittableObject> rectHittableObjects = new ArrayList<>();
+    public static Boolean running = true;
+    private static ArrayList<Thread> threads = new ArrayList<>();
+    public static Player player;
+
+
+
+    public Scene(int screenWidth, int screenHeight) {
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+        groundY = (int) (screenHeight * 0.8);
+    }
+
+    public static void startMove(){
+        Log.d("Scene","startMove");
+        running = true;
+        distance = 0;
+        Thread thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while(running){
+                    long start = System.currentTimeMillis();
+                    distance += speed/GameView.FPS;
+//                    Log.d("Scene","Distance:" + distance);
+                    for(RectHittableObject o: rectHittableObjects){
+                        if(o.getX() - distance < screenWidth && !o.getMoveStarted()){
+                            o.setX(o.getX() - distance);
+                            o.startMoveLeftX(speed);
+                        }
+                    }
+                    long end = System.currentTimeMillis();
+                    while(end - start < GameView.minDrawTime){
+                        try {
+                            Thread.sleep(1);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                        end = System.currentTimeMillis();
+                    }
+                }
+
+            }
+        });
+        threads.add(thread);
+        thread.start();
+    }
+
+    public static void init_game_object(Context context){
+        Random random = new Random();
+        if(rectHittableObjects != null)
+            rectHittableObjects.clear();
+        staticObject.add(new Ground());
+        System.out.println(rectHittableObjects.size());
+        player = new Player(300,groundY - Player.playerHeight, Player.playerWidth, Player.playerHeight,context);
+        rectHittableObjects.add(player);
+        for(int i = 5; i < 100; i++){
+            rectHittableObjects.add(new Box(i * 800 + random.nextInt(500),Scene.groundY - 100, 100,100,context));
+        }
+        for(int i = 2; i < 100; i++){
+            rectHittableObjects.add(new Cloud(i * 800 + random.nextInt(400), 300, 150,100,context));
+            rectHittableObjects.add(new Cloud(i * 1000 + random.nextInt(800), 100, 150,100,context));
+            rectHittableObjects.add(new Bird(i * 900 + random.nextInt(800), 200, 100,100,context));
+        }
+
+
+    }
+
+    public static void end(){
+        running = false;
+        for(RectHittableObject o: rectHittableObjects){
+            Thread thread = o.getThread();
+            if(thread != null) {
+                try {
+                    thread.join();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        for(Thread t: threads){
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        rectHittableObjects.clear();
+
+    }
+
+}

app/src/main/java/com/echo/colorizeit/ui/a_image_upload_activity/ImageUploadViewActivity.java

@@ -22,6 +22,7 @@ import androidx.lifecycle.ViewModelProvider;
 import androidx.navigation.ui.AppBarConfiguration;
 
 import com.echo.colorizeit.Util;
+import com.echo.colorizeit.myganme.GameActivity;
 import com.echo.colorizeit.ui.BaseActivity;
 import com.echo.colorizeit.ImageUtil.PhotoLib;
 import com.echo.colorizeit.Interfaces.RequestsListener;
@@ -39,7 +40,6 @@ public class ImageUploadViewActivity extends BaseActivity {
     private ImageUploadViewActivity _this = this;
 
 
-
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -62,19 +62,25 @@ public class ImageUploadViewActivity extends BaseActivity {
 //            }
 //        });
         model.setImageViewDataByPath(intent.getStringExtra("sourceFilePath"));
-
+        binding.imageProcessingAnimation.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Intent intent = new Intent(_this, GameActivity.class);
+                startActivity(intent);
+            }
+        });
         colorize_image();
         binding.CompareButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                if(model.getImageViewData().getValue() == model.getSourceImageBitmap()){
+                if (model.getImageViewData().getValue() == model.getSourceImageBitmap()) {
                     model.setImageViewDataByBitmap(model.getColorizedImageBitmap());
                     binding.uploadFinishAnimationView.playAnimation();
-                }
-                else{
+                } else {
                     model.setImageViewDataByBitmap(model.getSourceImageBitmap());
                 }
-            }});
+            }
+        });
 
         binding.SaveImageButton.setOnClickListener(new View.OnClickListener() {
             @Override
@@ -162,7 +168,7 @@ public class ImageUploadViewActivity extends BaseActivity {
                 final Dialog dialog = new Dialog(_this, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
 
 
-                ImageView imgView =  new ImageView(_this);
+                ImageView imgView = new ImageView(_this);
                 imgView.setImageBitmap((Bitmap) model.getImageViewData().getValue());
                 dialog.setContentView(imgView);
                 dialog.show();
@@ -294,7 +300,6 @@ public class ImageUploadViewActivity extends BaseActivity {
     }
 
 
-
     public void makeFullScreen() {
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

app/src/main/java/com/echo/colorizeit/ui/f_main_index_page_view/MainIndexPageFragment.java

@@ -28,6 +28,7 @@ import androidx.lifecycle.ViewModelProvider;
 
 import com.echo.colorizeit.ImageUtil.GlideEngine;
 import com.echo.colorizeit.Util;
+import com.echo.colorizeit.myganme.GameActivity;
 import com.echo.colorizeit.ui.BaseFragment;
 import com.echo.colorizeit.ui.a_image_upload_activity.ImageUploadViewActivity;
 import com.echo.colorizeit.ui.v_others.ResizableImageView;
@@ -172,6 +173,14 @@ public class MainIndexPageFragment extends BaseFragment {
             }
         });
 
+        binding.wellComeView.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Intent intent = new Intent(getActivity(), GameActivity.class);
+                startActivity(intent);
+            }
+        });
+
 
         return root;
     }