private static void Main(string[] args)
{
if (args.Length < 1)
{
PrintMissingPathMessage();
return;
}
var gameFullPath = args[0];
// We need to initialize containers at the beginning
NegumContainer.RegisterKnownTypes();
NegumGameContainer.RegisterKnownTypes();
var client = new NegumSdlClient();
Console.WriteLine($"Loading directory: {gameFullPath}");
client.Initialize(gameFullPath);
Console.WriteLine("Directory loaded.");
client.CreateWindow();
client.Start();
client.Clear();
}
public override async Task <ISprite> ReadAsync(BinaryReader binaryReader, string signature, string version)
{
var paletteReader = NegumContainer.Resolve <IPaletteReader>();
var pcxReader = NegumContainer.Resolve <IPcxReader>();
var sprite = new SffSpriteV1
{
Signature = signature,
Version = version,
GroupCount = binaryReader.ReadUInt32(),
ImageCount = binaryReader.ReadUInt32(),
PosFirstSubFileOffset = binaryReader.ReadUInt32(), // Next Sub File Offset
Length = binaryReader.ReadUInt32(), // Sub-Header Size
PaletteType = binaryReader.ReadByte(), // Shared Palette Byte; 0 - individual, 1 - shared
Blank = binaryReader.ReadBytes(3).ToUtf8String(),
Comments = binaryReader.ReadBytes(476).ToUtf8String()
};
for (var i = 0; i < sprite.ImageCount; ++i)
{
var subFile = await ReadSubFileAsync(pcxReader, binaryReader, i, paletteReader, sprite);
sprite.AddSubFile(subFile);
}
return(sprite);
}
public async Task Should_Count_Number_Of_Scenes_And_Print_Details(string path)
{
this.InitializeContainer();
var config = await this.ParseWithSubsections(path);
var manager = (IStoryboardManager)NegumContainer.Resolve <IStoryboardManager>().UseConfiguration(config);
var scenes = manager.Scenes;
Assert.True(scenes.Count() == 3);
var time = scenes.FirstOrDefault().FadeInTime;
var timeDetails = time.GetTimeSpan().Ticks;
Assert.True(timeDetails == 35);
var introConfig = await this.ParseAnimation(path);
var introManager =
(IAnimationManager)NegumContainer.Resolve <IAnimationManager>().UseConfiguration(introConfig);
var actions = introManager.Animations;
Assert.True(actions.Count() == 3);
Assert.True(actions.ElementAt(0).ActionNumber == 0);
Assert.True(actions.ElementAt(0).Parts.Count() == 1);
Assert.True(actions.ElementAt(1).ActionNumber == 1);
Assert.True(actions.ElementAt(1).Parts.Count() == 1);
Assert.True(actions.ElementAt(2).Parts.Count() == 1);
Assert.True(actions.ElementAt(2).Parts.ElementAt(0).Frames.Count() == 2301);
}
public void ProcessChunk(byte[] chunkData, IDictionary <string, object> chunkProcessorState)
{
var paletteReader = NegumContainer.Resolve <IPaletteReader>();
var palette = paletteReader.ReadAsync(chunkData).Result;
chunkProcessorState.Add(this.GetChunkName(), palette);
}
protected async Task <Stream> ReadFromUrl(string url)
{
var urlReader = NegumContainer.Resolve <IUrlReader>();
var stream = await urlReader.ReadAsync(url);
return(stream);
}
/// <summary>
/// </summary>
/// <returns>New Negum Client object.</returns>
/// <param name="negumDirPath">Path to the Negum directory.</param>
/// <param name="ipAddress">IP address which will be used during the game. See: ISideConfiguration.ConnectionContext</param>
/// <param name="port">Port which will be used during the game. See: IConnectionContext.Port</param>
public static async Task <INegumClient> CreateAsync(string negumDirPath, string ipAddress = null, int port = -1)
{
var engineProvider = NegumContainer.Resolve <IEngineProvider>();
var engine = await engineProvider.InitializeAsync(negumDirPath);
if (string.IsNullOrWhiteSpace(ipAddress))
{
ipAddress = NetworkHelper.GetLocalAddress();
}
if (port == -1)
{
port = NetworkHelper.GetNextFreePort();
}
var connectionContext = new ConnectionContext
{
Hostname = ipAddress,
Port = port
};
var sideConfig = new SideConfiguration
{
ConnectionContext = connectionContext,
Engine = engine
};
var client = new NegumClient(sideConfig);
return(client);
}
public async Task Should_Parse_Triggers(string path)
{
this.InitializeContainer();
var config = await this.ParseConstants(path);
var manager = (ICharacterCommandsManager)NegumContainer.Resolve <ICharacterCommandsManager>().UseConfiguration(config);
var states = manager.States;
Assert.True(states.Any());
var state = states.FirstOrDefault();
Assert.True(state != null);
var triggers = state.Triggers;
Assert.True(triggers.Any());
var trigger = triggers.FirstOrDefault();
Assert.True(trigger != null);
Assert.True(trigger.IsTriggerAll);
Assert.True(trigger.NameRaw.Equals(TriggerEntry.TriggerAllKey));
Assert.True(trigger.ExpressionRaw.Equals("command = SmashKFUpper"));
}
private async Task <IConfiguration> ParseInternal <TReader>(string path)
where TReader : IConfigurationReader
{
var reader = NegumContainer.Resolve <TReader>();
var data = await reader.ReadAsync(path);
return(data);
}
public void Should_Register_All_Client_Modules()
{
NegumGameContainer.RegisterKnownTypes();
Assert.NotNull(NegumContainer.Resolve <IClientPacketHandler>());
Assert.NotNull(NegumContainer.Resolve <IInputManager>());
Assert.NotNull(NegumContainer.Resolve <IClientHooks>());
}
public override IVectorEntry Get()
{
var reader = NegumContainer.Resolve <IStringVectorReader>();
this.Vector = reader.ReadAsync(this.RawValue).Result;
return(this);
}
public async Task Should_Read_Font_NoDef(string path)
{
NegumContainer.RegisterKnownTypes();
var reader = NegumContainer.Resolve <IFontPathReader>();
var font = await reader.ReadAsync(path);
Assert.NotNull(font);
}
protected virtual async Task <TManager> ReadManagerAsync <TManager, TReader>(string path)
where TManager : IManager
where TReader : IConfigurationReader
{
var reader = NegumContainer.Resolve <TReader>();
var configuration = await reader.ReadAsync(path);
return((TManager)NegumContainer.Resolve <TManager>().UseConfiguration(configuration));
}
/// <summary>
/// Method used to parse common properties vor various Font versions.
/// </summary>
/// <param name="font"></param>
/// <param name="manager"></param>
protected virtual void ProcessConfiguration(Font font, IFontManager manager)
{
var pointReader = NegumContainer.Resolve <IPointReader>();
font.Size = pointReader.ToPointAsync(manager.Def.Size).Result;
font.Spacing = pointReader.ToPointAsync(manager.Def.Spacing).Result;
font.Offset = pointReader.ToPointAsync(manager.Def.Offset).Result;
font.Type = manager.Def.Type;
}
public async Task Should_Create_New_Negum_Client_Object(string negumDirPath)
{
NegumContainer.RegisterKnownTypes();
NegumGameContainer.RegisterKnownTypes();
var client = await NegumClientFactory.CreateAsync(negumDirPath);
Assert.NotNull(client);
}
public async Task Should_Read_Engine_Using_Registered_Loaders(string path)
{
this.InitializeContainer();
var engineProvider = NegumContainer.Resolve <IEngineProvider>();
var engine = await engineProvider.InitializeAsync(path);
Assert.True(engine != null);
}
public async Task Should_Parse_Font(string path)
{
this.InitializeContainer();
var config = await this.Parse(path);
var manager = (IFontManager)NegumContainer.Resolve <IFontManager>().UseConfiguration(config);
Assert.True(manager.Def.Type.Equals("bitmap"));
}
public async Task <ISprite> ReadAsync(string path)
{
var fileContentStream = await NegumContainer.Resolve <IFileContentReader>().ReadAsync(path);
var memoryStream = await NegumContainer.Resolve <IMemoryStreamReader>().ReadAsync(fileContentStream);
var sprite = await NegumContainer.Resolve <ISpriteReader>().ReadAsync(memoryStream);
return(sprite);
}
protected virtual async Task <TManager> FindManagerAsync <TManager>(string dirName, string filePath)
where TManager : IManager
{
var reader = NegumContainer.Resolve <IFilePathReader>();
var file = reader.FindFile(dirName, filePath);
var manager = await this.ReadManagerAsync <TManager>(file);
return(manager);
}
public async Task <ISffPngImageHeader> ReadAsync(Stream input)
{
var expectedHeader = new byte[] { 137, 80, 78, 71, 13, 10, 26, 10 };
var headerBytes = new byte[SffPngHelper.ImageHeaderLength];
if (input.Read(headerBytes) != SffPngHelper.ImageHeaderLength)
{
throw new ArgumentException($"Cannot read header bytes.");
}
if (!expectedHeader.SequenceEqual(headerBytes))
{
throw new ArgumentException($"Malformed image header.");
}
var pngChunkHeaderReader = NegumContainer.Resolve <ISffPngChunkHeaderReader>();
var pngChunkHeader = await pngChunkHeaderReader.ReadAsync(input);
if (pngChunkHeader.Length != SffPngHelper.ChunkHeaderLength)
{
throw new ArgumentException($"Invalid PNG image header length: {pngChunkHeader.Length}");
}
if (!pngChunkHeader.Name.Equals("IHDR"))
{
throw new ArgumentException($"Invalid PNG image header name: {pngChunkHeader.Name}");
}
var headerChunkBytes = new byte[SffPngHelper.ChunkHeaderLength];
if (input.Read(headerChunkBytes) != SffPngHelper.ChunkHeaderLength)
{
throw new ArgumentException($"Cannot read header chunk bytes,");
}
var crc = new byte[SffPngHelper.CrcDataLength];
if (input.Read(crc) != SffPngHelper.CrcDataLength)
{
throw new ArgumentException($"Cannot read CRC data from header chunk.");
}
var width = SffPngHelper.ReadBigEndian(headerChunkBytes, 0);
var height = SffPngHelper.ReadBigEndian(headerChunkBytes, 4);
var imageHeader = new SffPngImageHeader(headerChunkBytes)
{
Width = width,
Height = height,
};
return(imageHeader);
}
public virtual async Task <ISprite> GetSpriteAsync(string dirName, string spritePath)
{
var file = this.FindFile(dirName, spritePath);
if (file == null)
{
return(null);
}
return(await NegumContainer.Resolve <ISpritePathReader>().ReadAsync(file.FullName));
}
public async Task Should_Parse_Palette_File(string url)
{
this.InitializeContainer();
var stream = await this.ReadFromUrl(url);
var paletteReader = NegumContainer.Resolve <IPaletteReader>();
var palette = await paletteReader.ReadAsync(stream);
Assert.True(palette.Count() == 256);
}
public async Task Should_Count_Number_Of_Scenes(string path, int sceneCount)
{
this.InitializeContainer();
var config = await this.ParseWithSubsections(path);
var manager = (IStoryboardManager)NegumContainer.Resolve <IStoryboardManager>().UseConfiguration(config);
var scenes = manager.Scenes;
Assert.True(scenes.Count() == sceneCount);
}
public async Task Should_Read_Character_Data(string path)
{
this.InitializeContainer();
var config = await this.Parse(path);
var manager = (ICharacterManager)NegumContainer.Resolve <ICharacterManager>().UseConfiguration(config);
var displayName = manager.Info.DisplayName;
Assert.True(displayName.Equals("Kung Fu Man"));
}
public async Task Should_Get_Appropriate_Key(string path)
{
this.InitializeContainer();
var config = await this.Parse(path);
var manager = (IConfigurationManager)NegumContainer.Resolve <IConfigurationManager>().UseConfiguration(config);
var key = manager.P1Keys.Keys.X;
Assert.True(key == 108);
}
public async Task Should_Get_Number_Of_Backgrounds(string path)
{
this.InitializeContainer();
var config = await this.ParseWithSubsections(path);
var manager = (IStageManager)NegumContainer.Resolve <IStageManager>().UseConfiguration(config);
var backgrounds = manager.Backgrounds;
Assert.True(backgrounds.Count() == 2);
}
public async Task Should_Parse_Win_Text(string path)
{
this.InitializeContainer();
var config = await this.Parse(path);
var manager = (IFightManager)NegumContainer.Resolve <IFightManager>().UseConfiguration(config);
var text = manager.Round.WinText.Text;
Assert.True(text.Equals("%s Wins"));
}
public async Task <Stream> ReadAsync(string path)
{
if (path.StartsWith("http") || path.StartsWith("www") || path.Contains("://"))
{
var urlReader = NegumContainer.Resolve <IUrlReader>();
return(await urlReader.ReadAsync(path));
}
var localFileReader = NegumContainer.Resolve <ILocalFileReader>();
return(await localFileReader.ReadAsync(path));
}
protected virtual async Task<IStage> GetStageAsync(FileInfo defFile)
{
var reader = NegumContainer.Resolve<IFilePathReader>();
var stage = new Stage();
stage.File = defFile;
stage.Manager = await this.ReadManagerAsync<IStageManager>(defFile);
stage.Sprite = await reader.GetSpriteAsync(defFile.DirectoryName, stage.Manager.BackgroundDef.SpriteFile);
return stage;
}
protected virtual async Task <IFont> GetFontV0Async(string path)
{
var fileContentStream = await NegumContainer.Resolve <IFileContentReader>().ReadAsync(path);
var memoryStream = await NegumContainer.Resolve <IMemoryStreamReader>().ReadAsync(fileContentStream);
var binaryReader = new BinaryReader(memoryStream);
var(signature, version) = this.ReadFileHeader(binaryReader);
return(await NegumContainer.Resolve <IFontV0Reader>().ReadAsync(binaryReader, signature, version));
}
public async Task Should_Read_Selection_Data(string path)
{
this.InitializeContainer();
var config = await this.Parse(path);
var manager = (ISelectionManager)NegumContainer.Resolve <ISelectionManager>().UseConfiguration(config);
Assert.True(manager.Characters.Characters.Count() == 2);
Assert.True(manager.Stages.StageFiles.Count() == 1);
Assert.True(manager.Options.ArcadeMaxMatches.RawValue.Equals("6,1,1,0,0,0,0,0,0,0"));
Assert.True(manager.Options.TeamMaxMatches.RawValue.Equals("4,1,1,0,0,0,0,0,0,0"));
}
