読者です 読者をやめる 読者になる 読者になる
ようこそ。睡眠不足なプログラマのチラ裏です。

Mが如くF#ive 夢、叶えしMono

プログラミング F#3.0 F# Mono MonoGame MonoDevelop Windows8 Mac Verlet法 XNA

この記事は、F# Advent Calendar 2012 の12日目です。ひとつ前の記事は@katayama_kさんの「スキャナが出力したPDFを、出力デバイスに合わせて変換しよう-F#マスターへの道」です。ありがたいことにソースコードを公開してくださっているので、iTextSharpを使ってPDFを扱いたい場合に参考になりそうです。








龍が如く5、NewスーパーマリオブラザーズU、などプレイしたいゲームが盛りだくさんだけど、ぜんぜんやる時間が取れない今日この頃ですが、みなさんいかがお過ごしでしょうか。
この記事では、F# と MonoGame でゲームを作ろう(Mac編)という話題を扱います。F#をゲーム制作に実用してみようという話です。関数型楽しい。ゲーム作るの楽しい。ならば組み合わせない手はない! いわゆるひとつの「カツカレー理論」を採用しましたが、あなたを満足させられるような 実用 や F# の 成分は少ないかもしれません。




私がはじめて関数型言語に触れたのは5年近く前で、言語は Haskell でした。まだ関数型について右も左もわからなかった頃、Webで偶然見つけた Haskell で書かれた テトリスクローンに心が躍り、Haskellで書かれたグラディウスクローン「Monadius」 に衝撃を受けた。「いつか俺も関数型言語でなんかゲーム作る」と胸が熱くなったのを今でもよく覚えています。関数型言語は、Webアプリケーションを開発できる程度には実用です。ゲームを作れる程度には実用です。正味な話だいたいなんでも作れます。ジョジョに人気も高まってきているせいか、Scala や F# などで実際にゲームを作って楽しんでいる人も少しずつ増えてきているようです。歩みは遅くとも流れは来ている。そう感じます。ひとむかし前と比べて、スマホやタブレットPCが一般層にまで浸透してきた今、個人で作ったゲームでも手軽に大きなマーケットに公開できるインフラも整ってきました。もしあなたがお気に入りのプログラミング言語でゲームを作れたら。それってとっても実用だなって。



MonoGameとは

MonoGame は一言で言うと XNA4.0 のオープンソース実装です。XNAは、Windows、Xbox 360、Windows Phone向けのゲームを作ることができるマルチプラットフォーム(ただしマイクロソフト系に限る)に対応のイケているフレームワークです。実際に利用してみるとすぐにわかりますが、初心者でも手軽にゲームを作ることができるように考えられて設計されています。もちろん、初心者のみをターゲットにしているものではなく、上級者なら高度な技術力をいかんなく発揮することもできます。C#VB、F#など、いずれかの .NETの言語さえ知っていれば、すぐにゲームプログラミングに取り組める環境が整っています。実際、ゲームプログラミングもXNAも素人な私ですが、特にハマることもなくゲームを作ることができました。「とことんF#よぷよ!」は、スーパーファミコンぷよぷよ通のとことんぷよぷよモード相当のもので、F# で書いた私のXNA処女作です。


そんなかわいい XNA ですが、 Windows8 では XNA はサポート対象外となってしまいました。この決定に、多くの XNA ゲーム開発者が涙したことは言うまでもありません。そこで救いの手を差し伸べるのが、オープンソースのゲーム開発フレームワーク MonoGame です。


