trace the contents from arrays in object

Hi, I know just posted yesterday abut this subject and even though I'm reading and testing, I'm confused with objects and associative arrays. I believe I have a random shuffled deck now, but I still can't find the way to get a trace from it.

Code:

---

var suits:Array = new Array("o", "c", "e", "b");
var aTemp:Array = new Array();

for (i = 0; i < suits.length; i++)
{
        for (j = 1; j <= 12; j++)
        {
                var oCard:Object = new Object();
                oCard.sCardSuit = suits[i];
                oCard.sCardNumber = j;

                aTemp.push(oCard);

                var aDeck:Array = new Array();
                while (aTemp.length > 0)
                {
                        r = Math.floor(Math.random() * aTemp.length);
                        aDeck.push(aTemp[r]);
                        aTemp.splice(r,1);

                        for (var oCard in aDeck){
                                trace(oCard.sCardSuit + " " + oCard.sCardNumber); // traces undefined
                                isn't the object in the array and its properties; the oCard's properties
                        }
                }
        }
}

---

thanks in advance for any hints

Hi Cap,

You seem to have changed it from yesterday , but never mind , here you go:

PHP Code:

---

var suits:Array = new Array("o", "c", "e", "b");
var aTemp:Array = new Array();

for (i = 0; i < suits.length; i++)
{
    for (j = 1; j < 13; j++)
    {
        var oCard:Object = new Object();
        oCard.sCardSuit = suits[i];
        oCard.sCardNumber = j;
        // Or like below instead...
        // var oCard:Object = {sCardSuit:suits[i], sCardNumber:j};
        
        aTemp.push(oCard);
    }
    //trace(aTemp);
}

var aDeck:Array = new Array();
while (aTemp.length > 0)
{
    r = Math.floor(Math.random() * aTemp.length);
    aDeck.push(aTemp[r]);
    aTemp.splice(r,1);
}
// put this outside the while as it mixes up the deck...
for (var s in aDeck)
{
    trace("Number: " + aDeck[s].sCardNumber + " - Suit: " + aDeck[s].sCardSuit);
}

// Optional below for further knowledge...
// trace(aDeck[0].sCardSuit + " - " + aDeck[0].sCardNumber); 


---

perhaps moot can shed some more light as I get slightly confused with object arrays sometimes too.

Hi,,

for (j = 1; j < 13; j++)

should be

for (j = 1; j < 14; j++)

as there are 13 cards in a deck (without jokers etc)

Hi, Fruit and thanks,

yes, in your all's cards.. I have been testing with it for our cards and have forgotten to change it again. I was changing it as a deference towards you, thought it ease your work. It doesn't make a big difference, I believe.

thanks, I should find the way to deal 4 hands out of that and sort it as I need.

Yeah, I'm slow to respond compared to you guys.

Yes it's confusing but it should be. It's one of those things that stops being confusing though.

We made the cards objects (a variable that can hold lots of different types of data). We put the cards into an array for the deck of cards.

You don't have to manipulate the array - sort, splice, etc. Objects are just like any other var as far as referencing (the variable name isn't the variable, it's a pointer to the variable).

string_0 = "Fred";
string_1 = string_0;

Both string_0 and string_1 point to the string "Fred".

object_0 = new Object();
object _1 = object_0;

Also, you can do the same with the properties of the object.

object_1.stringName = object_0.stringName;

So you don't want to manipulate the array to "shuffle" the deck. You can just swap the references.

Here's how you can swap the card IN spot 12 (not card 12, 12 is the spot in the deck array) with the card in spot 13 in the deck.

oCardTemp = new Object();
oCardTemp = oCard[12];
oCard[12] = oCard[13];
oCard[13] = oCardTemp;

You can do the same with the properties if you want, but this does it all at once. You can see how once the data better represents the real world object, your code naturally clears up.

....out of time.

Thanks for the replies, Moot.

They have been helpful. I am just slow to assimilate things. I read and practice as much as I can, but time flies.

