Mikor a PDRP fejlesztésével elérkeztem a pókergépek berakásával (kb. 2011 november), akkor elkezdtem azt egy ilyen úton fejleszteni. Órákat pókereztünk, míg sikerült kialakítanom a játékmenetet, a lapellenõrzõt. A kinézet és az irányítás kialakítása már könnyebb volt. (kinézetben köszönet jár kadaradam-nak is)
WolverinZ-nek ezer köszönet a türelméért, neki is köszönhetitek, hogy eljutottam a szkripttel, hogy publikálhatom. A szkriptet nem terveztem publikálni, mert egyedi volt. Most, hogy ha PDRP-be berakom, akkor sokára kerül játék alá, ha pedig tartogatom, valaki eljut oda, hogy lesz egy hasonszõrû póker szkriptje, és akkor bizonygassam, hogy ezt én mûveltem..
ɐʞzssǝlosz szkriptje ettõl teljesen független.
 

#define copyCards(%1,%2,%3,%4,%5); %5[0] = %1[0];%5[1] = %1[1];%5[2] = %1[2];%5[3] = %2;%5[4] = %3;%5[5] = %4[0];%5[6] = %4[1];
[/quote]
Pontos vesszõt törölni kell.
 

public pkr_NewRound();
public pkr_NewRound()

 
A felsõ public helyett forward.
 

public RoundEnd();
public RoundEnd()
public pkr_Alone();
public pkr_Alone()

 
Szintén.
És {} hiány végett reklamál még.
 error 037: invalid string (possibly non-terminated string)
 

new CardNames[13][9] =
{
{\"kettes\"},
{\"hármas\"},
{\"négyes\"},
{\"ötös\"},
[/quote]
De ezek a gondok lehet csak nálam jelentkeztek, apróságok amúgy, már javítottam.
Amúgy találtam egy texas holdem laperõsség leírást, ami eléggé érthetõen leírja az egyforma lapok közül melyik az erõsebb, ha érdekel.
http://www.pokerszabalyok.com/rank
Edit:
Ez nagyon tetszik nekem, hogy erre a logikai menetre nem gondoltam nem is értem. (mindig van új a nap alatt)
 

stock randomCard()
{
new card;
do card = 13*random(4)+random(13); while(card_picked[card]);
card_picked[card] = true;
return card;
}

 
Azt hiszem egy kis átalakítás után sebesség mérés teszt lesz, és ha nem bánod ezt a logikai megoldást felhasználom én is.
Nekem nagyon gyorsan kellene 5 újabb lap ami még nem volt leosztva, nem egyenként.

stock pkr_Best(playerid)
{
new cardcarry[7];
cardcarry[0] = flop[0];cardcarry[1] = flop[1];cardcarry[2] = flop[2];cardcarry[3] = turn;cardcarry[4] = river;cardcarry[5] = hand[playerid][0];cardcarry[6] = hand[playerid][1];;
new tmphand[5];
tmphand=BestHand(cardcarry);
return tmphand;
}
[/quote]
Köszi, használni fogom.
Mivel írtam egy gyors tesztet:
 

#include <a_samp>
enum
bla
{
fivecards_hand[10]
};
new
PP_Info[MAX_PLAYERS][bla];
new
bool:card_picked[52];
public
OnFilterScriptInit()
{
//...............................
new
time = GetTickCount();
for(new i; i < 100000; i++)
{
do
{
   RandomNumber(52, PP_Info[0][fivecards_hand], 10);
}
while(HasDuplicateValues(PP_Info[0][fivecards_hand], 10))
}
printf(\"1 módszer time: %dms 100.000 ezres ismétlõdésnél.\", GetTickCount() - time);
//..............................
time = GetTickCount();
for(new i; i < 100000; i++)
{
for(new p; p < 10; p++) // 10 darab nem egyforma véletlenszám összeállítása.
{
   PP_Info[0][fivecards_hand][p] = randomCard();
}
for(new d; d < sizeof card_picked; d++)   // randomCard segéd változójának törlése
{
   card_picked[d] = false;
}
}
printf(\"2 módszer time: %dms 100.000 ezres ismétlõdésnél.\", GetTickCount() - time);   
return 1;
}
//..............................
stock
randomCard()
{
new card;
do card = 13*random(4)+random(13); while(card_picked[card]);
card_picked[card] = true;
return card;
}
//..............................
stock
RandomNumber(value, array[ ], size = sizeof array)
{
for(new p = 0; p < size; p++) array[p] = random(value);
}
stock
HasDuplicateValues(const array[ ], size = sizeof array)
{
for(new f = 0; f < size - 1; ++f)
{
for(new c = f + 1; c < size; ++c)
{
   if(array[f] == array[c])
   {
      return true;
   }
}
}
return false;
}

 
És gyorsabb az általad használt változat:
 

[2012.03.24 19:37:13] 1 módszer time: 2856ms 100.000 ezres ismétlõdésnél.
[2012.03.24 19:37:15] 2 módszer time: 1841ms 100.000 ezres ismétlõdésnél.
[/quote]
Edit:
Bocsánat a reklámért de kicsit átalakítottam számomra megfelelõ állapotra és a gyorsasága ennyit javult:
[2012.03.24 20:11:06] 3 módszer time: 684ms 100.000 ezres ismétlõdésnél. (ami több mint negyede annak amit használtam eddig (idõben) vagyis több mint négyszer gyorsabb)