Jump to content

Nazalassa

Members
 View Profile  See their activity

  • Posts

    1,480

  • Joined

  • Last visited

 Content Type 

Everything posted by Nazalassa

  1. Nazalassa
    COP - Center of Pressure (KSP2)
  2. Nazalassa
    N 55
  3. Nazalassa
    N 55
  4. Nazalassa
    N 55 Ping
  5. Nazalassa
    N 55 Pong
  6. Nazalassa
    N 55 Ping
  7. Nazalassa
    I made 16 designs for icons on trajectories. Note that they're just supposed to represent roughly how it would look, it's not the actual look... For example, if you're looking for KSP1-style icons, you're probably looking for 1 - Above Full Arrow, even if it looks a bit different. 1 - Above Full Arrow 2 - Below Full Arrow 3 - Above Alpha Arrow 4 - Below Alpha Arrow 5 - Above Full Dot 6 - Below Full Dot 7 - Above Alpha Dot 8 - Below Alpha Dot 9 - Dotless Line 10 - Inline Dotless Line 11 - Line 12 - Inline Line 13 - Above Pointer 14 - Below Pointer 15 - Above Crosshair 16 - Below Crosshair Made with GIMP, although the trajectory [blue line] was made in Inkscape, then converted to png. Images were firther converted to gif format using ImageMagick-ims6.q16's onvert command.
  8. Nazalassa
    N 55
  9. Nazalassa
    N 55
  10. Nazalassa
    N 55 ty
  11. Nazalassa
    [ WARNING | This post has been repurposed. It is roughly one day younger. ] I modified the OP and added a library to keep track of all the KAL logic & computing stuff we do :) Right now there are the crafts from @HB Stratos and me. If we want to make a CPU I suggest we first try to make an all-8-bit one, 256 bytes of total memory (maybe 192 program ROM, the rest is I/O, RAM, and possibly stack), with a small set of operations (LDA, LDB, STA, STB, LAV, LBV, JMP, ADD, NOP, maybe SUB and BNE-like things).
  12. Nazalassa
    N 57
  13. Nazalassa
    It would be totally possible to detect staging (at least when something decouples) or keyboard inputs that trigger either a specific action group, or pitch yaw that kind of things. -- [ MERGED WITH BELOW POST ] -- Log 23.3 OK the bus works! yeeeey Original state (I changed the values of the registers myself) Register A writes to the bus (AR A WRITE is enabled) and register B loads from the bus (AR B READ is enabled), effectively doing an A to B transfer. Now register C writes to the bus and register B reads, transfering data from C to B. Here's how it works! Each of the three lines is a register. Each register has 3 KALs, from left to right: read, store, write. Normally read and write are disabled, although store is always enabled. When write is enabled, it writes the contents of the register to the bus. When read is enabled, it stores the contents of the bus into the register. The thing works like that: Basically each KAL is a buffer, the bus writes into the read KALs, which each write into their register's store KAL, which does the same with the write KAL, which writes to the bus again. It's like this: R → S → W ]-- Register ↖ ↙ Bus ]-- Bus However, the read and write KALs of each register aren't always enabled, which means that we can decide when we want eachregister to read/write from/to the bus. Oh, by the way, here's how it looks in one KAL: Instead of having the sloped stuff from the adder, I used my script to generate a buffer, which basically sets the play position of the target KAL to the one of the current one. Download: https://kerbalx.com/Nazalassa/8-bit-bus-prototype
  14. Nazalassa
    3801 _New_page_
  15. Nazalassa
    I second that
  16. Nazalassa
    Welcome @sunnyssk!
  17. Nazalassa
    Nice! Then if we couple both scripts it'll be easier :) I think I have an idea for a 8-bit analog bus with 8-bit analog registers, it would use 1 KAL for the bus itself and 3 KALs per register. The main reason we do that is probably because it's fun and we may will learn things about how computers work.
  18. Nazalassa
    N 59
  19. Nazalassa
    N 45N 45
  20. Nazalassa
    N 45
  21. Nazalassa
    Nope, but it may be @Nate Simpson.
  22. Nazalassa
    OK I just copy-pasted around 2,000 lines of timestamps in the .craft. Time to see how it behaves. (cross your fingers :P) -- Oh great, 0 parts in 1 stage. I guess KSP doesn't like it. We have to find another way, I'll post the script in the OP rn (doc will follow)
  23. Nazalassa
    N 45 Due to this Positive attack, I call @Jacob Kerman @Souptime @Akagi @LHACK4142 @Kerbalsaurus @SSTO Crasher @Abel Military Services @Admiral Fluffy @WaldeB @Ben J. Kerman and every other Negative
  24. Nazalassa
    Analysis 23.2 I think it would be fine if we made like 8-bit blocks (between 0 and 255) and stick two of them together when we need 16 bits etc., and hardcode very precise values with the help of the python script. As the script generates things like that: +---------------------+ | ___ | | _____| | | _____| | | ___| | +-0-----1-----2-----3-+ So if there's a tiny, tiny imprecision, it will be corrected. After analysing the way the analog adder I made works, I think that the issue is that I made something like tha instead: +------------------+ | _,-' | | _,-' | | _,-' | | _,-' | +-0----1----2----3-+ (Imagine the line is a straight line between start and stop) So the source of the imprecision is probably just the fact that I was lazy and didn't literally hardcode the values in the "flat" way I showed above (the first one). I'll try to use the first way and see if it works. Also I noticed bitwise addition is like 1 physics tick or something, the lower that we can get.
  25. Nazalassa
    N 43
×
×
  • Create New...