Beiträge von Sub Royal

Habe ich mal gemacht, die Errors sind leider immernoch die gleichen
Warum muss das Array MAX_STR_LEN enthalten? Wird jeder char etwa einzeln da abgespeichert oder komplette Strings?

int ch,lines;
			while(!feof(fIn))
			{
			  ch = fgetc(fIn);
			  if(ch == '\n')
			  {
				lines++;
			  }
			}
			int *ptr = malloc(sizeof(int)*lines*4);  
			char fileArray[lines][MAX_STR_LEN];
			FILE *fOut = fopen("output.txt", "wb");
			if (ptr == NULL)
			   {
			   printf(" Out of memory!\n");
			   exit(1);
			   } 
			clock_t t;
			t = clock();
			char buf[512];
			int counter=0;
			while ((fgets(buf, sizeof(buf), fIn) != NULL))
			{	
				strcpy(fileArray[counter][MAX_STR_LEN],buf);
				counter++;
			}
			qsort(fileArray,3,sizeof(*fileArray),(int(*)(const void*,const void*))strcmp);
			int k;
			while(k < sizeof(fileArray))
			{
				if(fileArray[k][MAX_STR_LEN] != fileArray[k+1][MAX_STR_LEN])
				{
				strcpy(fileArray[k][MAX_STR_LEN],buf);
				fprintf(fOut,"%s",buf);		
				}
				k++;
			}
			free(ptr);
			t = clock() - t;
			double time_taken = ((double)t)/CLOCKS_PER_SEC; // in seconds
			printf("\nThe removal took %.4f seconds to finish \n", time_taken);
			fclose(fOut);
			fclose(fIn);
			return 0;

Moin

Aktuell bin ich daran ein Programm zu schreiben, um Zeilenduplikate in einer Textdatei zu finden, und zu eliminieren.

Dabei erstelle ich ein Array mit [lines] Anzahl der Lines .
Dann werden aus der Textdatei die Zeilen als String in das Array gesteckt.
Das Array wird dann sortiert, und dann soll das Array durchgegangen werden, ob das k-te Element und das k+1-te Element unterschiedlich sind, und dann wird in eine Datei geprintet.

Irgendwie verstehe ich aber die Probleme die der Compiler macht nicht, da ich ja letztendlich im Array Daten vom Typ char habe, aber laut Compiler diese scheinbar ints sind.
Weiterhin bekomme ich immer die aussagekraeftige Meldung "Speicherzugriffsfehler"

Hier mal mein Code, vielleicht weiss jemand ja weiter.

