Steam Class Reference

Inheritance diagram for Steam:

Public Member Functions
void	Init ()
void	CheckUpdate ()
void	CheckDLC ()
void	TestHasDLC ()
void	CreateUserContent (BaseModPackage p)
void	UpdateUserContent (PublishedFileId_t fileId)
WorkshopItemData	CreateItemData (BaseModPackage p)

Static Public Member Functions
static bool	HasDLC (ID_DLC id)
static void	GetAchievement (ID_Achievement id)
static void	ResetAllAchievement ()
static void	ResetAchievement (ID_Achievement id)
static void	QueryAllMyPublished (Action< List< WorkshopItem > > onComplete, Action< string > onFail=null, float timeout=10f)

Public Attributes
SteamworksBehaviour	steamworks
UserGeneratedContentQueryManager	ugc
WorkshopItem	testData
BaseModPackage	currentPackage

Static Public Attributes
static Steam	Instance

Private Member Functions
void	Awake ()
void	CreateOrUpdateUserContent (List< WorkshopItem > items)

Detailed Description

Definition at line 11 of file Steam.cs.

Member Function Documentation

Awake()

void Steam.Awake ( )

inlineprivate

Definition at line 23 of file Steam.cs.

    {
        Instance = this;
    }

References Instance.

CheckDLC()

void Steam.CheckDLC ( )

inline

Definition at line 38 of file Steam.cs.

    {
        Debug.Log(HasDLC(ID_DLC.Test));
    }

References Debug, and HasDLC().

CheckUpdate()

void Steam.CheckUpdate ( )

inline

Definition at line 34 of file Steam.cs.

    {
    }

Referenced by CoreDebug.UpdateInput().

CreateItemData()

WorkshopItemData Steam.CreateItemData ( BaseModPackage  p )

inline

Definition at line 279 of file Steam.cs.

    {
        FileInfo fileInfo = new FileInfo(p.dirInfo.FullName + "/preview.jpg");
        DirectoryInfo directoryInfo = new DirectoryInfo(p.dirInfo.FullName);
        WorkshopItemData result = new WorkshopItemData
        {
            appId = steamworks.settings.applicationId,
            title = p.title,
            description = p.description,
            content = directoryInfo,
            preview = fileInfo,
            metadata = (p.id ?? ""),
            tags = p.tags,
            visibility = ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic
        };
        switch (p.visibility)
        {
        case "Unlisted":
            result.visibility = ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityUnlisted;
            break;
        case "Private":
            result.visibility = ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPrivate;
            break;
        case "FriendsOnly":
            result.visibility = ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityFriendsOnly;
            break;
        }
        Debug.Log(App.Client.Owner.id);
        Debug.Log(result.appId);
        Debug.Log(p.id);
        Debug.Log(directoryInfo.Exists + "/" + directoryInfo.FullName);
        Debug.Log(fileInfo.Exists + "/" + fileInfo.FullName);
        return result;
    }

References Debug, BaseModPackage.description, BaseModPackage.dirInfo, BaseModPackage.id, steamworks, BaseModPackage.tags, BaseModPackage.title, title, and BaseModPackage.visibility.

Referenced by CreateOrUpdateUserContent(), and UpdateUserContent().

CreateOrUpdateUserContent()

void Steam.CreateOrUpdateUserContent ( List< WorkshopItem >  items )

inlineprivate

Definition at line 208 of file Steam.cs.

    {
        Debug.Log("Creating Content2");
        BaseModPackage baseModPackage = currentPackage;
        Debug.Log(items.Count);
        foreach (WorkshopItem item in items)
        {
            if (item.keyValueTags.IsEmpty())
            {
                continue;
            }
            StringKeyValuePair[] keyValueTags = item.keyValueTags;
            for (int i = 0; i < keyValueTags.Length; i++)
            {
                StringKeyValuePair stringKeyValuePair = keyValueTags[i];
                if (stringKeyValuePair.key == "id" && stringKeyValuePair.value == baseModPackage.id && item.Owner.IsMe)
                {
                    Debug.Log("Updating Content");
                    UpdateUserContent(item.FileId);
                    return;
                }
            }
        }
        Debug.Log("Creating Content");
        CreateItemData(baseModPackage).Create(null, null, new WorkshopItemKeyValueTag[1]
        {
            new WorkshopItemKeyValueTag
            {
                key = "id",
                value = baseModPackage.id
            }
        }, delegate(WorkshopItemDataCreateStatus result)
        {
            LayerProgress.completed = true;
            if (result.hasError)
            {
                Dialog.Ok("mod_publish_error");
                EClass.ui.Say(result.errorMessage);
                Debug.Log("error:" + result.errorMessage);
            }
            else
            {
                Dialog.Ok("mod_created");
                Debug.Log("created");
            }
        });
    }

