No. of Reviews: 22
Review 1
Purchased!
INCREDIBLE FREEDOM, LIMITLESS EXPERIMANTATION
This game is incredibly original and brilliant beyond measure. The game, to me,
is reminiscent of Scribblenauts, as the player is rather overpowered. Such
power, though, leads and infinity of almost boundless possibilities. I wouldn't
recommend this game to speedrunners, as I believe trying to find the most fun
solution to a problem is the best aspect of this game. The time travel mechanic
really encourages experimentation, even when reckless.
Well worth your money and your time.
import steamLibrary
if not hackNSlash.bought then
HackNSlash.buy()
end
Review 2
Purchased!
I actually really enjoyed ~1 hour of this game, near the middle. Unfortunately,
the first 2 hours of the game were a chore, and the last 2 hours were crazy
buggy.
Ultimately, the buggy nature of the last hour of the game is why I do not
recommend it. Perfectly fine and valid solutions to puzzles sometimes won't work
until you restart the game. Heck, even redoing the exact same change sometimes
won't have the same result. In a game about coding, that's a huge no-no.
I had a glitch at the end where I couldn't get into the epilogue, even though I
hadn't edited anything that would affect it. I tried different things for
literally half an hour. In the end, I restarted the game and somehow it worked.
To add insult to injury, the ending was utterly unsatisfying, and left me
feeling like I wasted my time.
Review 3
Purchased!
WARNING:
NOT recommended for people who cannot grasp programming logic.
While the game starts out easy and friendly towards people with no programming
knowledge, it gets a lot harder
in Chapter 4 for people who have never written any code.
Plus, to REALLY enjoy this game to the max, you need to have an inherent
curiosity for tinkering with the massive amount
of possibilities the game gives you near the last quarter of its ~6.5h (if you
don't get stuck much on puzzles) playtime.
To people who DO enjoy the tinkering and regularly try to break the limits of
games, I say:
"I hacked an event and made my fairy companion Bob exclaim 'Sheiiiit n***a,
we're so dead' upon triggering a deadly timebomb trap.
9.9/10 best, most innovative game I've played in a long time"
Review 4
Purchased!
As a progammer and a lover of puzzle games, I figured that I'd brave the mixed
reviews since I fall within the target demographic. Despite that, this game was
a disappointment. The puzzles are either uninspired or obscure, the game is
liable to crash often, and the dialogue is grating.
Some of the early problems were promising, but simple. "Hacking" objects to
modify high-level object properties made for some novel challenges, but there
are few enough hackable objects and few enough properties within each that most
of these puzzles reduced to "hack problem object, adjust obvious property."
At some point in the game we are given the ability to actually examine and edit
objects' code. Unfortunately this also leads to either frustrating or overly
simple puzzles. Many times in the game we simply enter an object's code and
change it's "isHackable" property to true, then hack the object and change some
obvious property. A fine puzzle to solve once, but to use it at several critical
points seems repetitive.
I'm not familiar with Lua (the langauge the player manipulates in-game) and
figured this game would at least give me a sense of the language. This was not
the case. The structure of the in-game code was such that its purpose was often
impossible to decipher - loops and conditions were presumably present but all
code was displayed in a perfectly linear manner and I emerged even more confused
about Lua than when I began.
Most of the late-game programming puzzles offer up the bit of code to be
modified pretty easily. Upon entering an object's code you can visit various
subclasses and functions, most of which are long and clearly critical to the
game's normal function. The game does allow you to visit these blocks of code
(though this sometimes crashes the game with longer sections) and does allow you
to modify them, but their size and codepenence generally means that no
meaningful changes can be made without "crashing the game" (errors created by
the player result in the "end of the universe" and you must reload), and puzzles
are rarely solved by doing so.
In contrast, other blocks of code have a very different style - short and with
clearly labeled variables that pertain to the puzzle at hand. Identifying which
blocks the game invites you to modify is pretty easy based only on this clear
difference in style, and once you've found the critical function you can often
change a simple boolean or integer without really understanding what you're
doing, and solving the puzzle.
This is not to say the game is a breeze - many puzzles are not obvious. The
challenge comes not from the innovation of the puzzles but by their obscurity.
No direction is given to the player in several key sections, and it's often
unclear whether you simply don't have the object required to get past a
challenge, or if you haven't dig deep enough in the code.
The final puzzle was especially unrewarding. A deep delve into the final boss's
code was fun, and I finally mananged to convice the boss to destroy itself.
Success! ...or, nope, I'm just stuck in the boss screen with no boss. I reloaded
and tried a different tactic, but this one defeated the boss as well as
destroyed the universe. Suspecting a bug, I turned to a guide which presented a
third, equally viable code tweak which was arbitrarily selected as the "correct"
one by the designers and moved the plot forward.
I also was able to accidentally skip a final puzzle by reloading at a particular
spot (which I only realized by reading a guide after completing the game), which
makes me unsure if this happened at other points in the game.
A final note is the humor: The writers try painfully hard to make witty dialogue
but it comes across as juvenile and bizzare. I'm a fan of good humor, high- or
low-brow, but this game delivers neither.
I DID finish the game in the hopes that such a novel concept would yield at
least a few inspired puzzles or challenges, and admittely a few did come close.
Riding the line between puzzle game and programming chalenge, ultimately the
game fails as either. To programmers and puzzlers, I advise you to seek fun
elsewhere.
Review 5
Purchased!
I just finished playing "Hack 'n' Slash". And by "finished", I don't mean
"completed the game"…
I got all the way to Act 4, or the "Tutorial", at which point the game expected
me to modify increasingly complex graphical abstractions of Lua script. I am not
a programer (not because I haven't ever tried), so this is the point where the
game stopped being at all fun. I'm not saying that I couldn't possibly have
figured it out and continued progressing, but…
I enjoyed what I played of this game, and don't regret purchasing it. However,
I'm a bit disappointed that the game puts up such a brick wall, after what had
been a fairly easy learning curve. I very quickly went from an "I am smart"
feeling to a "this is the point where I fail to 'measure up'" feeling.
Review 6
Purchased!
Half-way through the game the tutorials and ease of play are thrown out of the
window for heavy convoluted scripting puzzles, which you won't know how to
complete without a decent understanding of programming/game design/and debuging.
The game developers didn't want to decide if they wanted to make a game for
kiddies who have never coded (which started the game with gear that is akin to
learning visual basic front-ends) or veterans who have an idea of what they
doing (going super script heavy the last half of the game)
This indecision of how they wanted to make a game really hampered it. The first
half was boring for me, but the second half really caught my interest as I
hacked my way into areas I wasn't supposed to be going. But then again, after
you get the super hacking powers the game gets vague on what you were doing.
This game is unfinished. It presents a security risk already demonstrated with
the community workshop mods available for it. (opening up other programs on your
comptuer) And feels like it was rushed to be finished in less than 2 months
dseign and development time combined.
I would reccomend it to anybody who's up for a debugging challenge. I wouldn't
reccomend it for people who haven't read a line of code before though. And I
wouldn't reccomend downloading any of the workshop mods available for it.
I really wish this was something morethan what it is. But as of right now, it's
just a proof of concept, and a reminder of what could have been.
Review 7
Purchased!
Clever concept, poorly implemented. Hard to know where to go next. Unclear
goals. Boring story.
Review 8
Purchased!
Top down legend of zelda knockoff with the ability to change code in the game!
An amazing idea, let down by a lack of attempts to teach the player. You can't
even look up walkthroughs as the code was changed in an update so most of the
guides are useless unless you use the newer speed runs.
it goes from fairly easy to understand coding concepts such as cracking a
password before suddenly tossing you in the deep end with needlessly complicated
code lines to perform simple functions.
If they would have just found some way to build the player up to the harder
concept stuff this would be one of the most interesting indie games around, But
truthfully, no-one who hasn't studied code languages should touch this
Review 9
Purchased!
This game feels a bit cheap at first and really lacks some polish, but its later
stages most definitely make up for all its flaws! As you progress through the
game, you'll get more and more control over the world as you literraly hack
deeper and deeper into the code of the game. Once you manage to get deep into
the latest act, this gets pretty insane and, dare I say, absolutely brilliant.
It's really nice to see that the author of this game managed to push its crazy
but greatly refreshing concept so far! Double Fine still delivers.
Much recommended! but definitely not for everyone
Review 10
Purchased!
Do not buy this game. This is not the programming game you want to buy. It is
not worth the money, and it is not currently, by my standards, a finished puzzle
game, much less one that teaches any reasonable amount of programming.
It is a beautiful idea for a game, and a very clever title for the idea. But
this game does not live up to the beauty of its idea. If you must buy it, wait
for the game that purports to teach programming to at least be itself adequately
programmed. That is not the game that is available right now.
Hack 'n' Slash is a game in which you swing your USB sword to, instead of
slaying things, set their hit points to 0. I can offer no higher praise for the
integration of the "hacking" in the game for the first few minutes of gameplay.
Instead of attacking the turtle, you hack its allegiance so it becomes your
ally. Instead of finding the right order of blocks to push for a block pushing
puzzle, you simply hack the number of remaining pushes allowed for one block.
Reprogramming the movement of the guards was hilarious.
Then, just as quickly as the fun begins, the clever puzzle design disintegrates.
The coding is still painfully inaccessible and unserviceable—if you're a
programmer, it's boring and tedious for no apparent reason, and if you're not a
programmer, there's no chance you'll really even understand the puzzle as it's
presented. As an experienced programmer, putting together the clues using
detailed understanding of how programming generally works got me through the
"programming puzzles", but left me painfully frustrated by how obtuse they were
guaranteed to be for someone who didn't automatically know that "HackBlock 1" is
probably the same in-game object as "blocks<1>". I see no reason to relate a red
letter 'a' directly to a red diamond symbol other than educated guesswork. A
game which requires trial and error is fine, but a game that requires too much
backtracking between trials and crashes when you don't know what you're doing is
not a game that encourages learning.
The most frustrating thing for me was when I immediately saw the solution the
programmers intended, but also that there were far more obvious and trivial
solutions. Let's take a hypothetical locked gate as an example: if instead of
entering the prescribed password, you simply toggled some output value from
"false" to "true," you might bypass the intended lesson entirely. Not only are
the puzzles poorly thought out, they don't even enforce the intended lesson. I
can't imagine anything other than inexperienced players blundering their way
through the "puzzles."
The game crashes when the built-in LUA interpreter falls apart, because instead
of being a sandboxed interpreter, the game runs code you throw at it natively,
and I wouldn't be surprised if the game was a legitimate security vulnerability
for getting admin access to the local machine. What's worse, the programming
conventions used are distracting, if not outright confusing. The variables that
are useful to hack aren't even always next to the lines of code they relate to,
requiring mundane back calculation or walking around to find the right variable.
Imagine if a game that wasn't about programming presented these qualities: for
instance, you found yourself in a hallway with five switches, and the purpose of
the switches only marginally explained to you. There is absolutely no feedback
to tell you what each switch does, unless you've solved the puzzle, or
unknowingly triggered a fail state. What's worse, these fail states cause you to
lose any forward progress made not only on the current 5-switch puzzle, but also
the 3-switch puzzles that you've managed to solve in the same hallway. This is
not what I consider a good puzzle game, but it is exactly the sort of scenario
Hack 'n' Slash unforgivingly drops players into. Where traditional games undergo
thorough testing to prevent the player from causing crashes, Hack 'n' Slash
markets the total (and completely unnecessary) instability of the game as a
feature. Can you imagine an point and click adventure game that crashed when you
used the wrong item on the wrong target? How is this fun for the player? Why
aren't they simply preventing unnecessary modifications, and adding iteration
limits and variable scopes to prevent accidents? The puzzles are poorly
designed, and just aren't fun.
And now for the rest of the game. As adventure games go, this game feels
incomplete: shoddy collision detection make movement a confusing dance, total
lack of information on what can and can't be done makes even thinking about
solutions total guesswork.Traditional adventure games leave a trail of
breadcrumbs to lead you along, and a useful assistant who makes sure the player
is at least going in the right direction. Not so in this half-done game. Between
acts the player is expected to know where they should romp for five minutes to
get to the next destination, and while this could be "part of the puzzle" in
some twisted logic the latter half of the game is a series of tedious
activities: wander until you reach the next scripted destination, randomly
permute code until success. Nothing is named in a useful fashion, nothing is
provided, and the game gives you more ways to cause a crash than it does any
meaningful direction towards a smart solution. There's invariably way too much
information available as "clues," and the player has no idea what's useful and
what's just there because the programmers thought it would be cool. I spend so
much time wading through unnecessary details for reasons I don't understand to
solve puzzles that aren't even intellectually challenging so much as they are a
series of inside jokes. The final puzzles aren't so much arcane wizardry as they
are exercises in variable tweaking, and there's not even any guide to explain
which variables should really be tweaked to start with. Behaviors not explained
before or after a particular puzzle are used and so players shouldn't even know
to try the things the developers expect us to know.
As someone who actually studied computer science, incidentally, I'm disappointed
by what the game refers to as algorithms. None of the implementations are
meaningfully quantifiable algorithms. This is what most saddens me, to be
honest: there are so many beautiful, challenging, and meaningful problems in
computer science that programming games could explore and teach. Even the final
chapter of the game, purported to be a legitimate programming challenge with
actual security applications, boils down to a series of password reading tricks
used earlier, or the mundane "wander, hack, permute" process. I was hoping to
maybe see some binary search, or some loop iteration, or even just simple
mathematics to inject actual challenge into the game, but instead found myself
going through the exact motions I go through when debugging ugly, poorly written
code. "If x ==y continue" tells me nothing about how many lines are actually
part of the if statement, by the way. LUA probably wouldn't have been my first
choice as a language for making the code readable to nonprogrammers. Might have
been smarter to create a simpler, if still Turing complete domain specific
version of LUA that doesn't throw unfamiliar terms like jump statements and
closure operations. I'm saddened by the possibility that LUA was chosen not
because it's a beautiful, educational language but because it made executing
user code easy (and highly destructive and universe-collapsing). I spent more
time shaking my head at the programming choices than solving the puzzles, and
even more time wondering why Double Fine failed to even make the non-programming
parts of the game enjoyable. It plays like a very promising alpha, which would
be encouraging, if the game wasn't being marketed as a full release.
This is not a programming game. This is not a well-programmed game. And what's
worse, this is not even a good game. I'd save your money if I were you.
Review 11
Purchased!
I loved the idea of this game. BUT it has alot of sequence breaks and further
than that alot of stuff that is VERY VERY important that you can just miss.
Because of this it is very frustrating
Review 12
Purchased!
TL;DR: A unique game for programmers, not an RPG at all but more of a
programming puzzle game. I guess the programming part is why a lot of people
don't enjoy it, though. If you know how to program and enjoy programming
puzzles, definitely buy it when on sale.
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
At first the game seems like some normal adventure game, with the quirk that you
can plug your sword into some monsters and change some of the way they behave.
Nice but limited, it's a game after all and most people enjoy this part.
Once you progress, you get more powerful abilities. If you though editing a
bunch of variables was cool, think again. Once you progress you can change the
actual game source code...
THAT BLEW MY MIND
The code editing does have some limitations: you cannot delete lines of code,
but you can change the logic used. And if you mess around too much you'll crash
the game. When it crashes you can go back in time to earlier states: it has
version control. If you know what you're doing it's not a hard game at all and
most puzzles are pretty straight forward.
The problem with it is that the story and pacing could have been better, and it
seems that the narrative is only a means to string together the different
puzzles.
Review 13
Purchased!
I LOVE this game! It's so unique and is a great way of visually teaching the
logical thought processes and patterns of programming without scaring people off
too much with all the syntax. I'd recommend any hobbyist programmer play this
game, as you'll enjoy it and it'll feel comfortable. I'd also recommend anyone
thinking about getting into programming to play this game, as it'll help you get
into a mindset for programming; this can help you learn HOW to think like a
programmer.
Review 14
Purchased!
Does this game have a brilliant concept?
Yes.
Is this game enjoyable for the general public?
Eh.
It's quite special for a developer to get an idea that rubs down to: Hey, isn't
it fun to let players alter the game the way they like and hack almost anything?
But, somewhere down the line of production, I guess they forgot to realize how
user-unfriendly this game can get beyond Act 4. It's not puzzle, oh no, not your
every day 'explore-and-find-clues' puzzle, it's a confusing, excrusiatingly
painful coding experience.
Worst of all, this game -crashes-, and by that I mean ALL the time. Any event
where you mess up on either hacking things, digging into Algorithm, you have the
potential to slam into different kind of bugs that the developer didn't iron
out. If you hit too many bugs, it wouldn't even allow you to go back to your
previous setting (An item in game that basically rewind what you do), forcing
you to shut down the game and restart.
Option menu is totally devoided of any options other than choosing
fullscreen/window mode, as well as sound. Where is the graphic options?
All around, it's a game with potential, but is underdeveloped. It's baffling
that this game can even win an indie game award with the state it currently is
in.
Review 15
Purchased!
Note: That "Reccomended" does *not* apply to people who aren't programmers. This
game isn't for you. If you aren't willing to do a little searching into how Lua
do, then it's especially not reccomended for you. Lua's weird.
It starts out a tad dull. Just a few silly "hacking" mechanics where you can do
goofy things like make a turtle have 5e7 hp, do 2.4e6 damage, and friendly.
That's alright and all. When I got the chance, I made sure to speed up time to
the max and change my running speed to as high as possible.
Then you get to the library.
The library is where the game really starts. You can go into files as they're
running and just screw with them.
I once made the game freeze so hard Alt-F4 didn't work by changing a numeric for
loop to going from 0 to 0.
The code is difficult to edit in that most of the variables are locked from you
and what operations are happening are immutable... you just get to screw with
the rest. Testing for equality, I see? Let's make that testing for inequality.
Working within the constraints given is extrmely entertaining, especially when
you're doing stuff you were never intended to. I highly reccomend finding the
book in the library for you.
The actual game's puzzles tend to be solved by calling functions that are
supposed to be called by the "success" script, which gets bypassed entirely, by
way of the "fight starts" script. That or flipping a loadbool or five.
The actual fun, though, that's when you start goofing around afterwards. Tired
of the stupid green fire everywhere in the library? Well, what if the init
file's "scale" were locked to 0? (It makes it invisible).
TL;DR: Reccomended for people who like to break things and are already
programmers, preferably fluent in Lua, since Lua's weird.
Review 16
Purchased!
HnS is a very short, deeply flawed, pretty creative puzzle game. If the writing
is inconsistent but generally terrible, the puzzles can be unfairly obscure, the
soundtrack merits a level "meh" if not a disapproving "feh" at some times, and
it comes off as a prototype that is exceedingly buggy and sometimes hard-crash
prone (e.g. the first room in Act 5), why "buy that for a dollar" even on DEEP
sale?
Because the gameplay is pretty unique, and the art is charming (Stacked and this
game give a good look at why DoubleFine is kind of like the anti-Kojiman
Tarantino of video game limited engagements). You progress from altering a few
variables on rocks and turtles (alas, LOGO!) to solving spatial puzzles with
non-obvious objects to tugging at a restrictive set of arguments and logical
tests directly in a strange room and machine floor metaphor for a program. The
final act involves regularly recursing into this "live-debugging" process for
objects you really would not ordinarily be expected to try to muck about with,
and there is a corny endgame, high-concept way of subverting objects that aren't
there. A Git-like branching checkpoint system seems cute and overkill at first
but will necessitate itself near the end. The game feels like around 3.5 to 4
hours of those comic interludes in Paper Mario, like where you had to bake a
cake that one time.
For all its quirks, what is maddening is this:
* Game is too short to let this wonderful system sink in, but there is also a
conspicuous lack of easy-to-have-added polish.
* For all various reviewers yammer on about programming, writing scripts is not
a capability you ever get; you are purely a saboteur of low cunning who breaks
things from within, as advertised. The old hacker ideal of making something is
not here unless you want to munge a burning bush to spawn a turtle breeding
ground which hatches an outhouse decal. Play Scribblenauts for those
shenanigans.
* It seems like DF dropped this game like a hot rock, which is just dumb given
how this game's potential far exceeds that of their other junk. The game and its
main menu strongly suggests moddability, and advertises this, but there is
*effectively* no support for Steam Workshop and no easy roadmap to how one might
decompile the Lua that is still compiled and correctly package mods. Any
community seems to have died long ago, and it is laughable in a truly sad way.
Review 17
Purchased!
This game is amazing. One of the best puzzle games I've ever played. Extra cool
if you happen to be a programmer, as the game eventually involves
parsing/modifying functions to progress.
Review 18
Purchased!
A very interesting concept, but I see several issues with this game.
Cons:
* It's absolutely NOT recommended for people with no programming/algorithmics
knowledge. The first half of the game should be doable by almost anyone, but as
soon as actual code is shown and modifiable (end of Act 4 and all of Act 5), it
can be overwhelming.
* The code you can hack is displayed in a very hard to understand way. I heard
it's based on the game's Lua bytecode. Why not let people see/modify the source
code instead? Bytecode is not meant to be read by humans.
You can see the code as text, or there is a sort of visual representation with
machines and crystals, but it's just too confusing. As a professional
programmer, I grasped most of it, but I think most people won't.
* The graphics look mostly bad. The characters are OK but the backgrounds... The
level design is meh, with many useless paths and dead ends.
* The music is forgettable
* A bit on the short side, with low replay value unless you just want to test
how far you can go with the hacking. But then why not program your own game
instead?
* The ending is surprising but weird, nonsensical and abrupt to me.
Pros:
* Awesome base concept
* Some of the puzzles are quite cleverly made
* The "Double Fine touch" is here, with quirky characters and dialogs, but it's
a bit weak. Psychonauts is way better in that regard.
* It's challenging for your brain for those who like that.
Not really a pro nor a con:
* Near the end I think I skipped an important scene completely with hacking.
That's pretty cool but I'm missing part of the story!
* It's only in English. I didn't really mind even though I'm French, but some
people will. I think it would be really hard to translate such a game anyway
(all the game's variables and functions would have to be translated)
Conclusion:
If you are a programming junkie, a bit curious, or just want to challenge your
brain, buy this game when it gets cheaper. Otherwise I think it will just be a
frustrating experience and you will not enjoy it.
Review 19
Purchased!
This is a cute concept. But terrible execution.
Short plot with predictable story elements and lackluster writing, which is
somewhat unusual for DoubleFine.
The 'hacking' aspect can be fun, but I can see it being unnecessarily difficult
for anyone without at least a passing interest in programming that doesn't
already have the fundamentals down. It doesn't really explain much to you, so
expect to do a lot of trial and error in that regard.
Overall, it took me like ~4 hours total despite getting 'stuck' a few times.
While I did get some enjoyment out of it, overall I wouldn't recommend it for
the average player, and definitely not at full price.
Review 20
Purchased!
I'd have to say that the concept behind this game is unique and really awesome.
However, like many other negative reviews, the execution is lacking. I'd still
recommend it, because I know that pulling this game off is extremely hard, and
the devs did not fail terribly at doing so. They didn't pull it off great, just
fine, but it's not game-wrecking either.
Hack 'n' Slash has a certain sense of novelty before you buy it. I mean, you
gotta change that boolean value to open the door! How cool is that?! But after a
while, the more complex puzzles kinda ticks you off with it's complexity. People
who have no prior background knowledge or experience with programming will find
this game impossible to complete, and will leave it hanging in their game
library.
The game is largely unguided, so you can actually run off and get yourself into
the wrong room/place before completing a certain task, or getting a certain
artifact. The game takes the difficulty up a few scary notches late into the
story, notably within the castle. I'm no elite programmer by any standards, and
I find that giving the entire library of source code in the castle is a little
overwhelming. I also did get lost a few times within the game, not knowing if I
should proceed this way or that.
All in all, I'd say it's a good challenge for those even with a strong
programming background. I'd recommend this game, but only if you know some basic
computer programming beforehand.
Review 21
Purchased!
Great concept, horrible exceution. Buy only on sale. If you've never written a
single line of code in your life this game could frustrate the crap out of you.
Up until the 4th act "hacking" is very repetitive, but should be easy enough for
everyone. I was hoping for the part of the game when editing of the code itself
starts but it doesn't. Ever. What starts in act 4 is just bad. I've never
programmed in LUA before, but why the game developers chose to mix scripting
with some colorful gems and going "into" scripts is beyond me. It's confusing.
Why they chose to hammer people down after relatively easy first part of the
game by denying us real power? A real editor/command line to modify/hack the
code?
I was hoping for something in a line of the CodeCombat browser game (Google that
if you want). This way Hack 'n' Slash could actually teach some programing to
people and giving a player more freedom.
5/10 (for graphics and general DubleFine dialogues).
Review 22
Purchased!
Recommended for programmers/tinkerers. Others will probably be confused and
disappointed. This review itself will likely not make that much sense to the
latter group.
It's in the current Humble Bundle Weekly at the $1 tier (ends 2015-11-5). Worth
it at that price for sure.
This is not a "programming" game (like TIS-100, SpaceChem, Human Resource
Machine, etc). It is a "hacking" game.
It is definitely not a "Hack and Slash" game as it may seem to be at first
glance. There is very little of anything resembling a normal game here, although
it has a vaguely Zelda-esque facade.
As a minor connoisseur of sorts when it comes to programming/hacking games, I'm
not aware of any other game that has done what HnS has (Edit: The more recently
released Else Heart.Break() seems to do something similar, but I haven't played
it yet).
The title is more of a proof of concept than a fully featured game. Not really a
surprise at this point coming from Double Fine. But the proof of concept alone
should be worth the price of admission and the time for those interested in this
sort of thing.
Most of the game is written in Lua (a very common game scripting language). The
game (gradually) exposes the ability to modify itself, but only to a limited
extent. You start off being able to only modify some instance variables of
certain entities (and later a handful of game instance globals, if you can find
them). Eventually you gain the ability to examine the code of just about
everything, but you can only modify constants (including the names of called
functions in some cases). You can also swap a few operators.
Although that sounds like a lot of power, there is actually fairly little you
can do that is interesting or useful. The majority of the "puzzles" reduce to
finding the right variable or operator to alter in typically fairly mundane ways
(e.g. flip a bool, comparison operator, make a number very large or very small).
That's not all that surprising considering how difficult it is to accomplish
something more meaningful from a gameplay perspective in this kind of system.
But what is there is reasonably fun/amusing. And thankfully it doesn't grow old
because the game is quite short.
Typically hackable entities can be "hacked" (have their state/instance vars
altered) by attacking them with a weapon. Later in the game, you gain the
ability to hack into a larger variety of entities by actually modifying the code
(again, only specific parts of the code). This is done in an unusual, noteworthy
fashion:
Instead of simply editing the code text/values directly, a visual/spatial
representation of the code is created in which you can walk around and modify
particular constants and operators.
Strangely, when the game shows you the Lua code, it doesn't actually show you
the raw code. Instead, it displays it in a rather strange, awkward syntax that
actually makes it more obfuscated than it is in the original Lua (for a typical
programmer, at least). I guess it could be said that this better immerses
already experienced programmers, forcing them to "learn" the system even if they
already know Lua.
Near the end of the game, you also gain the ability to browse the entire(?) lua
game source. This is represented as a library in game, where each level of the
library is a directory, and staircases are the means for directory traversal.
Individual files are books on a bookshelf that can be stored in your inventory
for direct hacking later. Again, despite how much power this seemingly conveys,
the actual usefulness of this is quite limited. But it's a cool experiment.
Hack 'n' Slash 
