private void Awake()
{
character = GameObject.Find("Character").transform;
characterControl = character.GetComponent <CharacterControl>();
map = GetComponent <DrawMap>();
setCameraSize();
}
void Start()
{
_boat = GameObject.FindWithTag("Player");
_currentTile = new Vector3(0, 0, 0);
_mapX = 0;
_mapZ = 0;
/*
* if (_size < 5) { _size = 5; }
*
* if (_size % 2 == 0){ _split = (_size / 2) - 1;} //Is even
* else { _split = (_size / 2); } //Is odd
*/
_islands = Resources.LoadAll <GameObject>("IslandPrefaps");
_pieceX = _water.GetComponent <Renderer>().bounds.size.x;
_pieceZ = _water.GetComponent <Renderer>().bounds.size.z;
_islandTypes = _islands.Length;
Map.LoadMap(_size);
Map.RandomGenerateMap(_size, _islandTypes);
DrawMap.DrawMapStart(_size, _water, _islands, _pieceX, _pieceZ, _objective);
//Instantiate(_water, new Vector3(0, 0, 0), Quaternion.identity);
}
public Test(VirtualResolution virtualResolution, DrawMap drawMap, Movement movement, Camera camera, IRenderer renderer, IAssetLoader assetLoader, SpriteBatch spriteBatch, GameDate gameDate)
{
_camera = camera;
_spriteBatch = spriteBatch;
RegisterSystem(drawMap.UpdateWindTrailTime);
RegisterSystem(drawMap.DrawMapBuffers);
RegisterSystem(drawMap.SetSubRenderer);
RegisterSystem(drawMap.DrawMaskBuffer);
RegisterSystem(drawMap.DrawMaskEntities);
RegisterSystem(drawMap.DrawFringeBuffer);
RegisterSystem(drawMap.DrawFringeEntities);
RegisterSystem(drawMap.FinaliseRender);
//RegisterSystem(drawMap.DebugDrawCollidableEntities, 999);
//RegisterSystem(camera.DebugDraw, 999);
//RegisterSystem(DebugDrawHtml, 1000);
RegisterSystem(movement.ProcessMovement, 0);
test = new WebView(renderer, assetLoader, spriteBatch,
virtualResolution.MaxWidth, virtualResolution.MaxHeight,
"file://content/ui/html/test.html");
gameDate.DisableTimeFlow();
}
private void Awake()
{
rb2d = GetComponent <Rigidbody2D>();
sprite = GetComponent <CharacterSprite>();
map = GameObject.Find("Main Camera").GetComponent <DrawMap>();
cameraMovement = map.GetComponent <CameraMovement>();
groundLayerMask = 1 << LayerMask.NameToLayer("Ground");
}
//internal void MakeDraw(DrawMap drawMap, int seedsTotal, int bestOfTotal)
//{
// Dictionary<int, Player> drawPlayers = new Dictionary<int, Player>();
// int totalDrawPlayers = (int)drawMap;
// int totalDrawMatches = totalDrawPlayers / TOTAL_MATCH_PLAYERS;
// int matchIncrement = (int)Math.Log(
// Convert.ToDouble(totalDrawMatches),
// Convert.ToDouble(TOTAL_MATCH_PLAYERS));
// int playerIndexForward = 0;
// int playerIndexBackward = totalDrawPlayers - 1;
// int playerPos = 1;
// int matchPosForward = 1;
// int matchPosBackward = totalDrawMatches;
// int matchNumber = 1;
// int matchInterval = 0;
// int incrementChangeIndex = 0;
// if(_totalLoadedPlayers < 2)
// throw new Exception("Insufficient loaded players. You must load two or more players.");
// // Set matchs
// for (int matchIndex = 0; matchIndex < totalDrawMatches; matchIndex++)
// {
// // Reset interval increment
// if (incrementChangeIndex == 2)
// {
// if (matchInterval == matchIncrement)
// matchInterval = 0;
// else if (matchInterval == 0)
// matchInterval = matchIncrement;
// incrementChangeIndex = 0;
// }
// Match match = new Match(_players[playerIndexForward], _players[playerIndexBackward], bestOfTotal);
// // Odd match
// if ((matchNumber % 2) != 0)
// {
// match.Number = matchPosForward + matchInterval;
// matchPosForward++;
// }
// // Even match
// else
// {
// match.Number = matchPosBackward - matchInterval;
// matchPosBackward--;
// }
// // Add match on Draw position.
// drawMatchs.Add(match.Number.Value, match);
// // Change indexes.
// incrementChangeIndex++;
// playerIndexForward++;
// playerIndexBackward--;
// matchNumber++;
// // Save players with draw ordered.
// drawPlayers.Add(playerPos, match.Opponent1 as Player);
// drawPlayers.Add(playerPos + 1, match.Opponent2 as Player);
// playerPos += 2;
// }
//}
internal void MakeDraw(DrawMap drawMap, int seedsTotal, int bestOfTotal)
{
Dictionary <int, Player> drawPlayers = new Dictionary <int, Player>();
int totalDrawPlayers = (int)drawMap;
int totalDrawMatches = totalDrawPlayers / TOTAL_MATCH_PLAYERS;
int playerIndexForward = 0;
int playerIndexBackward = totalDrawPlayers - 1;
int playerPos = 1;
int matchPosUp = 1;
int matchPosDown = totalDrawMatches;
if (_totalLoadedPlayers < 2)
{
throw new Exception("Insufficient loaded players. You must load two or more players.");
}
Match match;
// First Match
match = new Match(_players[playerIndexForward], _players[playerIndexBackward], bestOfTotal);
match.Number = matchPosUp;
drawMatchs.Add(match.Number.Value, match);
// Last Match
match = new Match(_players[playerIndexForward++], _players[playerIndexBackward--], bestOfTotal);
match.Number = matchPosDown;
drawMatchs.Add(match.Number.Value, match);
int matchIncrement = (int)Math.Log(
Convert.ToDouble(totalDrawMatches),
Convert.ToDouble(TOTAL_MATCH_PLAYERS));
// Process left of the half matches
for (int matchIndex = 0; matchIndex < (totalDrawMatches / 2) - 2; matchIndex++)
{
// Create match
//match = new Match(_players[playerIndexForward], _players[playerIndexBackward], bestOfTotal);
//match.Number
//// Add match on Draw position.
//drawMatchs.Add(match.Number.Value, match);
// Change indexes.
playerIndexForward++;
playerIndexBackward--;
// Save players with draw ordered.
drawPlayers.Add(playerPos, match.Opponent1 as Player);
drawPlayers.Add(playerPos + 1, match.Opponent2 as Player);
playerPos += 2;
}
}
void Awake()
{
input = GameObject.Find("InputController").GetComponent <InputController>();
world = GameObject.Find("WorldGeneration").GetComponent <WorldGeneration>();
items = GameObject.Find("ItemController").GetComponent <ItemController>();
mapController = GameObject.Find("WorldGeneration").GetComponent <DrawMap>();
uiController = GameObject.Find("UIController").GetComponent <UIController>();
gameController = GameObject.Find("GameController").GetComponent <GameController>();
timeController = GameObject.Find("TimeController").GetComponent <TimeController>();
spriteAnimator = GetComponent <SpriteAnimator>();
}
private void Awake()
{
timer = GameObject.Find("Timer").GetComponent <Text>();
finalTimer = GameObject.Find("FinalTimer").GetComponent <Text>();
panel = GameObject.Find("Panel").GetComponent <Image>();
player = GetComponent <CharacterControl>();
title = GameObject.Find("Title").GetComponent <Image>();
startGame = GameObject.Find("StartGame").GetComponent <Text>();
orbCount = GameObject.Find("OrbCount").GetComponent <Text>();
map = GameObject.Find("Main Camera").GetComponent <DrawMap>();
instructions = GameObject.Find("Instructions");
UpdateOrbText();
}
void Awake()
{
items = GameObject.Find("ItemController").GetComponent <ItemController>();
gameController = GameObject.Find("GameController").GetComponent <GameController>();
drawMap = GetComponent <DrawMap>();
// Initialize the map arrays.
perlin = new float[i_max, j_max];
map = new int[i_max, j_max];
octave = new float[i_max, j_max];
forest = new float[i_max, j_max];
// Initialize the forest sprite array.
tiles = new GameObject[i_max, j_max];
}
private void Start()
{
gameObject.transform.position = Vector3.zero;
Instance = this;
Players = new List <GameObject>();
MyMap = gameObject.AddComponent <DrawMap>();
TeamName = new List <string>();
TeamColor = new List <Color>();
CanvasObject = Instantiate((GameObject)Resources.Load("Prefabs/Panel"));
CanvasObject.transform.SetParent(transform);
Transform tmp = CanvasObject.transform.Find("TilePanel");
TilePanel = tmp.GetComponent <RectTransform>();
tmp = CanvasObject.transform.Find("CharacterPanel");
CharPanel = tmp.GetComponent <RectTransform>();
}
// Use this for initialization
void Start()
{
_drawMap = this.GetComponent <DrawMap>();
MapData.initMapData();
initAudioCtrl();
DrawMap();
if (GameManagerGlobalData.isFirstTimeEnter)
{
setGameState(GameState.Plot);
PlayerAudioCtrl.getInstance().play(PlayerAudioData.CHAPTER_01_1);
PlayerAudioCtrl.getInstance().play(PlayerAudioData.SLIDER_TO_FRONT_TIPS, initGameState);
GameManagerGlobalData.isFirstTimeEnter = false;
}
else
{
initGameState();
}
}
void Update()
{
/*
*
* if (Input.GetKeyDown(KeyCode.K)){
* for (int i = 0; i < 5; ++i)
* {
* Map._Instances[i, 0, 0] = Instantiate(_water, new Vector3(i+1 * 20, 0, 0), Quaternion.identity);
* }
*
* }
* if (Input.GetKeyDown(KeyCode.L))
* {
* for (int i = 0; i < 5; ++i)
* {
* Destroy(Map._Instances[i, 0, 0]);
* }
*
* }
*/
if (_boat.transform.position.z > (_currentTile.z + _pieceZ / 2 + 1))
{
DrawMap.DrawMapUp(_size, _water, _currentTile, _islands, _pieceX, _pieceZ);
_currentTile.z = _currentTile.z + _pieceZ;
}
if (_boat.transform.position.x > (_currentTile.x + _pieceX / 2 + 1))
{
DrawMap.DrawMapRight(_size, _water, _currentTile, _islands, _pieceX, _pieceZ);
_currentTile.x = _currentTile.x + _pieceX;
}
if (_boat.transform.position.x < (_currentTile.x - _pieceX / 2 - 1))
{
DrawMap.DrawMapLeft(_size, _water, _currentTile, _islands, _pieceX, _pieceZ);
_currentTile.x = _currentTile.x - _pieceX;
}
if (_boat.transform.position.z < (_currentTile.z - _pieceZ / 2 - 1))
{
DrawMap.DrawMapDown(_size, _water, _currentTile, _islands, _pieceX, _pieceZ);
_currentTile.z = _currentTile.z - _pieceZ;
}
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMapData(Vector2.zero);
DrawMap display = FindObjectOfType <DrawMap> ();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureSampler2D.TextureFromHeightMap(mapData.heightMap));
}
else if (drawMode == DrawMode.ColourMap)
{
display.DrawTexture(TextureSampler2D.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD), TextureSampler2D.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.FalloffMap)
{
display.DrawTexture(TextureSampler2D.TextureFromHeightMap(FalloffMapGenerator.GenerateFalloffMap(mapChunkSize)));
}
}
private void mainForm_Load(object sender, EventArgs e)
{
varList = new ArrayList();
ioList = new ArrayList();
/////////////////////////////////////////////////////////////
///create a mutex to only a instance
//////////////////////////////////////////////////////////////
bool createNew;
Attribute guid_attr = Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(GuidAttribute));
string guid = ((GuidAttribute)guid_attr).Value;
_mutex = new System.Threading.Mutex(true, guid, out createNew);
if (false == createNew)
{
MessageBox.Show("only a instance");
this.Close();
}
_mutex.ReleaseMutex();
/////////////////////////////////////////////////////////////
///starting watcher
////////////////////////////////////////////////////////////
netScanner = new NetworkScanner(); //
if (this.netWatcher != null) //
{
this.netWatcher.Dispose(); //
this.netWatcher = null;
}
this.netWatcher = new NetworkWatcher(netScanner.Controllers); //watching controller
this.netWatcher.Found += new EventHandler <NetworkWatcherEventArgs>(HandleFoundEvent); //online event
this.netWatcher.Lost += new EventHandler <NetworkWatcherEventArgs>(HandleLostEvent); //offline event
this.netWatcher.EnableRaisingEvents = true; //active event
///////////////////////////////////////////////////////////
///drawing winform
//////////////////////////////////////////////////////////
int ledWidth = SystemInformation.VirtualScreen.Width;
int ledHeight = SystemInformation.VirtualScreen.Height;
this.MaximumSize = new Size(ledWidth, ledHeight); //
this.MinimumSize = new Size(ledWidth, ledHeight);
///calculate some var
panelHide.Top = 0;
panelHide.Left = 0;
panelHide.Width = ledWidth;
panelHide.Height = ledHeight;
DrawMap.GoldenSectionST gsTop, gsLeft;
double topOffset = ledHeight;
double leftOffset = ledWidth;
for (int i = 0; i < 4; i++)
{
gsTop = DrawMap.GoldenSection(topOffset);
topOffset = gsTop.shortGS;
gsLeft = DrawMap.GoldenSection(leftOffset);
leftOffset = gsLeft.shortGS;
}
int topO = (int)topOffset;
int leftO = (int)leftOffset;
drawMap1.Top = 0;
drawMap1.Left = 0;
drawMap1.Width = leftO + 19 * topO;
drawMap1.Height = 5 * topO + 15 * (topO / 3);
int topOff = drawMap1.Height;
int leftOff = drawMap1.Width;
listViewController.Top = topO;
listViewController.Left = leftOff;
listViewController.Width = this.ClientRectangle.Width - leftOff - leftO;
listViewController.Height = topOff;
int colWidth = listViewController.Width / 7;
for (int i = 0; i < 7; i++)
{
listViewController.Columns[i].Width = colWidth;
}
panelLeftTop.Top = topOff + 2 * topO;
panelLeftTop.Left = leftO;
panelLeftTop.Width = listViewController.Width / 2;
panelLeftTop.Height = (this.ClientRectangle.Height - topOff - 3 * topO);
panelLeftBottom.Top = panelLeftTop.Top;
panelLeftBottom.Left = panelLeftTop.Right + leftO;
panelLeftBottom.Width = panelLeftTop.Width;
panelLeftBottom.Height = panelLeftTop.Height;
int labelWidth = listViewController.Right - panelLeftBottom.Right - leftO;
int labelHeight = topO;
labelMode.Top = panelLeftTop.Top;
labelMode.Left = panelLeftBottom.Right + leftO;
labelMode.Size = new Size(labelWidth, labelHeight);
labelMode.Text = "N/A";
labelStatus.Top = labelMode.Bottom + topO / 2;
labelStatus.Left = labelMode.Left;
labelStatus.Size = new Size(labelWidth, labelHeight);
labelStatus.Text = "N/A";
labelExecStatus.Top = labelStatus.Bottom + topO / 2;
labelExecStatus.Left = labelMode.Left;
labelExecStatus.Size = new Size(labelWidth, labelHeight);
labelExecStatus.Text = "N/A";
buttonExit.Size = new Size(labelWidth, 2 * labelHeight);
buttonExit.Top = panelLeftBottom.Bottom - 2 * labelHeight;
buttonExit.Left = labelMode.Left;
buttonExit.Enabled = true;
buttonStart.Size = new Size(labelWidth, 2 * labelHeight);
buttonStart.Top = panelLeftBottom.Bottom - 4 * labelHeight - topO;
buttonStart.Left = labelMode.Left;
buttonStart.Enabled = false;
textBoxRapidList.Top = labelExecStatus.Bottom + topO;
textBoxRapidList.Left = labelMode.Left;
textBoxRapidList.Width = labelWidth;
textBoxRapidList.Height = buttonStart.Top - labelExecStatus.Bottom - 2 * topO;
textBoxRapidList.Enabled = false;
buttonIO.Top = topO;
buttonIO.Left = leftO;
buttonIO.Size = new Size(panelLeftTop.Width - 2 * leftO, 2 * topO);
buttonIO.Enabled = false;
groupBoxInfo.Top = buttonIO.Bottom;
groupBoxInfo.Left = leftO;
groupBoxInfo.Width = panelLeftTop.Width - 2 * leftO;
groupBoxInfo.Height = panelLeftTop.Height - 4 * topO;
for (int i = 0; i < 2; i++)
{
listViewInfo.Columns[i].Width = listViewInfo.Width / 2 - 5;
}
listViewInfo.Enabled = false;
groupBoxInfo.Enabled = false;
groupBoxInfo.Visible = false;
groupBoxMonitor.Top = buttonIO.Bottom;
groupBoxMonitor.Left = leftO;
groupBoxMonitor.Width = panelLeftTop.Width - 2 * leftO;
groupBoxMonitor.Height = panelLeftTop.Height - 4 * topO;
for (int i = 0; i < 3; i++)
{
listViewMonitor.Columns[i].Width = listViewMonitor.Width / 3 - 2;
}
listViewMonitor.Enabled = false;
groupBoxMonitor.Enabled = false;
groupBoxPERS.Top = topO;
groupBoxPERS.Left = leftO;
groupBoxPERS.Width = panelLeftTop.Width - 2 * leftO;
groupBoxPERS.Height = 7 * topO;
groupBoxPERS.Enabled = false;
groupBoxData.Top = groupBoxPERS.Bottom + topO;
groupBoxData.Left = leftO;
groupBoxData.Width = panelLeftTop.Width - 2 * leftO;
groupBoxData.Height = panelLeftBottom.Height - groupBoxPERS.Bottom - 2 * topO;
listViewData.Columns[0].Width = listViewMonitor.Width / 3 - 2;
listViewData.Columns[1].Width = listViewMonitor.Width - listViewData.Columns[0].Width;
listViewData.Enabled = false;
groupBoxData.Enabled = false;
comboBoxTask.Top = topO;
comboBoxTask.Left = leftO;
comboBoxTask.Width = (groupBoxData.Width - 3 * leftO) / 2;
comboBoxTask.Enabled = false;
comboBoxModule.Top = topO;
comboBoxModule.Left = comboBoxTask.Right + leftO;
comboBoxModule.Width = comboBoxTask.Width;
comboBoxModule.Enabled = false;
textBoxName.Top = comboBoxModule.Bottom + topO / 2;
textBoxName.Left = leftO;
textBoxName.Width = comboBoxTask.Width;
textBoxName.Enabled = false;
buttonInput.Top = textBoxName.Bottom + topO / 2;
buttonInput.Left = leftO;
buttonInput.Size = new Size(textBoxName.Width, textBoxName.Height);
buttonInput.Enabled = false;
buttonClear.Top = buttonInput.Top;
buttonClear.Left = comboBoxModule.Left;
buttonClear.Size = new Size(textBoxName.Width, textBoxName.Height);
buttonClear.Enabled = false;
panelHide.Visible = false;
//////////////////////////////////////////////////////////
///scaning
/////////////////////////////////////////////////////////
ScanControllerToListView();
}
// en faire une pour le terrain et une pour temperature / humidity ou whatever ?
// pour pouvoir en afficher plusieurs d'un coup
public static Texture2D GetTexture(TileData[,] tileDataMap, DrawMap drawMap, bool drawUnderwaterSteps, Biome[] biomes)
{
//TileData[,] tileDataMap = mapData.tileDataMap;
int width = tileDataMap.GetLength(0);
int height = tileDataMap.GetLength(1);
Color biomeBorderColor = Color.black; // à mettre avec la suivante en public inspector terrain setting
Color edgeColor = Color.white;
Color cityColor = Color.magenta; // en fonction du thème couleur de la ville ?
var texture = new Texture2D(width, height);
Color[] pixels = new Color[width * height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
// moyen de generaliser le drawing des edges et borders ici
switch (drawMap)
{
case DrawMap.Height:
//Set color range, 0 = black, 1 = white
if (tileDataMap[x, y].isEdge)
{
pixels[x + y * width] = edgeColor;
}
else
{
pixels[x + y * width] = Color.Lerp(Color.black, Color.white, tileDataMap[x, y].terrainHeight);
}
break;
case DrawMap.HeightType:
if (tileDataMap[x, y].isBiomeBorder)
{
pixels[x + y * width] = biomeBorderColor;
}
else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps)
{
pixels[x + y * width] = edgeColor;
}
else
{
pixels[x + y * width] = tileDataMap[x, y].terrainType.color;
}
break;
// sur les trois qui suivent c chiant de pas voir les heights faut refaire des f°
case DrawMap.Humidity:
if (tileDataMap[x, y].isBiomeBorder)
{
pixels[x + y * width] = biomeBorderColor;
}
else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps)
{
pixels[x + y * width] = edgeColor;
}
else
{
pixels[x + y * width] = tileDataMap[x, y].humidityType.color;
}
break;
case DrawMap.Temperature:
if (tileDataMap[x, y].isBiomeBorder)
{
pixels[x + y * width] = biomeBorderColor;
}
else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps)
{
pixels[x + y * width] = edgeColor;
}
else
{
pixels[x + y * width] = tileDataMap[x, y].temperatureType.color;
}
break;
case DrawMap.Biome:
if (tileDataMap[x, y].isBiomeBorder)
{
pixels[x + y * width] = biomeBorderColor;
}
else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps)
{
pixels[x + y * width] = edgeColor;
}
else
{
for (int i = 0; i < biomes.Length; i++)
{
if (biomes[i].biomeType == tileDataMap[x, y].biomeType)
{
pixels[x + y * width] = biomes[i].pixelColor;
break;
}
}
if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.DeepWater)
{
pixels[x + y * width] = tileDataMap[x, y].terrainType.color;
}
else if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.ShallowWater)
{
pixels[x + y * width] = tileDataMap[x, y].terrainType.color;
}
}
break;
case DrawMap.City:
if (tileDataMap[x, y].isBiomeBorder)
{
pixels[x + y * width] = biomeBorderColor;
}
else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps)
{
pixels[x + y * width] = edgeColor;
}
else if (tileDataMap[x, y].isCity)
{
pixels[x + y * width] = cityColor;
}
else
{
for (int i = 0; i < biomes.Length; i++)
{
if (biomes[i].biomeType == tileDataMap[x, y].biomeType)
{
pixels[x + y * width] = biomes[i].pixelColor;
break;
}
}
if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.DeepWater)
{
pixels[x + y * width] = tileDataMap[x, y].terrainType.color;
}
else if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.ShallowWater)
{
pixels[x + y * width] = tileDataMap[x, y].terrainType.color;
}
}
break;
}
}
}
texture.SetPixels(pixels);
texture.wrapMode = TextureWrapMode.Clamp;
texture.Apply();
return(texture);
}
void FixedUpdate()
{
/*
*
* if (Input.GetKeyDown(KeyCode.K)){
* for (int i = 0; i < 5; ++i)
* {
* Map._Instances[i, 0, 0] = Instantiate(_water, new Vector3(i+1 * 20, 0, 0), Quaternion.identity);
* }
*
* }
* if (Input.GetKeyDown(KeyCode.L))
* {
* for (int i = 0; i < 5; ++i)
* {
* Destroy(Map._Instances[i, 0, 0]);
* }
*
* }
*/
if (_boat.transform.position.z > (_currentTile.z + _pieceZ / 2 + 1))
{
//Debug.Log(_mapX + " " + _mapZ + " x and Y before up ");
DrawMap.DrawMapUp(_size, _water, _currentTile, _mapX, _mapZ, _islands, _pieceX, _pieceZ, _objective);
++_mapZ;
if (_mapZ == _size)
{
_mapZ = 0;
}
_currentTile.z = _currentTile.z + _pieceZ;
//Debug.Log(_mapX + " " + _mapZ + " x and Y after up ");
}
if (_boat.transform.position.x > (_currentTile.x + _pieceX / 2 + 1))
{
DrawMap.DrawMapRight(_size, _water, _currentTile, _mapX, _mapZ, _islands, _pieceX, _pieceZ, _objective);
++_mapX;
if (_mapX == _size)
{
_mapX = 0;
}
_currentTile.x = _currentTile.x + _pieceX;
}
if (_boat.transform.position.x < (_currentTile.x - _pieceX / 2 - 1))
{
DrawMap.DrawMapLeft(_size, _water, _currentTile, _mapX, _mapZ, _islands, _pieceX, _pieceZ, _objective);
--_mapX;
if (_mapX == -1)
{
_mapX = _size + _mapX;
}
_currentTile.x = _currentTile.x - _pieceX;
}
if (_boat.transform.position.z < (_currentTile.z - _pieceZ / 2 - 1))
{
//Debug.Log(_mapX + " " + _mapZ + " x and Y before down ");
DrawMap.DrawMapDown(_size, _water, _currentTile, _mapX, _mapZ, _islands, _pieceX, _pieceZ, _objective);
--_mapZ;
if (_mapZ < 0)
{
_mapZ = _size + _mapZ;
}
_currentTile.z = _currentTile.z - _pieceZ;
//Debug.Log(_mapX + " " + _mapZ + " x and Y after down ");
}
}
private void button4_Click_1(object sender, EventArgs e)
{
DrawMap.save(tempath + @"\" + "TcMap.txt");
}
void Awake()
{
PopulateDirectionList();
instance = this;
blocksMapper = new List <BlockMapper>();
}
private void SetUpRounds()
{
// SetUpInfo
Vector2Int positionCurrent = PositionPlayerStart;
rounds = DataMap.GetRoundDatas();
Direct lasDir = Direct.Down;
for (int i = 0; i < rounds.NumberRound - 1; i++)
{
RoundData roundCurrent = rounds.GetRound(i);
roundCurrent.position = positionCurrent;
List <Direct> drs = new List <Direct>();
drs.Add(Direct.Left);
drs.Add(Direct.Right);
drs.Add(Direct.Up);
if (lasDir == Direct.Right)
{
roundCurrent.AddDirect(Direct.Left);
drs.Remove(Direct.Left);
}
if (lasDir == Direct.Left)
{
roundCurrent.AddDirect(Direct.Right);
drs.Remove(Direct.Right);
}
if (lasDir == Direct.Up)
{
roundCurrent.AddDirect(Direct.Down);
}
int a = Random.Range(0, drs.Count);
lasDir = drs[a];
roundCurrent.AddDirect(lasDir);
positionCurrent = GetNewPosition(positionCurrent, lasDir);
}
RoundData bossRound = rounds.GetRound(rounds.NumberRound - 1);
bossRound.position = positionCurrent;
if (lasDir == Direct.Right)
{
bossRound.AddDirect(Direct.Left);
}
if (lasDir == Direct.Left)
{
bossRound.AddDirect(Direct.Right);
}
if (lasDir == Direct.Up)
{
bossRound.AddDirect(Direct.Down);
}
for (int i = 0; i < rounds.NumberRound; i++)
{
RoundData r = rounds.GetRound(i);
SetRoundData(r);
DrawMap.Draw(r.textMap, (Vector3Int)r.position);
}
for (int i = 0; i < rounds.NumberRound - 1; i++)
{
RoundData r1 = rounds.GetRound(i);
RoundData r2 = rounds.GetRound(i + 1);
Vector2Int p1 = r1.position;
Vector2Int p2 = r2.position;
if (p1.x == p2.x)
{
DrawMap.DrawConnect((Vector3Int)r1.GetPositionOutSide(Direct.Up), (Vector3Int)r2.GetPositionOutSide(Direct.Down));
}
else
if (p1.y == p2.y)
{
if (p1.x < p2.x)
{
DrawMap.DrawConnect((Vector3Int)r1.GetPositionOutSide(Direct.Right), (Vector3Int)r2.GetPositionOutSide(Direct.Left));
}
else
{
DrawMap.DrawConnect((Vector3Int)r2.GetPositionOutSide(Direct.Right), (Vector3Int)r1.GetPositionOutSide(Direct.Left));
}
}
}
}
public utils(DrawMap manager)
{
_mapManager = manager;
_instance = this;
}
