* added support for non-damaging multi-target spells

* fixed not updating menu in battles

CBattleInterface.cpp

@@ -386,6 +386,8 @@ void CBattleInterface::show(SDL_Surface * to)
 	}
 
 	
+	SDL_SetClipRect(to, &buf); //restoring previous clip_rect
+
 	//showing menu background and console
 	blitAt(menu, pos.x, 556 + pos.y, to);
 	console->show(to);
@@ -401,6 +403,10 @@ void CBattleInterface::show(SDL_Surface * to)
 	bConsoleUp->show(to);
 	bConsoleDown->show(to);
 
+	
+	SDL_GetClipRect(to, &buf);
+	SDL_SetClipRect(to, &pos);
+
 	//showing hero animations
 	if(attackingHero)
 		attackingHero->show(to);
@@ -1418,6 +1424,26 @@ void CBattleInterface::battleFinished(const BattleResult& br)
 void CBattleInterface::spellCasted(SpellCasted * sc)
 {
 	std::vector< std::string > anims; //for magic arrow and ice bolt
+
+#define DISPLAY2(SP_ID) \
+			if(sc->skill < 3) \
+			{ \
+				displayEffect(SP_ID, sc->tile); \
+			} \
+			else \
+			{ \
+				std::map<int, CStack> stacks = LOCPLINT->cb->battleGetStacks(); \
+				for(std::map<int, CStack>::iterator it = stacks.begin(); it!=stacks.end(); ++it) \
+				{ \
+					if((CGI->spellh->spells[sc->id].positiveness >= 0 && it->second.owner == LOCPLINT->playerID) \
+						||(CGI->spellh->spells[sc->id].positiveness <= 0 && it->second.owner != LOCPLINT->playerID ) \
+						) \
+					{ \
+						displayEffect(SP_ID, it->second.position); \
+					} \
+				} \
+			}  
+
 	switch(sc->id)
 	{
 	case 15: //magic arrow
@@ -1492,65 +1518,68 @@ void CBattleInterface::spellCasted(SpellCasted * sc)
 		}
 	case 27: //shield
 		{
-			displayEffect(27, sc->tile);
+			DISPLAY2(27);
 			break;
 		}
 	case 28: //air shield
 		{
-			displayEffect(2, sc->tile);
+			DISPLAY2(2);
 			break;
 		}
 	case 41: //bless
 		{
-			displayEffect(36, sc->tile);
+			DISPLAY2(36);
 			break;
 		}
 	case 42: //curse
 		{
-			displayEffect(40, sc->tile);
+			DISPLAY2(40);
 			break;
 		}
 	case 43: //bloodlust
 		{
-			displayEffect(4, sc->tile); //TODO: give better animation for this spell
+			DISPLAY2(4);
+			//TODO: give better animation for this spell
 			break;
 		}
 	case 45: //weakness
 		{
-			displayEffect(56, sc->tile); //TODO: give better animation for this spell
+			DISPLAY2(56);
+			//TODO: give better animation for this spell
 			break;
 		}
 	case 46: //stone skin
 		{
-			displayEffect(54, sc->tile);
+			DISPLAY2(54);
 			break;
 		}
 	case 48: //prayer
 		{
-			displayEffect(0, sc->tile);
+			DISPLAY2(0);
 			break;
 		}
 	case 53: //haste
 		{
-			displayEffect(31, sc->tile);
+			DISPLAY2(31);
 			break;
 		}
 	case 54: //slow
 		{
-			displayEffect(19, sc->tile);
+			DISPLAY2(19);
 			break;
 		}
 	case 56: //frenzy
 		{
-			displayEffect(17, sc->tile);
+			DISPLAY2(17);
 			break;
 		}
 	case 61: //forgetfulness
 		{
-			displayEffect(42, sc->tile);
+			DISPLAY2(42);
 			break;
 		}
 	}
+#undef DISPLAY2
 }
 
 void CBattleInterface::castThisSpell(int spellID)

server/CGameHandler.cpp

@@ -1313,121 +1313,361 @@ upgend:
 							case 27: //shield
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 27;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 27;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 28: //air shield
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 28;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 28;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 41: //bless
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 41;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 41;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 42: //curse
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 42;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 42;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 43: //bloodlust
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 43;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 43;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 45: //weakness
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 45;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 45;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 46: //stone skin
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 46;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 46;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 48: //prayer
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 48;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 48;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 53: //haste
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 53;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 53;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 54: //slow
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 54;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 54;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 56: //frenzy
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 56;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = 1; //! - different duration
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 56;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							case 61: //forgetfulness
 								{
 									SetStackEffect sse;
+									if(getSchoolLevel(h,s) < 3) //not expert
+									{
 										sse.stack = gs->curB->getStackT(ba.destinationTile)->ID;
 										sse.effect.id = 61;
 										sse.effect.level = getSchoolLevel(h,s);
 										sse.effect.turnsRemain = h->getPrimSkillLevel(2);
 										sendAndApply(&sse);
+									}
+									else
+									{
+										for(int it=0; it<gs->curB->stacks.size(); ++it)
+										{
+											//if it's non negative spell and our unit or non positive spell and hostile unit
+											if((VLC->spellh->spells[ba.additionalInfo].positiveness >= 0 && gs->curB->stacks[it]->owner == h->tempOwner)
+												||(VLC->spellh->spells[ba.additionalInfo].positiveness <= 0 && gs->curB->stacks[it]->owner != h->tempOwner )
+												)
+											{
+												sse.stack = gs->curB->stacks[it]->ID;
+												sse.effect.id = 61;
+												sse.effect.level = getSchoolLevel(h,s);
+												sse.effect.turnsRemain = h->getPrimSkillLevel(2);
+												sendAndApply(&sse);
+											}
+										}
+									}
 									break;
 								}
 							}