ソースコード source code

下記アプリの主要なソースコードを公開しています。アプリ開発の参考になれば幸いです。

画像等が別途必要ですので下記情報のみでアプリが完成するものではありません。 アプリは少しずつ機能拡張していますのでストア公開されているアプリと内容が異なる場合があります。 コードはコピーして自由にお使いいただけます。ただし著作権は放棄しておりませんので全部の再掲載はご遠慮ください。部分的に再掲載したり、改変して再掲載するのは構いません。 自身のアプリ作成の参考として個人使用・商用問わず自由にお使いいただけます。 コード記述のお手本を示すものではありません。ミニアプリですので変数名などさほど気遣いしていない部分も有りますし間違いも有るかと思いますので参考程度にお考え下さい。 他の賢者の皆様が公開されているコードを参考にした箇所も含まれます。Flutter開発の熟練者が書いたコードではありません。 エンジニア向け技術情報共有サービスではありませんので説明は省いています。 GitHubなどへの公開は予定しておりません。

下記コードの最終ビルド日: 2023-11-26

pubspec.yaml

name: twosidesofcoin
description: "Two Sides Of Coin"
# The following line prevents the package from being accidentally published to
# pub.dev using `flutter pub publish`. This is preferred for private packages.
publish_to: 'none' # Remove this line if you wish to publish to pub.dev

# The following defines the version and build number for your application.
# A version number is three numbers separated by dots, like 1.2.43
# followed by an optional build number separated by a +.
# Both the version and the builder number may be overridden in flutter
# build by specifying --build-name and --build-number, respectively.
# In Android, build-name is used as versionName while build-number used as versionCode.
# Read more about Android versioning at https://developer.android.com/studio/publish/versioning
# In iOS, build-name is used as CFBundleShortVersionString while build-number is used as CFBundleVersion.
# Read more about iOS versioning at
# https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
# In Windows, build-name is used as the major, minor, and patch parts
# of the product and file versions while build-number is used as the build suffix.
version: 2.0.1+10

environment:
  sdk: '>=3.3.0-200.0.dev <4.0.0'

# Dependencies specify other packages that your package needs in order to work.
# To automatically upgrade your package dependencies to the latest versions
# consider running `flutter pub upgrade --major-versions`. Alternatively,
# dependencies can be manually updated by changing the version numbers below to
# the latest version available on pub.dev. To see which dependencies have newer
# versions available, run `flutter pub outdated`.
dependencies:
  flutter:
    sdk: flutter

  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  cupertino_icons: ^1.0.6
  package_info_plus: ^5.0.1
  shared_preferences: ^2.0.17
  flutter_localizations:    #多言語ライブラリの本体    # .arbファイルを更新したら flutter gen-l10n
    sdk: flutter
  intl: ^0.18.1     #多言語やフォーマッタなどの関連ライブラリ
  google_mobile_ads: ^4.0.0
  just_audio: ^0.9.35
  video_player: ^2.8.1

dev_dependencies:
  flutter_test:
    sdk: flutter

  flutter_launcher_icons: ^0.13.1    #flutter pub run flutter_launcher_icons
  flutter_native_splash: ^2.3.6     #flutter pub run flutter_native_splash:create

  # The "flutter_lints" package below contains a set of recommended lints to
  # encourage good coding practices. The lint set provided by the package is
  # activated in the `analysis_options.yaml` file located at the root of your
  # package. See that file for information about deactivating specific lint
  # rules and activating additional ones.
  flutter_lints: ^3.0.1

# For information on the generic Dart part of this file, see the
# following page: https://dart.dev/tools/pub/pubspec

flutter_launcher_icons:
  android: "launcher_icon"
  ios: true
  image_path: "assets/icon/icon.png"
  adaptive_icon_background: "assets/icon/icon_back.png"
  adaptive_icon_foreground: "assets/icon/icon_fore.png"

flutter_native_splash:
  color: '#c29553'
  image: 'assets/image/splash.png'
  color_dark: '#c29553'
  image_dark: 'assets/image/splash.png'
  fullscreen: true
  android_12:
    icon_background_color: '#c29553'
    image: 'assets/image/splash.png'
    icon_background_color_dark: '#c29553'
    image_dark: 'assets/image/splash.png'

# The following section is specific to Flutter packages.
flutter:
  generate: true    #自動生成フラグの有効化

  # The following line ensures that the Material Icons font is
  # included with your application, so that you can use the icons in
  # the material Icons class.
  uses-material-design: true

  # To add assets to your application, add an assets section, like this:
  # assets:
  #   - images/a_dot_burr.jpeg
  #   - images/a_dot_ham.jpeg
  assets:
    - assets/image/
    - assets/sound/

  # An image asset can refer to one or more resolution-specific "variants", see
  # https://flutter.dev/assets-and-images/#resolution-aware

  # For details regarding adding assets from package dependencies, see
  # https://flutter.dev/assets-and-images/#from-packages

  # To add custom fonts to your application, add a fonts section here,
  # in this "flutter" section. Each entry in this list should have a
  # "family" key with the font family name, and a "fonts" key with a
  # list giving the asset and other descriptors for the font. For
  # example:
  # fonts:
  #   - family: Schyler
  #     fonts:
  #       - asset: fonts/Schyler-Regular.ttf
  #       - asset: fonts/Schyler-Italic.ttf
  #         style: italic
  #   - family: Trajan Pro
  #     fonts:
  #       - asset: fonts/TrajanPro.ttf
  #       - asset: fonts/TrajanPro_Bold.ttf
  #         weight: 700
  #
  # For details regarding fonts from package dependencies,
  # see https://flutter.dev/custom-fonts/#from-packages

lib/ad_mob.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-02-06
///
library;

import 'package:flutter/material.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart';
import 'package:flutter/foundation.dart' show kIsWeb;
import 'dart:io';

class AdMob {
  late BannerAd _adMobBanner;
  bool _isAdMob = false;
  AdMob() { //constructor
    String adBannerUnitId = '';
    if (!kIsWeb && Platform.isAndroid) {
      //adBannerUnitId = 'ca-app-pub-3940256099942544/6300978111';  //test
      adBannerUnitId = 'ca-app-pub-0000000000000000/0000000000';
      _isAdMob = true;
    } else if (!kIsWeb && Platform.isIOS) {
      //adBannerUnitId = 'ca-app-pub-3940256099942544/6300978111';  //test
      adBannerUnitId = 'ca-app-pub-0000000000000000/0000000000';
      _isAdMob = true;
    }
    if (_isAdMob) {
      _adMobBanner = BannerAd(
        adUnitId: adBannerUnitId,
        size: AdSize.banner,
        request: const AdRequest(),
        listener: const BannerAdListener(),
      );
    }
  }
  void load() {
    if (_isAdMob) {
      _adMobBanner.load();
    }
  }
  void dispose() {
    if (_isAdMob) {
      _adMobBanner.dispose();
    }
  }
  Widget getAdBannerWidget() {
    if (_isAdMob) {
      return Container(
        alignment: Alignment.center,
        width: _adMobBanner.size.width.toDouble(),
        height: _adMobBanner.size.height.toDouble(),
        child: AdWidget(ad: _adMobBanner),
      );
    } else {
      return Container();
    }
  }
  double getAdBannerHeight() {
    if (_isAdMob) {
      return _adMobBanner.size.height.toDouble();
    } else {
      return 150;  //for web
    }
  }
}

lib/const_value.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-10-15
///
library;

import 'package:flutter/material.dart';

class ConstValue {
  //pref
  static const String prefLanguageCode = 'languageCode';
  static const String prefCoinRatio = 'coinRatio';
  static const String prefCountdownTime = 'countdownTime';
  static const String prefSoundReadyVolume = 'soundReadyVolume';
  static const String prefSoundStartVolume = 'soundStartVolume';
  //color
  static const Color colorHeader = Color.fromRGBO(0,0,0,0.1);
  static const Color colorHeaderOn = Color.fromRGBO(148,128,121,1);
  static const Color colorNote = Color.fromRGBO(0,0,0,0.8);
  static const Color colorBack = Color.fromRGBO(154,132,71,1);
  static const Color colorSettingHeader = Color.fromRGBO(154,132,71,1);
  static const Color colorUiActiveColor = Color.fromRGBO(154,132,71,1);
  static const Color colorUiInactiveColor = Colors.black26;
  //sound
  static const String audioZero = 'assets/sound/zero.wav';    //無音1秒
  static const String audioReady = 'assets/sound/switch.wav';
  static const String audioAction = 'assets/sound/slide.wav';
  //movie
  static const List<String> movieCoins = [
    'assets/image/coin_a.mp4',
    'assets/image/coin_b.mp4',
  ];
  //image
  static const List<String> imageNumbers = [
    'assets/image/number_null.webp',
    'assets/image/number1.webp',
    'assets/image/number2.webp',
    'assets/image/number3.webp',
    'assets/image/number4.webp',
    'assets/image/number5.webp',
    'assets/image/number6.webp',
    'assets/image/number7.webp',
    'assets/image/number8.webp',
    'assets/image/number9.webp',
  ];
  //string
  static const Map<String,String> languageCode = {
    'en': 'English',
    'bg': 'български език',
    'cs': 'Čeština',
    'da': 'dansk',
    'de': 'Deutsch',
    'el': 'Ελληνικά',
    'es': 'Español',
    'et': 'eesti keel',
    'fi': 'Suomen kieli',
    'fr': 'Français',
    'hu': 'magyar nyelv',
    'it': 'Italiano',
    'ja': '日本語',
    'lt': 'lietuvių kalba',
    'lv': 'Latviešu',
    'nl': 'Nederlands',
    'pl': 'Polski',
    'pt': 'Português',
    'ro': 'limba română',
    'ru': 'русский',
    'sk': 'Slovenčina',
    'sv': 'svenska',
    'th': 'ภาษาไทย',
    'zh': '中文',
  };

}

lib/empty.dart

lib/language_state.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-01-27
///
library;

import 'package:twosidesofcoin/preferences.dart';

class LanguageState {

  static String _languageCode = 'en';

  //言語コードを記録
  static Future<void> setLanguageCode(String str) async {
    _languageCode = str;
    await Preferences.setLanguageCode(_languageCode);
  }
  //言語コードを返す
  static Future<String> getLanguageCode() async {
    _languageCode = await Preferences.getLanguageCode() ?? 'en';
    return _languageCode;
  }

}

lib/main.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-10-02
///
library;

import 'dart:async';
import 'dart:math';
import 'package:flutter/material.dart';
import 'package:package_info_plus/package_info_plus.dart';
import 'package:flutter_gen/gen_l10n/app_localizations.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart' if (dart.library.html) 'empty.dart';
import 'package:flutter/foundation.dart' show kIsWeb;
import 'package:video_player/video_player.dart';

//自身で作成したclassを読み込む
import 'package:twosidesofcoin/const_value.dart';
import 'package:twosidesofcoin/language_state.dart';
import 'package:twosidesofcoin/version_state.dart';
import 'package:twosidesofcoin/setting.dart';
import 'package:twosidesofcoin/ad_mob.dart';
import 'package:twosidesofcoin/page_state.dart';
import 'package:twosidesofcoin/preferences.dart';
import 'package:twosidesofcoin/audio_play.dart';

void main() {
  runApp(const MainApp());
}

class MainApp extends StatefulWidget {    //statefulに変更して言語変更に対応
  const MainApp({super.key});
  @override
  State<MainApp> createState() => _MainAppState();
}

class _MainAppState extends State<MainApp> {
  Locale localeLanguage = const Locale('en');
  @override
  Widget build(BuildContext context) {
    if (kIsWeb == false) {
      MobileAds.instance.initialize();
    }
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      localizationsDelegates: AppLocalizations.localizationsDelegates,   //多言語化
      supportedLocales: AppLocalizations.supportedLocales,  //自動で言語リストを生成
      locale: localeLanguage,
      home: const MainHomePage(),
    );
  }
}

