使用Netduino构建您自己的西蒙游戏

描述

在这个项目中，您将使用 Netduino、不同颜色的 LED、按钮和压电扬声器构建一个受流行逻辑游戏 Simon 启发的游戏，您将使用Netduino.Foundation创建逻辑。

按钮（或瞬时触觉按钮）是用于在按下时完成电路并在释放时断开电路的物理按钮。按钮的尺寸和配置范围很广，我们将使用带有四 (4) 条引线的通用类型，这些引线旨在适合标准原型板。按下按钮时，所有四根导线都已连接。您可以在此处阅读有关按钮的更多信息。

压电扬声器（或压电扬声器）是一种利用压电效应产生声音的扬声器。最初的机械运动是通过向压电材料施加电压产生的，并且这种运动通常使用隔膜和谐振器转换为可听声音。

Netduino.Foundation是一个使用 Netduino 上的 .NET MicroFramework 快速轻松地构建连接事物的平台。它由 Wilderness Labs 创建，完全开源并由 Netduino 社区维护。

如果您是 Netduino 开发新手，我建议您转到 Netduino 入门项目以正确设置您的开发环境。

第 1 步 - 组装电路

 

西蒙游戏的电路组装连接到 Netduino

 

第 2 步 - 创建 Netduino 项目

在 Visual Studio 2015 for Windows 或最新的 Visual Studio for Mac 中创建 Netduino 项目；由于我们的游戏是游戏 Simon 的变体，所以我们称它为Simone 。

第 3 步 - 添加 Netduino.Foundation NuGet 包

视窗

右键单击您的Simone项目，然后单击Manage NuGet Packages 。在浏览选项卡中，搜索Netduino.Foundation；它应该是第一个搜索结果。单击安装按钮。

 

将 Netduino.Foundation NuGet 包添加到您的项目中

 

苹果系统

在解决方案资源管理器中按住 Alt 键单击您的Simone项目，然后单击添加 => 添加 NuGet 包以打开 NuGet 包窗口。搜索Netduino.Foundation包并单击Add Package将其添加到您的项目中。

 

将 Netduino.Foundation NuGet 包添加到您的项目中

 

第 4 步 - 为 Simon 项目编写代码

添加 SimonGame类

我们要添加到项目中的第一个类包含西蒙游戏的主要逻辑。为您的项目添加一个名为SimonGame的新类并添加以下代码：

using System;
using Microsoft.SPOT;
namespace Simone
{
   public enum GameState
   {
       Start,
       NextLevel,
       Win,
       GameOver,
   }
   public class SimonEventArgs : EventArgs
   {
       public GameState GameState { get; set; }
       public SimonEventArgs (GameState state)
       {
           GameState = state;
       }
   }
   public class SimonGame
   {
       public delegate void GameStateChangedDelegate(object sender, SimonEventArgs e);
       public event GameStateChangedDelegate OnGameStateChanged = delegate { };
       static int MAX_LEVELS = 25;
       static int NUM_BUTTONS = 4;
       int[] Steps = new int[MAX_LEVELS];
       public int Level { get; set; }
       int currentStep;
       Random rand = new Random((int)DateTime.Now.Ticks);
       public void Reset ()
       {
           OnGameStateChanged(this, new SimonEventArgs(GameState.Start));
           Level = 1;
           currentStep = 0;
           NextLevel();
       }
       public int[] GetStepsForLevel ()
       {
           var steps = new int[Level];
           for (int i = 0; i < Level; i++)
               steps[i] = Steps[i];
           return steps;
       }
       public void EnterStep(int step)
       {
           if (Steps[currentStep] == step)
           {
               Debug.Print("Correct step: " + step + " Current step: " + currentStep);
               currentStep++;
           }
           else
           {
               Debug.Print("wrong step: " + step + " should be: " + Steps[currentStep]);
               OnGameStateChanged(this, new SimonEventArgs(GameState.GameOver));
               Reset();
           }
           if(currentStep == Level)
           {
               NextLevel();
           }
       }
       void NextLevel ()
       {
           currentStep = 0;
           Level++;
           if(Level >= MAX_LEVELS)
           {
               OnGameStateChanged(this, new SimonEventArgs(GameState.Win));
               Reset();
               return;
           }
           var level = string.Empty;
           for (int i = 0; i < Level; i++)
           {
               Steps[i] = rand.Next(NUM_BUTTONS);
               level += Steps[i] + ", ";
           }
           Debug.Print(level);
           OnGameStateChanged(this, new SimonEventArgs(GameState.NextLevel));
       }
   }
}

