discussion Anti-Social & Lurker - Hideout spot

[micmitja]

yet he seems more fun than you, already he smiles at life instead of hiding from the world

so you want to get

You must be registered to see attachments

You must be registered to see attachments

 

[k3652]

It can hardly be called 'spying' when you leave your windows blinds wide open. And right in front of my tree perch as well.

What do you see when you look at the back of their head?

Also, that's no golden egg, that's a bedazzled buttplug!

ow, ok I didn't know

You must be registered to see attachments

sorry my friend but smiling does a lot x:

so you want to get

You must be registered to see attachments

AH the golden character is the one who bans D=

 

[mlpatreon2]

You must be registered to see attachments

Sorry but the "reaction" didn't seem sufficent for this. And I think you both are hitting a wall between a francophone and an anglophone.

 

[k3652]

the famous culture shock =<

 

[-Bonk-]

You must be registered to see attachments

Hello my lustful lewdians, how goes the monday ?

 

[k3652]

You must be registered to see attachments

Hello my lustful lewdians, how goes the monday ?

good and you? do you have a nice day ?

 

[Evil Surgeon]

Oh that's what happens!

You must be registered to see attachments

Wait, robot?
CAN I GET LASER EYES!

Bye Conzi, get some good sleep!

You must be registered to see attachments

Laser eyes?



I wanted sharks with friggin' laser beams.. but did I get them? No, I got sea bass. I thought to myself when I saw them..

 

[k3652]

Sorry but the "reaction" didn't seem sufficent for this. And I think you both are hitting a wall between a francophone and an anglophone.

why your follow me

 

[mlpatreon2]

why your follow me

Am I?

 

[IIIlllIII]

You must be registered to see attachments

Hello my lustful lewdians, how goes the monday ?

Hello, Im new here. Nice to meet you

 

[Saturnus]

ow, ok I didn't know

sorry my friend but smiling does a lot x:


AH the golden character is the one who bans D=

The masked man is the one who will ban!
The golden man is for prostate pleasure.

Sorry but the "reaction" didn't seem sufficent for this. And I think you both are hitting a wall between a francophone and an anglophone.

Those are pretty fancy words you're using there.

Now, if you'll excuse me, I have to go replace a garbage disposal.

 

[k3652]

The masked man is the one who will ban!
The golden man is for prostate pleasure.


Those are pretty fancy words you're using there.

Now, if you'll excuse me, I have to go replace a garbage disposal.