That 13th card is no problem, the deck I will use has only 12 of them. I need an algorithm to sort the suits in a specific order, not alphabetically. I suppose I need an algorithm. I'm not so sure. I think the last time I had solved this same problem I may have split the arrays I had and concatenated them to sort them as I wished.

If there is a simpler way with the objects, I guess I need more time to understand it. I can't seem to find any sorting method that could do that for me.

Sorting code sucks. I had to go look it up.

Once you create an array of objects, you can sort the array on the objects' properties using sortOn. You list which properties and how to sort those properties.

This code creates the deck of cards (i made regular cards) and then sorts it descending. You have to read the adobe help on sortOn to get how the sortOn parameters work.

Code:

---

aCardValues = new Array("Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King");
aDeckOfCards = new Array();
aDeckOfCards2 = new Array();


for (i = 0; i < 4; i++) {
        for (j = 0; j < 13; j++) {
                var oCard: Object = new Object();
                oCard.sCardSuit = i;
                oCard.sCardNumber = j;
                aDeckOfCards.push(oCard);
        }
}


//  sort deck by card suit, then card number descending - you have to add that the sort is numeric not string
aDeckOfCards.sortOn(["sCardSuit", "sCardNumber"], [Array.DESCENDING, Array.DESCENDING | Array.NUMERIC]);


for (i = 0; i < aDeckOfCards.length; i++) {
        trace("Card: " + aCardValues[aDeckOfCards[i].sCardNumber] + " of " + aCardSuits[aDeckOfCards[i].sCardSuit]);
        //trace("Card: " + aDeckOfCards[i].sCardNumber + " of " + aDeckOfCards[i].sCardSuit);
}


aDeckOfCards.sortOn("sCardNumber", Array.NUMERIC);
trace("Card: " + aCardValues[aDeckOfCards[0].sCardNumber] + " of " + aCardSuits[aDeckOfCards[0].sCardSuit]);

---

Afternoon, Moot,

thanks so much. Experimenting with your code I have just used Array.UNIQUESORT, Array.NUMERIC and it works like a charm to sort the cards by the suit order I want.

I had misunderstood the uniqueSort method before thinking it would not sort an item if repeated. I'm still confused with the naming of items, elements or fields in arrays.

thanks again.

Hi again, Moot.

Just to "apologize" for not noticing what you meant by keeping the cardSuit a number... I still can't really see how it works but, thanks for all. I simply rushed to try it out and didn't even notice the full example.

You also mentioned the arrays don't need to be manipulated...

Did you mean to say a function wouldn't be needed to create the randomness of the cards?

Hi again, Moot. I have been experimenting or playing around with the code example you showed me and I can't get anything out of the last step of this all. Splitting the deck into hands...

When I got to it, I wasn't able to trace anything out of it and I have double checked my code thinking I'm following the same pattern as when I randomized it for example. I want to make new arrays representing the players hands but I only get a positive trace if I convert the aPlayer1Hand array into an object like I saw in flash's help. By positive I mean I get the [object, object] trace. Using it as an array I get undefined. I would think I'm pushing the aDeck into the player1Hand just like extracting it from the aTemp array. Can you please take a look at it, even though this might not be the best way to end this up?

Code:

---

aCardSuits = new Array("hearts", "spades", "clubs", "diamonds");
aCardValues = new Array("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13");
aTemp = new Array();

for (i = 0; i < 4; i++)
{
        for (j = 0; j < 13; j++)
        {
                var oCard:Object = new Object();
                oCard.sCardSuit = i;
                oCard.sCardNumber = j;
                aTemp.push(oCard);
        }
}

//  sort deck by card suit normal
//aTemp.sortOn(["sCardSuit", "sCardNumber"],[Array.UNIQUESORT, Array.NUMERIC]);

for (i = 0; i < aTemp.length; i++)
{
        //trace("Card: " + aCardValues[aTemp[i].sCardNumber] + " of " + aCardSuits[aTemp[i].sCardSuit]);
        //trace("Card: " + aTemp[i].sCardNumber + " of " + aTemp[i].sCardSuit);
}

