Wanted: your top 5 ways to improve scripting

We're doing some medium-term planning and need your input. I've just reviewed the last couple of months of forum postings, so I've got a pretty good list started, but here's your chance to say what you want the very most.

Put your highest priority items at the top of the list. This thread is for scripting features only. Have at it!

Thanks!
Aaron

switch/case

non say/shout/whisper object to object communication (objects can send IMs, can we make them receive them too via a llListenIM or equivalent, so that they can talk across sims?)

a way to transfer inventory across objects, tied in with the above cross-sim communication, so that we can update lots of objects in a single shot.

documentation is a big one past that. Some of the functions are quirky, and some are even incorrectly cast in the helpfile (incorrect number of arguments, for the present working script language)

manipulation of other objects without communicating to them so that they manipulate themselves


that's all I can think of for now.

1. arrays (multidimensional array support included)
2. text parsing beyond llParseString2List and substrings (regular expressions )
3. switch statements (break command if implimented should break any loop not just switch statements)
4. user defined data structures (or how about classes? )
5. include directives (so we can make script files that are essentually function libraries)

1: user defined type
2: so way to see how much resources a script has left, stack/heap space
3: llListen with partial matches (not nessisarily regex, but something would be nice)
4: ability to #include other scripts
5: ability to rather then put a script in an object, put a link to a script in your inventory so i can modify a single script and have the changes affact all the objects with that script

1. Arrays
2. #includes
3. ability to update a script and have all objects containing that script be updated
4. structs
5. ability to write to a notecard

1. llMessageBox with messagebox() event
2. Ability to write data to a notecard in objects inventory (overwrite or append)
3. regular expressions
4. arrays / multidimensional

and to quote hiro:

5. ability to rather then put a script in an object, put a lick to a script in your inventory so i can modify a single script and have the changes affact all the objects with that script

#!

Oohhhh, I replace my #5 (Choclate Chip Cookies) with Shebang's #2

No.. popups.. allowed.. no!

1) a find/replace option (plz oh plz)
2) ability to update all instances of a script
3) arrays
4) user defined types
5) #include(if possible)

1: Ability to add/delete/edit scripts across multiple selected objects. And I'm being nice here, I'm saying "selected" objects, aka, not the difficult multi-sim stuff.
2: Find & Replace function.
3: Optional automatic method statement placement(I really hate writing out a full listen(integer chan, blah, blah, blah) I'm willing to just use a default).
4: Right clicking in a parameter field which requires constants would list all possible constants (which would be clickable to place into the field).
5: Better tab key indentation, so that if I move the cursor one space across a tabbed indentation, it actually moves the 5 full spaces rather than me having to hit the key 5 times to make it across that space.

1. Permission Controls For Scripts.*
2. Easy Communication between scripts on an object (#include)**
3. Arrays
4. Structs
5. "Find..." with a "Replace" option.


* So I can sell a script and the person can't see the script. It should allow for a lengthy description to be seen even if the script is no edit and possible allow function declarations to show.

** I want this to work in a perhaps unintuitive way. I would like to be able to create my own library file with custom functions/actions. I want to be able to lock it (via #1) and sell it so the person who buys it can't edit it. I want them to be able to put it on an object they own and be able to #include it and call the methods in it even though they don't have write permissions to the #included file

Disclaimer - new to scripting so I probably haven't hit the same problems as some others...

1. More in-depth documentation (esp. some of the physics commands - I have no idea what are sensible values for some of them)

2. Single step debug - save me putting in all those llSays (with associated particle spam when I've got it wrong!)

3. Ability to change a script across several objects

4. Ability to create libraries which can be called from other scripts

5. ummm..... run out now! (but cookies sound good )

1) script access control.(same as ama's)
2) library/#include(again same as ama's)
3) more flexible sensor function, so i can say how much info i want stored concerning each object, like i only want their key's and there velocities. the hope being that the fewer number of flags we ask the system to watch, the more items we can sense.
4) a bought(key id) event
5) two levels of scripts. first is like what we have now, where each script is individual, any edits you make only happen on the one you are working on. Second is there is a parent script that all similar scripts reference to, so any changes in the parent automatically show up in the child.
6) Camera control!!!! and detection see this thread

