Beiträge von Sub Royal

Sub Royal · 3. März 2018

Zitat von Marcel_Colbetti

Chillige Idee. Muss man auch mal drauf kommen.
Mir gefällt es kann man es testen?

Ja schreib mir ne PN dann zeig ichs dir

Also wenn jemand testen will, einfach ne PN schreiben, dann versuch ich paar zusammen zu trommeln

Update:

Code

# 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

Alles anzeigen

Rekursive Implementierung war nun erfolgreich!

Neuste Version verfuegbar im GitHub Repo:

https://github.com/Knogle/LastBedStanding

//edit: Thread wird nurnoch im englischen SA-MP Forum fortgesetzt.

Sub Royal · 10. Februar 2018

Gibt es noch SA:MP Gamer hier?

Sub Royal · 2. Juli 2017

Gute Idee, werde ich mal probieren

Sub Royal · 19. Juni 2017

Ich gruesse euch liebe Community,
Ich habe aktuell folgendes probiert:

Habe mir einen Multithreadtauglichen Mergesort Algorithmus gebaut, und einen normalen Heapsort Algorithmus.
Das Problem ist nun folgendes:

Ich erstelle bei beiden ein Random Array mit einer Groesse von z.B. 10000.
Ab dem Zeitpunkt wird die Zeit vom Sortiervorgang gemessen, sowohl bei Mergesort als auch Heapsort.
Sind beides unabhaengige ausfuehrbare Dateien.

Das Problem ist: Mergesort braucht trotz Multicore Optimierung 4 mal solange wie mein Heapsort Algorithmus.
Woran kann das liegen?

Einmal Mergesort

C

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>




#define MIN_LENGTH 4


int DEBUG;


typedef struct 
{
    int *array;
    int left;
    int right;
    int tid;
} thread_data_t;


int number_of_threads;
pthread_mutex_t lock_number_of_threads;


int my_comp(const void *larg, const void *rarg) 
{
    int l = *(int *)larg;
    int r = *(int *)rarg;
    if (l < r) 
	{
        return -1;
    } 
	else if (l == r) 
	{
        return 0;
    }
    return 1;
}


void merge(int *data, int left, int right, int tid) 
{
    if (DEBUG) 
	{
        printf("[%d] Merging %d to %d\n", tid, left, right);
    }
    int ctr = 0;
    int i = left;
    int mid = left + ((right - left) / 2);
    int j = mid + 1;
    int *c = (int *) malloc((right - left + 1) * sizeof(int));
    while (i <= mid && j <= right) 
	{
        if (data[i] <= data[j]) 
		{
            c[ctr++] =  data[i++];
        } 
		else 
		{
            c[ctr++] =  data[j++];
        }
    }
    if (i == mid + 1) 
	{
        while (j <= right) 
		{
            c[ctr++] = data[j++];
        }
    } 
	else 
	{
        while (i <= mid) 
		{
            c[ctr++] = data[i++];
        }
    }
    i = left;
    ctr = 0;
    while (i <= right) 
	{
        data[i++] = c[ctr++];
    }
    free(c);
    return;
}


void *merge_sort_threaded(void *arg) 
{
    thread_data_t *data = (thread_data_t *) arg;
    int l = data->left;
    int r = data->right;
    int t = data->tid;
    if (r - l + 1 <= MIN_LENGTH) 
	{
        if (DEBUG) 
		{
            printf("[%d] Calling qsort(%d, %d).\n", t, l, r);
        }
        qsort(data->array + l, r - l + 1, sizeof(int), my_comp);
    }
	else 
	{
        int m = l + ((r - l) / 2);
        thread_data_t data_0;
        data_0.left = l;
        data_0.right = m;
        data_0.array = data->array;
        pthread_mutex_lock(&lock_number_of_threads);
            data_0.tid = number_of_threads++;
        pthread_mutex_unlock(&lock_number_of_threads);
        pthread_t thread0;
        int rc = pthread_create(&thread0,
                                NULL,
                                merge_sort_threaded,
                                &data_0);
        int created_thread_0 = 1;
        if (rc) 
		{
            if (DEBUG) 
			{
                printf("[%d] Failed to create thread, calling qsort.", data_0.tid);
            }
            created_thread_0 = 0;
            qsort(data->array + l, m - l + 1, sizeof(int), my_comp);
        }
        thread_data_t data_1;
        data_1.left = m + 1;
        data_1.right = r;
        data_1.array = data->array;
        pthread_mutex_lock(&lock_number_of_threads);
            data_1.tid = number_of_threads++;
        pthread_mutex_unlock(&lock_number_of_threads);
        pthread_t thread1;
        rc = pthread_create(&thread1,
                            NULL,
                            merge_sort_threaded,
                            &data_1);
        int created_thread_1 = 1;
        if (rc) 
		{
            if (DEBUG) 
			{
                printf("[%d] Failed to create thread, calling qsort.", data_1.tid);
            }
            created_thread_1 = 0;
            qsort(data->array + m + 1, r - m, sizeof(int), my_comp);
        }
        if (created_thread_0) 
		{
            pthread_join(thread0, NULL);
        }
        if (created_thread_1) 
		{
            pthread_join(thread1, NULL);
        }
        merge(data->array, l, r, t);
    }
    pthread_exit(NULL);
    return NULL;
}


void merge_sort(int *array, int start, int finish) 
{
    thread_data_t data;
    data.array = array;
    data.left = start;
    data.right = finish;


    number_of_threads = 0;
    pthread_mutex_init(&lock_number_of_threads, NULL);
    data.tid = 0;
    pthread_t thread;
    int rc = pthread_create(&thread,
                            NULL,
                            merge_sort_threaded,
                            &data);
    if (rc) 
	{
        if (DEBUG) 
		{
            printf("[%d] Failed to create thread, calling qsort.",
                   data.tid);
        }
        qsort(array + start,
              finish - start + 1,
              sizeof(int),
              my_comp);
    }
    pthread_join(thread, NULL);
    return;
}




int main()
    {
        int size=0,loop,qrand;
        int *array;
        printf("Array-Groesse eingeben: ");
        scanf("%d", &size);
        array = (int *) malloc(size * sizeof(int));
        if(array != NULL)
        {
            printf("\nSpeicher ist reserviert\n");
            printf("\nFilling array.\n");
    	for(loop=0;loop<size;loop++)
    	{
                qrand=rand() %20;
                array[loop]=qrand;
                printf("%d",qrand);
    	}
        }
        else printf("\nKein freier Speicher vorhanden.\n");


	printf("\nMerge Sort..\n");
		clock_t t;
		t = clock();
          merge_sort(array, 0, size - 1);
        for(loop=0;loop<size;loop++)
        {
            printf("%d",array[loop]);
        }
	if((size * sizeof(int)) < 1000)
	{
        printf("\n %lu Bytes wurden freigegeben\n",(size * sizeof(int)));
	}
	else if((size *sizeof(int))>=1000)
	{
	printf("\n %lu Kilobytes wurden freigegeben\n",((size * sizeof(int))/1000));
	}
	else if((size * sizeof(int))>=1000*1000)
	{
	printf("\n %lu Megabytes wurden freigegeben\n", ((size * sizeof(int))/1000*1000));
	}
        free(array);
		pthread_mutex_destroy(&lock_number_of_threads);
	t = clock() - t;
	printf("Sorting took %f seconds to finish \n", time_taken);
        return 0;
    }

Alles anzeigen

Ist es eventuell falsch implementiert?

C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>


void quicksort(int *A, int len);




