Jump to content


  • Posts

  • Joined


532 Excellent

1 Follower

Profile Information

  • About me
    Miniature Builder

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. Yes, if you want to check the limits, probably a second interpolator variant is the the way to go. The interface is supposed to provide a moving target and the servo tries to follow that target in real time.
  2. A servo could run in two modes: 1) It once gets a target and then autonomously moves there, such that the trajectory respects the limits (range, speed, acceleration) and comes to a stop at the target. This process is what I call interpolation. 2) Some other device does the interpolation, and sends a position to the servo at every physics tick. The servo moves to this position without trying to stop there. It may enforce its limits, or leave that to the other device and just blindly copy the position. When I wrote the interpolator, we built the interface for mode 1 because that was the most straightforward use of a servo. It is totally possible to add the other mode too. The simplest way would be to bypass the interpolator and overwrite the servo position each tick.
  3. Yes that's it. It is actually not that hard to remember, because it was the worst bug during my TweakScale career, which was open a long time and cost the mod quite some reputation.
  4. Just for your info: the last problem that only hit the root part was an access with a hardcoded index, something roughly like 'transform...getChild[0]', that should have been 'transform...getChild["model"]'. That code had worked for years, until in a new KSP version the index [0] of the root part pointed to some camera-related transformation. Which led to a hard to find bug that broke the camera whenever the root part was scaled. Maybe the issue here is similar.
  5. The problem is that this makes upscaled SRBs useless. Also the stock parts do not follow that logic. Instead they seem balanced with a useful TWR and burn time in mind. This was the motivation for the current SRB exponents.
  6. These are the exponents for the stock wing modules: https://github.com/net-lisias-ksp/TweakScale/blob/master/GameData/TweakScale/ScaleExponents.cfg#L169-L186 Mass of wings is scaled with an exponent of 2, so that a large wing should be equivalent to the same area worth of small wings. dragAtMaxAoA does not appear (hopefully that means that it is a coefficient and not a total value).
  7. Just in case you haven't ruled that out already: the two sliders can also come from the same module. Both members "tweakScale" and "tweakName" have a tweakable, and a correctly initialized TweakScale module is supposed to use one of them and hide the other.
  8. I faintly remember that KSP does some automatic conversion that has caused confusion in the past. It was something along the lines of converting every "_" to "." in part names. Might also be config strings in general.
  9. The module disables itself if it is not the first one: https://github.com/net-lisias-ksp/TweakScale/blob/master/Source/Scale/Scale.cs#L750-L757
  10. Yes this will work. Just as :BEFORE[TweakScale] works because the patches that come with TweakScale take effect at an earlier time. So things are not as trivial as they seem. Actually I like the idea of preferring "%type=..." just because it leads to more robust behavior.
  11. My decisions for the exponents mostly came from gameplay considerations. For example stock tanks have a fixed ratio between fuel content and dry mass. If one stock tank is twice as big as another in all directions, it has 8x the fuel and 8x the dry mass. As a rule of thumb, an enlarged part should compare to the same mass, cost and utility as several copies of the original. And most general, an exponent is right when both the enlarged and the shrinked part have some use in the game. A wrong exponent usually leads to one side being overpowered and the other being useless. Example: for a rocket engine, the exponents for mass, cost and thrust are equal. And that number is chosen in a way such that a scaled engine is able to lift a stack of somewhat reasonable and useful height. Edit: since there are many parts whose utility scales with area (instead of volume), there are separate scaletypes for them: "stack_square" and "free_square": https://github.com/pellinor0/TweakScale/blob/master/GameData/TweakScale/DefaultScales.cfg#L21-L62
  12. Actually most non-stock modules work fine with TweakScale's config interface, see all the non-stock entries in https://github.com/pellinor0/TweakScale/blob/master/GameData/TweakScale/ScaleExponents.cfg#L236-L463 If the effect you need can be done by scaling a kspField in the target partModule, TweakScale support can be done with a ModuleManager config. Note that the exponent names refer to variable names in the C#-code (which might or might not correspond to config nodes appearing in some .cfg file). Only if this mechanism does not work do we need C#-code, either in the TweakScale codebase or in the other mod.
  13. My experience is that CKAN hasn't caused trouble for TweakScale yet. It targets inexperienced users and should only see the stable releases. I found it quite useful for the initial installation, but also prefer to update things manually and selectively.
  14. Curiously, I thought on something like that recently. But I consider this to be "tricky" to implement as it would break an (programming) interface that are in use for years. OK, there're techniques to make things coexist, but we need to balance cost and benefits of such a feature. The "easier" changes on the programming interface would render the user interface less intuitive, and vice versa. (quoting this from the old TweakScale thread) The scaling part is quite simple and has been done before (for example the DIY Kits in GC). Some other questions are * Many parts in TweakScale assume the scaling has one degree of freedom, for example the config interface (scaleFactors, exponents, techRequired), the API for other mods. Is it clear how they should behave once a part can be scaled with two or three degrees of freedom? What additional config possibilities does this need? * Will the resulting config interface still be usable for the average modder? * How many parts benefit from non-isotropic scaling? This is the main point why I haven't done this yet. Most models just look bad when stretched. Edit: for simple cases like visually stretching an adapter, it could also be a separate part module that lacks all the interaction with other part modules.
  15. Let's move the discussion to the new thread and close this one.
  • Create New...