src/hcode/btech/mech.avail.c

Go to the documentation of this file.

/*
 * $Id: mech.avail.c,v 1.1.1.1 2005/01/11 21:18:11 kstevens Exp $
 *
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1996 Markus Stenberg
 *       All rights reserved
 *
 * Created: Fri Nov  8 19:53:17 1996 fingon
 * Last modified: Sat Jun  6 22:11:41 1998 fingon
 *
 */

/* Code to use the availability headers made by Nim */

#include <stdio.h>

#include "mech.h"
#include "mech.avail.h"
#include "coolmenu.h"
#include "mycool.h"
#include "p.template.h"
#include "p.mech.mechref_ident.h"

#define IsMech(i) ((i) < NUM_MECHA)
#define IsAero(i) ((i) >= NUM_MECHA && (i) < (NUM_MECHA + NUM_AEROS))

#define Table(id,fi) \
(IsMech(id) ? mech_availability[id].fi : \
 IsAero(id) ? aero_availability[id - NUM_MECHA].fi : 0)

static int find_score(int table, int id)
{
        switch (table) {
#undef Map
#define Map(a,b) case a: return Table(id,b); break;
                Map(FAC_FS, FS);
                Map(FAC_LC, LC);
                Map(FAC_DC, DC);
                Map(FAC_CC, CC);
                Map(FAC_FWL, FWL);
                Map(FAC_MISC, MISC);
                Map(FAC_MERC, MERC);
        case FAC_FC:
                return (find_score(FAC_FS, id) + find_score(FAC_LC, id)) / 2;
#undef Map
        }
        return 0;
}

/* Indeksointi:
   0 - NUM_MECHA-1                   = Mechs
   NUM_MECHA - NUM_MECHA+NUM_AEROS-1 = Aeros
 */

#define STACK_SIZE NUM_MECHA + NUM_AEROS

static void mech_list_maker(dbref player, int table, int types, int tons,
                                                        int opt, int max, int mode, char *tbuf)
{
        int mech_stack[STACK_SIZE][2];
        int i, j, k;
        int tp = 0;
        int dif;
        int count = 0, ftons = 0, otons = tons;
        coolmenu *c = NULL;
        const char *d;

        bzero(mech_stack, sizeof(mech_stack));
        for(i = 0; i < STACK_SIZE; i++) {
                if(!(types & 1) && IsMech(i))
                        continue;
                if(!(types & 2) && IsAero(i))
                        continue;
                j = find_score(table, i);
                if(opt) {
                        if((dif = abs(Table(i, tons) - opt)) > max && max)
                                continue;
                        j = j * (100 - dif) * (100 - dif);
                } else
                        j = j * 10000;
                if(!j)
                        continue;
                tp += j;
                mech_stack[i][0] = j;
        }
        if(!tp) {
                if(!mode)
                        notify(player, "No 'mechs matching that criteria!");
                else
                        strcpy(tbuf, tprintf("#-1 ERROR: NO UNITS WITH FLAG %d FOUND",
                                                                 types));
                return;
        }
        /* Ok.. We've made the table. Time to use it */
        while ((tons >= MAX(20, opt - max))) {
                i = Number(1, tp);
                for(j = 0; j < STACK_SIZE; j++) {
                        i -= mech_stack[j][0];
                        if(i <= 0)
                                break;
                }
                if((k = Table(j, tons)) > tons)
                        continue;
                mech_stack[j][1]++;
                tons -= k;
                count++;
                ftons += k;
        }
        /* We've a mech list. Time to show it :> */
        if(mode == 0) {
                addline();
                sim(tprintf("Mechs/Aeros/Whatever made for %s (%d tons)",
                                        side_names[table], otons), CM_ONE | CM_CENTER);
                addline();
                if(!count)
                        vsi("No mechs created? (Too low tonnage?)");
                else {
                        vsi(tprintf("%-4s %-10s %-20s %-6s %-s", "Tons", "Ref", "Name",
                                                "Chance", "Count"));
                        for(i = 0; i < STACK_SIZE; i++)
                                if(mech_stack[i][1]) {
                                        d = find_mechname_by_mechref(Table(i, name));
                                        vsi(tprintf("%4d %-10s %-20s %6.2f %d", Table(i, tons),
                                                                Table(i, name), d ? d : "Unknown",
                                                                (float) 100.0 * mech_stack[i][0] / tp,
                                                                mech_stack[i][1]));

                                }
                        addline();
                        vsi(tprintf("Avg weight: %.2f Total tons: %d",
                                                (float) ftons / count, ftons));
                }
                addline();
                ShowCoolMenu(player, c);
                KillCoolMenu(c);
        } else {
                *tbuf = 0;
                for(i = 0; i < STACK_SIZE; i++)
                        for(j = 0; j < mech_stack[i][1]; j++)
                                sprintf(tbuf + strlen(tbuf), "%s ", Table(i, name));
                if(*tbuf)
                        tbuf[strlen(tbuf) - 1] = 0;
        }
}

