Exemple #1
0
			public tileReader(tileReader copy)
			{
				id = nextId;
				nextId++;

				filePos = copy.filePos;

				tileLookup = new TileImportance(copy.tileLookup);
				tile = new Tile(copy.tile);
				tileOrder = new List<Byte>();

				tilesRead = copy.tilesRead;

				foreach (Byte b in copy.tileOrder)
					tileOrder.Add(b);
			}
Exemple #2
0
		private TileImportance[] ScanWorldTiles()
		{
			Byte tryByte;
			Byte tileType;
			Tile curTile;
			Int32 i, j, k;
			tileReader curReader;
			tileReader splitReader;
			TileImportance curList;
			TileImportance[] returnList;

			List<tileReader> readerList = new List<tileReader>();

			buffReader.Seek(stream.Position);

			// We set up the lookup we can change here and we'll simply change it.
			// We might not even need this lookup at all.  Work the logic later.
			curReader = new tileReader(stream.Position);
			curReader.startAt = new Point(0, 0);
			curReader.splitAt = 255;
			curList = curReader.tileLookup;
			curTile = curReader.tile;
			readerList.Add(curReader);

			for (i = 0; i < MaxX; i++)
			{
				progress = (Int32)(((i * MaxY) / (double)(MaxX * MaxY)) * 100);

				for (j = 0; j < MaxY; j++)
				{
					// If somehow we manage to knock out every reader as bad then we need to quit.
					if (readerList.Count == 0)
						return null;

					for (k = 0; k < readerList.Count; k++)
					{
						// No reason to keep resetting these if we only have one path going.
						if (readerList.Count > 1)
						{
							curReader = readerList[k];
							curList = curReader.tileLookup;
							curTile = curReader.tile;

							buffReader.Seek(curReader.filePos);
						}

						tryByte = buffReader.ReadByte();

						if (tryByte > 1)
							goto badPath;

						if (tryByte == 1)
						{
							curTile.Active = true;

							tileType = buffReader.ReadByte();
							curTile.TileType = tileType;

							if (curList.isKnown(tileType) == false)
							{
								// Here we need to split the lists.
								curReader.tileOrder.Add(tileType);
								curList.setKnown(tileType, true);
								splitReader = new tileReader(curReader);
								splitReader.startAt = new Point(i, j);
								splitReader.splitAt = tileType;
								curList.setImportant(tileType, false);
								splitReader.tileLookup.setImportant(tileType, true);
								readerList.Add(splitReader);
								bw.ReportProgress(progress, String.Format("Split #{0} {1}", splitReader.id, readerList.Count));

								curTile.Important = false;
							}
							else
							{
								curTile.Important = curList.isImportant(tileType);
							}
						}
						else
						{
							curTile.Active = false;
							curTile.Important = false;
						}

						if (curTile.Important == true)
						{
							curTile.Frame = new PointInt16(buffReader.ReadInt16(), buffReader.ReadInt16());
						}

						// isLighted
						tryByte = buffReader.ReadByte();

						if (tryByte > 1)
							goto badPath;

						// isWall
						tryByte = buffReader.ReadByte();

						if (tryByte > 1)
							goto badPath;

						if (tryByte == 1)
						{
							curTile.Wall = true;
							// wallType
							tryByte = buffReader.ReadByte();

							// It turns out there will never be a wall type 0.
							if (tryByte == 0)
								goto badPath;

							curTile.WallType = tryByte;
						}
						else
						{
							curTile.Wall = false;
						}

						// isWater
						tryByte = buffReader.ReadByte();

						if (tryByte > 1)
							goto badPath;

						if (tryByte == 1)
						{
							// waterLevel
							tryByte = buffReader.ReadByte();
							curTile.LiquidLevel = tryByte;

							// We can have any water value besides zero, if the isWater bit is set.
							if (tryByte == 0)
								goto badPath;

							// isLava
							tryByte = buffReader.ReadByte();

							if (tryByte > 1)
								goto badPath;

							if (tryByte == 1)
								curTile.Lava = true;
							else
								curTile.Lava = false;
						}

						curReader.filePos = buffReader.Position;

						// This path passed over the end of the tile range.  Bad path.
						// We might not always have a valid chest position though, if they
						// have changed something in a new version.
						if (posChests != 0 && curReader.filePos > posChests)
							goto badPath;

						curReader.tilesRead++;
						continue;

					badPath:
						bw.ReportProgress(progress, String.Format("Path #{0} Terminated {1}", readerList[k].id, readerList.Count - 1));

						// Erase the bad path from the list to process.
						readerList.RemoveAt(k);

						// Now that we removed one we need to move the loop back one to 
						// compensate for how it shifts them over.  Otherwise we could
						// have a 0,1,2 then remove 1 which leaves 0,1 and our next
						// loop is for 2 so the old 2 (new 1) gets skipped.
						k--;
						// If we took it back to one we'll need to set up for the next loop
						// as we put the skip in to speed it up.
						if (readerList.Count == 1)
						{
							curReader = readerList[0];
							curList = curReader.tileLookup;
							curTile = curReader.tile;

							buffReader.Seek(curReader.filePos);
						}
					}
				}
			}

			// Time to prep for the return.
			returnList = new TileImportance[readerList.Count];

			// Find the first one that matched up with the end of the tile position.
			for (k = 0; k < readerList.Count; k++)
			{
				if (readerList[k].filePos == posChests)
					break;
			}

			// Now generate the list but put the one that matched first, if one existed.
			if (readerList.Count == k)
			{
				for (i = 0; i < readerList.Count; i++)
					returnList[i] = readerList[i].tileLookup;
			}
			else
			{
				returnList[0] = readerList[k].tileLookup;

				j = 1;
				for (i = 0; i < readerList.Count; i++)
				{
					if (i != k)
					{
						returnList[j] = readerList[k].tileLookup;
						j++;
					}
				}
			}

			//bw.ReportProgress(progress, String.Format("Path #{0} Terminated {1}", readerList[k].id, readerList.Count - 1));

			return returnList;
		}
Exemple #3
0
 public Client(ClientOps ops = default, uint didLookup = default, sync.Once initOnce = default, error initErr = default, @string name = default, note.Verifiers verifiers = default, tileReader tileReader = default, long tileHeight = default, @string nosumdb = default, parCache record = default, parCache tileCache = default, sync.Mutex latestMu = default, tlog.Tree latest = default, slice <byte> latestMsg = default, sync.Mutex tileSavedMu = default, map <tlog.Tile, bool> tileSaved = default)
 {
     this.ops         = ops;
     this.didLookup   = didLookup;
     this.initOnce    = initOnce;
     this.initErr     = initErr;
     this.name        = name;
     this.verifiers   = verifiers;
     this.tileReader  = tileReader;
     this.tileHeight  = tileHeight;
     this.nosumdb     = nosumdb;
     this.record      = record;
     this.tileCache   = tileCache;
     this.latestMu    = latestMu;
     this.latest      = latest;
     this.latestMsg   = latestMsg;
     this.tileSavedMu = tileSavedMu;
     this.tileSaved   = tileSaved;
 }