/*-- Klippenschubsen --*/

#strict 2

static const MODE_Normal = 0, MODE_ScrollsOnly = 1, MODE_Cancer = 2;
static const MENU_Landscape = 0, MENU_Mode = 1, MENU_Settings = 2;

static setupDone, setupPlayer;
static gameMode;
static landscape;
static deathmatchEnabled, deathmatchKillLimit;
static relaunches, playerScore, teamScore;
static g_iSaveSectIndex,szSection;
static pChooser,iDif;

func Initialize()
{
	// Create background sound, fog and rain
	SoundLevel("Ambiente", 50);
  for (var i; i < 300; ++i)
	{
		CreateParticle("Fog", Random(LandscapeWidth()), Random(LandscapeHeight()) + 500, RandomX(3, 9), 0, RandomX(1000, 1500));
	}
  CreateObject(RAIN, 0, 0, NO_OWNER);

	// Moving brick
	CreateObject(BRK2, 225, 150, NO_OWNER);
	CreateObject(BRK2, 985, 150, NO_OWNER);
	
	// Initial values
	deathmatchKillLimit = 20;
	setupDone = false;
	setupPlayer = -1;
	relaunches = CreateArray();
	playerScore = CreateArray();
	teamScore = CreateArray();
	
	// Initialize scoreboard
	SetScoreboardData(SBRD_Caption, 0, "{{MELE}}");
	SetScoreboardData(SBRD_Caption, 1, "{{GBLT}}");
	SetScoreboardData(SBRD_Caption, 2, "{{CXIV}}");
	DoScoreboardShow(1);
	
	ScriptGo(true);
}

func InitializePlayer(int player)
{
	if (!setupDone && setupPlayer == -1)
	{
		setupPlayer = player;
		ShowSetup();
	}

	/*if (!iDif && GetCrew(GetPlayerCount() - 1)) InitializePlayer2(0);
	if (!FindObject(DTHM)) relaunches[player] = 10;*/

	UpdateScoreboard();
}

func RemovePlayer(int player, int team)
{
	playerScore[player] = 0;
	UpdateScoreboard();

	// Player leaves and is still in setup?
	if (!setupDone && setupPlayer == player)
	{
		// Try to find any other player to continue setup
		for (var i = 0; i < GetPlayerCount(); ++i)
		{
			setupPlayer = GetPlayerByIndex(i);
			if (setupPlayer != player)
			{
				ShowSetup();
				return;
			}
		}
	}
	
	// No other players?
	setupPlayer = -1;
}

func ShowSetup(int menuStage, int selection, bool back)
{
	var clonk = GetCrew(setupPlayer);
	
	// Clonk already in setup menu?
	if (clonk->GetMenu()) return;
	
	//int CreateMenu (id idSymbol, object pMenuObject, object pCommandObject, int iExtra, string szCaption, int iExtraData, int iStyle, bool fPermanent, id idMenuID); 
	//int AddMenuItem (string szCaption, string szCommand, id idItem, object pMenuObject, int iCount, int iParameter, string szInfoCaption, int iExtra, any XPar1, any XPar2);
	
	CreateMenu(ROCK, clonk, 0, C4MN_Extra_None, 0, 0, C4MN_Style_Context);
	
	if (menuStage == MENU_Landscape)
	{
		clonk->AddMenuItem("Default landscape", "ShowSetup(MENU_Mode, 0)", ROCK);
	}
	else if (menuStage == MENU_Mode)
	{
		if (!back) landscape = selection;
		
		// List modes
		
		var modes = [
			["Normal", MODE_Normal],
			["Scrolls only", MODE_ScrollsOnly],
			["Cancer", MODE_Cancer]];
			
		var itemIndex = 0;
		for (var mode in modes)
		{
			clonk->AddMenuItem(mode[0], Format("ShowSetup(MENU_Settings, %d)", mode[1]), ROCK);
			if (mode[1] == gameMode) clonk->SelectMenuItem(itemIndex);
			++itemIndex;
		}
		
		clonk->AddMenuItem("Back", "ShowSetup(MENU_Landscape, 0, true)", ROCK);
	}
	else if (menuStage == MENU_Settings)
	{
		if (!back) gameMode = selection;
		clonk->AddMenuItem("Back", "ShowSetup(MENU_Mode, 0, true)", ROCK);
	}
}

func Script2()
{
	// Reopen setup menu if it was closed (by player or runtime join)
	if (!setupDone && setupPlayer != -1) ShowSetup();
	
	UpdateScoreboard();
	
	goto(1);
	return 1;
}

