[Feature Request] Other ways to monetize to help keep severs from feeling the need to add pay-to-win elements.

[DanielWillett]

I know it turned out really long but please read :)

I know how you feel about p2w, and selling items in general, but the truth is theres not a lot of non-invasive ways to make some ROI back hosting Unturned servers. I think p2w could be reduced some by adding more opportunities to monetize while keeping gameplay fair. I want to propose a full system for servers to offer purely cosmetic upgrades, mainly skins, to players without imposing any 'p2w' behavior. Since selling marketplace items is against the rules (understandably so), it would be nice to be able to create custom server-specific cosmetics in workshop mods.

Another thing that would help with finding other ways to monetize servers is allowing the server to update the name without rejoining. This has been an extremely popular request over the years, and wouldn't be too hard to implement. This is used in many servers to add chat tags, like [Rank #1], [Admin], [MVP], etc. To add on to this, allowing a plugin to change players' skin color, hair, and other customization features mid-game would allow for in-game stores, etc. Also custom faces and hair from masterbundle would be a welcome change. If possible custom stances but I know that would take a lot more work.

Another feature Rocket kind of started adding was player name colors. Player name colors could be fully made into a vanilla feature where the color is displayed everywhere the name is. This would only be something a plugin could change or maybe could change with an admin command but would act like the 'blue hammer' color and could also be updated mid-session.

I'd welcome more ideas for simple customization in this thread.

Summary:

• Pre-accept async event so we can actually query all this stuff from a database without freezing the server.
  • Even if you dont accept this propsal please add this event it makes querying player information with a database before they join (like moderation info) so much easier.
• Custom workshop skins (even mythics)
• The ability to turn off marketplace skins but still allow workshop skins to be displayed (see code).
• Changing name mid-session
• Changing skin color, hair, etc mid-session
• Set which faces the player can see on their radial UI.
• Custom face textures and hair/beard models from masterbundles. (this would probably require moving the vanilla ones to the core bundle)
• Adding 'player name color' which changes the color of the player's name everywhere it appears (except nametags probably).

Mid-session customization API

/* SteamPending.cs */

/// <summary>
/// Initial set of all non-marketplace skins the player has access to.
/// </summary>
public ConcurrentBag<Guid> AccessibleSkins { get; } = new ConcurrentBag<Guid>();
// why tf is ConcurrentBag<T> not ICollection<T>..., anyway it should be concurrent so stuff can be added from another thread after a database query

/// <summary>
/// Initial set of all faces the player has access to (to show on the UI).
/// </summary>
public ConcurrentBag<MasterBundleReference<Texture2D>> AccessibleFaces { get; } = new ConcurrentBag<MasterBundleReference<Texture2D>>
{
   new MasterBundleReference<Texture2D>("core.masterbundle", "../Faces/1/Texture.png"),
   .. etc
};



/* Player.cs (or some other player class) */
private readonly List<Guid> _accessibleSkins = new List<Guid>(/* initialized from SteamPending */);
private readonly List<MasterBundleReference<Texture2D>> _accessibleFaces = new List<MasterBundleReference<Texture2D>>(/* initialized from SteamPending */);

/// <summary>
/// List of all non-marketplace skins currently available to the player.
/// </summary>
public IReadOnlyList<Guid> AccessibleSkins { get; } = new ReadOnlyCollection<Guid>(_accessibleSkins);

/// <summary>
/// List of all faces the player has access to (to show on the UI).
/// </summary>
public IReadOnlyList<MasterBundleReference<Texture2D>> AccessibleFaces { get; } = new ReadOnlyCollection<MasterBundleReference<Texture2D>>(_accessibleFaces);