MonoGameは、内部的にはOpenGLベースでの総書き換えなので、Windowsに限らずともさまざまなOS上で動作します。前身は XNA で開発されたゲームを iOS 上で動作させる目的で開発されていた XNATouch でした。@smallgeek さんが紹介してくださった、Mono for Android のお仲間です(Mono for Android と F# - FsNinja)。現在では AndroidiOSMac OS XLinux 。そして Windows 8 ストア向けゲームの開発も可能になりました。また、今後 PlayStation Mobile をサポートする予定があり、鋭意開発中とのことです。「PSVita で F# が動くぞ...!!」が来る日も近い? 胸が熱くなる。


MonoGame のここがいいね!

MonoGame の素晴らしい点は、なにより XNA4.0 で使用するのと全く同じ名前空間を使用していることです。これにより、XNAAPI が完全に保たれていてます。2Dのみでなく、部分的ではあるものの3Dのサポートもされているので、理論的には XNAで書かれたプログラムを参照設定の変更や各プラットフォームに依存するゲーム起動部分(Gameクラスの起動)などに関するわずかな変更を加えるだけで、異なるプラットフォームに簡単に移植することができます。WOPE (Write Once, Play Everywhere) 「一度書けば、どこでも動く」 の御旗のもとに開発されている MonoGame を利用することで、初心者でも手軽にクロスプラットフォームに対応したゲームを作ることができます。.NET FrameworkXNA の知識や経験をそのまま使えるという恩恵を受けながら、あらゆるプラットフォーム(市場)に対してゲームを発信することができます。MonoGame には、 iOSAndroid 向けのハイクオリティなゲームが開発(あるいはXNAからの移植)されているという実績があり、十分にその有用性が確認できます。 また、MonoDevelop はもちろん、 Visual Studio での開発もサポートされています。XNA あるいは .NET開発者にとって、最も注目すべきゲーム開発フレームワークのひとつと言えるでしょう。



この記事を書いたきっかけ

MonoGame の F# テンプレートの作者である@7sharp9氏のツイートおよびブログの記事を見たのがきっかけです。素敵な記事を書いてくださっています。感謝。


F# and MonoGame on the Mac
http://7sharpnine.com/posts/Fsharp-and-MonoGame-on-the-Mac/
現在は、簡単に導入ができるアドインが提供されているので、この記事の内容は古いものになってしまっていますが、
MonoGameのF#テンプレートの導入方法について書かれています。初めて利用するときに参考にさせていただきました。


MonoGame 3D Basics
http://7sharpnine.com/posts/monogame-3d-basics/
正四面体の描画方法について解説されています。



とりあえず MonoGame を使ってみる (Windows8編)



Windows環境では、MonoGameインストーラをダウンロードして、インストールします。すると、Visual Studio 向けの MonoGameのプロジェクトテンプレート(C#用)が追加されますので、それで開発することができます。「えっ?F#のテンプレートはないのかい?」まだありません。XNA4.0同様にF#向けのテンプレートは用意されていませんが、デスクトップゲームであれば、 XNA4.0 と同じ要領で 各MonoGame FrameworkのDLLを参照設定してWindows アプリケーションとして作成することで F# でMonoGameを利用したゲームを作れます。動画は以前私が F# + XNA4.0で作ったものを F# + MonoGameへ移植したものです。ソースコードの修正を必要とせず動作しました。MonoGameは Windows8 ストア向けのゲーム開発もサポートしています。しかし、 F# で開発することはできません(2012/12/12現在)。



例の非常に残念な画像



F# で作れる部分はあくまで Portable Class Library(F#では Portable Library)のみに限られるので、MonoGame に依存する部分は F#で書く事はできません(くやしいです!)。MonoGame のAPI に合わせたインターフェイスを Portable Library に定義して1つ被せてラップすることで、依存部分のみ C# に委譲して F# で書ける部分を増やすように作ることも可能ですが、非常に面倒くさい作業になりますし、正直やってられないので現実的な方法ではないでしょう。Portable Library で書けない部分は、素直に C# に頼りましょう。ちなみに「とことんF#よぷよ!」の例で言うと、MonoGame(XNA)に依存しない namespace PuyoPuyoLibrary(PuyoPuyo.fs) (ソースコードがある記事)の部分を Portable Libraryとして利用することができます。





なお、VMWare (5.0.1)上のWindows8でも動作しましたが、VMWareではGPUやドライバーに大きく影響されてしまいますので、環境によっては SpriteFontがうまく描画されないようです。




XNA4.0 から MonoGameへ 「とことんF#よぷよ!」の移植


非常に退屈な動画




この動画は、F#とXNAで動作していたゲームを MonoGame を使って Mac OS X上で動くように移植する様子を録画したものです。(一部、端折ってます)。開発環境を整えるところが大半で移植作業というほどの手間はなく、ソースコードの変更はごくごくわずかです。 F#とXNAで作ったゲームがこうも簡単に Mac で動いてしまったのには、感動しました。「Mac でも、Monoがあるからできるよ!」と聞いて 「それ知ってます!」とは答えることはできたものの、実際やってみるまであまりピンときませんでした。今回こうして 自分で書いたものが 実際に Mac で動くのを目の当たりにすると、なんだかとっても気分が良いものです。自分は特に何もしていないんですが、なぜか悦に浸れますw



Mono も MonoDevelop も MonoGameもすばらしいね!



F# と MonoGame のゲーム開発環境構築について補足

非常に退屈な動画をご覧いただけたのなら、ほぼ説明は必要ないかもしれませんが、Macでの F# + MonoGame の開発環境の構築について補足情報を書いておきます。


インストール前の下準備
なにかしらの Mac を用意します(仮想環境でもよい)。


Xcode をダウンロードします(無料)
https://developer.apple.com/jp/technologies/tools/
最新のものを取得するとよいでしょう。



せっかくなので、Macの開発者登録もしておくとよいかも(無料)



MonoDevelopをダウンロードします(無料)


http://monodevelop.com/Download


MonoDevelop 3.0.5(安定版) MonoDevelop 3.0.5 installer (Mac OS X) をダウンロードします
MonoDevelop 3.0.6(Beta)でもよいです。



■ Mono Framework をダウンロードします(無料)


http://www.go-mono.com/mono-downloads/download.html


Mono + GTK# Beta Version: 3.0.2 (Mac OS X) 
Mono MRE installer および Mono MDK installer をダウンロードします



■MonoGameのソースコード を GitHub から取得します(無料)
https://github.com/mono/MonoGame
この工程はもしかするとなくすことができるのかもしれません。



インストールの手順

Xcodeをインストールします
動画では省略した部分です。
ただダブルクリックしてもマシンにはインストールされませんので、アプリケーションフォルダにコピーしましょう。
Windowsと勝手が違うので、Mac 初心者のわたしは最初よくわかりませんでしたよ。



■Mono Frameworkをインストールします。
Mono MRE 3.0.2 installer と Mono MDK 3.0.2 installer をそれぞれインストールします。
動画のとおりです。



つい最近 バージョン3.0.2が出たので、ワンステップでF#をインストールできるようになりました(いいね!)。


バージョン 3.0.1までは、F#がバンドルされていなかったので、
GitHub から fsharpのソースコードを取得してきて、home brewを入れたりターミナルからのコマンド操作でビルドをするという、ちょっとした工程が必要でしたが、
3.0.2からは、F#3.0 がMonoに標準装備されたので、本当にお手軽に MonoのF#の環境を作れるようになりました。ま、おかげで動画作り直しだったわけですが。



MonoDevelop を インストールします。
動画のとおりです。ドラッグアンドドロップしましょう。


■F# アドインを追加します。
動画のとおりです。ワンクリックでバインディングできます。


■MonoGame テンプレートアドインを追加します。
動画のとおりです。こちらのURLをコピーして(http://www.infinitespace-studios.co.uk/monodevelop/main.mrep)アドインを追加しましょう。
これで F#の MonoGameプロジェクトテンプレートが利用できます。

こちらも、わたしがMonoGameを触り始めた11月中ごろにはまだなくて、F#のMonoGameテンプレートを利用するにはちょっとした工程が必要でした。先ほどもご紹介しましたが、テンプレートの作者である @7sharp9 氏の記事で解説されてる内容を実行する必要がありました(F# and MonoGame on the Mac)。動画を見ていただけるとわかりますが、実際にテンプレートを開いてみると、バインディングがうまくいっていないように見えます。わたしの環境の問題でしょうか。直接的な解決策ではありませんが、GitHubから取得した MonoGameのMacOS向けのソリューションを、xbuildでビルドしたものを、直接参照設定することで、MonoGameを利用することができるようになります。


これでF#でMonoGameを使ってゲームプログラミングができます。




準備は整った!さぁShow Timeだ


「F# と MonoGame でゲームが作れるって言われてもさ。 そもそもゲームなんて作ったことないし、何から始めたらよいかわからん。」



ですよねー。最初はだれでもそうです。でもよく考えてみてください。そもそも仕事などで作る業務アプリケーションやWebアプリケーション。基幹システムや組み込み開発など、どんなプログラムだって初めは「作ったことのないもの」ばかりのはずです。作ったことのないものを作る楽しさ。みなさんなら知っていますよね? わたしもゲームを作るのは素人で趣味の域を脱していませんので偉そうなことは言えませんが、やってみると楽しいのでぜひ手を動かしてみてください。



はじめてゲームを作るときは、まずは真似から始めることをおすすめします。アマチュアバンドが、好きなバンドの曲をコピーするのと同じように、それはとてもよい練習です。まずは真似から始めて、慣れてきたら自分たちでちょっとアレンジする、ゆくゆくはオリジナルもやってみたいね!みたいなね。プログラミングを楽しく上達することができます。何事もまずは真似からじゃないでしょうか。「落ちものパズルゲーム」は比較的簡単に作れるので、テトリスクローンは、しばしば練習題材に使われます。「いや俺が作りたいのはね、よくあるオーソドックスな横スクロールのアクションゲームなんだけど。その手のやつのサンプルないの?」ないこともないですが、言語を限定しないとしても、参考にできそうなものは少ないでしょう。「C#で欲しい」と言われると更に減りますし、F# でとなると非常に限定されます。




MonoGameゲームプログラミングの基本(というかXNAと同じ!)

MonoGame はすべてのAPI が XNA4.0 と一致するので、XNA と全く同じ感覚でゲームプログラミングができます。基本は、Gameクラスを継承したゲームを起動するためのクラスを作成し、必要な処理について、メソッドを適宜オーバーライドして実装します。各コンテンツを読み込んだり(LoadContent)、ゲームの状態を更新したり(Update)、描画(Draw)をする処理を書く、それがはじめの一歩です。



namespace MgaGotoku
open MonoMac.AppKit
open MonoMac.Foundation
open System
open System.Runtime.Serialization
open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Audio
open Microsoft.Xna.Framework.Graphics
open Microsoft.Xna.Framework.Input
open Microsoft.Xna.Framework.Storage

/// Mが如く
type MgaGotokuGame () as this = 
  inherit Game()
  /// ゲームタイトル、グラフィックデバイスマネージャ、スプライトバッチ
  let gametitle, gmanager, sprite = "Mが如く", new GraphicsDeviceManager(this), lazy new SpriteBatch(this.GraphicsDevice)
  
  /// サンドを鳴らす
  let soundPlay (se:Lazy<SoundEffectInstance>) = se.Force().Play()
  
  /// デフォルトコンストラクタ
  do 
    // Windowの横幅
    gmanager.PreferredBackBufferWidth <- 800
    // Windowの縦幅
    gmanager.PreferredBackBufferHeight <- 480
    ()

  /// ゲームが実行開始する前に必要な初期化処理をここに書きます。
  /// ここで必要なサービスを照会して、関連するグラフィック以外のコンテンツを読む込めます。
  override this.Initialize() =
    base.Window.Title <-gametitle;
    base.Initialize()

  /// LoadContentはゲームごとに1回呼び出されます。
  /// 基本的には、ここですべてのコンテンツを読み込みます。
  override this.LoadContent() =
    base.LoadContent()

  /// UnloadContentはゲームごとに1回呼び出されます。
  /// ここですべてのコンテンツをアンロードします。
  override this.UnloadContent () = 
    base.UnloadContent()

  /// ゲームの状態の更新処理をここに書きます。
  /// プレイヤーの入力判定、キャラクタの衝突判定、オーディオの再生などなど
  override this.Update(gameTime) = 
    base.Update gameTime

  /// ゲームの描画処理をここに書きます
  /// gameTimeは、ゲームの瞬間的なタイミング情報です。
  override this.Draw(gameTime) = base.Draw gameTime |> fun _ ->
    gmanager.GraphicsDevice.Clear(Color.CornflowerBlue)
    sprite.Force().Begin ()
    // Texture2Dであれば、ここでスプライトバッチを描画します。
    sprite.Force().End ()

  /// 終了時の処理をここに書きます。
  override this.EndRun () = base.EndRun(); 

type AppDelegate() = 
    inherit NSApplicationDelegate()
    
    override x.FinishedLaunching(notification) =
        let game = new MgaGotokuGame()
        game.Run()
    
    override x.ApplicationShouldTerminateAfterLastWindowClosed(sender) =
        true
 
module main =         
    [<EntryPoint>]
    let main args =
        NSApplication.Init ()
        using (new NSAutoreleasePool()) (fun n -> 
            NSApplication.SharedApplication.Delegate <- new AppDelegate()
            NSApplication.Main(args) )
        0


ここからジョジョに肉付けをしていきます。プレイヤーの入力(キーボード、ゲームパッド、タッチ操作など)も簡単に取得できますので、プレイヤーの操作に合わせて2Dの画像を上下左右に動かせるようにしてみましょう。そして、SoungクラスやSoundEffectクラスを使うと*.wavや*.mp3などの音を簡単に鳴らせるので、お気に入りの曲を鳴らしてみましょう。なんだかゲームが作れそうな気になってきます!





Mが如くF#ive 夢、叶えしMono

ここからは、おまけです。


さて、そろそろ寒〜い記事のタイトルについて触れなければならない。
「また、くだらないこと考えて...」ご名答である。でも思いついちゃったんだからしょうがない。
これを書くきっかけを与えてくれた(?)のは @gab_km さんである。

Mが如くF#ive 夢、叶えしMono





うん。龍が如くは無理。知ってます! 無理だとわかっていて言っていますね?いじわるだねッ☆ 無理なものは無理なんだけど、できることもあるんじゃないかと思って考えた。古き良き王道横スクロールアクション的なアレなら今からでも間に合うもしれない。上記のやり取りで何か悪い電波を受信してしまいました。人に強制されるのは嫌いだけど、自分で思いつちゃったらこれはもうしょうがない。やるしかない。



WiiU でも新しいやつがでたばかりですが、全世界で人気の王道横スクロールアクションゲームは多くの人がそのクローンを作ろうと試みています。YouTube等の動画サイトで 「Mario C#」とか「Mario XNA」あたりで検索をすると、XNAで作ろうとしたクローンの動画がたくさんでてくる。JavaScriptで実装してみた話とかが割と有名でしょうか。私もパズルゲームやシューティングゲームは趣味でいくつか作った経験があるのだけど、アクションゲームは作ったことがなかった。時間もなかったのでそれっぽいものができるかどうか微妙なところでしたが、なんとなくそれっぽい動き(Mが如く)になりました。ぜんぜん全くF#である必要性もないし、どちらかというと「それC#で」が求められている感がある。だが、F#で書いた。この誰にも求められていない感が良いね。「龍が如く5」と、「New スーパーマリオブラザーズ U」の誘惑に負けそうになりながらも、我慢して書きました。全然時間がなくてコードをきれいに書いている余裕がなかったので質は非常にアレですが、コメントは多めに書きましたので、どうか生温かい目で見てください。加えて、「〇〇をF#で書いてみた」的なネタ記事はもっと増えてもいいと思っている。別に屁理屈を言ったり言い訳をするつもりは毛頭ないけど、そういうのも逆説的に"実用"なのではないのかなって。



マリオの動きを真似る

実際にやってみて改めてわかったんですが、マリオの動きや操作感はむかしから非常によく練られていたということ。操作していて楽しいようによく考えて作られている。勉強になるなあ。





Mario.fs

namespace MarioLibrary
open System
open System.Collections.Generic
open System.Text
open Microsoft.Xna.Framework.Content
open Microsoft.Xna.Framework.Graphics
open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Audio

[<AutoOpen>]
module MarioLibrary =
  type Direction = Left | Right         // キャラの向き
  type Motion = Stop | Run | Break      // 停止、移動、ブレーキ
  type State = Stand | Squat            // 立ち、しゃがみ
  type CollisionType = Head | Foot | No // Y軸の当たり判定タイプ:頭、足、なし

  // 幅、立ち状態の高さ、しゃがみ状態の高さ
  let characterWidth, standHeight, squatHeight  = 32, 52, 36
   
  /// ヒゲの配管工
  [<AllowNullLiteral>]
  type Mario internal () = 
    member val Game : Game = null with get,set  // ゲームメイン
    member val X = 0. with get,set              // キャラクタのX座標を取得または設定します。
    member val Y = 0. with get,set              // キャラクタのY座標を取得または設定します。
    member val YPrev = 0. with get,set          // キャラの前回のY座標を保持
    member val Direction = Right with get,set   // キャラの方向
    member val HeadBlock = false with get,set   // 頭にぶつかったか否かを取得または設定します。
    member val Condition = Stand with get,set   // 立ち、しゃがみの状態を取得または設定します。
    member val State = Stop with get,set        // キャラの動作状態
    member val Jumping = false with get,set     // ジャンプ中か否かを取得または設定します。
    member val Air = false with get,set         // キャラクタが空中にいるか否かを取得または設定します。
    member val Jumpval = 0. with get,set        // Verlet法の加算値
    member val Dash = false with get,set        // ダッシュ状態か否か
    member val JumpUp = false with get,set      // 上昇か落下かどうか
    member val LeverVX = 0. with get,set        // 方向キーによる加速度
    member val DashVX = 0. with get,set         // ダッシュによる加速度
    member val AddjumpCnt = 0 with get,set      // Verlet法の加算カウンタ
    member val Jumpadded = 0 with get,set       // Verlet法上昇下降カウンタ
    member val Timer = 0. with get,set          // アニメーション用のタイマー
    member val Blocks = Seq.empty<Rectangle> with get,set // 当たり判定対象のブロックを取得または設定します。

  /// マリオをつくる
  let createMario x y game = new Mario(X = x, Y =y, YPrev = y, Game = game, Direction = Right, State = Stop, Condition = Stand)

  // ダッシュによる最大速度、ダッシュによる加速度、歩行による最大速度、歩行による加速度
  let dashMaxSpeed, dashAcceleration, leverMaxSpeed, leverAcceleration = 6.5, 0.08, 5.5, 0.08

  /// Verlet法の加算値。値を変更でジャンプの放物線を調整
  let verletArr = [ 1.0; 0.5; 0.5; 0.5; 0.5; 0.5; 0.25; 0.25; 0.25; 0.25; 0.25; 0.25; 0.15;]

  // 歩行アニメーション用のベースフレーム、FPS
  let baseFreamRight, baseFreamLeft, fps = 55., -55., 60.

  /// スペースキーを押し続けた場合の加算の割合
  let jumpAddSep = Math.Max(Math.Round((fps |> decimal) / 5m, 1), 1m)

  /// 1メートルを何ピクセルとするか
  let mppx = 34.

  /// 重力加速度
  let gravity = 9.8 * mppx

  /// 重力加速度 × フレーム表示間隔()2let gh2 = Convert.ToSingle(gravity * Math.Pow((1. / fps), 2.))

  /// キャラクタテクスチャ幅を取得します
  let width = characterWidth

  /// 移動アニメフレーム
  let mutable moveFrame = 0

  /// キャラクタテクスチャ高さを取得します
  let height (m:Mario) = m.Condition |> function 
    | Squat -> squatHeight 
    | Stand -> standHeight

  /// 現在のキャラクタのX軸における加速度を取得します。
  let getAcceleration (m:Mario) = m.DashVX + m.LeverVX      

  /// 初速度を取得します
  let getV (m:Mario) = 
    let peakY = m.Y - float (standHeight * 3)
    -1. * Math.Sqrt(2. * gravity * (m.Y - peakY))

  /// キャラの座標を表すRectangleを返します
  let posRect (m:Mario) px py = m.Condition |> function
    | Stand -> Rectangle (px, py, characterWidth, standHeight)
    | Squat -> Rectangle (px, py + 16, characterWidth, squatHeight)

  /// ジャンプ音、頭ぶつけた時の音の遅延ロード用
  let se (m:Mario)  = 
    let jumpSuper, bump = ["jump-super";"bump";] |> List.map (fun name -> m.Game.Content.Load<SoundEffect>(@"Content\sound\" + name).CreateInstance() |> fun x -> x.Volume <- 1.0f; lazy x) |> function 
      | a::b::[] -> a,b | _ -> invalidArg "tlist" "リストの長さが違うよ。"
    jumpSuper, bump

  /// Y軸 キャラクタと障害物の当たり判定
  let collisionY (m:Mario) (nextY:float) bumpPlay =
    let px, py = m.X |> int, (Math.Ceiling(nextY)) |> int
    let prec = posRect m px py

    let normalAction () = m.Air <- true
    let normal = normalAction () ; false, float py
    let footAction () = m.HeadBlock <- false; m.Air <- false
    let headAction () = 
      if bumpPlay then
        se m |> snd |> fun bump -> bump.Force().Play()
      m.HeadBlock <- true

    let f (brec:Rectangle) =  
      if prec.Intersects(brec) then
        // 空中
        m.Air <- true
        // 頭の衝突
        if ((prec.Top < brec.Bottom || prec.Top < brec.Bottom) && prec.Bottom > brec.Bottom) then
          true, brec.Bottom |> float, Head 
        // 足の衝突
        elif ((prec.Bottom > brec.Top || prec.Bottom > brec.Top) && prec.Top < brec.Top) then
          true, (brec.Top - standHeight) |> float, Foot
        else
          false, float py, No
      else
        false, float py, No

    if m.Blocks = null || m.Blocks |> Seq.length = 0 then
      false, nextY
    else
      m.Blocks |> Seq.map f
      |> Seq.tryFind(fun (x,_,_) -> x) 
      |> function
      | None -> normal
      | Some (r,y,c) -> c |> function
      | Head -> headAction(); r,y
      | Foot -> footAction(); r,y
      | No   -> normalAction(); r,y

  /// ジャンプ
  let jump (m:Mario) = 
    let px, py = m.X |> int, m.Y - 17. |> int
    let prec = Rectangle(px, py, width, m |> height)
    let result,_ = collisionY m (prec.Y |> float) true
    let jumpSuper, bump = se m
    if result then
      bump.Force().Play()
    else
      jumpSuper.Force().Play()
      m.JumpUp <- true
      m.Jumping <- true

  /// Verlet法で次のY座標を取得する
  let calcVerlet (m:Mario) = 
    let f () = 
      // キャラクターの次のY座標をVerlet法で算出
      let possibleY = 
        if m.Jumping && m.Y = m.YPrev then
          // 初速度から算出
          gravity / (Convert.ToDouble(2. * Math.Pow(fps, 2.))) + getV m  / fps + m.Y 
        else
          // 現在の加速値から算出
          m.Y + m.Y - m.YPrev + m.Jumpval

      // Y座標の当たり判定を行う
      let result, backY = collisionY m possibleY true
      m.YPrev <- m.Y //tempY
      if result |> not then
        possibleY
      else
        m.JumpUp <- false
        m.AddjumpCnt <- 0
        m.Jumpadded <- 0
        m.Jumping <- false
        backY

    if m.JumpUp then
      // 上昇中
      verletArr |> List.map (fun x -> x * -1.) |> fun varray ->
      if m.AddjumpCnt > 0 then
        m.Jumpadded <- m.Jumpadded + 1
        if (m.Jumpadded >= Seq.length varray) then
          // 最後の加算。これ以上キーを押し続けても加算しない
          m.Jumpval <- varray.[Seq.length varray - 1]
          m.AddjumpCnt <- 0
          m.JumpUp <- false
        else
          m.Jumpval <- varray.[m.Jumpadded - 1]
      m.AddjumpCnt <- m.AddjumpCnt + 1
      f ()
    else
      // 落下中
      m.JumpUp <- false
      m.AddjumpCnt <- 0
      m.Jumpadded <- m.Jumpadded + 1
      verletArr |> List.rev |> fun varray -> 
      if m.Jumpadded >= Seq.length varray then
        m.Jumpval <- varray.[Seq.length varray - 1]
      else
        m.Jumpval <- varray.[m.Jumpadded - 1]
      f()

  /// X軸 キャラクタと障害物との当たり判定
  let collisionX (m:Mario) nextX = 
    let normal = false, m.X
    let px = nextX |> int
    let py = m.Y |> int
    let prec = posRect m px py

    let f (brec:Rectangle) =  
      let slowdown () =
        m.DashVX <- m.DashVX / 1.3
        m.LeverVX <- m.LeverVX / 1.3

      if prec.Intersects(brec) then
        if m |> getAcceleration > 0. then
          if brec.Left < prec.Right then
            slowdown ()
            true, (brec.Left - characterWidth) |> float
          elif brec.Right < prec.Left then
            slowdown ()
            true, brec.Right |> float
          else normal
        elif m |> getAcceleration < 0. then
          if brec.Left < prec.Right then
            slowdown ()
            true, brec.Right|> float
          elif brec.Right < prec.Left then
            slowdown ()
            true, (brec.Right + characterWidth)|> float
          else normal
        else normal
      else normal

    if m.Blocks = null || m.Blocks |> Seq.length = 0 then
      false, nextX
    else
      m.Blocks |> Seq.map f
      |> Seq.tryFind(fun (x,y) -> x) 
      |> function
      | None -> normal
      | Some x -> x

  /// キャラクタの描画
  let drawMario (m:Mario) (spriteBatch : SpriteBatch) (gameTime : GameTime) = 
    /// 状態に応じたSpriteEffectを返します
    let getSpriteEffect = fun () -> m.Direction |> function
      | Left  -> SpriteEffects.FlipHorizontally // 反転
      | Right -> SpriteEffects.None             // そのまま描画

    /// 現在のキャラクタテクスチャの短形を取得する
    let textureRectangle () =
      let height = m |> height
      if m.Condition = Squat then 
        Nullable (Rectangle(192, 16, characterWidth, height)) // しゃがみ
      elif m.Air && m.HeadBlock then
        Nullable (Rectangle(160, 0, width, height)) // 頭ぶつけて空中
      elif m.Air && m.Jumping |> not then
        Nullable (Rectangle(64, 0, width, height)) 
      elif m.Jumping then
        Nullable (Rectangle(160, 0, width, height))
      elif m |> getAcceleration = 0. then
        Nullable (Rectangle(96, 0, characterWidth, height))
      elif m.State = Break then
        Nullable (Rectangle(128, 0, characterWidth, height)) // ブレーキしてたら
      // 加速してたら
      elif m.State = Run then
        m.Timer <- m.Timer +  getAcceleration m * 4.
        let nextFrame = ref 0.
        m.Direction |> function
        | Left  -> nextFrame := baseFreamLeft -  getAcceleration m
        | Right -> nextFrame := baseFreamRight - getAcceleration m

        if m.Direction = Right && m.Timer > !nextFrame || m.Direction = Left && m.Timer < !nextFrame then
          m.Timer <- 0.
          let rect = Rectangle(moveFrame * characterWidth, 0, characterWidth, height)
          moveFrame <- moveFrame + 1
          if moveFrame > 2 then
            moveFrame <- 0
          Nullable rect
        else
          Nullable (Rectangle(moveFrame * characterWidth, 0, characterWidth, height))
      else
        Nullable (Rectangle(96, 0, characterWidth, height))

    /// 右向きのマリオのテクスチャ遅延ロード
    let marioTexture = lazy m.Game.Content.Load<Texture2D>(@"Content\image\right") 
    let px, py = m.X |> int, m.Y |> int
    spriteBatch.Draw(marioTexture.Force(), posRect m px py, textureRectangle (), Color.White, 0.f, Vector2.Zero, getSpriteEffect(), 0.f)

  /// 加速度から割り出される次のフレームのX座標
  let nextX (m:Mario) = Math.Ceiling(m.X + getAcceleration m)

  /// Verlet法から割り出される次のフレームのY座標
  let nextY (m:Mario) = m |> calcVerlet 

  /// X軸移動
  let moveX (m:Mario) =
    let nextX = nextX m
    let result,x = collisionX m nextX
    if (m.Air |> not && m.Condition = Squat) then
      if result |> not then
        m.X <- nextX |> float
      else
        m.X <- x 
    elif result |> not then
        m.X <- nextX |> float

  /// Y軸移動
  let moveY (m:Mario) = m.Y <- nextY m |> float

  /// 立つ
  let standUp (m:Mario) = 
    let py = m.Y - 17.
    if m |> getAcceleration <> 0. then
      let result,_ = collisionY m py false
      if not result then
        m.Condition <- Stand
    else
      let result,_ = collisionY m py false
      if not result then
        m.Condition <- Stand
      moveX m

  // 緩やかに減速
  let slowdown (m:Mario) = 
    if m.LeverVX > 0. then
      if m.LeverVX - leverAcceleration < 0. then
        m.LeverVX <-  0.
      else
        m.LeverVX <- m.LeverVX - leverAcceleration
    elif m.LeverVX < 0. then
      if m.LeverVX + leverAcceleration > 0. then
        m.LeverVX <-  0.
      else 
        m.LeverVX <- m.LeverVX + leverAcceleration
    if m.DashVX > 0. then
      if m.DashVX - leverAcceleration < 0. then
        m.DashVX <- 0.
      else
        m.DashVX <- m.DashVX - leverAcceleration
    elif m.DashVX < 0. then
      if m.DashVX + leverAcceleration > 0. then
        m.DashVX <- 0.
      else
        m.DashVX <- m.DashVX + leverAcceleration

  /// ブレーキ
  let break' (m:Mario) =  
    m.State <- Break
    m |> slowdown 

  /// 最大加速度を制御します
  let getMaxAcceleration (m:Mario) = 
    if m.LeverVX > 0. && m.LeverVX > leverMaxSpeed then
        m.LeverVX <- leverMaxSpeed
    elif (m.LeverVX < leverMaxSpeed * -1.) then
        m.LeverVX <- leverMaxSpeed * -1.
    if m.DashVX > 0. && m.DashVX > dashMaxSpeed then
        m.DashVX <- dashMaxSpeed
    elif (m.DashVX < dashMaxSpeed * -1.) then
        m.DashVX <- dashMaxSpeed * -1.

  /// デフォルトは右に加速
  let accel (m:Mario) f d c = 
    if m.Direction = Left then
      m.State <- Break
    if not m.Jumping then
      // 空中ではない場合キャラの向きを変える
      m.Direction <- c
    if m.LeverVX < 0. |> d then
      m.DashVX <- m.DashVX + f (dashAcceleration * 1.5)
      if m.DashVX >= 0. |> d then
        if m.DashVX - f (leverAcceleration * 0.8) < 0. then
          m.DashVX<- 0. 
        else
          m.DashVX <- m.DashVX - f (leverAcceleration * 0.8)
      m.LeverVX <- m.LeverVX + f (dashAcceleration * 2.5)
      if m.LeverVX >= 0. |> d then
        m.DashVX <- 0.
    else
      if m |> getAcceleration > 0. |> d then
        m.State <- Run
      if m.Dash then
        m.DashVX <- m.DashVX + f dashAcceleration
      else
        if m.DashVX > 0. |> d then
          if m.DashVX - f (leverAcceleration * 0.8) < 0. then 
            //m.DashVX <- 0. 
            m.DashVX <- m.DashVX - f (leverAcceleration * 0.8)
      m.LeverVX <- m.LeverVX + f leverAcceleration
    m |> getMaxAcceleration

Main.fs

namespace MgaGotoku
open MonoMac.AppKit
open MonoMac.Foundation
open System
open System.Linq 
open System.Collections.Generic
open System.Runtime.Serialization
open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Audio
open Microsoft.Xna.Framework.Graphics
open Microsoft.Xna.Framework.Input
open Microsoft.Xna.Framework.Storage
open Microsoft.Xna.Framework.Media
open MarioLibrary

type GameState = Playing | Die | Gameover | End

/// Mが如く
type MgaGotokuGame () as this = 
  inherit Game()

  /// ゲームタイトル、グラフィックデバイスマネージャ、スプライトバッチ
  let gametitle, gmanager, sprite = "Mが如くF#ive 夢、叶えしMono", new GraphicsDeviceManager(this), lazy new SpriteBatch(this.GraphicsDevice)
  /// プレイヤー
  let mutable player : Mario = Unchecked.defaultof<_>
  /// ゲームの状態
  let mutable gameState = Playing

  /// コイン、フロアタイル、ソリッドタイル、土管のテクスチャ遅延ロード用
  let coinTexture,floorTileTexture,solidTileTexture,greenPipeTexture, gameoverTexture = 
    ["coin";"brownFloorTile";"brownSolidTile";"greenPipe";"gameover"] 
    |> List.map (fun name -> lazy this.Content.Load<Texture2D>(@"Content\image\" + name)) |> function 
    | a::b::c::d::e::[] -> a,b,c,d,e | _ -> invalidArg "tlist" "長さが違う"

  /// coin取得音
  let getCoin = lazy (this.Content.Load<SoundEffect>(@"Content\sound\getcoin"))
  /// die
  let die = lazy (this.Content.Load<SoundEffect>(@"Content\sound\smb_mariodie").CreateInstance())
  let gameover = lazy (this.Content.Load<SoundEffect>(@"Content\sound\smb_gameover").CreateInstance())

  /// ゲームのBGM遅延ロード用
  let bgm = lazy (this.Content.Load<SoundEffect>(@"Content\sound\overworld").CreateInstance()) 

  /// サンドを鳴らす
  let soundPlay (se:Lazy<SoundEffectInstance>) = se.Force().Play()

  // 配置するフロアタイル
  let floors = [-5..15]@[17..30] |> List.map (fun x -> new Rectangle(33 * x, 452, 32, 32))
               
  // フロアタイルの描画  
  let drawFloors () =
    // すべてのフロアタイルを描画
    floors |> List.iter (fun rect -> sprite.Force().Draw(floorTileTexture.Force(), rect,  Color.White))

  // 配置するブロック
  let blocks = [2..4] |> List.map (fun x -> new Rectangle(100 + 32 * x, 416 - (33 * (x - 1)), 32, 32))
  // ブロックの描画  
  let drawBlocks () =
    // すべてのブロックを描画
    blocks |> List.iter (fun rect -> sprite.Force().Draw(solidTileTexture.Force(), rect,  Color.White))

  // アニメーション用テクスチャRectangleを取得するクロージャー
  let animationTextureRectangle width hight max  = 
    let flame = 10
    let animeWait, counter = ref 0, ref 0
    (fun () -> 
      animeWait := !animeWait + 1
      let rect = new Rectangle(!counter * width, 0, width, hight)
      if !animeWait > flame then 
        animeWait := 0;
        incr counter
        if !counter > max then counter := 0
        Nullable rect
      else Nullable rect)

  // 配置するコイン
  let coins = new List<Rectangle>()  
  // コインの点滅を表現
  let coinTextureRect = animationTextureRectangle 20 28 3 
  // コインの描画
  let drawCoins () =
    // クロージャからコインのカレントテクスチャRectangleを取得
    let coinRect = coinTextureRect ()
    // すべての配置するコインを描画
    coins.ToList() |> Seq.iter (fun rect -> sprite.Force().Draw(coinTexture.Force(), new Vector2(rect.X |> float32, rect.Y |> float32), coinRect,  Color.White))

  // 配置する土管
  let greenPipes = [0..0] |> List.map (fun x -> new Rectangle(32 * 15, 452-77 , 48, 77))
  // 土管の描画
  let drawGreenPipes () =
    // すべての配置する土管を描画
    greenPipes |> List.iter (fun rect -> sprite.Force().Draw(greenPipeTexture.Force(), rect,  Color.White))

  /// コインとの当たり判定
  let checkTouchCoin =
    let wait =ref 0.
    (fun () -> 
      async { let terget = coins.ToList()
              wait := !wait + 1.
              if !wait > 2. then
                let prect = new Rectangle(player.X |> int, player.Y |> int, 32, 52)
                terget |> Seq.filter (fun coin -> prect.Intersects(coin)) 
                        |> Seq.iter (fun coin -> ignore <| getCoin.Force().Play(); ignore <| coins.Remove(coin))
                wait := 0. } |> Async.Start)

  /// X座標における画面からはみ出した場合、反対側から出てくるように
  let checkWindowOut () =
    if player.X > 800. && player |> getAcceleration > 0. then
      player.X <- -32.// 画面右隅へ
    if player.X < -32. && player |> getAcceleration < 0. then
      player.X <- 800.// 画面左隅へ

  /// しんでしまったか判定
  let checkDie () =
    if gameState = Playing && player.Y > 510. then
      ignore <| bgm.Force().Stop()
      ignore <| die.Force().Play()
      gameState <- Die

  /// プレイヤーの情報を更新
  let updatePlayer () = 
    let f () = 
      player |> moveX ; player |> moveY
      checkTouchCoin >> checkWindowOut >> checkDie <| ()
    // ゲームの終了条件をチェックします。
    if (GamePad.GetState(PlayerIndex.One).Buttons.Back = ButtonState.Pressed) then
        this.Exit()
    // ジャンプ処理
    if player.Jumping |> not then
      if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Z) && (player.HeadBlock |> not)) then
        if (player.Air |> not) then
          player |> jump
    elif player.Jumping then
      if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Z) |> not) then
        player.JumpUp <- false

    // 左右両方入力されていたら
    if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Right) &&
        Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Left)) then
      // ブレーキ
      player |> break'; f ()
    else
      // 左右未入力なら緩やかに減速
      if ((Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Right) |> not) && (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Left) |> not)) then
        if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Down)) then
          player.Condition <- Squat
          // 緩やかに減速
          player |> slowdown; f ()
        else
          player |> standUp 
          player |> slowdown; f ()
      else
        player |> standUp
        if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Right)) then
          if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.X)) then
            player.Dash <- true
          else
            player.Dash <- false
          accel player id id Right
        if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.Left)) then
          if (Keyboard.GetState(PlayerIndex.One).IsKeyDown(Keys.X)) then
            player.Dash <- true
          else
            player.Dash <- false
          accel player (fun x -> -1. * x) not Left
        f ()

  /// デフォルトコンストラクタ
  do 
    gmanager.PreferredBackBufferWidth  <- 800 // Windowの横幅
    gmanager.PreferredBackBufferHeight <- 480 // Windowの縦幅
    this.TargetElapsedTime <- TimeSpan.FromSeconds(1./60.)

  /// ゲームが実行開始する前に必要な初期化処理をここに書きます。
  override this.Initialize() =
    // ウィンドウタイトルを設定
    base.Window.Title <-gametitle;

    // コインを配置
    let d, m, width, height = 30, 25, 20, 28
    let space = 
      let f source = [0..31] |> Seq.filter(fun x -> source |> Seq.exists (fun y -> x = y) |> not )
      seq { yield [] |> f 
            yield [10..14]@18::[20] |> f 
            yield [10;18;20;] |> f        
            yield 10::[17..21] |> f
            yield [10..13]@18::[20] |> f 
            yield 10::[17..21] |> f            
            yield [10;18;20;] |> f
            yield [10;18;20] |> f
            yield [] |> f 
            yield [] |> f } 
      |> Seq.mapi (fun i x -> x,i)
    space |> Seq.iter (fun (h,i) -> h |> Seq.iter (fun x -> coins.Add(new Rectangle(m * x, d * i, width, height))))

    // BGMを鳴らす
    ignore <| bgm.Force().Play() 
    base.Initialize()

  /// LoadContentはゲームごとに1回呼び出されます。
  /// 基本的には、ここですべてのコンテンツを読み込みます。
  override this.LoadContent() =
    player <- createMario 0. 400. this
    player.Blocks <- floors.Concat(blocks).Concat(greenPipes)
    base.LoadContent()

  /// UnloadContentはゲームごとに1回呼び出されます。
  /// ここですべてのコンテンツをアンロードします。
  override this.UnloadContent () = 
    base.UnloadContent()

  /// ゲームの状態の更新処理をここに書きます。
  /// プレイヤーの入力判定、キャラクタの衝突判定、オーディオの再生などなど
  override this.Update(gameTime) = 
    gameState |> function
    | Playing  -> 
      updatePlayer ()
    | Die -> 
      if die.Force().State = SoundState.Stopped then
        gameState <- Gameover
    | Gameover ->
        gameover.Force().Play()
        gameState <- End
    | End -> ()
    base.Update gameTime

  /// ゲームの描画処理をここに書きます
  /// gameTimeは、ゲームの瞬間的なタイミング情報です。
  override this.Draw(gameTime) = base.Draw gameTime |> fun _ ->
    gameState |> function
   | Playing | Die ->
      gmanager.GraphicsDevice.Clear(Color.CornflowerBlue)
      // スプライトバッチ処理開始
      sprite.Force().Begin ()
      // 各描画処理を実行
      [drawFloors; drawCoins;drawBlocks;drawGreenPipes;] |> List.iter (fun f -> f())
      // プレイヤーを描画
      drawMario player (sprite.Force()) gameTime
      // スプライトバッチ処理終了
      sprite.Force().End ()
    | Gameover | End ->
      gmanager.GraphicsDevice.Clear(Color.Black)
      sprite.Force().Begin ()
      sprite.Force().Draw(gameoverTexture.Force(), Vector2(200.f,150.f), Color.White)
      sprite.Force().End ()

  /// 終了時の処理をここに書きます。
  override this.EndRun () = base.EndRun()

