private IEnumerable <GameObject> LoadGameObjects(MinerGame game, StageLevel level)
{
var gameObjectsList = new List <GameObject>();
gameObjectsList.Add(new Player(game, Player));
gameObjectsList.AddRange(Terrain.Select(t => new Terrain(game, t)));
return(gameObjectsList);
}
private static string GetStageFilePath(StageLevel stageLevel)
{
var pathBase = AppSettings.Default.StagesPath;
pathBase += stageLevel.ToString().ToLower();
pathBase += ".xml";
return(pathBase);
}
public static IndexEntry GetEntry( this Conflict conflict, StageLevel stageLevel )
{
switch ( stageLevel ) {
case StageLevel.Ancestor:
return conflict.Ancestor;
case StageLevel.Ours:
return conflict.Ours;
case StageLevel.Theirs:
return conflict.Theirs;
default:
return null;
}
}
public static Stage Create(MinerGame game, StageLevel level)
{
Stage stage;
XmlSerializer serializer = new XmlSerializer(typeof(StageCreator));
using (var reader = new StreamReader(GetStageFilePath(level)))
{
var creator = (StageCreator)serializer.Deserialize(reader);
var objects = creator.LoadGameObjects(game, level);
stage = new Stage(game, level, creator.Size, objects);
}
return(stage);
}
public override int GetHashCode()
{
int hash = 1;
if (StageLevel != 0)
{
hash ^= StageLevel.GetHashCode();
}
hash ^= map_.GetHashCode();
hash ^= monsters_.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public void SetStageItem(int index, StageLevel level, int stageindex)
{
if (myStageList.Length == 0)
{
myStageList = GetComponentsInChildren <StageItem>();
for (int i = 0; i < myStageList.Length; ++i)
{
myStageList[i].gameObject.SetActive(false);
}
}
if (myStageList.Length > index && myStageList[index] != null)
{
myStageList[index].gameObject.SetActive(true);
myStageList[index].SetStageInfomation(level, stageindex);
}
}
public void PostComplexPlan()
{
var id = Guid.NewGuid().ToString();
const StageLevel Level = StageLevel.MultiPack;
// Create a plan with a stage that has a limit
var stage = new Stage {
StageLevel = Level
};
stage.Limits.Add(new Limit());
var item = new Plan {
PlanId = id
};
item.Stages.Add(stage);
var result = this.controller.Post(item);
Assert.IsNotNull(result);
Assert.IsInstanceOf <CreatedAtRouteResult>(result);
var res = result as CreatedAtRouteResult;
Assert.AreEqual((int)HttpStatusCode.Created, res.StatusCode);
Assert.IsTrue(res.RouteValues.ContainsKey("id"));
Assert.IsInstanceOf <Plan>(res.Value);
// Get the plan
result = this.controller.Get(id);
Assert.IsNotNull(result);
Assert.IsInstanceOf <OkObjectResult>(result);
var objectResult = result as OkObjectResult;
Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
Assert.IsInstanceOf <Plan>(objectResult.Value);
// Test the plan
item = objectResult.Value as Plan;
Assert.AreEqual(item.PlanId, id);
// Test for one stage
Assert.AreEqual(item.Stages.Count, 1);
Assert.AreEqual(item.Stages[0].StageLevel, Level);
// Test for one limit in the stage
Assert.AreEqual(item.Stages[0].Limits.Count, 1);
}
/// <summary>
/// Initialises a new instance of the <see cref="DoDrawing" /> class.
/// </summary>
///
/// <param name="drawingId"> The drawing id to evaluate. </param>
/// <param name="repository"> The repository the drawing is persistent in. </param>
private DoDrawing(string drawingId, IDrawingRepository repository)
{
this.repository = repository;
this.drawing = this.repository.Find(drawingId);
this.stageLevel = StageLevel.New;
var level = StageLevel.New;
foreach (Stage stage in this.drawing.Packs[0].Stages)
{
if (stage.Results.Count != 0)
{
this.stageLevel = level;
}
++level;
}
this.result = 0;
}
public Stage(MinerGame game, StageLevel level, Vector2 size, IEnumerable <GameObject> objects)
: base(game)
{
Level = level;
Size = size;
CollisionSolver = new CollisionSolver(this, game);
GameObjects = objects.ToList();
Game.Components.Add(CollisionSolver);
foreach (var o in GameObjects)
{
Game.Components.Add(o);
}
Player = (Player)Game.Components.Single(o => o is Player);
}
public static string GetConflictContent( string rootFolder, StageLevel stage, string conflict )
{
using ( var repository = new Repository( rootFolder ) ) {
var conflictEntry = repository.Index.Conflicts.FirstOrDefault( c => c.GetPath() == conflict );
if ( conflictEntry == null ) {
throw new InvalidDataException( "Could not find the matching conflict entry for " + conflict );
}
IndexEntry entry = conflictEntry.GetEntry( stage );
if ( entry == null ) {
return null;
}
Blob stageBlob = repository.Lookup<Blob>( entry.Id );
using ( var reader = new StreamReader( stageBlob.GetContentStream() ) ) {
return reader.ReadToEnd();
}
}
}
public override void OnPress (GameObject oBtn)
{
if (oBtn.name == "BtnEasy") {
m_eStageLevel = StageLevel.Easy;
} else if (oBtn.name == "BtnNormal") {
m_eStageLevel = StageLevel.Normal;
} else if (oBtn.name == "BtnHard") {
m_eStageLevel = StageLevel.Hard;
} else if (oBtn.name == "BtnGameStart") {
InGameData ();
AdsData.PlayAds ();
} else if (oBtn.name == "BtnBack") {
ResetGold ();
ResetItem ();
m_sManager.SetScene (SceneState.Main);
} else if (oBtn.name == "ViewEffect") {
m_eEffect = SkillState.None;
} else if (oBtn.name == "ViewMath") {
m_eMath = SkillState.None;
} else if (oBtn.name == "ViewPassive") {
m_ePassive = SkillState.None;
} else if (oBtn.name.Contains ("Skill")) {
int idx = int.Parse (oBtn.name.Replace ("Skill", ""));
if (3 > idx) {
if (HasEnoughGold((SkillState)idx, m_eMath, m_ePassive)) {
m_eEffect = (SkillState)idx;
}
} else if (5 < idx) {
if (HasEnoughGold(m_eEffect, m_eMath, (SkillState)idx)) {
m_ePassive = (SkillState)idx;
}
} else {
if (HasEnoughGold(m_eEffect, (SkillState)idx, m_ePassive)) {
m_eMath = (SkillState)idx;
}
}
}
SetStageLevel ();
SetAllSkill ();
}
public override void MakeObjects()
{
Size windowSize = WinformRender.Instance.NowForm.Size;
Size gameSize = new Size(224, 304);
Vec2D playerStartPoint = new Vec2D(gameSize.Width / 2, gameSize.Height - 32);
// 백그라운드 오브젝트 생성
BackGround backGround = new BackGround();
backGround.Name = "BackGround";
Vec2D point = new Vec2D(224 / 2, 320 / 2);
backGround.transform.position = point;
AddObject(backGround);
backGround = new BackGround();
point = new Vec2D(224 / 2, 320 / 2 - 320 + 8);
backGround.transform.position = point;
AddObject(backGround);
backGround = new BackGround();
point = new Vec2D(224 / 2, 320 / 2 - 640 + 16);
backGround.transform.position = point;
AddObject(backGround);
Size BackgroundSize = backGround.GetComponent <SpriteComponent>().Image.Size;
// 플레이어 생성
Player player = new Player();
point = playerStartPoint;
player.transform.position = point;
InputComponent input = player.GetComponent <InputComponent>();
if (input != null)
{
input.MaxWidth = gameSize.Width;
}
TargetScrolling targetScrolling = player.GetComponent <TargetScrolling>();
if (targetScrolling != null)
{
targetScrolling.Destination = playerStartPoint;
}
AddObject(player);
// 게임 중앙에 모이기 위한 위치 설정
CompanyHeadquarter company = new CompanyHeadquarter();
point = new Vec2D(224 / 2, 16 * 5);
company.transform.position = point;
AddObject(company);
GameObject unitPosition;
Vec2D localPoint;
int totalLine = 6;
int[] enemyCountAtLine = new int[] { 4, 4, 8, 8, 10, 10 };
// 여러개의 빈 오브젝트를 생성해서 위의 company의 자식으로 설정
// 부모만 움직이면 자식도 움직이기 설정
for (int t = 0; t < totalLine; t++)
{
for (int i = 0; i < enemyCountAtLine[t]; i++)
{
unitPosition = new GameObject();
company.transform.SetChild(unitPosition);
localPoint = new Vec2D(16 * i - (enemyCountAtLine[t] / 2 - 1) * 16 - 8, 16 * t - 40);
unitPosition.transform.localPosition = localPoint;
AddObject(unitPosition);
}
}
EnemySpawner enemySpawner = new EnemySpawner();
AddObject(enemySpawner);
PlayerLifeManager playerLifeManager = new PlayerLifeManager();
LifeManager lifeManager = playerLifeManager.GetComponent <LifeManager>();
if (lifeManager != null)
{
lifeManager.playerhealth = player.GetComponent <HealthSystem>();
lifeManager.player = player;
}
AddObject(playerLifeManager);
Text score = new Text();
score.transform.position = new Vec2D(gameSize.Width / 10 * 4, 0);
TextComponet textComponet = score.GetComponent <TextComponet>();
AddObject(score);
Text gameOver = new Text();
gameOver.transform.position = new Vec2D(gameSize.Width / 10 * 3, gameSize.Height / 2);
TextComponet textComponet2 = gameOver.GetComponent <TextComponet>();
textComponet2.Text = "GameOver";
gameOver.Enabled = false;
AddObject(gameOver);
StageLevel stageLevel = new StageLevel();
Vec2D vec2D = new Vec2D();
vec2D.X = gameSize.Width;
vec2D.Y = gameSize.Height - 8;
stageLevel.transform.position = vec2D;
stageLevel.Enabled = false;
AddObject(stageLevel);
UIManagerObject uIManagerObject = new UIManagerObject();
UIManager uIManager = uIManagerObject.GetComponent <UIManager>();
if (textComponet != null && uIManager != null)
{
uIManager.scoreText = textComponet;
uIManager.gameOverObject = gameOver;
uIManager.stageLevelObejct = stageLevel;
}
AddObject(uIManagerObject);
WayPointManager wayPointManager = new WayPointManager();
WayPoints wayPoints = wayPointManager.GetComponent <WayPoints>();
wayPoints.GameSize = new Vec2D(gameSize.Width, gameSize.Height);
AddObject(wayPointManager);
GameManagerObject gameManagerObject = new GameManagerObject();
AddObject(gameManagerObject);
}
public static string ToString(StageLevel stageLevel)
{
return ToInt(stageLevel).ToString();
}
public static int ToInt(StageLevel stageLevel)
{
return (int)stageLevel;
}
public void SetStageInfomation(StageLevel level, int stageindex)
{
txtStage.text = stageindex.ToString();
_stageSceneCode = level.StageCode;
_myLevel = level;
}
