/* 
 * File:		monster_quest.c
 * Autor:		Kylo (na bazie quest.c made by Elvaron)
 * Date:		28.11.97
 * Last Update:	28.11.97 
 * Opis:		Monster z funkcjami przydatnymi w questach
 */
 
// Dolaczamy przydatne makra
#include <macros.h>
// Definicje wlasne
// Utworzenie wywolania VBFC dla funkcji fun argumentami arg (|arg1|arg2|...)
#define VBFC_ME_ARG(fun,arg) ("@@" + (fun) + ":" + file_name(this_object()) \
								+ (arg) + "@@")
// Dokladne sprawdzanie typow
#pragma strict_types

// Dziedziczymy 
inherit "/std/act/seqaction.c";
inherit "/std/act/asking.c";

// Zmienne globalne
// Public
// przechowuje wskaznik do gracza z ktorym ncp rozmawia(jak nie roamawia to 0)
object Aplikant=0;
// przechowuje parametry aktualnej reakcji -  typ reakcji i jej numer
// 0 dawanie questa, 1 zalicznie questa, 2 reakcja 
int Reakcja_Typ,Reakcja_Nr;
// przechowje parametry akcji - czas(jak 1 agument w alarm) 
// komenda - jesli ten string jest komenda to wykonuje go
// jesli nie to mowi go do gracza
mixed *Akcje=({0});
// przechowuje aktalna pozycje w akcje
int Pozycja=0;

// Private
// przechowuje losowe wypowiedzi akcje i ruchy
private mixed *Temp_Seq=({0,0,0});
// zawiera reakcje 
private mixed *Reakcje=({ ({0}), ({0}), ({0}) });
// zawiera propy 
private mixed *Propy=({ ({""}),({ ({""}), ({""}) }), ({""}) });
// zawiera informacj o bitach questa - grupe i bit
private mixed *Bity=({ ({0}), ({0}) });
// zawiera nazwy plikow z logami
private string *Logi=({""});
// zawiera Odzywki npc
// elementy to argumenty dla command_say():
// [0] - odpowiedz domyslna
// [1] - gracz poszedl nie wysluchawszy do konca. Musi byc to komenda 
//      do powiedzenia ogolnie lub wykonania a nie sam tekst. 
//      (Nie ma juz gracza do ktorego mozna by go powiedziec) 
// [2] - odpowiedz udzielana gdy npc walczy z kims a jest pytany o cos
//		(przez kogos innego).
// [3] - odpowiedz udzielana gdy npc walczy z kims i ten ktos go o cos pyta
// [4] - odpowiedz udzielana gdy npc odpowiada i wtedy go ktos atakuje
//		(inny niz zadajacy pytanie)
// [5] - odpowiedz udzielana gdy npc odpowiana i wtedy pytajacy go atakuje
// [6] - rozmawia z kims innym
// [7] - juz rozmawia z tym graczem
// [8] - gracz juz zrobil (dostal exp i set_bit) questa a 
//		chce go jescze raz wziasc
// [9] - gracz zaliczyl questa (ma propa mowiacego o zrobieniu ale nie dostal
//		jeszcze expa i set_bit) a chce wziasc questa jeszcze raz
//		jeszcze w fazie implementacji
// [10] - gracz juz zrobil (dostal exp i set bit) questa a chce go zakonczyc
//		jeszcze raz
// [11] - gracz chce konczyc questa a go nie dostal
// [12] - gracz chce konczyc questa a go nie wykonal
// [13] - gracz daje cos npc a on juz rozmawia z kims innym
// [14] - gracz daje cos npc a on juz z nim rozmawia
// 9,13,14-w fazie implementacji
// Dalem wartosci domyslne ale lepiej dopasuj to do swoich potrzeb
private string *Odzywki=({
	"Nie mam na ten temat nic do powiedzenia.",
	"'Chyba sobie poszedl.",
	"Poczekaj tylko go zabije.",
	"Teraz to chce rozmawiac..., nie ma tak dobrze.",
	"Zabije go i dokonczymy nasza rozmowe.",
	"Nie podobaja ci sie moje odpowiedzi?",
	"Poczekaj chwilke az skoncze ta rozmowe.",
 	"Spokojnie, zaraz do tego dojdziemy.",
 	"Juz mi wystarczajaco pomogles.",
 	"Juz zrobiles to co chcialem.",
 	"Przeciez jestesmy juz kwita.",
 	"Nie wiem o czym mowisz.",
 	"Nie wykonales jeszcze zadania."});
