public CollisionTahPageControl(CollisionItem argCollisionEntry)
{
InitializeComponent();
collisionEntry = argCollisionEntry;
Text = Path.GetFileName(collisionEntry.tah.path);
TDCGExplorer.TDCGExplorer.SetToolTips(Text);
DataTable data = new DataTable();
data.Columns.Add(TextResource.CollisionFrom, Type.GetType("System.String"));
data.Columns.Add(TextResource.CollisionTo, Type.GetType("System.String"));
data.Columns.Add(TextResource.CollisionedTAH, Type.GetType("System.String"));
foreach (ArcsCollisionRecord col in collisionEntry.entries)
{
ArcsDatabase db = TDCGExplorer.TDCGExplorer.ArcsDB;
// 衝突した先のtahを取得する.
ArcsTahEntry to = db.GetTah(col.toTahID);
// 既に同じ名前で追加していないか調べる.
ArcsTahFilesEntry fromfile = db.GetTahFilesEntry(col.fromFilesID);
ArcsTahFilesEntry tofile = db.GetTahFilesEntry(col.toFilesID);
DataRow row = data.NewRow();
string[] content = { fromfile.GetDisplayPath(), tofile.GetDisplayPath().ToLower(), to.shortname };
row.ItemArray = content;
data.Rows.Add(row);
}
dataGridView.DataSource = data;
dataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
dataGridView.ReadOnly = true;
dataGridView.AllowUserToAddRows = false;
dataGridView.AllowUserToDeleteRows = false;
selectIndex(0);
}
private long CollectStatistic(HashPage pg, HashStatistic stat, int height)
{
long totalHeight = 0;
stat.nPages += 1;
if (++height > stat.maxHeight)
{
stat.maxHeight = height;
}
foreach (object child in pg.items)
{
if (child is HashPage)
{
totalHeight += CollectStatistic((HashPage)child, stat, height);
}
else if (child != null)
{
int collisionChainLength = 0;
for (CollisionItem item = (CollisionItem)child; item != null; item = item.next)
{
collisionChainLength += 1;
}
if (stat.maxCollisionChainLength < collisionChainLength)
{
stat.maxCollisionChainLength = collisionChainLength;
}
stat.nItems += collisionChainLength;
stat.nChains += 1;
totalHeight += height;
}
}
return(totalHeight);
}
private static Dictionary <CollisionItem, Type> LoadCollisionDict(string fileLocation)
{
Dictionary <CollisionItem, Type> colDict = new Dictionary <CollisionItem, Type>();
var fileStream = File.OpenRead(fileLocation);
var fileReader = new StreamReader(fileStream);
fileReader.ReadLine();
while (!fileReader.EndOfStream)
{
string line = fileReader.ReadLine();
string[] columns = line.Split(',');
CollisionItem colItem = new CollisionItem
{
Collider = columns[0],
Collidee = columns[1],
ColDirection = DirectionFromString(columns[2])
};
if (columns[4].ToLowerInvariant().Equals(CollisionUtilConstants.True))
{
colItem.PixelPerfect = true;
}
Type c = Type.GetType(CollisionUtilConstants.CollisionNamespace + columns[3]);
colDict.Add(colItem, c);
}
fileReader.Close();
return(colDict);
}
public void OnPlayer1Hit()
{
if (_lastCollisionItem == CollisionItem.Player1)
{
return;
}
HandleVerticalWallCollision();
_lastCollisionItem = CollisionItem.Player1;
}
private static CollisionItem BuildCollisionItem(string colliderAssem, string collideeAssem, CollisionItem.Direction dir, bool pixelPerfect)
{
CollisionItem col = new CollisionItem
{
Collider = colliderAssem.Split('.').Last(),
Collidee = collideeAssem.Split('.').Last(),
ColDirection = dir,
PixelPerfect = pixelPerfect
};
return(col);
}
public void Remove(object key)
#endif
{
HashPage pg = root;
if (pg != null)
{
uint divisor = 1;
int hashCode = key.GetHashCode();
while (true)
{
int h = (int)((uint)hashCode / divisor % pageSize);
object child = pg.items[h];
if (child is HashPage)
{
pg = (HashPage)child;
divisor *= pageSize;
}
else
{
CollisionItem prev = null;
for (CollisionItem item = (CollisionItem)child; item != null; item = item.next)
{
if (item.hashCode == hashCode && item.key.Equals(key))
{
if (prev != null)
{
prev.next = item.next;
prev.Modify();
}
else
{
pg.items[h] = item.next;
pg.Modify();
}
nElems -= 1;
Modify();
#if USE_GENERICS
return(true);
#else
return;
#endif
}
prev = item;
}
break;
}
}
}
#if USE_GENERICS
return(false);
#endif
}
public void Reset()
{
currItem = null;
nextItem = null;
stack.Clear();
HashPage pg = hash.root;
if (pg != null)
{
int start = 0;
int sp = 0;
DepthFirst:
while (true)
{
for (int i = start; i < pg.items.Count; i++)
{
object child = pg.items[i];
if (child != null)
{
stack.Add(new StackElem(pg, i));
sp += 1;
if (child is HashPage)
{
pg = (HashPage)child;
start = 0;
goto DepthFirst;
}
else
{
nextItem = (CollisionItem)child;
return;
}
}
}
if (sp != 0)
{
StackElem top = (StackElem)stack[--sp];
stack.RemoveAt(sp);
pg = top.page;
start = top.pos + 1;
}
else
{
break;
}
}
}
}
private void HandleWallCollision()
{
if (_gameObject.Left <= LeftBounds ||
_gameObject.Left >= RightBounds)
{
_lastCollisionItem = CollisionItem.Wall;
HandleVerticalWallCollision();
}
if (_gameObject.Top <= BottomBounds ||
_gameObject.Top >= TopBounds)
{
_lastCollisionItem = CollisionItem.Wall;
HandleHorizontalWallCollision();
}
}
public bool MoveNext()
{
if (nextItem != null)
{
currItem = nextItem;
if ((nextItem = nextItem.next) == null)
{
int sp = stack.Count;
do
{
StackElem top = (StackElem)stack[--sp];
stack.RemoveAt(sp);
HashPage pg = top.page;
int start = top.pos + 1;
DepthFirst:
while (true)
{
for (int i = start; i < pg.items.Count; i++)
{
object child = pg.items[i];
if (child != null)
{
stack.Add(new StackElem(pg, i));
sp += 1;
if (child is HashPage)
{
pg = (HashPage)child;
start = 0;
goto DepthFirst;
}
else
{
nextItem = (CollisionItem)child;
return(true);
}
}
}
break;
}
} while (sp != 0);
}
return(true);
}
return(false);
}
public override void Deallocate()
{
foreach (object child in items)
{
if (child is HashPage)
{
((HashPage)child).Deallocate();
}
else
{
CollisionItem next;
for (CollisionItem item = (CollisionItem)child; item != null; item = next)
{
next = item.next;
item.Deallocate();
}
}
}
base.Deallocate();
}
/// <summary>
/// Se è punto ritorna chi lo ha fatto
/// </summary>
/// <returns></returns>
private string HandleWallCollision()
{
if (_gameObject.Left <= LeftBounds)
{
return("player2");
}
if (_gameObject.Left >= RightBounds)
{
return("player1");
}
if (_gameObject.Top <= BottomBounds ||
_gameObject.Top >= TopBounds)
{
_lastCollisionItem = CollisionItem.Wall;
HandleHorizontalWallCollision();
}
return(null);
}
public bool TryGetValue(object key, out object val)
#endif
{
HashPage pg = root;
if (pg != null)
{
uint divisor = 1;
int hashCode = key.GetHashCode();
while (true)
{
int h = (int)((uint)hashCode / divisor % pageSize);
object child = pg.items[h];
if (child is HashPage)
{
pg = (HashPage)child;
divisor *= pageSize;
}
else
{
for (CollisionItem item = (CollisionItem)child; item != null; item = item.next)
{
if (item.hashCode == hashCode && item.key.Equals(key))
{
#if USE_GENERICS
val = (V)item.obj;
#else
val = item.obj;
#endif
return(true);
}
}
break;
}
}
}
val = null;
return(false);
}
private void DetectCollisions(IGameObject collider, List <KeyValuePair <float, ICommandCollision> > overlapCommandDict, List <KeyValuePair <ICommandCollision, IGameObject[]> > objectsDict)
{
foreach (ICollidableObject collidee in _gameObjects)
{
string colliderS = collider.ToString().Split('.').Last();
string collideeS = collidee.ToString().Split('.').Last();
if (collider != collidee && collider.BoundingBox.Intersects(collidee.BoundingBox))
{
CollisionItem colItem = BuildCollisionItem(colliderS, collideeS, DirectionFromBoundingBox(collidee.BoundingBox, collider.BoundingBox), false);
colItem.ColDirection = DirectionFromBoundingBox(collider.BoundingBox, collidee.BoundingBox);
var collisionRect = Rectangle.Intersect(collidee.BoundingBox, collider.BoundingBox);
float collisionArea = collisionRect.Width * collisionRect.Height;
Type commandType;
if (_collisionDict.TryGetValue(colItem, out commandType))
{
ICommandCollision command = Activator.CreateInstance(commandType) as ICommandCollision;
overlapCommandDict.Add(new KeyValuePair <float, ICommandCollision>(collisionArea, command));
objectsDict.Add(new KeyValuePair <ICommandCollision, IGameObject[]>(command, new[] { collider, collidee }));
}
else
{
colItem.PixelPerfect = true;
if (_collisionDict.TryGetValue(colItem, out commandType))
{
if (PixelPerfectCollision(((IVisibleObject)collider).GetSprite(), ((IVisibleObject)collidee).GetSprite()))
{
ICommandCollision command = Activator.CreateInstance(commandType) as ICommandCollision;
overlapCommandDict.Add(new KeyValuePair <float, ICommandCollision>(collisionArea, command));
objectsDict.Add(new KeyValuePair <ICommandCollision, IGameObject[]>(command, new[] { collider, collidee }));
}
}
}
}
}
}
public CollisionPair(IItem item1, int robotLinkId1, IItem item2, int robotLinkId2)
{
CollisionItem1 = new CollisionItem(item1, robotLinkId1);
CollisionItem2 = new CollisionItem(item2, robotLinkId2);
}
public CollisionPair(IItem item1, IItem item2)
{
CollisionItem1 = new CollisionItem(item1);
CollisionItem2 = new CollisionItem(item2);
}
public void Set(object key, object obj)
{
int hashCode = key.GetHashCode();
HashPage pg = root;
if (pg == null)
{
pg = new HashPage(Storage, pageSize);
int h = (int)((uint)hashCode % pageSize);
pg.items[h] = new CollisionItem(key, obj, hashCode);
root = pg;
nElems = 1;
Modify();
}
else
{
uint divisor = 1;
while (true)
{
int h = (int)((uint)hashCode / divisor % pageSize);
object child = pg.items[h];
if (child is HashPage)
{
pg = (HashPage)child;
divisor *= pageSize;
}
else
{
CollisionItem prev = null;
CollisionItem last = null;
int collisionChainLength = 0;
for (CollisionItem item = (CollisionItem)child; item != null; item = item.next)
{
if (item.hashCode == hashCode)
{
if (item.key.Equals(key))
{
item.obj = obj;
item.Modify();
return;
}
if (prev == null || prev.hashCode != hashCode)
{
collisionChainLength += 1;
}
prev = item;
}
else
{
collisionChainLength += 1;
}
last = item;
}
if (prev == null || prev.hashCode != hashCode)
{
collisionChainLength += 1;
}
if (collisionChainLength > loadFactor)
{
HashPage newPage = new HashPage(Storage, pageSize);
divisor *= pageSize;
CollisionItem next;
for (CollisionItem item = (CollisionItem)child; item != null; item = next)
{
next = item.next;
int hc = (int)((uint)item.hashCode / divisor % pageSize);
item.next = (CollisionItem)newPage.items[hc];
newPage.items[hc] = item;
item.Modify();
}
pg.items[h] = newPage;
pg.Modify();
pg = newPage;
}
else
{
CollisionItem newItem = new CollisionItem(key, obj, hashCode);
if (prev == null)
{
prev = last;
}
if (prev != null)
{
newItem.next = prev.next;
prev.next = newItem;
prev.Modify();
}
else
{
pg.items[h] = newItem;
pg.Modify();
}
nElems += 1;
Modify();
return;
}
}
}
}
}
