public LuaArgs read(LuaArgs args)
{
int x = args.GetInt(0);
int y = args.GetInt(1);
if (args.IsNil(2))
{
if (x >= 0 && x < Image.Width &&
y >= 0 && y < Image.Height)
{
var b = Image[x, y];
return(new LuaArgs(b));
}
return(new LuaArgs(0));
}
else
{
int length = args.GetInt(2);
if (length < 0)
{
throw new LuaError("Read length must be positive");
}
if (x < 0 || x >= Image.Width ||
y < 0 || y >= Image.Height ||
(x + y * Image.Width + length) > Image.Width * Image.Height)
{
throw new LuaError("Read must start and end within the image bounds");
}
var result = Image.Read(x, y, length);
return(new LuaArgs(result));
}
}
public LuaArgs stopSound(LuaArgs args)
{
var path = args.GetString(0);
m_entity.StopSound(path);
return(LuaArgs.Empty);
}
public LuaArgs shutdown(LuaArgs args)
{
m_cpu.RequestShutdown();
throw new LuaYield(LuaArgs.Empty, delegate {
return(LuaArgs.Empty);
});
}
public LuaArgs setOverlayAlignment(LuaArgs args)
{
var line = args.GetInt(0) - 1;
var alignment = args.GetString(1);
switch (alignment)
{
case "left":
{
m_state.SetTerminalAlignment(line, TextAlignment.Left);
break;
}
case "right":
{
m_state.SetTerminalAlignment(line, TextAlignment.Right);
break;
}
case "center":
{
m_state.SetTerminalAlignment(line, TextAlignment.Center);
break;
}
default:
{
throw new LuaError("Invalid alignment: " + alignment);
}
}
return(LuaArgs.Empty);
}
public LuaArgs scrollOverlay(LuaArgs args)
{
var i = args.GetInt(0);
m_state.ScrollTerminal(i);
return(LuaArgs.Empty);
}
public LuaArgs canTranslate(LuaArgs args)
{
var language = m_state.Game.Language;
var key = args.GetString(0);
return(new LuaArgs(language.CanTranslate(key)));
}
public LuaArgs write(LuaArgs args)
{
try
{
CheckOpen();
if (m_openMode == LuaFileOpenMode.Write)
{
// Write some stuff
int i = 0;
LuaContinuation continuation = null;
continuation = delegate {
if (!args.IsNil(i))
{
return(WriteOneAsync(args[i++], continuation));
}
else
{
return(new LuaArgs(this));
}
};
return(continuation.Invoke(LuaArgs.Empty));
}
return(new LuaArgs(this));
}
catch (IOException e)
{
return(new LuaArgs(LuaValue.Nil, e.Message));
}
}
private void QueueEvent(string eventName, LuaArgs args)
{
if (m_computer != null)
{
m_computer.Events.Queue(eventName, args);
}
}
public LuaArgs loadlib(LuaArgs args)
{
args.GetString(0); // libname
args.GetString(1); // funcname
// We don't support loading C libraries
return(LuaArgs.Empty);
}
public LuaArgs getFreeSpace(LuaArgs args)
{
CheckConnected();
return(new LuaArgs(
Math.Max(Mount.Capacity - Mount.UsedSpace, 0)
));
}
private Sound parseSound(LuaArgs args, int index)
{
LuaTable table = args.GetTable(index);
string waveform = table.IsNil("waveform") ? "square" : table.GetString("waveform");
float volume = table.IsNil("volume") ? 1.0f : table.GetFloat("volume");
float duty = table.IsNil("duty") ? 0.5f : table.GetFloat("duty");
float duration = table.GetFloat("duration");
float attack = table.IsNil("attack") ? 0.0f : table.GetFloat("attack");
float decay = table.IsNil("decay") ? 0.0f : table.GetFloat("decay");
float frequency = table.GetFloat("frequency");
float slide = table.IsNil("slide") ? 0.0f : table.GetFloat("slide");
float vibratoDepth = table.IsNil("vibrato_depth") ? 0.0f : table.GetFloat("vibrato_depth");
float vibratoFrequency = table.IsNil("vibrato_frequency") ? 0.0f : table.GetFloat("vibrato_frequency");
bool loop = table.IsNil("loop") ? false : table.GetBool("loop");
var sound = new Sound();
sound.Waveform = ParseWaveform(waveform);
sound.Volume = Clamp(volume, 0.0f, 1.0f);
sound.Duty = Clamp(duty, 0.0f, 1.0f);
sound.Attack = Math.Max(attack, 0.0f);
sound.Duration = Math.Max(duration, 0.0f);
sound.Decay = Math.Max(decay, 0.0f);
sound.Frequency = Math.Max(frequency, 0.0f);
sound.Slide = slide;
sound.VibratoDepth = Math.Max(vibratoDepth, 0.0f);
sound.VibratoFrequency = Math.Max(vibratoFrequency, 0.0f);
sound.Loop = loop;
return(sound);
}
public LuaArgs find(LuaArgs args)
{
var wildcard = Sanitize(args.GetString(0));
try
{
CheckConnected();
var dir = wildcard.GetDir();
var namePattern = wildcard.GetName();
var nameRegex = new Regex("^" + Regex.Escape(namePattern).Replace("\\*", ".*") + "$");
var table = new LuaTable();
int i = 0;
if (Mount.Exists(dir) && Mount.IsDir(dir))
{
foreach (var name in Mount.List(dir))
{
if (nameRegex.IsMatch(name))
{
table[++i] = FilePath.Combine(dir, name).ToString();
}
}
}
return(new LuaArgs(table));
}
catch (IOException e)
{
throw new LuaError(e.Message);
}
}
public LuaArgs open(LuaArgs args)
{
var path = Sanitize(args.GetString(0));
var mode = args.IsNil(1) ? "r" : args.GetString(1);
try
{
CheckConnected();
if (mode == "r")
{
CheckFileExists(path);
return(new LuaArgs(new LuaFile(Mount.OpenForRead(path))));
}
else if (mode == "rb")
{
CheckFileExists(path);
return(new LuaArgs(new LuaFile(Mount.OpenForBinaryRead(path), LuaFileOpenMode.Read)));
}
else if (mode == "w")
{
CheckWritable();
CheckDirDoesNotExist(path);
CheckParentDirExists(path);
return(new LuaArgs(new LuaFile(WritableMount.OpenForWrite(path, false))));
}
else if (mode == "wb")
{
CheckWritable();
CheckDirDoesNotExist(path);
CheckParentDirExists(path);
return(new LuaArgs(new LuaFile(WritableMount.OpenForBinaryWrite(path, false), LuaFileOpenMode.Write)));
}
else if (mode == "a")
{
CheckWritable();
CheckDirDoesNotExist(path);
CheckParentDirExists(path);
return(new LuaArgs(new LuaFile(WritableMount.OpenForWrite(path, true))));
}
else if (mode == "ab")
{
CheckWritable();
CheckDirDoesNotExist(path);
CheckParentDirExists(path);
return(new LuaArgs(new LuaFile(WritableMount.OpenForBinaryWrite(path, true), LuaFileOpenMode.Write)));
}
else
{
throw new LuaError("Unsupported mode: " + mode);
}
}
catch (FileNotFoundException)
{
return(LuaArgs.Nil);
}
catch (IOException e)
{
throw new LuaError(e.Message);
}
}
public LuaArgs write(LuaArgs args)
{
int x = args.GetInt(0);
int y = args.GetInt(1);
if (args.IsNumber(2))
{
var n = args.GetByte(2);
CheckWritable();
if (x >= 0 && x < Image.Width &&
y >= 0 && y < Image.Height)
{
Image[x, y] = n;
}
return(LuaArgs.Empty);
}
else
{
var bytes = args.GetByteString(2);
if (x < 0 || x >= Image.Width ||
y < 0 || y >= Image.Height ||
(x + y * Image.Width + bytes.Length) > Image.Width * Image.Height)
{
throw new LuaError("Write must start and end within the image bounds");
}
CheckWritable();
Image.Write(bytes, 0, bytes.Length, x, y);
return(LuaArgs.Empty);
}
}
public LuaArgs difftime(LuaArgs args)
{
var t2 = args.GetDouble(0);
var t1 = args.GetDouble(1);
return(new LuaArgs(t2 - t1));
}
public LuaArgs searchpath(LuaArgs args)
{
var name = args.GetString(0);
var path = args.GetString(1);
var sep = args.IsNil(2) ? "." : args.GetString(2);
var rep = args.IsNil(3) ? "/" : args.GetString(3);
var fixedName = name.Replace(sep, rep);
var fixedPath = path.Replace("?", fixedName);
var candidates = fixedPath.Split(';');
var errorBuilder = new StringBuilder();
foreach (var candidate in candidates)
{
var candPath = new FilePath(candidate);
if (m_fileSystem.Exists(candPath) && !m_fileSystem.IsDir(candPath))
{
return(new LuaArgs(candidate));
}
else
{
if (errorBuilder.Length > 0)
{
errorBuilder.Append('\n');
}
errorBuilder.Append("no file '" + candidate + "'");
}
}
return(new LuaArgs(LuaValue.Nil, errorBuilder.ToString()));
}
public LuaArgs output(LuaArgs args)
{
if (args.IsNil(0))
{
return(new LuaArgs(m_output.Value));
}
else if (args.IsObject <LuaFile>(0))
{
m_output.Value = args.GetObject <LuaFile>(0);
return(LuaArgs.Empty);
}
else
{
var path = new FilePath(args.GetString(0));
try
{
m_output.Value = new LuaFile(m_fileSystem.OpenForWrite(path, false));
return(LuaArgs.Empty);
}
catch (IOException e)
{
throw new LuaError(e.Message);
}
}
}
public LuaArgs combine(LuaArgs args)
{
var a = new FilePath(args.GetString(0));
var b = new FilePath(args.GetString(1));
return(new LuaArgs(FilePath.Combine(a, b).ToString()));
}
public LuaArgs read(LuaArgs args)
{
int start = args.GetInt(0);
if (args.IsNil(1))
{
if (start >= 0 && start < Buffer.Length)
{
var b = Buffer[start];
return(new LuaArgs(b));
}
return(new LuaArgs(0));
}
else
{
int length = args.GetInt(1);
if (length < 0)
{
throw new LuaError("Read length must be positive");
}
if (start < 0 || start + length > Buffer.Length)
{
throw new LuaError("Read must start and end within the buffer");
}
var result = Buffer.Read(start, length);
return(new LuaArgs(result));
}
}
public LuaArgs match(LuaArgs args)
{
var path = new FilePath(args.GetString(0));
var wildcard = new FilePath(args.GetString(1));
return(new LuaArgs(path.Matches(wildcard)));
}
public LuaArgs stopParticles(LuaArgs args)
{
var path = args.GetString(0);
m_entity.StopParticles(path);
return(LuaArgs.Empty);
}
public LuaArgs saveTGA(LuaArgs args)
{
var image = args.GetObject <LuaImage>(0).Image;
var palette = args.GetObject <LuaPalette>(1).Palette;
try
{
if (args.IsNil(2))
{
// Save to a string and return it
using (var stream = new MemoryStream())
{
TGAImage.Encode(image, palette, stream);
return(new LuaArgs(stream.ToArray()));
}
}
else
{
// Save to a stream
var file = args.GetObject <LuaFile>(2);
CheckFileMode(file, "tga", LuaFileOpenMode.Write, LuaFileContentType.Binary);
TGAImage.Encode(image, palette, file.InnerStream);
return(LuaArgs.Empty);
}
}
catch (IOException e)
{
throw new LuaError(e.Message);
}
}
public LuaArgs setVisible(LuaArgs args)
{
var visible = args.GetBool(0);
m_entity.Visible = visible;
return(LuaArgs.Empty);
}
public LuaArgs newPalette(LuaArgs args)
{
var size = args.IsNil(0) ? 16 : args.GetInt(0);
if (size < 1 || size > 256)
{
throw new LuaError("Palette size must be in range 1-256");
}
if (m_computer.Memory.Alloc(size * 3))
{
// Create a simple greyscale palette
uint usize = (uint)size;
uint[] colors = new uint[usize];
colors[0] = 0x000000ff;
for (uint i = 1; i < colors.Length; ++i)
{
uint bright = ((i * 255) / (usize - 1)) & 0xff;
colors[i] = (bright << 24) + (bright << 16) + (bright << 8) + 255;
}
var palette = new Palette(colors);
return(new LuaArgs(new LuaPalette(palette, m_computer.Memory)));
}
else
{
throw new LuaError("not enough memory");
}
}
public LuaArgs setCastShadows(LuaArgs args)
{
var castShadows = args.GetBool(0);
m_entity.CastShadows = castShadows;
return(LuaArgs.Empty);
}
public LuaArgs clear(LuaArgs args)
{
var color = args.IsNil(0) ? (byte)0 : args.GetByte(0);
m_graphics.Clear(color);
return(LuaArgs.Empty);
}
public LuaArgs reboot(LuaArgs args)
{
m_cpu.RequestReboot();
throw new LuaYield(LuaArgs.Empty, delegate {
return(LuaArgs.Empty);
});
}
public LuaArgs newFont(LuaArgs args)
{
var image = args.GetObject <LuaImage>(0);
var characters = args.GetString(1);
var characterWidth = args.GetInt(2);
var characterHeight = args.GetInt(3);
if (characterWidth <= 0)
{
throw new LuaError("Character width must be positive");
}
if (characterWidth > image.Image.Width)
{
throw new LuaError("Character width must be less than image width");
}
if (characterHeight <= 0)
{
throw new LuaError("Character height must be positive");
}
if (characterHeight > image.Image.Height)
{
throw new LuaError("Character width must be less than image height");
}
var font = new Font(image.Image, characters, characterWidth, characterHeight, true);
return(new LuaArgs(new LuaFont(font, image)));
}
public LuaArgs fill(LuaArgs args)
{
var color = args.GetByte(0);
if (args.IsNil(1))
{
CheckWritable();
Image.Fill(color);
}
else
{
int x = args.GetInt(1);
int y = args.GetInt(2);
int w = args.GetInt(3);
int h = args.GetInt(4);
if (w < 0)
{
throw new LuaError("Fill width must be positive");
}
if (h < 0)
{
throw new LuaError("Fill height must be positive");
}
if (x < 0 || x + w > Image.Width ||
y < 0 || y + h > Image.Height)
{
throw new LuaError("Fill must start and end within the image bounds");
}
CheckWritable();
Image.Fill(color, x, y, w, h);
}
return(LuaArgs.Empty);
}
public LuaArgs getPowerStatus(LuaArgs args)
{
PowerStatus status;
double chargeLevel;
m_computer.GetPowerStatus(out status, out chargeLevel);
return(new LuaArgs(status.ToString().ToLower(), chargeLevel));
}