// zawiera domene ktorej dotycza Questy domyslnie Imperium
private string Domena="Imperium";

// Deklaracje funkcji
public varargs void
add_give(mixed *pytanie,mixed *reakcje,int group,int bit,string prop=(""));

public varargs int
command_say(string command,object gracz=(0));

public string
odpowiedz_domyslna();

private int
czy_zajety();
// Definicje funkcji

/*
 * Nazwa funkcji:	add_give()	
 * Opis:			dodaje danie questa i ustawia inne parametry 
 *					zwiazane z questem
 * Argumenty:		mixed *pytanie - zawiera string lub tablice stringow
 *					o ktore zapytany npc da questa. Jesli pytanie = ""
 *					to nie wykona sie add_ask
 *					mixed *reakcje - tablica zawierajaca rekcje npc podczas
 *					dawania questa, na przemina:
 *					czas do rekcji (pierwszy parametr set_alarm),
 *					string z reakcja
 *					reakcja to albo komenda do wykonania, albo tekst ktory
 *					npc powie do gracza 
 *					int grupa, int bit - do funkcji test_bit() 
 *					string prop_g - prop nadawany po wzieciu questa
 *					string prop_d (opcjonalnie) - prop prop mowiacy o 
 *					zrobieniu questa i sprawdzany przy odzywce nr 9
 *					(w fazie implementacji);
 * Zwraca:			nic nie zwraca
 */

varargs public void
add_give(mixed *pytanie,mixed *reakcje,int grupa,int bit,
	string prop_g,string prop_d=(""))
{
	int i;
	i=(++Reakcje[0][0]);
	Reakcje[0]+=({reakcje});
	if (!(pytanie == ({""})))
		add_ask(pytanie,VBFC_ME_ARG("reakcja","|give|" + i));
	Bity[0]+=({ ({grupa, bit}) });
	Propy[0]+=({prop_g});
 	return; 
 
}
// koniec add_give

/*
 * Nazwa funkcji:	add_done()	
 * Opis:			dodaje danie zakonczenie questa
 * Argumenty:		mixed *pytanie - zawiera string lub tablice stringow
 *					o ktore zapytany npc zakonczy questa. Jesli tablica
 *					to "" nie wykona sie add_ask
 *					mixed *reakcje - tablica zawierajaca rekcje npc podczas
 *					zakonczenia questa, na przemina czas do rekcji (pierwszy
 *					parametr set_alarm),string z rekcja npc,
 *					reakcja to albo komenda do wykonania, albo tekst kory
 *					npc powie do gracza 
 *					int grupa, int bit - do funkcji set_bit() 
 *					string logfile - nazwa pliku z logami
 *					string prop_d - prop sprawdzany przy
 *					zakonczeniu questa mowicy o jego wykonaniu
 *					string prop_g - prop sprawdzany przy
 *					zakonczeniu questa mowiacy o jego wzieciu
 *					(opcjonalny)
 * Zwraca:			nic nie zwraca
 */

public void
add_done(mixed *pytanie,mixed *reakcje,int grupa,int bit,string logfile,
	string prop_d,string prop_g=(""))
{
	int i;
	i=(++Reakcje[1][0]);
	Reakcje[1]+=({reakcje});
	if (!(pytanie == ({""}))) 
		add_ask(pytanie,(VBFC_ME_ARG("reakcja","|done|" + i)));
	Bity[1]+=({ ({grupa, bit }) });
	Logi+=({logfile});
	Propy[1][0]+=({prop_d});
	Propy[1][1]+=({prop_g});
	return;
}
// koniec  add_done

/*
 * Nazwa funkcji:	add_reakcja()	
 * Opis:			dodaje reakcje
 * Argumenty:		mixed *pytanie - zawiera string lub tablice stringow
 *					o ktore zapytany npc zareguje. Jesli tablica
 *					to "" nie wykona sie add_ask
 *					mixed *reakcje - tablica zawierajaca rekcje npc podczas
 *					zakonczenia questa, na przemina czas do rekcji (pierwszy
 *					parametr set_alarm),string z rekcja npc,
 *					reakcja to albo komenda do wykonania, albo tekst kory
 *					npc powie do gracza 
 *					string prop (opcjonalnie) - prop dawany przy reakcji
 * Zwraca:			nic nie zwraca
 */