/// <summary>
/// Gives this player the ability to use custom workshop skins.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentException">Skin is on the marketplace, access can not be given.</exception>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
/// <returns><see langword="false"/> if the player already has access to the skin, otherwise <see langword="true"/>.</returns>
public bool GiveAccessToSkin(SkinAsset skin)
{
    ThreadUtil.assertIsGameThread();

    if (skin == null)
        throw new ArgumentNullException(nameof(skin));

    if (skin.IsOnMarketplace /* needs created (plz not internal) */) // the client would also run this check
        throw new ArgumentException("Can not give access for a marketplace skin.", nameof(skin));

    if (_accessibleSkins.Contains(skin.GUID))
        return false;

    _accessibleSkins.Add(skin.GUID);
    // call rpc to set skin access to true
    return true;
}

/// <summary>
/// Removes this player's ability to use custom workshop skins.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentException">Skin is on the marketplace, access can not be taken.</exception>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
/// <returns><see langword="false"/> if the player doesn't already have access to the skin, otherwise <see langword="true"/>.</returns>
public bool RevokeAccessToSkin(SkinAsset skin)
{
    ThreadUtil.assertIsGameThread();

    if (skin == null)
        throw new ArgumentNullException(nameof(skin));

    if (skin.IsOnMarketplace) // the client would also run this check
        throw new ArgumentException("Can not revoke access for a marketplace skin.", nameof(skin));

    int index = _accessibleSkins.IndexOf(skin.GUID);

    if (index == -1)
        return false;

    _accessibleSkins.RemoveAt(index);
    // call rpc to set skin access to false
    return true;
}

/// <summary>
/// Gives this player the ability to use a given face.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
/// <returns><see langword="false"/> if the player already has access to the face, otherwise <see langword="true"/>.</returns>
public bool GiveAccessToFace(MasterBundleReference<Texture2D> face)
{
    ThreadUtil.assertIsGameThread();

    // todo: add equality comparer to MasterBundleReference
    if (_accessibleFaces.Contains(face))
        return false;

    _accessibleSkins.Add(face);
    // call rpc to set face access to true
    return true;
}

/// <summary>
/// Removes this player's ability to use custom workshop skins.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
/// <returns><see langword="false"/> if the player doesn't already have access to the face, otherwise <see langword="true"/>.</returns>
public bool RevokeAccessToFace(MasterBundleReference<Texture2D> face)
{
    ThreadUtil.assertIsGameThread();

    int index = _accessibleFaces.IndexOf(face);

    if (index == -1)
        return false;

    _accessibleSkins.RemoveAt(index);
    // call rpc to set face access to false
    return true;
}

/* Also make all these public (without the RPC obv.) from SteamPlayer */

private string _nickName;

/// <summary>
/// The name players inside the user's group see.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentOutOfRangeException">Nick name length must be between 2 and 32 characters inclusively.</exception>
public string NickName
{
    get => _nickName;
    set
    {
        ThreadUtil.assertIsGameThread();
        if (value == null)
            throw new ArgumentNullException(nameof(value));

        if (value.Length > 32 || value.Length < 2) /* these def need a constant somewhere */
            throw new ArgumentOutOfRangeException(nameof(value), "Nick name length must be between 2 and 32 characters inclusively.");

        _nickName = value;
        // send nick name via RPC
    }
}

private string _characterName;

/// <summary>
/// The name players outside the user's group see.
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentOutOfRangeException">Character name length must be between 2 and 32 characters inclusively.</exception>
public string CharacterName
{
    get => _characterName;
    set
    {
        ThreadUtil.assertIsGameThread();
        if (value == null)
            throw new ArgumentNullException(nameof(value));

        if (value.Length > 32 || value.Length < 2)
            throw new ArgumentOutOfRangeException(nameof(value), "Character name length must be between 2 and 32 characters inclusively.");

        _characterName = value;
        // send character name via RPC
    }
}

private Color _nameColor;

/// <summary>
/// The player's name is displayed with this color everywhere in-game.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public Color NameColor
{
    get => _nameColor;
    set
    {
        ThreadUtil.assertIsGameThread();
        _nameColor = value;
        // send name color via RPC
    }
}

private Color _skinColor;

