private void Start()
{
if (magicBook == null)
{
magicBook = FindObjectOfType <MagicBook> ();
}
if (currentMagicSlot == null)
{
currentMagicSlot = FindObjectOfType <CurrentMagicSlot> ();
}
tileMapManager = GameManager.Instance.tileMapManager;
player = GetComponent <Player> ();
magicBook.OnMagicClickEvent += MagicChange;
currentMagicSlot.OnClickEvent += MagicInput;
magicBook.MagicActionSet();
magicMarker.gameObject.SetActive(false);
if (currentMagic != null)
{
currentMagicSlot.Magic = currentMagic;
}
magicPoint = maxMagicPoint;
GameManager.Instance.ActionOnTurn += TurnRegenMagicPoint;
}
/// <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()
{
//GraphicsDevice
//engine components created
tileMapM = new TileMapManager(this);
audioM = new AudioManager(this);
inputM = new InputManager(this);
//engine helpers created
textM = new TextManager(screenSize.Width);
menuM = new MenuManager(this, textM);
//create engine manager
engineM = new EngineManager(this, tileMapM, eventM, textM, /*fontB,*/ audioM);
//load manager
loadM = new Loader(this);//, textureProcessor);
//associate components with the game
Components.Add(eventM);
Components.Add(menuM);
Components.Add(tileMapM);
Components.Add(audioM);
Components.Add(loadM);
Components.Add(inputM);
Components.Add(engineM);
//add services for storage - disabled for now until missing component fix in place
//Components.Add(new GamerServicesComponent(this));
//create an event to handle exit command
this.Exiting += new EventHandler <EventArgs>(GM_Exiting);
base.Initialize();
}
public override void Adjust()
{
targetList.Clear();
int angle = caster.directionToCoordinate.GetAngle();
foreach (Coordinate coord in searchArea.coordList)
{
Tile targetTile = TileMapManager.GetTile(coord.Rotate(angle) + caster.coordinate);
if (targetTile != null)
{
if (targetTile.unit != null)
{
targetList.Add(targetTile.unit);
}
}
}
foreach (Coordinate coord in searchArea.coordList)
{
Tile targetTile = TileMapManager.GetTile(coord.Rotate(angle) + caster.coordinate);
if (targetTile != null)
{
targetTile.GetComponent <SpriteRenderer>().color = new Color32(255, 100, 100, 255);
}
}
foreach (Effect effect in effectList)
{
effect.targetList = targetList;
effect.Adjust();
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
tileMapManager = GetComponent <TileMapManager> ();
generator = GetComponent <Generator> ();
cameraMovement = gameObject.GetComponent <CameraMovement> ();
uiManager = gameObject.GetComponent <UIManager> ();
if (GameObject.FindGameObjectWithTag("ItemDataBase") == null)
{
itemDataBase = Instantiate(itemDataBase, Vector3.zero, Quaternion.identity) as ItemDataParser;
}
else
{
itemDataBase = GameObject.FindGameObjectWithTag("ItemDataBase").GetComponent <ItemDataParser> ();
}
}
public bool MoveToPosition(Coordinate coordinate)
{
Tile targetTile = TileMapManager.GetTile(coordinate);
if (targetTile != null)
{
if (targetTile.unit == null)
{
TileMapManager.GetTile(this.coordinate).unit = null;
transform.position = targetTile.transform.position;
targetTile.unit = this;
this.coordinate = coordinate;
return(true);
}
else
{
Debug.Log("Can't Move There Position. Aready Unit exist (" + coordinate.x + "," + coordinate.y + ") - move");
return(false);
}
}
else
{
Debug.Log("There is NullTile (" + coordinate.x + "," + coordinate.y + ") - move");
return(false);
}
}
// Use this for initialization
void Start()
{
space = new mSpace(0, 0, width - 1, height - 1);
map = new Tree(space);
map = map.splitmSpace(space, splitTime);
tm = TileMapManager.Instance;
tm.Initialize(width, height);
//Debug.Log(tm.GetTile(1, 2));
//Tile test;
//test = tm.GetTile(1, 2);
//test.SetGroundInfo(EGround.Wall);
Tree temp = map;
drawPath(map, PathType.Wall);
makeRoom(temp);
drawSplitedSpace(temp);
drawPath(map, PathType.Path);
//drawPathBlock(map.root.mx, map.root.my);
//Debug.Log(GetSpaceFromTree(map).root.x);
}
public static void engineInit()
{
//savedata should start first
saveData = new SaveDataManager();
menuManager = new MenuManager();
frameManager = new FrameManager();
tileMapManager = new TileMapManager();
uiManager = new UIManager();
uiManager.AddMessage(new Message(0, 0, "no man was here. v0.1.1", ConsoleColor.White, ConsoleColor.Black), false);
input = new InputManager();
rayTracer = new RayTracer(frameManager.height, frameManager.width, 1, 3, 90, true);
rayTracer.camera.doUpdate = true;
rayTracer.ambientLight = 0.075;
worldManager = new WorldManager(200);
frameManager.addLayer(tileMapManager);
frameManager.addLayer(rayTracer);
frameManager.addLayer(uiManager);
}
//Called on initialization
private void Awake()
{
//Setting the static reference
if (globalReference == null)
{
globalReference = this;
}
else
{
Destroy(this);
return;
}
//Initializing our list of visible tile objects
this.visibleTileObjects = new Dictionary <TileInfo, GameObject>();
//If we're starting a new game, we need to generate the map first
if (GameData.globalReference.loadType == LevelLoadType.GenerateNewLevel)
{
//Determining which of the starting zones to generate
int regionIndex = Mathf.RoundToInt(Random.Range(1, this.GetComponent <CreateMapRegions>().veryEasy.regions.Count)) - 1;
this.CreateNewTileMap(this.GetComponent <CreateMapRegions>().veryEasy.regions[regionIndex]);
}
//If we're loading a previous game we let the SaveLoadManager handle it
else
{
//Loading the tile grid using the SaveLoadManager
SaveLoadManager.globalReference.LoadTileGrid(GameData.globalReference.saveFolder);
}
}
protected virtual void Start()
{
inverseMoveTime = 1f / moveTime;
tileMapManager = GameManager.Instance.tileMapManager;
material = GetComponentInChildren <MeshRenderer> ().material;
Health = maxHealth;
isDead = false;
Shield = 0;
}
private void OnEnable()
{
mainCamera = Camera.main;
mainCamera.transform.position = offset;
tileMapManager = GameManager.Instance.tileMapManager;
tileSize = tileMapManager.tileSize;
mainCamera.orthographicSize = 6 * tileSize;
//GetMinMax ();
}
void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
}
}
//Constructor function for this class
public PlayerProgress(GameData gameData_, TileMapManager tileGrid_, LevelUpManager levelUpManager_, CharacterManager charManager_, QuestTracker questTracker_)
{
//Setting the GameData.cs variables
this.difficulty = gameData_.currentDifficulty;
this.allowNewUnlockables = gameData_.allowNewUnlockables;
this.folderName = gameData_.saveFolder;
this.randState = Random.state;
//Setting the CreateTileGrid.cs variables
this.gridCols = tileGrid_.cols;
this.gridRows = tileGrid_.rows;
//Setting the HUDChallengeRampUpTimer.cs variables
this.currentDifficulty = HUDChallengeRampUpTimer.globalReference.currentDifficulty;
this.currentDifficultyTimer = HUDChallengeRampUpTimer.globalReference.currentTimer;
//Setting the LevelUpManager variable
this.characterLevel = levelUpManager_.characterLevel;
//Setting the PartyGroup.cs variables
this.partyGroup1 = new PartySaveData(PartyGroup.globalReference);
//Looping through all of the dead character info in CharacterManager.cs
this.deadCharacters = new List <DeadCharacterInfo>();
for (int d = 0; d < charManager_.deadCharacters.Count; ++d)
{
this.deadCharacters.Add(charManager_.deadCharacters[d]);
}
//Looping through all of the enemy tile encounters in CharacterManager.cs
this.enemyTileEncounters = new List <EnemyTileEncounterInfo>();
for (int e = 0; e < CharacterManager.globalReference.tileEnemyEncounters.Count; ++e)
{
//Making sure the encounter isn't null first
if (CharacterManager.globalReference.tileEnemyEncounters[e] != null)
{
//Creating a new tile encounter info for the enemy
EnemyTileEncounterInfo enemyInfo = new EnemyTileEncounterInfo(CharacterManager.globalReference.tileEnemyEncounters[e]);
//Adding the enemy encounter info to our list to serialize
this.enemyTileEncounters.Add(enemyInfo);
}
}
//Looping through all of the quests in our quest log
this.questLog = new List <string>();
foreach (Quest q in questTracker_.questLog)
{
this.questLog.Add(JsonUtility.ToJson(new QuestSaveData(q), true));
}
//Saving all of the finished quest names
this.finishedQuests = questTracker_.completedQuestNames;
}
void GiveDamageToPosition(Coordinate position, int damage)
{
Tile targetTile = TileMapManager.GetTile(position);
if (targetTile != null)
{
if (targetTile.unit != null)
{
targetTile.unit.GetDamage(damage);
}
}
}
void Start()
{
//Set the game managers instance to this so that we can access it statically
GameManager.instance = this;
//Initialise the item database
ItemDatabase.LoadDatabase();
//Load the map prefab and initialize it
var prefab = Resources.Load <GameObject>("Prefabs/TileMap");
var instance = Instantiate(prefab);
MapView = instance.GetComponent <ITileMapObject>();
//create the map manager and pass it the map object
MapManager = gameObject.AddComponent <TileMapManager>();
MapManager.Initialize(MapView);
selectionPrefab = Resources.Load <GameObject>("Prefabs/SelectedObject");
//Initialize the starting state of the game
StartGame();
}
void drawSpace(mSpace target)
{
Tile test;
//Debug.Log(target.x + " " + target.y + " " + target.w + " " + target.h);
for (int i = 0; i < target.h + 1; i++)
{
for (int j = 0; j < target.w + 1; j++)
{
if (i == 0 || i == target.h || j == 0 || j == target.w)
{
test = TileMapManager.GetTile(new Coordinate(target.x + j, target.y + i));
test.SetGroundInfo(E_Ground.Wall);
}
else
{
test = TileMapManager.GetTile(new Coordinate(target.x + j, target.y + i));
test.SetGroundInfo(E_Ground.Ground);
}
}
}
}
void drawPathBlock(int x, int y, PathType type)
{
Tile test;
if (type == PathType.Wall)
{
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 2; j++)
{
if (i != 0 && j != 0)
{
test = TileMapManager.GetTile(new Coordinate(x + i, y + j));
test.SetGroundInfo(E_Ground.Wall);
}
}
}
}
else
{
test = TileMapManager.GetTile(new Coordinate(x, y));
test.SetGroundInfo(E_Ground.Ground);
}
}
private void Start()
{
tileMapManager = GameManager.Instance.tileMapManager;
}
public void Dead()
{
TileMapManager.GetTile(coordinate).unit = null;
Destroy(gameObject);
}
/// <summary>
/// Called from PopulateTileMap. Creates all locations tied to this region
/// </summary>
/// <param name="regionInfo_">The RegionInfo that contains all of the locations to spawn</param>
private void SpawnLocations(RegionInfo regionInfo_)
{
//Reference to the TileMapManager for easy use
TileMapManager tileMap = TileMapManager.globalReference;
//A copy of our node list so we can make sure there are no duplicate spawns
List <TileInfo> nodeListCopy = new List <TileInfo>();
for (int copy = 0; copy < this.nodePoints.Count; copy++)
{
nodeListCopy.Add(this.nodePoints[copy]);
}
//Spawning the city
int spawnIndex = Mathf.RoundToInt(Random.Range(0, nodeListCopy.Count - 1));
TileInfo spawnLoc = nodeListCopy[spawnIndex];
spawnLoc.decorationModel = regionInfo_.regionCity.gameObject;
tileMap.cityTiles.Add(spawnLoc);
nodeListCopy.RemoveAt(spawnIndex);
//Spawning the dungeon
spawnIndex = Mathf.RoundToInt(Random.Range(0, nodeListCopy.Count - 1));
spawnLoc = nodeListCopy[spawnIndex];
spawnLoc.decorationModel = regionInfo_.regionDungeon.gameObject;
tileMap.dungeonTiles.Add(spawnLoc);
nodeListCopy.RemoveAt(spawnIndex);
//Figuring out which of the locations to spawn
List <int> locationsToSpawn = new List <int>();
for (int l = 0; l < regionInfo_.locationList.Count; l++)
{
//Looping through each location to see how many times it should be spawned
for (int s = 0; s < regionInfo_.locationList[l].maxNumber; s++)
{
//If our count is below the minimum number of instances, we add the location without rolling
if (s < regionInfo_.locationList[l].minNumber)
{
locationsToSpawn.Add(l);
}
//Otherwise we roll to see if this instance of the location should be spawned
else
{
float roll = Random.Range(0f, 1f);
if (roll < regionInfo_.locationList[l].spawnChance)
{
locationsToSpawn.Add(l);
}
}
}
}
//Spawning each of the locations
for (int i = 0; i < locationsToSpawn.Count; i++)
{
spawnIndex = Mathf.RoundToInt(Random.Range(0, nodeListCopy.Count - 1));
spawnLoc = nodeListCopy[spawnIndex];
spawnLoc.decorationModel = regionInfo_.locationList[locationsToSpawn[i]].location.gameObject;
nodeListCopy.RemoveAt(spawnIndex);
}
}
void Awake()
{
Instance = this;
}
static void Main(string[] args)
{
double sum = 0;
double sum2 = 0;
double sum3 = 0;
long inUse = 0;
int iterations = 1;
int updateIterations = 1;
int startX = -627;
int startY = -1;
int endX = -627;
int endY = 1;
TileMapManager tileMapManager;
for (int b = 0; b < iterations; b++)
{
Stopwatch watch = new Stopwatch();
watch.Start();
GeneratorSettings settings = new GeneratorSettings(1, 50, 1.5f, 1000000, 10000000, true, 1000f);
AreaSpread[] spreads = new AreaSpread[7]
{
new AreaSpread(1, 1, 0.30f, 20, 250, true, true, 5, SpreadOption.Circle, LayerType.Height),
new AreaSpread(2, 1, 0.125f, 20, 200, true, true, 5, SpreadOption.Circle, LayerType.Height),
new AreaSpread(2, 0, 0.01f, 1, 2, false, false, 0, SpreadOption.None, LayerType.PointsOfInterest),
new AreaSpread(3, 0, 0.005f, 1, 2, false, false, 0, SpreadOption.None, LayerType.PointsOfInterest),
new AreaSpread(4, 0, 0.005f, 1, 2, false, false, 0, SpreadOption.None, LayerType.PointsOfInterest),
new AreaSpread(5, 0, 0.005f, 1, 2, false, false, 0, SpreadOption.None, LayerType.PointsOfInterest),
new AreaSpread(6, 0, 0.005f, 1, 2, false, false, 0, SpreadOption.None, LayerType.PointsOfInterest)
};
tileMapManager = new TileMapManager(settings, spreads);
tileMapManager.Changelevel(settings, startX, startY, false);
StreamedTileMap map = tileMapManager.CurrentLevel;
watch.Stop();
double seconds = watch.Elapsed.TotalSeconds;
tileMapManager.Update(startY, startX);
Tile[] screenMap = map.GetTileMapInScreen(800, 600);
SaveToFile(screenMap, null, "screenMap" + b.ToString(), 800 / 50);
watch.Restart();
int counter = 0;
for (int k = 0; k < 9; k++)
{
counter += SaveToFile(map.Maps[k].MapSurface, map.Maps[k].ObjectPlacement, "map" + b.ToString() + "_" + k.ToString(), map.TileColumnCount);
}
watch.Stop();
watch.Restart();
tileMapManager.Update(endY, endX);
watch.Stop();
double update1 = watch.Elapsed.TotalSeconds;
Thread.Sleep(5000); //wait for generation thread (only for debugging)
watch.Restart();
tileMapManager.Update(endY, endX);
watch.Stop();
double update2 = watch.Elapsed.TotalSeconds;
for (int k = 0; k < 9; k++)
{
counter += SaveToFile(map.Maps[k].MapSurface, map.Maps[k].ObjectPlacement, "map2_" + b.ToString() + "_" + k.ToString(), map.TileColumnCount);
}
Log("Tiles generated: " + counter.ToString());
Log("Generation time: " + seconds.ToString() + " seconds");
Log("Write time: " + watch.Elapsed.TotalSeconds.ToString() + " seconds");
Log("Update1 time: " + update1.ToString() + " seconds");
Log("Update2 time: " + update2.ToString() + " seconds");
screenMap = map.GetTileMapInScreen(800, 600);
SaveToFile(screenMap, null, "screenMap2_" + b.ToString(), 800 / 50);
for (int i = 0; i < updateIterations; i++)
{
watch.Restart();
tileMapManager.Update(endY - i, endX - i);
Tile[] data = map.GetTileMapInScreen(800, 600);
watch.Stop();
update2 = watch.Elapsed.TotalMilliseconds;
sum += update2;
Log("Update time: " + update2.ToString() + " ms");
inUse += Process.GetCurrentProcess().PrivateMemorySize64;
Log("MemoryInUse: " + Process.GetCurrentProcess().PrivateMemorySize64.ToString() + " byte");
}
watch.Restart();
tileMapManager.Update(startY, startX);
watch.Stop();
update2 = watch.Elapsed.TotalMilliseconds;
sum2 += update2;
Log("Update time: " + update2.ToString() + " ms");
Thread.Sleep(2000);
watch.Restart();
tileMapManager.Update(startY, startX);
watch.Stop();
update2 = watch.Elapsed.TotalMilliseconds;
sum3 += update2;
Log("Update time: " + update2.ToString() + " ms");
Log("Done");
}
Console.Clear();
Log("Iterations: " + iterations.ToString());
Log("UpdateIterations: " + (iterations * updateIterations).ToString());
Log("Avg Update Time: " + (sum / (iterations * updateIterations)).ToString() + " ms");
Log("Avg Update Time (Pre GridChange):" + (sum2 / iterations).ToString() + " ms");
Log("Avg Update Time (GridChange):" + (sum3 / iterations).ToString() + " ms");
Log("Avg MemoryInUse: " + (inUse / (iterations * updateIterations)).ToString() + " byte");
Log("Final MemoryInUse: " + Process.GetCurrentProcess().PrivateMemorySize64.ToString() + " byte");
MatchFiles();
Console.ReadKey();
}
private void Start()
{
tileMapManager = GameManager.Instance.tileMapManager;
GameManager.Instance.ActionOnTurn += ItemSpawn;
itemIndex = 0;
}
/// <summary>
/// This constructs a path from the specified start point to
/// some point in the set of destinations.
///
/// Will only construct paths up to a certain maximum COST;
/// as of now, going from one square to another costs 1 unit.
/// So the maximum cost is the maximum path length.
///
/// Returns null if no path was found.
///
/// Running time (if no path is found, the worst case) is O(k+n^2), where
/// n=maxCost
/// k=destinations.Count
///
/// Assumes no negative cost paths, as in Djikstra's algorithm
/// </summary>
/// <param name="startPoints">The set of start points we could be happy with.</param>
/// <param name="goalPoints">The set of possible destinations we could be happy with.</param>
/// <param name="maxCost">Maximum cost of any path.</param>
/// <param name="manager">The WorldManager that we use to do our pathing.</param>
/// <param name="startTime">The time we start the algorithm. Use GameTime.TotalGameTime</param>
/// <returns>The shortest path from here to somewhere in there; returns null iff there is no path of cost less than maxCost.</returns>
public static Path GetPath <T, S, M>(HashSet <Point> startPoints, HashSet <Point> goalPoints, int maxCost, TileMapManager <T, S, M> manager, TimeSpan startTime)
where T : InGameObject
where S : MapCell, Copyable <S>
where M : TileMap <S>, new()
{
//check for trivialities- we can't find a path to nowhere or from nowhere
if (goalPoints.Count == 0 || startPoints.Count == 0)
{
return(null);
}
Heap <Path> heap = null;
if (goalPoints.Count == 1)
{
heap = new PathToPointHeap(goalPoints.Single());
}
else
{
heap = new PathHeap();
}
//now set up a list of points we've seen before, so as to not
//check the same position a billion times
Dictionary <Point, int> bestDistancesFound = new Dictionary <Point, int>();
foreach (Point startPoint in startPoints)
{
bestDistancesFound[startPoint] = 0;
heap.Add(new Path(startPoint));
if (goalPoints.Contains(startPoint))
{
return(new Path(startPoint));
}
}
while (heap.Count > 0)
{
//if there's new passability information, start the process over
if (manager.LastGeneralPassabilityUpdate != null && //if it's null, we're definitely OK
startTime < manager.LastGeneralPassabilityUpdate)
{
startTime = manager.LastGeneralPassabilityUpdate;
heap.Clear();
bestDistancesFound = new Dictionary <Point, int>();
foreach (Point startPoint in startPoints)
{
bestDistancesFound[startPoint] = 0;
heap.Add(new Path(startPoint));
}
}
Path bestPath = heap.Pop();
//if we didn't cap out our path length yet,
//check out the adjacent points to form longer paths
if (bestPath.Cost < maxCost)
{
int newCost = bestPath.Cost + 1;
//for each possible extension ...
foreach (Point adj in manager.GetAdjacentPoints(bestPath.End.X, bestPath.End.Y))
{
//if we hit a destination, great, stop
if (goalPoints.Contains(adj))
{
return(new Path(bestPath, adj, newCost));
}
//don't bother adding this possible extension back on unless
//it's either a completely new point or a strict improvement over another path
if (bestDistancesFound.Keys.Contains(adj) && bestDistancesFound[adj] <= newCost)
{
continue;
}
//otherwise, this is a perfectly serviceable path extension and we should look into it
bestDistancesFound[adj] = newCost;
heap.Add(new Path(bestPath, adj, newCost));
}
}
}
return(null);
}
/// <summary>
/// This constructs a path from the specified start point to
/// some point in the set of destinations.
///
/// Will only construct paths up to a certain maximum COST;
/// as of now, going from one square to another costs 1 unit.
/// So the maximum cost is the maximum path length.
///
/// Returns null if no path was found.
///
/// Running time (if no path is found, the worst case) is O(k+n^2), where
/// n=maxCost
/// k=destinations.Count
///
/// Assumes no negative cost paths, as in Djikstra's algorithm
/// </summary>
/// <param name="startPoint">The point we start from.</param>
/// <param name="goalPoints">The set of possible destinations we could be happy with.</param>
/// <param name="maxCost">Maximum cost of any path.</param>
/// <param name="manager">The WorldManager that we use to do our pathing.</param>
/// <param name="startTime">The time we start the algorithm.</param>
/// <returns>The shortest path from here to somewhere in there; returns null iff there is no path of cost less than maxCost.</returns>
public static Path GetPath <T, S, M>(Point startPoint, HashSet <Point> goalPoints, int maxCost, TileMapManager <T, S, M> manager, TimeSpan startTime)
where T : InGameObject
where S : MapCell, Copyable <S>
where M : TileMap <S>, new()
{
HashSet <Point> startPoints = new HashSet <Point>();
startPoints.Add(startPoint);
return(GetPath(startPoints, goalPoints, maxCost, manager, startTime));
}
/// <summary>
/// This constructs a path from the specified start point to
/// some point in the set of destinations.
///
/// Will only construct paths up to a certain maximum COST;
/// as of now, going from one square to another costs 1 unit.
/// So the maximum cost is the maximum path length.
///
/// Returns null if no path was found.
///
/// Running time (if no path is found, the worst case) is O(k+n^2), where
/// n=maxCost
/// k=destinations.Count
///
/// Assumes no negative cost paths, as in Djikstra's algorithm
/// </summary>
/// <param name="startPoint">The point we start from.</param>
/// <param name="goalPoints">The set of possible destinations we could be happy with.</param>
/// <param name="maxCost">Maximum cost of any path.</param>
/// <param name="manager">The WorldManager that we use to do our pathing.</param>
/// <param name="startTime">The time we start the algorithm.</param>
/// <returns>The shortest path from here to somewhere in there; returns null iff there is no path of cost less than maxCost.</returns>
public static Path GetPath <T, S, M>(Point startPoint, HashSet <Point> goalPoints, int maxCost, TileMapManager <T, S, M> manager, GameTime startTime)
where T : InGameObject
where S : MapCell, Copyable <S>
where M : TileMap <S>, new()
{
return(PathHunter.GetPath <T, S, M>(startPoint, goalPoints, maxCost, manager, startTime.TotalGameTime));
}
public void Move(E_Direction direction)
{
leader.direction = direction;
Coordinate nextPosition;
switch (direction)
{
case E_Direction.Up:
nextPosition = new Coordinate(0, 1);
break;
case E_Direction.Left:
nextPosition = new Coordinate(-1, 0);
break;
case E_Direction.Down:
nextPosition = new Coordinate(0, -1);
break;
case E_Direction.Right:
nextPosition = new Coordinate(1, 0);
break;
default:
nextPosition = new Coordinate(0, 0);
break;
}
Coordinate resultPosition = leader.coordinate;
TraceInfo traceInfo = new TraceInfo(direction, leader.coordinate);
for (int point = 1; point <= leader.movePoint; point++)
{
Tile t = TileMapManager.GetTile(nextPosition * point + leader.coordinate);
if (t != null)
{
//이동 가능한지 확인구간
if (t.unit == null)
{
traceInfo = new TraceInfo(direction, resultPosition);
resultPosition = nextPosition * point + leader.coordinate;
AddTrace(traceInfo);
}
else
{
break;
}
}
else
{
break;
}
}
leader.MoveToPosition(resultPosition);
for (int index = 0; index < memberList.Count; index++)
{
if (positionTrace.Count - 1 >= index)
{
memberList[index].MoveToPosition(positionTrace[index].coordinate);
memberList[index].direction = positionTrace[index].direction;
}
else
{
break;
}
}
//문제 발생 가능함. 리더의 밀쳐지기 혹은 급작스런 이동시.
}