else 
	{	
		FILE *fIn = fopen(argv[1], "r");
		if ( fIn == 0 )
		{
			printf( "Could not open file\n" );
		}
		else
		{	
			int ch,lines;
			while(!feof(fIn))
			{
			  ch = fgetc(fIn);
			  if(ch == '\n')
			  {
				lines++;
			  }
			}
			int *ptr = malloc(sizeof(int)*lines*4);  
			char fileArray[lines];
			FILE *fOut = fopen("output.txt", "wb");
			if (ptr == NULL)
			   {
			   printf(" Out of memory!\n");
			   exit(1);
			   } 
			clock_t t;
			t = clock();
			char buf[512];
			int counter=0;
			while ((fgets(buf, sizeof(buf), fIn) != NULL))
			{	
				strcpy(fileArray[counter],buf);
				counter++;
			}
			qsort(fileArray,3,sizeof(*fileArray),(int(*)(const void*,const void*))strcmp);
			int k;
			while(k < sizeof(fileArray))
			{
				if(fileArray[k] != fileArray[k+1])
				{
				strcpy(fileArray[k],buf);
				fprintf(fOut,"%s",buf);		
				}
				k++;
			}
			free(ptr);
			t = clock() - t;
			double time_taken = ((double)t)/CLOCKS_PER_SEC; // in seconds
			printf("\nThe removal took %.4f seconds to finish \n", time_taken);
			fclose(fOut);
			fclose(fIn);
			return 0;
		}

Die Fehler

duplicatefinder.c: In function ‘main’:
duplicatefinder.c:62:12: warning: passing argument 1 of ‘strcpy’ makes pointer from integer without a cast [-Wint-conversion]
     strcpy(fileArray[counter],buf);
            ^~~~~~~~~
In file included from duplicatefinder.c:2:0:
/usr/include/string.h:125:14: note: expected ‘char * restrict’ but argument is of type ‘char’
 extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
              ^~~~~~
duplicatefinder.c:72:12: warning: passing argument 1 of ‘strcpy’ makes pointer from integer without a cast [-Wint-conversion]
     strcpy(fileArray[k],buf);
            ^~~~~~~~~
In file included from duplicatefinder.c:2:0:
/usr/include/string.h:125:14: note: expected ‘char * restrict’ but argument is of type ‘char’
 extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
              ^~~~~~

Warum meckern eigentlich soviele im englischen SA-MP Forum rum wenn man #pramga tabsize 0 benutzt?
Bringt das irgendwelche Nachteile?

Changelog

# Change Log
All notable changes to this project will be documented in this file.


## Initial Release


## [0.1a] - 2017-03-14
### Added
- Binarysearch instead of iterators for pickup system.
- /stealth command to make yourself invisible for 60 seconds on minimap.


## [0.1b] - 2017-03-20
### Added
- Possibility to get a Warpkit to teleport yourself back to your base by using /warp command. Can be purchased for $100k in the shop.
- New reference map files including new PlayerInfoPickups array. 
- New pickup type InfoPickups, to show certain important server information like rules, FAQ and more..
- SaveUser_data function to save userdata periodically into the user file.
- ResetPlayerData function to reset player vars and arrays after death/disconnect.
- TeleportPlayerToBase function to teleport the player back to his base using /warp command or /spawn command (Admin only).
-


### Removed
- The Seasparrow of team YELLOW on Chilliad map due to balancing.
- Usless/Unused player vars and arrays.




### Fix
- /stealth kit which didnt work before. The player was invisible on the map all the time. No reset.
- Map bugs on CHILLIAD and GREEN PALMS map.
- String length of several strings due to display problems.




## [0.1b] - 2017-03-21
### Added
- Added weather system for random weather.
- Weather can be set by admins, using /weather ID
- /dropmoney uses GenerateRandomPickup function now, to create money pickups.
- system to check if a team has won the game. (if other teams are empty)
- Improved several minor bugs.
- Major changes in score system.
- The winner of the team will now be determined if there is no player left in other teams
- Recursive function will be called in OnPlayerDeath instead of OnPlayerSpawn now.
- Dead player will be thrown into TEAM_SPECTATOR after death now if the bed is missing.
- GetPlayerCount() function added to count amount of players for use in TeamsAlive(bool:value) function.
- Recursive function TeamsAlive(bool:value) function (false/true) to count teams alive or check if there is only one team left.
- Fighting Style menu to purchase different fightstyles.


### Fix
- Increased weapon prices due to balancing reasons.
- Changed bomb activation radius to 150m instead of 100m.


## [0.1b] - 2017-03-28
### Added
- Function GivePlayerMoneyText to give or remove money from a player and display gametext.
- #define to change the value of Money Pickups.


## [0.1b] - 2017-03-28
### Added
- Function GivePlayerMoneyText to give or remove money from a player and display gametext.
- #define to change the value of Money Pickups.


## [0.1.3a] - 2018-03-02
### Fix
- Fixed major bugs.
- Fixed y_ini problems.
- Fixed a huge amount of bugs.
- Code optimization

Ich gruesse euch liebe Community,

Hiermit praesentiere ich mein aktuelles Miniprojekt Last Bed Standing, basierend auf Grand Larceny!

Motivation:

Idee und Ziel dieses Projekts war es das Bedwars Minigame welches es auf vielen Minecraft Servern gibt in SA-MP und im SA-MP Stil nachzubauen (Bett sprengen statt abbauen etc..), und mal ein andere Art von Servern erstellen, denn man sieht ja leider nur noch Reallife.
Weiterhin programmiere ich im Rahmen meines Studiums viel in C, und warum nicht mal bisschen ueben durch Programmieren in einer C aehnlichne Sprache? Daraus ist dieses Projekt in nun ca. 2 Wochen entstanden, und was geht schon ueber ein Selfmade?
Desweiteren bin ich ein Fan von OpenSource Software, weshalb auch dieses Projekt hier fuer alle verfuegbar sein sollte.

Letztlich ist das Projekt nur aus Spass, und etwas Uebung fuer das Studium entstanden, und wird in Zukunft noch geupdated.

Aktuell befindet sich der Gamemode im Alpha Stadium und wird vorraussichtlich jede Woche geupdated.
Wenn es eine fehlerfreie Version gibt wird unter die GNU Public License gestellt, damit jeder das Werk aendern, verbreiten kann usw. soll ja schliesslich etwas fuer alle sein

Das Fragment welches aus Grand Larceny ist, ist lediglich die Team bzw. Stadtauswahl, meiner Ansicht nach viel schoener als der Standardkram den man auf sovielen Servern sieht.

Aktuell gibt es 3 Teams zur Auswahl aehnlich wie in Bedwars wo es zu Beginn auch eine Teamauswahl gibt.
Team ROT befindet sich am Sherman Staudamm, westlich von El Castillo del Diablo, Team GRAU bei Area 51 und Team BLAU bei Verdant Meadows, dem Flughafen.

Jedes Team verfuegt ueber einen Shop mit einem "Villager" bei welchem man Waffen, Armour , Skills und eine Bombe kaufen kann die noetig ist um ein feindliches Bett zu zerstoeren.
Alle Teams haben nahe Ihrer Base irgendein Fahrzeug wie z.B. Panzer oder Seasparrow um sich besser vor Feinden verteidigen zu koennen.

Jedes Team besitzt einen "Bronzespawner" bzw. da ich das ganze im GTA Stil machen wollte, einen Geldspawner, welcher random Geldpickups generiert, welche noetig sind um sich Waffen und andere Dinge zu kaufen.

Ziel ist es das Bett des feindlichen Teams zu zerstoeren (wobei nach dem Zerstoeren eines Betts das jeweilige Team nicht mehr respawnen kann), und dann die restlichen Spieler zu eliminieren, und so das Spiel zu gewinnen, wie in Bedwars halt.
Der Gamemode ist inzwischen im Vergleich zum Ursprungs Grand Larceny, nun mit insgesamt 2400 Zeilen ziemlich umfangreich.

Das ganze habe ich inzwischen mit 4 Spielern insgesamt ausprobiert, und ein Spiel dauert durchschnittlich 10 Minuten.
Der Spassfaktor ist trotz der Einfachheit des Gamemodes sehr gross!

Der Gamemode ist komplett in ENGLISCH geschrieben um auch Spieler aus anderen Laendern anzusprechen.

Aktuell laeuft das Script unter knogleinsi.de als SA-MP Server mit 32 Slots, und wird auch weiterhin dort laufen.

Weiterhin sind aktuell 4 verschiene Maps spielbar, und man kann problemlos weitere erstellen, dazu einfach die Muster in pawno/includes anschauen.

Features:

Das Script besitzt rund 3100 Zeilen, und ist eigentlich komplett selbst geschrieben, bis auf Tipps anderer User.
Der Teil aus Grand Larceny wurde grundlegend veraendert.

Es ist moeglich selbst Maps zu erstellen, dazu kann man einfach das Muster aus dem Ordner /pawno/include auf Github ziehen.

//Color tags for textdraw use
#define FIRST_TEAM_COLOR_TAG {610D96}VIOLET
#define SECOND_TEAM_COLOR_TAG {FFFF00}YELLOW
#define THIRD_TEAM_COLOR_TAG {8B4513}BROWN




#define TEAM_ONE_SEL_INTERIOR 0
#define TEAM_TWO_SEL_INTERIOR 0
#define TEAM_THREE_SEL_INTERIOR 0




#define TEAM_ONE_INTERIOR 0
#define TEAM_TWO_INTERIOR 0
#define TEAM_THREE_INTERIOR 0
// Team colors
#define COLOR_TEAM_ONE 0x610D9655 //Violet
#define COLOR_TEAM_TWO 0xFFFF0055 //Yellow
#define COLOR_TEAM_THREE 0x8B451355 //Brown




//Where the teams are located..
#define FIRST_TEAM_LOCATION Mount Chilliad (South)
#define SECOND_TEAM_LOCATION Mount Chilliad (North)
#define THIRD_TEAM_LOCATION Mount Chilliad (West)




stock const Float:GlobalActors[][]={
    {-2261.4497,-1983.6539,251.0746,149.3091},//Violet
    {-2816.3923,-1530.5948,140.8438,352.9545},//Brown
    {-2347.8748,-1355.2128,299.7364,194.9771},//Yellow1
    { -2294.6057,-1282.0396,259.3622,221.0728},//Yellow2
    {0.0,0.0,0.0,0.0},//Not defined    
    {0.0,0.0,0.0,0.0}//Not defined
};




stock const Float:GlobalZones[][]={
    {-2452.354, -2066.984, -2160.407, -1891.816},//Violet
    {-2849.402, -1646.58, -2732.623, -1413.023},//Brown
    {-2428.998, -1389.667, -2218.796, -1202.821}//Yellow
};




stock const Float:MoneySpawns[][]={    
    {-2335.7568,-2340.2905,-2023.9417,-2027.9861,270.0450,269.2450},//Violet
    {-2279.4812,-2283.4812,-1286.3794,-1294.3794,258.9622,258.3622},//Yellow
    {-2810.7144,-2819.3496,-1493.0504,-1495.6464,139.3078,138.9078},//Brown
    {-2303.8931,-2337.4104,-1607.2054,-1644.9517,483.7031,482.9031}//Main
};






stock const Float:MAP_WORLDBOUNDS[][]={
    {-1728.326, -2977.858, -945.9079, -2323.897}
};




stock const Float:ClassSel_SetupTeamTEAM_POS[][]={
    {-2244.3000000,-2015.5000000,280.3999900},//Violet
    {-2282.7908,-1377.0408,365.6920},//Yellow
    {-2758.2195,-1479.8926,202.8240}//Brown
};




stock const Float:ClassSel_SetupTeamTEAM_LOOK_AT[][]={
    {-2316.7000000,-2040.2000000,261.2000000},//Violet
    {-2305.9270,-1254.1742,239.8091},//Yellow
    {-2834.3979,-1553.4116,110.3533}//Brown
};




stock const Float:beds[][] = {
    {-2340.7637,-2024.7919,270.5094},//Violet
    {-2812.6035,-1515.9814,140.8438},//Brown
    {-2326.8735,-1356.4872,300.2661}//Yellow
};




stock const Float:gSpawnsTeam_TEAM_ONE[][] = {//Violet
    {-2340.0759,-1984.2560,327.3245,96.6453},
    {-2265.7549,-1982.4696,251.1930,327.2607},
    {-2336.1033,-2026.0273,270.5272,153.9858},
    {-2371.8701,-2009.8907,259.0939,163.6758},
    {-2431.2183,-2012.5878,228.1622,206.6029},
    {-2321.6675,-2031.6503,260.7211,265.2202},
    {-2284.3025,-1956.8335,270.9055,218.2196}
};




stock const Float:gSpawnsTeam_TEAM_TWO[][] = {//Yellow
    {-2287.0525,-1284.2802,259.3622,128.5823},
    {-2323.8572,-1258.1201,243.6398,317.2668},
    {-2290.4866,-1276.1278,259.3622,308.1799},
    {-2275.3657,-1322.3977,277.1953,338.5501},
    {-2336.4958,-1357.4409,299.7297,13.6672}, 
    {-2353.0078,-1359.2170,299.7364,282.7996}, 
    {-2412.6658,-1368.1118,332.8622,297.8398}
};




stock const Float:gSpawnsTeam_TEAM_THREE[][] = {
    {-2818.0842,-1523.5146,140.8438,266.4268}, // brown1
    {-2816.4951,-1536.1785,139.2891,87.5118}, // brown2
    {-2865.6543,-1551.7012,139.9026,98.4785}, // brown3
    {-2835.2129,-1509.0914,138.5741,279.8769}, // brown4
    {-2818.6655,-1518.3864,140.8438,265.4634}, // brown5
    {-2813.6826,-1460.6605,136.2261,272.9834} // brown6
};

Einfach Koordinaten, Farben und Namen anpassen, und fertig!

Teamsize ist die Anzahl an Teams (Werde ich in Teamcount oder aehnlich umbauen) und kann zwischen 2 und 6 gewaehlt werden.
Genutzt wird eine Moeglichst effiziente Programmierweise, beispielsweise Binaersuche statt Iteratoren etc.
Pickupsystem ist dank der Hilfe von Usern hier nun super erweiterbar und super effizient.

Der Gamemode nutzt sscanf, jedoch keinen Command Generator, um strtok endlich komplett zu verdraengen.
Das Stats System nutzt y_ini, und es werden wie im Minecraft Bedwars, zerstoerte Betten, Kills/Deaths getrackt, und zusaetzlich noch detonierte Bomben, welche man im Shop kaufen kann.

Es gibt zwei neue Features in der Version 0.1b:

Stealth:

Man kann sich im Shop ein Stealth Paket kaufen, durch welches man auf der Map 60 Sekunden unsichtbar ist.

Bomb:

Eine Bombe kann im Shop erworben werden, diese kann irgendwo platziert werden, und dann aus bis zu 100 Metern Entfernung durch die "Y" Taste gesprengt werden.

Eine Reihe Admin Commands wurde inzwischen implementiert.
Weiterhin habe ich auch einige Maps aus meinem alten Projekt Hitoyoshi implementiert, damit diese noch Verwendung haben.

Fuer die naechste Version welche Mittwoch erscheinen soll, ist die Implementierung von Incognitos Streamer geplant.

Es gibt aktuell 3 Maps mit 4 Teams, und 1 Map mit 3 Teams

... weitere Features in neuer Version, siehe auch http://forum.sa-mp.com/showthread.php?p=3846056#post3846056

Hier mal einen kleinen Ueberblick ueber die Teams, und deren Lage, auf eine der aktuell 4 Maps.

Bilder:

Eine Bombe wird an einem Bett platziert!

Das Bett detoniert, und geht in Flammen auf!

Die auf Grand Larceny basierende Teamauswahl

Eins der 3 Teams die man auswaehlen kann.

Der Shop des Teams ROT

"Bronzespawner" und kleine Tafel die jedes Team besitzt, auf welcher Informationen zum Spiel angezeigt und aktualisiert werden.

Die aus Bedwars bekannte "Mitte"

Das Bett von Team GREY

Download:

Einfach das Repo klonen

https://github.com/Knogle/LastBedStanding

Den Englischen Thread den ich wesentlich haeufiger updaten werde verlinke ich hier

http://forum.sa-mp.com/forumdisplay.php?f=71

Moin

Update ist draussen.

Pickups werden nun mit Kalibers System verwaltet, inklusive Binaersuche, daher super erweiterbar, und verdammt schnell!
Bugs wurden alle gefixxt (bekannte Bugs), und es wurden 2 zusaetzliche Maps hinzugefuegt.

Weiterhin kann nun jeder seine eigenen Maps erstellen, dazu einfach das Muster aus dem pawno/include Ordner nehmen, und einfach Koordinaten und Farben ersetzen, fertig!
Shop wurde erweitert, Commands fuer Admins hinzugefuegt, y_ini Stats System und mehr hinzugefuegt.

Vollstaendiges changelog kommt die Tage auf github

https://github.com/Knogle/LastBedStanding

Gibt es die Moeglichkeit die Streamdistance von Pickups einzustellen, bei CreatePickup? Oder geht das bei Streamern?

habe den Fehler dank dem englischen SAMP Forum gefunden

stock GetPickupType(pickupid, &index)
{
	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
	if(ares > -1 && MoneyPickups[ares] == pickupid) return index=ares,ACTOR_TYPE;
	new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
	if(mres > -1 && MoneyPickups[mres] == pickupid) return index=mres,MONEY_TYPE;
	return INVALID_PICKUP_TYPE;
}

Habe faelschlicherweise auch unten MoneyPickups drin statt ActorPickups jetzt gehts einwandfrei

Zitat von Jeffry

Eventuell leere Indizes.Um Fehler mit der ID 0 zu vermeiden entweder alle Array-Indizes auf -1 setzen, oder ganz oben in OnGameModeInit ein Pickup im Nirgendwo erstellen, das hat dann die ID 0 und wird nie aufgerufen.

Siehe Post #24.196.

Danke dir, das hat mir schonmal geholfen die doppelten IDs zu verhindern
Habe jedoch immernoch das Problem wenn:

Den Teil aus Post #24.196 habe ich auch eingebaut.

Ich das hier habe

stock GetPickupType(pickupid, &index)
    {
    	new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
    	if(MoneyPickups[mres] == pickupid && mres > -1) return index=mres,MONEY_TYPE;
    	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
    	if(ActorPickups[ares] == pickupid && ares > -1) return index=ares,ACTOR_TYPE;	
    	return INVALID_PICKUP_TYPE;
    }

Und dann ein ActorPickup einsammle, dann wird INVALID_PICKUP_TYPE returnt, weshalb weiss ich nicht.
Wenn ich ein MoneyPickup einsammle ist alles gut, dann funktioniert alles so wie es soll.
Ist alles umgedreht, also der Teil mit den ActorPickups oben, funktionieren die ActorPickups super, sammle ich jedoch ein MoneyPickup ein wird INVALID_PICKUP_TYPE returnt.

So als wuerde es mir scheinen dass nach dem ersten if statement der direkt dannach zu return INVALID_PICKUP_TYPE geht.

Aktuell benutze ich den Teil von Kaliber der prima funkt mit den beiden for Schleifen, mit der Suche waere aber die Kroenung

stock GetPickupType(pickupid, &index)
{
    for(new i; i<sizeof(money_pickups); i++)
    {
        if(money_pickups[i] == pickupid) return index=i,MONEY_TYPE;
    }
    for(new i; i<sizeof(actor_pickups); i++)
    {
        if(actor_pickups[i] == pickupid) return index=i,ACTOR_TYPE;
    }
    return INVALID_PICKUP_TYPE;
}

Sind Queues eigentlich moeglich in PAWN?

Lob an @Kaliber Dafuer dass er sich um alle meine dummen Fragen kuemmert

Zitat von Kaliber

Nein, das bedeutet dass du in beiden Arrays die selben IDs hast xD

Irgendwas stimmt da mit deiner Zuweisung nicht

Aber wie gesagt, eigentlich musst du Money pickups nicht extra definieren nur alle anderen

Ja das probiere ich mal
Mit der Zuweisugn hmm, habe da nix gefunden
Habe mal die Inhalte von dem kleineren Array im grossen gesucht, und das einzige wo es immer ein match gibt, ist bei Pickupid 0, die ist in beiden drin, keine Ahnung warum
Alle anderen sind nicht in den jeweils anderem Array enthalten

Ich muss leider nochmal stoeren

stock GetPickupType(pickupid, &index)
{
	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
	if(ActorPickups[ares] == pickupid && ares > -1) return index=ares,ACTOR_TYPE;	
	new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
	if(MoneyPickups[mres] == pickupid && mres > -1) return index=mres,MONEY_TYPE;
	return INVALID_PICKUP_TYPE;
}

Wenn ich das so schreibe, dann funktioniert das ganze nur fuer die Actor Pickups, das heisst beim Geld einsammeln kriegt der Spieler kein Geld

stock GetPickupType(pickupid, &index)
{
	new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
	if(MoneyPickups[mres] == pickupid && mres > -1) return index=mres,MONEY_TYPE;
	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
	if(ActorPickups[ares] == pickupid && ares > -1) return index=ares,ACTOR_TYPE;	
	return INVALID_PICKUP_TYPE;
}

Wenn ich das so rum mache ist das genau umgedreht Money Pickups funktionieren, das heisst der Spieler kriegt Geld, jedoch funktionieren die ActorPickups nicht
Kann ich das irgendwie mit nem if-else Gebilde loesen ?

1A !! Danke es funktioniert jetzt einwandfrei
An die Sache mit dem return 0 habe ich garnicht gedacht

Danke dir ! warum funktioniert deine binaersuche , jedoch meine nicht? Habe ich da was falsch gemacht?

Super dann werde ich mal folgendes einbauen

new ares = binsearch(pickupid,ActorPickups,sizeof(ActorPickups));
		if(ares != -1) return index=ares,ACTOR_TYPE;
		printf("ID: %d ares: %d",pickupid,ares);
		new mres = binsearch(pickupid,MoneyPickups,sizeof(MoneyPickups));
		if(mres != -1) return index=mres,MONEY_TYPE;
		printf("ID: %d mres: %d",pickupid,mres);

Vielen Dank nochmal! Zu Binaersuche im PAWN konnte mir leider im englischen Forum nicht geholfen werden

Zitat von Akino Kiritani

Nein der letzte Eintrag ist -1.
Die Frage ist nur was er genau vorhat, will er wirklich nur den letzten Wert(so wie es für mich klingt) oder will er den letzten Wert der nicht dem Standardwert entspricht(deine Schleife).

Ja ich wollte nur den wirklich letzten Wert

Noch ne Frage
Meine binary suche ist irgendwie kaputt returnt immer 0,kA warum, hat jemand eventuell zufaellig ne binaersuch Funktion auf Lager?

Oder muss ich l un r eventuell anders festlegen?

Der fragliche Teil:

new mres = binsearch(MoneyPickups,pickupid,MoneyPickups[0],MoneyPickups[sizeof(MoneyPickups)-1]);
        if(MoneyPickups[mres] == pickupid) return index=mres,MONEY_TYPE;
        printf("ID:%d mres: %d",pickupid,mres);

Es kommt immer zu return 0 aus meiner binsearch funktion

stock binsearch(a[],key,l,r)
{
    new k;
    while(r >=l)
    {
        k = (l+r)/2;
        if(key == a[k])
        {
            return k;
        }
        if(key < a[k]) 
        {
        r = k-1;
        }
        else 
        {    
        l= k+1;
        }        
    }    
    return 0;
}

Habe als l das erste Element genommen also das am weitesten Links ist MoneyPickups[0] und das am weitesten rechts ist MoneyPickups[sizeof(MoneyPickups)-1]

Dickes Lob an Kaliber seine Tipps waren bisher ausnahmslos erfolgreich, bin dafuer sehr dankbar.
Gab viele knifflige Probleme an denen ich ohne Kaliber wohl immernoch nagen wuerde

Danke Kaliber:

So jetzt kommt meine vielleicht fuer heute letzte Frage

Ich werde tatsaechlich spaeter noch mehr Pickups hinzufuegen, deshalb habe ich das mit dem sortieren mal gemacht.

Bei dem Array mit den Actors ist das kein Problem, da aendert sich ja nix dran, und es funktioniert auch

stock GetPickupType(pickupid, &index)
{
		new mres = binsearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
HeapSort(MoneyPickups);
		if(MoneyPickups[mres] == pickupid) return index=mres,MONEY_TYPE;
		new ares = binsearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
		if(ActorPickups[ares] == pickupid) return index=ares,ACTOR_TYPE;
	return INVALID_PICKUP_TYPE;
}

public OnPlayerPickUpPickup(playerid, pickupid)
{
	new index;
	switch(GetPickupType(pickupid,index))
	{
	case INVALID_PICKUP_TYPE:
		{
		}
	case MONEY_TYPE:
		{
			maxmoney -= 1;
			GivePlayerMoney(playerid, 1000);
			printf("ID picked up: %d",maxmoney);
			MoneyPickups[index]=-1;
			DestroyPickup(pickupid);


		}
	case ACTOR_TYPE:
		{
			ShowMenuForPlayer(shopmenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	}
	return 1;
}

Mal angenommen ich will das Array sortieren damit das mit der binaersuche klappt, wo muesste ich das Sortieren dann ausfuehren also wo im Code?
Habe dazu eine super tolle HeapSort Funktion

stock HeapSort (array [], n = sizeof (array))
{
	new i;
	for (i = n / 2; i > 0; --i) // Make heap
	SinkDown (array, i, n);


	for (i = n; i > 1; --i)
	{
		Swap (array [i - 1], array [0]);
		SinkDown (array, 1, i - 1);
	}
}


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


static stock SinkDown (array [], i, m)
{
	new j;
	while (2 * i <= m)
	{
		j = 2 * i;
		if (j < m && array [j - 1] < array [j])
		++j;

		if (array [i - 1] < array [j - 1])
		{
			Swap (array [i - 1], array [j - 1]);
			i = j;
		}
		else
		i = m;
	}
}


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


static stock Swap (&a, &b)
{
	new s;
	s = a;
	a = b;
	b = s;
}

Wow klasse das funktioniert alles 1A jetzt funktioniert mein Gamemode endlich und ich kann endlich die neue Version veroeffentlichen
Die enum Variante ist wirklich klasse!

Mir ist jedoch aufgefallen, da mein Skript jetzt mit Makros vollgeballert wurde, bestimmt 600-700 Zeilen mit einem # inzwischen dauert das Compilen leider ziemlich lange!

Noch ne Frage zu dem OnPlayerPickUpPickup

Da wird ja letztendlich in dem Array gesucht wie ich das sehe, das kann ja bei 4000 MoneyPickups beispielsweise ziemlich lange dauern.
Damit es keinen Ueberlauf an Pickups gibt (ueber 4096) habe ich die so definiert, ist das richtig?

new ActorPickups[sizeof(GlobalActors)];new MoneyPickups[MAX_PICKUPS-sizeof(GlobalActors)-1];

Ist es eventuell weiterhin sinvoll oder moeglich, bei GetPickupType die binaere Suche anzuwenden? Zumindest hat sie ja eine geringere Laufzeit
Habe da an sowas gedacht was ich mal aus nem C Buch entnommen, und umgebaut habe

stock binsearch(a[],key,l,r)
{
	new k;
	while(r >=l)
	{
		k = (l+r)/2;
		if(key == a[k]) return k;
		if(key < a[k]) r = k=1;
		else l= k+1	
	}	
	return 0;
}

Habe mir eventuell folgendes gedacht

stock GetPickupType(pickupid, &index)
{
	for(new i; i<sizeof(MoneyPickups); i++)
	{
		if(binsearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1)) return index=i,MONEY_TYPE;
	}
	for(new i; i<sizeof(ActorPickups); i++)
	{
		if(binsearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1)) return index=i,ACTOR_TYPE;
	}
	return INVALID_PICKUP_TYPE;
}

//edit: vergiss meinen Code der ist mist

Danke dir, leider haut das auch irgendwie nicht hin:/

Nochmal alle Teile.

Auf den Counter via Globale Variable habe ich verzichtet da ich das in einer for schleife eh mit Iterator mache (oder ist das mein Fehler? :D)

Nochmal die Actor Funktion wo das PickUp generiert wird

stock CreateGlobalActor(actorid,modelid,Float:ax,Float:ay,Float:az,Float:angle,Float:distance,pickupid)
{
	actorid = CreateActor(modelid,ax,ay,az,angle);
	new Float:x, Float:y, Float:z;
	GetActorPos(actorid, x, y, z);
	GetXYInFrontOfActor(actorid, x, y, distance);
	pickupid = CreatePickup(1210,2,x,y,z,-1);
	SetActorInvulnerable(actorid, true);
	printf("Actor created, pickupid %d",pickupid);
	return pickupid;
}

Wo es aufgesammelt wird

public OnPlayerPickUpPickup(playerid, pickupid)
{
	for(new i=0; i<sizeof(GlobalActors); i++)
	{
		if(pickupid != ActorPickups[i])continue;
		ShowMenuForPlayer(shopmenu,playerid);
		TogglePlayerControllable(playerid,false);
		return 1;
	}
	maxmoney = maxmoney -1;
	DestroyPickup(pickupid);
	GivePlayerMoney(playerid, 1000);
	printf("ID picked up: %d",maxmoney);
	return 1;
}

Und der Funktionsaufruf

for(new g=0;g<sizeof(GlobalActors);g++)
	{
		CreateGlobalActor(g+1,274,GlobalActors[g][0],GlobalActors[g][1],GlobalActors[g][2],GlobalActors[g][3],3.0,ActorPickups[g]);		
		SetActorInvulnerable(g+1, true);
	}

Wenn ich alles richtig verstanden habe, muesste die Pickupid, beispielsweise bei der ersten Iteration bei g= 0 ActorPickups[0] uebergeben werden, und dann ActorPickups[0] = CreatePickup dann ausgefuehrt werden, oder?
Oder kann man keiene Werte aus Arrays in einer Funktion uebergeben?

Weitere Frage:

Ich habe einen Command mit dem ein Spieler unsichtbar wird, und setze dann einen Timer von 60 Sekunden um ihn wieder sichtbar zu machen.
Problem ist: Ueber einen Timer kann ich ja keine Parameter an die Funktion uebergeben, wie kriege ich das dann realisiert? Muss ich vielleicht mit dem & Symbol arbeiten? Weil irgendwie muss die Funktion ja wissen bei welchem Spieler die 60 Sekunden abgelaufen sind.

Macht es ausserdem irgendwo sinn in PAWN volatile einzusetzen? Ich habe mal in meine Arrays testweise volatile reingepackt, sehe aber keinen Unterschied.
Auch in der Dokumentation zu PAWN habe ich nix zu volatile gefunden, kenne das nur aus C daher weiss ich nicht was es in PAWN bringen sollte

Kaliber:

Habe es mit der Pickupzuweisung so wie in deinem Vorschlag gemacht

Habe jedoch ein kleines Problem:

public OnPlayerPickUpPickup(playerid, pickupid)
{
	for(new i;i<sizeof(GlobalActors);i++)
	{
		if(pickupid == ActorPickups[i])
		{
			ShowMenuForPlayer(shopmenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
		else
		{
			maxmoney = maxmoney -1;
			DestroyPickup(pickupid);
			GivePlayerMoney(playerid, 1000);
			printf("ID picked up: %d",maxmoney);
			break;
		}


	}
	return 1;
}

Ich versuche gerade irgendwie hinzukriegen, dass der else Teil ausgefuehrt wird, wenn das aufgesammelte Pickup keine Pickupid aus ActorPickups, aber natuehrlich klappt das nicht verneunftig.

Wie kann ich realisieren, dass else erst ausgefuehrt wird, wenn die For schleife durch ist, und die Bedingung darin nicht erfuellt ist?

Mit der Pickup Array Sache habe ich irgendwie immernoch ein Problem: /

Hier weise ich dem Pickup die ID zu

for(new g=0;g<sizeof(GlobalActors);g++)
	{
		CreateGlobalActor(g+1,274,GlobalActors[g][0],GlobalActors[g][1],GlobalActors[g][2],GlobalActors[g][3],3.0,ActorPickups[g]);		
		SetActorInvulnerable(g+1, true);
	}

Dazugehoerige Funktion

stock CreateGlobalActor(actorid,modelid,Float:ax,Float:ay,Float:az,Float:angle,Float:distance,pickupid)
{
	actorid = CreateActor(modelid,ax,ay,az,angle);
	new Float:x, Float:y, Float:z;
	GetActorPos(actorid, x, y, z);
	GetXYInFrontOfActor(actorid, x, y, distance);
	pickupid = pickupid + 1000;
	pickupid = CreatePickup(1210,2,x,y,z,-1);
	SetActorInvulnerable(actorid, true);
	printf("Actor created, pickupid %d",pickupid);
	return pickupid;
}

printf gibt immer aus dass die Pickupids 1, 2,3,4,5 sind, bei einer sizeof(GlobalActors) von 5, egal was ich als pickupid in die Funktion gebe

Daher war auch der Teil mit OnPlayerPickUpPickup irgendwie nicht funktionsfaehig

for(new i;i<sizeof(ActorPickups);i++)
{
if(pickupid == ActorPickups[i])
		{
			ShowMenuForPlayer(shopmenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
}

Habe ich wieder einen Fehler drin?