public MachineTestInput ConstructInput(MachineTestOutput output)
{
MachineTestInput input = new MachineTestInput();
if (output != null)
{
input._credit = output._remainCredit;
input._lucky = output._remainLucky;
input._isRespin = output._shouldRespin;
input._isPayProtection = output._isPayProtection;
}
else
{
input._credit = _config._initCredit;
input._lucky = _config._initLucky;
input._isRespin = false;
input._isPayProtection = _config._isPayProtectionEnable;
}
if (output != null && output._spinResult.IsRespin)
{
//keep betAmount
input._betAmount = output._spinResult.BetAmount;
}
else
{
input._betAmount = GetBetAmount((int)input._credit);
}
return(input);
}
public MachineTestOutput Run(MachineTestInput input)
{
CoreSpinResult spinResult = Spin(input);
MachineTestIndieGameResult indieGameResult = _indieGameManager.Run(input);
MachineTestOutput output = ConstructOutput(input, spinResult, indieGameResult);
return(output);
}
private string ConstructResult(int id, MachineTestInput input, MachineTestOutput output)
{
CoreSpinResult spinResult = output._spinResult;
SpinResultType spinResultType = spinResult.Type;
List <string> symbolNames = ListUtility.MapList(spinResult.SymbolList, (CoreSymbol s) => {
return(s.SymbolData.Name);
});
string symbolNameStr = string.Join(_delimiter, symbolNames.ToArray());
int resultType = CoreUtility.SpinResultTypeToInt(spinResultType);
int resultId = 0;
if (spinResultType == SpinResultType.Win)
{
resultId = spinResult.GetPayoutId();
}
else if (spinResultType == SpinResultType.NearHit)
{
resultId = spinResult.GetNearHitId();
}
int lucky = CoreUtility.LuckyModeToInt(spinResult.LuckyMode);
long curCredit = input._credit;
int consumedBetAmount = (int)spinResult.ConsumedBetAmount;
float winRatio = spinResult.WinRatio;
long creditChange = output._creditChange;
long remainCredit = output._remainCredit;
int luckyChange = output._luckyChange;
int remainLucky = output._remainLucky;
int isRespin = spinResult.IsRespin ? 1 : 0;
List <string> isFixedStrList = ListUtility.MapList(spinResult.IsFixedList, (bool b) => {
return(b ? "1" : "0");
});
string isFixedStr = string.Join(_delimiter, isFixedStrList.ToArray());
int isTriggerIndieGame = output._isTriggerIndieGame ? 1 : 0;
ulong indieGameWinAmount = output._indieGameWinAmount;
string indieGameCustomData = output._indieGameCustomData;
string result = string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15},{16}",
id, symbolNameStr, resultType, resultId, lucky, curCredit, consumedBetAmount, winRatio,
creditChange, remainCredit, luckyChange, remainLucky, isRespin, isFixedStr, isTriggerIndieGame,
indieGameWinAmount, indieGameCustomData);
return(result);
}
private MachineTestOutput ConstructOutput(MachineTestInput input, CoreSpinResult spinResult,
MachineTestIndieGameResult indieGameResult)
{
MachineTestOutput output = new MachineTestOutput();
output._spinResult = spinResult;
//when respin, not subtract
output._creditChange = (input._isRespin) ? 0 : -(int)input._betAmount;
if (spinResult.Type == SpinResultType.Win)
{
output._creditChange += (int)spinResult.WinAmount;
}
//consider indie game
if (indieGameResult != null)
{
output._creditChange += (long)indieGameResult._winAmount;
}
output._remainCredit = input._credit + output._creditChange;
output._luckyChange = _machine.LuckyManager.LongLuckyManager.GetSubtractLongLucky(spinResult);
output._remainLucky = input._lucky - output._luckyChange;
if (output._remainLucky < 0)
{
output._remainLucky = 0;
}
output._shouldRespin = _machine.ShouldRespin();
if (_machine.LastSmallGameState == SmallGameState.None && _machine.SmallGameState != SmallGameState.None)
{
output._isChangeToSpecialSmallGameState = true;
}
output._isPayProtection = input._isPayProtection;
if (indieGameResult != null)
{
output._isTriggerIndieGame = true;
output._indieGameWinAmount = indieGameResult._winAmount;
output._indieGameCustomData = indieGameResult._customData;
}
return(output);
}
private MachineTestUserResult RunSingleUserResult(CoreMachine machine, int userIndex, uint startSeed)
{
MachineTestUserResult userResult = new MachineTestUserResult(machine, userIndex, _config._spinCount, startSeed);
MachineTestIndieGameManager indieGameManager = new MachineTestIndieGameManager(machine);
MachineTestRound round = new MachineTestRound(machine, _config, indieGameManager);
MachineTestInput input = null;
MachineTestOutput output = null;
for (int i = 0; i < _config._spinCount; i++)
{
bool canRun = true;
do
{
input = round.ConstructInput(output);
canRun = round.CanRun(input);
if (canRun)
{
output = round.Run(input);
MachineTestRoundResult roundResult = new MachineTestRoundResult(input, output);
userResult.AddRoundResult(roundResult);
}
else
{
break;
}
} while(output._shouldRespin);
if (!canRun)
{
break;
}
}
return(userResult);
}
public MachineTestRoundResult(MachineTestInput input, MachineTestOutput output)
{
_input = input;
_output = output;
}
