party.cpp

S.C.O.U.R.G.E.是一款类似Rogue的游戏

/***************************************************************************
                          scourge.cpp  -  description
                             -------------------
    begin                : Sat May 3 2003
    copyright            : (C) 2003 by Gabor Torok
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "party.h"

#define GUI_WIDTH 500
#define MIN_GUI_WIDTH 100
#define GUI_HEIGHT 165

#define MAX_SIZE 0
#define MIN_SIZE 1

Party::Party(Scourge *scourge) {
  this->scourge = scourge;

  lastEffectOn = false;

  startRound = true;
  mainWin = NULL;
  calendar = Calendar::getInstance();

  for(int i = 0; i < getPartySize(); i++) {
	party[i] = NULL;
  }
  createUI();
  reset();
}

Party::~Party() {
  delete calendar;
  for(int i = 0; i < getPartySize(); i++) {
	if(party[i]) {
	  delete party[i];
	}
  }
}

void Party::reset() {
  // Init the party; hard code for now
  // This will be replaced by a call to the character builder which either
  // loads or creates the party.
  for(int i = 0; i < getPartySize(); i++) {
	if(party[i]) {
	  delete party[i];
	}
  }
  Creature **pc = createHardCodedParty();
  party[0] = player = pc[0];
  party[1] = pc[1];
  party[2] = pc[2];
  party[3] = pc[3];
  
  player1Button->getLabel()->setText(party[0]->getName());
  player1Button->setSelected(true);
  player2Button->getLabel()->setText(party[1]->getName());
  player3Button->getLabel()->setText(party[2]->getName());
  player4Button->getLabel()->setText(party[3]->getName());

  Event *e;  
  Date d(0, 0, 6, 0, 0, 0); // 6 hours (format : sec, min, hours, days, months, years)
  for(int i = 0; i < 4 ; i++){
	e = new ThirstHungerEvent(calendar->getCurrentDate(), d, party[i], scourge, Event::INFINITE_EXECUTIONS);
	calendar->scheduleEvent((Event*)e);   // It's important to cast!!
  }
}

void Party::startPartyOnMission() {
  // Start calendar and add thirst & hunger event scheduling
  calendar->reset(false);

  player_only = false;
  partyDead = false;

  // set player to be the first non-dead character
  for(int i = 0; i < 4; i++) {
	if(!party[i]->getStateMod(Constants::dead)) {
	  setPlayer(getParty(i));
	  break;
	}
  }
  setFormation(Constants::DIAMOND_FORMATION - Constants::DIAMOND_FORMATION);
  getPlayer()->cancelTarget();
  
  // init the rest of the party
  for(int i = 1; i < 4; i++) {
	getParty(i)->setNext(getPlayer(), i);
	getParty(i)->cancelTarget();
  }
}

void Party::setPartyMotion(int motion) {
  for(int i = 0; i < 4; i++) {
	if(party[i] != player) party[i]->setMotion(motion);
  }
}

void Party::followTargets() {
  for(int i = 0; i < 4; i++) {
	if(!party[i]->getStateMod(Constants::dead) && 
	   party[i]->getTargetCreature()) {
	  party[i]->setSelXY(party[i]->getTargetCreature()->getX(),
						 party[i]->getTargetCreature()->getY());
	}
  }
}

bool Party::switchToNextLivePartyMember() {
	Creature *oldPlayer = player;
	// find the player's index
	int n = -1;
	for(int t = 0; t < 4; t++) {
		if(party[t] == player) {
			n = t;
			break;
		}
	}			
	// switch to next player
	n++; if(n >= 4) n = 0;
	for(int t = 0; t < 4; t++) {
		if(!party[n]->getStateMod(Constants::dead)) {
			setPlayer(n);
			break;
		}
		n++; if(n >= 4) n = 0;
	}
	bool res = (oldPlayer != player);
	if(!res) partyDead = true;
	return res;
}

void Party::setPlayer(int n) {
  player = party[n];
  player->setNextDontMove(NULL, 0);
  //  player->setSelXY(-1, -1); // don't move
  // init the rest of the party
  int count = 1;
  for(int i = 0; i < 4; i++) {
	if(i != n) party[i]->setNextDontMove(player, count++);
  }

  //  move = 0;
  scourge->getMap()->refresh();
  scourge->getMap()->center(getPlayer()->getX(), getPlayer()->getY());
  player1Button->setSelected(false);
  player2Button->setSelected(false);
  player3Button->setSelected(false);
  player4Button->setSelected(false);
  switch(n) {
  case 0 : player1Button->setSelected(true); break;
  case 1 : player2Button->setSelected(true); break;
  case 2 : player3Button->setSelected(true); break;
  case 3 : player4Button->setSelected(true); break;
  }
  scourge->getMap()->center(player->getX(), player->getY(), true);
}

/**
   Setting the formation ends single-step mode (back to group mode).
 */