//aTemp.sortOn("sCardNumber",Array.NUMERIC);
//trace("Card: " + aCardValues[aTemp[0].sCardNumber] + " of " + aCardSuits[aTemp[0].sCardSuit]);

// ------------------------------------------------------------------------------------------------------------------

// RANDOMIZE THE DECK

var aDeck:Array = new Array();
while (aTemp.length > 0)
{
        r = Math.floor(Math.random() * aTemp.length);
        aDeck.push(aTemp[r]);
        aTemp.splice(r,1);
}

//aDeck.sortOn(["sCardSuit", "sCardNumber"],[Array.DESCENDING, Array.DESCENDING | Array.NUMERIC]);

// ------------------------------------------------------------------------------------------------------------------

// SPLIT THE DECK

var aPlayer1Hand:Array = new Array();

for (k = 1; k <= 13; k++)
{
        aPlayer1Hand.push.aDeck.pop();
        trace("aPlayer1Hand ="+ aPlayer1Hand);
        trace(aCardValues[aPlayer1Hand[k].sCardNumber] + " - " + aCardSuits[aPlayer1Hand[k].sCardSuit]);
}

---

Hi again,

I got this working even though I still can't tell the difference between the for looop and the way I'm doing it now. It's pushing the object into an array as well to my understanding...

Perhaps, very probably there's a simpler way to split the hands, but I couldn't find it. Thanks for the help.

Code:

---

var player1Hand:Array = new Array();
var player2Hand:Array = new Array();
var player3Hand:Array = new Array();
var player4Hand:Array = new Array();

while (aDeck.length > 0 && aDeck.length > 36)
{
        player1Hand.push(aDeck.pop());
}

player1Hand.sortOn(["sCardSuit"],[Array.NUMERIC]);

while (aDeck.length > 0 && aDeck.length > 24)
{
        player2Hand.push(aDeck.pop());
}

player2Hand.sortOn(["sCardSuit"],[Array.NUMERIC]);

while (aDeck.length > 0 && aDeck.length > 12)
{
        player3Hand.push(aDeck.pop());
}

player3Hand.sortOn(["sCardSuit"],[Array.NUMERIC]);

while (aDeck.length > 0 && aDeck.length > 0)
{
        player4Hand.push(aDeck.pop());
}

player4Hand.sortOn(["sCardSuit"],[Array.NUMERIC]);

---

Hi Cap,

Have a whirl with this, new document

PHP Code:

---

var suits:Array = new Array("Hearts", "Spades", "Diamonds", "Clubs");
var values:Array = new Array("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13");
var aTemp:Array = new Array();
var aDeck:Array = new Array();
var playerHand:Array = new Array();
var i:Number, j:Number;

createCards();

function createCards():Void
{
    trace("Creating card objects...");
    for (i = 0; i < suits.length; i++)
    {
        for (j = 0; j < values.length; j++)
        {
            var oCard:Object = {sCardNumber:Number(values[j]), sCardSuit:suits[i]};
            aTemp.push(oCard);
        }
    }
    randomiseCards();
}

function randomiseCards():Void
{
    trace("Randomising card objects...");
    while (aTemp.length > 0)
    {
        r = Math.floor(Math.random() * aTemp.length);
        aDeck.push(aTemp[r]);
        aTemp.splice(r,1);
    }
    createHands();
}

function createHands():Void
{
    trace("Creating hands...\n");
    for (i = 0; i < aDeck.length; i++)
    {
        playerHand[i] = new Array();
        playerHand[i].push(aDeck.splice(0, values.length));
        //trace("Player: " + (i + 1) + " - " + playerHand[i]);
    }
    showHands();
}

function showHands():Void
{
    for (i = 0; i < suits.length; i++)
    {
        trace("Player: " + (i + 1));
        playerHand[i][0].sortOn("sCardNumber",Array.NUMERIC);
        for (j = 0; j < values.length; j++)
        {
            trace("\t" + playerHand[i][0][j].sCardNumber + " - " + playerHand[i][0][j].sCardSuit);
        }
        trace(playerHand[i][0].length + " cards");
        trace("----------");
    }
} 


