博客园_加菲猫

XNA游戏：各种输入测试

2012-05-27T06:07:00Z

测试XNA游戏中键盘输入，触控输入，按钮输入

Game1.cs

Action.cs 游戏操作的类型

namespace InputHandlerDemo
{
static class Actions
{
// 自定义的操作类型
public const string Jump = "Jump";
public const string Exit = "Exit";
public const string Up = "Up";
public const string Pause = "Pause";
}
}

下面是输入的操作的封装类

GameInput.cs

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Input.Touch;

namespace InputHandlerDemo.Inputs
{
/// <summary>
/// 游戏输入管理类
/// </summary>
class GameInput
{
//输入类型字典
Dictionary<string, Input> Inputs = new Dictionary<string, Input>();
//获取输入类型
public Input GetInput(string theAction)
{
//如果没有改类型的输入操作则添加一个
if (Inputs.ContainsKey(theAction) == false)
{
Inputs.Add(theAction, new Input());
}

return Inputs[theAction];
}

public void BeginUpdate()
{
Input.BeginUpdate();
}

public void EndUpdate()
{
Input.EndUpdate();
}

public bool IsConnected(PlayerIndex thePlayer)
{
// If there never WAS a gamepad connected, just say the gamepad is STILL connected
if (Input.GamepadConnectionState[thePlayer] == false)
return true;

return Input.IsConnected(thePlayer);
}

public bool IsPressed(string theAction)
{
if (!Inputs.ContainsKey(theAction))
{
return false;
}

return Inputs[theAction].IsPressed(PlayerIndex.One);
}
/// <summary>
/// 判断单击的状态
/// </summary>
/// <param name="theAction">动作</param>
/// <param name="thePlayer">玩家</param>
/// <returns></returns>
public bool IsPressed(string theAction, PlayerIndex thePlayer)
{
if (Inputs.ContainsKey(theAction) == false)
{
return false;
}

return Inputs[theAction].IsPressed(thePlayer);
}

public bool IsPressed(string theAction, PlayerIndex? thePlayer)
{
if (thePlayer == null)
{
PlayerIndex theReturnedControllingPlayer;
return IsPressed(theAction, thePlayer, out theReturnedControllingPlayer);
}

return IsPressed(theAction, (PlayerIndex)thePlayer);
}

public bool IsPressed(string theAction, PlayerIndex? thePlayer, out PlayerIndex theControllingPlayer)
{
if (!Inputs.ContainsKey(theAction))
{
theControllingPlayer = PlayerIndex.One;
return false;
}

if (thePlayer == null)
{
if (IsPressed(theAction, PlayerIndex.One))
{
theControllingPlayer = PlayerIndex.One;
return true;
}

if (IsPressed(theAction, PlayerIndex.Two))
{
theControllingPlayer = PlayerIndex.Two;
return true;
}

if (IsPressed(theAction, PlayerIndex.Three))
{
theControllingPlayer = PlayerIndex.Three;
return true;
}

if (IsPressed(theAction, PlayerIndex.Four))
{
theControllingPlayer = PlayerIndex.Four;
return true;
}

theControllingPlayer = PlayerIndex.One;
return false;
}

theControllingPlayer = (PlayerIndex)thePlayer;
return IsPressed(theAction, (PlayerIndex)thePlayer);
}

public void AddGamePadInput(string theAction, Buttons theButton,
bool isReleasedPreviously)
{
GetInput(theAction).AddGamepadInput(theButton, isReleasedPreviously);
}

public void AddTouchTapInput(string theAction, Rectangle theTouchArea,
bool isReleasedPreviously)
{
GetInput(theAction).AddTouchTapInput(theTouchArea, isReleasedPreviously);
}

public void AddTouchSlideInput(string theAction, Input.Direction theDirection,
float slideDistance)
{
GetInput(theAction).AddTouchSlideInput(theDirection, slideDistance);
}

public void AddKeyboardInput(string theAction, Keys theKey,
bool isReleasedPreviously)
{
GetInput(theAction).AddKeyboardInput(theKey, isReleasedPreviously);
}

public void AddTouchGestureInput(string theAction, GestureType theGesture,
Rectangle theRectangle)
{
GetInput(theAction).AddTouchGesture(theGesture, theRectangle);
}

public void AddAccelerometerInput(string theAction, Input.Direction theDirection,
float tiltThreshold)
{
GetInput(theAction).AddAccelerometerInput(theDirection, tiltThreshold);
}

public Vector2 CurrentGesturePosition(string theAction)
{
return GetInput(theAction).CurrentGesturePosition();
}

public Vector2 CurrentGestureDelta(string theAction)
{
return GetInput(theAction).CurrentGestureDelta();
}

public Vector2 CurrentGesturePosition2(string theAction)
{
return GetInput(theAction).CurrentGesturePosition2();
}

public Vector2 CurrentGestureDelta2(string theAction)
{
return GetInput(theAction).CurrentGestureDelta2();
}

public Point CurrentTouchPoint(string theAction)
{
Vector2? currentPosition = GetInput(theAction).CurrentTouchPosition();
if (currentPosition == null)
{
return new Point(-1, -1);
}

return new Point((int)currentPosition.Value.X, (int)currentPosition.Value.Y);
}

public Vector2 CurrentTouchPosition(string theAction)
{
Vector2? currentTouchPosition = GetInput(theAction).CurrentTouchPosition();
if (currentTouchPosition == null)
{
return new Vector2(-1, -1);
}

return (Vector2)currentTouchPosition;
}

public float CurrentGestureScaleChange(string theAction)
{
// Scaling is dependent on the Pinch gesture. If no input has been setup for
// Pinch then just return 0 indicating no scale change has occurred.
if (!GetInput(theAction).PinchGestureAvailable) return 0;

// Get the current and previous locations of the two fingers
Vector2 currentPositionFingerOne = CurrentGesturePosition(theAction);
Vector2 previousPositionFingerOne
= CurrentGesturePosition(theAction) - CurrentGestureDelta(theAction);
Vector2 currentPositionFingerTwo = CurrentGesturePosition2(theAction);
Vector2 previousPositionFingerTwo
= CurrentGesturePosition2(theAction) - CurrentGestureDelta2(theAction);

// Figure out the distance between the current and previous locations
float currentDistance = Vector2.Distance(currentPositionFingerOne, currentPositionFingerTwo);
float previousDistance
= Vector2.Distance(previousPositionFingerOne, previousPositionFingerTwo);

// Calculate the difference between the two and use that to alter the scale
float scaleChange = (currentDistance - previousDistance) * .01f;
return scaleChange;
}

public Vector3 CurrentAccelerometerReading(string theAction)
{
return GetInput(theAction).CurrentAccelerometerReading;
}

}
}

GestureDefinition.cs

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input.Touch;

namespace InputHandlerDemo.Inputs
{
/// <summary>
/// 手势定义
/// </summary>
class GestureDefinition
{
public GestureType Type;
public Rectangle CollisionArea;
public GestureSample Gesture;
public Vector2 Delta;
public Vector2 Delta2;
public Vector2 Position;
public Vector2 Position2;

public GestureDefinition(GestureType theGestureType, Rectangle theGestureArea)
{
Gesture = new GestureSample(theGestureType, new TimeSpan(0),
Vector2.Zero, Vector2.Zero,
Vector2.Zero, Vector2.Zero);
Type = theGestureType;
CollisionArea = theGestureArea;
}

public GestureDefinition(GestureSample theGestureSample)
{
Gesture = theGestureSample;
Type = theGestureSample.GestureType;
CollisionArea = new Rectangle((int)theGestureSample.Position.X,
(int)theGestureSample.Position.Y, 5, 5);

Delta = theGestureSample.Delta;
Delta2 = theGestureSample.Delta2;
Position = theGestureSample.Position;
Position2 = theGestureSample.Position2;
}

}
}

Input.cs

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Input.Touch;
using Microsoft.Xna.Framework;
using Microsoft.Devices.Sensors;

