• R/O
  • SSH
  • HTTPS

nlgp1: Commit


Commit MetaInfo

Revision737 (tree)
Zeit2011-02-21 23:08:57
Autorbiikame

Log Message

Nlgp1.Sprites.SpriteActionを修正

Ändern Zusammenfassung

Diff

--- trunk/Nlgp1/Nlgp1/Characters/Character.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Characters/Character.cs (revision 737)
@@ -11,8 +11,8 @@
1111 /// キャラクタクラス
1212 /// </summary>
1313 public class Character : Sprite {
14- public Character( int typeID , SpriteType spriteType , Size characterSize , Vec2 location )
15- : base( LayerType.Character , typeID , spriteType , "CharacterImages" , characterSize , string.Format( "Character-{0}" , typeID ) , location )
14+ public Character( int typeID , SpriteType spriteType , Size characterSize , Vec2 position )
15+ : base( LayerType.Character , typeID , spriteType , "CharacterImages" , characterSize , string.Format( "Character-{0}" , typeID ) , position )
1616 {
1717 }
1818
--- trunk/Nlgp1/Nlgp1/Characters/SpriteFactory.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Characters/SpriteFactory.cs (revision 737)
@@ -11,190 +11,174 @@
1111
1212 namespace Nlgp1.Characters {
1313 public static class SpriteFactory {
14- private static Sprite create( int typeID , Vec2 location , Size characterSize ){
15- var newSprite = new Character( typeID , SpriteType.Monster , characterSize , location );
16- newSprite.Bound.BlankLeft = 2;
17- newSprite.Bound.BlankRight = 2;
18- newSprite.Bound.BlankTop = 0;
19- newSprite.Bound.BlankBottom = 2;
20- return newSprite;
14+ private static Sprite create( int typeID , Vec2 position , Size characterSize ){
15+ var sprite = new Character( typeID , SpriteType.Monster , characterSize , position );
16+ sprite.Rectangle.BlankLeft = 2;
17+ sprite.Rectangle.BlankRight = 2;
18+ sprite.Rectangle.BlankTop = 0;
19+ sprite.Rectangle.BlankBottom = 2;
20+ return sprite;
2121 }
2222 /// <summary>
2323 /// キャラクタを生成してマップ上に配置します。
2424 /// </summary>
2525 /// <param name="typeId">生成するスプライトを表すID</param>
26- /// <param name="location">初期位置</param>
26+ /// <param name="position">初期位置</param>
2727 /// <param name="characterSize">スプライトのサイズ</param>
2828 /// <returns>生成されたキャラクタオブジェクト</returns>
29- public static Sprite CreateSprite( int typeID , Vec2 location , Size characterSize ) {
30- Sprite newSprite = create( typeID , location , characterSize );
29+ public static Sprite CreateSprite( int typeID , Vec2 position , Size characterSize ) {
30+ var sprite = create( typeID , position , characterSize );
3131 switch( typeID ) {
32- case 2:
33- break;
34- case 4:
35- #region ゆっくりと左に歩いてくる
36- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
37- e.Target.Speed.X = -0.01f;
38- } );
39- #endregion
40- break;
41- case 5:
42- #region ゆっくりと右に歩いてくる
43- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
44- e.Target.Speed.X = +0.01f;
45- } );
46- #endregion
47- break;
48- case 6:
49- #region ジャンプしながら左に向かってくる
32+ case 2:
33+ break;
34+ case 4:
35+ #region ゆっくりと左に歩いてくる
36+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
37+ e.Sprite.Speed.X = -0.01f;
38+ } );
39+ #endregion
40+ break;
41+ case 5:
42+ #region ゆっくりと右に歩いてくる
43+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
44+ e.Sprite.Speed.X = +0.01f;
45+ } );
46+ #endregion
47+ break;
48+ case 6:
49+ #region ジャンプしながら左に向かってくる
5050
51- newSprite.Speed.MaxY = 4;
52- newSprite.JumpPower = 4;
53- newSprite.UpGravity = 0.05f;
54- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
55- e.Target.Speed.X = -0.01f;
56- e.Target.StartJump();
57- } );
58- #endregion
59- break;
60- case 7:
61- #region ジャンプしながら右に向かってくる
62- newSprite.Speed.MaxY = 4;
63- newSprite.JumpPower = 4;
64- newSprite.UpGravity = 0.05f;
65- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
66- e.Target.Speed.X = 0.01f;
67- e.Target.StartJump();
68- } );
69- #endregion
70- break;
71- case 8:
72- #region 壁にぶつかったら方向転換して左右に移動する
73- // newSprite = new Character( typeID , SpriteAttributes.Monster , new Size( 256 , 32 ) );
74- // newSprite.GetRectangle.CellX = cellX; // キャラクタの X 軸のセル座標を指定します。
75- // newSprite.GetRectangle.CellY = cellY; // キャラクタの Y 軸のセル座標を指定します。
76- // newSprite.GetRectangle.PrevReset();
77- // newSprite.LogicParameter.InitX = cellX * MapData.CellSize;
78- // newSprite.LogicParameter.InitY = cellY * MapData.CellSize;
79- newSprite.Speed.X = 1;
80- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
81- if( e.Target.ImmediateSpritesAreBlock( DirectionFlags.Right ) ) {
82- e.Target.Speed.X = -0.3f;
83- } else if( e.Target.ImmediateSpritesAreBlock( DirectionFlags.Left ) ) {
84- e.Target.Speed.X = 0.3f;
51+ sprite.Speed.MaxY = 4;
52+ sprite.JumpPower = 4;
53+ sprite.UpGravity = 0.05f;
54+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
55+ e.Sprite.Speed.X = -0.01f;
56+ e.Sprite.StartJump();
57+ } );
58+ #endregion
59+ break;
60+ case 7:
61+ #region ジャンプしながら右に向かってくる
62+ sprite.Speed.MaxY = 4;
63+ sprite.JumpPower = 4;
64+ sprite.UpGravity = 0.05f;
65+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
66+ e.Sprite.Speed.X = 0.01f;
67+ e.Sprite.StartJump();
68+ } );
69+ #endregion
70+ break;
71+ case 8:
72+ #region 壁にぶつかったら方向転換して左右に移動する
73+ // newSprite = new Character( typeID , SpriteAttributes.Monster , new Size( 256 , 32 ) );
74+ // newSprite.GetRectangle.CellX = cellX; // キャラクタの X 軸のセル座標を指定します。
75+ // newSprite.GetRectangle.CellY = cellY; // キャラクタの Y 軸のセル座標を指定します。
76+ // newSprite.GetRectangle.PrevReset();
77+ // newSprite.LogicParameter.InitX = cellX * MapData.CellSize;
78+ // newSprite.LogicParameter.InitY = cellY * MapData.CellSize;
79+ sprite.Speed.X = 1;
80+ sprite.Rectangle.Hitted += ( sender , e ) => {
81+ if( e.Direction == Direction.Right ) {
82+ e.Target.Sprite.Speed.X = -0.3f;
83+ }
84+ else if( e.Direction == Direction.Left ) {
85+ e.Target.Sprite.Speed.X = 0.3f;
86+ }
87+ };
88+ #endregion
89+ break;
90+ case 9:
91+ #region 床から落下しないように左右に移動する。
92+ sprite.Rectangle.Acted += ( sender , e ) => {
93+ bool hitsLower = false;
94+ bool hitsUpper = true;
95+ foreach( SpriteRectangleTarget hittedResult in e.Targets ) {
96+ if( hittedResult.Direction == Direction.Bottom ) {
97+ if( hittedResult.Lower <= 0 ) {
98+ hitsLower = true;
99+ }
100+ if( hittedResult.Upper >= 0 ) {
101+ hitsUpper = true;
102+ }
85103 }
86- } );
87- #endregion
88- break;
89- case 9:
90- #region 床から落下しないように左右に移動する。
91- newSprite.ActionCellCount = 2;
92- newSprite.LogicParameter.Universal["reverse"] = false;
93- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
94- if( e.Target.ImmediateSpritesAreBlock( DirectionFlags.Left | DirectionFlags.Bottom ) ) {
95- e.Target.Speed.X = -0.05f;
96- } else {
97- e.Target.LogicParameter.Universal["reverse"] = true;
104+ if( !hitsLower ) {
105+ e.Source.Sprite.Speed.X = -0.05f;
98106 }
99- if( (bool)e.Target.LogicParameter.Universal["reverse"] && e.Target.ImmediateSpritesAreBlock( DirectionFlags.Right | DirectionFlags.Bottom ) ) {
100- e.Target.Speed.X = 0.05f;
101- } else {
102- e.Target.LogicParameter.Universal["reverse"] = false;
107+ else if( !hitsUpper ) {
108+ e.Source.Sprite.Speed.X = +0.05f;
103109 }
104- } );
105- #endregion
106- break;
107- case 10:
108- #region 上下に浮遊する
109- // newSprite.CanDefaultAction = false;
110- newSprite.LogicParameter.Radius = 50;   // 半径
111- newSprite.LogicParameter.Angle = 90; // 角度
112- newSprite.LogicParameter.Speed = 1; // 速度
113- newSprite.LogicParameter.LimitDistance = 100;// 移動距離
114- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
115- SpriteAction.GivenDirection( e.Target , e.Target.LogicParameter.InitX , e.Target.LogicParameter.InitY );
116- } );
117- #endregion
118- break;
119- case 11:
120- #region 時計回り
121- newSprite.CanActDefault = false; // 既定の重力計算などを無効にする。
122- newSprite.LogicParameter.Radius = 100; // 半径
123- newSprite.LogicParameter.Speed = 8; // 回転速度
124- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
125- SpriteAction.Rotation( e.Target , e.Target.LogicParameter.InitX , e.Target.LogicParameter.InitY , true );
126- } );
127- #endregion
128- break;
129- case 12:
130- #region 反時計回り
131- newSprite.IsBlock = false;
132- newSprite.LogicParameter.Speed = 2;
133- newSprite.LogicParameter.Radius = 100;
134- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
135- // SpriteAction.HitStop( PlayerStatus.Player , e.Target );
136- SpriteAction.Rotation( e.Target , e.Target.LogicParameter.InitX , e.Target.LogicParameter.InitY , false );
137- } );
138- #endregion
139- break;
140- case 13:
141- #region 空中を回転しながら浮遊する
142- newSprite.LogicParameter.LimitDistance = 150; // 移動距離
143- newSprite.LogicParameter.Speed = 2; // 上下に移動するときの速度
144- newSprite.LogicParameter.Angle = 90; // 移動する方向。90度 = 上下方向。45度 = 斜めなど。
145- newSprite.CanActDefault = false;
146- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
147- SpriteAction.GivenDirection( e.Target , e.Target.LogicParameter.InitX , e.Target.LogicParameter.InitY );
148- newSprite.LogicParameter.Angle++;
149- } );
150- #endregion
151- break;
152- case 14:
153- #region 10秒アイテム
154- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
155- if( e.Target.Bound.HitTest( PlayerStatus.Player.Bound ) ) {
156- PlayerStatus.TimerInitialize();
157- e.Target.Dispose();
158- }
159- } );
160- #endregion
161- break;
162- case 15:
163- #region 乗ると強制的に右に移動する
164- newSprite.CanActDefault = false;
165- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
166- if( SpriteAction.HitDirection( PlayerStatus.Player , e.Target ) == DirectionType.Top ) {
167- SpriteAction.Physisorption( PlayerStatus.Player , e.Target , DirectionType.Top );
168- if( e.Target.LogicParameter.Count >= 6 ) {
169- PlayerStatus.Player.TryMove( PlayerStatus.Player.Bound.Width + PlayerStatus.Player.X + 2 , PlayerStatus.Player.Y );
170- e.Target.LogicParameter.Count = 0;
171- }
172- e.Target.LogicParameter.Count++;
173- }
174- } );
175- #endregion
176- break;
177- case 16:
178- #region 乗ると強制的に左に移動する
179- newSprite.CanActDefault = false;
180- newSprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
181- if( SpriteAction.HitDirection( PlayerStatus.Player , e.Target ) == DirectionType.Top ) {
182- SpriteAction.Physisorption( PlayerStatus.Player , e.Target , DirectionType.Top );
183- if( e.Target.LogicParameter.Count >= 6 ) {
184- PlayerStatus.Player.TryMove( PlayerStatus.Player.Bound.Width + PlayerStatus.Player.X - 2 , PlayerStatus.Player.Y );
185- e.Target.LogicParameter.Count = 0;
186- }
187- e.Target.LogicParameter.Count++;
188- }
189- } );
190- #endregion
191- break;
192- case 17:
110+ }
111+ };
112+ #endregion
113+ break;
114+ case 10:
115+ #region 上下に浮遊する
116+ // newSprite.CanDefaultAction = false;
117+ sprite.LogicParameter.Radius = 50;   // 半径
118+ sprite.LogicParameter.Angle = 90; // 角度
119+ sprite.LogicParameter.Speed = 1; // 速度
120+ sprite.LogicParameter.LimitDistance = 100;// 移動距離
121+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
122+ Sprite.GivenDirection( e.Sprite , e.Sprite.LogicParameter.InitX , e.Sprite.LogicParameter.InitY );
123+ } );
124+ #endregion
125+ break;
126+ case 11:
127+ #region 時計回り
128+ sprite.CanActDefault = false; // 既定の重力計算などを無効にする。
129+ sprite.LogicParameter.Radius = 100; // 半径
130+ sprite.LogicParameter.Speed = 8; // 回転速度
131+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
132+ Sprite.Rotation( e.Sprite , e.Sprite.LogicParameter.InitX , e.Sprite.LogicParameter.InitY , true );
133+ } );
134+ #endregion
135+ break;
136+ case 12:
137+ #region 反時計回り
138+ sprite.IsBlock = false;
139+ sprite.LogicParameter.Speed = 2;
140+ sprite.LogicParameter.Radius = 100;
141+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
142+ // Sprite.HitStop( PlayerStatus.Player , e.Target );
143+ Sprite.Rotation( e.Sprite , e.Sprite.LogicParameter.InitX , e.Sprite.LogicParameter.InitY , false );
144+ } );
145+ #endregion
146+ break;
147+ case 13:
148+ #region 空中を回転しながら浮遊する
149+ sprite.LogicParameter.LimitDistance = 150; // 移動距離
150+ sprite.LogicParameter.Speed = 2; // 上下に移動するときの速度
151+ sprite.LogicParameter.Angle = 90; // 移動する方向。90度 = 上下方向。45度 = 斜めなど。
152+ sprite.CanActDefault = false;
153+ sprite.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
154+ Sprite.GivenDirection( e.Sprite , e.Sprite.LogicParameter.InitX , e.Sprite.LogicParameter.InitY );
155+ sprite.LogicParameter.Angle++;
156+ } );
157+ #endregion
158+ break;
159+ case 14:
160+ #region 10秒アイテム
161+ sprite.Rectangle.Hitted += ( sender ,e ) => {
162+ if( e.Target == PlayerStatus.Player.Rectangle ) {
163+ PlayerStatus.TimerInitialize();
164+ }
165+ };
166+ #endregion
167+ break;
168+ case 15:
169+ #region 乗ると強制的に右に移動する
170+ #endregion
171+ break;
172+ case 16:
173+ #region 乗ると強制的に左に移動する
174+ #endregion
175+ break;
176+ case 17:
193177
194- default:
195- break;
178+ default:
179+ break;
196180 }
197- return newSprite;
181+ return sprite;
198182 }
199183 }
200184 }
--- trunk/Nlgp1/Nlgp1/Players/PlayerStatus.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Players/PlayerStatus.cs (revision 737)
@@ -54,8 +54,8 @@
5454 /// <summary>
5555 /// 自分自身のキャラクタを初期化します。
5656 /// </summary>
57- /// <param name="location">初期位置</param>
58- public static Sprite LoadPlayer( Vec2 location ) {
57+ /// <param name="position">初期位置</param>
58+ public static Sprite LoadPlayer( Vec2 position ) {
5959 TimerInitialize();
6060
6161 if( Player != null )
@@ -62,7 +62,7 @@
6262 Player.Dispose();
6363
6464 // 自分自身のパラメータは、ここで設定する
65- Player = new Character( 1 , SpriteType.Player , MapData.DefaultChipSize , location );
65+ Player = new Character( 1 , SpriteType.Player , MapData.DefaultChipSize , position );
6666 Player.HitPoint = 100;
6767 // Player.GetRectangle.BlankLeft = -2;
6868 // Player.GetRectangle.BlankRight = -2;
@@ -78,17 +78,16 @@
7878 */
7979
8080 #region プレーヤー自身に対するActionイベント
81- Player.Acted += new EventHandler<SpriteActedEventArgs>( ( sender , e ) => {
82- if( ( e.Target.MovingDirection & DirectionFlags.Top ) != 0 &&
83- e.Target.GetHittingSprites( AspectType.Vertical ).Any( ( sprite ) => ( sprite.IsDestroyable ) ) ) {
81+ Player.Rectangle.Hitted += ( sender , e ) => {
82+ if( e.Direction == Direction.Top && e.Target.Sprite.IsDestroyable ) {
8483 // 上方向に移動しており、衝突したセルが破壊可能であれば、そのセルを置換します。
85- GameMap.RemoveSprite( e.Target.VerticalPos );
84+ e.Target.Sprite.Remove();
8685 }
8786 // if( Player.Attacking == AttackTypes.DivineBuster ) {
8887 // Player.RunAttack( Player.Attacking ).Start();
8988 // Player.Attacking = AttackTypes.None;
9089 // }
91- } );
90+ };
9291 #endregion
9392
9493 /*
--- trunk/Nlgp1/Nlgp1/Stages/GameMap.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Stages/GameMap.cs (revision 737)
@@ -2,7 +2,9 @@
22 using System.Collections.Generic;
33 using System.IO;
44 using System.Linq;
5+using Box2DX.Collision;
56 using Box2DX.Common;
7+using Box2DX.Dynamics;
68 using Nlgp1.Characters;
79 using Nlgp1.Common;
810 using Nlgp1.Common.Drawing;
@@ -27,31 +29,38 @@
2729 GameMap.stageNo = stageNo;
2830 MapData mapData = MapData.Load( rootPath , stageNo );
2931
32+ GameMap.sheetSize = Utility.GetEnumValues< LayerType >().Aggregate( new Size() , ( size , layerType ) => {
33+ Cell[,] sheet = mapData.GetSheet( layerType );
34+ return new Size( sheet.GetLength( 0 ) , sheet.GetLength( 1 ) );
35+ } );
36+ GameMap.stageArea = new AABB {
37+ LowerBound = new Vec2(),
38+ UpperBound = new Vec2( sheetSize.Width * MapData.CellSize , sheetSize.Height * MapData.CellSize ),
39+ };
40+ GameMap.world = new World( stageArea , new Vec2() , false );
41+
3042 // マップ上にキャラクタを配置する。
31- GameMap.sheetSize = new Size();
3243 foreach( LayerType layerType in Enum.GetValues( typeof( LayerType ) ) ) {
3344 Cell[,] sheet = mapData.GetSheet( layerType );
34- GameMap.sheetSize.Width = System.Math.Max( GameMap.sheetSize.Width , sheet.GetLength( 0 ) );
35- GameMap.sheetSize.Height = System.Math.Max( GameMap.sheetSize.Height , sheet.GetLength( 1 ) );
3645 for( int x = 0 ; x < sheet.GetLength( 0 ) ; x++ ) {
3746 for( int y = 0 ; y < sheet.GetLength( 1 ) ; y++ ) {
3847 Cell cell = sheet[ x , y ];
39- Vec2 location = new Vec2( x , y ) * MapData.CellSize;
48+ Vec2 position = new Vec2( x + 0.5f , y + 0.5f ) * MapData.CellSize;
4049 if( cell.CellTypeID >= 1 ) {
4150 Sprite sprite;
4251 if( layerType == LayerType.Character ) {
4352 if( cell.CellTypeID == 1 ) {
44- sprite = PlayerStatus.LoadPlayer( location ); // プレーヤー
53+ sprite = PlayerStatus.LoadPlayer( position ); // プレーヤー
4554 }
4655 else {
47- sprite = SpriteFactory.CreateSprite( cell.CellTypeID , location , MapData.DefaultChipSize ); // キャラクタ
56+ sprite = SpriteFactory.CreateSprite( cell.CellTypeID , position , MapData.DefaultChipSize ); // キャラクタ
4857 }
4958 }
5059 else {
51- sprite = new Sprite( layerType , cell.CellTypeID , SpriteType.Monster , Path.Combine( @"Stages\Defines\Maps\Normal" , layerType.ToString() ) , MapData.DefaultChipSize , null , location );
60+ sprite = new Sprite( layerType , cell.CellTypeID , SpriteType.Monster , Path.Combine( @"Stages\Defines\Maps\Normal" , layerType.ToString() ) , MapData.DefaultChipSize , null , position );
61+ sprite.UpGravity = 0;
62+ sprite.DownGravity = 0;
5263 }
53- sprite.UpGravity = 0;
54- sprite.DownGravity = 0;
5564 sprite.IsBlock = ( cell.CellFlags & CellFlags.Wall ) != 0;
5665 sprite.IsDestroyable = ( cell.CellFlags & CellFlags.Destroy ) != 0;
5766 sprite.Friction = cell.Friction;
@@ -59,19 +68,19 @@
5968 }
6069 }
6170 }
62- GameMap.stageSize = new Vec2( sheetSize.Width * MapData.CellSize , sheetSize.Height * MapData.CellSize );
6371 }
6472
6573 public static void UnloadStage() {
66- foreach( Sprite sprite in Sprite.SpriteCollection().Cast< Sprite >().Reverse() ) {
74+ foreach( Sprite sprite in Sprite.SpriteCollection().Reverse() ) {
6775 sprite.Dispose();
6876 }
6977 }
7078
7179 public static void UpdateStage() {
80+ GameMap.world.Step( 1 , 8 , 1 );
7281 // キャラクタアクション
73- foreach( Sprite sprite in Sprite.SpriteCollection().Cast< Sprite >() ) {
74- if( StageView.IsVisibleSprite( sprite.X , sprite.Y , sprite.ActionCellCount ) ) {
82+ foreach( Sprite sprite in Sprite.SpriteCollection() ) {
83+ if( StageView.IsVisibleSprite( sprite.Action.Position.X , sprite.Action.Position.Y , sprite.ActableCellCount ) ) {
7584 sprite.Act();
7685 }
7786 }
@@ -113,37 +122,15 @@
113122
114123 private static Size sheetSize;
115124
116- private static Vec2 stageSize;
125+ private static AABB stageArea;
117126
118- /// <summary>
119- /// 座標を指定してそこにあるスプライト群を取得します。
120- /// </summary>
121- /// <param name="location">座標</param>
122- /// <returns>指定した座標に存在するスプライト</returns>
123- public static IEnumerable< Sprite > GetSprites( Vec2 location ) {
124- return Sprite.SpriteCollection().Cast< Sprite >().Where( ( sprite ) => {
125- return sprite.Bound.HitTest( location );
126- } );
127+ public static World World {
128+ get {
129+ return GameMap.world;
130+ }
127131 }
128132
129- /// <summary>
130- /// 指定された座標がステージの範囲内かどうかを返します。
131- /// </summary>
132- /// <param name="location">座標</param>
133- /// <returns>ステージ範囲内かどうか</returns>
134- public static bool IsStageArea( Vec2 location ) {
135- return ( 0 <= location.X && location.X <= GameMap.stageSize.X ) && ( 0 <= location.Y && location.Y <= GameMap.stageSize.Y );
136- }
137-
138- /// <summary>
139- /// スプライトを削除します。
140- /// </summary>
141- /// <param name="location">座標</param>
142- public static void RemoveSprite( Vec2 location ) {
143- foreach( Sprite sprite in GameMap.GetSprites( location ) ) {
144- sprite.Dispose();
145- }
146- }
133+ private static World world;
147134 }
148135 }
149136
--- trunk/Nlgp1/Nlgp1/Motions/SpriteMotion.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Motions/SpriteMotion.cs (revision 737)
@@ -157,25 +157,25 @@
157157 private MotionType GetMotionType( Sprite sprite ) {
158158 MotionType result = MotionType.RestRight;
159159 if( sprite.IsNowJumping == false &&
160- ( sprite.MovingDirection == DirectionFlags.Left || sprite.MovingDirection == DirectionFlags.Right ) && sprite.Speed.IsEmpty ) {
160+ ( sprite.MovingDirection == Directions.Left || sprite.MovingDirection == Directions.Right ) && sprite.Speed.IsEmpty ) {
161161 // 静止状態
162- if( sprite.RestDirection == ( sprite.RestDirection | DirectionFlags.Right ) )
162+ if( sprite.Direction == ( sprite.Direction | Directions.Right ) )
163163 result = MotionType.RestRight;
164164 else
165165 result = MotionType.RestLeft;
166- } else if( sprite.RestDirection == DirectionFlags.Right ) {
166+ } else if( sprite.Direction == Directions.Right ) {
167167 if( sprite.IsBoosting )
168168 result = MotionType.BoostRight;
169169 else
170170 result = MotionType.WalkRight;
171- } else if( sprite.RestDirection == DirectionFlags.Left ) {
171+ } else if( sprite.Direction == Directions.Left ) {
172172 if( sprite.IsBoosting )
173173 result = MotionType.BoostLeft;
174174 else
175175 result = MotionType.WalkLeft;
176- } else if( sprite.RestDirection == ( sprite.RestDirection | DirectionFlags.Right ) ) {
176+ } else if( sprite.Direction == ( sprite.Direction | Directions.Right ) ) {
177177 // 右方向
178- if( sprite.RestDirection == ( sprite.RestDirection | DirectionFlags.Top ) ) {
178+ if( sprite.Direction == ( sprite.Direction | Directions.Top ) ) {
179179 if( sprite.IsBoosting )
180180 result = MotionType.BoostUpRight;
181181 else
@@ -186,9 +186,9 @@
186186 else
187187 result = MotionType.UpRight;
188188 }
189- } else if( sprite.RestDirection == ( sprite.RestDirection | DirectionFlags.Left ) ) {
189+ } else if( sprite.Direction == ( sprite.Direction | Directions.Left ) ) {
190190 // 左方向
191- if( sprite.RestDirection == ( sprite.RestDirection | DirectionFlags.Top ) ) {
191+ if( sprite.Direction == ( sprite.Direction | Directions.Top ) ) {
192192 if( sprite.IsBoosting )
193193 result = MotionType.BoostUpLeft;
194194 else
--- trunk/Nlgp1/Nlgp1/Sprites/SpriteAction.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Sprites/SpriteAction.cs (revision 737)
@@ -1,208 +1,27 @@
11 using System;
2+using System.Collections.Generic;
3+using Box2DX.Common;
24 using Nlgp1.Parameters;
3-using Nlgp1.Sprites;
4-using Nlgp1.Common;
5-using Nlgp1.Common.Drawing;
65
7-namespace Nlgp1.Utilities {
6+namespace Nlgp1.Sprites {
87 /// <summary>
98 /// 汎用のアクションイベント用ロジック
109 /// </summary>
11- public static class SpriteAction {
12- /// <summary>
13- /// 軸を中心に回転を行います。
14- /// </summary>
15- /// <param name="target">対象のスプライト</param>
16- /// <param name="x">中心となるX軸の座標</param>
17- /// <param name="y">中心となるY軸の座標</param>
18- /// <param name="rightRotation">右回りに回転を行うようにします。</param>
19- public static void Rotation( Sprite target , float x , float y , bool rightRotation ) {
20- target.X = x + ( target.LogicParameter.Radius * MathEx.Cos( MathEx.PI / 180 * target.LogicParameter.Angle ) );
21- target.Y = y + ( target.LogicParameter.Radius * MathEx.Sin( MathEx.PI / 180 * target.LogicParameter.Angle ) );
10+ public sealed class SpriteAction {
2211
23- if( rightRotation ) {
24- target.LogicParameter.Angle += target.LogicParameter.Speed;
25- if( target.LogicParameter.Angle > 360 )
26- target.LogicParameter.Angle = 0;
27- } else {
28- target.LogicParameter.Angle -= target.LogicParameter.Speed;
29- if( target.LogicParameter.Angle < 0 )
30- target.LogicParameter.Angle = 360;
31- }
12+ public SpriteAction( Vec2 position , IEnumerable< SpriteRectangle > rectangles ) {
13+ this.position = position;
3214 }
33- /// <summary>
34- /// スプライトを一定の方向に行き来するように移動します。
35- /// </summary>
36- /// <param name="target">対象のスプライト</param>
37- /// <param name="x">中心のX座標</param>
38- /// <param name="y">中心のY座標</param>
39- public static void GivenDirection( Sprite target , float x , float y ) {
40- // 移動方向を切り替える
41- if( target.LogicParameter.Radius > target.LogicParameter.LimitDistance )
42- target.LogicParameter.Universal["GivenDirection"] = false;
43- else if( target.LogicParameter.Radius < -target.LogicParameter.LimitDistance )
44- target.LogicParameter.Universal["GivenDirection"] = true;
4515
46- // 移動距離を加算する。数値を変えると速度が変化する
47- if( (bool)target.LogicParameter.Universal["GivenDirection"] )
48- target.LogicParameter.Radius += target.LogicParameter.Speed;
49- else
50- target.LogicParameter.Radius -= target.LogicParameter.Speed;
51-
52- target.X = x + ( target.LogicParameter.Radius * MathEx.Cos( MathEx.PI / 180 * target.LogicParameter.Angle ) );
53- target.Y = y + ( target.LogicParameter.Radius * MathEx.Sin( MathEx.PI / 180 * target.LogicParameter.Angle ) );
16+ public void Act() {
5417 }
55- /// <summary>
56- /// キャラクタオブジェクトをVerlet積分法に基づいて移動する。
57- /// </summary>
58- /// <param name="target">対象のスプライト</param>
59- /// <param name="friction">摩擦</param>
60- /// <param name="maxSpeedX">X軸方向の最高速度</param>
61- /// <param name="maxSpeedY">Y軸方向の最高速度</param>
62- public static void Verlet( Sprite target , float friction , float maxSpeedX , float maxSpeedY ) {
63- if( target.Speed.X != 0 || friction != 0 ) {
64- if( target.X - target.PrevX > 0 && target.Speed.X < 0) {
65- target.PrevX = target.X;
66- }else if( target.X - target.PrevX < 0 && target.Speed.X > 0){
67- target.PrevX = target.X;
68- }
69- var x_temp = target.X;
70- target.X +=
71- System.Math.Min(
72- System.Math.Max( target.X - target.PrevX + target.Speed.X + friction , -maxSpeedX ) ,
73- maxSpeedX
74- );
75- target.PrevX = x_temp;
76- }
7718
78- if( target.Y - target.PrevY > 0 && target.Speed.Y < 0 ) {
79- target.PrevY = target.Y;
80- } else if( target.Y - target.PrevY < 0 && target.Speed.Y > 0 ) {
81- target.PrevY = target.Y;
19+ public Vec2 Position {
20+ get {
21+ return this.position;
8222 }
83- var y_temp = target.Y;
84- float gravity;
85- if( target.IsFlying == false )
86- gravity = target.Y < target.PrevY ? -target.UpGravity : -target.DownGravity;
87- else{
88- gravity = -target.FlyGravity;
89- }
90-
91- target.Y +=
92- System.Math.Max(
93- System.Math.Min( target.Y - target.PrevY + target.Speed.Y - gravity , maxSpeedY ) ,
94- -maxSpeedY
95- );
96- target.PrevY = y_temp;
9723 }
98- /// <summary>
99- /// スプライトと衝突したときにリバウンドを行う。
100- /// </summary>
101- /// <param name="source">targetに衝突するスプライト</param>
102- /// <param name="target">対象のスプライト</param>
103- /// <param name="bound">反動で移動する距離</param>
104- public static void HitBound( Sprite source , Sprite target , float bound ) {
105- if( source.Bound.HitTest( target.Bound ) == false )
106- return;
107- float angle = MathEx.Angle( source.X , source.Y , target.X , target.Y );
108- if( angle > 0 )
109- angle = -angle;
110- else
111- angle = System.Math.Abs( angle );
112- source.TryMove( target.X + ( bound * MathEx.Cos( MathEx.PI / 180 * angle ) ) , target.Y + ( bound * MathEx.Sin( MathEx.PI / 180 * angle ) ) );
113- }
114- /// <summary>
115- /// スプライトとの衝突を判定してリバウンドを行わずに停止します。
116- /// つまり対象キャラクタを壁のように見立てます。
117- /// </summary>
118- /// <param name="source">targetに衝突するスプライト</param>
119- /// <param name="target">対象のスプライト</param>
120- public static void HitStop( Sprite source , Sprite target ) {
121- float x = source.X;
122- float y = source.Y;
123- if( source.Bound.HitTest( target.Bound , AspectType.Vertical ) ) {
124- float top = System.Math.Abs( System.Math.Abs( source.Bound.Top ) - System.Math.Abs( target.Bound.Bottom ) );
125- float bottom = System.Math.Abs( System.Math.Abs( source.Bound.Bottom ) - System.Math.Abs( target.Bound.Top ) );
126- if( top < bottom ) {
127- if( target.IsNowJumping ) {
128- y = target.Bound.Bottom + MapData.CellSize / 2;
129- }
130- } else {
131- //y = target.GetRectangle.Top - source.Height;
132- y = target.Bound.Top + target.Bound.Height;
133- }
134- }
13524
136- if( source.Bound.HitTest( target.Bound , AspectType.Horizontal ) ) {
137- float left = System.Math.Abs( System.Math.Abs( source.Bound.Left ) - System.Math.Abs( target.Bound.Right ) );
138- float right = System.Math.Abs( System.Math.Abs( source.Bound.Right ) - System.Math.Abs( target.Bound.Left ) );
139- if( left > right )
140- x = target.Bound.Left - target.Bound.Width;
141- else
142- x = target.Bound.Right;
143- }
144- source.TryMove( x , y );
145- }
146- /// <summary>
147- /// 方向を指定してスプライト1がスプライト2に吸着するようにする。
148- /// </summary>
149- /// <param name="source">スプライト1</param>
150- /// <param name="target">スプライト2</param>
151- /// <param name="dir">吸着する方向</param>
152- public static void Physisorption( Sprite source , Sprite target , DirectionType dir ) {
153- float x = source.X;
154- float y = source.Y;
155- switch( dir ) {
156- case DirectionType.Top:
157- if( source.MoveTest( DirectionType.Top , true ) == false )
158- source.Y = ( target.Bound.Top - target.Bound.Height );
159- break;
160- case DirectionType.Bottom:
161- if( source.MoveTest( DirectionType.Bottom , true ) == false )
162- source.Y = ( target.Bound.Bottom + target.Bound.Height ) - MapData.CellSize;
163- break;
164- case DirectionType.Left:
165- if( source.MoveTest( DirectionType.Left , true ) == false )
166- source.X = ( target.Bound.Left + target.Bound.Width );
167- break;
168- case DirectionType.Right:
169- if( source.MoveTest( DirectionType.Right , false ) == false )
170- source.X = ( target.Bound.Right - target.Bound.Width ) - source.Bound.Width;
171- break;
172- default:
173- break;
174- }
175- }
176- /// <summary>
177- /// スプライト1がスプライト2に最も衝突している方向を取得する。
178- /// </summary>
179- /// <param name="source">スプライト1</param>
180- /// <param name="target">スプライト2</param>
181- /// <returns>最も衝突している方向</returns>
182- public static DirectionType HitDirection( Sprite source , Sprite target ) {
183- DirectionType dir = DirectionType.None;
184- float max = float.MinValue;
185- float top = System.Math.Abs( source.Bound.HitDistance( DirectionType.Top , target.Bound ) );
186- float bottom = System.Math.Abs( source.Bound.HitDistance( DirectionType.Bottom , target.Bound ) );
187- float left = System.Math.Abs( source.Bound.HitDistance( DirectionType.Left , target.Bound ) );
188- float right = System.Math.Abs( source.Bound.HitDistance( DirectionType.Right , target.Bound ) );
189- if( max < top && top != 0 ) {
190- max = top;
191- dir = DirectionType.Top;
192- }
193- if( max < bottom && bottom != 0 ) {
194- max = bottom;
195- dir = DirectionType.Bottom;
196- }
197- if( max < left && left != 0 ) {
198- max = left;
199- dir = DirectionType.Left;
200- }
201- if( max < right && right != 0 ) {
202- max = right;
203- dir = DirectionType.Right;
204- }
205- return dir;
206- }
25+ private Vec2 position;
20726 }
20827 }
--- trunk/Nlgp1/Nlgp1/Sprites/Sprite.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Sprites/Sprite.cs (revision 737)
@@ -57,8 +57,8 @@
5757 /// <param name="imageTypeName">使用するグラフィックフォルダ名</param>
5858 /// <param name="chipSize">スプライトのサイズ(最小=32x32)</param>
5959 /// <param name="debugID">デバッグ用 識別子 (通常使わない)</param>
60- /// <param name="location">初期位置</param>
61- public Sprite( LayerType layerType , int typeID , SpriteType spriteType , string imageTypeName , Size chipSize , string debugID , Vec2 location ) {
60+ /// <param name="position">初期位置</param>
61+ public Sprite( LayerType layerType , int typeID , SpriteType spriteType , string imageTypeName , Size chipSize , string debugID , Vec2 position ) {
6262 lock( objectList )
6363 objectList.Add( this );
6464
@@ -65,7 +65,11 @@
6565 this.Motion = SpriteMotion.Get( layerType , imageTypeName , typeID , chipSize );
6666 this.Speed = new Speed();
6767 this.LogicParameter = new ActionParameter();
68- this.Bound = new SpriteBound( this , MathEx.ToAABB( 0 , 0 , chipSize.Width , chipSize.Height ) );
68+ this.Rectangle = new SpriteRectangle( this , new AABB {
69+ LowerBound = new Vec2( chipSize.Width * -0.5f , chipSize.Height * +0.5f ),
70+ UpperBound = new Vec2( chipSize.Width * +0.5f , chipSize.Height * +0.5f ),
71+ } );
72+ this.Action = new SpriteAction( position , new SpriteRectangle[] { this.Rectangle } );
6973
7074 this.SpriteType = spriteType;
7175 this.TypeID = typeID;
@@ -80,17 +84,14 @@
8084 JumpPower = 5;
8185 FlyGravity = 0.05f;
8286 IsBlock = true;
83- ActionCellCount = 2;
87+ ActableCellCount = 2;
8488 CanActDefault = true;
8589 startTick = Environment.TickCount;
8690 actedEventParameter = new SpriteActedEventArgs( this );
8791
8892 this.DebugID = debugID;
89- this.X = location.X;
90- this.Y = location.Y;
91- this.ResetPrev();
92- this.LogicParameter.InitX = this.X;
93- this.LogicParameter.InitY = this.Y;
93+ this.LogicParameter.InitX = position.X;
94+ this.LogicParameter.InitY = position.Y;
9495 }
9596
9697 /// <summary>
@@ -142,16 +143,24 @@
142143 /// <summary>
143144 /// スプライトの位置、サイズを取得または、設定します。
144145 /// </summary>
145- public SpriteBound Bound {
146+ public SpriteRectangle Rectangle {
146147 get;
147148 private set;
148149 }
149150
151+ /// <summary>
152+ /// スプライトアクションを取得または、設定します。
153+ /// </summary>
154+ public SpriteAction Action {
155+ get;
156+ private set;
157+ }
158+
150159 #region 方向
151160 /// <summary>
152161 /// スプライトの静止状態での向きを取得します。
153162 /// </summary>
154- public DirectionFlags RestDirection {
163+ public Directions Direction {
155164 get;
156165 private set;
157166 }
@@ -158,40 +167,14 @@
158167 /// <summary>
159168 /// スプライトが移動している方向を取得します。
160169 /// </summary>
161- public DirectionFlags MovingDirection {
162- get {
163- DirectionFlags dirV;
164- DirectionFlags dirH;
165-
166- if( Y - PrevY < 0 )
167- dirV = DirectionFlags.Top;
168- else if( Y != PrevY )
169- dirV = DirectionFlags.Bottom;
170- else
171- dirV = DirectionFlags.None;
172-
173- if( X - PrevX < 0 )
174- dirH = DirectionFlags.Left;
175- else if( X != PrevX )
176- dirH = DirectionFlags.Right;
177- else
178- dirH = DirectionFlags.None;
179-
180- if( dirV != DirectionFlags.None && dirH != DirectionFlags.None )
181- RestDirection = dirV | dirH;
182- else if( dirV == DirectionFlags.None )
183- RestDirection = dirH;
184- else if( dirH == DirectionFlags.None )
185- RestDirection = dirV;
186- else
187- return DirectionFlags.None;
188- return RestDirection;
189- }
170+ public Directions MovingDirection {
171+ get;
172+ private set;
190173 }
191174 /// <summary>
192175 /// スプライトが衝突したBlock属性のセルの方向を取得します。
193176 /// </summary>
194- public DirectionFlags HitBlockDirection {
177+ public Directions HitBlockDirection {
195178 get;
196179 private set;
197180 }
@@ -274,7 +257,7 @@
274257 /// <summary>
275258 /// スプライトが画面外にあるときに活動できる外枠のセル数を取得または、設定します。
276259 /// </summary>
277- public int ActionCellCount {
260+ public int ActableCellCount {
278261 get;
279262 set;
280263 }
@@ -349,283 +332,6 @@
349332 }
350333 #endregion
351334
352- #region 直近のスプライト・衝突したスプライトの取得
353- /// <summary>
354- /// 方向を指定してスプライトの直近のスプライト群を取得します。
355- /// </summary>
356- /// <param name="direction">方向の組み合わせ</param>
357- /// <returns>スプライト群</returns>
358- public IEnumerable< Sprite > GetImmediateSprites( DirectionFlags direction ) {
359- Vec2 location = Location;
360- bool isLeft = ( direction & DirectionFlags.Left ) != 0;
361- bool isRight = ( direction & DirectionFlags.Right ) != 0;
362- bool isTop = ( direction & DirectionFlags.Top ) != 0;
363- bool isBottom = ( direction & DirectionFlags.Bottom ) != 0;
364- if( isLeft && !isRight ) {
365- location.X = this.Bound.Left;
366- }
367- if( isRight && !isLeft ) {
368- location.X = this.Bound.Right;
369- }
370- if( isTop && !isBottom ) {
371- location.Y = this.Bound.Top;
372- }
373- if( isBottom && !isTop ) {
374- location.Y = this.Bound.Bottom;
375- }
376- return GameMap.GetSprites( location );
377- }
378- /// <summary>
379- /// 方向を指定してスプライトの直近に存在するセルがブロック属性かまたは、ステージ範囲外であるかどうか取得します。
380- /// </summary>
381- /// <param name="direction">方向</param>
382- /// <returns>ブロック属性のスプライトであるかどうか</returns>
383- public bool ImmediateSpritesAreBlock( DirectionFlags direction ) {
384- if( GetImmediateSprites( direction ).Any( ( sprite ) => sprite.IsBlock ) ) {
385- return true;
386- }
387- else {
388- Vec2 location = Location;
389- bool isLeft = ( direction & DirectionFlags.Left ) != 0;
390- bool isRight = ( direction & DirectionFlags.Right ) != 0;
391- bool isTop = ( direction & DirectionFlags.Top ) != 0;
392- bool isBottom = ( direction & DirectionFlags.Bottom ) != 0;
393- if( isLeft && !isRight ) {
394- location.X = this.Bound.Left;
395- }
396- if( isRight && !isLeft ) {
397- location.X = this.Bound.Right;
398- }
399- if( isTop && !isBottom ) {
400- location.Y = this.Bound.Top;
401- }
402- if( isBottom && !isTop ) {
403- location.Y = this.Bound.Bottom;
404- }
405- return GameMap.IsStageArea( location );
406- }
407- }
408- /// <summary>
409- /// 座標を指定してスプライトの直近に存在するセルがブロック属性かまたは、ステージ範囲外であるかどうか取得します。
410- /// </summary>
411- /// <param name="location">座標</param>
412- /// <returns>ブロック属性のスプライトであるかどうか</returns>
413- public bool ImmediateSpritesAreBlock( Vec2 location ) {
414- return GameMap.GetSprites( location ).Any( ( sprite ) => sprite.IsBlock ) && GameMap.IsStageArea( location );
415- }
416- /// <summary>
417- /// 既定の移動処理によって移動しようとした先のセルがマップ外かBlock属性かどうか取得します。
418- /// </summary>
419- /// <param name="aspect">移動方向</param>
420- /// <returns>ブロック属性のスプライトか</returns>
421- public bool ImmediateSpritesAreBlock( AspectType aspect ) {
422- switch( aspect ) {
423- case AspectType.Horizontal:
424- return ImmediateSpritesAreBlock( this.HorizontalPos );
425- case AspectType.Vertical:
426- return ImmediateSpritesAreBlock( this.VerticalPos );
427- default:
428- throw new ArgumentException();
429- }
430- }
431- /// <summary>
432- /// 既定の移動処理によって移動しようとした先のスプライト群を取得します。
433- /// </summary>
434- /// <param name="aspect">移動方向</param>
435- /// <returns>スプライト群</returns>
436- public IEnumerable< Sprite > GetHittingSprites( AspectType aspect ) {
437- switch( aspect ) {
438- case AspectType.Horizontal:
439- return GameMap.GetSprites( this.HorizontalPos );
440- case AspectType.Vertical:
441- return GameMap.GetSprites( this.HorizontalPos );
442- default:
443- throw new ArgumentException();
444- }
445- }
446- #endregion
447-
448- #region 当たり判定・衝突判定
449- /// <summary>
450- /// 衝突している異なる属性のスプライトをコレクションで取得します。
451- /// </summary>
452- /// <returns></returns>
453- public IEnumerable<Sprite> HitSpriteCollection() {
454- foreach( Sprite obj in SpriteCollection() ) {
455- if( obj != this && obj.IsBlock &&
456- obj.SpriteType != SpriteType.Hide && obj.SpriteType != this.SpriteType && Bound.HitTest( obj.Bound ) )
457- yield return obj;
458- }
459- }
460- /// <summary>
461- /// スプライトを指定した座標に移動を試みます。
462- /// 移動は、X軸→Y軸の順で判定され衝突した時点で移動を打ち消します。
463- /// </summary>
464- /// <param name="toX">移動先のピクセル(X)座標</param>
465- /// <param name="toY">移動先のピクセル(Y)座標</param>
466- /// <returns>衝突した方向</returns>
467- public DirectionFlags TryMove( float toX , float toY ) {
468- if( toX > X ) {
469- // 右に移動
470- for( ; toX > X ; X++ ) {
471- if( MoveTest( DirectionType.Right , true ) )
472- return DirectionFlags.Right;
473- }
474- } else if( toX < X ) {
475- // 左に移動
476- for( ; toX < X ; X-- ) {
477- if( MoveTest( DirectionType.Left , true ) )
478- return DirectionFlags.Left;
479- }
480- }
481- if( toY > Y ) {
482- // 下に移動
483- for( ; toY > Y ; Y++ ) {
484- if( MoveTest( DirectionType.Bottom , true ) )
485- return DirectionFlags.Bottom;
486- }
487- } else if( toY < Y ) {
488- // 上に移動
489- for( ; toY > Y ; Y-- ) {
490- if( MoveTest( DirectionType.Top , true ) )
491- return DirectionFlags.Top;
492- }
493- }
494- return DirectionFlags.None;
495- }
496- private Vec2 dummy = new Vec2();
497- /// <summary>
498- /// 指定した方向に移動しようとした場合に衝突するかどうか判定します。
499- /// </summary>
500- /// <param name="dir">移動方向</param>
501- /// <param name="isRecovery">衝突時に位置を補正するかどうか</param>
502- /// <returns>衝突するかどうか</returns>
503- public bool MoveTest( DirectionType dir , bool isRecovery ) {
504- return MoveTest( dir , ref dummy , isRecovery , 2 , true );
505- }
506- /// <summary>
507- /// 指定した方向に衝突するまで移動を行います。
508- /// </summary>
509- /// <param name="dir">移動方向</param>
510- /// <param name="hitPos">衝突した座標を受け取ります。</param>
511- /// <param name="isRecovery">衝突時に位置を補正するかどうか</param>
512- /// <returns>衝突するかどうか</returns>
513- public bool MoveTest( DirectionType dir , ref Vec2 hitPos , bool isRecovery , int blank , bool isNotSprite ) {
514- Sprite hitSprite = null;
515- switch( dir ) {
516- case DirectionType.Top:
517- #region 上方向
518- hitPos.Y = Bound.Top;
519- if( isNotSprite == false )
520- hitSprite = HitSprite( AspectType.Vertical );
521- for( int i = blank ; Bound.Width - blank > i ; i++ ) {
522- hitPos.X = ( Bound.Left + i );
523- if( hitSprite != null || this.IsBlockSprite( hitPos ) ) {
524- if( isRecovery ) {
525- if( hitSprite != null ) {
526- float dirPos = RestDirection == ( RestDirection | DirectionFlags.Left ) ? hitSprite.Bound.Right - Bound.Width : hitSprite.Bound.Left;
527- if( hitSprite.TryMove( dirPos , hitSprite.Bound.Top - ( Bound.Height - hitSprite.Bound.Height ) ) == DirectionFlags.None )
528- hitSprite.ResetPrev();
529- } else {
530- Y = ( hitPos.Y );
531- }
532- }
533- return true;
534- }
535- }
536- break;
537- #endregion
538- case DirectionType.Bottom:
539- #region 下方向
540- hitPos.Y = Bound.Bottom;
541- if( isNotSprite == false )
542- hitSprite = HitSprite( AspectType.Vertical );
543- for( int i = blank ; Bound.Width - blank > i ; i++ ) {
544- hitPos.X = ( Bound.Left + i );
545- if( hitSprite != null || this.IsBlockSprite( hitPos ) ) {
546- if( isRecovery ) {
547- if( hitSprite != null && hitSprite.TryMove(
548- hitSprite.X ,
549- hitSprite.Bound.Top + ( Bound.Height + hitSprite.Bound.Height ) )
550- == DirectionFlags.None ) {
551- hitSprite.ResetPrev();
552- } else {
553- Y = ( hitPos.Y ) - Bound.Height;
554- }
555- }
556- return true;
557- }
558- }
559- break;
560- #endregion
561- case DirectionType.Left:
562- #region 左方向
563- hitPos.X = Bound.Left;
564- if( isNotSprite == false )
565- hitSprite = HitSprite( AspectType.Horizontal );
566- for( int i = blank ; Bound.Height - blank > i ; i++ ) {
567- hitPos.Y = ( Bound.Bottom - i );
568- if( this.IsBlockSprite( hitPos ) || hitSprite != null ) {
569- if( isRecovery ) {
570- if( hitSprite != null ){
571- float toX = hitSprite.Bound.Left - ( System.Math.Abs( X - PrevX ) );
572- float toY = Y;
573- if( hitSprite.TryMove( toX , toY ) == DirectionFlags.None ){
574- hitSprite.ResetPrev();
575- return true;
576- }
577- }
578- X = ( hitPos.X );
579- }
580- return true;
581- }
582- }
583- break;
584- #endregion
585- case DirectionType.Right:
586- #region 右方向
587- hitPos.X = Bound.Right;
588- if( isNotSprite == false )
589- hitSprite = HitSprite( AspectType.Horizontal );
590- for( int i = blank ; Bound.Height - blank > i ; i++ ) {
591- hitPos.Y = ( Bound.Bottom - i );
592- if( this.IsBlockSprite( hitPos ) || hitSprite != null ) {
593- if( isRecovery ) {
594- if( hitSprite != null && hitSprite.TryMove( hitSprite.Bound.Left + ( System.Math.Abs( X - PrevX ) ) , hitSprite.Y ) == DirectionFlags.None ) {
595- hitSprite.ResetPrev();
596- } else {
597- X = ( hitPos.X ) - Bound.Width;
598- }
599- }
600- return true;
601- }
602- }
603- break;
604- #endregion
605- default:
606- break;
607- }
608- return false;
609- }
610- /// <summary>
611- /// 指定位置のスプライトがブロック属性を持っているかどうか取得します。
612- /// </summary>
613- /// <param name="x">座標</param>
614- /// <returns>ブロック属性かまたは、ステージ範囲外かどうか</returns>
615- public bool IsBlockSprite( Vec2 location ) {
616- return GameMap.GetSprites( location ).Any( ( sprite ) => {
617- return sprite != this && sprite.IsBlock;
618- } );
619- }
620- private Sprite HitSprite( AspectType aspect ) {
621- foreach( var s in HitSpriteCollection() ) {
622- if( s.IsBlock && Bound.HitTest( s.Bound , aspect ) && Bound.HitTest( s.Bound ) )
623- return s;
624- }
625- return default( Sprite );
626- }
627- #endregion
628-
629335 #region ロジック
630336
631337 private SpriteActedEventArgs actedEventParameter = null;
@@ -643,78 +349,14 @@
643349 }
644350 // 参考→http://d.hatena.ne.jp/Gemma/20080517/1211010942
645351
646- #region 移動先を計算する
647- if( CanActDefault ) {
648- // 真下のセルの摩擦を取得して影響を計算する。
649- float friction = 0;
650- if( IsNowJumping == false ) {
651- foreach( Sprite bottomSprite in this.GetImmediateSprites( DirectionFlags.Bottom ) ) {
652- if( bottomSprite.Friction != 0 ) {
653- if( X - PrevX > bottomSprite.Friction )
654- friction = -bottomSprite.Friction;
655- else if( X - PrevX < -bottomSprite.Friction )
656- friction = +bottomSprite.Friction;
657- }
658- }
659- }
660- // ジャンプ力の増加を打ち切る
661- if( --jumpBoost < 0 )
662- Speed.Y = 0;
663-
664- SpriteAction.Verlet( this , friction , IsBoosting ? Speed.MaxBoostX : Speed.MaxX , IsBoosting ? Speed.MaxBoostY : Speed.MaxY );
665- }
666- #endregion
667-
668- IsNowJumping = true;
669-
670- #region 障害物判定
671- verticalPos.X = 0;
672- verticalPos.Y = 0;
673- horizontalPos.X = 0;
674- horizontalPos.Y = 0;
675- DirectionFlags hitDirV = DirectionFlags.None;
676- DirectionFlags hitDirH = DirectionFlags.None;
677-
678- if( MovingDirection == ( MovingDirection | DirectionFlags.Top ) ) {
679- // 上方向に速度がある
680- if( MoveTest( DirectionType.Top , ref verticalPos , CanActDefault , 1 , false ) )
681- hitDirV = DirectionFlags.Top;
682- } else if( MovingDirection == ( MovingDirection | DirectionFlags.Bottom ) ) {
683- // 下方向に速度がある
684- if( MoveTest( DirectionType.Bottom , ref verticalPos , CanActDefault , 1 , false ) ) {
685- hitDirV = DirectionFlags.Bottom;
686- jumpBoost = JumpPower;
687- IsNowJumping = false;
688- }
689- }
690- if( MovingDirection == ( MovingDirection | DirectionFlags.Left ) ) {
691- // 左方向に速度がある
692- if( MoveTest( DirectionType.Left , ref horizontalPos , CanActDefault , 1 , false ) )
693- hitDirH = DirectionFlags.Left;
694- } else if( MovingDirection == ( MovingDirection | DirectionFlags.Right ) ) {
695- // 右方向に速度がある
696- if( MoveTest( DirectionType.Right , ref horizontalPos , CanActDefault , 1 , false ) )
697- hitDirH = DirectionFlags.Right;
698- }
699-
700- if( hitDirH != DirectionFlags.None && hitDirV != DirectionFlags.None )
701- HitBlockDirection = hitDirH | hitDirV;
702- else if( hitDirH == DirectionFlags.None )
703- HitBlockDirection = hitDirV;
704- else if( hitDirV == DirectionFlags.None )
705- HitBlockDirection = hitDirH;
706- else
707- HitBlockDirection = DirectionFlags.None;
708- #endregion
709-
710- if( Acted != null )
711- Acted( this , actedEventParameter );
352+ this.Action.Act();
353+ this.OnActed( this , this.actedEventParameter );
712354 }
713355 /// <summary>
714356 /// ジャンプを入力を開始します。
715357 /// </summary>
716358 public void StartJump() {
717- if( IsNowJumping == false && MoveTest( DirectionType.Top , false ) == false ) {
359+ if( IsNowJumping == false ) {
718360 Speed.Y = -JumpPower;
719361 jumpBoost = JumpPower;
720362 }
@@ -736,7 +378,7 @@
736378 /// 飛行を開始します。
737379 /// </summary>
738380 public void StartFly() {
739- if( IsBoosting && IsNowJumping && MovingDirection == ( MovingDirection | DirectionFlags.Bottom ) )
381+ if( IsBoosting && IsNowJumping && MovingDirection == ( MovingDirection | Directions.Bottom ) )
740382 IsFlying = true;
741383 }
742384 /// <summary>
@@ -759,6 +401,76 @@
759401 /// 行動が発生して既定の行動が実行されたあとに発生します。
760402 /// </summary>
761403 public event EventHandler<SpriteActedEventArgs> Acted;
404+
405+ public void OnActed( object sender , SpriteActedEventArgs e ) {
406+ if( this.Acted != null ) {
407+ this.Acted( sender , e );
408+ }
409+ }
410+
411+ /// <summary>
412+ /// 軸を中心に回転を行います。
413+ /// </summary>
414+ /// <param name="target">対象のスプライト</param>
415+ /// <param name="x">中心となるX軸の座標</param>
416+ /// <param name="y">中心となるY軸の座標</param>
417+ /// <param name="rightRotation">右回りに回転を行うようにします。</param>
418+ public static void Rotation( Sprite target , float x , float y , bool rightRotation ) {
419+ throw new NotImplementedException();
420+ }
421+ /// <summary>
422+ /// スプライトを一定の方向に行き来するように移動します。
423+ /// </summary>
424+ /// <param name="target">対象のスプライト</param>
425+ /// <param name="x">中心のX座標</param>
426+ /// <param name="y">中心のY座標</param>
427+ public static void GivenDirection( Sprite target , float x , float y ) {
428+ throw new NotImplementedException();
429+ }
430+ /// <summary>
431+ /// キャラクタオブジェクトをVerlet積分法に基づいて移動する。
432+ /// </summary>
433+ /// <param name="target">対象のスプライト</param>
434+ /// <param name="friction">摩擦</param>
435+ /// <param name="maxSpeedX">X軸方向の最高速度</param>
436+ /// <param name="maxSpeedY">Y軸方向の最高速度</param>
437+ public static void Verlet( Sprite target , float friction , float maxSpeedX , float maxSpeedY ) {
438+ throw new NotImplementedException();
439+ }
440+ /// <summary>
441+ /// スプライトと衝突したときにリバウンドを行う。
442+ /// </summary>
443+ /// <param name="source">targetに衝突するスプライト</param>
444+ /// <param name="target">対象のスプライト</param>
445+ /// <param name="bound">反動で移動する距離</param>
446+ public static void HitBound( Sprite source , Sprite target , float bound ) {
447+ throw new NotImplementedException();
448+ }
449+ /// <summary>
450+ /// 方向を指定してスプライト1がスプライト2に吸着するようにする。
451+ /// </summary>
452+ /// <param name="source">スプライト1</param>
453+ /// <param name="target">スプライト2</param>
454+ /// <param name="dir">吸着する方向</param>
455+ public static void Physisorption( Sprite source , Sprite target , Direction dir ) {
456+ throw new NotImplementedException();
457+ }
458+ /// <summary>
459+ /// スプライト1がスプライト2に最も衝突している方向を取得する。
460+ /// </summary>
461+ /// <param name="source">スプライト1</param>
462+ /// <param name="target">スプライト2</param>
463+ /// <returns>最も衝突している方向</returns>
464+ public static Direction HitDirection( Sprite source , Sprite target ) {
465+ throw new NotImplementedException();
466+ }
467+
468+ /// <summary>
469+ /// スプライトを削除します。
470+ /// </summary>
471+ public void Remove() {
472+ this.Dispose();
473+ }
762474 #endregion
763475
764476 #region IDisposable メンバー
@@ -780,7 +492,7 @@
780492 }
781493 #endregion
782494
783- #region IDraw メンバー
495+ #region IDrawable メンバー
784496 void IDrawable.Draw( Location location ) {
785497 if( this.SpriteType == SpriteType.Hide )
786498 return;
@@ -788,7 +500,7 @@
788500 }
789501 Vec2 IDrawable.DrawnPoint {
790502 get {
791- return Location;
503+ return this.Action.Position;
792504 }
793505 }
794506 ChipGraphics IDrawable.ChipSet {
@@ -823,127 +535,7 @@
823535 }
824536 #endregion
825537
826- #region IBounds メンバー
827- private Vec2 location = new Vec2();
828- private Vec2 prevLocation = new Vec2();
829- private DirectionFlags dirH = DirectionFlags.None;
830- private DirectionFlags dirV = DirectionFlags.None;
831-
832- /// <summary>
833- /// 現在の座標を取得します。
834- /// </summary>
835- public Vec2 Location {
836- get {
837- return location;
838- }
839- }
840- /// <summary>
841- /// 前回の座標を取得します。
842- /// </summary>
843- public Vec2 PrevLocation {
844- get {
845- return prevLocation;
846- }
847- }
848- /// <summary>
849- /// X軸の座標を取得または、設定します。
850- /// </summary>
851- public float X {
852- get {
853- return this.location.X;
854- }
855- set {
856- if( this.location.X > value )
857- dirH = DirectionFlags.Left;
858- else if( this.location.X < value )
859- dirH = DirectionFlags.Right;
860- else
861- dirH = DirectionFlags.None;
862-
863- if( this.location.X != value ) {
864- this.location.X = value;
865- OnPosChange();
866- }
867- }
868- }
869- /// <summary>
870- /// Y軸の座標を取得または、設定します。
871- /// </summary>
872- public float Y {
873- get {
874- return this.location.Y;
875- }
876- set {
877- if( this.location.Y > value )
878- dirV = DirectionFlags.Top;
879- else if( this.location.Y < value )
880- dirV = DirectionFlags.Bottom;
881- else
882- dirV = DirectionFlags.None;
883- if( this.location.Y != value ) {
884- this.location.Y = value;
885- OnPosChange();
886- }
887- }
888- }
889-
890- /// <summary>
891- /// スプライトの前回のY座標を取得または、設定します。
892- /// </summary>
893- public float PrevY {
894- get {
895- return this.prevLocation.Y;
896- }
897- set {
898- this.prevLocation.Y = value;
899- }
900- }
901- /// <summary>
902- /// スプライトの前回のX座標を設定または、取得します。
903- /// </summary>
904- public float PrevX {
905- get {
906- return this.prevLocation.X;
907- }
908- set {
909- this.prevLocation.X = value;
910- }
911- }
912-
913- /// <summary>
914- /// 向きを取得します。
915- /// </summary>
916- public DirectionFlags Direction {
917- get {
918- if( dirH != DirectionFlags.None && dirV != DirectionFlags.None )
919- return dirH | dirV;
920- else if( dirH == DirectionFlags.None )
921- return dirV;
922- else
923- return dirH;
924- }
925- }
926-
927- /// <summary>
928- /// 前回座標を現在座標に初期化します。
929- /// </summary>
930- public void ResetPrev() {
931- prevLocation.X = X;
932- prevLocation.Y = Y;
933- }
934-
935- /// <summary>
936- /// 座標が変更されたときに発生します。
937- /// </summary>
938- public event EventHandler PosChanged;
939-
940- /// <summary>
941- /// PosChangedイベントを発生させます。
942- /// </summary>
943- protected void OnPosChange() {
944- if( PosChanged != null )
945- PosChanged( this , EventArgs.Empty );
946- }
538+ #region ISpriteBound メンバー
947539 #endregion
948540
949541 #region デバッグ用メンバー
--- trunk/Nlgp1/Nlgp1/Sprites/SpriteActedEventArgs.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Sprites/SpriteActedEventArgs.cs (revision 737)
@@ -15,13 +15,13 @@
1515 /// SpriteActedEventArgsクラスの新しいインスタンスを初期化します。
1616 /// </summary>
1717 /// <param name="target">対象のスプライト</param>
18- public SpriteActedEventArgs( Sprite target ) {
19- this.Target = target;
18+ public SpriteActedEventArgs( Sprite sprite ) {
19+ this.Sprite = sprite;
2020 }
2121 /// <summary>
2222 /// 対象のスプライトを取得します。
2323 /// </summary>
24- public Sprite Target {
24+ public Sprite Sprite {
2525 get;
2626 private set;
2727 }
@@ -35,13 +35,13 @@
3535 /// SpriteActedEventArgsクラスの新しいインスタンスを初期化します。
3636 /// </summary>
3737 /// <param name="target">対象のスプライト</param>
38- public SpriteActedEventArgs( T target ) {
39- this.Target = target;
38+ public SpriteActedEventArgs( T sprite ) {
39+ this.Sprite = sprite;
4040 }
4141 /// <summary>
4242 /// 対象のスプライトを取得します。
4343 /// </summary>
44- public T Target {
44+ public T Sprite {
4545 get;
4646 private set;
4747 }
--- trunk/Nlgp1/Nlgp1/Attacks/Guns/Gun.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Attacks/Guns/Gun.cs (revision 737)
@@ -21,8 +21,8 @@
2121 }
2222
2323 #region IGun メンバー
24- Gun( int typeID , IAttack source , Size gunSize , string debugID , Vec2 location )
25- : base( LayerType.Character , typeID , source.Owner.SpriteType , "GunImages" , gunSize , debugID , location )
24+ Gun( int typeID , IAttack source , Size gunSize , string debugID , Vec2 position )
25+ : base( LayerType.Character , typeID , source.Owner.SpriteType , "GunImages" , gunSize , debugID , position )
2626 {
2727 this.Owner = source;
2828
--- trunk/Nlgp1/Nlgp1/IDrawable.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/IDrawable.cs (revision 737)
@@ -27,7 +27,7 @@
2727 /// <summary>
2828 /// 描画に使用するチップセットを取得します。
2929 /// </summary>
30- ChipGraphics ChipSet{
30+ ChipGraphics ChipSet {
3131 get;
3232 }
3333 }
--- trunk/Nlgp1/Nlgp1/Parameters/ISpriteBound.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Parameters/ISpriteBound.cs (nonexistent)
@@ -1,74 +0,0 @@
1-
2-namespace Nlgp1.Parameters {
3- public interface ISpriteBound {
4- /// <summary>
5- /// 横幅を取得または、設定します。
6- /// </summary>
7- float Width {
8- get;
9- }
10- /// <summary>
11- /// 縦幅を取得または、設定します。
12- /// </summary>
13- float Height {
14- get;
15- }
16-
17- /// <summary>
18- /// 左端の座標を取得します。
19- /// </summary>
20- float Left {
21- get;
22- }
23- /// <summary>
24- /// 上端の座標を取得します。
25- /// </summary>
26- float Top {
27- get;
28- }
29- /// <summary>
30- /// 右端の座標を取得します。
31- /// </summary>
32- float Right {
33- get;
34- }
35- /// <summary>
36- /// 下端の座標を取得します。
37- /// </summary>
38- float Bottom {
39- get;
40- }
41-
42-
43- int BlankLeft {
44- get;
45- set;
46- }
47- int BlankRight {
48- get;
49- set;
50- }
51- int BlankTop {
52- get;
53- set;
54- }
55- int BlankBottom {
56- get;
57- set;
58- }
59-
60- /// <summary>
61- /// 衝突方向を指定して重なってる距離を取得します。
62- /// </summary>
63- /// <param name="dir">衝突方向</param>
64- /// <param name="toRect">対象の短形</param>
65- /// <returns>重なってる部分の距離</returns>
66- float HitDistance( DirectionType dir , ISpriteBound toRect );
67- /// <summary>
68- /// 対象と衝突しているかどうか判定します。
69- /// </summary>
70- /// <param name="toRect">対象のオブジェクト</param>
71- /// <returns>衝突しているかどうか</returns>
72- bool HitTest( ISpriteBound toRect );
73- }
74-}
--- trunk/Nlgp1/Nlgp1/Parameters/SpriteBound.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Parameters/SpriteBound.cs (nonexistent)
@@ -1,176 +0,0 @@
1-using System;
2-using Box2DX.Collision;
3-using Box2DX.Common;
4-using Nlgp1.Common;
5-using Nlgp1.Sprites;
6-using Nlgp1.Utilities;
7-
8-namespace Nlgp1.Parameters {
9- public class SpriteBound : ISpriteBound {
10-
11- public SpriteBound( Sprite sprite , AABB aabb ) {
12- this.sprite = sprite;
13- this.aabb = aabb;
14- }
15-
16- public Sprite Sprite {
17- get {
18- return this.sprite;
19- }
20- }
21-
22- private Sprite sprite;
23- private AABB aabb;
24- /// <summary>
25- /// サイズを取得します。
26- /// </summary>
27- public Vec2 Size {
28- get {
29- return new Vec2( this.Width , this.Height );
30- }
31- }
32- /// <summary>
33- /// 横幅を取得または、設定します。
34- /// </summary>
35- public float Width {
36- get {
37- return this.aabb.GetWidth() - ( this.BlankLeft + this.BlankRight );
38- }
39- }
40- /// <summary>
41- /// 縦幅を取得または、設定します。
42- /// </summary>
43- public float Height {
44- get {
45- return this.aabb.GetHeight() - ( this.BlankTop + this.BlankBottom );
46- }
47- }
48-
49- #region 当たり判定の余白
50- /// <summary>
51- /// 左側の余白をピクセル単位で設定または、取得します。
52- /// </summary>
53- public int BlankLeft {
54- get;
55- set;
56- }
57- /// <summary>
58- /// 右側の余白をピクセル単位で設定または、取得します。
59- /// </summary>
60- public int BlankRight {
61- get;
62- set;
63- }
64- /// <summary>
65- /// 上側の余白をピクセル単位で設定または、取得します。
66- /// </summary>
67- public int BlankTop {
68- get;
69- set;
70- }
71- /// <summary>
72- /// 下側の余白をピクセル単位で設定または、取得します。
73- /// </summary>
74- public int BlankBottom {
75- get;
76- set;
77- }
78- #endregion
79-
80- #region 頂点座標
81- /// <summary>
82- /// 左端の座標を取得します。
83- /// </summary>
84- public float Left {
85- get {
86- return this.sprite.X + this.aabb.GetLeft() + this.BlankLeft;
87- }
88- }
89- /// <summary>
90- /// 上端の座標を取得します。
91- /// </summary>
92- public float Top {
93- get {
94- return this.sprite.Y + this.aabb.GetTop() + this.BlankLeft;
95- }
96- }
97- /// <summary>
98- /// 右端の座標を取得します。
99- /// </summary>
100- public float Right {
101- get {
102- return this.sprite.X + this.aabb.GetRight() - this.BlankRight;
103- }
104- }
105- /// <summary>
106- /// 下端の座標を取得します。
107- /// </summary>
108- public float Bottom {
109- get {
110- return this.sprite.Y + this.aabb.GetBottom() - this.BlankBottom;
111- }
112- }
113- #endregion
114-
115- #region 当たり判定
116- /// <summary>
117- /// 対象と衝突しているかどうか判定します。
118- /// </summary>
119- /// <param name="toRect">対象のオブジェクト</param>
120- /// <returns>衝突しているかどうか</returns>
121- public bool HitTest( ISpriteBound toRect ) {
122- return HitTest( toRect , AspectType.Horizontal ) && HitTest( toRect , AspectType.Vertical );
123- }
124- /// <summary>
125- /// 縦または、横の何れかを指定した衝突しているかどうか判定する。
126- /// </summary>
127- /// <param name="toRect">対象のオブジェクト</param>
128- /// <param name="aspect">縦または、横を指定します。</param>
129- /// <returns>衝突しているかどうか</returns>
130- public bool HitTest( ISpriteBound toRect , AspectType aspect ) {
131- switch( aspect ) {
132- case AspectType.Vertical:
133- return Top + BlankTop < toRect.Bottom - toRect.BlankBottom && Bottom - BlankBottom > toRect.Top + toRect.BlankTop;
134- case AspectType.Horizontal:
135- return Left + BlankLeft < toRect.Right - toRect.BlankRight && Right - BlankRight > toRect.Left + toRect.BlankLeft;
136- default:
137- return HitTest( toRect );
138- }
139- }
140- /// <summary>
141- /// 衝突方向を指定して重なってる距離を取得します。
142- /// </summary>
143- /// <param name="dir">衝突方向</param>
144- /// <param name="toRect">対象の短形</param>
145- /// <returns>重なってる部分の距離</returns>
146- public float HitDistance( DirectionType dir , ISpriteBound toRect ) {
147- if( HitTest( toRect ) == false )
148- return 0;
149- if( ( dir == DirectionType.Left || dir == DirectionType.Right ) && HitTest( toRect , AspectType.Horizontal ) ) {
150- switch( dir ) {
151- case DirectionType.Left:
152- return toRect.Left - Right;
153- case DirectionType.Right:
154- return toRect.Right - Left;
155- }
156- } else if( HitTest( toRect , AspectType.Vertical ) ) {
157- switch( dir ) {
158- case DirectionType.Top:
159- return toRect.Bottom - Top;
160- case DirectionType.Bottom:
161- return toRect.Top - Bottom;
162- }
163- }
164- return 0;
165- }
166-
167- public bool HitTest( Vec2 location ) {
168- float left = this.Left + this.BlankLeft;
169- float top = this.Top + this.BlankTop;
170- float right = this.Right - this.BlankRight;
171- float bottom = this.Bottom - this.BlankBottom;
172- return ( left < location.X && location.X < right ) && ( top < location.Y && location.Y < bottom );
173- }
174- #endregion
175- }
176-}
--- trunk/Nlgp1/Nlgp1/Parameters/SpriteRectangle.cs (nonexistent)
+++ trunk/Nlgp1/Nlgp1/Parameters/SpriteRectangle.cs (revision 737)
@@ -0,0 +1,138 @@
1+using System;
2+using Box2DX.Collision;
3+using Box2DX.Common;
4+using Nlgp1.Common;
5+using Nlgp1.Sprites;
6+using Nlgp1.Utilities;
7+
8+namespace Nlgp1.Parameters {
9+ public class SpriteRectangle : ISpriteRectangle {
10+
11+ public SpriteRectangle( Sprite sprite , AABB aabb ) {
12+ this.Sprite = sprite;
13+ this.aabb = aabb;
14+ }
15+
16+ public readonly Sprite Sprite;
17+
18+ public AABB AABB {
19+ get {
20+ return new AABB {
21+ LowerBound = new Vec2( this.Left , this.Top ),
22+ UpperBound = new Vec2( this.Right , this.Bottom ),
23+ };
24+ }
25+ }
26+
27+ private readonly AABB aabb;
28+
29+ /// <summary>
30+ /// サイズを取得します。
31+ /// </summary>
32+ public Vec2 Size {
33+ get {
34+ return new Vec2( this.Width , this.Height );
35+ }
36+ }
37+ /// <summary>
38+ /// 横幅を取得または、設定します。
39+ /// </summary>
40+ public float Width {
41+ get {
42+ return this.aabb.GetWidth() - ( this.BlankLeft + this.BlankRight );
43+ }
44+ }
45+ /// <summary>
46+ /// 縦幅を取得または、設定します。
47+ /// </summary>
48+ public float Height {
49+ get {
50+ return this.aabb.GetHeight() - ( this.BlankTop + this.BlankBottom );
51+ }
52+ }
53+
54+ #region 当たり判定の余白
55+ /// <summary>
56+ /// 左側の余白をピクセル単位で設定または、取得します。
57+ /// </summary>
58+ public int BlankLeft {
59+ get;
60+ set;
61+ }
62+ /// <summary>
63+ /// 右側の余白をピクセル単位で設定または、取得します。
64+ /// </summary>
65+ public int BlankRight {
66+ get;
67+ set;
68+ }
69+ /// <summary>
70+ /// 上側の余白をピクセル単位で設定または、取得します。
71+ /// </summary>
72+ public int BlankTop {
73+ get;
74+ set;
75+ }
76+ /// <summary>
77+ /// 下側の余白をピクセル単位で設定または、取得します。
78+ /// </summary>
79+ public int BlankBottom {
80+ get;
81+ set;
82+ }
83+ #endregion
84+
85+ #region 頂点座標
86+ /// <summary>
87+ /// 左端の座標を取得します。
88+ /// </summary>
89+ public float Left {
90+ get {
91+ return this.aabb.GetLeft() + this.BlankLeft;
92+ }
93+ }
94+ /// <summary>
95+ /// 上端の座標を取得します。
96+ /// </summary>
97+ public float Top {
98+ get {
99+ return this.aabb.GetTop() + this.BlankLeft;
100+ }
101+ }
102+ /// <summary>
103+ /// 右端の座標を取得します。
104+ /// </summary>
105+ public float Right {
106+ get {
107+ return this.aabb.GetRight() - this.BlankRight;
108+ }
109+ }
110+ /// <summary>
111+ /// 下端の座標を取得します。
112+ /// </summary>
113+ public float Bottom {
114+ get {
115+ return this.aabb.GetBottom() - this.BlankBottom;
116+ }
117+ }
118+ #endregion
119+
120+ #region ロジック拡張
121+ public event EventHandler< SpriteRectangleHittedEventArgs > Hitted;
122+
123+ public void OnHitted( object sender , SpriteRectangleHittedEventArgs e ) {
124+ if( this.Hitted != null ) {
125+ this.Hitted( sender , e );
126+ }
127+ }
128+
129+ public event EventHandler< SpriteRectangleActedEventArgs > Acted;
130+
131+ public void OnActed( object sender , SpriteRectangleActedEventArgs e ) {
132+ if( this.Acted != null ) {
133+ this.Acted( sender , e );
134+ }
135+ }
136+ #endregion
137+ }
138+}
--- trunk/Nlgp1/Nlgp1/Parameters/SpriteRectangleActedEventArgs.cs (nonexistent)
+++ trunk/Nlgp1/Nlgp1/Parameters/SpriteRectangleActedEventArgs.cs (revision 737)
@@ -0,0 +1,36 @@
1+using System;
2+using System.Collections.Generic;
3+using Box2DX.Collision;
4+
5+namespace Nlgp1.Parameters {
6+
7+ public sealed class SpriteRectangleActedEventArgs : EventArgs {
8+
9+ public SpriteRectangleActedEventArgs( SpriteRectangle source , IEnumerable< SpriteRectangleTarget > targets ) {
10+ this.Source = source;
11+ this.Targets = targets;
12+ }
13+
14+ public readonly SpriteRectangle Source;
15+
16+ public readonly IEnumerable< SpriteRectangleTarget > Targets;
17+ }
18+
19+ public sealed class SpriteRectangleTarget {
20+
21+ public SpriteRectangleTarget( SpriteRectangle target , Direction direction , float lower , float upper ) {
22+ this.Target = target;
23+ this.Direction = direction;
24+ this.Lower = lower;
25+ this.Upper = upper;
26+ }
27+
28+ public readonly SpriteRectangle Target;
29+
30+ public readonly Direction Direction;
31+
32+ public readonly float Lower;
33+
34+ public readonly float Upper;
35+ }
36+}
--- trunk/Nlgp1/Nlgp1/Parameters/SpriteRectangleHittedEventArgs.cs (nonexistent)
+++ trunk/Nlgp1/Nlgp1/Parameters/SpriteRectangleHittedEventArgs.cs (revision 737)
@@ -0,0 +1,26 @@
1+using System;
2+using Box2DX.Collision;
3+
4+namespace Nlgp1.Parameters {
5+
6+ public sealed class SpriteRectangleHittedEventArgs : EventArgs {
7+
8+ public SpriteRectangleHittedEventArgs( SpriteRectangle source , SpriteRectangle target , Direction direction , float lower , float upper ) {
9+ this.Source = source;
10+ this.Target = target;
11+ this.Direction = direction;
12+ this.Lower = lower;
13+ this.Upper = upper;
14+ }
15+
16+ public readonly SpriteRectangle Source;
17+
18+ public readonly SpriteRectangle Target;
19+
20+ public readonly Direction Direction;
21+
22+ public readonly float Lower;
23+
24+ public readonly float Upper;
25+ }
26+}
--- trunk/Nlgp1/Nlgp1/Parameters/Types.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Parameters/Types.cs (revision 737)
@@ -8,7 +8,7 @@
88 /// 上下左右での方向を表します。
99 /// </summary>
1010 [Flags]
11- public enum DirectionFlags {
11+ public enum Directions {
1212 /// <summary>
1313 /// 方向なし
1414 /// </summary>
@@ -33,32 +33,28 @@
3333 /// <summary>
3434 /// 上・下・左・右の何れかを表す
3535 /// </summary>
36- public enum DirectionType {
36+ public enum Direction {
3737 /// <summary>
38- /// 未指定
39- /// </summary>
40- None = 0,
41- /// <summary>
4238 /// 上
4339 /// </summary>
44- Top = 1 ,
40+ Top = 0 ,
4541 /// <summary>
4642 /// 下
4743 /// </summary>
48- Bottom = 2 ,
44+ Bottom = 1 ,
4945 /// <summary>
5046 /// 左
5147 /// </summary>
52- Left = 4 ,
48+ Left = 2 ,
5349 /// summary>
5450 /// 右
5551 /// </summary>
56- Right = 8
52+ Right = 3
5753 }
5854 /// <summary>
5955 /// 縦・横方向を表す。
6056 /// </summary>
61- public enum AspectType {
57+ public enum Aspect {
6258 /// <summary>
6359 /// 縦方向。垂直
6460 /// </summary>
--- trunk/Nlgp1/Nlgp1/Parameters/ISpriteRectangle.cs (nonexistent)
+++ trunk/Nlgp1/Nlgp1/Parameters/ISpriteRectangle.cs (revision 737)
@@ -0,0 +1,60 @@
1+
2+namespace Nlgp1.Parameters {
3+ public interface ISpriteRectangle {
4+ /// <summary>
5+ /// 横幅を取得または、設定します。
6+ /// </summary>
7+ float Width {
8+ get;
9+ }
10+ /// <summary>
11+ /// 縦幅を取得または、設定します。
12+ /// </summary>
13+ float Height {
14+ get;
15+ }
16+
17+ /// <summary>
18+ /// 左端の座標を取得します。
19+ /// </summary>
20+ float Left {
21+ get;
22+ }
23+ /// <summary>
24+ /// 上端の座標を取得します。
25+ /// </summary>
26+ float Top {
27+ get;
28+ }
29+ /// <summary>
30+ /// 右端の座標を取得します。
31+ /// </summary>
32+ float Right {
33+ get;
34+ }
35+ /// <summary>
36+ /// 下端の座標を取得します。
37+ /// </summary>
38+ float Bottom {
39+ get;
40+ }
41+
42+
43+ int BlankLeft {
44+ get;
45+ set;
46+ }
47+ int BlankRight {
48+ get;
49+ set;
50+ }
51+ int BlankTop {
52+ get;
53+ set;
54+ }
55+ int BlankBottom {
56+ get;
57+ set;
58+ }
59+ }
60+}
--- trunk/Nlgp1/Nlgp1/Program.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Program.cs (revision 737)
@@ -85,31 +85,25 @@
8585 public static void DebugSprite( Sprite s ) {
8686 message = string.Format(
8787 @"Pos > X ={0} Y ={1}
88-Prev > X ={2} Y ={3}
89- Top ={4} Bottom={5} Left={6} Right ={7}
90-Speed > X ={8} Y ={9}
91-Direction = {10}
92-MovingDir = {11}
93-Jump={12} Hit={13} FPS = {14}
94-X = {15} Y = {16}
88+ Top ={2} Bottom={3} Left={4} Right ={5}
89+Speed > X ={6} Y ={7}
90+Direction = {8}
91+MovingDir = {9}
92+Jump={10} Hit={11} FPS = {12}
9593 " ,
96- s.X ,
97- s.Y ,
98- s.PrevX ,
99- s.PrevY ,
100- s.Bound.Top ,
101- s.Bound.Bottom ,
102- s.Bound.Left ,
103- s.Bound.Right ,
94+ s.Action.Position.X ,
95+ s.Action.Position.Y ,
96+ s.Rectangle.Top ,
97+ s.Rectangle.Bottom ,
98+ s.Rectangle.Left ,
99+ s.Rectangle.Right ,
104100 s.Speed.X ,
105101 s.Speed.Y ,
106- s.RestDirection ,
102+ s.Direction ,
107103 s.MovingDirection ,
108104 s.IsNowJumping ,
109105 s.HitPoint ,
110- rate.FlameRate ,
111- s.X - s.PrevX ,
112- s.Y - s.PrevY
106+ rate.FlameRate
113107 );
114108 }
115109 }
--- trunk/Nlgp1/Nlgp1/Utilities/MathEx.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1/Utilities/MathEx.cs (revision 737)
@@ -80,17 +80,22 @@
8080 return aabb.UpperBound.Y;
8181 }
8282
83- public static AABB ToAABB( Vec2 lowerBound , Vec2 upperBound ) {
84- return new AABB {
85- LowerBound = lowerBound,
86- UpperBound = upperBound,
87- };
83+ public static float GetLeft( this Segment segment ) {
84+ return System.Math.Min( segment.P1.X , segment.P2.X );
8885 }
8986
90- public static AABB ToAABB( float left , float top , float right , float bottom ) {
91- return ToAABB( new Vec2( left , top ) , new Vec2( right , bottom ) );
87+ public static float GetTop( this Segment segment ) {
88+ return System.Math.Min( segment.P1.Y , segment.P2.Y );
9289 }
9390
91+ public static float GetRight( this Segment segment ) {
92+ return System.Math.Max( segment.P1.X , segment.P2.X );
93+ }
94+
95+ public static float GetBottom( this Segment segment ) {
96+ return System.Math.Max( segment.P1.Y , segment.P2.Y );
97+ }
98+
9499 /// <summary>
95100 /// キャラクタ間の距離を取得します。
96101 /// </summary>
@@ -98,7 +103,7 @@
98103 /// <param name="toChar">対象のキャラクタ</param>
99104 /// <returns>対象キャラクタとの距離</returns>
100105 public static float Distance( Sprite source , Sprite toChar ) {
101- return MathEx.Sqrt( MathEx.Pow2( source.X - toChar.X ) + MathEx.Pow2( source.Y - toChar.Y ) );
106+ throw new NotImplementedException();
102107 }
103108 /// <summary>
104109 /// 二点間の距離を取得します。
--- trunk/Nlgp1/Nlgp1.Common/Utility.cs (revision 736)
+++ trunk/Nlgp1/Nlgp1.Common/Utility.cs (revision 737)
@@ -2,6 +2,7 @@
22 using System.Collections.Generic;
33 using System.Globalization;
44 using System.IO;
5+using System.Linq;
56 using System.Reflection;
67 using System.Xml;
78
@@ -103,6 +104,10 @@
103104
104105 }
105106
107+ public static IEnumerable< T > GetEnumValues< T >() where T : struct {
108+ return Enum.GetValues( typeof( T ) ).Cast< T >();
109+ }
110+
106111 public static T Construct<T>( params object[] args ) {
107112 return ( T )( typeof( T ).InvokeMember( null , BindingFlags.CreateInstance | BindingFlags.Public , null , null , args ) );
108113 }
Show on old repository browser