Android SDK Appletからの移植

無数のボールが跳ね回るアプレットのソースが公開されているので、そちらの移植を乱暴にやりつつ、泥縄式におぼえていきたい。
http://homepage.mac.com/catincat/java/physics/mass/
http://homepage.mac.com/catincat/java/physics/mass/MassiveBall.java

まず
Applet = View
Color = 存在しないので新しく作る
Graphics = Canvas
Image = Bitmap
という感じで置き換えて乱暴にコードを削った。
マウス処理はちょっと後回しにしておいて
repaint() = invalidate()
Graphics.setcolor() = Paint.setARGB()
とかやった
もとのアプレットはメイン処理をデーモンスレッドで走らせててそこでrepaintしていたが、同じ様にやると
Only the original thread that created a view hierarchy can touch its views
といって怒られた。とりあえず早い所結果が見たいので
http://code.google.com/android/samples/ApiDemos/src/com/google/android/samples/graphics/GLView1.html
ここのメッセージハンドラの処理を見て、スレッドじゃなくタイマー処理で再描画を呼び出すことにした。

ものすごーくラフで、いろいろ整理してないけどとりあえずボールが沢山出て動く、ってところまでいけたのがこれ。



sample source

package com.andor.ball;

import android.app.Activity;
import android.os.Bundle;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;

public class AndroBall extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        setContentView(new MassiveBall(this));
    }

}


class MassiveBall extends SimulationApplet {
    static final double _r_max=16,_r_mid=12,_r_min=6;
    Ball[] _largeBalls=new Ball[20];
    Ball[] _smallBalls=new Ball[30];
    Ball[] _allBalls=new Ball[_largeBalls.length+_smallBalls.length];
    Grid _grid;
    Ball _seizedBall;
    public void run(){
    	
    }

   public MassiveBall(Context context) {
	   super(context);
       int i=0;
       int j;
       int c;
       c= _largeBalls.length;
       for (j=0;j           _allBalls[i]=_largeBalls[j]=createBall(_r_max,_r_mid);

       c= _smallBalls.length;
       for (j=0;j           _allBalls[i]=_smallBalls[j]=createBall(_r_mid,_r_min);
       
       _grid=new Grid(_width,_height,_r_mid,10);

   }

   protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w,h,oldw,oldh);
    }

	
    private Ball createBall(double in_r_max,double in_r_min) {
        float d1,d2,d3;
        d1 = (float)Math.random();
        d2 = (float)Math.random();
        d3 = (float)Math.random();
        int i1,i2,i3;
        i1 = (int)(Math.random()*255);
        i2 = (int)(Math.random()*255);
        i3 = (int)(Math.random()*255);
    	double r=d1*(in_r_max-in_r_min)+in_r_min;
        double d = r*2;
        double x=d2*(_width-d)+r;
        double y=d3*(_height-d)+r;
        Color color=new Color(i1,i2,i3);
        return new Ball(x,y,r,color);
    }