---

Of course it's hard to do and of course you don't get it. Arrays are a huge deal. You should learn arrays, what they mean, and how to use them at the beginning when you learn what a variable is and "if" statements. I guarantee creating a deck of cards like this is a test question in many programming classes.

It's high-level stuff which means you can write your code a million ways but the most efficient, coder-friendly, business-friendly code (usable code) is very hard to do. This post requires me, or whoever, to think and write new code.

A good way to sort an array of objects (unique sorting issues) is to not sort the objects, but to sort the positions (array of numbers). So I changed the data a little but it still makes sense.

Here's example code (AS3 but easy to convert). It's example code so look at it for concepts. It may not actually work for your application.

Code:

---

var aCardSuits: Array;
var aCardValues: Array;
var aCards: Array;
var aDeckOne: Array;
var aDeckTwo: Array;
var i: int;
var j: int;


public function Main() {
        //  set vars
        aCardSuits = new Array("H", "C", "S", "D");
        aCardValues = new Array("Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King");

        aCards = new Array(); //  the cards
        aDeckOne = new Array(); //  a deck of the cards - an array of the cards

        //  create the cards
        for (i = 0; i < 4; i++) {
                for (j = 0; j < 13; j++) {
                        var oCard: Object = new Object();
                        oCard.sCardSuit = i;
                        oCard.sCardValue = j;
                        aCards.push(oCard);
                }
        }

        aDeckOne = aCards;
        fShuffleDeck(aDeckOne);
}


function fShuffleDeck(aPassDeck) {
        trace("fShuffleDeck()");
        var iRandomIndex: int = 0;
        var iActualIndex: int = 0;

        //  create array of numbers
        var aTempDeck: Array = [];
        for (i = 0; i < aCards.length; i++) {
                aTempDeck.push(i);
        }

        for (i = 0; i < aCards.length; i++) {
                iRandomIndex = (Math.random() * aTempDeck.length);
                iActualIndex = aTempDeck[iRandomIndex];
                aPassDeck[iActualIndex] = aCards[i];
                aTempDeck.splice(iRandomIndex, 1);
        }

        fTraceDeck(aPassDeck);
}


function fTraceDeck(aPassDeck) {
        trace("fTraceDeck():  length: " + aPassDeck.length);
        for (i = 0; i < aPassDeck.length; i++) {
                trace("Card " + i + ": " + aCardSuits[aPassDeck[i].sCardSuit] + "-" + aCardValues[aPassDeck[i].sCardValue]);
        }
        trace("\n");
}

---

I was hoping somebody else would get on this thread but I did the code last night so I'm posting it.

Good day,

thanks both, FruitBeard and Moot,

I have been looking at both for a while, staying with FruitBeard's because it shows the 4 hands and I understood most of it but the last part.

I guess I will never know how I got mine to trace the suits in my needed order and I'm trying to compare it against FruitBeard's example code.

It all runs similarly until showing the cards and I can't seem to see the difference

The sorting really confuses me. If you write it inside brackets. What exactly does that mean? It first sorts element index 0 with that method and element index 1 with whichever other you choose?

I keep getting the suits in an alphabetical order no matter what method I try to use.

Hi Cap,

I have a feeling you may be better off with Moots as I believe you have more control over the whole pack with easier reference, you can quite easily split the finished array into four hands of random cards the way you spliced it before.

Hi Cap,

As for the code I posted , if you wanted to change the display ordering, then simply use something like so

PHP Code:

---

playerHand[i][0].sortOn(['sCardSuit', 'sCardNumber'], [Array.ALPHANUMERIC, Array.NUMERIC]); 


---

that will put each hand in suit and number order that they have been dealt

so
1 spades
3 spades
9 spades
13 spades

2 hearts
7 hearts
11 hearts

and so on

I had never seen the alphanumeric method before.

But I have mine sorted as hearts, spades, clubs diamonds and clubs... (or the order I need with my cards)

I used NUMERIC thinking I was sorting both arrays and it sorted the suits the way they are in the array declaration.