int max (int *a, int n, int i, int j, int k) 
{
    int m = i;
    if (j < n && a[j] > a[m]) {
        m = j;
    }
    if (k < n && a[k] > a[m]) {
        m = k;
    }
    return m;
}
void downheap (int *a, int n, int i) 
{
    while (1) {
        int j = max(a, n, i, 2 * i + 1, 2 * i + 2);
        if (j == i) {
            break;
        }
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
        i = j;
    }
}
void heapsort (int *a, int n) 
{
    int i;
    for (i = (n - 2) / 2; i >= 0; i--) {
        downheap(a, n, i);
    }
    for (i = 0; i < n; i++) {
        int t = a[n - i - 1];
        a[n - i - 1] = a[0];
        a[0] = t;
        downheap(a, n - i - 1, 0);
    }
}
void quicksort(int *A, int len)
{
  if (len < 2) return;
  int pivot = A[len / 2];
  int i, j;
  for (i = 0, j = len - 1; ; i++, j--)
  {
    while (A[i] < pivot) i++;
    while (A[j] > pivot) j--;
    if (i >= j) break;
    int temp = A[i];
    A[i]     = A[j];
    A[j]     = temp;
  }
  quicksort(A, i);
  quicksort(A + i, len - i);
}








    int main()
    {
        int size=0,loop,qrand;
        int *array;
        printf("Array-Groesse eingeben: ");
        scanf("%d", &size);
        // Allocate memory
        array = (int *) malloc(size * sizeof(int));
        if(array != NULL)
        {
            printf("\nSpeicher ist reserviert\n");
            printf("\nFilling array.\n");
    	for(loop=0;loop<size;loop++)
    	{
                qrand=rand() %20;
                array[loop]=qrand;
                printf("%d",qrand);
    	}
        }
        else printf("\nKein freier Speicher vorhanden.\n");


	printf("\nHeapsort..\n");
	clock_t t;
				t = clock();
        heapsort(array,size);
        for(loop=0;loop<size;loop++)
        {
            printf("%d",array[loop]);
        }
	if((size * sizeof(int)) < 1000)
	{
        printf("\n %lu Bytes wurden freigegeben\n",(size * sizeof(int)));
	}
	else if((size *sizeof(int))>=1000)
	{
	printf("\n %lu Kilobytes wurden freigegeben\n",((size * sizeof(int))/1000));
	}
	else if((size * sizeof(int))>=1000*1000)
	{
	printf("\n %lu Megabytes wurden freigegeben\n", ((size * sizeof(int))/1000*1000));
	}
        free(array);
	//Reallocate memory above	
		t = clock() - t;
	double time_taken = ((double)t)/CLOCKS_PER_SEC; // in seconds
	printf("Sorting took %f seconds to finish \n", time_taken);
        return 0;
    }

Alles anzeigen

Verfuegbar sind 24 Threads beim System

Sub Royal · 27. Mai 2017

Wie kann ich einen AudioStream abspielen den ich vom lokalen Server beziehe, also keine remote Adresse?

Wie muss da meine PlayAudioStreamForPlayer Zeile aussehen, wenn die entsprechende Audio Datei beispielsweise im gleichen Ordner liegt wie der Server?

Sub Royal · 4. Mai 2017

Vielen Dank!

Ich habe mir das mal angeschaut, bin aber nicht so ganz ueberzeugt von der performance weil irgendwie bei dem quickSort Algorithmus von Slice der Worst Case nicht ausgeschlossen wurde .
Habe deshalb versucht bei mir das Pivot Element aus dem Mittelwert von 2 Werten zu waehlen, um zu gewaehrleisten dass ich immer O(n log n) habe

Habe das ganze nun gebaut bekommen, jedoch noch 1 Problem:

Bekomme irgendwie nicht selten als WeaponInfo[pickupid][wModel] Nullen als Werte, eventuell durch meinen fehlerhaften Umgang mit random?

Weiterhin sind die WeaponPickups da, funktionieren auch, jedoch bekomme ich z.B. wenn ich eine Katana einsammle, eine M4
Wo muss ich da nach dem Problem suchen? Vielleicht beim Sortieren?

Bitte um Rat

OnPlayerPickUpPickUp und dazugehoerige Funktion

C