请注意，SimonGame类实现了以下方法：

• 重置- 从第一关开始游戏

• int[] GetStepsForLevel - 返回某个级别的一系列步骤

• EnterStep - 验证用户按下的按钮是正确的选项

• NextLevel - 用于为新级别生成新的步骤序列

它还包含GameStates和SimonEventArgs ，用于在游戏更改为任何状态时触发事件。更多关于下一个。

添加应用类

对于这个项目，我们实现了一个通用的App软件模式来管理所有的外围设备和主要逻辑。

将一个新的App类添加到您的项目中，然后粘贴以下代码：

using System;
using System.Threading;
using Microsoft.SPOT;
using N = SecretLabs.NETMF.Hardware.Netduino;
using Netduino.Foundation.LEDs;
using Netduino.Foundation.Audio;
using Netduino.Foundation.Sensors.Buttons;
namespace Simone
{
   public class App
   {
       int ANIMATION_DELAY = 200;
       Led[] leds = new Led[4];
       float[] notes = new float[] { 261.63f, 329.63f, 392, 523.25f };
       PushButton[] buttons = new PushButton[4];
       PiezoSpeaker speaker;
       bool isAnimating = false;
       SimonGame game = new SimonGame();
       public void Run()
       {
           Debug.Print("Welcome to Simon");
           InitializePeripherals();
           SetAllLEDs(true);
           game.OnGameStateChanged += OnGameStateChanged;
           game.Reset();
       }
       private void InitializePeripherals()
       {
           leds[0] = new Led(N.Pins.GPIO_PIN_D0);
           leds[1] = new Led(N.Pins.GPIO_PIN_D1);
           leds[2] = new Led(N.Pins.GPIO_PIN_D2);
           leds[3] = new Led(N.Pins.GPIO_PIN_D3);
           buttons[0] = new PushButton(N.Pins.GPIO_PIN_D10, Netduino.Foundation.CircuitTerminationType.High);
           buttons[1] = new PushButton(N.Pins.GPIO_PIN_D11, Netduino.Foundation.CircuitTerminationType.High);
           buttons[2] = new PushButton(N.Pins.GPIO_PIN_D12, Netduino.Foundation.CircuitTerminationType.High);
           buttons[3] = new PushButton(N.Pins.GPIO_PIN_D13, Netduino.Foundation.CircuitTerminationType.High);
           buttons[0].PressStarted += OnButton0;
           buttons[1].PressStarted += OnButton1;
           buttons[2].PressStarted += OnButton2;
           buttons[3].PressStarted += OnButton3;
           speaker = new PiezoSpeaker(N.PWMChannels.PWM_PIN_D5);
           SetAllLEDs(false);
       }
       private void OnGameStateChanged(object sender, SimonEventArgs e)
       {
           var th = new Thread(() =>
           {
               switch (e.GameState)
               {
                   case GameState.Start:
                       break;
                   case GameState.NextLevel:
                       ShowStartAnimation();
                       ShowNextLevelAnimation(game.Level);
                       ShowSequenceAnimation(game.Level);
                       break;
                   case GameState.GameOver:
                       ShowGameOverAnimation();
                       game.Reset();
                       break;
                   case GameState.Win:
                       ShowGameWonAnimation();
                       break;
               }
           });
           th.Start();
       }
       private void SetAllLEDs(bool isOn)
       {
           leds[0].IsOn = isOn;
           leds[1].IsOn = isOn;
           leds[2].IsOn = isOn;
           leds[3].IsOn = isOn;
       }
       private void ShowStartAnimation()
       {
           if (isAnimating)
               return;
           isAnimating = true;
           SetAllLEDs(false);
           for (int i = 0; i < 4; i++)
           {
               leds[i].IsOn = true;
               Thread.Sleep(ANIMATION_DELAY);
           }
           for (int i = 0; i < 4; i++)
           {
               leds[3 - i].IsOn = false;
               Thread.Sleep(ANIMATION_DELAY);
           }
           isAnimating = false;
       }
       private void ShowNextLevelAnimation(int level)
       {
           if (isAnimating)
               return;
           isAnimating = true;
           SetAllLEDs(false);
           for (int i = 0; i < level; i++)
           {
               Thread.Sleep(ANIMATION_DELAY);
               SetAllLEDs(true);
               Thread.Sleep(ANIMATION_DELAY * 3);
               SetAllLEDs(false);
           }
           isAnimating = false;
       }
       private void ShowSequenceAnimation(int level)
       {
           if (isAnimating)
               return;
           isAnimating = true;
           var steps = game.GetStepsForLevel();
           SetAllLEDs(false);
           for (int i = 0; i < level; i++)
           {
               Thread.Sleep(200);
               TurnOnLED(steps[i], 400);
           }
           isAnimating = false;
       }
       private void ShowGameOverAnimation()
       {
           if (isAnimating)
               return;
           isAnimating = true;
           speaker.PlayTone(123.47f, 750);
           for (int i = 0; i < 20; i++)
           {
               SetAllLEDs(false);
               Thread.Sleep(50);
               SetAllLEDs(true);
               Thread.Sleep(50);
           }
           isAnimating = false;
       }
       private void ShowGameWonAnimation()
       {
           ShowStartAnimation();
           ShowStartAnimation();
           ShowStartAnimation();
           ShowStartAnimation();
       }
       private void TurnOnLED(int index, int durration = 400)
       {
           leds[index].IsOn = true;
           speaker.PlayTone(notes[index], durration);
           leds[index].IsOn = false;
       }
        DateTime lastPressed;
       private void OnButton(int buttonIndex)
       {
           if (DateTime.Now - lastPressed < TimeSpan.FromTicks(5000000)) //0.5s
               return;
           Debug.Print("Button tapped: " + buttonIndex);
           if (isAnimating == false)
           {
               lastPressed = DateTime.Now;
               TurnOnLED(buttonIndex);
               game.EnterStep(buttonIndex);
           }
       }
       private void OnButton0(object sender, EventArgs e)
       {
           OnButton(0);
       }
       private void OnButton1(object sender, EventArgs e)
       {
           OnButton(1);
       }
       private void OnButton2(object sender, EventArgs e)
       {
           OnButton(2);
       }
       private void OnButton3(object sender, EventArgs e)
       {
           OnButton(3);
       }
   }
}