namespace InputHandlerDemo.Inputs
{
/// <summary>
/// 输入操作类
/// </summary>
class Input
{
Dictionary<Keys, bool> keyboardInputs = new Dictionary<Keys, bool>();
Dictionary<Buttons, bool> gamepadInputs = new Dictionary<Buttons, bool>();
Dictionary<Rectangle, bool> touchTapInputs = new Dictionary<Rectangle, bool>();
Dictionary<Direction, float> touchSlideInputs = new Dictionary<Direction, float>();
Dictionary<int, GestureDefinition> gestureInputs = new Dictionary<int, GestureDefinition>();
Dictionary<Direction, float> accelerometerInputs = new Dictionary<Direction, float>();

static public Dictionary<PlayerIndex, GamePadState> CurrentGamePadState//当前玩家的控制状态
= new Dictionary<PlayerIndex, GamePadState>();

static public Dictionary<PlayerIndex, GamePadState> PreviousGamePadState//上一个玩家的控制状态
= new Dictionary<PlayerIndex, GamePadState>();

static public TouchCollection CurrentTouchLocationState;//当前的触控集合
static public TouchCollection PreviousTouchLocationState;//上一个触控集合
static public KeyboardState CurrentKeyboardState;//当前的键盘状态
static public KeyboardState PreviousKeyboardState;//上一个键盘状态

static public Dictionary<PlayerIndex, bool> GamepadConnectionState
= new Dictionary<PlayerIndex, bool>();

static private List<GestureDefinition> detectedGestures = new List<GestureDefinition>();

static private Accelerometer accelerometerSensor;
static private Vector3 currentAccelerometerReading;
//方向
public enum Direction
{
Up,
Down,
Left,
Right
}

public Input()
{
if (CurrentGamePadState.Count == 0)
{
CurrentGamePadState.Add(PlayerIndex.One, GamePad.GetState(PlayerIndex.One));
CurrentGamePadState.Add(PlayerIndex.Two, GamePad.GetState(PlayerIndex.Two));
CurrentGamePadState.Add(PlayerIndex.Three, GamePad.GetState(PlayerIndex.Three));
CurrentGamePadState.Add(PlayerIndex.Four, GamePad.GetState(PlayerIndex.Four));

PreviousGamePadState.Add(PlayerIndex.One, GamePad.GetState(PlayerIndex.One));
PreviousGamePadState.Add(PlayerIndex.Two, GamePad.GetState(PlayerIndex.Two));
PreviousGamePadState.Add(PlayerIndex.Three, GamePad.GetState(PlayerIndex.Three));
PreviousGamePadState.Add(PlayerIndex.Four, GamePad.GetState(PlayerIndex.Four));

GamepadConnectionState.Add(PlayerIndex.One,
CurrentGamePadState[PlayerIndex.One].IsConnected);
GamepadConnectionState.Add(PlayerIndex.Two,
CurrentGamePadState[PlayerIndex.Two].IsConnected);
GamepadConnectionState.Add(PlayerIndex.Three,
CurrentGamePadState[PlayerIndex.Three].IsConnected);
GamepadConnectionState.Add(PlayerIndex.Four,
CurrentGamePadState[PlayerIndex.Four].IsConnected);
}
//添加重力感应
if (accelerometerSensor == null)
{
accelerometerSensor = new Accelerometer();
accelerometerSensor.ReadingChanged
+= new EventHandler<AccelerometerReadingEventArgs>(AccelerometerReadingChanged);
}
}
/// <summary>
/// 开始更新
/// </summary>
static public void BeginUpdate()
{
//PlayerIndex游戏玩家的索引，添加4个玩家
CurrentGamePadState[PlayerIndex.One] = GamePad.GetState(PlayerIndex.One);
CurrentGamePadState[PlayerIndex.Two] = GamePad.GetState(PlayerIndex.Two);
CurrentGamePadState[PlayerIndex.Three] = GamePad.GetState(PlayerIndex.Three);
CurrentGamePadState[PlayerIndex.Four] = GamePad.GetState(PlayerIndex.Four);
//当前触摸的地方
CurrentTouchLocationState = TouchPanel.GetState();
//玩家1的状态
CurrentKeyboardState = Keyboard.GetState(PlayerIndex.One);

detectedGestures.Clear();
while (TouchPanel.IsGestureAvailable)
{
GestureSample gesture = TouchPanel.ReadGesture();
detectedGestures.Add(new GestureDefinition(gesture));
}
}
/// <summary>
/// 结束更新
/// </summary>
static public void EndUpdate()
{
//PlayerIndex游戏玩家的索引，日安家
PreviousGamePadState[PlayerIndex.One] = CurrentGamePadState[PlayerIndex.One];
PreviousGamePadState[PlayerIndex.Two] = CurrentGamePadState[PlayerIndex.Two];
PreviousGamePadState[PlayerIndex.Three] = CurrentGamePadState[PlayerIndex.Three];
PreviousGamePadState[PlayerIndex.Four] = CurrentGamePadState[PlayerIndex.Four];

PreviousTouchLocationState = CurrentTouchLocationState;
PreviousKeyboardState = CurrentKeyboardState;
}

private void AccelerometerReadingChanged(object sender, AccelerometerReadingEventArgs e)
{
currentAccelerometerReading.X = (float)e.X;
currentAccelerometerReading.Y = (float)e.Y;
currentAccelerometerReading.Z = (float)e.Z;
}
// 添加一个键盘输入
public void AddKeyboardInput(Keys theKey, bool isReleasedPreviously)
{
if (keyboardInputs.ContainsKey(theKey))
{
keyboardInputs[theKey] = isReleasedPreviously;
return;
}
keyboardInputs.Add(theKey, isReleasedPreviously);
}
//添加一个游戏按钮输入
public void AddGamepadInput(Buttons theButton, bool isReleasedPreviously)
{
if (gamepadInputs.ContainsKey(theButton))
{
gamepadInputs[theButton] = isReleasedPreviously;
return;
}
gamepadInputs.Add(theButton, isReleasedPreviously);
}
//添加一个手势单击输入
public void AddTouchTapInput(Rectangle theTouchArea, bool isReleasedPreviously)
{
if (touchTapInputs.ContainsKey(theTouchArea))
{
touchTapInputs[theTouchArea] = isReleasedPreviously;
return;
}
touchTapInputs.Add(theTouchArea, isReleasedPreviously);
}
//添加一个手势滑动输入
public void AddTouchSlideInput(Direction theDirection, float slideDistance)
{
if (touchSlideInputs.ContainsKey(theDirection))
{
touchSlideInputs[theDirection] = slideDistance;
return;
}
touchSlideInputs.Add(theDirection, slideDistance);
}

public bool PinchGestureAvailable = false;//手势是否可用
public void AddTouchGesture(GestureType theGesture, Rectangle theTouchArea)
{
TouchPanel.EnabledGestures = theGesture | TouchPanel.EnabledGestures;
gestureInputs.Add(gestureInputs.Count, new GestureDefinition(theGesture, theTouchArea));
if (theGesture == GestureType.Pinch)
{
PinchGestureAvailable = true;
}
}

static private bool isAccelerometerStarted = false;//重力加速是否可用
public void AddAccelerometerInput(Direction direction, float tiltThreshold)
{
if (!isAccelerometerStarted)
{
try
{
accelerometerSensor.Start();
isAccelerometerStarted = true;
}
catch (AccelerometerFailedException e)
{
isAccelerometerStarted = false;
System.Diagnostics.Debug.WriteLine(e.Message);
}
}

accelerometerInputs.Add(direction, tiltThreshold);
}

public void RemoveAccelerometerInputs()
{
if (isAccelerometerStarted)
{
try
{
accelerometerSensor.Stop();
isAccelerometerStarted = false;
}
catch (AccelerometerFailedException e)
{
// The sensor couldn't be stopped.
System.Diagnostics.Debug.WriteLine(e.Message);
}
}

accelerometerInputs.Clear();
}

static public bool IsConnected(PlayerIndex thePlayerIndex)
{
return CurrentGamePadState[thePlayerIndex].IsConnected;
}

//是否选中玩家
public bool IsPressed(PlayerIndex thePlayerIndex)
{
return IsPressed(thePlayerIndex, null);
}

public bool IsPressed(PlayerIndex thePlayerIndex, Rectangle? theCurrentObjectLocation)
{
if (IsKeyboardInputPressed())
{
return true;
}

if (IsGamepadInputPressed(thePlayerIndex))
{
return true;
}

if (IsTouchTapInputPressed())
{
return true;
}

if (IsTouchSlideInputPressed())
{
return true;
}
//点钟矩形区域
if (IsGestureInputPressed(theCurrentObjectLocation))
{
return true;
}

return false;
}

private bool IsKeyboardInputPressed()
{
foreach (Keys aKey in keyboardInputs.Keys)
{
if (keyboardInputs[aKey]
&& CurrentKeyboardState.IsKeyDown(aKey)
&& !PreviousKeyboardState.IsKeyDown(aKey))
{
return true;
}
else if (!keyboardInputs[aKey]
&& CurrentKeyboardState.IsKeyDown(aKey))
{
return true;
}
}

return false;
}

private bool IsGamepadInputPressed(PlayerIndex thePlayerIndex)
{
foreach (Buttons aButton in gamepadInputs.Keys)
{
if (gamepadInputs[aButton]
&& CurrentGamePadState[thePlayerIndex].IsButtonDown(aButton)
&& !PreviousGamePadState[thePlayerIndex].IsButtonDown(aButton))
{
return true;
}
else if (!gamepadInputs[aButton]
&& CurrentGamePadState[thePlayerIndex].IsButtonDown(aButton))
{
return true;
}
}

return false;
}

private bool IsTouchTapInputPressed()
{
foreach (Rectangle touchArea in touchTapInputs.Keys)
{
if (touchTapInputs[touchArea]
&& touchArea.Intersects(CurrentTouchRectangle)
&& PreviousTouchPosition() == null)
{
return true;
}
else if (!touchTapInputs[touchArea]
&& touchArea.Intersects(CurrentTouchRectangle))
{
return true;
}
}

return false;
}

private bool IsTouchSlideInputPressed()
{
foreach (Direction slideDirection in touchSlideInputs.Keys)
{
if (CurrentTouchPosition() != null && PreviousTouchPosition() != null)
{
switch (slideDirection)
{
case Direction.Up:
{
if (CurrentTouchPosition().Value.Y + touchSlideInputs[slideDirection]
< PreviousTouchPosition().Value.Y)
{
return true;
}
break;
}

case Direction.Down:
{
if (CurrentTouchPosition().Value.Y - touchSlideInputs[slideDirection]
> PreviousTouchPosition().Value.Y)
{
return true;
}
break;
}

case Direction.Left:
{
if (CurrentTouchPosition().Value.X + touchSlideInputs[slideDirection]
< PreviousTouchPosition().Value.X)
{
return true;
}
break;
}

case Direction.Right:
{
if (CurrentTouchPosition().Value.X - touchSlideInputs[slideDirection]
> PreviousTouchPosition().Value.X)
{
return true;
}
break;
}
}
}
}

return false;
}

private bool IsGestureInputPressed(Rectangle? theNewDetectionLocation)
{
currentGestureDefinition = null;

if (detectedGestures.Count == 0) return false;

// Check to see if any of the Gestures defined in the gestureInputs
// dictionary have been performed and detected.
foreach (GestureDefinition userDefinedGesture in gestureInputs.Values)
{
foreach (GestureDefinition detectedGesture in detectedGestures)
{
if (detectedGesture.Type == userDefinedGesture.Type)
{
// If a Rectangle area to check against has been passed in, then
// use that one, otherwise use the one originally defined
Rectangle areaToCheck = userDefinedGesture.CollisionArea;
if (theNewDetectionLocation != null)
areaToCheck = (Rectangle)theNewDetectionLocation;

// If the gesture detected was made in the area where users were
// interested in Input (they intersect), then a gesture input is
// considered detected.
if (detectedGesture.CollisionArea.Intersects(areaToCheck))
{
if (currentGestureDefinition == null)
{
currentGestureDefinition
= new GestureDefinition(detectedGesture.Gesture);
}
else
{
// Some gestures like FreeDrag and Flick are registered many,
// many times in a single Update frame. Since there is only
// one variable to store the gesture info, you must add on
// any additional gesture values so there is a combination
// of all the gesture information in currentGesture
currentGestureDefinition.Delta += detectedGesture.Delta;
currentGestureDefinition.Delta2 += detectedGesture.Delta2;
currentGestureDefinition.Position += detectedGesture.Position;
currentGestureDefinition.Position2 += detectedGesture.Position2;
}
}
}
}
}

if (currentGestureDefinition != null) return true;

return false;
}

private bool IsAccelerometerInputPressed()
{
foreach (KeyValuePair<Direction, float> input in accelerometerInputs)
{
switch (input.Key)
{
case Direction.Up:
{
if (Math.Abs(currentAccelerometerReading.Y) > input.Value
&& currentAccelerometerReading.Y < 0)
{
return true;
}
break;
}

case Direction.Down:
{
if (Math.Abs(currentAccelerometerReading.Y) > input.Value
&& currentAccelerometerReading.Y > 0)
{
return true;
}
break;
}

case Direction.Left:
{
if (Math.Abs(currentAccelerometerReading.X) > input.Value
&& currentAccelerometerReading.X < 0)
{
return true;
}
break;
}

case Direction.Right:
{
if (Math.Abs(currentAccelerometerReading.X) > input.Value
&& currentAccelerometerReading.X > 0)
{
return true;
}
break;
}
}
}

return false;
}

GestureDefinition currentGestureDefinition;
public Vector2 CurrentGesturePosition()
{
if (currentGestureDefinition == null)
return Vector2.Zero;

return currentGestureDefinition.Position;
}

public Vector2 CurrentGesturePosition2()
{
if (currentGestureDefinition == null)
return Vector2.Zero;

return currentGestureDefinition.Position2;
}

public Vector2 CurrentGestureDelta()
{
if (currentGestureDefinition == null)
return Vector2.Zero;

return currentGestureDefinition.Delta;
}

public Vector2 CurrentGestureDelta2()
{
if (currentGestureDefinition == null)
return Vector2.Zero;

return currentGestureDefinition.Delta2;
}

public Vector2? CurrentTouchPosition()
{
foreach (TouchLocation location in CurrentTouchLocationState)
{
switch (location.State)
{
case TouchLocationState.Pressed:
return location.Position;

case TouchLocationState.Moved:
return location.Position;
}
}

return null;
}

private Vector2? PreviousTouchPosition()
{
foreach (TouchLocation location in PreviousTouchLocationState)
{
switch (location.State)
{
case TouchLocationState.Pressed:
return location.Position;

case TouchLocationState.Moved:
return location.Position;
}
}

return null;
}

private Rectangle CurrentTouchRectangle
{
get
{
Vector2? touchPosition = CurrentTouchPosition();
if (touchPosition == null)
return Rectangle.Empty;

return new Rectangle((int)touchPosition.Value.X - 5,
(int)touchPosition.Value.Y - 5,
10,
10);
}
}

public Vector3 CurrentAccelerometerReading
{
get
{
return currentAccelerometerReading;
}
}
}
}

