If you haven’t check out the run-and-gun videos…they look much more fun to me than the platform parts.
Oh hell I have hahah, this game looks awesome!
Get a soldering iron, it looks like the card itself isn’t damaged. Totally fixable 
Put in the oven and hope for the best.
Yeah, I just looked into it. The problem is that there are 4 extremely tiny holes in the USB metal connector that the 4 tiny wires went in to before, and those have been snapped. The holes are ~0.2-0.3mm big and seem to be snapped at the entrance, so soldering those on again probably isn’t possible. The only way to repair it would be to find a new USB connector like this one, remove the old 4 wires sticking up (that fucked up my thumb) and solder on the new one. I haven’t found them on anything except AliExpress with 15-39 days shipping. -__- Faster shipping than that costs twice as much as the damn sound card did in the first place…
I really needed that card since the electromagnetism of 450 watts of graphics cards didn’t play well with the internal sound card on my motherboard. Every time I started a game it lead I sounded like a hurricane to all my friends online. Still haven’t managed to shake off the “Whistling Mic” nickname they gave me. Q_Q
Thanks for the link; it looks like they have what I need, but there’s a 20€ shipping fee for small orders… x___x
Have you tried take any “usb to micro usb” wire
(you can have billions of them, they come with all phones…)
and take connector from it?)
My “WIDT” contribution isn’t that impressive, but I want to keep this thread going!
I’ve decided to write a small scripting language (just in Java, no fanciness going on yet) and today I wrote my simple tokenizer.
A test file:
def testFunc() {
int i = 0;
string s = "";
string st = s;
int j = i * 1 - 2;
ret 1 + 1;
}
This is stripped of whitespace,
deftestFunc(){inti=0;strings="";stringst=s;intj=i*1-2;ret1+1;}
And then tokenized to produce this:
DEFINE_FUNCTION : def
NONKEYWORD : testFunc
OPEN_PARENTHESIS : (
CLOSE_PARENTHESIS : )
OPEN_CURLY_BRACKET : {
VAR_INT : int
NONKEYWORD : i
EQUALITY_OPERATOR : =
NONKEYWORD : 0
SEMICOLON : ;
VAR_STRING : string
NONKEYWORD : s
EQUALITY_OPERATOR : =
QUOTATION_MARK : "
QUOTATION_MARK : "
SEMICOLON : ;
VAR_STRING : string
NONKEYWORD : st
EQUALITY_OPERATOR : =
NONKEYWORD : s
SEMICOLON : ;
VAR_INT : int
NONKEYWORD : j
EQUALITY_OPERATOR : =
NONKEYWORD : i
MULTIPLICATION_OPERATOR : *
NONKEYWORD : 1
SUBTRACTION_OPERATOR : -
NONKEYWORD : 2
SEMICOLON : ;
RETURN : ret
NONKEYWORD : 1
ADDITION_OPERATOR : +
NONKEYWORD : 1
SEMICOLON : ;
CLOSE_CURLY_BRACKET : }
Very basic for now, but I haven’t read anything about tokenization and I didn’t go to college (so no compiler course). There’s still some issues to work out, both design wise and code wise, but I’m happy with the progress I made today. Next steps are huge and I haven’t researched anything, so this might take a while.
I can’t wait to start writing functions in my own scripting language
I’ve recently started working on an isometric game, got map rotation and edge wrapping working this morning, so there are no map corners to wedge your city into.
I put the finishing touches in on my Java interpreter for my small functional language experiment.
main! => (printLine! "Hello world!")
The language is based on expression lists where each successive expression is applied to the previous expression if possible. The hello world example first evaluates printLine! and then applies a string constant to it, causing it to print. => is the declaration operator and is used to bind the result of an expression to a name.
Lambdas are curried by design (simplifies a lot, both for partial application of functions and for me as the interpreter implementer). Here we declare that add is a lambda with one argument returning a lambda taking another argument and summing the arguments.
sum => x -> y -> (x + y)
The language is optionally typed and currently has no type enforcement, but typed syntax is allowed (just not implemented yet). That would look like this:
sumInts => x: Int -> y: Int -> (x + y)
x is evaluated, + is applied to x (+ is a method of Int) which returns a partially applied function which is then evaluated when y is applied to it. x $ + $ y, you could say.
KiloGram => type (amount: Int)
Declares a type with one field, amount, of type Int. Ints, Longs and other primitives are objects too. This makes the language quite slow but if performance becomes important I’ll write a compiler instead. Or something. Performance isn’t a priority currently.
FiveKilos => (new KiloGram 5)
We instantiate the KiloGram type as you would expect. Same syntax as Java.
member double => self -> (self amount * 2)
There’s a method returning double the amount of the KiloGram. The member keyword by default attaches the method to the type that was last declared; but the language has open classes and we can add another method at any time and any place to any type.
member triple of KiloGram => self -> (self amount * 3)
And since some of you may be wondering where the assignments are, they’re done using the <- (store in) operator.
index <- 0
Stores the value 0 in variable index. Type inference sets index to an Int.
There are more features that I haven’t included in this post because I’m not sure anyone else is interested in seeing more and I feel I’ve scratched the itch of showing off the language for criticism now.
Some of the features not shown, but implemented, are:
- Module syntax
- Require for loading other files
- C FFI (built on JNA for simplicity)
- Conditionals as expressions
Technical details: the parser is generated by ANTLR according to a 60-line grammar, JUnit is used to test various cases (that’s been invaluable so far), and JNA is used to access C libraries (for the FFI; because at this stage I prefer ease of use to speed).
If anyone is interested in hearing more or trying out the interpreter or seeing the source just ask and I’ll gladly share 
EDIT: I forgot, functional languages always show off their factorial functions, well, here’s mine
factorial => x -> if (x = 0) then 1 else (x * (factorial (x - 1)))
Wrote a few articles for the JGLOOm wiki, we’re almost done with the first release. Most of our planned functions are finished!
Playtested a lot of Basingstoke this evening. It’s slowly getting there.
Cas
I am looking forward to it. Tho I hope i am better at it than titans revenge.
This is software rendered, 11,000 polygons, 3 light sources, 25fps, texture mapping, full frustum clipping, gouraud shading with specular highlights.
Still addicted to software rendering, this will be replacing the graphics engine in Shard Master soon and I might remaster the graphics in VSim by implementing this new engine into it as well
Not related:
Also learning QT C++ and their Q3D engine.
I am in a perpetual battle with Alli to stop the game being ludicrously difficult. I spent all day arguing with him that the game was too hard, but he just couldn’t see it. Even though I, who know how the game is designed, couldn’t get past level 1 75% of the time, and had never even seen level 3. Eventually he capitulated with a 5-line code change and oh! Look I can get to level 3 finally. Sheesh.
Here’s a top tip: don’t ever listen to yourself when it comes to difficulty testing. Listen to the testers.
Cas
Apart from being more advanced, is it any faster than the previous rendering tech you wrote?
I’d say yes because it runs at similar speeds but with much better quality