public interface ITaskBehaviour {
    void Update();
}

class CellScript : ITaskBehaviour {
    public void Update() {
        // Step1:動作確認
        System.Diagnostics.Debug.Print( "Updateが呼ばれました：value={0}, location=[{1},{2}]",
                                        lblCell.Text,
                                        lblCell.Location.X, lblCell.Location.Y );
    }
}

    public partial class Form1 : Form {
        List<ITaskBehaviour> taskList = new List<ITaskBehaviour>();
 
        //*********************************************************************
        /// <summary> 画面表示時のハンドラ
        /// </summary>
        //*********************************************************************
        private void Form1_Load( object sender, EventArgs e ) {
            ...
 
            timGameTimer.Interval = 100;
            timGameTimer.Enabled = true;
 
            // 動作確認用のセルを生成する
            taskList.Add( new CellScript( this.pnlBase,   64, 0, 0 ) );
            taskList.Add( new CellScript( this.pnlBase,  256, 1, 0 ) );
            taskList.Add( new CellScript( this.pnlBase, 1024, 2, 0 ) );
            taskList.Add( new CellScript( this.pnlBase,65535, 3, 0 ) );
 
            taskList.Add( new CellScript( this.pnlBase,    8, 0, 1 ) );
            taskList.Add( new CellScript( this.pnlBase,    4, 1, 1 ) );
 
            taskList.Add( new CellScript( this.pnlBase,    2, 3, 2 ) );
 
            ...
        }
 
 
        private void timGameTimer_Tick(object sender, EventArgs e) {
            // すべてのタスク(セル)に定期的に処理を行わせる
            foreach (ITaskBehaviour task in taskList) {
                task.Update();
            }
        }
    }
}

class CellScript {
 
    enum STATE {
        IDLE,
        SLIDE
    }
 
    STATE curState = STATE.IDLE;

    const int SLIDE_FRAME = 50;
 
    int slidingFrame = 0;
    Point slideOffset  = new Point(0,0);
    Point destLocation = new Point(0,0);
 
    //*********************************************************************
    /// <summary> コンストラクタ
    /// </summary>
    /// <param name="value"></param>
    /// <param name="x"></param>
    /// <param name="y"></param>
    //*********************************************************************
    public CellScript( Panel pnlBoard, int cellValue, int x, int y ) {
        this.pnlBoard = pnlBoard;
        _createLabel();
        initPosition( x, y );
        setValue( cellValue );
 
        curState = STATE.IDLE;
    }
 
    //*********************************************************************
    /// <summary> セルの初期位置を指定する
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    //*********************************************************************
    public void initPosition(int x, int y) {
        if (lblCell == null) {
            return;
        }
 
        lblCell.Location = new Point( x*CELL_SIZE + (x+1)*CELL_PADDING,
                                      y*CELL_SIZE + (y+1)*CELL_PADDING );
    }
 
    //*********************************************************************
    /// <summary> セルを移動させる
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    //*********************************************************************
    public void setPosition(int x, int y) {
        if (lblCell == null) {
            return;
        }
 
        // 移動先を求める
        destLocation = new Point( x*CELL_SIZE + (x+1)*CELL_PADDING,
                                  y*CELL_SIZE + (y+1)*CELL_PADDING );
 
        // 現在位置と、移動先の差(移動距離)を求める
        slideOffset = new Point( lblCell.Location.X - destLocation.X,
                                 lblCell.Location.Y - destLocation.Y );
 
        // 状態を移動中にする
        curState = STATE.SLIDE;
        slidingFrame = 0;
    }

    public void Update() {
 
        switch (curState) {
            case STATE.IDLE:
                // do nothing
                break;
            case STATE.SLIDE:
                slidingFrame += 1;
 
                int x = destLocation.X + (int)( slideOffset.X * ( (SLIDE_FRAME-slidingFrame) / (float)SLIDE_FRAME ) );
                int y = destLocation.Y + (int)( slideOffset.Y * ( (SLIDE_FRAME-slidingFrame) / (float)SLIDE_FRAME ) );
                lblCell.Location = new Point( x, y );
 
                if (slidingFrame >= SLIDE_FRAME) {
                    slidingFrame = 0;
                    curState = STATE.IDLE;
                }
                break;
        }
    }

        private void button1_Click(object sender, EventArgs e) {
            cellScript.setPosition( 3, 3 );
        }

