private bool SharedValidateCanCompleteTask(
IStaticWorldObject worldObject,
int taskIndex,
ICharacter character)
{
var privateState = GetPrivateState(worldObject);
var taskCompletionState = privateState.TaskCompletionState;
if (taskCompletionState[taskIndex])
{
Logger.Warning("Task already completed", character);
return(false);
}
if (InputItemsHelper.SharedPlayerHasRequiredItems(character,
this.TasksList[taskIndex].InputItems,
noCheckInCreativeMode: true))
{
return(true);
}
Logger.Warning("Not enough items to finish the task", character);
if (IsClient)
{
NotificationSystem.ClientShowNotification(
ConstructionSystem.NotificationNotEnoughItems_Message,
color: NotificationColor.Bad,
icon: this.Icon);
}
return(false);
}
private void ServerRemote_CompleteTask(IStaticWorldObject objectLaunchpad, int taskIndex)
{
this.VerifyGameObject(objectLaunchpad);
var character = ServerRemoteContext.Character;
if (!this.SharedCanInteract(character, objectLaunchpad, writeToLog: true))
{
return;
}
if (!this.SharedValidateCanCompleteTask(objectLaunchpad, taskIndex, character))
{
return;
}
// consume items
if (CreativeModeSystem.SharedIsInCreativeMode(character))
{
Logger.Important(character + " is in creative mode - no items deduction on task completion.");
}
else
{
InputItemsHelper.ServerDestroyItems(character, this.TasksList[taskIndex].InputItems);
}
var privateState = GetPrivateState(objectLaunchpad);
var taskCompletionState = privateState.TaskCompletionState;
taskCompletionState = taskCompletionState.ToArray();
taskCompletionState[taskIndex] = true;
privateState.TaskCompletionState = taskCompletionState;
Logger.Important(objectLaunchpad + " task completed: #" + taskIndex, character);
}
private void ServerRemote_BuildReactor(IStaticWorldObject worldObjectGenerator, byte reactorIndex)
{
this.VerifyGameObject(worldObjectGenerator);
var character = ServerRemoteContext.Character;
if (!this.SharedCanInteract(character, worldObjectGenerator, writeToLog: true))
{
return;
}
if (reactorIndex >= this.ReactorsCountMax)
{
throw new ArgumentOutOfRangeException(nameof(reactorIndex));
}
var privateState = GetPrivateState(worldObjectGenerator);
var publicState = GetPublicState(worldObjectGenerator);
var reactorPrivateStates = privateState.ReactorStates;
var reactorPrivateState = reactorPrivateStates[reactorIndex];
if (reactorPrivateState is not null)
{
throw new Exception($"The reactor is already built: #{reactorIndex} in {worldObjectGenerator}");
}
if (!InputItemsHelper.SharedPlayerHasRequiredItems(character,
this.BuildAdditionalReactorRequiredItems,
noCheckInCreativeMode: true))
{
throw new Exception($"Not enough items to build a reactor: #{reactorIndex} in {worldObjectGenerator}");
}
if (!CreativeModeSystem.SharedIsInCreativeMode(character))
{
InputItemsHelper.ServerDestroyItems(character, this.BuildAdditionalReactorRequiredItems);
}
reactorPrivateState = new ObjectGeneratorPragmiumReactorPrivateState();
reactorPrivateStates[reactorIndex] = reactorPrivateState;
this.ServerSetupReactorPrivateState(worldObjectGenerator, reactorPrivateState);
var reactorPublicStates = publicState.ReactorStates;
reactorPublicStates[reactorIndex] = new ObjectGeneratorPragmiumReactorPublicState();
// force refresh over the network and properly binding the state owner object
privateState.ReactorStates = reactorPrivateStates.ToArray();
publicState.ReactorStates = reactorPublicStates.ToArray();
}
public void ClientBuildReactor(IStaticWorldObject worldObjectGenerator, byte reactorIndex)
{
if (!InputItemsHelper.SharedPlayerHasRequiredItems(ClientCurrentCharacterHelper.Character,
this.BuildAdditionalReactorRequiredItems,
noCheckInCreativeMode: true))
{
NotificationSystem.ClientShowNotification(
ObjectTinkerTable.ErrorMessage_ComponentItemsRequried,
color: NotificationColor.Bad,
icon: this.Icon);
return;
}
this.CallServer(_ => _.ServerRemote_BuildReactor(worldObjectGenerator, reactorIndex));
}
private void ServerRemote_Repair()
{
var character = ServerRemoteContext.Character;
var tinkerTableObject =
InteractionCheckerSystem.SharedGetCurrentInteraction(character) as IStaticWorldObject;
this.VerifyGameObject(tinkerTableObject);
var worldObjectPrivateState = GetPrivateState(tinkerTableObject);
var containerInput = worldObjectPrivateState.ContainerInput;
var containerOutput = worldObjectPrivateState.ContainerOutput;
var inputItem1 = containerInput.GetItemAtSlot(0);
var inputItem2 = containerInput.GetItemAtSlot(1);
if (!ValidateCanRepair(character, tinkerTableObject, out var error))
{
Logger.Warning(tinkerTableObject + " cannot repair: " + error, character);
return;
}
if (!CreativeModeSystem.SharedIsInCreativeMode(character))
{
InputItemsHelper.ServerDestroyItems(character, RequiredRepairComponentItems);
}
var resultDurabilityFraction = SharedCalculateResultDurabilityFraction(inputItem1, inputItem2, character);
Server.Items.DestroyItem(inputItem2);
Server.Items.MoveOrSwapItem(inputItem1,
containerOutput,
out _);
var resultItemProto = (IProtoItemWithDurablity)inputItem1.ProtoGameObject;
var resultItemPrivateState = inputItem1.GetPrivateState <IItemWithDurabilityPrivateState>();
resultItemPrivateState.DurabilityCurrent = (uint)Math.Round(
resultDurabilityFraction * resultItemProto.DurabilityMax,
MidpointRounding.AwayFromZero);
character.ServerAddSkillExperience <SkillMaintenance>(
SkillMaintenance.ExperiencePerItemRepaired);
Logger.Info(
$"Item repaired: {inputItem1}. Second item was destroyed to use for repair components: {inputItem2}");
}
private void ServerRemote_Repair()
{
var character = ServerRemoteContext.Character;
var tinkerTableObject =
InteractionCheckerSystem.SharedGetCurrentInteraction(character) as IStaticWorldObject;
this.VerifyGameObject(tinkerTableObject);
var worldObjectPrivateState = GetPrivateState(tinkerTableObject);
var containerInput = worldObjectPrivateState.ContainerInput;
var containerOutput = worldObjectPrivateState.ContainerOutput;
var inputItem1 = containerInput.GetItemAtSlot(0);
var inputItem2 = containerInput.GetItemAtSlot(1);
if (!ValidateCanRepair(character, tinkerTableObject, out var error))
{
Logger.Warning(tinkerTableObject + " cannot repair: " + error, character);
return;
}
if (!CreativeModeSystem.SharedIsInCreativeMode(character))
{
InputItemsHelper.ServerDestroyItems(character, RequiredRepairComponentItems);
}
var resultItemProto = (IProtoItemWithDurability)inputItem1.ProtoGameObject;
var resultDurabilityFraction = SharedCalculateResultDurabilityFraction(inputItem1, inputItem2, character);
// break the second input item (it will force spawning ammo in this slot if it's a loaded weapon)
ItemDurabilitySystem.ServerModifyDurability(inputItem2,
-(double)resultItemProto.DurabilityMax,
roundUp: false);
if (!inputItem2.IsDestroyed)
{
// ensure the second input item is destroyed
Server.Items.DestroyItem(inputItem2);
}
Server.Items.MoveOrSwapItem(inputItem1,
containerOutput,
out _);
var resultItemPrivateState = inputItem1.GetPrivateState <IItemWithDurabilityPrivateState>();
if (resultDurabilityFraction < 1 &&
character.SharedHasSkillFlag(SkillMaintenance.Flags.ChanceToRepairCompletely) &&
RandomHelper.RollWithProbability(0.05))
{
// 5% chance to repair item completely rolled successfully
resultDurabilityFraction = 1;
this.CallClient(character,
_ => _.ClientRemote_ItemRepairedCompletely(inputItem1.ProtoItem));
}
resultItemPrivateState.DurabilityCurrent = (uint)Math.Round(
resultDurabilityFraction * resultItemProto.DurabilityMax,
MidpointRounding.AwayFromZero);
character.ServerAddSkillExperience <SkillMaintenance>(
SkillMaintenance.ExperiencePerItemRepaired);
Logger.Info(
$"Item repaired: {inputItem1}. Second item was destroyed to use for repair components: {inputItem2}");
}
