人生で影響を受けた本100冊。
https://qiita.com/kaizen_nagoya/items/16af53acbb147a94172e
3番目の本のプログラマ編。
3. ピーターラビットのおはなし
2002/10, ビアトリクス・ポター
http://www.gutenberg.org/ebooks/14838
html(gutenberg)
http://www.gutenberg.org/files/14838/14838-h/14838-h.htm
https://www.amazon.co.jp/dp/4834018555/
https://bookmeter.com/books/455313
https://booklog.jp/item/1/4834018555
ミスポッターという原作者に関する映画で、本書ができあがるまでが分ります。
絵を重視して、簡単な物語がつく本。
漫画でもなく、コミックでもなく、絵本なのですね。
日本以外で、落ち着いた絵を見るのは、驚きです。
ヨーロッパでうさぎというと、ミーフィーも思い出します。
人間に共通の感覚があるということに気がついた作品です。
よいものは、どこへ行ってもよいと認められる。
子ども向けには、とてもよいクリスマスプレゼントになると思います。
３歳から５才くらい向けだと思えるし、
１０歳でも楽しめる本だと思います。
コンピュータ用のCD−ROMもあわせて楽しむとよいかも。
紹介用に作成した各国語資料 by @kaizen_nagoya
The story of Miss Moppet
https://www.slideshare.net/kaizenjapan/the-storyofmissmoppet
La historia de la Senorita Minina
https://www.slideshare.net/kaizenjapan/la-historiadelasenoritaminina
ChatGPT
ピーターラビットのおはなし ビアトリクス・ポター からプログラマが学ぶとよい視点を７つご紹介ください。
ChatGPT:
『ピーターラビットのおはなし』（ビアトリクス・ポター）から、プログラマが学べる視点を7つ挙げます。作品の物語や創作背景をプログラミングの世界に置き換えたヒントとしてご覧ください。
- 好奇心と探究心のコントロール
ピーターは好奇心から禁じられた畑へ入ります。
→ 教訓：新しい技術やライブラリを試すことは大切だが、リスク評価や事前調査を怠らないバランス感覚が必要。- リスク管理と安全設計
ピーターは危険を顧みずに行動し、結果として追われます。
→ 教訓：コードの変更やデプロイでは、バックアップ・テスト・ロールバック計画など安全策を事前に設けることが重要。- 素早い状況判断と機転
逃げる最中もピーターは道を選び、障害物を避けます。
→ 教訓：障害が発生した際、冷静なログ解析や即応パッチで被害を最小化する迅速な判断力を鍛える。- 失敗からの学習
物語の最後にピーターは懲りて体調を崩し、教訓を得ます。
→ 教訓：バグや障害は貴重な知見。ポストモーテムを行い、原因を記録し次の改善につなげる姿勢が重要。- シンプルな表現力
ポターは簡潔な言葉と挿絵で豊かな世界を描写。
→ 教訓：コードも短く読みやすく、コメントやドキュメントは簡潔に。読み手に伝わるシンプルさが品質を高める。- ユーザー視点のデザイン
絵本は子どもでも理解できる構成。
→ 教訓：アプリやツールはユーザー層に合わせたUI/UX設計が不可欠。対象読者を意識した情報設計が大切。- 持続的な作品づくり
出版から100年以上愛され続ける魅力。
→ 教訓：長期保守できるコード・設計・ドキュメントを意識し、技術トレンドが変わっても読まれるソフトウェアを目指す。
これらは単なる寓話的な読み替えではなく、
開発計画（好奇心とリスク管理）
運用保守（障害対応、長期保守）
品質向上（シンプルで伝わるコード）
といった実務の重要領域に直結します。
７つの視点でプログラム設計例 をソースコードで示してください。
ChatGPT:
では、先ほどの7つの学びの視点を反映した簡単なプログラム設計例を Python で示します。各視点ごとにコメントを入れ、どの部分がどの教訓に対応するかを明確にします。
'''python
import random
import logging
1. 好奇心と探究心のコントロール
新しい処理を試すが、事前に条件を確認して安全かチェック
def explore_new_feature(user_level):
if user_level < 3:
print("まだ新しい機能は試さないでください。")
return False
print("新機能を試す！")
return True
2. リスク管理と安全設計
エラー時の安全策として try-except とバックアップ処理を追加
def risky_operation(data):
backup = data.copy() # データのバックアップ
try:
# ランダムな操作で失敗する可能性
if random.random() < 0.3:
raise ValueError("操作失敗！")
data.append("成功")
except Exception as e:
logging.error(f"エラー発生: {e}. バックアップに復元します")
data = backup
return data
3. 素早い状況判断と機転
障害や異常を検知して別処理へフォールバック
def handle_task(task):
if task == "danger":
print("危険検知！安全な処理に切り替え")
task = "safe_task"
print(f"処理中: {task}")
4. 失敗からの学習
失敗回数を記録して次回の判断に反映
failure_log = []
def perform_action(action):
try:
if random.random() < 0.4:
raise RuntimeError("アクション失敗")
print(f"{action} 成功")
except RuntimeError as e:
print(e)
failure_log.append(action)
5. シンプルな表現力
関数名・変数名を分かりやすく、処理も短く明快
def add_numbers(a, b):
return a + b # シンプルに処理内容を明示
6. ユーザー視点のデザイン
入力を丁寧にチェックし、ユーザーにわかりやすく出力
def get_user_input():
while True:
choice = input("数字を入力してください: ")
if choice.isdigit():
return int(choice)
print("無効な入力です。数字を入力してください。")
7. 持続的な作品づくり
長期運用を考え、再利用可能な構造にする
class TaskManager:
def init(self):
self.tasks = []
def add_task(self, task_name):
self.tasks.append(task_name)
print(f"タスク追加: {task_name}")
def show_tasks(self):
print("現在のタスク一覧:")
for t in self.tasks:
print(f"- {t}")
--- メイン処理例 ---
if name == "main":
data = []
explore_new_feature(user_level=2) # 1
data = risky_operation(data) # 2
handle_task("danger") # 3
perform_action("action1") # 4
print(add_numbers(5, 7)) # 5
user_number = get_user_input() # 6
print(f"入力値: {user_number}")
manager = TaskManager() # 7
manager.add_task("開発環境構築")
manager.show_tasks()
'''
🔹 このコードで学べるポイント
好奇心と探究心のコントロール → explore_new_feature()
リスク管理と安全設計 → risky_operation()
素早い状況判断と機転 → handle_task()
失敗からの学習 → perform_action() と failure_log
シンプルな表現力 → add_numbers()
ユーザー視点のデザイン → get_user_input()
持続的な作品づくり → TaskManager クラス
もし希望なら、このコードを**「ピーターラビットの物語風」に擬人化してコメント付きでさらに物語風プログラミング例**にアレンジすることも可能です。
作ってほしいですか？
はい。お願いします。
ChatGPT:
では、先ほどの7つの視点をピーターラビットの物語風に擬人化して、プログラムに反映した例を作りました。
コード内のコメントも物語風にしています。
import random
import logging
🌱 1. 好奇心と探究心のコントロール
ピーターはマグレガーさんの畑に入りたい。でも無茶は禁物。
def explore_garden(rabbit_age):
if rabbit_age < 2:
print("ピーター: まだ畑に行くのは危険だよ…")
return False
print("ピーター: よーし、畑を探検だ！")
return True
🐾 2. リスク管理と安全設計
危ない畑での冒険。失敗したらすぐに逃げる準備。
def risky_adventure(items):
backup = items.copy() # いざという時のために隠れ場所に隠す
try:
if random.random() < 0.3:
raise ValueError("ピーター: あっ！見つかった！")
items.append("新鮮な野菜ゲット")
except Exception as e:
logging.error(f"{e} 隠れ場所に退避します")
items = backup
return items
🏃♂️ 3. 素早い状況判断と機転
マグレガーさんが来た！どう逃げる？
def escape_danger(event):
if event == "farmer":
print("ピーター: 危ない！安全な茂みに逃げるよ")
event = "safe_spot"
print(f"ピーターは {event} に向かって進む")
📖 4. 失敗からの学習
失敗しても次に活かす！記録しておこう。
failure_log = []
def gather_food(food):
try:
if random.random() < 0.4:
raise RuntimeError("ピーター: 野菜を落としちゃった！")
print(f"ピーター: {food} を収穫成功！")
except RuntimeError as e:
print(e)
failure_log.append(food)
✨ 5. シンプルな表現力
小さなウサギでも分かる簡単な方法
def count_vegetables(a, b):
return a + b # 野菜を数えるだけのシンプルな方法
👀 6. ユーザー視点のデザイン
ウサギの目線で、わかりやすく入力を聞く
def choose_vegetable():
while True:
choice = input("どの野菜を取りたい？数字で選んでね: ")
if choice.isdigit():
return int(choice)
print("数字で教えてね、ピーター！")
🌳 7. 持続的な作品づくり
長く安全に暮らすための秘密基地管理
class Burrow:
def init(self):
self.stock = []
def add_food(self, item):
self.stock.append(item)
print(f"巣穴に {item} を貯蔵したよ")
def show_stock(self):
print("巣穴の中の食料:")
for f in self.stock:
print(f"- {f}")
--- ピーターの一日の冒険 ---
if name == "main":
backpack = []
explore_garden(rabbit_age=1) # 🌱 まだ若いピーター
backpack = risky_adventure(backpack) # 🐾 危険な冒険
escape_danger("farmer") # 🏃♂️ マグレガーさんが来た！
gather_food("にんじん") # 📖 野菜を収穫
print(count_vegetables(3, 2)) # ✨ 数える
choice = choose_vegetable() # 👀 ユーザー視点
print(f"ピーターが選んだ野菜: {choice}")
home = Burrow() # 🌳 巣穴管理
home.add_food("レタス")
home.show_stock()
print(f"失敗ログ: {failure_log}") # 失敗も記録して次に活かす
🔹 この物語風コードでの対応
🌱 好奇心と探究心のコントロール → explore_garden()
🐾 リスク管理と安全設計 → risky_adventure()
🏃♂️ 素早い状況判断と機転 → escape_danger()
📖 失敗からの学習 → gather_food() と failure_log
✨ シンプルな表現力 → count_vegetables()
👀 ユーザー視点のデザイン → choose_vegetable()
🌳 持続的な作品づくり → Burrow クラス
もし希望なら、このコードをさらに「物語進行型ゲーム」のようにして、ピーターの冒険を画面で追体験できる小アプリ版に拡張することもできます。
作ってほしいですか？
はい。お願いします。
ChatGPT:
では、先ほどの物語風コードを簡単なテキストベースの冒険ゲーム形式に拡張します。
ピーターラビットの一日の冒険を、ユーザーの選択で進められる小アプリ版です。
import random
import logging
logging.basicConfig(level=logging.ERROR)
--- クラス定義 ---
class Burrow:
"""巣穴管理クラス"""
def init(self):
self.stock = []
def add_food(self, item):
self.stock.append(item)
print(f"巣穴に {item} を貯蔵したよ")
def show_stock(self):
print("\n巣穴の中の食料:")
for f in self.stock:
print(f"- {f}")
print()
--- 関数定義 ---
def explore_garden(rabbit_age):
"""好奇心とリスクコントロール"""
print("\nピーター: 畑を探検するよ！")
if rabbit_age < 2:
print("でもまだ若すぎるみたい…今回は止めておこう")
return False
return True
def risky_adventure(items):
"""リスク管理と安全設計"""
backup = items.copy()
print("\nピーター: 危険だけど、野菜を取りに行くよ！")
try:
if random.random() < 0.3:
raise ValueError("マグレガーさんが来た！逃げろ！")
items.append("新鮮な野菜")
print("ピーター: 野菜ゲット！")
except Exception as e:
logging.error(e)
print("ピーター: バックアップに退避…")
items = backup
return items
def escape_danger(event):
"""素早い状況判断と機転"""
if event == "farmer":
print("ピーター: マグレガーさんだ！安全な茂みに逃げよう")
event = "safe_spot"
print(f"ピーターは {event} に向かって進む\n")
def gather_food(food, failure_log):
"""失敗からの学習"""
try:
if random.random() < 0.4:
raise RuntimeError(f"{food} を落としてしまった！")
print(f"ピーター: {food} を収穫成功！")
return True
except RuntimeError as e:
print("ピーター:", e)
failure_log.append(food)
return False
def count_vegetables(a, b):
"""シンプルな表現力"""
return a + b
def choose_vegetable():
"""ユーザー視点のデザイン"""
while True:
choice = input("どの野菜を取りたい？数字で選んでね: ")
if choice.isdigit():
return int(choice)
print("数字で教えてね、ピーター！")
--- メインゲーム ---
def adventure_game():
print("🐰 ピーターラビットの一日冒険ゲーム 🐰")
failure_log = []
backpack = []
home = Burrow()
age = int(input("ピーターの年齢を入力してください (例: 1,2,3): "))
# 探検
if explore_garden(age):
backpack = risky_adventure(backpack)
# 危険回避
escape_danger("farmer")
# 食料収集
foods = ["にんじん", "レタス", "トマト"]
for food in foods:
gather_food(food, failure_log)
# 数える
total_veg = count_vegetables(3, 2)
print(f"ピーターは野菜を合計 {total_veg} 個持っているよ")
# ユーザー選択
veg_choice = choose_vegetable()
print(f"ピーターが選んだ野菜: {veg_choice}")
home.add_food("選んだ野菜")
# 巣穴の食料確認
home.show_stock()
# 失敗ログ表示
if failure_log:
print(f"ピーターの失敗ログ: {failure_log}")
else:
print("ピーターは今日は全て成功したよ！")
--- ゲーム開始 ---
if name == "main":
adventure_game()
🔹 ゲームの特徴
探索とリスク管理 → 畑を探検して野菜を取る
危険回避 → マグレガーさんを検知して逃げる
失敗の学習 → 収穫に失敗した場合は failure_log に記録
シンプルな操作 → 野菜の数を合計する簡単な関数
ユーザー参加 → どの野菜を取るか選択できる
巣穴管理 → 集めた野菜を巣穴に貯蔵
物語体験 → ピーターの冒険を追体験できる
希望であれば、次のステップとして複数ルート・分岐を追加して、ゲームが1回限りでなく繰り返し遊べる「冒険シナリオ型ゲーム」に拡張することも可能です。
作りますか？
あなた:
はい。お願いします。
ChatGPT:
では、先ほどの冒険ゲームをさらに拡張して、複数ルート・分岐があり、繰り返し遊べる冒険シナリオ型ゲームにしてみます。
プレイヤーの選択によって結果が変わり、ピーターの一日を何度でも楽しめます。
import random
import logging
logging.basicConfig(level=logging.ERROR)
--- クラス定義 ---
class Burrow:
"""巣穴管理クラス"""
def init(self):
self.stock = []
def add_food(self, item):
self.stock.append(item)
print(f"巣穴に {item} を貯蔵したよ")
def show_stock(self):
print("\n巣穴の中の食料:")
for f in self.stock:
print(f"- {f}")
print()
--- 関数定義 ---
def explore_garden(age):
"""好奇心とリスクコントロール"""
print("\nピーター: 畑を探検するよ！")
if age < 2:
print("まだ若すぎるみたい…今回は安全策を取ろう")
return False
return True
def risky_adventure(items):
"""リスク管理と安全設計"""
backup = items.copy()
print("\nピーター: 危険だけど、野菜を取りに行くよ！")
try:
if random.random() < 0.3:
raise ValueError("マグレガーさんが来た！逃げろ！")
items.append("新鮮な野菜")
print("ピーター: 野菜ゲット！")
except Exception as e:
logging.error(e)
print("ピーター: バックアップに退避…")
items = backup
return items
def escape_danger(event):
"""素早い状況判断と機転"""
if event == "farmer":
print("ピーター: マグレガーさんだ！安全な茂みに逃げよう")
event = "safe_spot"
print(f"ピーターは {event} に向かって進む\n")
def gather_food(food, failure_log):
"""失敗からの学習"""
try:
if random.random() < 0.4:
raise RuntimeError(f"{food} を落としてしまった！")
print(f"ピーター: {food} を収穫成功！")
return True
except RuntimeError as e:
print("ピーター:", e)
failure_log.append(food)
return False
def count_vegetables(a, b):
"""シンプルな表現力"""
return a + b
def choose_vegetable(foods):
"""ユーザー視点のデザイン"""
while True:
print("どの野菜を取りたい？")
for idx, food in enumerate(foods):
print(f"{idx + 1}: {food}")
choice = input("番号で選んでね: ")
if choice.isdigit() and 1 <= int(choice) <= len(foods):
return foods[int(choice) - 1]
print("有効な番号を入力してね！")
--- 新規：冒険シナリオ分岐 ---
def adventure_scenario(age, burrow, failure_log):
print("\n🌿 冒険のルートを選ぼう！")
print("1: 畑を真っ直ぐ進む（リスク高）")
print("2: 小道を回る（リスク低）")
route = input("選択肢 1 または 2: ")
if route == "1":
print("危険なルートを進むよ！")
backpack = risky_adventure([])
escape_danger("farmer")
gather_food("にんじん", failure_log)
elif route == "2":
print("安全な小道を進むよ。ゆっくり探検")
gather_food("レタス", failure_log)
else:
print("無効な選択。安全な小道を進むことにした")
gather_food("トマト", failure_log)
# ランダムイベント
if random.random() < 0.3:
print("\n🎵 ランダムイベント: 小鳥たちと遊ぶ")
print("ピーター: 楽しいひととき！体力回復")
else:
print("\nピーター: 静かに畑を見渡すだけ")
# 食料を巣穴に貯蔵
veg = choose_vegetable(["にんじん", "レタス", "トマト"])
burrow.add_food(veg)
--- メインゲームループ ---
def adventure_game():
print("🐰 ピーターラビットの冒険シナリオゲーム 🐰")
age = int(input("ピーターの年齢を入力してください (例: 1,2,3): "))
burrow = Burrow()
failure_log = []
while True:
if explore_garden(age):
adventure_scenario(age, burrow, failure_log)
burrow.show_stock()
if failure_log:
print(f"ピーターの失敗ログ: {failure_log}")
else:
print("ピーターは今日は全て成功したよ！")
replay = input("もう一度冒険する？ (y/n): ")
if replay.lower() != "y":
print("ピーター: 今日の冒険はここまで！おやすみなさい🐇")
break
--- ゲーム開始 ---
if name == "main":
adventure_game()
🔹 改良ポイント
複数ルート選択 → 「危険ルート」と「安全ルート」の選択肢
ランダムイベント → 小鳥と遊ぶなど、毎回変化するイベント
繰り返しプレイ可能 → ゲーム終了後に再挑戦できるループ
ユーザー参加型シナリオ → 選択に応じて収穫やイベントが変化
冒険の結果記録 → 巣穴の食料と失敗ログを維持
もし希望であれば、次のステップとして GUI化してボタン操作で選択できる「ビジュアル冒険ゲーム版」 にもできます。
作りますか？
ここまでのどれかの版をC++とRUSTで記述してください。
ChatGPT:
では、ここまで作った物語風ピーターラビット冒険ゲーム（簡単版）を、C++版とRust版に変換して示します。
まずは Python の「小規模テキストベース冒険ゲーム」を元にしています。
1️⃣ C++版
#include
#include
#include
#include
#include
class Burrow {
std::vectorstd::string stock;
public:
void add_food(const std::string& item) {
stock.push_back(item);
std::cout << "巣穴に " << item << " を貯蔵したよ\n";
}
void show_stock() {
std::cout << "\n巣穴の中の食料:\n";
for (const auto& f : stock) std::cout << "- " << f << "\n";
std::cout << std::endl;
}
};
// 好奇心とリスクコントロール
bool explore_garden(int age) {
std::cout << "\nピーター: 畑を探検するよ！\n";
if (age < 2) {
std::cout << "まだ若すぎるみたい…今回は止めておこう\n";
return false;
}
return true;
}
// リスク管理と安全設計
std::vectorstd::string risky_adventure(std::vectorstd::string items) {
std::vectorstd::string backup = items;
std::cout << "\nピーター: 危険だけど、野菜を取りに行くよ！\n";
if ((double)rand()/RAND_MAX < 0.3) {
std::cout << "マグレガーさんが来た！バックアップに退避…\n";
return backup;
}
items.push_back("新鮮な野菜");
std::cout << "ピーター: 野菜ゲット！\n";
return items;
}
// 素早い状況判断
void escape_danger(const std::string& event) {
if (event == "farmer") std::cout << "ピーター: マグレガーさんだ！安全な茂みに逃げよう\n";
}
// 失敗から学習
bool gather_food(const std::string& food, std::vectorstd::string& failure_log) {
if ((double)rand()/RAND_MAX < 0.4) {
std::cout << "ピーター: " << food << " を落としてしまった！\n";
failure_log.push_back(food);
return false;
}
std::cout << "ピーター: " << food << " を収穫成功！\n";
return true;
}
// シンプルな表現力
int count_vegetables(int a, int b) {
return a + b;
}
std::string choose_vegetable(const std::vectorstd::string& foods) {
while (true) {
std::cout << "どの野菜を取りたい？\n";
for (size_t i=0;i<foods.size();i++) std::cout << i+1 << ": " << foods[i] << "\n";
int choice;
std::cin >> choice;
if (choice >=1 && choice <= (int)foods.size()) return foods[choice-1];
std::cout << "有効な番号を入力してね！\n";
}
}
int main() {
srand(time(NULL));
std::cout << "🐰 ピーターラビットの一日冒険ゲーム 🐰\n";
int age;
std::cout << "ピーターの年齢を入力してください (例: 1,2,3): ";
std::cin >> age;
Burrow home;
std::vector<std::string> failure_log;
std::vector<std::string> backpack;
if (explore_garden(age)) {
backpack = risky_adventure(backpack);
}
escape_danger("farmer");
std::vector<std::string> foods = {"にんじん","レタス","トマト"};
for (const auto& f : foods) gather_food(f, failure_log);
std::cout << "ピーターは野菜を合計 " << count_vegetables(3,2) << " 個持っているよ\n";
std::string veg_choice = choose_vegetable(foods);
home.add_food(veg_choice);
home.show_stock();
if (!failure_log.empty()) {
std::cout << "ピーターの失敗ログ:\n";
for (auto &f: failure_log) std::cout << "- " << f << "\n";
} else {
std::cout << "ピーターは今日は全て成功したよ！\n";
}
return 0;
}
2️⃣ Rust版
use rand::Rng;
use std::io;
struct Burrow {
stock: Vec,
}
impl Burrow {
fn new() -> Burrow { Burrow { stock: Vec::new() } }
fn add_food(&mut self, item: &str) {
self.stock.push(item.to_string());
println!("巣穴に {} を貯蔵したよ", item);
}
fn show_stock(&self) {
println!("\n巣穴の中の食料:");
for f in &self.stock { println!("- {}", f); }
println!();
}
}
// 好奇心とリスクコントロール
fn explore_garden(age: u32) -> bool {
println!("\nピーター: 畑を探検するよ！");
if age < 2 {
println!("まだ若すぎるみたい…今回は止めておこう");
return false;
}
true
}
// リスク管理と安全設計
fn risky_adventure(items: &mut Vec) {
let mut rng = rand::thread_rng();
println!("\nピーター: 危険だけど、野菜を取りに行くよ！");
if rng.gen::() < 0.3 {
println!("マグレガーさんが来た！バックアップに退避…");
return;
}
items.push("新鮮な野菜".to_string());
println!("ピーター: 野菜ゲット！");
}
// 素早い状況判断
fn escape_danger(event: &str) {
if event == "farmer" {
println!("ピーター: マグレガーさんだ！安全な茂みに逃げよう");
}
}
// 失敗から学習
fn gather_food(food: &str, failure_log: &mut Vec) {
let mut rng = rand::thread_rng();
if rng.gen::() < 0.4 {
println!("ピーター: {} を落としてしまった！", food);
failure_log.push(food.to_string());
} else {
println!("ピーター: {} を収穫成功！", food);
}
}
// シンプルな表現力
fn count_vegetables(a: i32, b: i32) -> i32 {
a + b
}
// ユーザー選択
fn choose_vegetable(foods: &[&str]) -> String {
loop {
println!("どの野菜を取りたい？");
for (i, f) in foods.iter().enumerate() {
println!("{}: {}", i+1, f);
}
let mut input = String::new();
io::stdin().read_line(&mut input).expect("入力エラー");
if let Ok(choice) = input.trim().parse::() {
if choice >=1 && choice <= foods.len() {
return foods[choice-1].to_string();
}
}
println!("有効な番号を入力してね！");
}
}
fn main() {
println!("🐰 ピーターラビットの一日冒険ゲーム 🐰");
let mut input = String::new();
println!("ピーターの年齢を入力してください (例: 1,2,3): ");
io::stdin().read_line(&mut input).expect("入力エラー");
let age: u32 = input.trim().parse().unwrap_or(1);
let mut home = Burrow::new();
let mut failure_log: Vec<String> = Vec::new();
let mut backpack: Vec<String> = Vec::new();
if explore_garden(age) {
risky_adventure(&mut backpack);
}
escape_danger("farmer");
let foods = ["にんじん","レタス","トマト"];
for f in &foods {
gather_food(f, &mut failure_log);
}
println!("ピーターは野菜を合計 {} 個持っているよ", count_vegetables(3,2));
let veg_choice = choose_vegetable(&foods);
home.add_food(&veg_choice);
home.show_stock();
if !failure_log.is_empty() {
println!("ピーターの失敗ログ:");
for f in &failure_log { println!("- {}", f); }
} else {
println!("ピーターは今日は全て成功したよ！");
}
}
このC++版・Rust版は、Python版の小規模冒険ゲームと同じ構造を保持し、
探検
危険回避
食料収集
ユーザー選択
巣穴管理
をすべて再現しています。
希望であれば、この分岐ルート＋ランダムイベント付きのシナリオ版もC++/Rustで作成できます。
作りますか？
あなた:
はい。お願いします。
ChatGPT:
では、先ほどの 「分岐ルート＋ランダムイベント付きのシナリオ版冒険ゲーム」 を C++ と Rust 両方で作成します。
Python版を忠実に再現しつつ、ループで繰り返しプレイでき、分岐とランダムイベントも反映します。
1️⃣ C++版（シナリオ＋分岐＋ランダムイベント）
#include
#include
#include
#include
#include
class Burrow {
std::vectorstd::string stock;
public:
void add_food(const std::string& item) {
stock.push_back(item);
std::cout << "巣穴に " << item << " を貯蔵したよ\n";
}
void show_stock() {
std::cout << "\n巣穴の中の食料:\n";
for (const auto& f : stock) std::cout << "- " << f << "\n";
std::cout << std::endl;
}
};
// 探検
bool explore_garden(int age) {
std::cout << "\nピーター: 畑を探検するよ！\n";
if (age < 2) {
std::cout << "まだ若すぎるみたい…今回は安全策を取ろう\n";
return false;
}
return true;
}
// 危険ルート
std::vectorstd::string risky_adventure(std::vectorstd::string items) {
std::vectorstd::string backup = items;
std::cout << "\nピーター: 危険だけど、野菜を取りに行くよ！\n";
if ((double)rand()/RAND_MAX < 0.3) {
std::cout << "マグレガーさんが来た！バックアップに退避…\n";
return backup;
}
items.push_back("新鮮な野菜");
std::cout << "ピーター: 野菜ゲット！\n";
return items;
}
// 危険回避
void escape_danger(const std::string& event) {
if (event == "farmer") std::cout << "ピーター: マグレガーさんだ！安全な茂みに逃げよう\n";
}
// 収穫
void gather_food(const std::string& food, std::vectorstd::string& failure_log) {
if ((double)rand()/RAND_MAX < 0.4) {
std::cout << "ピーター: " << food << " を落としてしまった！\n";
failure_log.push_back(food);
} else {
std::cout << "ピーター: " << food << " を収穫成功！\n";
}
}
// 野菜選択
std::string choose_vegetable(const std::vectorstd::string& foods) {
while (true) {
std::cout << "どの野菜を取りたい？\n";
for (size_t i=0;i<foods.size();i++) std::cout << i+1 << ": " << foods[i] << "\n";
int choice;
std::cin >> choice;
if (choice >=1 && choice <= (int)foods.size()) return foods[choice-1];
std::cout << "有効な番号を入力してね！\n";
}
}
// 分岐シナリオ
void adventure_scenario(int age, Burrow& burrow, std::vectorstd::string& failure_log) {
std::cout << "\n🌿 冒険のルートを選ぼう！\n";
std::cout << "1: 危険ルート\n2: 安全な小道\n";
int route;
std::cin >> route;
if (route == 1) {
std::vector<std::string> backpack;
backpack = risky_adventure(backpack);
escape_danger("farmer");
gather_food("にんじん", failure_log);
} else {
std::cout << "安全な小道を進むよ\n";
gather_food("レタス", failure_log);
}
// ランダムイベント
if ((double)rand()/RAND_MAX < 0.3) {
std::cout << "\n🎵 ランダムイベント: 小鳥たちと遊ぶ\n";
std::cout << "ピーター: 楽しいひととき！体力回復\n";
}
// 食料巣穴に貯蔵
std::string veg = choose_vegetable({"にんじん","レタス","トマト"});
burrow.add_food(veg);
}
// ゲームループ
int main() {
srand(time(NULL));
std::cout << "🐰 ピーターラビットの冒険シナリオゲーム 🐰\n";
int age;
std::cout << "ピーターの年齢を入力してください (例: 1,2,3): ";
std::cin >> age;
Burrow home;
std::vector<std::string> failure_log;
while (true) {
if (explore_garden(age)) {
adventure_scenario(age, home, failure_log);
}
home.show_stock();
if (!failure_log.empty()) {
std::cout << "ピーターの失敗ログ:\n";
for (auto &f: failure_log) std::cout << "- " << f << "\n";
}
std::cout << "もう一度冒険する？ (1=はい 0=いいえ): ";
int replay;
std::cin >> replay;
if (replay != 1) {
std::cout << "ピーター: 今日の冒険はここまで！おやすみなさい🐇\n";
break;
}
}
return 0;
}
2️⃣ Rust版（シナリオ＋分岐＋ランダムイベント）
use rand::Rng;
use std::io;
struct Burrow {
stock: Vec,
}
impl Burrow {
fn new() -> Burrow { Burrow { stock: Vec::new() } }
fn add_food(&mut self, item: &str) {
self.stock.push(item.to_string());
println!("巣穴に {} を貯蔵したよ", item);
}
fn show_stock(&self) {
println!("\n巣穴の中の食料:");
for f in &self.stock { println!("- {}", f); }
println!();
}
}
fn explore_garden(age: u32) -> bool {
println!("\nピーター: 畑を探検するよ！");
if age < 2 {
println!("まだ若すぎるみたい…今回は安全策を取ろう");
return false;
}
true
}
fn risky_adventure(items: &mut Vec) {
let mut rng = rand::thread_rng();
println!("\nピーター: 危険だけど、野菜を取りに行くよ！");
if rng.gen::() < 0.3 {
println!("マグレガーさんが来た！バックアップに退避…");
return;
}
items.push("新鮮な野菜".to_string());
println!("ピーター: 野菜ゲット！");
}
fn escape_danger(event: &str) {
if event == "farmer" {
println!("ピーター: マグレガーさんだ！安全な茂みに逃げよう");
}
}
fn gather_food(food: &str, failure_log: &mut Vec) {
let mut rng = rand::thread_rng();
if rng.gen::() < 0.4 {
println!("ピーター: {} を落としてしまった！", food);
failure_log.push(food.to_string());
} else {
println!("ピーター: {} を収穫成功！", food);
}
}
fn choose_vegetable(foods: &[&str]) -> String {
loop {
println!("どの野菜を取りたい？");
for (i, f) in foods.iter().enumerate() {
println!("{}: {}", i+1, f);
}
let mut input = String::new();
io::stdin().read_line(&mut input).expect("入力エラー");
if let Ok(choice) = input.trim().parse::() {
if choice >=1 && choice <= foods.len() {
return foods[choice-1].to_string();
}
}
println!("有効な番号を入力してね！");
}
}
fn adventure_scenario(age: u32, burrow: &mut Burrow, failure_log: &mut Vec) {
println!("\n🌿 冒険のルートを選ぼう！");
println!("1: 危険ルート\n2: 安全な小道");
let mut input = String::new();
io::stdin().read_line(&mut input).expect("入力エラー");
let route = input.trim();
if route == "1" {
let mut backpack: Vec<String> = Vec::new();
risky_adventure(&mut backpack);
escape_danger("farmer");
gather_food("にんじん", failure_log);
} else {
println!("安全な小道を進むよ");
gather_food("レタス", failure_log);
}
let mut rng = rand::thread_rng();
if rng.gen::<f64>() < 0.3 {
println!("\n🎵 ランダムイベント: 小鳥たちと遊ぶ");
println!("ピーター: 楽しいひととき！体力回復");
}
let veg = choose_vegetable(&["にんじん","レタス","トマト"]);
burrow.add_food(&veg);
}
fn main() {
println!("🐰 ピーターラビットの冒険シナリオゲーム 🐰");
let mut input = String::new();
println!("ピーターの年齢を入力してください (例: 1,2,3): ");
io::stdin().read_line(&mut input).expect("入力エラー");
let age: u32 = input.trim().parse().unwrap_or(1);
let mut burrow = Burrow::new();
let mut failure_log: Vec<String> = Vec::new();
loop {
if explore_garden(age) {
adventure_scenario(age, &mut burrow, &mut failure_log);
}
burrow.show_stock();
if !failure_log.is_empty() {
println!("ピーターの失敗ログ:");
for f in &failure_log { println!("- {}", f); }
}
println!("もう一度冒険する？ (y/n): ");
input.clear();
io::stdin().read_line(&mut input).expect("入力エラー");
if input.trim().to_lowercase() != "y" {
println!("ピーター: 今日の冒険はここまで！おやすみなさい🐇");
break;
}
}
}
>✅ この C++ / Rust 版は以下を実現しています：
分岐ルート（危険ルート／安全ルート）
ランダムイベント（小鳥と遊ぶなど）
巣穴への食料貯蔵
失敗ログの記録
繰り返しプレイ可能（ゲームループ）
ユーザー選択型のインタラクティブ体験
希望であれば、次はGUI（ボタン操作）で選択できる可視化版も作成できます。
作りますか？
ChatGPT の回答は必ずしも正しいとは限りません。重要な情報は確認するようにしてください。