Topics created by Hexagon

@Seamus They currently have access to virtual objects, which is fun, but I get what they want. I was looking at doing something like the first so I'm glad to see I'm not the only one who thinks that would be feasable. I would probably actually build a "forge" command that would just straight up make the item according to spec.

Still curious about what other people do to secure their code and objects from accidents and bad actors.

There may be a better name for it, but skills are in an alphabetical list right? This works fine until you get to Knowledge, which breaks into Knowledge: Arcana, Knowledge: History, Knowledge: Weird Campaign Thing #1, etc. They're just a bunch of blanks in the middle of the list to be filled in when appropriate. Maybe six are standard, and the rest are totally meant to be specific to your game. Profession does the same thing, but for literally any job you could have.

So having those in the middle of a list you want to reference by position could be a challenge. If I wanted to keep that, and I may, I just have to break them out into a parallel list. Which means adapting the standard character sheet, but I'm already adapting an entire game, why wouldn't I update the character sheet to reflect the medium?

I'm looking forward to working on the health system because I sort of expect it to be easier. It's just integer math. But d20 stuff is weird and I'll get it done and then I will remember "Oh you think you're clever? Now account for level draining attacks" and I'll have to go get a beer and think about it for a while.

@Derp Ooooh. Ok. Thanks.

Yeah, I can't help! But I understand!

Thanks @Ashen-Shugar @Lotherio. That's about what I figured, but it was worth asking.

Yeah I'm not aware of anything in Penn/Tiny that would do this.

You could also ask the coder to create a global altmail() function that just wraps around mail(). Would only take them a minute, vs. asking them to build something unusual into +finger to let you capture the output, or implement your alt mail check as a global.

@Griatch said in What is out there? Hard and soft codebases of choice.:

Edit: But if with "passive condition" you mean something like "at the moment of entering bob, if this condition is True then get back this version of the command, otherwise this other version", then you need to do a little more work:

You could solve this by adding all your conditional commands to the cmdset and tell them not to merge but to remain separate (but same-named) in the set. You then plug in your own MULTIMATCH_ERROR handler. When you use "bob" you will then get multiple possible command-matches. The normal result on a multimatch is to give you a list of commands and let you pick the one you want to use (it may matter if you are using the "push" command on the red or blue button after all). But your multimatch handler could instead check the condition and run only the command the condition dictates.

A bit of a necro of this thread, but it struck me that that the dynamic changing of commands based on a condition is a lot easier in Evennia than I suggested above. The question was essentially "at the moment of entering bob, if this condition is True, get back this version of the bob command, otherwise get the other condition". The way to go is to use locks. Here we decide which bob command to use depending on if the caller has the Attribute "foo" or not:

from evennia import Command, CmdSet class CmdBob1(Command): key = "bob" locks = "cmd: not attr(foo)" def func(self): # stuff this first bob command does class CmdBob2(Command): key = "bob" locks = "cmd: attr(foo)" def func(self): # stuff this second bob command does

Explanation: Above we create two Evennia Commands, both keyed as "bob" but doing (supposedly) different things. Each also has a lock string. Locks is a mini-language in Evennia, where you call small python functions that always return True/False and combine their returns into the result of the lock. In this case the lock string is cmd:attr(foo) and cmd:not attr(foo) respectively. The cmd bit is the lock type. For a Command, if the cmd type lock is not passed, the entire Command is unavailable to the player at this time. The lock is using the attr(name) lock function. This is a predefined lock function that checks if the caller has an Attribute with the given name ("foo") at all. So in this case, if the "foo" Attribute is set, CmdBob1 will fail the lock and CmdBob2 will pass it and vice versa. You could of course define your own custom lock funcs like is_it_full_moon etc. It's a normal Python function you just tell Evennia to treat as a lock function.

... We now just need to add these two commands into their own cmdsets and add them both to whatever object should be able to use or supply the "bob" command(s). When you then enter "bob" on the input line you will get the result of either CmdBob1 or CmdBob2 depending on if you have the "foo" attribute set on yourself or not.

I added it as a Q&A hint to the Evennia tips and tricks section.

@Hexagon said in XP Tax:

