Editing Modding Tutorials/Custom Comp Classes

Jump to navigation Jump to search

Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.

Latest revision Your text
Line 1: Line 1:
−
{{BackToTutorials}}
+
Creating a custom comp class is a convenient way to add new functionality to RimWorld.
−
Creating a custom comp class is a convenient way to add new functionality to RimWorld. Comps aren't a formal concept in the code: they're a design pattern used in different places. They allow for a more modular approach to adding functionality to different objects.
 
  
−
=The types of Components=
+
== Prerequisites ==
−
These are the places where the Comps design pattern is used, each with differing behaviour suited for their respective area. From most specific to most generic:
+
* You need to have [[Modding Tutorials/Setting up a solution|set up your editor and environment]]
−
==HediffComp==
+
* You need to know [[Modding Tutorials/Writing custom code|how to write custom code]]
−
A relatively simple Comp for adding more complex behaviour to Hediffs.
+
* You should probably understand Defs at least somewhat.
  
−
==ThingComp==
+
== def (xml) and C# structure ==
−
{{Main|Modding Tutorials/ThingComp}}
 
−
A very powerful Component that is tied to a specific Thing. These are often used to store data, give special functionality to the Thing they're tied to and are one of the building blocks of RimWorld modding and RimWorld in general. While not as powerful as a [[Modding Tutorials/Def classes|fully custom class]], they provide plenty of functionality for a lot of general use cases without compatibility issues.
 
  
−
==WorldObjectComp==
+
=== Setup, Defs, and Classes ===
−
Like a ThingComp, but for WorldObjects.
+
You will have some custom def and it will have something like this:
 +
==== Defs (xml) ====
 +
  <ThingDef ...>
 +
    ...
 +
    ...
 +
    <comps>
 +
      <<nowiki>li</nowiki> Class="MyNamespace.MyCompProperties">
 +
        <myCustomCompProperty>some value</myCustomCompProperty>
 +
        <mySecondCompProp>4</mySecondCompProp>
 +
      </<nowiki>li</nowiki>>
 +
      <<nowiki>li</nowiki>>
 +
        ''<<nowiki>!--</nowiki> this is kind of like <tag>MN.MyCustomTag</tag>:-->''
 +
        <compClass>MyNamespace.MyCustomThingComp</compClass>
 +
      </<nowiki>li</nowiki>>
 +
    </comps>
 +
  </ThingDef>
 +
==== C# ====
 +
  namespace MyNamespace ''// For example, LWM.ModName - by using your ''
 +
                        ''//  handle/name/etc, you almost certainly guarantee uniqueness''
 +
  {
 +
  '''//////////// <<nowiki>li</nowiki Class="MyNamespace.MyCompProperties"> ////////////'''
 +
  public class MyCompProperties : CompProperties ''// Name this as you wish, of course''
 +
  {
 +
    public Properties() {
 +
      this.compClass = typeof(MyNamespace.MyLinkedCompThing); ''// rename as appropriate''
 +
    }
 +
    public string myCustomCompProperty; ''// Name matches def, of course''
 +
    public int mySecondCompProp = 1; ''// Can set default values''
 +
  }
 +
 
 +
  ''// this ThingComp is used to actually access the comp property defined above''
 +
  '''''// this is not "<compClass>MyNamespace.MyCustomThingComp</compClass>"'''''
 +
  public class MyLinkedCompThing : ThingComp
 +
  {
 +
    public string myCustomCompProperty
 +
    {
 +
      get
 +
      {
 +
        return ((MyCompProperties)this.props).myCustomCompProperty;
 +
      }
 +
    }
 +
    public int mySecondCompProperty ''// Have to get all the names right''
 +
    { get  { return ((MyCompProperties)this.props).mySecondCompProperty; } } ''//etc''
 +
  }
 +
  '''//////////// <compClass>MyNamespace.MyCustomThingComp</compClass> ////////////'''
 +
  public class MyCustomThingComp : ThingComp
 +
  {
 +
    public override void CompTick()
 +
    {
 +
      // do stuff
 +
    }
 +
    public override void CompTickRare() //etc
 +
    public override ... // Check out Verse/ThingComp.cs for more ideas
 +
  }
 +
  } // end MyNamespace
  
