HarmonyOS ミニゲーム: Eat Beans---分散データベースと分散タスク スケジューリングに基づく

[[417423]]

詳細については、以下をご覧ください。

51CTOとHuaweiが共同で構築したHongmengテクノロジーコミュニティ

https://harmonyos..com

序文

私は深セン大学の学部生です。学校の授業で最も一般的に使用されるプログラミング言語をいくつか学びましたが、それでも本から得た知識は浅く、本当に理解するには実践する必要があると感じています。実践的な練習なしに、ただ単に言語を学ぶだけでは明らかに不十分です。ちょうど Hongmeng がリリースされたので、この機会を利用して、授業で学んだことを Hongmeng で実践してみることにしました。この目的のために、私は深セン大学の木棉鴻蒙グループに参加し、仲間と共に勉強しました。夏休み中に、Kapok グループで Hongmeng 分散データベース、分散タスク スケジューリングなどについて学習したので、この間学んだことを記録するためにこの記事を書きました。

概要

この豆を食べるゲームは、シングルプレイヤーバージョンと2プレイヤーバージョンに分かれています。シングルプレイヤーバージョンでは、2体のモンスターがプレイヤーを追いかけます。追いつかれずに皿の上の豆を全部食べればプレイヤーの勝ちです。 2人用バージョンでは、分散データベースと分散スケジューリングの機能を使用して、2人でオンラインで豆を食べることができます。

ゲームのカバーは次のとおりです。

ゲームモードを選択してください:

2人プレイモードでの装備選択インターフェース:

ゲームインターフェースのスクリーンショットは次のとおりです。

シングルプレイヤーモード

2人プレイモード

文章

シングルプレイヤーゲーム

お絵かきゲーム

マップは 2 次元配列の形式で保存されます。次のように、1 は壁、2 はプレイヤー、3 はモンスター、0 は豆です。

