irihapeti

if have a good gfx card then max draw distance for static/still views renders faster after all resources have been downloaded and when cache is not full it renders faster bc it culls less. It culls less bc: is this previous known resource within the draw distance? If the answer is yes to everything then it dont need to cull the scene + but... the test for draw distance rendering speed is to stand close to the intersection of 4 really busy sims and run in a figure-8 pattern as fast as you can. Changing the direction randomly. Figure-8 and not just plain rotate. Do this with a complex textured/modelled scripted object chasing/following you really closely you will find that when do this (random figure-8) the camera angles of the scene changes rapidly as do the camera angle/view of what is chasing you short draw distance beats long draw distance everytime FPS-wise in this case is the same for any scene where the camera is moving or when stuff is moving into and out of the scene. like other avatars for example

Madelaine McMasters wrote: And I have a pet theory that the unknown is at least the square of the known. you made a comment on the other about lfsr and it made me start to think about random in the universe. Rather than put this on there I put on here bc it goes down the same path I think (: + like is the universe truly random? or is it just to large for us to model at this time. so just appears random? it ties in with are we limited by our imagination. or are we really only limited by the materials and tools available in our own time. For example: if Da Vinci had a fuel synthesiser and a welding torch. if the Egyptians had a bulldozer, etc + if we did have the materials and tools and modelled the universe then what would the starting seed be? Given that it cant be 0. 0+0=0. 0*0=0. 0<<0=0 etc would it be 1? if it wasnt 1 then means that would be some other seed number. which implies that is/can be multi-universes. each with own starting seeds drawn from some larger set outside of the universes themselves if was 1 (or whichever seed) then can know that this/our universe is an arrangement of seeming random events which are not random. only pseudorandom and therefore deterministic. If so then if know the seed and the starting algo (which can be very simple I think) then can know all the past and all the future + the cool thing about the universe algo is that, where life as we know it, is in parts self-modifying code (natural selection/mutation) which can be modelled also bc mutation algo while can seem random is not. Notrandom in the sense it can be modelled and reproduced. Even if each mutation method has own self-modifying algo and own PRNG. the seed of which is fed by outcomes of other mutation algos. bc the seed for them is drawn from the state of the universe PRNG localised in spacetime to them, and also drawn in part from the outcomes of other mutation algos in turn. Which all resolve back to the universe starting seed + just need a really really big computer and fast to compute it. at least as big and fast as the universe is/was at any given time one that maybe grows itself forever as time progresses (which seems unlikely bc this would be a magical property seems like to me) or (which is more likely i think) the computer would be bound by the same physical laws as the universe it contains. Meaning is some actual space limit to the computer itself. Which means that the universe itself is finite. So maybe when the sum of the universe hits the upperbound limit then kaboom !!! game over. reset and ready player one (: or maybe never reset after kaboom! and thats all. game over forever + is not enough to just/only have a seed at the start tho. Need a starting algo as well i think that start algo is maybe: universe = seed = 1; while (universe += seed / (seed + universe)); so what happens with this algo? as universe grows larger it divide itself by the magnitude of itself. (is how cells work? life?) they multiply by division? at some time the universe computer runs out of spacebits and eventual end up divide by zero. kaboom !!! maybe (:

be good Bobbie ok cheap doesn't get you Japanese Japanese language gets you Japanese customers who speak Japanese Not every vendor caters for every other language speakers. Like a lot of English-only speaking vendors for example

is possible on some computers to lengthen the timeout (which is usually 2 seconds by default) and have it recover the app. It dont work on all computers tho with the SL viewer. and only on some other games not all it depends on how the game software is written to handle hardware fail/timeout + is not recommended by Microsoft to mess with Timeout Detection. Is a process made available to gfx card manufacturers and gfx devs to test with. If fry your computer doing this then will void the manufacturer warranty also most likely but here is the dets if you into this kinda thing: http://msdn.microsoft.com/en-us/Library/Windows/Hardware/ff569918(v=vs.85).aspx you on your own if fry it tho + the actual recommendation is to always run the latest NVidia gfx driver by installing NVidia Update and have it look after you: http://www.nvidia.com/object/nvidia-update.html and if Shadows takes longer than the manufacturer timeout setting to paint then turn Shadows off in the viewer

one way to think about it is can use states and jump to them based on game flow tasks/levels are grouped into logical state groups. either by game logic, code similarities, or both a advantage of using states is that only have to open listens and link messages depending on the specific state/task while needed, and can also call/suspend support scripts as needed from within the current state. When the state changes anything open will close automagically. a level/task timer is reset when the state re-enters, etc also while can arrange the tasks into state groups you not restricted to a linear flow. Can jump from any state/task to any other as you like example: [ETA] i add a line to end of state main so the script dont go catatonic if anyone do mod this so that level 29 is reached integer prev;integer this;integer next;default{ state_entry() { // initialise app on start here prev = -1; this = 0; next = this; // on start next state is same as this state // start main loop state main; }}state main{ state_entry() { prev = this; // save the previous state/task this = next; // make the next state/task this state/task and execute // jump table if (this < 10) state state0; if (this < 20) state state1; if (this < 29) state state2; // etc... // when complete the game (level 29) then llOwnerSay("Annnnd... the winner is ...... you !!! tada !!!"); // back to the spawn which in this example is State0 task 0. // Altho typically the spawn is state/task -1 // Negatives are usual used for safezones and if player go OOC / suspend play // this = -2 for example. when player resumes then // next = prev; // state main; // fail safe state default; } }state state0{ state_entry() { // setup state0 tasks 0..9 here } touch_end(integer num) { if (this == 0) { llOwnerSay("ready player one"); next = 1; } else if (this == 1) next = 2; //etc... else next = 10; // exit state main; } state_exit() { // tidyup state0 tasks 0..9 here llOwnerSay((string)this + " : " + (string)next); }}state state1{ state_entry() { // setup state1 tasks 10..19 here } touch_end(integer num) { integer completed = TRUE; // or false depending on actual task if (this == 10) next = 11; else if (this == 11) { // this code the most important for game flow based on completed if (completed) next = 12; // level up else next = prev; // back to previous state/game level/task // or next = whichever task/level depending on game logic } else next = 20; // exit state main; } state_exit() { // tidyup state1 tasks 10..19 here llOwnerSay((string)this + " : " + (string)next); }}state state2{ state_entry() { // setup state2 tasks 20..29 here } touch_end(integer num) { integer completed = TRUE; // or false depending on actual task if (this == 20) { llOwnerSay("wooohoo! nearly there"); next = 27; } else if (this == 27) { llOwnerSay("one to gooooo!!!"); next = 28; } else if (this == 28) { completed = FALSE; if (completed) next = 29; // ooo! a winner else { llOwnerSay("nuuuuu !!! sorry you lost! o.m.g !!! have to start all over again (:"); next = 0; // back to start } } else next = 0; // is the end failsafe. return to start // exit state main; } state_exit() { // tidyup state0 tasks 20..29 here llOwnerSay((string)this + " : " + (string)next); }}

LepreKhaun wrote: If such precision was required, you might have a point. But since I no longer support that suggestion, regardless of the approximation, , I'll move on to more productive things and hope you do as well. precision is always required in the field of mathematics. Approximation is only ever done when the spacetime cost of computation outweigh the spacetime cost of finding the optimal solution. The optimal solution you already found previous so yes agree. Is unproductive to continue wasting spacetime on computing an answer to a problem where no problem exists

about the dominion part i was just taking the scripture literally. That God kicked them out of Eden. If all the animals were in Eden then they would of got kicked out as well or can see it as I understand you meaning. As a astral plane thingy? Is the Earth plane with all the animals. Is the Eden plane with Adam and Eve the planes being astral meaning that Adam and Eve can physically inhabit the same space as the animals. Which when I think about it a bit more makes more sense to me. Eden being a plane/state of wairua/soul/spirit/conciousness + about personal pos i personal dont dismiss/reject the existence of God in the spirit/soul sense. Might be. might not be. dunno. When I die then I will find out only if is true. If is false then I wont have any conciousness to know is false. So no biggie really either way I think and if true and the gatekeeper of Heaven determine that I am not good enough to join their gated community then I dont really care. Am not going to cry about it if rejected. I will just go on and find my own path in Hell if it turns out thats all there is for me. like they have demon levels in Hell apparently. so I will just try to level up as far as best as I can

i vote for this

is interesting line of thought this if they hadnt of eaten from the tree then would they have had babies and still be in the Garden today living eternally? so next thought what would have all the animals created before Adam, which are outside the Garden, be doing over zillions of years? Having babies and evolving is it possible that humans are not descended from Adam and Eve even tho they got kicked out of the Garden to be with the other animals? + also God created Adam in his own image. Is it possible that God is not of human form? If so then Adam was not of human form If go down this path then maybe we just want to be descended from Adam and Eve bc we want to think that God made us special to rule over all other animals. Maybe we just one of the other animals

LepreKhaun wrote: Ahhh, I see what you're saying. So, if that pattern applies: 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/256 * 1/256 = 2^(-15) * 2^(-15) * 2^(-15) * 2^(-15) * 2^(-15) * 2^(-15) * 2^(-15) * 2^(-8) * 2^(-8) = 2^(-121) ~ 3.7615819e-37 Then the formula becomes (3,300 - 2)*(3,300 - 1) * 8 * 3.7615819e-37= 87,040,816 * 3.7615819e-37 Giving us approximately 3.274e-29 instead of 8.748e-24. Mmmm, but I still agree with your original assessment- too big of a chance. Why risk it? Your design change is much better! is an arrangement of unique keys coming in n = 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/256 * 1/256 is right for the 1st. the 2nd n is 1 less than this. the 3rd n is 2 less. and so on instead of power(n,n) as your workings show, is factorial(n) coming in. refer the 2bit example i gave before which shows this ETA: [removed inconclusive statement from here] ETA more. 1/256 is actual not right. is (256/32768)/32768 + changing the end encoding as you originally suggested is the best way. Is no question about this. zero collision is better than non-zero collision no matter how tiny. Specially when is no extra coding cost or runtime load you know this. You a dev professional with 20+ years experience. If you raise this topic with your RL colleagues and tell them it dont matter bc tiny then the seniors in the group will frown at you. The juniors will go waaaaah !!!

look at the pattern xxxxxxxxAxxxxxxxxA xxxxxxxAA xxxxxxAxA xxxxxAxxA xxxxAxxxA xxxAxxxxA xxAxxxxxA xAxxxxxxA AxxxxxxxA

LepreKhaun wrote: irihapeti wrote: LepreKhaun wrote: And, on reflection, I see it was completely unneeded since the odds of ever matching anything NOT on a key boundary is vanishly small (it works out to be (number_of_keys_added - 2)*(number_of_keys_added - 1)/2*8 * 1.329228e-36 * 1/256 = approximately 0.000,000,000,000,000,000,000,008,748 - figuring 3,300 eight 15 bit possibilities with a ninth of 8 bits, all having to match) and one just needs llSubStringIndex(). I've changed my original code to reflect this much better solution since the chance of a false positive is so incredibly small the complication I had originally added is unnecessary. [Edited to more correctly show that the first two additions to the data string will, of course, never result in a false match and to cite my source as to how that extremely small figure is to be obtained. you might want to check your arithmetic 2 encoded keys: ABCDEFGHa XJKYMNOPb compare a 3rd key QRSTUVWXc where lowercase in the set [0..255] and uppercase in the set [0..32767] the potential cross-boundary collisions are: BCDEFGHax CDEFGHaXj DEFGHaXJk EFGHaXJKy FGHaXJKYm GHaXJKYMn HaXJKYMNo aXJKYMNOp + also need to factor in that the set of all keys is an arrangement using 2bits by example: k = [00,01] c = [0,0] compare [10]. 0 collision k = [00,01,10] c = [0,0][1,1] compare [11]. 1 collision --- k = [00,01] c = [0,0] compare [11]. 0 collision k = [00,01,11] c = [0,0][1,1] compare [10]. 0 collision --- k = [00,10] c = [0,1] compare [01] 1 collision k = [00,10,01] c = [0,1][0,0] compare [11] 0 collision --- k = [00,10] c = [0,1] compare [11]. 0 collision k = [00,10,11] c = [0,1][0,1] compare [01]. 1 collision. as the 2nd collision will never happen etc Well, you started off right. First possible mismatch is when the 3rd key is added and, yes, there are only 8 possible places for it to mismatch. But you skipped figuring out what is the possibility of each of those mismatches at that point. See, each of those 8 possible mismatches must each exactly match 9 characters. The first character has 2^15 possible states, so its chance of mismatching is 1 out of 32,768 or 0.000030517578125. The chance of the first character AND THEN the second character mismatching is 1/32768 * 1/32768 (since the first and second characters are independent of each, as per my cited source for how this math works). The chance of the 3rd character then mismatching after the first two is given as 1/32768 * 1/32768 * 1/32768 and so on until the final character, which has 2^8 states. So, the possibility of any 1 of those mismatches is: 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/32768 * 1/256 ~ 1.329228e-36 * 1/256 And, since we have 8 possible mismatches when we add the third key, its possible mismatch chance is: 8 * 1.329228e-36 * 1/256 Now, when we add the 4th key it has 16 places to mismatch, the fifth key has 24, the sixth key 32 etc (since if(character_place%9==0) we actually have a good match). And, yes, we do have to "factor in that the set of all keys is an arrangement", let me show you how my original formula does exactly that. Since the keys are added into the arrangement one at a time, we have to add the previous chances of mismatches as we go. In other words, though the 4th key has 16 possible mismatches, we can't disregard the 8 possibilities the third had. And when the fifth key is added, the running total is 8 + 16 + 24; 6th is 8 + 16 + 24 + 32; and so on to the 3,300th key added, which would be 8 + 16 + 24 + 32 + 40 + 48 + ... + 26,384; where "..." is a fairly long string of numbers, the last if which is (3,300 - 3) * 8. That final string of numbers can be simplified using a high school formula. First we factor out the 8, giving us 8 * (1 + 2 + 3 + 4 + ... + 3,298) and we see we're just doing the sum of consecutive integers (N(N+1)/2) so we simply plug in 3300 -2 for N, multiply by factor of 8 and then again by the chance of each mismatch and we have: (3300 - 2)*(3300 - 1)/2 * 8 * 1.329228e-36 * 1/256 or approximately 0.000,000,000,000,000,000,000,008,748 Hope that clears it up for you. look at the pattern. is 7 of 1/32768 and 2 of 1/256 ETA: also each key is not n where n = 0xFFFF,FFFF,FFFF,FFFF,FFFF,FFFF,FFFF,FFFF. Only the 1st one is. The 2nd key is n-1. The third key is n-2. The 4th key is n-3. The keys are an arrangement. Factoring all as 1/n puts your number out by billions look at the bit pattern example. It shows this + you over-estimating the probability of collision. is billions less probability than the number you posted if you are going to gamble with your script users then best to know what the probabilities actual are

i think that before can definitively answer the God question then have to answer the question: Is it possible to create a universe?

LepreKhaun wrote: And, on reflection, I see it was completely unneeded since the odds of ever matching anything NOT on a key boundary is vanishly small (it works out to be (number_of_keys_added - 2)*(number_of_keys_added - 1)/2*8 * 1.329228e-36 * 1/256 = approximately 0.000,000,000,000,000,000,000,008,748 - figuring 3,300 eight 15 bit possibilities with a ninth of 8 bits, all having to match) and one just needs llSubStringIndex(). I've changed my original code to reflect this much better solution since the chance of a false positive is so incredibly small the complication I had originally added is unnecessary. [Edited to more correctly show that the first two additions to the data string will, of course, never result in a false match and to cite my source as to how that extremely small figure is to be obtained. you might want to check your arithmetic 2 encoded keys: ABCDEFGHa XJKYMNOPb compare a 3rd key QRSTUVWXc where lowercase in the set [0..255] and uppercase in the set [0..32767] the potential cross-boundary collisions are: BCDEFGHax CDEFGHaXj DEFGHaXJk EFGHaXJKy FGHaXJKYm GHaXJKYMn HaXJKYMNo aXJKYMNOp + also need to factor in that the set of all keys is an arrangement using 2bits by example: k = [00,01] c = [0,0] compare [10]. 0 collision k = [00,01,10] c = [0,0][1,1] compare [11]. 1 collision --- k = [00,01] c = [0,0] compare [11]. 0 collision k = [00,01,11] c = [0,0][1,1] compare [10]. 0 collision --- k = [00,10] c = [0,1] compare [01] 1 collision k = [00,10,01] c = [0,1][0,0] compare [11] 0 collision --- k = [00,10] c = [0,1] compare [11]. 0 collision k = [00,10,11] c = [0,1][0,1] compare [01]. 1 collision. as the 2nd collision will never happen etc

LepreKhaun wrote: irihapeti wrote: jejejejje (: can still remember that convo + when you going to start the ethics debate in GD ?? Kant and Rawls and Locke and all that Thank you for clarifying your motivations. one day like probably never you going to get over yourself. in the meantime... oranges

LepreKhaun wrote: Good luck with all that... ty

if want to see whats up there then use this default{ touch_start(integer total_number) { llSetForce(< 0, 0, 999999999>, FALSE); }} will end up like this. this at 100,000 and still going edit if change 999999999999 to X or Y then will be the fastest trip you ever made across the grid. if dont crash first (: buildings avatars orbs pftt!!! will go straight thru them. i think LL capped setforce so it takes about 2-3 secs now to cross a sim. havent done that for ages. but is still pretty fast

get the best ASUS mobo that you can afford i have this one http://www.newegg.com/Product/ProductList.aspx?Submit=ENE&DEPA=0&Order=BESTMATCH&Description=ASUS+P8B75M&N=-1&isNodeId=1 goes good + also if your mother wants to board with you then make sure she pay her share ok q; (:

you got 1 unnecessary addition in the end encoding as well as reintroduce collision + also if move the encoding to the harness side then more oranges. 3424 about

jejejejje (: can still remember that convo + when you going to start the ethics debate in GD ?? Kant and Rawls and Locke and all that

if you got nothing much to do then open the World Map. in last Location box enter 4095 and click the Teleport button (:

Dillon Levenque wrote: 'roar'

Perrie Juran wrote: Madelaine McMasters wrote: irihapeti wrote: if was a bit weird then i usual sit on it again just to make sure is actual really weird and not just me (: I think there's some law of self observation that applies here, insuring that you can't actually know whether it's the thing, or you, that's weird. It requires others telling you for the truth to be revealed. ;-). Self Aweirdness? jejejejjeje (: i like that. imma self aweird lol jejejejjejjeje (:

if anyone do use the above algo then replace this code: b = (b & 0xFF); e += llBase64ToString(llIntegerToBase64( 0xE0808000 | (((b + 0x800) << 12) & 0xF000000) | (((b + 0x0800) << 10) & 0x3F0000) | ((b << 8) & 0x3F00))); with this b = (b & 0xFF) | 0x8800; e += llBase64ToString(llIntegerToBase64( 0xE0808000 | ((b << 12) & 0xF000000) | ((b << 10) & 0x3F0000) | ((b << 8) & 0x3F00))); + means that the chance of cross-boundary collision is 0. 0 like in never dunno why LepreKhaun is now regressing his own design. It dont make any sense at all to do this. The coding cost of zero collision guaranteed is zero + the cost of non-zero isnt mathematical when it happens. The cost is a really unhappy customer a once in a zillion year storm ? once in a zillion zillion ? a zillion zillion zillion even. Only needs to happen once and unhappy. The coder who sold you the non-zero app in these situations will just go: gosh !!! wow !! really ??? like relly really !!??!!? woooo !!! how unlucky can you be ??? oh! well

if take your question lieral then yes. i done everything q; (: well clicked it on or sat on it anyways. at least once. if was a bit weird then i usual sit on it again just to make sure is actual really weird and not just me (: