public void set2DArray()
{
data = new ArrayLayout();
ArrayLayout.COLUMNS = c_COLUMNS;
data.rows = new ArrayLayout.rowData[b_ROWS];
data.make_columns();
}
public void set2DArray()
{
data = new ArrayLayout();
ArrayLayout.COLUMNS = Game_Controller.Instance.COLUMNS;
data.rows = new ArrayLayout.rowData[Game_Controller.Instance.ROWS];
data.make_columns();
}
public void changeRoomList()
{
if (pmove.playerFloor == "FirstFloor")
{
rooms = FirstFloor;
}
else if (pmove.playerFloor == "SecondFloor")
{
rooms = SecondFloor;
}
else if (pmove.playerFloor == "ThirdFloor")
{
rooms = ThirdFloor;
}
}
// assumes that there are n_dims indices pushed onto stack
// stack balance: in = n_dims, out = 1
private void calc_offset(ArrayLayout arr, int n_dims)
{
var dims = 0.UpTo(n_dims - 1);
dims.Reverse().ForEach((dim, i) =>
{
var @ref = arr.Node.AssertCast <HirExpression>();
Func <int, HirExpression> get_length = dim1 =>
{
var m_getlength = typeof(Array).GetMethod("GetLength").AssertNotNull();
return(new Eval(new Apply(new Lambda(m_getlength), @ref, new HirConst(dim1))));
};
var e_subprod = (dim + 1).UpTo(n_dims - 1).Fold(null as HirExpression, (curr, j) =>
{
var factor = get_length(j);
return(curr == null ? factor : Operator.Multiply(curr, factor));
}) ?? new HirConst(1);
ld(e_subprod);
ld("mul.lo");
if (i != 0)
{
ld("add");
}
if (i != n_dims - 1)
{
swap();
}
});
var r_offset = (Reg)pop_expr();
var el_t = arr.Node.Type().GetElementType();
var el_sz = Marshal.SizeOf(el_t);
_ptx.Add(new mul {
mode = mulm.lo, type = typeof(int), d = r_offset, a = r_offset, b = new PtxConst(el_sz)
});
push(r_offset);
var raw = (Reg)arr.Ptr.Offset.Base;
ld(raw);
op("add");
}
public static List <Position> CoveredPositions(this ArrayLayout layout, Position location)
{
var coveredPositions = new List <Position>();
for (int y = 0; y < layout.column.Length; y++)
{
for (int x = 0; x < layout.column[y].row.Length; x++)
{
if (layout.column[y].row[x])
{
var pos = new Position(x, y) + location - BuildingData.center;
//print(new Position(x, y) + center - BuildingData.center);
//myTile.itemPlaceable = false;
coveredPositions.Add(pos);
}
}
}
return(coveredPositions);
}
private void HandleGridUpdate()
{
if (grid == null)
{
grid = new ArrayLayout();
}
if (grid.rows == null)
{
grid.rows = new List <ArrayLayout.RowData>();
ArrayLayout.RowData column = new ArrayLayout.RowData {
row = new List <Tile> {
EditorCreateNewTileObject(0, 0)
}
};
grid.rows.Add(column);
}
// In case we are editing data, not the grid size, return
if (gridSize.x == grid.rows.Count && gridSize.x > 0)
{
if (gridSize.y == grid.rows[0].row.Count && gridSize.y > 0)
{
return;
}
}
if (gridSize.x <= 0)
{
// Always make sure we have at least 1 value
gridSize.x = 1;
int endIndex = grid.rows.Count - gridSize.x;
DestroyTileRow(gridSize.x, endIndex);
grid.rows.RemoveRange(gridSize.x, endIndex);
return;
}
if (gridSize.y <= 0)
{
// Always make sure we have at least 1 value
gridSize.y = 1;
for (int i = 0; i < grid.rows.Count; i++)
{
int endIndex = grid.rows[i].row.Count - gridSize.y;
DestroyTileColumn(grid.rows[i].row, gridSize.y, endIndex);
grid.rows[i].row.RemoveRange(gridSize.y, endIndex);
}
return;
}
// Make the rows bigger in case of a resize
if (gridSize.x > grid.rows.Count)
{
int difference = gridSize.x - grid.rows.Count;
// Update the rows and make sure the columns are filled up with the correct size
for (int i = grid.rows.Count, size = grid.rows.Count + difference; i < size; i++)
{
List <Tile> columns = new List <Tile>();
if (columns.Count < gridSize.y)
{
for (int y = 0; y < gridSize.y; y++)
{
columns.Add(EditorCreateNewTileObject(i, y));
}
}
ArrayLayout.RowData rowData = new ArrayLayout.RowData {
row = columns
};
grid.rows.Add(rowData);
}
}
// Make the rows smaller in case of a resize
else if (gridSize.x < grid.rows.Count)
{
int endIndex = grid.rows.Count - gridSize.x;
DestroyTileRow(gridSize.x, endIndex);
grid.rows.RemoveRange(gridSize.x, endIndex);
}
// In case only the gridSize.y has been updated
else
{
// Fill up the columns
for (int x = 0; x < gridSize.x; x++)
{
if (gridSize.y > grid.rows[x].row.Count)
{
int difference = gridSize.y - grid.rows[x].row.Count;
for (int y = grid.rows[x].row.Count, size = grid.rows[x].row.Count + difference; y < size; y++)
{
grid.rows[x].row.Add(EditorCreateNewTileObject(x, y));
}
}
else if (gridSize.y < grid.rows[x].row.Count)
{
int endIndex = grid.rows[x].row.Count - gridSize.y;
DestroyTileColumn(grid.rows[x].row, gridSize.y, endIndex);
grid.rows[x].row.RemoveRange(gridSize.y, endIndex);
}
}
}
}
public ArrayPosition(int r, int c, ArrayLayout barrelCP)
{
this.x = r;
this.y = c;
this.checkpointTransform = barrelCP.rows[r].column[c].transform;
}
/// <summary>
/// This entire function works based on "God only knows"
/// Try to make a better code or leave as it is.
/// </summary>
/// <param name="zMaxPosition"></param>
private void ChangeStagePosition(float zMaxPosition)
{
baseStageBuilder[0].start.SetActive(false);
//currentStagesDesign.RemoveRange(0, 4);
#region POG do Capeta
ArrayLayout lastButOne = currentStageConfig[4];
ArrayLayout last = currentStageConfig[5];
//Array.Clear(currentStageConfig, 0, currentStageConfig.Length);
currentStageConfig[0] = lastButOne;
currentStageConfig[1] = last;
#endregion
//currentStageConfig.RemoveRange(0, 4);
for (int i = 0; i < baseStageBuilder.Length; i++)
{
//if(currentStagesDesign.ElementAtOrDefault(i) != null)
if (i < 2)
{
for (int z = 0; z < 13; z++)
{
for (int x = 0; x < 13; x++)
{
baseStageBuilder[i].UpdateStageDesign(x, z, currentStageConfig[i].rows[z].row[x]);
}
}
}
else
{
//var stageDeisng = easyStageDesign[Random.Range(0, easyStageDesign.Length)];
//currentStagesDesign.Add(stageDeisng);
//baseStageBuilder[i].UpdateStageDesign(stageDeisng);
var stageDeisgn = easyStageDesign[UnityEngine.Random.Range(0, easyStageDesign.Length)];
//currentStagesDesign.Add(stageDeisgn);
//currentStageConfig[i] = stageDeisgn.data;
//currentStageConfig.Add(stageDeisgn.data);
for (int z = 0; z < 13; z++)
{
for (int x = 0; x < 13; x++)
{
int value = stageDeisgn.data.rows[z].row[x];
if (value == (int)StageElements.Fuel)
{
float rnd = UnityEngine.Random.Range(0f, 100f) / 100f;
if (rnd > spawnFuelPercent)
{
value = (int)StageElements.Empty;
}
}
baseStageBuilder[i].UpdateStageDesign(x, z, value);
//currentStageConfig[i].rows[z].row = new int[13];
currentStageConfig[i].rows[z].row[x] = value;
}
}
}
}
}
