protected override void OnInit(EventArgs e)
{
mContainer = new TitleContainer(string.Empty);
Template.InstantiateIn(mContainer);
divHelp.Controls.Add(mContainer);
base.OnInit(e);
}
public void Initialize(TitleContainer control)
{
control.Width = 300;
child = new Placeholder{Text = "My Child", Height = 250};
control.Title = "My Title";
control.Child = child;
}
protected override void LoadContent()
{
/// <summary>method <c>LoadContent</c> load the game content.</summary>
_spriteBatch = new SpriteBatch(GraphicsDevice);
using (var stream = TitleContainer.OpenStream("Content/charactersheet.png"))
{
characterSheetTexture = Texture2D.FromStream(this.GraphicsDevice, stream);
}
// (With this.Content) Load your game content here
title = Content.Load <SpriteFont>("Title");
paragraph = Content.Load <SpriteFont>("Paragraph");
}
public Stream Open(string assetName)
{
if (AssetManager.SeparatorSymbol != Path.DirectorySeparatorChar)
{
assetName = assetName.Replace(AssetManager.SeparatorSymbol, Path.DirectorySeparatorChar);
}
if (!string.IsNullOrEmpty(BaseFolder))
{
assetName = Path.Combine(BaseFolder, assetName);
}
return(TitleContainer.OpenStream(assetName));
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
testTexture = null;
if (!Program.loadTexture)
{
return;
}
//decrypt tpf file;
string tpfFile = Program.orgFileName.Substring(0, Program.orgFileName.Length - 5) + "tpf";
try {
if (Program.targetTPF != null)
{
foreach (var t in Program.targetTPF.Textures)
{
textureMap.Add(t.Name, getTextureFromBitmap(readDdsStreamToBitmap(new MemoryStream(t.Bytes)), this.GraphicsDevice));
// System.Windows.MessageBox.Show("Added:" + t.Name);
}
}
else
if (File.Exists(tpfFile))
{
var tpf = SoulsFormats.TPF.Read(tpfFile);
foreach (var t in tpf.Textures)
{
textureMap.Add(t.Name, getTextureFromBitmap(readDdsStreamToBitmap(new MemoryStream(t.Bytes)), this.GraphicsDevice));
// System.Windows.MessageBox.Show("Added:" + t.Name);
}
}
} catch (Exception e)
{
}
using (var stream = TitleContainer.OpenStream("singleColor.png"))
{
testTexture = Texture2D.FromStream(this.GraphicsDevice, stream);
}
// testTexture = getTextureFromBitmap(readDdsFileToBitmap("EliteKnight.dds"),this.GraphicsDevice);
/* string path = @"data\img\27.png";
*
* System.Drawing.Bitmap btt = new System.Drawing.Bitmap(path);
* test = Texture2D.FromStream(this.GraphicsDevice, File.OpenRead(path));
* test = getTextureFromBitmap(btt, this.GraphicsDevice);*/
// TODO: use this.Content to load your game content here
}
/// <summary>
///
/// </summary>
/// <param name="containerName"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public Boolean FileExists(String containerName, String fileName)
{
try
{
using (Stream stream = TitleContainer.OpenStream(String.Join(@"\", containerName, fileName)))
{
return(true);
}
}
catch (FileNotFoundException)
{
return(false);
}
}
/// <summary>
/// Plays a sound file from the application assets.
/// </summary>
/// <param name="soundName"></param>
private static void PlaySound(string soundName)
{
using (var stream = TitleContainer.OpenStream(soundName))
{
if (stream == null)
{
return;
}
var effect = SoundEffect.FromStream(stream);
FrameworkDispatcher.Update();
effect.Play();
}
}
protected internal override Video Read(ContentReader input, Video existingInstance)
{
string path = input.ReadObject <string>();
path = Path.Combine(input.ContentManager.RootDirectory, path);
path = TitleContainer.GetFilename(path);
/*int durationMS =*/ input.ReadObject <int>();
/*int width =*/ input.ReadObject <int>();
/*int height =*/ input.ReadObject <int>();
/*float framesPerSecond =*/ input.ReadObject <Single>();
/*int soundTrackType =*/ input.ReadObject <int>(); // 0 = Music, 1 = Dialog, 2 = Music and dialog
return(new Video(path));
}
protected override void LoadContent()
{
// Notice that loading a model is very similar
// to loading any other XNB (like a Texture2D).
// The only difference is the generic type.
model = Content.Load <Model> ("robot");
// We aren't using the content pipeline, so we need
// to access the stream directly:
using (var stream = TitleContainer.OpenStream("Content/checkerboard.png"))
{
checkerboardTexture = Texture2D.FromStream(this.GraphicsDevice, stream);
}
}
public static Texture2D LoadTextureFromFile(string filePath, GraphicsDevice graphicsDevice)
{
try
{
using (System.IO.Stream stream = TitleContainer.OpenStream(filePath)) //TODO what is TitleContainer?
{
return(LoadTextureFromStream(stream, graphicsDevice));
}
}
catch
{
throw new System.IO.FileLoadException("Cannot load '" + filePath + "' file!");
}
}
public CharacterEntity(GraphicsDevice graphicsDevice)
{
if (characterSheetTexture == null)
{
using var stream = TitleContainer.OpenStream("Content/charactersheet.png");
characterSheetTexture = Texture2D.FromStream(graphicsDevice, stream);
}
walkDown = new Animation()
.AddFrame(new Rectangle(0, 0, 32, 32), TimeSpan.FromSeconds(.25))
.AddFrame(new Rectangle(32, 0, 32, 32), TimeSpan.FromSeconds(.25))
.AddFrame(new Rectangle(0, 0, 32, 32), TimeSpan.FromSeconds(.25))
.AddFrame(new Rectangle(64, 0, 32, 32), TimeSpan.FromSeconds(.25));
}
private BmFont loadFont(string path)
{
var fontFilePath = findFile(path);
using (var stream = TitleContainer.OpenStream(fontFilePath))
{
var fontFile = FontLoader.Load(stream);
var fontPng = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(path), fontFile.Pages[0].File);
// textRenderer initialization will go here
stream.Close();
return(new BmFont(fontFile, fontPng));
}
}
/// <summary>
/// Load track data
/// </summary>
/// <param name="setFilename">Set filename</param>
public static TrackData Load(string setFilename)
{
// Load track data
using (StreamReader file = new StreamReader(TitleContainer.OpenStream(
Directory + "\\" + setFilename + "." + Extension)))
{
// Load everything into this class with help of the XmlSerializer.
TrackData loadedTrack = (TrackData)
new XmlSerializer(typeof(TrackData)).
Deserialize(file.BaseStream);
// Return loaded file
return(loadedTrack);
}
}
/// <summary>
/// Given the path to a file relative to the game's content directory,
/// reads the file as text and returns the content as a string.
/// </summary>
/// <param name="contentPath">
/// The path ot hte file to read relative to the content directory.
/// </param>
/// <returns>
/// The content of the file as a string.
/// </returns>
public static async Task <string> ReadFileAsync(string contentPath)
{
string fileContent = string.Empty;
using (var stream = TitleContainer.OpenStream(Path.Combine(Engine.Instance.Content.RootDirectory, contentPath)))
{
using (var reader = new StreamReader(stream))
{
fileContent = await reader.ReadToEndAsync();
}
}
return(fileContent);
}
private static LevelData[] LoadXmlDoc()
{
string data = null;
using (var fs = TitleContainer.OpenStream("levels.xml")) {
using (var sr = new StreamReader(fs))
data = sr.ReadToEnd();
}
var lvls = new List <LevelData>();
var doc = XDocument.Parse(data);
foreach (var ld in doc.Root.Elements("LevelData"))
{
if (ld.IsEmpty)
{
break;
}
var levelData = new LevelData();
levelData.map = new Array <Array <int> >();
var map = ld.Element("map");
foreach (var aoi in map.Elements("ArrayOfInt"))
{
var a = new Array <int>();
foreach (var i in aoi.Elements("int"))
{
a.push(Convert.ToInt32(i.Value));
}
levelData.map.push(a);
}
levelData.playerDir = Convert.ToInt32(ld.Element("playerDir").Value);
int x = Convert.ToInt32(ld.Element("player").Element("x").Value);
int y = Convert.ToInt32(ld.Element("player").Element("y").Value);
levelData.player = new Point(x, y);
levelData.food = Convert.ToInt32(ld.Element("food").Value);
levelData.endingDist = Convert.ToInt32(ld.Element("endingDist").Value);
levelData.turns = Convert.ToInt32(ld.Element("turns").Value);
lvls.Add(levelData);
}
return(lvls.ToArray());
}
protected virtual void ReloadAsset <T>(string originalAssetName, T currentAsset)
{
string str = originalAssetName;
if (string.IsNullOrEmpty(str))
{
throw new ArgumentNullException("assetName");
}
if (this.disposed)
{
throw new ObjectDisposedException("ContentManager");
}
if (this.graphicsDeviceService == null)
{
this.graphicsDeviceService = this.serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
if (this.graphicsDeviceService == null)
{
throw new InvalidOperationException("No Graphics Device Service");
}
}
try
{
Stream stream = this.OpenStream(str);
try
{
using (BinaryReader xnbReader = new BinaryReader(stream))
{
using (ContentReader contentReaderFromXnb = this.GetContentReaderFromXnb(str, ref stream, xnbReader, (Action <IDisposable>)null))
{
contentReaderFromXnb.InitializeTypeReaders();
contentReaderFromXnb.ReadObject <T>(currentAsset);
contentReaderFromXnb.ReadSharedResources();
}
}
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
}
catch (ContentLoadException ex)
{
string assetName = this.Normalize <T>(TitleContainer.GetFilename(Path.Combine(this.RootDirectory, str)));
this.ReloadRawAsset <T>(currentAsset, assetName, originalAssetName);
}
}
public void Play(int id)
{
if (effectInstance != null && effectInstance.State == SoundState.Playing)
{
effectInstance.Stop();
}
SoundModel selectedSound = Sounds.First(s => s.ID == id);
var stream = TitleContainer.OpenStream(selectedSound.Uri);
effectInstance = SoundEffect.FromStream(stream).CreateInstance();
FrameworkDispatcher.Update();
effectInstance.Play();
}
public void LoadContent()
{
System.IO.Stream imgStream = TitleContainer.OpenStream(GameManager.Instance.Content.RootDirectory + "/images.txt");
System.IO.StreamReader reader = new System.IO.StreamReader(imgStream);
string line = reader.ReadLine();
while (line != null)
{
string[] data = line.Split(new char[] { ' ' });
int lastPos = data[0].LastIndexOf('.');
string name = data[0].Substring(0, lastPos);
LoadImage(name, data[1]);
line = reader.ReadLine();
}
}
public static bool LoadTitleLevel(string Path)
{
Stream s = TitleContainer.OpenStream("Content/Levels/" + Path + ".lvl");
if (s != null)
{
GameManager.SetLevel(new Level(false));
GameManager.GetLevel().Read(new BinaryReader(s));
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Method to load each level
/// </summary>
private void LoadLevel()
{
levelIndex = (levelIndex + 1) % numberOfLevels;
if (level != null)
{
level.Dispose();
}
string path = string.Format("Content/Levels/{0}.txt", levelIndex);
using (Stream fileStream = TitleContainer.OpenStream(path))
{
level = new LevelHandler(Services, fileStream, levelIndex);
}
}
public Animation(GraphicsDevice graphicsDevice, String dir)
{
string[] files = System.IO.Directory.GetFiles(dir);
frameCount = files.Count();
AnimationFrames = new List <Texture2D>();
for (int i = 0; i < frameCount; i++)
{
System.Diagnostics.Debug.WriteLine(files[i]);
System.Diagnostics.Debug.WriteLine(files[i].Remove(0, "Content/".Length));
var stream = TitleContainer.OpenStream(files[i].Remove(0, "Content/".Length));
AnimationFrames.Add(Texture2D.FromStream(graphicsDevice, stream));
}
frameHeight = AnimationFrames[0].Height;
frameWidth = AnimationFrames[0].Width;
}
public override Stream OpenInputStream(String path)
{
if (path.StartsWith("monkey://data/"))
{
try{
return(TitleContainer.OpenStream(PathToContentPath(path)));
}catch (Exception) {
}
}
else
{
return(base.OpenInputStream(path));
}
return(null);
}
public override void Init(GraphicsDeviceManager _graphics, ContentManager Content, GraphicsDevice GraphicsDevice, ScreenManager screenManager, Game game)
{
this.game = game;
FPS = new Vector2(10, 10);
font = Content.Load <SpriteFont>("File");
FontSystem fontSystem = FontSystemFactory.Create(GraphicsDevice, 2048, 2048);
fontSystem.AddFont(TitleContainer.OpenStream($"{Content.RootDirectory}/Monaco-1.ttf"));
GuiHelper.Setup(game, fontSystem);
_ui = new IMGUI();
Text = new Vector2(30, 30);
base.Init(_graphics, Content, GraphicsDevice, screenManager, game);
}
protected void Page_Init()
{
if (_content != null)
{
BoxContainer c = new BoxContainer();
Content.InstantiateIn(c);
phContent.Controls.Add(c);
}
if (_title != null)
{
TitleContainer t = new TitleContainer();
Title.InstantiateIn(t);
phTitle.Controls.Add(t);
}
}
public FlxTilemap loadMapFile(String CSVdataFile, String Graphic, int TileWidth, int TileHeight, uint DrawIndex = 0, int CollideIndex = 1)
{
string CsvData = "";
using (var stream = TitleContainer.OpenStream("Content/" + CSVdataFile))
using (var reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
CsvData += reader.ReadLine() + "\n";
}
stream.Dispose();
}
return(loadMap(CsvData, Graphic, TileWidth, TileHeight, DrawIndex, CollideIndex));
}
public TileBase Initialise(int x, int y, string image)
{
X = x;
Y = y;
var yFromTop = Screen.Height - 1 - y;
var rawY = yFromTop * TileDimension;
var rawX = x * TileDimension;
Position = new Rectangle(rawX, rawY, TileDimension, TileDimension);
using (var stream = TitleContainer.OpenStream($"Content/img/{image}")) // ToDo: this should be done using a `Content.mgcb` file, but I couldn't get it to work
_texture = Texture2D.FromStream(GameLoopBase.GraphicsDevice, stream);
return(this);
}
public void readLevels()
{
Stream stream = TitleContainer.OpenStream("Content/levels/levels.txt");
StreamReader sr = new StreamReader(stream);
String temp = "";
while (!sr.EndOfStream)
{
temp = "corrupted load";//will be replaced if loaded properly
temp = sr.ReadLine();
level_names.Add(temp);
}
sr.Close();
}
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
//whiteRectangle = Content.Load<Texture2D>("60789_01");
whiteRectangle = new Texture2D(GraphicsDevice, 1, 1);
whiteRectangle.SetData(new[] { Color.White });
// We aren't using the content pipeline, so we need
// to access the stream directly:
using (var stream = TitleContainer.OpenStream("Content/checkerboard.png"))
{
checkerboardTexture = Texture2D.FromStream(this.GraphicsDevice, stream);
}
}
/// <summary>
/// After the font has been loaded, (with the <see cref="FilePath"/>, <see cref="GlyphHeight"/>, and <see cref="GlyphWidth"/> fields filled out) this method will create the actual texture.
/// </summary>
public void Generate()
{
cachedFonts = new Dictionary <Font.FontSizes, Font>();
LoadedFilePath = System.IO.Path.Combine(Global.SerializerPathHint, FilePath);
// I know.. bad way to do this.. yuck
if (!Settings.LoadingEmbeddedFont)
{
using (System.IO.Stream fontStream = TitleContainer.OpenStream(LoadedFilePath))
Image = Texture2D.FromStream(Global.GraphicsDevice, fontStream);
ConfigureRects();
}
}
private void LoadMap(string mapName)
{
// Unloads the content for the current level before loading the next one.
if (map != null)
{
map.Dispose();
}
// Load the level.
string levelPath = string.Format("Content/Maps/{0}.txt", mapName);
using (Stream fileStream = TitleContainer.OpenStream(levelPath))
map = new Map(Services, fileStream);
}
private void PlaySound(string path)
{
if (!string.IsNullOrEmpty(path))
{
using (var stream = TitleContainer.OpenStream(path))
{
if (stream != null)
{
var effect = SoundEffect.FromStream(stream);
FrameworkDispatcher.Update();
effect.Play();
}
}
}
}
private void LoadLevel(int levelnr)
{
if (map != null)
{
map.Dispose();
}
string path = $"Content/MapContent/{levelnr}.txt";
using (Stream stream = TitleContainer.OpenStream(path))
{
map = new Map(mapContent, stream);
Console.WriteLine(path);
}
}
protected virtual async Task <Stream> OpenStreamAsync(string assetName)
{
Stream stream;
try
{
var assetPath = Path.Combine(RootDirectory, assetName) + ".xnb";
// This is primarily for editor support.
// Setting the RootDirectory to an absolute path is useful in editor
// situations, but TitleContainer can ONLY be passed relative paths.
#if DESKTOPGL || WINDOWS
if (Path.IsPathRooted(assetPath))
{
stream = File.OpenRead(assetPath);
}
else
#endif
stream = await TitleContainer.OpenStreamAsync(assetPath);
#if ANDROID
// Read the asset into memory in one go. This results in a ~50% reduction
// in load times on Android due to slow Android asset streams.
MemoryStream memStream = new MemoryStream();
stream.CopyTo(memStream);
memStream.Seek(0, SeekOrigin.Begin);
stream.Close();
stream = memStream;
#endif
}
#if !WEB
catch (FileNotFoundException fileNotFound)
{
throw new ContentLoadException("The content file was not found.", fileNotFound);
}
#if !WINDOWS_UAP
catch (DirectoryNotFoundException directoryNotFound)
{
throw new ContentLoadException("The directory was not found.", directoryNotFound);
}
#endif
#endif
catch (Exception exception)
{
throw new ContentLoadException("Opening stream error.", exception);
}
return(stream);
}
public void ToggleIsOpenOn(TitleContainer control)
{
control.ToggleIsOpenOn = control.ToggleIsOpenOn == ClickGesture.SingleClick
? ClickGesture.DoubleClick
: ClickGesture.SingleClick;
Debug.WriteLine("ToggleIsOpenOn: " + control.ToggleIsOpenOn);
}
public void Toggle_IsOpen(TitleContainer control)
{
control.IsOpen = !control.IsOpen;
Debug.WriteLine("IsOpen" + control.IsOpen);
}
public void Animate_Default_Speed(TitleContainer control)
{
control.AnimationDuration = 0.15;
}
public void Child_Height_250(TitleContainer control)
{
child.Height = 250;
}
public void Toggle_AnimateIcon(TitleContainer control)
{
control.AnimateIcon = !control.AnimateIcon;
Debug.WriteLine("AnimateIcon: " + control.AnimateIcon);
}
public void Child_Height_10(TitleContainer control)
{
child.Height = 10;
}
public void Animate_Slow(TitleContainer control)
{
control.AnimationDuration = 1;
}
public void ShouldThrowExceptionWhenTemplateNotFound()
{
var control = new TitleContainer();
Templates.Instance.ApplyTemplate(control);
}
public void Child_Height_Random(TitleContainer control)
{
child.Height = RandomData.Random.Next(10, 300);
}