    protected synchronized void run(double in_dt) {
    	if (_smallBalls == null){
    		return;
    	}
    	if (_largeBalls == null){
    		return;
    	}
    	if (_grid == null){
    		return;
    	}

    	_grid.clear();
        int i;
        int c;
        
        c = _smallBalls.length;
        for (i=0;i            _grid.add(_smallBalls[i],_smallBalls[i].x,_smallBalls[i].y);

        _grid.apply(new Grid.Operator() {
            public void matchObjects(Object a,Object b) {
                if (((Ball)a).id<((Ball)b).id)
                    ((Ball)a).collide((Ball)b);
            }
        });
        
        
        c = _largeBalls.length;
        for (i=0;i            for (int j=0;j                _largeBalls[i].collide(_largeBalls[j]);
            for (int j=0;j<_smallBalls.length;j++)
                _largeBalls[i].collide(_smallBalls[j]);
        }

        c = _allBalls.length;
        for (i=0;i            _allBalls[i].fall(in_dt);
            _allBalls[i].bound(_width,_height);
            _allBalls[i].move(in_dt);
        }
        if (_seizedBall!=null) {
            _seizedBall.u+=in_dt*2*((_mouse_x-_seizedBall.x)/_ft-_seizedBall.u)/_ft;
            _seizedBall.v+=in_dt*2*((_mouse_y-_seizedBall.y)/_ft-_seizedBall.v)/_ft;
        }
    }
    
    public void mousePressed(int x,int y) {
        for (int i=0;i<_allBalls.length;i++) {
            Ball b=_allBalls[i];
            double dx=b.x-x;
            double dy=b.y-y;
            if (dx*dx+dy*dy        }
    }
    
    public void mouseReleased(int x,int y) {
        _seizedBall=null;
    }
    
    protected void paintOffscreen(Canvas g) {
    	int i;
    	int c;
    	int x,y,w,h;
    	Color color;
    	if (_allBalls == null){
    		return;
    	}
    	c =_allBalls.length;
       	Paint paint = new Paint();
    	for (i=0;i            Ball b=_allBalls[i];
        	x = (int)(b.x-b.r);
           	y = (int)(b.y-b.r);
           	w = (int)b.r;
           	color=b.color;
           	paint.setARGB(255, color.r, color.g, color.b);
            g.drawCircle(x, y, w, paint);
        }
    }
}

class Color{
	public int r,g,b;
	public Color(int in_r,int in_g,int in_b){
		r = in_r;
		g = in_g;
		b = in_b;
	}
}

abstract class SimulationApplet extends View implements Runnable,MouseListener {
    public static final double _ft=0.1;
    private static final double _dt=0.01;
    
    private Bitmap _image;
    protected int _width = 320;
    protected int _height = 240;
    protected int _mouse_x,_mouse_y;
    protected boolean _mouse_down;
    
    Canvas _canvas;
    private Rect _rect = new Rect();
    private Paint _paint;
    AndroBall _parent;

    private long            _nextTime;
    private boolean         is_animate;    
    
    public SimulationApplet(Context c) {
        super(c);
        is_animate = false;
        _paint = new Paint();
        _paint.setAntiAlias(true);
        _paint.setARGB(255, 255, 255, 255);    	
    }

    protected void onAttachedToWindow() {
        is_animate = true;
        Message msg = mHandler.obtainMessage(INVALIDATE);
        _nextTime = SystemClock.uptimeMillis();
        mHandler.sendMessageAtTime(msg, _nextTime);
        super.onAttachedToWindow();
    }	

    protected void onDetachedFromWindow() {
        is_animate = false;
        super.onDetachedFromWindow();
    }
    
    private static final int INVALIDATE = 1;
    private final Handler mHandler = new Handler() {
        @Override
                public void handleMessage(Message msg) {
            if (is_animate && msg.what == INVALIDATE) {
            	run(_dt);
            	invalidate();
                msg = obtainMessage(INVALIDATE);
                long current = SystemClock.uptimeMillis();
                if (_nextTime < current) {
                    _nextTime = current + 5;
                }
                sendMessageAtTime(msg, _nextTime);
                _nextTime += 5;
            }
        }
    };	    
    
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        int curW = _image != null ? _image.width() : 0;
        int curH = _image != null ? _image.height() : 0;
        if (curW >= w && curH >= h) {
            return;
        }
        if (curW < w) curW = w;
        if (curH < h) curH = h;
        _width=curW;
        _height=curH;
        Bitmap newBitmap = Bitmap.createBitmap(curW, curH, false);
        Canvas newCanvas = new Canvas();
        newCanvas.setDevice(newBitmap);
        if (_image != null) {
            newCanvas.drawBitmap(_image, 0, 0, null);
        }
        _image = newBitmap;
        _canvas = newCanvas;
    }
    
    protected abstract void run(double dt);

    public boolean onMotionEvent(MotionEvent event) {
        int action = event.getAction();
        _mouse_x = (int)event.getX();
        _mouse_y = (int)event.getY();
        
        if ((action == MotionEvent.ACTION_DOWN) || (action == MotionEvent.ACTION_MOVE)){
	        _mouse_down=true;
	        mousePressed(_mouse_x,_mouse_y);
        }else{
	        _mouse_down=false;
	        mouseReleased(_mouse_x,_mouse_y);
        }
        return true;
    }
    protected void onDraw(Canvas canvas) {
    	if ((_rect != null) && (_paint != null)){
	    	_rect.set(0, 0,
	                _width,_height);
	    	_canvas.drawRect(_rect, _paint);
	    	paintOffscreen(_canvas);
    	}
    	if (_image != null) {
        	canvas.drawBitmap(_image, 0, 0, null);
        }
    }
    protected abstract void paintOffscreen(Canvas canvas);
}
class Ball {
    private static final double _elasticity=0.8;
    private static final double _gravity=200;
    private static final double _bounce=0.7;
    private static int _number=0;
    
    public double x,y;
    public double u,v;
    public double r,m;
    public final double d;
    public int id;
    public Color color;

    public Ball(double x,double y,double r,Color color) {
        this.x=x;
        this.y=y;
        this.r=r;
        this.d = r*2;
        this.color=color;
        m=Math.PI*r*r;
        id=_number++;
    }
    
    public void fall(double dt) {
        v+=dt*_gravity;
    }
    
    public void move(double dt) {
        x+=dt*u;
        y+=dt*v;
    }
    
    public void collide(Ball b) {
        double dx=b.x-x;
        double dy=b.y-y;
        double dr=Math.sqrt(dx*dx+dy*dy);
        if (dr            dx/=dr;
            dy/=dr;
            double dw=(b.u-u)*dx+(b.v-v)*dy;
            if (dw<0) {
                double fw=dw*(1+_elasticity)/(b.m+m);
                u+=fw*dx*b.m;
                v+=fw*dy*b.m;
                b.u+=-fw*dx*m;
                b.v+=-fw*dy*m;
            }
            double fr=_bounce*(dr-b.r-r)/(b.m+m);
            x+=fr*dx*b.m;
            y+=fr*dy*b.m;
            b.x+=-fr*dx*m;
            b.y+=-fr*dy*m;
        }
    }
    
    public void bound(double width,double height) {
        if (x            if (u<0) u*=-_elasticity;
            x+=_bounce*(r-x);
        }
        if (x>width-r) {
            if (u>0) u*=-_elasticity;
            x+=_bounce*(width-r-x);
        }
        if (y            if (v<0) v*=-_elasticity;
            y+=_bounce*(r-y);
        }
        if (y>height-r) {
            if (v>0) v*=-_elasticity;
            y+=_bounce*(height-r-y);
        }
    }
}

class Grid {
    private double _width,_height,_delta;
    private int _cols,_rows,_capacity;
    private Object[][][] _cells;
    private int[][] _counts;
    
    public Grid(double width,double height,double delta,int capacity) {
        this._width=width;
        this._height=height;
        this._delta=delta;
        this._capacity=capacity;
        _cols=(int)Math.ceil(width/delta);
        _rows=(int)Math.ceil(height/delta);
        _cells=new Object[_cols][_rows][capacity];
        _counts=new int[_cols][_rows];
    }
    
    public void clear() {
    	int c,c2;
    	int i,j;
    	c = _cols;
    	c2 = _rows;
    	for (i=0;i            for (j=0;j                _counts[i][j]=0;
    }
    
    public void add(Object obj,double x,double y) {
        int i=(int)(x/_delta);
        int j=(int)(y/_delta);
        if (i<0) i=0;
        if (i>=_cols) i=_cols-1;
        if (j<0) j=0;
        if (j>=_rows) j=_rows-1;
        if (_counts[i][j]<_capacity)
            _cells[i][j][_counts[i][j]++]=obj;
    }
    
    public void apply(Operator op) {
        for (int i=0;i<_cols;i++) {
            int i2min=Math.max(0,i-1);
            int i2max=Math.min(i+1,_cols-1);
            for (int j=0;j<_rows;j++) {
                int j2min=Math.max(0,j-1);
                int j2max=Math.min(j+1,_rows-1);
                for (int k=0;k<_counts[i][j];k++) 
                    for (int i2=i2min;i2<=i2max;i2++)
                        for (int j2=j2min;j2<=j2max;j2++)
                            for (int k2=0;k2<_counts[i2][j2];k2++)
                                op.matchObjects(
                                    _cells[i][j][k],
                                    _cells[i2][j2][k2]);
            }
        }
    }
    
    public interface Operator {
        void matchObjects(Object a,Object b);
    }

    
}

interface MouseListener {
	void mousePressed(int _mouse_x,int _mouse_y);
	void mouseReleased(int x,int y);
}