but I neither like playing the prostate nor being banned /)(°^°)(\

 

[Slumdum]

You must be registered to see attachments

Hello my lustful lewdians, how goes the monday ?

Bonki!

You must be registered to see attachments

Laser eyes?



I wanted sharks with friggin' laser beams.. but did I get them? No, I got sea bass. I thought to myself when I saw them..

Wanna borrow the SlumShark?

 

[mlpatreon2]

Those are pretty fancy words you're using there.

Now, if you'll excuse me, I have to go replace a garbage disposal.

Why yes, I like using fancy words, writing elaborate looking stuff, and such and so on. Imagine how much longer would I type just if I knew some other words.

 

[User_61141]

Hello my lustful lewdians, how goes the monday ?

great, slowly building my quote wall, cleaning some thrash here and there

You must be registered to see attachments

 

[Evil Surgeon]

Bonki!

You must be registered to see attachments

Wanna borrow the SlumShark?

You must be registered to see attachments

Your... SlumShark?? *looks around at everybody*

 

[k3652]

great, slowly building my quote wall, cleaning some thrash here and there

You must be registered to see attachments

the man in the situation, I'm sure he played in jon wick c:

 

[kuraiken]

I think some of the things to consider here, is that AI should be used to help, rather than to build completely (at this stage at least) and, like you say - it's not wrong necessarily, but just not ideal. In my experience, AI won't ever give you ideal since that's where some of our humanity and problem solving comes in. Also, remember it's an iterative process, so give it your feedback to improve it. Just like you would if you hired an outside developer/artist that doesn't do what you want.

That said, can I ask what AI you were using to Generate? Because that changes the output MASSIVELY. Let me share with you what I've just done in GPT based on your code. For reference, both of the below are ChatGPT 4o and both are brand new unique conversatons.

Spoiler: First Question and Response

Spoiler: Question

Can you improve this Javascript based on the users request?

For instance, I had it generate a 3x3 gameboard with card objects created based on a prototype object that is supposed to have 4 random values from 1-9 and functions to access its neighbors dynamically based on the current position. //

Prototype object for the card const cardPrototype = { values: Array.from({ length: 4 }, () => Math.floor(Math.random() * 9) + 1), top: function() { return gameboard[this.row - 1][this.col]; }, bottom: function() { return gameboard[this.row + 1][this.col]; }, left: function() { return gameboard[this.row][this.col - 1]; }, right: function() { return gameboard[this.row][this.col + 1]; } }; // Create a 3x3 gameboard with card objects const gameboard = Array.from({ length: 3 }, () => Array.from({ length: 3 }, () => Object.create(cardPrototype)) ); // Assign row and column properties to each card gameboard.forEach((row, i) => { row.forEach((card, j) => { card.row = i; card.col = j; }); });

Spoiler: Response

Sure, I'll make a few improvements to the JavaScript code to enhance clarity, functionality, and ensure it adheres to best practices.

1. The values array should be generated dynamically for each card object.
2. The neighbor functions should handle boundary conditions gracefully.
3. Use Object.assign to create card objects to ensure the values array is unique for each card.

Here is the improved code:

// Prototype object for the card
const cardPrototype = {
  init: function(row, col) {
    this.row = row;
    this.col = col;
    this.values = Array.from({ length: 4 }, () => Math.floor(Math.random() * 9) + 1);
  },
  top: function() {
    return this.row > 0 ? gameboard[this.row - 1][this.col] : null;
  },
  bottom: function() {
    return this.row < gameboard.length - 1 ? gameboard[this.row + 1][this.col] : null;
  },
  left: function() {
    return this.col > 0 ? gameboard[this.row][this.col - 1] : null;
  },
  right: function() {
    return this.col < gameboard[this.row].length - 1 ? gameboard[this.row][this.col + 1] : null;
  }
};

// Create a 3x3 gameboard with card objects
const gameboard = Array.from({ length: 3 }, (_, row) =>
  Array.from({ length: 3 }, (_, col) => {
    const card = Object.create(cardPrototype);
    card.init(row, col);
    return card;
  })
);

// For demonstration: log the gameboard and one card's neighbors
console.log(gameboard);
console.log('Neighbors of card at (1,1):', gameboard[1][1].top(), gameboard[1][1].bottom(), gameboard[1][1].left(), gameboard[1][1].right());

Changes and Improvements:​

1. Dynamic values Array: The values array is now dynamically generated for each card during initialization.
2. Boundary Handling: The neighbor functions (top, bottom, left, right) now check boundaries to avoid accessing undefined array elements.
3. Initialization Method: Added an init method to the prototype for setting up row, col, and values properties.
4. Object Creation: Used Object.create and card.init to ensure each card gets unique values.

This code should now correctly create a 3x3 gameboard with cards having unique values and correctly handle neighbor lookups.

Spoiler: Second Question and Response

Spoiler: Question

A User is discussing trouble using AI Language Models to write code for a Java project. As I am unfamiliar with Java, can you take a look at his query below and perhaps improve his code to something more appropriate? It is interesting, though I've tried something similar on a javascript AI and immediately realized a whole lot of implementation problems. It works well as a piece limited, but in the greater whole, the AI chooses implementation versions that do not really work. For instance, I had it generate a 3x3 gameboard with card objects created based on a prototype object that is supposed to have 4 random values from 1-9 and functions to access its neighbors dynamically based on the current position. This is the result // Prototype object for the card const cardPrototype = { values: Array.from({ length: 4 }, () => Math.floor(Math.random() * 9) + 1), top: function() { return gameboard[this.row - 1][this.col]; }, bottom: function() { return gameboard[this.row + 1][this.col]; }, left: function() { return gameboard[this.row][this.col - 1]; }, right: function() { return gameboard[this.row][this.col + 1]; } }; // Create a 3x3 gameboard with card objects const gameboard = Array.from({ length: 3 }, () => Array.from({ length: 3 }, () => Object.create(cardPrototype)) ); // Assign row and column properties to each card gameboard.forEach((row, i) => { row.forEach((card, j) => { card.row = i; card.col = j; }); }); While this isn't wrong, that's not really dynamic. It works if you make sure that you tell the card it's new position every time you change on what tile it is, but it cannot dynamically detect the neighbors. A dynamic solution would be to use a function to access the gameboard, find the current row & column indexes and then use those to calculate the neighbors. This also only works on a fixed gameboard size with fixed dimensions, since the gameboard is automatically divided into rows and columns. This also fixes how the gameboard's tiles are accessible, because it predefines the size of the gameboard during creation. Instead, a different and more flexible solution would've been to have the gameboard creates as containing an array of x tiles, giving the gameboard a width & height and rather than using direct +/- operations on fixed tiles, using modulo to dynamically access the correct neighbors even if the size & width change. So it's a correct solution that might not work in the actual project, due to restrictions in what choices it has made for the implementation. I think it's a nifty thing for simple and straightforward operations, but I don't think it can, in the solution, correctly account of implentation-based restrictions in how it's going to have to interact in the greater whole. The particular choice made by the AI does provide the fastest solution (predefined values, even less math) but it's not necessarily giving the solution that would actually work with the project. I wonder if anyone managed to get it to work with something like PixiJS and create a simple visual game - because I wonder if the AI would detect the necessary restrictions in rendering hierarchy.

Spoiler: Response

It seems the user is trying to dynamically handle the position of cards on a gameboard in a JavaScript context, and they would like a more flexible solution that doesn't rely on fixed positions. Here's an improved version of the code that dynamically calculates the neighbours and can adapt to changes in the gameboard's size:

// Card constructor function
function Card(row, col, gameboard) {
  this.row = row;
  this.col = col;
  this.gameboard = gameboard;
  this.values = Array.from({ length: 4 }, () => Math.floor(Math.random() * 9) + 1);
}

Card.prototype.getNeighbour = function (dRow, dCol) {
  const newRow = this.row + dRow;
  const newCol = this.col + dCol;
 
  if (newRow >= 0 && newRow < this.gameboard.length && newCol >= 0 && newCol < this.gameboard[0].length) {
    return this.gameboard[newRow][newCol];
  }
  return null;
};

Card.prototype.top = function () {
  return this.getNeighbour(-1, 0);
};

Card.prototype.bottom = function () {
  return this.getNeighbour(1, 0);
};

Card.prototype.left = function () {
  return this.getNeighbour(0, -1);
};

Card.prototype.right = function () {
  return this.getNeighbour(0, 1);
};

// Function to create a gameboard
function createGameboard(rows, cols) {
  const gameboard = Array.from({ length: rows }, (_, row) =>
    Array.from({ length: cols }, (_, col) => new Card(row, col, gameboard))
  );
 
  // Assign the gameboard reference after creation
  gameboard.forEach(row => row.forEach(card => card.gameboard = gameboard));
 
  return gameboard;
}

// Create a 3x3 gameboard
const gameboard = createGameboard(3, 3);

// Example: Access neighbours of the card at (1, 1)
const card = gameboard[1][1];
console.log('Top:', card.top());
console.log('Bottom:', card.bottom());
console.log('Left:', card.left());
console.log('Right:', card.right());

Explanation:​

1. Card Constructor: The Card function is used to create card objects with dynamic row and column properties. Each card also holds a reference to the gameboard it belongs to.
2. getNeighbour Method: This method calculates the new row and column indices based on the current position and checks if the new indices are within bounds. If they are, it returns the neighbouring card; otherwise, it returns null.
3. Direction Methods: The top, bottom, left, and right methods use getNeighbour to find the card in the corresponding direction.
4. createGameboard Function: This function creates a gameboard of the specified size and populates it with cards. Each card is initially created without a reference to the gameboard, but after the gameboard is fully created, each card's gameboard reference is updated.

This approach allows the gameboard to dynamically calculate neighbours regardless of the board size and ensures that the card objects are aware of their own positions and the gameboard they belong to. This should address the user's concerns about flexibility and dynamic interaction in the project.

So, I'm not sure how much credit you give those responses? I'm not trying to "prove you wrong" or anything like that, just trying to say "have you tried this?" - you might look at this code and still call it bullshit, since I don't really know what I'm talking about when it comes to Java! I just thought it'd be interesting to get your perspective on it.

I used

You must be registered to see links

and you're probably right that there's better AI code generation platforms. But I don't know them, so I just used what came up. It wasn't meant to be a definitive test either.
It does what it's supposed to do well enough, but the main problem I'm thinking of are always A. Readability and B. Integration into overall code. Using RPG Maker MZ's "specific" code I'm pretty used to run into the weird ways how code that I have to integrate & alias into works.
So since implementation of one thing often mandates specific implementation elsewhere, that's always a key worry for me.

The code the AI has generated has me a little stumped. It's first of all not working. The issue seems to be that it's actually trying to hand over the gameboard itself *during* the construction process.

Spoiler: Error Section

// Function to create a gameboard

function createGameboard(rows, cols) {
  const gameboard = Array.from({ length: rows }, (_, row) =>
    Array.from({ length: cols }, (_, col) => new Card(row, col, gameboard))
  );

  // Assign the gameboard reference after creation
  gameboard.forEach(row => row.forEach(card => card.gameboard = gameboard));
  return gameboard;
}

As the "new Card" is created, the function tries to pass the gameboard to that card, which is impossible, because the new card is created during the construction process of the gameboard, so it doesn't exist yet.
Likewise, the gameboard still creates rows into seperate arrays.

Here's the solution how I'd design it (plus an added Wall)

Spoiler: Solution

class Wall {
  constructor() {
  }

  values() {
    return [9,9,9,9]
  }
}

class Card {
  constructor(values) {
    this._values = values;
  }

  values() {
    return this._values;
  }

  getOwnPosition() {
    const index = $GameBoard.tiles().findIndex(card => card === this);
    const row = Math.floor(index / $GameBoard.width);
    const column = index % $GameBoard.width;
    return {row, column, index}
  }

  leftNeighbor() {
    const pos = this.getOwnPosition();
    if (pos.column === 0) {
      return new Wall();
    }
    return $GameBoard.tiles()[pos.index - 1];
  }

  rightNeighbor() {
    const pos = this.getOwnPosition();
    if (pos.column === $GameBoard.width - 1) {
      return new Wall();
    }
    return $GameBoard.tiles()[pos.index + 1];
  }

  topNeighbor() {
    const pos = this.getOwnPosition();
    if (pos.row === 0) {
      return new Wall();
    }
    return $GameBoard.tiles()[pos.index - $GameBoard.width];
  }

  bottomNeighbor() {
    const pos = this.getOwnPosition();
    if (pos.row === $GameBoard.height - 1) {
      return new Wall();
    }
    return $GameBoard.tiles()[pos.index + $GameBoard.width];
  }
}

class Gameboard {
  constructor(width, height) {
    this.width = width;
    this.height = height;
    this.createTiles();
  }

  tiles() {
    return this._tiles;
  }

  createTiles() {
    this._tiles = [];
    for (let i = 1; i <= this.width * this.height; i++) {
      this.addCardToSlot();
    }
  }

  addCardToSlot() {
    const min = 1;
    const max = 9;
    const values = Array.from({ length: 4 }, () => this.createRandomNumber(min, max))
    this._tiles.push(new Card(values));
  }

  createRandomNumber(min, max) {
    return Math.floor((Math.random() * (max - min + 1))) + min;
  }
}

// Create Board
const $GameBoard = new Gameboard(3, 3);

// Neighbor example

// retrieves the values of the card above the fourth card (row 2, column 1)
console.log($GameBoard.tiles()[3].topNeighbor().values)

I create a Wall object which will be returned with predefined values whenever we don't have a neighbor. (Can be used for Wall mechanics, e.g. Triple Triad).
This is basically just a gimmick addition, the computer should in the prompt always return "null" (meaning no tile), whereas I decided to hand over the wall.

Then I create the Card Object. This is created with external values, so if I instead of random values wanted to retrieve values from a DB (e.g. a Card Database) I can integrate this easily.
Values is used to always get the cards values (.e.g Triple Triad Card Attack values).
getOwnPosition hands back an object with this card's location data that is dynamically generated. If I simply switch to cards in the main array, the position will automatically update without any further input from me.
The Neighbor checks simply get my own tile's data from the gameboard, then check if there cannot be a Neighbor. (In which case I hand back the Wall)
If it's not a wall, it calculates the correct card index based on the width of the game board and hands me those values.

The Gameboard is pretty simple in its generation.
Some of the advantages present here is that I can access all of the boards tiles through the $GameBoard.tiles() method and don't have to deal with multiple subarrays inside an array.
The Gameboard's position data is always right, the Neighbors always correct, even should the Board for some reason change in size.
While this version is slower (due to retrieving values & doing calculations instead of just picking up pre-defined values), it's very robust. Parameters can be changed easily, and everything still works. It also has a, in my opinion, much more coherent and readable structure, which means the code is much easier to edit & maintain.

Took me a awhile to respond.
AI is much faster, that's true. The most useful cases I can imagine is when a programmer wants to know the method of how something is done, rather than a specific complete implementation of a part of the code.
The second version of the AI you posted is at least a lot more readable, and the use of the Array.from method is pretty curious enough that I used it myself rather than creating a for loop iteration & pushing values.

 

[-Bonk-]

good and you? do you have a nice day ?

Was ok til a few minutes ago. I think i got dumped but .....mixed signals ya know

Hello, Im new here. Nice to meet you

Hello, I'm Bonky and this is my first day as well. It's nice to meet you IIIIIIIIII

You must be registered to see attachments

 

[k3652]

What do you call the people who clean up crime scenes and corpses in your countries?

in France it's all just "nettoyeur" (cleaners), maybe it's different where you live! v=