    class Form1 {
        ...
 
        private void button1_Click(object sender, EventArgs e)
        {
            // 移動先のセル(本当はBoardManagerが計算すべきものだが、動作確認のために手入力している)
            List<Tuple<int,int>> destPos = new List<Tuple<int,int>>();
            destPos.Add( new Tuple<int,int>(0,2) );
            destPos.Add( new Tuple<int,int>(1,2) );
            destPos.Add( new Tuple<int,int>(2,3) );
            destPos.Add( new Tuple<int,int>(3,2) );
            destPos.Add( new Tuple<int,int>(0,3) );
            destPos.Add( new Tuple<int,int>(1,3) );
            destPos.Add( new Tuple<int,int>(3,3) );
 
            // 登録されているすべてのセルを、上に書いた場所へ移動させる
            int offset = 0;
            foreach (ITaskBehaviour task in taskList) {
                CellScript cellScript = task as CellScript;
                int x = destPos[offset].Item1;
                int y = destPos[offset].Item2;
 
                cellScript.setPosition( x, y );
                offset++;
 
            }
        }
 
        ...

using System.Windows.Forms;
using System.Collections.Generic;
using System.Drawing;
using System;
 
class CellScript {
    /// <summary>セルの大きさ</summary>
    public const int CELL_SIZE = 50;
 
    /// <summary>セル間の隙間</summary>
    public const int CELL_PADDING = 4;
 
    private Panel pnlBoard;
    private Label lblCell;
 
    // コンストラクタ
    public CellScript( Panel pnlBoard, int cellValue, int x, int y ) {
        ...
    }
 
    // セルの位置を指定する
    public void setPosition(int x, int y) {
        ...
    }
 
    // セルに値をセットする
    public void setValue (int cellValue) {
        ...
    }
}

/// <summary>セルの大きさ</summary>
public const int CELL_SIZE = 50;
 
/// <summary>セル間の隙間</summary>
public const int CELL_PADDING = 4;

private Panel pnlBoard;
private Label lblCell;

// コンストラクタ
public CellScript( Panel pnlBoard, int cellValue, int x, int y );
 
// セルの位置を指定する
public void setPosition(int x, int y);
 
// セルに値をセットする
public void setValue (int cellValue);

//*********************************************************************
/// <summary> コンストラクタ
/// </summary>
/// <param name="value"></param>
/// <param name="x"></param>
/// <param name="y"></param>
//*********************************************************************
public CellScript( Panel pnlBoard, int cellValue, int x, int y ) {
    this.pnlBoard = pnlBoard;
    _createLabel();
    setPosition( x, y );
    setValue( cellValue );
}

//*********************************************************************
/// <summary> セルのラベルを作成する
/// </summary>
//*********************************************************************
private void _createLabel() {
    if (pnlBoard == null) {
        return;
    }
 
    lblCell = new System.Windows.Forms.Label();
 
    lblCell.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
    lblCell.Location = new System.Drawing.Point(0, 0);
    lblCell.Name = "cellLabel";
    lblCell.Size = new System.Drawing.Size(CELL_SIZE, CELL_SIZE);
    lblCell.Text = "";
    lblCell.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
 
    pnlBoard.Controls.Add(this.lblCell);
    lblCell.BringToFront();
}

//*********************************************************************
/// <summary> セルの位置を指定する
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
//*********************************************************************
public void setPosition(int x, int y) {
    if (lblCell == null) {
        return;
    }
 
    int dispPixelOffsetX = x*CELL_SIZE + (x+1)*CELL_PADDING;
    int dispPixelOffsetY = y*CELL_SIZE + (y+1)*CELL_PADDING;
 
    lblCell.Location = new System.Drawing.Point(dispPixelOffsetX, dispPixelOffsetY);
}

//*********************************************************************
/// <summary> セルに値をセットする
/// </summary>
/// <param name="cellValue"></param>
//*********************************************************************
public void setValue (int cellValue) {
    lblCell.Text = cellValue.ToString();
 
    // セルの値に応じた色/フォントをセットする
    lblCell.BackColor = _getCellColor( cellValue );
    lblCell.Font      = _getCellFont( cellValue );
}
 
//*********************************************************************
/// <summary> セルの値に応じた色を返す
/// </summary>
/// <param name="cellValue"></param>
/// <returns></returns>
//*********************************************************************
private Color _getCellColor( int cellValue ) {
    //　セルの値を元に何番目かを求める 2:1番目, 4:2番目, 8:3番目, 16:4番目 ...
    int offset = (int)Math.Log(cellValue, 2 );
    offset = Math.Max( 0, offset);
 
    // 色を求める(番号が増えるほど青暗くするが、見づらいので0x60以下には暗くしない)
        int col = Math.Max( 60, 255 - offset*20 );
    return Color.FromArgb( 255, col, col, 0xff);
}
 
//*********************************************************************
/// <summary> セルの値に応じたフォントを返す
/// </summary>
/// <param name="cellValue"></param>
/// <returns></returns>
//*********************************************************************
private Font _getCellFont( int cellValue ) {
    // 数字の大きさに合わせてフォントサイズを切り替える
    float fontSize = 12;
    if (cellValue >= 1000) {
        fontSize = 10;
    }
    if (cellValue >= 10000) {
        fontSize = 8;
    }
    return new System.Drawing.Font("Meiryo UI", fontSize, 
                                    System.Drawing.FontStyle.Regular, 
                                    System.Drawing.GraphicsUnit.Point, 
                                    ((byte)(128)));
}

public partial class Form1 : Form {
    //*********************************************************************
    /// <summary> 画面表示時のハンドラ
    /// </summary>
    //*********************************************************************
    private void Form1_Load( object sender, EventArgs e ) {
 
        // 動作確認用のセルを生成する
        new CellScript( this.pnlBase,   64, 0, 0 );
        new CellScript( this.pnlBase,  256, 1, 0 );
        new CellScript( this.pnlBase, 1024, 2, 0 );
        new CellScript( this.pnlBase,65535, 3, 0 );
 
        new CellScript( this.pnlBase,    8, 0, 1 );
        new CellScript( this.pnlBase,    4, 1, 1 );
 
        new CellScript( this.pnlBase,    2, 3, 2 );
 
 
 
        // 盤面の大きさを調整する
        int boardSize     = CellScript.CELL_SIZE    * BoardManager.BOARD_SIZE +
                            CellScript.CELL_PADDING * (BoardManager.BOARD_SIZE+1) +
                            2;
        this.pnlBase.Size = new System.Drawing.Size(boardSize, boardSize);
    }
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Windows.Forms;
 
namespace Mock2048 {
    public partial class Form1 : Form {
        BoardManager boardMgr;
 
