averytoad65

Not a lot of changes for right now, but that’s mainly, because I spent my time making an EXE for SWP so the ship doesn’t get rejected again.
But, I implemented a small feature.. loopbacks! A loopback lets you specify if the RPC Package should return to the sender once the client sends it to the server, this is useful so there is less confusion about if you should run the RPC function locally as well, or if the package comes from the server-side. It also has practical usages, but I can’t think of any examples off the top of my head.
Next up is (hopefully) documentation and cleanup of the existing RPC handling code. Let’s see how that goes.
Happy coding and thank you for reading!

… so I spent 3 hours implementing RPCs (Remote Procedure Calls), and boy oh boy… it’s a mess, like most things in this!
So, let’s dive into it, shall we?
At first I began with writing a RPC Attribute class, plain and simple, afterwards a small RPCManager to ensure that I can easily call RPCs from anywhere. Then followed a small RPC Package to make it easy for the server to communicate that the clients should execute a function, all well and good… Until it came to implementing how you’re supposed to run the function. Granted, I took the easy way out: only allow static methods. But I don’t want that to be the case forever, I want this to eventually run on object instances too, but that’s gonna take a bit for me to do. Probably past the time limit of this whole Flavortown thing, so, screw it. Anyways, so after implementing all that, I was met with an issue: RPCs weren’t registering. So, what did I mess up? Well I had the call to subscribe my RPC to the RPCManager in the RPCAttribute constructor, should work, right? Well, the developers of roslyn (the C# compiler) decided to throw me a giant “F**k you,” because the constructor for an Attribute is never called until you somehow reference the RPC via MethodInfo.GetCustomAttributes() and whatnot… suffice to say it took me a bit to figure out.
But, hey, I finally did it. Now you can register static functions are RPCs with a specific ID and you can easily call ‘em through the server, now all I have left to do is make the communication system with the RPCPacket work in a way that a client can request to execute a RPC to the server and then the server can spread that message to other clients.. and I should definitely get parameters working. But, I think first I’ll focus on cleaning up this steaming mess of redundant calls and whatnot, and heavy documentation, right now only god and I know what this code does, not very sustainable.

Anyhow, happy coding!

The first release of SWP is live and you can download it now at https://github.com/averyocean65/swp/releases/tag/v1.0.0

The release features all the functionality shown off so far and then some! Since the last devlog I added line-wrapping and a save confirmation dialog that shows up when you close a tab. So happy that I can ship this project now. Happy coding!

Another really short patchlog:

• Moved Function classes to new package
• Completely refactor FunctionPart system to make use of inheritance rather than one do-it-all class
• Documented Misc class
• Added Misc.combine(double a, double b, Operator operator)

Have a nice day and happy coding!

I wrote the world’s messiest codebase, but at least it compiles. Now I do have to take a break from programming because my right hand is starting to hurt from the excessive abuse of Rider shortcuts. I did a ton of stuff and honestly if you care about it, I’d just check the git commit history for today. Goodnight and thank you for reading, happy coding!

I feel like one of the best programmers of all time right now - my complex workaround for making a dynamic package library somehow worked on the first try! I managed to finally make it so you can easily initialize a UdpClientApp or UdpServerApp and send packages from it! And it just… works! As long as you make a registry for the packages which adds them to PackageHandler.Packages using PackageHandler.RegisterPacket(…) but that’s beside the point. What I mean to say is that, the fundemental principle of my application is done, a more simplistic way to send and parse data packets over a network. Can it be optimized? 100%. Will I optimize it? Perhaps, we’ll see how much time I have for that until I ship the project. For now though, I will happily enjoy this win and dance around like a silly goober to “Na Na Na (Na Na Na Na Na Na Na Na Na)” by My Chemical Romance. See ya, and thank you, you lovely individual, for reading this!

Oh, also, if you care to check out what I made and you can’t find the GitHub repo, you can find the project source code at: https://github.com/averyocean65/UdpClub/

Ok, I got bored of fractions and decided to start on implementing the function system. It may not be the most intuitive system, as you may see from the first screenshot, but I can tell you one thing. It freakin’ works! I am so happy to see that this system works first-try without a hitch, seriously! By the way, the third image shows the polynomial from the tests (graphed in GeoGebra). I am excited to see how I can implement this function system into some personal projects when I finish this library, speaking of which… where to next? Well, I’m honestly not sure, I thought about doing complex numbers, but I don’t know if I can faithfully implement them given that I know nothing about them except for (sqrt(-1) = i) and (i^2 = -1), oh and Euler’s expression (e^(pi*i) + 1 = 0). So that probably doesn’t suffice. I could definitely add some functions to my function class, like creating derivatives, making anti-derivatives, calculating integrals (would require anti-derivatives), finding spots where the function equals 0, limits, basically whatever algebra I was taught in my high school career. Though finding intersections for the x-axis would cause issues with trigonometric functions, hm. I guess I’ll have to figure it out later, for now, I’m celebrating because my function class works!

Got the basic instruction class working with a few sample instructions shown in the runtime main file. This is probably going to be one of the last devlogs I post today, since I wanna write some music before I go to bed. Thank you to whoever reads this, you’re awesome!

I added the equality function to my fraction class! Right now it throws an IllegalArgumentException when you don’t give it a fraction, but I hope to expand it to accept numerical inputs too, which will make the code in my fraction test class look just a bit nicer. Alongside this I also added my own float equality function, since I couldn’t find anything outside of the “==” operator, which I have been told is unreliable. Maybe I’m wrong though, who knows! I’ll definitely test using the regular operator soon.

I finally got a basic framework running to send data between a server and client via the UDP protocol. I am extremely happy to see that I got it up and running from only an hour of work. Unfortunately there is a bug in the package handling, as the server and client should constantly send packages to each other, so I have to do some debugging to see what’s going wrong. Very strong start though! Hope I can get the Package and Package Manager classes implemented tomorrow if I manage to iron this bug out.