TouchIndicator.cs

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input.Touch;
using Microsoft.Xna.Framework.Content;

namespace InputHandlerDemo.Inputs
{
/// <summary>
/// 触控轨迹
/// </summary>
class TouchIndicator
{
int alphaValue = 255;
public int TouchID;

Texture2D touchCircleIndicatorTexture;
Texture2D touchCrossHairIndicatorTexture;
//轨迹集合
List<Vector2> touchPositions = new List<Vector2>();
/// <summary>
/// 初始化触摸轨迹
/// </summary>
/// <param name="touchID"></param>
/// <param name="content"></param>
public TouchIndicator(int touchID, ContentManager content)
{
TouchID = touchID;

touchCircleIndicatorTexture = content.Load<Texture2D>("Circle");
touchCrossHairIndicatorTexture = content.Load<Texture2D>("Crosshair");
}

private Vector2? TouchPosition(TouchCollection touchLocationState)
{
TouchLocation touchLocation;
if (touchLocationState.FindById(TouchID, out touchLocation))
{
return touchLocation.Position;
}

return null;
}

public void Update(TouchCollection touchLocationState)
{
Vector2? currentPosition = TouchPosition(touchLocationState);
if (currentPosition == null)
{
if (touchPositions.Count > 0)
{
alphaValue -= 20;
if (alphaValue <= 0)
{
touchPositions.Clear();
alphaValue = 255;
}
}
}
else
{
if (alphaValue != 255)
{
touchPositions.Clear();
alphaValue = 255;
}

touchPositions.Add((Vector2)currentPosition);
}
}
/// <summary>
/// 绘制界面
/// </summary>
/// <param name="batch"></param>
public void Draw(SpriteBatch batch)
{
if (touchPositions.Count != 0)
{
Vector2 previousPosition = touchPositions[0];
Vector2 offsetForCenteringTouchPosition = new Vector2(-25, 0);
//绘制触摸的轨迹
foreach (Vector2 aPosition in touchPositions)
{
DrawLine(batch,
touchCircleIndicatorTexture,
touchCrossHairIndicatorTexture,
previousPosition + offsetForCenteringTouchPosition,
aPosition + offsetForCenteringTouchPosition,
new Color(0, 0, 255, alphaValue));

previousPosition = aPosition;
}
}
}
/// <summary>
/// 画线
/// </summary>
/// <param name="batch"></param>
/// <param name="lineTexture"></param>
/// <param name="touchTexture"></param>
/// <param name="startingPoint"></param>
/// <param name="endingPoint"></param>
/// <param name="lineColor"></param>
void DrawLine(SpriteBatch batch, Texture2D lineTexture, Texture2D touchTexture,
Vector2 startingPoint, Vector2 endingPoint, Color lineColor)
{
batch.Draw(touchTexture, startingPoint, lineColor);

Vector2 difference = startingPoint - endingPoint;
float lineLength = difference.Length() / 8;

for (int i = 0; i < lineLength; i++)
{
batch.Draw(lineTexture, startingPoint, lineColor);
startingPoint.X -= difference.X / lineLength;
startingPoint.Y -= difference.Y / lineLength;
}

batch.Draw(touchTexture, endingPoint, lineColor);
}
}
}

TouchIndicatorCollection.cs

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Input.Touch;
using Microsoft.Xna.Framework.Graphics;