References CreateItemData(), currentPackage, Debug, item, Dialog.Ok(), EClass.ui, and UpdateUserContent().

Referenced by CreateUserContent().

CreateUserContent()

void Steam.CreateUserContent ( BaseModPackage  p )

inline

Definition at line 117 of file Steam.cs.

    {
        LayerProgress.Start("Uploading").onCancel = delegate
        {
        };
        p.UpdateMeta(updateOnly: true);
        currentPackage = p;
        QueryAllMyPublished(CreateOrUpdateUserContent, delegate(string error)
        {
            LayerProgress.completed = true;
            Debug.LogError(error);
            Dialog.Ok("mod_publish_error");
        });
    }

References CreateOrUpdateUserContent(), currentPackage, Debug, Dialog.Ok(), LayerProgress.onCancel, QueryAllMyPublished(), LayerProgress.Start(), and BaseModPackage.UpdateMeta().

GetAchievement()

static void Steam.GetAchievement ( ID_Achievement  id )

inlinestatic

Definition at line 53 of file Steam.cs.

    {
        if (BaseCore.IsOffline)
        {
            return;
        }
        try
        {
            foreach (AchievementObject achievement in Instance.steamworks.settings.achievements)
            {
                if (achievement.Id == id.ToString())
                {
                    if (achievement.IsAchieved)
                    {
                        return;
                    }
                    try
                    {
                        achievement.Unlock();
                        achievement.Store();
                        EClass.ui.Say("sys_acv".lang(achievement.Name), Resources.Load<Sprite>("Media/Graphics/Icon/Achievement/acv_" + id));
                        SE.Play("achievement");
                        return;
                    }
                    catch (Exception ex)
                    {
                        Debug.LogError("Error Achievement 1:" + ex);
                        return;
                    }
                }
            }
        }
        catch (Exception ex2)
        {
            Debug.LogError("Error Achievement 2:" + ex2);
        }
        Debug.Log("Achievement not found:" + id);
    }

References Debug, Instance, BaseCore.IsOffline, steamworks, and EClass.ui.

Referenced by Chara._ShowDialog(), FactionBranch.AddMemeber(), Chara.Die(), Religion.JoinFaith(), Player.ModKarma(), Trait.OnBarter(), UIHangIcon.OnClickCorner(), TraitDrink.OnDrink(), Chara.OnInsulted(), Trait.OnLockOpen(), AI_Fish.ProgressFish.OnProgressComplete(), TraitDiary.OnRead(), ConSmoking.OnStart(), DramaManager.ParseLine(), FoodEffect.Proc(), ActEffect.Proc(), AI_Eat.Run(), AI_Idle.Run(), Chara.ShowDialog(), Chara.Slap(), CoreDebug.UpdateAlways(), Player.UpdateNyan(), and DramaOutcome.upgrade_miscreation().

HasDLC()

static bool Steam.HasDLC ( ID_DLC  id )

inlinestatic

Definition at line 43 of file Steam.cs.

    {
        return id switch
        {
            ID_DLC.CursedManor => true, 
            ID_DLC.BackerReward => EClass.core.config.HasBackerRewardCode(), 
            _ => EClass.core.config.HasBackerRewardCode(), 
        };
    }

References Core.config, EClass.core, and CoreConfig.HasBackerRewardCode().

Referenced by CheckDLC(), FactionBranch.ReceivePackages(), and TestHasDLC().

Init()

void Steam.Init ( )

inline

Definition at line 28 of file Steam.cs.

    {
        SteamAPI.Init();
        BaseCore.IsOffline = !App.Client.LoggedOn || SteamSettings.behaviour == null;
    }

Referenced by Core.Start().

QueryAllMyPublished()

static void Steam.QueryAllMyPublished ( Action< List< WorkshopItem > >  onComplete, Action< string >  onFail = null, float  timeout = 10f  )

inlinestatic

