Faster strategy is to make the cell just loop over the virus duplication until it dies of exhaustion to get exponential growth. No need to directly kill it. But I guess that will be part 4 >:)
Yeah, that's part of my original strategy when I made my first virus! It's also more space-efficient, I think you only need 5 codons to actually get the job done :O
I wouldn’t say that the cells infected with “5× None-None” (or the first “Remove-Wall” attempt) UGOs _never_ die. I wouldn’t even say that uninfected cells never die. The waste particles could theoretically happen to bunch up all at once and hit the same wall in a short period of time and kill off a cell before it has a chance to repair it, especially more inefficient cells. I mean that one cell at 4:30 came pretty close to dying.
As cary said, hes not an expert in genetic and stuff so his work isn't perfect. But with more research and calculations, you could make the cells last forever without modifications
Speaking of mutations, I made the virus that Cary did with a few more writes, and the virus kept cutting things off! I'm using the open-source version, in case that changes anything, and I think this is a bug. I see no problems with my virus that would cause this.
1: Virus is made to just replicate 2: Cells compete and cells with viruses die earlier 3: Virus replicates and maybe adds helpful code but still weakens cell over all (maybe another codon repair to make up for extra codons) 4: Cells develop anti-virus 5: Now viruses try to kill/weaken hosts before replicating using all resources as fast as possible
Idk why, but I find these Simulator videos extremely interesting! They're my favorites! Also, my prediction for the most effective virus next video is that you'll swap the "Remove Wall" gene with more "Write None" genes that copy the virus. This way, the cell will fill up with so many viruses it will explode! And then the viruses inside are gonna be free and start infecting a lot more cells, just like a real viral infection!
I've found that using REMOVE │ WALL reduces the amount of viruses that can be produced by any one cell, but since it kills the cell early it speeds things up a lot.
I've been experimenting with the sketch, and I've found out that if you increase the world size, you get a fractal-like pattern! It's also important to note that only a few values for WORLD_SIZE actually work, as otherwise there are cells directly on the bounds and the waste removal code fails because there's no space left for the waste. I've successfully tried the values 4, 9, 12 (default), 25, 28, 36, 81 and 84 (some perfect squares and some perfect squares + 3 work, I'll examine the code that generates the world to see if that's necessarily the case). However, the food particle number is constant, so cells might die (with WORLD_SIZE = 4, they die in seconds), you should also adjust that, and the frame rate drops for bigger worlds (as is to be expected).
Numbers that work are 1, 4, 9, 12, 25, 28, 33, 36, 73, 76, 81, 84, 97, 100, 105, 108 Taking differences gives 3, 5, 3, 13, 3, 5, 3, 37, 3, 5, 3, 13, 3, 5, 3 That's an abacaba pattern. (start with the first term, then put the next between tow identical sequences) The reason for this is because of the fractal nature of the Sierpinski carpet used to make the arrangements. Any number will work, as long as it no cells touch an edge, so you can find smaller ones hidden in larger ones. Many sequences also work, like powers of 3 times 4, but many squares are just coincidences. I actually used the pattern to make more working numbers before testing them. Using trial and error, I found the next number in the sequence after 37 is 109, so the next working number after 108 is 217 (it seems to be that the big jumps are 1+the number they first start from).
Oooohh, that's an even better term to describe it! It reminds me of that toy model that all the kids in my middle school used to play in the computer labs. I think it was called "The Powder Toy" or something...
This doesn't actually work, since it releases a 10 codon virus which is sterile and cannot infect any cells, you need to change it to: Read RGL -1 to 7
@TheCandyCouch No it does fit everything, remember it's hand is at the - Move Hand - RGL 0 to 0 Meaning -1 is - Move Hand - Inward and 7 is - Remove Food
My recipe's times: - 1st (& only) infection at 20t (ticks). - 1st dead cell at 155t. - All cells are infected after 460t. - The whole organism is dead after 555t. Here's the recipe: Move Hand (0, 0) Move Hand Inwards Read (0, 4) Move Hand Outwards Write (0, 4)
It would be cool to combine this with the Conway's game of life. like the virus simulator just runs as normal but every 100 ticks maybe it does one iteration of Conway's game of life and each cell is one of the grids. then they can regenerate and die and stuff and you can experiment with different ways the cells are arranged
simple ugo: mv hand in mv hand rgl 0,0 read rgl -1,3 mv hand out write none it just keeps making copies that end up bouncing around the cell wall until it breaks and then the copies can spread, sorta just like how the none none ugo killed the cell except this makes copies which have the ability to continue the chain. if you want it to infect faster then just add a ton of write commands to the end and adjust the read command to fit them in. finally, you might wanna keep the cell alive for longer to produce more ugo's before bursting but there arent enough commands to fit all that in rip leafy
To keep the cell alive longer you can make this UGO : mv hand rgl 0,0 mv hand in read rgl 0, 8 write -5, 3 mv hand out digest food rem waste rep wall write none
Cary Huang's Virus Simulator 2020: Watch the 44 cells live in harmony and then develop the perfect virus to kill them off as quickly as possible! Virus Simulator 2020: The pandemic simulator like no other! Now open-source!
*Carykh:* "I don't want to have two different branches at the same time running on different platforms; that would be too much of a mess." *Minecraft:* "I want to have two different branches at the same time running on different platforms; it is almost too much of a mess."
i just realized you can put two or more WRITE NONE operations in series for exponential growth. for some reason the simulator really fun to experiment and play with :)
I think to make this virus you created ideal, you should get rid of the “remove wall” bit; that way, instead of just making one virus and dying, the infected cell just keeps making more and more viruses until they break its wall and they burst (just like how actual viruses work).
I made a fun virus to watch: move hand inward move hand RGL(0,0) read RGL(-1,4) move hand outward write RGL(0,0) repair wall This makes up to 13 equivalent viruses per infected cell. It's usually 5 to 11 ev/ic It's basically a regular UGO replicator with an added repair wall codon to keep the cell building viruses for longer.
In the java version, I made a virus that got everything infected by 235 since edit, and all dead by 277 All it did was Move hand inward, move to 0,0, read -2,6. move outward, write, write, write, write, write Most of the cells ran out of energy after writing all the viruses and just exploded on their own
If you want something really deadly try this : mv hand 0,0 mv hand in read 0,8 mv hand out write write write write rem wall I've got every cell infected by 160 and all dead by 190
I think it's a reference to the elimination music that plays in the TWOW videos, but also played in this video when the virus killed a cell, like at 4:24
I love how you take feedback so well, it makes your videos so much better. As a postgraduate doing their Masters of Infectious Diseases it’s nice to see someone doing their best to understand what they are talking about and share it with their audience using their own skills in computer programming.
Most cells that die during viral infections are actually killed by cytotoxic T cells that trigger apoptosis after recognising viral peptides being presented by the MHC class 1 of infected cells. That’s why an overactive immune response is what typically kills the host rather than the virus itself, and why corticosteroids are used to dampen the immune response.
Does "Digest Waste" do anything, such as dircetly harm cell health? can I Digest Wall? what about Remove RGL 0 to 0? What I'm saying is that some documentation like an md file on what each combination codon does would be great.
Digest Waste doesn't do a lot. It reduces energy by 1.4% as is standard for all commands, and a green line appears between the hand and the waste particle like with Digest Food. Otherwise, nothing of note happens. The waste remains waste, and no other damage is done. Remove RGL does even less. It just reduces energy by 1.4%. No codons are removed.
Fun fact: You can increase the world size in the code, if your PC can handle it. If you can handle it, I recommend setting the world size to 36 due to how the cells are generated. You also want to increase the max food significantly, or otherwise the entire board will starve to death. 1800 seems to work fine. I got a virus to eliminate the entire board in a mere 400-ish ticks. (movehand 0-0, movehand inward, read 0-8, movehand outward, write none, write none, write none, write none, write none)
I figured it's faster when you put "remove wall" at the end. It produce one less copy of the virus, but it doesn't have to wait until the wall breaks before spreading the viruses. Overall, it's much faster. Although, I haven't tried with a oversized world like you did... I also tried to produce less virus, to try to keep the cell alive for longer, which give a chance to get a 2nd iteration of virus generation, but that's still slower than exploding and spreading the viruses and let other cells generate more viruses.
My record for 100% kill with one starting UGO on the OpenProssesing version: *~282T* Can you beat me? My strat was: MH ¦ IN MH ¦ 0,0 RE ¦ -2,6 MH ¦ OUT WRI ¦ NON WRI ¦ NON WRI ¦ NON WRI ¦ NON WRI ¦ NON I'm not gonna get a better score because I'm too lazy to simulate a different one or download processing though.
Dang, that's pretty fast! I think I've gotten down to the 230s in my test runs (although I don't wanna reveal my genome just yet). It looks like Hallo beat me with 208 though? (Of course, a lot of it comes down to random chance of the particle-bouncing)
For 251t I used: MH IN MH 0,0 RD -1,7 MH OUT WR NONE WR NONE WR NONE WR NONE WR NONE Looks Hallo's version does better (210t for me) by replacing the last WR NONE with RM WALL, which results in the cell dying sooner.
A lot of people are saying that the most efficient thing would be to keep on making viruses until the cell explodes, but that isn't true. It took around 250t for all cells to die with this: Move hand inward Move hand RGL (0 to 0) Read RGL (-1 to 7) Move hand outward Write none Write none Write none Write none Write none With that, cells kept on producing viruses until their walls couldn't handle it, which would be anywhere from 4 to 10 viruses. But usually, the cell would make 5 viruses and then take a bit of time to explode (but not enough time that it would make any more) Replacing the last codon with 'Remove wall' instead of 'Write none' significantly speeds up the process. In my test it took 200t instead of 250t, because even though cells were producing less viruses, they were dying faster.
The first souloution Move hand RGL (0 to 0) Move hand Inward Read RGL (0 to 8) Move hand Outward Write RGL (0 to 8) Write RGL (1 to 9) Write RGL (2 to 10) Write RGL (3 to 11) Write RGL (4 to 12)
My prototype for a "zombie" virus that completely overwrites the cell's genome: Move hand Inward Move hand (0,0) Read (-1,7) Write (8,16) Move hand Outward Write None Repair Wall Digest Food Remove Waste
I made a mutating virus, It only picks up one random codon, but it's still technically mutating. Here it is: NONE | NONE MOVE HAND | INWARD MOVE HAND | WEAK LOC READ | RGL (0 to 0) MOVE HAND | RGL (0 to 0) WRITE | RGL (-4 to -4) READ | RGL (-4 to 4) MOVE HAND | OUTWARD WRITE | NONE
I made a virus with the ability to lay dormant in a cell, Sometimes it will just stay there in the cell not doing anything, it takes forever to kill all the cells. Here it is: MOVE HAND | INWARD MOVE HAND | RGL (0 to 0) WRITE | RGL (4 to 4) READ | RGL (-1 to 4) MOVE HAND | OUTWARD NONE | NONE
I barely understand this but this is extremely interesting. I feel like you could help a lot of people understand how diseases work with something like this.
Do you know how to make a vaccine in this game? "Infect" a cell with a harmless snippet of the actual virus so when it comes ,the ugo bounces out pf the vaccinated cell
Thats not how vaccines work in real life. Nor is it possible for a vaccine to work without an immune system. It’s like supplying weapons to a nation with no soldiers…
@@DanksterPaws well carykh already said that this isn't a exact replica of real life and just show some concepts, and my vaccine thing probably isn't a real mechanic of the game but more of a exploit
355 Ticks (Javascript Version) with the following UGO: Move Hand Inward Move Hand RGL (0 to 0) Read RGL (-1 to 4) Write RGL (5 to 10) Move Hand Outward Write None It mimics the real world behaviour of some viruses to force the cell to only produce virus particels until the cells bursts. In the Simulation you end up with 2 to 3 new UGOs that are released after a quite quick death of the cell, because all energy was taken to produce UGOs and to insert multiple copys of the UGOs Codons into the cell. Pretty neat if you ask me.
You should make it so that when it copies the codons, it also copies the decay (when injected outward), thus making it not as easy to cause a successful virus.
how does this work? when I run it doesn't show the full screen and the side doesn't show buttons like the "Make UGO" button (I'm using proccessing 3.5.4
I think its a problem with the game size and the size of ur screen so if you go to line 61 (you can see what line you are on on the left side of the window) there should be a bit of code that looks like this size(1728,972) if you find the size of ur screen in pixels and replace the numbers it will change the size of the game so you can fine tune it to ur screen size fun fact like 30 others have a similar problem
@@craftingnerf2593 i have the same problem, thanks a lot for the fix! edit: it didn't work BUT i found that changing int W_W and int W_H to the resolution of your screen lets you make viruses, just can't change their size (always going to be 5 codons big)
2 things. 1. I was the 10,000th viewer on the virus simulator on open processing! 2. I also made my own virus on that where you write it 4 times and don't move hand outward near the end cause it would have already done that (and read RGL -1 to 7).
I've played with your code a bit and I realized that it's almost turing complete! You can even make evolvable code/viruses (which I did) that is able to multiply by itself. To do so: 1. Add mutations. Like in 1 in 10 000 chance every step that the codon can change to a totally new one 2. Allow cell regrowth. 1 in 100 chance that the dead cell may come alive again 3. Increase maximum codon amount to 60+ 4. Increase time speed Then whole cells will emerge that copy big parts of their genomes until they burst and seed their genomes to all other cells. This will repeat till the "virus" genome is broken beyond repair by other cells bursting. To solve this, you could add a different kind of self repair, which would need additional "compare" codon and a "remove" codon. Then a whole new types of viruses/cells should be able to evolve by themselves that just dominate the population.
You misspelled one of the files in your GitHub repo. For "Cell.pde", you added an extra dot, making it "Cell.pde.", so Processing won't automatically find it. Edit: just opened a pull request to fix it.
I tried a few things : First, the most basic idea: Let the virus reproduce until it overcrowds the cell and destroys the wall through collisions. 6 UGOs was usually the limit before a cell died, and then those would be released and infect more until the tissue is killed. Took ~584t. Then I just ramped it up. Why not speed the process up and have the virus repeatedly reproduce? The virus now writes itself 5 times. Apparently, writing a UGO drains a ton of energy and 5 writes is almost always enough to doom a cell to exhaustion. Even though only 5 UGOs are released instead of 6 when a cell dies, the cell is killed much quicker, and infection is faster. Took ~250t. My final virus was one that corrupted the cell. It would overwrite the weakest command with "move hand inward," and the reproduce a UGO of the virus. A cell might lose the ability to repair its wall, eat food, or remove waste. It may even damage the virus itself, neutering either its killing potential or its infectivity. Eventually, the cell dies and releases 3 or so UGOs. This virus killed faster than virus 1, but released fewer UGOs, and thus infected fewer cells. It wound up with an almost identical time to V1, taking ~588t.
Looked through the code for a while to try to see how I could edit the arrangement of the cells. Turns out they're always just generated in the shape of the Sierpiński carpet. Very clever
Turns out if you duplicate the "Write None" Codon a couple more times, it becomes an exponential killing machine. One cells produces 3 viruses. Leading to 1 infection, then 3 with 1 killed, then 9 with 4 killed, then 27 with 13 killed, etc I also had one case where due to the position of the codon in the cell, the cell produced 3 viruses, then ran out of energy to kill itself, but died anyways because it wasn't repairing the wall either
the perfect UGO should be the one you made that can recall itself infinitelly but with 2 or more write code, like this it takes more to kill but will replicate itself more like a real virus
really interesting thing i found was to throw a bunch of single "write none" UGO and see thier effects on cells (I actually turned one into a write non factory and let it explode). It can have very different and interesting effects depending on where it lands in the host cell!
I can't get the processing version to work, I tried processing 3.3.3, like the readme file says, but it keeps giving an error that tells me that " size(1728,972); can't be used here".
I think its a problem with the game size and the size of ur screen so if you go to line 61 (you can see what line you are on on the left side of the window) there should be a bit of code that looks like this size(1728,972) if you find the size of ur screen in pixels and replace the numbers it will change the size of the game so you can fine tune it to ur screen size
not to sound like one of those "OMG wHerE PaRT 4 y u nO MakE It" people but are you going to finish this or not? I thought you made a new years resolution to finish this and other things but I can't find it? please explain
Here is an interesting one: it has an initial setup of 3 codons which copies the virus to memory, a payload of 3, and then a final section, still 3 codons, which serves the purpose of executing the payload again, skipping(overwriting) the initial genome of the cell. (Setup) MOVE HAND | RGL (0 to 0) MOVE HAND | INWARD READ | RGL (0 to 8) (Payload) MOVE HAND | OUTWARD DIGEST | FOOD WRITE | NONE (Final Section) MOVE HAND | RGL (0 to 0) MOVE HAND | INWARD WRITE | RGL (0 to 8)
Well, it's pretty PRETTY basic, but I got it. The first generation makes 2 copies of the second one, then it kills the host. The second generation just kills the host. The payload for the second generation is arbitrary, but can only be two codons long at most. (Gen. One) MOVE HAND | RGL (0 to 0) MOVE HAND | INWARD READ | RGL (7 to 8) MOVE HAND | OUTWARD WRITE | NONE WRITE | NONE REMOVE | WALL (Gen. Two) MOVE HAND | OUTWARD REMOVE | WALL If you could fit more codons inside the UGO, you could make virtually unlimited copies of Gen 2, without "executing" its payload (which could also be more complex than just killing itself)
Soooooo, I've edited the program to allow making UGOs with unlimited amount of codons and I've increased the maximum number of codons a cell can have. I've created a virus that can make a copy of another arbitrary virus, without executing its genome. Instead it executes an alternative routine which we can use to keep the cell alive for a bit more. It might be possible to optimize it a little (in some places you have a MOVE HAND | INWARD followed by a MOVE HAND | OUTWARD), but it gets the job done. In my tests it was able to create up to 3 copies of G2 before the host either starved or exploded. Although it doesn't overwrite the cell's genome, it might interfere with its functions (the hand might not be placed in the right spot when the interpreter returns to the original genome of the cell), which often causes the cell to fail when it attempts to restore its codons; but that's hardly an issue, since the cell is gonna die way before any codon goes bad. G2 is a simple self-replicating virus, which I think we'll see in the next episode; again, the payload could be anything. Here's the entire genome (28 codons!), with a very brief explanation: (Create a copy of G2) 00. MOVE HAND | RGL (0 to 0) 01. MOVE HAND | INWARD 02. READ | RGL (9 to 13) 03. MOVE HAND | OUTWARD 04. WRITE | NONE 05. MOVE HAND | INWARD (Copy G2 to buffer, then overwrite G2 with alt. rout.) 06. WRITE | RGL (23 to 27) 07. READ | RGL (18 to 22) 08. WRITE | RGL (9 to 13) (Generation 2; the offsets here are relative to the new virus) 09. MOVE HAND | RGL (0 to 0) 10. MOVE HAND | INWARD 11. READ | RGL (0 to 4) 12. MOVE HAND | OUTWARD 13. WRITE | NONE (Copy buffer to G2, then overwrite buffer with alt. rout.) 14. READ | RGL (23 to 27) 15. WRITE | RGL (9 to 13) 16. READ | RGL (18 to 22) 17. WRITE | RGL (23 to 27) (Alternative Routine) 18. MOVE HAND | OUTWARD 19. DIGEST | FOOD 20. REMOVE | WASTE 21. REPAIR | WALL 22. MOVE HAND | INWARD (Buffer) 23. NONE | NONE 24. NONE | NONE 25. NONE | NONE 26. NONE | NONE 27. NONE | NONE
I cant wait to play this, I have to wait because im about to go to sleep so I dont have access to my computer. Have to do it tomorrow. But experimenting around will be really cool
I set the max number of codons to 200 instead of 20 and the max number of UGO codons to 99 instead of 9. I then created a UGO that writes UGOs until out of energy, then hs a bunch of blank codons so that lots of waste will be produced, which will attack more walls. Edit: Multiple UGOs went into one cell, making a waste explosion, which quickly destroyed nearby healthy cells.
I bet 20 dollars that the next episode will have a virus that just keeps adding viral objects within the cell untill the cell walls cant repair fast enough. The interesting thing is that is similar to how actual viruses work
By looping the recursion theory and maxing out replication, I managed to get "full death" in about 200 ticks on the Open Processing version using this UGO: Move Hand Inward, Move Hand RGL (0 to 0), Read RGL (-1 to 7), Move Hand Outward, Write None, Write None, Write None, Write None, Remove Wall. Only 9 lines because that appears to be the maximum in OP, no idea if this strategy works better or worse due to max. line changes in the better version.
To guarantee an integer in js, you can always do x = a / b | 0 (if a, b > 0) x = +(a / b).toFixed(0) (converts to string and than back) x = a / b ^ 0 (when you are certain a / b !== 0)
I made a mutating virus, It only picks up one random codon, but it's still technically mutating. Here it is: NONE | NONE MOVE HAND | INWARD MOVE HAND | WEAK LOC READ | RGL (0 to 0) MOVE HAND | RGL (0 to 0) WRITE | RGL (-4 to -4) READ | RGL (-4 to 4) MOVE HAND | OUTWARD WRITE | NONE
10:07 If you "inject" enough of these viruses into the organism, you can kill it off in no time! Also, btw i made a version with 3 "Write Virus" codons and it's working very good! it took about 220t for all the cells to get infected with the triple virus and it took only 246t for all the cells to die. I also made another version where it makes 2 more of itself while making the cell push food out which means it gets much less nutrients as the Viruses bang inside of its membrane instead of making it just die immediately. It took 330t for everyone to get infected and 428t for the last cell to finally die.
I've found the best strategy is to make a virus that actively repairs the wall while multiplying. Eventually, because of all the missing codons, the wall will break and release way more virus particles than before. It's also significantly more potent because it can create so many replicas of itself within such a short amount of time
My most common code does that AND gives it more energy at the same time. Absolutely devastating. It releases like 12 viruses on cell death. MOVE HAND INWARD MOVE HAND (RGL 0 to 0) READ (RGL -1 to 7) MOVE HAND OUTWARD WRITE NONE WRITE NONE DIGEST FOOD REPAIR WALL WRITE NONE
By writing the UGO to write "none" outwardly five times (a total of eight codons each), the cell exhausts of energy after generating five UGOs, and the cell wall soon bursts due to lack of maintenance, releasing five UGOs into the interstitial fluid
Hi. I'd appreciate if you added support for different sized monitors. Just making so changing W_W and W_H have an actual effect would be appreciated. Perhaps you will already do that but only once 4/4 comes out. (The Browser works just fine tho, phew!)
my favourite is move hand inwards, move hand rgo 0 to 0, read rgo -1 to 7, move hand outward, write none, write none, write none, write none, remove wall. I would use the last one with write none aswell but sometimes the cell like barely lives through it all. If there was only one more i could fit that would be great.
I thought on two similar strats. On the first the idea is to substitute the entire code of the cell with the one from the virus, here's the code: MOVE HAND inward MOVE HAND rgl (0 to 0) READ rgl (-1 to 7) WRITE rgl (8 to 17) MOVE HAND outward WRITE none WRITE none WRITE none WRITE none The second one is similar, but instead of doing WRITE none 3 times, you trade one of them for a DIGEST food, because I every time the cell was stopping to work due to energy way too early, here's the code: MOVE HAND inward MOVE HAND rgl (0 to 0) READ rgl (-1 to 7) WRITE rgl (8 to 17) MOVE HAND outward DIGEST food WRITE none WRITE none WRITE none Idk which one is better, because you need to trade creating a new UGO for another command, but you might get more rounds of executing the code, so in theory more UGOs. I thought on adding a REPAIR wall command after the DIGEST food to increase the longevity of the cell before it explodes a bit more so it can create even more UGOs, but I don't think that would help a lot since it would take forever for a cell to explode.
if this is a simulation of a blood stream you should probably add white blood cells that attack ugos before they infect cells. (the immune system isnt only made up of white blood cells but implementing the ENTIRETY of the immune system would be an epic task and would defeat the purpose of the simulation)
"This is going to be the last part because I want to be done with this project"
>part 3/4
Twisted Logic ya wanna watch the rest of the video?
@@NStripleseven shh it's an funny
r/usernamechecksout
Now that’s some
*Twisted Logic*
Don’t worry there is NO PART 4
Faster strategy is to make the cell just loop over the virus duplication until it dies of exhaustion to get exponential growth. No need to directly kill it. But I guess that will be part 4 >:)
Yeah, that's part of my original strategy when I made my first virus! It's also more space-efficient, I think you only need 5 codons to actually get the job done :O
Smart
Yeah, thought of the same thing.
I've made it do 4 copies and if it still has enough energy left it self destructs. Killed all in 210 ticks.
Here I made this:
MOVE HAND INWARD
MOVE HAND RGL (0 to 0)
READ RGL (-1 to 7)
MOVE HAND OUTWARD
WRITE NONE
WRITE NONE
WRITE NONE
WRITE NONE
WRITE NONE
You know, naming the file "Virus.pde" seems a bit questionable.
Imagine downloading the game and being told to run the file.
oopsies that is true!
i should've been more descriptive and called it "virus_WILL_SPREAD_WHEN_LAUNCHED.pde"
@@carykh lol
@@carykh *literally laughed so hard I fell off my bed*
@@nohintshere literally laughed i accedently fallen off 10 km tower...
wait.
I wouldn’t say that the cells infected with “5× None-None” (or the first “Remove-Wall” attempt) UGOs _never_ die. I wouldn’t even say that uninfected cells never die. The waste particles could theoretically happen to bunch up all at once and hit the same wall in a short period of time and kill off a cell before it has a chance to repair it, especially more inefficient cells. I mean that one cell at 4:30 came pretty close to dying.
Think of it as "no guaranteed death within a finite amount of time"
Or there are no food particles inside every time it gets to DIGEST | FOOD so it starves
More none codons do actually increase the chance of cell death due to the fact it uses more energy, without increasing food digestion.
As cary said, hes not an expert in genetic and stuff so his work isn't perfect. But with more research and calculations, you could make the cells last forever without modifications
true
This virus isn’t perfect, but it enables random mutations:
MOVE HAND INWARD
READ RGL (0, 8)
MOVE HAND OUTWARD
WRITE NONE
Nice
that's an simple virus but effective
The seed of evolution
Speaking of mutations, I made the virus that Cary did with a few more writes, and the virus kept cutting things off! I'm using the open-source version, in case that changes anything, and I think this is a bug. I see no problems with my virus that would cause this.
Miluna_Mimi Could you list your codons? Maybe I can debug the issue for you.
Cell: "Hey why do I remember the numbers 45-4700-5795-46-60-46-23?"
Also cell: "OH WAIT NO HELP-"
THE NUMBERS MASON
WHAT DO THEY MEAN
1: Virus is made to just replicate
2: Cells compete and cells with viruses die earlier
3: Virus replicates and maybe adds helpful code but still weakens cell over all (maybe another codon repair to make up for extra codons)
4: Cells develop anti-virus
5: Now viruses try to kill/weaken hosts before replicating using all resources as fast as possible
part 5 material right here, cary
13:07
Ah, yes the most deadly virus,
*I N W A R D*
wait till he sees outward
gourmetbird, wait till he watches Onward.
@@felipevasconcelos6736 oh no... dont say that you're gonna kill him
@@felipevasconcelos6736 wait till he sees bottomward
BAHAHAHAHAHAHA
Edit: I wrote this before I read the other replies. Other replies = ????? Original comment = BAHAHAHAHAHAHA
Idk why, but I find these Simulator videos extremely interesting! They're my favorites!
Also, my prediction for the most effective virus next video is that you'll swap the "Remove Wall" gene with more "Write None" genes that copy the virus. This way, the cell will fill up with so many viruses it will explode! And then the viruses inside are gonna be free and start infecting a lot more cells, just like a real viral infection!
I've found that using REMOVE │ WALL reduces the amount of viruses that can be produced by any one cell, but since it kills the cell early it speeds things up a lot.
I've been experimenting with the sketch, and I've found out that if you increase the world size, you get a fractal-like pattern! It's also important to note that only a few values for WORLD_SIZE actually work, as otherwise there are cells directly on the bounds and the waste removal code fails because there's no space left for the waste. I've successfully tried the values 4, 9, 12 (default), 25, 28, 36, 81 and 84 (some perfect squares and some perfect squares + 3 work, I'll examine the code that generates the world to see if that's necessarily the case). However, the food particle number is constant, so cells might die (with WORLD_SIZE = 4, they die in seconds), you should also adjust that, and the frame rate drops for bigger worlds (as is to be expected).
Yeah it's in the shape of the Sierpiński carpet. The cells actually fill in the areas which are cut out of the fractal.
Numbers that work are 1, 4, 9, 12, 25, 28, 33, 36, 73, 76, 81, 84, 97, 100, 105, 108
Taking differences gives 3, 5, 3, 13, 3, 5, 3, 37, 3, 5, 3, 13, 3, 5, 3
That's an abacaba pattern. (start with the first term, then put the next between tow identical sequences)
The reason for this is because of the fractal nature of the Sierpinski carpet used to make the arrangements. Any number will work, as long as it no cells touch an edge, so you can find smaller ones hidden in larger ones. Many sequences also work, like powers of 3 times 4, but many squares are just coincidences.
I actually used the pattern to make more working numbers before testing them.
Using trial and error, I found the next number in the sequence after 37 is 109, so the next working number after 108 is 217 (it seems to be that the big jumps are 1+the number they first start from).
Here's the numbers up to 10000: 4, 9, 12, 25, 28, 33, 36, 73, 76, 81, 84, 97, 100, 105, 108, 217, 220, 225, 228, 241, 244, 249, 252, 289, 292, 297, 300, 313, 316, 321, 324, 649, 652, 657, 660, 673, 676, 681, 684, 721, 724, 729, 732, 745, 748, 753, 756, 865, 868, 873, 876, 889, 892, 897, 900, 937, 940, 945, 948, 961, 964, 969, 972, 1945, 1948, 1953, 1956, 1969, 1972, 1977, 1980, 2017, 2020, 2025, 2028, 2041, 2044, 2049, 2052, 2161, 2164, 2169, 2172, 2185, 2188, 2193, 2196, 2233, 2236, 2241, 2244, 2257, 2260, 2265, 2268, 2593, 2596, 2601, 2604, 2617, 2620, 2625, 2628, 2665, 2668, 2673, 2676, 2689, 2692, 2697, 2700, 2809, 2812, 2817, 2820, 2833, 2836, 2841, 2844, 2881, 2884, 2889, 2892, 2905, 2908, 2913, 2916, 5833, 5836, 5841, 5844, 5857, 5860, 5865, 5868, 5905, 5908, 5913, 5916, 5929, 5932, 5937, 5940, 6049, 6052, 6057, 6060, 6073, 6076, 6081, 6084, 6121, 6124, 6129, 6132, 6145, 6148, 6153, 6156, 6481, 6484, 6489, 6492, 6505, 6508, 6513, 6516, 6553, 6556, 6561, 6564, 6577, 6580, 6585, 6588, 6697, 6700, 6705, 6708, 6721, 6724, 6729, 6732, 6769, 6772, 6777, 6780, 6793, 6796, 6801, 6804, 7777, 7780, 7785, 7788, 7801, 7804, 7809, 7812, 7849, 7852, 7857, 7860, 7873, 7876, 7881, 7884, 7993, 7996, 8001, 8004, 8017, 8020, 8025, 8028, 8065, 8068, 8073, 8076, 8089, 8092, 8097, 8100, 8425, 8428, 8433, 8436, 8449, 8452, 8457, 8460, 8497, 8500, 8505, 8508, 8521, 8524, 8529, 8532, 8641, 8644, 8649, 8652, 8665, 8668, 8673, 8676, 8713, 8716, 8721, 8724, 8737, 8740, 8745, 8748.
That's how human tissue is as big as
And also some cells die of hunger on bigger worlds.
I've also heard the term "Toy Model" used to describe a simplified simulation of a more complex phenomenon.
Oooohh, that's an even better term to describe it! It reminds me of that toy model that all the kids in my middle school used to play in the computer labs. I think it was called "The Powder Toy" or something...
@@carykh It was called The Powder Toy.
@@carykh powder toy, from danball.
@@Stingpie There's two of them actually, an online version which is more bare bones and a downloadable version which is actually really versatile
To this day still waiting for part 4
and still waiting...
@@dawnsclim4382 [F]
Still waiting
@@xxpromlggamerproxx Damn. I guess it's coming out after Half-Life 3 at this point.
“Last part” (three of four)
i see what you did there
four
Odd
Ye lol
He did say that he will split the video based on the poll. Audio was recorded before that I bet.
Communism Virus (fixed):
Move Hand Inward
Move Hand RGL 0 to 0
Read RGL -1 to 7
Move Hand Outward
Write
Write
Write
Write
Remove Food
This doesn't actually work, since it releases a 10 codon virus which is sterile and cannot infect any cells, you need to change it to:
Read RGL -1 to 7
@TheCandyCouch No it does fit everything, remember it's hand is at the
- Move Hand - RGL 0 to 0
Meaning -1 is
- Move Hand - Inward
and 7 is
- Remove Food
@TheCandyCouch It isn't relative to the current command (unless it's a move hand command) its relative to the hand.
@@PyPylia yeah i accidentally posted it too early sorry
remove the remove food codon. Just write until it explodes, like mine.
Has anyone realised this being is a donut?
Not until I read *this*
Miluna_Mimi the more you know
So are humans, basically. (With a few extra holes.)
wiped out all cells in 188t. very cool little project here! it would be cool to see this turned into a full programming-esk game.
Im a genome and you’ve been genomed
My recipe's times:
- 1st (& only) infection at 20t (ticks).
- 1st dead cell at 155t.
- All cells are infected after 460t.
- The whole organism is dead after 555t.
Here's the recipe:
Move Hand (0, 0)
Move Hand Inwards
Read (0, 4)
Move Hand Outwards
Write (0, 4)
@Frederick Kellett
Sorry, I meant "1st manual virus insertion".
It would be cool to combine this with the Conway's game of life. like the virus simulator just runs as normal but every 100 ticks maybe it does one iteration of Conway's game of life and each cell is one of the grids. then they can regenerate and die and stuff and you can experiment with different ways the cells are arranged
simple ugo:
mv hand in
mv hand rgl 0,0
read rgl -1,3
mv hand out
write none
it just keeps making copies that end up bouncing around the cell wall until it breaks and then the copies can spread, sorta just like how the none none ugo killed the cell except this makes copies which have the ability to continue the chain.
if you want it to infect faster then just add a ton of write commands to the end and adjust the read command to fit them in.
finally, you might wanna keep the cell alive for longer to produce more ugo's before bursting but there arent enough commands to fit all that in
rip leafy
Hey hey hey, don't just copy real world behaviour into this simulator game >:(
To keep the cell alive longer you can make this UGO :
mv hand rgl 0,0
mv hand in
read rgl 0, 8
write -5, 3
mv hand out
digest food
rem waste
rep wall
write none
"rip leafy"
bfdia 1 be like
Cary Huang's Virus Simulator 2020:
Watch the 44 cells live in harmony and then develop the perfect virus to kill them off as quickly as possible!
Virus Simulator 2020: The pandemic simulator like no other! Now open-source!
Just add "Write" twice, then the fun starts
That’s what I was thinking!
Why stop at two when you can do more?
How to make ugo factory: make a virus that spams write none, making a ton of itself
*Carykh:* "I don't want to have two different branches at the same time running on different platforms; that would be too much of a mess."
*Minecraft:* "I want to have two different branches at the same time running on different platforms; it is almost too much of a mess."
i am a JAVA EDITION BOY
(but that might also be because I mostly played in 2010-2012 and haven't played much since)
I think java edition has more freedom than bedrock editions which is why I also use java edition
Bedrock has a few cool features (Like more apparent physics, and cauldron stuff), but java is still superior.
Trash Trash mods and texture packs exist
@@sirpiggyz6579 yah, one of the reasons why it's better.
i just realized you can put two or more WRITE NONE operations in series for exponential growth. for some reason the simulator really fun to experiment and play with :)
Wowee, glad to see you're still working on this!
13:11 none inward with left beef
I think to make this virus you created ideal, you should get rid of the “remove wall” bit; that way, instead of just making one virus and dying, the infected cell just keeps making more and more viruses until they break its wall and they burst (just like how actual viruses work).
I made a fun virus to watch:
move hand inward
move hand RGL(0,0)
read RGL(-1,4)
move hand outward
write RGL(0,0)
repair wall
This makes up to 13 equivalent viruses per infected cell. It's usually 5 to 11 ev/ic
It's basically a regular UGO replicator with an added repair wall codon to keep the cell building viruses for longer.
OH MY GOODNESS. I HAVE BEEN WAITING FOR THIS SINCE PART 2! SO EXCITED
k so?
Cell: I fear no man, except that thing...
*pink cyan yellow purple*
It scares me.
Yellow purple will strike fear into their hearts
Still waiting for Virus Simulator Part 4/4...
In the java version, I made a virus that got everything infected by 235 since edit, and all dead by 277
All it did was
Move hand inward, move to 0,0, read -2,6. move outward, write, write, write, write, write
Most of the cells ran out of energy after writing all the viruses and just exploded on their own
If you want something really deadly try this :
mv hand 0,0
mv hand in
read 0,8
mv hand out
write
write
write
write
rem wall
I've got every cell infected by 160 and all dead by 190
Gotta say, was NOT expecting that elimination, oh well. Better luck next time TWOWers!!
?
[INSERT CONFUSION HERE]
I think it's a reference to the elimination music that plays in the TWOW videos, but also played in this video when the virus killed a cell, like at 4:24
*Confused Visibility*
Insert incoherent screaming here
I love how you take feedback so well, it makes your videos so much better. As a postgraduate doing their Masters of Infectious Diseases it’s nice to see someone doing their best to understand what they are talking about and share it with their audience using their own skills in computer programming.
Most cells that die during viral infections are actually killed by cytotoxic T cells that trigger apoptosis after recognising viral peptides being presented by the MHC class 1 of infected cells. That’s why an overactive immune response is what typically kills the host rather than the virus itself, and why corticosteroids are used to dampen the immune response.
Does "Digest Waste" do anything, such as dircetly harm cell health?
can I Digest Wall?
what about Remove RGL 0 to 0?
What I'm saying is that some documentation like an md file on what each combination codon does would be great.
digest wall dealt damage to wall equal to some amount, perhaps the HP you wouldve gained from repairing it instead?
You can answer all of these things and more via downloading the opensource code from Github, and the "Processing" program - both on description!
Indeed, you can digest the wall! It damages the wall, but it’s not lethal until it loops 2 or 3 times.
@@GRBtutorials Digesting the wall also gives a small amount of energy. Eat yourself to survive!
Digest Waste doesn't do a lot. It reduces energy by 1.4% as is standard for all commands, and a green line appears between the hand and the waste particle like with Digest Food. Otherwise, nothing of note happens. The waste remains waste, and no other damage is done.
Remove RGL does even less. It just reduces energy by 1.4%. No codons are removed.
Thanks for letting us play it and look at the code 4 free.. You are just a hero haha
YES FINALLY PART 3 THANK YOU SO MUCH CARY!!!
Fun fact: You can increase the world size in the code, if your PC can handle it. If you can handle it, I recommend setting the world size to 36 due to how the cells are generated. You also want to increase the max food significantly, or otherwise the entire board will starve to death. 1800 seems to work fine. I got a virus to eliminate the entire board in a mere 400-ish ticks. (movehand 0-0, movehand inward, read 0-8, movehand outward, write none, write none, write none, write none, write none)
I figured it's faster when you put "remove wall" at the end. It produce one less copy of the virus, but it doesn't have to wait until the wall breaks before spreading the viruses. Overall, it's much faster. Although, I haven't tried with a oversized world like you did... I also tried to produce less virus, to try to keep the cell alive for longer, which give a chance to get a 2nd iteration of virus generation, but that's still slower than exploding and spreading the viruses and let other cells generate more viruses.
My record for 100% kill with one starting UGO on the OpenProssesing version:
*~282T*
Can you beat me?
My strat was:
MH ¦ IN
MH ¦ 0,0
RE ¦ -2,6
MH ¦ OUT
WRI ¦ NON
WRI ¦ NON
WRI ¦ NON
WRI ¦ NON
WRI ¦ NON
I'm not gonna get a better score because I'm too lazy to simulate a different one or download processing though.
208t:
MH IN
MH 0:0
RE -1:7
MH OUT
WR NONE
WR NONE
WR NONE
WR NONE
RM WLL
Dang, that's pretty fast! I think I've gotten down to the 230s in my test runs (although I don't wanna reveal my genome just yet). It looks like Hallo beat me with 208 though? (Of course, a lot of it comes down to random chance of the particle-bouncing)
For 251t I used:
MH IN
MH 0,0
RD -1,7
MH OUT
WR NONE
WR NONE
WR NONE
WR NONE
WR NONE
Looks Hallo's version does better (210t for me) by replacing the last WR NONE with RM WALL, which results in the cell dying sooner.
196.6t
move hand | inward
move hand | 0,0
read | -1,7
move hand | outward
write | none
write | none
write | none
write | none
remove | wall
A lot of people are saying that the most efficient thing would be to keep on making viruses until the cell explodes, but that isn't true. It took around 250t for all cells to die with this:
Move hand inward
Move hand RGL (0 to 0)
Read RGL (-1 to 7)
Move hand outward
Write none
Write none
Write none
Write none
Write none
With that, cells kept on producing viruses until their walls couldn't handle it, which would be anywhere from 4 to 10 viruses. But usually, the cell would make 5 viruses and then take a bit of time to explode (but not enough time that it would make any more)
Replacing the last codon with 'Remove wall' instead of 'Write none' significantly speeds up the process. In my test it took 200t instead of 250t, because even though cells were producing less viruses, they were dying faster.
The first souloution
Move hand RGL (0 to 0)
Move hand Inward
Read RGL (0 to 8)
Move hand Outward
Write RGL (0 to 8)
Write RGL (1 to 9)
Write RGL (2 to 10)
Write RGL (3 to 11)
Write RGL (4 to 12)
Glad there’s no bots
Edit: oh dear lord
Thank you, Brock *bot* . Very cool!
Thank you, Brock *bot* . Very cool!
Thank you, Brock bot . Very cool!
Thank you, Brock *bot* . Very cool!
Thank you, Brock *bot* . Very cool!
So glad you're continuing this series!
unfortunately not as much now...
My prototype for a "zombie" virus that completely overwrites the cell's genome:
Move hand Inward
Move hand (0,0)
Read (-1,7)
Write (8,16)
Move hand Outward
Write None
Repair Wall
Digest Food
Remove Waste
I made a mutating virus,
It only picks up one random codon, but it's still technically mutating.
Here it is:
NONE | NONE
MOVE HAND | INWARD
MOVE HAND | WEAK LOC
READ | RGL (0 to 0)
MOVE HAND | RGL (0 to 0)
WRITE | RGL (-4 to -4)
READ | RGL (-4 to 4)
MOVE HAND | OUTWARD
WRITE | NONE
Works like a charm.
I made a virus with the ability to lay dormant in a cell,
Sometimes it will just stay there in the cell not doing anything, it takes forever to kill all the cells.
Here it is:
MOVE HAND | INWARD
MOVE HAND | RGL (0 to 0)
WRITE | RGL (4 to 4)
READ | RGL (-1 to 4)
MOVE HAND | OUTWARD
NONE | NONE
@@PyPylia neat
Neat
I’ve been waiting for this for three months!!!
i think cells should have some kind of defense mechanism maybe, or maybe cells designed to fight infection??
like "REMOVE | UGO" ?
Remove ugo could make it so a cell could forever make new viruses
@@hioyua650 it could also be a possibility for it being a vaccine ..
Remove ugo would be like remove waste. It wouldn't remove the codons, you would need a special thing for that
@@hioyua650 true.. true..
I barely understand this but this is extremely interesting. I feel like you could help a lot of people understand how diseases work with something like this.
DUDE WHERE'S PART 4 WE'VE WAITED FOR ALMOST A YEAR!!!!!
It's been 2 years now
Congratulations on half a million subscribers!
Do you know how to make a vaccine in this game? "Infect" a cell with a harmless snippet of the actual virus so when it comes ,the ugo bounces out pf the vaccinated cell
Thats not how vaccines work in real life. Nor is it possible for a vaccine to work without an immune system. It’s like supplying weapons to a nation with no soldiers…
Well game logic
@@DanksterPawswell the game isn't real life
@@dawnsclim4382 The game is a simulation of real life. That’s like saying an airplane simulator should allow you to go to space
@@DanksterPaws well carykh already said that this isn't a exact replica of real life and just show some concepts, and my vaccine thing probably isn't a real mechanic of the game but more of a exploit
355 Ticks (Javascript Version) with the following UGO:
Move Hand Inward
Move Hand RGL (0 to 0)
Read RGL (-1 to 4)
Write RGL (5 to 10)
Move Hand Outward
Write None
It mimics the real world behaviour of some viruses to force the cell to only produce virus particels until the cells bursts. In the Simulation you end up with 2 to 3 new UGOs that are released after a quite quick death of the cell, because all energy was taken to produce UGOs and to insert multiple copys of the UGOs Codons into the cell. Pretty neat if you ask me.
You should make it so that when it copies the codons, it also copies the decay (when injected outward), thus making it not as easy to cause a successful virus.
Then it wouldn't be able to repair its codons.
we need more Cary Key Hole
petition to bring back Cary key hole
how does this work? when I run it doesn't show the full screen and the side doesn't show buttons like the "Make UGO" button (I'm using proccessing 3.5.4
I think its a problem with the game size and the size of ur screen so if you go to line 61 (you can see what line you are on on the left side of the window) there should be a bit of code that looks like this
size(1728,972)
if you find the size of ur screen in pixels and replace the numbers it will change the size of the game so you can fine tune it to ur screen size
fun fact like 30 others have a similar problem
@@craftingnerf2593 i have the same problem, thanks a lot for the fix! edit: it didn't work BUT i found that changing int W_W and int W_H to the resolution of your screen lets you make viruses, just can't change their size (always going to be 5 codons big)
2 things.
1. I was the 10,000th viewer on the virus simulator on open processing!
2. I also made my own virus on that where you write it 4 times and don't move hand outward near the end cause it would have already done that (and read RGL -1 to 7).
where’s part 4 💀
I've played with your code a bit and I realized that it's almost turing complete! You can even make evolvable code/viruses (which I did) that is able to multiply by itself.
To do so:
1. Add mutations. Like in 1 in 10 000 chance every step that the codon can change to a totally new one
2. Allow cell regrowth. 1 in 100 chance that the dead cell may come alive again
3. Increase maximum codon amount to 60+
4. Increase time speed
Then whole cells will emerge that copy big parts of their genomes until they burst and seed their genomes to all other cells. This will repeat till the "virus" genome is broken beyond repair by other cells bursting.
To solve this, you could add a different kind of self repair, which would need additional "compare" codon and a "remove" codon.
Then a whole new types of viruses/cells should be able to evolve by themselves that just dominate the population.
You misspelled one of the files in your GitHub repo. For "Cell.pde", you added an extra dot, making it "Cell.pde.", so Processing won't automatically find it. Edit: just opened a pull request to fix it.
Oooh, thanks for pointing that out! Not sure how that happened, but I will fix it
I tried a few things
:
First, the most basic idea: Let the virus reproduce until it overcrowds the cell and destroys the wall through collisions. 6 UGOs was usually the limit before a cell died, and then those would be released and infect more until the tissue is killed. Took ~584t.
Then I just ramped it up. Why not speed the process up and have the virus repeatedly reproduce? The virus now writes itself 5 times. Apparently, writing a UGO drains a ton of energy and 5 writes is almost always enough to doom a cell to exhaustion. Even though only 5 UGOs are released instead of 6 when a cell dies, the cell is killed much quicker, and infection is faster. Took ~250t.
My final virus was one that corrupted the cell. It would overwrite the weakest command with "move hand inward," and the reproduce a UGO of the virus. A cell might lose the ability to repair its wall, eat food, or remove waste. It may even damage the virus itself, neutering either its killing potential or its infectivity. Eventually, the cell dies and releases 3 or so UGOs. This virus killed faster than virus 1, but released fewer UGOs, and thus infected fewer cells. It wound up with an almost identical time to V1, taking ~588t.
last time I was this early twow 23a was the newest twow episode.
Looked through the code for a while to try to see how I could edit the arrangement of the cells. Turns out they're always just generated in the shape of the Sierpiński carpet. Very clever
Fun Fact: If you put "Fun Fact" in your comment people will automatically read it.
Fun Fact:i steal peoples ideas in the replies
Fun fact: I do the same with Douglas Pantz
Fun Fact: I have the most likes
corona listening: WRITE THAT DOWN! WRITE THAT DOWN!
Whenever he says UGO I can't not think about Yu-Gi-Oh
It's time to d-d-d-d-go to prison
OH MY GOSH i didn't even realize that! this is gonna be like the GIF-pronouncing war huh
Turns out if you duplicate the "Write None" Codon a couple more times, it becomes an exponential killing machine. One cells produces 3 viruses. Leading to 1 infection, then 3 with 1 killed, then 9 with 4 killed, then 27 with 13 killed, etc
I also had one case where due to the position of the codon in the cell, the cell produced 3 viruses, then ran out of energy to kill itself, but died anyways because it wasn't repairing the wall either
When he said that the virus wasn't spreading, I downloaded the game and tried to figure it out myself.
So then you spread the virus... very interesting.
I cant seem to find where to run the game
the perfect UGO should be the one you made that can recall itself infinitelly but with 2 or more write code, like this it takes more to kill but will replicate itself more like a real virus
"Just cause I wanna finish it up!"
(doesn't finishes it up)
really interesting thing i found was to throw a bunch of single "write none" UGO and see thier effects on cells (I actually turned one into a write non factory and let it explode). It can have very different and interesting effects depending on where it lands in the host cell!
I can't get the processing version to work, I tried processing 3.3.3, like the readme file says, but it keeps giving an error that tells me that " size(1728,972); can't be used here".
Actually, nvm PLEASE ADD A WAY TO RESIZE THE WINDOW, I got it to work, and found out that it’s to big for my laptop.
Edit: in screen size
I think its a problem with the game size and the size of ur screen so if you go to line 61 (you can see what line you are on on the left side of the window) there should be a bit of code that looks like this
size(1728,972)
if you find the size of ur screen in pixels and replace the numbers it will change the size of the game so you can fine tune it to ur screen size
@@craftingnerf2593 Thanks, but, the things on the right side of the Screen go off Screen, is there a way to fix that?
Can’t wait to miss around with this! I’m sure I’ll have fun with this like with your evolution simulator
Why is there no part 4 for 9 months wlep
now 18 months ITS BEEN MORE THAN A YEAR HURRY UP
not to sound like one of those "OMG wHerE PaRT 4 y u nO MakE It" people but are you going to finish this or not? I thought you made a new years resolution to finish this and other things but I can't find it? please explain
if you want to correctly depict how obesity kills you, try
move hand outward
digest food
digest food
digest food
digest food
digest food
digest food
digest food
digest food
I've been waiting for this!! I love this series so much.
stop looking at the comment section.
but...
but I have!..
no thanks I've been here for a bout an hr
its amazing playing with this, think itd be possible for a level editor with a text file u can share?
also i would like it even more if there was an infinite map version and you could try and see who could kill every cell in the last amount of time
I'm so early, I can't see the comments.
Here is an interesting one: it has an initial setup of 3 codons which copies the virus to memory, a payload of 3, and then a final section, still 3 codons, which serves the purpose of executing the payload again, skipping(overwriting) the initial genome of the cell.
(Setup)
MOVE HAND | RGL (0 to 0)
MOVE HAND | INWARD
READ | RGL (0 to 8)
(Payload)
MOVE HAND | OUTWARD
DIGEST | FOOD
WRITE | NONE
(Final Section)
MOVE HAND | RGL (0 to 0)
MOVE HAND | INWARD
WRITE | RGL (0 to 8)
Next I wanna try to make a virus that gets a predefined mutation in the second generation
Well, it's pretty PRETTY basic, but I got it. The first generation makes 2 copies of the second one, then it kills the host. The second generation just kills the host. The payload for the second generation is arbitrary, but can only be two codons long at most.
(Gen. One)
MOVE HAND | RGL (0 to 0)
MOVE HAND | INWARD
READ | RGL (7 to 8)
MOVE HAND | OUTWARD
WRITE | NONE
WRITE | NONE
REMOVE | WALL
(Gen. Two)
MOVE HAND | OUTWARD
REMOVE | WALL
If you could fit more codons inside the UGO, you could make virtually unlimited copies of Gen 2, without "executing" its payload (which could also be more complex than just killing itself)
Soooooo, I've edited the program to allow making UGOs with unlimited amount of codons and I've increased the maximum number of codons a cell can have. I've created a virus that can make a copy of another arbitrary virus, without executing its genome. Instead it executes an alternative routine which we can use to keep the cell alive for a bit more. It might be possible to optimize it a little (in some places you have a MOVE HAND | INWARD followed by a MOVE HAND | OUTWARD), but it gets the job done. In my tests it was able to create up to 3 copies of G2 before the host either starved or exploded. Although it doesn't overwrite the cell's genome, it might interfere with its functions (the hand might not be placed in the right spot when the interpreter returns to the original genome of the cell), which often causes the cell to fail when it attempts to restore its codons; but that's hardly an issue, since the cell is gonna die way before any codon goes bad. G2 is a simple self-replicating virus, which I think we'll see in the next episode; again, the payload could be anything.
Here's the entire genome (28 codons!), with a very brief explanation:
(Create a copy of G2)
00. MOVE HAND | RGL (0 to 0)
01. MOVE HAND | INWARD
02. READ | RGL (9 to 13)
03. MOVE HAND | OUTWARD
04. WRITE | NONE
05. MOVE HAND | INWARD
(Copy G2 to buffer, then overwrite G2 with alt. rout.)
06. WRITE | RGL (23 to 27)
07. READ | RGL (18 to 22)
08. WRITE | RGL (9 to 13)
(Generation 2; the offsets here are relative to the new virus)
09. MOVE HAND | RGL (0 to 0)
10. MOVE HAND | INWARD
11. READ | RGL (0 to 4)
12. MOVE HAND | OUTWARD
13. WRITE | NONE
(Copy buffer to G2, then overwrite buffer with alt. rout.)
14. READ | RGL (23 to 27)
15. WRITE | RGL (9 to 13)
16. READ | RGL (18 to 22)
17. WRITE | RGL (23 to 27)
(Alternative Routine)
18. MOVE HAND | OUTWARD
19. DIGEST | FOOD
20. REMOVE | WASTE
21. REPAIR | WALL
22. MOVE HAND | INWARD
(Buffer)
23. NONE | NONE
24. NONE | NONE
25. NONE | NONE
26. NONE | NONE
27. NONE | NONE
First
Fang84 your first
@@Crisism3 He's first
no, shush
No one cares
Helinos that’s what I said
absolutely brutal self-replicating virus. Move Inward, Move Hand RGL 0 to 0, Read RGL -1 to 4, Write RGL 5 to 11, Move Outward, Write RGL 0 to 0.
I cant wait to play this, I have to wait because im about to go to sleep so I dont have access to my computer. Have to do it tomorrow. But experimenting around will be really cool
I set the max number of codons to 200 instead of 20 and the max number of UGO codons to 99 instead of 9. I then created a UGO that writes UGOs until out of energy, then hs a bunch of blank codons so that lots of waste will be produced, which will attack more walls.
Edit: Multiple UGOs went into one cell, making a waste explosion, which quickly destroyed nearby healthy cells.
I bet 20 dollars that the next episode will have a virus that just keeps adding viral objects within the cell untill the cell walls cant repair fast enough. The interesting thing is that is similar to how actual viruses work
I'm still laughing at the Game Over RPG music when the cell dies, dont know why, it's too dramatic
By looping the recursion theory and maxing out replication, I managed to get "full death" in about 200 ticks on the Open Processing version using this UGO: Move Hand Inward, Move Hand RGL (0 to 0), Read RGL (-1 to 7), Move Hand Outward, Write None, Write None, Write None, Write None, Remove Wall. Only 9 lines because that appears to be the maximum in OP, no idea if this strategy works better or worse due to max. line changes in the better version.
To guarantee an integer in js, you can always do
x = a / b | 0 (if a, b > 0)
x = +(a / b).toFixed(0) (converts to string and than back)
x = a / b ^ 0 (when you are certain a / b !== 0)
Virus simulator: *Exists*
Fake Viruses: I used to rule the world
Cells would pop when I gave the word
And we would then spread!
infect the cells that we used to scare
I made a mutating virus,
It only picks up one random codon, but it's still technically mutating.
Here it is:
NONE | NONE
MOVE HAND | INWARD
MOVE HAND | WEAK LOC
READ | RGL (0 to 0)
MOVE HAND | RGL (0 to 0)
WRITE | RGL (-4 to -4)
READ | RGL (-4 to 4)
MOVE HAND | OUTWARD
WRITE | NONE
10:07 If you "inject" enough of these viruses into the organism, you can kill it off in no time!
Also, btw i made a version with 3 "Write Virus" codons and it's working very good!
it took about 220t for all the cells to get infected with the triple virus and it took only 246t for all the cells to die.
I also made another version where it makes 2 more of itself while making the cell push food out which means it gets much less nutrients as the Viruses bang inside of its membrane instead of making it just die immediately. It took 330t for everyone to get infected and 428t for the last cell to finally die.
Is there a part 4 yet?
True OGs were playing this before the video 😎
I've found the best strategy is to make a virus that actively repairs the wall while multiplying. Eventually, because of all the missing codons, the wall will break and release way more virus particles than before. It's also significantly more potent because it can create so many replicas of itself within such a short amount of time
what is it
My most common code does that AND gives it more energy at the same time. Absolutely devastating. It releases like 12 viruses on cell death.
MOVE HAND INWARD
MOVE HAND (RGL 0 to 0)
READ (RGL -1 to 7)
MOVE HAND OUTWARD
WRITE NONE
WRITE NONE
DIGEST FOOD
REPAIR WALL
WRITE NONE
By writing the UGO to write "none" outwardly five times (a total of eight codons each), the cell exhausts of energy after generating five UGOs, and the cell wall soon bursts due to lack of maintenance, releasing five UGOs into the interstitial fluid
I’ve decided, this is what leafy looks like inside.
YOU MADE LEAFY SICK YOU MONSTER!!!
Hi. I'd appreciate if you added support for different sized monitors. Just making so changing W_W and W_H have an actual effect would be appreciated.
Perhaps you will already do that but only once 4/4 comes out.
(The Browser works just fine tho, phew!)
my favourite is move hand inwards, move hand rgo 0 to 0, read rgo -1 to 7, move hand outward, write none, write none, write none, write none, remove wall. I would use the last one with write none aswell but sometimes the cell like barely lives through it all. If there was only one more i could fit that would be great.
It's here! Been waiting for this!
I am so excited to play this, I have been waiting for so long. When is it going to become a mobile app?
I thought on two similar strats. On the first the idea is to substitute the entire code of the cell with the one from the virus, here's the code:
MOVE HAND inward
MOVE HAND rgl (0 to 0)
READ rgl (-1 to 7)
WRITE rgl (8 to 17)
MOVE HAND outward
WRITE none
WRITE none
WRITE none
WRITE none
The second one is similar, but instead of doing WRITE none 3 times, you trade one of them for a DIGEST food, because I every time the cell was stopping to work due to energy way too early, here's the code:
MOVE HAND inward
MOVE HAND rgl (0 to 0)
READ rgl (-1 to 7)
WRITE rgl (8 to 17)
MOVE HAND outward
DIGEST food
WRITE none
WRITE none
WRITE none
Idk which one is better, because you need to trade creating a new UGO for another command, but you might get more rounds of executing the code, so in theory more UGOs. I thought on adding a REPAIR wall command after the DIGEST food to increase the longevity of the cell before it explodes a bit more so it can create even more UGOs, but I don't think that would help a lot since it would take forever for a cell to explode.
if this is a simulation of a blood stream you should probably add white blood cells that attack ugos before they infect cells. (the immune system isnt only made up of white blood cells but implementing the ENTIRETY of the immune system would be an epic task and would defeat the purpose of the simulation)