namespace InputHandlerDemo.Inputs
{
/// <summary>
/// 触控轨迹集合
/// </summary>
class TouchIndicatorCollection
{
List<TouchIndicator> touchPositions = new List<TouchIndicator>();
/// <summary>
/// 更新游戏界面
/// </summary>
/// <param name="gameTime"></param>
/// <param name="content"></param>
public void Update(GameTime gameTime, ContentManager content)
{
//在XNA中，TouchPanel可以向我们提供大量关于触控操作的信息获取触控的集合
TouchCollection currentTouchLocationState = TouchPanel.GetState();
foreach (TouchLocation location in currentTouchLocationState)
{//获取触控的位置
bool isTouchIDAlreadyStored = false;
foreach (TouchIndicator indicator in touchPositions)
{
//如果触控的位置id存在则跳出整个循环
if (location.Id == indicator.TouchID)
{
isTouchIDAlreadyStored = true;
break;
}
}

if (!isTouchIDAlreadyStored)
{
//加入一个触控的位置
TouchIndicator indicator = new TouchIndicator(location.Id, content);
touchPositions.Add(indicator);
}
}

foreach (TouchIndicator indicator in touchPositions)
{
indicator.Update(currentTouchLocationState);
}
}

public void Draw(SpriteBatch batch)
{
foreach (TouchIndicator indicator in touchPositions)
{
indicator.Draw(batch);
}
}
}
}

本文链接

XNA游戏：软键盘弹窗输入

2012-04-15T12:32:00Z

在XNA中如果我们需要输入文字，那么我们就需要使用到软键盘了，在XNA中使用软键盘要用到Guide.BeginShowKeyboardInput方法，由于游戏的Update是会不断地执行的，所以要由Guide.IsVisible来检查弹出输入框是否已经显示出来了。

Guide.BeginShowKeyboardInput方法的参数
PlayerIndex    玩家的编号，手机是PlayerIndex.One
Title    输入窗口的标题
Description    输入窗口的描述
DefaultText    默认的文字
Callback    回调的方法
State    使用者想要传送的物件

Guide.BeginShowMessageBox时弹出一个窗口没有软键盘输入，这个方法的参数分別是
Title    窗口的标题
Text    窗口的文字
Buttons    按钮
FoucsButton    预设的按钮
Icon    图标
Callback    回调的方法
State    使用者想要传送的物件

示例

本文链接

XNA游戏：手势触控

2012-04-15T11:30:00Z

在XNA游戏中使用到手势触控操作时，需要引入using Microsoft.Xna.Framework.Input.Touch;

空间，在该空间下下面两个类在触控编程中会用到。
TouchLocation 用来保存某一个触摸点的状态信息。
TouchCollection 是保存了当前所有触控状态（TouchLocation）的集合。

当我们把一个指头在屏幕上操作，可能会有这样三种动作：按，移动，移开。那么这三个操作在WP7的XNA里如何获取呢？我们就需要了解XNA里的TouchPanel和TouchCollection这两个类

TouchCollection touchState= TouchPanel.GetState();
Foreach(TouchLocation location in touchState)
{
switch(location.State)
{
case TouchLocationState.Pressed://按下
……
break;

case TouchLocationState.Moved://移动
……
break;

case TouchLocationState.Released://释放
……
break;

}
}

TouchLocation ：
    State 触摸状态，包含4个状态
         > TouchLocationState.Pressed 表示屏幕被触摸时手指按下的一瞬间
         > TouchLocationState.Moved 表示手指按下后正在移动，经过测试可知，在手指按下的一瞬间State为Pressed ，在手指按下后抬起前这段时间内的状态均是Moved
         > TouchLocationState.Invalid 无效状态
         > TouchLocationState.Released 表示手指抬起的一瞬间
    ID 表示当前触摸事件的ID，一个完成的触控事件的过程应该是“Pressed -> Moved -> Released ”在这个过程中ID是一致的，用来在多点触摸时区分触摸的每个点。
    Position 触摸位置，包含两个属性
         > X 当前触摸位置的X轴坐标
        > Y 当前触摸位置的Y轴坐标
         （横屏全屏情况下，屏幕的左上角坐标为（0，0）右下角坐标为（800,480））

和触控操作类似的还有叫“手势”的，也算复杂的触控吧。

TouchPanel.EnabledGestures = GestureType.FreeDrag;//用来指定手势，必须要先设定，否则

报错

if (TouchPanel.EnabledGestures != GestureType.None)
{
switch (TouchPanel.ReadGesture())
{
case GestureType.Tap: //单击
break;
case GestureType.DoubleTap://双击
break;
case GestureType.FreeDrag://自由拖动
break;
case GestureType.DragComplete://拖动完成
break;
case GestureType.Flick://轻弹
break;
case GestureType.Hold://按住不动
break;
case GestureType.HorizontalDrag://横向拖动
break;
case GestureType.None://无手势
break;
case GestureType.Pinch://捏
break;
case GestureType.PinchComplete://捏完
break;
case GestureType.VerticalDrag://纵向拖动
break;
}
}

示例一各种手势的测试：

示例二多点触控的测试：

本文链接

XNA游戏：横竖屏设置

2012-04-15T07:46:00Z

手机设备里面，会有横竖屏的状态，一般会有3种情况，一个中是竖屏，一个是右横屏，一个是左横屏，横屏的设置是通过GraphicsDeviceManager类的SupportedOrientations属性来设置的，GraphicsDeviceManager类在XNA类库介绍中提到的该类型是非常重要的。它为开发者提供方法来管理目标设备的显卡资源。简单地说就是调用显卡的一个接口，该对象的GraphicsDevice属性代表当前目标设备的显卡。

示例：

本文链接

XNA游戏：重力感应

2012-04-15T07:14:00Z

Windows Phone XNA游戏提供的重力传感器可以利用量测重力的原理判手机移动的方向，允许使用者利用摇动或甩动手机的方式控制游戏的执行，其原理和汽车的安全气囊相同，在侦测到汽车快速减速的时候立刻充气以保护驾驶人与乘客不会受伤。要使用重力传感器当做游戏程序的输入，以 XNA 为基础的游戏程序可以利用 Accelerometer 类别提供的功能启用/停用重力加速器，取得重力加速器的状态，以及处理重力加速器引发的事件。

Accelerometer 类别常用的属性

属性名称	说明
State	管理重力加速器状态的属性，其型态为 SensorState 列举型态。有关 SensorState 列举型态合法的内容值可以参考表4 的说明。

Accelerometer 类别常用的方法

方法名称	说明
Start	开始从重力加速器读取数据。
Stop	结束从重力加速器读取数据。

Accelerometer 类别常用的事件

事件名称	说明
ReadingChanged	当重力加速器读取到数据时会引发的事件。

处理 ReadingChanged 事件的事件处理程序的第二个参数的型态为 AccelerometerReadingEventArgs 类别，其 X、Y、与 X 属性的内容值代表智能型手机在 X 轴、Y 轴、和 Z 轴的加速方向，而不是三度空间的坐标，其单位为重力单位，也就是 G 力 (1G = 9.81 m/s2)。除了 X、Y、与 Z 三个属性以外，还有一个名称为 Timestamp 的属性，负责记录重力加速器读取数据的时间点。

请注意当手机放在平坦的桌面上，而且正面朝上的时候，AccelerometerReadingEventArgs 类别的 Z 字段的内容值会是 -1.0，表示 Z 轴承受 -1G 的重力，而当手机放在平坦的桌面上，而且正面朝下的时候，AccelerometerReadingEventArgs 类别的 Z 字段的内容值就会是 +1.0，表示 Z 轴承受 1G 的重力。

[说明]

透过 Accelerometer 类别的 State 属性取得的重力加速器状态是 SensorState 列举型态的数据，其合法的内容值请参考表的说明：

内容值名称	说明
NotSupported	未支持重力加速器。
Ready	重力加速器处于可以处理数据的状态。
Initializing	重力加速器正在初始化。
NoData	未支持重力加速器。
NoPermissions	呼叫者没有权限取用重力加速器接收到的数据。
Disabled	重力加速器处于禁用的状态。

要使用重力加速器判断智能型手机加速的方向，首先您必须使用鼠标的右键点中 [Solution Explorer] 窗口中的项目名称，从出现的菜单选择 [Add Reference] 功能，然后于出现的窗口中选择名称为 Microsoft.Devices.Sensors 的组件，添加引用上去。

下面看一个例子：

using System;
using System.Windows;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Input.Touch;
using Microsoft.Xna.Framework.Media;

using Microsoft.Devices.Sensors;

namespace AccelerometerSample
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
SpriteFont readingsFont;//字体资源
Accelerometer accelerometer;//重力加速器
double X;
double Y;
double Z;

public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";

// Frame rate is 30 fps by default for Windows Phone.
TargetElapsedTime = TimeSpan.FromTicks(333333);

}

/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
//初始化重力加速器
accelerometer = new Accelerometer();
//读取重力改变事件
accelerometer.ReadingChanged += new EventHandler<AccelerometerReadingEventArgs>(AccelerometerReadingChanged);
//开始其中重力加速器
accelerometer.Start();

base.Initialize();
}

/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);

// TODO: use this.Content to load your game content here
//加载字体资源
readingsFont = Content.Load<SpriteFont>("readings");

}

/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
accelerometer.Stop();
}

/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();

// TODO: Add your update logic here

base.Update(gameTime);
}

/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);

