Array of JavaScript arrow functions

Question

I'm implementing the card game Hearts in JavaScript, and one of the core elements of the game is that you can pass your cards to other players. My game has strictly 4 players, no more, no less.

The passing order goes left, right, straight ahead, then no passing. Therefore, P1 would pass to P2, P4, P3, and then pass to nobody. The cycle loops until the game is over.

I am trying to implement this logic via arrow functions, however, it is not working. What I am trying to do is print out the player, and the player that they should pass to, based on a given index.

Here is my code, I hope it is clear what I am trying to do.

const players = [1, 2, 3, 4];
const passingOrder = 2;
const passCards = [
  i => (i + 1) % 4, //pass left
  i => (i - 1 + 4) % 4, //pass right
  i => (i + 2) % 4, //pass straight
  i => i //pass to ones self
];

players.forEach((player, index) => {
  console.log(player + "passes to " + passCards[passingOrder](index))
})

Your code calls 3rd arrow function which is i => (i + 2) % 4 and gives output 2, 3, 0, 1. I don't get why you think this is wrong. — Onur Arı
– Onur Arı, Commented Feb 17, 2020 at 6:44
note that in your console.log, player is a player from 1 to 4, whereas passCards[...] gives an index to players. — grodzi
– grodzi, Commented Feb 17, 2020 at 6:45

Jacob · Accepted Answer · 2020-02-17 06:49:11Z

1

Your players a 1 based while the index is 0 based.

Try

console.log(player + "passes to " + (passCards[passingOrder](index) + 1))

Or make your players const players = [0, 1, 2, 3];.

answered Feb 17, 2020 at 6:49

Jacob

9262 gold badges8 silver badges19 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

nonopolarity · Accepted Answer · 2020-02-17 07:51:52Z

1, 2, 3, 4 are not good numbers to work with when you have to do MOD, which produces something from 0 and up, and you use it to indicate which user.

Use 0, 1, 2, 3 instead:

const players = [0, 1, 2, 3];
const passingOrder = 2;
const passCards = [
  i => (i + 1) % 4, //pass left
  i => (i - 1 + 4) % 4, //pass right
  i => (i + 2) % 4, //pass straight
  i => i //pass to ones self
];

players.forEach((player, index) => {
  console.log(player + "passes to " + passCards[passingOrder](index))
})

Or if you want to keep it 1, 2, 3, 4, or even use names, you need to use the index generated to find the player using players[generatedIndex], where generatedIndex is passCards[passingOrder](index):

const players = [1, 2, 3, 4];
const passingOrder = 2;
const passCards = [
  i => (i + 1) % 4, //pass left
  i => (i - 1 + 4) % 4, //pass right
  i => (i + 2) % 4, //pass straight
  i => i //pass to ones self
];

players.forEach((player, index) => {
  console.log(player + "passes to " + players[passCards[passingOrder](index)])
})

And you can use names if you want:

const players = ["Peter", "Paul", "Mary", "Susan"];
const passingOrder = 2;
const passCards = [
  i => (i + 1) % 4, //pass left
  i => (i - 1 + 4) % 4, //pass right
  i => (i + 2) % 4, //pass straight
  i => i //pass to ones self
];

players.forEach((player, index) => {
  console.log(player + " passes to " + players[passCards[passingOrder](index)])
})

And all passing methods:

const players = ["Peter", "Paul", "Mary", "Susan"];
const passCards = [
  i => (i + 1) % 4, //pass left
  i => (i - 1 + 4) % 4, //pass right
  i => (i + 2) % 4, //pass straight
  i => i //pass to ones self
];

passCards.forEach((passMethod, iPassMethod) => {
  console.log(`Game ${iPassMethod + 1}`);
  players.forEach((player, index) => {
    console.log(player + " passes to " + players[passMethod(index)])
  })
  console.log("\n");
})

Lewis · Accepted Answer · 2020-02-17 06:57:04Z

We're going to cheat. Rather than waste time trying to solve this in an overly creative way, we're going to make an object that lays out the association between players and their passing direction. Let's skip the modulus for this one.

Doing things this way also happens to keep our code readable, and is more intuitive at first glance. Notice how we could easily extend this to three dimensions by just adding up and down keys to passingOrder and directions.

Sometimes it pays off to be lazy!

var players = [1, 2, 3, 4];
var passingOrder = ["left", "right", "center"];
var directions = {
  1: {
    left: 2,
    center: 3,
    right: 4
  },
  2: {
    left: 3,
    center: 4,
    right: 1
  },
  3: {
    left: 4,
    center: 1,
    right: 2
  },
  4: {
    left: 1,
    center: 2,
    right: 3
  }
};

players.forEach(
  player => passingOrder.forEach(
    pass => console.log(player, "passes to", directions[player][pass])
  )
);

sfy · Accepted Answer · 2020-02-17 07:06:30Z

0

I would go a simple solution, each player should remember his passing order, if he can't, he should not join the game.

class Player {
  constructor(id, passOrder, name = 'Anounymous') {
    this.id = id
    this.name = name
    this.passOrder = passOrder
  }
}


let players = [
  new Player(1, [2, 4, 3], 'Alex'),
  new Player(2, [3, 1, 4], 'Billy'),
  new Player(3, [4, 2, 1]),
  new Player(4, [1, 3, 2], 'Tom')
]

players.forEach((p, i) => {
  console.log(`#${i+1} Player ${p.name} pass to `)
  p.passOrder.forEach(np => {
    console.log(`    #${np} player ${players[np-1].name},`)
  })
  console.log('-------------------')
})

answered Feb 17, 2020 at 7:06

sfy

3,4081 gold badge24 silver badges23 bronze badges

Comments

grodzi · Accepted Answer · 2020-02-17 07:08:38Z

In your case, you have passCards which takes an index and return an index. You can also consider passTo (just named differently) which takes a player and returns a player.

Below an example in which passTo defines the possible actions

const players = [1, 2, 3, 4];
const passingOrder = 2;
const passTo = (players => {
  const inIndexSpace = cb => {
    return player => {
      const i = players.indexOf(player)
      return players[cb(i)]
    }
  }
  return {
    left: inIndexSpace(i => (i + 1) % 4),
    right: inIndexSpace(i => (i - 1 + 4) % 4),
    straight: inIndexSpace(i => (i + 2) % 4),
    self: inIndexSpace(i => i)
  }
})(players)

players.forEach((player, index) => {
  console.log(player + "passes to " + passTo.straight(player))
})

which in "minimal" form (which you should avoid since dupplicate code) would be

const players = [1, 2, 3, 4];
const passingOrder = 2;
const passTo = [
  player => { const i = players.indexOf(player); return players[(i + 1) % 4]},
  player => { const i = players.indexOf(player); return players[(i - 1 + 4) % 4]},
  player => { const i = players.indexOf(player); return players[(i + 2) % 4]},
  player => { const i = players.indexOf(player); return players[i]}
];

players.forEach((player, index) => {
  console.log(player + "passes to " + passTo[passingOrder](player))
})

Collectives™ on Stack Overflow

Array of JavaScript arrow functions

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related