All the sorts are string-based by default so you have to state it's a number sort. It tricks you because 0-9 will sort fine as a string, it doesn't break until 10+.

// sort deck by card suit, then card number descending - you have to add that the sort is numeric not string
aDeckOfCards.sortOn(["sCardSuit", "sCardNumber"], [ Array.DESCENDING | Array.NUMERIC, Array.DESCENDING | Array.NUMERIC]);

Fruit is helping you with the way you sort of know - a two-dimensional array. I think you should switch to array of objects now. You'll switch eventually. ;>

I know my code isn't the best code and has mistakes, it's just better and easier to use array of objects than two-dimensional arrays.

Was just thinking about how I think your data is the problem (how the cards are represented) and I think I have a solution without using objects.

Use regular numbers 0-51 to represent the cards. That way it's totally easy to handle the cards and you only need a simple array to display the card.

var aCardsDisplayNames:Array = new Array("Ace of Hearts", "2 of Hearts", "3 of Hearts", "4 of Hearts", "5 of Hearts", "6 of Hearts", etc.);

So anywhere in your code, a 1 is the 2 of hearts, a 4 is a the 5 of hearts, etc.

So all your arrays will be simple arrays that you can store numbers in and sort easily.

Sound good?

Hi, Moot, FruitBeard, it sounds great!

thanks for all the hints. I am sure this can be done plenty of different ways and I appreciate your suggestions, but it's quite hard to assimilate all this info. I was beginning to guess this is working with two dimensional arrays. Associative arrays?

I was just working with the latest example FruitBeard posted and got it to sort fine for my needs, but there is one thing I would like explaining on if you can spare the time.

In the last function:

Code:

---