public void
add_reakcja(mixed *pytanie,mixed *reakcje,string prop=(""))
{
 	int i;
	i=(++Reakcje[2][0]);
	Reakcje[2]+=({reakcje});
	if (!(pytanie == ({""}))) 
		add_ask(pytanie,(VBFC_ME_ARG("reakcja","|reaguj|" + i)));
	Propy[2]+=({prop});
	return;
}
// koniec add_reakcja

/*
 * Nazwa funkcji:	ustaw_odzywki
 * Opis:			ustawia odzywki (reakje)
 * Argumenty:		mixed odzywki jesli brak drugiego parametru (lub = -1) to
 *					tablica z odzywkami (reakcjami)
 *					elementy to argumenty dla command_say():
 *					jesli podany drugi argument to jest to numer odzywki
 *					( reakcji ) ktora ma byc ustawiona a pierwszy
 *					argument zawiera jej tresc
 *					Numery odzywek:			
 * [0] - odpowiedz domyslna
 * [1] - gracz poszedl nie wysluchawszy do konca. Musi byc to komenda 
 * 		do powiedzenia ogolnie lub wykonania a nie sam tekst. 
 *		(Nie ma juz gracza do ktorego mozna by go powiedziec) 
 * [2] - odpowiedz udzielana gdy npc walczy z kims a jest pytany o cos
 *		(przez kogos innego).
 * [3] - odpowiedz udzielana gdy npc walczy z kims i ten ktos go o cos pyta
 * [4] - odpowiedz udzielana gdy npc odpowiada i wtedy go ktos atakuje
 *		(inny niz zadajacy pytanie)
 * [5] - odpowiedz udzielana gdy npc odpowiana i wtedy pytajacy go atakuje
 * [6] - rozmawia z kims innym
 * [7] - juz rozmawia z tym graczem
 * [8] - gracz juz zrobil (dostal exp i set_bit) questa a 
 *		chce go jescze raz wziasc
 * [9] - gracz zaliczyl questa (ma propa mowiacego o zrobieniu ale nie dostal
 *		jeszcze expa i set_bit) a chce wziasc questa jeszcze raz
 * [10] - gracz juz zrobil (dostal exp i set bit) questa a chce go zakonczyc
 *		jeszcze raz
 * [11] - gracz chce konczyc questa a go nie dostal
 * [12] - gracz chce konczyc questa a go nie wykonal
 * [13] - gracz daje cos npc a on juz rozmawia z kims innym
 * [14] - gracz daje cos npc a on juz z nim rozmawia
 * 9,13,14-w fazie implementacji
 * Zwraca:			nic nie zwraca
 */
 
public void
ustaw_odzywki(mixed odzywki,int nr=-1)
{
	if (nr == -1)
		Odzywki=odzywki;
	else
		Odzywki[nr]=odzywki;
}
// koniec ustwaw_odzywki

/*
 * Nazwa funkcji:	odpowiedz_domyslna	
 * Opis:			funkcja dajaca domyslna odpowiedz (reakcje) gdy npc nie
 *					jest zajety lub odpowiednia odzywke gdy jest
 * Argumenty:		brak
 * Zwraca:			pusty string (VBFC)
 */

public string
odpowiedz_domyslna()
{
	if (czy_zajety())
		return "";
	command_say(Odzywki[0],this_player());
	return "";
}
// koniec odpowiedz_domyslna()

/*
 * Nazwa funkcji:	set_default_answer()	
 * Opis:			przykrycie standartowej funkcji tak aby sprawdzala
 *					czy npc nie jest zajety
 *					reakcje takie same jak w przypadku pytania dodanego
 *					add_give,add_done,add_rekcja
 * Argumenty:		string answer - tekst z odpowiedzia, jesli brak
 *					brany jest on z odzywek - patrz ustaw_odzywki
 * Zwraca:			nic nie zwraca
 */
 
public void
set_default_answer(string answer=(""))
{	if (answer=="")
		answer=Odzywki[0];
	else
		Odzywki[0]=answer;
	::set_default_answer(VBFC_ME("odpowiedz_domyslna"));
}
// koniec set_default_anserw