/// <summary>
/// The color of the player model's skin.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public Color SkinColor
{
    get => _skinColor;
    set
    {
        ThreadUtil.assertIsGameThread();
        _skinColor = value;
        // send skin color via RPC
    }
}

private Color _hairColor;

/// <summary>
/// The color of the player model's hair and beard.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public Color HairColor
{
    get => _hairColor;
    set
    {
        ThreadUtil.assertIsGameThread();
        _hairColor = value;
        // send hair color via RPC
    }
}

private Color _markerColor;

/// <summary>
/// The color of the player's marker on the map.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public Color MarkerColor
{
    get => _markerColor;
    set
    {
        ThreadUtil.assertIsGameThread();
        _markerColor = value;
        // send marker color via RPC
    }
}

private EPlayerSkillset _skillset;

/// <summary>
/// The player's skillset, affecting which skills are lost on death and their default values.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public EPlayerSkillset Skillset
{
    get => _skillset;
    set
    {
        ThreadUtil.assertIsGameThread();
        _skillset = value;
        // send skillset via RPC
    }
}

// maybe create a new enum or struct for face and beard
private MasterBundleReference<Texture2D> _face;

/// <summary>
/// Custom texture to use for the player's face.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public MasterBundleReference<Texture2D> Face
{
    get => _face;
    set
    {
        ThreadUtil.assertIsGameThread();
        _face = value;
        // send face via RPC
    }
}

private MasterBundleReference<GameObject> _beard;

/// <summary>
/// Custom model to use for the player's beard.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public MasterBundleReference<GameObject> Beard
{
    get => _beard;
    set
    {
        ThreadUtil.assertIsGameThread();
        _beard = value;
        // send beard via RPC
    }
}

private MasterBundleReference<GameObject> _hair;

/// <summary>
/// Custom model to use for the player's hair.
/// </summary>
/// <exception cref="NotSupportedException">Not on main thread.</exception>
public MasterBundleReference<GameObject> Hair
{
    get => _hair;
    set
    {
        ThreadUtil.assertIsGameThread();
        _hair = value;
        // send hair via RPC
    }
}


/* ServerConfigData */

public enum CosmeticVisibilityType
{
    All,
    Marketplace,
    Custom,
    None
}

[JsonConverter(typeof(StringEnumConverter))]
public CosmeticVisibilityType WeaponCosmeticType;

[JsonConverter(typeof(StringEnumConverter))]
public CosmeticVisibilityType VehicleCosmeticType;

[JsonConverter(typeof(StringEnumConverter))]
public CosmeticVisibilityType ClothingCosmeticType;

Async pre-accept event (please)

As a somewhat optional (but very much needed) part of this, I'd like to also propose an async event for before a player gets accepted which would run in the Provider.accept() method. This would allow plugin devs to query a database (among other things) on join for which skins they should have and not require the main thread be locked. Making a patch for this is not very fun, so having this officially supported would be great. If you really want to get fancy you could add a CancellationToken to the event which cancels if the player tries to cancel joining.
Basically this would be inserted after the player is removed from the pending list in Provider.accept function. A Tags property would also be added to SteamPending to allow easily transferring data from the on pending event to later on after they join.

/* SteamPending.cs */

/// <summary>
/// Allows plugins to add custom data to a pending steam player duing async loading.
/// </summary>
public IDictionary<string, object> Tags { get; } = new ConcurrentDictionary<string, object>();



/* Player.cs (or some other player class) */

/// <summary>
/// Allows plugins to add custom data to a pending steam player duing async loading.
/// </summary>
public IReadOnlyDictionary<string, object> Tags { get; }
    = new ReadOnlyDictionary<string, object>(new Dictionary<string, object>(/* pending tags from SteamPending */) );
      /* using a normal dictionary here since its faster than a concurrent and this'll only be readonly */      