// TODO: Add your drawing code here
spriteBatch.Begin();
//绘制文字
spriteBatch.DrawString(readingsFont, "X: " + X.ToString("0.00"), new Vector2(50, 50), Color.White);
spriteBatch.DrawString(readingsFont, "Y: " + Y.ToString("0.00"), new Vector2(50, 75), Color.White);
spriteBatch.DrawString(readingsFont, "Z: " + Z.ToString("0.00"), new Vector2(50, 100), Color.White);
spriteBatch.End();

base.Draw(gameTime);
}

void AccelerometerReadingChanged(object sender, AccelerometerReadingEventArgs e)
{
//触发UI更新
Deployment.Current.Dispatcher.BeginInvoke(() => NewReading(e));
}
//赋值XYZ的值
void NewReading(AccelerometerReadingEventArgs e)
{
X = e.X;
Y = e.Y;
Z = e.Z;
}
}
}

本文链接

XNA游戏：Bizzy Bees蜜蜂警官游戏

2012-04-10T15:20:00Z

先来看一下游戏的界面

游戏的思路差不多像俄罗斯方块一样，上面的花一直往下掉，然后你就需要选中一只蜜蜂来吃上面的花，当蜜蜂的颜色和花的颜色一样或者花是彩色的花的时候，花就会被蜜蜂给吃掉，这时候这只蜜蜂也会被随机生成一只新的蜜蜂。当吃掉一朵彩色的花的时候，会增加一分，当花落到了底下的时候游戏结束。

看一下下面的代码：

花的对象

Flower.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DemoGame
{
class Flower
{
public int Color;//颜色
public float X;//X轴坐标
public float Y;//Y轴坐标

public Flower(int color, float x, float y)
{
this.Color = color;
this.X = x;
this.Y = y;
}
}
}

花的列容器

Column.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;

namespace DemoGame
{
class Column
{
const int columnTop = 150;//列头高度，当花移动出这个高度后将开始新增新花
const int numberOfFlowerColors = 6;//花颜色的数量
const int rainbowFlowerColor = 6; //彩虹花的颜色
const int flowerDeltaY = 80;
const int flowerWidth = 72;//花的宽度
const int flowerHeight = 72;//花的高度
const int columnBottom = 620;//列的高度用来判断花是否移动到底了

private List<Flower> flowers = null;//花的集合
private SpriteBatch spriteBatch;//绘制花
private float x;//花的X轴，X轴的坐标是固定的
private Random r;
private Texture2D flowerMap;//花的纹理

public float Velocity = 0.4f;//速度
/// <summary>
/// 判断是否有花移动到底
/// </summary>
public bool ReachedBottom
{
get
{
if (flowers.Count != 0 && flowers[0].Y >= columnBottom)
return true;
else
return false;
}
}
/// <summary>
/// 初始化一列
/// </summary>
/// <param name="content">当前的ContentManager</param>
/// <param name="spriteBatch">当前的SpriteBatch</param>
/// <param name="x"></param>
/// <param name="seed"></param>
public Column(ContentManager content, SpriteBatch spriteBatch, float x, int seed)
{
this.spriteBatch = spriteBatch;
this.x = x;
this.flowers = new List<Flower>();
this.r = new Random(seed);
this.flowerMap = content.Load<Texture2D>("flowermap");

//初始化添加3朵花
AddRandomFlower(x, columnTop + 2 * flowerDeltaY);
AddRandomFlower(x, columnTop + flowerDeltaY);
AddRandomFlower(x, columnTop);
}
/// <summary>
/// 随机添加一朵花
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
private void AddRandomFlower(float x, int y)
{
int color = r.Next(numberOfFlowerColors+1);
flowers.Add(new Flower(color, x, y));
}
/// <summary>
/// 在spriteBatch中绘制花精灵
/// </summary>
public void Draw()
{
foreach (Flower flower in flowers)
{
spriteBatch.Draw(flowerMap, new Vector2(flower.X, flower.Y), new Rectangle(flower.Color * flowerWidth, 0, flowerWidth, flowerHeight), Color.White);
}
}
/// <summary>
/// 更新列
/// </summary>
public void Update()
{
foreach (Flower f in flowers)
{
f.Y += Velocity;//增加Y轴的偏移量，表示正在向下移动
}
//如果最上面的花已经全部离开顶部，则需要随机生成新的花从上面下来
if (flowers.Count == 0 || flowers[flowers.Count - 1].Y > columnTop)
AddRandomFlower(x, columnTop - flowerDeltaY);
}
/// <summary>
/// 获取最底下的一朵花
/// </summary>
/// <returns></returns>
public Flower GetBottomFlower()
{
if (flowers.Count > 0)
return flowers[0];
else
return null;
}
/// <summary>
/// 移走最底下的一朵花
/// </summary>
internal void RemoveBottomFlower()
{
if (flowers.Count > 0)
flowers.RemoveAt(0);
}
}
}

蜜蜂对象
Bee.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DemoGame
{
class Bee
{
public int Color;//蜜蜂颜色
public bool IsSelected = false;//是否选中

public Bee(int color)
{
this.Color = color;
}
}
}

蜜蜂容器
BeePicker.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;

namespace DemoGame
{
class BeePicker
{
const int beeDeltaX = 96;
const int beeStartX = 5;
const int beeStartY = 700;
const int numberOfBeeColors = 5;//蜜蜂颜色的数量

private List<Bee> bees = null;//蜜蜂集合
private SpriteBatch spriteBatch;
private Texture2D beeMap;
private Random r;

public BeePicker(ContentManager content, SpriteBatch spriteBatch, int seed)
{
beeMap = content.Load<Texture2D>("beemap");
this.spriteBatch = spriteBatch;
bees = new List<Bee>();
r = new Random(seed);

for (int i = 0; i < 5; i++)
{
AddRandomBee();
}

}
/// <summary>
/// 添加一只蜜蜂
/// </summary>
private void AddRandomBee()
{
bees.Add(new Bee(r.Next(numberOfBeeColors + 1)));
}
/// <summary>
/// 绘制蜜蜂
/// </summary>
public void Draw()
{
for (int i = 0; i < 5; i++)
{
if(bees[i].IsSelected)
spriteBatch.Draw(beeMap, new Vector2(beeStartX + i * beeDeltaX, beeStartY), new Rectangle(bees[i].Color * 91, 0, 91, 91), Color.DimGray);
else
spriteBatch.Draw(beeMap, new Vector2(beeStartX + i * beeDeltaX, beeStartY), new Rectangle(bees[i].Color * 91, 0, 91, 91), Color.White);
}
}
/// <summary>
/// 选中一只蜜蜂
/// </summary>
/// <param name="x"></param>
public void MarkSelectedBee(float x)
{
GetSelectedBee(x).IsSelected = true;
}
/// <summary>
/// 获取选中的蜜蜂
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public Bee GetSelectedBee(float x)
{
int index = (int)(x / beeDeltaX);
return bees[index];
}
/// <summary>
/// 移除和替换蜜蜂
/// </summary>
/// <param name="selectedBee"></param>
/// <param name="availableFlowers"></param>
public void RemoveAndReplaceBee(Bee selectedBee, List<int> availableFlowers)
{
int beeIndex = bees.IndexOf(selectedBee);

//check if we already have a bee that matches the available flowers
//remember to skip over the selectedBee since it will be removed in a moment
bool match = false;
int rainbowColor = 6;

//if there is a rainbow flower it will always match
if (availableFlowers.Contains(rainbowColor))
match = true;
else
{
for (int i = 0; i < bees.Count; i++)
{
if(i != beeIndex && availableFlowers.Contains(bees[i].Color)){
match = true;
break;
}
}
}

int color;
if(match){
//we already have a match, just add a random colored bee
color = r.Next(numberOfBeeColors + 1 );
}
else{
//we have no match so we must pick a color from the available colors
color = availableFlowers[r.Next(availableFlowers.Count)];
}

//set the selected bee to the new color to "create" a new bee
bees[beeIndex].Color = color;
}

internal void DeselectAll()
{
foreach (Bee bee in bees)
bee.IsSelected = false;
}
}
}

游戏主程序
Game1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Input.Touch;
using Microsoft.Xna.Framework.Media;