func OnClonkDeath(object clonk, int killedBy)
{
	var isDeathmatch = !!FindObject(DTHM);
	var player = clonk->GetOwner();
	var team = GetPlayerTeam(player);
	var teamKill = GetPlayerID(killedBy) == 0 || killedBy == player || team != 0 && team == GetPlayerTeam(killedBy);

	// Killed by opponent?
	if (!teamKill)
	{
		++playerScore[killedBy];
		if (isDeathmatch) CheckDeathmatchKillCount();
	}
	else
	{
		// Deathmatch: Decrement score on suicide or team kill.
		if (isDeathmatch) --playerScore[killedBy];
	}
	
	// Update relaunch counter
	if (!isDeathmatch)
	{
		// No relaunches left?
		if (relaunches[player] - 1 < 0)
		{
			EliminatePlayer(player);
			return;
		}
		else
		{
			--relaunches[player];
		}

		// Show relaunch message. Warn player if it was his last relaunch.
		if (relaunches[player] == 0)
		{
			PlayerMessage(player, "$MsgLastRelaunch$");
		}
		else
		{
			PlayerMessage(player, "$MsgRelaunch$", 0, relaunches[player]);
		}
	}

	// Create new clonk at random position
	var positions = [[168, 120], [301, 150], [914, 150], [1050, 120]];
	var position = positions[Random(GetLength(positions))];
	var newclonk = CreateObject(CLNK, position[0], position[1], player);
	newclonk->GrabObjectInfo(clonk);

	// Armageddon?
	if (FindObject(FRRN)) 
	{
		AddEffect("DoTerra", newclonk, 200, 50);
		AddEffect("Bottom", newclonk, 200, 2);
	}

	SelectCrew(player, newclonk, true);
}

func CheckDeathmatchKillCount()
{
	var gameOver = false;

	if (GetTeamCount() == 0)
	{
		var winner = -1;
		
		// Check if a player has reached the kill limit
		for (var i = 0; i < GetPlayerCount(); ++i)
		{
			var plr = GetPlayerByIndex(i);
			if (playerScore[plr] >= deathmatchKillLimit)
			{
				winner = plr;
				gameOver = true;
				break;
			}
		}

		// Eliminate other players if there is a winner
		for (var i = 0; i < GetPlayerCount(); ++i)
		{
			var plr = GetPlayerByIndex(i);
			if (plr != winner) EliminatePlayer(plr);
		}
	}
	else
	{
		var winnerTeam = 0;

		// Clear team score array
		teamScore = CreateArray(GetTeamCount());

		// Calculate team score and check if kill limit is reached
		for (var i = 0; i < GetPlayerCount(); ++i)
		{
			var plr = GetPlayerByIndex(i), team = GetPlayerTeam(plr);
			teamScore[team] += playerScore[plr];
			if (teamScore >= deathmatchKillLimit)
			{
				winnerTeam = team;
				gameOver = true;
				break;
			}
		}

		// Do we have a winner?
		if (winnerTeam != 0)
		{
			for (var i = 0; i < GetPlayerCount(); ++i)
			{
				var plr = GetPlayerByIndex(i);
				if (GetPlayerTeam(plr) != winnerTeam) EliminatePlayer(plr);
			}
		}
	}
	
	UpdateScoreboard();
	
	if (gameOver) GameOver(2014);
}

func UpdateScoreboard()
{
	for (var plr; plr < GetPlayerCount(); ++plr)
	{
		SortScoreboard(0, true);
		plr = GetPlayerByIndex(plr);
		SetScoreboardData(plr, 0, GetTaggedPlayerName(plr), relaunches[plr]);
		SetScoreboardData(plr, 2, Format("%d", playerScore[plr]));
		if (relaunches[plr] < 0)
		{
			SetScoreboardData(plr, 1, Format("<c c80000>%s</c>", "$Death$"));
		}
		else if (relaunches[plr] <= 1)
		{
			SetScoreboardData(plr, 1, Format("<c c80000>%d</c>", relaunches[plr]));
		}
		else
		{
			SetScoreboardData(plr, 1, Format("%d", relaunches[plr]));
		}
	}
}

/*-----------------------Spielmodi-----------------------*/

//Auswahl
func InitializePlayer2(iPlr)
{
  pChooser=GetHiRank(iPlr);
  CreateMenu(EFLN,pChooser,0,0,0,0,1);
  AddMenuItem("$Mode1$","SetDif",ROCK,pChooser,0,1);
  AddMenuItem("$Mode2$","SetDif",FLRN,pChooser,0,2);
  AddMenuItem("$Mode3$","SetDif",SMGC,pChooser,0,3);
  AddMenuItem("$Mode4$","SetDif",FXV1,pChooser,0,4);
  AddMenuItem("$Random$","SetDif",RMMG,pChooser,0,RandomX(1,4));
  return(1);
}

func SetDif(dummy,i)
{
 if (i == 1) Message("$Mode1$");
 if (i == 2) Message("$Mode2$");
 if (i == 3) Message("$Mode3$");
 if (i == 4) Message("$Mode4$");
 
 if (i==1) CreateObject(SPWN);
 if (i==2) 
  {
   Schedule("ChangeSection(\"SuddenDeath\")",10);
   Message("$Load$");
  }
 if (i==3) 
 {
 CreateObject(MSPW);
 SetGamma(RGB(5,5,10),RGB(80,80,150),RGB(200,200,255));
 }
 if (i==4) UltimateExtreme();
return(1);
}