这堂课发生了几件事。这里最需要注意的是，Simone 是作为状态机工作的，这意味着在开始游戏时，传递到下一个关卡，游戏的输赢都是游戏状态，当改变状态时，会触发一个事件和OnGameStateChanged事件处理程序将根据游戏状态运行适当的例程。

输入 - 按钮

用户与 Simon 游戏交互的唯一方式是通过四个按钮。在代码中，这些按钮在顶部声明，将按钮命名为四个项目的数组，在InitializePeripherals方法中，我们实例化每个PushButton并在声明每个按钮的处理程序之后，它们都调用OnButton方法最终检查按下的按钮是否是游戏序列的正确步骤。

输出 - LED 和压电扬声器

本项目中用于输出的外围设备是 LED 和 PiezoSpeaker。使用Netduino.Fundation ，我们可以在InitializerPeripherals方法中简单地实例化四 (4) 个LED和PiezoSpeaker对象，我们在其中指定这些组件连接到 Netduino 的引脚。

动画

为了给用户反馈游戏所处的状态，我们编写了以下动画方法：

• 私人无效 ShowStartAnimation()

• 私人无效 ShowNextLevelAnimation（int 级别）

• 私人无效ShowSequenceAnimation（int级别）

• 私人无效 ShowGameOverAnimation()

• 私人无效 ShowGameWonAnimation()

这些动画方法是按一定顺序打开和关闭 LED 的显式脚本，以表达游戏的不同状态。

节目班

最后，创建一个新的App类对象并调用Run方法。您的代码应如下所示：

using System.Threading;
namespace Simone
{
   public class Program
   {
       public static void Main ()
       {
           App app = new App();
           app.Run();
           Thread.Sleep(Timeout.Infinite);
       }
   }
}
namespace System.Diagnostics
{
   public enum DebuggerBrowsableState
   {
       Never = 0,
       Collapsed = 2,
       RootHidden = 3
   }
}

第 5 步 - 运行项目

单击 Visual Studio 中的运行按钮以查看您的 Simon 游戏在运行中！注意开始动画，所有 LED 都会闪烁一定次数，以指示您当前处于哪个级别！

查看 Netduino.Foundation

就您可以使用Netduino.Foundation做的大量令人兴奋的事情而言，这个项目只是冰山一角。

• 它带有一个庞大的外围驱动程序库，其中包含最常见的传感器和外围设备的驱动程序。

• 外围驱动程序封装了核心逻辑并公开了一个简单、干净、现代的 API。

• 这个项目得到了一个不断发展的社区的支持，该社区不断致力于构建很酷的互联事物，并且总是很高兴能帮助新人并讨论新项目。

参考

• SimoneCompleteSolution

• Netduino.Foundation

• Netduino.Foundation：按钮