for (i = 0; i < aSuits.length; i++)
        {
        trace("Player: " + (i + 1));
        playerHand[i][0].sortOn(["sCardSuit", "sCardNumber"],[Array.NUMERIC, Array.NUMERIC]);
        for (j = 0; j < aValues.length; j++)
        {
                trace("\t" + aValues[playerHand[i][0][j].sCardNumber] + " - " + aSuits[playerHand[i][0][j].sCardSuit]);
        }

---

I added the suits and the values like in one of the previous examples but I would like to see what happens.

I understand the playerHand[i] meaning 1, 2, 3 or 4, but I can't see what the [0] nor the [j] represent.

Hi Cap,

it means 0 ,1, 2, 3 actually

playerHand consists of 4 arrays - each of the 4 consists of one(at present), each one consists of 13 parts in this case for cards.


[ [ [ [j],[j],[j],[j] ] ] , [ [ [j],[j],[j],[j] ] ], [ [ [j],[j],[j],[j] ] ], [ [ [j],[j],[j],[j] ] ] ]

playerHand > playerHand[0] > playerHand[0][0] > playerHand[0][0][j]
j could be called s, it does not matter

not sure why you got rid of the alphanumeric sort as I get this trace, it places them in number order and suit order

PHP Code:

---

Creating card objects...
Randomising card objects...
Creating hands...

Player: 1
    4 - Clubs
    12 - Clubs
    1 - Diamonds
    8 - Diamonds
    1 - Hearts
    3 - Hearts
    10 - Hearts
    11 - Hearts
    12 - Hearts
    3 - Spades
    4 - Spades
    6 - Spades
    13 - Spades
13 cards
----------
Player: 2
    1 - Clubs
    2 - Clubs
    3 - Clubs
    5 - Clubs
    9 - Clubs
    2 - Diamonds
    13 - Diamonds
    5 - Hearts
    8 - Hearts
    9 - Hearts
    13 - Hearts
    10 - Spades
    11 - Spades
13 cards
----------
Player: 3
    6 - Clubs
    10 - Clubs
    11 - Clubs
    6 - Diamonds
    7 - Diamonds
    12 - Diamonds
    6 - Hearts
    7 - Hearts
    1 - Spades
    2 - Spades
    8 - Spades
    9 - Spades
    12 - Spades
13 cards
----------
Player: 4
    7 - Clubs
    8 - Clubs
    13 - Clubs
    3 - Diamonds
    4 - Diamonds
    5 - Diamonds
    9 - Diamonds
    10 - Diamonds
    11 - Diamonds
    2 - Hearts
    4 - Hearts
    5 - Spades
    7 - Spades
13 cards
---------- 


---

I hope that explains the [i][0][j] a bit better for you, but again you might still be better off listening to Moots suggestions

Hi, FruitBeard,

thanks for the explanation. I will need to look at it again a few more times...

I think I am following Moot's suggestions. I need a little time to be completely sure, but I am assigning the variable values to the index positions in the arrays.

I changed the alphanumeric sort because, this way, I can have hearts, spades, diamonds and clubs, instead of clubs, diamonds, hearts and spades so I can display them properly when I use the values with movie clips.

The cards aren't 2d. So you don't need to go through figuring out 2d arrays (a tough concept).

You can use two seperate arrays to create the text, but never use two arrays to represent one set of cards.

Here is example code made from the 2d code. I can't test this or even run it so just use it as guide.

Code:

---

var aSuits:Array = new Array("Hearts", "Spades", "Diamonds", "Clubs");
var aValues:Array = new Array("Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King");
var aTempDeck:Array = new Array();
var aDeck:Array = new Array();
var aPlayerHand_0:Array = new Array();
var aPlayerHand_1:Array = new Array();
var nHandSize:Number = 5;
var i:Number, j:Number;



function fMain():Void
{
    trace("fMain()");
    for (i = 0; i < 52; i++)
    {
        aDeck[i] = i;
    }
    fShuffleDeck();
}

function fShuffleDeck():Void
{                       
        //  this should create a copy of the deck, then randomly push numbers back into aDeck
        var iRandomIndex:int = 0;
    aTempDeck = aDeck;
        aDeck = [];
    while (aTempDeck.length > 0)
    {
        iRandomIndex = (Math.random() * aTempDeck.length);
        aDeck.push(aTempDeck[iRandomIndex]);
        aTempDeck.splice(iRandomIndex, 1);
    }
    fDealHands();
}

function fDealHands():Void
{
    trace("fDealHands()");
    for (i = 0; i < nHandSize; i++)
    {
        aPlayerHand_0 = new Array();
        aPlayerHand_0.push(aDeck[aDeck.length - i]));
    }
    fShowHands();
}

function fShowHands():Void
{
    for (i = 0; i < aPlayerHand_0.length; i++)
    {
        //trace("Card " + i ": " + aPlayerHand_0[i]);
                fShowCard(i);
    }
}

function fShowCard(nPassNo){
        //  get display name of card
        var nSuitIndex:Number;
        var nValueIndex:Number;
        nSuitIndex = Math.floor(nPassNo/aValues.length);
        nValueIndex = Math.floor(nPassNo/aSuits.length);       
        trace(aValues[nValueIndex] + " of " aSuits[nSuitIndex]);
}


fMain();

---

See how once the data is corrected, you're not even sorting an array? The only time "hearts" or "ace" is involved is when you create the text on the card.

Hi,

Not sure whats going on here Moot, there were a couple of syntax errors with the code after testing (just a couple of extra brackets here and there and int is a as3 data type i believe).

PHP Code:

---

var aSuits:Array = new Array("Hearts", "Spades", "Diamonds", "Clubs");
var aValues:Array = new Array("Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King");
var aTempDeck:Array = new Array();
var aDeck:Array = new Array();
var aPlayerHand_0:Array = new Array();
var aPlayerHand_1:Array = new Array();
var nHandSize:Number = 5;
var i:Number, j:Number;

function fMain():Void
{
    trace("fMain()");
    for (i = 0; i < 52; i++)
    {
        aDeck[i] = i;
    }
    fShuffleDeck();
}