namespace DemoGame
{
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

//纹理
Texture2D backgroundTexture;
Texture2D foregroundTexture;
Texture2D hudTexture;
Texture2D flowerMapTexture;
//分数
int score = 0;
//字体
SpriteFont largeFont;
SpriteFont mediumFont;
SpriteFont smallFont;

List<Column> columns;//列集合
bool gameOver = false;//标记游戏是否结束
BeePicker beePicker = null;//蜜蜂处理类
Bee selectedBee = null;//蜜蜂

public Game1()
{
graphics = new GraphicsDeviceManager(this);
//设置游戏图像的宽和高
graphics.PreferredBackBufferHeight = 800;
graphics.PreferredBackBufferWidth = 480;

Content.RootDirectory = "Content";

// Frame rate is 30 fps by default for Windows Phone.
TargetElapsedTime = TimeSpan.FromTicks(333333);

// Extend battery life under lock.
InactiveSleepTime = TimeSpan.FromSeconds(1);
}
/// <summary>
/// 初始化
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
//添加触摸事件
TouchPanel.EnabledGestures = GestureType.Tap;

base.Initialize();
}
/// <summary>
/// 加载资源
/// </summary>
protected override void LoadContent()
{
//创建一个新的SpriteBatch用来绘制纹理
spriteBatch = new SpriteBatch(GraphicsDevice);
//加载纹理
backgroundTexture = Content.Load<Texture2D>("GameScreenBackground");
foregroundTexture = Content.Load<Texture2D>("GameScreenForeground");
hudTexture = Content.Load<Texture2D>("HUDBackground");
flowerMapTexture = Content.Load<Texture2D>("flowermap");
//加载字体资源
largeFont = Content.Load<SpriteFont>("LargeMenuFont");
mediumFont = Content.Load<SpriteFont>("MediumMenuFont");
smallFont = Content.Load<SpriteFont>("SmallMenuFont");
//初始化列
InitializeColumns();
beePicker = new BeePicker(Content, spriteBatch, System.DateTime.Now.Millisecond);
}
/// <summary>
/// 初始化列
/// </summary>
private void InitializeColumns()
{
columns = new List<Column>();

int seed = System.DateTime.Now.Millisecond;
//初始化6列
for (int i = 0; i < 5; i++)
{
columns.Add(new Column(Content, spriteBatch, i * 92 + 22, seed + i));
}
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}

/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// 退出游戏
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();

// 添加更新的逻辑
if (!gameOver)
{
//处理用户的操作
while (TouchPanel.IsGestureAvailable)//是否触摸到屏幕
{
GestureSample gesture = TouchPanel.ReadGesture();//获取手势
if (gesture.GestureType == GestureType.Tap)//点击操作
{
HandleInput(gesture.Position);//传入点击的位置，处理点击操作
}
}
//更新花的状态，即不停地往下移动
foreach (Column c in columns)
{
c.Update();
if (c.ReachedBottom)//花到达底部，游戏结束
{
gameOver = true;
break;
}
}
}

base.Update(gameTime);
}
/// <summary>
/// 点击输入操作处理
/// </summary>
/// <param name="position"></param>
private void HandleInput(Vector2 position)
{
if (position.X > 0 && position.X < 480 && position.Y > 700 && position.Y < 800)//点种了蜜蜂的位置
HandleBeeSelection(position.X);
else if (selectedBee != null)//选中了蜜蜂
HandleFlowerSelection(position.X, position.Y);
}
/// <summary>
/// 处理选中花的操作
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
private void HandleFlowerSelection(float x, float y)
{
//判断是否点中了列的位置
if (x > 10 && x < 470 && y > 100 && y < 700)
{
int rainbowColor = 6;
int selectedColumnIndex = (int)((x - 10) / 92);
//获取点中的列
Column selectedColumn = columns[selectedColumnIndex];
//获取点中的列底部的花
Flower selectedFlower = selectedColumn.GetBottomFlower();

//判断是否点中了底部的花，并且花的颜色和蜜蜂的颜色要相等，或者花是彩色的花
if(selectedFlower != null && (selectedFlower.Color == selectedBee.Color || selectedFlower.Color == rainbowColor))
{
//移除花
selectedColumn.RemoveBottomFlower();
//替换另外一只蜜蜂，并且要保证至少要有一只蜜蜂可以和最底层的花可以匹配得上
List<int> availableFlowers = GetAvailableFlowers();
beePicker.RemoveAndReplaceBee(selectedBee, availableFlowers);

//取消对蜜蜂的选中状态
beePicker.DeselectAll();
selectedBee = null;//设置选中的蜜蜂为null

//如果蜜蜂吃掉的是彩色的花则增加一分
if (selectedFlower.Color == rainbowColor)
{
score++;
//如果分数达到10, 20, 30... 则不断地增加花下落的Y轴偏移量速度
if ((score % 10) == 0)
{
foreach (Column c in columns)
c.Velocity += 0.1f;
}
}
}
}
}
/// <summary>
/// 获取最底下花的颜色，用来作为随机生成蜜蜂的一个条件
/// </summary>
/// <returns></returns>
private List<int> GetAvailableFlowers()
{
List<int> flowerColors = new List<int>();
foreach (Column c in columns)
{
Flower f = c.GetBottomFlower();
if (f != null)
flowerColors.Add(f.Color);
}
return flowerColors;
}
/// <summary>
/// 处理选中蜜蜂操作
/// </summary>
/// <param name="x"></param>
private void HandleBeeSelection(float x)
{
//first de-select any previously selected bee
if (selectedBee != null)
{
selectedBee.IsSelected = false;
selectedBee = null;
}
//Mark and select the new bee
beePicker.MarkSelectedBee(x);
selectedBee = beePicker.GetSelectedBee(x);
}

/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);

spriteBatch.Begin();
//画游戏背景
spriteBatch.Draw(backgroundTexture, Vector2.Zero, Color.White);
//判断游戏是否结束
if (!gameOver)
{
//绘制花精灵
foreach (Column c in columns)
c.Draw();
//绘制蜜蜂精灵
beePicker.Draw();
}
else
{
spriteBatch.DrawString(largeFont, "GAME OVER", new Vector2(150, 400), Color.Red);
}

spriteBatch.Draw(foregroundTexture, Vector2.Zero, Color.White);
DrawHUD();
spriteBatch.End();

base.Draw(gameTime);
}
/// <summary>
/// 初始化屏幕
/// </summary>
private void DrawHUD()
{
spriteBatch.Draw(hudTexture, new Vector2(7, 7), Color.White);
//Print out game score and level
spriteBatch.DrawString(mediumFont, "Marathon", new Vector2(40, 10), Color.Blue);
spriteBatch.DrawString(largeFont, score.ToString(), new Vector2(127, 45), Color.Yellow);
//TODO: Draw a flower on the HUD
spriteBatch.Draw(flowerMapTexture, new Vector2(40, 45), new Rectangle(6*72, 0, 72, 72), Color.White, 0, Vector2.Zero, 0.5f, SpriteEffects.None, 0f);
//Print out instructions
spriteBatch.DrawString(smallFont, "Match flowers and bees", new Vector2(210, 10), Color.Yellow);
spriteBatch.DrawString(smallFont, "Rainbow flowers match", new Vector2(206, 30), Color.Yellow);
spriteBatch.DrawString(smallFont, "with all bees", new Vector2(260, 50), Color.Yellow);
//Print out goal message
spriteBatch.DrawString(largeFont, "Collect Rainbow Flowers", new Vector2(50, 115), Color.Blue);
}
}
}

游戏的项目结构

参考文章：

http://blogs.msdn.com/b/tess/archive/2012/03/02/xna-for-windows-phone-walkthrough-creating-the-bizzy-bees-game.aspx

本文链接

Windows Phone 7 框架和页面

2012-03-28T16:20:00Z

一、Windows Phone 7 框架(PhoneApplicationFrame)和页面(PhoneApplicationPage)

在一个wp7应用程序运行的时候，程序的整个UI架构会由会有一个PhoneApplicationFrame和一个或者多个PhoneApplicationPage组成。PhoneApplicationFrame是一个顶级容器，里面容纳了PhoneApplicationPage，一个程序里面只有一个PhoneApplicationFrame，我们在App.xaml.cs里面看到的RootFrame就是当前程序的框架了。

下面的方法会对RootFrame完成初始化操作

private void InitializePhoneApplication()
{
if (phoneApplicationInitialized)
return;
RootFrame = new PhoneApplicationFrame();
RootFrame.Navigated += CompleteInitializePhoneApplication;
RootFrame.NavigationFailed += RootFrame_NavigationFailed;
phoneApplicationInitialized = true;
}

private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
{
if (RootVisual != RootFrame)
RootVisual = RootFrame;
RootFrame.Navigated -= CompleteInitializePhoneApplication;
}

关于(PhoneApplicationFrame)和(PhoneApplicationPage)的关系可以用下面的一张图来表示

二、页面(PhoneApplicationPage)的导航

wp7页面的互相跳转的逻辑是用一个堆栈结构的容器来管理这些页面。如下图

当应用程序中的页面调用 Navigate 时，当前页面会被放到后退堆栈上，并且系统将创建并显示目标页的新实例。当你在应用程序的页面之间进行导航时，系统会将多个条目添加到此堆栈。当页面调用 GoBack 时，或者当用户按手机的“返回”按键时，将放弃当前页面，并将堆栈顶部的页面从后退堆栈中弹出并进行显示。此后退导航会继续弹出并显示，直到堆栈中不再有条目。此时，点按手机的“返回”按键将终止应用程序。

这个堆栈容器我们是可以通过PhoneApplicationPage出操控的，操控的相关方法和属性如下：

属性
BackStack 获取一个 IEnumerable，它用于枚举后退导航历史记录中的条目。
CanGoBack 获取一个值，该值指示在后退导航历史记录中是否至少存在一个条目。

