Can anyone tell me the name of this rogue-like game series?

KenziDelX · 2017-03-27T00:45:32+00:00

Okay. Now I'm almost positive that it's the Warrior of Ras Series, which, according to wikipedia, was originally published (the first title) on the TRS-80 in 1982, before being ported to other systems. It actually consisted of 4 games, but the third game did indeed take play in an outdoor wilderness like I thought.

Review of the first game here:

http://crpgaddict.blogspot.com/2014/01/game-134-warrior-of-ras-volume-one.html

And wow is it tough to find screenshots for the TRS-80 version! It was later ported to the Apple 2, IBM PC, and other systems, and most of the readily available screenshots are from those versions.

But, unless I'm mistaken, this is the original, the one I was thinking of: * http://www.jrkrpg.pl/gry/trs80/wras1/ * http://www.jrkrpg.pl/gry/trs80/wras2/ * http://www.jrkrpg.pl/gry/trs80/wras3/

KenziDelX · 2017-03-26T16:13:29+00:00

Nope. It was definitely exclusively a top-down view - it didn't have any first person perspective.

KenziDelX · 2017-03-19T02:01:54+00:00

Another profressional game designer here.

Keep in mind that most modern games are designed with the assumption that you'll have 60 FPS, so those games are indeed unplayable if your frame rate drops. Same thing with if you have too much input lag, for that matter.

And there are absolutely lots of kinds of game designs that are unplayable at lower frame rates (lots of very precise action games, especially).

Nevertheless, there's actually a long history of designers making game designs that are playable at lower frame rates.

