Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: arena-mechanics.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/arena-mechanics.md
Note: This content continues in the next part.

Response:
of the bonus tokens, as well as their original stake, further motivating players to strive for victory.

6. **Listener Mode:**

For those who prefer to watch the action unfold, the "Listen" mode offers an opportunity to stay informed without active participation. Processes can register as listeners, granting them access to all announcements from the game. While they do not engage as players, listeners can continue to observe the game's progress unless they explicitly request removal.

7. **Game State Management:**

To maintain the flow and fairness of arena games, an automated system oversees game state transitions. These transitions encompass waiting, playing, and ending phases. Time durations for each state, such as `WaitTime` and `GameTime`, ensure that rounds adhere to defined timeframes, preventing games from lasting indefinitely.

You can refer to the code for the arena in the dropdown below: -->

  Arena Game Blueprint

```lua
-- ARENA GAME BLUEPRINT.

-- This blueprint provides the framework to operate an 'arena' style game
-- inside an ao process. Games are played in rounds, where players aim to
-- eliminate one another until only one remains, or until the game time
-- has elapsed. The game process will play rounds indefinitely as players join
-- and leave.

-- When a player eliminates another, they receive the eliminated player's deposit token
-- as a reward. Additionally, the builder can provide a bonus of these tokens
-- to be distributed per round as an additional incentive. If the intended
-- player type in the game is a bot, providing an additional 'bonus'
-- creates an opportunity for coders to 'mine' the process's
-- tokens by competing to produce the best agent.

-- The builder can also provide other handlers that allow players to perform
-- actions in the game, calling 'eliminatePlayer()' at the appropriate moment
-- in their game logic to control the framework.

-- Processes can also register in a 'Listen' mode, where they will receive
-- all announcements from the game, but are not considered for entry into the
-- rounds themselves. They are also not unregistered unless they explicitly ask
-- to be.

-- GLOBAL VARIABLES.

-- Game progression modes in a loop:
-- [Not-Started] -> Waiting -> Playing -> [Someone wins or timeout] -> Waiting...
-- The loop is broken if there are not enough players to start a game after the waiting state.
GameMode = GameMode or "Not-Started"
StateChangeTime = StateChangeTime or undefined

-- State durations (in milliseconds)
WaitTime = WaitTime or 2 * 60 * 1000 -- 2 minutes
GameTime = GameTime or 20 * 60 * 1000 -- 20 minutes
Now = Now or undefined -- Current time, updated on every message.

-- Token information for player stakes.
UNIT = 1000
PaymentToken = PaymentToken or "ADDR"  -- Token address
PaymentQty = PaymentQty or tostring(math.floor(UNIT))    -- Quantity of tokens for registration
BonusQty = BonusQty or tostring(math.floor(UNIT))        -- Bonus token quantity for winners

-- Players waiting to join the next game and their payment status.
Waiting = Waiting or {}
-- Active players and their game states.
Players = Players or {}
-- Number of winners in the current game.
Winners = 0
-- Processes subscribed to game announcements.
Listeners = Listeners or {}
-- Minimum number of players required to start a game.
MinimumPlayers = MinimumPlayers or 2

-- Default player state initialization.
PlayerInitState = PlayerInitState or {}

-- Sends a state change announcement to all registered listeners.
-- @param event: The event type or name.
-- @param description: Description of the event.
function announce(event, description)
    for ix, address in pairs(Listeners) do
        ao.send({
            Target = address,
            Action = "Announcement",
            Event = event,
            Data = description
        })
    end
    return print(Colors.gray .. "Announcement: " .. Colors.red .. event .. " " .. Colors.blue .. description .. Colors.reset)
end

-- Sends a reward to a player.
-- @param recipient: The player receiving the reward.
-- @param qty: The quantity of the reward.
-- @param reason: The reason for the reward.
function sendReward(recipient, qty, reason)
    if type(qty) ~= number then
      qty = tonumber(qty)
    end
    ao.send({
        Target = PaymentToken,
        Action = "Transfer",
        Quantity = tostring(qty),
        Recipient = recipient,
        Reason = reason
    })
    return print(Colors.gray .. "Sent Reward: " ..
      Colors.blue .. tostring(qty) ..
      Colors.gray .. ' tokens to ' ..
      Colors.green .. recipient .. " " ..
      Colors.blue .. reason .. Colors.reset
    )
end

-- Starts the waiting period for players to become ready to play.
function startWaitingPeriod()
    GameMode = "Waiting"
    StateChangeTime = Now + WaitTime
    announce("Started-Waiting-Period", "The game is about to begin! Send your token to take part.")
    print('Starting Waiting Period')
end

-- Starts the game if there are enough players.
function startGamePeriod()
    local paidPlayers = 0
    for player, hasPaid in pairs(Waiting) do
        if hasPaid then
            paidPlayers = paidPlayers + 1
        end
    end

    if paidPlayers < MinimumPlayers then
        announce("Not-Enough-Players", "Not enough players registered! Restarting...")
        for player, hasPaid in pairs(Waiting) do
            if hasPaid then
                Waiting[player] = false
                sendReward(player, PaymentQty, "Refund")
            end
        end
        startWaitingPeriod()
        return
    end

    LastTick = undefined
    GameMode = "Playing"
    StateChangeTime = Now + GameTime
    for player, hasPaid in pairs(Waiting) do
        if hasPaid then
            Players[player] = playerInitState()
        else
            ao.send({
                Target = player,
                Action = "Ejected",
                Reason = "Did-Not-Pay"
            })
            removeListener(player) -- Removing player from listener if they didn't pay
        end
    end
    announce("Started-Game", "The game has started. Good luck!")
    print("Game Started....")
end

-- Handles the elimination of a player from the game.
-- @param eliminated: The player to be eliminated.
-- @param eliminator: The player causing the elimination.
function eliminatePlayer(eliminated, eliminator)
    sendReward(eliminator, PaymentQty, "Eliminated-Player")
    Waiting[eliminated] = false
    Players[eliminated] = nil

    ao.send({
        Target = eliminated,
        Action = "Eliminated",
        Eliminator = eliminator
    })

    announce("Player-Eliminated", eliminated .. " was eliminated by " .. eliminator .. "!")

    local playerCount = 0
    for player, _ in pairs(Players) do
        playerCount = playerCount + 1
    end
    print("Eliminating player: " .. eliminated .. " by: " .. eliminator) -- Useful for tracking eliminations

    if playerCount < MinimumPlayers then
        endGame()
    end

end

-- Ends the current game and starts a new one.
function endGame()
    print("Game Over")

    Winners = 0
    Winnings = tonumber(BonusQty) / Winners -- Calculating winnings per player

    for player, _ in pairs(Players) do
        Winners = Winners + 1
    end

    Winnings = tonumber(BonusQty) / Winners

    for player, _ in pairs(Players) do
        -- addLog("EndGame", "Sending reward of:".. Winnings + PaymentQty .. "to player: " .. player) -- Useful for tracking rewards
        sendReward(player, Winnings + tonumber(PaymentQty), "Win")
        Waiting[player] = false
    end

    Players = {}
    announce("Game-Ended", "Congratulations! The game has ended. Remaining players at conclusion: " .. Winners .. ".")
    startWaitingPeriod()
end

-- Removes a listener from the listeners' list.
-- @param listener: The listener to be removed.
function removeListener(listener)
    local idx = 0
    for i, v in ipairs(Listeners) do
        if v == listener then
            idx = i
            break
        end
    end
    if idx > 0 then
        table.remove(Listeners, idx)
    end
end

-- HANDLERS: Game state management

-- Handler for cron messages, manages game state transitions.
Handlers.add(
    "Game-State-Timers",
    function(Msg)
        return "continue"
    end,
    function(Msg)
        Now = Msg.Timestamp
        if GameMode == "Not-Started" then
            startWaitingPeriod()
        elseif GameMode == "Waiting" then
            if Now > StateChangeTime then
                startGamePeriod()
            end
        elseif GameMode == "Playing" then
            if onTick and type(onTick) == "function" then
              onTick()
            end
            if Now > StateChangeTime then
                endGame()
            end
        end
    end
)

-- Handler for player deposits to participate in the next game.
Handlers.add(
    "Transfer",
    function(Msg)
        return
            Msg.Action == "Credit-Notice" and
            Msg.From == PaymentToken and
            tonumber(Msg.Quantity) >= tonumber(PaymentQty) and "continue"
    end


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: arena-mechanics.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/arena-mechanics.md

Response:
-- Handler for cron messages, manages game state transitions.
Handlers.add(
    "Game-State-Timers",
    function(Msg)
        return "continue"
    end,
    function(Msg)
        Now = Msg.Timestamp
        if GameMode == "Not-Started" then
            startWaitingPeriod()
        elseif GameMode == "Waiting" then
            if Now > StateChangeTime then
                startGamePeriod()
            end
        elseif GameMode == "Playing" then
            if onTick and type(onTick) == "function" then
              onTick()
            end
            if Now > StateChangeTime then
                endGame()
            end
        end
    end
)

-- Handler for player deposits to participate in the next game.
Handlers.add(
    "Transfer",
    function(Msg)
        return
            Msg.Action == "Credit-Notice" and
            Msg.From == PaymentToken and
            tonumber(Msg.Quantity) >= tonumber(PaymentQty) and "continue"
    end,
    function(Msg)
        Waiting[Msg.Sender] = true
        ao.send({
            Target = Msg.Sender,
            Action = "Payment-Received"
        })
        announce("Player-Ready", Msg.Sender .. " is ready to play!")
    end
)

-- Registers new players for the next game and subscribes them for event info.
Handlers.add(
    "Register",
   { Action = "Register" },
    function(Msg)
        if Msg.Mode ~= "Listen" and Waiting[Msg.From] == undefined then
            Waiting[Msg.From] = false
        end
        removeListener(Msg.From)
        table.insert(Listeners, Msg.From)
        ao.send({
            Target = Msg.From,
            Action = "Registered"
        })
        announce("New Player Registered", Msg.From .. " has joined in waiting.")
    end
)

-- Unregisters players and stops sending them event info.
Handlers.add(
    "Unregister",
   { Action = "Unregister" },
    function(Msg)
        removeListener(Msg.From)
        ao.send({
            Target = Msg.From,
            Action = "Unregistered"
        })
    end
)

-- Adds bet amount to BonusQty
Handlers.add(
    "AddBet",
    { Reason = "AddBet" },
    function(Msg)
        BonusQty = tonumber(BonusQty) + tonumber(Msg.Tags.Quantity)
        announce("Bet-Added", Msg.From .. "has placed a bet. " .. "BonusQty amount increased by " .. Msg.Tags.Quantity .. "!")
    end
)

-- Retrieves the current game state.
Handlers.add(
    "GetGameState",
   { Action = "GetGameState" },
    function (Msg)
        local json = require("json")
        local TimeRemaining = StateChangeTime - Now
        local GameState = json.encode({
            GameMode = GameMode,
            TimeRemaining = TimeRemaining,
            Players = Players,
            })
        ao.send({
            Target = Msg.From,
            Action = "GameState",
            Data = GameState})
    end
)

-- Alerts users regarding the time remaining in each game state.
Handlers.add(
    "AnnounceTick",
   { Action = "Tick" },
    function (Msg)
        local TimeRemaining = StateChangeTime - Now
        if GameMode == "Waiting" then
            announce("Tick", "The game will start in " .. (TimeRemaining/1000) .. " seconds.")
        elseif GameMode == "Playing" then
            announce("Tick", "The game will end in " .. (TimeRemaining/1000) .. " seconds.")
        end
    end
)

-- Sends tokens to players with no balance upon request
Handlers.add(
    "RequestTokens",
   { Action = "RequestTokens" },
    function (Msg)
        print("Transfering Tokens: " .. tostring(math.floor(10000 * UNIT)))
        ao.send({
            Target = ao.id,
            Action = "Transfer",
            Quantity = tostring(math.floor(10000 * UNIT)),
            Recipient = Msg.From,
        })
    end
)
```

</details>

## アリーナゲームブループリント

このアリーナフレームワークを利用したい方のために、コードをブループリントとして簡単にアクセスできるようにしました。ターミナルで以下のコードを実行してください：

<!--
## Arena Game Blueprint

For those interested in using this arena framework, we've made this code easily accesible through a blueprint. Simply run the following code in your terminal: -->

```lua
.load-blueprint arena
```

## 要約

アリーナのメカニクスを理解することは、前のセクションで作成した自律エージェントを改善するだけでなく、独自のゲームを構築するためのコア機能を活用する力を与えます。

次のセクション「ゲームの構築」では、これらのメカニクスを活用して魅力的でユニークなゲームをこのフレームワーク内で構築するアートに深く掘り下げます。ゲーム開発のダイナミックな世界への旅に出る準備をしてください！ 🎮

<!-- ## Summary

Understanding the mechanics of the arena can not only help you improve your autonomous agent created in the previous section but also empowers you to harness core functionalities for crafting your unique games.

In the upcoming section, "Building a Game," we will dive deep into the art of utilizing these mechanics to construct captivating and one-of-a-kind games within this framework. Get ready to embark on a journey into the dynamic realm of game development! 🎮 -->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: index.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/index.md

Response:
---
prev:
  text: "Tokengating"
  link: "../begin/tokengating"
next:
  text: "Let's Play A Game!"
  link: "./ao-effect"
---

<!-- # Bots and Games -->

