Trust me when I say that my way would be much, much easier.

Yes, that's what I want. And yes, I can implement it, using BlitEntityFrame. However, your suggestions for alternate methods seem kind of...goofy.

something that would make my sort function better (because I keep looking up the same variable)
bind(string name, variable)//binds the varible named with the string name to variable (variable must be of the same type as what is named in name)

TRotScale

Overloading of functions.
Default parameter for functions.
More hardcoded visual effects like Mosaic().

This is done in advance of a why-can't-I-do-this-in-verge section of the faq. Please comment/add too.

Quote: Originally posted by gannon

the ability to have the get and set functions work with things in structs //this way you could pass structs and even have structs within structs (kinda) - Hard, but on its way I think. Personally I'd just have one array of a struct, and pass ints as stack references.

the ability to pass things with callfunction (even a simple two ints only) without using globals //this would make making general functions much easier - A few catch-all globals won't kill you

robust debugger //on the fly variable editing and the whole bit - AHAHAHA... would be nice (suggestions of debugging methods?)

Quote: Originally posted by Gayo

I'd like the ability to define one entity's position in terms of relation to another entity. This wouldn't be TOO hard to implement in VC, but it'd be a lot nicer if it were inherent in the system. - This *is* rather easy to do yourself. (will show how)

On the "I can do it myself but it'd be cool if it were built-in" note, colour-replacing and colour-masking functions would be nice. - I have a general colour library I'll be making public. It's fine for one off swaps, but too slow for anything gameloop side.

Some way to set zones so that they automatically call their associated event every x seconds. - HookTimer() a new function on the zone call, and handle from there.

The ability to change an entity's walkstrings at runtime, overriding its chr walkstrings. Even just the ability to change a cached chr's walkstrings (only in memory, not in the actual file) would be cool, though, since I'd mostly want to do this for the main character sprite. - ME TOO! Much more flexiblity over chr would be great. Current work around for this kind of thing: make multiple chr files and use ChangeCHR()

And, one that has no chance of ever being added: it'd be nice if you could set a map flag so that the map wrapped. This would really only be useful for RPG overworlds, and I can think of a few cheats to work around it, but this is a wish list. - Agree. Very hard to workround this (suggestion from above though)

Quote: Originally posted by zaril

return myStruct; - Will copy from my help post (with & correction of course ;)

Quote: Originally posted by Technetium

Confuses me, so I'm ignoring - but we need moar sections on tile animation/useage of alphabit (you do know alpha is another way of doing lucent right? So you can always change the mask to get another lucent effect)

Quote: Originally posted by Gayo

Here's something I've been thinking about: say I want to enforce a specific draw order for entities, so some are consistently on top of others. So what I would do is have no entity draw in the renderstring, then make a DrawEntities function that draws them in the order I want (using BlitEntityFrame), and HookRender that. Would this be significantly sped up if VERGE had a DrawEntity that just drew an individual entity on its own in the same way the entity draw in the renderstring normally would? Because if so, I'd like that. - Right, I've had something similar to this in p7 with wanting to put 'dead' entites under liveones, but otherwise respect the y sorting. However, Gayo's post confuses me, so I'm not sure what he's after. ATM: I HooKEntityRender() stuff to void Dead() {} when they die, and pick up their rendering in a HookRetrace() under the entity layer.

Quote: Originally posted by Omni

...FlipBlit...so why no MirrorBlit? Seems a fair request to me - any better ways of doing at the mo than a flip/rot combo?

Quote: Originally posted by TomT64

A function to render the current frame of a CHR INDEPENDENT OF THE MAP whether or not it is moving. Also provide a way to put it somewhere other than the center or edge of the map. This is good for an FF3 style overworld and other Mode 7 effects (perhaps). - Expand on current entity rendering methods, examples will be useful here.

Also MAEK STRUCTS LOCAL and allow returning of all data types available to verge. - Explain diminshed memory management concerns, vs. copy constructor problems. (Unless you're after references too Tom? :)

Oh and add floats too. - Explain fixed point numbers again to everyone.

Quote: Originally posted by Wooly

This way, an entity could warp to someplace whitout having to stop the main character from moving. Any work arounds? I can think of some nasty ones - turn of obstructability, turn speed all the way up and do an x,y movecode for instance, with out calling ShowPage();

Quote: Originally posted by Toen

TRotScale - Seems fair. Any work arounds?

Quote: Originally posted by mcgrue

MakeGmae(); - Copy the wonderfully comprehensive but still easy to understand Sully code, and replace whatever bits you feel the need to create phresh content.

Quote: Originally posted by Buckermann

Overloading of functions. - CallFunction()
Default parameter for functions. - Global variables.
More hardcoded visual effects like Mosaic(). - Write your own. I may be adding stuff to help this over time - any specific things?

Quote:Originally posted by Zip


Quote: Originally posted by gannon

the ability to have the get and set functions work with things in structs //this way you could pass structs and even have structs within structs (kinda) - Hard, but on its way I think. Personally I'd just have one array of a struct, and pass ints as stack references.

the ability to pass things with callfunction (even a simple two ints only) without using globals //this would make making general functions much easier - A few catch-all globals won't kill you

robust debugger //on the fly variable editing and the whole bit - AHAHAHA... would be nice (suggestions of debugging methods?)

the purpose of my suggestions is more for libraries (ie you don't know the rest of the code. you should code that way anyway). you should never have globals if at all possible. and the get and set would allow you to fake passing of structs without having them have to be in a specific array (you could have multiple arrays of them or temporary structs to do work on)

you missed one of my suggestions

bind(string name, variable)//binds the variable named with the string name to variable (variable must be of the same type as what is named in name)

also two things
how can callfunction permit overloading of functions?
default parameters allow you to change the function without changing all the things that call it
and also unneeded global variables is just asking for bugs

correctness is very important for debugging and mantaining code. I am not asking for OO I am asking for the ability to write code without needing to know the other parts of the code.
the bind is just for speed because I call the get on the same array over and over (I can not know the name of the array other than what is passed in because it is a general function. why make people write the same function that everyone else already wrote several times because they need it on different arrays)

function overloading is where you have two functions with the same name with different arguments
ie
int max(int x, int y)
int max(int a, int b, int c)
string max(string a, string b)
how would you do that with using callfunction?

but for a sorting function that sorts by keys (you are not sure what type they are) you could just call max(key1,key2) and have it take care of it

btw. there are workarounds for everything we don't even need strings or structs because we have ints and DMA. This is not about what workarounds are there it is about what would be best in code (this is an interpreted lang don't forget)

I know for some of them the workarounds would not be hard but they are rarely preferable because anything done in verge is automatically slower than what is done by the engine. I don't see general overhead for many of the suggestions.
I never said that structs have to be local I just want to have access to an arbitrary named one. This would allow libraries to be made. (it is very hard to make them in the current state) With libraries people can get around there limited programming knowledge. Without them people will go to things that require less programming knowledge because verge makes you write everything from scratch several times over with small variations.