type AppDelegate() = 
    inherit NSApplicationDelegate()
    
    override x.FinishedLaunching(notification) =
        let game = new MgaGotokuGame()
        game.Run()
    
    override x.ApplicationShouldTerminateAfterLastWindowClosed(sender) =
        true
 
module main =         
    [<EntryPoint>]
    let main args =
        NSApplication.Init ()
        using (new NSAutoreleasePool()) (fun n -> 
            NSApplication.SharedApplication.Delegate <- new AppDelegate()
            NSApplication.Main(args) )
        0


マリオの歩行とダッシュ
マリオは左右の方向キーが押下されている間、歩行状態となり特定のスピードまで加速します。左右の方向キーに加えてダッシュ用のボタンを押下していると、さらに最大スピードに達するまで加速します。というのが、横移動の基本となります。


減速
これは歩行とダッシュに密接に関係があるところ。加速があれば減速もある、そりゃそうだ。運動には慣性が働くもの。それを無視してしまうと非常に違和感のあるものになります。方向キーが離さてすぐにキャラクタがその場に急停止してしまうと非常に不自然です。なのでボタンが離されると緩やかに減速してから停止するように速度を調整してやる必要があります。物理エンジンでも使っていれば、この辺のことは勝手にやってくれるんでしょうが。


他にも移動している方向と逆に方向キーを入力したとき、急ブレーキをする表現があったり、移動中にしゃがむことで緩やかに減速するなど、細かな仕様を満たす必要がある。


