next »

[Hangedman]

ARQA
A game of instant death

Core Engine
████████████████████
100% complete
Graphics
███████████████████░
95% complete
Local
██████████████████░░
90% complete
Netplay
░░░░░░░░░░░░░░░░░░░░
Temporarily cancelled

FINAL BUILD FOR NOW, BUGFIXES MAY COME.

ARQA is a card game about swordfighting. It is quick, violent, and about exploiting every moment of weakness.
It was in no way inspired by Nidhogg, but I today realized that I will forever be asked whether it was or not.

In ARQA, both players are silent fighters on an unknown battlefield. All they have at their disposal are their techniques honed from a lifetime of skill. Each card is such a skill. Skills can be weighted, so to speak, to affect either the player or the opponent. All cards affect 3 stats: Attack, Finesse, and Defense. Most cards also increase Exhaustion to the user only, which climbs from 0 to 9 and then causes you to lose a turn at 9.

The trick is: both players play at once, and both cards played resolve at once, unless they are special cards that deliberately occur second.

Normal Cards > Special Cards > Killing Blow

In order to win, you must gain a state of advantage. That is, have an opponent who has 0 in one stat and have 9 in one yourself. Then you can play a Killing Blow to win the game, so long as they do not prevent the stats from becoming balanced again.

[Inanimate]

• A very VERY fast-paced and simple card game

• fast-paced and simple card game

• card game

HAVE MY BABIES

[ChevyRay]

FLASHPUNKKKKK do eeeet!

I will love you forever.

[Hangedman]

OKAY. FALSH IT FGONNNA BE (mouthful of celebratory croissant)

ALSO: Gonna make a meatspace version too.
PLAYING FLASH GAMES IN REAL LIFE

[ChevyRay]

RAD. If you need assistance or anything, I'll try to be online as much as possible all week, just hit me up. Good luck!

 

[Hangedman]

Found this in a dumpster behind the 7/11. If no one claims it in 30 days I get to keep it



Also, came up with a SUPER AWESOME mechanic for doing local multiplayer with closed hands. Will elaborate more later, suffice to say it riffs on ancient technology and Pokemon Stadium.

[Hangedman]

Working on card mockups.
Simple design and high-contrast design.
Not really sure how I'm going to do images for all of them.

     

[Inanimate]

That is intriguingly cryptic.

[Hangedman]

At midnight, once the compo is officially started, I will reveal the core concept and my basic mechanics.

Until then I am a

[Hangedman]

Totally missed out on midnight, because I realized the forum time is borked and had to alter my time zone in the wrong direction twice to get it right.

Anyway: game info added to main post.
I'm also going to link to milestones along the way there.

LOCAL MULTIPLAY EXPLAINED:
I had an interesting idea for local multiplay. Having both closed hands on one screen seemed utterly pointless. The Pokemon Stadium method seemed like the best course of action (hold down button to reveal cards so you can reconceal them quickly) but I realized that probably wasn't enough, because the numbers are too easy to read on the fly. So now I have the element method.
At the beginning, each player selects an element.
Instead of revealing cards when the button is held down, it reveals a series of numbers that represent the 5 cards in the hand. Each element will have a printable card and/or text file listing what cards the numbers correspond to. And each element has different numbers for each card. Eg. Holding down your key would show '28'. If you selected Fire, you could look at the Fire list you printed and see that 28 corresponds to the 'Push' card I posted above. While for all of the other elements, 28 represents a different card.

I know it's a lot to take in, but thoughts?

[Inanimate]

This all sounds pretty genius. Looking forward to playing it!

[Hangedman]

Okay, Flashpunk guys (especially Chevy), already need some help.

I am making one Entity for each card in the hand, but each one needs to be able to switch between being any card. Simple variable work, but the graphics.

Should I use a spritemap? The filesize of the image the cards draw from will be monumental (if all cards are in one big file) and that could cause some serious lag. Or a graphicslist? Or something else?

[Sos]

I'd override _render()

[Hangedman]

I'd override _render()

  I know how to do that, but I don't know how it would help me. Care to elaborate on the method you have in mind?

[Sos]

make _render not actually render the sprite, but render an arbitrary graphics of a card.

[Hangedman]

Okay folks. I'm working on an algorithm that assigns a 50-card deck random values from 0-49, (DeckArray) and ensures there are no duplicates. I'm almost there, but i'm kind of stuck. The current algorithm re-randomizes each index once if it's already in the deck, but not again. Here's the code.

