private void OnPlayerRespawn(UnturnedPlayer rocketPlayer, Vector3 vect, byte angle)
{
var player = UPlayer.From(rocketPlayer);
var skillsToRestore = player.Metadata.GetOrDefault <Dictionary <USkill, byte> >("KEEP_SKILL", null);
if (skillsToRestore != null)
{
foreach (var pair in skillsToRestore)
{
player.SetSkillLevel(pair.Key, pair.Value);
}
skillsToRestore.Clear();
}
}
private void HomePlayerMove(UnturnedPlayer player, Vector3 newPosition)
{
if (!UEssentials.Config.Home.CancelTeleportWhenMove || !CommandHome.Delay.ContainsKey(player.CSteamID.m_SteamID))
{
return;
}
CommandHome.Delay[player.CSteamID.m_SteamID].Cancel();
CommandHome.Delay.Remove(player.CSteamID.m_SteamID);
UPlayer.TryGet(player, p => {
EssLang.Send(p, "TELEPORT_CANCELLED_MOVED");
});
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
switch (args.Length)
{
case 1:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
DropKit(src, args[0], src.ToPlayer().Position);
EssLang.Send(src, "DROPKIT_SENDER", args[0]);
break;
case 2:
if (!src.HasPermission($"{Permission}.other"))
{
return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
}
if (!UPlayer.TryGet(args[1].ToString(), out var player))
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[1]));
}
DropKit(src, args[0], player.Position);
EssLang.Send(src, "DROPKIT_PLAYER", args[0], player.DisplayName);
break;
case 4:
var pos = args.GetVector3(1);
if (pos.HasValue)
{
DropKit(src, args[0], pos.Value);
EssLang.Send(src, "DROPKIT_LOCATION", args[1], args[2], args[3]);
}
else
{
return(CommandResult.LangError("INVALID_COORDS", args[1], args[2], args[3]));
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
void OnPlayerRespawn(UnturnedPlayer player, Vector3 vect, byte angle)
{
var playerId = player.CSteamID.m_SteamID;
if (!CachedSkills.ContainsKey(playerId))
{
return;
}
var uplayer = UPlayer.From(playerId);
CachedSkills[playerId].ForEach(pair => {
uplayer.SetSkillLevel(pair.Key, pair.Value);
});
}
public override bool GiveTo(UPlayer player, bool dropIfInventoryFull = true)
{
var added = false;
var item = UnturnedItem;
for (var i = 0; i < Amount; i++)
{
added = player.Inventory.tryAddItem(item, true);
if (!added && dropIfInventoryFull)
{
ItemManager.dropItem(item, player.Position, true, Dedicator.isDedicated, true);
}
}
return(added);
}
public override bool GiveTo( UPlayer player, bool dropIfInventoryFull = true )
{
var added = false;
var item = UnturnedItem;
for ( var i = 0; i < Amount; i++ )
{
added = player.Inventory.tryAddItem( item, true );
if ( !added && dropIfInventoryFull )
{
ItemManager.dropItem( item, player.Position, true, Dedicator.isDedicated, true );
}
}
return added;
}
// Start is called before the first frame update
void Start()
{
// 플레이어 컴포넌트 설정
_player = gameObject.GetComponent <UPlayer>();
// 플레이어 애니메이션 컴포넌트 설정
_playerAnimation = gameObject.GetComponent <PlayerAnimation>();
// 로컬 플레이어인지 체크
if (!photonView.IsMine)
{
return;
}
// 조이스틱 초기화
JoyStickInitialize();
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.Length < 2)
{
return(CommandResult.ShowUsage());
}
var target = args[0].ToPlayer;
if (target == null)
{
return(CommandResult.Lang(EssLang.PLAYER_NOT_FOUND, args[0]));
}
var rawMsg1 = UEssentials.Config.PrivateMessageFormat;
var rawMsg2 = UEssentials.Config.PrivateMessageFormat2;
var color1 = ColorUtil.GetColorFromString(ref rawMsg1);
var color2 = ColorUtil.GetColorFromString(ref rawMsg2);
var message = string.Format(rawMsg1, src.DisplayName, args.Join(1));
var message2 = string.Format(rawMsg2, target.DisplayName, args.Join(1));
target.SendMessage(message, color1);
src.SendMessage(message2, color2);
Spies.ForEach(p => {
UPlayer.From(p).SendMessage($"Spy: ({src.DisplayName} -> " +
$"{target.CharacterName}): {args.Join( 1 )}", Color.gray);
});
if (Conversations.ContainsKey(src.DisplayName))
{
if (!Conversations[src.DisplayName].Equals(target.DisplayName))
{
Conversations[src.DisplayName] = target.CharacterName;
}
}
else
{
Conversations.Add(src.DisplayName, target.DisplayName);
}
return(CommandResult.Success());
}
/// <summary>
/// Give this kit to player
/// </summary>
public void GiveTo(UPlayer player)
{
var onetime = false;
foreach (var kitItem in Items)
{
var added = kitItem.GiveTo(player);
if (added || onetime)
{
continue;
}
EssLang.Send(player, "INVENTORY_FULL"); // TODO: Remove msgs
onetime = true;
}
EssLang.Send(player, "KIT_GIVEN_RECEIVER", Name);
}
/// <summary>
/// Give this kit to player
/// </summary>
public void GiveTo(UPlayer player)
{
var sentInventoryFullMessage = false;
foreach (var kitItem in Items)
{
var added = kitItem.GiveTo(player);
if (added || sentInventoryFullMessage)
{
continue;
}
EssLang.Send(player, "INVENTORY_FULL");
sentInventoryFullMessage = true;
}
EssLang.Send(player, "KIT_GIVEN_RECEIVER", Name);
}
void UpdateAlert(UnturnedPlayer player)
{
if (!player.IsAdmin || lastUpdateCheck > DateTime.Now)
{
return;
}
var updater = EssCore.Instance.Updater;
if (!updater.IsUpdated())
{
lastUpdateCheck = DateTime.Now.AddMinutes(10);
Tasks.New(t => {
UPlayer.From(player).SendMessage("[uEssentials] New version avalaible " +
$"{updater.LastResult.LatestVersion}!", Color.cyan);
}).Delay(1000).Go();
}
}
/// <summary>
/// Give this kit to player
/// </summary>
public void GiveTo(UPlayer player)
{
var onetime = false;
foreach (var kitItem in Items)
{
var added = kitItem.GiveTo(player);
if (added || onetime)
{
continue;
}
EssLang.INVENTORY_FULL.SendTo(player);
onetime = true;
}
EssLang.KIT_GIVEN_RECEIVER.SendTo(player, Name);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.Length == 0)
{
return(CommandResult.ShowUsage());
}
if (args[0].Is("*"))
{
foreach (var player in UServer.Players.Where(player => player.HasComponent <FrozenPlayer>()))
{
player.RemoveComponent <FrozenPlayer>();
EssLang.UNFROZEN_PLAYER.SendTo(player, src.DisplayName);
}
EssLang.UNFROZEN_ALL.SendTo(src);
}
else
{
var target = UPlayer.From(args[0].ToString());
if (target == null)
{
return(CommandResult.Lang(EssLang.PLAYER_NOT_FOUND, args[0]));
}
if (!target.HasComponent <FrozenPlayer>())
{
return(CommandResult.Lang(EssLang.NOT_FROZEN, target.DisplayName));
}
else
{
target.RemoveComponent <FrozenPlayer>();
EssLang.UNFROZEN_SENDER.SendTo(src, target.DisplayName);
EssLang.UNFROZEN_PLAYER.SendTo(target, src.DisplayName);
}
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var playerId = src.ToPlayer().CSteamId.m_SteamID;
if (!ReplyTo.TryGetValue(playerId, out var targetId))
{
return(CommandResult.LangError("NOBODY_TO_REPLY"));
}
var target = UPlayer.From(targetId);
if (target == null)
{
return(CommandResult.LangError("NO_LONGER_ONLINE"));
}
src.DispatchCommand($"tell \"{target.DisplayName}\" \"{args.Join(0)}\"");
return(CommandResult.Success());
}
private void DeathMessages(UnturnedPlayer player, EDeathCause cause, ELimb limb, CSteamID killer)
{
if (!(EssLang.GetEntry($"DEATH_{cause}") is string message))
{
return;
}
var hasKiller = killer != CSteamID.Nil;
var arguments = new object[hasKiller ? 3 : 2];
var color = ColorUtil.GetColorFromString(ref message);
arguments[0] = player.CharacterName;
arguments[1] = EssLang.Translate($"LIMB_{limb}") ?? "?";
if (hasKiller)
{
arguments[2] = UPlayer.From(killer)?.CharacterName ?? "?";
}
UServer.Broadcast(string.Format(message, arguments), color);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.Length == 0)
{
return(CommandResult.ShowUsage());
}
if (args[0].Is("*"))
{
UServer.Players
.Where(player => !player.HasComponent <FrozenPlayer>())
.ForEach(player => {
player.AddComponent <FrozenPlayer>();
EssLang.FROZEN_PLAYER.SendTo(player, src.DisplayName);
});
EssLang.FROZEN_ALL.SendTo(src);
}
else
{
var found = UPlayer.TryGet(args[0], player => {
if (player.HasComponent <FrozenPlayer>())
{
EssLang.ALREADY_FROZEN.SendTo(src, player.DisplayName);
}
else
{
player.AddComponent <FrozenPlayer>();
EssLang.FROZEN_SENDER.SendTo(src, player.DisplayName);
EssLang.FROZEN_PLAYER.SendTo(player, src.DisplayName);
}
});
if (!found)
{
return(CommandResult.Lang(EssLang.PLAYER_NOT_FOUND, args[0]));
}
}
return(CommandResult.Success());
}
private decimal GetCommandCost(CommandOptions.CommandEntry commandOptions, UPlayer player)
{
var cost = commandOptions.Cost;
if (commandOptions.PerGroupCost != null)
{
R.Permissions.GetGroups(player.RocketPlayer, false)
.OrderBy(g => - g.Priority)
.FirstOrDefault(g => {
// Check if there is a cost specified to the player's group.
var result = commandOptions.PerGroupCost.TryGetValue(g.Id, out var groupCost);
// If there is, use that cost
if (result)
{
cost = groupCost;
}
return(result);
});
}
return(cost);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var target = args[0].ToPlayer;
if (target == null)
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
var pmSettings = UEssentials.Config.PrivateMessage;
var formatFrom = pmSettings.FormatFrom;
var formatTo = pmSettings.FormatTo;
var formatSpy = pmSettings.FormatSpy;
var formatFromColor = ColorUtil.GetColorFromString(ref formatFrom);
var formatToColor = ColorUtil.GetColorFromString(ref formatTo);
var formatSpyColor = ColorUtil.GetColorFromString(ref formatSpy);
var targetName = target.DisplayName;
var srcName = src.IsConsole ? pmSettings.ConsoleDisplayName : src.DisplayName;
formatFrom = string.Format(formatFrom, srcName, args.Join(1));
formatTo = string.Format(formatTo, targetName, args.Join(1));
formatSpy = string.Format(formatSpy, srcName, targetName, args.Join(1));
target.SendMessage(formatFrom, formatFromColor);
src.SendMessage(formatTo, formatToColor);
Spies.ForEach(p => {
UPlayer.From(p).SendMessage(formatSpy, formatSpyColor);
});
if (!src.IsConsole)
{
ReplyTo[target.CSteamId.m_SteamID] = src.ToPlayer().CSteamId.m_SteamID;
}
return(CommandResult.Success());
}
private void GiveExp(UPlayer player, int amount)
{
var playerExp = player.UnturnedPlayer.skills.experience;
if (amount < 0)
{
if ((playerExp - amount) < 0)
{
playerExp = 0;
}
else
{
playerExp += (uint)amount;
}
}
else
{
if ((playerExp + amount) > int.MaxValue)
{
playerExp = int.MaxValue;
}
else
{
playerExp += (uint)amount;
}
}
if (amount >= 0)
{
EssLang.Send(player, "EXPERIENCE_RECEIVED", amount);
}
else
{
EssLang.Send(player, "EXPERIENCE_LOST", -amount);
}
player.Experience = playerExp;
}
/**
* @brief 캐릭터가 죽을 시 리스폰을 하는 코루틴 입니다.
*
* @param playerObject 리스폰 시킬 플레이어 게임오브젝트
* @param _teamInfo 리스폰 시킬 플레이어의 팀 정보
*/
IEnumerator CouroutinRespawn(GameObject playerObject, ETeamInfo _teamInfo)
{
// 플레이어 오브젝트가 없다면 코루틴 종료
if (!playerObject)
{
Debug.LogError("Have not Player Information");
yield break;
}
// 캐릭터를 잠시 비활성화 시킴
playerObject.SetActive(false);
// 설정된 리스폰 딜레이 시간만큼 기다림
yield return(new WaitForSeconds(respawnDelay));
// 플레이어 오브젝트의 최상위 부모를 가져옴
Transform playerTransform = playerObject.transform;
// 위치를 스타팅 지점으로 초기화
playerTransform.position = startingList[(int)_teamInfo].position;
// 캐릭터 회전값 초기화
playerTransform.forward = startingList[(int)_teamInfo].forward;
// 플레이어 컴포넌트를 가져옴
UPlayer _playerComponent = playerObject.GetComponent <UPlayer>();
if (_playerComponent)
{
// 플레이어의 체력 등 필요한 정보를 초기화
_playerComponent.Initialize();
}
// 리스폰 시간이 지났다면 다시 활성화
playerObject.SetActive(true);
yield break;
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args[0].Equals("*"))
{
UServer.Players
.Where(player => !player.HasComponent <FrozenPlayer>())
.ForEach(player => {
player.AddComponent <FrozenPlayer>();
EssLang.Send(player, "FROZEN_PLAYER", src.DisplayName);
});
EssLang.Send(src, "FROZEN_ALL");
}
else
{
var found = UPlayer.TryGet(args[0], player => {
if (player.HasComponent <FrozenPlayer>())
{
EssLang.Send(src, "ALREADY_FROZEN", player.DisplayName);
}
else
{
player.AddComponent <FrozenPlayer>();
EssLang.Send(src, "FROZEN_SENDER", player.DisplayName);
EssLang.Send(player, "FROZEN_PLAYER", src.DisplayName);
}
});
if (!found)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
}
return(CommandResult.Success());
}
private void OnTriggerStay(Collider other)
{
// 로컬플레이어가 아니라면 함수 종료
if (!photonView.IsMine)
{
return;
}
// 플레이어만 감지 함
if (other.tag != TAG_PLAYER)
{
return;
}
// 현재 감지된 플레이어의 정보를 가져옴
UPlayer target = other.gameObject.GetComponentInChildren <UPlayer>();
// 감지된 플레이어가 같은 팀이라면 함수 종료
if (_playerState.teamInfo == target.GetData().teamInfo)
{
return;
}
// 감지된 오브젝트로 바라보는 방향벡터를 구함
Vector3 direction = (other.transform.position) - (transform.position);
transform.forward = direction.normalized;
// 코루틴이 실행 중이 아니라면
if (!isRunning)
{
isRunning = true;
// 공격 시작
CannonAttack(other.transform.position);
}
}
public bool Has(UPlayer player, decimal amount)
{
return((player.Experience - amount) >= 0);
}
public decimal GetBalance(UPlayer player)
{
return(player.Experience);
}
public bool Is( UPlayer other )
{
if ( !IsValidPlayerName )
return false;
return ToPlayer == other;
}
public override bool GiveTo(UPlayer player, bool dropIfInventoryFull = true)
{
UEssentials.EconomyProvider.IfPresent(h => h.Deposit(player, Amount));
return(true);
}
private static void GiveItem( ICommandSource src, UPlayer target, ICommandArgument itemArg,
ICommandArgument amountArg, bool allPlayers = false )
{
ItemAsset asset;
if ( itemArg.IsUshort )
{
var id = itemArg.ToUshort;
asset = (ItemAsset) Assets.find( EAssetType.ITEM, id );
}
else
{
asset = UnturnedItems.GetItemAssetByName( itemArg.ToLowerString );
}
if ( asset == null )
{
src.SendMessage( $"Could not find an item with this name or id: {itemArg}" );
return;
}
ushort amt = 1;
if ( amountArg != null )
{
if ( !amountArg.IsShort )
{
EssLang.INVALID_NUMBER.SendTo( src, amountArg );
}
else if ( amountArg.ToUshort <= 0 )
{
EssLang.MUST_POSITIVE.SendTo( src );
}
else
{
amt = amountArg.ToUshort;
goto give;
}
return;
}
give:
var playersToReceive = new List<UPlayer>();
var item = new Item( asset.id, true );
if ( allPlayers )
{
UServer.Players.ForEach( playersToReceive.Add );
EssLang.GIVEN_ITEM_ALL.SendTo( src, amt, asset.Name );
}
else
{
playersToReceive.Add( target );
if ( !src.IsConsole && src.ToPlayer() != target )
{
EssLang.GIVEN_ITEM.SendTo( src, amt, asset.Name, target.CharacterName );
}
}
playersToReceive.ForEach( p =>
{
var success = p.GiveItem( item, amt, true );
EssLang.RECEIVED_ITEM.SendTo( p, amt, asset.Name );
if ( !success )
{
EssLang.INVENTORY_FULL.SendTo( p );
}
} );
}
public RaycastInfo TraceRay(UPlayer player, float distance, int masks)
{
return(DamageTool.raycast(new Ray(player.Look.aim.position, player.Look.aim.forward), distance, masks));
}
/// <summary>
/// Give this item to an specified player
/// </summary>
/// <param name="player"> player that you should give this item </param>
/// <param name="dropIfInventoryFull"> determine if this item should be dropped
/// on ground if inventory is full </param>
/// <returns> False if could not be added(full inventory) otherwise true </returns>
public virtual bool GiveTo( UPlayer player, bool dropIfInventoryFull = true )
{
return player.GiveItem( UnturnedItem, dropIfInventoryFull );
}
/// <summary>
/// Give this item to an specified player
/// </summary>
/// <param name="player"> player that you should give this item </param>
/// <param name="dropIfInventoryFull"> determine if this item should be dropped
/// on ground if inventory is full </param>
/// <returns> False if could not be added(full inventory) otherwise true </returns>
public override bool GiveTo(UPlayer player, bool dropIfInventoryFull = true)
{
return(player.GiveItem(UnturnedItem, dropIfInventoryFull));
}
protected PlayerComponent()
{
Player = UPlayer.From( GetComponent<SDG.Unturned.Player>() );
}
public override void Execute(ICommandContext context)
{
if (args.Length == 0 || (args.Length == 1 && src.IsConsole))
{
return(CommandResult.ShowUsage());
}
if (args.Length == 1)
{
var player = src.ToPlayer();
var kitName = args[0].ToLowerString;
if (!KitModule.Instance.KitManager.Contains(kitName))
{
return(CommandResult.LangError("KIT_NOT_EXIST", kitName));
}
var requestedKit = KitModule.Instance.KitManager.GetByName(kitName);
if (!requestedKit.CanUse(player))
{
return(CommandResult.LangError("KIT_NO_PERMISSION"));
}
var steamPlayerId = player.CSteamId.m_SteamID;
var kitCost = requestedKit.Cost;
if (
kitCost > 0 &&
UEssentials.EconomyProvider.IsPresent &&
!src.HasPermission("essentials.bypass.kitcost")
)
{
var ecoProvider = UEssentials.EconomyProvider.Value;
if (!ecoProvider.Has(player, kitCost))
{
return(CommandResult.LangError("KIT_NO_MONEY", kitCost, ecoProvider.CurrencySymbol));
}
}
var globalCooldown = EssCore.Instance.Config.Kit.GlobalCooldown;
var kitCooldown = requestedKit.Cooldown;
if (!src.HasPermission("essentials.bypass.kitcooldown"))
{
// Check if is on global cooldown
if (globalCooldown > 0 && GlobalCooldown.ContainsKey(steamPlayerId))
{
var remainingTime = DateTime.Now - GlobalCooldown[steamPlayerId];
if ((remainingTime.TotalSeconds + 1) < globalCooldown)
{
return(CommandResult.LangError("KIT_GLOBAL_COOLDOWN",
TimeUtil.FormatSeconds((uint)(globalCooldown - remainingTime.TotalSeconds))));
}
}
// Check if is on cooldown for this specific kit
if (kitCooldown > 0)
{
if (!Cooldowns.TryGetValue(steamPlayerId, out var playerCooldowns) || playerCooldowns == null)
{
Cooldowns[steamPlayerId] = playerCooldowns = new Dictionary <string, DateTime>();
}
if (playerCooldowns.TryGetValue(kitName, out var lastTimeUsedThisKit))
{
var remainingTime = DateTime.Now - lastTimeUsedThisKit;
if ((remainingTime.TotalSeconds + 1) < kitCooldown)
{
return(CommandResult.LangError("KIT_COOLDOWN", TimeUtil.FormatSeconds(
(uint)(kitCooldown - remainingTime.TotalSeconds))));
}
}
}
}
if (kitCost > 0 && !src.HasPermission("essentials.bypass.kitcost"))
{
UEssentials.EconomyProvider.IfPresent(ec =>
{
ec.Withdraw(player, kitCost);
EssLang.Send(player, "KIT_PAID", kitCost, ec.CurrencySymbol);
});
}
requestedKit.GiveTo(player);
// Only apply the cooldowns if the player received the kit
// and does not have the bypass permission.
if (!src.HasPermission("essentials.bypass.kitcooldown"))
{
if (globalCooldown > 0)
{
GlobalCooldown[steamPlayerId] = DateTime.Now;
}
if (kitCooldown > 0)
{
Cooldowns[steamPlayerId][kitName] = DateTime.Now;
}
}
}
else if (args.Length == 2)
{
var kitName = args[0].ToLowerString;
if (!src.HasPermission($"essentials.kit.{kitName}.other"))
{
return(CommandResult.NoPermission($"essentials.kit.{kitName}.other"));
}
if (!KitModule.Instance.KitManager.Contains(kitName))
{
return(CommandResult.LangError("KIT_NOT_EXIST", kitName));
}
var kit = KitModule.Instance.KitManager.GetByName(kitName);
if (args[1].Equals("*"))
{
UServer.Players.ForEach(kit.GiveTo);
context.User.SendLocalizedMessage(Translations, "KIT_GIVEN_SENDER_ALL", kitName);
}
else
{
if (!UPlayer.TryGet(args[1].ToString(), out var target))
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[1]));
}
kit.GiveTo(target);
context.User.SendLocalizedMessage(Translations, "KIT_GIVEN_SENDER", kitName, target);
}
}
return(CommandResult.Success());
}
private void GenericPlayerDeath(UnturnedPlayer rocketPlayer, EDeathCause cause, ELimb limb, CSteamID murderer)
{
const string METADATA_KEY = "KEEP_SKILL";
const string KEEP_SKILL_PERM = "essentials.keepskill.";
var player = UPlayer.From(rocketPlayer);
var allPercentage = -1; // essentials.keepskill.all.<percentage>
// Save skills in metadata, that will be restored when player respawn.
// Format: Skill -> NewValue
// Get or instantiate new Dictionary
Dictionary <USkill, byte> skillsToRestore;
if (player.Metadata.Has(METADATA_KEY))
{
skillsToRestore = player.Metadata.Get <Dictionary <USkill, byte> >(METADATA_KEY);
}
else
{
skillsToRestore = new Dictionary <USkill, byte>();
player.Metadata[METADATA_KEY] = skillsToRestore;
}
// Parse keepskill permissions
foreach (var perm in player.Permissions.Where(perm => perm.StartsWith(KEEP_SKILL_PERM)))
{
var kind = perm.Substring(KEEP_SKILL_PERM.Length);
var keepPercentage = 100;
if (string.IsNullOrEmpty(kind))
{
continue;
}
// Parse percentage, if present.
// e.g 'essentials.keepskill.cardio.25' -> keepPercentage = 25
if (kind.IndexOf('.') >= 0)
{
// Split 'skill.percentage'
var parts = kind.Split('.');
if (!int.TryParse(parts[1], out keepPercentage))
{
continue;
}
// Percentage must be between 0-100
if (keepPercentage < 0)
{
keepPercentage = 0;
}
if (keepPercentage > 100)
{
keepPercentage = 100;
}
kind = parts[0]; // let only skill name
}
if (kind.EqualsIgnoreCase("all"))
{
allPercentage = keepPercentage;
continue;
}
// Parse skill from name
var fromName = USkill.FromName(kind);
if (fromName.IsAbsent)
{
continue;
}
skillsToRestore[fromName.Value] = (byte)Math.Ceiling(player.GetSkillLevel(fromName.Value) * (keepPercentage / 100.0));
}
// All Skills
if (allPercentage != -1)
{
foreach (var skill in USkill.Skills)
{
// We wanna not change previously added skills.
// This will allow to set a separated percentage while using modifier 'all' (essentials.keepskill.all)
// e.g
// essentials.keepskill.all.50
// essentials.keepskill.cardio.100
// this will keep 50% of all skills and 100% of cardio skill
if (skillsToRestore.ContainsKey(skill))
{
continue;
}
var newValue = Math.Ceiling(player.GetSkillLevel(skill) * (allPercentage / 100.0));
skillsToRestore[skill] = (byte)newValue;
}
}
}
public override bool GiveTo(UPlayer player, bool dropIfInventoryFull = true)
{
VehicleTool.giveVehicle(player.UnturnedPlayer, Id);
return(true);
}
protected PlayerComponent()
{
Player = UPlayer.From(GetComponent <SDG.Unturned.Player>());
}
/// <summary>
/// Give this kit to player
/// </summary>
public void GiveTo( UPlayer player )
{
var onetime = false;
foreach ( var kitItem in Items )
{
var added = kitItem.GiveTo( player );
if ( added || onetime ) continue;
EssLang.INVENTORY_FULL.SendTo( player );
onetime = true;
}
EssLang.KIT_GIVEN_RECEIVER.SendTo( player, Name );
}