CanGoForward 获取一个值，该值指示在前进导航历史记录中是否至少存在一个条目。

方法

GoBack 导航到后退导航历史记录中的最新条目；如果后退导航时没有条目，则引发异常。

GoForward 导航到前进导航历史记录中的最新条目，如果前进导航时没有条目，则引发异常。对于Windows Phone，该方法始终引发异常，因为没有前进导航堆栈。（从 Frame 继承。）
RemoveBackEntry 此方法用于从后退堆栈中移除最近的条目，如果没有要移除的条目，则引发InvalidOperationException。如果您想移除多个项目，则多次调用此方法。此 API 是同步的，因此必须从UI 线程调用。

事件
Navigated 当已找到导航的内容并且内容可用时发生。（从 Frame 继承。）
Navigating 当请求新的导航时发生。（从 Frame 继承。）
NavigationFailed 在导航到请求的内容过程中遇到错误时发生。（从 Frame 继承。）
NavigationStopped 在通过调用 StopLoading()()()() 方法终止导航时发生，或者在当前导航进行过程中请求新的导航时发生。（从 Frame 继承。）
Obscured 当 shell chrome 包含帧时发生。
OrientationChanged 当 Orientation 属性发生更改时发生。

三。下面用跟一个Demo来显示一下获取程序的框架(PhoneApplicationFrame)和页面(PhoneApplicationPage)

扩展方法类

Extensions.cs

using System.Windows;
using System.Windows.Media;
using System.Collections.Generic;
using System.Linq;

namespace PageDemo
{
public static class Extensions
{
/// <summary>
/// 获取该元素的可见树里面所有的子元素
/// </summary>
/// <param name="element">可见元素</param>
public static IEnumerable<DependencyObject> GetVisualDescendants(this DependencyObject element)
{
return GetVisualDescendantsAndSelfIterator(element).Skip(1);
}
/// <summary>
/// 获取该元素的可见树里面所有的子元素以及该元素本身
/// </summary>
/// <param name="element">可见元素</param>
public static IEnumerable<DependencyObject> GetVisualDescendantsAndSelfIterator(DependencyObject element)
{
Queue<DependencyObject> remaining = new Queue<DependencyObject>();
remaining.Enqueue(element);

while (remaining.Count > 0)
{
DependencyObject obj = remaining.Dequeue();
yield return obj;

foreach (DependencyObject child in obj.GetVisualChildren())
{
remaining.Enqueue(child);
}
}
}
/// <summary>
/// 获取该元素的可见树里面下一级的子元素
/// </summary>
/// <param name="element">可见元素</param>
public static IEnumerable<DependencyObject> GetVisualChildren(this DependencyObject element)
{
return GetVisualChildrenAndSelfIterator(element).Skip(1);
}
/// <summary>
/// 获取该元素的可见树里面下一级的子元素以及该元素本身
/// </summary>
/// <param name="element">可见元素</param>
public static IEnumerable<DependencyObject> GetVisualChildrenAndSelfIterator(this DependencyObject element)
{
yield return element;

int count = VisualTreeHelper.GetChildrenCount(element);
for (int i = 0; i < count; i++)
{
yield return VisualTreeHelper.GetChild(element, i);
}
}
}
}

测试获取程序页面类

Test.cs

using System.Windows;
using Microsoft.Phone.Controls;
using System.Linq;
using System.Collections.Generic;

namespace PageDemo
{
public class Test
{
/// <summary>
/// 获取当前的程序展示的页面
/// </summary>
public static PhoneApplicationPage Page
{
get { return (Application.Current.RootVisual as PhoneApplicationFrame).GetVisualDescendants().OfType<PhoneApplicationPage>().FirstOrDefault(); }
}
/// <summary>
/// 获取所有的框架下的页面
/// </summary>
public static List<PhoneApplicationPage> Pages
{
get { return (Application.Current.RootVisual as PhoneApplicationFrame).GetVisualDescendants().OfType<PhoneApplicationPage>().ToList<PhoneApplicationPage>(); }
}
/// <summary>
/// 获取程序所有的UI元素
/// </summary>
public static List<DependencyObject> Elements
{
get { return (Application.Current.RootVisual as PhoneApplicationFrame).GetVisualDescendants().ToList<DependencyObject>(); }
}
}
}

private void button1_Click(object sender, RoutedEventArgs e)
{
if (Test.Page != null)
{
MessageBox.Show(Test.Page.ToString());
}
}

单击的效果

欢迎购买我的书籍《深入浅出Windows Phone 7应用开发》感谢大家的支持！！

http://product.dangdang.com/product.aspx?product_id=22624989

本文链接

Windows Phone 7 自定义事件

2012-03-26T15:41:00Z

在Windows Phone的应用开发里面，对于事件这种东西我们可以随处可见，系统本来就已经封装好了各种各样的事件机制，如按钮的单击事件等等的。在实际的开发中，我们需要自己去给相关的类自定义一些事件来满足业务的要求，特别在使用观察着模式的时候，在wp7中利用事件去实现是理所当然的。

自定义事件步骤有下面的几个步骤：

1、继承EventArgs类实现自己自定义的事件参数；

2、定义一个委托；

3、定义一个事件

4、添加事件。

下面来看一下一个Demo对自定义事件的实现，这个Demo只是对网络请求的状态进行一个简单的事件监控的调用处理：

自定义的事件参数类

StateChangedEventArgs.cs

using System;

namespace EventDemo
{
/// <summary>
/// 状态事件
/// </summary>
public class StateChangedEventArgs : EventArgs
{
public readonly string NewState;
public readonly DateTime Timestamp;

public StateChangedEventArgs(string newstate)
{
this.NewState = newstate;
this.Timestamp = DateTime.Now;
}
}
}

在业务类里面定义事件：

NetTask.cs

using System;
using System.Net;
using System.Threading;
using System.IO;

namespace EventDemo
{
public class NetTask
{
//定义委托
public delegate void StateChanged(NetTask sender, StateChangedEventArgs args);
//定义事件
public event StateChanged OnStateChanged;
//出事状态
public string NetTaskName = "";

/// <summary>
/// 网络任务
/// </summary>
/// <param name="url"></param>
public void StartNetTask(string url)
{
bool success = false;
int attempt = 0;
while (attempt < 3)
{
AsyncCallback callback = null;
//开启线程等待
ManualResetEvent webRequestWait = new ManualResetEvent(false);
Uri targetUri = new Uri(url);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(targetUri);
request.Method = "POST";
if (callback == null)
{
callback = delegate(IAsyncResult asRequest)
{
try
{
success = true;
webRequestWait.Set();
//……
}
catch
{
OnStateChanged(this, new StateChangedEventArgs("重试"));
webRequestWait.Set();
}
};
}
request.BeginGetRequestStream(callback, request);

//等待线程结束
webRequestWait.WaitOne();
if (success)
{
break;
}
attempt++;
Thread.Sleep(1000);
}
if (success)
{
OnStateChanged(this, new StateChangedEventArgs("成功"));
Thread.Sleep(50);
}
else
{
OnStateChanged(this, new StateChangedEventArgs("失败"));
}
}
}
}

简单的测试一下

MainPage.xaml.cs

using System.Windows;
using Microsoft.Phone.Controls;

namespace EventDemo
{
public partial class MainPage : PhoneApplicationPage
{
public MainPage()
{
InitializeComponent();
}

private void button1_Click(object sender, RoutedEventArgs e)
{
NetTask netTask = new NetTask();
netTask.OnStateChanged += OnStateChanged;
netTask.NetTaskName = "测试网络";
netTask.StartNetTask("http://www.cnblogs.com");
}

public void OnStateChanged(object sender, StateChangedEventArgs e)
{
NetTask temp = sender as NetTask;
textBlock2.Text = temp.NetTaskName + "," + e.NewState+","+e.Timestamp.ToLongTimeString();
}
}
}

运行的效果如下：

欢迎购买我的书籍《深入浅出Windows Phone 7应用开发》感谢大家的支持！！

http://product.dangdang.com/product.aspx?product_id=22624989

本文链接

Windows Phone 7 LongListSelector控件实现分类列表和字母索引

2012-03-24T12:51:00Z

在wp7手机里面的联系人列表和程序里面里面我们可以看到一个根据字母索引来定位联系人或者应用程序的控件，那么这个控件就是LongListSelector控件了。

LongListSelector是一种比ListBox更加强大的列表控件，你可以根据你列表的信息来分类排列，根据类别快速定位到你选中的类别的列表下，在数据量很大的情况下这种分类的优势很明显。LongListSelector可以自定义列表头，列表尾、类表头、列别尾等的样式和数据，可以实现各种个性化的列表样式和不同的数据的展现方式。Windows Phone 7手机的联系人列表就是基于LongListSelector控件设计的。LongListSelector控件的常用属性和常用事件分别如表12.6和表12.7所示。

表12.6 LongListSelector控件常用属性