Code:

//SHUFFLING DECK
for (var h:int = 0; h < 50; h += 1) //50 CARDS IN DECK
{
	var k:int = Math.floor(Math.random() * 50); //RAND FROM 0-49
				
	for (var chk:int = 0; chk < h; chk += 1) //CHECK PREVIOUS CARDS
	{
		if (k == DeckArray[chk])
		{
			k = Math.floor(Math.random() * 50);
		}
	}
				
	DeckArray[h] = k;  //FINALLY INPUT VALUE
}

Just can't quite think this out. Little help?

[Sos]

I can do it in C, but i hope you get it

Code:

int c,cards[DECK],shuffled[DECK],r;

// you need to initialise 'shuffled to 0 (or sth that itsn't a card) here
memset(shuffled,0,4*DECK); // null the array

for (c=0;c<DECK;c++) // loop through UNSHUFFLED CARDS
{
   r = rand()%DECK; // pick a random position in shuffled deck
   while (shuffled[r]) r=(r+1)%DECK; // get next pos if it's taken and wrap around if needed
   // got free (null) position, now place the card there
   shuffled[r] = cards[c];
}

EDIT: so basically, the idea is that you DON'T pick a card for a shuffled deck slot, but assign a shuffled position to each card in the deck

[Lemming]

You can do this in-place in linear time, just find a random card that's not among the 'i' first cards, swap that with the i+1th card and don't touch it again.

I did a quick implementation in python, since it looks like pseudo-code. Most of the code is actually to generate the deck, but it's pretty sweet and should be clear.

This one actually shuffles a 52-card array, but the algorithm can be used to randomize any array regardless of type or size, in linear time. So just create your array with values 0-49, then shuffle it.

Code:

import random

class deck:
        def __init__(self):
                self.cards = []
                for i in range(14):
                        for j in ["Hearts", "Diamonds", "Clubs", "Spades"]:
                                if i == 0:
                                        token = 'A'
                                elif i == 11:
                                        token = 'J'
                                elif i == 12:
                                        token = 'Q'
                                elif i == 13:
                                        token = 'K'
                                else:
                                        token = str(i)

                                self.cards.append(token + " " + j)

        def shuffle(self):
                for i in range(len(self.cards)):
                        # swap a random card with the first card,
                        # and we have the first card figured out.
                        idx = random.randint(i, len(self.cards)-1) # random index between i and the last card
                        tmp = self.cards[idx]
                        self.cards[idx] = self.cards[i]
                        self.cards[i] = tmp
d = deck()
print(d.cards)

#shuffle deck
d.shuffle()
print(d.cards)

Relevant part (algorithm) for readability:

Code:

        def shuffle(self):
                for i in range(len(self.cards)):
                        # swap a random card with the first card,
                        # and we have the first card figured out.
                        idx = random.randint(i, len(self.cards)-1) # random index between i and the last card
                        tmp = self.cards[idx]
                        self.cards[idx] = self.cards[i]
                        self.cards[i] = tmp

Edit: I really wanna push this algorithm so here it is in C, if that helps, with 50 cards:

Code:

        int cards[50];
        size_t i;
        for(i = 0; i < 50; ++i)
                cards[i] = i;
        for(i = 50 - 1; i > 0; --i)
        {
                size_t idx = rand() % (i+1);
                int tmp = cards[i];
                cards[i] = cards[idx];
                cards[idx] = tmp;
        }

[TobiasW]

Another option would be to start with a sorted deck from 0..49, and then

Code:

for (int i = 0; i < 49; i++) {
     swapCards(i, rand()%50);
}

I'm not sure and I'm no math pro, but I think Sos' wrap method might heighten the probability that cards are sorted after a long stretch of filled slots.

For example:
|8||5|6||7||4|10|2|9|3||||1|||||
Now for 6 out of the 20 possibilities, the 11 would be placed after the 3.
Then for 7 out of the 20 possibilities, the 12 would be placed after the 11.
...and so forth.



edit: Oh, I took to long to post.

[Zaratustra]

jesus christ.

Code:

int cards[52];
int place;

for (i = 0; i < 52; i++)
{
   cards[i] = -1;
}
for (i = 0; i < 52; i++)
{
   do { place = random(52); } while (cards[place] != -1);
   cards[place] = i;
}