void Party::setFormation(int formation) {
  this->formation = formation;
  for(int i = 0; i < 4; i++) {
	party[i]->setFormation(formation);
  }
  player_only = false;

  groupButton->setSelected(!isPlayerOnly());
  startRound = true;
  roundButton->setSelected(startRound);
  diamondButton->setSelected(false);
  staggeredButton->setSelected(false);
  squareButton->setSelected(false);
  rowButton->setSelected(false);
  scoutButton->setSelected(false);
  crossButton->setSelected(false);
  switch(formation + Constants::DIAMOND_FORMATION) {
  case Constants::DIAMOND_FORMATION:
    diamondButton->setSelected(true); break;
  case Constants::STAGGERED_FORMATION:
    staggeredButton->setSelected(true); break;
  case Constants::SQUARE_FORMATION:
    squareButton->setSelected(true); break;
  case Constants::ROW_FORMATION:
    rowButton->setSelected(true); break;
  case Constants::SCOUT_FORMATION:
    scoutButton->setSelected(true); break;
  case Constants::CROSS_FORMATION:
    crossButton->setSelected(true); break;
  }
}

void Party::togglePlayerOnly() {
  player_only = (player_only ? false : true);
  // in group mode everyone hunts the same creature
  if(!player_only) {
	for(int i = 0; i < 4; i++) {
	  if(party[i] != player) 
		party[i]->setTargetCreature(player->getTargetCreature());
	}
  }
  if(player_only)
	scourge->getMap()->addDescription(Constants::getMessage(Constants::SINGLE_MODE), 0.5f, 0.5f, 1.0f);
  else
	scourge->getMap()->addDescription(Constants::getMessage(Constants::GROUP_MODE), 0.5f, 0.5f, 1.0f);
  groupButton->setSelected(!isPlayerOnly());
}

void Party::forceStopRound() {
  startRound = false;
  toggleRound();
}

void Party::toggleRound(bool test) {
  if(startRound == test) toggleRound();
}

void Party::toggleRound() {
  startRound = (startRound ? false : true);
  if(startRound){
	scourge->getMap()->addDescription(Constants::getMessage(Constants::REAL_TIME_MODE), 0.5f, 0.5f, 1.0f);
  }
  else{
	scourge->getMap()->addDescription(Constants::getMessage(Constants::TURN_MODE), 0.5f, 0.5f, 1.0f);    
  }
   
  // Freeze / unfreeze calendar
  calendar->setPause(!startRound); 
  
  // Freeze / unfreeze animations
  for(int i = 0; i < getPartySize(); i++){
    getParty(i)->getShape()->setPauseAnimation(!startRound);
  }  
  for(int i = 0; i < scourge->getCreatureCount(); i++){
    scourge->getCreature(i)->getShape()->setPauseAnimation(!startRound);
  } 
  roundButton->setSelected(startRound);
}

void Party::setTargetCreature(Creature *creature) { 
  if(player_only) {
	player->setTargetCreature(creature);
  } else {
	for(int i = 0; i < getPartySize(); i++) {
	  party[i]->setTargetCreature(creature); 
	}
  }
}

