mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-28 17:32:32 +12:00
03416d24e1
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
246 lines
12 KiB
C++
246 lines
12 KiB
C++
//
|
|
// Copyright 2020 Electronic Arts Inc.
|
|
//
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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 3 of the License, or (at your option) any later version.
|
|
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
|
|
// in the hope that it will be useful, but with permitted additional restrictions
|
|
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
|
// distributed with this program. You should have received a copy of the
|
|
// GNU General Public License along with permitted additional restrictions
|
|
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
|
|
|
/* $Header: /CounterStrike/FIXED.CPP 1 3/03/97 10:24a Joe_bostic $ */
|
|
/***********************************************************************************************
|
|
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
|
***********************************************************************************************
|
|
* *
|
|
* Project Name : Command & Conquer *
|
|
* *
|
|
* File Name : FIXED.CPP *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : 06/20/96 *
|
|
* *
|
|
* Last Update : July 3, 1996 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* fixed::As_ASCII -- Returns a pointer (static) of this number as an ASCII string. *
|
|
* fixed::To_ASCII -- Convert a fixed point number into an ASCII string. *
|
|
* fixed::fixed -- Constructor for fixed integral from ASCII initializer. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "fixed.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
|
|
/*
|
|
** These are some handy fixed point constants. Using these constants instead of manually
|
|
** constructing them is not only faster, but more readable.
|
|
*/
|
|
const fixed fixed::_1_2(1, 2); // 1/2
|
|
const fixed fixed::_1_3(1, 3); // 1/3
|
|
const fixed fixed::_1_4(1, 4); // 1/4
|
|
const fixed fixed::_3_4(3, 4); // 3/4
|
|
const fixed fixed::_2_3(2, 3); // 2/3
|
|
|
|
|
|
fixed::fixed(int numerator, int denominator)
|
|
{
|
|
if (denominator == 0) {
|
|
Data.Raw = 0U;
|
|
} else {
|
|
Data.Raw = (unsigned int)(((unsigned __int64)numerator * PRECISION) / denominator);
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* fixed::fixed -- Constructor for fixed integral from ASCII initializer. *
|
|
* *
|
|
* This will parse the ASCII initialization string into a fixed point number. *
|
|
* The source string can be a conventional fixed point representation (e.g., "1.0", ".25") *
|
|
* or a percent value (e.g. "100%", "25%", "150%"). For percent values, the trailing "%" *
|
|
* is required. *
|
|
* *
|
|
* INPUT: ascii -- Pointer to the ascii source to translate into a fixed point number. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: It is possible to specify an ASCII string that has more precision and *
|
|
* magnitude than can be represented by the fixed point number. In such a case, *
|
|
* the resulting value is undefined. *
|
|
* *
|
|
* HISTORY: *
|
|
* 06/20/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
fixed::fixed(char const * ascii)
|
|
{
|
|
/*
|
|
** If there is no valid pointer, then default to zero value. This takes care of any
|
|
** compiler confusion that would call this routine when the programmer wanted the
|
|
** integer parameter constructor to be called.
|
|
*/
|
|
if (ascii == NULL) {
|
|
Data.Raw = 0U;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
** The whole part (if any) always starts with the first legal characters.
|
|
*/
|
|
char const * wholepart = ascii;
|
|
|
|
/*
|
|
** Skip any leading white space.
|
|
*/
|
|
while (isspace(*ascii)) {
|
|
ascii++;
|
|
}
|
|
|
|
/*
|
|
** Determine if the number is expressed as a percentage. Detect this by
|
|
** seeing if there is a trailing "%" character.
|
|
*/
|
|
char const * tptr = ascii;
|
|
while (isdigit(*tptr)) {
|
|
tptr++;
|
|
}
|
|
|
|
/*
|
|
** Percentage value is specified as a whole number but is presumed to be
|
|
** divided by 100 to get mathematical fixed point percentage value.
|
|
*/
|
|
if (*tptr == '%') { // Removed '/' preceding '%'. ST - 5/8/2019
|
|
Data.Raw = (unsigned int)(((unsigned __int64)atoi(ascii) * PRECISION) / 100ULL);
|
|
} else {
|
|
|
|
Data.Composite.Whole = Data.Composite.Fraction = 0U;
|
|
if (wholepart && *wholepart != '.') {
|
|
Data.Composite.Whole = (unsigned short)atoi(wholepart);
|
|
}
|
|
|
|
const char * fracpart = strchr(ascii, '.');
|
|
if (fracpart) fracpart++;
|
|
if (fracpart) {
|
|
unsigned int frac = (unsigned int)atoi(fracpart);
|
|
|
|
int len = 0;
|
|
unsigned int base = 1;
|
|
char const * fptr = fracpart;
|
|
while (isdigit(*fptr)) {
|
|
fptr++;
|
|
len++;
|
|
base *= 10U;
|
|
}
|
|
|
|
Data.Composite.Fraction = (unsigned short)(((unsigned __int64)frac * PRECISION) / base);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* fixed::To_ASCII -- Convert a fixed point number into an ASCII string. *
|
|
* *
|
|
* Use this routine to convert this fixed point number into an ASCII null terminated *
|
|
* string. This is the counterpart to the fixed point constructor that takes an ASCII *
|
|
* string. *
|
|
* *
|
|
* INPUT: buffer -- Pointer to the buffer to hold the fixed point ASCII string. *
|
|
* *
|
|
* maxlen -- The length of the buffer. *
|
|
* *
|
|
* OUTPUT: Returns with the number of characters placed in the buffer. The trailing null is *
|
|
* not counted in this total. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/03/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
int fixed::To_ASCII(char * buffer, int maxlen) const
|
|
{
|
|
if (buffer == NULL) return(0);
|
|
|
|
/*
|
|
** Determine the whole and fractional parts of the number. The fractional
|
|
** part number is the value in 1000ths.
|
|
*/
|
|
unsigned int whole = Data.Composite.Whole;
|
|
unsigned int frac = ((unsigned int)Data.Composite.Fraction * 1000U) / PRECISION;
|
|
char tbuffer[32];
|
|
|
|
/*
|
|
** If there number consists only of a whole part, then the number is simply
|
|
** printed into the buffer. If there is a fractional part, then there
|
|
** will be a decimal place followed by up to three digits of accuracy for the
|
|
** fractional component.
|
|
*/
|
|
if (frac == 0) {
|
|
sprintf(tbuffer, "%u", whole);
|
|
} else {
|
|
sprintf(tbuffer, "%u.%02u", whole, frac);
|
|
|
|
char * ptr = &tbuffer[strlen(tbuffer)-1];
|
|
while (*ptr == '0') {
|
|
*ptr = '\0';
|
|
ptr--;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If no maximum length to the output buffer was specified, then presume the
|
|
** output buffer is just long enough to store the number and the trailing
|
|
** zero.
|
|
*/
|
|
if (maxlen == -1) {
|
|
maxlen = strlen(tbuffer)+1;
|
|
}
|
|
|
|
/*
|
|
** Fill the output buffer with the ASCII number.
|
|
*/
|
|
strncpy(buffer, tbuffer, maxlen);
|
|
|
|
/*
|
|
** Return with the number of ASCII characters placed into the output buffer.
|
|
*/
|
|
int len = strlen(tbuffer);
|
|
if (len < maxlen-1) return(len);
|
|
return(maxlen-1);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* fixed::As_ASCII -- Returns a pointer (static) of this number as an ASCII string. *
|
|
* *
|
|
* This number will be converted into an ASCII string (using a static buffer) and the *
|
|
* string pointer will be returned. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the ASCII representation of this fixed point number. *
|
|
* *
|
|
* WARNINGS: As with all static return pointers, the pointer is valid only until such time *
|
|
* as this routine is called again. *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/03/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
char const * fixed::As_ASCII(void) const
|
|
{
|
|
static char buffer[32];
|
|
|
|
To_ASCII(buffer, sizeof(buffer));
|
|
return(buffer);
|
|
}
|