公共   int [][] グリッド={
           {1、1、1、1、1、1、1、1、1、1、1、1、1、1、1}、
           {1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1},
           {1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1},
           {1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1},
           {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
           {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
           {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
           {1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1},
           {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1},
           {1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1},
           {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
           {1, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
           {1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1},
           {1、2、0、0、0、0、0、0、0、0、0、0、0、0、1}、
           {1、1、1、1、1、1、1、1、1、1、1、1、1、1、1}};;

ゲームパネルを描く

パブリックvoid 描画テーブル ( intグリッド [][]){
       LayoutConfig を ComponentContainer に追加します。 
 
       Component.DrawTask タスク = 新しい Component.DrawTask() {
           @オーバーライド
public void onDraw(Component コンポーネント、Canvas キャンバス) {
               ペイント paint = new Paint();
               ペイントの色を黒に設定します。 
 
               RectFloat rect=new RectFloat(30-20,250-20,長さ*15+間隔*14+30+20,長さ*15+間隔*14+250+20);
               キャンバスに矩形を描画します。 
 
 ( int row = 0; row < height; row++)の場合
               {
 （ int​  列= 0;列< 幅;列++){
                       もし
                       (グリッド[行][列]==食べ物 || グリッド[行][列]==空){
                           ペイントの色を黒に設定します。
                       }
そうでない場合(グリッド[行][列]==壁)
                           ペイントの色を青に設定します。
そうでない場合(グリッド[行][列]==プレイヤー1)
                           ペイントの色をREDに設定します。
そうでない場合(グリッド[行][列]==モンスター)
                           ペイントにMAGENTAを設定します。
                       RectFloat rectFloat=new RectFloat(30+列*(長さ+間隔),250+行*(長さ+間隔),30+長さ+列*(長さ+間隔),250+長さ+行*(長さ+間隔));
                       キャンバスに矩形を描画します。
                       if(grids[行][列]==food){
                           ペイントの色を黄色に設定します。
                           円 円=新しい円(30+列*(長さ+間隔)+長さ/2,250+行*(長さ+間隔)+長さ/2,長さ/5);
                           キャンバスに円を描画します。
                       }
                   }
               } 
 
 
           }
       };
       レイアウトにタスクを追加します。
       UIContent を設定します。
   }

ボタンを描く

次のコードは、4 つの方向ボタンをそれぞれ描画し、ボタンが押されたときにコールバック メソッドを設定します。下方向のボタンを押すと、プレイヤーの方向は左に設定されます。

パブリックvoid 描画ボタン() {
            ShapeElement の背景 = 新しい ShapeElement();
            背景.setRgbColor(新しいRgbColor(174, 158, 143));
            背景.setCornerRadius(100); 
 
            ボタン button1 = new Button(this);
            button1.setText( "←" );
            button1.setTextAlignment(TextAlignment.CENTER);
            ボタン1にテキストカラーを設定します(Color.WHITE);
            ボタン1.テキストサイズを設定します(100);
            ボタン1.setMarginTop(1500);
            ボタン1.setMarginLeft(180);
            ボタン1.setPadding(10,0,10,0);
            button1.setBackground(背景);
            button1.setClickedListener(新しいComponent.ClickedListener() {
                @オーバーライド
パブリックvoid onClick(コンポーネント コンポーネント) {
                    プレイヤー.left (); //プレイヤーの方向を左に設定する
                }
            });
            レイアウトにコンポーネントを追加します(ボタン1)。 
 
            ボタン button2 = new Button(this);
            button2.setText( "↑" );
            button2.setTextAlignment(TextAlignment.CENTER);
            ボタン2.setTextColor(Color.WHITE);
            ボタン2.テキストサイズを設定します(100);
            ボタン2.setMarginLeft(470);
            ボタン2.setTopMargin(-330);
            ボタン2.setPadding(10,0,10,0);
            button2.setBackground(背景);
            button2.setClickedListener(新しいComponent.ClickedListener() {
                @オーバーライド
パブリックvoid onClick(コンポーネント コンポーネント) {
                    プレイヤーをアップします。 //プレイヤーの方向を上向きに設定する
                }
            });
            レイアウトにコンポーネントを追加します(ボタン2)。 
 
            ボタン button3 = new Button(this);
            button3.setText( "→" );
            button3.setTextAlignment(TextAlignment.CENTER);
            ボタン3.setTextColor(Color.WHITE);
            ボタン3.テキストサイズを設定します(100);
            ボタン3.setMarginLeft(760);
            ボタン3.setMarginTop(55);
            ボタン3.setPadding(10,0,10,0);
            button3.setBackground(背景);
            button3.setClickedListener(新しいComponent.ClickedListener() {
                @オーバーライド
パブリックvoid onClick(コンポーネント コンポーネント) {
                    プレイヤーの右（） ;プレイヤーの方向を右に設定する
                }
            });
            レイアウトにコンポーネントを追加します(ボタン3)。 
 
            ボタン button = new Button(this);
            ボタン.setText( "↓" );
            ボタン.setTextSize(100);
            button.setTextAlignment(TextAlignment.CENTER);
            ボタン。テキストカラーを設定します(Color.WHITE);
            ボタン.setMarginTop(100);
            ボタン.setMarginLeft(470);
            ボタン.setPadding(10,10,10,10);
            ボタンの背景を設定します。
            button.setClickedListener(新しいComponent.ClickedListener() {
                @オーバーライド
パブリックvoid onClick(コンポーネント コンポーネント) {
                    プレイヤーを下へ移動します。プレイヤーの方向を下向きに設定する
                }
            });
            レイアウトにコンポーネントを追加します。
        }

プレイヤークラス

プレーヤー クラスの属性は、方向、プレーヤーの x 座標、y 座標、プレーヤーのスコアです。プレイヤー クラスのメソッドは、player_run()、left()、right()、up()、down() などです。player_run() は、プレイヤー インスタンスの方向に基づいて、プレイヤー インスタンスの次のステップが壁であるかどうかを判断します。そうでない場合は、次のステップに進みます。方向キーが押されたときに方向を変更するには、left() などのメソッドを使用します。

以下にいくつかのキーコードのみを掲載します。

パブリッククラス Player
 {
    プライベートint方向;
公共 プレイヤーxの整数値。
公共 プレイヤーyの整数値。
    プライベート静的最終int food=0;
    プライベート静的最終int wall = 1;
    プライベート静的最終intプレーヤー=2;
    プライベート静的最終intモンスター=3;
    プライベート静的最終int空=4;
    プライベート静的最終int  左= 1;
    プライベート静的最終int up=2;
    プライベート静的最終int  右=3;
    プライベート静的最終int down=4; 
 
パブリックプレイヤー( int方向、 intプレイヤー_x、 intプレイヤー_y)
    {
        this.direction=方向;
        プレイヤーxをプレイヤxとします。
        プレイヤーyを引数に取ります。
    } 
 
公共  int [][] player_run( int [][] グリッド) {
 int [][]grid=グリッド;
        if (方向 ==左) {
            （グリッド[プレイヤー_y][プレイヤー_x - 1] != 壁）
            {
                グリッド[player_y][player_x - 1] = プレイヤー;
                グリッド[player_y][player_x] = 空;
                プレイヤー_x --;  
            }
        }それ以外の場合 (方向 == 上)
        {
            （グリッド[プレイヤー_y - 1][プレイヤー_x] != 壁）
            {
                グリッド[player_y - 1][player_x] = 食べ物;
                グリッド[player_y][player_x] = 空;
                プレイヤー_y --;  
            }
        }
そうでない場合 (方向 ==右)
        {
            （グリッド[プレイヤー_y][プレイヤー_x + 1] != 壁）
            {
                グリッド[player_y][player_x + 1] = プレイヤー;
                グリッド[player_y][player_x] = 空;
                プレイヤー_x++;
            }
        }それ以外の場合 (方向 == 下) { 
 
            （グリッド[player_y + 1][player_x] != 壁）の場合
            {
                グリッド[player_y + 1][player_x] = プレイヤー;
                グリッド[player_y][player_x] = 空;
                プレイヤー_y++;
            }
        }
グリッドを返します。
    } 
 
パブリックvoid左()
    {
        this.direction =左;
    }
パブリックvoid up()
    {
        this.direction=上;
    }
公共の無効権（）
    {
        this.direction =右;
    } 
 
パブリックvoidダウン()
    {
        this.direction=下;
    }
 }

モンスター

モンスタークラスは主にプレイヤーを追跡することを実現します。ここで使用される方法は、モンスターの現在の座標と追いつくプレイヤーの現在の座標の差を計算することです。追跡はこのゲームで最も複雑な部分です。注意すべき点は次のとおりです:

1. 2体のモンスターが重ならないようにする必要がある

2. モンスターは食べ物があるグリッドを通過すると食べ物を食べることができないため、現在のグリッドが食べ物グリッドであるかどうかを判断する必要があります。この目的のために、ブールフラグ isfood が設定されます。

Monster クラスのプロパティとコンストラクターは次のとおりです。

パブリッククラスモンスター{
    プライベートintモンスター_x;
    プライベートintモンスター_y;
    private int x_difference;//列の差
    private int y_difference;//行の差
    プライベートint x_distance; //行の距離
    プライベートint y_distance; //列の距離
    プライベート最終int壁 = 1;
    プライベート最終intプレイヤー = 2;
    プライベート最終intモンスター = 3;
    プライベート最終int food = 0;
    プライベート最終int空=4;
    プライベートブール値 isfood = true ; 
 
 
パブリックモンスター( intモンスターx、 intモンスターy) {
        モンスターxをコピーします。
        モンスターを生成
    }

追跡方法: 現在のモンスターとプレイヤー間の x 方向と y 方向の距離を計算し、距離が大きい方向を選択して最初に追跡します。モンスターがこの方向に移動できない場合（両側に壁がある場合）は、反対方向への追跡に切り替えます。

公共  int [][] chase1( int [][] grids, Player player) {
 int [][] グリッド = グリッド;
        this.x_difference = モンスターx - player.getPlayer_x();
        this.y_difference = monster_y - player.getPlayer_y();
        this.x_distance = 数学。絶対値(x_差);
        this.y_distance = 数学。 abs (y_difference);
 //現在の位置が食べ物かどうかを判断します。食べ物の場合は、まず現在の位置を食べ物に設定してから次のステップに進みます
//食べ物でない場合は、現在の位置を空に設定して次のステップに進みます
        if(isfood == true )
            グリッド[モンスター_y][モンスター_x]=食べ物;
そうでない場合 (isfood == false )
            グリッド[モンスター_y][モンスター_x]=空;
        if (y_distance < x_distance) //y方向の距離が小さい場合は、まずx方向から近づきます
        {
            if (x_difference > 0 && grid[monster_y][monster_x - 1] != 壁 && grid[monster_y][monster_x - 1] != モンスター)
            {
                モンスターx --;  
                if(grid[monster_y][monster_x]==food) //次のステップが食べ物の場合、フラグを設定する
                {
                    isfood = true ;
                    グリッド[モンスター_y][モンスター_x] = モンスター; 
 
                }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                {
                    isfood = false ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
            }
そうでない場合、(x_difference < 0 && grid[monster_y][monster_x +1] != 壁 && grid[monster_y][monster_x - 1] != モンスター) {
                モンスター_x++;
                if(grid[monster_y][monster_x]==0)//次のグリッドに食べ物があるかどうかを判断します。そうであれば、フラグをtrueに設定します。それ以外の場合はfalseに設定する 
                {
                    isfood = true ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                {
                    isfood = false ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
            }
 else // x方向がブロックされている場合は、代わりにy方向に追跡します
                {
                if (y_difference > 0 && grid[monster_y - 1][monster_x] != 壁 && grid[monster_y - 1][monster_x] != モンスター) {
                    モンスター_y --;  
                    グリッド[モンスター_y][モンスター_x]==0の場合
                    {
                        isfood = true ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                    {
                        isfood = false ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
                }
そうでない場合 (y_difference < 0 && grid[monster_y + 1][monster_x] != wall && grid[monster_y + 1][monster_x] != monster)
                {
                    モンスター_y++;
                    グリッド[モンスター_y][モンスター_x]==0の場合
                    {
                        isfood = true ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                    {
                        isfood = false ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
                }
            }
        }
 else // x 方向の距離が小さいか 2 つが等しい場合は、まず y 方向に追いつきます
        {
            if (y_difference > 0 && grid[monster_y - 1][monster_x] != 壁 && grid[monster_y - 1][monster_x] != モンスター) {
                モンスター_y --;  
                グリッド[モンスター_y][モンスター_x]==0の場合
                {
                    isfood = true ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                {
                    isfood = false ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
            }
そうでない場合 (y_difference < 0 && grid[monster_y + 1][monster_x] != wall && grid[monster_y + 1][monster_x] != monster) {
                モンスター_y++;
                グリッド[モンスター_y][モンスター_x]==0の場合
                {
                    isfood = true ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                {
                    isfood = false ;
                    グリッド[モンスター_y][モンスター_x] = モンスター;
                }
            } 
 
それ以外 
                {
                if (x_difference > 0 && grid[monster_y][x_distance - 1] != 壁 && grid[monster_y][monster_x-1] != モンスター) {
                    モンスターx --;  
                    グリッド[モンスター_y][モンスター_x]==0の場合
                    {
                        isfood = true ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                    {
                        isfood = false ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
                }
そうでない場合 (x_difference < 0 && grid[monster_y][monster_x + 1] != 壁 && grid[monster_y][monster_x+1] != モンスター)
                {
                    モンスター_x++;
                    グリッド[モンスター_y][モンスター_x]==0の場合
                    {
                        isfood = true ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
そうでない場合(グリッド[モンスター_y][モンスター_x]==4)
                    {
                        isfood = false ;
                        グリッド[モンスター_y][モンスター_x] = モンスター;
                    }
                }
            }
        }
グリッドを返します。
        }

ゲームオーバーまたはゲーム成功を引きます

まず、ゲームが終了したか成功したかを判断する必要があります。モンスターに捕まることをゲームの終了と定義します。つまり、プレイヤーの x 座標と y 座標が同時にモンスターの 1 つと同じになったときです。ボード上の豆がすべて食べられたらゲーム成功とみなされます。ゲームの終了とゲームの成功を判断するコードは次のとおりです。

プライベートブール型 gamesucess()
      {
 ( int row = 0; row < height; row++)の場合
          {
 （ int​  列= 0;列< 幅;列++)
              {
                  if (グリッド[行][列] == 0)
戻る 間違い;
              }
          }
戻る 真実;
      } 
 
      private boolean game_over(プレイヤー player,モンスター monster1,モンスター monster2)
      {
          if((player.getPlayer_x()==monster1.getMonster_x() && player.getPlayer_y()==monster1.getMonster_y()) || (player.getPlayer_x()==monster2.getMonster_x() && player.getPlayer_y()==monster2.getMonster_y()))
戻る 真実;
それ以外 
戻る 間違い;
      }

ゲーム結果を描画するためのコードは次のとおりです。

プライベート void drawGame_over()
   {
       タイマーをキャンセルします。
       テキスト text=new Text(this);
       text.setText( "ゲームオーバー" );
       テキストのサイズを100に設定します。
       テキストの色を BLUE に設定します。
       text.setTextAlignment(TextAlignment.CENTER);
       テキストの上下マージンを設定します(-1800,0);
       テキストの余白を350,0に設定します。
       レイアウトにコンポーネントを追加します。
       UIContent を設定します。
   } 
 
プライベート void drawGamesuccess()
   {
       タイマーをキャンセルします。
       テキスト text=new Text(this);
       text.setText( "ゲーム成功" );
       テキストのサイズを100に設定します。
       テキストの色を BLUE に設定します。
       text.setTextAlignment(TextAlignment.CENTER);
       テキストの上下マージンを設定します(-1800,0);
       テキストの余白を350,0に設定します。
       レイアウトにコンポーネントを追加します。
       UIContent を設定します。
   }

2人用ゲーム

分散タスクスケジューリングとページジャンプ

2人プレイモードでは、デバイス選択ページを設定しました。デバイス A を選択したパーティはプレイヤー 1 を操作し、もう一方のパーティは自動的にパーティ B として設定され、プレイヤー 2 を操作します。さらに重要なのは、2 つのデバイスのうち 1 つが選択を行うと、両方のデバイスが同時にゲーム ページに自動的にジャンプすることを期待しています。そこで、パラメータ付きの分散タスクスケジューリングを使用して別のマシンのタスク起動を制御し、パラメータ付きの同じページジャンプ（つまり、presentステートメント）を使用してこのマシンのジャンプを実現しました。具体的なコードは次のとおりです。

まず、config.json ファイルで必要な権限を宣言し、それを「module」コード ブロックに追加する必要があります。

次に、MainAbility クラスで機密性の高い権限を明示的に宣言します。

パブリッククラス MainAbility は Ability を拡張します
{
    @オーバーライド
パブリックvoid onStart(インテント インテント) {
        super.onStart(インテント);
        文字列[] 権限 = {
 "ohos.permission.READ_USER_STORAGE" 、 // データベースの読み取り権限
"ohos.permission.WRITE_USER_STORAGE" 、 // データベースの書き込み権限
"ohos.permission.DISTRIBUTED_DATASYNC" //分散データ同期権限
        };
        ユーザーからの権限を要求します(権限、0);
        super.setMainRoute(MainAbilitySlice.class.getName());
    }
 }

次に、分散スケジューリング方式を使用して別のデバイスをプルアップし、ページジャンプを使用してローカルデバイスのジャンプを完了します。これら両方のジャンプはパラメータ付きのジャンプであり、その目的は、デバイス操作オブジェクトの後続のバインディングを容易にすることです。

分散スケジューリングに関して注意すべき点が 2 つあります。

1. BUNDLE_NAMEとABILITY_NAMEの設定

BUNDLE_NAME は、構成ファイルの app ブロックにあります。

ABILITY_NAME は、モジュール コード ブロックの abilities セクションにあります。

2. 分散スケジューリングでは、Ability クラスのみをスケジュールでき、AbilitySlice クラスはスケジュールできません。 AbilitySlice クラスをスケジュールする場合は、まず Ability クラスをスケジュールし、その中の super.setMainRoute() メソッドを介して AbilitySlice クラスにジャンプすることができます。著者は最初にこのミスを犯し、スケジュール作成に失敗しました。

分散スケジューリングとページ スケジューリングのコードは次のとおりです。

パブリッククラス ChooseAB_Ability は AbilitySlice を拡張します { 
 
    プライベート静的最終文字列 BUNDLE_NAME = "com.example.test" ;
    プライベート静的最終文字列 ABILITY_NAME = "com.example.test.Test" ; 
 
 
パブリックvoid onStart(インテント インテント) {
        super.onStart(インテント);
        UIContent をスーパーに設定します。 
 
 //接続されたデバイスを取得する
        リスト<DeviceInfo> deviceInfoList = DeviceManager.getDeviceList(DeviceInfo.FLAG_GET_ONLINE_DEVICE);
       if( deviceInfoList.size ()==0)
戻る;
       文字列デバイスID=deviceInfoList.get(0).getDeviceId(); 
 
        ボタン buttonA = (Button) findComponentById(ResourceTable.Id_A_btn);
        buttonA.setClickedListener(コンポーネント -> { 
 
                // FAをリモートで起動する
                インテント remoteIntent = 新しい Intent();
                操作 operation = new Intent.OperationBuilder().withDeviceId(deviceID)
                        .withBundleName(バンドル名)
                        .withAbilityName(アビリティ名)
                        .withFlags(Intent.FLAG_ABILITYSLICE_MULTI_DEVICE)
                        。建てる（）; 
 
                リモートインテントの操作を設定します。
                remoteIntent.setParam( "デバイス" , "B" ); //ジャンプパラメータを設定します。 「device」はキー、 「B」は値です
            試す {
                // ターゲットデバイスに指定されたFAが含まれているかどうか
                リスト<AbilityInfo> abilityInfoList = getBundleManager().queryAbilityByIntent(remoteIntent, 0, 0);
                （abilityInfoList != null && !abilityInfoList.isEmpty()）の場合 {
                    リモートインテントを開始します。 //別のデバイスをスケジュールする
                }
            } キャッチ (RemoteException e) {
                //エラーを処理する
            } 
 
           //パラメータによるページジャンプ
 
                インテントintent1=新しいインテント();
                intent1.setParam( "デバイス" , "A" ); //パラメータを設定する
                present(new MultiGameAbility_3(),intent1);ページジャンプ
 
        }); 
 
 //別のボタンのコードは基本的に上記と同じですが、渡されるパラメータが異なります
        ボタン buttonB = (Button) findComponentById(ResourceTable.Id_B_btn);
        buttonB.setClickedListener(新しいComponent.ClickedListener() {
            @オーバーライド
パブリックvoid onClick(コンポーネント コンポーネント) {
                 インテント remoteIntent = 新しい Intent(); 
 
                操作 operation = new Intent.OperationBuilder().withDeviceId(deviceID)
                        .withBundleName(バンドル名)
                       .withAbilityName(アビリティ名)
                     .withFlags(Intent.FLAG_ABILITYSLICE_MULTI_DEVICE)
                        。建てる（）; 
 
                リモートインテントの操作を設定します。
                remoteIntent.setParam( "デバイス" , "A" );
                試す {
                    // ターゲットデバイスに指定されたFAが含まれているかどうか
                    リスト<AbilityInfo> abilityInfoList = getBundleManager().queryAbilityByIntent(remoteIntent, 0, 0);
                    （abilityInfoList != null && !abilityInfoList.isEmpty()）の場合 {
                        リモートインテントを開始します。
                    }
                } キャッチ (RemoteException e) {
                    //エラーを処理する
                } 
 
               インテントintent1=新しいインテント();
               intent1.setParam( "デバイス" , "B" );
               新しい MultiGameAbility_3() が存在します。intent1 です。
                } 
 
        }); 
 
    }
 }

分散データベースの構築

グローバル変数を次のように定義します。

プライベート静的最終文字列 STORE_ID = "distributed_db" ;
プライベート SingleKvStore シングルKvストア;
プライベート KvManager kvManager;

データベースを構築するプロセスは次のとおりです。

プライベート void initDbManager()
    {
        kvManager = createManager();
        単一のKvStore=createDb(kvManager);
        subscribeDb(シングルKvStore);
    } 
 
    プライベート KvManager createManager()
    {
        KvManagerConfig config = 新しい KvManagerConfig(this);
        KvManager マネージャー = KvManagerFactory.getInstance().createKvManager(config);
リターンマネージャー;
    } 
 
 
 //KvManagerを使用してデータベースを作成する
    プライベート SingleKvStore createDb(KvManager kvManager)
    {
        SingleKvStore kvStore = null ;
        試す{
            オプション options=新しいオプション();
            options.setCreateIfMissing( true ).setEncrypt( false ).setKvStoreType(KvStoreType.SINGLE_VERSION);
            kvStore=kvManager.getKvStore(オプション、STORE_ID);
        }
        キャッチ (KvStoreException 例外)
        {
            //エラー処理
        }
 kvStoreを返します。 
 
    } 
 
 //データベースの変更を購読する
    プライベート void subscribeDb(SingleKvStore singleKvStore)
    {
        クラス KvStoreObserverClient は KvStoreObserver を実装します
        {
パブリックvoid onChange(ChangeNotification 通知)
            {
                if(queryContact_Int( "player1_d" )!=エラー)
                    direction1=queryContact_Int( "player1_d" );
                if(queryContact_Int( "player2_d" )!=エラー)
                    direction2=queryContact_Int( "player2_d" );
                if(queryContact_String( "配列" )!= null )
                    配列=queryContact_String( "配列" );
                if(queryContact_Int( "A_Score" )!=エラー)
                    A_スコア=queryContact_Int( "A_スコア" );
                if(queryContact_Int( "A_Score" )!=エラー)
                    B_スコア=queryContact_Int( "A_スコア" ); 
 
            }
        }
        KvStoreObserver kvStoreObserverClient = 新しい KvStoreObserverClient();
        単一のKvStore.subscribe(SubscribeType.SUBSCRIBE_TYPE_ALL、kvStoreObserverClient);
    }

データベースの追加、削除、変更、クエリ

ドキュメントを読むと、分散データベースの挿入操作と変更操作は同じステートメントであることがわかります。キーワードがデータベースに存在しない場合は、挿入操作が実行されます。キーワードがデータベースに存在する場合は、更新操作が実行されます。これはある程度はよりスマートで便利ですが、2 つの機能を分離した方が明確になると思います。学習の過程で、私たちは次のような間違いを犯しました。先入観を持っていて、クエリが成功すると想定し、プログラムがクラッシュするのです。実際、これは Throws クラスであり、スローされるエラーの 1 つはキーワードが存在しないというエラーであるため、すべての Throws クラスに対して try+catch 形式を厳密に使用することが重要です。

文字列の追加、変更、クエリは次のとおりです。

 // 文字列を挿入
 プライベート void inputData_String(文字列キー、文字列値)
    { 
 
        if(キー== null ||キー.isEmpty()|| 値 == null || 値 .isEmpty())
            ;//キーワードが空の場合、何も実行されません
それ以外 
        キーワードが空でなく、キーワードに値がない場合、putString操作が実行されます。
            if (queryContact_String(キー) == null )
            {
                singleKvStore.putString(キー、値 );
            }
        } 
 
    }
 //文字列を変更する
    private void update_String(文字列キー、文字列値)
    {
        if(キー== null || key .isEmpty()|| 値 == null || value.isEmpty()|| queryContact_String(キー)== null )
            ; //キーワードが空の場合、何も実行されません
それ以外 
            singleKvStore.putString(キー、値 );
    }
 //文字列クエリ
    プライベート文字列 queryContact_String(文字列キー)
    {
        試す {
 singleKvStore.getString(キー)を返します。
        }
        キャッチ (KvStoreException 例外)
        {
戻る ヌル; //何か問題が発生した場合、以降の操作ではnullを返します
        }
    }

整数の加算、変更、クエリ

プライベートint queryContact_Int(文字列キー)
    {
        試す {
 singleKvStore.getInt(キー)を返します。
        }
        キャッチ (KvStoreException 例外)
        {
エラーを返します。 //ここでエラーはプログラムには現れない負の整数（-1）として定義されます
        }
    } 
 
    プライベート void update_Int(文字列キー、 int値)
    { 
 
        if (キー== null ||キー.isEmpty()||queryContact_Int(キー)== error)
            ;
それ以外 
            singleKvStore.putInt(キー, 値);
    } 
 
    プライベート void inputData_Int(文字列キー、 int値)
    { 
 
        if(queryContact_Int(キー)==エラー)
        {
            singleKvStore.putInt(キー, 値);
        }
それ以外 
            ; 
 
    }

ネットワークデバイスIDバインディング

ID をバインドするには、データベースを使用してバインドし、デバイス ID と対応する値をデータベースに渡すという方法があります。

（「A」または「B」）。これら 2 つのデバイスは同じプログラムを実行しているため、ミラーリングされていると言えますが、操作がローカルでのみ実行されると「上書き」の状況が発生する可能性があります。そのため、バインド操作を実行するには 3 番目の場所のパブリック領域が必要になり、データベースを選択します。

まず、ローカル デバイス ID と接続されている別のデバイスの ID を取得する必要があります。

プライベート文字列 self; //すべての変数
プライベート文字列その他; //グローバル変数
パブリックvoid getId()
   {
       KvManagerFactory をインスタンス化します。 //自分のIDを取得する
       リスト<DeviceInfo> onlineDevices = DeviceManager.getDeviceList(DeviceInfo.FLAG_GET_ONLINE_DEVICE);
       ( onlineDevices.size () == 0)の場合
戻る;
       その他 = onlineDevices.get(0).getDeviceId(); //ネットワーク内の別のデバイスのIDを取得する
   }

上記の分散スケジューリングとページジャンプでインテント クラスのパラメータを使用し、分散データベースと連携してデバイスをバインドするコードは次のようになります。

 （意図がnullではない場合）
               //デバイスをバインド
               if (intent.getStringParam( "デバイス" ).equals( "A" )) {
                   入力データ文字列(自己、 "A" );
                   入力データ文字列(その他、 「B」 );
               }そうでない場合 (intent.getStringParam( "device" ).equals( "B" )) {
                   入力データ文字列(自己、 "B" );
                   inputData_String(その他、 「A」 );
               }
           }

この時点でID同期は完了です。

ユーザーインターフェース

シングルプレイヤーモードと比較して、2プレイヤーモードのボタンは操作オブジェクトにバインドされ、ボタンのコールバックメソッドは次のように変更されます（ボタンの1つを例に挙げます）。

 button_left.setClickedListener(新しいComponent.ClickedListener() {
                @オーバーライド
パブリックvoid onClick(コンポーネント コンポーネント) {
                    if(queryContact_String(self).equals( "A" )) {
                        プレイヤー1.左();
                        update_Int( "player1_d" 、player1.getDirection());
                    }
そうでない場合、(queryContact_String(self).equals( "B" ))
                    {
                        プレイヤー2.左（）;
                        update_Int( "player2_d" 、player2.getDirection());
                    }
                }
            });

ゲームを同期する方法

ゲームを同期する方法は多数ありますが、基本的には何らかの値をデータベースに渡すことを意味します。考えられる方法は3つあります。

1. 最も直接的なアイデアは、バイト型の配列を渡すことです。渡すことができるのは 1 次元配列のみなので、2 次元配列の行の添え字をキーワードとして使用し、列を 1 次元配列として渡すことができます。しかし、試してみたところ、配列を渡すとプログラムがクラッシュする可能性があることがわかりました。データの読み書きには時間がかかるため、ミニゲームの高いリフレッシュ レートではデバイスが配列転送を完了することが難しいと推測されます。

2. まず 2 次元配列を文字列に変換し、その文字列を分散データベースに転送します。配列と文字列間の変換はローカルで実行できるため、非常に高速になります。この方法では、デバイスはデータベースの読み取りと書き込みを 1 回だけ実行して完了します。

3. プレイヤーの座標と方向を渡します。この方法は、文字列と配列間の変換を必要とせず、データベースの読み取り量も少ないため、デバイスで完了できます。

すると、2 番目の実装コードのみが以下に公開され、3 番目の実装コードは後続の完全なコードで公開されます。

配列と文字列を変換する方法は次のとおりです。

プライベート文字列Array_to_String( int grids[][])
   {
       StringBuilder ビルダー = 新しい StringBuilder();
 ( int i=0;i<15;i++)の場合
       {
 ( int j=0;j<15;j++)の場合
           {
               ビルダー.append(グリッド[i][j]);
           }
       }
 builder.toString()を返します。
   } 
 
   プライベートint [][] String_to_Array(文字列値)
   {
 int [][] grid=グリッド;
 ( int i=0;i<15;i++)の場合
       {
 ( int j=0;j<15;j++)の場合
           {
            グリッド[i][j] =整数.parseInt(値.部分文字列(i*15+j,i*15+j+1));
           }
       }
グリッドを返します。
   }

プログラムの初期化: 起動時にデータベースにいくつかの初期値を書き込む

パブリックボイド初期化() {
           レイアウト = 新しい DirectionalLayout(this);
           inputData_Int( "player1_d" 、方向1); //2人のプレイヤーの初期方向をデータベースにアップロードする
           inputData_Int( "player2_d" 、方向2); 
 
           inputData_Int( "A_スコア" ,0);
           inputData_Int( "B_スコア" ,0); 
 
           配列=Array_to_String(グリッド); //配列を文字列に変換する
           inputData_String( "array" ,array);//文字列をデータベースに書き込みます*/ 
 
           描画ボタン();
           描画テーブル();
       }

視覚的な同期

分散データベース上のデータを視覚的に同期したい場合は、より高速にコールバックする時間オブジェクトを作成し、描画メソッドを継続的に呼び出して視覚的な同期を実現する必要があります。同時に、スタンドアロン バージョンには player_run() をコールバックするための時間オブジェクトもあります。

  パブリックvoid 実行()
        {
            timer1 = 新しいタイマー(); 
 
            timer1.schedule(new TimerTask() {
                @オーバーライド
パブリックボイド実行（）{
                    getUITaskDispatcher().asyncDispatch(()->
                    {
                      if(!(game_over(player1,monster1,monster2)||game_over(player2,monster1,monster2)||gamesucess()))
                        {
                           if(queryContact_String( "配列" )!= null )
                           {
 player1.setDirection(queryContact_Int( "player1_d" )); player2.setDirection(queryContact_Int( "player2_d" ));
                                配列 = queryContact_String( "配列" );
                                グリッド = String_to_Array(配列);
                                player1.setScore(queryContact_Int( "A_Score" ));
                                player2.setScore(queryContact_Int( "B_Score" )); 
 
 
                            }
                           描画テーブルテスト();
                        }
それ以外 
                           ;
                    });
                }
            },0,70); 
 
            timer2 = 新しいタイマー();
            timer2.schedule(新しいTimerTask() {
                @オーバーライド
パブリックvoid 実行()
                {
                    getUITaskDispatcher().asyncDispatch(()->{
                        {
                            ゲームオーバーの場合(プレイヤー1、モンスター1、モンスター2)||ゲームオーバーの場合(プレイヤー2、モンスター1、モンスター2))
                            {
                                ゲームオーバーを描画します。
                            }
そうでない場合(ゲーム成功())
                            {
                                ゲームの成功を描画します。
                            }
それ以外 
                            {
                                player1.setDirection(queryContact_Int( "player1_d" ));
                                player2.setDirection(queryContact_Int( "player2_d" ));
                                if(queryContact_String( "配列" )!= null )
                                {
                                    配列 = queryContact_String( "配列" );
                                    グリッド = String_to_Array(配列);
                                }
                                グリッド = player1.player_run_test(グリッド);
                                グリッド=player2.player_run_test(グリッド);
                                配列=Array_to_String(グリッド);
                                update_String( "配列" ,配列);
                            }
                        }
                    });
                }
            },0,2000);
        }

まとめ

この学習ノートは、ゲーム「Eating Beans」の実装と、UI 設定、ページ ジャンプ、分散データベース、分散タスク スケジューリングなど、最近学習した内容を記録したものです。私の最初の実践的なプロジェクトであるため、このプロジェクトには多少の小さな問題と未解決の問題があります。例えば、2人プレイモードではモンスターが存在すると「モンスタークローン問題」が頻繁に発生するため、モンスター設定は解除されます。解決しようとしましたが、うまくいきませんでした。これはデータベースの読み取りと書き込みに関連していると思います。完全なコードは、いくつかの変更を加えた後に後でリリースされる予定です。その時までに、皆さんがその中の誤りを指摘してくれることを願っています。もちろん、私はこのプロジェクトで未解決の問題を解決するために努力し続けます。

詳細については、以下をご覧ください。

51CTOとHuaweiが共同で構築したHongmengテクノロジーコミュニティ

https://harmonyos..com