ef_verify: Reject invalid plane flag combinations
[empserver] / src / lib / subs / mslsub.c
1 /*
2  *  Empire - A multi-player, client/server Internet based war game.
3  *  Copyright (C) 1986-2021, Dave Pare, Jeff Bailey, Thomas Ruschak,
4  *                Ken Stevens, Steve McClure, Markus Armbruster
5  *
6  *  Empire is free software: you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation, either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  *
19  *  ---
20  *
21  *  See files README, COPYING and CREDITS in the root of the source
22  *  tree for related information and legal notices.  It is expected
23  *  that future projects/authors will amend these files as needed.
24  *
25  *  ---
26  *
27  *  mslsub.c: Missile subroutine stuff
28  *
29  *  Known contributors to this file:
30  *     Ken Stevens, 1995
31  *     Steve McClure, 1996-2000
32  *     Markus Armbruster, 2004-2021
33  */
34
35 #include <config.h>
36
37 #include <stdlib.h>
38 #include "chance.h"
39 #include "misc.h"
40 #include "nat.h"
41 #include "news.h"
42 #include "nsc.h"
43 #include "nuke.h"
44 #include "optlist.h"
45 #include "plague.h"
46 #include "plane.h"
47 #include "prototypes.h"
48 #include "queue.h"
49 #include "sect.h"
50 #include "ship.h"
51 #include "xy.h"
52
53 int
54 msl_launch(struct plnstr *pp, int type, char *what, coord x, coord y,
55            natid victim, int *sublaunchp)
56 {
57     struct shpstr ship;
58     struct nukstr nuke;
59     int sublaunch = 0;
60     char *base, *in_or_at, *from;
61
62     mpr(pp->pln_own, "Preparing to launch %s at %s %s %s%s\n",
63         prplane(pp),
64         cname(victim),
65         what,
66         type != EF_SECTOR ? "in " : "",
67         xyas(x, y, pp->pln_own));
68     if (pp->pln_ship >= 0) {
69         getship(pp->pln_ship, &ship);
70         base = prship(&ship);
71         in_or_at = " in ";
72         if (mchr[(int)ship.shp_type].m_flags & M_SUB) {
73             sublaunch = 1;
74             from = "in hatch";
75         } else
76             from = "on deck";
77     } else {
78         if (pp->pln_harden > 0) {
79             base = "missile silo";
80             in_or_at = " at ";
81             from = "in silo";
82         } else {
83             base = in_or_at = "";
84             from = "on launch pad";
85         }
86     }
87     mpr(pp->pln_own, "\tLaunching from %s%s%s\n",
88         base, in_or_at, xyas(pp->pln_x, pp->pln_y, pp->pln_own));
89
90     CANT_HAPPEN(pp->pln_flags & PLN_LAUNCHED);
91     pp->pln_flags |= PLN_LAUNCHED;
92     putplane(pp->pln_uid, pp);
93
94     if (chance((0.05 + (100 - pp->pln_effic) / 100.0)
95                * (1 - techfact(pp->pln_tech, 1.0)))) {
96         mpr(pp->pln_own, "KABOOOOM!  Missile explodes %s!\n", from);
97         if (getnuke(nuk_on_plane(pp), &nuke)) {
98             mpr(pp->pln_own, "%s lost!\n", prnuke(&nuke));
99             nuke.nuk_effic = 0;
100             putnuke(nuke.nuk_uid, &nuke);
101         }
102 #if 0
103         /*
104          * Disabled for now, because it breaks callers that call
105          * msl_launch() for each member of a list of planes, created
106          * by msl_sel() or perform_mission().  Damage to the base can
107          * damage other planes.  Any copies of them in the list become
108          * stale.  When msl_launch() modifies and writes back such a
109          * stale copy, the damage gets wiped out, triggering a seqno
110          * oops.
111          */
112         if (chance(0.33)) {
113             struct sctstr sect;
114             int dam;
115
116             dam = pln_damage(pp, 'p', NULL) / 2;
117             if (pp->pln_ship >= 0) {
118                 shipdamage(&ship, dam);
119                 putship(ship.shp_uid, &ship);
120             } else {
121                 mpr(pp->pln_own, "Explosion damages %s %d%%\n",
122                     xyas(pp->pln_x, pp->pln_y, pp->pln_own), dam);
123                 getsect(pp->pln_x, pp->pln_y, &sect);
124                 sectdamage(&sect, dam);
125                 putsect(&sect);
126             }
127         }
128 #endif
129         return -1;
130     }
131
132     mpr(pp->pln_own, "\tSHWOOOOOSH!  Missile launched!\n");
133
134     if (type != EF_PLANE)
135         mpr(victim, "Incoming %s missile sighted at %s...\n",
136             sublaunch ? "sub-launched" : cname(pp->pln_own),
137             xyas(x, y, victim));
138
139     if (type == EF_SECTOR || type == EF_LAND) {
140         if (msl_abm_intercept(pp, x, y, sublaunch))
141             return -1;
142     }
143     if (type == EF_SHIP) {
144         if (shp_missile_defense(x, y, pp->pln_own, pln_def(pp))) {
145             return -1;
146         }
147     }
148
149     if (sublaunchp)
150         *sublaunchp = sublaunch;
151     return 0;
152 }
153
154 int
155 msl_hit(struct plnstr *pp, int hardtarget, int type,
156         int news_item, int snews_item, int sublaunch, natid victim)
157 {
158     int hitchance, hit;
159
160     if (nuk_on_plane(pp) >= 0) {
161         mpr(pp->pln_own, "\tArming nuclear warheads...\n");
162         hit = 1;
163     } else {
164         hitchance = pln_hitchance(pp, hardtarget, type);
165         hit = pct_chance(hitchance);
166         mpr(pp->pln_own, "\t%d%% hit chance...%s\n", hitchance,
167             hit ? "HIT!" : "miss");
168     }
169
170     if (type != EF_PLANE)
171         mpr(victim, "...Incoming %s missile %s\n",
172             sublaunch ? "" : cname(pp->pln_own),
173             hit ? "HIT!\n" : "missed\n");
174     if (hit && news_item) {
175         if (sublaunch)
176             nreport(victim, snews_item, 0, 1);
177         else
178             nreport(pp->pln_own, news_item, victim, 1);
179     }
180     return hit;
181 }
182
183 void
184 msl_sel(struct emp_qelem *list, coord x, coord y, natid victim,
185         int wantflags, int nowantflags, int mission)
186 {
187     struct plchrstr *pcp;
188     struct plnstr plane;
189     struct plist *irv;
190     struct nstr_item ni;
191
192     emp_initque(list);
193     snxtitem_all(&ni, EF_PLANE);
194     while (nxtitem(&ni, &plane)) {
195         if (!plane.pln_own)
196             continue;
197
198         pcp = &plchr[(int)plane.pln_type];
199         if (!(pcp->pl_flags & P_M))
200             continue;
201         if (wantflags && (pcp->pl_flags & wantflags) != wantflags)
202             continue;
203         if (nowantflags && pcp->pl_flags & nowantflags)
204             continue;
205         if (mission && plane.pln_mission != mission)
206             continue;
207         if (mission &&
208             plane.pln_radius < mapdist(x, y, plane.pln_opx, plane.pln_opy))
209             continue;
210         if (relations_with(plane.pln_own, victim) >= NEUTRAL)
211             continue;
212         /* missiles go one way, so we can use all the range */
213         if (plane.pln_range < mapdist(x, y, plane.pln_x, plane.pln_y))
214             continue;
215         if (plane.pln_mobil <= 0)
216             continue;
217         if (plane.pln_effic < 100)
218             continue;
219         if (opt_MARKET) {
220             if (ontradingblock(EF_PLANE, &plane))
221                 continue;
222         }
223         if (!pln_airbase_ok(&plane, 1, 0))
224             continue;
225         /* got a valid interceptor */
226         irv = malloc(sizeof(*irv));
227         irv->load = 0;
228         irv->pstage = PLG_HEALTHY;
229         irv->pcp = &plchr[(int)plane.pln_type];
230         irv->plane = plane;
231         emp_insque(&irv->queue, list);
232     }
233 }
234
235 static int
236 msl_intercept(struct plnstr *msl, struct sctstr *sp, int sublaunch,
237               struct emp_qelem *irvlist, char *att_name, char *def_name,
238               int news_item)
239 {
240     struct plnstr *pp;
241     struct emp_qelem *intlist;
242     struct emp_qelem intfoo;
243     struct emp_qelem *qp;
244     struct emp_qelem *next;
245     struct plist *ip;
246     int icount = 0;
247     short destroyed;
248     char *who = sublaunch ? "" : cname(msl->pln_own);
249
250     intlist = &intfoo;
251     emp_initque(intlist);
252     /* First choose interceptors belonging to the target sector */
253     /* only allow two defense missiles per missile attack */
254     for (qp = irvlist->q_forw; qp != irvlist && icount < 2; qp = next) {
255         next = qp->q_forw;
256         ip = (struct plist *)qp;
257         pp = &ip->plane;
258         if (pp->pln_own != sp->sct_own)
259             continue;
260         if (mission_pln_equip(ip, NULL, 0) < 0) {
261             emp_remque(qp);
262             free(qp);
263             continue;
264         }
265         /* got one interceptor, delete from irv_list and
266          * add to  int_list.
267          */
268         emp_remque(qp);
269         emp_insque(qp, intlist);
270         putplane(pp->pln_uid, pp);
271         icount++;
272     }
273     /* only allow two defense missiles per missile attack */
274     for (qp = irvlist->q_forw; qp != irvlist && icount < 2; qp = next) {
275         next = qp->q_forw;
276         ip = (struct plist *)qp;
277         pp = &ip->plane;
278         if (mission_pln_equip(ip, NULL, 0) < 0) {
279             emp_remque(qp);
280             free(qp);
281             continue;
282         }
283         /* got one interceptor, delete from irv_list and
284          * add to  int_list.
285          */
286         emp_remque(qp);
287         emp_insque(qp, intlist);
288         putplane(pp->pln_uid, pp);
289         icount++;
290     }
291     /* Now, clean out the queue */
292     while (!QEMPTY(irvlist)) {
293         qp = irvlist->q_forw;
294         emp_remque(qp);
295         free(qp);
296     }
297     if (icount == 0) {
298         mpr(sp->sct_own, "No %ss launched to intercept.\n", def_name);
299         return 0;
300     }
301
302     /* attempt to destroy incoming missile */
303
304     destroyed = 0;
305     while (!destroyed && !QEMPTY(intlist)) {
306         qp = intlist->q_forw;
307         ip = (struct plist *)qp;
308         pp = &ip->plane;
309
310         mpr(msl->pln_own, "%s %s launched in defense!\n",
311             cname(pp->pln_own), def_name);
312         if (sp->sct_own == pp->pln_own) {
313             mpr(sp->sct_own, "%s launched to intercept %s %s!\n",
314                 def_name, who, att_name);
315         } else {
316             mpr(sp->sct_own,
317                 "%s launched an %s to intercept the %s %s!\n",
318                 cname(pp->pln_own), def_name, who, att_name);
319             mpr(pp->pln_own,
320                 "%s launched to intercept %s %s arcing towards %s territory!\n",
321                 def_name, who, att_name, cname(sp->sct_own));
322         }
323
324         if (msl_launch(pp, EF_PLANE, att_name, sp->sct_x, sp->sct_y,
325                        msl->pln_own, NULL) >= 0
326             && msl_hit(pp, pln_def(msl), EF_PLANE, 0, 0, 0, msl->pln_own)) {
327             mpr(msl->pln_own, "%s destroyed by %s %s!\n",
328                 att_name, cname(pp->pln_own), def_name);
329             mpr(sp->sct_own, "%s %s intercepted!\n", who, att_name);
330             if (sp->sct_own != pp->pln_own)
331                 mpr(pp->pln_own, "%s %s intercepted!\n", who, att_name);
332             if (sublaunch)
333                 nreport(pp->pln_own, news_item, 0, 1);
334             else
335                 nreport(pp->pln_own, news_item, msl->pln_own, 1);
336             destroyed = 1;
337         }
338         /* zap the missile */
339         pp->pln_effic = 0;
340         putplane(pp->pln_uid, pp);
341         emp_remque(qp);
342         free(qp);
343     }
344     /* Clean out what is left in the list */
345     while (!QEMPTY(intlist)) {
346         qp = intlist->q_forw;
347         emp_remque(qp);
348         free(qp);
349     }
350     if (destroyed)
351         return 1;
352     if (icount) {
353         mpr(msl->pln_own, "%s made it through %s defenses!\n",
354             att_name, def_name);
355         mpr(sp->sct_own, "%s made it through %s defenses!\n",
356             att_name, def_name);
357     }
358     return 0;
359 }
360
361 int
362 msl_abm_intercept(struct plnstr *msl, coord x, coord y, int sublaunch)
363 {
364     struct sctstr sect;
365     struct emp_qelem irvlist;
366
367     getsect(x, y, &sect);
368     msl_sel(&irvlist, x, y, msl->pln_own, P_N, 0, 0);
369     return msl_intercept(msl, &sect, sublaunch,
370                          &irvlist, "warhead", "abm",
371                          sublaunch ? N_NUKE_SSTOP : N_NUKE_STOP);
372 }
373
374 int
375 msl_asat_intercept(struct plnstr *msl, coord x, coord y)
376 {
377     struct sctstr sect;
378     struct emp_qelem irvlist;
379
380     getsect(x, y, &sect);
381     mpr(sect.sct_own, "%s has positioned a satellite over %s\n",
382         cname(msl->pln_own), xyas(x, y, sect.sct_own));
383     msl_sel(&irvlist, x, y, msl->pln_own, P_O, 0, 0);
384     return msl_intercept(msl, &sect, 0,
385                          &irvlist, "satellite", "a-sat missile",
386                          N_SAT_KILL);
387 }