マリオのジャンプの実装
マリオのジャンプは、これまでも様々なアクションゲームで模倣されてきたと思う。ボタンの押下時間に応じてジャンプ力が変化するところなんかは、アクション性に大きな影響を与えている。あの心地よい放物線を描くジャンプは、どんな風につくられているのか? 以前、読んだマリオのジャンプ実装法とVerlet積分 - Gemmaの日記を思い出しまして、再度拝見。なるほどーシンプルな原理でつくられているんですね。とりあえずそのままやってみると、当然ジャンプはする。だが、記事のまんま実装してもマリオ的な放物線にはならない。まぁそりゃそうですよね。続編として、マリオのジャンプ実装法とVerlet積分(実践編) - Gemmaの日記もありますが、ソースコードへのはリンクは切れていた。Verlet法というのを使うといい感じにできるということがわかったので、ググってみる。すると、どうやら分子動力学に関する話題のようである。なんとなく理屈はわかったけどどう実装すれば?なるほどわからん。



すると、そのままズバリのわかりやすい良記事を発見。ありがたい。→ ジャンプしたときの座標をVerlet法で求める - 無職のプログラミング



上記記事では、既定値とする地面(Y座標)に操作対象のオブジェクトが接地しているときは、キャラクタに重力が働かないように実装されてる。それだと、ジャンプして上にあるブロックに乗っかることもできないし、乗っかったブロックから落下することもできない。なので、記事を参考にしつつジャンプをしていないときも常にキャラクタに重力がかかるように実装する。するとマリオ的なジャンプのソレがうまいこといく。誤解を恐れずにいうと、使う側からすると、Verlet法というのは「現在の位置と前回の位置と経過する時間から次の位置を割り出せば楽じゃん」というもの。キャラクタの位置状況を把握しやすいし便利。よくよく考えてみると、X軸方向の移動に関しても結局は時間経過による移動なので、同様の方法で実装することもできる。ただ、マリオを表現する場合、移動している方向と逆に方向キーを入力したとき、急ブレーキをする表現が必要なので、キー入力時間による加速度を制御したほうが、実装は楽かもしれません。結果オーライだった。


