public void read(byte[] data, int offset)
{
cmd = (short)LE.getuint16(data, offset); offset += 2;
len = (short)LE.getuint16(data, offset); offset += 2;
session = LE.getuint32(data, offset); offset += 4;
status = LE.getuint32(data, offset); offset += 4;
context = LE.getuint64(data, offset); offset += 8;
options = LE.getuint32(data, offset); offset += 4;
switch (cmd)
{
case CMD_RR_DATA:
ihandle = LE.getuint32(data, offset); offset += 4;
timeout = (short)LE.getuint16(data, offset); offset += 2;
count = (short)LE.getuint16(data, offset); offset += 2;
if (count != 2)
{
throw new Exception("ab:bad ip packet");
}
type_1 = (short)LE.getuint16(data, offset); offset += 2;
len_1 = (short)LE.getuint16(data, offset); offset += 2;
type_2 = (short)LE.getuint16(data, offset); offset += 2;
len_2 = (short)LE.getuint16(data, offset); offset += 2;
break;
case CMD_GET_SESSION:
protocol = (short)LE.getuint16(data, offset); offset += 2;
flags = (short)LE.getuint16(data, offset); offset += 2;
break;
}
}
public void write(byte[] data, int offset, ABContext abcontext)
{
session = abcontext.session;
context = abcontext.context;
abcontext.increment();
LE.setuint16(data, offset, cmd); offset += 2;
LE.setuint16(data, offset, len); offset += 2;
LE.setuint32(data, offset, session); offset += 4;
LE.setuint32(data, offset, status); offset += 4;
LE.setuint64(data, offset, context); offset += 8;
LE.setuint32(data, offset, options); offset += 4;
switch (cmd)
{
case CMD_RR_DATA:
LE.setuint32(data, offset, ihandle); offset += 4;
LE.setuint16(data, offset, timeout); offset += 2;
LE.setuint16(data, offset, count); offset += 2;
LE.setuint16(data, offset, type_1); offset += 2;
LE.setuint16(data, offset, len_1); offset += 2;
LE.setuint16(data, offset, type_2); offset += 2;
LE.setuint16(data, offset, len_2); offset += 2;
break;
case CMD_GET_SESSION:
LE.setuint16(data, offset, protocol); offset += 2;
LE.setuint16(data, offset, flags); offset += 2;
break;
}
}
public static void Operaciones()
{
string frase, LE;
int indice = 0;
string Aux = "";
Console.Clear();
Console.WriteLine("********************************************************");
Console.WriteLine(" ----- Intercalacion de Mayusculas y Minusculas --------");
Console.WriteLine("********************************************************");
Console.WriteLine("Digite una frase : ");
frase = Console.ReadLine();
Console.WriteLine("********************************************************");
indice = 1;
while ((indice <= frase.Length))
{
LE = IntercalarFrase(frase, indice - 1, 1);
if ((indice % 2 == 0))
{
Aux = Aux + LE.ToLower();
}
else
{
Aux = Aux + LE.ToUpper();
}
indice++;
}
Console.WriteLine();
Console.WriteLine("Frase Intercalada : {0}", Aux);
Console.WriteLine("********************************************************");
Console.WriteLine();
Console.WriteLine("Pulsa para volver al Menu.");
Console.ReadLine();
}
public static JFTag[] decodeMultiPacket(byte[] data, int tagcnt)
{
int cmd = LE.getuint16(data, 0);
int id = LE.getuint16(data, 2);
int len = LE.getuint32(data, 4);
int cnt = LE.getuint16(data, 8);
if (cnt != tagcnt)
{
return(null);
}
JFTag[] tags = new JFTag[tagcnt];
int pos = 10;
for (int a = 0; a < tagcnt; a++)
{
tags[a] = new JFTag(null);
int type = LE.getuint16(data, pos);
pos += 2;
int datalen = LE.getuint16(data, pos);
pos += 2;
JFTag tag = new JFTag(null);
tag.data = Arrays <byte> .CopyOf(data, pos, pos + datalen);
pos += datalen;
}
return(tags);
}
private int readuint32()
{
int _uint32 = LE.getuint32(data, datapos);
datapos += 4;
return(_uint32);
}
public void write(byte[] data, int offset)
{
data[offset++] = cmd;
data[offset++] = count;
data[offset++] = path_1;
data[offset++] = class_1;
data[offset++] = path_2;
data[offset++] = class_2;
data[offset++] = ticktime;
data[offset++] = ticktimeout;
LE.setuint16(data, offset, len); offset += 2;
data[offset++] = service;
data[offset++] = tag_size;
data[offset++] = tag_type;
data[offset++] = tag_len;
Arrays <byte> .Copy(tag_chars, 0, data, offset, tag_chars.Length); offset += tag_chars.Length;
if (tag_chars.Length % 2 != 0)
{
data[offset++] = 0; //padding
}
Arrays <byte> .Copy(tagdata, 0, data, offset, tagdata.Length); offset += tagdata.Length;
data[offset++] = route_size;
data[offset++] = route_res;
data[offset++] = route_seg;
data[offset++] = route_addr;
}
public static byte[] makeWritePacket(JFTag[] tags, byte[][] tagdata)
{
int size = 8 + 2;
for (int a = 0; a < tags.Length; a++)
{
int strlen = tags[a].tag.Length;
size += 1 + strlen;
size += tagdata[a].Length;
}
byte[] data = new byte[size];
LE.setuint16(data, 0, 0x0004); //write tag cmd
LE.setuint16(data, 2, 0x1234); //unique id
LE.setuint32(data, 4, size - 8); //data Length
LE.setuint16(data, 8, tags.Length); //count
int pos = 12;
for (int a = 0; a < tags.Length; a++)
{
int strlen = tags[a].tag.Length;
LE.setuint8(data, pos, strlen); //strlen
pos++;
Arrays <byte> .Copy(tags[a].tag.ToByteArray(), 0, data, pos, strlen);
pos += strlen;
LE.setuint16(data, pos, tags[a].type); //tag type
pos += 2;
LE.setuint16(data, pos, tagdata[a].Length); //tag size
pos += 2;
Arrays <byte> .Copy(tagdata[a], 0, data, pos, tagdata[a].Length);
pos += tagdata[a].Length;
}
return(data);
}
private int readuint16()
{
int _uint16 = LE.getuint16(data, datapos);
datapos += 2;
return(_uint16);
}
public static void Operaciones()
{
string linea, LE;
int suma;
Console.WriteLine("**************************************************");
Console.WriteLine("-----------Cantidad de Volcales Cerradas ---------");
Console.WriteLine("**************************************************");
Console.WriteLine("Digite una Frase : ");
Console.WriteLine("");
linea = Console.ReadLine();
Console.WriteLine("***************************************************");
suma = 0;
linea = linea.ToUpper();
Console.WriteLine(linea);
for (int i = 0; i < linea.Length; i++)
{
LE = Mid(linea, i, 1);
if (LE.Contains("U") || LE.Contains("I"))
{
suma = suma + 1;
}
}
Console.WriteLine("****************************************************");
Console.WriteLine("Existen {0} Vocales Cerradas. ", suma);
Console.WriteLine("****************************************************");
Console.WriteLine("Pulsa una tecla para volver al menu."); Console.ReadLine();
} //End Method
public Tile(TVec2 ID, TVec3 scale, TVec3 position, TMesh cube, TMesh ball, bool walkable)
{
this.ID = ID;
this.cube = LE.CopyEntity(cube);
this.ball = LE.CopyEntity(ball);
this.walkable = walkable;
LE.ShowEntity(this.cube);
//set position and scale
LE.ScaleEntity(this.cube, scale);
LE.PositionEntity(this.cube, position);
LE.ScaleEntity(this.ball, new TVec3(scale.X / 2, scale.Y / 2, scale.Z / 2));
LE.PositionEntity(this.ball, new TVec3(position.X, position.Y + 1, position.Z));
//Set a different Color when the tile is non walkable
if (!this.walkable)
{
LE.EntityColor(this.cube, Tile.BLACK);
}
else
{
LE.EntityColor(this.cube, Tile.PINK);
LE.EntityColor(this.ball, Tile.YELLOW);
}
}
public override string GenerateCode()
{
/**/
var s = "";
var register = "";
var v = TryGetValue();
if (v != null)
{
register = MIPS.GetReg();
s += MIPS.Emit(MIPS.Opcodes.li, register, v.ToString(), "\t\t\t# calculated in compilation time :)");
return(s);
}
var l = LE.GenerateCode();
//var reg2 = (MIPS.regCount - 1).ToReg();
var reg2 = MIPS.LastReg();//
var r = RE.GenerateCode();
//var reg1 = (MIPS.regCount - 1).ToReg();
var reg1 = MIPS.LastReg();//
register = MIPS.GetReg();
switch (OP)
{
case "+":
s += MIPS.Emit(MIPS.Opcodes.add, register, reg2, reg1);
break;
case "-":
s += MIPS.Emit(MIPS.Opcodes.sub, register, reg2, reg1);
break;
case "*":
s += MIPS.Emit(MIPS.Opcodes.mul, register, reg2, reg1);
break;
case "/":
s += MIPS.Emit(MIPS.Opcodes.div, register, reg2, reg1);
break;
default:
break;
}
if (l.Contains("Method"))
{
return(l + r + s);
}
else
{
return(r + l + s);
}
}
public static bool isPacketComplete(byte[] data)
{
if (data.Length < 8)
{
return(false);
}
//int cmd = LE.getuint16(data, 0);
//int id = LE.getuint16(data, 2);
int len = LE.getuint32(data, 4);
return(data.Length >= 8 + len);
}
/** Save entire wav file (supports 16/32bit only) */
public bool Save(IOStream os)
{
if (bits != 16 && bits != 32)
{
return(false);
}
int size = 0;
switch (bits)
{
case 16:
bytes = 2;
size = samples16.Length * 2;
break;
case 32:
bytes = 4;
size = samples32.Length * 4;
break;
}
try {
byte[] data = new byte[20];
//write RIFF header (20 bytes);
LE.setString(data, 0, 4, "RIFF");
LE.setuint32(data, 4, size + 36); //rest of file size
LE.setString(data, 8, 4, "WAVE");
LE.setString(data, 12, 4, "fmt ");
LE.setuint32(data, 16, 16); //fmt size
os.Write(data, 0, 20);
//write fmt header (16 bytes)
data = new byte[16 + 4 + 4];
LE.setuint16(data, 0, 1); //PCM
LE.setuint16(data, 2, chs);
LE.setuint32(data, 4, rate);
LE.setuint32(data, 8, bytes * chs * rate); //bytes rate/sec
LE.setuint32(data, 12, bytes * chs); //block align
LE.setuint16(data, 14, bits);
LE.setString(data, 16, 4, "data");
LE.setuint32(data, 20, size);
os.Write(data, 0, 16 + 4 + 4);
switch (bits)
{
case 16: os.Write(LE.shortArray2byteArray(samples16, null)); break;
case 32: os.Write(LE.intArray2byteArray(samples32, null)); break;
}
} catch (Exception e) {
errmsg = e.ToString();
return(false);
}
return(false);
}
public static byte[] makeReadPacket(JFTag tag)
{
int strlen = tag.tag.Length;
byte[] data = new byte[8 + 2 + 1 + strlen];
LE.setuint16(data, 0, 0x0003); //read tag cmd
LE.setuint16(data, 2, 0x1234); //unique id
LE.setuint32(data, 4, 2 + strlen); //data Length
LE.setuint16(data, 8, 1); //count
LE.setuint8(data, 10, strlen); //strlen
Arrays <byte> .Copy(tag.tag.ToByteArray(), 0, data, 11, strlen);
return(data);
}
private long readuint64()
{
long _uint64;
if (le)
{
_uint64 = LE.getuint64(data, datapos);
}
else
{
_uint64 = BE.getuint64(data, datapos);
}
datapos += 8;
return(_uint64);
}
private int readuint32()
{
int _uint32;
if (le)
{
_uint32 = LE.getuint32(data, datapos);
}
else
{
_uint32 = BE.getuint32(data, datapos);
}
datapos += 4;
return(_uint32);
}
private short readuint16()
{
int _uint16;
if (le)
{
_uint16 = LE.getuint16(data, datapos);
}
else
{
_uint16 = BE.getuint16(data, datapos);
}
datapos += 2;
return((short)_uint16);
}
public static JFTag decodePacket(byte[] data)
{
int cmd = LE.getuint16(data, 0);
int id = LE.getuint16(data, 2);
int len = LE.getuint32(data, 4);
int cnt = LE.getuint16(data, 8);
if (cnt != 1)
{
return(null);
}
int type = LE.getuint16(data, 10);
int size = LE.getuint16(data, 12);
int datalen = len - 6;
JFTag tag = new JFTag(null);
tag.data = Arrays <byte> .CopyOf(data, 12, 12 + datalen);
return(tag);
}
/** Queues pending data to be written on next cycle. (only valid if start() has been called). */
public void SetValue(String value)
{
byte[] data = null;
if (IsBE())
{
switch (Size)
{
case TagType.Bit: data = new byte[] { (byte)(value.Equals("0") ? 0 : 1) }; break;
case TagType.Int8: data = new byte[] { Byte.ValueOf(value) }; break;
case TagType.Int16: data = new byte[2]; BE.setuint16(data, 0, Int32.ValueOf(value)); break;
case TagType.Int32: data = new byte[4]; BE.setuint32(data, 0, Int32.ValueOf(value)); break;
case TagType.Float32: data = new byte[4]; BE.setuint32(data, 0, Float.FloatToIntBits(Float.ValueOf(value))); break;
case TagType.Float64: data = new byte[4]; BE.setuint64(data, 0, Double.DoubleToLongBits(Double.ValueOf(value))); break;
}
}
else
{
switch (Size)
{
case TagType.Bit: data = new byte[] { (byte)(value.Equals("0") ? 0 : 1) }; break;
case TagType.Int8: data = new byte[] { Byte.ValueOf(value) }; break;
case TagType.Int16: data = new byte[2]; LE.setuint16(data, 0, Int32.ValueOf(value)); break;
case TagType.Int32: data = new byte[4]; LE.setuint32(data, 0, Int32.ValueOf(value)); break;
case TagType.Float32: data = new byte[4]; LE.setuint32(data, 0, Float.FloatToIntBits(Float.ValueOf(value))); break;
case TagType.Float64: data = new byte[4]; LE.setuint64(data, 0, Double.DoubleToLongBits(Double.ValueOf(value))); break;
}
}
lock (pendingLock) {
pending = data;
}
}
public static void CVocalesCerradas()
{
string NOM;
int K, SUM;
string LE;
Console.Write("DIGITE UNA FRASE : "); NOM = Console.ReadLine();
SUM = 0;
NOM = NOM.ToUpper();
Console.Write(NOM);
for (K = 1; K < NOM.Length; K++)
{
LE = Extras.Mid(NOM, K, 1);
if (LE.Contains("U") || LE.Contains("I"))
{
SUM = SUM + 1;
}
}
Console.WriteLine("EXISTEN {0} VOCALES CERRADAS", SUM);
Console.WriteLine("pulse una tecla:"); Console.ReadKey(); Console.Clear();
}
static void Main(string[] args)
{
string NOM;
int K, SUM;
string LE;
Console.Write("DIGITE UNA FRASE : "); NOM = Console.ReadLine();
SUM = 0;
NOM = NOM.ToUpper();
Console.Write(NOM);
for (K = 1; K < NOM.Length; K++)
{
LE = Mid(NOM, K, 1);
if (LE.Contains("U") || LE.Contains("I"))
{
SUM = SUM + 1;
}
}
Console.WriteLine("EXISTEN {0} VOCALES CERRADAS", SUM);
Console.Write("Pulse una Tecla:"); Console.ReadLine();
}
public void ShowPath()
{
bool startFound = false;
TVec2 currentTile = endTile;
List <TVec2> pathTiles = new List <TVec2>();
while (startFound == false)
{
List <TVec2> adjacentTiles = GetAdjacentTiles(currentTile);
//check to see what newest current tile
foreach (TVec2 adjacentTile in adjacentTiles)
{
//Check if it is the start tile
if (adjacentTile.X == startTile.X && adjacentTile.Y == startTile.Y)
{
startFound = true;
}
//it has to be inside the closed as well as in the open list
if (closedList.Contains(adjacentTile) || openList.Contains(adjacentTile))
{
if (grid[(int)adjacentTile.X, (int)adjacentTile.Y].cost <= grid[(int)currentTile.X, (int)currentTile.Y].cost &&
grid[(int)adjacentTile.X, (int)adjacentTile.Y].cost > 0)
{
//Change the current Tile
currentTile = adjacentTile;
//Add this adjacent tile to the path list
pathTiles.Add(adjacentTile);
//Show the ball
LE.ShowEntity(grid[(int)adjacentTile.X, (int)adjacentTile.Y].ball);
break;
}
}
}
}
}
public static byte[] makeWritePacket(JFTag tag, byte[] tagdata)
{
int strlen = tag.tag.Length;
byte[] data = new byte[8 + 2 + 1 + strlen + 2 + 2 + tagdata.Length];
LE.setuint16(data, 0, 0x0004); //write tag cmd
LE.setuint16(data, 2, 0x1234); //unique id
LE.setuint32(data, 4, 2 + strlen); //data Length
LE.setuint16(data, 8, 1); //count
LE.setuint8(data, 10, strlen); //strlen
Arrays <byte> .Copy(tag.tag.ToByteArray(), 0, data, 11, strlen);
int pos = 11 + strlen;
LE.setuint16(data, pos, tag.type); //tagtype
pos += 2;
LE.setuint16(data, pos, tagdata.Length); //tag size
pos += 2;
Arrays <byte> .Copy(tagdata, 0, data, pos, tagdata.Length);
return(data);
}
/// <summary>
/// Divides the right operand from the left one.
/// </summary>
/// <param name="Left">Left operand.</param>
/// <param name="Right">Right operand.</param>
/// <param name="Node">Node performing the operation.</param>
/// <returns>Result</returns>
public static IElement EvaluateDivision(IElement Left, IElement Right, ScriptNode Node)
{
IRingElement RE = Right as IRingElement;
IElement Result;
IRingElement Temp;
if (Left is IRingElement LE && RE != null)
{
Temp = RE.Invert();
if (Temp != null)
{
Result = LE.MultiplyRight(Temp);
if (Result != null)
{
return(Result);
}
Result = Temp.MultiplyLeft(LE);
if (Result != null)
{
return(Result);
}
}
}
if (Left.IsScalar)
{
if (Right.IsScalar)
{
ISet LeftSet = Left.AssociatedSet;
ISet RightSet = Right.AssociatedSet;
if (!LeftSet.Equals(RightSet))
{
if (!Expression.Upgrade(ref Left, ref LeftSet, ref Right, ref RightSet, Node))
{
throw new ScriptRuntimeException("Incompatible operands.", Node);
}
LE = Left as IRingElement;
RE = Right as IRingElement;
if (LE != null && RE != null)
{
Temp = RE.Invert();
if (Temp != null)
{
Result = LE.MultiplyRight(Temp);
if (Result != null)
{
return(Result);
}
Result = Temp.MultiplyLeft(LE);
if (Result != null)
{
return(Result);
}
}
}
}
throw new ScriptRuntimeException("Operands cannot be divided.", Node);
}
else
{
LinkedList <IElement> Elements = new LinkedList <IElement>();
foreach (IElement RightChild in Right.ChildElements)
{
Elements.AddLast(EvaluateDivision(Left, RightChild, Node));
}
return(Right.Encapsulate(Elements, Node));
}
}
else
{
if (Right.IsScalar)
{
LinkedList <IElement> Elements = new LinkedList <IElement>();
foreach (IElement LeftChild in Left.ChildElements)
{
Elements.AddLast(EvaluateDivision(LeftChild, Right, Node));
}
return(Left.Encapsulate(Elements, Node));
}
else
{
ICollection <IElement> LeftChildren = Left.ChildElements;
ICollection <IElement> RightChildren = Right.ChildElements;
if (LeftChildren.Count == RightChildren.Count)
{
LinkedList <IElement> Elements = new LinkedList <IElement>();
IEnumerator <IElement> eLeft = LeftChildren.GetEnumerator();
IEnumerator <IElement> eRight = RightChildren.GetEnumerator();
try
{
while (eLeft.MoveNext() && eRight.MoveNext())
{
Elements.AddLast(EvaluateDivision(eLeft.Current, eRight.Current, Node));
}
}
finally
{
eLeft.Dispose();
eRight.Dispose();
}
return(Left.Encapsulate(Elements, Node));
}
else
{
LinkedList <IElement> LeftResult = new LinkedList <IElement>();
foreach (IElement LeftChild in LeftChildren)
{
LinkedList <IElement> RightResult = new LinkedList <IElement>();
foreach (IElement RightChild in RightChildren)
{
RightResult.AddLast(EvaluateDivision(LeftChild, RightChild, Node));
}
LeftResult.AddLast(Right.Encapsulate(RightResult, Node));
}
return(Left.Encapsulate(LeftResult, Node));
}
}
}
}
private void writeuint32(int val)
{
LE.setuint32(tmp, 0, val);
baos.Write(tmp, 0, 4);
}
private void writeuint16(int val)
{
LE.setuint16(tmp, 0, val);
baos.Write(tmp, 0, 2);
}
/////////////////////// A* ///////////////////////
///add the starting node to the open list
///while the open list is not empty
/// {
/// current node = node from open list with the lowest cost
/// if currentnode = goal
/// path complete
/// else
/// move current node to the closed list
/// for each adjacent node
/// if it lies with the field
/// and it isn't an obstacle
/// and it isn't on the open list
/// and isn't on the closed list
/// move it to the open list and calculate cost
//////////////////////////////////////////////////
#endregion
public void SearchPath(TVec2 startTile, TVec2 endTile)
{
this.startTile = startTile;
this.endTile = endTile;
//Reset all the values
for (int i = 0; i < AStartTest.gridWidth; i++)
{
for (int j = 0; j < AStartTest.gridHeight; j++)
{
grid[i, j].cost = 0;
grid[i, j].heuristic = 0;
}
}
#region Path validation
bool canSearch = true;
if (grid[(int)startTile.X, (int)startTile.Y].walkable == false)
{
Console.WriteLine("The start tile is non walkable. Choose a different value than: " + startTile.ToString());
canSearch = false;
}
if (grid[(int)endTile.X, (int)endTile.Y].walkable == false)
{
Console.WriteLine("The end tile is non walkable. Choose a different value than: " + endTile.ToString());
canSearch = false;
}
#endregion
//Start the A* algorithm
if (canSearch)
{
//add the starting tile to the open list
openList.Add(startTile);
currentTile = new TVec2(-1, -1);
//while Openlist is not empty
while (openList.Count != 0)
{
//current node = node from open list with the lowest cost
currentTile = GetTileWithLowestTotal(openList);
//If the currentTile is the endtile, then we can stop searching
if (currentTile.X == endTile.X && currentTile.Y == endTile.Y)
{
Console.WriteLine("YEHA, We found the end tile!!!! :D");
break;
}
else
{
//move the current tile to the closed list and remove it from the open list
openList.Remove(currentTile);
closedList.Add(currentTile);
//Get all the adjacent Tiles
List <TVec2> adjacentTiles = GetAdjacentTiles(currentTile);
foreach (TVec2 adjacentTile in adjacentTiles)
{
//adjacent tile can not be in the open list
if (!openList.Contains(adjacentTile))
{
//adjacent tile can not be in the closed list
if (!closedList.Contains(adjacentTile))
{
//move it to the open list and calculate cost
openList.Add(adjacentTile);
Tile tile = grid[(int)adjacentTile.X, (int)adjacentTile.Y];
//Calculate the cost
tile.cost = grid[(int)currentTile.X, (int)currentTile.Y].cost + 1;
//Calculate the manhattan distance
tile.heuristic = ManhattanDistance(adjacentTile);
//calculate the total amount
tile.total = tile.cost + tile.heuristic;
//make this tile green
LE.EntityColor(tile.cube, Tile.GREEN);
}
}
}
}
}
}
//Pain the start and end tile red
LE.EntityColor(grid[(int)startTile.X, (int)startTile.Y].cube, Tile.RED);
LE.EntityColor(grid[(int)endTile.X, (int)endTile.Y].cube, Tile.RED);
//Show the path
ShowPath();
}
/// <summary>
/// Calculates Left ^ Right.
/// </summary>
/// <param name="Left">Left operand.</param>
/// <param name="Right">Right operand.</param>
/// <param name="Node">Node performing the operation.</param>
/// <returns>Result</returns>
public static IElement EvaluatePower(IElement Left, IElement Right, ScriptNode Node)
{
DoubleNumber DR = Right as DoubleNumber;
if (Left is DoubleNumber DL && DR != null)
{
return(new DoubleNumber(Math.Pow(DL.Value, DR.Value)));
}
if (Left is IRingElement LE && DR != null)
{
double d = DR.Value;
if (d >= long.MinValue && d <= long.MaxValue && Math.Truncate(d) == d)
{
long n = (long)d;
if (n < 0)
{
LE = LE.Invert();
if (LE == null)
{
throw new ScriptRuntimeException("Base element not invertible.", Node);
}
n = -n;
}
else if (n == 0)
{
if (!(LE is ICommutativeRingWithIdentityElement LE2))
{
throw new ScriptRuntimeException("Base element ring does not have unity.", Node);
}
return(LE2.One);
}
IRingElement Result = null;
while (n > 0)
{
if ((n & 1) == 1)
{
if (Result == null)
{
Result = LE;
}
else
{
Result = (IRingElement)Multiply.EvaluateMultiplication(Result, LE, Node);
}
}
n >>= 1;
if (n > 0)
{
LE = (IRingElement)Multiply.EvaluateMultiplication(LE, LE, Node);
}
}
return(Result);
}
else
{
throw new ScriptRuntimeException("Exponent too large.", Node);
}
}
if (Left.IsScalar)
{
if (Right.IsScalar)
{
throw new ScriptRuntimeException("Power operation could not be computed.", Node);
}
else
{
LinkedList <IElement> Elements = new LinkedList <IElement>();
foreach (IElement RightChild in Right.ChildElements)
{
Elements.AddLast(EvaluatePower(Left, RightChild, Node));
}
return(Right.Encapsulate(Elements, Node));
}
}
else
{
if (Right.IsScalar)
{
LinkedList <IElement> Elements = new LinkedList <IElement>();
foreach (IElement LeftChild in Left.ChildElements)
{
Elements.AddLast(EvaluatePower(LeftChild, Right, Node));
}
return(Left.Encapsulate(Elements, Node));
}
else
{
ICollection <IElement> LeftChildren = Left.ChildElements;
ICollection <IElement> RightChildren = Right.ChildElements;
if (LeftChildren.Count == RightChildren.Count)
{
LinkedList <IElement> Elements = new LinkedList <IElement>();
IEnumerator <IElement> eLeft = LeftChildren.GetEnumerator();
IEnumerator <IElement> eRight = RightChildren.GetEnumerator();
try
{
while (eLeft.MoveNext() && eRight.MoveNext())
{
Elements.AddLast(EvaluatePower(eLeft.Current, eRight.Current, Node));
}
}
finally
{
eLeft.Dispose();
eRight.Dispose();
}
return(Left.Encapsulate(Elements, Node));
}
else
{
LinkedList <IElement> LeftResult = new LinkedList <IElement>();
foreach (IElement LeftChild in LeftChildren)
{
LinkedList <IElement> RightResult = new LinkedList <IElement>();
foreach (IElement RightChild in RightChildren)
{
RightResult.AddLast(EvaluatePower(LeftChild, RightChild, Node));
}
LeftResult.AddLast(Right.Encapsulate(RightResult, Node));
}
return(Left.Encapsulate(LeftResult, Node));
}
}
}
}
public bool Load(IOStream wav)
{
errmsg = "";
try {
byte[] data = new byte[30];
//read RIFF header (20 bytes);
wav.Read(data, 0, 20);
if (!LE.getString(data, 0, 4).Equals("RIFF"))
{
throw new Exception("wav is not a valid WAV file (RIFF)");
}
if (!LE.getString(data, 8, 4).Equals("WAVE"))
{
throw new Exception("wav is not a valid WAV file (WAVE)");
}
if (!LE.getString(data, 12, 4).Equals("fmt "))
{
throw new Exception("wav is not a valid WAV file (fmt )");
}
int fmtsiz = LE.getuint32(data, 16);
if ((fmtsiz < 16) || (fmtsiz > 30))
{
throw new Exception("wav is not a valid WAV file (fmtsiz)");
}
wav.Read(data, 0, fmtsiz);
if (LE.getuint16(data, 0) != 1)
{
throw new Exception("wav is not PCM");
}
chs = LE.getuint16(data, 2);
if (chs < 1 || chs > 2)
{
throw new Exception("wav is not supported (# chs)");
}
rate = LE.getuint32(data, 4);
bits = LE.getuint16(data, 14);
switch (bits)
{
// case 8: bytes = 1; break; //can't support 8bit for now (upscale later ???)
case 16: bytes = 2; break;
case 24: bytes = 3; break;
case 32: bytes = 4; break;
default: throw new Exception("wav is not supported (bits=" + bits + ")");
}
wav.Read(data, 0, 8);
while (true)
{
dataLength = LE.getuint32(data, 4);
if (LE.getString(data, 0, 4).Equals("data"))
{
break;
}
//ignore chunk (FACT, INFO, etc.)
wav.SetPosition(wav.GetPosition() + dataLength);
wav.Read(data, 0, 8);
}
samples8 = wav.ReadAll().ToArray();
wav.Close();
switch (bits)
{
case 8: return(true);
case 24:
//TODO!!!???
break;
case 16:
samples16 = new short[dataLength / 2];
CPP.Add("std::memcpy(samples16->data(), samples8->data(), dataLength);");
break;
case 32:
samples32 = new int[dataLength / 4];
CPP.Add("std::memcpy(samples32->data(), samples8->data(), dataLength);");
break;
}
} catch (Exception e1) {
errmsg = e1.ToString();
wav.Close();
return(false);
}
return(true);
}
// Module defining this command
// Optional custom code for this activity
/// <summary>
/// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run.
/// </summary>
/// <param name="context">The NativeActivityContext for the currently running activity.</param>
/// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns>
/// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks>
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context)
{
System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create();
System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName);
// Initialize the arguments
if (InputObject.Expression != null)
{
targetCommand.AddParameter("InputObject", InputObject.Get(context));
}
if (FilterScript.Expression != null)
{
targetCommand.AddParameter("FilterScript", FilterScript.Get(context));
}
if (Property.Expression != null)
{
targetCommand.AddParameter("Property", Property.Get(context));
}
if (Value.Expression != null)
{
targetCommand.AddParameter("Value", Value.Get(context));
}
if (EQ.Expression != null)
{
targetCommand.AddParameter("EQ", EQ.Get(context));
}
if (CEQ.Expression != null)
{
targetCommand.AddParameter("CEQ", CEQ.Get(context));
}
if (NE.Expression != null)
{
targetCommand.AddParameter("NE", NE.Get(context));
}
if (CNE.Expression != null)
{
targetCommand.AddParameter("CNE", CNE.Get(context));
}
if (GT.Expression != null)
{
targetCommand.AddParameter("GT", GT.Get(context));
}
if (CGT.Expression != null)
{
targetCommand.AddParameter("CGT", CGT.Get(context));
}
if (LT.Expression != null)
{
targetCommand.AddParameter("LT", LT.Get(context));
}
if (CLT.Expression != null)
{
targetCommand.AddParameter("CLT", CLT.Get(context));
}
if (GE.Expression != null)
{
targetCommand.AddParameter("GE", GE.Get(context));
}
if (CGE.Expression != null)
{
targetCommand.AddParameter("CGE", CGE.Get(context));
}
if (LE.Expression != null)
{
targetCommand.AddParameter("LE", LE.Get(context));
}
if (CLE.Expression != null)
{
targetCommand.AddParameter("CLE", CLE.Get(context));
}
if (Like.Expression != null)
{
targetCommand.AddParameter("Like", Like.Get(context));
}
if (CLike.Expression != null)
{
targetCommand.AddParameter("CLike", CLike.Get(context));
}
if (NotLike.Expression != null)
{
targetCommand.AddParameter("NotLike", NotLike.Get(context));
}
if (CNotLike.Expression != null)
{
targetCommand.AddParameter("CNotLike", CNotLike.Get(context));
}
if (Match.Expression != null)
{
targetCommand.AddParameter("Match", Match.Get(context));
}
if (CMatch.Expression != null)
{
targetCommand.AddParameter("CMatch", CMatch.Get(context));
}
if (NotMatch.Expression != null)
{
targetCommand.AddParameter("NotMatch", NotMatch.Get(context));
}
if (CNotMatch.Expression != null)
{
targetCommand.AddParameter("CNotMatch", CNotMatch.Get(context));
}
if (Contains.Expression != null)
{
targetCommand.AddParameter("Contains", Contains.Get(context));
}
if (CContains.Expression != null)
{
targetCommand.AddParameter("CContains", CContains.Get(context));
}
if (NotContains.Expression != null)
{
targetCommand.AddParameter("NotContains", NotContains.Get(context));
}
if (CNotContains.Expression != null)
{
targetCommand.AddParameter("CNotContains", CNotContains.Get(context));
}
if (In.Expression != null)
{
targetCommand.AddParameter("In", In.Get(context));
}
if (CIn.Expression != null)
{
targetCommand.AddParameter("CIn", CIn.Get(context));
}
if (NotIn.Expression != null)
{
targetCommand.AddParameter("NotIn", NotIn.Get(context));
}
if (CNotIn.Expression != null)
{
targetCommand.AddParameter("CNotIn", CNotIn.Get(context));
}
if (Is.Expression != null)
{
targetCommand.AddParameter("Is", Is.Get(context));
}
if (IsNot.Expression != null)
{
targetCommand.AddParameter("IsNot", IsNot.Get(context));
}
return(new ActivityImplementationContext()
{
PowerShellInstance = invoker
});
}
internal void LoadData(LE.GameEngine.board.BoardSerializable gameData)
{
//Player1.LoadSaveData(gameData);
//Game.StartNewGame();
}