/*
 * Nazwa funkcji: 	czy_zaliczony
 * Opis:			sprawdza czy dany quest byl juz kiedys przez gracza
 *					zaliczony
 * Argumenty:		brak
 * Zwraca:			1 - gdy quest juz byl kiedys zaliczony
 *					0 - w przeciwny wypadku
 */
 
private int
czy_zaliczony()
{
	if (this_player()->test_bit(Domena,Bity[0][Reakcja_Nr][0],
		Bity[0][Reakcja_Nr][1]))
	{
		if (Reakcja_Typ==0)
 			command_say(Odzywki[8],this_player());
		if (Reakcja_Typ==1)
			command_say(Odzywki[10],this_player());
		return 1;
	}
//	if (!((this_player()->query_prop(Propy[1][Reakcja_Nr][0])) &&
//		(Reakcja_Typ=0)))
//	{
//		command_say(Odzywki[9],this_player());
//		return 1;
//	}
	return 0;
}
// koniec czy_zaliczony

 
/*
 * Nazwa funkcji: 	czy_otwarty()
 * Opis:			sprawdza czy sa warunki do dania questa
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			1 - mozna dac questa
 *					0 - nie mozna dac questa
 */

public int
czy_otwarty()
{
	return 1;
}
// koniec czy_otwarty

/*
 * Nazwa funkcji:	czy_zrobiony
 * Opis:			sprawdza czy gracz ma propa mowiacego o wzieciu qesta
 *					i o wykonaniu questa przy probie zakonczenia
 *					ew odpowiednia reakcja
 * Argumenty:		brak
 * Zwraca:			1 - ma te propy (oba)
 *					0 - w przeciwnym przypadku
 */

private int
czy_zrobiony()
{
	
	if((!this_player()->query_prop(Propy[1][1][Reakcja_Nr])) &&
		(Propy[1][1][Reakcja_Nr]!=""))
	{
		command_say(Odzywki[11],this_player());
		return 1;
	}
	if(!this_player()->query_prop(Propy[1][0][Reakcja_Nr]))
	{
		command_say(Odzywki[12],this_player());
		return 1;
	}
	return 0;
}
// koniec funkcji czy_zrobiony

/*
 * Nazwa funkcji:	czy_zakonczyc
 * Opis:			sprawdza czy sa warunki do zakonczyc questa
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			1 - mozna zakonczyc quest
 *					0 - nie mozna zakonczyc questa 
 */

public int
czy_zakonczyc()
{
	return 1;
}
// koniec czy_zakonczyc


/*
 * Nazwa funkcji: 	czy_mozna
 * Opis:			sprawdza czy mozna wykonac reakcje
 * Argumenty:		brak
 *					do przykrycia we wlasnym obiekcie
 * Zwraca:			1 - gdy mozna
 *					0 - gdy nie mozna
 */
 
public int
czy_mozna()
{
	return 1;
}
// koniec czy_mozna

/*
 * Nazwa funkcji:	czy_zajety()
 * Opis:			sprawdz czy npc nie jest juz czyms zajety:
 *					czy walczy
 *					juz rozmawia z tym graczem
 *					rozmawia z kims innym
 * Argumenty:		brak
 * Zwraca:			1 - gdy zajety
 *					0 - gdy wolny
 */

private int
czy_zajety()
{
	if (this_object()->query_attack())
	{
		if (this_object()->query_attack()==this_player())
			command_say(Odzywki[3],this_player());
		else
			command_say(Odzywki[2],this_player());
		return 1;
	}
	if (this_player()==Aplikant)
	{
		command_say(Odzywki[7],this_player());
		return 1;
	}
	if (Aplikant!=0)
	{
		command_say(Odzywki[6],this_player());
		return 1;
	}
	return 0;
}
// koniec czy_zajety

/*
 * Nazwa funkcji:	rozpoczecie		
 * Opis:			wykonywana przed rozpoczeciem reakcji
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

void
rozpoczecie()
{
}
// koniec rozpoczecie

/*
 * Nazwa funkcji:	odejscie		
 * Opis:			wykonywana gdy wykonywanie reakcji zostalo przerwane
 *					w trakcie przez odejscie gracz
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

void
odejscie()
{
}
// koniec odejscie

/*
 * Nazwa funkcji:	zaatakowanie		
 * Opis:			wykonywana gdy wykonanie akcji zastalo przerwane przez
 *					atak na npc-a
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */
 
