public FillInfo GetFillInfo(int id)
{
for (int i = 0; i < fillInfos.Count; i++)
{
FillInfo fillInfo = fillInfos[i];
if (fillInfo.id == id)
{
return(fillInfo);
}
}
return(null);
}
public void InitFillInfo()
{
config_map_item map_item = BattleModel.Instance.crtConfig;
FillInfo fillInfo = GetFillInfo(map_item.fill);
if (fillInfo == null)
{
fillInfo = new FillInfo();
fillInfo.id = map_item.fill;
string content = GameMgr.resourceMgr.GetTextString("txt/fill.ab", fillInfo.id.ToString());
fillInfo.FillTxt(content);
fillInfos.Add(fillInfo);
}
crtFillInfo = fillInfo;
FillInfo.FILL_COUNT = 0;
}
/// <summary>
/// Renders fill changes
/// </summary>
/// <param name="info"> Fill information </param>
void renderFillInfo(FillInfo info)
{
WorldRegion undoRegion = World.GetLayerRegion(info.Bounds, World.SelectedLayer),
redoRegion = World.GetLayerRegion(info.Bounds, World.SelectedLayer);
int selectionWidth = TilesetSelection.Width / TileSize.Width,
selectionHeight = TilesetSelection.Height / TileSize.Height;
// <bounds loop>
for (int boundsX = info.Bounds.X; boundsX < info.Bounds.Right; boundsX += selectionWidth)
{
for (int boundsY = info.Bounds.Y; boundsY < info.Bounds.Bottom; boundsY += selectionHeight)
{
// <render loop>
for (int renderX = boundsX, sx = 0; renderX < boundsX + selectionWidth; renderX++, sx++)
{
for (int renderY = boundsY, sy = 0; renderY < boundsY + selectionHeight; renderY++, sy++)
{
int offsetX = renderX - info.Bounds.X,
offsetY = renderY - info.Bounds.Y;
// determine if the point from the current selection iteration should be rendered.
// must be inside the region bounds and an existing change
if (offsetX >= info.Bounds.Width || offsetY >= info.Bounds.Height || !info.Changes[offsetX][offsetY])
{
continue;
}
WorldTile tile = TileFromSelectionOffset(sx, sy);
World.SetTile(renderX, renderY, tile);
redoRegion[offsetX, offsetY] = tile;
}
}
// </render loop>
}
}
// </bounds loop>
ChangesUndo = new TileChangesRegion(undoRegion, info.Bounds.Location, World.SelectedLayer);
ChangesRedo = new TileChangesRegion(redoRegion, info.Bounds.Location, World.SelectedLayer);
History.Add(PackagedHistoryItem());
}
/// <summary>
/// Preenche apenas as tabelas de dados especificadas.
/// </summary>
/// <param name="sources">Os nomes das origens. Formato de cada uma: <c>dataTable:tabela_ou_view</c></param>
public int FillData(params string[] sources)
{
try
{
int c = 0;
using (AdpConnection conn = CreateConnection())
{
foreach (string rawInfo in sources)
{
FillInfo fi = new FillInfo(rawInfo);
using (AdpDataAdapter da = new AdpDataAdapter())
{
if (fi.Source == fi.DataTable && ds.Tables.Contains(fi.DataTable))
{
DataTable dt = ds.Tables[fi.DataTable];
lock (dt)
{
string old = dt.TableName;
dt.TableName = GetPhysicalTableName(dt);
new AdpCommandBuilder(da, conn, dt, AdpCommandOperation.Select);
c += da.Fill(dt);
dt.TableName = old;
}
}
else
{
da.SelectCommand = new AdpCommand("SELECT * FROM " + fi.Source, conn);
if (!ds.Tables.Contains(fi.DataTable))
{
Debug.WriteLine(String.Format("WARN: DataTable {0} doesn't exist.", fi.DataTable));
}
c += da.Fill(ds, fi.DataTable);
}
}
}
}
return(c);
}
catch (Exception ex)
{
throw new ConnectorException("Erro ao realizar o preenchimento dos dados", ex);
}
}
/// <summary>
/// Renders fill changes
/// </summary>
/// <param name="info"> Fill information </param>
void renderFillInfo(FillInfo info)
{
WorldRegion undoRegion = World.GetLayerRegion(info.Bounds, World.SelectedLayer),
redoRegion = World.GetLayerRegion(info.Bounds, World.SelectedLayer);
int selectionWidth = TilesetSelection.Width / TileSize.Width,
selectionHeight = TilesetSelection.Height / TileSize.Height;
// <bounds loop>
for (int boundsX = info.Bounds.X; boundsX < info.Bounds.Right; boundsX += selectionWidth)
{
for (int boundsY = info.Bounds.Y; boundsY < info.Bounds.Bottom; boundsY += selectionHeight)
{
// <render loop>
for (int renderX = boundsX, sx = 0; renderX < boundsX + selectionWidth; renderX++, sx++)
{
for (int renderY = boundsY, sy = 0; renderY < boundsY + selectionHeight; renderY++, sy++)
{
int offsetX = renderX - info.Bounds.X,
offsetY = renderY - info.Bounds.Y;
// determine if the point from the current selection iteration should be rendered.
// must be inside the region bounds and an existing change
if (offsetX >= info.Bounds.Width || offsetY >= info.Bounds.Height || !info.Changes[offsetX][offsetY])
continue;
WorldTile tile = TileFromSelectionOffset(sx, sy);
World.SetTile(renderX, renderY, tile);
redoRegion[offsetX, offsetY] = tile;
}
}
// </render loop>
}
}
// </bounds loop>
ChangesUndo = new TileChangesRegion(undoRegion, info.Bounds.Location, World.SelectedLayer);
ChangesRedo = new TileChangesRegion(redoRegion, info.Bounds.Location, World.SelectedLayer);
History.Add(PackagedHistoryItem());
}
/// <summary>
/// Computes a fill region and points contained in it based
/// on the origin
/// </summary>
/// <param name="origin"> Initial fill point </param>
/// <returns> Fill information generated from origin </returns>
FillInfo computeFillInfo(Point origin)
{
FillInfo fillInfo = new FillInfo();
fillInfo.Bounds = new Rectangle(origin.X, origin.Y, origin.X, origin.Y);
WorldTile targetTile = World.GetTile(origin);
//queue containing tiles to check
List<Point> fillQ = new List<Point>();
fillQ.Add(origin);
//list that will be pushed with points valid
//for change. This is used later to populate
//our flag array
List<Point> changedPoints = new List<Point>();
//cache this condition for later optimization
bool checkRect = World.SelectionRectangle != Rectangle.Empty;
//iteration bounds. used for optimization
int boundLeft, boundRight, boundTop, boundBottom;
//set the bounds depending on the selection rectangle
if (checkRect)
{
boundLeft = World.SelectionRectangle.X.Clamp(0, WorldSize.Width);
boundRight = World.SelectionRectangle.Right.Clamp(0, WorldSize.Width);
boundTop = World.SelectionRectangle.Y.Clamp(0, WorldSize.Height);
boundBottom = World.SelectionRectangle.Bottom.Clamp(0, WorldSize.Height);
}
else
{
boundLeft = boundTop = 0;
boundRight = WorldSize.Width;
boundBottom = WorldSize.Height;
}
//array of flags containing tiles already processed for optimization
bool[][] processedTiles = new bool[WorldSize.Width][];
for (int i = 0; i < WorldSize.Width; i++)
processedTiles[i] = new bool[WorldSize.Height];
//process fill queue until there's no remaining options
while (fillQ.Count > 0) {
//take this point from the queue
Point currentPoint = fillQ[0];
fillQ.RemoveAt(0);
//set the current point as a valid change
changedPoints.Add(currentPoint);
processedTiles[currentPoint.X][currentPoint.Y] = true;
//seek left
int left = currentPoint.X;
while (--left >= boundLeft && World.GetTile(left, currentPoint.Y) == targetTile); left++;
//seek right
int right = currentPoint.X;
while (++right < boundRight && World.GetTile(right, currentPoint.Y) == targetTile); right--;
//adjust fill region bounds
fillInfo.Bounds.X = Math.Min(left, fillInfo.Bounds.X);
fillInfo.Bounds.Y = Math.Min(currentPoint.Y, fillInfo.Bounds.Y);
fillInfo.Bounds.Width = Math.Max(right, fillInfo.Bounds.Width);
fillInfo.Bounds.Height = Math.Max(currentPoint.Y, fillInfo.Bounds.Height);
//used for optimizing left-right iterations
bool lAbove = false;
bool lBelow = false;
//iterate through row based on calculation and
//add other potential rows
for (int x = left; x <= right; x++) {
Point fillPoint = new Point(x, currentPoint.Y);
changedPoints.Add(fillPoint);
//check tile above
if (fillPoint.Y > boundTop) {
Point pointAbove = new Point(fillPoint.X, fillPoint.Y - 1);
if (!processedTiles[pointAbove.X][pointAbove.Y] && World.GetTile(pointAbove) == targetTile)
{
if (!lAbove)
fillQ.Add(pointAbove);
lAbove = true;
}
else
{
lAbove = false;
}
//declare this tile as processed
processedTiles[pointAbove.X][pointAbove.Y] = true;
}
//check tile below
if (fillPoint.Y + 1 < boundBottom)
{
Point pointBelow = new Point(fillPoint.X, fillPoint.Y + 1);
if (!processedTiles[pointBelow.X][pointBelow.Y] && World.GetTile(pointBelow) == targetTile)
{
if (!lBelow)
fillQ.Add(pointBelow);
lBelow = true;
}
else
{
lBelow = false;
}
//declare this tile as processed
processedTiles[pointBelow.X][pointBelow.Y] = true;
}
}
}
//normalize fill region size
fillInfo.Bounds.Width = fillInfo.Bounds.Width - fillInfo.Bounds.X + 1;
fillInfo.Bounds.Height = fillInfo.Bounds.Height - fillInfo.Bounds.Y + 1;
//if there's a selection in the world, determine if we should
//use it, or the bounds of the changes
if (checkRect && !World.SelectionRectangle.Contains(fillInfo.Bounds))
{
fillInfo.Bounds = World.SelectionRectangle;
}
fillInfo.Changes = new bool[fillInfo.Bounds.Width][];
for (int i = 0; i < fillInfo.Bounds.Width; i++)
fillInfo.Changes[i] = new bool[fillInfo.Bounds.Height];
//convert changed tiles into flags for optimized
//use in applying changes
foreach (Point change in changedPoints)
{
fillInfo.Changes[change.X - fillInfo.Bounds.X]
[change.Y - fillInfo.Bounds.Y] = true;
}
return fillInfo;
}
/// <summary>
/// Preenche a tabela de dados especificada, com os critérios especificados.
/// </summary>
/// <param name="source">O nome da origem. Formato: <c>dataTable:tabela_ou_view</c></param>
/// <param name="cond">O critério de seleção dos registros.</param>
/// <param name="orderBy">A ordem</param>
public int FillData(string source, SqlCondition cond, SqlOrder orderBy)
{
FillInfo fi = new FillInfo(source);
return(FillData(fi.DataTable, new SqlQuery(new SqlTableSource(fi.Source), cond, orderBy)));
}
private FillInfo[,] GenerateRefillTrendMap(Container2D_Rectangular container)
{
var ret = new FillInfo[container.Height, container.Width];
var slots = container.WrapperRect;
Action<int, int, List<SlotWrapper2D>> picker = (x, y, list)=>{
if (x < 0 || x >= container.Width) return;
if (y < 0 || y >= container.Height) return;
if (null != slots[y, x].slotAttribute && slots[y, x].slotAttribute.category == SlotAttribute.Category.INSULATOR)
{
return;
}
list.Add(slots[y, x]);
};
Action<int, int> exitMarker = (x, y)=>{
if (null == ret[y, x])
{
ret[y, x] = new FillInfo();
ret[y, x].ancestorPos = new Pos2D(x, y + 1);
}
};
container.ForeachSlot((x, y, slot)=>{
if (null != ret[y, x])
return;
if (null != slot.slotAttribute && slot.slotAttribute.category == SlotAttribute.Category.INSULATOR)
return;
var ctx = new AStar.Context<SlotWrapper2D>();
ctx.start = slots[y, x];
ctx.procTrait = (s)=>{
return s.Trait;
};
ctx.procWeight = (SlotWrapper2D from, SlotWrapper2D to)=>{
foreach (var t in surroundingOffsets){
if (to.pos.x == from.pos.x + t.item1 && to.pos.y == from.pos.y + t.item2){
return t.item3;
}
}
throw new NotImplementedException();
};
ctx.procTermination = (SlotWrapper2D s)=>{
return s.pos.y == container.Height - 1;
};
ctx.procDistanceEstimator = (SlotWrapper2D s)=>{
return (container.Height - 1 - s.pos.y) * 1.0001f;
};
ctx.procAdjacencies = (SlotWrapper2D s)=>{
var list = new List<SlotWrapper2D>();
foreach (var t in surroundingOffsets){
picker.Invoke(s.pos.x + t.item1, s.pos.y + t.item2, list);
}
return list;
};
if (AStar.Evaluate(ctx))
{
var result = ctx.path;
if (result.Count <= 0)
{
exitMarker.Invoke(x, y);
}
else
{
result.Reverse();
for (int i = 0, len = result.Count - 1; i < len; i++)
{
if (null != ret[result[i].pos.y, result[i].pos.x]) continue;
var t = new FillInfo();
t.ancestorPos = new Pos2D(result[i + 1].pos.x, result[i + 1].pos.y);
ret[result[i].pos.y, result[i].pos.x] = t;
}
exitMarker(result[result.Count - 1].pos.x, result[result.Count - 1].pos.y);
}
}
else
{
ret[y, x] = new FillInfo();
}
});
for (int y = 0; y < container.Height; y++)
{
for (int x = 0; x < container.Width; x++)
{
var fi = ret[y, x];
if (null == fi) continue;
if (fi.IsOnSpot) continue;
fi.childrenPos = new List<Pos2D>();
foreach (var t in surroundingOffsets)
{
var sx = x + t.item1;
var sy = y + t.item2;
if (!container.IsLegalPosition(sx, sy))
{
continue;
}
var slot = container.GetSlot(sx, sy);
if (null != slot && null != slot.slotAttribute && slot.slotAttribute.category == SlotAttribute.Category.INSULATOR)
{
continue;
}
var touch = ret[sy, sx];
if (null != touch.ancestorPos && touch.ancestorPos.x == x && touch.ancestorPos.y == y)
{
fi.childrenPos.Add(new Pos2D(sx, sy));
}
}
}
}
return ret;
}
/// <summary>
/// Preenche apenas as tabelas de dados especificadas.
/// </summary>
/// <param name="sources">Os nomes das origens. Formato de cada uma: <c>dataTable:tabela_ou_view</c></param>
public int FillData(params string[] sources)
{
try
{
int c = 0;
using (AdpConnection conn = CreateConnection())
{
foreach (string rawInfo in sources)
{
FillInfo fi = new FillInfo(rawInfo);
using (AdpDataAdapter da = new AdpDataAdapter())
{
if (fi.Source == fi.DataTable && ds.Tables.Contains(fi.DataTable))
{
DataTable dt = ds.Tables[fi.DataTable];
lock (dt)
{
string old = dt.TableName;
dt.TableName = GetPhysicalTableName(dt);
new AdpCommandBuilder(da, conn, dt, AdpCommandOperation.Select);
c += da.Fill(dt);
dt.TableName = old;
}
}
else
{
da.SelectCommand = new AdpCommand("SELECT * FROM " + fi.Source, conn);
if (!ds.Tables.Contains(fi.DataTable))
Debug.WriteLine(String.Format("WARN: DataTable {0} doesn't exist.", fi.DataTable));
c += da.Fill(ds, fi.DataTable);
}
}
}
}
return c;
}
catch (Exception ex)
{
throw new ConnectorException("Erro ao realizar o preenchimento dos dados", ex);
}
}
private List<RefillFlowRecord.Path> CollectFillPathList(Container2D_Rectangular container, FillInfo[,] fillInfos)
{
var ret = new List<RefillFlowRecord.Path>();
for (int x = 0; x < container.Width; x++)
{
var sub = CollectFromPos(container, fillInfos, x, container.Height - 1);
if (null == sub) continue;
sub.Sort((lhr, rhr)=>{
return (lhr.movements.Count > rhr.movements.Count) ? -1 : 1;
});
var len = sub.Count;
for (int i = 0; i < len; i++)
{
var index = i + 1;
var s = sub[i];
s.src = new Pos2D(x, container.Height - 1 + index);
for (int j = 1; j <= index; j++)
{
s.movements.Add(new Pos2D(x, container.Height - 1 + j));
}
s.movements.Reverse();
}
ret.AddRange(sub);
}
return ret;
}
private Tuple<Pos2D, int> DepthFirstSearch(SlotWrapper2D[,] slots,
FillInfo[,] infos,
int fromX, int fromY)
{
Tuple<Pos2D, int> ret = null;
var fi = infos[fromY, fromX];
foreach (var t in fi.childrenPos)
{
if (null == slots[t.y, t.x])
{
var branchSearch = DepthFirstSearch(slots, infos, t.x, t.y);
if (null == ret || branchSearch.item2 > ret.item2)
{
ret = branchSearch;
}
}
}
if (null == ret)
{
ret = new Tuple<Pos2D, int>(new Pos2D(fromX, fromY), 0);
}
else
{
ret.item2 = ret.item2 + 1;
}
return ret;
}
private List<Pos2D> CollectRefillEnds(Container2D_Rectangular container, FillInfo[,] fillInfoMap)
{
var slots = container.WrapperRect;
var ret = new List<Pos2D>();
container.ForeachSlot((x, y, slot)=>{
if (null != slot) return;
if (fillInfoMap[y, x].IsOnSpot) return;
foreach (var t in surroundingOffsets){
if (!container.IsLegalPosition(x + t.item1, y + t.item2)) continue;
if (null != slots[y + t.item2, x + t.item1]) continue;
var fi = fillInfoMap[y + t.item2, x + t.item1];
if (!fi.IsOnSpot && fi.ancestorPos.x == x && fi.ancestorPos.y == y)
{
return;
}
}
ret.Add(new Pos2D(x, y));
});
return ret;
}
private RefillFlowRecord DoApply(Container2D_Rectangular container, FillInfo[,] fillInfoMap)
{
var ret = new RefillFlowRecord();
var slots = container.WrapperRect;
container.ForeachSlot((x, y, slot)=>{
if (null != slot) return;
var fi = fillInfoMap[y, x];
if (fi.IsOnSpot){
ret.OnSpotList.Add(new Pos2D(x, y));
}
});
var ends = CollectRefillEnds(container, fillInfoMap);
var dir = new Dictionary<int, Tuple<SlotWrapper2D, int>>();
foreach (var e in ends)
{
var pos = fillInfoMap[e.y, e.x].ancestorPos;
int inverseDepth = 0;
while (container.IsLegalPosition(pos.x, pos.y))
{
var s = slots[pos.y, pos.x];
if (null != s)
{
inverseDepth++;
if (!dir.ContainsKey(s.Trait))
{
dir.Add(s.Trait, new Tuple<SlotWrapper2D, int>(s, inverseDepth));
}
else if (dir[s.Trait].item2 < inverseDepth)
{
dir[s.Trait].item2 = inverseDepth;
}
}
pos = fillInfoMap[pos.y, pos.x].ancestorPos;
}
}
var list = new List<Tuple<SlotWrapper2D, int>>();
foreach (var kvp in dir)
{
list.Add(kvp.Value);
}
list.Sort((lhr, rhr)=>{
return (lhr.item2 < rhr.item2) ? -1 : 1;
});
foreach (var t in list)
{
var src = t.item1.pos;
var moveTo = DepthFirstSearch(slots, fillInfoMap, src.x, src.y);
var dst = moveTo.item1;
var path = new RefillFlowRecord.Path();
path.src = src.Clone();
path.dst = dst.Clone();
container.SwapSlot(src.x, src.y, dst.x, dst.y);
var cur = path.dst;
do {
path.movements.Add(cur);
cur = fillInfoMap[cur.y, cur.x].ancestorPos;
} while (cur != path.src);
path.movements.Add(path.src);
path.movements.Reverse();
ret.NonFillMovements.Add(path);
}
ret.FillMovements = CollectFillPathList(container, fillInfoMap);
return ret;
}
/// <summary>
/// Computes a fill region and points contained in it based
/// on the origin
/// </summary>
/// <param name="origin"> Initial fill point </param>
/// <returns> Fill information generated from origin </returns>
FillInfo computeFillInfo(Point origin)
{
FillInfo fillInfo = new FillInfo();
fillInfo.Bounds = new Rectangle(origin.X, origin.Y, origin.X, origin.Y);
WorldTile targetTile = World.GetTile(origin);
//queue containing tiles to check
List <Point> fillQ = new List <Point>();
fillQ.Add(origin);
//list that will be pushed with points valid
//for change. This is used later to populate
//our flag array
List <Point> changedPoints = new List <Point>();
//cache this condition for later optimization
bool checkRect = World.SelectionRectangle != Rectangle.Empty;
//iteration bounds. used for optimization
int boundLeft, boundRight, boundTop, boundBottom;
//set the bounds depending on the selection rectangle
if (checkRect)
{
boundLeft = World.SelectionRectangle.X.Clamp(0, WorldSize.Width);
boundRight = World.SelectionRectangle.Right.Clamp(0, WorldSize.Width);
boundTop = World.SelectionRectangle.Y.Clamp(0, WorldSize.Height);
boundBottom = World.SelectionRectangle.Bottom.Clamp(0, WorldSize.Height);
}
else
{
boundLeft = boundTop = 0;
boundRight = WorldSize.Width;
boundBottom = WorldSize.Height;
}
//array of flags containing tiles already processed for optimization
bool[][] processedTiles = new bool[WorldSize.Width][];
for (int i = 0; i < WorldSize.Width; i++)
{
processedTiles[i] = new bool[WorldSize.Height];
}
//process fill queue until there's no remaining options
while (fillQ.Count > 0)
{
//take this point from the queue
Point currentPoint = fillQ[0];
fillQ.RemoveAt(0);
//set the current point as a valid change
changedPoints.Add(currentPoint);
processedTiles[currentPoint.X][currentPoint.Y] = true;
//seek left
int left = currentPoint.X;
while (--left >= boundLeft && World.GetTile(left, currentPoint.Y) == targetTile)
{
;
}
left++;
//seek right
int right = currentPoint.X;
while (++right < boundRight && World.GetTile(right, currentPoint.Y) == targetTile)
{
;
}
right--;
//adjust fill region bounds
fillInfo.Bounds.X = Math.Min(left, fillInfo.Bounds.X);
fillInfo.Bounds.Y = Math.Min(currentPoint.Y, fillInfo.Bounds.Y);
fillInfo.Bounds.Width = Math.Max(right, fillInfo.Bounds.Width);
fillInfo.Bounds.Height = Math.Max(currentPoint.Y, fillInfo.Bounds.Height);
//used for optimizing left-right iterations
bool lAbove = false;
bool lBelow = false;
//iterate through row based on calculation and
//add other potential rows
for (int x = left; x <= right; x++)
{
Point fillPoint = new Point(x, currentPoint.Y);
changedPoints.Add(fillPoint);
//check tile above
if (fillPoint.Y > boundTop)
{
Point pointAbove = new Point(fillPoint.X, fillPoint.Y - 1);
if (!processedTiles[pointAbove.X][pointAbove.Y] && World.GetTile(pointAbove) == targetTile)
{
if (!lAbove)
{
fillQ.Add(pointAbove);
}
lAbove = true;
}
else
{
lAbove = false;
}
//declare this tile as processed
processedTiles[pointAbove.X][pointAbove.Y] = true;
}
//check tile below
if (fillPoint.Y + 1 < boundBottom)
{
Point pointBelow = new Point(fillPoint.X, fillPoint.Y + 1);
if (!processedTiles[pointBelow.X][pointBelow.Y] && World.GetTile(pointBelow) == targetTile)
{
if (!lBelow)
{
fillQ.Add(pointBelow);
}
lBelow = true;
}
else
{
lBelow = false;
}
//declare this tile as processed
processedTiles[pointBelow.X][pointBelow.Y] = true;
}
}
}
//normalize fill region size
fillInfo.Bounds.Width = fillInfo.Bounds.Width - fillInfo.Bounds.X + 1;
fillInfo.Bounds.Height = fillInfo.Bounds.Height - fillInfo.Bounds.Y + 1;
//if there's a selection in the world, determine if we should
//use it, or the bounds of the changes
if (checkRect && !World.SelectionRectangle.Contains(fillInfo.Bounds))
{
fillInfo.Bounds = World.SelectionRectangle;
}
fillInfo.Changes = new bool[fillInfo.Bounds.Width][];
for (int i = 0; i < fillInfo.Bounds.Width; i++)
{
fillInfo.Changes[i] = new bool[fillInfo.Bounds.Height];
}
//convert changed tiles into flags for optimized
//use in applying changes
foreach (Point change in changedPoints)
{
fillInfo.Changes[change.X - fillInfo.Bounds.X]
[change.Y - fillInfo.Bounds.Y] = true;
}
return(fillInfo);
}
private FillInfo[,] GenerateRefillTrendMap(Container2D_Rectangular container)
{
var ret = new FillInfo[container.Height, container.Width];
var slots = container.WrapperRect;
Action <int, int, List <SlotWrapper2D> > picker = (x, y, list) => {
if (x < 0 || x >= container.Width)
{
return;
}
if (y < 0 || y >= container.Height)
{
return;
}
if (null != slots[y, x].slotAttribute && slots[y, x].slotAttribute.category == SlotAttribute.Category.INSULATOR)
{
return;
}
list.Add(slots[y, x]);
};
Action <int, int> exitMarker = (x, y) => {
if (null == ret[y, x])
{
ret[y, x] = new FillInfo();
ret[y, x].ancestorPos = new Pos2D(x, y + 1);
}
};
container.ForeachSlot((x, y, slot) => {
if (null != ret[y, x])
{
return;
}
if (null != slot.slotAttribute && slot.slotAttribute.category == SlotAttribute.Category.INSULATOR)
{
return;
}
var ctx = new AStar.Context <SlotWrapper2D>();
ctx.start = slots[y, x];
ctx.procTrait = (s) => {
return(s.Trait);
};
ctx.procWeight = (SlotWrapper2D from, SlotWrapper2D to) => {
foreach (var t in surroundingOffsets)
{
if (to.pos.x == from.pos.x + t.item1 && to.pos.y == from.pos.y + t.item2)
{
return(t.item3);
}
}
throw new NotImplementedException();
};
ctx.procTermination = (SlotWrapper2D s) => {
return(s.pos.y == container.Height - 1);
};
ctx.procDistanceEstimator = (SlotWrapper2D s) => {
return((container.Height - 1 - s.pos.y) * 1.0001f);
};
ctx.procAdjacencies = (SlotWrapper2D s) => {
var list = new List <SlotWrapper2D>();
foreach (var t in surroundingOffsets)
{
picker.Invoke(s.pos.x + t.item1, s.pos.y + t.item2, list);
}
return(list);
};
if (AStar.Evaluate(ctx))
{
var result = ctx.path;
if (result.Count <= 0)
{
exitMarker.Invoke(x, y);
}
else
{
result.Reverse();
for (int i = 0, len = result.Count - 1; i < len; i++)
{
if (null != ret[result[i].pos.y, result[i].pos.x])
{
continue;
}
var t = new FillInfo();
t.ancestorPos = new Pos2D(result[i + 1].pos.x, result[i + 1].pos.y);
ret[result[i].pos.y, result[i].pos.x] = t;
}
exitMarker(result[result.Count - 1].pos.x, result[result.Count - 1].pos.y);
}
}
else
{
ret[y, x] = new FillInfo();
}
});
for (int y = 0; y < container.Height; y++)
{
for (int x = 0; x < container.Width; x++)
{
var fi = ret[y, x];
if (null == fi)
{
continue;
}
if (fi.IsOnSpot)
{
continue;
}
fi.childrenPos = new List <Pos2D>();
foreach (var t in surroundingOffsets)
{
var sx = x + t.item1;
var sy = y + t.item2;
if (!container.IsLegalPosition(sx, sy))
{
continue;
}
var slot = container.GetSlot(sx, sy);
if (null != slot && null != slot.slotAttribute && slot.slotAttribute.category == SlotAttribute.Category.INSULATOR)
{
continue;
}
var touch = ret[sy, sx];
if (null != touch.ancestorPos && touch.ancestorPos.x == x && touch.ancestorPos.y == y)
{
fi.childrenPos.Add(new Pos2D(sx, sy));
}
}
}
}
return(ret);
}
private List<RefillFlowRecord.Path> CollectFromPos(Container2D_Rectangular container, FillInfo[,] fillInfos, int fromX, int fromY)
{
if (!container.IsLegalPosition(fromX, fromY) || null != container.GetSlot(fromX, fromY)) return null;
var fi = fillInfos[fromY, fromX];
var ret = new List<RefillFlowRecord.Path>();
var selfPos = new Pos2D(fromX, fromY);
var self = new RefillFlowRecord.Path();
self.dst = selfPos;
ret.Add(self);
foreach (var child in fi.childrenPos)
{
var sub = CollectFromPos(container, fillInfos, child.x, child.y);
if (null == sub) continue;
ret.AddRange(sub);
}
foreach (var r in ret)
{
r.src = selfPos;
r.movements.Add(selfPos);
}
return ret;
}
private static Fill GetNewFill(FillInfo fillInfo, Boolean ignoreMod = true)
{
var fill = new Fill();
var patternFill = new PatternFill();
if (fillInfo.Fill.PatternTypeModified || ignoreMod)
patternFill.PatternType = fillInfo.Fill.PatternType.ToOpenXml();
if (fillInfo.Fill.PatternColorModified || ignoreMod)
{
var foregroundColor = new ForegroundColor();
if (fillInfo.Fill.PatternColor.ColorType == XLColorType.Color)
foregroundColor.Rgb = fillInfo.Fill.PatternColor.Color.ToHex();
else if (fillInfo.Fill.PatternColor.ColorType == XLColorType.Indexed)
foregroundColor.Indexed = (UInt32)fillInfo.Fill.PatternColor.Indexed;
else
{
foregroundColor.Theme = (UInt32)fillInfo.Fill.PatternColor.ThemeColor;
if (fillInfo.Fill.PatternColor.ThemeTint != 1)
foregroundColor.Tint = fillInfo.Fill.PatternColor.ThemeTint;
}
patternFill.AppendChild(foregroundColor);
}
if (fillInfo.Fill.PatternBackgroundColorModified || ignoreMod)
{
var backgroundColor = new BackgroundColor();
if (fillInfo.Fill.PatternBackgroundColor.ColorType == XLColorType.Color)
backgroundColor.Rgb = fillInfo.Fill.PatternBackgroundColor.Color.ToHex();
else if (fillInfo.Fill.PatternBackgroundColor.ColorType == XLColorType.Indexed)
backgroundColor.Indexed = (UInt32)fillInfo.Fill.PatternBackgroundColor.Indexed;
else
{
backgroundColor.Theme = (UInt32)fillInfo.Fill.PatternBackgroundColor.ThemeColor;
if (fillInfo.Fill.PatternBackgroundColor.ThemeTint != 1)
backgroundColor.Tint = fillInfo.Fill.PatternBackgroundColor.ThemeTint;
}
patternFill.AppendChild(backgroundColor);
}
fill.AppendChild(patternFill);
return fill;
}
/// <summary>
/// Preenche a tabela de dados especificada, com os critérios especificados.
/// </summary>
/// <param name="source">O nome da origem. Formato: <c>dataTable:tabela_ou_view</c></param>
/// <param name="cond">O critério de seleção dos registros.</param>
/// <param name="orderBy">A ordem</param>
public int FillData(string source, SqlCondition cond, SqlOrder orderBy)
{
FillInfo fi = new FillInfo(source);
return FillData(fi.DataTable, new SqlQuery(new SqlTableSource(fi.Source), cond, orderBy));
}