Definition at line 132 of file Steam.cs.

    {
        List<WorkshopItem> results = new List<WorkshopItem>();
        HashSet<PublishedFileId_t> ids = new HashSet<PublishedFileId_t>();
        uint page = 1u;
        bool done = false;
        UgcQuery query = UgcQuery.GetMyPublished();
        ExecutePage();
        if (!done && (bool)Instance)
        {
            Instance.StartCoroutine(Timeout());
        }
        void ExecutePage()
        {
            query.SetReturnKeyValueTags(tags: true);
            query.SetReturnMetadata(metadata: true);
            if (!query.Execute(HandleResults))
            {
                ReportError("UgcQuery.Execute failed at page " + page);
            }
        }
        void HandleResults(UgcQuery q)
        {
            if (!done)
            {
                results.AddRange(q.ResultsList.Where((WorkshopItem r) => ids.Add(r.FileId)));
                if (q.ResultsList.Count == 0 || page >= q.pageCount)
                {
                    done = true;
                    query.Dispose();
                    onComplete?.Invoke(results);
                }
                else
                {
                    query.SetPage(++page);
                    EClass.core.actionsNextFrame.Add(ExecutePage);
                }
            }
        }
        void ReportError(string error)
        {
            if (!done)
            {
                done = true;
                query.Dispose();
                if (onFail != null)
                {
                    onFail(error);
                }
                else
                {
                    Debug.LogError(error);
                }
            }
        }
        IEnumerator Timeout()
        {
            uint lastPage = page;
            float time = Time.realtimeSinceStartup;
            while (!done)
            {
                if (lastPage != page)
                {
                    lastPage = page;
                    time = Time.realtimeSinceStartup;
                }
                if (Time.realtimeSinceStartup - time > timeout)
                {
                    ReportError("UgcQuery timed out at page " + page + " (" + results.Count + " items fetched)");
                    break;
                }
                yield return null;
            }
        }
    }

References BaseCore.actionsNextFrame, EClass.core, Debug, and Instance.

Referenced by CreateUserContent().

ResetAchievement()

static void Steam.ResetAchievement ( ID_Achievement  id )

inlinestatic

Definition at line 101 of file Steam.cs.

    {
        AchievementObject achievementObject = Instance.steamworks.settings.achievements.FirstOrDefault((AchievementObject a) => a.Id == id.ToString());
        if (achievementObject != null)
        {
            achievementObject.ClearAchievement();
            achievementObject.Store();
        }
    }

References Instance, and steamworks.

Referenced by CoreDebug.ResetAchievement().

ResetAllAchievement()

static void Steam.ResetAllAchievement ( )

inlinestatic

Definition at line 92 of file Steam.cs.

    {
        foreach (AchievementObject achievement in Instance.steamworks.settings.achievements)
        {
            achievement.ClearAchievement();
            achievement.Store();
        }
    }

References Instance, and steamworks.

Referenced by CoreDebug.ResetAllAchievement().

TestHasDLC()

void Steam.TestHasDLC ( )

inline

Definition at line 111 of file Steam.cs.

    {
        Debug.Log(HasDLC(ID_DLC.Test));
        Debug.Log(HasDLC(ID_DLC.CursedManor));
    }

References Debug, and HasDLC().

UpdateUserContent()

void Steam.UpdateUserContent ( PublishedFileId_t  fileId )

inline

Definition at line 256 of file Steam.cs.

    {
        Debug.Log("Updating Content");
        BaseModPackage p = currentPackage;
        WorkshopItemData workshopItemData = CreateItemData(p);
        workshopItemData.publishedFileId = fileId;
        workshopItemData.Update(delegate(WorkshopItemDataUpdateStatus result)
        {
            LayerProgress.completed = true;
            if (result.hasError)
            {
                Dialog.Ok("mod_publish_error");
                EClass.ui.Say(result.errorMessage);
                Debug.Log("error:" + result.errorMessage);
            }
            else
            {
                Dialog.Ok("mod_updated");
                Debug.Log("updated");
            }
        });
    }

References CreateItemData(), currentPackage, and Debug.

Referenced by CreateOrUpdateUserContent().

Member Data Documentation

currentPackage

BaseModPackage Steam.currentPackage

Definition at line 21 of file Steam.cs.

Referenced by CreateOrUpdateUserContent(), CreateUserContent(), and UpdateUserContent().

Instance

Steam Steam.Instance

static

Definition at line 13 of file Steam.cs.

Referenced by Awake(), GetAchievement(), QueryAllMyPublished(), ResetAchievement(), and ResetAllAchievement().

steamworks

SteamworksBehaviour Steam.steamworks

Definition at line 15 of file Steam.cs.

Referenced by Core.Awake(), CreateItemData(), CoreDebug.FirstAdventurer(), GetAchievement(), ResetAchievement(), and ResetAllAchievement().

testData

WorkshopItem Steam.testData

Definition at line 19 of file Steam.cs.

ugc

UserGeneratedContentQueryManager Steam.ugc

Definition at line 17 of file Steam.cs.

---

The documentation for this class was generated from the following file:

• Elin/Steam.cs