How to transform JavaScript OOP into functional

I'm curious how my game would look like in functional style instead of OOP.

Here are core lines of code in Node.js:

if (!player.owns(flag) && player.near(flag)  && flag.isUnlocked()) {
    player.capture(flag);
}

My guess was, it could look like this:

var canCapture = [not(owns), isNear, canUnlock].every(function(cond) {
    return cond(playerData, flagData);  
});

if(canCapture) {
    // how to capture?
}

But not sure, as not experienced functional coder. I'm interested in every answer close to the subject (it can be even in other programming style).

It could look somewhat like this:

if (!player.owns(flag) && player.near(flag)  && flag.isUnlocked()) {
    capturingPlayer = player.capture(flag);
}

where capturingPlayer is a new object, whose difference to player is that is has captured a flag. player is unmodified by the call to capture.

If you prefer a "non-OO" syntax (whatever that could mean)

if (!owns(player, flag) && near(player, flag)  && isUnlocked(flag)) {
    capturingPlayer = capture(player, flag);
}

To expand and hopefully clarify a bit:

Functional programming, in the sense employed by the functional programming community, does not just mean "functions/procedures are first-class objects".

What it does mean is that functions are functions in the mathematical sense, i.e.

  • All functions return a value.
  • Every function returns the same value every time it's passed the same arguments.
  • A function has no side-effects whatsoever - there are no mutable objects or assignment.

So, as long as none of your object's methods mutate the object, you don't really need to change much to program in a "functional style".

Edit:

Unfortunately both "functional" and "object-oriented" (in particular) are pretty ill-defined concepts.
Try and find a definition of "object-oriented" - there are at least as many definitions as there are people attempting to define it.
To get an understanding of functional programming, read Why functional programming matters by John Hughes, at least twice.