@Ganymede Is this not somewhat similar to reducing the auto-gain XP (you're just subtracting it off the front end, before the player gets a chance to pay it later as "tax")?
"Tax" may be an ugly word. I have started to think of it as "stat decay" the more we've all talked about this.

The key difference, which you touched on later in your post, is that stat decay is taking away something they have (reducing a skill), while reduced XP is taking away something they never had (the XP was never in their pocket, they just earned less of it). It's human nature to be less comfortable with losing something you already have than losing something you never had, it feels like you're being punished.

@Thenomain said in What is your preferred method of function creation?:

@faraday

Yup, that's how it works. But you can log in via alias. connect Smithy password

If you want server consistency, you're going to have to code a lpmatch() that honors it. Good luck. Please share.

Something most people don't realize either is you can connect by your dbref#

So from the connect screen doing something like 'co #69 pass' would work.

@Apocalycious said in Reality Levels and WOD Realms:

@Hexagon
I logged in to check, and HM has rlevels:

Level: real Value: 0x00000001 Desc: desc-interpreter Level: shadow Value: 0x00000002 Desc: shadow-desc Level: invis Value: 0x00000004 Desc: desc-interpreter Level: twilight Value: 0x00000008 Desc: desc-interpreter Level: all Value: 0x0000000f Desc: desc-interpreter

The Hedge was not actually an rlevel, just a different grid. The Shadow one was useful because the rooms were all the same in the Shadow, but it allowed for different descs in shadow/real. Extensive use was made of it, and most of the main grid rooms and many builds had shadow-descs set.

If I recall correctly, early on the Twilight one did make people invisible except to other people in Twilight. I never made much use of it (and it didn't get used very much in general), so I don't remember if those policies changed with time, or what they changed to. I don't remember the invis one getting used at all.

While Cajun Nights isn't active at all anymore, it is still up and will give a very good idea of how things work with realities. It uses them to extreme conclusions for massive amounts of manipulations.

Reality levels: (30 configured) ------------------------------------------------------------------------------ Level: Real Value: 0x00000001 Desc: _Desc Level: Umbra Value: 0x00000002 Desc: _UMBRADESC Level: OUTTIME Value: 0x00000004 Desc: _Desc Level: AWARE1 Value: 0x00000008 Desc: _AWAREDESC Level: AWARE3 Value: 0x00000010 Desc: _AWAREDESC Level: AWARE5 Value: 0x00000020 Desc: _AWAREDESC Level: AWARE7 Value: 0x00000040 Desc: _AWAREDESC Level: AWARE9 Value: 0x00000080 Desc: _AWAREDESC Level: MIND1 Value: 0x00000100 Desc: _AUSPEXDESC Level: MIND2 Value: 0x00000200 Desc: _AUSPEXDESC Level: MIND3 Value: 0x00000400 Desc: _AUSPEXDESC Level: MIND4 Value: 0x00000800 Desc: _AUSPEXDESC Level: MIND5 Value: 0x00001000 Desc: _AUSPEXDESC Level: MIND6 Value: 0x00002000 Desc: _AUSPEXDESC Level: SPIRIT1 Value: 0x00004000 Desc: _SPIRITDESC Level: SPIRIT2 Value: 0x00008000 Desc: _SPIRITDESC Level: SPIRIT3 Value: 0x00010000 Desc: _SPIRITDESC Level: SPIRIT4 Value: 0x00020000 Desc: _SPIRITDESC Level: SPIRIT5 Value: 0x00040000 Desc: _SPIRITDESC Level: HIGHUMBR Value: 0x00080000 Desc: _CONCEPTDESC Level: WRAITH Value: 0x00100000 Desc: _WRAITHDESC Level: TELEPATH Value: 0x00200000 Desc: _TELEPATHDESC Level: SYNERGY Value: 0x00400000 Desc: SYNERGYDESC Level: HEARING Value: 0x00800000 Desc: _MURMUR Level: OBF1 Value: 0x01000000 Desc: _AUSPEXDESC Level: OBF2 Value: 0x02000000 Desc: _AUSPEXDESC Level: OBF3 Value: 0x04000000 Desc: _AUSPEXDESC Level: OBF4 Value: 0x08000000 Desc: _AUSPEXDESC Level: OBF5 Value: 0x10000000 Desc: _AUSPEXDESC Level: ALL Value: 0x1fffffff Desc: _DESC Enhancement: @lock/user works as a Reality Lock (type 1). ------------------------------------------------------------------------------

As for how to set things up 'properly' with Reality Levels, that's an open question that requires an open answer. There really is no 'right' way to do it or that many 'wrong' ways.

In essence, realities allows you to share the same physical space by applying virtual layers over the top of it.

Another good example is layered GIF's when you work with photoshop or gimp. You have one layer which is the background. The next layer is the plants and trees, the layer after that the weather like leaves that blow around, the next layer maybe fog on the ground, then the next layer animals flying or walking and the next the people who walk around.

6 complete layers, each one absolutely separate from each other, but with the right 'permissions' allowing each layer to interact with any of the other layers however you want. That's a bit like reality levels. You can modify the @rxlevel and @txlevel on the fly (there's sideeffect functions as well) so someone can switch realities by somthing simple like walking through an exit, or issuing a $command or any number of other things. And with locks (if available) you can dynamically define realities based on conditionals on top of it.

Lots of flexibility.