−
==MapComponent==
+
=== Accessing your Comps ===
−
{{Main|Modding Tutorials/GameComponent}}
+
Just setting up your custom comps doesn't do you a lot of good if you can't access them!
−
Much like a ThingComp, except these exist at the Map level. They're most useful for keeping tracks of multiple things at once, storing data, and can serve as a coordinator or general managing entity.
 
  
−
==WorldComponent==
+
'''To do'''
−
{{Main|Modding Tutorials/GameComponent}}
 
−
Similar to a MapComponent, but lives on the World level.
 
  
−
==GameComponent==
+
=== Cautions, traps, etc ===
−
{{Main|Modding Tutorials/GameComponent}}
+
If you have the same comp in an abstract def and attempt to redefine it in a child def, it will get counted twice.  It's possible to get around this in the code, if you want to have default comps:
−
Similar to a WorldComponent, but lives at the Game level.
 
  
−
The distinction between a GameComponent and a WorldComponent might not be too obvious, but a GameComponent gets instantiated when a new Game is started:
+
  <ThingDef Name=ParentWithDefault ... Abstract=true>
−
* Upon start of the tutorial
+
    ...
−
* When the player starts the Scenario Configuration (rolling for colonists)
+
    <comps>
−
* When a save is loaded from the main menu
+
      <l<nowiki>i</nowiki> Class="MyCompPropertiesWithDefault">
 +
        <myValue>3</myValue><!--default!-->
 +
      </l<nowiki>i</nowiki>>
 +
    </comps>
 +
  </ThingDef>
 +
  <ThingDef ParentName="ParentWihtDefault">
 +
    ...
 +
    <comps>
 +
      <l<nowiki>i</nowiki> Class="MyCompPropertiesWithDefault">
 +
        <myValue>5</myValue><!-- override default!-->
 +
      </<nowiki>l</nowiki>i>
 +
    </comps>
 +
  </ThingDef>
  
−
==StorytellerComp==
 
−
These are a specific type of Component that determines the behaviour of the storyteller.
 
  
−
=Which one to use=
 
−
Use whatever is most appropriate, really. Does it deal with a Pawn's health? HediffComp. Is it functionality at Thing level? ThingComp. Does it have to do with two pawns, or multiple items on a map? Probably a MapComponent, or maybe a WorldComponent.
 
  
−
[[Category:Modding tutorials]][[Category:Modding]]
+
  public class MyLinkedCompThing : ThingComp
 +
  {
 +
    public string myCustomCompProperty //etc
 +
   
 +
    public override void Initialize (CompProperties props) {
 +
      base.Initialize(props);
 +
      // Remove duplicate entries and ensure the last entry is the only one left
 +
      //  This allows a default abstract def with the comp
 +
      //  and child def to change the comp value:
 +
      MyCompProprtiesWithDefault[] list = this.parent.GetComps<MyCompPropertiesWithDefault>().ToArray();
 +
      // Remove everything but the last entry; harmless if only one entry:
 +
      for (var i = 0; i < list.Length-1; i++)
 +
      {
 +
        this.parent.AllComps.Remove(list[i]);
 +
      }
 +
    }
 +
 
 +
  ///etc
 +
  }
 +
 
 +
[[Category:Modding tutorials]][[Category:Modding]][[Category:Defs]]

Please note that all contributions to RimWorld Wiki are considered to be released under the CC BY-SA 3.0 (see RimWorld Wiki:Copyrights for details). If you do not want your writing to be edited mercilessly and redistributed at will, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource. Do not submit copyrighted work without permission!

Cancel Editing help (opens in new window)

Templates used on this page:

Retrieved from "https://rimworldwiki.com/wiki/Modding_Tutorials/Custom_Comp_Classes"