        public Form1() {
            InitializeComponent();
 
            // ボードマネージャの生成
            boardMgr = new BoardManager();
        }
 
        //*********************************************************************
        /// <summary> 画面表示時のハンドラ
        /// </summary>
        //*********************************************************************
        private void Form1_Load( object sender, EventArgs e ) {
 
            // Formコントロール自身がキー入力を取得可能とする
            this.KeyPreview = true;
 
            //盤面の初期化
            boardMgr.initBoard();
 
            // 盤面を表示する
            boardMgr.displayBoard(txtLog); 
        }
 
 
        //*********************************************************************
        /// <summary> キー入力時のハンドラ
        /// </summary>
        //*********************************************************************
        private void Form1_KeyDown( object sender, KeyEventArgs e ) {
            DIR direction;
 
            // ゲームオーバーのときは何もしない
            if (boardMgr.IsGameOver) {
                return;
            }
 
            // スライド方向を判定する
            switch (e.KeyCode) {
                case Keys.Up:    direction = DIR.UP;    break;
                case Keys.Right: direction = DIR.RIGHT; break;
                case Keys.Down:  direction = DIR.DOWN;  break;
                case Keys.Left:  direction = DIR.LEFT;  break;
                default:
                    // 矢印キー以外は無視
                    return; 
            }
 
            // 指定された方向に移動させる
            bool isMove = boardMgr.slideCell( direction );
            if ( !isMove ) {
                // スライドさせてみたが1セルも動かなかった -> 何もしなかったとみなす
                return;
            }
 
            // 盤面を表示する
            boardMgr.displayBoard(txtLog);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
 
public enum DIR {
    UP,
    RIGHT,
    DOWN,
    LEFT,
};
 
public class BoardManager {
    const int BOARD_SIZE = 4;
 
    // ゲームの状態(ゲームオーバーしたか否か)
    private bool isGameOver = false;
    public  bool IsGameOver {
        get{ return this.isGameOver; }
    }
 
    // 乱数
    System.Random rand = new Random();
 
    // 盤面の情報
    private int[,] board = new int[BOARD_SIZE,BOARD_SIZE];      
 
    //*********************************************************************
    /// <summary> 盤面の初期化を行う
    /// </summary>
    //*********************************************************************
    public void initBoard() {
        isGameOver = false;
 
        // ランダムに2マス埋める
        for (int loop = 0; loop < 2; loop++) {
            _addCell();
        }
    }
 
    //*********************************************************************
    /// <summary> 盤面を画面に表示させる
    /// </summary>
    //*********************************************************************
    public void displayBoard( System.Windows.Forms.TextBox displayArea ) {
 
        // ゲームオーバーのときは描画しない
        if (isGameOver) {
            displayArea.Text = "GAME OVER";
            return;
        }
 
        string boardData = "";
 
        // すべての行のデータを出すまで繰り返し
        for (int y = 0; y < 4; y++) {
            // 1行分のデータを出力
            for (int x = 0; x < 4; x++) {
                boardData += "[" + String.Format("{0, 2}", board[x,y]) + "] ";
            }
            boardData += Environment.NewLine;
            boardData += Environment.NewLine;
        }
 
        displayArea.Text = boardData;
 
        log( "** Boardを描画します**" );
        log( boardData );
 
        displayArea.Select(0,0);
        displayArea.ReadOnly = true;
    }
 
    //*********************************************************************
    /// <summary>　指定された方向に移動させる
    /// </summary>
    /// <param name="keyCode"></param>
    //*********************************************************************
    public bool slideCell( DIR dir ) {
        bool isMove = false;
        bool retVal;
 
        // 入力されたキーを判定する
        switch ( dir ) {
            case DIR.UP:
                // 2～4列目に対し上方向のスライドを試みる
                for (int y = 1; y < BOARD_SIZE; y++) {
                    for (int x = 0; x < BOARD_SIZE; x++) {  
                        retVal = _moveCell( x, y, dir );
                        isMove = (retVal==true) ? true : isMove;
                    }
                }
                break;
            case DIR.DOWN:
                // 1～3列目に対し下方向のスライドを試みる
                for (int y = BOARD_SIZE-2; y >= 0; y--) {
                    for (int x = 0; x < BOARD_SIZE; x++) {  
                        retVal = _moveCell( x, y, dir );
                        isMove = (retVal==true) ? true : isMove;
                    }
                }
                break;
            case DIR.LEFT:
                // 2～4行目に対し左方向のスライドを試みる
                for (int y = 0; y < BOARD_SIZE; y++) {
                    for (int x = 1; x < 4; x++) {
                        retVal = _moveCell( x, y, dir );
                        isMove = (retVal==true) ? true : isMove;
                    }
                }
                break;
            case DIR.RIGHT:
                // 1～3行目に対し右方向のスライドを試みる
                for (int y = 0; y < BOARD_SIZE; y++) {
                    for (int x = BOARD_SIZE-2; x >= 0; x--) {
                        retVal = _moveCell( x, y, dir );
                        isMove = (retVal==true) ? true : isMove;
                    }
                }
                break;
            default:
                //txtLog.Text = "";
                break;                        
        }
        log( "セルをスライドさせました 方向=" + dir.ToString() + " 移動あり?=" + isMove );
 
 
        // セルを追加する
        bool isSuccess = _addCell();
        if (!isSuccess) {
            // セルが追加できない(=空セルがない)時は、ゲームオーバーとみなす
            isGameOver = true;
        }
 
        // 追加した結果、まだスライド可能かチェック
        if (!_canSlide()) {
            // どの方向にもスライドできない場合は、詰みなのでゲームオーバー
            isGameOver = true;
        }
 
        return isMove;
    }
 
 
    //*********************************************************************
    /// <summary> 空いているところに、1つセルを追加する
    /// </summary>
    /// <returns></returns>
    //*********************************************************************
    private bool _addCell() {
 
        // あいているセルを1つ取得する
        Tuple<int,int> freePos = _getEmptyCell_AtRandom();
        if (freePos == null) {
            return false; // 空セル無し
        }
 
        // 取得した空セルにセットする
        int val = rand.Next(1,3) * 2;
        board[freePos.Item1,freePos.Item2] = val;
 
        log( "  -> セットする値=" + val );
 
        return true;
    }
 
 
    //*********************************************************************
    /// <summary> 空セルをランダムで1つ取得する
    /// </summary>
    /// <returns></returns>
    //*********************************************************************
    private Tuple<int,int> _getEmptyCell_AtRandom() {
        List<Tuple<int,int>> emptyCellList = new List<Tuple<int,int>>();
 
        // 空セルを全部Listに集める
        for (int y = 0; y < BOARD_SIZE; y++) {
            for (int x = 0; x < BOARD_SIZE; x++) {
                if ( board[x,y] == 0 ) {
                    emptyCellList.Add( new Tuple<int,int>(x,y) );
                }
            }
        }           
        if (emptyCellList.Count <= 0) {
            // 空セルが1つも無い! ->nullを返して終了。
            return null;　
        }
 
        // 空セルの中から1つをランダムで抽選する
        int offset = rand.Next(0, emptyCellList.Count-1);
        Tuple<int,int> emptyCell = emptyCellList[offset];
 
        log( "空セルを取得しました [" + emptyCell.Item1 + ", " + emptyCell.Item2 + "] 残りの空数=" + (emptyCellList.Count-1) );
        return emptyCell;
    }
 
 
    //*********************************************************************
    /// <summary>　セルのスライドが可能がチェックする
    /// </summary>
    /// <returns></returns>
    //*********************************************************************
    private bool _canSlide() {
        // 上下に連続して同じ数字があるかチェック
        for (int x = 0; x < BOARD_SIZE; x++) {
            for (int y = 0; y < BOARD_SIZE; y++) {
                if (board[x, y] == 0) {
                    // 空セルがある -> スライド可能
                    return true;
                }
 
                if (x != BOARD_SIZE-1 && board[x, y] == board[x+1, y]) {
                    // 右に同じ数字が続く場所がある -> スライド可能
                    return true;
                }
                if (y != BOARD_SIZE-1 && board[x, y] == board[x, y+1]) {
                    // 下に同じ数字が続く場所がある -> スライド可能
                    return true;
                }
 
            }
        }
 
        // ここまできた -> どの方向にもスライドできない
        return false;
    }
 
 
    //*********************************************************************
    /// <summary>　指定された方向にセルをスライドさせる
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <param name="dir"></param>
    //*********************************************************************
    private bool _moveCell( int x, int y, DIR dir ) {
        int endX;
        int endY;
        bool isDuplicate;
 
        // 移動先のセル位置を求める
        _getDestPos( x, y, dir, out endX, out endY, out isDuplicate );
 
        // セルを移動
        int targetVal = board[x,y];
        board[x,y] = 0;
        board[endX,endY] = targetVal * (isDuplicate ? 2 : 1 );
 
        // セルが動いたか否かを返す
        bool isMove;
        if (x == endX && y == endY) {
            isMove = false;
        } else {
            isMove = true;
        }
 
        return isMove;
    }
 
 
    //*********************************************************************
    /// <summary>　指定された方向にセルをスライドさせた時の移動先を求める
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <param name="dir"></param>
    /// <param name="endX"></param>
    /// <param name="endY"></param>
    /// <param name="isDuplicate"></param>
    //*********************************************************************
    private void _getDestPos( int x, int y, DIR dir, out int endX, out int endY, out bool isDuplicate ) {
 
        // initialize
        endX = x;
        endY = y;
        isDuplicate = false;
 
        // 指定されたセルの値を取得
        int targetCellVal = board[x,y];
        if (targetCellVal == 0) {
            return;
        }
 
        // 移動方向を元に探索方向のオフセットを決める
        int dx = 1;
        int dy = 1;
        switch ( dir ) {
            case DIR.UP:    dx =  0; dy = -1; break;
            case DIR.RIGHT: dx =  1; dy =  0; break;
            case DIR.DOWN:  dx =  0; dy =  1; break;
            case DIR.LEFT:  dx = -1; dy =  0; break;
        }
 
 
        // 何かにぶつかるまで探索する
        while (true) {
            if (endX + dx < 0 || endY + dy < 0 || endX + dx >= BOARD_SIZE || endY + dy >= BOARD_SIZE) {
                // 壁にぶつかった -> 1つ手前の場所でストップ
                isDuplicate = false;
                break;
            } else if (board[endX + dx, endY + dy] != 0) {
                // 他のセルにぶつかった
                if (targetCellVal == board[endX + dx, endY + dy]) {
                    // 衝突先が同じ値だった　-> 重ねる
                    endX += dx;
                    endY += dy;
                    isDuplicate = true;
                    break;
                } else {
                    // 衝突先が異なる値だった　-> 1つ手前の場所でストップ
                    isDuplicate = false;
                    break;
                }
            } else {
                // 何にもぶつからなかった -> さらに次の位置をチェック
                endX += dx;
                endY += dy;
                continue;
            }               
        }
        //log( "セルの移動を行います [" + x + ", " + y + "] -> [" + endX + ", " + endY + "] dup=" + isDuplicate );
    }
 
    //*********************************************************************
    /// <summary> デバッグログを出力する
    /// </summary>
    /// <param name="message"></param>
    //*********************************************************************
    private void log(string message) {
        Debug.WriteLine( message );
    }
}

ゲーム状態の管理を追加(isGameOver変数)
KeyDown()に、ゲームオーバー判定を追加
KeyDown()に、1手動かすたびに新セルの生成処理を追加
initBoard()に、盤面の初期化処理(ランダムで2セル生成)を追加
addCell()として、新セルの生成のメソッドを追加
slideCell()に、スライドした結果セルの移動があったか否かを取得できるよう修正

using System;
using System.Collections.Generic;
using System.Data;
using System.Windows.Forms;
using System.Diagnostics;
 
namespace Mock2048 {
    enum DIR {
        UP,
        RIGHT,
        DOWN,
        LEFT,
    };
 
    public partial class Form1 : Form {
        const int BOARD_SIZE = 4;
 
        // ゲームの状態管理(ゲームオーバーしたか否か)
        bool isGameOver = false;
 
        // 乱数
        System.Random rand = new Random();
 
        // 盤面の情報
        private int[,] board = new int[BOARD_SIZE,BOARD_SIZE];      
 
        public Form1() {
            InitializeComponent();
        }
 
        //*********************************************************************
        /// <summary> 画面表示時のハンドラ
        /// </summary>
        //*********************************************************************
        private void Form1_Load( object sender, EventArgs e ) {
            // Formコントロール自身がキー入力を取得可能とする
            this.KeyPreview = true;
 
            //盤面の初期化
            initBoard();
 
            // 盤面を表示する
            displayBoard(); 
        }
 
 
        //*********************************************************************
        /// <summary> キー入力時のハンドラ
        /// </summary>
        //*********************************************************************
        private void Form1_KeyDown( object sender, KeyEventArgs e ) {
            DIR direction;
 
            // ゲームオーバーのときは何もしない
            if (isGameOver) {
                return;
            }
 
 
            // 指定された方向に移動させる
            switch (e.KeyCode) {
                case Keys.Up:    direction = DIR.UP;    break;
                case Keys.Right: direction = DIR.RIGHT; break;
                case Keys.Down:  direction = DIR.DOWN;  break;
                case Keys.Left:  direction = DIR.LEFT;  break;
                default:
                    // 矢印キー以外は無視
                    return; 
            }
            bool isMove = slideCell( direction );
            if ( !isMove ) {
                // スライドさせてみたが1セルも動かなかった -> 何もしなかったとみなす
                return;
            }
 
 
            // セルを追加する
            bool isSuccess = addCell();
            if (!isSuccess) {
                // セルが追加できない(=空セルがない)時は、ゲームオーバーとみなす
                isGameOver = true;
            }
 
            // 追加した結果、まだスライド可能かチェック
            if (!canSlide()) {
                // どの方向にもスライドできない場合は、詰みなのでゲームオーバー
                isGameOver = true;
            }
 
            // 盤面を表示する
            displayBoard();
        }
 
        //*********************************************************************
        /// <summary> 盤面の初期化を行う
        /// </summary>
        //*********************************************************************
        private void initBoard() {
            isGameOver = false;
 
            // ランダムに2マス埋める
            for (int loop = 0; loop < 2; loop++) {
                addCell();
            }
        }
 
        //*********************************************************************
        /// <summary> 空いているところに、1つセルを追加する
        /// </summary>
        /// <returns></returns>
        //*********************************************************************
        private bool addCell() {
 
            // あいているセルを1つ取得する
            Tuple<int,int> freePos = getEmptyCell_AtRandom();
            if (freePos == null) {
                return false; // 空セル無し
            }
 
            // 取得した空セルにセットする
            int val = rand.Next(1,3) * 2;
            board[freePos.Item1,freePos.Item2] = val;
 
            log( "  -> セットする値=" + val );
 
            return true;
        }
 
        //*********************************************************************
        /// <summary> 空セルをランダムで1つ取得する
        /// </summary>
        /// <returns></returns>
        //*********************************************************************
        private Tuple<int,int> getEmptyCell_AtRandom() {
            List<Tuple<int,int>> emptyCellList = new List<Tuple<int,int>>();
 
            // 空セルを全部Listに集める
            for (int y = 0; y < BOARD_SIZE; y++) {
                for (int x = 0; x < BOARD_SIZE; x++) {
                    if ( board[x,y] == 0 ) {
                        emptyCellList.Add( new Tuple<int,int>(x,y) );
                    }
                }
            }           
            if (emptyCellList.Count <= 0) {
                // 空セルが1つも無い! ->nullを返して終了。
                return null;　
            }
 
            // 空セルの中から1つをランダムで抽選する
            int offset = rand.Next(0, emptyCellList.Count-1);
            Tuple<int,int> emptyCell = emptyCellList[offset];
 
            log( "空セルを取得しました [" + emptyCell.Item1 + ", " + emptyCell.Item2 + "] 残りの空数=" + (emptyCellList.Count-1) );
            return emptyCell;
        }
 
        //*********************************************************************
        /// <summary> 盤面を画面に表示させる
        /// </summary>
        //*********************************************************************
        private void displayBoard() {
 
            // ゲームオーバーのときは描画しない
            if (isGameOver) {
                txtLog.Text = "GAME OVER";
                return;
            }
 
            string boardData = "";
 
            // すべての行のデータを出すまで繰り返し
            for (int y = 0; y < 4; y++) {
                // 1行分のデータを出力
                for (int x = 0; x < 4; x++) {
                    boardData += "[" + String.Format("{0, 2}", board[x,y]) + "] ";
                }
                boardData += Environment.NewLine;
                boardData += Environment.NewLine;
            }
 
            txtLog.Text = boardData;
 
            log( "** Boardを描画します**" );
            log( boardData );
 
            txtLog.Select(0,0);
            txtLog.ReadOnly = true;
        }
 
        //*********************************************************************
        /// <summary>　セルのスライドが可能がチェックする
        /// </summary>
        /// <returns></returns>
        //*********************************************************************
        private bool canSlide() {
            // 上下に連続して同じ数字があるかチェック
            for (int x = 0; x < BOARD_SIZE; x++) {
                for (int y = 0; y < BOARD_SIZE; y++) {
                    if (board[x, y] == 0) {
                        // 空セルがある -> スライド可能
                        return true;
                    }
 
                    if (x != BOARD_SIZE-1 && board[x, y] == board[x+1, y]) {
                        // 右に同じ数字が続く場所がある -> スライド可能
                        return true;
                    }
                    if (y != BOARD_SIZE-1 && board[x, y] == board[x, y+1]) {
                        // 下に同じ数字が続く場所がある -> スライド可能
                        return true;
                    }
 
                }
            }
 
            // ここまできた -> どの方向にもスライドできない
            return false;
        }
 
        //*********************************************************************
        /// <summary>　指定された方向に移動させる
        /// </summary>
        /// <param name="keyCode"></param>
        //*********************************************************************
        private bool slideCell( DIR dir ) {
            bool isMove = false;
            bool retVal;
 
            // 入力されたキーを判定する
            switch ( dir ) {
                case DIR.UP:
                    // 2～4列目に対し上方向のスライドを試みる
                    for (int y = 1; y < BOARD_SIZE; y++) {
                        for (int x = 0; x < BOARD_SIZE; x++) {  
                            retVal = moveCell( x, y, DIR.UP );
                            isMove = (retVal==true) ? true : isMove;
                        }
                    }
                    break;
                case DIR.DOWN:
                    // 1～3列目に対し下方向のスライドを試みる
                    for (int y = BOARD_SIZE-2; y >= 0; y--) {
                        for (int x = 0; x < BOARD_SIZE; x++) {  
                            retVal = moveCell( x, y, DIR.DOWN );
                            isMove = (retVal==true) ? true : isMove;
                        }
                    }
                    break;
                case DIR.LEFT:
                    // 2～4行目に対し左方向のスライドを試みる
                    for (int y = 0; y < BOARD_SIZE; y++) {
                        for (int x = 1; x < 4; x++) {
                            retVal = moveCell( x, y, DIR.LEFT );
                            isMove = (retVal==true) ? true : isMove;
                        }
                    }
                    break;
                case DIR.RIGHT:
                    // 1～3行目に対し右方向のスライドを試みる
                    for (int y = 0; y < BOARD_SIZE; y++) {
                        for (int x = BOARD_SIZE-2; x >= 0; x--) {
                            retVal = moveCell( x, y, DIR.RIGHT );
                            isMove = (retVal==true) ? true : isMove;
                        }
                    }
                    break;
                default:
                    //txtLog.Text = "";
                    break;                        
            }
 
            log( "セルをスライドさせました 方向=" + dir.ToString() + " 移動あり?=" + isMove );
 
            return isMove;
        }
 
        //*********************************************************************
        /// <summary>　指定された方向にセルをスライドさせる
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="dir"></param>
        //*********************************************************************
        private bool moveCell( int x, int y, DIR dir ) {
            int endX;
            int endY;
            bool isDuplicate;
 
            // 移動先のセル位置を求める
            getDestPos( x, y, dir, out endX, out endY, out isDuplicate );
 
            // セルを移動
            int targetVal = board[x,y];
            board[x,y] = 0;
            board[endX,endY] = targetVal * (isDuplicate ? 2 : 1 );
 
            // セルが動いたか否かを返す
            bool isMove;
            if (x == endX && y == endY) {
                isMove = false;
            } else {
                isMove = true;
            }
 
            return isMove;
        }
 
 
        //*********************************************************************
        /// <summary>　指定された方向にセルをスライドさせた時の移動先を求める
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="dir"></param>
        /// <param name="endX"></param>
        /// <param name="endY"></param>
        /// <param name="isDuplicate"></param>
        //*********************************************************************
        private void getDestPos( int x, int y, DIR dir, out int endX, out int endY, out bool isDuplicate ) {
 
            // initialize
            endX = x;
            endY = y;
            isDuplicate = false;
 
            // 指定されたセルの値を取得
            int targetCellVal = board[x,y];
            if (targetCellVal == 0) {
                return;
            }
 
            // 移動方向を元に探索方向のオフセットを決める
            int dx = 1;
            int dy = 1;
            switch ( dir ) {
                case DIR.UP:    dx =  0; dy = -1; break;
                case DIR.RIGHT: dx =  1; dy =  0; break;
                case DIR.DOWN:  dx =  0; dy =  1; break;
                case DIR.LEFT:  dx = -1; dy =  0; break;
            }
 
 
            // 何かにぶつかるまで探索する
            while (true) {
                if (endX + dx < 0 || endY + dy < 0 || endX + dx >= BOARD_SIZE || endY + dy >= BOARD_SIZE) {
                    // 壁にぶつかった -> 1つ手前の場所でストップ
                    isDuplicate = false;
                    break;
                } else if (board[endX + dx, endY + dy] != 0) {
                    // 他のセルにぶつかった
                    if (targetCellVal == board[endX + dx, endY + dy]) {
                        // 衝突先が同じ値だった　-> 重ねる
                        endX += dx;
                        endY += dy;
                        isDuplicate = true;
                        break;
                    } else {
                        // 衝突先が異なる値だった　-> 1つ手前の場所でストップ
                        isDuplicate = false;
                        break;
                    }
                } else {
                    // 何にもぶつからなかった -> さらに次の位置をチェック
                    endX += dx;
                    endY += dy;
                    continue;
                }               
            }
 
            //log( "セルの移動を行います [" + x + ", " + y + "] -> [" + endX + ", " + endY + "] dup=" + isDuplicate );
        }
 
        //*********************************************************************
        /// <summary> デバッグログを出力する
        /// </summary>
        /// <param name="message"></param>
        //*********************************************************************
        private void log(string message) {
            Debug.WriteLine( message );
        }
    }
}