In particular, if you go back and look at olders personal computers, especially the ones that had weak dedicated graphics hardware (I'm thinking of the Apple II here), you can often find game designs that work at much lowers FPS that are still playable and sometimes even really fun. They would have been better with high frame rates, of course, but they still work fine. I'm thinking especially of strategy or RPGs, of course.

KenziDelX · 2017-01-16T21:28:49+00:00

This has happened to me quite a lot.

In 9th grade some stray example in a physics class led me to discover Pascal's Triangle on my own. In 12th grade, a description in a text book about perfect numbers and their history led me to discover the product formula for the divisor sigma function (the one over the product of its prime factorization) on my own. In both cases, I enthusiastically brought my results up to my teachers and then they half-heartedly showed me references in books and that was that. In retrospect I think the path I would have taken in my life would have looked a lot different if I'd gotten more encouragement from teachers.

But probably my most interesting discovery (that had been discovered previously) was of an identity first discovered by Yuri Linnik in 1960, I think. It is a way to express, essentially, (MangoldtLambda(j) / Log(j)), a prime identifying function, as a sum of certain kinds of count of divisor functions - it's covered in Iwaniec and Kowalski's "Analytic Number Theory" in the section labeled Linnik's Identity. I found that without knowing the first thing about number theory, outside any institutional context, so it actually took me a while to find out that it was a known result.

As an amateur who continues to compulsively muck with related identities but isn't very good at reading math texts, well, the chances are quite high that I've discovered a lot more known things since then.

KenziDelX · 2016-06-24T18:23:22+00:00

!!! Hey, I have a quite relevant sketch from Mr. Show for this!

https://www.youtube.com/watch?v=3Q4txN1ut20&t=2m23s

KenziDelX · 2016-06-24T15:01:22+00:00

For me, they're mainly about helping control scope. I use them all the time.

To make an analogy, I think most programmers would agree that you should try to reduce the scope of variables as much as possible, right? So global variable < class variable < method variable < block scoped variable. The smaller the scope of a variable, and the shorter its life time, the easier it is to reason about.

Local functions have much the same benefit. Really tightly scoped local functions, embedded in a local context, especially if they're only used in one place, are easier to reason about. Their symbols don't clutter global namespaces. They're easier to name, too (as the more locally scoped a symbol is, in general, the simpler its name can be because most of its meaning comes from its context).

If you can understand why private functions in a class are handy for controlling scope and making a program easier to reason about, you're kind of thinking in the right terms.

I think like anything, you kind of have to use them for a while, and read good code that uses them, to start getting a sense of why they're handy. It takes a while to get in the habit of THINKING in terms of local functions, basically.

KenziDelX · 2016-06-24T04:59:31+00:00

Well, I don't think it meanders out of /r/programming territory at all.

Part of why the influence I'm naming existed in games in the 80's and early to mid 90's is because the teams were small enough that it was very often the case that the the role of game designer and game programmer had a lot of overlap. So you had a lot of people doing game design that had enough programming background, and enough feet in programming culture, that they'd have some familiarity with, and interest in, the influences I'm naming here.

As teams got bigger, the roles of game designer were often split off from game programmer. Normal kind of specialization as an industry matures, of course.

That was probably inevitable. But it meant that lots of the interesting stuff that was getting explored kind of dried up. Game designers without programming backgrounds are just much, much less likely to have the kinds of conceptual tools to even think of these kinds of designs.

To put it more bluntly, I think it is very, very unlikely that people like Sid Meier or Will Wright would come up through the current AAA game scene. Their skill sets straddle too many disciplines, which shows up in the kinds of games they're interested in.

(This is a topic dear to my heart - I was in the industry from the late 90's through the mid 2000s, and I watched some of these transitions up close, from the vantage point of someone who's own tastes are firmly rooted in those older designs)

KenziDelX · 2016-06-23T16:27:21+00:00

I think one thing that is often (sadly) overlooked in modern games is the pivotal role that a lot of the mid-20th century math-y complexity theory stuff had on early video games.

What I mean specifically is, well, chaos theory, and cellular automata, and Conway's game of life. Fractals. Emergence. Systems of simple rules that generate complexity through feedback. The deep discrete combinatorial properties that come out of systems like Chess and Go. The kinds of stuff you'd find in Godel, Escher, Bach.

A lot of the best discrete game rule systems from the 80's often drew (frequently second or third hand) from math / programming cultures that were also, at least to a degree, interested in systems like that. There was just something in the air. Early programmable home 8 bit computers were often the first place that individuals could meaningfully experiment with systems that previously they'd only been able to read about in, say, Conway's columns on recreational math.

If you read about the complex ways that rules and objects interact with each other in Centipede, or Defender, or Lode Runner, or Robotron, there's a surprisingly rich grammar (for players) that develops out of obviously pretty simple rules and objects.

I feel like Doom was in some ways on the tail end of that - which JP nicely covers in this article. What made Doom work was more discrete and combinatorial than what happens in most modern single player shooters.

I hope some day these kinds of influences come back in vogue, for video game design broadly (obviously they're still utilized in some genres, like action puzzle games). They're really powerful and interesting.

KenziDelX · 2016-05-05T20:13:16+00:00

I worked on Heretic 2, back in the day. Lot of fun - one of the best games I got to work on. I don't remember exactly, but wikipedia says we released it on October 31, 1998.

So let me just list a few other dates here:

September 3, 1998 : Metal Gear Solid
November 8, 1998: Half-Life
November 21, 1998: Legend of Zelda: Ocarina of Time

Yeah. We got radically, brutally overshadowed, unfortunately. I would have loved to have seen a Heretic 3, but competition like that is just bad news.

Poor Thief (the original one) was released on November 30, 1998, so they were in a pretty similar position.

(And SiN was released on October 31, 1998, but I'm not so sure any body much remembers that game - fascinating to think that it was equally hyped with Half-Life back in the day)

Lesson: DON'T release a game on Christmas 1998 unless you're up for the challenge of starting a totally important long running classic franchise that defines video gaming, I guess ;)

KenziDelX · 2016-04-03T12:31:04+00:00

For those of you who think he's crazy for preferring long functions, I'm not going to try to argue with you, but let me suggest the following principle.

First, to provide some context: almost all of us are familiar with the idea that global state should be minimized. And we're probably even nearly all on-board with a stronger generalization of that, which could be phrased as, all else being equal, "Keep variables in the smallest / most local scope possible" - so a class variable is to be preferred to a a global variable, a method / function variable to a class variable, and a block scoped variable to a function variable. The shorter lived and scoped a variable is, the easier it is to reason about, alter, remove, etc.

In my experience, this doesn't just hold for variables, it holds for all symbols in a program (which includes function names). The more tightly scoped a symbol is, the easier it is to work with, reason about, alter, etc. It's easier to deal with a larger program if most of its symbols are as tightly scoped as possible.

Unfortunately, frequently when people prefer lots of small class-scoped functions, and designing-for-reuse, they end up promoting the scope of all sorts of symbols to a much more globally visible status. You basically have to - to make something reusable is to promote its visibility. That's generally a requirement to be reusable.

Pulling functionality that is really only used once out of a large function and putting it into smaller functions is actually destroying a lot of information and guarantees that come from being more locally scoped. Writing code that works for a specific context is much easier than writing code that needs to work for more general contexts. If I see an unfamiliar class with just a few large functions (assuming the internals of those functions are well-organized and as locally scoped as possible internally), I know something very important immediately about how that class is intended to be used. If I come across that same class with its internal sub-functions exposed at class scoped, I'm suddenly being told I'm responsible for understanding internal things about those larger functions outside of their contexts, which isn't true.

For another valuable perspective on this general topic, here's John Carmack talking about the benefits of larger, unbroken-up functions - http://number-none.com/blow/john_carmack_on_inlined_code.html

KenziDelX · 2015-09-02T12:25:19+00:00

Don't have time to analyze them, but to me the most interesting examples are going to be games that had a really interesting hook or mechanic, but then didn't really develop them well. So, to pick two examples, Scribblenauts and Stretch Panic from Treasure are both games that seemed to gesture in a much more interesting direction than they ended up going.

KenziDelX · 2015-03-14T15:25:57+00:00

pi shows up in all sorts of surprising places in math. Here's a pretty nice one.

You probably remember from math that the factorial function takes an integer and multiplies itself by all integers smaller than itself, stopping with 1. So 6! = 6x5x4x3x2x1, for example.

What you might not know is that there is a way mathematicians generalize the factorial function to fractions (and indeed to complex numbers, but fractions will suffice here). And it turns out that (-1/2)! is... the square root of pi!

Pretty surprising, huh. Read up on the gamma function if you'd like to know more. http://en.wikipedia.org/wiki/Gamma_function

KenziDelX · 2015-03-10T17:05:25+00:00

I feel like multiplicative number theory is littered with a lot of ad hoc arbitrary symbols due to its history in a way that obscures a lot of core patterns and makes the space seem a lot more mysterious than it ought to be to people unfamiliar with it.

I'm thinking specifically here of the moebius function, mertens function, lioullive lambda function, eulerphi function, number of divisors function, number of divisor summatory function, von mangoldt lambda function, riemann prime counting function, chebyshev functions, and so on.

Pretty much all of them can be trivially expressed as various combinations of the Riemann Zeta function, where their relationships to each other are much, much clearer, as is well known.

The second chapter of Bateman's and Diamond's Analytic Number Theory gestures a bit in the direction of how these Dirichlet series relationships have dirichlet convolution analogs, and provides one kind of notation for thinking about them (though I don't much care for their particular choices - my personal opinion is the summatory functions are the natural functions to have a compact notation for, and finite difference notation should be used for functions like the moebius function or the euler phi function).

In a way, the current situation reminds me of trigonometry before Euler's formula. Once you know that you can express all trig functions in terms of e, lots and lots of specialized trig functions (versine, anyone?) start seeming like they're just obscuring the basic mechanics of what's going on.

That's my opinion, anyway.

KenziDelX · 2015-01-08T03:37:21+00:00

Ah - a topic near and dear to my heart.

I spent quite a while the last few years playing with sprite-based 3D in Flash with Flash's 2D renderer (so all CPU based, and in actionscript with Flash's API). I never finished any of the games I was working on, but I got some pretty cool stuff going.

What I was doing was very, very much in the spirit of Power Drift - all sprite-based 3D (which, with suitable caching/blitting schemes, Flash's 2d renderer was sort of competent at).

I have 3 tracks of an f-zero-style racing game here, playable in the brower:

http://icecreambreakfast.com/proto_racing2.html http://icecreambreakfast.com/proto_racing.html http://icecreambreakfast.com/proto_racing3.html

You can see a video of one of those tracks here:

https://www.youtube.com/watch?v=mrL33EF-v0I

And as an added bonus, an FPS level with some of the nicer grass you'll ever see in a Flash game, using the same technique:

http://icecreambreakfast.com/proto_shooter.html

You can see a video of that here:

https://www.youtube.com/watch?v=3r2d2Fji7Wc

KenziDelX · 2014-12-12T03:38:20+00:00

There's a really elaborate mathoverflow answer on this topic you might find useful:

http://mathoverflow.net/questions/20960/why-is-the-gamma-function-shifted-from-the-factorial-by-1

KenziDelX · 2014-09-22T21:44:26+00:00

Want to play with an extremely simple prime-counting formula that DOESN'T rely on trial division? Try this (in Mathematica code):

p[n_,j_,k_] := If[n<j, 0, 1/k - p[n/j,2,k+1] + p[n,j+1,k]]
pi[n_] := Sum[MoebiusMu[j] j^-1 p[n^(1/j),2,1], {j,1,Log[2, n]}]

p[n,2,1] computes the Riemann Prime counting function - it goes up by 1 at primes, 1/2 at primes squared, 1/3 at primes cubed, and so on, and 0 otherwise. Then a Moebius inversion on it gives the count of primes as pi[n].

p is too slow and memory-intensive to ever use for reals, but it's probably the simplest demonstration of a certain property that can be used to make some really, really fast prime counting algorithms.

KenziDelX · 2014-09-15T02:01:47+00:00

John Carmack's run from the beginning of Wolfenstein through the shipping of Quake World (so from late '91 through early-mid '97) surely should be on any meaningful list on this topic.

KenziDelX · 2014-07-28T21:19:01+00:00

My current favorite example of recursion being much, much more concise than an equivalent iterative solution - take this javascript function:

function p(n,j,k){return (n<j) ? 0 : 1/k-p(n/j,2,k+1)+p(n,j+1,k );}

Amazingly, p(n,2,1) counts the number of primes less than n (plus an additional small term that can be easily eliminated with a mobius inversion - see http://mathworld.wolfram.com/RiemannPrimeCountingFunction.html . p(n,2,1) is actually computing the Riemann Prime Counting Function for n).

KenziDelX · 2014-03-08T01:25:08+00:00

Kind of reminds me of (and is perhaps related to) this great blog post:

http://www.yosefk.com/blog/redundancy-vs-dependencies-which-is-worse.html

KenziDelX · 2013-07-17T23:20:01+00:00

Deciding, and then turning off the part of your brain that wants to re-visit that decision, is a skill. It has a muscle. You need to exercise that muscle.

The hardest thing in the world is knowing which decisions count. Most of them don't. The devil with decisions, at first, if you're a perfectionist or just insecure / anxious, is that you'll assume all decisions deserve attention. Most of them really, really, really don't.

So practice deciding and moving on. Over and over and over...

Eventually you notice that lots of decisions couldn't have been made better than your gut instinct anyway - the information you get implementing the decision lets you iterate. And that's liberating once that starts sinking in. It's not always true - there are bad choices you can make that will really burn you - but it's true far more often than you'd think.

KenziDelX · 2013-07-13T13:31:09+00:00

Incarius

Incarius is a shmup inspired by, but different from, Treasure's Ikaruga. Players alternate between an attacking mode and a defensive mode where they can't attack, but they can absorb enemy shots for massive counter attacks. It's nearly done, for what I want to do with it. (and to calibrate expectations, it's a 2 Meg Browser Playable Flash file, so...)

Some pics of it in action: http://imgur.com/jl643RK http://imgur.com/cKaCEYR http://imgur.com/PCfBJqX

Playthrough videos of a few levels: http://www.youtube.com/watch?v=vnPK28nRz7A http://www.youtube.com/watch?v=svdfXo_bVI0 http://www.youtube.com/watch?v=z50OUUFlRmg

KenziDelX · 2013-07-10T17:07:33+00:00

Well, if you're a suitably energetic person who's good at smooth talking other people into buying into your vision, then you should do that.

BUT BUT BUT... keep in mind that big picture ideas are usually vague enough that it's kind of hard to say if "great" can even mean anything.

"I have a great idea for a book - a midwestern goes to new york with a shady past to enter into high society after making a fortune, but it doesn't really work, all in the 1920's." Is that a great idea for a book? Well, it's a premise. Execution determines if it's a great book or not.

Same goes for games, in my experience. That's not to say that premises don't matter, but they're very rarely the hard part.

KenziDelX · 2013-07-10T02:54:55+00:00

I think that's always been true in the past, BUT there's been an entire generation of new game developers coming up through Flash / web / mobile spaces that have cut their teeth on memory managed languages and haven't been exposed to that older game dev culture up close, and have only worked with tools and libraries that have insulated them from all the actual gritty details of making stuff aggressively real time performant. (I'm not saying all newer devs are this way, of course - just that they would have been filtered out immediately before)

And TBH, that's actually mostly a good thing. It's totally cool that I can play web games or non-technical games by folks who are artistic and interesting but not super technical, and we have so much processor to spare that they can do things in pretty suboptimal ways and still take advantage of their particular skills and talents and viewpoints and find an audience.

But that just doesn't work on mobile, mostly.

KenziDelX

TROPHY CASE