public void TestSimpleSub()
{
var team = new Player[3];
team[0] = MakePlayer(150, PositionEnum.RB, true, 0);
team[1] = MakePlayer(150, PositionEnum.WR, true, 1);
team[2] = MakePlayer(240, PositionEnum.WR, false, 2);
var updatedPlayers = new SwapHelper().GetUpdatedPlayers(team);
Assert.AreEqual(0, updatedPlayers[0].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[0].Points);
Assert.AreEqual(true, updatedPlayers[0].Starting);
Assert.AreEqual(PositionEnum.RB, updatedPlayers[0].Position);
Assert.AreEqual(0, updatedPlayers[0].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[0].AlreadySubbed);
Assert.AreEqual(240, updatedPlayers[1].PointsUpdated);
Assert.AreEqual(240, updatedPlayers[1].Points);
Assert.AreEqual(true, updatedPlayers[1].Starting);
Assert.AreEqual(PositionEnum.WR, updatedPlayers[1].Position);
Assert.AreEqual(2, updatedPlayers[1].OriginalIndex);
Assert.AreEqual(true, updatedPlayers[1].AlreadySubbed);
Assert.AreEqual(150, updatedPlayers[2].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[2].Points);
Assert.AreEqual(false, updatedPlayers[2].Starting);
Assert.AreEqual(PositionEnum.WR, updatedPlayers[2].Position);
Assert.AreEqual(1, updatedPlayers[2].OriginalIndex);
Assert.AreEqual(true, updatedPlayers[2].AlreadySubbed);
}
public void TestNoSubs()
{
var team = new Player[16];
team[0] = MakePlayer(150, PositionEnum.QB, true, 0);
team[1] = MakePlayer(150, PositionEnum.RB, true, 1);
team[2] = MakePlayer(150, PositionEnum.WR, true, 2);
team[3] = MakePlayer(150, PositionEnum.TE, true, 3);
team[4] = MakePlayer(150, PositionEnum.RB, true, 4);
team[5] = MakePlayer(150, PositionEnum.WR, true, 5);
team[6] = MakePlayer(150, PositionEnum.K, true, 6);
team[7] = MakePlayer(150, PositionEnum.DL, true, 7);
team[8] = MakePlayer(150, PositionEnum.LB, true, 8);
team[9] = MakePlayer(150, PositionEnum.DB, true, 9);
team[10] = MakePlayer(150, PositionEnum.LB, true, 10);
team[11] = MakePlayer(120, PositionEnum.WR, false, 11);
team[12] = MakePlayer(120, PositionEnum.RB, false, 12);
team[13] = MakePlayer(120, PositionEnum.LB, false, 13);
team[14] = MakePlayer(120, PositionEnum.LB, false, 14);
team[15] = MakePlayer(130, PositionEnum.LB, false, 15);
var updatedPlayers = new SwapHelper().GetUpdatedPlayers(team);
var test = 1;
}
public override void Undo(TextDocument context)
{
// Make the change
base.Undo(context);
// Fire the undo version of the info by swapping the
// old and new length and setting the undo flag
var undoInfo = _info;
undoInfo.IsUndoing = true;
SwapHelper.Swap(ref undoInfo.OldLength, ref undoInfo.NewLength);
context.FireDocumentChange(undoInfo);
}
private static ValuationResultRange CreateValuationRange(Swap swap, string baseParty)
{
Money payPresentValue = SwapHelper.GetPayPresentValue(swap, baseParty);
Money payFutureValue = SwapHelper.GetPayFutureValue(swap, baseParty);
Money receivePresentValue = SwapHelper.GetReceivePresentValue(swap, baseParty);
Money receiveFutureValue = SwapHelper.GetReceiveFutureValue(swap, baseParty);
Money swapPresentValue = SwapHelper.GetPresentValue(swap, baseParty);
Money swapFutureValue = SwapHelper.GetFutureValue(swap, baseParty);
var resultRange = new ValuationResultRange
{
PresentValue = swapPresentValue.amount,
FutureValue = swapFutureValue.amount,
PayLegPresentValue = payPresentValue.amount,
PayLegFutureValue = payFutureValue.amount,
ReceiveLegPresentValue = receivePresentValue.amount,
ReceiveLegFutureValue = receiveFutureValue.amount
};
return(resultRange);
}
private static void Main()//used by eastmoney
{
#region 1.原始方法
int i1 = 1, i2 = 2;
Console.WriteLine($"I need Swap int:i1 = {i1},i2 = {i2}");
SwapHelper.Swap(ref i1, ref i2);
Console.WriteLine($"After Swap int:i1 = {i1},i2 = {i2}");
Console.WriteLine("\n========================\n");
string s1 = "aaa", s2 = "bbb";
Console.WriteLine($"I need Swap string:s1 = {s1},s2 = {s2}");
SwapHelper.Swap(ref s1, ref s2);
Console.WriteLine($"After Swap string:s1 = {s1},s2 = {s2}");
Console.WriteLine("\n\n==========华丽的分割线==============\n\n");
#endregion
#region 2.泛型方法
char c1 = 'A', c2 = '5';
Console.WriteLine($"I can Swap everything:c1 = {c1},c2 = {c2}");
SwapHelper.Swap <char>(ref c1, ref c2);
Console.WriteLine($"After Swap :c1 = {c1},c2 = {c2}");
Console.WriteLine("\n========================\n");
decimal d1 = 1.00m, d2 = 3.00m;
Console.WriteLine($"I can Swap everything:d1 = {d1},d2 = {d2}");
SwapHelper.Swap <decimal>(ref d1, ref d2);
Console.WriteLine($"After Swap :d1 = {d1},c2 = {d2}");
#endregion
Console.Read();
}
/// <summary>
/// PR_LoadProgs
/// </summary>
public static void LoadProgs()
{
FreeHandles();
QBuiltins.ClearState();
_DynamicStrings.Clear();
// flush the non-C variable lookup cache
for (int i = 0; i < GEFV_CACHESIZE; i++)
{
_gefvCache[i].field = null;
}
CRC.Init(out _Crc);
byte[] buf = Common.LoadFile("progs.dat");
_Progs = Sys.BytesToStructure <dprograms_t>(buf, 0);
if (_Progs == null)
{
Sys.Error("PR_LoadProgs: couldn't load progs.dat");
}
Con.DPrint("Programs occupy {0}K.\n", buf.Length / 1024);
for (int i = 0; i < buf.Length; i++)
{
CRC.ProcessByte(ref _Crc, buf[i]);
}
// byte swap the header
_Progs.SwapBytes();
if (_Progs.version != PROG_VERSION)
{
Sys.Error("progs.dat has wrong version number ({0} should be {1})", _Progs.version, PROG_VERSION);
}
if (_Progs.crc != PROGHEADER_CRC)
{
Sys.Error("progs.dat system vars have been modified, progdefs.h is out of date");
}
// Functions
_Functions = new dfunction_t[_Progs.numfunctions];
int offset = _Progs.ofs_functions;
for (int i = 0; i < _Functions.Length; i++, offset += dfunction_t.SizeInBytes)
{
_Functions[i] = Sys.BytesToStructure <dfunction_t>(buf, offset);
_Functions[i].SwapBytes();
}
// strings
offset = _Progs.ofs_strings;
int str0 = offset;
for (int i = 0; i < _Progs.numstrings; i++, offset++)
{
// count string length
while (buf[offset] != 0)
{
offset++;
}
}
int length = offset - str0;
_Strings = Encoding.ASCII.GetString(buf, str0, length);
// Globaldefs
_GlobalDefs = new ddef_t[_Progs.numglobaldefs];
offset = _Progs.ofs_globaldefs;
for (int i = 0; i < _GlobalDefs.Length; i++, offset += ddef_t.SizeInBytes)
{
_GlobalDefs[i] = Sys.BytesToStructure <ddef_t>(buf, offset);
_GlobalDefs[i].SwapBytes();
}
// Fielddefs
_FieldDefs = new ddef_t[_Progs.numfielddefs];
offset = _Progs.ofs_fielddefs;
for (int i = 0; i < _FieldDefs.Length; i++, offset += ddef_t.SizeInBytes)
{
_FieldDefs[i] = Sys.BytesToStructure <ddef_t>(buf, offset);
_FieldDefs[i].SwapBytes();
if ((_FieldDefs[i].type & DEF_SAVEGLOBAL) != 0)
{
Sys.Error("PR_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL");
}
}
// Statements
_Statements = new dstatement_t[_Progs.numstatements];
offset = _Progs.ofs_statements;
for (int i = 0; i < _Statements.Length; i++, offset += dstatement_t.SizeInBytes)
{
_Statements[i] = Sys.BytesToStructure <dstatement_t>(buf, offset);
_Statements[i].SwapBytes();
}
// Swap bytes inplace if needed
if (!BitConverter.IsLittleEndian)
{
offset = _Progs.ofs_globals;
for (int i = 0; i < _Progs.numglobals; i++, offset += 4)
{
SwapHelper.Swap4b(buf, offset);
}
}
GlobalStruct = Sys.BytesToStructure <globalvars_t>(buf, _Progs.ofs_globals);
_Globals = new float[_Progs.numglobals - globalvars_t.SizeInBytes / 4];
Buffer.BlockCopy(buf, _Progs.ofs_globals + globalvars_t.SizeInBytes, _Globals, 0, _Globals.Length * 4);
_EdictSize = _Progs.entityfields * 4 + dedict_t.SizeInBytes - entvars_t.SizeInBytes;
_HGlobals = GCHandle.Alloc(_Globals, GCHandleType.Pinned);
_GlobalsAddr = _HGlobals.AddrOfPinnedObject().ToInt64();
_HGlobalStruct = GCHandle.Alloc(Progs.GlobalStruct, GCHandleType.Pinned);
_GlobalStructAddr = _HGlobalStruct.AddrOfPinnedObject().ToInt64();
}
float IByteOrderConverter.LittleFloat(float l)
{
return(SwapHelper.FloatSwap(l));
}
int IByteOrderConverter.LittleLong(int l)
{
return(SwapHelper.LongSwap(l));
}
short IByteOrderConverter.LittleShort(short l)
{
return(SwapHelper.ShortSwap(l));
}
/// <summary>
/// PR_LoadProgs
/// </summary>
public void LoadProgs( )
{
FreeHandles( );
Host.ProgramsBuiltIn.ClearState( );
_DynamicStrings.Clear( );
// flush the non-C variable lookup cache
for (var i = 0; i < GEFV_CACHESIZE; i++)
{
_gefvCache[i].field = null;
}
Framework.Crc.Init(out _Crc);
var buf = FileSystem.LoadFile("progs.dat");
_Progs = Utilities.BytesToStructure <Program>(buf, 0);
if (_Progs == null)
{
Utilities.Error("PR_LoadProgs: couldn't load Host.Programs.dat");
}
Host.Console.DPrint("Programs occupy {0}K.\n", buf.Length / 1024);
for (var i = 0; i < buf.Length; i++)
{
Framework.Crc.ProcessByte(ref _Crc, buf[i]);
}
// byte swap the header
_Progs.SwapBytes( );
if (_Progs.version != ProgramDef.PROG_VERSION)
{
Utilities.Error("progs.dat has wrong version number ({0} should be {1})", _Progs.version, ProgramDef.PROG_VERSION);
}
if (_Progs.crc != ProgramDef.PROGHEADER_CRC)
{
Utilities.Error("progs.dat system vars have been modified, progdefs.h is out of date");
}
// Functions
_Functions = new ProgramFunction[_Progs.numfunctions];
var offset = _Progs.ofs_functions;
for (var i = 0; i < _Functions.Length; i++, offset += ProgramFunction.SizeInBytes)
{
_Functions[i] = Utilities.BytesToStructure <ProgramFunction>(buf, offset);
_Functions[i].SwapBytes( );
}
// strings
offset = _Progs.ofs_strings;
var str0 = offset;
for (var i = 0; i < _Progs.numstrings; i++, offset++)
{
// count string length
while (buf[offset] != 0)
{
offset++;
}
}
var length = offset - str0;
_Strings = Encoding.ASCII.GetString(buf, str0, length);
// Globaldefs
_GlobalDefs = new ProgramDefinition[_Progs.numglobaldefs];
offset = _Progs.ofs_globaldefs;
for (var i = 0; i < _GlobalDefs.Length; i++, offset += ProgramDefinition.SizeInBytes)
{
_GlobalDefs[i] = Utilities.BytesToStructure <ProgramDefinition>(buf, offset);
_GlobalDefs[i].SwapBytes( );
}
// Fielddefs
_FieldDefs = new ProgramDefinition[_Progs.numfielddefs];
offset = _Progs.ofs_fielddefs;
for (var i = 0; i < _FieldDefs.Length; i++, offset += ProgramDefinition.SizeInBytes)
{
_FieldDefs[i] = Utilities.BytesToStructure <ProgramDefinition>(buf, offset);
_FieldDefs[i].SwapBytes( );
if ((_FieldDefs[i].type & ProgramDef.DEF_SAVEGLOBAL) != 0)
{
Utilities.Error("PR_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL");
}
}
// Statements
_Statements = new Statement[_Progs.numstatements];
offset = _Progs.ofs_statements;
for (var i = 0; i < _Statements.Length; i++, offset += Statement.SizeInBytes)
{
_Statements[i] = Utilities.BytesToStructure <Statement>(buf, offset);
_Statements[i].SwapBytes( );
}
// Swap bytes inplace if needed
if (!BitConverter.IsLittleEndian)
{
offset = _Progs.ofs_globals;
for (var i = 0; i < _Progs.numglobals; i++, offset += 4)
{
SwapHelper.Swap4b(buf, offset);
}
}
GlobalStruct = Utilities.BytesToStructure <GlobalVariables>(buf, _Progs.ofs_globals);
_Globals = new Single[_Progs.numglobals - GlobalVariables.SizeInBytes / 4];
Buffer.BlockCopy(buf, _Progs.ofs_globals + GlobalVariables.SizeInBytes, _Globals, 0, _Globals.Length * 4);
_EdictSize = _Progs.entityfields * 4 + Edict.SizeInBytes - EntVars.SizeInBytes;
ProgramDef.EdictSize = _EdictSize;
_HGlobals = GCHandle.Alloc(_Globals, GCHandleType.Pinned);
_GlobalsAddr = _HGlobals.AddrOfPinnedObject( ).ToInt64( );
_HGlobalStruct = GCHandle.Alloc(Host.Programs.GlobalStruct, GCHandleType.Pinned);
_GlobalStructAddr = _HGlobalStruct.AddrOfPinnedObject( ).ToInt64( );
}
public void TestSubSingleQbFirst()
{
var team = new Player[16];
team[0] = MakePlayer(150, PositionEnum.QB, true, 0);
team[1] = MakePlayer(150, PositionEnum.RB, true, 1);
team[2] = MakePlayer(150, PositionEnum.WR, true, 2);
team[3] = MakePlayer(150, PositionEnum.TE, true, 3);
team[4] = MakePlayer(150, PositionEnum.RB, true, 4);
team[5] = MakePlayer(150, PositionEnum.WR, true, 5);
team[6] = MakePlayer(150, PositionEnum.K, true, 6);
team[7] = MakePlayer(150, PositionEnum.DL, true, 7);
team[8] = MakePlayer(150, PositionEnum.LB, true, 8);
team[9] = MakePlayer(150, PositionEnum.DB, true, 9);
team[10] = MakePlayer(150, PositionEnum.LB, true, 10);
team[11] = MakePlayer(240, PositionEnum.QB, false, 11);
team[12] = MakePlayer(80, PositionEnum.RB, false, 12);
team[13] = MakePlayer(120, PositionEnum.LB, false, 13);
team[14] = MakePlayer(20, PositionEnum.LB, false, 14);
team[15] = MakePlayer(130, PositionEnum.LB, false, 15);
var updatedPlayers = new SwapHelper().GetUpdatedPlayers(team);
Assert.AreEqual(240, updatedPlayers[0].PointsUpdated);
Assert.AreEqual(240, updatedPlayers[0].Points);
Assert.AreEqual(true, updatedPlayers[0].Starting);
Assert.AreEqual(PositionEnum.QB, updatedPlayers[0].Position);
Assert.AreEqual(11, updatedPlayers[0].OriginalIndex);
Assert.AreEqual(true, updatedPlayers[0].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[1].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[1].Points);
Assert.AreEqual(true, updatedPlayers[1].Starting);
Assert.AreEqual(PositionEnum.RB, updatedPlayers[1].Position);
Assert.AreEqual(1, updatedPlayers[1].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[1].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[2].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[2].Points);
Assert.AreEqual(true, updatedPlayers[2].Starting);
Assert.AreEqual(PositionEnum.WR, updatedPlayers[2].Position);
Assert.AreEqual(2, updatedPlayers[2].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[2].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[3].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[3].Points);
Assert.AreEqual(true, updatedPlayers[3].Starting);
Assert.AreEqual(PositionEnum.TE, updatedPlayers[3].Position);
Assert.AreEqual(3, updatedPlayers[3].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[3].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[4].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[4].Points);
Assert.AreEqual(true, updatedPlayers[4].Starting);
Assert.AreEqual(PositionEnum.RB, updatedPlayers[4].Position);
Assert.AreEqual(4, updatedPlayers[4].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[4].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[5].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[5].Points);
Assert.AreEqual(true, updatedPlayers[5].Starting);
Assert.AreEqual(PositionEnum.WR, updatedPlayers[5].Position);
Assert.AreEqual(5, updatedPlayers[5].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[5].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[6].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[6].Points);
Assert.AreEqual(true, updatedPlayers[6].Starting);
Assert.AreEqual(PositionEnum.K, updatedPlayers[6].Position);
Assert.AreEqual(6, updatedPlayers[6].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[6].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[7].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[7].Points);
Assert.AreEqual(true, updatedPlayers[7].Starting);
Assert.AreEqual(PositionEnum.DL, updatedPlayers[7].Position);
Assert.AreEqual(7, updatedPlayers[7].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[7].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[8].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[8].Points);
Assert.AreEqual(true, updatedPlayers[8].Starting);
Assert.AreEqual(PositionEnum.LB, updatedPlayers[8].Position);
Assert.AreEqual(8, updatedPlayers[8].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[8].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[9].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[9].Points);
Assert.AreEqual(true, updatedPlayers[9].Starting);
Assert.AreEqual(PositionEnum.DB, updatedPlayers[9].Position);
Assert.AreEqual(9, updatedPlayers[9].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[9].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[10].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[10].Points);
Assert.AreEqual(true, updatedPlayers[10].Starting);
Assert.AreEqual(PositionEnum.LB, updatedPlayers[10].Position);
Assert.AreEqual(10, updatedPlayers[10].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[10].AlreadySubbed);
Assert.AreEqual(150, updatedPlayers[11].PointsUpdated);
Assert.AreEqual(150, updatedPlayers[11].Points);
Assert.AreEqual(false, updatedPlayers[11].Starting);
Assert.AreEqual(PositionEnum.QB, updatedPlayers[11].Position);
Assert.AreEqual(0, updatedPlayers[11].OriginalIndex);
Assert.AreEqual(true, updatedPlayers[11].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[12].PointsUpdated);
Assert.AreEqual(80, updatedPlayers[12].Points);
Assert.AreEqual(false, updatedPlayers[12].Starting);
Assert.AreEqual(PositionEnum.RB, updatedPlayers[12].Position);
Assert.AreEqual(12, updatedPlayers[12].OriginalIndex);
Assert.AreEqual(false, updatedPlayers[12].AlreadySubbed);
Assert.AreEqual(0, updatedPlayers[13].PointsUpdated);
Assert.AreEqual(120, updatedPlayers[13].Points);
Assert.AreEqual(false, updatedPlayers[13].Starting);
Assert.AreEqual(PositionEnum.LB, updatedPlayers[13].Position);
Assert.AreEqual(13, updatedPlayers[13].OriginalIndex);
Assert.AreEqual(0, updatedPlayers[14].PointsUpdated);
Assert.AreEqual(20, updatedPlayers[14].Points);
Assert.AreEqual(false, updatedPlayers[14].Starting);
Assert.AreEqual(PositionEnum.LB, updatedPlayers[14].Position);
Assert.AreEqual(14, updatedPlayers[14].OriginalIndex);
Assert.AreEqual(0, updatedPlayers[15].PointsUpdated);
Assert.AreEqual(130, updatedPlayers[15].Points);
Assert.AreEqual(false, updatedPlayers[15].Starting);
Assert.AreEqual(PositionEnum.LB, updatedPlayers[15].Position);
Assert.AreEqual(15, updatedPlayers[15].OriginalIndex);
}