and rather than repeat everything else, i will just say i second every post here.(especially about writing to notecards, and find/replace, and... i better stop before i just resay what everyone else said).

1) Arrays!! God do I miss them here.

2) Add more functionality to touch(), touch_end(), and touch_start() as such:
touch(integer total_number, integer side, float x, float y) where side is what side the object was touched on, and x and y are the local coordinates of where the object was touched. (for example, if you touched an 1mx1m object in the center, it would return x=0.5 y=0.5)

3) Add to llPlaySound (etc.) as such: llPlaySound(key sound, float volume, float pitch, float length) where pitch is what pitch to play the sample at and length is how long to play the sample.

4) The #include or llCall(key script, string function,[mixed args...[) ability or even better an inherit function. Kind of would allow a mixture of the #include and the global modification. (i.e. inherit x script. X script functions/vars are available to the local script. If x script is modified, it effects all of those objects that inheritted x.)

5) Script permissions.. Pretty much what people were speaking about above. Allow the modification of the objects but lock out the scripts.

6) llMakeMoney()... come on, one can dream.

I probably could go on for another 50...

1. more events in where the llDetected* functions work.

2. Camera Control (nice one Nada! ).

3. llGiveInventory(), llMoveToTarget, llSetpos, and other stuff that it inside-current-sim-only to be globally available and usable.

4. More scripted control of an object's properties (I want to cut it, make it hollow, set the dimple (sphere)).

5. Eiasier memory managment, eiather more mem allocated to scripts, or a mem debug mode.

(OK this is more then 5)

6. Eiasier rotation!!! Please!! (espicially rots around a non-central axis).

7. llGetSim(), llTeleportTo(), and llListen and llSensor filters that you can actually define within the function (ex. llSensor("",~llGetOwner(),blah,blah,blah) would only look for people not the owner of an object, this would be helpful because a sensor can only detect 15 objects/avitars at a time.)

8. AN EIASIER WAY TO CREATE WINDOWS!!!

1. Simple include, not this fancy pants "link to a script in inventory" business

2. Ability to write to a notecard

3. Some way to communicate with the outside world. Objects being able to receive email would be one good way

4. The fancy-pants kind of include

5. Proper, canonical documentation.

1. International support. It sucks that I have to copy-paste ";", "=" and the like from other scripts because my DK-keyboard ain't supported
2. Switch-statement
3. #includes
4. structs
5. Arrays

Im just now starting to play with scripting so I don't have much to offer. I do wish though that if you were playing with a script you had a chance to rename it upon save. Also, if you have a script and get a second (updated or not) copy of the same script... that the new copy was named in succession rather that the same.

SO, I have a "new script" and then get another copy of "new script".. when it lands in my inventory it gets auto renamed "new script 1", "new script 2" etc rather than having several "new scripts" that I cant tell which is which.

1. Some way of allowing scripts to get more memory, even if just for data storage. (Notecard writing functionality will work, though it's a bit clunky.)

2. Communication with the outside world. As others have pointed out, email would be just fine.

3. A debugger, so we can get at the memory contents of the script vm directly. Something with as much power as gdb would be nice, but even just basic probing and editing functionality would be cool.

4. Pointers? Not only are they useful on their own, they would allow for multidimensional lists as well. Admittedly adding them in at this point in development would be difficult at best.

5. Chocolate chip cookies!!
llDispenseCookie(integer num);
Causes num cookies to come out of the user's floppy drive.

hehe, I love how many people have gone for cookies even though I had to retract mine

I hate to say it Bob, but I don't think Pointers would make it. I can't think of a faster way to make a server crash or lag to a halt then an unending list of pointers

We need better Documentation! Especially on the physics scripts, there all kinds of limitations on these, but theres no place to see them!

Detailed documentation on physics scripts is essential!

Hey Wednesday, what do you mean by Simple #include? How does it differ from what I suggested? I'm just not sure I understand.

Not sure if this is a appropriate post for this thread, but it would help noob's I think....

How about a something like Visual Basic type interface for scripting?

But yes the ability to read/write from note cards to have a permanent nonresetting list base would be great.