void
zaatakowanie()
{
}
// koniec zaatakowanie

/*
 * Nazwa funkcji:	podczas		
 * Opis:			wykonywana podczas reakcji (po kazdej reakcji npc)
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

void 
podczas()
{
}
// koniec podczas

/*
 * Nazwa funkcji:	zakonczenie		
 * Opis:			wykonywana po calkowitym zakonczeniu reakcji
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

void
zakonczenie()
{
}
// koniec zakonczenie

/*
 * Nazwa funkcji:	zakonczenie_questa
 * Opis:			wykonywana po calkowitym zakonczeniu questa
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

void
zakonczenie_questa()
{
}
// koniec zakonczenie_questa

/*
 * Nazwa funkcji:	calc_exp()
 * Opis:			obliczenie ilosci expa do dania
 *					do przykrycia we wlasnym obiekcie
 * Argumenty:		brak
 * Zwraca:			int - wynik obliczen
 */

int 
calc_exp()
{
	return 0;
}

/*
 * Nazwa funkcji:	end_quest()
 * Opis:			funkcja konczaca questa 
 *					ustawia bit,zapiasuje fakt zrobienia w logu
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

void
end_quest()
{
        seteuid("silvy");
	write_file(Logi[Reakcja_Nr],ctime(time()) + ": " + 
		Aplikant->query_name() + ", " + calc_exp() + "xp." +
		"\n");
	Aplikant->set_bit(Bity[1][Reakcja_Nr][0],Bity[1][Reakcja_Nr][1]);
	Aplikant->add_exp(calc_exp());
	zakonczenie_questa();
}

/*
 * Nazwa funkcji:	command_say()
 * Opis:			Jesli przekazany string jest komenda to wykonanie go
 * 					w przeciwnym wypadku npc mowi ten string do gracza
 *					(jesli zostal przekazany drugi argument)
 * Argumenty:		string komenda - komenda do wykonania lub 
 *					tekst do wypowiedzi
 * 					object gracz - (opcjonalny) wskaznik do gracza ktorego 
 *					skierowana jest wypowiedz
 * Zwraca:			1 - w przypadku sukcesu
 *					0 - w przeciwnym razie
 */

public varargs int
command_say(string komenda,object gracz=(0))
{
	if(command(komenda))
		return 1;
	if(gracz)
	{
		command(("powiedz do " + OB_NAME(gracz) + " " + komenda));
		return 1;
	}
	return 0;
} 
// koniec comand_say()

/*
 * Nazwa funkcji:	start_reakcja
 * Opis:			przygotowanie do reakcji oraz
 *					zapamietanie losowych wypowiedzi (add_chat i add_cchat) 
 *					akcji (add_act i add_cact)
 *					ruchow (set_follow i set_random-move)
 *					i wylaczenie ich
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

private void
start_reakcja()
{
	Akcje = Reakcje[Reakcja_Typ][Reakcja_Nr];		
	Aplikant=this_player();
	Temp_Seq[0]=seq_query("_mon_chat");
	seq_delete("_mon_chat");
	Temp_Seq[1]=seq_query("_mon_ran_act");
	seq_delete("_mon_ran_act");
	Temp_Seq[2]=seq_query("_mon_ranwalk");
	seq_delete("_mon_ranwalk");
}
// koniec start_reakcja

/*
 * Nazwa funkcji:	end_reakcja
 * Opis:			zakonczenie reakcji oraz
 *					odtworzenie losowych wypowiedzi (add_chat i add_cchat) 
 *					akcji (add_act i add_cact)
 *					ruchow (set_follow i set_random-move)
 *					i wlaczenie ich
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

private void
end_reakcja()
{
	Aplikant=0;
	Pozycja=0;
	seq_new("_mon_chat");
	seq_addfirst("_mon_chat",Temp_Seq[0]);
	seq_new("_mon_ran_act");
	seq_addfirst("_mon_ran_act",Temp_Seq[1]);
	seq_new("_mon_ranwalk");
	seq_addfirst("_mon_ranwalk",Temp_Seq[2]);
}
// koniec end_reakcja()

/*
 * Nazwa funkcji:	end_akcje()
 * Opis:			Po pomyslnym zakonczniu akcji dla give i wypowiedzi
 *					dodaje propy :
 *					give - prop questa + give
 *					wypowiedz - prop questa + nr wypowiedzi
 *					dla done konczy questa:
 *					ustawia bity,daje expa, usuwa propy zwazane z questem,
 *					itp.
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */
 