class MainHomePage extends StatefulWidget {
  const MainHomePage({super.key});
  @override
  State<MainHomePage> createState() => _MainHomePageState();
}

class _MainHomePageState extends State<MainHomePage> with SingleTickerProviderStateMixin {
  final AdMob _adMob = AdMob(); //広告表示
  final AudioPlay _audioPlay = AudioPlay(); //効果音
  late Random _random;
  double _screenWidth = 0;  //画面幅
  bool _busyFlag = false; //動作中
  //countdown
  late Timer _timer;  //カウントダウンで使用
  int _countdownSubtraction = 0;  //_countdownTimeが代入されて実際にカウントダウンされる
  String _imageCountdownNumber = ConstValue.imageNumbers[0];  //カウントダウン画像
  double _countdownScale = 3;   //カウントダウン画像の拡大率
  double _countdownOpacity = 0; //カウントダウン画像の非透明度
  int _timerCount = 30; //Timerで処理される1秒間の数
  //動画
  final List<VideoPlayerController?> _videoPlayerController = [null,null];
  int _coinIndex = 0;  //0|1

  //アプリのバージョン取得
  void _getVersion() async {
    PackageInfo packageInfo = await PackageInfo.fromPlatform();
    setState(() {
      VersionState.versionSave(packageInfo.version);
    });
  }
  //言語準備
  void _getCurrentLocale() async {
    Locale locale = Locale(await LanguageState.getLanguageCode());
    if (mounted) {  //Widgetが存在する。Widgetが存在しない時の実行によるエラーを回避する為。
      context.findAncestorStateOfType<_MainAppState>()!
        ..localeLanguage = locale
        ..setState(() {});
    }
  }
  //ページ起動開始時に一度だけ呼ばれる
  @override
  void initState() {
    super.initState();
    _getVersion();
    _getCurrentLocale();
    LanguageState.getLanguageCode();
    _adMob.load();
    _audioPlay.playZero();
    _random = Random(DateTime.now().millisecondsSinceEpoch);
    //
    for (int i = 0; i < 2; i++) {
      _videoPlayerController[i] = VideoPlayerController.asset(ConstValue.movieCoins[i],
        videoPlayerOptions: VideoPlayerOptions(mixWithOthers: true),  //複数の動画を処理
      );
      _videoPlayerController[i]?.addListener(() => setState((){}) );
      _videoPlayerController[i]?.setLooping(false);
      _videoPlayerController[i]?.initialize().then((_) => setState((){}) );
    }
    //
    (() async {
      await Preferences.initial();
      _audioPlay.soundVolume01 = Preferences.soundReadyVolume;
      _audioPlay.soundVolume02 = Preferences.soundStartVolume;
      setState(() {});
    })();
  }
  //ページ終了時に一度だけ呼ばれる
  @override
  void dispose() {
    PageState.setCurrentPage('');
    _adMob.dispose();
    _timer.cancel();
    for (int i = 0; i < 2; i++) {
      _videoPlayerController[i]?.dispose();
    }
    super.dispose();
  }
  //画面全体
  @override
  Widget build(BuildContext context) {
    _screenWidth = MediaQuery.of(context).size.width;
    return Scaffold(
      backgroundColor: ConstValue.colorBack,
      appBar: AppBar(
        backgroundColor: _busyFlag ? ConstValue.colorHeaderOn : ConstValue.colorHeader,
        //タイトル表示
        title: const Text('Coin toss',
          style: TextStyle(
            color: Colors.white,
            fontSize: 15.0,
          )
        ),
        //設定ボタン
        actions: <Widget>[
          Opacity(
            opacity: _busyFlag ? 0.1 : 1,
            child: TextButton(
              onPressed: () async {
                if (_busyFlag) {
                  return;
                }
                bool? ret = await Navigator.of(context).push(
                  MaterialPageRoute<bool>(builder:(context) => const SettingPage()),
                );
                //awaitで呼び出しているので、settingから戻ったら以下が実行される。
                if (ret!) { //設定で適用だった場合
                  _getCurrentLocale();
                  _audioPlay.soundVolume01 = Preferences.soundReadyVolume;
                  _audioPlay.soundVolume02 = Preferences.soundStartVolume;
                  setState(() {});
                }
              },
              child: Text(
                AppLocalizations.of(context)!.setting,
                style: const TextStyle(
                  color: Colors.white,
                )
              )
            )
          )
        ]
      ),
      body: SafeArea(
        child: GestureDetector(
          onTap: () {
            _onClickStart();
          },
          child: Column(children:[
            Expanded(
              child: Stack(children:[
                Positioned(
                  top: 0,
                  child: SizedBox(
                    width: _screenWidth,
                    height: _screenWidth * 2,
                    child: VideoPlayer(_videoPlayerController[_coinIndex]!),
                  )
                ),
                Center(
                  child: Opacity(
                    opacity: _countdownOpacity,
                    child: Transform.scale(
                      scale: _countdownScale,
                      child: Image.asset(_imageCountdownNumber),
                    )
                  )
                ),
                SizedBox(
                  width: double.infinity,
                  child: Text(AppLocalizations.of(context)!.start,
                    textAlign: TextAlign.center,
                    style: const TextStyle(color: ConstValue.colorNote)
                  )
                ),
              ])
            ),
            //広告
            Padding(
              padding: const EdgeInsets.only(top: 10, left: 0, right: 0, bottom: 0),
              child: SizedBox(
                width: double.infinity,
                child: _adMob.getAdBannerWidget(),
              )
            )
          ])
        )
      )
    );
  }
  //カウントダウンタイマー
  void _timerStart() {
    _timer = Timer.periodic(const Duration(milliseconds: (1000 ~/ 30)), (timer) {
      setState(() {
        _countdown();
      });
    });
  }
  //START
  void _onClickStart() async {
    if (_busyFlag) {
      return;
    }
    _busyFlag = true;
    for (int i = 0; i < 2; i++) {
      await _videoPlayerController[i]!.seekTo(Duration.zero);
    }
    _countdownSubtraction = Preferences.countdownTime;
    if (_countdownSubtraction == 0) { //カウントダウンしない場合
      _moviePlay();
    } else {
      _audioPlay.soundVolume01 = Preferences.soundReadyVolume;
      _audioPlay.play01();
      _timerStart();
    }
  }
  //動画再生
  void _moviePlay() async {
    _audioPlay.soundVolume02 = Preferences.soundStartVolume;
    _audioPlay.play02();
    _coinIndex = (_random.nextInt(101) < Preferences.coinRatio) ? 1 : 0;
    _videoPlayerController[_coinIndex]!.play();
    Future.delayed(const Duration(milliseconds: 2300)).then((_) => {
      _movieStopChecker(),
    });
  }
  //動画の終了を待ってから_busyFlagをfalseにする
  void _movieStopChecker() {
    if (_videoPlayerController[_coinIndex]!.value.isPlaying) {
      Future.delayed(const Duration(milliseconds: 300)).then((_) => {
        _movieStopChecker(),
      });
    } else {
      _busyFlag = false;
      setState((){});
    }
  }
  //Timerで定期実行
  void _countdown() {
    //カウントダウン終了時
    if (_countdownSubtraction == 0) {
      return;
    }
    //数字画像を切り替え
    if (_timerCount == 30) {
      _imageCountdownNumber = ConstValue.imageNumbers[_countdownSubtraction];
    }
    _timerCount -= 1;
    if (_timerCount <= 0) {
      _timerCount = 30;
      _countdownSubtraction -= 1;
      if (_countdownSubtraction == 0) {
        _imageCountdownNumber = ConstValue.imageNumbers[0];
        _timer.cancel();
        _moviePlay();
      }
    }
    _countdownScale = 1 + (0.1 * (_timerCount / 30));
    if (_timerCount >= 20) {
      _countdownOpacity = (30 - _timerCount) / 10;
    } else if (_timerCount <= 5) {
      _countdownOpacity = _timerCount / 5;
    } else {
      _countdownOpacity = 1;
    }
  }
}

lib/page_state.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-10-05
///
library;

//現在のページを記録。initStateでタイミングが合わない時にbuild内で一度だけ実行させるために使用。
class PageState {

  static String _currentPage = '';

  static void setCurrentPage(String str) {
    _currentPage = str;
  }

  static String getCurrentPage() {
    return _currentPage;
  }

}

lib/preferences.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-10-26
///
library;

import 'package:shared_preferences/shared_preferences.dart';

import 'package:twosidesofcoin/const_value.dart';

//デバイスに情報を保存
class Preferences {

  static bool ready = false;
  //この値は常に最新にしておく
  static String _languageCode = '';
  static int _coinRatio = 50; //0..100
  static int _countdownTime = 0;
  static double _soundReadyVolume = 0.5;
  static double _soundStartVolume = 0.5;

  static String get languageCode {
    return _languageCode;
  }
  static int get coinRatio {
    return _coinRatio;
  }
  static int get countdownTime {
    return _countdownTime;
  }
  static double get soundReadyVolume {
    return _soundReadyVolume;
  }
  static double get soundStartVolume {
    return _soundStartVolume;
  }

  static Future<void> initial() async {
    _languageCode = await getLanguageCode();
    _coinRatio = await getCoinRatio();
    _countdownTime = await getCountdownTime();
    _soundReadyVolume = await getSoundReadyVolume();
    _soundStartVolume = await getSoundStartVolume();
    ready = true;
  }

  //----------------------------

  //言語コード
  static Future<void> setLanguageCode(String str) async {
    _languageCode = str;
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setString(ConstValue.prefLanguageCode, str);
  }
  static Future<String> getLanguageCode() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    final String str = prefs.getString(ConstValue.prefLanguageCode) ?? 'en';
    return str;
  }

  //----------------------------

  //比率
  static Future<void> setCoinRatio(int num) async {
    _coinRatio = num;
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setInt(ConstValue.prefCoinRatio, num);
  }
  static Future<int> getCoinRatio() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    final int num = prefs.getInt(ConstValue.prefCoinRatio) ?? 50;
    return num;
  }

  //----------------------------

  //カウントダウン時間
  static Future<void> setCountdownTime(int num) async {
    _countdownTime = num;
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setInt(ConstValue.prefCountdownTime, num);
  }
  static Future<int> getCountdownTime() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    final int num = prefs.getInt(ConstValue.prefCountdownTime) ?? 0;
    return num;
  }

  //----------------------------

  //効果音音量
  static Future<void> setSoundReadyVolume(double num) async {
    _soundReadyVolume = num;
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setDouble(ConstValue.prefSoundReadyVolume, num);
  }
  static Future<double> getSoundReadyVolume() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    final double num = prefs.getDouble(ConstValue.prefSoundReadyVolume) ?? 0.5;
    return num;
  }

  //----------------------------

  //効果音音量
  static Future<void> setSoundStartVolume(double num) async {
    _soundStartVolume = num;
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setDouble(ConstValue.prefSoundStartVolume, num);
  }
  static Future<double> getSoundStartVolume() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    final double num = prefs.getDouble(ConstValue.prefSoundStartVolume) ?? 0.5;
    return num;
  }

//----------------------------

}

lib/setting.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-10-15
///
library;

import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/app_localizations.dart';

import 'package:twosidesofcoin/const_value.dart';
import 'package:twosidesofcoin/preferences.dart';
import 'package:twosidesofcoin/language_state.dart';
import 'package:twosidesofcoin/version_state.dart';
import 'package:twosidesofcoin/ad_mob.dart';
import 'package:twosidesofcoin/page_state.dart';

class SettingPage extends StatefulWidget {
  const SettingPage({super.key});

  @override
  State<SettingPage> createState() => _SettingPageState();
}