/* Provider.cs */
/// <summary>
/// Handles <see cref="Provider.OnAcceptingPlayerAsync"/>.
/// </summary>
/// <param name="player">The player being accepted</param>
/// <returns><see langword="null"/> if the player should be accepted, otherwise the reason for denying the player.</returns>
public delegate Task<string> AcceptingPlayerAsync(SteamPending player);

/// <summary>
/// Invoked just before the player is accepted.
/// </summary>
public static event AcceptingPlayerAsync OnAcceptingPlayerAsync;

// originally replaces accept
internal static void StartAccept(SteamPending pending)
{
    // remove from pending list like it already does

    if (OnAcceptingPlayerAsync == null)
    {
        accept(pending);
        return;
    }

    // awaiting a Task-returning event doesn't work in C#, as only one of the tasks will actually be waited on
    // its also an option to not start them all at once,
    // but it was cleaner for the code sample to keep them starting on the main thread this way which would be more convenient for using the event
    Delegate[] listeners = OnAcceptingPlayerAsync.GetInvocationList();
    Task<string>[] tasks = new Task<string>[listeners.Length];
    for (int i = 0; i < listeners.Length; ++i)
    {
        AcceptingPlayerAsync listener = (AcceptingPlayerAsync)listeners[i];
        try
        {
            tasks[i] = listener.Invoke(pending);
        }
        catch (Exception ex)
        {
            CommandWindow.LogError($"Error invoking {listener.Method} for {nameof(OnAcceptingPlayerAsync)} from {listener.Method.DeclaringType?.Assembly.GetName().Name ?? "unknown assembly"}.");
            CommandWindow.LogError(ex);
        }
    }

    if (tasks.All(task => task.IsCompletedSuccessfully)) // none of the event handlers used async
    {
        accept(pending);
        return;
    }

    Task.Run(async () =>
    {
        string rejectionMessage = null;
        for (int i = 0; i < tasks.Length; ++i)
        {
            AcceptingPlayerAsync listener = (AcceptingPlayerAsync)listeners[i];
            try
            {
                string msg = await tasks[i];
                if (msg != null)
                {
                    // all tasks have already started so breaking now could break other taks or keep their errors from logging
                    rejectionMessage = msg;
                }
            }
            catch (Exception ex)
            {
                CommandWindow.LogError($"Error invoking {listener.Method} for {nameof(OnAcceptingPlayerAsync)} from {listener.Method.DeclaringType?.Assembly.GetName().Name ?? "unknown assembly"}.");
                CommandWindow.LogError(ex);
            }
        }

        GameThreadQueueUtil.QueueGameThreadWorkItem((object state) =>
        {
            string rejectReason = (string)state;
            SteamPending pendingPlayer = pending;
            if (rejectReason == null)
            {
                accept(pendingPlayer);
            }
            else
            {
                // looks like you'd have to add this since it's not in pending anymore, maybe could make a new reject method taking a SteamPending instead
                SteamGameServerInventory.DestroyResult(pendingPlayer.inventoryResult);
                pendingPlayer.inventoryResult = SteamInventoryResult_t.Invalid;

                reject(pendingPlayer.transportConnection, ESteamRejection.PLUGIN, rejectReason);
            }
        }, rejectionMessage);
    });
}

private static void accept(SteamPending pending)
{
    // sanity check
    ThreadUtil.assertIsGameThread();

    // the rest of the accept code
}

[tonislcs]

This is a really good feature request while running unturned servers is not cheap not at all when you have to consider finding good company with good location, good uptime and good ddos protection which is not cheap at all and only way to pay for such things is adding p2w elements things like having server skins would be really nice and would make people become creative while creating them for their community

[SDGNelson]

I do agree it would be useful to support waiting for an arbitrary number of background tasks before accepting a player. It's certainly on my wishlist and I'd convert the vanilla stuff to extend the same feature. (e.g., Steam authentication, inventory, groups).

[TeemoCell]

Really good features. Hope to see them soon :)

[liebesleid-eth]

atleast workshop skins ;-;-;-;-;