void debug_makemechs(dbref player, void *data, char *buffer)
{
        char *args[7];
        int argc;
        int table;
        int tons;
        int opt = 0;
        int max = 0;
        int types = 0xff;

        argc = mech_parseattributes(buffer, args, 6);
        DOCHECK(argc < 2, "Insufficient arguments!");
        DOCHECK(argc > 5, "Too many arguments!");
        DOCHECK((table =
                         compare_array(side_names_short, args[0])) < 0,
                        "Invalid faction name!");
        DOCHECK((tons = atoi(args[1])) < 20, "Invalid tonnage!");
        DOCHECK(tons > 4000, "Max of 4000 tons of mecha at once! Sowwy!");
        if(argc > 2) {
                DOCHECK(Readnum(types, args[2]), "Invalid type bitvector!");
                if(argc > 3) {
                        DOCHECK((opt = atoi(args[3])) < 20, "Invalid optTonnage!");
                        if(argc > 4)
                                DOCHECK((max = atoi(args[4])) < 5, "Invalid MaxDifference!");
                }
        }
        mech_list_maker(player, table, types, tons, opt, max, 0, NULL);
}

#define FUNCHECK(a,b) \
if (a) { safe_tprintf_str(buff, bufc, b); return; }

void fun_btmakemechs(char *buff, char **bufc, dbref player, dbref cause,
                                         char *fargs[], int nfargs, char *cargs[], int ncargs)
{
        /* fargs[0] = faction 
           fargs[1] = numtons
           fargs[2] = types
           fargs[3] = opttons
           fargs[4] = maxvar 
         */
        int table;
        int tons;
        int opt = 0;
        int max = 0;
        char buf[LBUF_SIZE];
        int types = 0xff;

        FUNCHECK(nfargs < 2, "#-1 Insufficient arguments!");
        FUNCHECK(nfargs > 5, "#-1 Too many arguments!");
        FUNCHECK((table =
                          compare_array(side_names_short, fargs[0])) < 0,
                         "#-1 Invalid faction name!");
        FUNCHECK((tons = atoi(fargs[1])) < 20, "#-1 Invalid tonnage!");
        FUNCHECK(tons > 4000, "#-1 Max of 4000 tons of mecha at once! Sowwy!");
        if(nfargs > 2) {
                FUNCHECK(Readnum(types, fargs[2]), "#-1 Invalid type bitvector!");
                if(nfargs > 3) {
                        FUNCHECK((opt = atoi(fargs[3])) < 20, "#-1 Invalid optTonnage!");
                        if(nfargs > 4)
                                FUNCHECK((max =
                                                  atoi(fargs[4])) < 5, "#-1 Invalid MaxDifference!");
                }
        }
        mech_list_maker(player, table, types, tons, opt, max, 1, buf);
        safe_tprintf_str(buff, bufc, "%s", buf);
}

---