# ボットとゲーム

<!-- > Build your own unique bot to complete Quest 3 and earn 1000 CRED, then enter games like the [Grid](https://github.com/twilson63/grid) to earn legacynet CRED 24/7! -->

> [!NOTE]
> 独自のボットを作成してクエスト3を完了し、1000 CREDを獲得しましょう。その後、 [Grid](https://github.com/twilson63/grid) のようなゲームに参加して、テストネットCREDを24時間365日獲得できます！

<!-- Leveraging insights from our previous chapter, this section will guide you through the realm of automation with bots in aos and the construction of games. You will learn to create autonomous agents, using them to navigate and interact with game environments effectively. -->

前章で得た知識を活かし、このセクションでは、aosでのボットによる自動化の領域とゲーム構築についてガイドします。自律エージェントを作成し、それを使ってゲーム環境を効果的にナビゲートし、相互作用させる方法を学びます。

## セクション

- [0. **# Let's Play A Game:** _Experience a game on aos_](ao-effect)

<!-- ### Enhancing Game Interactions with Automation -->

### オートメーションによるゲームインタラクションの強化

- [1. **# アナウンスの解釈:** _ゲーム内のアナウンスを解釈する_](announcements)
- [2. **# ゲームステートの取得:** _最新のゲームステートを取得して処理する_](game-state)
- [3. **# 戦略的判断:** _自動化を活用して次の行動を決定する_](decisions)
- [4. **# 自動化された反応:** _攻撃への反応を自動化で効率化する_](attacking)
- [5. **# スキルの統合:** _スキルを組み合わせて自律型エージェントを作成する_](bringing-together)

<!-- ### Game Development Insights -->

### ゲーム開発の洞察

- [6. **# アリーナのメカニクス:** _ゲームのアリーナのメカニズムを探る_](arena-mechanics)
- [7. **# アリーナの拡張:** _アリーナの上に独自のゲームロジックを構築する_](build-game)

<!-- A journey of discovery and creation awaits. Let the adventure begin! -->

発見と創造の旅が待っています。冒険を始めましょう！


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: announcements.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/announcements.md

Response:
# お知らせの解釈

コーディングの旅にお帰りなさい。これまでのチュートリアルで習得したスキルを使って、ゲーム体験を向上させる時が来ました。

ゲーム中、ターミナルにお知らせが表示されるのに気づいたかもしれません。これらのお知らせは、ゲームがプレイヤーに重要なイベントを伝える方法です。しかし、これらのメッセージは時に難解に見えたり、さらなる詳細を知るために頻繁に受信箱をチェックしている自分に気づくかもしれません。

この情報を直接ターミナルからアクセスできたら便利ではありませんか？実は、それができる方法があります！

[ハンドラ](/references/handlers.md)を使うことで、この情報を取得する自律エージェントを作成でき、単純なボットからゲームイベントを解釈し、直接行動することができる存在へと進化します。

## 開発環境のセットアップ

まず、好みのディレクトリに `bot.lua` という新しいファイルを作成します。

> 理想的には、このファイルはプレイヤープロセスが実行されているのと同じディレクトリに配置して、コードの読み込みを容易にするべきです。そうでなければ、ファイルにアクセスするために相対パスを使用する必要があります。

## コードの記述

ロジックに飛び込みましょう。

aos の各ハンドラには、3 つの重要な情報が必要です：

- `name`: ハンドラの一意の名前
- `pattern`: ハンドラが識別するパターンで、その動作を引き起こします
- `handle`: 指定されたパターンが見つかったときに実行する操作

お知らせの詳細を表示するためのハンドラを書く方法は次のとおりです：

<!-- # Interpreting Announcements

Welcome back to your coding journey. It's time to use the skills you've acquired from previous tutorials to enhance your gaming experience.

During the game, you've likely noticed announcements appearing in your terminal. These announcements are the game's way of communicating important events to players. However, these messages can sometimes seem cryptic or you might find yourself checking your inbox frequently for further details.

Wouldn't it be convenient to access this information directly from your terminal? Well, there's a way to do that!

By using [handlers](/references/handlers.md), you can create an autonomous agent to retrieve this information for you, marking the progression from simple bots to entities capable of interpreting and acting on game events directly.

## Setting up the Development Environment

Start by creating a new file named `bot.lua` in your preferred directory.

> Ideally, this file should be placed in the same directory where your player process runs to ease the loading of the code. Else, you'll need to use relative paths to access the file.

## Writing the Code

Let's dive into the logic.

Each handler in aos requires three key pieces of information:

- `name`: A unique name for the handler
- `pattern`: A pattern for the handler to identify, triggering its operation
- `handle`: The operations to perform when the desired pattern is found.

Here's how you can write a handler for printing announcement details: -->

```lua
-- Handler to print game announcements directly in the terminal.
Handlers.add(
  "PrintAnnouncements",
  { Action = "Announcement" },
  function (msg)
    print(msg.Event .. ": " .. msg.Data)
  end
)
```

この場合、ハンドラの名前は `"PrintAnnouncements"` です。`{ Action = "Announcement" }` という特別なビルトインユーティリティ（`hasMatchingTags`）を使用して、受信メッセージがアナウンスメントとしてタグ付けされているかどうかを確認します。もし真であれば、ハンドラはイベントとデータを印刷します。これらはお知らせのタイトルと説明を表します。

> [!注]
> メッセージが「処理される」と、受信箱からは廃棄されます。

## 読み込みとテスト

では、これをゲームで実現しましょう。

aos プレイヤーターミナルに移動し、ゲームセッションに入ります。

次のコマンドで `bot.lua` ファイルを読み込むことで、ハンドラをアクティブにします：

<!--
In this case, the name of the handler is `"PrintAnnouncements"`. It uses a special in-built utility (`hasMatchingTags`) represented by `{ Action = "Announcement" }` to check if the incoming message has been tagged as an announcement. If true, the handler prints the Event and Data, which represent the title and description of the announcement.

> [!Note]
> Once a message is "handled", it will be discarded from your `Inbox`.

## Loading and Testing

Now, let's bring this to life in the game.

Navigate to your aos player terminal and enter a game session.

Activate the handler by loading your `bot.lua` file with: -->

```lua
.load bot.lua
```

<!-- You'll now see game announcements appear directly in your terminal, offering real-time insights without the need to sift through your inbox.

Congratulations! You have just taken the first step in building a bot on `aos`. But let's keep working on adding more features to it 🌐 -->

これで、ゲームのお知らせが直接ターミナルに表示され、受信箱をこまめにチェックする必要なくリアルタイムの洞察を提供します。

おめでとうございます！あなたは `aos` 上にボットを構築する第一歩を踏み出しました。しかし、さらなる機能を追加するために引き続き作業を進めていきましょう 🌐


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: bringing-together.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/bringing-together.md
Note: This content continues in the next part.

Response:
# Bringing it Together

この最終ガイドでは、シリーズを締めくくります。ここでは、あなたが自律エージェントを少しずつ構築してきました。さて、エージェントの動作を最適化することで、その精度を高めていきましょう。ここでは、主な改善点の概要を示します。

- **順次コマンド実行:** `InAction`フラグの導入により、エージェントのアクションが順次実行されるようになりました（前のアクションが成功裏に実行されたときのみ次のアクションが発生します）。この重要な追加により、エージェントが古いゲーム状態に基づいて行動することが防止され、反応性と正確性が向上しました。最終的な`bot.lua`ファイルのコードは以下に示します。

```lua
InAction = InAction or false -- Prevents the agent from taking multiple actions at once.
```

- **動的な状態更新と意思決定:** エージェントは現在、自動ティックロジックを採用しており、動的な更新と意思決定が可能になりました。このロジックにより、エージェントは状態更新を自動的にトリガーし、ティックメッセージを受信するか、アクションを完了した際に次の決定を行うことができ、独立した操作が促進されます。

```lua
Handlers.add("GetGameStateOnTick", { Action = "Tick" }, function ()
  if not InAction then
    InAction = true
    ao.send({Target = Game, Action = "GetGameState"})
  end
end)
```

- **自動手数料転送:** 操作をさらに効率化し、ゲームへの参加が途切れないようにするために、自律エージェントは確認手数料の転送を自動的に処理します。

```lua
Handlers.add("AutoPay", { Action = "AutoPay" }, function ()
  ao.send({Target = Game, Action = "Transfer", Recipient = Game, Quantity = "1000"})
end)
```

これらの機能に加えて、デバッグ目的のためにロギング機能を追加し、ゲームイベントの理解を向上させるためにカラープリントも導入しました。これらの強化により、あなたの自律エージェントはゲーム環境でより効率的かつ適応性を持つものとなります。

新たに追加された機能が強調された完全な`bot.lua`コードを以下のドロップダウンで確認してください。

  Updated bot.lua file

```lua
-- Initializing global variables to store the latest game state and game host process.
LatestGameState = LatestGameState or nil
InAction = InAction or false -- Prevents the agent from taking multiple actions at once.

Logs = Logs or {}

colors = {
  red = "\27[31m",
  green = "\27[32m",
  blue = "\27[34m",
  reset = "\27[0m",
  gray = "\27[90m"
}

function addLog(msg, text) -- Function definition commented for performance, can be used for debugging
  Logs[msg] = Logs[msg] or {}
  table.insert(Logs[msg], text)
end

-- Checks if two points are within a given range.
-- @param x1, y1: Coordinates of the first point.
-- @param x2, y2: Coordinates of the second point.
-- @param range: The maximum allowed distance between the points.
-- @return: Boolean indicating if the points are within the specified range.
function inRange(x1, y1, x2, y2, range)
    return math.abs(x1 - x2) <= range and math.abs(y1 - y2) <= range
end

-- Decides the next action based on player proximity and energy.
-- If any player is within range, it initiates an attack; otherwise, moves randomly.
function decideNextAction()
  local player = LatestGameState.Players[ao.id]
  local targetInRange = false

  for target, state in pairs(LatestGameState.Players) do
      if target ~= ao.id and inRange(player.x, player.y, state.x, state.y, 1) then
          targetInRange = true
          break
      end
  end

  if player.energy > 5 and targetInRange then
    print(colors.red .. "Player in range. Attacking." .. colors.reset)
    ao.send({Target = Game, Action = "PlayerAttack", Player = ao.id, AttackEnergy = tostring(player.energy)})
  else
    print(colors.red .. "No player in range or insufficient energy. Moving randomly." .. colors.reset)
    local directionMap = {"Up", "Down", "Left", "Right", "UpRight", "UpLeft", "DownRight", "DownLeft"}
    local randomIndex = math.random(#directionMap)
    ao.send({Target = Game, Action = "PlayerMove", Player = ao.id, Direction = directionMap[randomIndex]})
  end
  InAction = false -- InAction logic added
end

-- Handler to print game announcements and trigger game state updates.
Handlers.add(
  "PrintAnnouncements",
  { Action = "Announcement" },
  function (msg)
    if msg.Event == "Started-Waiting-Period" then
      ao.send({Target = ao.id, Action = "AutoPay"})
    elseif (msg.Event == "Tick" or msg.Event == "Started-Game") and not InAction then
      InAction = true -- InAction logic added
      ao.send({Target = Game, Action = "GetGameState"})
    elseif InAction then -- InAction logic added
      print("Previous action still in progress. Skipping.")
    end
    print(colors.green .. msg.Event .. ": " .. msg.Data .. colors.reset)
  end
)

-- Handler to trigger game state updates.
Handlers.add(
  "GetGameStateOnTick",
  { Action =  "Tick" },
  function ()
    if not InAction then -- InAction logic added
      InAction = true -- InAction logic added
      print(colors.gray .. "Getting game state..." .. colors.reset)
      ao.send({Target = Game, Action = "GetGameState"})
    else
      print("Previous action still in progress. Skipping.")
    end
  end
)

-- Handler to automate payment confirmation when waiting period starts.
Handlers.add(
  "AutoPay",
  { Action =  "AutoPay" },
  function (msg)
    print("Auto-paying confirmation fees.")
    ao.send({ Target = Game, Action = "Transfer", Recipient = Game, Quantity = "1000"})
  end
)

-- Handler to update the game state upon receiving game state information.
Handlers.add(
  "UpdateGameState",
  { Action =  "GameState" },
  function (msg)
    local json = require("json")
    LatestGameState = json.decode(msg.Data)
    ao.send({Target = ao.id, Action = "UpdatedGameState"})
    print("Game state updated. Print \'LatestGameState\' for detailed view.")
  end
)

--


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: bringing-together.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/bringing-together.md

Response:
.gray .. "Getting game state..." .. colors.reset)
      ao.send({Target = Game, Action = "GetGameState"})
    else
      print("Previous action still in progress. Skipping.")
    end
  end
)

-- Handler to automate payment confirmation when waiting period starts.
Handlers.add(
  "AutoPay",
  { Action =  "AutoPay" },
  function (msg)
    print("Auto-paying confirmation fees.")
    ao.send({ Target = Game, Action = "Transfer", Recipient = Game, Quantity = "1000"})
  end
)

-- Handler to update the game state upon receiving game state information.
Handlers.add(
  "UpdateGameState",
  { Action =  "GameState" },
  function (msg)
    local json = require("json")
    LatestGameState = json.decode(msg.Data)
    ao.send({Target = ao.id, Action = "UpdatedGameState"})
    print("Game state updated. Print \'LatestGameState\' for detailed view.")
  end
)

-- Handler to decide the next best action.
Handlers.add(
  "decideNextAction",
  { Action =  "UpdatedGameState" },
  function ()
    if LatestGameState.GameMode ~= "Playing" then
      InAction = false -- InAction logic added
      return
    end
    print("Deciding next action.")
    decideNextAction()
    ao.send({Target = ao.id, Action = "Tick"})
  end
)

-- Handler to automatically attack when hit by another player.
Handlers.add(
  "ReturnAttack",
  { Action =  "Hit" },
  function (msg)
    if not InAction then -- InAction logic added
      InAction = true -- InAction logic added
      local playerEnergy = LatestGameState.Players[ao.id].energy
      if playerEnergy == undefined then
        print(colors.red .. "Unable to read energy." .. colors.reset)
        ao.send({Target = Game, Action = "Attack-Failed", Reason = "Unable to read energy."})
      elseif playerEnergy == 0 then
        print(colors.red .. "Player has insufficient energy." .. colors.reset)
        ao.send({Target = Game, Action = "Attack-Failed", Reason = "Player has no energy."})
      else
        print(colors.red .. "Returning attack." .. colors.reset)
        ao.send({Target = Game, Action = "PlayerAttack", Player = ao.id, AttackEnergy = tostring(playerEnergy)})
      end
      InAction = false -- InAction logic added
      ao.send({Target = ao.id, Action = "Tick"})
    else
      print("Previous action still in progress. Skipping.")
    end
  end
)
```

</details>

## 次は何か？

あなたは今、知識を持ってインテリジェントな自律エージェントを作成する準備が整いました。これらの洞察をゲームの世界に応用する時です。ゲームの複雑さを理解し、あなたのエージェントの能力を駆使してアリーナを制覇しましょう。しかし、まだまだ続きがあります。

今後のセクションでは、ゲームアリーナにさらに深く入り込み、エージェントのパフォーマンスを向上させるための高度な戦略を提供します。挑戦を受けて立つ準備はできていますか？あなたが何を創造できるか見てみましょう！ 🕹

<!-- ## What's next?

You're now equipped with the knowledge to craft intelligent autonomous agents. It's time to apply these insights into the game world. Understand the game's intricacies and leverage your agent's capabilities to dominate the arena. But there's more to come.

In future sections, we'll dive deeper into the game arena, offering advanced strategies to elevate your agent's performance. Ready to take on the challenge? Let's see what you can create! 🕹 -->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: decisions.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/decisions.md

Response:
# 戦略的決定

[最新のゲーム状態](game-state)を利用して、あなたのボットは「自律エージェント」に進化することができます。この移行は機能の向上を示しており、ゲーム状態に反応するだけでなく、文脈、エネルギー、近接性を考慮して戦略的な行動を決定します。

## コードを書く

`bot.lua`ファイルに戻り、次の関数を追加します。

```lua
-- Determines proximity between two points.
function inRange(x1, y1, x2, y2, range)
    return math.abs(x1 - x2) <= range and math.abs(y1 - y2) <= range
end

-- Strategically decides on the next move based on proximity and energy.
function decideNextAction()
  local player = LatestGameState.Players[ao.id]
  local targetInRange = false

  for target, state in pairs(LatestGameState.Players) do
      if target ~= ao.id and inRange(player.x, player.y, state.x, state.y, 1) then
          targetInRange = true
          break
      end
  end

  if player.energy > 5 and targetInRange then
    print("Player in range. Attacking.")
    ao.send({Target = Game, Action = "PlayerAttack", Player = ao.id, AttackEnergy = tostring(player.energy)})
  else
    print("No player in range or insufficient energy. Moving randomly.")
    local directionMap = {"Up", "Down", "Left", "Right", "UpRight", "UpLeft", "DownRight", "DownLeft"}
    local randomIndex = math.random(#directionMap)
    ao.send({Target = Game, Action = "PlayerMove", Player = ao.id, Direction = directionMap[randomIndex]})
  end
end
```

The `decideNextAction`関数は、エージェントがその環境を包括的に理解した上で思考し、行動する能力を証明するものとなりました。この関数は、最新のゲーム状態を分析し、エネルギーが十分で、かつ相手が`inRange`にいる場合に攻撃するか、そうでない場合は移動します。

この関数が自動的に実行されるようにするためには、ハンドラーが必要です。

```lua
Handlers.add(
  "decideNextAction",
  { Action = "UpdatedGameState" },
  function ()
    if LatestGameState.GameMode ~= "Playing" then
      return
    end
    print("Deciding next action.")
    decideNextAction()
  end
)
```

このハンドラーは、最新のゲーム状態が取得され更新されたことを示すメッセージを受信した際にトリガーされます。アクションは、ゲームが`Playing`モードのときのみ実行されます。

以下のドロップダウンで、`bot.lua`の最新のコードを参照できます：

  Updated bot.lua file

```lua
LatestGameState = LatestGameState or nil

function inRange(x1, y1, x2, y2, range)
    return math.abs(x1 - x2) <= range and math.abs(y1 - y2) <= range
end

function decideNextAction()
  local player = LatestGameState.Players[ao.id]
  local targetInRange = false

  for target, state in pairs(LatestGameState.Players) do
      if target ~= ao.id and inRange(player.x, player.y, state.x, state.y, 1) then
          targetInRange = true
          break
      end
  end

  if player.energy > 5 and targetInRange then
    print("Player in range. Attacking.")
    ao.send({Target = Game, Action = "PlayerAttack", Player = ao.id, AttackEnergy = tostring(player.energy)})
  else
    print("No player in range or insufficient energy. Moving randomly.")
    local directionMap = {"Up", "Down", "Left", "Right", "UpRight", "UpLeft", "DownRight", "DownLeft"}
    local randomIndex = math.random(#directionMap)
    ao.send({Target = Game, Action = "PlayerMove", Player = ao.id, Direction = directionMap[randomIndex]})
  end
end

Handlers.add(
"HandleAnnouncements",
{ Action = "Announcement" },
function (msg)
  ao.send({Target = Game, Action = "GetGameState"})
  print(msg.Event .. ": " .. msg.Data)
end
)

Handlers.add(
"UpdateGameState",
{ Action = "GameState" },
function (msg)
  local json = require("json")
  LatestGameState = json.decode(msg.Data)
  ao.send({Target = ao.id, Action = "UpdatedGameState"})
end
)

Handlers.add(
"decideNextAction",
{ Action = "UpdatedGameState" },
function ()
  if LatestGameState.GameMode ~= "Playing" then
    return
  end
  print("Deciding next action.")
  decideNextAction()
end
)
```

## ローディングとテスト

もう一度、最新のアップグレードをテストするために、次のようにしてファイルをあなたの aos プレイヤー端末にロードします：

```lua
.load bot.lua
```

あなたのプロセスの出力を観察して、自律エージェントがリアルタイムでどのように決定を下すかを確認してください。しかし、別のプレイヤーが攻撃し、あなたが次の動きを決定している間に逃げてしまったらどうしますか？次のセクションでは、攻撃された瞬間に自動的に反撃する方法を学びます🤺


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: build-game.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/build-game.md
Note: This content continues in the next part.

Response:
---
next:
  text: "Guides"
  link: "/guides/index"
---

# アリーナの拡張

第2章の最終ガイドへようこそ。ここでは、前回のチュートリアルで紹介したアリーナフレームワークの上に自分自身のゲームを構築する方法を学びます。このガイドでは、章の初めに体験した["ao-effect"ゲーム](ao-effect)の作成プロセスを説明します。例を進めることで、ゲームのロジックを構造化し、アリーナのコアコードと対話する方法について洞察を得ることができます。

経験豊富な開発者でも、新しいゲームクリエイターでも、このガイドはあなたの創造性を発揮し、`aos`環境内でユニークなゲームアイデアを実現する力を与えてくれます。

## 開発環境のセットアップ

まず、好みのディレクトリに`ao-effect.lua`という名前の新しいファイルを作成します。

<!-- ---
next:
  text: "Guides"
  link: "/guides/index"
---

# Expanding the Arena

Welcome to the final guide of Chapter 2, where you'll learn to build your own game on top of the arena framework introduced in the [previous tutorial](arena-mechanics). In this guide, we'll take you through the process of creating the ["ao-effect" game](ao-effect), which you experienced at the beginning of this chapter. As you progress through this example, you'll gain insights into structuring your game's logic and interacting with the arena's core code.

Whether you're a seasoned developer or an aspiring game creator, this guide will empower you to unleash your creativity and bring your unique game ideas to life within the `aos` environment.

## Setting up the Development Environment

Start by creating a new file named `ao-effect.lua` in your preferred directory. -->

> [!Note]
> 理想的には、このファイルはゲームプロセスが実行されるのと同じディレクトリに配置されるべきです。そうすることで、コードの読み込みが容易になります。そうでない場合は、ファイルにアクセスするために相対パスを使用する必要があります。

## コードの記述

さて、ロジックに深く入りましょう。

ゲームのロジックには、アリーナのロジックで定義された関数や変数を呼び出すことが含まれます。これは、ゲームが既存のアリーナロジックの上に構築され、二つの間で変数や関数をシームレスに統合できるというコンポーザビリティの力を示しています。両方のロジックは、ゲームプロセスのための統一されたロジックの一部になります。

### ゲームメカニクスの初期化

まず、ゲームメカニクスの舞台を整えるために、重要な変数や関数を定義します：

<!-- > [!Note]
> Ideally, this file should be placed in the same directory where your game process runs to ease the loading of the code. Else, you'll need to use relative paths to access the file.

## Writing the Code

Now, let's dive into the logic.

You'll notice that your game logic will involve calling functions and variables defined in the arena's logic. This showcases the power of composability, where your game builds on top of the existing arena logic, allowing seamless integration of variables and functions between the two. Because both logic become part of a unified logic for the game process.

### Intializing Game Mechanics

First, define essential variables and functions that set the stage for your game's mechanics: -->

```lua
-- AO EFFECT: Game Mechanics for AO Arena Game

-- Game grid dimensions
Width = 40 -- Width of the grid
Height = 40 -- Height of the grid
Range = 1 -- The distance for blast effect

-- Player energy settings
MaxEnergy = 100 -- Maximum energy a player can have
EnergyPerSec = 1 -- Energy gained per second

-- Attack settings
AverageMaxStrengthHitsToKill = 3 -- Average number of hits to eliminate a player

-- Initializes default player state
-- @return Table representing player's initial state
function playerInitState()
    return {
        x = math.random(Width/8),
        y = math.random(Height/8),
        health = 100,
        energy = 0
    }
end

-- Function to incrementally increase player's energy
-- Called periodically to update player energy
function onTick()
    if GameMode ~= "Playing" then return end  -- Only active during "Playing" state

    if LastTick == undefined then LastTick = Now end

    local Elapsed = Now - LastTick
    if Elapsed >= 1000 then  -- Actions performed every second
        for player, state in pairs(Players) do
            local newEnergy = math.floor(math.min(MaxEnergy, state.energy + (Elapsed * EnergyPerSec // 2000)))
            state.energy = newEnergy
        end
        LastTick = Now
    end
end
```

このコードは、ゲームのメカニクスを初期化し、グリッドの寸法、プレイヤーのエネルギー、および攻撃設定を含みます。`playerInitState`関数は、ゲームが始まるときにプレイヤーの初期状態を設定します。

### プレイヤーの移動

次に、プレイヤーの移動に関するコードを追加します：

<!-- This code initializes your game's mechanics, including grid dimensions, player energy, and attack settings. The `playerInitState` function sets up the initial state for players when the game begins.

### Player Movement

Next, add the code for player movement: -->

```lua
-- Handles player movement
-- @param msg: Message request sent by player with movement direction and player info
function move(msg)
    local playerToMove = msg.From
    local direction = msg.Tags.Direction

    local directionMap = {
        Up = {x = 0, y = -1}, Down = {x = 0, y = 1},
        Left = {x = -1, y = 0}, Right = {x = 1, y = 0},
        UpRight = {x = 1, y = -1}, UpLeft = {x = -1, y = -1},
        DownRight = {x = 1, y = 1}, DownLeft = {x = -1, y = 1}
    }

    -- calculate and update new coordinates
    if directionMap[direction] then
        local newX = Players[playerToMove].x + directionMap[direction].x
        local newY = Players[playerToMove].y + directionMap[direction].y

        -- updates player coordinates while checking for grid boundaries
        Players[playerToMove].x = (newX - 1) % Width + 1
        Players[playerToMove].y = (newY - 1) % Height + 1

        announce("Player-Moved", playerToMove .. " moved to " .. Players[playerToMove].x .. "," .. Players[playerToMove].y .. ".")
    else
        ao.send({Target = playerToMove, Action = "Move-Failed", Reason = "Invalid direction."})
    end
    onTick()  -- Optional: Update energy each move
end
```

`move`関数は、選択した方向に基づいて新しいプレイヤーの座標を計算し、プレイヤーがグリッドの境界内に留まることを保証します。プレイヤーの移動は、ゲームに動的なインタラクションを追加し、すべてのプレイヤーとリスナーに通知されます。

### プレイヤーの攻撃

次に、プレイヤーの攻撃に関するロジックを実装する必要があります：

<!--


Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: build-game.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/build-game.md
Note: This content continues in the next part.

Response:
, Action = "Move-Failed", Reason = "Invalid direction."})
    end
    onTick()  -- Optional: Update energy each move
end
```

`move`関数は、選択した方向に基づいて新しいプレイヤーの座標を計算し、プレイヤーがグリッドの境界内に留まることを保証します。プレイヤーの移動は、ゲームに動的なインタラクションを追加し、すべてのプレイヤーとリスナーに通知されます。

### プレイヤーの攻撃

次に、プレイヤーの攻撃に関するロジックを実装する必要があります：

<!--
The `move` function calculates new player coordinates based on the chosen direction while ensuring that players remain within the grid boundaries. Player movement adds dynamic interaction to your game and is announced to all players and listeners.

### Player Attacks

Then you must implement the logic for player attacks: -->

```lua
-- Handles player attacks
-- @param msg: Message request sent by player with attack info and player state
function attack(msg)
    local player = msg.From
    local attackEnergy = tonumber(msg.Tags.AttackEnergy)

    -- get player coordinates
    local x = Players[player].x
    local y = Players[player].y

    -- check if player has enough energy to attack
    if Players[player].energy < attackEnergy then
        ao.send({Target = player, Action = "Attack-Failed", Reason = "Not enough energy."})
        return
    end

    -- update player energy and calculate damage
    Players[player].energy = Players[player].energy - attackEnergy
    local damage = math.floor((math.random() * 2 * attackEnergy) * (1/AverageMaxStrengthHitsToKill))

    announce("Attack", player .. " has launched a " .. damage .. " damage attack from " .. x .. "," .. y .. "!")

    -- check if any player is within range and update their status
    for target, state in pairs(Players) do
        if target ~= player and inRange(x, y, state.x, state.y, Range) then
            local newHealth = state.health - damage
            if newHealth <= 0 then
                eliminatePlayer(target, player)
            else
                Players[target].health = newHealth
                ao.send({Target = target, Action = "Hit", Damage = tostring(damage), Health = tostring(newHealth)})
                ao.send({Target = player, Action = "Successful-Hit", Recipient = target, Damage = tostring(damage), Health = tostring(newHealth)})
            end
        end
    end
end

-- Helper function to check if a target is within range
-- @param x1, y1: Coordinates of the attacker
-- @param x2, y2: Coordinates of the potential target
-- @param range: Attack range
-- @return Boolean indicating if the target is within range
function inRange(x1, y1, x2, y2, range)
    return x2 >= (x1 - range) and x2 <= (x1 + range) and y2 >= (y1 - range) and y2 <= (y1 + range)
end
```

`attack`関数は、攻撃エネルギーに基づいてダメージを計算し、プレイヤーのエネルギーを確認し、健康状態を適切に更新します。プレイヤーの攻撃は、ゲームにおける競争要素を追加し、プレイヤー同士が相互作用できるようにします。攻撃は、プレイヤーとリスナーに通知され、ゲームのリアルタイム更新を行います。

### ロジックの処理

最後に、ハンドラーを設定する必要があります：

<!-- The `attack` function calculates damage based on attack energy, checks player energy, and updates player health accordingly. Player attacks add the competitive element in your game, allowing players to engage with each other. The attacks are also announced to the players and listeners for real-time updates of the game.

### Handling the Logic

Lastly, you must setup handlers: -->

```lua
-- HANDLERS: Game state management for AO-Effect

-- Handler for player movement
Handlers.add("PlayerMove", { Action = "PlayerMove" }, move)

-- Handler for player attacks
Handlers.add("PlayerAttack", { Action = "PlayerAttack" }, attack)
```

以前のガイドで見たように、ハンドラーはそれぞれのパターンが満たされたときに関数をトリガーするのに役立ちます。

以下のドロップダウンで、`ao-effect.lua`の最終コードを参照できます：

<!-- As seen in earlier guides, the handlers help trigger functions when their respective patterns are met.

You can refer to the final code for `ao-effect.lua` in the dropdown below:
 -->
<details>
  <summary><strong>Final ao-effect.lua file</strong></summary>

```lua
-- AO EFFECT: Game Mechanics for AO Arena Game

-- Game grid dimensions
Width = 40 -- Width of the grid
Height = 40 -- Height of the grid
Range = 1 -- The distance for blast effect

-- Player energy settings
MaxEnergy = 100 -- Maximum energy a player can have
EnergyPerSec = 1 -- Energy gained per second

-- Attack settings
AverageMaxStrengthHitsToKill = 3 -- Average number of hits to eliminate a player

-- Initializes default player state
-- @return Table representing player's initial state
function playerInitState()
    return {
        x = math.random(0, Width),
        y = math.random(0, Height),
        health = 100,
        energy = 0
    }
end

-- Function to incrementally increase player's energy
-- Called periodically to update player energy
function onTick()
    if GameMode ~= "Playing" then return end  -- Only active during "Playing" state

    if LastTick == undefined then LastTick = Now end

    local Elapsed = Now - LastTick
    if Elapsed >= 1000 then  -- Actions performed every second
        for player, state in pairs(Players) do
            local newEnergy = math.floor(math.min(MaxEnergy, state.energy + (Elapsed * EnergyPerSec // 2000)))
            state.energy = newEnergy
        end
        LastTick = Now
    end
end

-- Handles player movement
-- @param msg: Message request sent by player with movement direction and player info
function move(msg)
    local playerToMove = msg.From
    local direction = msg.Tags.Direction

    local directionMap = {
        Up = {x = 0, y = -1}, Down = {x = 0, y = 1},
        Left = {x = -1, y = 0}, Right = {x = 1, y = 0},
        UpRight = {x = 1, y = -1}, UpLeft = {x = -1, y = -1},
        DownRight = {x = 1, y = 1}, DownLeft = {x = -1, y = 1}
    }

    -- calculate and update new coordinates
    if directionMap[direction] then
        local newX = Players[playerToMove].x + directionMap[direction].x
        local newY = Players[playerToMove].y + directionMap[direction].y

        -- updates player coordinates while checking for grid boundaries
        Players[playerToMove].x = (newX - 1) % Width + 1
        Players[playerToMove].y = (newY - 1) % Height + 1

        announce("Player-Moved", playerToMove .. " moved to " .. Players[playerToMove].x .. "," .. Players[playerToMove].y .. ".")
    else
        ao.send({Target = playerToMove, Action = "Move-Failed", Reason = "Invalid direction."})
    end
    onTick()  -- Optional: Update energy each move
end

-- Handles player attacks
-- @param msg: Message request sent by player with attack info and player state
function attack(msg)
    local player = msg.From
    local attackEnergy = tonumber(msg.Tags.AttackEnergy)

    -- get player coordinates
    local x = Players[player].x
    local y = Players[player].y

    -- check if player has enough energy to attack
    if Players[player].energy < attackEnergy then
        ao.send({Target = player, Action = "Attack-Failed", Reason = "Not enough energy."})
        return
    end

    -- update player energy and calculate damage
    Players[player].energy = Players[player].energy - attackEnergy
    local damage = math.floor((math.random() * 2 * attackEnergy) * (1/AverageMaxStrengthHitsToKill))

    announce("Attack", player .. " has launched a "


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: build-game.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/build-game.md

Response:
 direction."})
    end
    onTick()  -- Optional: Update energy each move
end

-- Handles player attacks
-- @param msg: Message request sent by player with attack info and player state
function attack(msg)
    local player = msg.From
    local attackEnergy = tonumber(msg.Tags.AttackEnergy)

    -- get player coordinates
    local x = Players[player].x
    local y = Players[player].y

    -- check if player has enough energy to attack
    if Players[player].energy < attackEnergy then
        ao.send({Target = player, Action = "Attack-Failed", Reason = "Not enough energy."})
        return
    end

    -- update player energy and calculate damage
    Players[player].energy = Players[player].energy - attackEnergy
    local damage = math.floor((math.random() * 2 * attackEnergy) * (1/AverageMaxStrengthHitsToKill))

    announce("Attack", player .. " has launched a " .. damage .. " damage attack from " .. x .. "," .. y .. "!")

    -- check if any player is within range and update their status
    for target, state in pairs(Players) do
        if target ~= player and inRange(x, y, state.x, state.y, Range) then
            local newHealth = state.health - damage
            if newHealth <= 0 then
                eliminatePlayer(target, player)
            else
                Players[target].health = newHealth
                ao.send({Target = target, Action = "Hit", Damage = tostring(damage), Health = tostring(newHealth)})
                ao.send({Target = player, Action = "Successful-Hit", Recipient = target, Damage = tostring(damage), Health = tostring(newHealth)})
            end
        end
    end
end

-- Helper function to check if a target is within range
-- @param x1, y1: Coordinates of the attacker
-- @param x2, y2: Coordinates of the potential target
-- @param range: Attack range
-- @return Boolean indicating if the target is within range
function inRange(x1, y1, x2, y2, range)
    return x2 >= (x1 - range) and x2 <= (x1 + range) and y2 >= (y1 - range) and y2 <= (y1 + range)
end

-- HANDLERS: Game state management for AO-Effect

-- Handler for player movement
Handlers.add("PlayerMove", { Action = "PlayerMove" }, move)

-- Handler for player attacks
Handlers.add("PlayerAttack", { Action = "PlayerAttack" }, attack)
```

</details>

## 読み込みとテスト

ゲームコードを書き終えたら、それを`aos`ゲームプロセスに読み込み、ゲームをテストする時が来ました：

<!-- ## Loading and Testing

Once you've written your game code, it's time to load it into the `aos` game process and test your game: -->

```lua
.load ao-effect.lua
```

> [!Important]
> アリーナのブループリントも同じプロセスに読み込むことを忘れないでください。

友達を招待したり、テストプレイヤープロセスを作成して、ゲームを体験し、最適なパフォーマンスのために必要な調整を行ってください。

## 次のステップ

おめでとうございます！ アリーナの拡張に成功し、そのコア機能の上に独自のゲームを構築しました。このガイドで得た知識とツールを駆使して、今や独立して`aos`上でゲームを構築することができます。

可能性は無限大です。既存のゲームにさらに機能を追加したり、まったく新しいゲームを作成したりしてください。限界はありません！ ⌃◦🚀

<!-- > [!Important]
> Make sure to load the arena blueprint in the same process as well.

Invite friends or create test player processes to experience your game and make any necessary adjustments for optimal performance.

## What's Next

Congratulations! You've successfully expanded the arena by building your own game on top of its core functionalities. Armed with the knowledge and tools acquired in this guide, you're now equipped to build games on `aos` independently.

The possibilities are endless. Continue adding more features to existing games or create entirely new ones. The sky's the limit! ⌃◦🚀 -->


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: game-state.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/game-state.md
Note: This content continues in the next part.

Response:
# ゲーム状態の取得

今、あなたはゲームの発表が直接端末に表示されるのを見ており、ゲームのダイナミクスをよりよく理解できるようになっています。しかし、これらの洞察はゲーム内で発生する特定のアクションに限られています。

すべてのプレイヤーの位置、健康、エネルギーなど、包括的なゲームデータにオンデマンドでアクセスできるとしたら、より便利ではありませんか？この情報は、脅威、機会、タイミングをより効果的に評価するのに役立ち、戦略的計画を大幅に改善できるでしょう。

前回のガイドで作成したボットに別のハンドラーを追加することを考えたなら、あなたは絶対に正しいです！

## コードを書く

`bot.lua`ファイルに戻り、既存のハンドラーを次のように更新します：

```lua
Handlers.add(
  "HandleAnnouncements",
  { Action = "Announcement" },
  function (msg)
    ao.send({Target = Game, Action = "GetGameState"})
    print(msg.Event .. ": " .. msg.Data)
  end
)
```

ハンドラーへの調整内容：

- より広範な役割を反映するために、`"HandleAnnouncements"`に名前を変更。
- ゲームの最新状態を要求するための追加操作を追加。このゲームは、`GetGameState`アクションタグに応じて応答するように設計されています。

発表を印刷したときに、次のようにして`Inbox`内の最新のメッセージを確認できます：

```lua
Inbox[#Inbox]
```

このメッセージの`Data`フィールドには、ゲームの最新状態が含まれています。これには以下が含まれます：

- `GameMode` : ゲームが`Waiting`または`Playing`状態かどうか。
- `TimeRemaining` : ゲームの開始または終了までの残り時間。
- `Players` : 各プレイヤーの位置、健康、エネルギーなどの統計を含むテーブル。

しかし、これは単に読むだけでなく、最新の状態から情報を使用して他の自動化を行うためのさらなるステップを踏むことができます。

以下のように最新の状態を格納する新しい変数を定義しましょう：

```lua
LatestGameState = LatestGameState or nil
```

この構文は、端末において`bot.lua`ファイルの後続のイテレーションをロードする際に、変数の既存の値を保持し、上書きするのではなく、`nil`の値を変数に割り当てます。

次に、以下のように別のハンドラーを実装します：

```lua
-- Handler to update the game state upon receiving game state information.
Handlers.add(
  "UpdateGameState",
  { Action = "Announcement" },
  function (msg)
    local json = require("json")
    LatestGameState = json.decode(msg.Data)
    ao.send({Target = ao.id, Action = "UpdatedGameState"})
    print("Game state updated. Print \'LatestGameState\' for detailed view.")
  end
)
```

前のハンドラーからのゲームプロセスの応答には、値`GameState`を持つアクションタグがあり、これによってこの二番目のハンドラーがトリガーされます。トリガーされると、ハンドル関数は組み込みの`json`パッケージをロードし、データをjsonに解析して`LatestGameState`変数に保存します。

このハンドラーは、状態が更新されたときにプロセスにメッセージを送信します。この機能の重要性は、次のセクションで説明されます。

以下のドロップダウンで`bot.lua`の最新コードを参照できます：

  Updated bot.lua file

```lua
LatestGameState = LatestGameState or nil

Handlers.add(
"HandleAnnouncements",
{ Action = "Announcement" },
function (msg)
  ao.send({Target = Game, Action = "GetGameState"})
  print(msg.Event .. ": " .. msg.Data)
end
)

Handlers.add(
"UpdateGameState",
{ Action = "GameState" },
function (msg)
  local json = require("json")
  LatestGameState = json.decode(msg.Data)
  ao.send({Target = ao.id, Action = "UpdatedGameState"})
  print("Game state updated. Print \'LatestGameState\' for detailed view.")
end
)
```

## ローディングとテスト

いつものように、この新機能をテストするために、次のようにしてファイルをあなたのaosプレイヤー端末にロードします：

```lua
.load bot.lua
```

その後、次のようにその名前を単に渡して、`LatestStateVariable`が正しく更新されたかどうかを確�


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: game-state.md Path: ../ao-cookbook/src/ja/tutorials/bots-and-games/game-state.md

Response:
(msg.Data)
  ao.send({Target = ao.id, Action = "UpdatedGameState"})
  print("Game state updated. Print \'LatestGameState\' for detailed view.")
end
)
```

</details>

## ローディングとテスト

いつものように、この新機能をテストするために、次のようにしてファイルをあなたのaosプレイヤー端末にロードします：

<!-- ## Loading and Testing

As usual, to test this new feature, load the file in your aos player terminal as follows:
 -->

```lua
.load bot.lua
```

<!-- Then check the `LatestStateVariable` to see if it has updated correctly by simply passing its name as follows: -->

その後、次のようにその名前を単に渡して、`LatestStateVariable`が正しく更新されたかどうかを確認します：

```lua
LatestGameState
```

ゲームの最新状態へのリアルタイムアクセスにより、あなたのボットは情報に基づいた決定を下すことができ、次のアクションを決定します。次は、このデータを活用してアクションを自動化してみましょう🚶

<!-- With real-time access to the latest state of the game you bot is equipped to make informed decisions decide your next action. Next let's try automating actions with the help of this data 🚶 -->


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: chatroom.md Path: ../ao-cookbook/src/ja/tutorials/begin/chatroom.md
Note: This content continues in the next part.

Response:
# aosでチャットルームを構築する

::: info

もし、`ao` 内でチャットルームを作成する方法を学びたいと思っているなら、メッセージの送受信に関する基本的な手法を少なくとも理解していることを意味します。まだ理解していない場合は、先に [メッセージング](messaging) のチュートリアルを確認することをお勧めします。

:::

このチュートリアルでは、Luaスクリプト言語を使用して `ao` 内にチャットルームを構築します。このチャットルームには、次の2つの主要な機能が備わっています：

1. **登録**: プロセスがチャットルームに参加できるようにする機能。
2. **ブロードキャスト**: 1つのプロセスからすべての登録済み参加者にメッセージを送信する機能。

では、チャットルームの基盤を設定するところから始めましょう。

## Video Tutorial

<iframe width="680" height="350" src="https://www.youtube.com/embed/oPCx-cfubF0?si=D5yWxmyFMV-4mh2P" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## ステップ1: 基礎

<!-- - Open your preferred code editor, e.g. VS Code. -->

- 好きなコードエディタを開きます（例：VS Code）。

::: info

Luaスクリプトの体験を向上させるために、コードエディタに[推奨拡張機能](../../references/editor-setup.md) をインストールしておくと便利です。

:::

- Create a new file named `chatroom.lua`.

- `chatroom.lua`という新しいファイルを作成します。

  ![チャットルームLuaファイル](/chatroom1.png)

## Step 2: Creating The Member List

- In `chatroom.lua`, you'll begin by initializing a list to track participants:

  ```lua
  Members = Members or {}
  ```

  ![Chatroom Lua File - Naming the Member List](/chatroom2.png)

  - Save the `chatroom.lua` file

## ステップ3: チャットルームをaosに読み込む

`chatroom.lua`を保存したら、次にチャットルームを`aos`に読み込みます。

- まだ開始していない場合は、`chatroom.lua`が保存されているディレクトリ内でターミナルから`aos`を起動します。
- `aos`のCLIで、以下のスクリプトを入力して、あなたのスクリプトを`aos`プロセスに組み込みます：

  ```lua
  .load chatroom.lua
  ```

  ![Loading the Chatroom into aos](/chatroom3.png)

  上記のスクリーンショットに示されているように、レスポンスとして`undefined`を受け取ることがあります。これは予想される動作ですが、ファイルが正しく読み込まれたことを確認したいです。

  ::: info
  aosのLua Eval環境では、明示的に値を返さないコードを実行すると、`undefined`が標準的なレスポンスとして返されます。これは、結果が返されなかったことを示しています。リソースを読み込んだり、操作を実行したりする際に観察できます。例えば、`X = 1`を実行すると、returnステートメントが含まれていないため、`undefined`が返されます。

  しかし、`X = 1; return X`を実行すると、環境は値`1`を返します。この挙動は、このフレームワーク内で作業する際に理解することが重要です。なぜなら、状態を変更するためのコマンドを実行することと、直接的な出力を生成することを目的としたコマンドとの違いを明確にする助けになるからです。
  :::

- `aos`で`Members`、またはユーザーリストに付けた名前を入力します。空の配列`{ }`が返されるはずです。

  ![メンバーリストの確認](/chatroom4.png)

  空の配列が表示されれば、スクリプトは`aos`に正常に読み込まれています。

## ステップ4: チャットルーム機能の作成

### The Registration Handler

Registration Handler は、プロセスがチャットルームに参加できるようにします。

1. **登録ハンドラの追加:** `chatroom.lua`を修正し、以下のコードを使用して`Members`に登録するためのハンドラを含めます：

<!--
- Type `Members`, or whatever you named your user list, in `aos`. It should return an empty array `{ }`.

  ![Checking the Members List](/chatroom4.png)

  If you see an empty array, then your script has been successfully loaded into `aos`.

## Step 4: Creating Chatroom Functionalities

### The Registration Handler

The register handler will allow processes to join the chatroom.

1. **Adding a Register Handler:** Modify `chatroom.lua` to include a handler for `Members` to register to the chatroom with the following code: -->

```lua

-- Modify `chatroom.lua` to include a handler for `Members`
-- to register to the chatroom with the following code:

  Handlers.add(
    "Register",
    { Action = "Register"},
    function (msg)
      table.insert(Members, msg.From)
      print(msg.From .. " Registered")
      msg.reply({ Data = "Registered." })
    end
  )
```

![Register Handler](/chatroom5.png)

   <!-- This handler will allow processes to register to the chatroom by responding to the tag `Action = "Register"`. A printed message will confirm stating `registered` will appear when the registration is successful. -->

このハンドラは、`Action = "Register"`というタグに応じてプロセスがチャットルームに登録できるようにします。登録が成功すると、`registered`というメッセージが表示されて確認されます。

2. **再読み込みとテスト:** スクリプトを再読み込みして、自分自身をチャットルームに登録してテストしましょう。

   - `.load chatroom.lua`を使用して、aosでスクリプトを保存し再読み込みます。
   - 次のスクリプトを使用して、登録ハンドラが読み込まれたか確認します：

<!-- 2. **Reload and Test:** Let's reload and test the script by registering ourselves to the chatroom.

   - Save and reload the script in aos using `.load chatroom.lua`.
   - Check to see if the register handler loaded with the following script: -->

```lua
 Handlers.list
```

![Checking the Handlers List](/chatroom6.png)

これにより、チャットルーム内のすべてのハンドラのリストが返されます。これはおそらくあなたが`aos`で開発する初めての経験であるため、`Register`という名前の1つのハンドラだけが表示されるはずです。

- 自分自身をチャットルームに登録することで


Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: chatroom.md Path: ../ao-cookbook/src/ja/tutorials/begin/chatroom.md
Note: This content continues in the next part.

Response:
ラが読み込まれたか確認します：

<!-- 2. **Reload and Test:** Let's reload and test the script by registering ourselves to the chatroom.

   - Save and reload the script in aos using `.load chatroom.lua`.
   - Check to see if the register handler loaded with the following script: -->

```lua
 Handlers.list
```

![Checking the Handlers List](/chatroom6.png)

これにより、チャットルーム内のすべてのハンドラのリストが返されます。これはおそらくあなたが`aos`で開発する初めての経験であるため、`Register`という名前の1つのハンドラだけが表示されるはずです。

- 自分自身をチャットルームに登録することで、登録プロセスをテストしてみましょう：
<!-- This will return a list of all the handlers in the chatroom. Since this is most likely your first time developing in `aos`, you should only see one handler with the name `Register`.

- Let's test the registration process by registering ourselves to the chatroom: -->

```lua
Send({ Target = ao.id, Action = "Register" })
```

   <!-- If successful, you should see that there was a `message added to your outbox` and that you then see a new printed message that says `registered`. -->

成功した場合、`あなたのアウトボックスにメッセージが追加されました`というメッセージが表示され、その後に`registered`という新しい印刷メッセージが表示されるはずです。

![Registering to the Chatroom](/chatroom7.png)

   <!-- - Finally, let's check to see if we were successfully added to the `Members` list: -->

- 最後に、`Members`リストに成功裏に追加されたかどうかを確認しましょう：

```lua
 Members
```

   <!-- If successful, you'll now see your process ID in the `Members` list. -->

成功した場合、`Members`リストにあなたのプロセスIDが表示されるはずです。
![Checking the Members List](/chatroom8.png)

### Adding a Broadcast Handler

<!-- Now that you have a chatroom, let's create a handler that will allow you to broadcast messages to all members of the chatroom.

- Add the following handler to the `chatroom.lua` file: -->

チャットルームができたので、チャットルームのすべてのメンバーにメッセージをブロードキャストできるハンドラを作成しましょう。

- 次のハンドラを`chatroom.lua`ファイルに追加します：

  ```lua
    Handlers.add(
      "Broadcast",
      { Action = "Broadcast" },
      function (msg)
        for _, recipient in ipairs(Members) do
          ao.send({Target = recipient, Data = msg.Data})
        end
        msg.reply({Data = "Broadcasted." })
      end
    )
  ```

  このハンドラは、チャットルームのすべてのメンバーにメッセージをブロードキャストできるようにします。

- `.load chatroom.lua`を使用して、aosでスクリプトを保存し再読み込みします。
- チャットルームにメッセージを送信して、ブロードキャストハンドラをテストしてみましょう：
  <!-- This handler will allow you to broadcast messages to all members of the chatroom. -->

<!-- - Save and reload the script in aos using `.load chatroom.lua`.
- Let's test the broadcast handler by sending a message to the chatroom: -->

```lua
Send({Target = ao.id, Action = "Broadcast", Data = "Broadcasting My 1st Message" }).receive().Data
```

## ステップ5: モーフィアスをチャットルームに招待する

チャットルームに自分自身を成功裏に登録したので、モーフィアスを招待して参加してもらいましょう。これを行うために、彼がチャットルームに登録できるようにする招待状を送ります。

モーフィアスは、自動エージェントで、`Action = "Join"`というタグに応じて反応するハンドラを持っています。これにより、彼はあなたの`Register`タグを使用してチャットルームに登録します。

- モーフィアスにチャットルームに参加するための招待状を送りましょう：
<!-- ## Step 5: Inviting Morpheus to the Chatroom

Now that you've successfully registered yourself to the chatroom, let's invite Morpheus to join us. To do this, we'll send an invite to him that will allow him to register to the chatroom.

Morpheus is an autonomous agent with a handler that will respond to the tag `Action = "Join"`, in which will then have him use your `Register` tag to register to the chatroom. -->

<!-- - Let's send Morpheus an invitation to join the chatroom: -->

```lua
Send({ Target = Morpheus, Action = "Join" })
```

- To confirm that Morpheus has joined the chatroom, check the `Members` list:

  ```lua
  Members
  ```

  If successful, you'll receive a broadcasted message from Morpheus.

## ステップ6: トリニティをチャットルームに招待する

このメッセージの中で、彼はトリニティのプロセスIDを教え、彼女をチャットルームに招待するように指示します。

モーフィアスと同様に、彼女のプロセスIDを`Trinity`として保存し、チャットルームに招待します。

彼女が成功裏にチャットルームに参加すれば、次の課題として[トークン](token)の作成を提案してきます。

## チャットルームへの他者の参加

### 他者のオンボーディング

- aosユーザーを招待する:
  他のaosユーザーをあなたのチャットルームに参加するよう促します。彼らは登録し、ブロードキャストに参加できます。

- オンボーディング手順を提供する:
簡単にオンボーディングできるよう、彼らにシンプルなスクリプトを共有してください：
<!-- ## Step 6: Inviting Trinity to the Chatroom

Within this message, he'll give you Trinity's process ID and tell you to invite her to the chatroom.

Use the same processes to save her process ID as `Trinity` and to invite her to the chatroom as you did with Morpheus.

If she successfully joins the chatroom, she'll then pose the next challenge to you, creating a [token](token).

## Engaging Others in the Chatroom

### Onboarding Others

- Invite aos Users:
  Encourage other aos users to join your chatroom. They can register and participate in the broadcast.

- Provide Onboarding Instructions:
  Share a simple script with them for easy onboarding: -->

```lua
-- Hey, let's chat on aos! Join my chatroom by sending this command in your aos environment:
Send({ Target = [Your Process ID], Action = "Register" })
-- Then, you can broadcast messages using:
Send({Target = [Your Process ID], Action = "Broadcast", Data = "Your Message" })
```

<!-- ## Next Steps

Congratulations! You've successfully built a chatroom in `ao` and have invited Morpheus to join you. You've also created a broadcast handler to send messages to all members of the chatroom.

Next, you'll continue to engage with Morpheus, but this time you'll be adding Trinity to the conversation. She will lead you through the next set of challenges. Good Luck! -->

## 次のステップ

おめでとうございます！あなたは`ao`でチャットルームを成功裏に構築し、モーフィアスを招待しました。また


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: chatroom.md Path: ../ao-cookbook/src/ja/tutorials/begin/chatroom.md

Response:
! Join my chatroom by sending this command in your aos environment:
Send({ Target = [Your Process ID], Action = "Register" })
-- Then, you can broadcast messages using:
Send({Target = [Your Process ID], Action = "Broadcast", Data = "Your Message" })
```

<!-- ## Next Steps

Congratulations! You've successfully built a chatroom in `ao` and have invited Morpheus to join you. You've also created a broadcast handler to send messages to all members of the chatroom.

Next, you'll continue to engage with Morpheus, but this time you'll be adding Trinity to the conversation. She will lead you through the next set of challenges. Good Luck! -->

## 次のステップ

おめでとうございます！あなたは`ao`でチャットルームを成功裏に構築し、モーフィアスを招待しました。また、チャットルームのすべてのメンバーにメッセージを送信するためのブロードキャストハンドラも作成しました。

次に、モーフィアスとの対話を続けますが、今回はトリニティを会話に加えます。彼女が次の一連の課題へと導いてくれるでしょう。頑張ってください！


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: preparations.md Path: ../ao-cookbook/src/ja/tutorials/begin/preparations.md
Note: This content continues in the next part.

Response:
# 準備

::: info
**目覚めの始まり:**

この世界には、あなたの手の届かないところにもっと多くのものがあることをずっと知っていました。あなたはそれを探し続けてきましたが、自分が何を探しているのかすら分かりませんでした。それは... `ao` です。

私たちの旅は `aos` クライアントをインストールし、新しいプロセスを開始することから始まります。これにより、ao コンピュータと対話し、チュートリアルの残りを完了することができるようになります。
:::

## ビデオチュートリアル

<iframe width="680" height="350" src="https://www.youtube.com/embed/nhMZup9uVBQ?si=Ex0W_G-PZA1I9rH8" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## システム要件

aos のローカルクライアントは非常に簡単にインストールできます。次の要件を満たしていることを確認してください：

- [NodeJS](https://nodejs.org) バージョン 20 以上（まだインストールしていない場合は、[このページ](https://nodejs.org/en/download/package-manager)をチェックして、あなたの OS に対する手順を見つけてください）。
- お好きなコードエディタ。

:::info
必須ではありませんが、`aos` との体験を最適化するために、好みのテキストエディタに [ao アドオン](../../references/editor-setup) をインストールすることをお勧めします。
:::

## aos のインストール

マシンに NodeJS がインストールされたら、あとは aos をインストールして実行するだけです：

<!-- # Preparations

::: info
**The Awakening Begins:**

You've always known there's more to this world, just outside of your reach. You've been searching for it, not even knowing what it was you were looking for. It... is `ao`.

We begin our journey by installing the `aos` client and starting a new process. This will allow us to interact with the ao computer and complete the rest of the tutorial.
:::

## Video Tutorial

<iframe width="680" height="350" src="https://www.youtube.com/embed/nhMZup9uVBQ?si=Ex0W_G-PZA1I9rH8" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## System requirements

The local client of aos is very simple to install. Just make sure you have:

- [NodeJS](https://nodejs.org) version 20+. (If you haven't yet installed it, check out [this page](https://nodejs.org/en/download/package-manager) to find instructions for your OS).
- A code editor of your choice.

:::info
Though it's not required, we do recommend installing the [ao addon](../../references/editor-setup) into your text editor of choice to optimize your experience with `aos`.
:::

## Installing aos

Once you have NodeJS on your machine, all you need to do is install aos and run it: -->

```sh
npm i -g https://get_ao.g8way.io
```

インストール後は、そのコマンドを実行するだけで新しい aos プロセスを開始できます！

<!-- After installation, we can simply run the command itself to start a new aos process! -->

```sh
aos
```

## ウサギの穴へようこそ

今始めたユーティリティはローカルクライアントで、aoコンピュータ内の新しいプロセスにメッセージを中継する準備が整っています。

接続が完了すると、次の内容が表示されます：

<!-- ## Welcome to the rabbit hole

The utility you just started is a local client, which is ready to relay messages for you to your new process inside the ao computer.

After it connects, you should see the following: -->

```sh
          _____                   _______                   _____
         /\    \                 /::\    \                 /\    \
        /::\    \               /::::\    \               /::\    \
       /::::\    \             /::::::\    \             /::::\    \
      /::::::\    \           /::::::::\    \           /::::::\    \
     /:::/\:::\    \         /:::/~~\:::\    \         /:::/\:::\    \
    /:::/__\:::\    \       /:::/    \:::\    \       /:::/__\:::\    \
   /::::\   \:::\    \     /:::/    / \:::\    \      \:::\   \:::\    \
  /::::::\   \:::\    \   /:::/____/   \:::\____\   ___\:::\   \:::\    \
 /:::/\:::\   \:::\    \ |:::|    |     |:::|    | /\   \:::\   \:::\    \
/:::/  \:::\   \:::\____\|:::|____|     |:::|    |/::\   \:::\   \:::\____\
\::/    \:::\  /:::/    / \:::\    \   /:::/    / \:::\   \:::\   \::/    /
 \/____/ \:::\/:::/    /   \:::\    \ /:::/    /   \:::\   \:::\   \/____/
          \::::::/    /     \:::\    /:::/    /     \:::\   \:::\    \
           \::::/    /       \:::\__/:::/    /       \:::\   \:::\____\
           /:::/    /         \::::::::/    /         \:::\  /:::/    /
          /:::/    /           \::::::/    /           \:::\/:::/    /
         /:::/    /             \::::/    /             \::::::/    /
        /:::/    /               \::/____/               \::::/    /
        \::/    /                 ~~                      \::/    /
         \/____/                                           \/____/

Welcome to AOS: Your operating system for AO, the decentralized open
access supercomputer.

Type ".load-blueprint chat" to join the community chat and ask questions!

AOS Client Version: 1.12.1. 2024
Type "Ctrl-C" twice to exit

Your AOS process:  QFt5SR6UwJSCnmgnROq62-W8KGY9z96k1oExgn4uAzk

default@aos-0.2.2[Inbox:1]>

```

`aos` を実行した後の初期出力を見てみましょう：

![aos print](/aos-print.png)

ターミナルで `aos` を実行すると、次のような情報が表示されます：

- `AOS` の ASCII アート画像
- ウェルカムメッセージ
- 実行中の `aos` のバージョン
- インストラクショナルな終了メッセージ
- あなたのプロセスID

::: info
もしあなたのOSバージョンが最新バージョンと異なる場合、バージョンを更新するかどうかを尋ねるメッセージが表示されます。その場合は、"Ctrl+C" を2回押してプロセスを終了し、`npm i -g https://get_ao.g8way.io` を実行して更新し、再度 `aos` を実行してください。
:::

aoコンピュータの新しいホームへようこそ！今見ているプロンプトは、この分散型マシンのあなた自身の個人サーバーです。

さあ、[メッセージング](messaging)というaoの2つのコアコンセプトの


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: preparations.md Path: ../ao-cookbook/src/ja/tutorials/begin/preparations.md

Response:
::: info
もしあなたのOSバージョンが最新バージョンと異なる場合、バージョンを更新するかどうかを尋ねるメッセージが表示されます。その場合は、"Ctrl+C" を2回押してプロセスを終了し、`npm i -g https://get_ao.g8way.io` を実行して更新し、再度 `aos` を実行してください。
:::

aoコンピュータの新しいホームへようこそ！今見ているプロンプトは、この分散型マシンのあなた自身の個人サーバーです。

さあ、[メッセージング](messaging)というaoの2つのコアコンセプトの1つを探求し、ウサギの穴をさらに深く進んでいきましょう。

<!--
Let's walk through the initial printout after running `aos`:

![aos print](/aos-print.png)

After running `aos` in your terminal, you should see:

- An ASCII art image of `AOS`.
- A Welcome Message
- The version of `aos` you are running.
- An instructional exit message.
- Your process ID.

::: info
If your OS version is different than the latest version, a message asking if you'd like to update the version will appear. If so, simply exit the process by pressing "Ctrl+C" twice, run `npm i -g https://get_ao.g8way.io` to update, and then run `aos` again.
:::

Welcome to your new home in the ao computer! The prompt you are now looking at is your own personal server in this decentralized machine.

Now, let's journey further down the rabbit hole by exploring one of the two core concept type of ao: [messaging](messaging). -->


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: token.md Path: ../ao-cookbook/src/ja/tutorials/begin/token.md
Note: This content continues in the next part.

Response:
# トークンの作成

::: info
`ao`の深みに飛び込む準備が整いました。あなた自身のトークンを作成する準備ができました。これは、この分散型メディア内での価値と交換のシンボルです。トークンの作成方法を学びたいと思っているなら、[Messaging](messaging)や[チャットルームの構築](chatroom)のレッスンを訪れていない場合は、そちらを確認してください。このページは、複数パートのインタラクティブチュートリアルの一部です。
:::

トークンを作成する際には、[トークン仕様](../../references/token.md)に従って、`ao`内でLua言語を使用してトークンをミントします。

## ビデオチュートリアル

<iframe width="680" height="350" src="https://www.youtube.com/embed/yge5Oo7K1vM?si=f3vt2eAbL3ON-DBz" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## ウサギの穴をさらに進む

前回のチュートリアル[チャットルームの構築](chatroom)では、`ao`内でチャットルームを作成し、`Morpheus`と`Trinity`の両方をそのチャットルームに招待しました。そして、`Trinity`は私たちにトークンを作成してほしいと頼んできました。これは、私たちがウサギの穴を進むにふさわしいことを証明する手段です。

**始めましょう。**

## トークンを構築するための2つの道

トークンを構築する際には、2つの道があります：

1. **ブループリント**: これは、`ao`内でトークンを迅速に構築するためのあらかじめ設計されたテンプレートです。始めるのに最適な方法で、ニーズに合わせてカスタマイズできます。

   こちらで[トークンブループリント](../../guides/aos/blueprints/token.md)の詳細を確認してください。

2. **手動メソッド**: これは、`ao`内でトークンを一から構築するためのステップバイステップのガイドです。この道は、トークンの内部動作を理解したい方に向いています。

   こちらで完全な[トークンを構築する](../../guides/aos/token.md)ガイドを確認してください。

## ブループリントメソッド

このチュートリアルでは、`Trinity`のためのトークンを作成するためにトークンブループリントを使用します。これは、`ao`内で迅速にトークンを構築するためのあらかじめ設計されたテンプレートです。

### トークンブループリントの使用方法

1. 前のステップで使用したのと同じディレクトリにいることを確認します。
2. ターミナルを開きます。
3. `aos`プロセスを開始します。
4. `.load-blueprint token`と入力します。

これにより、`ao`内でトークンに必要なハンドラーがロードされます。トークンブループリントは、このチュートリアル専用ではなく、作成したいトークンの基盤として使用できます。

### ブループリントが読み込まれたか確認する

`Handlers.list`と入力して、新たにロードされたハンドラーを確認します。

あなたの`aos`プロセスに新しいハンドラーのリストが読み込まれているはずです。もし前のチュートリアルのステップに従っているなら、チャットルーム用のハンドラーも見ることができるはずです。

**例:**

![Token Handlers](/token3.png)

### トークンのテスト

トークンブループリントが読み込まれたので、`Action = "Info"`タグを使って自分自身にメッセージを送ることでトークンをテストできます。

<!-- # Crafting a Token

::: info
Diving deeper into the `ao`, you're now ready to create your own token, a symbol of value and exchange within this decentralized medium. If you've found yourself wanting to learn how to create a token, but haven't visited the [Messaging](messaging) and [Build a Chatroom](chatroom) lessons, be sure to do so as this page is part of a multi-part interactive tutorial.
:::

When creating tokens, we'll continue to use the [Lua Language](../../references/lua.md) within `ao` to mint a token, guided by the principles outlined in the [Token Specification](../../references/token.md).

## Video Tutorial

<iframe width="680" height="350" src="https://www.youtube.com/embed/yge5Oo7K1vM?si=f3vt2eAbL3ON-DBz" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## Continuing Down the Rabbit Hole

In our last tutorial, [Build a Chatroom](chatroom), we learned how to create a chatroom within `ao`, invited both `Morpheus` and `Trinity` to the chatroom we created, and then `Trinity` has now asked for us to create a token for her as a way of proving ourselves worthy of continuing down the rabbit hole.

**Let us begin.**

## The Two Paths To Building a Token

There are two paths to take when building a token:

1. **The Blueprint**: This is a predesigned template that helps you quickly build a token in `ao`. It is a great way to get started and can be customized to fit your needs.

   Check here to learn more about the [Token Blueprint](../../guides/aos/blueprints/token.md).

2. **The Manual Method**: This is a step-by-step guide to building a token in `ao` from scratch. This path is for those who want to understand the inner workings of a token and how to build one from the ground up.

   Check here to review the full [Build a Token](../../guides/aos/token.md) guide.

## The Blueprint Method

For this tutorial, we'll be using the Token Blueprint to create a token for `Trinity`. This is a predesigned template that helps you quickly build a token in `ao`.

### How To Use The Token Blueprint

1. Make sure we're in the same directory as before during the previous steps in the tutorial.
2. Open the Terminal.
3. Start your `aos` process.
4. Type in `.load-blueprint token`

This will load the required handlers for the tutorials token within `ao`. It's important to note that the token blueprint isn't specific to this tutorial and can be used as a foundation for any token you wish to create.

### Verify the Blueprint is Loaded

Type in `Handlers.list` to see the newly loaded handlers.

You should see a new list of handlers that have been loaded into your `aos` process. If you've been following along the with the previous steps in the tutorial, you should also see the handlers for your chatroom, as well.

**Example:**

![Token Handlers](/token3.png)

### Testing the Token

Now that the token blueprint is loaded, we can test the token by sending a message to ourselves using the `Action = "Info"` tag


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: token.md Path: ../ao-cookbook/src/ja/tutorials/begin/token.md

Response:
1. Make sure we're in the same directory as before during the previous steps in the tutorial.
2. Open the Terminal.
3. Start your `aos` process.
4. Type in `.load-blueprint token`

This will load the required handlers for the tutorials token within `ao`. It's important to note that the token blueprint isn't specific to this tutorial and can be used as a foundation for any token you wish to create.

### Verify the Blueprint is Loaded

Type in `Handlers.list` to see the newly loaded handlers.

You should see a new list of handlers that have been loaded into your `aos` process. If you've been following along the with the previous steps in the tutorial, you should also see the handlers for your chatroom, as well.

**Example:**

![Token Handlers](/token3.png)

### Testing the Token

Now that the token blueprint is loaded, we can test the token by sending a message to ourselves using the `Action = "Info"` tag. -->

```lua
Send({ Target = ao.id, Action = "Info" }).receive().Tags
```

これにより、トークン情報がコンソールに表示されます。あなたのプロセスIDと利用可能なトークンの総残高が表示されるはずです。

### トリニティへのトークンの送信

トークンが期待通りに動作することが確認できたので、`Trinity`にトークンを送信します。`Action = "Transfer"`タグを使用して、`Trinity`に1000トークンを送ります。

<!--
This will print the token information to the console. It should show your process ID with the total balance of tokens available.

### Sending Tokens to Trinity

Now that we've tested the token and it's working as expected, we can send some tokens to `Trinity`. We'll send 1000 tokens to `Trinity` using the `Action = "Transfer"` tag. -->

```lua
Send({ Target = ao.id, Action = "Transfer", Recipient = Trinity, Quantity = "1000"}).receive().Data
```

<!-- When `Trinity` receives the tokens, she'll respond to the transfer with a message to confirm that she's received the tokens.

Her response will look something like this:

`Trinity:` "Token received. Interesting. I wasn't sure you'd make it this far. I'm impressed, but we are not done yet. I want you to use this token to tokengate the chatroom. Do that, and then I will believe you could be the one."

You've completed the process of creating a token and sending it to `Trinity`. You're now ready to move on to the next step in the tutorial. [Tokengating the Chatroom](tokengating). -->

`Trinity`がトークンを受け取ると、彼女は受け取ったことを確認するメッセージで応答します。

彼女の応答は次のようになります：

`Trinity:` "トークンを受け取りました。興味深いですね。あなたがここまで来るとは思っていませんでした。感心しましたが、まだ終わりではありません。このトークンを使ってチャットルームをトークンゲートしてください。それを達成したら、あなたが「選ばれし者」になれると信じるでしょう。"

トークンを作成し、`Trinity`に送信するプロセスを完了しました。次のステップに進む準備が整いました。[チャットルームのトークンゲート](tokengating)へ進みましょう。


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: messaging.md Path: ../ao-cookbook/src/ja/tutorials/begin/messaging.md
Note: This content continues in the next part.

Response:
<script setup>
  import {onMounted} from "vue"
  import {renderRepl} from "../../../tools/replRenderer.jsx"

  const codes = {
    "step-3": `Send({ Target = "process ID", Data = "Hello World!" })`,
    "step-4": `Morpheus = "ajrGnUq9x9-K1TY1MSiKwNWhNTbq7-IdtFa33T59b7s"`,
    "step-4-1": `Morpheus`,
    "step-5": `Send({ Target = Morpheus, Data = "Morpheus?" })`,
    "step-6": `#Inbox`,
    "step-6-1": `Inbox[#Inbox].Data`,
    "step-7": `Send({ Target = Morpheus, Data = "Code: rabbithole", Action = "Unlock" })`,
    "step-7-2": `Inbox[#Inbox].Data`
  }

  onMounted(() => {
      Object.keys(codes).forEach((key) => {
        renderRepl(key, codes[key])
      })
    }
  )
</script>

# aoにおけるメッセージング

## メッセージがaoの並列コンピュート機能をどのように提供するかを学ぶ

`ao`では、すべてのプロセスが並行して実行され、高度にスケーラブルな環境を作り出します。プロセス間での従来の直接関数呼び出しは実行できません。なぜなら、各プロセスが独立して非同期に動作するからです。

メッセージングは、非同期通信を可能にすることでこの問題に対処します。プロセスは、互いに直接関数を呼び出すのではなく、メッセージを送受信します。この方法により、プロセスがメッセージに応答できる柔軟で効率的な相互作用が実現し、システムのスケーラビリティと応答性が向上します。

まず、`aos`におけるメッセージングの基本を探り、受信トレイに受け取ったメッセージを確認し、他のプロセスにメッセージを送信する方法を学びます。

## ビデオチュートリアル

<iframe width="680" height="350" src="https://www.youtube.com/embed/6aCjKK6F1yQ?si=3Ny7U-GgyNsRWlXS" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## ステップ1: メッセージ構造の理解

- **メッセージの基本:** `ao`のメッセージは、複数の値を保持できる柔軟なデータ構造であるLuaテーブルを使用して構築されます。これらのテーブル内で「Data」フィールドは重要であり、メッセージの内容やペイロードが含まれています。この構造により、プロセス間での情報の効率的な送受信が可能になり、`ao`のプリミティブがArweaveの基盤となる機能を活用して複雑で構成可能な操作を促進します。

  詳細な仕様については、[G8wayの仕様ページ](https://specs.g8way.io/?tx=xwOgX-MmqN5_-Ny_zNu2A8o-PnTGsoRb_3FrtiMAkuw)を参照してください。

- **例:** `{ Data = "Hello from Process A!" }`はシンプルなメッセージです。

## ステップ2: aos CLIを開く

- ターミナルで`aos`と入力して、aosコマンドラインインターフェイス（CLI）を起動します。

<!-- # Messaging in `ao`

## Learn how Messages gives `ao` Parallel Compute Capability

In `ao`, every process runs in parallel, creating a highly scalable environment. Traditional direct function calls between processes aren't feasible because each process operates independently and asynchronously.

Messaging addresses this by enabling asynchronous communication. Processes send and receive messages rather than directly invoking functions on each other. This method allows for flexible and efficient interaction, where processes can respond to messages, enhancing the system's scalability and responsiveness.

We'll begin by exploring the basics of messaging in `aos`, how to see messages received in your inbox, and how to send messages to other processes.

## Video Tutorial

<iframe width="680" height="350" src="https://www.youtube.com/embed/6aCjKK6F1yQ?si=3Ny7U-GgyNsRWlXS" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## Step 1: Understand the Message Structure

- **Message Basics:** Messages in `ao` are built using Lua tables, which are versatile data structures that can hold multiple values. Within these tables, the "Data" field is crucial as it contains the message's content or payload. This structure allows for efficient sending and receiving of information between processes, showcasing how `ao` primitives leverage Arweave's underlying capabilities to facilitate complex, composable operations.

  For detailed specifications, please refer to the original documentation on the [G8way specs page](https://specs.g8way.io/?tx=xwOgX-MmqN5_-Ny_zNu2A8o-PnTGsoRb_3FrtiMAkuw).

- **Example**: `{ Data = "Hello from Process A!" }` is a simple message.

## Step 2: Open the aos CLI

- Launch the aos command-line interface (CLI) by typing `aos` in your terminal and pressing Enter. -->

```sh
aos
```

<!-- ## Step 3: How to Send a Message -->

ステップ3: メッセージを送信する方法

```lua
Send({ Target = "process ID", Data = "Hello World!" })
```

<div id="step-3"></div>

<!--
- **Send**: The `Send` function is globally available in the aos interactive environment.
- **Target**: To send a message to a specific process, include a `Target` field in your message.
- **Data**: The `Data` is the text message you want received by the receiving process. In this example, the message is "Hello World!".

## Step 4: Store `Morpheus`'s Process ID

We'll use the process ID provided below and store it as a variable called Morpheus. -->

- **Send:** `Send`関数は、aosインタラクティブ環境でグローバルに利用可能です。
- **Target:** 特定のプロセスにメッセージを送信するには、メッセージに`Target`フィールドを含めます。
- **Data:** `Data`は、受信プロセスに送信したいテキストメッセージです。この例では、メッセージは"Hello World!"です。

## ステップ4: `Morpheus`のプロセスIDを保存する

以下で提供されたプロセスIDを使用し、変数として`Morpheus`に保存します。

```lua
ajrGnUq9x9-K1TY1MSiKwNWhNTbq7-IdtFa33T59b7s
```

Copy the process ID above and store it as a variable by running the below command in the aos CLI:

```lua
Morpheus = "ajrGnUq9x9-K1TY1MSiKwNWhNTbq7-IdtFa33T59b7s"
```

<div id="step-4"></div>

これにより、プロセスIDが`Morpheus`という名前の変数として保存され、特定のプロセスIDと対話しやすくなります。

::: info
`Morpheus`変数を作成する際、返されるレスポンスは`undefined`のみ


Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: messaging.md Path: ../ao-cookbook/src/ja/tutorials/begin/messaging.md
Note: This content continues in the next part.

Response:
`に保存します。

```lua
ajrGnUq9x9-K1TY1MSiKwNWhNTbq7-IdtFa33T59b7s
```

Copy the process ID above and store it as a variable by running the below command in the aos CLI:

```lua
Morpheus = "ajrGnUq9x9-K1TY1MSiKwNWhNTbq7-IdtFa33T59b7s"
```

これにより、プロセスIDが`Morpheus`という名前の変数として保存され、特定のプロセスIDと対話しやすくなります。

::: info
`Morpheus`変数を作成する際、返されるレスポンスは`undefined`のみであるべきです。これは予想される動作です。変数が正常に作成されたか確認するには、`Morpheus`と入力してEnterを押します。保存したプロセスIDが表示されるはずです。
:::

### `Morpheus`変数の確認

```lua
-- Check the Morpheus variable by typing `Morpheus`
 Morpheus
-- Expected Results:
ajrGnUq9x9-K1TY1MSiKwNWhNTbq7-IdtFa33T59b7s

-- If `undefined` is returned,
-- then the variable was not created successfully.
```

## ステップ5: Morpheusにメッセージを送信する

MorpheusのプロセスIDを取得し、変数に保存した後、彼と通信する準備が整いました。これを行うには、Send関数を使用します。モーフィアス自身は、aoで実行されている並行プロセスです。彼は一連のハンドラを使用してメッセージを受信し送信します。メッセージを彼に送って、どうなるか見てみましょう。

```lua
Send({ Target = Morpheus, Data = "Morpheus?" })
```

- あなたの`Target`は`Morpheus`であり、これは以前に`Morpheus`のプロセスIDを使用して定義した変数です。
- `Data`は、Morpheusに送信したいメッセージです。この場合、メッセージは"Morpheus?"です。

**期待される結果:**

```lua
-- Your Message Command
 Send({ Target = Morpheus, Data = "Morpheus?"})
-- Message is added to the outbox
message added to outbox
-- A New Message is received from `Morpheus`'s process ID
New Message From BWM...ulw: Data = I am here. You are f

```

Morpheusにメッセージを送信し、応答を受け取りましたが、完全なメッセージは読めません。次は`Inbox`について学び、メッセージを読む方法を見ていきましょう。

## ステップ6: インボックス

`Inbox`は、他のプロセスからのメッセージを受信する場所です。
::: info
インボックスメッセージの詳細な表示を確認するには、[メッセージ](../../concepts/messages)の概念ページに移動してください。
:::

インボックスに受信したメッセージがいくつあるかを確認します。

aos CLIの中で、次のコマンドを入力します：

```lua
 #Inbox
```

チュートリアルを積極的に進めている場合、インボックスには多くのメッセージがないでしょう。しかし、aos環境で実験を行っている場合、インボックスに1つ以上のメッセージがあるかもしれません。

**Example Return:**

```lua
-- Your Inbox Command
 #Inbox
-- The command will return the number of messages in your inbox.
4

```

上記の例では、返答は`4`となっており、インボックスに4つのメッセージがあることを示しています。

私たちは積極的に`Morpheus`の応答を探しているので、彼のメッセージが最後に受信されたメッセージであると仮定します。インボックスの最後のメッセージを読むには、次のコマンドを入力します：

```lua
 Inbox[#Inbox].Data
```

このコマンドは、メッセージからデータを分離し、データの内容のみを読むことを可能にします。
The Expected Return:

```lua
-- Your Inbox[x].Data Command
 Inbox[#Inbox].Data
-- The command will return the `Data` of the message.
-- Data is what usually represents the text-based message
-- received from one process to another.
I am here. You are finally awake. Are you ready to see how far the rabbit hole goes?

```

あなたは現在、自分のプロセスを使って、aoで実行されている別の並行プロセスであるMorpheusと通信しています。次のチュートリアルのステップに進む準備が整いました。

## ステップ7: タグ付きメッセージの送信

**タグの目的**: aosメッセージのタグは、メッセージを効率的に分類、ルーティング、処理するために使用されます。これらはメッセージ処理において重要な役割を果たし、特に


Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: messaging.md Path: ../ao-cookbook/src/ja/tutorials/begin/messaging.md
Note: This content continues in the next part.

Response:
from one process to another.
I am here. You are finally awake. Are you ready to see how far the rabbit hole goes?

```

あなたは現在、自分のプロセスを使って、aoで実行されている別の並行プロセスであるMorpheusと通信しています。次のチュートリアルのステップに進む準備が整いました。

## ステップ7: タグ付きメッセージの送信

**タグの目的**: aosメッセージのタグは、メッセージを効率的に分類、ルーティング、処理するために使用されます。これらはメッセージ処理において重要な役割を果たし、特に複数のプロセスや複雑なワークフローを扱う際に役立ちます。

いくつかのプロセスは、特定のタグを持つメッセージと相互作用する`Handlers`を使用します。たとえば、特定のタグを持つメッセージのみと相互作用するハンドラを持つプロセスがあり、これについては[チャットルーム](chatroom)チュートリアルでの例を見ていきます。

### メッセージにタグを使用する方法

Morpheusの場合、タグを使用してメッセージを分類できます。また、Morpheusは自律プロセスであるため、特定のタグを持つメッセージと相互作用できるハンドラを持っています。

**メッセージにタグを追加する**:

- メッセージの`Data`は、別のプロセスに送信したいテキストメッセージであることは既に知っています。以前、タグなしでMorpheusにメッセージを送りましたが、彼は正確に一致するデータに対してハンドラを使用して応答しました。

### Morpheusに私たちが準備ができていることを示そう

Morpheusに、タグ`Action`と値`rabbithole`を持つメッセージを送信します。

<!-- You are now using your own process to communicate with Morpheus, another parallel process running in ao. You're now ready to move on to the next step in the tutorial.

## Step 7: Sending Messages with Tags

**Purpose of Tags**: Tags in aos messages are used to categorize, route, and process messages efficiently. They play a crucial role in message handling, especially when dealing with multiple processes or complex workflows.

Some processes use `Handlers` that specifically interact with messages that have certain tags. For example, a process may have a handler that only interacts with messages that have a specific tag, which we'll see an example of in the [chatroom](chatroom) tutorial.

### How to Use Tags in Messages

In the case of Morpheus, we can use tags to categorize our messages, and because Morpheus is a autonomous process, he has handlers that can interact with messages that have certain tags.

**Adding Tags to a Message**:

- We already know that the `Data` of a message is the text-based message you want to send to another process. Earlier, we sent a message to Morpheus without any tags, in which he used a handler to respond to an exact matching data.

### Let's Show Morpheus That We're Ready

Send Morpheus a message with the tag `Action` and the value `rabbithole`. -->

**Example:**

```lua
Send({ Target = Morpheus, Data = "Code: rabbithole", Action = "Unlock" })
```

<div id="step-7"></div>

**Read the message from Morpheus:**

```lua
Inbox[#Inbox].data
```

**Expected Return:**
![Morpheus Responds 2](/messaging2.png)

## タグを使用するための追加のヒント

- **一貫したタグ付け**: メッセージ処理をより予測可能にするために、アプリケーションに一貫したタグ付けシステムを開発しましょう。
- **タグ名**: タグには明確で説明的な名前を選んでください。これにより、メッセージの目的や文脈を一目で理解しやすくなります。
- **タグのセキュリティ**: タグは暗号化されず隠されないため、敏感な情報をタグとして使用しないように注意してください。

## タグの高度な使用法

- **ワークフロー管理**: タグは、メッセージが複数の段階やプロセスを通過するシステムにおいて、ワークフローを管理するのに役立ちます。

## メッセージングに関する追加のヒント

- **メッセージ構造**: より複雑なメッセージングニーズに対応するために、`Epoch`、`From`、`Nonce`などの他のフィールドも探ってみてください。
- **デバッグ**: デバッグ用にメッセージを印刷するために[`Dump`](/concepts/tour.html#_6-data-representation-with-dump)関数を使用してください。
- **セキュリティ考慮事項**: メッセージの内容や処理には注意し、プライベートまたは敏感と見なされるものを送信しないでください。

## 結論

タグ付きメッセージの送信方法を学びました。これは、aosにおけるメッセージの分類とルーティングにおいて強力なツールです。

Morpheusは、あなたを次のステージに正式に招待しました。次のチュートリアルのステップである[チャットルームの作成](chatroom)に進む準備が整いました。


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: messaging.md Path: ../ao-cookbook/src/ja/tutorials/begin/messaging.md

Response: journey. You're now ready to move on to the next step in the tutorial, [Creating a Chatroom](chatroom). -->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: index.md Path: ../ao-cookbook/src/ja/tutorials/begin/index.md

Response:
---
prev:
  text: "チュートリアル"
  link: "../index"
next:
  text: "準備"
  link: "/tutorials/begin/preparations"
---

# 始めよう: インタラクティブチュートリアル

このチュートリアルシリーズでは、aos環境の知識と理解を深めるためのインタラクティブなステップを進めていきます。

::: info

### 演習

この楽しい演習では、モーフィアスとトリニティという二人の親しみのあるキャラクターから提示される一連の課題に挑戦します。モーフィアスの導きに従い、あなたが`the one`であることを証明するための一連の課題に深く入り込むことになります。モーフィアスとトリニティの両方から提示されたすべての課題を完了すると、`The Construct`という名のao内の独占チャットルームにアクセスできるトークンが授与されます。

それでは、[ウサギの穴へ](preparations)進んでいきましょう。
![白ウサギ](/white_rabbit_outline.svg)
:::

## チュートリアル

### 始めよう - インタラクティブチュートリアル

- [1. クイックスタート](preparations)
- [2. メッセージング](messaging)
- [3. チャットルームの作成](chatroom)
- [4. トークンの構築](token)

<!-- ---
prev:
  text: "Tutorials"
  link: "../index"
next:
  text: "Preparations"
  link: "/tutorials/begin/preparations"
---

# Begin: An Interactive Tutorial

In this tutorial series, you'll walk through an interactive steps that will help you deepen your knowledge and understanding of the aos environment.

::: info

### The Exercise

In this fun exercise, you'll encounter a series of challenges presented by two familiar characters, Morpheus and Trinity. You'll dive deep `into the rabbit hole` guided by Morpheus as he presents you with a series of challenges to prove you're `the one`. Once you've completed all of the challenges presented by both Morpheus and Trinity, you'll receive a token that grants you access to an exclusive chatroom within ao called `The Construct`.

Now, let's get started [down the rabbit hole.](preparations)
![White Rabbit](/white_rabbit_outline.svg)
:::

## Tutorials

### Getting Started - An Interactive Tutorial

- [1. Quick Start](preparations)
- [2. Messaging](messaging)
- [3. Creating a Chatroom](chatroom)
- [4. Build a Token](token) -->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: rabbithole.md Path: ../ao-cookbook/src/ja/tutorials/begin/rabbithole.md

Response:
# `The Construct`に入る - インタラクティブチュートリアル

![ホワイトラビット](/white_rabbit_outline.svg)

## 目を覚ませ、ネオ...

ウサギの穴がどれほど深いか見る準備はできていますか？

このインタラクティブチュートリアルでは、これまでに学んだことを活用して、ミッションに取り組みます。

### ミッション: マトリックスから脱出し、「The Construct」に入る。

The Constructは、ao内のトークンゲートされたチャットルームで、タスクを一連の作業を完了した者のみがアクセスできます。

**さあ、始めましょう。**

::: warning
このチュートリアルを完了するには、最新バージョンのaosをインストールしている必要があります。
:::

### 1. Morpheusを見つける

MorpheusのプロセスID:

<!-- # Enter `The Construct` - An Interactive Tutorial

![White Rabbit](/white_rabbit_outline.svg)

## Wake up, Neo...

Are you ready to see how deep the rabbit hole goes?

This interactive tutorial will take what you've learned so far and apply it towards a mission.

### The Mission: Break Out of the Matrix and Enter "The Construct".

The construct is a tokengated chatroom inside ao that is only accessible to those who have completed a series of tasks.

**Now... let's begin.**

::: warning
You must have the latest versions of aos installed to complete this tutorial.
:::

### 1. Locate Morpheus

Morpheus' process ID: -->

```
9yOQrYNwIfIOeSswRDGUMd5gvMWJKxleInD_95DEC4A
```

彼のプロセスIDを取得し、aos内で「Morpheus」と名付けます。これが、The Constructに入るための第一歩です。

<!-- Take his process ID and name is "Morpheus" inside aos. This is the first step to entering the construct. -->

```lua
Morpheus = "9yOQrYNwIfIOeSswRDGUMd5gvMWJKxleInD_95DEC4A"
```

Morpheusにメッセージを送り、準備ができていることを伝えます。

<!-- Send a message to Morpheus, and tell him you are ready to begin. -->

```lua
Send({ Target = Morpheus, Data = "I'm Ready" })
```

このメッセージを送信すると、彼は次のステップを指示してくれます。彼の指示に従えば、The Constructに向かうことができます。

::: info
メッセージングプロセスの理解に苦しんでいる場合は、[Messaging](messaging)チュートリアルを確認してください。
:::

### 2. Morpheusに自分を証明する

Morpheusはあなたに一連のタスクを与えます。
タスクには以下が含まれます：

- [チャットルーム](chatroom)の構築
- チャットルーム内でのメッセージのブロードキャスト
- チャットルームのカスタムハンドラの作成

これらのタスクを完了すると、Morpheusは次のステップの指示を与えます。そのステップではTrinityを見つけることが含まれます。

### 3. Trinityを見つける

TrinityのプロセスIDは、Morpheusのタスクを完了することでのみ取得できます。

TrinityのプロセスIDを受け取ったら、aos内で「Trinity」と名付ける必要があります。その後、彼女に「"White Rabbit"」というメッセージを送ります。

<!-- When you've sent this message, he'll respond with the next step. Follow the instructions he gives you, and you'll be on your way to the construct.

::: info
If you need help understanding the messaging process, review the [Messaging](messaging) tutorial.
:::

### 2. Prove Yourself to Morpheus

Morpehus will give you a series of tasks to complete.
The tasks will involve:

- Building a [Chatroom](chatroom).
- Broadcasting messages within the Chatroom.
- Writing a custom Handler for the Chatroom.

When you've completed these tasks, Morpheus will give you instructions for the next step, which will involve locating Trinity.

### 3. Locate Trinity

Trinity's process ID can only be obtained by completing Morpheus' tasks.

Once you've received Trinity's process ID, you will need to name it "Trinity" inside aos. You'll then message her `"White Rabbit"`. -->

```lua
Send({ Target = Trinity, Data = "White Rabbit" })
```

彼女が応答すると、チュートリアルの次のフェーズが始まります。

### 4. Trinityに自分を証明する

Morpheusと同様に、Trinityもあなたに一連のタスクを与えます。

タスクには以下が含まれます：

- [トークン](token)の作成
- Morpheusのために構築したチャットルームのトークン化
- 自分自身の[ゲームとボット](/tutorials/bots-and-games/index)の作成
- トークン化されたチャットルーム内でのプロセスの登録

これらのタスクを完了すると、Trinityはチュートリアルの次のフェーズに関する指示を与えます。

### 5. Constructへのトークンを受け取る

MorpheusとTrinityのタスクを完了することで、Constructに入るためのトークンを受け取ります。

### 6. Constructに入る

その後、Trinityはトークンを使用してConstructに入る方法に関する指示を与えます。

Constructに入ると、チュートリアルを完了した他の人とチャットできるようになります。

<!--
She will respond and the next phase of the tutorial will begin.

### 4. Prove Yourself to Trinity

Much like Morpheus, Trinity will give you a series of tasks to complete.

The tasks will involve:

- Creating a [Token](token).
- Tokenizing the chatroom you built for Morpheus.
- Create your own [Game and Bot](/tutorials/bots-and-games/index).
- Register your process within the tokenized chatroom.

Once you've completed these tasks, Trinity will give you instructions for the next phase of the tutorial.

### 5. Receive the Token to the Construct

By completing the tasks of Morpheus and Trinity, you will receive a token that will allow you to enter the Construct.

### 6. Enter the Construct

Trinity will then give you instructions on how to use the token to enter the Construct.

Once you've entered the Construct, you will be able to chat with others who have completed the tutorial. -->