public void Create(string directory, string saveName)
{
var frontBitmap = new Bitmap(WIDTH, HEIGHT);
var backBitmap = new Bitmap(WIDTH, HEIGHT);
using (var frontGraphics = Graphics.FromImage(frontBitmap))
{
frontGraphics.SmoothingMode = SmoothingMode.AntiAlias;
frontGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
frontGraphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
frontGraphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
using (var brush = new SolidBrush(Color.White))
frontGraphics.FillRectangle(brush, 0, 0, WIDTH, HEIGHT);
using (var backGraphics = Graphics.FromImage(backBitmap))
{
backGraphics.SmoothingMode = SmoothingMode.AntiAlias;
backGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
backGraphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
backGraphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
using (var brush = new SolidBrush(Color.White))
backGraphics.FillRectangle(brush, 0, 0, WIDTH, HEIGHT);
_images.ForEach(x => x.Image.Apply(frontGraphics, backGraphics, x.X, x.Y, x.BackX, x.BackY));
frontGraphics.Flush();
backGraphics.Flush();
frontBitmap.Save(PathX.Build(directory, saveName + "Front" + _pageNumber + ".png"), ImageFormat.Png);
backBitmap.Save(PathX.Build(directory, saveName + "Back" + _pageNumber + ".png"), ImageFormat.Png);
}
}
frontBitmap.Dispose();
backBitmap.Dispose();
}
public override void WriteToParcel(Parcel dest, ParcelableWriteFlags flags)
{
base.WriteToParcel(dest, flags);
dest.WriteInt(PathX.Count);
dest.WriteIntArray(PathX.ToArray());
dest.WriteIntArray(PathY.ToArray());
}
public FileWriter(ConcurrentQueue <string> pendingLogs, string logFilePath)
{
_logFilePath = logFilePath;
_pendingLogs = pendingLogs ?? throw new ArgumentNullException(nameof(pendingLogs));
if (File.Exists(_logFilePath))
{
DateTime lastWriteTime = File.GetLastWriteTimeUtc(_logFilePath);
DateTime appOpenTime = DateTime.UtcNow - TimeSpan.FromSeconds(GetAppTime());
// clear log file if it used for previous session
if (appOpenTime > lastWriteTime)
{
string prevPath = PathX.RemoveExtension(_logFilePath) + "-prev" + Path.GetExtension(_logFilePath);
if (File.Exists(prevPath))
{
File.Delete(prevPath);
}
File.Move(_logFilePath, prevPath);
}
}
// launch 'write loop' thread
_thread = new Thread(ThreadedWriteLoop);
_thread.Start();
}
// Restart the server on a different map in developer mode
static void Session_DevMap_f(CmdArgs args)
{
var map = args[1];
if (string.IsNullOrEmpty(map))
{
return;
}
map = PathX.StripFileExtension(map);
// make sure the level exists before trying to change, so that a typo at the server console won't end the game handle addon packs through reloadEngine
var s = "maps/{map}.map";
var ff = fileSystem.FindFile(s, true);
switch (ff)
{
case FIND.NO: common.Printf($"Can't find map {s}\n"); return;
case FIND.ADDON:
common.Printf($"map {s} is in an addon pak - reloading\n");
CmdArgs rl_args = new();
rl_args.AppendArg("devmap");
rl_args.AppendArg(map);
cmdSystem.SetupReloadEngine(rl_args);
return;
default: break;
}
cvarSystem.SetCVarBool("developer", true);
sessLocal.StartNewGame(map, true);
}
private TmxTileSetData ReadTileset(XElement element, string subdirectory)
{
var source = element.AttributeToString("source", null);
var result = new TmxTileSetData();
if (source != null)
{
var path = string.IsNullOrWhiteSpace(subdirectory) ? source : $"{subdirectory}/{source}";
var thisSubDir = PathX.GetDirectoryName(path);
using (var stream = contentProvider.Open(path))
{
XDocument doc = XDocument.Load(stream);
result = ReadTileset(doc.Element("tileset"), thisSubDir);
}
}
else
{
result.Name = element.AttributeToString("name");
result.TileSize = element.AttributesToSize("tilewidth", "tileheight");
result.TileCount = element.AttributeToInt("tilecount");
result.Columns = element.AttributeToInt("columns");
ReadProperties(result.Properties, element.Element("properties"));
var image = element.Element("image");
result.ImageSource = PathX.NormalizePath(
Path.Combine(subdirectory, image.AttributeToString("source")));
result.ImageSize = image.AttributesToSize("width", "height");
foreach (var eTile in element.Elements("tile"))
{
var id = eTile.AttributeToInt("id");
var properties = eTile.Element("properties");
var tileData = new TmxTileData();
result.Tiles[id] = tileData;
ReadProperties(result.Tiles[id].Properties, properties);
var objects = eTile.Element("objectgroup");
foreach (var obj in objects?.Elements("object") ?? Enumerable.Empty <XElement>())
{
tileData.Collision.Add(ReadMapObjectData(obj));
}
}
}
result.FirstTileId = element.AttributeToInt("firstgid", 1);
return(result);
}
// Opens a wave file for reading
public int Open(string strFileName, out WaveformatEx pwfx)
{
pwfx = default;
mbIsReadingFromMemory = false;
mpbData = null;
mpbDataCur = 0;
if (strFileName == null)
{
return(-1);
}
var name = strFileName;
// note: used to only check for .wav when making a build
name = PathX.SetFileExtension(name, ".ogg");
if (fileSystem.ReadFile(name, out var _) != -1)
{
return(OpenOGG(name, out pwfx));
}
mpwfx = default;
mhmmio = fileSystem.OpenFileRead(strFileName);
if (mhmmio == null)
{
mdwSize = 0; return(-1);
}
if (mhmmio.Length <= 0)
{
mhmmio = null; return(-1);
}
if (ReadMMIO() != 0)
{
Close(); return(-1);
} // ReadMMIO will fail if its an not a wave file
mfileTime = mhmmio.Timestamp;
if (ResetFile() != 0)
{
Close(); return(-1);
}
// After the reset, the size of the wav file is mck.cksize so store it now
mdwSize = (int)(mck.cksize / sizeof(short));
mMemSize = (int)mck.cksize;
if (mck.cksize != 0xffffffff)
{
pwfx = mpwfx.Format; return(0);
}
return(-1);
}
public VolumeIcon()
{
InitializeComponent();
IsMuted = false;
var dropShadowColorBinding = BindingHelper.CreateOneWayBinding(DropShadowColorProperty, this);
BindingOperations.SetBinding(DropShadowVolume, DropShadowEffect.ColorProperty, dropShadowColorBinding);
BindingOperations.SetBinding(DropShadowX, DropShadowEffect.ColorProperty, dropShadowColorBinding);
var foregroundBinding = BindingHelper.CreateOneWayBinding(ForegroundProperty, this);
PathVolume.SetBinding(Shape.FillProperty, foregroundBinding);
PathX.SetBinding(VisibilityProperty, BindingHelper.CreateOneWayBinding(IsMutedProperty, this, new BooleanToVisibilityConverter()));
}
static void Sess_WritePrecache_f(CmdArgs args)
{
if (args.Count != 2)
{
common.Printf("USAGE: writePrecache <execFile>\n"); return;
}
var str = args[1];
str = PathX.DefaultFileExtension(str, ".cfg");
var f = fileSystem.OpenFileWrite(str, "fs_configpath");
declManager.WritePrecacheCommands(f);
renderModelManager.WritePrecacheCommands(f);
uiManager.WritePrecacheCommands(f);
fileSystem.CloseFile(f);
}
static void Session_TestMap_f(CmdArgs args)
{
var map = args[1];
if (string.IsNullOrEmpty(map))
{
return;
}
map = PathX.StripFileExtension(map);
cmdSystem.BufferCommandText(CMD_EXEC.NOW, "disconnect");
var s = $"dmap maps/{map}.map";
cmdSystem.BufferCommandText(CMD_EXEC.NOW, s);
s = $"devmap {map}";
cmdSystem.BufferCommandText(CMD_EXEC.NOW, s);
}
private static void SaveCardBack(int width, int height, string instructionsDir, JObject deck, string savePath)
{
var cardBack = new Bitmap(width, height);
cardBack.WithGraphics(g =>
{
g.DrawImage(Image.FromFile(Path.Combine(instructionsDir, deck.GetPropertyValue("CardBackPath"))),
new Rectangle(0, 0, width, height),
new Rectangle(
deck.ContainsKey("CardBackTrim") ? (int)deck["CardBackTrim"] : 0,
deck.ContainsKey("CardBackTrim") ? (int)deck["CardBackTrim"] : 0,
width,
height),
GraphicsUnit.Pixel);
g.Flush();
var result = deck.ContainsKey("Scale") ? ResizeImage(cardBack, (int)(cardBack.Width * (decimal)deck["Scale"]), (int)(cardBack.Height * (decimal)deck["Scale"])) : cardBack;
result.Save(PathX.Build(instructionsDir, savePath, deck.GetPropertyValue("Name") + "Back" + ".png"),
ImageFormat.Png);
});
}
static void Go(string instructionsPath)
{
var instructionsDir = Path.GetDirectoryName(instructionsPath);
var instructions = JObjectX.FromFile(instructionsPath);
var directions = new Directions(((JArray)instructions["Images"]).ToObject <List <JObject> >());
var imagesToPrint = directions.ExtractImages(new ImageDetails(instructionsDir));
var pageNumber = 1;
var pages = new List <Page> {
new Page(1)
};
imagesToPrint.ForEach(x => Enumerable.Range(0, x.Count).ForEach(_ =>
{
if (!pages.Last().CanAdd(x))
{
pages.Add(new Page(++pageNumber));
}
pages.Last().Add(x);
}));
pages.ForEach(x => x.Create(PathX.Build(instructionsDir, instructions.GetPropertyValue("SavePath")), instructions.GetPropertyValue("SaveName")));
imagesToPrint.ForEach(x => x.Dispose());
}
static void Go(string instructionsPath)
{
var instructionsDir = Path.GetDirectoryName(instructionsPath);
var instructions = JObjectX.FromFile(instructionsPath);
var savePath = instructions.GetPropertyValue("SavePath");
var decks = ((JArray)instructions["Decks"]).ToObject <List <JObject> >();
decks.ForEach(deck =>
{
var cards = new DirectoryInfo(PathX.Build(instructionsDir, deck.GetPropertyValue("Path"))).GetFiles("*.png").ToList();
var sampleCard = Image.FromFile(cards[0].FullName);
var width = sampleCard.Width;
var height = sampleCard.Height;
sampleCard.Dispose();
var deckSheets = new List <List <FileInfo> >();
for (int i = 0; i < cards.Count; i += 70)
{
deckSheets.Add(cards.GetRange(i, Math.Min(70, cards.Count - i)));
}
for (var deckIndex = 0; deckIndex < deckSheets.Count; deckIndex++)
{
var deckSheet = deckSheets[deckIndex];
var bitmap = new Bitmap(width * 10, height * 7);
bitmap.WithGraphics(g =>
{
for (var cardIndex = 0; cardIndex < deckSheet.Count; cardIndex++)
{
using (var cardImage = Image.FromFile(deckSheet[cardIndex].FullName))
g.DrawImage(cardImage, new Point(cardIndex % 10 * width, (int)Math.Floor((decimal)cardIndex / 10) * height));
}
g.Flush();
var result = deck.ContainsKey("Scale") ? ResizeImage(bitmap, (int)(bitmap.Width * (decimal)deck["Scale"]), (int)(bitmap.Height * (decimal)deck["Scale"])) : bitmap;
result.Save(PathX.Build(instructionsDir, savePath, deck.GetPropertyValue("Name") + deckIndex + ".png"), ImageFormat.Png);
});
}
SaveCardBack(width, height, instructionsDir, deck, savePath);
});
}
private static void Go(string instructionsPath)
{
var instructionsDir = Path.GetDirectoryName(instructionsPath);
var instructions = JObjectX.FromFile(instructionsPath);
var propertyInstructions = ((JArray)instructions["Properties"]).Select(x => new PropertyInstruction((JObject)x)).ToList();
var itemProcessor = new JObjectBuilder(propertyInstructions);
var spreadsheetID = instructions.GetPropertyValue("SpreadSheetID");
var range = instructions.GetPropertyValue("Range");
var unprocessedItems = GetDataFromGoogleSheets(spreadsheetID, range);
var items = unprocessedItems.Select(x => itemProcessor.Build(x)).ToList();
if (instructions.ContainsKey("Sort"))
{
items.Sort((a, b) => a.GetPropertyValue(instructions.GetPropertyValue("Sort")).CompareTo(b.GetPropertyValue(instructions.GetPropertyValue("Sort"))));
}
var jArray = new JArray(items);
dynamic jObject = new JObject();
jObject.Items = jArray;
var output = instructions.GetPropertyValue("Output");
File.WriteAllText(PathX.Build(instructionsDir, output), jObject.ToString());
}
// Loads any of the supported image types into a cannonical 32 bit format.
// Automatically attempts to load .jpg files if .tga files fail to load.
// *pic will be null if the load failed.
// Anything that is going to make this into a texture would use makePowerOf2 = true, but something loading an image as a lookup table of some sort would leave it in identity form.
// It is important to do this at image load time instead of texture load time for bump maps.
// Timestamp may be null if the value is going to be ignored
// If pic is null, the image won't actually be loaded, it will just find the timestamp.
internal static void R_LoadImage(string cname, ref byte *pic, out int width, out int height, out DateTime timestamp, bool makePowerOf2)
{
var name = cname;
if (pic != byteX.empty)
{
pic = null;
}
timestamp = default;
width = 0;
height = 0;
name = PathX.DefaultFileExtension(name, ".tga");
if (name.Length < 5)
{
return;
}
name = name.ToLowerInvariant();
var ext = PathX.ExtractFileExtension(name);
if (ext == "tga")
{
// try tga first
LoadTGA(name, ref pic, out width, out height, out timestamp);
if ((pic == byteX.empty) || (timestamp == default))
{
LoadJPG(PathX.DefaultFileExtension(PathX.StripFileExtension(name), ".jpg"), ref pic, out width, out height, out timestamp);
}
}
else if (ext == "pcx")
{
LoadPCX32(name, ref pic, out width, out height, out timestamp);
}
else if (ext == "bmp")
{
LoadBMP(name, ref pic, out width, out height, out timestamp);
}
else if (ext == "jpg")
{
LoadJPG(name, ref pic, out width, out height, out timestamp);
}
if (width < 1 || height < 1)
{
if (pic != byteX.empty)
{
R_StaticFree(pic); pic = null;
}
}
// convert to exact power of 2 sizes
if (pic != byteX.empty && makePowerOf2)
{
int w, h;
int scaled_width, scaled_height;
byte *resampledBuffer;
w = width;
h = height;
for (scaled_width = 1; scaled_width < w; scaled_width <<= 1)
{
;
}
for (scaled_height = 1; scaled_height < h; scaled_height <<= 1)
{
;
}
if (scaled_width != w || scaled_height != h)
{
if (ImageManager.image_roundDown.Bool && scaled_width > w)
{
scaled_width >>= 1;
}
if (ImageManager.image_roundDown.Bool && scaled_height > h)
{
scaled_height >>= 1;
}
resampledBuffer = R_ResampleTexture(pic, w, h, scaled_width, scaled_height);
R_StaticFree(pic);
pic = resampledBuffer;
width = scaled_width;
height = scaled_height;
}
}
}
static void GenerateFileFrom(List <SceneElement> sceneAssets)
{
using (var fileWithWriter = FileX.OpenFileFlushedAndReadyToWrite(GENERATED_FILE_NAME))
{
StreamWriter writer = fileWithWriter.StreamWriter;
writer.Write(
@"// THIS CODE IS GENERATED
// DO NOT MODIFY IT
using UnityEditor;
using UnityEditor.SceneManagement;
public static class SceneShortcuts
{
");
sceneAssets.Sort((a, b) => a.Path.CompareTo(b.Path));
int prio = 0;
string lastFolder = "";
foreach (SceneElement scene in sceneAssets)
{
if (ShouldSceneBeExcluded(scene.Path))
{
continue;
}
string sceneName = Path.GetFileNameWithoutExtension(scene.Path);
string scenePathNoExt = PathX.RemoveExtension(scene.Path);
string folder = scenePathNoExt.RemoveFirst(sceneName);
string methodName = scenePathNoExt.Replace(' ', '_').Replace('/', '_').Replace('(', '_').Replace(')', '_');
if (lastFolder != folder)
{
prio += 1000;
}
string menuItemName;
if (FLATTEN)
{
menuItemName = sceneName;
}
else
{
menuItemName = scenePathNoExt;
foreach (string searchFolder in SCENE_SEARCH_FOLDERS)
{
if (scenePathNoExt.StartsWith(searchFolder))
{
menuItemName = menuItemName.Remove(0, searchFolder.Length + 1);
}
}
foreach (var word in MENU_ITEM_STRIPPED_WORDS)
{
menuItemName = menuItemName.RemoveFirst(word);
}
}
writer.WriteLine($@" [MenuItem(""Scene Shortcuts/{menuItemName}"", priority = {prio++})]");
writer.WriteLine($@" public static void {methodName}() => LoadScene(""{scene.Path}"");");
writer.WriteLine();
lastFolder = folder;
}
writer.Write(
@"
private static void LoadScene(string scenePath)
{
if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
{
EditorSceneManager.OpenScene(scenePath);
}
}
}
");
fileWithWriter.Dispose();
}
}
public ImageToPrint(int count, int trim, string directory, string front, string back)
: this(count, trim, Image.FromFile(PathX.Build(directory, front)), Image.FromFile(PathX.Build(directory, back)))
{
}