private void 
end_akcje()
{
	if (Reakcja_Typ==1)
		end_quest();
	else
		Aplikant->add_prop(Propy[Reakcja_Typ][Reakcja_Nr],1);
	return;
}
// koniec end_akcje()

/*
 * Nazwa funkcji:	przechowaj_reakcje()
 * Opis:			Przechowuje typ reakcji give-0,done-1 reguj-2
 *					w Reakcja_typ
 *					i numer reakcji w Reakcja_Nr 
 *					sprawdza poprawnosc parametrow
 * Argumenty:		string typ_reakcji - give,done,reguj
 *					string nr_reakcji - string z numerem reakcji 
 * Zwraca:			1 sukces
 *					0 bledne parametry
 */

private int
przechowaj_reakcje(string typ_reakcji,string nr_reakcji)
{
	switch(typ_reakcji)
	{
	case "give":
		Reakcja_Typ=0;
		break;
	case "done":
		Reakcja_Typ=1;
		break;
	case "reaguj":
		Reakcja_Typ=2;
		break;
	default:
		return 0;
	}
	if(!(Reakcja_Nr=atoi(nr_reakcji)))
		return 0;
	if((Reakcja_Nr < 1) || (Reakcja_Nr > Reakcje[Reakcja_Typ][0]))
		return 0;
	return 1;
}
// koniec przechowaj_reakcje()

/*
 * Nazwa funkcji:	reakcja()	
 * Opis:			Reakcja npc na pytanie
 * Argumenty:		string nr_quest - string z numerem questa
 *					string nr_reakcja - string z numerem reakcji, 
 *					lub give lub done
 *					argumenty to stringi bo funkcja wywolywana VBFC
 * Zwraca:			pusty string - VBFC
 */

string
reakcja(string typ_reakcji,string nr_reakcji)
{
	if(czy_zajety())
		return "";
	if(!(przechowaj_reakcje(typ_reakcji,nr_reakcji)))
		return "";
	if(Reakcja_Typ == 0)
	{
		if(czy_zaliczony())
			return "";
		if(!(czy_otwarty()))
			return "";
	}
	if(Reakcja_Typ == 1)
	{
		if(czy_zaliczony())
			return "";
		if(czy_zrobiony())
			return "";
		if(!(czy_zakonczyc()))
			return "";
	}
	if(!(czy_mozna()))
		return "";
	rozpoczecie();		
	start_reakcja();
	set_alarm(Akcje[Pozycja],0.0,"akcja");
	return"";
}
// koniec funkcji reakcja()

/*
 * Nazwa funkcji:	akcja()
 * Opis:			wykonanie jednej akcji npc z Akcje i ew
 *					rozpoczecie nastepnej
 *					zaleznie od zawartosci Pozycja
 * Argumenty:		brak
 * Zwraca:			nic nie zwraca
 */

private void
akcja()
{
	if (!present(Aplikant,environment(this_object())))
	{
		command_say(Odzywki[1],Aplikant);
		odejscie();
		end_reakcja();
		return;
	}
	if (this_object()->query_attack())
	{
		if (this_object()->query_attack()==Aplikant)
			command_say(Odzywki[5],Aplikant);
		else
			command_say(Odzywki[4],Aplikant);
		zaatakowanie();
		end_reakcja();
		return;
	}
	if (Pozycja < sizeof(Akcje)-2)
	{
		++Pozycja;
		command_say(Akcje[Pozycja],Aplikant);
		++Pozycja;
		set_alarm(Akcje[Pozycja],0.0,"akcja");
		podczas();
		return;
	}
	if (Pozycja == sizeof(Akcje)-2)
	{
		++Pozycja;
		command_say(Akcje[Pozycja],Aplikant);
		zakonczenie();
		end_akcje();
		end_reakcja();
		return;
	}
}
// koniec funkcji akcja

/*
 * Nazwa funkcji:	
 * Opis:
 * Argumenty:
 * Zwraca:
 */