From 9c43b1f41c52098d68a48c3a3d46bd8397c0cf91 Mon Sep 17 00:00:00 2001
From: hyb1996 <946994919@qq.com>
Date: Sat, 24 Mar 2018 13:37:10 +0800
Subject: [PATCH] opt: API of canvas

---
 .../main/assets/sample/画布/贪吃蛇美化版.js   | 188 ++++++++++++++++++
 .../{Canvas.java => ScriptCanvas.java}        |  20 +-
 .../core/graphics/ScriptCanvasView.java       |  33 ++-
 3 files changed, 232 insertions(+), 9 deletions(-)
 create mode 100644 app/src/main/assets/sample/画布/贪吃蛇美化版.js
 rename autojs/src/main/java/com/stardust/autojs/core/graphics/{Canvas.java => ScriptCanvas.java} (97%)

diff --git a/app/src/main/assets/sample/画布/贪吃蛇美化版.js b/app/src/main/assets/sample/画布/贪吃蛇美化版.js
new file mode 100644
index 00000000..0210fe5e
--- /dev/null
+++ b/app/src/main/assets/sample/画布/贪吃蛇美化版.js
@@ -0,0 +1,188 @@
+"ui";
+
+ui.layout(
+    <vertical>
+        <canvas id="board" layout_weight="1"/>
+        <relative h="120">
+            <button id="up" text="↑" w="60" h="60" layout_alignParentTop="true" layout_centerHorizontal="true"/>
+            <button id="left" text="←" w="60" h="60" layout_alignParentBottom="true" layout_toLeftOf="@id/down"/>
+            <button id="down" text="↓" w="60" h="60" layout_alignParentBottom="true" layout_centerHorizontal="true"/>
+            <button id="right" text="→" w="60" h="60" layout_alignParentBottom="true" layout_toRightOf="@id/down"/>
+        </relative>
+    </vertical>
+);
+
+//蛇的颜色
+const SNAKE_COLOR = colors.parseColor("#9EDBB0");
+//背景色
+const BG_COLOR = colors.parseColor("#ffffff");
+//苹果颜色
+const APPLE_COLOR = colors.parseColor("#f44336");
+//墙的颜色
+const WALL_COLOR = colors.parseColor("#607d8b");
+//文本颜色
+const TEXT_COLOR =  colors.parseColor("#03a9f4");
+//蛇头图片
+const SNAKE_HEAD = images.fromBase64("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");
+
+//蛇自动移动的时间间隔，调小可以增加难度
+const MOVE_INTERVAL = 500;
+//方块宽度
+const BLOCK_WIDTH = 40;
+//游戏区域宽高
+const GAME_BORAD_HEIGHT = 20;
+const GAME_BORAD_WIDTH = 15;
+
+//蛇的四个移动方向
+const DIRECTION_LFET = {x: -1, y: 0};
+const DIRECTION_RIGHT = {x: 1, y: 0};
+const DIRECTION_UP = {x: 0, y: -1};
+const DIRECTION_DOWN = {x: 0, y: 1};
+
+//蛇，是一个蛇身的坐标的数组
+var snake = [{x: 4, y: 2}, {x: 3, y: 2}, {x: 2, y: 2}];
+//苹果的坐标
+var apple = generateApple();
+//当前蛇的移动方向
+var direction = DIRECTION_RIGHT;
+//标记游戏是否结束
+var isGameOver = false;
+//分数
+var score = 0;
+
+var paint = new Paint();
+ui.board.on("draw", function(canvas){
+    //绘制背景色
+    canvas.drawColor(BG_COLOR);
+    //绘制分数
+    paint.setColor(TEXT_COLOR);
+    paint.setTextSize(50);
+    canvas.drawText("分数: " + score, 30, 70, paint);
+    //如果游戏结束则绘制游戏结束字样
+    if(isGameOver){
+        canvas.drawText("游戏结束！", canvas.getWidth() - 280, 70, paint);
+    }
+    //计算坐标偏移，是的游戏区域绘制在画面的水平居中位置
+    var offset = {
+        x: (canvas.getWidth() - (GAME_BORAD_WIDTH + 2) * BLOCK_WIDTH) / 2,
+        y: 100
+    };
+    //偏移坐标
+    canvas.translate(offset.x, offset.y);
+    //绘制围墙
+    paint.setColor(WALL_COLOR);
+    for(var i = 0; i <= GAME_BORAD_WIDTH + 1; i++){
+        //上围墙
+        drawBlock(canvas, paint, i, 0);
+        //下围墙
+        drawBlock(canvas, paint, i, GAME_BORAD_HEIGHT + 1);
+    }
+    for(var i = 0; i <= GAME_BORAD_HEIGHT + 1; i++){
+        //左围墙
+        drawBlock(canvas, paint, 0, i);
+        //右围墙
+        drawBlock(canvas, paint, GAME_BORAD_WIDTH + 1, i);
+    }
+    //绘制蛇头
+    canvas.drawImage(SNAKE_HEAD, x * BLOCK_WIDTH, y * BLOCK_WIDTH, paint);
+    //绘制蛇身
+    paint.setColor(SNAKE_COLOR);
+    for(var i = 1; i < snake.length; i++){
+        drawBlock(canvas, paint, snake[i].x, snake[i].y);
+    }
+    //绘制苹果
+    paint.setColor(APPLE_COLOR);
+    drawBlock(canvas, paint, apple.x, apple.y);
+});
+
+//启动游戏线程
+var gameThread = threads.start(game);
+
+//按键点击时改变蛇的移动方向
+ui.left.on("click", ()=> direction = DIRECTION_LFET);
+ui.right.on("click", ()=> direction = DIRECTION_RIGHT);
+ui.up.on("click", ()=> direction = DIRECTION_UP);
+ui.down.on("click", ()=> direction = DIRECTION_DOWN);
+
+
+function game(){
+    //每隔一段时间让蛇自动前进
+    setInterval(()=>{
+        move(direction.x, direction.y);
+    }, MOVE_INTERVAL);
+}
+
+function move(dx, dy){
+    log("move: %d, %d", dx, dy);
+    direction.x = dx;
+    direction.y = dy;
+    //蛇前进时把一个新的方块添加到蛇头前面
+    var head = snake[0];
+    snake.splice(0, 0, {
+        x: head.x + dx,
+        y: head.y + dy
+    });
+    //如果蛇头吃到了苹果
+    if(snakeEatsApple()){
+        //添加分数和重新生成苹果
+        score += 5;
+        apple = generateApple();
+    }else{
+        //没有吃到苹果的情况下把蛇尾去掉保持蛇身长度不变
+        snake.pop();
+    }
+    //碰撞检测
+    collisionTest();
+}
+
+function snakeEatsApple(){
+    return snake[0].x == apple.x && snake[0].y == apple.y;
+}
+
+function generateApple(){
+    //循环生成苹果直至苹果不会生成在蛇身上
+    var x, y;
+    do{
+        x = random(1, GAME_BORAD_WIDTH);
+        y = random(1, GAME_BORAD_HEIGHT);
+    }while(!isAppleValid(x, y));
+    log("generateApple: ", {x: x, y: y});
+    return {x: x, y: y};
+}
+
+function isAppleValid(x, y){
+    for (var i = 0; i < snake.length; i++) {
+        if (snake[i].x == x && snake[i].y == y) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function collisionTest(){
+    //检测蛇有没有撞到墙上
+    var head = snake[0];
+    if(head.x < 1 || head.x > GAME_BORAD_WIDTH
+        || head.y < 1 || head.y > GAME_BORAD_HEIGHT){
+            gameOver();
+            return;
+    }
+    //检测蛇有没有撞到自己
+    for(var i = 1; i < snake.length; i++){
+        if(snake[i].x == head && snake[i].y == head){
+            gameOver();
+            return;
+        }
+    }
+}
+
+function gameOver(){
+    gameThread.interrupt();
+    isGameOver = true;
+}
+
+function drawBlock(canvas, paint, x, y){
+    x *= BLOCK_WIDTH;
+    y *= BLOCK_WIDTH;
+    canvas.drawRect(x, y, x + BLOCK_WIDTH, y + BLOCK_WIDTH, paint);
+}
\ No newline at end of file
diff --git a/autojs/src/main/java/com/stardust/autojs/core/graphics/Canvas.java b/autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvas.java
similarity index 97%
rename from autojs/src/main/java/com/stardust/autojs/core/graphics/Canvas.java
rename to autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvas.java
index f305f111..495553de 100644
--- a/autojs/src/main/java/com/stardust/autojs/core/graphics/Canvas.java
+++ b/autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvas.java
@@ -1,6 +1,7 @@
 package com.stardust.autojs.core.graphics;
 
 import android.graphics.Bitmap;
+import android.graphics.Canvas;
 import android.graphics.DrawFilter;
 import android.graphics.Matrix;
 import android.graphics.Paint;
@@ -17,28 +18,35 @@ import android.support.annotation.RequiresApi;
 
 import com.stardust.autojs.core.image.ImageWrapper;
 import com.stardust.autojs.runtime.ScriptRuntime;
-import com.stardust.autojs.runtime.exception.ScriptException;
 
 /**
  * Created by Stardust on 2018/3/22.
  */
 
-public class Canvas {
+public class ScriptCanvas {
 
-    private final android.graphics.Canvas mCanvas;
+    private android.graphics.Canvas mCanvas;
 
-    public Canvas(android.graphics.Canvas canvas) {
+    public ScriptCanvas(android.graphics.Canvas canvas) {
         mCanvas = canvas;
     }
 
-    public Canvas(@NonNull Bitmap bitmap) {
+    public ScriptCanvas(@NonNull Bitmap bitmap) {
         mCanvas = new android.graphics.Canvas(bitmap);
     }
 
-    public Canvas(@NonNull ImageWrapper image) {
+    public ScriptCanvas(@NonNull ImageWrapper image) {
         this(image.getBitmap());
     }
 
+    public ScriptCanvas() {
+
+    }
+
+    void setCanvas(Canvas canvas) {
+        mCanvas = canvas;
+    }
+
     public boolean isHardwareAccelerated() {
         return mCanvas.isHardwareAccelerated();
     }
diff --git a/autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvasView.java b/autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvasView.java
index 2bccdf48..3cba2185 100644
--- a/autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvasView.java
+++ b/autojs/src/main/java/com/stardust/autojs/core/graphics/ScriptCanvasView.java
@@ -4,16 +4,17 @@ import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Color;
+import android.os.SystemClock;
 import android.util.Log;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 
 import com.stardust.autojs.core.eventloop.EventEmitter;
 import com.stardust.autojs.runtime.ScriptRuntime;
+import com.stardust.autojs.runtime.exception.ScriptInterruptedException;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadPoolExecutor;
 
 /**
  * Created by Stardust on 2018/3/16.
@@ -28,6 +29,7 @@ public class ScriptCanvasView extends SurfaceView implements SurfaceHolder.Callb
     private final SurfaceHolder mHolder;
     private ExecutorService mDrawingThreadPool;
     private ScriptRuntime mScriptRuntime;
+    private volatile long mTimePerDraw = 1000 / 30;
 
     public ScriptCanvasView(Context context, ScriptRuntime scriptRuntime) {
         super(context);
@@ -37,6 +39,15 @@ public class ScriptCanvasView extends SurfaceView implements SurfaceHolder.Callb
         init();
     }
 
+
+    public void setMaxFps(int maxFps) {
+        if (maxFps <= 0) {
+            mTimePerDraw = 0;
+        } else {
+            mTimePerDraw = 100 / maxFps;
+        }
+    }
+
     private void init() {
         mHolder.addCallback(this);
     }
@@ -59,13 +70,21 @@ public class ScriptCanvasView extends SurfaceView implements SurfaceHolder.Callb
         mDrawingThreadPool.execute(() -> {
             Canvas canvas = null;
             SurfaceHolder holder = getHolder();
+            long time = SystemClock.uptimeMillis();
+            ScriptCanvas scriptCanvas = new ScriptCanvas();
             try {
                 while (mDrawing) {
                     canvas = holder.lockCanvas();
-                    canvas.drawColor(Color.WHITE);
-                    emit("draw", canvas, this);
+                    scriptCanvas.setCanvas(canvas);
+                    scriptCanvas.drawColor(Color.WHITE);
+                    emit("draw", scriptCanvas, this);
                     holder.unlockCanvasAndPost(canvas);
                     canvas = null;
+                    long dt = mTimePerDraw - (SystemClock.uptimeMillis() - time);
+                    if (dt > 0) {
+                        sleep(dt);
+                    }
+                    time = SystemClock.uptimeMillis();
                 }
             } catch (Exception e) {
                 mScriptRuntime.exit(e);
@@ -78,6 +97,14 @@ public class ScriptCanvasView extends SurfaceView implements SurfaceHolder.Callb
         });
     }
 
+    private void sleep(long dt) {
+        try {
+            Thread.sleep(dt);
+        } catch (InterruptedException e) {
+            throw new ScriptInterruptedException(e);
+        }
+    }
+
     @Override
     protected void onWindowVisibilityChanged(int visibility) {
         Log.d(LOG_TAG, "onWindowVisibilityChanged: " + this + ": visibility=" + visibility + ", mDrawingThreadPool=" + mDrawingThreadPool);