public bool TryParse(GameCache cache, List <string> args, out IBlamType result, out string error)
{
result = null;
if (args.Count != 4)
{
error = $"{args.Count} arguments supplied; should be 4";
return(false);
}
else if (!short.TryParse(args[0], out short top))
{
error = $"Unable to parse \"{args[0]}\" (top) as `short`.";
return(false);
}
else if (!short.TryParse(args[1], out short left))
{
error = $"Unable to parse \"{args[1]}\" (left) as `short`.";
return(false);
}
else if (!short.TryParse(args[2], out short bottom))
{
error = $"Unable to parse \"{args[2]}\" (bottom) as `short`.";
return(false);
}
else if (!short.TryParse(args[3], out short right))
{
error = $"Unable to parse \"{args[3]}\" (right) as `short`.";
return(false);
}
else
{
result = new Rectangle2d(top, left, bottom, right);
error = null;
return(true);
}
}
public CacheForm(DirectoryInfo cacheDirectory)
{
InitializeComponent();
if (cacheDirectory.GetFiles("*.dat").Length == 0) // gen3
{
var smf = new SelectMapForm(cacheDirectory);
if (smf.ShowDialog() != DialogResult.OK)
{
Close();
}
Text = smf.SelectedFile.FullName;
Cache = GameCache.Open(smf.SelectedFile);
}
else // HO
{
Text = cacheDirectory.FullName + "\\tags.dat";
Cache = GameCache.Open(new FileInfo(Text));
}
var docFile = new FileInfo(Path.Combine(Application.StartupPath, "BlamCore.xml"));
if (Documentation.ChildNodes.Count == 0 && docFile.Exists)
{
Documentation.Load(docFile.FullName);
}
}
public override object Execute(List <string> args)
{
if (args.Count != 1)
{
return(false);
}
var path = args[0];
var file = new FileInfo(path);
/*
* MapFile map;
*
* using(var stream = new FileStream(path, FileMode.Open))
* using(var reader = new EndianReader(stream))
* {
* map = new MapFile(reader);
* }
*/
GameCache cache;
cache = new GameCache(file);
return(true);
}
public bool TryParse(GameCache cache, List <string> args, out IBlamType result, out string error)
{
result = null;
if (args.Count != 2)
{
error = $"{args.Count} arguments supplied; should be 2";
return(false);
}
else if (!float.TryParse(args[0], out float x))
{
error = $"Unable to parse \"{args[0]}\" (x) as `float`.";
return(false);
}
else if (!float.TryParse(args[1], out float y))
{
error = $"Unable to parse \"{args[1]}\" (y) as `float`.";
return(false);
}
else
{
result = new RealPoint2d(x, y);
error = null;
return(true);
}
}
public static Tag Parse(GameCache cache, string name)
{
if (name == "****" || name == "null")
{
return(Null);
}
if (name.Length < 4)
{
if (name.Length == 3)
{
name = $"{name} ";
}
else if (name.Length == 2)
{
name = $"{name} ";
}
}
if (TagDefinition.TryFind(name, out var type))
{
var attribute = TagStructure.GetTagStructureAttribute(type);
return(new Tag(attribute.Tag));
}
foreach (var pair in TagGroup.Instances)
{
if (name == cache.StringTable.GetString(pair.Value.Name))
{
return(pair.Value.Tag);
}
}
return(Null);
}
public bool TryParse(GameCache cache, List <string> args, out IBlamType result, out string error)
{
result = null;
if (args.Count != 3)
{
error = $"{args.Count} arguments supplied; should be 3";
return(false);
}
else if (!float.TryParse(args[0], out float i))
{
error = $"Unable to parse \"{args[0]}\" (i) as `float`.";
return(false);
}
else if (!float.TryParse(args[1], out float j))
{
error = $"Unable to parse \"{args[1]}\" (j) as `float`.";
return(false);
}
else if (!float.TryParse(args[2], out float d))
{
error = $"Unable to parse \"{args[2]}\" (d) as `float`.";
return(false);
}
else
{
result = new RealPlane2d(i, j, d);
error = null;
return(true);
}
}
public static CommandContext Create(CommandContextStack contextStack, GameCache cache)
{
var context = new CommandContext(contextStack.Context, "tags");
Populate(contextStack, context, cache);
return(context);
}
/// <summary>
/// Rollback all info about storage back to cache state.
/// </summary>
/// <param name="cache"></param>
public void RollbackGame(GameCache cache)
{
UpdateResourceNum(
cache.descriptor.GetPlayerInfo(Unit.TypeEnum.Bread, Unit.OwnerEnum.Black),
cache.descriptor.GetPlayerInfo(Unit.TypeEnum.Bread, Unit.OwnerEnum.White));
SwitchTurn(cache.descriptor.Turn, cache.turnNum);
}
public static void Populate(CommandContext context, GameCache info, CachedTag tag, RenderMethod renderMethod)
{
context.AddCommand(new ListArgumentsCommand(info, tag, renderMethod));
context.AddCommand(new SetArgumentCommand(info, tag, renderMethod));
context.AddCommand(new ListBitmapsCommand(info, tag, renderMethod));
context.AddCommand(new SpecifyBitmapsCommand(info, tag, renderMethod));
}
public bool TryParse(GameCache cache, List <string> args, out IBlamType result, out string error)
{
result = null;
if (args.Count != 4)
{
error = $"{args.Count} arguments supplied; should be 4";
return(false);
}
else if (!float.TryParse(args[0], out float i))
{
error = $"Unable to parse \"{args[0]}\" (i) as `float`.";
return(false);
}
else if (!float.TryParse(args[1], out float j))
{
error = $"Unable to parse \"{args[1]}\" (j) as `float`.";
return(false);
}
else if (!float.TryParse(args[2], out float k))
{
error = $"Unable to parse \"{args[2]}\" (k) as `float`.";
return(false);
}
else if (!float.TryParse(args[3], out float w))
{
error = $"Unable to parse \"{args[3]}\" (w) as `float`.";
return(false);
}
else
{
result = new RealQuaternion(i, j, k, w);
error = null;
return(true);
}
}
public GeometryToObjectConverter(
GameCacheHaloOnlineBase destCache, Stream destStream, GameCache sourceCache,
Stream sourceStream, Scenario scenario, int structureBspIndex)
{
DestCache = destCache;
DestStream = destStream;
SourceCache = sourceCache;
SourceStream = sourceStream;
StructureBspIndex = structureBspIndex;
PortTag = new PortTagCommand(destCache, sourceCache);
PortTag.SetFlags(PortTagCommand.PortingFlags.Default);
Scenario = scenario;
StructureBspIndex = structureBspIndex;
StructureBsp = SourceCache.Deserialize <ScenarioStructureBsp>(SourceStream, Scenario.StructureBsps[structureBspIndex].StructureBsp);
sLdT = SourceCache.Deserialize <ScenarioLightmap>(SourceStream, Scenario.Lightmap);
if (SourceCache.Version >= CacheVersion.Halo3ODST)
{
Lbsp = SourceCache.Deserialize <ScenarioLightmapBspData>(SourceStream, sLdT.LightmapDataReferences[StructureBspIndex]);
}
else
{
Lbsp = sLdT.Lightmaps[StructureBspIndex];
}
var resourceDefinition = SourceCache.ResourceCache.GetRenderGeometryApiResourceDefinition(Lbsp.Geometry.Resource);
Lbsp.Geometry.SetResourceBuffers(resourceDefinition);
StructureBspResources = SourceCache.ResourceCache.GetStructureBspTagResources(StructureBsp.CollisionBspResource);
}
public bool TryParse(GameCache cache, List <string> args, out IBounds result, out string error)
{
result = null;
error = null;
var argType = GetType().GenericTypeArguments[0];
var argCount = SetFieldCommand.RangeArgCount(argType);
if (argCount * 2 != args.Count)
{
error = $"{args.Count} arguments supplied; should be {argCount * 2}";
return(false);
}
var min = SetFieldCommand.ParseArgs(cache, argType, null, args.Take(argCount).ToList());
var max = SetFieldCommand.ParseArgs(cache, argType, null, args.Skip(argCount).Take(argCount).ToList());
if (min.Equals(false) || max.Equals(false))
{
error = $"Invalid value parsed.";
return(false);
}
result = Activator.CreateInstance(this.GetType(), new object[] { min, max }) as IBounds;
return(true);
}
public bool TryParse(GameCache cache, List <string> args, out IBlamType result, out string error)
{
result = null;
if (args.Count != 4)
{
error = $"{args.Count} arguments supplied; should be 4";
return(false);
}
else if (!float.TryParse(args[0], out float a))
{
error = $"Unable to parse \"{args[0]}\" (a) as `float`.";
return(false);
}
else if (!float.TryParse(args[1], out float r))
{
error = $"Unable to parse \"{args[1]}\" (r) as `float`.";
return(false);
}
else if (!float.TryParse(args[2], out float g))
{
error = $"Unable to parse \"{args[2]}\" (g) as `float`.";
return(false);
}
else if (!float.TryParse(args[3], out float b))
{
error = $"Unable to parse \"{args[3]}\" (b) as `float`.";
return(false);
}
else
{
result = new RealArgbColor(a, r, g, b);
error = null;
return(true);
}
}
/// <summary>
/// Rollback the board to cached state.
/// </summary>
public void RollbackGame(GameCache cache)
{
ClearGame();
boardUnit = new Unit[BoardInfo.Row, BoardInfo.Col];
boardBread = new Unit[BoardInfo.Row, BoardInfo.Col];
boardState = new GridState[BoardInfo.Row, BoardInfo.Col];
playerInfo = new Dictionary <Unit.TypeEnum, int>[2] {
new Dictionary <Unit.TypeEnum, int>(), new Dictionary <Unit.TypeEnum, int>()
};
restBreadNum = 0;
for (int i = 0; i < BoardInfo.Row; i++)
{
for (int j = 0; j < BoardInfo.Col; j++)
{
boardState[i, j] = cache.descriptor.GetGridState(i, j);
if (boardState[i, j] == GridState.Bread)
{
CreateUnit(new UnitInfo(new Position(i, j), Unit.TypeEnum.Bread));
}
var unitInfo = cache.descriptor.GetUnitInfo(i, j);
if (unitInfo.type >= Unit.TypeEnum.Scout && unitInfo.type <= Unit.TypeEnum.Bomb)
{
CreateUnit(unitInfo);
}
}
}
for (Unit.TypeEnum type = Unit.TypeEnum.Bread; type < Unit.TypeEnum.Void; type++)
{
playerInfo[(int)Unit.OwnerEnum.Black][type] = cache.descriptor.GetPlayerInfo(type, Unit.OwnerEnum.Black);
playerInfo[(int)Unit.OwnerEnum.White][type] = cache.descriptor.GetPlayerInfo(type, Unit.OwnerEnum.White);
}
restBreadNum = cache.descriptor.RestResource;
SwitchTurn(cache.descriptor.Turn);
}
public bool TryParse(GameCache cache, List <string> args, out IBlamType result, out string error)
{
result = null;
if (args.Count != 2)
{
error = $"{args.Count} arguments supplied; should be 2";
return(false);
}
else if (!float.TryParse(args[0], out float yaw))
{
error = $"Unable to parse \"{args[0]}\" (yaw) as `float`.";
return(false);
}
else if (!float.TryParse(args[1], out float pitch))
{
error = $"Unable to parse \"{args[1]}\" (pitch) as `float`.";
return(false);
}
else
{
result = new RealEulerAngles2d(
Angle.FromDegrees(yaw),
Angle.FromDegrees(pitch));
error = null;
return(true);
}
}
protected override IList <UserRank> GetCacheList()
{
rankList.Clear();
if (rankingData.RankList.Count == 0)
{
var gameCache = new ShareCacheStruct <GameCache>();
var levelrank = gameCache.FindKey("LevelRanking");
if (levelrank == null)
{
levelrank = new GameCache();
levelrank.Key = "LevelRanking";
levelrank.Value = "";
gameCache.Add(levelrank);
gameCache.Update();
}
LevelRankingData data = null;
data = JsonUtils.Deserialize <LevelRankingData>(levelrank.Value);
if (data == null)
{
data = new LevelRankingData();
}
}
foreach (var v in rankingData.RankList)
{
UserRank rank = new UserRank(v);
rankList.Add(rank);
}
return(rankList);
}
public PickerDialog(Instance emulator)
: this()
{
Debug.Assert(emulator != null);
_emulator = emulator;
string cachePath = GameCache.DefaultPath;
_cache = new GameCache();
_cache.Load(cachePath);
umdGameListing.SetCache(_cache);
umdGameListing.Text = "UMDs";
msGameListing.Text = "EBOOTs";
msGameListing.RegionEnabled = false;
SetEnabledState(true);
//this.FindGames();
//umdGameListing_SelectionChanged( umdGameListing, EventArgs.Empty );
this.DialogResult = DialogResult.Cancel;
}
public RenderMaterial(Direct3D.Device device, GameCache cache, TagTool.Geometry.RenderMaterial material)
{
if (material.RenderMethod == null)
{
return;
}
using (var cacheStream = cache.OpenCacheRead())
{
var renderMethod = cache.Deserialize <RenderMethod>(cacheStream, material.RenderMethod);
var template = cache.Deserialize <RenderMethodTemplate>(cacheStream, renderMethod.ShaderProperties[0].Template);
Textures = new Dictionary <string, RenderTexture>();
for (var shaderMapIndex = 0; shaderMapIndex < renderMethod.ShaderProperties[0].TextureConstants.Count; shaderMapIndex++)
{
var shaderMapName = cache.StringTable.GetString(template.TextureParameterNames[shaderMapIndex].Name);
if (Textures.ContainsKey(shaderMapName))
{
continue;
}
var shaderMap = renderMethod.ShaderProperties[0].TextureConstants[shaderMapIndex];
var shaderMapDefinition = cache.Deserialize <Bitmap>(cacheStream, shaderMap.Bitmap);
Textures[shaderMapName] = new RenderTexture(device, cache, shaderMapDefinition, shaderMap.BitmapIndex);
}
}
}
/// <summary>
/// 悔棋点击事件
/// </summary>
public void OnUndoClick()
{
if (GameCache.maps.Count >= 3)
{
//回合状态回退
if (GameController.playing == Playing.OnRed || GameController.playing == Playing.RedAdding)
{
GameController.playing = Playing.OnRed;
}
else
{
GameController.playing = Playing.OnBlack;
}
//棋谱回退 并移除回退前两步信息
GameUtil.SetChessBoardByMaps(GameCache.maps.Count - 1 - 2);
GameCache.maps.RemoveRange(GameCache.maps.Count - 2, 2);
GameCache.attrMaps.RemoveRange(GameCache.attrMaps.Count - 2, 2);
GameCache.UpdateChessData(); //更新映射关系，但不计入图谱
UndoEvent();
}
else
{
//GameObject.Find("UndoButton").GetComponent<Button>().enabled = false;
}
}
public SoundControl(GameCache cache, CachedTag tag, Sound sound) :
this()
{
Cache = cache;
Instance = tag;
Sound = sound;
SoundFile = new FileInfo(Path.Combine(Application.StartupPath, "temp", $"{Instance.Index:X4}.mp3"));
}
/// <summary>
/// 重置游戏数据
/// </summary>
public static void ResetGame()
{
IsBattle = false;
step = 0;
gameStatus = GameStatus.NotBegin;
playing = Playing.None;
GameCache.ClearCache();
}
public void UpdateGameData()
{
GameCache.UpdateChessData();
GameCache.SetMaps();
GameCache.SetAttrMaps();
UpdateGameDataCompleteEvent();
step++;
}
public ArgbColorControl(GameCache cache, FieldInfo field) :
this()
{
Cache = cache;
Field = field;
label1.Text = field.Name.ToSpaced().Replace("_", "");
new ToolTip().SetToolTip(label1, $"{field.FieldType} {CacheForm.GetDocumentation(field)}");
}
public CharacterGenerator()
{
HumanoidMatcher = new Regex(IoC.Get <CharacterConfig>().HumanoidMatcher);
UniqueHumanoidMatcher = new Regex(IoC.Get <CharacterConfig>().UniqueHumanoidMatcher);
Ignored = IoC.Get <CharacterConfig>().IgnoredCharacters.ToArray();
_cache = new GameCache <List <CharacterModel> >("npcs");
}
public StructMultiControl(CacheForm form, GameCache cache, CachedTag tag, object definition) :
this()
{
Form = form;
Cache = cache;
Instance = tag;
Definition = definition;
}
private void EndReceive(IAsyncResult res)
{
var state = res.AsyncState as SocketReceiveBundle;
var ep = new IPEndPoint(IPAddress.Any, Port);
byte[] data = null;
try {
data = state.UdpClient.EndReceive(res, ref ep);
} catch (ObjectDisposedException ex) {
Log.Info($"{nameof(EndReceive)}: This is more or less expected", ex);
return;
}
if (data.Length < 4)
{
Receive();
return;
}
var length = data[0] | data[1] << 8 | data[2] << 16 | data[3] << 24;
if (data.Length < length)
{
Receive();
return;
}
data = data.Skip(4).ToArray();
try {
using (var ms = new MemoryStream(data)) {
ms.Position = 0;
var bf = new BinaryFormatter();
var hg = (HostedGame)bf.Deserialize(ms);
if (hg.Host == "0.0.0.0")
{
hg.HostAddress = $"{ep.Address}:{hg.Port}";
}
lock (GameCache) {
if (GameCache.Contains(hg.Id.ToString()))
{
GameCache.Remove(hg.Id.ToString());
}
GameCache.Add(hg.Id.ToString(), hg, DateTime.Now.AddSeconds(10));
if (_awaitingStart.TryGetValue(hg.Id, out var tcs))
{
tcs.SetResult(hg);
}
}
}
} catch (Exception ex) {
Log.Error($"{nameof(EndReceive)}: Error reading data", ex);
}
Receive();
}
public RuntimeSerializationContext(GameCache cache, ProcessMemoryStream processStream, uint tagAddress, uint originalOffset, uint headerSize, uint originalSize)
{
Cache = cache;
ProcessStream = processStream;
StartAddress = tagAddress;
OriginalStructOffset = originalOffset;
HeaderSize = headerSize;
OriginalSize = originalSize;
}
public static CommandContext Create(CommandContext parent, GameCache cache, CachedTag tag, CollisionModel definition)
{
var groupName = cache.StringTable.GetString(tag.Group.Name);
var commandContext = new CommandContext(parent, string.Format("{0:X8}.{1}", tag.Index, groupName));
Populate(commandContext, cache, tag, definition);
return(commandContext);
}
public static void Populate(CommandContext context, GameCache cache, CachedTag tag, RenderModel renderModel)
{
context.AddCommand(new SpecifyShadersCommand(cache, tag, renderModel));
context.AddCommand(new DumpRenderGeometryCommand(cache, renderModel.Geometry));
context.AddCommand(new ReplaceRenderGeometryCommand(cache, tag, renderModel));
context.AddCommand(new ExtractModelCommand(cache, renderModel));
context.AddCommand(new ExtractBitmapsCommand(cache, renderModel));
context.AddCommand(new ExtractBMFCommand(cache, renderModel));
}
public ShaderMatcherNew(GameCache baseCache, GameCache portingCache, Stream baseCacheStream, Stream portingCacheStream, bool useMS30 = false)
{
UseMs30 = useMS30;
BaseCache = baseCache;
PortingCache = portingCache;
BaseCacheStream = baseCacheStream;
PortingCacheStream = portingCacheStream;
Init();
}
public PickerDialog( Instance emulator )
: this()
{
Debug.Assert( emulator != null );
_emulator = emulator;
string cachePath = GameCache.DefaultPath;
_cache = new GameCache();
_cache.Load( cachePath );
umdGameListing.SetCache( _cache );
umdGameListing.Text = "UMDs";
msGameListing.Text = "EBOOTs";
msGameListing.RegionEnabled = false;
SetEnabledState( true );
//this.FindGames();
//umdGameListing_SelectionChanged( umdGameListing, EventArgs.Empty );
this.DialogResult = DialogResult.Cancel;
}
public GameRoom(string gameId, GameCache roomCache = null, int emptyRoomLiveTime = 0)
: base(gameId, roomCache, emptyRoomLiveTime)
{
}
public void SetCache( GameCache cache )
{
_cache = cache;
}