public OnPlayerPickUpDynamicPickup(playerid, pickupid)
{
	new index;
	switch(GetPickupType(pickupid,index))
	{
	case INVALID_PICKUP_TYPE:
		{
		}
	case MONEY_TYPE:
		{
			PickupCounter[MONEY_TYPE] -= 1;
			GivePlayerMoney(playerid, MoneyVal);
			MoneyPickups[index]=-1;
			quickSort(MoneyPickups,0,sizeof(MoneyPickups)-1);
			DestroyDynamicPickup(pickupid);
		}
	case ACTOR_TYPE:
		{
			ShowMenuForPlayer(shopmenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	case INFO_TYPE:
		{
			ShowMenuForPlayer(infomenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	case WEAPONTYPE_M4..WEAPONTYPE_FIRE_EXTINGUSHER:
		{
			printf("RECEIVED WEAPON");
			printf("WEAPON: %d",WeaponInfo[pickupid][wModel]);
			printf("WEAPON: Pickupid: %d WeaponID %d Ammo: %d",pickupid,WeaponInfo[pickupid][wModel],WeaponInfo[pickupid][wAmmo]);
			PickupCounter[GENERIC_WEAPON] -= 1;
			new weaponname;
			switch(WeaponInfo[pickupid][wModel])//Gibt nur die ModelID aus
			{
				case 356:
				weaponname = WEAPON_M4;
				case 355:
				weaponname = WEAPON_AK47;
				case 358:
				weaponname = WEAPON_SNIPER;
				case 357:
				weaponname = WEAPON_RIFLE;
				case 348:
				weaponname = WEAPON_DEAGLE;
				case 346:
				weaponname = WEAPON_COLT45;
				case 347:
				weaponname = WEAPON_SILENCED;
				case 351:
				weaponname = WEAPON_SHOTGSPA;
				case 349:
				weaponname = WEAPON_SHOTGUN;
				case 350:
				weaponname = WEAPON_SAWEDOFF;
				case 352:
				weaponname = WEAPON_UZI;
				case 372:
				weaponname = WEAPON_TEC9;
				case 353:
				weaponname = WEAPON_MP5;
				case 342:
				weaponname = WEAPON_GRENADE;
				case 344:
				weaponname = WEAPON_MOLTOV;
				case 359:
				weaponname = WEAPON_ROCKETLAUNCHER;
				case 337:
				weaponname = WEAPON_SHOVEL;
				case 341:
				weaponname = WEAPON_CHAINSAW;
				case 339:
				weaponname = WEAPON_KATANA;
				case 336:
				weaponname = WEAPON_BAT;
				case 325:
				weaponname = WEAPON_FLOWER;
				case 326:
				weaponname = WEAPON_CANE;
				case 371:
				weaponname = WEAPON_PARACHUTE;
				case 366:
				weaponname = WEAPON_FIREEXTINGUISHER;		
			}
			GivePlayerWeapon(playerid, weaponname, WeaponInfo[pickupid][wAmmo]);
			WeaponPickups[index] = -1;
			HeapSort(WeaponPickups);
			quickSort2(WeaponInfo,0,0,sizeof(WeaponInfo)-1);
			DestroyDynamicPickup(pickupid);
		}
	}
	return 1;
}
stock GetPickupType(pickupid, &index)
{
	new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
	if(mres > -1 && MoneyPickups[mres] == pickupid) return index=mres,MONEY_TYPE;
	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
	if(ares > -1 && ActorPickups[ares] == pickupid) return index=ares,ACTOR_TYPE;
	new ires = binarysearch(InfoPickups,pickupid,0,sizeof(InfoPickups)-1);
	if(ires > -1 && InfoPickups[ires] == pickupid) return index=ires,INFO_TYPE;
	new dres = binarysearch(WeaponPickups,pickupid,0,sizeof(WeaponPickups)-1);
	if(dres > -1 && WeaponPickups[dres] == pickupid) 
	{
		switch(WeaponInfo[pickupid][wModel])
		{
			case	356:
			return index=dres,WEAPONTYPE_M4;
			case	355:
			return index=dres,WEAPONTYPE_AK47;
			case	358:
			return index=dres,WEAPONTYPE_SNIPERRIFLE;
			case	357:
			return index=dres,WEAPONTYPE_CUNTGUN;
			case	348:
			return index=dres,WEAPONTYPE_DESERT_EAGLE;
			case	346:
			return index=dres,WEAPONTYPE_PISTOL_9MM;
			case	347:
			return index=dres,WEAPONTYPE_SILENCED_9MM;
			case	351:
			return index=dres,WEAPONTYPE_SPAS12;
			case	349:
			return index=dres,WEAPONTYPE_SHOTGUN;
			case	350:
			return index=dres,WEAPONTYPE_SAWN_OFF;
			case	352:
			return index=dres,WEAPONTYPE_MICRO_UZI;
			case	372:
			return index=dres,WEAPONTYPE_TEC9;
			case	353:
			return index=dres,WEAPONTYPE_MP5;
			case	342:
			return index=dres,WEAPONTYPE_GRENADE;
			case	344:
			return index=dres,WEAPONTYPE_MOLOTOW;
			case	359:
			return index=dres,WEAPONTYPE_RPG;
			case	337:
			return index=dres,WEAPONTYPE_SHOVEL;
			case	341:
			return index=dres,WEAPONTYPE_CHAINSAW;
			case	339:
			return index=dres,WEAPONTYPE_KATANA;
			case	336:
			return index=dres,WEAPONTYPE_BASEBALL;
			case	325:
			return index=dres,WEAPONTYPE_FLOWER;
			case	326:
			return index=dres,WEAPONTYPE_CANE;
			case	371:
			return index=dres,WEAPONTYPE_PARACHUTE;
			case	366:
			return index=dres,WEAPONTYPE_FIRE_EXTINGUSHER;
			case 0:
			return INVALID_PICKUP_TYPE;
		}
	}	
	return INVALID_PICKUP_TYPE;
}

Alles anzeigen

C

stock quickSort2(array[][],idx, left, right)
{
	new
	tempLeft = left,
	tempRight = right,
	pivot = array[(left + right) / 2][idx],
	tempVar
	;
	while(tempLeft <= tempRight)
	{
		while(array[tempLeft][idx] < pivot) tempLeft++;
		while(array[tempRight][idx] > pivot) tempRight--;


		if(tempLeft <= tempRight)
		{
			tempVar = array[tempLeft][idx], array[tempLeft][idx] = array[tempRight][idx], array[tempRight][idx] = tempVar;
			tempLeft++, tempRight--;
		}
	}
	if(left < tempRight) quickSort(array[idx], left, tempRight);
	if(tempLeft < right) quickSort(array[idx], tempLeft, right);
}

Alles anzeigen

Jede 20ms wird eins generiert

C

public MONEY_MAIN()//MAIN
{
	{
		new Float:Z;
		new Float:rx1=((frandom((floatabs(MAP_WORLDBOUNDS[0][0]-MAP_WORLDBOUNDS[0][1])))+MAP_WORLDBOUNDS[0][1]));
		new Float:ry2=((frandom((floatabs(MAP_WORLDBOUNDS[0][2]-MAP_WORLDBOUNDS[0][3])))+MAP_WORLDBOUNDS[0][3]));
		MapAndreas_FindZ_For2DCoord(rx1,ry2,Z);
		GenerateRandomPickup(1212,19,rx1,rx1+1,ry2,ry2+1,Z,Z+0.5,0);
	}


	{
		new Float:Z;
		new Float:rx1=((frandom((floatabs(MAP_WORLDBOUNDS[0][0]-MAP_WORLDBOUNDS[0][1])))+MAP_WORLDBOUNDS[0][1]));
		new Float:ry2=((frandom((floatabs(MAP_WORLDBOUNDS[0][2]-MAP_WORLDBOUNDS[0][3])))+MAP_WORLDBOUNDS[0][3]));
		MapAndreas_FindZ_For2DCoord(rx1,ry2,Z);
		new randWeap = random(VAL_PICKUPTYPES-INFO_TYPE)+INFO_TYPE+1;
		GenerateRandomWeaponPickup(randWeap,19,rx1,rx1+1,ry2,ry2+1,Z,Z+0.5,0);
	}


}

Alles anzeigen

Die Funktion dazu

C

stock GenerateRandomWeaponPickup(weapon,type,Float:x_max,Float:x_min,Float:y_max,Float:y_min,Float:z_max,Float:z_min,virtualworld)
{
	if(PickupCounter[GENERIC_WEAPON] <= sizeof(WeaponPickups))
	{
		new Float:rx1=((frandom((floatabs(x_max-x_min)))+x_min));
		new Float:ry2=((frandom((floatabs(y_max-y_min)))+y_min));
		new Float:rz3=((frandom((floatabs(z_max-z_min)))+z_min));
		new modelid;
		switch(weapon)
		{
			case	WEAPONTYPE_M4:
			modelid = 356;
			case	WEAPONTYPE_AK47:
			modelid = 355;
			case	WEAPONTYPE_SNIPERRIFLE:
			modelid = 358;
			case	WEAPONTYPE_CUNTGUN:
			modelid = 357;
			case	WEAPONTYPE_DESERT_EAGLE:
			modelid = 348;
			case	WEAPONTYPE_PISTOL_9MM:
			modelid = 346;
			case	WEAPONTYPE_SILENCED_9MM:
			modelid = 347;
			case	WEAPONTYPE_SPAS12:
			modelid = 351;
			case	WEAPONTYPE_SHOTGUN:
			modelid = 349;
			case	WEAPONTYPE_SAWN_OFF:
			modelid = 350;
			case	WEAPONTYPE_MICRO_UZI:
			modelid = 352;
			case	WEAPONTYPE_TEC9:
			modelid = 372;
			case	WEAPONTYPE_MP5:
			modelid = 353;
			case	WEAPONTYPE_GRENADE:
			modelid = 342;
			case	WEAPONTYPE_MOLOTOW:
			modelid = 344;
			case	WEAPONTYPE_RPG:
			modelid = 359;
			case	WEAPONTYPE_SHOVEL:
			modelid = 337;
			case	WEAPONTYPE_CHAINSAW:
			modelid = 341;
			case	WEAPONTYPE_KATANA:
			modelid = 339;
			case	WEAPONTYPE_BASEBALL:
			modelid = 336;
			case	WEAPONTYPE_FLOWER:
			modelid = 325;
			case	WEAPONTYPE_CANE:
			modelid = 326;
			case	WEAPONTYPE_PARACHUTE:
			modelid = 371;
			case	WEAPONTYPE_FIRE_EXTINGUSHER:
			modelid = 366;
		}
		PickupCounter[GENERIC_WEAPON] = PickupCounter[GENERIC_WEAPON] +1;
		WeaponPickups[PickupCounter[GENERIC_WEAPON]] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		WeaponInfo[PickupCounter[GENERIC_WEAPON]][wModel] = modelid;
		WeaponInfo[PickupCounter[GENERIC_WEAPON]][wAmmo] = random(1000)+10;
		HeapSort(WeaponPickups);	
		quickSort2(WeaponInfo,0,0,sizeof(WeaponInfo)-1);
	}
}

Alles anzeigen

Die dazugehoerigen enums

C

enum 
{
	INVALID_PICKUP_TYPE,
	MONEY_TYPE,
	ACTOR_TYPE,
	INFO_TYPE,
	GENERIC_WEAPON,
	WEAPONTYPE_M4,
	WEAPONTYPE_AK47,
	WEAPONTYPE_SNIPERRIFLE,
	WEAPONTYPE_CUNTGUN,
	WEAPONTYPE_DESERT_EAGLE,
	WEAPONTYPE_PISTOL_9MM,
	WEAPONTYPE_SILENCED_9MM,
	WEAPONTYPE_SPAS12,
	WEAPONTYPE_SHOTGUN,
	WEAPONTYPE_SAWN_OFF,
	WEAPONTYPE_MICRO_UZI,
	WEAPONTYPE_TEC9,
	WEAPONTYPE_MP5,
	WEAPONTYPE_GRENADE,
	WEAPONTYPE_MOLOTOW,
	WEAPONTYPE_RPG,
	WEAPONTYPE_SHOVEL,
	WEAPONTYPE_CHAINSAW,
	WEAPONTYPE_KATANA,
	WEAPONTYPE_BASEBALL,
	WEAPONTYPE_FLOWER,
	WEAPONTYPE_CANE,
	WEAPONTYPE_PARACHUTE,
	WEAPONTYPE_FIRE_EXTINGUSHER,
	VAL_PICKUPTYPES
};


enum
{
	wModel,
	wAmmo,	
	VAL_INFO
};

Alles anzeigen

Die Arrays

C

new ActorPickups[NUM_ACTORS];
#if !defined NUM_WEAPONS
#error NUM_WEAPONS must be defined!!!
#endif
new WeaponPickups[NUM_WEAPONS];
new WeaponInfo[NUM_WEAPONS][VAL_INFO];
new InfoPickups[sizeof(PlayerInfoPickups)];
new MoneyPickups[MAX_PICKUPS-sizeof(ActorPickups)-sizeof(InfoPickups)-NUM_WEAPONS-1];

Die Zuweisung der Munition geht auch bisher gut.
Jedoch ist halt die Modelid des erstellen Pickups, nicht die Modelid des Pickups bei GetPickUpType, als wuerde da irgendwas durcheinander kommen

Habe daher ueberlegt ob ich hier

Unter OnPlayerPickUpPickup

switch(WeaponInfo[pickupid][wModel])
{

statt der pickupid den Index nehmen muss den ich aus der Binaersuche rauskriege

Sub Royal · 4. Mai 2017

Zitat von Jeffry

Nein, das ist falsch so.
Du musst die pickupid als ersten Index nehmen, nur diese ist eindeutig. Außerdem hast du einen sofortigen Zugriff, ohne Schleife.

PickupCounter[weapontype] kann ja für jeden "weapontype" die gleichen Werte wieder annehmen, somit besteht keine Eindeutigkeit.

new pickupid = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);WeaponInfo[pickupid][wModel] = modelid;WeaponInfo[pickupid][wAmmo] = random(1000)+10;

Beim Pickup:
if(WeaponInfo[pickupid][wModel] != 0) GivePlayerWeapon(playerid, WeaponInfo[pickupid][wModel], WeaponInfo[pickupid][wAmmo]);

Mehr ist es nicht.

Alles anzeigen

Danke Jeffry Ich glaube ich bin zu kompliziert.
Musste das aufgrund meines komplexen Pickup Systems noch etwas umbauen.

Das Problem mit der Eindeutigkeit habe ich auch erkannt.

So sieht mein Pickup Teil jetzt aus

C

public OnPlayerPickUpDynamicPickup(playerid, pickupid)
{

	new index;
	switch(GetPickupType(pickupid,index))
	{
	case INVALID_PICKUP_TYPE:
		{
		}
	case MONEY_TYPE:
		{
			PickupCounter[MONEY_TYPE] -= 1;
			GivePlayerMoney(playerid, MoneyVal);
			MoneyPickups[index]=-1;
			quickSort(MoneyPickups,0,sizeof(MoneyPickups)-1);
			DestroyDynamicPickup(pickupid);
		}
	case ACTOR_TYPE:
		{
			ShowMenuForPlayer(shopmenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	case INFO_TYPE:
		{
			ShowMenuForPlayer(infomenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	case WEAPONTYPE_M4..WEAPONTYPE_FIRE_EXTINGUSHER:
		{

			PickupCounter[GENERIC_WEAPON] -= 1;
			new weaponname;
			switch(WeaponInfo[pickupid][wModel])//Gibt nur die ModelID aus
			{

				case 356:
				weaponname = WEAPON_M4;
				case 355:
				weaponname = WEAPON_AK47;
				case 358:
				weaponname = WEAPON_SNIPER;
				case 357:
				weaponname = WEAPON_RIFLE;
				case 348:
				weaponname = WEAPON_DEAGLE;
				case 346:
				weaponname = WEAPON_COLT45;
				case 347:
				weaponname = WEAPON_SILENCED;
				case 351:
				weaponname = WEAPON_SHOTGSPA;
				case 349:
				weaponname = WEAPON_SHOTGUN;
				case 350:
				weaponname = WEAPON_SAWEDOFF;
				case 352:
				weaponname = WEAPON_UZI;
				case 372:
				weaponname = WEAPON_TEC9;
				case 353:
				weaponname = WEAPON_MP5;
				case 342:
				weaponname = WEAPON_GRENADE;
				case 344:
				weaponname = WEAPON_MOLTOV;
				case 359:
				weaponname = WEAPON_ROCKETLAUNCHER;
				case 337:
				weaponname = WEAPON_SHOVEL;
				case 341:
				weaponname = WEAPON_CHAINSAW;
				case 339:
				weaponname = WEAPON_KATANA;
				case 336:
				weaponname = WEAPON_BAT;
				case 325:
				weaponname = WEAPON_FLOWER;
				case 326:
				weaponname = WEAPON_CANE;
				case 371:
				weaponname = WEAPON_PARACHUTE;
				case 366:
				weaponname = WEAPON_FIREEXTINGUISHER;		
			}
			GivePlayerWeapon(playerid, weaponname, WeaponInfo[pickupid][wAmmo]);
			WeaponPickups[index] = -1;
			HeapSort(WeaponPickups);
			DestroyDynamicPickup(pickupid);

		}


	}
	return 1;
}




stock GetPlayerNameID(playerid)
{
	new name[MAX_PLAYER_NAME+24];
	GetPlayerName(playerid,name,sizeof(name));
	format(name,sizeof(name),"{%06x}%s (%d){FFFFFF}", GetPlayerColor(playerid) >>> 8,name,playerid);
	return name;
}


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


		switch(WeaponInfo[pickupid][wModel])//Gibt nur die ModelID aus
		{

			case	356:
			return index=dres,WEAPONTYPE_M4;
			case	355:
			return index=dres,WEAPONTYPE_AK47;
			case	358:
			return index=dres,WEAPONTYPE_SNIPERRIFLE;
			case	357:
			return index=dres,WEAPONTYPE_CUNTGUN;
			case	348:
			return index=dres,WEAPONTYPE_DESERT_EAGLE;
			case	346:
			return index=dres,WEAPONTYPE_PISTOL_9MM;
			case	347:
			return index=dres,WEAPONTYPE_SILENCED_9MM;
			case	351:
			return index=dres,WEAPONTYPE_SPAS12;
			case	349:
			return index=dres,WEAPONTYPE_SHOTGUN;
			case	350:
			return index=dres,WEAPONTYPE_SAWN_OFF;
			case	352:
			return index=dres,WEAPONTYPE_MICRO_UZI;
			case	372:
			return index=dres,WEAPONTYPE_TEC9;
			case	353:
			return index=dres,WEAPONTYPE_MP5;
			case	342:
			return index=dres,WEAPONTYPE_GRENADE;
			case	344:
			return index=dres,WEAPONTYPE_MOLOTOW;
			case	359:
			return index=dres,WEAPONTYPE_RPG;
			case	337:
			return index=dres,WEAPONTYPE_SHOVEL;
			case	341:
			return index=dres,WEAPONTYPE_CHAINSAW;
			case	339:
			return index=dres,WEAPONTYPE_KATANA;
			case	336:
			return index=dres,WEAPONTYPE_BASEBALL;
			case	325:
			return index=dres,WEAPONTYPE_FLOWER;
			case	326:
			return index=dres,WEAPONTYPE_CANE;
			case	371:
			return index=dres,WEAPONTYPE_PARACHUTE;
			case	366:
			return index=dres,WEAPONTYPE_FIRE_EXTINGUSHER;
		case 0:
			return INVALID_PICKUP_TYPE;

		}


	}	



	return INVALID_PICKUP_TYPE;
}

Alles anzeigen

Wobei es hier vielleicht sinvoll waere, die ganzen Faelle nicht 1000 mal hinzuschreiben, sondern fuer die Waffen vielleicht case 5..20: bla bla weil die Waffentypen in einem enum definiert sind

C

stock GenerateRandomWeaponPickup(weapon,type,Float:x_max,Float:x_min,Float:y_max,Float:y_min,Float:z_max,Float:z_min,virtualworld)
{
	if(PickupCounter[GENERIC_WEAPON] <= sizeof(WeaponPickups))
	{
		new Float:rx1=((frandom((floatabs(x_max-x_min)))+x_min));
		new Float:ry2=((frandom((floatabs(y_max-y_min)))+y_min));
		new Float:rz3=((frandom((floatabs(z_max-z_min)))+z_min));
		PickupCounter[GENERIC_WEAPON] = PickupCounter[GENERIC_WEAPON] +1;
		new modelid;
		switch(weapon)
		{
			case	WEAPONTYPE_M4:
			modelid = 358;
			case	WEAPONTYPE_AK47:
			modelid = 355;
			case	WEAPONTYPE_SNIPERRIFLE:
			modelid = 358;
			case	WEAPONTYPE_CUNTGUN:
			modelid = 357;
			case	WEAPONTYPE_DESERT_EAGLE:
			modelid = 348;
			case	WEAPONTYPE_PISTOL_9MM:
			modelid = 346;
			case	WEAPONTYPE_SILENCED_9MM:
			modelid = 347;
			case	WEAPONTYPE_SPAS12:
			modelid = 351;
			case	WEAPONTYPE_SHOTGUN:
			modelid = 349;
			case	WEAPONTYPE_SAWN_OFF:
			modelid = 350;
			case	WEAPONTYPE_MICRO_UZI:
			modelid = 352;
			case	WEAPONTYPE_TEC9:
			modelid = 372;
			case	WEAPONTYPE_MP5:
			modelid = 353;
			case	WEAPONTYPE_GRENADE:
			modelid = 342;
			case	WEAPONTYPE_MOLOTOW:
			modelid = 344;
			case	WEAPONTYPE_RPG:
			modelid = 359;
			case	WEAPONTYPE_SHOVEL:
			modelid = 337;
			case	WEAPONTYPE_CHAINSAW:
			modelid = 341;
			case	WEAPONTYPE_KATANA:
			modelid = 339;
			case	WEAPONTYPE_BASEBALL:
			modelid = 336;
			case	WEAPONTYPE_FLOWER:
			modelid = 325;
			case	WEAPONTYPE_CANE:
			modelid = 326;
			case	WEAPONTYPE_PARACHUTE:
			modelid = 371;
			case	WEAPONTYPE_FIRE_EXTINGUSHER:
			modelid = 366;
		}
		WeaponPickups[PickupCounter[GENERIC_WEAPON]] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		WeaponInfo[WeaponPickups[PickupCounter[GENERIC_WEAPON]]][wModel] = modelid;
		WeaponInfo[WeaponPickups[PickupCounter[GENERIC_WEAPON]]][wAmmo] = random(1000)+10;
		HeapSort(WeaponPickups);
	}
}

Alles anzeigen

Werde das erstmal so probieren PickupCounter[GENERIC_WEAPON] ist der Zaehler fuer die Pickups

C

stock GenerateRandomPickup(modelid,type,Float:x_max,Float:x_min,Float:y_max,Float:y_min,Float:z_max,Float:z_min,virtualworld)
{
	if(PickupCounter[MONEY_TYPE] <= sizeof(MoneyPickups))
	{
		moneyval= moneyval+1000;
		new Float:rx1=((frandom((floatabs(x_max-x_min)))+x_min));
		new Float:ry2=((frandom((floatabs(y_max-y_min)))+y_min));
		new Float:rz3=((frandom((floatabs(z_max-z_min)))+z_min));
		PickupCounter[MONEY_TYPE] = PickupCounter[MONEY_TYPE] +1;
		MoneyPickups[PickupCounter[MONEY_TYPE]] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		HeapSort(MoneyPickups);
	}


}

Alles anzeigen

C

public MONEY_MAIN()//MAIN
{
	{
		new Float:Z;
		new Float:rx1=((frandom((floatabs(MAP_WORLDBOUNDS[0][0]-MAP_WORLDBOUNDS[0][1])))+MAP_WORLDBOUNDS[0][1]));
		new Float:ry2=((frandom((floatabs(MAP_WORLDBOUNDS[0][2]-MAP_WORLDBOUNDS[0][3])))+MAP_WORLDBOUNDS[0][3]));
		MapAndreas_FindZ_For2DCoord(rx1,ry2,Z);
		GenerateRandomPickup(1212,19,rx1,rx1+1,ry2,ry2+1,Z,Z+0.5,0);
	}


	{
		new Float:Z;
		new Float:rx1=((frandom((floatabs(MAP_WORLDBOUNDS[0][0]-MAP_WORLDBOUNDS[0][1])))+MAP_WORLDBOUNDS[0][1]));
		new Float:ry2=((frandom((floatabs(MAP_WORLDBOUNDS[0][2]-MAP_WORLDBOUNDS[0][3])))+MAP_WORLDBOUNDS[0][3]));
		MapAndreas_FindZ_For2DCoord(rx1,ry2,Z);
		new randWeap = random(VAL_PICKUPTYPES-INFO_TYPE)+INFO_TYPE+1;
		GenerateRandomWeaponPickup(randWeap,19,rx1,rx1+1,ry2,ry2+1,Z,Z+0.5,0);
	}


}

Alles anzeigen

Hat jemand Tipps fuer das umbauen der HeapSort Funktion damit ich sie mit multidimensionalen arrays nutzen kann ?:D

C

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;
	}
}


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

Alles anzeigen

Sub Royal · 3. Mai 2017

Vielen Dank^^ Das Problem beruht bei mir scheinbar auf dem falschen Verstaendnis von Arrays
Habe mir das bisher immer wie ne Matrix vorgestellt

Habe es dank des Beispiels geschafft

C

WeaponPickups[PickupCounter[weapontype]] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		WeaponInfo[WeaponPickups[PickupCounter[weapontype]]][wModel] = modelid;
		WeaponInfo[WeaponPickups[PickupCounter[weapontype]]][wAmmo] = random(1000)+10;

Sub Royal · 3. Mai 2017

1000 habe ich auch mal probiert, mag er leider auch nicht

Scheinbar bleibt dann nur der Weg ueber 2 separate Arrays was auch wieder doof ist

1 fuer Pickup ID und 1 fuer Waffen ID und die Munition dazu

Habe eventuell noch die Idee ein 2D Array zu machen, und WaffenID und Munition in der 2. Dimension als float zu speichern , WaffenID,Munition, und dann durch shiften beides zu trennen, und die Pickupid in der ersten Dimension in einen Float zu konvertieren, und beim Auslesen wieder in einen Int

Wuerde die gerne wie folgt erzeugen

C

stock GenerateRandomWeaponPickup(weapontype,ammo,type,Float:x_max,Float:x_min,Float:y_max,Float:y_min,Float:z_max,Float:z_min,virtualworld)
{
	if(PickupCounter[weapontype] <= sizeof(WeaponPickups))
	{
		new Float:rx1=((frandom((floatabs(x_max-x_min)))+x_min));
		new Float:ry2=((frandom((floatabs(y_max-y_min)))+y_min));
		new Float:rz3=((frandom((floatabs(z_max-z_min)))+z_min));
		PickupCounter[weapontype] = PickupCounter[weapontype] +1;
		new modelid;
		switch(weapontype)
		{
			case	WEAPONTYPE_M4:
			modelid = 358;
			case	WEAPONTYPE_AK47:
			modelid = 355;
			case	WEAPONTYPE_SNIPERRIFLE:
			modelid = 358;
			case	WEAPONTYPE_CUNTGUN:
			modelid = 357;
			case	WEAPONTYPE_DESERT_EAGLE:
			modelid = 348;
			case	WEAPONTYPE_PISTOL_9MM:
			modelid = 346;
			case	WEAPONTYPE_SILENCED_9MM:
			modelid = 347;
			case	WEAPONTYPE_SPAS12:
			modelid = 351;
			case	WEAPONTYPE_SHOTGUN:
			modelid = 349;
			case	WEAPONTYPE_SAWN_OFF:
			modelid = 350;
			case	WEAPONTYPE_MICRO_UZI:
			modelid = 352;
			case	WEAPONTYPE_TEC9:
			modelid = 372;
			case	WEAPONTYPE_MP5:
			modelid = 353;
			case	WEAPONTYPE_GRENADE:
			modelid = 342;
			case	WEAPONTYPE_MOLOTOW:
			modelid = 344;
			case	WEAPONTYPE_RPG:
			modelid = 359;
			case	WEAPONTYPE_SHOVEL:
			modelid = 337;
			case	WEAPONTYPE_CHAINSAW:
			modelid = 341;
			case	WEAPONTYPE_KATANA:
			modelid = 339;
			case	WEAPONTYPE_BASEBALL:
			modelid = 336;
			case	WEAPONTYPE_FLOWER:
			modelid = 325;
			case	WEAPONTYPE_CANE:
			modelid = 326;
			case	WEAPONTYPE_PARACHUTE:
			modelid = 371;
			case	WEAPONTYPE_FIRE_EXTINGUSHER:
			modelid = 366;
		}
		WeaponPickups[PickupCounter[weapontype]][modelid][ammo] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		HeapSort(WeaponPickups);
	}
}

Alles anzeigen

Der Haken ist jedoch dass ich dann ein fettes Array brauche, am besten von der Groesse Pickups[MAX_PICKUPS][MAX_PICKUPS][MAX_PICKUPS], oder zumindest WeaponPickups[NUM_WEAPONS][NUM_WEAPONS][NUM_WEAPONS] wobei NUM_WEAPONS irgendwie bei 1000-5000 liegt

Ich koennte natuehrlich die Munition dann festlegen wenn der Spieler das Pickup einsammelt, aber dann spare ich gerade mal eine Dimension ein, und bin immernoch bei 2

Sub Royal · 3. Mai 2017

Warum bringt das hier den Compiler zu crashen?

C

new ActorPickups[NUM_ACTORS];
#if !defined NUM_WEAPONS
#error NUM_WEAPONS must be defined!!!
#endif
new GeneralPickupInfo[MAX_PICKUPS][MAX_PICKUPS][MAX_PICKUPS];    
new InfoPickups[sizeof(PlayerInfoPickups)];
new MoneyPickups[MAX_PICKUPS-sizeof(ActorPickups)-sizeof(InfoPickups)-sizeof(GeneralPickupInfo)-1];

MAX_PICKUPS ist auf 20000

Sub Royal · 1. Mai 2017

Moin ein grosses Problem^^

Habe mein Pickupsystem

Folgende Pickuptypen definiert

C

enum 
{
	INVALID_PICKUP_TYPE,
	MONEY_TYPE,
	ACTOR_TYPE,
	INFO_TYPE,
	WEAPONTYPE_M4,
	WEAPONTYPE_AK47,
	WEAPONTYPE_SNIPERRIFLE,
	WEAPONTYPE_CUNTGUN,
	WEAPONTYPE_DESERT_EAGLE,
	WEAPONTYPE_PISTOL_9MM,
	WEAPONTYPE_SILENCED_9MM,
	WEAPONTYPE_SPAS12,
	WEAPONTYPE_SHOTGUN,
	WEAPONTYPE_SAWN_OFF,
	WEAPONTYPE_MICRO_UZI,
	WEAPONTYPE_TEC9,
	WEAPONTYPE_MP5,
	WEAPONTYPE_GRENADE,
	WEAPONTYPE_MOLOTOW,
	WEAPONTYPE_RPG,
	WEAPONTYPE_SHOVEL,
	WEAPONTYPE_CHAINSAW,
	WEAPONTYPE_KATANA,
	WEAPONTYPE_BASEBALL,
	WEAPONTYPE_FLOWER,
	WEAPONTYPE_CANE,
	WEAPONTYPE_PARACHUTE,
	WEAPONTYPE_FIRE_EXTINGUSHER,
	VAL_PICKUPTYPES
};

Alles anzeigen

C

#define NUM_ACTORS 200
#define NUM_WEAPONS 5000


new ActorPickups[NUM_ACTORS];
new WeaponPickups[NUM_WEAPONS];
new InfoPickups[sizeof(PlayerInfoPickups)];
new MoneyPickups[MAX_PICKUPS-sizeof(ActorPickups)-sizeof(InfoPickups)-sizeof(WeaponPickups)-1];

1 Funktion um Random Weapon Pickups zu erstellen, und eine um Random Geldpickups zu erstellen ( letzteres funktioniert aktuell problemlos)

C

stock GenerateRandomWeaponPickup(weapontype,type,Float:x_max,Float:x_min,Float:y_max,Float:y_min,Float:z_max,Float:z_min,virtualworld)
{
	if(PickupCounter[weapontype] <= sizeof(WeaponPickups))
	{
		new Float:rx1=((frandom((floatabs(x_max-x_min)))+x_min));
		new Float:ry2=((frandom((floatabs(y_max-y_min)))+y_min));
		new Float:rz3=((frandom((floatabs(z_max-z_min)))+z_min));
		PickupCounter[weapontype] = PickupCounter[weapontype] +1;
		new modelid;
		switch(weapontype)
		{
			case	WEAPONTYPE_M4:
			modelid = 358;
			case	WEAPONTYPE_AK47:
			modelid = 355;
			case	WEAPONTYPE_SNIPERRIFLE:
			modelid = 358;
			case	WEAPONTYPE_CUNTGUN:
			modelid = 357;
			case	WEAPONTYPE_DESERT_EAGLE:
			modelid = 348;
			case	WEAPONTYPE_PISTOL_9MM:
			modelid = 346;
			case	WEAPONTYPE_SILENCED_9MM:
			modelid = 347;
			case	WEAPONTYPE_SPAS12:
			modelid = 351;
			case	WEAPONTYPE_SHOTGUN:
			modelid = 349;
			case	WEAPONTYPE_SAWN_OFF:
			modelid = 350;
			case	WEAPONTYPE_MICRO_UZI:
			modelid = 352;
			case	WEAPONTYPE_TEC9:
			modelid = 372;
			case	WEAPONTYPE_MP5:
			modelid = 353;
			case	WEAPONTYPE_GRENADE:
			modelid = 342;
			case	WEAPONTYPE_MOLOTOW:
			modelid = 344;
			case	WEAPONTYPE_RPG:
			modelid = 359;
			case	WEAPONTYPE_SHOVEL:
			modelid = 337;
			case	WEAPONTYPE_CHAINSAW:
			modelid = 341;
			case	WEAPONTYPE_KATANA:
			modelid = 339;
			case	WEAPONTYPE_BASEBALL:
			modelid = 336;
			case	WEAPONTYPE_FLOWER:
			modelid = 325;
			case	WEAPONTYPE_CANE:
			modelid = 326;
			case	WEAPONTYPE_PARACHUTE:
			modelid = 371;
			case	WEAPONTYPE_FIRE_EXTINGUSHER:
			modelid = 366;
		}
		WeaponPickups[PickupCounter[weapontype]] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		HeapSort(WeaponPickups);
	}
}
stock GenerateRandomPickup(modelid,type,Float:x_max,Float:x_min,Float:y_max,Float:y_min,Float:z_max,Float:z_min,virtualworld)
{
	if(PickupCounter[MONEY_TYPE] <= sizeof(MoneyPickups))
	{
		moneyval= moneyval+1000;
		new Float:rx1=((frandom((floatabs(x_max-x_min)))+x_min));
		new Float:ry2=((frandom((floatabs(y_max-y_min)))+y_min));
		new Float:rz3=((frandom((floatabs(z_max-z_min)))+z_min));
		PickupCounter[MONEY_TYPE] = PickupCounter[MONEY_TYPE] +1;
		MoneyPickups[PickupCounter[MONEY_TYPE]] = CreateDynamicPickup(modelid,type,rx1,ry2,rz3,virtualworld);
		HeapSort(MoneyPickups);
	}


}

Alles anzeigen

Hier wird jede 20ms ein Pickup generiert von beiden Typen, eine Random Waffe.

C

public MONEY_MAIN()//MAIN
{
	{
		new Float:Z;
		new Float:rx1=((frandom((floatabs(MAP_WORLDBOUNDS[0][0]-MAP_WORLDBOUNDS[0][1])))+MAP_WORLDBOUNDS[0][1]));
		new Float:ry2=((frandom((floatabs(MAP_WORLDBOUNDS[0][2]-MAP_WORLDBOUNDS[0][3])))+MAP_WORLDBOUNDS[0][3]));
		MapAndreas_FindZ_For2DCoord(rx1,ry2,Z);
		GenerateRandomPickup(1212,19,rx1,rx1+1,ry2,ry2+1,Z,Z+0.5,0);
	}


	{
		new Float:Z;
		new Float:rx1=((frandom((floatabs(MAP_WORLDBOUNDS[0][0]-MAP_WORLDBOUNDS[0][1])))+MAP_WORLDBOUNDS[0][1]));
		new Float:ry2=((frandom((floatabs(MAP_WORLDBOUNDS[0][2]-MAP_WORLDBOUNDS[0][3])))+MAP_WORLDBOUNDS[0][3]));
		MapAndreas_FindZ_For2DCoord(rx1,ry2,Z);
		new randWeap = random(VAL_PICKUPTYPES-INFO_TYPE)+INFO_TYPE+1;
		GenerateRandomWeaponPickup(randWeap,19,rx1,rx1+1,ry2,ry2+1,Z,Z+0.5,0);
	}


}

Alles anzeigen

Meine OnPlayerPickUp Callback

C

public OnPlayerPickUpDynamicPickup(playerid, pickupid)
{
	new index;
	switch(GetPickupType(pickupid,index))
	{
	case INVALID_PICKUP_TYPE:
		{
		}
	case MONEY_TYPE:
		{
			PickupCounter[MONEY_TYPE] -= 1;
			GivePlayerMoney(playerid, MoneyVal);
			MoneyPickups[index]=-1;
			quickSort(MoneyPickups,0,sizeof(MoneyPickups)-1);
			DestroyDynamicPickup(pickupid);
		}
	case ACTOR_TYPE:
		{
			ShowMenuForPlayer(shopmenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	case INFO_TYPE:
		{
			ShowMenuForPlayer(infomenu,playerid);
			TogglePlayerControllable(playerid,false);
		}
	case WEAPONTYPE_M4:
		{
			GivePlayerWeapon(playerid,)
			PickupCounter[WEAPONTYPE_M4] -= 1;
			DestroyDynamicPickup(pickupid);
		}
		case WEAPONTYPE_AK47:
		{
		}
		case WEAPONTYPE_SNIPERRIFLE:
		{
		}
		case WEAPONTYPE_CUNTGUN:
		{
		}
		case WEAPONTYPE_DESERT_EAGLE:
		{
		}
		case WEAPONTYPE_PISTOL_9MM:
		{
		}
		case WEAPONTYPE_SILENCED_9MM:
		{
		}
		case WEAPONTYPE_SPAS12:
		{
		}
		case WEAPONTYPE_SHOTGUN:
		{
		}
		case WEAPONTYPE_SAWN_OFF:
		{
		}
		case WEAPONTYPE_MICRO_UZI:
		{
		}
		case WEAPONTYPE_TEC9:
		{
		}
		case WEAPONTYPE_MP5:
		{
		}
		case WEAPONTYPE_GRENADE:
		{
		}
		case WEAPONTYPE_MOLOTOW:
		{
		}
		case WEAPONTYPE_RPG:
		{
		}
		case WEAPONTYPE_SHOVEL:
		{
		}
		case WEAPONTYPE_CHAINSAW:
		{
		}
		case WEAPONTYPE_KATANA:
		{
		}
		case WEAPONTYPE_BASEBALL:
		{
		}
		case WEAPONTYPE_FLOWER:
		{
		}
		case WEAPONTYPE_CANE:
		{
		}
		case WEAPONTYPE_PARACHUTE:
		{
		}
		case WEAPONTYPE_FIRE_EXTINGUSHER:
		{
		}
	}
	return 1;
}

Alles anzeigen

Problem ist jetzt: Wie weiss ich welchen Weapontyp bzw. Pickuptyp ich genau habe? Ich speicher ja unabhaengig vom Waffentyp, (WEAPONTYPE_M4, WEAPONTYPE_AK47)... alles in einem Array WeaponPickups mit Index PickupCounter (damit max. NUM_WEAPONS Pickups generiert werden)

Wie kann ich jetzt einen Weg finden, wenn der Spieler ein Pickup mit Pickup ID aus dem Array WeaponPickups aufsammelt, der entsprechende Waffentyp noch bei rauskommt?
Brauche ich dazu noch ein extra Array?

Hier der Teil wo ich nicht weiter weiss wie ich das loesen kann, markiert mit Fragezeichen

C

stock GetPickupType(pickupid, &index)
{
	new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
	if(mres > -1 && MoneyPickups[mres] == pickupid) return index=mres,MONEY_TYPE;
	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
	if(ares > -1 && ActorPickups[ares] == pickupid) return index=ares,ACTOR_TYPE;
	new ires = binarysearch(InfoPickups,pickupid,0,sizeof(InfoPickups)-1);
	if(ires > -1 && InfoPickups[ires] == pickupid) return index=ires,INFO_TYPE;
	////???????
	new dres = binarysearch(WeaponPickups,pickupid,0,sizeof(WeaponPickups)-1);
	if(ires > -1 && WeaponPickups[ires] == pickupid) return index=ires,INFO_TYPE;


	return INVALID_PICKUP_TYPE;
}

Alles anzeigen

Ich will halt umgehen fuer jede Waffe ein einzelnes Array machen zu muessen

Oder ist vielleicht ein multidimensionales Array sinnvoll, indem ich Pickuptyp und ID speichere und eventuell noch Munition die der Spieler bekommen soll beim aufsammeln?

Sub Royal · 25. April 2017

Das klappt! Danke

Nochwas; Gibt es die Moeglichkeit, irgendwie z.B. das 1. Element aus einem enum einem Integer zuzuweisen? z.B. new x = enum (1) oder sowas?

Sub Royal · 25. April 2017

Schonmal vielen Dank dafuer

Habe jetzt mein enum was ich noch auf ca. 40 Elemente ausdehnen werde

C

enum PickupTypes
{
	INVALID_PICKUP_TYPE,
	MONEY_TYPE,
	ACTOR_TYPE,
	INFO_TYPE,
	WEAPONTYPE_M4
};

Jedoch das Problem dass ich nun tag mismatchs bekomme wo ich die Inhalte wie MONEY_TYPE vorher eingesetzt habe

C

new mres = binarysearch(MoneyPickups,pickupid,0,sizeof(MoneyPickups)-1);
	if(mres > -1 && MoneyPickups[mres] == pickupid) return index=mres,MONEY_TYPE;
	new ares = binarysearch(ActorPickups,pickupid,0,sizeof(ActorPickups)-1);
	if(ares > -1 && ActorPickups[ares] == pickupid) return index=ares,ACTOR_TYPE;
	new ires = binarysearch(InfoPickups,pickupid,0,sizeof(InfoPickups)-1);
	if(ires > -1 && InfoPickups[ires] == pickupid) return index=ires,INFO_TYPE;

Ist es weiterhin einfacher moeglich zu verhindern dass die MAX_PICKUPS Grenze nicht ueberschritten wird?

Aktuell habe ich dieses komische Konstrukt hier

C

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

Sub Royal · 25. April 2017

Gibt es die Moeglichkeit die Anzahl der Elemente in einem enum zu bestimmen?

Ich muss ein Array erstellen als Zaehler fuer erstellte Pickups, und habe in einem enum die Pickuptypen.
Dann will ich das Array CreatedPickups[Anzahl der Elemente aus dem enum] mit Index den entsprechenden Pickuptyp aus dem enum haben.

Gibts da irgendwelche Tricks?

Sub Royal · 24. April 2017

Ist da ein goto nicht eleganter? Warum wird goto so verabscheut wenn man es doch oft ganz nett einsetzen kann, z.B. bei Endlosschleifen?

Wenn ich mir den Linux Kernel anschaue, der ist vollgeklatsch mit gotos

Sub Royal · 24. April 2017

Kali habe noch eine Frage

Gibt es irgendeine simple Moeglichkeit um zu schauen ob der Spieler am skydiven ist?

Weiterhin ne Frage zu deinem Code

Was hat es mit "for(;;)" auf sich?

Sub Royal · 24. April 2017

Super
Das heisst ich kann statt das hier

#define COLOR_TEAM_ONE 0x8B451355 //Brown

#define COLOR_TEAM_ONE_STEALTH 0x8B451300 //Brown

Das hier machen?

#define COLOR_TEAM_ONE 0x8B451355 //Brown

#define COLOR_TEAM_ONE_STEALTH getInv(COLOR_TEAM_ONE) (((COLOR_TEAM_ONE)>>8)<<8) //Brown

Sub Royal · 24. April 2017

Vielen Dank Auch wenn ich das Shiften irgendwie nie raffe mit mehreren >>>, vorallem nicht bei Hex

Habe es jetzt so

C

stock SetPlayerInvisible(playerid)
{
	new hexstring[32];
	new hex = GetPlayerColor(playerid);
	format(hexstring,sizeof(hexstring),"0x%08x",(hex>>8)<<8 );
	sscanf(hexstring, "x", hex);
	SetPlayerColor(playerid,hex);
}

Sub Royal · 24. April 2017

Danke Kali, finde deine Posts immer wieder super

Habe eine Frage:

Kann ich eine Hexzahl so shiften, dass ich am Ende immer 00 rauskriege? Also von 0xFF00FFAA zu 0xFF00FF00 ?

Habe aktuell folgendes

C

stock GetPlayerNameID(playerid)
{
	new name[MAX_PLAYER_NAME+24];
	GetPlayerName(playerid,name,sizeof(name));
	format(name,sizeof(name),"{%06x}%s (%d){FFFFFF}", GetPlayerColor(playerid) >>> 8,name,playerid);
	return name;
}

Wuerde aber gerne eine Funktion machen, mit der ich die Spielerfarbe des Spielers nehmen kann, und dann setzen, jedoch mit 00 am Ende, also unsichtbar auf der Minimap

Sub Royal · 24. April 2017

Habe aktuell eine kleine Funktion geschrieben.

Diese soll einfach 2 beliebige Spieler auf dem Server tauschen, also die Positionen beider Spieler tauschen.

Kann ich das ganze noch optimieren?
Ich habe leider nur diesen Ansatz bisher hingekriegt

C

stock SwapPlayers()
{
	if(GetPlayerCount() >= 2)
	{
		flag:
		new randPlayer = random(GetPlayerCount());
		if(GetPlayerCount() < 2)
		return;
		goto flag;	
		new Float:x1,Float:y1,Float:z1;
		GetPlayerPos(randPlayer,x1,y1,z1);
		flag2:
		new randPlayer2 = random(GetPlayerCount());
		if(!IsPlayerConnected(randPlayer2) || randPlayer2 != randPlayer)
		if(GetPlayerCount() < 2)
		return;
		goto flag2;	
		new Float:x2,Float:y2,Float:z2;
		GetPlayerPos(randPlayer2,x2,y2,z2);
		//Teleport
		if(!IsPlayerConnected(randPlayer) || !IsPlayerConnected(randPlayer2))
		{
			randPlayer = INVALID_PLAYER_ID;
			randPlayer2 = INVALID_PLAYER_ID;
			SwapPlayers();
		}
		SetPlayerPos(randPlayer,x2,y2,z2);
		SetPlayerPos(randPlayer2,x1,y1,z1);
		new pname[MAX_PLAYER_NAME+64];
		GetPlayerName(randPlayer2,pname,sizeof(pname));
		SendClientMessageEx(randPlayer,COLOR_WHITE,"SERVER: You have swapped your position with %s(%d)",pname,randPlayer2);
		GetPlayerName(randPlayer,pname,sizeof(pname));
		SendClientMessageEx(randPlayer2,COLOR_WHITE,"SERVER: You have swapped your position with %s(%d)",pname,randPlayer);
	}
}

Alles anzeigen

Oder die haessliche Variante ohne goto

C

stock SwapPlayers()
{
	if(GetPlayerCount() >= 2)
	{
		new randPlayer = random(GetPlayerCount());
		do
		{
		randPlayer = random(GetPlayerCount());
		if(!IsPlayerConnected(randPlayer))
		if(GetPlayerCount() < 2)
		return;
		}
		while (!IsPlayerConnected(randPlayer));

		new Float:x1,Float:y1,Float:z1;
		GetPlayerPos(randPlayer,x1,y1,z1);

		new randPlayer2 = random(GetPlayerCount());
		do
		{
		randPlayer2 = random(GetPlayerCount());
		if(GetPlayerCount() < 2)
		return;
		}
		while (!IsPlayerConnected(randPlayer2) && randPlayer2 != randPlayer);

		new Float:x2,Float:y2,Float:z2;
		GetPlayerPos(randPlayer2,x2,y2,z2);

		//Teleport

		if(!IsPlayerConnected(randPlayer) || !IsPlayerConnected(randPlayer2))
		{
			randPlayer = INVALID_PLAYER_ID;
			randPlayer2 = INVALID_PLAYER_ID;
			SwapPlayers();
		}
		SetPlayerPos(randPlayer,x2,y2,z2);
		SetPlayerPos(randPlayer2,x1,y1,z1);
		new pname[MAX_PLAYER_NAME+64];
		GetPlayerName(randPlayer2,pname,sizeof(pname));
		SendClientMessageEx(randPlayer,COLOR_WHITE,"SERVER: You have swapped your position with %s(%d)",pname,randPlayer2);
		GetPlayerName(randPlayer,pname,sizeof(pname));
		SendClientMessageEx(randPlayer2,COLOR_WHITE,"SERVER: You have swapped your position with %s(%d)",pname,randPlayer);
	}

}

Alles anzeigen

Beiträge von Sub Royal

Last Bed Standing - Bedwars in SA-MP! 0.1.3

Smalltalk

Multithread Mergesort langsamer als Singlethread Heapsort?

Multithread Mergesort langsamer als Singlethread Heapsort?

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen

[SAMMELTHREAD] Kleine Scripting Fragen