function fShuffleDeck():Void
{
    //  this should create a copy of the deck, then randomly push numbers back into aDeck
    var iRandomIndex:Number = 0;
    aTempDeck = aDeck;
    aDeck = [];
    while (aTempDeck.length > 0)
    {
        iRandomIndex = (Math.random() * aTempDeck.length);
        aDeck.push(aTempDeck[iRandomIndex]);
        aTempDeck.splice(iRandomIndex,1);
    }
    fDealHands();
}

function fDealHands():Void
{
    trace("fDealHands()");
    for (i = 0; i < nHandSize; i++)
    {
        aPlayerHand_0 = new Array();
        aPlayerHand_0.push(aDeck[aDeck.length - i]);
    }
    fShowHands();
}

function fShowHands():Void
{
    for (i = 0; i < aPlayerHand_0.length; i++)
    {
        //trace("Card " + i ": " + aPlayerHand_0[i]);
        fShowCard(i);
    }
}

function fShowCard(nPassNo)
{
    //  get display name of card
    var nSuitIndex:Number;
    var nValueIndex:Number;
    nSuitIndex = Math.floor(nPassNo / aValues.length);
    nValueIndex = Math.floor(nPassNo / aSuits.length);
    trace(aValues[nValueIndex] + " of " + aSuits[nSuitIndex]);
}

fMain(); 


---

it traces

fMain()
fDealHands()
Ace of Hearts

Cap, even when you get the hang of all this you got to make the game work like a game of cards!!!

Hi, Fruit,

I know. I wish I had the money and the partners because I'm sure it would attract users , but I'll be trying to get it started for the moment.

Thanks for all, to Moot as well. I haven't tried to tinker with the last example when I still haven't really assimilated your previous post with the explanation on the array elements, but I will keep a copy of it to look at it every now and then.

will be posting soon.

The main change in the code is that the cards are stored in a single-dimensional (regular) array not a two-dimensional array.

Each card is simply identified by a number. 0 is the Ace of Hearts, 1 is the 2 of Hearts, ... 51 is the King of Clubs.

So, everything is simpler. To sort some cards, instead of:
playerHand[i][0].sortOn(["sCardSuit", "sCardNumber"],[Array.NUMERIC, Array.NUMERIC]);

You use:
aPlayerHand.sort();

This clears up the code a lot but it's still complicated code.

Sorry but I won't have time to debug the code now. Stick some traces in and check playerHand_0.length. It's probably not populating.

This is working. It generates the cards, shuffles the deck, deals a hand, and sorts a hand.

Code:

---

var aSuits: Array = new Array("Hearts", "Spades", "Diamonds", "Clubs");
var aValues: Array = new Array("Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King");
var aCardText: Array = new Array();
var aTempDeck: Array = new Array();
var aDeck: Array = new Array();
var aPlayerHand_0: Array = new Array();
var nHandSize: Number = 5;
var i: Number, j: Number;


function Main() {
        //trace("Main()");
        for (i = 0; i < 52; i++) {
                aDeck[i] = i;
                aCardText[i] = aValues[i % aValues.length] + " of " + aSuits[Math.floor(i / aValues.length)];
                //trace(aCardText[i]);
        }
        fShuffleDeck();
}

function fShuffleDeck(): void {
        //  this should create a copy of the deck, then randomly push numbers back into aDeck
        var iRandomIndex: int = 0;
        aTempDeck = aDeck;
        aDeck = [];
        while (aTempDeck.length > 0) {
                iRandomIndex = (Math.random() * aTempDeck.length);
                aDeck.push(aTempDeck[iRandomIndex]);
                aTempDeck.splice(iRandomIndex, 1);

        }
        fDealHands();
}

function fDealHands(): void {
        //trace("fDealHands()");
        for (i = 0; i < nHandSize; i++) {
                aPlayerHand_0.push(aDeck[aDeck.length - 1 - i]);
        }
        fShowHand();
        aPlayerHand_0.sort(Array.NUMERIC);
        fShowHand();
}

function fShowHand(): void {
        trace("\n" + "fShowHand()");
        for (i = 0; i < aPlayerHand_0.length; i++) {
                trace(aPlayerHand_0[i] + ": " + aCardText[aPlayerHand_0[i]]);
        }
}

---