void Party::movePlayers() {   
  if(player_only) {	
	// move everyone
	for(int i = 0; i < getPartySize(); i++) {
	  if(!party[i]->getStateMod(Constants::dead)) {
		party[i]->moveToLocator(scourge->getMap());
	  }
	}
	// center on player
	scourge->getMap()->center(player->getX(), player->getY());
  } else {
	// In group mode:
	
	// move the leader
	if(!player->getStateMod(Constants::dead)) {
	  player->moveToLocator(scourge->getMap());
	  scourge->getMap()->center(player->getX(), player->getY());
	}
	
	// others follow the player
	for(int t = 0; t < getPartySize(); t++) {
	  if(!party[t]->getStateMod(Constants::dead) && party[t] != player) {
		party[t]->moveToLocator(scourge->getMap());
	  }
	}	
  }
}

int Party::getTotalLevel() {
  int totalLevel = 0;
  for(int i = 0; i < scourge->getParty()->getPartySize(); i++) 
	totalLevel += scourge->getParty()->getParty(i)->getLevel();
  return totalLevel;
}

/**
   Create a party programmatically until the party editor is made.
 */
Creature **Party::createHardCodedParty() {
  Creature **pc = (Creature**)malloc(sizeof(Creature*) * 4);

  // FIXME: consider using newCreature here
  // the end of startMission would have to be modified to not delete the party
  // also in scourge, where-ever creatureCount is used to mean all monsters would have
  // to change (maybe that's a good thing too... same logic for party and monsters)
  pc[0] = new Creature(scourge, Character::getCharacterByName("Assassin"), "Alamont");
  pc[0]->setLevel(1); 
  pc[0]->setExp(300);
  pc[0]->setHp();
  pc[0]->setMp();
  pc[0]->setHunger(8);
  pc[0]->setThirst(7); 
  pc[0]->setStateMod(Constants::blessed, true);
  pc[0]->setStateMod(Constants::poisoned, true);

  pc[1] = new Creature(scourge, Character::getCharacterByName("Knight"), "Barlett");
  pc[1]->setLevel(1); 
  pc[1]->setExp(200);
  pc[1]->setHp();
  pc[1]->setMp();
  pc[1]->setHunger(10);
  pc[1]->setThirst(9);
  pc[1]->setStateMod(Constants::drunk, true);
  pc[1]->setStateMod(Constants::cursed, true);      

  pc[2] = new Creature(scourge, Character::getCharacterByName("Summoner"), "Corinus");
  pc[2]->setLevel(3); 
  pc[2]->setExp(150);
  pc[2]->setHp();
  pc[2]->setMp();
  pc[2]->setHunger(3);
  pc[2]->setThirst(2);
  pc[2]->setStateMod(Constants::ac_protected, true);
  pc[2]->setStateMod(Constants::magic_protected, true);
  pc[2]->setStateMod(Constants::cursed, true);
  //  for(int i = 0; i < Constants::STATE_MOD_COUNT; i++) 
  //  	if(i != Constants::dead) pc[2]->setStateMod(i, true);

  pc[3] = new Creature(scourge, Character::getCharacterByName("Naturalist"), "Dialante");    
  pc[3]->setLevel(1); 
  pc[3]->setExp(400);
  pc[3]->setHp();
  pc[3]->setMp();
  pc[3]->setHunger(10);
  pc[3]->setThirst(10);
  pc[3]->setStateMod(Constants::possessed, true);          
  
  // compute starting skill levels
  for(int i = 0; i < 4; i++) {
	for(int skill = 0; skill < Constants::SKILL_COUNT; skill++) {
	  int n = pc[i]->getCharacter()->getMinSkillLevel(skill) + (int)(20.0 * rand()/RAND_MAX);
	  if(n > pc[i]->getCharacter()->getMaxSkillLevel(skill)) 
		n = pc[i]->getCharacter()->getMaxSkillLevel(skill);
	  pc[i]->setSkill(skill, n);
	}
  }

  // add some items
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Bastard sword")));
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Horned helmet")));
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Dagger")));
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Minor health potion")));  
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Minor health potion")));  
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Liquid armor")));  
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Potion of Speed")));
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Potion of Coordination")));
  pc[0]->addInventory(scourge->newItem(RpgItem::getItemByName("Potion of Power")));