Lucas de Vries
1100 lines
22 KiB
ActionScript
1100 lines
22 KiB
ActionScript
export NotifyType, NotifyTriggerMode, Notification;
|
|
export yieldNotification, receiveNotifications;
|
|
export createNotification, readNotification, loadNotification;
|
|
export VoteNotification;
|
|
export WarStatusNotification, WarStatusType;
|
|
export WarEventNotification, WarEventType;
|
|
export WonderNotification;
|
|
export CardNotification;
|
|
export RenameNotification;
|
|
export AnomalyNotification;
|
|
export FlagshipBuiltNotification;
|
|
export StructureBuiltNotification;
|
|
export EmpireMetNotification;
|
|
export GenericNotification;
|
|
export TreatyEventNotification, TreatyEventType;
|
|
export DonationNotification;
|
|
|
|
import influence;
|
|
from influence import ICardNotification, TreatyEventType;
|
|
import saving;
|
|
import util.formatting;
|
|
import buildings;
|
|
import icons;
|
|
|
|
enum NotifyType {
|
|
NT_Vote,
|
|
NT_WarStatus,
|
|
NT_WarEvent,
|
|
NT_Wonder,
|
|
NT_Card,
|
|
NT_Renamed,
|
|
NT_Anomaly,
|
|
NT_FlagshipBuilt,
|
|
NT_StructureBuilt,
|
|
NT_Generic,
|
|
NT_MetEmpire,
|
|
NT_TreatyEvent,
|
|
NT_Donation,
|
|
|
|
NT_COUNT,
|
|
NT_INVALID,
|
|
};
|
|
|
|
enum NotifyTriggerMode {
|
|
NTM_Ignore,
|
|
NTM_KillClass,
|
|
NTM_KillEvents,
|
|
NTM_KillTop
|
|
};
|
|
|
|
// {{{ Basic Notification
|
|
class Notification : Serializable, Savable {
|
|
double time = gameTime;
|
|
|
|
//Way that events are dismissed when viewed
|
|
NotifyTriggerMode get_triggerMode() const {
|
|
return NTM_KillEvents;
|
|
}
|
|
|
|
//The class context specifier for out-of-context notifications
|
|
string formatClass() const {
|
|
return "";
|
|
}
|
|
|
|
//The textual string of this notification
|
|
string formatEvent() const {
|
|
return "";
|
|
}
|
|
|
|
//Notification sound to play when the notice appears
|
|
const SoundSource@ get_sound() const {
|
|
return sound::alert_generic;
|
|
}
|
|
|
|
//The iconic representation of this notification
|
|
Sprite get_icon() const {
|
|
return Sprite();
|
|
}
|
|
|
|
//Model to display 3D icon
|
|
const Model@ get_model() const {
|
|
return null;
|
|
}
|
|
|
|
//Material to display 3D icon
|
|
const Material@ get_material() const {
|
|
return null;
|
|
}
|
|
|
|
//Whether to pulse the icon
|
|
bool get_pulseIcon() const {
|
|
return false;
|
|
}
|
|
|
|
//The type of notification
|
|
NotifyType get_type() const {
|
|
return NT_INVALID;
|
|
}
|
|
|
|
//Object that this notification relates to
|
|
Object@ get_relatedObject() const {
|
|
return null;
|
|
}
|
|
|
|
//How many times the icon should flash when this event happens
|
|
int get_flashCount() const {
|
|
return 3;
|
|
}
|
|
|
|
//Should be transitive and commutative, or weirdness can happen.
|
|
bool sharesClass(const Notification& other) const {
|
|
return false;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) {
|
|
msg << uint(type);
|
|
msg << time;
|
|
}
|
|
|
|
void read(Message& msg) {
|
|
msg >> time;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) {
|
|
file << uint(type);
|
|
file << time;
|
|
}
|
|
|
|
void load(SaveFile& file) {
|
|
file >> time;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Vote Notification
|
|
class VoteNotification : Notification {
|
|
InfluenceVoteStub vote;
|
|
InfluenceVoteEvent event;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Vote;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return Sprite(spritesheet::Notifications, 0);
|
|
}
|
|
|
|
string formatClass() const override {
|
|
if(vote.startedBy is defaultEmpire)
|
|
return vote.formatTitle();
|
|
return formatEmpireName(vote.startedBy)+": "+vote.formatTitle();
|
|
}
|
|
|
|
bool sharesClass(const Notification& other) const override {
|
|
const VoteNotification@ notif = cast<const VoteNotification>(other);
|
|
if(notif is null)
|
|
return false;
|
|
return notif.vote.id == vote.id;
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
return event.formatEvent();
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << vote;
|
|
msg << event;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> vote;
|
|
msg >> event;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << vote;
|
|
file << event;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> vote;
|
|
file >> event;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Card Notification
|
|
class CardNotification : Notification, ICardNotification {
|
|
InfluenceCardPlayEvent event;
|
|
InfluenceCard@ subjectCard;
|
|
InfluenceEffect@ subjectEffect;
|
|
int voteId = -1;
|
|
|
|
NotifyTriggerMode get_triggerMode() const {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Card;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return event.card.type.icon;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return formatEmpireName(event.card.owner)+": "+event.card.formatTitle();
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
return event.formatNotification(this);
|
|
}
|
|
|
|
Object@ get_relatedObject() const {
|
|
for(uint i = 0, cnt = event.targets.length; i < cnt; ++i) {
|
|
auto@ targ = event.targets[i];
|
|
if(targ.obj !is null)
|
|
return targ.obj;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << event;
|
|
msg << voteId;
|
|
|
|
if(subjectCard !is null) {
|
|
msg.write1();
|
|
msg << subjectCard;
|
|
}
|
|
else {
|
|
msg.write0();
|
|
}
|
|
|
|
if(subjectEffect !is null) {
|
|
msg.write1();
|
|
msg << subjectEffect;
|
|
}
|
|
else {
|
|
msg.write0();
|
|
}
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> event;
|
|
msg >> voteId;
|
|
|
|
if(msg.readBit()) {
|
|
if(subjectCard is null)
|
|
@subjectCard = InfluenceCard(msg);
|
|
else
|
|
msg >> subjectCard;
|
|
}
|
|
|
|
if(msg.readBit()) {
|
|
if(subjectEffect is null)
|
|
@subjectEffect = InfluenceEffect(msg);
|
|
else
|
|
msg >> subjectEffect;
|
|
}
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << event;
|
|
file << voteId;
|
|
|
|
if(subjectCard !is null) {
|
|
file.write1();
|
|
file << subjectCard;
|
|
}
|
|
else {
|
|
file.write0();
|
|
}
|
|
|
|
if(subjectEffect !is null) {
|
|
file.write1();
|
|
file << subjectEffect;
|
|
}
|
|
else {
|
|
file.write0();
|
|
}
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> event;
|
|
if(file >= SV_0080)
|
|
file >> voteId;
|
|
|
|
if(file.readBit()) {
|
|
if(subjectCard is null)
|
|
@subjectCard = InfluenceCard(file);
|
|
else
|
|
file >> subjectCard;
|
|
}
|
|
|
|
if(file.readBit()) {
|
|
if(subjectEffect is null)
|
|
@subjectEffect = InfluenceEffect(file);
|
|
else
|
|
file >> subjectEffect;
|
|
}
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ War Status Notification
|
|
enum WarStatusType {
|
|
WST_War,
|
|
WST_ProposePeace,
|
|
WST_AcceptPeace,
|
|
};
|
|
|
|
class WarStatusNotification : Notification {
|
|
Empire@ withEmpire;
|
|
uint statusType;
|
|
|
|
NotifyTriggerMode get_triggerMode() const override {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_WarStatus;
|
|
}
|
|
|
|
const SoundSource@ get_sound() const {
|
|
if(statusType == WST_War)
|
|
return sound::alert_combat;
|
|
else
|
|
return sound::alert_generic;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return Sprite(spritesheet::Notifications, 1);
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return format(locale::WAR_STATUS, formatEmpireName(withEmpire));
|
|
}
|
|
|
|
bool sharesClass(const Notification& other) const override {
|
|
const WarStatusNotification@ notif = cast<const WarStatusNotification>(other);
|
|
return notif !is null && notif.withEmpire is withEmpire;
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
switch(statusType) {
|
|
case WST_War:
|
|
return format(locale::WAR_STATUS_WAR, formatEmpireName(withEmpire));
|
|
case WST_ProposePeace:
|
|
return format(locale::WAR_STATUS_PROPOSE, formatEmpireName(withEmpire));
|
|
case WST_AcceptPeace:
|
|
return format(locale::WAR_STATUS_ACCEPT, formatEmpireName(withEmpire));
|
|
}
|
|
return "--";
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << withEmpire;
|
|
msg << statusType;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> withEmpire;
|
|
msg >> statusType;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << withEmpire;
|
|
file << statusType;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> withEmpire;
|
|
file >> statusType;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ War Event Notification
|
|
enum WarEventType {
|
|
WET_ContestedSystem,
|
|
WET_LostPlanet,
|
|
};
|
|
|
|
class WarEventNotification : Notification {
|
|
Object@ obj;
|
|
uint eventType;
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return obj;
|
|
}
|
|
|
|
NotifyTriggerMode get_triggerMode() const override {
|
|
return NTM_KillTop;
|
|
}
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_WarEvent;
|
|
}
|
|
|
|
const SoundSource@ get_sound() const {
|
|
if(eventType == WET_LostPlanet)
|
|
return sound::alert_lostasset;
|
|
else
|
|
return sound::alert_combat;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
switch(eventType) {
|
|
case WET_LostPlanet:
|
|
return Sprite(spritesheet::Notifications, 2);
|
|
}
|
|
return Sprite(material::SystemUnderAttack);
|
|
}
|
|
|
|
string formatClass() const override {
|
|
Region@ region = cast<Region>(obj);
|
|
if(region is null)
|
|
@region = obj.region;
|
|
if(region is null)
|
|
return format(locale::WAR_EVT, "--");
|
|
return format(locale::WAR_EVT, region.name);
|
|
}
|
|
|
|
bool sharesClass(const Notification& other) const override {
|
|
const WarEventNotification@ notif = cast<const WarEventNotification>(other);
|
|
if(notif is null)
|
|
return false;
|
|
|
|
const Region@ myRegion = cast<const Region@>(obj);
|
|
if(myRegion is null)
|
|
@myRegion = obj.region;
|
|
|
|
const Region@ theirRegion = cast<const Region@>(notif.obj);
|
|
if(theirRegion is null)
|
|
@theirRegion = notif.obj.region;
|
|
|
|
return myRegion !is null && myRegion is theirRegion;
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
switch(eventType) {
|
|
case WET_ContestedSystem:
|
|
return format(locale::WAR_EVT_CONTEST, obj.name);
|
|
case WET_LostPlanet:
|
|
return format(locale::WAR_EVT_LOST, obj.name);
|
|
}
|
|
return "--";
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << obj;
|
|
msg << eventType;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> obj;
|
|
msg >> eventType;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << obj;
|
|
file << eventType;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> obj;
|
|
file >> eventType;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Treaty Event Notification
|
|
class TreatyEventNotification : Notification {
|
|
Treaty treaty;
|
|
uint eventType;
|
|
Empire@ empOne;
|
|
Empire@ empTwo;
|
|
|
|
NotifyTriggerMode get_triggerMode() const override {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_TreatyEvent;
|
|
}
|
|
|
|
const SoundSource@ get_sound() const {
|
|
return sound::alert_generic;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
if(eventType == TET_Subjugate)
|
|
return Sprite(material::LoyaltyIcon);
|
|
return Sprite(material::Propositions);
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return treaty.name;
|
|
}
|
|
|
|
bool sharesClass(const Notification& other) const override {
|
|
const TreatyEventNotification@ notif = cast<const TreatyEventNotification>(other);
|
|
if(notif is null)
|
|
return false;
|
|
return notif.treaty.id == treaty.id;
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
string text = "---";
|
|
switch(eventType) {
|
|
case TET_Invite: text = empTwo is null ? locale::NOTIF_TREATY_INVITE_OTHER : locale::NOTIF_TREATY_INVITE; break;
|
|
case TET_Leave: text = locale::NOTIF_TREATY_LEAVE; break;
|
|
case TET_Dismiss: text = locale::NOTIF_TREATY_DISMISS; break;
|
|
case TET_Join: text = locale::NOTIF_TREATY_JOIN; break;
|
|
case TET_Decline: text = locale::NOTIF_TREATY_DECLINE; break;
|
|
case TET_Subjugate: text = locale::NOTIF_VASSAL; break;
|
|
}
|
|
return format(text, treaty.name,
|
|
formatEmpireName(empOne), formatEmpireName(empTwo),
|
|
formatEmpireName(treaty.leader),
|
|
treaty.leader !is null ? formatEmpireName(treaty.leader)+"'s '" : "");
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << treaty;
|
|
msg << eventType;
|
|
msg << empOne;
|
|
msg << empTwo;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> treaty;
|
|
msg >> eventType;
|
|
msg >> empOne;
|
|
msg >> empTwo;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << treaty;
|
|
file << eventType;
|
|
file << empOne;
|
|
file << empTwo;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> treaty;
|
|
file >> eventType;
|
|
file >> empOne;
|
|
file >> empTwo;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Wonder Notification
|
|
class WonderNotification : Notification {
|
|
Empire@ fromEmpire;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Wonder;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << fromEmpire;
|
|
|
|
uint did = 0;
|
|
msg << did;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> fromEmpire;
|
|
|
|
uint did = 0;
|
|
msg >> did;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << fromEmpire;
|
|
file.writeIdentifier(SI_PlanetDesignation, 0);
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> fromEmpire;
|
|
uint did = file.readIdentifier(SI_PlanetDesignation);
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Rename Notification
|
|
class RenameNotification : Notification {
|
|
Empire@ fromEmpire;
|
|
Object@ obj;
|
|
string fromName;
|
|
string toName;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Renamed;
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return obj;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
string txt = format(locale::RENAME_NOTIF, toName);
|
|
txt = format("[color=$1]$2[/color]", toString(fromEmpire.color), txt);
|
|
return txt;
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
return format(locale::RENAME_EVT, formatEmpireName(fromEmpire), fromName, toName);
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << fromEmpire;
|
|
msg << obj;
|
|
msg << fromName;
|
|
msg << toName;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> fromEmpire;
|
|
msg >> obj;
|
|
msg >> fromName;
|
|
msg >> toName;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << fromEmpire;
|
|
file << obj;
|
|
file << fromName;
|
|
file << toName;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> fromEmpire;
|
|
file >> obj;
|
|
file >> fromName;
|
|
file >> toName;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Anomaly Notification
|
|
class AnomalyNotification : Notification {
|
|
Object@ obj;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Anomaly;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
Region@ reg = obj.region;
|
|
if(reg !is null)
|
|
return format(locale::ANOMALY_NOTIFICATION, reg.name);
|
|
return format(locale::ANOMALY_NOTIFICATION, "???");
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return obj;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << obj;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> obj;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << obj;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> obj;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Generic Notification
|
|
class GenericNotification : Notification {
|
|
Empire@ fromEmp;
|
|
Object@ obj;
|
|
string iconDesc;
|
|
string title;
|
|
string desc;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Generic;
|
|
}
|
|
|
|
NotifyTriggerMode get_triggerMode() const {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
array<string>@ getParts() {
|
|
array<string> parts;
|
|
if(fromEmp !is null) {
|
|
parts.insertLast(bbescape(fromEmp.name));
|
|
parts.insertLast(toString(fromEmp.color));
|
|
}
|
|
else {
|
|
parts.insertLast("--");
|
|
parts.insertLast("#ffffff");
|
|
}
|
|
if(obj !is null) {
|
|
parts.insertLast(obj.name);
|
|
parts.insertLast(toString(obj.owner.color));
|
|
}
|
|
else {
|
|
parts.insertLast("--");
|
|
parts.insertLast("#ffffff");
|
|
}
|
|
return parts;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return format(localize(title), getParts());
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
return format(localize(desc), getParts());
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return getSprite(iconDesc);
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return obj;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << fromEmp;
|
|
msg << obj;
|
|
msg << iconDesc;
|
|
msg << title;
|
|
msg << desc;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> fromEmp;
|
|
msg >> obj;
|
|
msg >> iconDesc;
|
|
msg >> title;
|
|
msg >> desc;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << fromEmp;
|
|
file << obj;
|
|
file << iconDesc;
|
|
file << title;
|
|
file << desc;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> fromEmp;
|
|
file >> obj;
|
|
file >> iconDesc;
|
|
file >> title;
|
|
file >> desc;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Flagship Built Notification
|
|
class FlagshipBuiltNotification : Notification {
|
|
Object@ obj;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_FlagshipBuilt;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return format(locale::BUILT_NOTIFICATION, obj.name);
|
|
}
|
|
|
|
NotifyTriggerMode get_triggerMode() const {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return obj;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << obj;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> obj;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << obj;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> obj;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Structure Built Notification
|
|
class StructureBuiltNotification : Notification {
|
|
Object@ obj;
|
|
const BuildingType@ bldg;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_StructureBuilt;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return bldg.sprite;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return format(locale::BUILT_ON_NOTIFICATION, bldg.name, obj.name);
|
|
}
|
|
|
|
NotifyTriggerMode get_triggerMode() const {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return obj;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << obj;
|
|
msg.writeSmall(bldg.id);
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> obj;
|
|
uint tid = msg.readSmall();
|
|
@bldg = getBuildingType(tid);
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << obj;
|
|
file.writeIdentifier(SI_Building, bldg.id);
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> obj;
|
|
uint tid = file.readIdentifier(SI_Building);
|
|
@bldg = getBuildingType(tid);
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Empire Met Notification
|
|
class EmpireMetNotification : Notification {
|
|
Empire@ metEmpire;
|
|
Object@ region;
|
|
bool gainsBonus = false;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_MetEmpire;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return Sprite(metEmpire.portrait);
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return format(locale::NOTIF_MET_EMPIRE, formatEmpireName(metEmpire), region.name);
|
|
}
|
|
|
|
string formatEvent() const override {
|
|
if(!gainsBonus)
|
|
return "";
|
|
return format(locale::NOTIF_MET_EMPIRE_BONUS, formatEmpireName(metEmpire), region.name, toString(config::INFLUENCE_CONTACT_BONUS, 0));
|
|
}
|
|
|
|
NotifyTriggerMode get_triggerMode() const {
|
|
return NTM_KillClass;
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return region;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << metEmpire;
|
|
msg << region;
|
|
msg << gainsBonus;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> metEmpire;
|
|
msg >> region;
|
|
msg >> gainsBonus;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << metEmpire;
|
|
file << region;
|
|
file << gainsBonus;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> metEmpire;
|
|
file >> region;
|
|
if(file >= SV_0097)
|
|
file >> gainsBonus;
|
|
}
|
|
};
|
|
// }}}
|
|
// {{{ Donation Notification
|
|
class DonationNotification : Notification {
|
|
DiplomacyOffer offer;
|
|
Empire@ fromEmpire;
|
|
|
|
NotifyType get_type() const override {
|
|
return NT_Donation;
|
|
}
|
|
|
|
Sprite get_icon() const override {
|
|
return icons::Donate;
|
|
}
|
|
|
|
string formatClass() const override {
|
|
return format(locale::NOTIF_DONATION, formatEmpireName(fromEmpire), offer.blurb);
|
|
}
|
|
|
|
bool sharesClass(const Notification& other) const override {
|
|
const DonationNotification@ notif = cast<const DonationNotification>(other);
|
|
if(notif is null)
|
|
return false;
|
|
return notif.fromEmpire is fromEmpire;
|
|
}
|
|
|
|
NotifyTriggerMode get_triggerMode() const override {
|
|
return NTM_KillTop;
|
|
}
|
|
|
|
Object@ get_relatedObject() const override {
|
|
return offer.obj;
|
|
}
|
|
|
|
//Networking
|
|
void write(Message& msg) override {
|
|
Notification::write(msg);
|
|
msg << fromEmpire;
|
|
msg << offer;
|
|
}
|
|
|
|
void read(Message& msg) override {
|
|
Notification::read(msg);
|
|
msg >> fromEmpire;
|
|
msg >> offer;
|
|
}
|
|
|
|
//Saving and loading
|
|
void save(SaveFile& file) override {
|
|
Notification::save(file);
|
|
file << fromEmpire;
|
|
file << offer;
|
|
}
|
|
|
|
void load(SaveFile& file) override {
|
|
Notification::load(file);
|
|
file >> fromEmpire;
|
|
file >> offer;
|
|
}
|
|
};
|
|
// }}}
|
|
|
|
// {{{ Data management
|
|
//Sending a list of notifications through yielding
|
|
void yieldNotification(Notification@ n) {
|
|
n.write(startYield());
|
|
finishYield();
|
|
}
|
|
|
|
//Receiving notification from a datalist
|
|
class Receiver : Serializable {
|
|
Notification@ n;
|
|
void write(Message& msg) {
|
|
}
|
|
void read(Message& msg) {
|
|
@n = readNotification(msg);
|
|
}
|
|
};
|
|
void receiveNotifications(array<Notification@>& list, DataList@ data) {
|
|
Receiver recv;
|
|
while(receive(data, recv))
|
|
list.insertLast(recv.n);
|
|
}
|
|
|
|
//Interface for the empire
|
|
interface NotificationStore {
|
|
void addNotification(Empire& emp, Notification@ n);
|
|
}
|
|
|
|
//Notification generation through messages or savefiles
|
|
Notification@ createNotification(uint type) {
|
|
switch(type) {
|
|
case NT_Vote: return VoteNotification();
|
|
case NT_WarStatus: return WarStatusNotification();
|
|
case NT_WarEvent: return WarEventNotification();
|
|
case NT_Wonder: return WonderNotification();
|
|
case NT_Card: return CardNotification();
|
|
case NT_Renamed: return RenameNotification();
|
|
case NT_Anomaly: return AnomalyNotification();
|
|
case NT_FlagshipBuilt: return FlagshipBuiltNotification();
|
|
case NT_StructureBuilt: return StructureBuiltNotification();
|
|
case NT_MetEmpire: return EmpireMetNotification();
|
|
case NT_Generic: return GenericNotification();
|
|
case NT_TreatyEvent: return TreatyEventNotification();
|
|
case NT_Donation: return DonationNotification();
|
|
}
|
|
return Notification();
|
|
}
|
|
|
|
Notification@ readNotification(Message& msg) {
|
|
uint type = 0;
|
|
msg >> type;
|
|
|
|
Notification@ n = createNotification(type);
|
|
n.read(msg);
|
|
return n;
|
|
}
|
|
|
|
Notification@ loadNotification(SaveFile& file) {
|
|
uint type = 0;
|
|
file >> type;
|
|
|
|
Notification@ n = createNotification(type);
|
|
n.load(file);
|
|
return n;
|
|
}
|
|
// }}}
|