func UltimateExtreme()
{
 RemoveAll(SPNP);
 RemoveAll(MSPN);
 RemoveObject(FindObject(SPWN));
 CastObjects(RCKF,10);
 CreateObject(FRRN);
 MusicLevel(0);
 SoundLevel("ExtremeAmbiente",100);
 SoundLevel("Ambiente",0);
 for (var Plr;Plr < GetPlayerCount();Plr ++)
  {
  relaunches[Plr] = 5;
  AddEffect("DoTerra",GetHiRank(Plr),200,50);
  AddEffect("Bottom",GetHiRank(Plr),200,2);
   } 
 var brick;
 for (var i;i<ObjectCount(BRK2);i++)
  if (brick = FindObject(BRK2,0,0,0,0,0,0,0,0,brick))
 SetClrModulation(RGB(220,20,20),brick);
 AddEffect("War",0,200,1);
 SetMaterialColor(Material("Brick"),100,0,0,150,0,0,20,0,0);
 SetGameSpeed(50);
 return(1);
}

/*----------------Landschaftstausch-------------------*/
func ChangeSection()
{
 for (var i;i<GetPlayerCount();i++)
  SaveSectObj(GetHiRank(i));
 LoadScenarioSection("SuddenDeath");
 return(RestoreSectObjs());
}

global func RestoreSectObjs()
  {
  var obj,X,Y;
  for (var i= 20;i>0;i--)
    {
     CreateObject(BRK2,i*90,0);
     CreateObject(SPNP,Random(LandscapeWidth()),Random(LandscapeHeight()+500));
    }
  CastObjects(CANN,RandomX(10,20),Random(150),LandscapeWidth()/2);
  CreateObject(RAIN);
  CreateObject(FLRN);
  CreateObject(MELE);
  // Alles gespeicherte wieder herstellen
  if (g_iSaveSectIndex)
    while (g_iSaveSectIndex--)
      if (obj=Global(20+g_iSaveSectIndex))
        { obj->SetObjectStatus(1); Global(20+g_iSaveSectIndex)=0; }
  g_iSaveSectIndex=0;
  for (var iPlr;iPlr<GetPlayerCount();iPlr++)
   {  
    while (!GBackSolid(X,Y) || !GBackSolid(X-1,Y))
    {
     if (Y == LandscapeHeight())
    {
     Y = 0;
     X ++;
    }
   Y ++;
   }
   SetPosition(X,0,GetHiRank(iPlr));
 }
 }

global func SaveSectObj(object obj)
{
	// No object?
	if (!obj) return;

	// Object already processed? (Avoid infinite recursion)
	var pTest, i;
	while (pTest = Global(20 + i++))
	{
		if (pTest == obj) return;
	}
	
	// Save contents
	var contentsCount = obj->ContentsCount();
	for (var i = 0; i < contentsCount; ++i)
	{
		SaveSectObj(obj->Contents(i));
	}

	// Save object
	Global(20 + g_iSaveSectIndex++) = obj;
	obj->SetObjectStatus(C4OS_INACTIVE);
}

/*-------------- Effects -----------------*/

global func FxDoTerraTimer(object target)
{
	if (target->ContentsCount() < 3) target->CreateContents(EFLN);
	ShakeViewPort(10);
	return 1;
}

global func FxBottomTimer(object target)
{
	if (target->GetY() >= LandscapeHeight() - 20) target->SetPosition(target->GetX() + RandomX(-10, 10), 0);
	return 1;
}

global func FxWarStart(object target, int effectNumber)
{
	EffectVar(0, 0, effectNumber) = 255;
	EffectVar(1, 0, effectNumber) = 1;
	return 1;
}

global func FxWarTimer(object target, int effectNumber)
{
	// Remove corpses
	for (var obj in FindObjects(Find_OCF(OCF_CrewMember), Find_Not(Find_OCF(OCF_Alive))))
	{
		obj->RemoveObject();
	}

	if (EffectVar(1, 0, effectNumber) == 1)
	{
		--EffectVar(0, 0, effectNumber);
	}
	else
	{
		++EffectVar(0, 0, effectNumber);
	}

	if (EffectVar(0, 0, effectNumber) < 0)
	{
		EffectVar(1, 0, effectNumber) = 0;
	}
	else if (EffectVar(0, 0, effectNumber) > 255)
	{
		EffectVar(1, 0, effectNumber) = 1;
	}

	var color = EffectVar(0, 0, effectNumber);
	SetSkyAdjust(RGB(255, color / 2, color / 4), RGB(128, color / 2, color / 4));
	SetGamma(RGB(2, 0, 0), RGB(128, color / 2, color / 4), RGB(180, color /2 , color / 4));

	return 1;
}