コインの取得(というか、物体との当たり判定)
MonoGame(XNA)には、矩形(四角形の位置とサイズ)を表すのに便利な Rectangle構造体 があります。Rectangle構造体 には、当たり判定(ある矩形が別の矩形に重なるかを判定)を手軽にできるIntersectメソッドが提供されています。なので、それを使えばあたり判定できる。ただし、これだけではどの方向からどの面に対してぶつかったのかの判定材料にはならないので、実際に必要な当たり判定を得るには、もう少し考慮が必要となる。判定をミスるとキャラが地面やブロックにめり込んで残念なことに。




よくわかりませんが、だいぶMが如く感(マリオっぽさ)を出せたんじゃないだろうか。これくらい実装できてくると、だんだんと面白くなってきて次第に欲がでてくる。ステージ1−1を丸ごと実装しようかななんて脳裏に浮かんだけど、冷静に考えると非常に面倒くさそうなので1発ネタはこれにて終了。ただ、今回書いたコードはあまりにもやっつけ仕事すぎるので、余裕ができたらキレイに書き直してみたいかも。



まとめ:つまり結局、どういうことだってばよ!?

ドライバー オン


モノドゥビタッチヘーンシーン! 
モノドゥビタッチヘーンシーン! 
モノドゥビタッチヘーンシーン! 


モノゲーム プリーズ エー、エー! xna!


モノデベロップ ヘーンシーン! 
モノデベロップ ヘーンシーン! 
モノデベロップ ヘーンシーン! 


アバンチュ・マック・タッチゴー!


キャモナ エフシャープ シェイクハーンズ チョーイーネ!!
任意のOSで実行!! サイコー!!


「さぁ、Show Timeだ」




次は、@otfさんですね。楽しみです。

広告を非表示にする