class _SettingPageState extends State<SettingPage> {
  final AdMob _adMob = AdMob(); //広告
  //これら変数はUIへの表示や入力の為に一時的に使用される。
  String _languageKey = ''; //言語コード 'en'
  String _languageValue = '';
  int _coinRatio = 50;
  int _countdownTime = 0;
  double _soundReadyVolume = 0.5;
  double _soundStartVolume = 0.5;

  //ページ起動時に一度だけ実行される
  @override
  void initState() {
    super.initState();
    _adMob.load();
  }
  //ページ終了時に一度だけ実行される
  @override
  void dispose() {
    PageState.setCurrentPage('');
    _adMob.dispose();
    super.dispose();
  }
  //ページ描画
  @override
  Widget build(BuildContext context) {
    //このページが開いたときに一度だけ実行される処理を記述。initStateではタイミングが合わない為。
    if (PageState.getCurrentPage() != 'setting') {
      PageState.setCurrentPage('setting');
      (() async {
        _languageKey = await LanguageState.getLanguageCode();
        _languageValue = ConstValue.languageCode[_languageKey] ?? '';
        await Preferences.initial();
        _coinRatio = Preferences.coinRatio;
        _countdownTime = Preferences.countdownTime;
        _soundReadyVolume = Preferences.soundReadyVolume;
        _soundStartVolume = Preferences.soundStartVolume;
        setState((){});
      })();
    }
    return Scaffold(
      appBar: AppBar(
        centerTitle: true,
        elevation: 0,
        //設定キャンセルボタン
        leading: IconButton(
          icon: const Icon(Icons.close),
          onPressed: () {
            Navigator.of(context).pop(false); //falseを返す
          },
        ),
        title: Text(AppLocalizations.of(context)!.setting),
        foregroundColor: const Color.fromRGBO(255,255,255,1),
        backgroundColor: ConstValue.colorSettingHeader,
        actions: [
          //設定OKボタン
          IconButton(
            icon: const Icon(Icons.check),
            onPressed: () async {
              await LanguageState.setLanguageCode(_languageKey);
              await Preferences.setCoinRatio(_coinRatio);
              await Preferences.setCountdownTime(_countdownTime);
              await Preferences.setSoundReadyVolume(_soundReadyVolume);
              await Preferences.setSoundStartVolume(_soundStartVolume);
              if (!mounted) {
                return;
              }
              Navigator.of(context).pop(true);  //trueを返す
            },
          ),
        ],
      ),
      body: Column(children:[
        Expanded(
          child: GestureDetector(
            onTap: () => FocusScope.of(context).unfocus(),  //背景タップでキーボードを仕舞う
            child: SingleChildScrollView(
              child: Padding(
                padding: const EdgeInsets.all(20),
                child: Column(children: [
                  Padding(
                      padding: const EdgeInsets.only(top: 18, left: 16, right: 16, bottom: 0),
                      child: Row(children: [
                        Text(AppLocalizations.of(context)!.coinRatio,style: const TextStyle(fontSize: 16)),
                        const Spacer(),
                      ])
                  ),
                  Padding(
                      padding: const EdgeInsets.only(top: 0, left: 16, right: 16, bottom: 6),
                      child: Row(children: <Widget>[
                        Text('A ${(100 - _coinRatio).toString().padLeft(3,'0')}'),
                        Expanded(
                          child: Slider(
                            value: _coinRatio.toDouble(),
                            min: 0,
                            max: 100,
                            divisions: 100,
                            onChanged: (double value) {
                              setState(() {
                                _coinRatio = value.toInt();
                              });
                            },
                            activeColor: ConstValue.colorUiActiveColor,
                            inactiveColor: ConstValue.colorUiInactiveColor,
                          )
                        ),
                        Text('B ${_coinRatio.toString().padLeft(3,'0')}'),
                      ])
                  ),
                  _border(),
                  Padding(
                      padding: const EdgeInsets.only(top: 18, left: 16, right: 16, bottom: 0),
                      child: Row(children: [
                        Text(AppLocalizations.of(context)!.countdownTime,style: const TextStyle(fontSize: 16)),
                        const Spacer(),
                      ])
                  ),
                  Padding(
                      padding: const EdgeInsets.only(top: 0, left: 16, right: 16, bottom: 6),
                      child: Row(children: <Widget>[
                        Text(_countdownTime.toString()),
                        Expanded(
                            child: Slider(
                              value: _countdownTime.toDouble(),
                              min: 0,
                              max: 9,
                              divisions: 9,
                              onChanged: (double value) {
                                setState(() {
                                  _countdownTime = value.toInt();
                                });
                              },
                              activeColor: ConstValue.colorUiActiveColor,
                              inactiveColor: ConstValue.colorUiInactiveColor,
                            )
                        )
                      ])
                  ),
                  _border(),
                  Padding(
                      padding: const EdgeInsets.only(top: 18, left: 16, right: 16, bottom: 0),
                      child: Row(children: [
                        Text(AppLocalizations.of(context)!.soundReadyVolume,style: const TextStyle(fontSize: 16)),
                        const Spacer(),
                      ])
                  ),
                  Padding(
                      padding: const EdgeInsets.only(top: 0, left: 16, right: 16, bottom: 6),
                      child: Row(children: <Widget>[
                        Text(_soundReadyVolume.toString()),
                        Expanded(
                            child: Slider(
                              value: _soundReadyVolume,
                              min: 0.0,
                              max: 1.0,
                              divisions: 10,
                              onChanged: (double value) {
                                setState(() {
                                  _soundReadyVolume = value;
                                });
                              },
                              activeColor: ConstValue.colorUiActiveColor,
                              inactiveColor: ConstValue.colorUiInactiveColor,
                            )
                        )
                      ])
                  ),
                  _border(),
                  Padding(
                      padding: const EdgeInsets.only(top: 18, left: 16, right: 16, bottom: 0),
                      child: Row(children: [
                        Text(AppLocalizations.of(context)!.soundStartVolume,style: const TextStyle(fontSize: 16)),
                        const Spacer(),
                      ])
                  ),
                  Padding(
                      padding: const EdgeInsets.only(top: 0, left: 16, right: 16, bottom: 6),
                      child: Row(children: <Widget>[
                        Text(_soundStartVolume.toString()),
                        Expanded(
                            child: Slider(
                              value: _soundStartVolume,
                              min: 0.0,
                              max: 1.0,
                              divisions: 10,
                              onChanged: (double value) {
                                setState(() {
                                  _soundStartVolume = value;
                                });
                              },
                              activeColor: ConstValue.colorUiActiveColor,
                              inactiveColor: ConstValue.colorUiInactiveColor,
                            )
                        )
                      ])
                  ),
                  _border(),
                  Padding(
                      padding: const EdgeInsets.only(top: 18, left: 0, right: 0, bottom: 0),
                      child: Row(children:[
                        const SizedBox(width:16),
                        Text(AppLocalizations.of(context)!.language,
                            style: const TextStyle(
                              fontSize: 16,
                            )
                        ),
                        const Spacer(),
                      ])
                  ),
                  Padding(
                    padding: const EdgeInsets.only(top: 12, left: 0, right: 0, bottom: 18),
                    child: Table(
                        children: <TableRow>[
                          TableRow(children: <Widget>[
                            _languageTableCell(0),
                            _languageTableCell(1),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(2),
                            _languageTableCell(3),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(4),
                            _languageTableCell(5),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(6),
                            _languageTableCell(7),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(8),
                            _languageTableCell(9),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(10),
                            _languageTableCell(11),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(12),
                            _languageTableCell(13),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(14),
                            _languageTableCell(15),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(16),
                            _languageTableCell(17),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(18),
                            _languageTableCell(19),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(20),
                            _languageTableCell(21),
                          ]),
                          TableRow(children: <Widget>[
                            _languageTableCell(22),
                            _languageTableCell(23),
                          ]),
                        ]
                    ),
                  ),
                  _border(),
                  Padding(
                    padding: const EdgeInsets.only(top: 24, left: 0, right: 0, bottom: 24),
                    child: Column(
                        crossAxisAlignment: CrossAxisAlignment.start,
                        children:[
                          Text(AppLocalizations.of(context)!.usage1),
                          const SizedBox(height:15),
                          Text(AppLocalizations.of(context)!.usage2),
                          const SizedBox(height:15),
                          Text(AppLocalizations.of(context)!.usage3),
                          const SizedBox(height:15),
                          Text(AppLocalizations.of(context)!.usage4),
                        ]
                    ),
                  ),
                  _border(),
                  Padding(
                    padding: const EdgeInsets.only(top: 24, left: 0, right: 0, bottom: 36),
                    child: SizedBox(
                      child: Text('version  ${VersionState.versionLoad()}',
                        style: const TextStyle(
                          fontSize: 10,
                        ),
                      ),
                    ),
                  ),
                ]),
              ),
            ),
          ),
        ),
        Padding(
          padding: const EdgeInsets.only(top: 10, left: 0, right: 0, bottom: 0),
          child: SizedBox(
            width: double.infinity,
            child: _adMob.getAdBannerWidget(),
          ),
        ),
      ]),
    );
  }
  //UIの仕切り用ボーダーライン
  Widget _border() {
    return Container(
      decoration: BoxDecoration(
        border: Border(
          top: BorderSide(
            color: Colors.grey.shade300,
            width: 1,
          ),
        ),
      ),
    );
  }
  //言語一覧表示
  TableCell _languageTableCell(int index) {
    return TableCell(
      child: RadioListTile(
        visualDensity: const VisualDensity(horizontal: VisualDensity.minimumDensity,vertical: VisualDensity.minimumDensity),
        contentPadding: EdgeInsets.zero,
        title: Text(ConstValue.languageCode.values.elementAt(index)),
        value: ConstValue.languageCode.values.elementAt(index),
        groupValue: _languageValue,
        onChanged: (String? value) {
          setState(() {
            _languageValue = value ?? '';
            _languageKey = ConstValue.languageCode.keys.elementAt(index);
          });
        },
        activeColor: ConstValue.colorUiActiveColor,
      ),
    );
  }

}

lib/version_state.dart

///
/// @author akira ohmachi
/// @copyright ao-system, Inc.
/// @date 2023-01-27
///
library;

class VersionState {

  static String _version = '';

  //バージョンを記録
  static void versionSave(String str) {
    _version = str;
  }
  //バージョンを返す
  static String versionLoad() {
    return _version;
  }

}

lib/l10n/app_bg.arb