名称	说明
DisplayAllGroups	bool类型的属性，当值为true时，它显示所有的分组无论该组中是否有选项或者数据，默认值为false。
GroupFooterTemplate	DataTemplate类型的属性，它是负责绑定每个组的底部的数据和样式的模板。
GroupHeaderTemplate	DataTemplate类型的属性，它是负责绑定每个组的顶部的数据和样式的模板。
GroupItemsPanel	ItemsPanelTemplate类型的属性，设置组的内部的Panel面板的内容。
GroupItemTemplate	DataTemplate类型的属性，它是负责绑定每个组里面的元素的数据和样式的模板。
ItemTemplate	DataTemplate类型的属性，它是负责绑定所有选项或者元素的数据和样式的模板。
ListFooterTemplate	DataTemplate类型的属性，它是负责绑定整个List底部的数据和样式的模板。
ListHeaderTemplate	DataTemplate类型的属性，它是负责绑定整个List顶部的数据和样式的模板。
SelectedItem	获取或者设置选中的选项
ShowListFooter	bool类型的属性，是否显示列脚，默认值为true。
ShowListHeader	bool类型的属性，是否显示列头，默认值为true。

表12.7 LongListSelector控件常用事件

名称	说明
Link	当查找的内容被找到时，触发的事件。用法示例： selector.Link += new EventHandler<LinkUnlinkEventArgs>(selector_Link); void selector_Link(object sender, LinkUnlinkEventArgs e) {...}
Unlink	查找的内容没有被找到时，触发的事件。用法示例: selector.Unlink += new EventHandler<LinkUnlinkEventArgs>(selector_Unlink); void selector_Unlink(object sender, LinkUnlinkEventArgs e) {... }
SelectionChanged	选择的选项改变时触发的事件。用法示例: selector.SelectionChanged += new SelectionChangedEventHandler(selector_SelectionChanged); void selector_SelectionChanged(object sender, SelectionChangedEventArgs e) {... }
ScrollingCompleted	当列表滚动结束的时候触发的事件。用法示例: selector.ScrollingCompleted += new EventHandler(selector_ScrollingCompleted); void selector_ScrollingCompleted(object sender, EventArgs e) {...}
ScrollingStarted	当列表滚动开始的时候触发的事件。用法示例: selector.ScrollingStarted += new EventHandler(selector_ScrollingStarted); void selector_ScrollingStarted(object sender, EventArgs e){...}

下面给出列表选择框的示例：演示如何使用LongListSelector控件进行列表信息分类。

代码清单12-6：列表选择框（源代码：第12章\Examples_12_6）

MainPage.xaml文件主要代码

<phone:PhoneApplicationPage.Resources>
<!—定义组头绑定模板-->
<DataTemplate x:Key="GroupHeader">
<Border Background="{StaticResource PhoneAccentBrush}" Margin="{StaticResource PhoneTouchTargetOverhang}" Padding="{StaticResource PhoneTouchTargetOverhang}">
<TextBlock Text="{Binding Key}"/>
</Border>
</DataTemplate>
<!—定义组选项绑定模板-->
<DataTemplate x:Key="GroupItem">
<Border Background="{StaticResource PhoneAccentBrush}" Margin="{StaticResource PhoneTouchTargetOverhang}" Padding="{StaticResource PhoneTouchTargetOverhang}">
<TextBlock Text="{Binding Key}" Style="{StaticResource PhoneTextLargeStyle}"/>
</Border>
</DataTemplate>
<!—定义列头绑定模板-->
<DataTemplate x:Key="ListHeader">
<TextBlock Text="Header" Style="{StaticResource PhoneTextTitle1Style}"/>
</DataTemplate>
<!—定义列表选项绑定模板-->
<DataTemplate x:Key="ItemTmpl">
<Grid>
<TextBlock Text="{Binding Title}"></TextBlock>
</Grid>
</DataTemplate>
</phone:PhoneApplicationPage.Resources>
……

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
<toolkit:LongListSelector x:Name="LongList" Background="Transparent"
ItemTemplate="{StaticResource ItemTmpl}"
ListHeaderTemplate="{StaticResource ListHeader}"
GroupHeaderTemplate="{StaticResource GroupHeader}"
GroupItemTemplate="{StaticResource GroupItem}" >
</toolkit:LongListSelector>
</Grid>
</Grid>
</phone:PhoneApplicationPage>

MainPage.xaml.cs文件代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Phone.Controls;
namespace LongListSelectorDemo
{
public partial class MainPage : PhoneApplicationPage
{
public MainPage()
{
InitializeComponent();
//使用List<T>来初始化数据
List<Item> mainItem = new List<Item>();
for (int i = 0; i < 10; i++)
{
mainItem.Add(new Item() { Content = "A类别", Title = "测试A " + i.ToString() });
mainItem.Add(new Item() { Content = "B类别", Title = "测试B" + i.ToString() });
mainItem.Add(new Item() { Content = "C类别", Title = "测试C" + i.ToString() });
}
//使用Linq来查询List<Item>数据按照Content来进行分组
var selected = from c in mainItem group c by c.Content into n select new GroupingLayer<string, Item>(n);
this.LongList.ItemsSource = selected;
}
//继承Linq的IGrouping接口来存储分组的数据
public class GroupingLayer<TKey, TElement> : IGrouping<TKey, TElement>
{
//分组数据
private readonly IGrouping<TKey, TElement> grouping;
//初始化
public GroupingLayer(IGrouping<TKey, TElement> unit)
{
grouping = unit;
}
//唯一的键值
public TKey Key
{
get { return grouping.Key; }
}
//重载判断相等方法
public override bool Equals(object obj)
{
GroupingLayer<TKey, TElement> that = obj as GroupingLayer<TKey, TElement>;
return (that != null) && (this.Key.Equals(that.Key));
}
public IEnumerator<TElement> GetEnumerator()
{
return grouping.GetEnumerator();
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return grouping.GetEnumerator();
}
}
//List选项的类 Content表示类别 Title表示选项的标题
public class Item
{
public string Title { get; set; }
public string Content { get; set; }
}
}
}

下面再来看看第二例子，实现LongListSelector控件的字母索引。

Item.cs

namespace LongListSelectorDemo
{
/// <summary>
/// 选项实体类
/// </summary>
public class Item
{
public string Name { get; set; }
public string Content { get; set; }
//获取名字的首个字符用来作为分组的依据
public static string GetFirstNameKey(Item item)
{
char key;
key = char.ToLower(item.Name[0]);
if (key < 'a' || key > 'z')
{
key = '#';
}
return key.ToString();
}
}
}

ItemInGroup.cs

using System.Collections.Generic;

namespace LongListSelectorDemo
{
/// <summary>
/// 组集合
/// </summary>
public class ItemInGroup: List<Item>
{
public ItemInGroup(string category)
{
Key = category;
}
//组的键
public string Key { get; set; }
//组是否有选项
public bool HasItems { get { return Count > 0; } }
}
}

Items.cs

using System.Collections.Generic;

namespace LongListSelectorDemo
{
/// <summary>
/// 总数据集合
/// </summary>
public class Items: List<ItemInGroup>
{
//索引
private static readonly string Groups = "#|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z";

public Items()
{
//获取要绑定的数据源
List<Item> items = new List<Item>();
items.Add(new Item { Name = "a测试", Content = "a内容" });
items.Add(new Item { Name = "b测试", Content = "b内容" });
items.Add(new Item { Name = "c测试", Content = "c内容" });
items.Add(new Item { Name = "d测试", Content = "d内容" });
items.Add(new Item { Name = "e测试", Content = "e内容" });
items.Add(new Item { Name = "f测试", Content = "f内容" });
items.Add(new Item { Name = "g测试", Content = "g内容" });
//组的字典列表
Dictionary<string, ItemInGroup> groups = new Dictionary<string, ItemInGroup>();

//初始化组列表，即用字母列表来分组
foreach (string c in Groups.Split('|'))
{
ItemInGroup group = new ItemInGroup(c.ToString());
//添加组数据到集合
this.Add(group);
groups[c.ToString()] = group;
}

//初始化选项列表，即按照选项所属的组来放进它属于的组里面
foreach (Item item in items)
{
//添加选项数据到集合
groups[Item.GetFirstNameKey(item)].Add(item);
}
}
}
}

MainPage.xaml

MainPage.xaml.cs

using Microsoft.Phone.Controls;

namespace LongListSelectorDemo
{
public partial class MainPage : PhoneApplicationPage
{
// Constructor
public MainPage()
{
InitializeComponent();
longListSelector.ItemsSource = new Items();
}
}
}

运行的效果如下：

欢迎购买我的书籍《深入浅出Windows Phone 7应用开发》感谢大家的支持！！

http://product.dangdang.com/product.aspx?product_id=22624989

本文链接

Windows Phone7 VS iPhone&Android 平台优劣势邀您参与PK [送书活动以及样章阅读]

2012-03-23T11:10:00Z

活动地址：http://bbs.chinaunix.net/thread-3688019-1-1.html

本文链接