{
	"@@locale":"bg",
	"@locale": {
		"description": "ブルガリア"
	},
	"setting": "Настройка",
	"start": "Докоснете в рамките на екрана, за да започнете.",
	"coinRatio": "Съотношение",
	"countdownTime": "Време за обратно броене",
	"soundReadyVolume": "Сила на звука: Звук за обратно броене",
	"soundStartVolume": "Сила на звука: Стартиране на звук",
	"language": "език",
	"usage1": "Хвърляне на монета.",
	"usage2": "Хвърлянето на монета е един от методите за двоично вземане на решения, за които се смята, че дава резултати с еднаква вероятност. Използва се предимно в ситуации, изискващи справедлив подход или за вземане на прости решения.",
	"usage3": "- Метод:\nОбикновено монета се поставя в дланта, хвърля се във въздуха и се оставя да се върти във въздуха. Резултатът е или глави, или опашки.\n- Справедливост:\nЗа да може една монета да улесни честното хвърляне на монета, от съществено значение е центърът на тежестта на монетата да е балансиран и да няма отклонение, въведено от метода на хвърляне или приземяване. Освен това силата и посоката на хвърлянето трябва да са еднакви.\n- Вероятност:\nТеоретично, в случай на справедлива монета, вероятността да получите глави или опашки е 50%. Това предполага, че монетата е проектирана справедливо и няма пристрастия в самото хвърляне.\n- Вземане на решение:\nХвърлянето на монети се използва като просто и бързо средство за вземане на решения. Използва се в ситуации, в които има две възможности или когато вземането на решение е предизвикателство.\n- Случайност:\nПоради присъщата си произволност, резултатите от хвърлянето на монети са трудни за предвиждане и стига да се провежда при справедливи условия, то се влияе по-малко от външни фактори.\n- Математическо съображение:\nРезултатите от хвърлянето на монета следват биномно разпределение. Очакваната стойност за броя на главите в n изпитания е n/2 и с нарастването на броя на изпитанията броят на главите и опашките се доближава до равенството.\n- Културна употреба:\nХвърлянето на монети се използва широко в културата като метод за гадаене или вземане на значими решения. Особено в ситуации, включващи труден избор, хората могат да прибягнат до хвърляне на монета и да основат преценката си на резултата.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_cs.arb

{
	"@@locale":"cs",
	"@locale": {
		"description": "チェコ"
	},
	"setting": "Nastavení",
	"start": "Začněte klepnutím na obrazovku.",
	"coinRatio": "Poměr",
	"countdownTime": "Čas odpočítávání",
	"soundReadyVolume": "Hlasitost: Zvuk odpočítávání",
	"soundStartVolume": "Hlasitost: Spustit zvuk",
	"language": "Jazyk",
	"usage1": "Hod mincí.",
	"usage2": "Hod mincí je jednou z metod binárního rozhodování, o které se předpokládá, že přináší výsledky se stejnou pravděpodobností. Používá se především v situacích vyžadujících férový přístup nebo pro jednoduchá rozhodnutí.",
	"usage3": "- Metoda:\nObecně se mince umístí do dlaně, vyhodí do vzduchu a nechá se otáčet ve vzduchu. Výsledkem jsou buď hlavy nebo ocasy.\n- Spravedlnost:\nAby mince usnadnila férový hod mincí, je nezbytné, aby těžiště mince bylo vyvážené a nedošlo k žádnému zkreslení způsobenému metodou házení nebo přistáním. Kromě toho by síla a směr hodu měly být jednotné.\n- Pravděpodobnost:\nTeoreticky je v případě poctivé mince pravděpodobnost získání Heads or Tails každý 50%. To předpokládá, že mince je navržena spravedlivě a v samotném házení není žádné zkreslení.\n- Rozhodování:\nHody mincí se používají jako jednoduchý a rychlý prostředek k rozhodování. Používá se v situacích, kdy existují dvě možnosti nebo když je rozhodování náročné.\n- Náhodnost:\nVzhledem ke své přirozené náhodnosti je těžké předvídat výsledky házení mincí, a pokud probíhá za spravedlivých podmínek, je méně ovlivněno vnějšími faktory.\n- Matematická úvaha:\nVýsledky hodu mincí sledují binomické rozdělení. Očekávaná hodnota počtu hlav v n pokusech je n/2 a jak se počet pokusů zvyšuje, počet hlav a ocasů se blíží rovnosti.\n- Kulturní využití:\nHody mincí jsou široce kulturně používány jako metoda pro věštění nebo činění smysluplných rozhodnutí. Zejména v situacích zahrnujících obtížná rozhodnutí se jednotlivci mohou uchýlit k hodu mincí a založit svůj úsudek na výsledném výsledku.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_da.arb

{
	"@@locale":"da",
	"@locale": {
		"description": "デンマーク"
	},
	"setting": "Indstilling",
	"start": "Tryk på skærmen for at starte.",
	"coinRatio": "Forhold",
	"countdownTime": "Nedtællingstid",
	"soundReadyVolume": "Lydstyrke: Nedtællingslyd",
	"soundStartVolume": "Lydstyrke: Start lyd",
	"language": "Sprog",
	"usage1": "Møntkast.",
	"usage2": "Møntkast er en af metoderne til binær beslutningstagning, der menes at give resultater med samme sandsynlighed. Det bruges primært i situationer, der kræver en fair tilgang eller til at træffe enkle beslutninger.",
	"usage3": "- Metode:\nGenerelt placeres en mønt i håndfladen, kastes op i luften og får lov til at rotere i luften. Resultatet er enten hoveder eller haler.\n- Retfærdighed:\nFor at en mønt skal lette et retfærdigt møntkast, er det vigtigt, at møntens tyngdepunkt er afbalanceret, og der er ingen skævhed indført af kastemetoden eller landingen. Derudover skal kraften og retningen af kastet være ensartet.\n- Sandsynlighed:\nTeoretisk set er sandsynligheden for at få Heads eller Tails i tilfælde af en fair mønt hver 50%. Dette forudsætter, at mønten er designet retfærdigt, og der er ingen skævhed i selve kastet.\n- Beslutningstagning:\nMøntkast bruges som et enkelt og hurtigt middel til beslutningstagning. Det bruges i situationer, hvor der er to muligheder, eller når det er udfordrende at træffe en beslutning.\n- Tilfældighed:\nPå grund af dens iboende tilfældighed er møntkastsresultater svære at forudsige, og så længe det udføres under rimelige forhold, er det mindre påvirket af eksterne faktorer.\n- Matematisk overvejelse:\nResultaterne af et møntkast følger en binomialfordeling. Den forventede værdi for antallet af hoveder i n forsøg er n/2, og efterhånden som antallet af forsøg stiger, nærmer antallet af hoveder og haler sig lighed.\n- Kulturel brug:\nMøntkast er meget kulturelt brugt som en metode til at spå eller tage meningsfulde beslutninger. Især i situationer, der involverer vanskelige valg, kan enkeltpersoner ty til en møntkast og basere deres vurdering på det resulterende resultat.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_de.arb

{
	"@@locale":"de",
	"@locale": {
		"description": "ドイツ"
	},
	"setting": "Einstellung",
	"start": "Tippen Sie zum Starten auf den Bildschirm.",
	"coinRatio": "Verhältnis",
	"countdownTime": "Countdown-Zeit",
	"soundReadyVolume": "Lautstärke: Countdown-Sound",
	"soundStartVolume": "Lautstärke: Startton",
	"language": "Sprache",
	"usage1": "Münzwurf.",
	"usage2": "Der Münzwurf ist eine der Methoden zur binären Entscheidungsfindung, von der angenommen wird, dass sie mit gleicher Wahrscheinlichkeit zu Ergebnissen führt. Es wird vor allem in Situationen eingesetzt, in denen ein faires Vorgehen erforderlich ist oder einfache Entscheidungen getroffen werden müssen.",
	"usage3": "- Methode:\nIm Allgemeinen wird eine Münze in die Handfläche gelegt, in die Luft geworfen und in der Luft rotieren gelassen. Das Ergebnis ist entweder Kopf oder Zahl.\n- Gerechtigkeit:\nDamit eine Münze einen fairen Münzwurf ermöglicht, ist es wichtig, dass der Schwerpunkt der Münze ausgeglichen ist und keine Vorspannung durch die Wurfmethode oder Landung entsteht. Darüber hinaus sollten Kraft und Richtung des Wurfs gleichmäßig sein.\n- Wahrscheinlichkeit:\nTheoretisch beträgt bei einer fairen Münze die Wahrscheinlichkeit, Kopf oder Zahl zu bekommen, jeweils 50 %. Dies setzt voraus, dass die Münze fair gestaltet ist und der Wurf selbst keine Voreingenommenheit aufweist.\n- Entscheidungsfindung:\nAls einfache und schnelle Entscheidungshilfe werden Münzwürfe eingesetzt. Es wird in Situationen eingesetzt, in denen es zwei Optionen gibt oder wenn die Entscheidungsfindung schwierig ist.\n- Zufälligkeit:\nAufgrund der inhärenten Zufälligkeit sind die Ergebnisse eines Münzwurfs schwer vorherzusagen, und solange er unter fairen Bedingungen durchgeführt wird, wird er weniger von externen Faktoren beeinflusst.\n- Mathematische Überlegung:\nDie Ergebnisse eines Münzwurfs folgen einer Binomialverteilung. Der erwartete Wert für die Anzahl der „Kopf“-Werte in n Versuchen beträgt n/2, und mit zunehmender Anzahl der Versuche nähert sich die Anzahl der „Kopf- und Zahl-Werte“ der Gleichheit an.\n- Kulturelle Nutzung:\nMünzwürfe werden kulturell häufig als Methode zur Wahrsagerei oder zum Treffen bedeutungsvoller Entscheidungen eingesetzt. Besonders in Situationen, in denen es um schwierige Entscheidungen geht, greifen Einzelpersonen möglicherweise auf einen Münzwurf zurück und stützen ihr Urteil auf das resultierende Ergebnis.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_el.arb

{
	"@@locale":"el",
	"@locale": {
		"description": "ギリシャ"
	},
	"setting": "Σύνθεση",
	"start": "Πατήστε μέσα στην οθόνη για να ξεκινήσετε.",
	"coinRatio": "Αναλογία",
	"countdownTime": "Χρόνος αντίστροφης μέτρησης",
	"soundReadyVolume": "Ένταση: Ήχος αντίστροφης μέτρησης",
	"soundStartVolume": "Ένταση: Έναρξη ήχου",
	"language": "Γλώσσα",
	"usage1": "Στρίβω νόμισμα.",
	"usage2": "Η εκτίναξη νομίσματος είναι μία από τις μεθόδους για τη λήψη δυαδικών αποφάσεων που πιστεύεται ότι αποφέρει αποτελέσματα με ίση πιθανότητα. Χρησιμοποιείται κυρίως σε καταστάσεις που απαιτούν δίκαιη προσέγγιση ή για τη λήψη απλών αποφάσεων.",
	"usage3": "- Μέθοδος:\nΓενικά, ένα νόμισμα τοποθετείται στην παλάμη, πετιέται στον αέρα και αφήνεται να περιστρέφεται στον αέρα. Το αποτέλεσμα είναι είτε Heads είτε Tails.\n- Δικαιοσύνη:\nΓια να διευκολύνει ένα κέρμα μια δίκαιη ρίψη νομίσματος, είναι απαραίτητο το κέντρο βάρους του κέρματος να είναι ισορροπημένο και να μην υπάρχει προκατάληψη που εισάγεται από τη μέθοδο ρίψης ή προσγείωσης. Επιπλέον, η δύναμη και η κατεύθυνση της εκτίναξης πρέπει να είναι ομοιόμορφες.\n- Πιθανότητα:\nΘεωρητικά, στην περίπτωση ενός ευνοϊκού νομίσματος, η πιθανότητα να αποκτήσετε Heads ή Tails είναι 50%. Αυτό προϋποθέτει ότι το κέρμα έχει σχεδιαστεί δίκαια και δεν υπάρχει προκατάληψη στην ίδια την εκτίναξη.\n- Λήψη αποφάσης:\nΟι ρίψεις νομισμάτων χρησιμοποιούνται ως απλό και γρήγορο μέσο λήψης αποφάσεων. Χρησιμοποιείται σε καταστάσεις όπου υπάρχουν δύο επιλογές ή όταν η λήψη μιας απόφασης είναι δύσκολη.\n- Τυχαία:\nΛόγω της εγγενούς τυχαιότητάς του, τα αποτελέσματα της ρίψης νομισμάτων είναι δύσκολο να προβλεφθούν, και εφόσον διεξάγεται υπό δίκαιες συνθήκες, επηρεάζεται λιγότερο από εξωτερικούς παράγοντες.\n- Μαθηματική θεώρηση:\nΤα αποτελέσματα μιας ρίψης νομίσματος ακολουθούν μια διωνυμική κατανομή. Η αναμενόμενη τιμή για τον αριθμό των Heads σε n δοκιμές είναι n/2 και καθώς αυξάνεται ο αριθμός των δοκιμών, ο αριθμός των Heads and Tails πλησιάζει την ισότητα.\n- Πολιτιστική χρήση:\nΟι ρίψεις νομισμάτων χρησιμοποιούνται ευρέως πολιτιστικά ως μέθοδος για μαντεία ή λήψη σημαντικών αποφάσεων. Ειδικά σε καταστάσεις που περιλαμβάνουν δύσκολες επιλογές, τα άτομα μπορεί να καταφύγουν σε μια ρίψη νομίσματος και να βασίσουν την κρίση τους στο αποτέλεσμα που προκύπτει.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_en.arb

{
	"@@locale":"en",
	"@locale": {
		"description": "英語"
	},
	"setting": "Setting",
	"start": "Tap within the screen to start.",
	"coinRatio": "Ratio",
	"countdownTime": "Countdown time",
	"soundReadyVolume": "Volume: Countdown sound",
	"soundStartVolume": "Volume: Start sound",
	"language": "Language",
	"usage1": "Coin toss.",
	"usage2": "Coin toss is one of the methods for binary decision-making believed to yield results with equal probability. It is primarily employed in situations requiring a fair approach or for making simple decisions.",
	"usage3": "- Method:\nGenerally, a coin is placed in the palm, tossed into the air, and allowed to rotate in mid-air. The result is either Heads or Tails.\n- Fairness:\nFor a coin to facilitate a fair coin toss, it is essential that the coin's center of gravity is balanced, and there is no bias introduced by the throwing method or landing. Additionally, the force and direction of the toss should be uniform.\n- Probability:\nTheoretically, in the case of a fair coin, the probability of getting Heads or Tails is each 50%. This assumes that the coin is designed fairly, and there is no bias in the toss itself.\n- Decision-making:\nCoin tosses are used as a simple and quick means of decision-making. It is employed in situations where there are two options or when making a decision is challenging.\n- Randomness:\nDue to its inherent randomness, coin toss outcomes are hard to predict, and as long as it is conducted under fair conditions, it is less influenced by external factors.\n- Mathematical Consideration:\nThe results of a coin toss follow a binomial distribution. The expected value for the number of Heads in n trials is n/2, and as the number of trials increases, the number of Heads and Tails approaches equality.\n- Cultural Usage:\nCoin tosses are widely culturally used as a method for divination or making meaningful decisions. Especially in situations involving difficult choices, individuals may resort to a coin toss and base their judgment on the resulting outcome.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_es.arb

{
	"@@locale":"es",
	"@locale": {
		"description": "スペイン"
	},
	"setting": "Configuración",
	"start": "Toque dentro de la pantalla para comenzar.",
	"coinRatio": "Relación",
	"countdownTime": "tiempo de cuenta regresiva",
	"soundReadyVolume": "Volumen: sonido de cuenta regresiva",
	"soundStartVolume": "Volumen: sonido de inicio",
	"language": "Idioma",
	"usage1": "Lanzamiento de la moneda.",
	"usage2": "El lanzamiento de moneda es uno de los métodos para la toma de decisiones binarias que se cree que produce resultados con la misma probabilidad. Se emplea principalmente en situaciones que requieren un enfoque justo o para tomar decisiones simples.",
	"usage3": "- Método:\nGeneralmente, se coloca una moneda en la palma de la mano, se lanza al aire y se deja girar en el aire. El resultado es Cara o Cruz.\n- Equidad:\nPara que una moneda facilite un lanzamiento justo, es esencial que el centro de gravedad de la moneda esté equilibrado y que no se introduzca ningún sesgo por el método de lanzamiento o el aterrizaje. Además, la fuerza y dirección del lanzamiento deben ser uniformes.\n- Probabilidad:\nTeóricamente, en el caso de una moneda justa, la probabilidad de obtener Cara o Cruz es cada una del 50%. Esto supone que la moneda está diseñada de manera justa y que no hay sesgos en el lanzamiento en sí.\n- Toma de decisiones:\nLos lanzamientos de monedas se utilizan como un medio sencillo y rápido para tomar decisiones. Se emplea en situaciones en las que hay dos opciones o cuando tomar una decisión es un desafío.\n- Aleatoriedad:\nDebido a su aleatoriedad inherente, los resultados del lanzamiento de una moneda son difíciles de predecir y, siempre que se realice en condiciones justas, estará menos influenciado por factores externos.\n- Consideración Matemática:\nLos resultados del lanzamiento de una moneda siguen una distribución binomial. El valor esperado para el número de caras en n ensayos es n/2 y, a medida que aumenta el número de ensayos, el número de caras y cruces se aproxima a la igualdad.\n- Uso cultural:\nEl lanzamiento de monedas se utiliza ampliamente culturalmente como método de adivinación o para tomar decisiones significativas. Especialmente en situaciones que involucran decisiones difíciles, las personas pueden recurrir al lanzamiento de una moneda y basar su juicio en el resultado resultante.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_et.arb

{
	"@@locale":"et",
	"@locale": {
		"description": "エストニア"
	},
	"setting": "Seadistamine",
	"start": "Alustamiseks puudutage ekraanil.",
	"coinRatio": "Suhe",
	"countdownTime": "Loendusaeg",
	"soundReadyVolume": "Helitugevus: tagasilugemise heli",
	"soundStartVolume": "Helitugevus: käivitusheli",
	"language": "Keel",
	"usage1": "Mündi viskamine.",
	"usage2": "Müntide loopimine on üks binaarsete otsuste tegemise meetoditest, mis usutavasti annab tulemusi võrdse tõenäosusega. Seda kasutatakse peamiselt olukordades, mis nõuavad õiglast lähenemist või lihtsate otsuste langetamiseks.",
	"usage3": "- Meetod:\nTavaliselt asetatakse münt peopessa, visatakse õhku ja lastakse õhu käes pöörlema hakata. Tulemuseks on kas pead või sabad.\n- õiglus:\nMündi õiglase mündiviskamise hõlbustamiseks on oluline, et mündi raskuskese oleks tasakaalus ja et viskemeetod või maandumine ei põhjustaks kõrvalekaldeid. Lisaks peaksid viskamise jõud ja suund olema ühtlane.\n- Tõenäosus:\nTeoreetiliselt on õiglase mündi puhul peade või sabade saamise tõenäosus kumbki 50%. See eeldab, et münt on kujundatud õiglaselt ja viskamisel endal pole erapoolikust.\n- Otsuse tegemine:\nMüntide viskamist kasutatakse lihtsa ja kiire otsustusvahendina. Seda kasutatakse olukordades, kus on kaks võimalust või kui otsuse tegemine on keeruline.\n- juhuslikkus:\nSelle loomupärase juhuslikkuse tõttu on mündiviskamise tulemusi raske ennustada ja seni, kuni see toimub õiglastes tingimustes, mõjutavad välistegurid seda vähem.\n- Matemaatiline kaalutlus:\nMündiviske tulemused järgivad binoomjaotust. Peade arvu eeldatav väärtus n katses on n/2 ning katsete arvu suurenedes läheneb Heade ja Tailide arv võrdsusele.\n- Kultuurikasutus:\nMüntide viskamist kasutatakse kultuuris laialdaselt ennustamise või mõtestatud otsuste tegemise meetodina. Eriti raskete valikutega seotud olukordades võivad üksikisikud kasutada mündiviskamist ja rajada oma otsuse tulemusele.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_fi.arb

{
	"@@locale":"fi",
	"@locale": {
		"description": "フィンランド"
	},
	"setting": "Asetus",
	"start": "Aloita napauttamalla näyttöä.",
	"coinRatio": "Suhde",
	"countdownTime": "Lähtölaskenta aika",
	"soundReadyVolume": "Äänenvoimakkuus: Ajastinääni",
	"soundStartVolume": "Äänenvoimakkuus: Aloitusääni",
	"language": "Kieli",
	"usage1": "Kolikonheitto.",
	"usage2": "Kolikonheitto on yksi binaarisen päätöksenteon menetelmistä, joiden uskotaan tuottavan tuloksia yhtä todennäköisyydellä. Sitä käytetään ensisijaisesti tilanteissa, jotka vaativat oikeudenmukaista lähestymistapaa tai yksinkertaisten päätösten tekemiseen.",
	"usage3": "- Menetelmä:\nYleensä kolikko asetetaan kämmenelle, heitetään ilmaan ja annetaan pyöriä ilmassa. Tuloksena on joko pää tai häntä.\n- Oikeudenmukaisuus:\nJotta kolikko helpottaisi reilua kolikonheittoa, on olennaista, että kolikon painopiste on tasapainossa, eikä heittomenetelmä tai laskeutuminen aiheuta harhaa. Lisäksi heiton voiman ja suunnan tulee olla tasaiset.\n- Todennäköisyys:\nTeoriassa reilun kolikon tapauksessa todennäköisyys saada päätä tai häntää on 50%. Tämä olettaa, että kolikko on suunniteltu oikeudenmukaisesti, eikä itse heitossa ole vinoa.\n- Päätöksenteko:\nKolikonheittoa käytetään yksinkertaisena ja nopeana päätöksenteon keinona. Sitä käytetään tilanteissa, joissa on kaksi vaihtoehtoa tai kun päätöksenteko on haastavaa.\n- Satunnaisuus:\nSen luontaisen satunnaisuuden vuoksi kolikonheiton tuloksia on vaikea ennustaa, ja niin kauan kuin se suoritetaan reiluissa olosuhteissa, ulkoiset tekijät eivät vaikuta siihen vähemmän.\n- Matemaattinen huomio:\nKolikonheiton tulokset noudattavat binomijakaumaa. Odotettu arvo päiden lukumäärälle n kokeessa on n/2, ja kokeiden määrän kasvaessa päiden ja pyrstöjen määrä lähestyy tasa-arvoa.\n- Kulttuurikäyttö:\nKolikonheittoa käytetään laajasti kulttuurisesti ennustamiseen tai mielekkäiden päätösten tekoon. Erityisesti vaikeita valintoja sisältävissä tilanteissa yksilöt voivat turvautua kolikonheittoon ja perustaa harkintansa lopputulokseen.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_fr.arb

{
	"@@locale":"fr",
	"@locale": {
		"description": "フランス"
	},
	"setting": "Paramètre",
	"start": "Appuyez sur l'écran pour commencer.",
	"coinRatio": "Rapport",
	"countdownTime": "Temps de compte à rebours",
	"soundReadyVolume": "Volume : son du compte à rebours",
	"soundStartVolume": "Volume : Démarrer le son",
	"language": "Langue",
	"usage1": "Tirage au sort.",
	"usage2": "Le tirage au sort est l'une des méthodes de prise de décision binaire censée donner des résultats avec une probabilité égale. Il est principalement utilisé dans des situations nécessitant une approche équitable ou pour prendre des décisions simples.",
	"usage3": "- Méthode:\nGénéralement, une pièce de monnaie est placée dans la paume, lancée en l’air et laissée tourner dans les airs. Le résultat est soit Pile, soit Face.\n- Justice:\nPour qu'une pièce facilite un tirage au sort équitable, il est essentiel que le centre de gravité de la pièce soit équilibré et qu'il n'y ait aucun biais introduit par la méthode de lancement ou d'atterrissage. De plus, la force et la direction du lancer doivent être uniformes.\n- Probabilité :\nThéoriquement, dans le cas d'une pièce équitable, la probabilité d'obtenir pile ou face est chacune de 50 %. Cela suppose que la pièce est conçue de manière équitable et qu'il n'y a aucun biais dans le tirage au sort lui-même.\n- Prise de décision:\nLes tirages au sort sont utilisés comme moyen simple et rapide de prise de décision. Il est utilisé dans des situations où il existe deux options ou lorsque la prise de décision est difficile.\n- Le hasard :\nEn raison de leur caractère aléatoire inhérent, les résultats du tirage au sort sont difficiles à prédire, et tant qu’ils se déroulent dans des conditions équitables, ils sont moins influencés par des facteurs externes.\n- Considération mathématique :\nLes résultats d’un tirage au sort suivent une distribution binomiale. La valeur attendue pour le nombre de Pile dans n essais est n/2, et à mesure que le nombre d'essais augmente, le nombre de Pile et de Pile se rapproche de l'égalité.\n- Utilisation culturelle :\nLes lancers de pièces sont largement utilisés culturellement comme méthode de divination ou de prise de décisions significatives. Surtout dans les situations impliquant des choix difficiles, les individus peuvent recourir à un tirage au sort et fonder leur jugement sur le résultat qui en résulte.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_hu.arb

{
	"@@locale":"hu",
	"@locale": {
		"description": "ハンガリー"
	},
	"setting": "Beállítás",
	"start": "Az indításhoz érintse meg a képernyőn belül.",
	"coinRatio": "Hányados",
	"countdownTime": "Visszaszámlálási idő",
	"soundReadyVolume": "Hangerő: Visszaszámláló hang",
	"soundStartVolume": "Hangerő: Indítási hang",
	"language": "Nyelv",
	"usage1": "Pénzfeldobás.",
	"usage2": "Az érmefeldobás a bináris döntéshozatal egyik módszere, amelyről úgy gondolják, hogy azonos valószínűséggel hoz eredményt. Elsősorban tisztességes megközelítést igénylő helyzetekben vagy egyszerű döntések meghozatalában alkalmazzák.",
	"usage3": "- Módszer:\nÁltalában egy érmét helyeznek a tenyérbe, feldobják a levegőbe, és hagyják forogni a levegőben. Az eredmény fejek vagy farok.\n- Méltányosság:\nAz érme tisztességes érmefeldobásához elengedhetetlen, hogy az érme súlypontja kiegyensúlyozott legyen, és ne legyen torzítás a dobási módszer vagy a leszállás miatt. Ezenkívül a feldobás erejének és irányának egységesnek kell lennie.\n- Valószínűség:\nElméletileg egy tisztességes érme esetében 50% a valószínűsége, hogy fejet vagy farkát kapnak. Ez azt feltételezi, hogy az érmét tisztességesen tervezték, és magában a feldobásban nincs torzítás.\n- Döntéshozatal:\nAz érmefeldobást egyszerű és gyors döntéshozatali eszközként használják. Olyan helyzetekben alkalmazzák, amikor két lehetőség van, vagy amikor a döntés meghozatala kihívást jelent.\n- Véletlenszerűség:\nA benne rejlő véletlenszerűség miatt az érmefeldobás kimenetele nehezen megjósolható, és amíg tisztességes körülmények között zajlik, addig kevésbé befolyásolják a külső tényezők.\n- Matematikai megfontolások:\nAz érmefeldobás eredménye binomiális eloszlást követ. A Fejek számának várható értéke n próbában n/2, és a kísérletek számának növekedésével a Heads and Tails száma megközelíti az egyenlőséget.\n- Kulturális felhasználás:\nAz érmefeldobást kulturálisan széles körben használják jóslási vagy értelmes döntések meghozatalára. Különösen nehéz döntésekkel járó helyzetekben az egyének érmefeldobáshoz folyamodhatnak, és az eredményre alapozhatják ítéletüket.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_it.arb

{
	"@@locale":"it",
	"@locale": {
		"description": "イタリア"
	},
	"setting": "Collocamento",
	"start": "Tocca all'interno dello schermo per iniziare.",
	"coinRatio": "Rapporto",
	"countdownTime": "Tempo del conto alla rovescia",
	"soundReadyVolume": "Volume: suono del conto alla rovescia",
	"soundStartVolume": "Volume: avvia il suono",
	"language": "Lingua",
	"usage1": "Lancio della moneta.",
	"usage2": "Il lancio della moneta è uno dei metodi per il processo decisionale binario che si ritiene produca risultati con uguale probabilità. Viene utilizzato principalmente in situazioni che richiedono un approccio corretto o per prendere decisioni semplici.",
	"usage3": "- Metodo:\nGeneralmente, una moneta viene posta nel palmo della mano, lanciata in aria e lasciata ruotare a mezz'aria. Il risultato è Testa o Croce.\n- Equità:\nAffinché una moneta faciliti un lancio corretto, è essenziale che il centro di gravità della moneta sia bilanciato e che non vi sia alcuna distorsione introdotta dal metodo di lancio o dall'atterraggio. Inoltre, la forza e la direzione del lancio dovrebbero essere uniformi.\n- Probabilità:\nTeoricamente, nel caso di una moneta equilibrata, la probabilità di ottenere testa o croce è ciascuna del 50%. Ciò presuppone che la moneta sia progettata in modo equo e che non vi siano pregiudizi nel lancio stesso.\n- Il processo decisionale:\nI lanci delle monete sono usati come mezzo semplice e veloce per prendere decisioni. Viene utilizzato in situazioni in cui ci sono due opzioni o quando prendere una decisione è difficile.\n- Casualità:\nA causa della sua intrinseca casualità, i risultati del lancio della moneta sono difficili da prevedere e, finché viene condotto in condizioni eque, è meno influenzato da fattori esterni.\n- Considerazione matematica:\nI risultati del lancio di una moneta seguono una distribuzione binomiale. Il valore atteso per il numero di teste in n prove è n/2 e, all'aumentare del numero di prove, il numero di teste e code si avvicina all'uguaglianza.\n-Utilizzo culturale:\nI lanci di monete sono ampiamente utilizzati culturalmente come metodo per divinare o prendere decisioni significative. Soprattutto in situazioni che comportano scelte difficili, gli individui possono ricorrere al lancio di una moneta e basare il proprio giudizio sul risultato risultante.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_ja.arb

{
	"@@locale":"ja",
	"@locale": {
		"description": "日本"
	},
	"setting": "設定",
	"start": "画面内をタップでスタート",
	"coinRatio": "比率",
	"countdownTime": "カウントダウン時間",
	"soundReadyVolume": "音量:カウントダウン",
	"soundStartVolume": "音量:スタート",
	"language": "言語",
	"usage1": "コイントス",
	"usage2": "「コイントス」は、公平な確率で結果が出ると考えられる二択の意思決定方法の一つです。主に非公正な状況や簡単な決断を行う際に使用されます。",
	"usage3": "方法:\n一般的には、硬貨を手のひらに置き、投げ上げ、空中で回転させます。結果は「表(Heads)」か「裏(Tails)」のどちらかです。\n公平性:\n硬貨が公平なコイントスであるためには、硬貨の重心が均等であり、投げ方や着地によるバイアスがないことが重要です。また、投げる力や方向も均等である必要があります。\n確率:\n理論的には、公平な硬貨の場合、表と裏が出る確率はそれぞれ50%です。これは、硬貨が公平に設計され、投げられる際に偏りがない場合の期待値です。\n意思決定:\nコイントスは、簡単かつ迅速な意思決定の手段として使用されます。例えば、二つの選択肢がある場合や、どちらかを選ぶのが難しい場面で利用されます。\nランダム性:\nコイントスはランダム性があるため、予測が難しく、公平な条件下で行われる限り、外部の要因に左右されにくいです。\n数学的考察:\nコイントスの結果は二項分布に従います。n回の試行で表が出る回数の期待値はn/2であり、試行回数が増えるほど表と裏が出る回数は近づきます。\n文化的な使用:\nコイントスは占いや意味深い決定の手段としても文化的に広く使用されます。特に難しい選択をする際に、コイントスを行い、結果に基づいて判断することがあります。",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_lt.arb

{
	"@@locale":"lt",
	"@locale": {
		"description": "リトアニア"
	},
	"setting": "Nustatymas",
	"start": "Norėdami pradėti, bakstelėkite ekrane.",
	"coinRatio": "Santykis",
	"countdownTime": "Atgalinės atskaitos laikas",
	"soundReadyVolume": "Garsumas: Atgalinės atskaitos garsas",
	"soundStartVolume": "Garsumas: pradžios garsas",
	"language": "Kalba",
	"usage1": "Monetos metimas.",
	"usage2": "Monetų metimas yra vienas iš dvejetainių sprendimų priėmimo metodų, kuris, kaip manoma, duoda rezultatų su vienoda tikimybe. Jis pirmiausia naudojamas situacijose, kai reikia sąžiningo požiūrio arba priimant paprastus sprendimus.",
	"usage3": "– Metodas:\nPaprastai moneta įdedama į delną, išmeta į orą ir leidžiama pasisukti ore. Rezultatas yra galvos arba uodegos.\n– Sąžiningumas:\nKad moneta palengvintų teisingą monetos metimą, labai svarbu, kad monetos svorio centras būtų subalansuotas, o metimo būdas ar nusileidimas nebūtų pakreiptas. Be to, metimo jėga ir kryptis turi būti vienodos.\n– Tikimybė:\nTeoriškai sąžiningos monetos atveju tikimybė gauti Heads arba Tails yra 50%. Tai daroma prielaida, kad moneta sukurta teisingai, o pats metimas nėra šališkas.\n– Sprendimų priėmimas:\nMonetų metimas naudojamas kaip paprasta ir greita sprendimų priėmimo priemonė. Jis naudojamas tais atvejais, kai yra dvi galimybės arba kai sprendimas yra sudėtingas.\n- Atsitiktinis:\nDėl jam būdingo atsitiktinumo monetų metimo rezultatus sunku nuspėti, o tol, kol jis vykdomas sąžiningomis sąlygomis, jam mažiau įtakos turi išoriniai veiksniai.\n- Matematinis svarstymas:\nMonetos metimo rezultatai atitinka dvejetainį pasiskirstymą. Numatoma galvų skaičiaus reikšmė n bandymų yra n/2, o didėjant bandymų skaičiui, galvų ir uodegų skaičius artėja prie lygybės.\n– Kultūrinis naudojimas:\nMonetų mėtymas yra plačiai naudojamas kaip būrimo ar prasmingų sprendimų būdas. Ypač sudėtingose situacijose žmonės gali mesti monetą ir pagrįsti savo sprendimą gautu rezultatu.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_lv.arb

{
	"@@locale":"lv",
	"@locale": {
		"description": "ラトビア"
	},
	"setting": "Iestatījums",
	"start": "Lai sāktu, pieskarieties ekrānā.",
	"coinRatio": "Attiecība",
	"countdownTime": "Atpakaļskaitīšanas laiks",
	"soundReadyVolume": "Skaļums: Atpakaļskaitīšanas skaņa",
	"soundStartVolume": "Skaļums: sākuma skaņa",
	"language": "Valoda",
	"usage1": "Monētu mešana.",
	"usage2": "Monētu mešana ir viena no bināro lēmumu pieņemšanas metodēm, kas, domājams, dod rezultātus ar vienādu varbūtību. To galvenokārt izmanto situācijās, kurās nepieciešama godīga pieeja vai vienkāršu lēmumu pieņemšanai.",
	"usage3": "- Metode:\nParasti monētu ievieto plaukstā, izmet gaisā un ļauj griezties gaisa vidū. Rezultāts ir galvas vai astes.\n- Taisnīgums:\nLai monēta atvieglotu godīgu monētas mešanu, ir svarīgi, lai monētas smaguma centrs būtu līdzsvarots un lai nebūtu nekādas novirzes no mešanas metodes vai piezemēšanās. Turklāt mešanas spēkam un virzienam jābūt vienādam.\n- Varbūtība:\nTeorētiski godīgas monētas gadījumā varbūtība iegūt Heads vai Tails ir katra 50%. Tas nozīmē, ka monēta ir izstrādāta godīgi un pašā mešanā nav neobjektivitātes.\n- Lēmumu pieņemšana:\nMonētu mešana tiek izmantota kā vienkāršs un ātrs lēmumu pieņemšanas līdzeklis. To izmanto situācijās, kad ir divas iespējas vai ja lēmuma pieņemšana ir izaicinoša.\n- Nejaušība:\nTā raksturīgā nejaušība, monētu mešanas rezultātus ir grūti paredzēt, un, ja vien tā tiek veikta godīgos apstākļos, to mazāk ietekmē ārējie faktori.\n- Matemātiskie apsvērumi:\nMonētas mešanas rezultāti atbilst binomiālajam sadalījumam. Paredzamā galviņu skaita vērtība n izmēģinājumos ir n/2, un, palielinoties izmēģinājumu skaitam, galvu un astes skaits tuvojas vienlīdzībai.\n- Kultūras izmantošana:\nMonētu mešana tiek plaši kulturāli izmantota kā metode zīlēšanai vai jēgpilnu lēmumu pieņemšanai. Īpaši situācijās, kas saistītas ar grūtām izvēlēm, indivīdi var ķerties pie monētas mešanas un balstīt savu spriedumu uz iegūto rezultātu.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_nl.arb

{
	"@@locale":"nl",
	"@locale": {
		"description": "オランダ"
	},
	"setting": "Instelling",
	"start": "Tik op het scherm om te starten.",
	"coinRatio": "Verhouding",
	"countdownTime": "Afteltijd",
	"soundReadyVolume": "Volume: aftelgeluid",
	"soundStartVolume": "Volume: Startgeluid",
	"language": "Taal",
	"usage1": "Munt gooien.",
	"usage2": "Het opgooien van munten is een van de methoden voor binaire besluitvorming waarvan wordt aangenomen dat deze resultaten met gelijke waarschijnlijkheid oplevert. Het wordt vooral gebruikt in situaties die een eerlijke aanpak vereisen of voor het nemen van eenvoudige beslissingen.",
	"usage3": "- Methode:\nOver het algemeen wordt een munt in de handpalm geplaatst, in de lucht gegooid en in de lucht rondgedraaid. Het resultaat is kop of munt.\n- Eerlijkheid:\nWil een munt een eerlijke toss vergemakkelijken, dan is het essentieel dat het zwaartepunt van de munt in evenwicht is en dat er geen vooringenomenheid wordt geïntroduceerd door de werpmethode of de landing. Bovendien moeten de kracht en richting van de worp uniform zijn.\n- Waarschijnlijkheid:\nTheoretisch is, in het geval van een eerlijke munt, de kans op kop of munt elk 50%. Hierbij wordt ervan uitgegaan dat de munt eerlijk is ontworpen en dat er geen sprake is van vooringenomenheid bij de worp zelf.\n- Besluitvorming:\nMuntworpen worden gebruikt als een eenvoudig en snel middel om beslissingen te nemen. Het wordt gebruikt in situaties waarin er twee opties zijn of wanneer het nemen van een beslissing een uitdaging is.\n- Willekeurigheid:\nVanwege de inherente willekeur zijn de uitkomsten van het opgooien van munten moeilijk te voorspellen, en zolang het onder eerlijke omstandigheden wordt uitgevoerd, wordt het minder beïnvloed door externe factoren.\n- Wiskundige overweging:\nDe resultaten van een toss volgen een binominale verdeling. De verwachte waarde voor het aantal koppen in n pogingen is n/2, en naarmate het aantal pogingen toeneemt, benadert het aantal koppen en munten gelijkheid.\n- Cultureel gebruik:\nHet opgooien van munten wordt cultureel veel gebruikt als methode voor waarzeggerij of het nemen van zinvolle beslissingen. Vooral in situaties waarin moeilijke keuzes een rol spelen, kunnen individuen hun toevlucht nemen tot een toss en hun oordeel baseren op de resulterende uitkomst.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_pl.arb

{
	"@@locale":"pl",
	"@locale": {
		"description": "ポーランド"
	},
	"setting": "Ustawienie",
	"start": "Stuknij na ekranie, aby rozpocząć.",
	"coinRatio": "Stosunek",
	"countdownTime": "Czas odliczania",
	"soundReadyVolume": "Głośność: Dźwięk odliczania",
	"soundStartVolume": "Głośność: Włącz dźwięk",
	"language": "Język",
	"usage1": "Rzut monetą.",
	"usage2": "Rzut monetą to jedna z metod binarnego podejmowania decyzji, która, jak się uważa, daje wyniki z równym prawdopodobieństwem. Stosowane jest przede wszystkim w sytuacjach wymagających uczciwego podejścia lub przy podejmowaniu prostych decyzji.",
	"usage3": "- Metoda:\nZwykle monetę umieszcza się w dłoni, wyrzuca w powietrze i pozwala jej obracać się w powietrzu. Rezultatem jest orzeł lub reszka.\n- Uczciwość:\nAby moneta umożliwiała uczciwy rzut monetą, ważne jest, aby środek ciężkości monety był zrównoważony i aby metoda rzucania lub lądowania nie powodowała odchyleń. Dodatkowo siła i kierunek rzutu powinny być jednakowe.\n- Prawdopodobieństwo:\nTeoretycznie w przypadku uczciwej monety prawdopodobieństwo wyrzucenia orła lub reszki wynosi 50%. Zakłada się, że moneta została zaprojektowana rzetelnie i że sam rzut nie jest stronniczy.\n- Podejmowanie decyzji:\nRzuty monetą są prostą i szybką metodą podejmowania decyzji. Stosuje się go w sytuacjach, gdy istnieją dwie możliwości lub gdy podjęcie decyzji jest trudne.\n- Losowość:\nZe względu na wrodzoną losowość wyniki rzutu monetą są trudne do przewidzenia i jeśli przeprowadzane są w uczciwych warunkach, czynniki zewnętrzne mają na nie mniejszy wpływ.\n- Rozważania matematyczne:\nWyniki rzutu monetą mają rozkład dwumianowy. Oczekiwana wartość liczby orłów w n próbach wynosi n/2, a wraz ze wzrostem liczby prób liczba orłów i reszek zbliża się do równości.\n- Wykorzystanie kulturowe:\nRzuty monetą są szeroko stosowane w kulturze jako metoda wróżenia lub podejmowania znaczących decyzji. Zwłaszcza w sytuacjach wymagających trudnych wyborów ludzie mogą uciec się do rzutu monetą i oprzeć swoją ocenę na uzyskanym wyniku.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_pt.arb

{
	"@@locale":"pt",
	"@locale": {
		"description": "ポルトガル"
	},
	"setting": "Contexto",
	"start": "Toque na tela para começar.",
	"coinRatio": "Razão",
	"countdownTime": "Tempo de contagem regressiva",
	"soundReadyVolume": "Volume: som de contagem regressiva",
	"soundStartVolume": "Volume: Iniciar som",
	"language": "Linguagem",
	"usage1": "Lançamento de moeda.",
	"usage2": "O lançamento da moeda é um dos métodos de tomada de decisão binária que se acredita produzir resultados com igual probabilidade. É empregado principalmente em situações que exigem uma abordagem justa ou para a tomada de decisões simples.",
	"usage3": "- Método:\nGeralmente, uma moeda é colocada na palma da mão, lançada ao ar e girada no ar. O resultado é cara ou coroa.\n- Justiça:\nPara que uma moeda facilite um lançamento justo, é essencial que o centro de gravidade da moeda esteja equilibrado e que não haja tendência introduzida pelo método de lançamento ou aterrissagem. Além disso, a força e a direção do lançamento devem ser uniformes.\n- Probabilidade:\nTeoricamente, no caso de uma moeda justa, a probabilidade de obter cara ou coroa é de 50% cada. Isso pressupõe que a moeda foi projetada de maneira justa e que não há tendência no lançamento em si.\n- Tomando uma decisão:\nO lançamento de moedas é utilizado como um meio simples e rápido de tomada de decisão. É empregado em situações em que existem duas opções ou quando a tomada de decisão é desafiadora.\n- Aleatoriedade:\nDevido à sua aleatoriedade inerente, os resultados do lançamento da moeda são difíceis de prever e, desde que seja conduzido em condições justas, é menos influenciado por fatores externos.\n- Consideração Matemática:\nOs resultados do sorteio seguem uma distribuição binomial. O valor esperado para o número de caras em n tentativas é n/2 e, à medida que o número de tentativas aumenta, o número de caras e coroas se aproxima da igualdade.\n- Uso Cultural:\nO lançamento de moedas é amplamente usado culturalmente como método de adivinhação ou de tomada de decisões significativas. Especialmente em situações que envolvem escolhas difíceis, os indivíduos podem recorrer ao sorteio e basear o seu julgamento no resultado resultante.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_ro.arb

{
	"@@locale":"ro",
	"@locale": {
		"description": "ルーマニア"
	},
	"setting": "Setare",
	"start": "Atingeți în ecran pentru a începe.",
	"coinRatio": "Raport",
	"countdownTime": "Timp de numărătoare inversă",
	"soundReadyVolume": "Volum: sunet de numărătoare inversă",
	"soundStartVolume": "Volum: pornire sunet",
	"language": "Limba",
	"usage1": "Aruncatul monedei.",
	"usage2": "Aruncarea monedelor este una dintre metodele de luare a deciziilor binare despre care se crede că dă rezultate cu probabilitate egală. Este folosit în primul rând în situații care necesită o abordare corectă sau pentru luarea unor decizii simple.",
	"usage3": "- Metoda:\nÎn general, o monedă este plasată în palmă, aruncată în aer și lăsată să se rotească în aer. Rezultatul este fie Cap, fie Cozi.\n- Corectitudine:\nPentru ca o monedă să faciliteze o aruncare corectă a monedei, este esențial ca centrul de greutate al monedei să fie echilibrat și nu există nicio părtinire introdusă de metoda de aruncare sau de aterizare. În plus, forța și direcția aruncării ar trebui să fie uniforme.\n- Probabilitate:\nTeoretic, în cazul unei monede corecte, probabilitatea de a obține Heads sau Tails este fiecare 50%. Aceasta presupune că moneda este proiectată corect și nu există nicio părtinire în aruncarea în sine.\n- Luarea deciziilor:\nAruncările de monede sunt folosite ca mijloc simplu și rapid de luare a deciziilor. Este folosit în situații în care există două opțiuni sau când luarea unei decizii este o provocare.\n- Aleatorie:\nDatorită aleatoriei sale inerente, rezultatele aruncării monedelor sunt greu de prezis și, atâta timp cât se desfășoară în condiții corecte, este mai puțin influențată de factori externi.\n- Consideratii matematice:\nRezultatele aruncării unei monede urmează o distribuție binomială. Valoarea așteptată pentru numărul de capete în n încercări este n/2, iar pe măsură ce numărul de încercări crește, numărul de capete și cozi se apropie de egalitate.\n- Utilizare culturală:\nAruncările de monede sunt utilizate pe scară largă din punct de vedere cultural ca metodă de ghicire sau de luare a deciziilor semnificative. În special în situațiile care implică alegeri dificile, persoanele pot recurge la aruncarea unei monede și își pot baza judecata pe rezultatul rezultat.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_ru.arb

{
	"@@locale":"ru",
	"@locale": {
		"description": "ロシア"
	},
	"setting": "Параметр",
	"start": "Нажмите на экране, чтобы начать.",
	"coinRatio": "Соотношение",
	"countdownTime": "Время обратного отсчета",
	"soundReadyVolume": "Громкость: звук обратного отсчета",
	"soundStartVolume": "Громкость: звук запуска",
	"language": "Язык",
	"usage1": "Подбрасывание монеты.",
	"usage2": "Подбрасывание монеты — это один из методов принятия двоичных решений, который, как полагают, дает результаты с равной вероятностью. Он в основном используется в ситуациях, требующих справедливого подхода или для принятия простых решений.",
	"usage3": "- Метод:\nОбычно монету кладут на ладонь, подбрасывают в воздух и позволяют ей вращаться в воздухе. Результат: «Орёл» или «Решка».\n- Справедливость:\nЧтобы монета способствовала честному подбрасыванию, важно, чтобы центр тяжести монеты был сбалансирован и не было смещения, вносимого методом броска или приземления. Кроме того, сила и направление броска должны быть одинаковыми.\n- Вероятность:\nТеоретически, в случае с честной монетой вероятность выпадения орла или решки составляет 50%. Это предполагает, что монета спроектирована честно и в самом подбрасывании нет предвзятости.\n- Принятие решений:\nПодбрасывание монеты используется как простой и быстрый способ принятия решений. Он используется в ситуациях, когда есть два варианта или когда принятие решения является сложным.\n- Случайность:\nИз-за присущей ему случайности результаты подбрасывания монеты трудно предсказать, и, пока оно проводится в справедливых условиях, на него меньше влияют внешние факторы.\n- Математическое рассмотрение:\nРезультаты подбрасывания монеты подчиняются биномиальному распределению. Ожидаемое значение количества орлов в n испытаниях равно n/2, и по мере увеличения количества испытаний количество орлов и решек приближается к равенству.\n- Культурное использование:\nПодбрасывание монет широко используется в культуре как метод гадания или принятия значимых решений. Особенно в ситуациях, связанных с трудным выбором, люди могут прибегнуть к подбрасыванию монеты и основывать свои суждения на полученном результате.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_sk.arb

{
	"@@locale":"sk",
	"@locale": {
		"description": "スロバキア"
	},
	"setting": "Nastavenie",
	"start": "Začnite klepnutím na obrazovku.",
	"coinRatio": "Pomer",
	"countdownTime": "Čas odpočítavania",
	"soundReadyVolume": "Hlasitosť: Zvuk odpočítavania",
	"soundStartVolume": "Hlasitosť: Spustenie zvuku",
	"language": "Jazyk",
	"usage1": "Hod mincou.",
	"usage2": "Hod mincou je jednou z metód binárneho rozhodovania, o ktorej sa predpokladá, že prináša výsledky s rovnakou pravdepodobnosťou. Používa sa predovšetkým v situáciách vyžadujúcich férový prístup alebo pri jednoduchých rozhodnutiach.",
	"usage3": "- metóda:\nVo všeobecnosti sa minca vloží do dlane, vyhodí sa do vzduchu a nechá sa otáčať vo vzduchu. Výsledkom sú buď hlavy alebo chvosty.\n- Spravodlivosť:\nAby minca uľahčila spravodlivý hádzanie, je nevyhnutné, aby bolo ťažisko mince vyvážené a nedochádzalo k žiadnemu skresleniu spôsobenému metódou hádzania alebo pristátia. Okrem toho by sila a smer hodu mali byť jednotné.\n- Pravdepodobnosť:\nTeoreticky je v prípade férovej mince pravdepodobnosť získania hláv alebo chvostov 50%. To predpokladá, že minca je navrhnutá spravodlivo a v samotnom hode nie je žiadna zaujatosť.\n- Rozhodovanie:\nHody mincou sa používajú ako jednoduchý a rýchly prostriedok na rozhodovanie. Používa sa v situáciách, keď sú dve možnosti alebo keď je rozhodovanie náročné.\n- Náhodnosť:\nV dôsledku svojej prirodzenej náhodnosti je ťažké predpovedať výsledky hádzania mincí a pokiaľ sa uskutočňuje za spravodlivých podmienok, je menej ovplyvnený vonkajšími faktormi.\n- Matematická úvaha:\nVýsledky hodu mincou sledujú binomické rozdelenie. Očakávaná hodnota počtu hláv v n pokusoch je n/2 a so zvyšujúcim sa počtom pokusov sa počet hláv a chvostov približuje k rovnosti.\n- Kultúrne využitie:\nHody mincou sa v kultúre široko používajú ako metóda na veštenie alebo prijímanie zmysluplných rozhodnutí. Najmä v situáciách, ktoré zahŕňajú ťažké rozhodnutia, sa jednotlivci môžu uchýliť k hodu mincou a založiť svoj úsudok na výslednom výsledku.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_sv.arb

{
	"@@locale":"sv",
	"@locale": {
		"description": "スウェーデン"
	},
	"setting": "Miljö",
	"start": "Tryck på skärmen för att starta.",
	"coinRatio": "Förhållande",
	"countdownTime": "Nedräkningstid",
	"soundReadyVolume": "Volym: Ljud för nedräkning",
	"soundStartVolume": "Volym: Startljud",
	"language": "Språk",
	"usage1": "Myntkastning.",
	"usage2": "Myntkastning är en av metoderna för binärt beslutsfattande som tros ge resultat med lika stor sannolikhet. Den används främst i situationer som kräver ett rättvist förhållningssätt eller för att fatta enkla beslut.",
	"usage3": "- Metod:\nI allmänhet placeras ett mynt i handflatan, kastas upp i luften och får rotera i luften. Resultatet är antingen Heads eller Tails.\n- Rättvisa:\nFör att ett mynt ska underlätta en rättvis myntkastning är det viktigt att myntets tyngdpunkt är balanserad, och att det inte finns någon förspänning som införs av kastmetoden eller landningen. Dessutom bör kraften och riktningen för kastningen vara enhetlig.\n- Sannolikhet:\nTeoretiskt, i fallet med ett rättvist mynt, är sannolikheten att få Heads eller Tails vardera 50%. Detta förutsätter att myntet är utformat rättvist, och det finns ingen fördom i själva kastningen.\n- Beslutsfattande:\nMyntkastning används som ett enkelt och snabbt sätt att fatta beslut. Den används i situationer där det finns två alternativ eller när det är svårt att fatta ett beslut.\n- Slumpmässighet:\nPå grund av dess inneboende slumpmässighet är myntkastningsresultat svåra att förutsäga, och så länge det utförs under rättvisa förhållanden påverkas det mindre av externa faktorer.\n- Matematisk övervägande:\nResultaten av en myntkastning följer en binomialfördelning. Det förväntade värdet för antalet Heads i n försök är n/2, och när antalet försök ökar närmar sig antalet Heads and Tails jämställdhet.\n- Kulturell användning:\nMyntkastning används i stor utsträckning kulturellt som en metod för att spå eller fatta meningsfulla beslut. Speciellt i situationer som involverar svåra val, kan individer ta till en myntkastning och basera sin bedömning på det resulterande resultatet.",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_th.arb

{
	"@@locale":"th",
	"@locale": {
		"description": "タイ"
	},
	"setting": "การตั้งค่า",
	"start": "แตะภายในหน้าจอเพื่อเริ่มต้น",
	"coinRatio": "อัตราส่วน",
	"countdownTime": "เวลานับถอยหลัง",
	"soundReadyVolume": "ระดับเสียง: เสียงนับถอยหลัง",
	"soundStartVolume": "ระดับเสียง: เริ่มเสียง",
	"language": "ภาษา",
	"usage1": "โยนเหรียญ.",
	"usage2": "การโยนเหรียญเป็นหนึ่งในวิธีการตัดสินใจแบบไบนารี่ที่เชื่อว่าจะให้ผลลัพธ์ที่มีความน่าจะเป็นเท่ากัน โดยหลักแล้วจะใช้ในสถานการณ์ที่ต้องใช้แนวทางที่ยุติธรรมหรือเพื่อการตัดสินใจง่ายๆ",
	"usage3": "- วิธี:\nโดยทั่วไปแล้ว เหรียญจะถูกวางบนฝ่ามือ โยนขึ้นไปในอากาศ และปล่อยให้หมุนอยู่กลางอากาศ ผลลัพธ์ที่ได้คือหัวหรือก้อย\n- ความเป็นธรรม:\nเพื่อให้เหรียญง่ายต่อการโยนเหรียญอย่างยุติธรรม จุดศูนย์ถ่วงของเหรียญจะต้องมีความสมดุล และไม่มีอคติใดๆ จากวิธีการขว้างหรือการลงสู่พื้น นอกจากนี้แรงและทิศทางของการโยนควรสม่ำเสมอ\n- ความน่าจะเป็น:\nตามทฤษฎี ในกรณีของเหรียญที่ยุติธรรม ความน่าจะเป็นที่จะได้หัวหรือก้อยคือทุกๆ 50% สิ่งนี้ถือว่าเหรียญได้รับการออกแบบมาอย่างยุติธรรม และไม่มีอคติในการโยน\n- การตัดสินใจ:\nการโยนเหรียญถูกใช้เป็นวิธีการตัดสินใจที่ง่ายและรวดเร็ว ใช้ในสถานการณ์ที่มีสองทางเลือกหรือเมื่อการตัดสินใจเป็นสิ่งที่ท้าทาย\n- ความสุ่ม:\nเนื่องจากการสุ่มโดยธรรมชาติ ผลลัพธ์ของการโยนเหรียญจึงคาดเดาได้ยาก และตราบใดที่ดำเนินการภายใต้เงื่อนไขที่ยุติธรรม ก็จะได้รับอิทธิพลจากปัจจัยภายนอกน้อยลง\n- การพิจารณาทางคณิตศาสตร์:\nผลลัพธ์ของการโยนเหรียญเป็นไปตามการแจกแจงแบบทวินาม ค่าที่คาดหวังสำหรับจำนวนเฮดและก้อยจะเท่ากับ n/2 และเมื่อจำนวนการทดลองเพิ่มขึ้น จำนวนเฮดและก้อยจะเข้าใกล้ความเท่าเทียมกัน\n- การใช้วัฒนธรรม:\nการโยนเหรียญถูกนำมาใช้กันอย่างแพร่หลายในวัฒนธรรมเพื่อเป็นวิธีการทำนายหรือการตัดสินใจที่มีความหมาย โดยเฉพาะอย่างยิ่งในสถานการณ์ที่เกี่ยวข้องกับการเลือกที่ยากลำบาก บุคคลอาจหันไปใช้การโยนเหรียญและตัดสินจากผลลัพธ์ที่ตามมา",
	"usage4": "",

	"dummy": "dummy"
}

lib/l10n/app_zh.arb

{
	"@@locale":"zh",
	"@locale": {
		"description": "中国"
	},
	"setting": "环境",
	"start": "点击屏幕内即可开始。",
	"coinRatio": "比率",
	"countdownTime": "倒计时时间",
	"soundReadyVolume": "音量:倒计时声音",
	"soundStartVolume": "音量:开始声音",
	"language": "语言",
	"usage1": "掷硬币。",
	"usage2": "抛硬币是二元决策的方法之一,人们相信它会以相同的概率产生结果。 它主要用于需要公平方法或做出简单决策的情况。",
	"usage3": "- 方法:\n通常,将一枚硬币放在手掌中,抛向空中,并使其在半空中旋转。 结果要么是正面,要么是反面。\n- 公平:\n为了使硬币能够公平地抛硬币,硬币的重心必须保持平衡,并且不存在因投掷方法或落地而产生的偏差。 另外,抛掷的力量和方向要均匀。\n- 概率:\n理论上,对于一枚公平的硬币,出现正面或反面的概率各为 50%。 这假设硬币的设计是公平的,并且抛掷本身不存在偏差。\n- 决策:\n抛硬币是一种简单而快速的决策方式。 它适用于有两种选择或做出决定具有挑战性的情况。\n- 随机性:\n由于其固有的随机性,抛硬币的结果很难预测,只要在公平的条件下进行,受外界因素的影响较小。\n- 数学考虑:\n抛硬币的结果服从二项式分布。 n 次试验中正面朝上的数量的预期值为 n/2,并且随着试验次数的增加,正面和反面的数量接近相等。\n- 文化用途:\n抛硬币在文化上被广泛用作占卜或做出有意义的决定的方法。 特别是在涉及困难选择的情况下,人们可能会采取抛硬币的方式,并根据结果做出判断。",
	"usage4": "",

	"dummy": "dummy"
}
このページでお気付きの点がございましたら
ご連絡いただけますと幸いです。
Eメール(任意)
送信内容
 

便利ウェブサイト