blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 268 | content_id stringlengths 40 40 | detected_licenses listlengths 0 58 | license_type stringclasses 2
values | repo_name stringlengths 5 118 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 816
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 2.31k 677M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 151
values | src_encoding stringclasses 33
values | language stringclasses 1
value | is_vendor bool 2
classes | is_generated bool 2
classes | length_bytes int64 3 10.3M | extension stringclasses 119
values | content stringlengths 3 10.3M | authors listlengths 1 1 | author_id stringlengths 0 228 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9c73ff8f659424e0f11e8328fd6bdcd8aa8a248e | 345b4f965b515a3387fdba062a075816398e384c | /src/lib/rt/src/os_eln/rt_io_m_co_7437_33.c | a0ce3db837ed3446ec11f39956b011e265e7a755 | [] | no_license | hfuhuang/proview | 4fd0bf089aa6e3a303aea666652e5046cf5855d7 | 4172df2ae577ff3202e29f28e0afdbe0cc8780a6 | refs/heads/master | 2020-12-24T17:17:05.556911 | 2010-01-14T15:16:16 | 2010-01-14T15:16:16 | null | 0 | 0 | null | null | null | null | ISO-8859-1 | C | false | false | 6,270 | c | /*
* Proview $Id: rt_io_m_co_7437_33.c,v 1.2 2005-09-01 14:57:56 claes Exp $
* Copyright (C) 2005 SSAB Oxelösund AB.
*
* This program 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 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with the program, if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* io_m_ssab_pi.c -- io methods for ssab cards. */
#if defined(OS_ELN)
# include string
# include stdlib
# include stdio
# include descrip
#else
# include <string.h>
# include <stdlib.h>
# include <stdio.h>
# include <descrip.h>
#endif
#include "pwr.h"
#include "rt_errh.h"
#include "pwr_baseclasses.h"
#include "rt_io_base.h"
#include "rt_io_msg.h"
#if defined(OS_ELN)
#include "rt_io_rtp.h"
#endif
#include "rt_io_card_init.h"
#include "rt_io_card_close.h"
#include "rt_io_card_read.h"
#define IO_MAXCHAN 4
#define RTP_CO_7435_33 40
#define RTP_CO_7437_33 41
/*----------------------------------------------------------------------------*\
\*----------------------------------------------------------------------------*/
/*** VMS Test ****/
#if defined(OS_VMS)
typedef int DEVICE;
#endif
/*** Slut VMS Test ****/
typedef struct {
pwr_tInt16 RackAddress;
pwr_tInt32 Address;
pwr_tInt16 CardType;
pwr_tInt32 OldValue[IO_MAXCHAN];
int FirstScan[IO_MAXCHAN];
} io_sLocal;
/*** VMS Test ****/
#if defined(OS_VMS)
static void rtpco_read(
pwr_tUInt16 *data,
pwr_tInt16 rack_address,
pwr_tInt32 card_address,
int nr,
pwr_tInt16 card_type)
{
*data = 21845;
}
static void rtpco_write(
int chan,
pwr_tInt16 rack_address,
pwr_tInt32 card_address,
pwr_tInt16 card_type)
{
}
#endif
/*** Slut VMS Test ****/
static pwr_tStatus IoCardInit (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
pwr_tStatus sts;
io_sLocal *local;
int i, j;
pwr_sClass_Co_7435_33 *op; /* Rtp 12/16 bit single counter */
pwr_sClass_Co_7437_33 *op_7437; /* RTP 4 x16 bit counter crad */
op = (pwr_sClass_Co_7435_33 *) cp->op;
local = calloc( 1, sizeof(*local));
local->RackAddress = ((pwr_sClass_Rack_RTP *) rp->op)->RackAddress;
local->Address = 1;
if ( cp->Class == pwr_cClass_Co_7435_33)
local->CardType = RTP_CO_7435_33;
else if ( cp->Class == pwr_cClass_Co_7437_33)
local->CardType = RTP_CO_7437_33;
for ( i = 0; i < IO_MAXCHAN; i++)
local->FirstScan[i] = 1;
cp->Local = local;
if ( op->MaxNoOfCounters == 1) /* If one RTP_CO 7435_33 */
{
rtpco_write( 0, local->RackAddress, op->CardAddress,
local->CardType);
}
else
{
op_7437 = (pwr_sClass_Co_7437_33 *) op;
for (i = 0; i < op_7437->MaxNoOfCounters; i++)
rtpco_write( (i << 8) | 0x440, local->RackAddress, op_7437->CardAddress,
local->CardType);
}
for ( i = 0; i < op->MaxNoOfCounters; i++)
* (pwr_tUInt32 *) cp->chanlist[i].vbp = 0;
errh_Info( "Init of co card '%s'", cp->Name);
return 1;
}
/*----------------------------------------------------------------------------*\
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardRead (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
io_sLocal *local;
pwr_sClass_Co_7435_33 *op; /* Rtp 12/16 bit single counter */
pwr_sClass_Co_7437_33 *op_7437; /* RTP 4 x16 bit counter crad */
pwr_tUInt16 invmask;
pwr_tUInt16 convmask;
int i;
pwr_tInt32 diff;
pwr_tUInt16 uco16_data;
if ( cp->AgentControlled)
return IO__SUCCESS;
local = (io_sLocal *) cp->Local;
op = (pwr_sClass_Co_7435_33 *) cp->op;
/* RTP produces two diffrent counter cards
7435_33 that is a 12 or 16 bit single channel card
7437_33 is a 4 channel 16 bit wide card.
The only way to diffrentiate between these cards is to look at
MaxNoOfChannels
The RTP cards can only count upwards */
/* Check if conversion should be done for this channel, if not
just don't do anything */
for ( i = 0; i < op->MaxNoOfCounters; i++)
{
if ( op->ConvMask & (1 << i))
{
/* Conversion is on */
if ( op->MaxNoOfCounters == 1) /* Check card type */
{
rtpco_read( &uco16_data, local->RackAddress, op->CardAddress, 0,
local->CardType);
}
else
{
op_7437 = (pwr_sClass_Co_7437_33 *) op;
/* Select channel */
rtpco_write( i << 8, local->RackAddress, op_7437->CardAddress,
local->CardType);
rtpco_read( &uco16_data, local->RackAddress, op_7437->CardAddress,
0, local->CardType);
}
/* Save the counter value */
*(pwr_tUInt32 *) cp->chanlist[i].vbp = uco16_data;
if ( local->CardType == RTP_CO_7435_33 &&
op->NoOfBits == 12) /* Check for type and range*/
{
if ( uco16_data >= local->OldValue[i]) /* Ok we haven't counted through zero */
diff = uco16_data - local->OldValue[i];
else
diff = uco16_data + (4095 - local->OldValue[i]);
}
else
{
if ( uco16_data >= local->OldValue[i]) /* Ok we haven't counted through zero */
diff = uco16_data - local->OldValue[i];
else
diff = uco16_data + (0xffff - local->OldValue[i]);
}
*(pwr_tUInt32 *) cp->chanlist[i].abs_vbp += diff;
local->OldValue[i] = uco16_data;
}
local->FirstScan[i] = 0;
}
return 1;
}
/*----------------------------------------------------------------------------*\
Every method to be exported to the workbench should be registred here.
\*----------------------------------------------------------------------------*/
pwr_dExport pwr_BindIoMethods(Co_7435_33) = {
pwr_BindIoMethod(IoCardInit),
pwr_BindIoMethod(IoCardRead),
pwr_NullMethod
};
pwr_dExport pwr_BindIoMethods(Co_7437_33) = {
pwr_BindIoMethod(IoCardInit),
pwr_BindIoMethod(IoCardRead),
pwr_NullMethod
};
| [
"claes"
] | claes |
22abcfd4c3e4d790ead67b2c04a7fe40e8a2a88a | ec7d1269672e09ff8ff2720b60f350677c8c15f1 | /arm-linux-gcc-4.5.1/4.5.1/arm-none-linux-gnueabi/sys-root/usr/include/openssl/stack.h | c555128cf97d841c6f233b1abf0945f70082cce3 | [] | no_license | ElevenH/First-Blood | 6a4d8ed48e93660c44b0623405bf30530eeea16b | 44ee02b8126c5609dc78d917633bde9caf4d0d68 | refs/heads/master | 2022-02-07T16:20:43.634359 | 2022-01-28T08:04:42 | 2022-01-28T08:04:42 | 46,023,766 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 4,396 | h | /* crypto/stack/stack.h */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code;not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES;LOSS OF USE, DATA, OR PROFITS;OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#ifndef HEADER_STACK_H
#define HEADER_STACK_H
#ifdef __cplusplus
extern "C"{
#endif
typedef struct stack_st
{
int num;
char **data;
int sorted;
int num_alloc;
int (*comp)(const void *, const void *);
} _STACK;/* Use STACK_OF(...) instead */
#define M_sk_num(sk) ((sk) ? (sk)->num:-1)
#define M_sk_value(sk,n) ((sk) ? (sk)->data[n] : NULL)
int sk_num(const _STACK *);
void *sk_value(const _STACK *, int);
void *sk_set(_STACK *, int, void *);
_STACK *sk_new(int (*cmp)(const void *, const void *));
_STACK *sk_new_null(void);
void sk_free(_STACK *);
void sk_pop_free(_STACK *st, void (*func)(void *));
int sk_insert(_STACK *sk, void *data, int where);
void *sk_delete(_STACK *st, int loc);
void *sk_delete_ptr(_STACK *st, void *p);
int sk_find(_STACK *st, void *data);
int sk_find_ex(_STACK *st, void *data);
int sk_push(_STACK *st, void *data);
int sk_unshift(_STACK *st, void *data);
void *sk_shift(_STACK *st);
void *sk_pop(_STACK *st);
void sk_zero(_STACK *st);
int (*sk_set_cmp_func(_STACK *sk, int (*c)(const void *, const void *)))
(const void *, const void *);
_STACK *sk_dup(_STACK *st);
void sk_sort(_STACK *st);
int sk_is_sorted(const _STACK *st);
#ifdef __cplusplus
}
#endif
#endif
| [
"pangchol@163.com"
] | pangchol@163.com |
723ab10c2a7d4439fdbdc894f07338d98cf63481 | 49780f24a92fcc9a7c855144fb195ae3736bf390 | /examples/devices/MSP430F1xx/MSP430x11x1_MSP430F21x1_Code_Examples/C/msp430x11x1_hfxtal.c | 03f3c9677d266e69539360271cc19eb28029e75c | [] | no_license | PiBoxY/msp430ware | 81fb264c86ff1f68f711965b793aa58794ae2f00 | 7c96db00f97bbfd3119843e18ac895a54b4a6d39 | refs/heads/master | 2020-04-21T07:29:13.386144 | 2019-02-06T11:32:42 | 2019-02-06T11:32:42 | 169,394,007 | 2 | 1 | null | null | null | null | UTF-8 | C | false | false | 4,301 | c | /* --COPYRIGHT--,BSD_EX
* Copyright (c) 2012, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*******************************************************************************
*
* MSP430 CODE EXAMPLE DISCLAIMER
*
* MSP430 code examples are self-contained low-level programs that typically
* demonstrate a single peripheral function or device feature in a highly
* concise manner. For this the code may rely on the device's power-on default
* register values and settings such as the clock configuration and care must
* be taken when combining code from several examples to avoid potential side
* effects. Also see www.ti.com/grace for a GUI- and www.ti.com/msp430ware
* for an API functional library-approach to peripheral configuration.
*
* --/COPYRIGHT--*/
//******************************************************************************
// MSP430x11x1 Demo - Basic Clock, MCLK Sourced from HF XTAL
//
// Description: Proper selection of an external HF XTAL for MCLK is shown by
// first polling the OSC fault until XTAL is stable - only then is MCLK
// sourced by LFXT1. MCLK/10 is on P1.1 driven by a software loop taking
// exactly 10 CPU cycles.
// ACLK = MCLK = LFXT1 = HF XTAL
// //* HF XTAL NOT INSTALLED ON FET *//
// //* Min Vcc required varies with MCLK frequency - refer to datasheet *//
//
// MSP430F1121
// -----------------
// /|\| XIN|-
// | | | HF XTAL (455k - 8Mhz)
// --|RST XOUT|-
// | |
// | P1.1|-->MCLK/10 = HFXTAL/10
// | P2.0|-->ACLK = HFXTAL
//
//
// M. Buccini
// Texas Instruments Inc.
// Feb 2005
// Built with CCE Version: 3.2.0 and IAR Embedded Workbench Version: 3.21A
//******************************************************************************
#include <msp430.h>
int main(void)
{
volatile unsigned int i;
WDTCTL = WDTPW + WDTHOLD; // Stop WDT
BCSCTL1 |= XTS; // ACLK = LFXT1 = HF XTAL
P2DIR |= 0x01; // P2.0 = output direction
P2SEL |= 0x01; // P2.0 = ACLK function
P1DIR |= 0x02; // P1.1 = output direction
do
{
IFG1 &= ~OFIFG; // Clear OSCFault flag
for (i = 0xFF; i > 0; i--); // Time for flag to set
}
while ((IFG1 & OFIFG)); // OSCFault flag still set?
BCSCTL2 |= SELM_3; // MCLK = LFXT1 (safe)
for (;;) // Infinate loop
{
P1OUT |= 0x02; // P1.1 = 1
P1OUT &= ~0x02; // P1.1 = 0
}
}
| [
"admin@piboxy.com"
] | admin@piboxy.com |
a105fecadc322b6e6b1d72a9195c3a15f28d00e1 | a614ff91eaa50a7521229f13f3c24681f69d6975 | /third_party/dav1d/src/arm/mc_init_tmpl.c | cf3a5fdef99a39c4dc9dbbc54b4d5ebea2daad5e | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] | permissive | therealglazou/gecko-dev | 1d971fc4f438526e5ab7f17daa13c6214da23ebc | 4e2f400fdf408787c5d010d7374da092d7bd03f3 | refs/heads/master | 2020-04-09T00:02:12.081354 | 2018-11-30T12:04:46 | 2018-11-30T12:04:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,899 | c | /*
* Copyright © 2018, VideoLAN and dav1d authors
* Copyright © 2018, Two Orioles, LLC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "src/mc.h"
#include "src/cpu.h"
decl_avg_fn(dav1d_avg_8bpc_neon);
decl_w_avg_fn(dav1d_w_avg_8bpc_neon);
decl_mask_fn(dav1d_mask_8bpc_neon);
void bitfn(dav1d_mc_dsp_init_arm)(Dav1dMCDSPContext *const c) {
const unsigned flags = dav1d_get_cpu_flags();
if (!(flags & DAV1D_ARM_CPU_FLAG_NEON)) return;
#if BITDEPTH == 8
c->avg = dav1d_avg_8bpc_neon;
c->w_avg = dav1d_w_avg_8bpc_neon;
c->mask = dav1d_mask_8bpc_neon;
#endif
}
| [
"tdaede@mozilla.com"
] | tdaede@mozilla.com |
5e79a594bf205b2f15376e3f6e97ae0dc261a7a9 | 7aba099849d7e7688687928a7320cb4afa568a99 | /ReflectiveDLLInjection/dll/src/ReflectiveLoader.c | 153c23a878ff0793f9dfbb6157040c62e24728a8 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | IMULMUL/Invoke-Vnc | c09be8f9af5faa35d3dffbfba778965f7252676d | 78bfc36bbd5b991d6905f5d09364a96b524d2dc7 | refs/heads/master | 2020-07-06T04:46:37.755839 | 2020-06-29T13:24:32 | 2020-06-29T13:24:32 | 202,896,363 | 0 | 0 | Apache-2.0 | 2020-06-29T17:15:48 | 2019-08-17T15:15:39 | C | UTF-8 | C | false | false | 21,940 | c | //===============================================================================================//
// Copyright (c) 2012, Stephen Fewer of Harmony Security (www.harmonysecurity.com)
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are permitted
// provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice, this list of
// conditions and the following disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// * Neither the name of Harmony Security nor the names of its contributors may be used to
// endorse or promote products derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//===============================================================================================//
#include "ReflectiveLoader.h"
//===============================================================================================//
// Our loader will set this to a pseudo correct HINSTANCE/HMODULE value
HINSTANCE hAppInstance = NULL;
//===============================================================================================//
#pragma intrinsic( _ReturnAddress )
// This function can not be inlined by the compiler or we will not get the address we expect. Ideally
// this code will be compiled with the /O2 and /Ob1 switches. Bonus points if we could take advantage of
// RIP relative addressing in this instance but I dont believe we can do so with the compiler intrinsics
// available (and no inline asm available under x64).
__declspec(noinline) ULONG_PTR caller( VOID ) { return (ULONG_PTR)_ReturnAddress(); }
//===============================================================================================//
// Note 1: If you want to have your own DllMain, define REFLECTIVEDLLINJECTION_CUSTOM_DLLMAIN,
// otherwise the DllMain at the end of this file will be used.
// Note 2: If you are injecting the DLL via LoadRemoteLibraryR, define REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR,
// otherwise it is assumed you are calling the ReflectiveLoader via a stub.
// This is our position independent reflective DLL loader/injector
#ifdef REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR
DLLEXPORT ULONG_PTR WINAPI ReflectiveLoader( LPVOID lpParameter )
#else
DLLEXPORT ULONG_PTR WINAPI ReflectiveLoader( VOID )
#endif
{
// the functions we need
LOADLIBRARYA pLoadLibraryA = NULL;
GETPROCADDRESS pGetProcAddress = NULL;
VIRTUALALLOC pVirtualAlloc = NULL;
NTFLUSHINSTRUCTIONCACHE pNtFlushInstructionCache = NULL;
USHORT usCounter;
// the initial location of this image in memory
ULONG_PTR uiLibraryAddress;
// the kernels base address and later this images newly loaded base address
ULONG_PTR uiBaseAddress;
// variables for processing the kernels export table
ULONG_PTR uiAddressArray;
ULONG_PTR uiNameArray;
ULONG_PTR uiExportDir;
ULONG_PTR uiNameOrdinals;
DWORD dwHashValue;
// variables for loading this image
ULONG_PTR uiHeaderValue;
ULONG_PTR uiValueA;
ULONG_PTR uiValueB;
ULONG_PTR uiValueC;
ULONG_PTR uiValueD;
ULONG_PTR uiValueE;
// STEP 0: calculate our images current base address
// we will start searching backwards from our callers return address.
uiLibraryAddress = caller();
// loop through memory backwards searching for our images base address
// we dont need SEH style search as we shouldnt generate any access violations with this
while( TRUE )
{
if( ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE )
{
uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
// some x64 dll's can trigger a bogus signature (IMAGE_DOS_SIGNATURE == 'POP r10'),
// we sanity check the e_lfanew with an upper threshold value of 1024 to avoid problems.
if( uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024 )
{
uiHeaderValue += uiLibraryAddress;
// break if we have found a valid MZ/PE header
if( ((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE )
break;
}
}
uiLibraryAddress--;
}
// STEP 1: process the kernels exports for the functions our loader needs...
// get the Process Enviroment Block
#ifdef _WIN64
uiBaseAddress = __readgsqword( 0x60 );
#else
uiBaseAddress = __readfsdword( 0x30 );
#endif
// get the processes loaded modules. ref: http://msdn.microsoft.com/en-us/library/aa813708(VS.85).aspx
uiBaseAddress = (ULONG_PTR)((_PPEB)uiBaseAddress)->pLdr;
// get the first entry of the InMemoryOrder module list
uiValueA = (ULONG_PTR)((PPEB_LDR_DATA)uiBaseAddress)->InMemoryOrderModuleList.Flink;
while( uiValueA )
{
// get pointer to current modules name (unicode string)
uiValueB = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.pBuffer;
// set bCounter to the length for the loop
usCounter = ((PLDR_DATA_TABLE_ENTRY)uiValueA)->BaseDllName.Length;
// clear uiValueC which will store the hash of the module name
uiValueC = 0;
// compute the hash of the module name...
do
{
uiValueC = ror( (DWORD)uiValueC );
// normalize to uppercase if the madule name is in lowercase
if( *((BYTE *)uiValueB) >= 'a' )
uiValueC += *((BYTE *)uiValueB) - 0x20;
else
uiValueC += *((BYTE *)uiValueB);
uiValueB++;
} while( --usCounter );
// compare the hash with that of kernel32.dll
if( (DWORD)uiValueC == KERNEL32DLL_HASH )
{
// get this modules base address
uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
// get the VA of the modules NT Header
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
// uiNameArray = the address of the modules export directory entry
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
// get the VA of the export directory
uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
// get the VA for the array of name pointers
uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
// get the VA for the array of name ordinals
uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
usCounter = 3;
// loop while we still have imports to find
while( usCounter > 0 )
{
// compute the hash values for this function name
dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) ) );
// if we have found a function we want we get its virtual address
if( dwHashValue == LOADLIBRARYA_HASH || dwHashValue == GETPROCADDRESS_HASH || dwHashValue == VIRTUALALLOC_HASH )
{
// get the VA for the array of addresses
uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
// use this functions name ordinal as an index into the array of name pointers
uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
// store this functions VA
if( dwHashValue == LOADLIBRARYA_HASH )
pLoadLibraryA = (LOADLIBRARYA)( uiBaseAddress + DEREF_32( uiAddressArray ) );
else if( dwHashValue == GETPROCADDRESS_HASH )
pGetProcAddress = (GETPROCADDRESS)( uiBaseAddress + DEREF_32( uiAddressArray ) );
else if( dwHashValue == VIRTUALALLOC_HASH )
pVirtualAlloc = (VIRTUALALLOC)( uiBaseAddress + DEREF_32( uiAddressArray ) );
// decrement our counter
usCounter--;
}
// get the next exported function name
uiNameArray += sizeof(DWORD);
// get the next exported function name ordinal
uiNameOrdinals += sizeof(WORD);
}
}
else if( (DWORD)uiValueC == NTDLLDLL_HASH )
{
// get this modules base address
uiBaseAddress = (ULONG_PTR)((PLDR_DATA_TABLE_ENTRY)uiValueA)->DllBase;
// get the VA of the modules NT Header
uiExportDir = uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew;
// uiNameArray = the address of the modules export directory entry
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
// get the VA of the export directory
uiExportDir = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
// get the VA for the array of name pointers
uiNameArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNames );
// get the VA for the array of name ordinals
uiNameOrdinals = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfNameOrdinals );
usCounter = 1;
// loop while we still have imports to find
while( usCounter > 0 )
{
// compute the hash values for this function name
dwHashValue = hash( (char *)( uiBaseAddress + DEREF_32( uiNameArray ) ) );
// if we have found a function we want we get its virtual address
if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
{
// get the VA for the array of addresses
uiAddressArray = ( uiBaseAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
// use this functions name ordinal as an index into the array of name pointers
uiAddressArray += ( DEREF_16( uiNameOrdinals ) * sizeof(DWORD) );
// store this functions VA
if( dwHashValue == NTFLUSHINSTRUCTIONCACHE_HASH )
pNtFlushInstructionCache = (NTFLUSHINSTRUCTIONCACHE)( uiBaseAddress + DEREF_32( uiAddressArray ) );
// decrement our counter
usCounter--;
}
// get the next exported function name
uiNameArray += sizeof(DWORD);
// get the next exported function name ordinal
uiNameOrdinals += sizeof(WORD);
}
}
// we stop searching when we have found everything we need.
if( pLoadLibraryA && pGetProcAddress && pVirtualAlloc && pNtFlushInstructionCache )
break;
// get the next entry
uiValueA = DEREF( uiValueA );
}
// STEP 2: load our image into a new permanent location in memory...
// get the VA of the NT Header for the PE to be loaded
uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
// allocate all the memory for the DLL to be loaded into. we can load at any address because we will
// relocate the image. Also zeros all memory and marks it as READ, WRITE and EXECUTE to avoid any problems.
uiBaseAddress = (ULONG_PTR)pVirtualAlloc( NULL, ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE );
// we must now copy over the headers
uiValueA = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
uiValueB = uiLibraryAddress;
uiValueC = uiBaseAddress;
while( uiValueA-- )
*(BYTE *)uiValueC++ = *(BYTE *)uiValueB++;
// STEP 3: load in all of our sections...
// uiValueA = the VA of the first section
uiValueA = ( (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader + ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader );
// itterate through all sections, loading them into memory.
uiValueE = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;
while( uiValueE-- )
{
// uiValueB is the VA for this section
uiValueB = ( uiBaseAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->VirtualAddress );
// uiValueC if the VA for this sections data
uiValueC = ( uiLibraryAddress + ((PIMAGE_SECTION_HEADER)uiValueA)->PointerToRawData );
// copy the section over
uiValueD = ((PIMAGE_SECTION_HEADER)uiValueA)->SizeOfRawData;
while( uiValueD-- )
*(BYTE *)uiValueB++ = *(BYTE *)uiValueC++;
// get the VA of the next section
uiValueA += sizeof( IMAGE_SECTION_HEADER );
}
// STEP 4: process our images import table...
// uiValueB = the address of the import directory
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_IMPORT ];
// we assume their is an import table to process
// uiValueC is the first entry in the import table
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
// itterate through all imports
while( ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name )
{
// use LoadLibraryA to load the imported module into memory
uiLibraryAddress = (ULONG_PTR)pLoadLibraryA( (LPCSTR)( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->Name ) );
// uiValueD = VA of the OriginalFirstThunk
uiValueD = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->OriginalFirstThunk );
// uiValueA = VA of the IAT (via first thunk not origionalfirstthunk)
uiValueA = ( uiBaseAddress + ((PIMAGE_IMPORT_DESCRIPTOR)uiValueC)->FirstThunk );
// itterate through all imported functions, importing by ordinal if no name present
while( DEREF(uiValueA) )
{
// sanity check uiValueD as some compilers only import by FirstThunk
if( uiValueD && ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{
// get the VA of the modules NT Header
uiExportDir = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
// uiNameArray = the address of the modules export directory entry
uiNameArray = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiExportDir)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_EXPORT ];
// get the VA of the export directory
uiExportDir = ( uiLibraryAddress + ((PIMAGE_DATA_DIRECTORY)uiNameArray)->VirtualAddress );
// get the VA for the array of addresses
uiAddressArray = ( uiLibraryAddress + ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->AddressOfFunctions );
// use the import ordinal (- export ordinal base) as an index into the array of addresses
uiAddressArray += ( ( IMAGE_ORDINAL( ((PIMAGE_THUNK_DATA)uiValueD)->u1.Ordinal ) - ((PIMAGE_EXPORT_DIRECTORY )uiExportDir)->Base ) * sizeof(DWORD) );
// patch in the address for this imported function
DEREF(uiValueA) = ( uiLibraryAddress + DEREF_32(uiAddressArray) );
}
else
{
// get the VA of this functions import by name struct
uiValueB = ( uiBaseAddress + DEREF(uiValueA) );
// use GetProcAddress and patch in the address for this imported function
DEREF(uiValueA) = (ULONG_PTR)pGetProcAddress( (HMODULE)uiLibraryAddress, (LPCSTR)((PIMAGE_IMPORT_BY_NAME)uiValueB)->Name );
}
// get the next imported function
uiValueA += sizeof( ULONG_PTR );
if( uiValueD )
uiValueD += sizeof( ULONG_PTR );
}
// get the next import
uiValueC += sizeof( IMAGE_IMPORT_DESCRIPTOR );
}
// STEP 5: process all of our images relocations...
// calculate the base address delta and perform relocations (even if we load at desired image base)
uiLibraryAddress = uiBaseAddress - ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;
// uiValueB = the address of the relocation directory
uiValueB = (ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.DataDirectory[ IMAGE_DIRECTORY_ENTRY_BASERELOC ];
// check if their are any relocations present
if( ((PIMAGE_DATA_DIRECTORY)uiValueB)->Size )
{
// uiValueC is now the first entry (IMAGE_BASE_RELOCATION)
uiValueC = ( uiBaseAddress + ((PIMAGE_DATA_DIRECTORY)uiValueB)->VirtualAddress );
// and we itterate through all entries...
while( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock )
{
// uiValueA = the VA for this relocation block
uiValueA = ( uiBaseAddress + ((PIMAGE_BASE_RELOCATION)uiValueC)->VirtualAddress );
// uiValueB = number of entries in this relocation block
uiValueB = ( ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) ) / sizeof( IMAGE_RELOC );
// uiValueD is now the first entry in the current relocation block
uiValueD = uiValueC + sizeof(IMAGE_BASE_RELOCATION);
// we itterate through all the entries in the current block...
while( uiValueB-- )
{
// perform the relocation, skipping IMAGE_REL_BASED_ABSOLUTE as required.
// we dont use a switch statement to avoid the compiler building a jump table
// which would not be very position independent!
if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_DIR64 )
*(ULONG_PTR *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += uiLibraryAddress;
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGHLOW )
*(DWORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += (DWORD)uiLibraryAddress;
#ifdef WIN_ARM
// Note: On ARM, the compiler optimization /O2 seems to introduce an off by one issue, possibly a code gen bug. Using /O1 instead avoids this problem.
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_ARM_MOV32T )
{
register DWORD dwInstruction;
register DWORD dwAddress;
register WORD wImm;
// get the MOV.T instructions DWORD value (We add 4 to the offset to go past the first MOV.W which handles the low word)
dwInstruction = *(DWORD *)( uiValueA + ((PIMAGE_RELOC)uiValueD)->offset + sizeof(DWORD) );
// flip the words to get the instruction as expected
dwInstruction = MAKELONG( HIWORD(dwInstruction), LOWORD(dwInstruction) );
// sanity chack we are processing a MOV instruction...
if( (dwInstruction & ARM_MOV_MASK) == ARM_MOVT )
{
// pull out the encoded 16bit value (the high portion of the address-to-relocate)
wImm = (WORD)( dwInstruction & 0x000000FF);
wImm |= (WORD)((dwInstruction & 0x00007000) >> 4);
wImm |= (WORD)((dwInstruction & 0x04000000) >> 15);
wImm |= (WORD)((dwInstruction & 0x000F0000) >> 4);
// apply the relocation to the target address
dwAddress = ( (WORD)HIWORD(uiLibraryAddress) + wImm ) & 0xFFFF;
// now create a new instruction with the same opcode and register param.
dwInstruction = (DWORD)( dwInstruction & ARM_MOV_MASK2 );
// patch in the relocated address...
dwInstruction |= (DWORD)(dwAddress & 0x00FF);
dwInstruction |= (DWORD)(dwAddress & 0x0700) << 4;
dwInstruction |= (DWORD)(dwAddress & 0x0800) << 15;
dwInstruction |= (DWORD)(dwAddress & 0xF000) << 4;
// now flip the instructions words and patch back into the code...
*(DWORD *)( uiValueA + ((PIMAGE_RELOC)uiValueD)->offset + sizeof(DWORD) ) = MAKELONG( HIWORD(dwInstruction), LOWORD(dwInstruction) );
}
}
#endif
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_HIGH )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += HIWORD(uiLibraryAddress);
else if( ((PIMAGE_RELOC)uiValueD)->type == IMAGE_REL_BASED_LOW )
*(WORD *)(uiValueA + ((PIMAGE_RELOC)uiValueD)->offset) += LOWORD(uiLibraryAddress);
// get the next entry in the current relocation block
uiValueD += sizeof( IMAGE_RELOC );
}
// get the next entry in the relocation directory
uiValueC = uiValueC + ((PIMAGE_BASE_RELOCATION)uiValueC)->SizeOfBlock;
}
}
// STEP 6: call our images entry point
// uiValueA = the VA of our newly loaded DLL/EXE's entry point
uiValueA = ( uiBaseAddress + ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.AddressOfEntryPoint );
// We must flush the instruction cache to avoid stale code being used which was updated by our relocation processing.
pNtFlushInstructionCache( (HANDLE)-1, NULL, 0 );
// call our respective entry point, fudging our hInstance value
#ifdef REFLECTIVEDLLINJECTION_VIA_LOADREMOTELIBRARYR
// if we are injecting a DLL via LoadRemoteLibraryR we call DllMain and pass in our parameter (via the DllMain lpReserved parameter)
((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, lpParameter );
#else
// if we are injecting an DLL via a stub we call DllMain with no parameter
((DLLMAIN)uiValueA)( (HINSTANCE)uiBaseAddress, DLL_PROCESS_ATTACH, NULL );
#endif
// STEP 8: return our new entry point address so whatever called us can call DllMain() if needed.
return uiValueA;
}
//===============================================================================================//
#ifndef REFLECTIVEDLLINJECTION_CUSTOM_DLLMAIN
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved )
{
BOOL bReturnValue = TRUE;
switch( dwReason )
{
case DLL_QUERY_HMODULE:
if( lpReserved != NULL )
*(HMODULE *)lpReserved = hAppInstance;
break;
case DLL_PROCESS_ATTACH:
dprintf("test");
hAppInstance = hinstDLL;
break;
case DLL_PROCESS_DETACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
}
return bReturnValue;
}
#endif
//===============================================================================================//
| [
"artem@localhost.localdomain"
] | artem@localhost.localdomain |
0f0244dbca525bbf4c6b1a08c568a8fdbe87291a | 751d837b8a4445877bb2f0d1e97ce41cd39ce1bd | /leetcode/shortest-completing-word.c | b23b86d9e1eb08fdbc82938d6f679a320f072da0 | [
"MIT"
] | permissive | qeedquan/challenges | d55146f784a3619caa4541ac6f2b670b0a3dd8ba | 56823e77cf502bdea68cce0e1221f5add3d64d6a | refs/heads/master | 2023-08-11T20:35:09.726571 | 2023-08-11T13:02:43 | 2023-08-11T13:02:43 | 115,886,967 | 2 | 1 | null | null | null | null | UTF-8 | C | false | false | 2,068 | c | /*
Find the minimum length word from a given dictionary words, which has all the letters from the string licensePlate.
Such a word is said to complete the given string licensePlate
Here, for letters we ignore case. For example, "P" on the licensePlate still matches "p" on the word.
It is guaranteed an answer exists. If there are multiple answers, return the one that occurs first in the array.
The license plate might have the same letter occurring multiple times.
For example, given a licensePlate of "PP", the word "pair" does not complete the licensePlate, but the word "supper" does.
Note:
licensePlate will be a string with length in range [1, 7].
licensePlate will contain digits, spaces, or letters (uppercase or lowercase).
words will have a length in the range [10, 1000].
Every words[i] will consist of lowercase letters, and have length in range [1, 15].
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdint.h>
#define nelem(x) (sizeof(x) / sizeof(x[0]))
const char *
shcw(const char *l, const char **w, size_t n)
{
size_t h1[256], h2[256];
size_t i, j, k, l1, l2;
memset(h1, 0, sizeof(h1));
for (i = 0; l[i]; i++) {
if (isalpha(l[i]))
h1[tolower(l[i]) & 0xff]++;
}
k = SIZE_MAX;
l2 = SIZE_MAX;
for (i = 0; i < n; i++) {
memset(h2, 0, sizeof(h2));
for (j = 0; w[i][j]; j++)
h2[tolower(w[i][j]) & 0xff]++;
l1 = j;
if (l1 >= l2)
continue;
for (j = 0; j < nelem(h2); j++)
h2[j] &= h1[j];
if (memcmp(h1, h2, sizeof(h1)) == 0) {
l2 = l1;
k = i;
}
}
if (k == SIZE_MAX)
return "";
return w[k];
}
int
main(void)
{
const char *s1[] = {"step", "steps", "stripe", "stepple"};
const char *s2[] = {"looks", "pest", "stew", "show"};
const char *s3[] = {"pair", "supper"};
printf("%s\n", shcw("1s3 PSt", s1, nelem(s1)));
printf("%s\n", shcw("1s3 456", s2, nelem(s2)));
printf("%s\n", shcw("1Z3 456", s2, nelem(s2)));
printf("%s\n", shcw("130", s2, nelem(s2)));
printf("%s\n", shcw("130", s2, nelem(s2)));
printf("%s\n", shcw("20304 PP", s3, nelem(s3)));
return 0;
}
| [
"qeed.quan@gmail.com"
] | qeed.quan@gmail.com |
70212219bdc3843046041e525de00b44a419c71b | 9496ed5237ed981caed36bceb1a5319664c316a8 | /nokia5110-clock/font.h | 43934f412b46933df3aacb419601b248d6e8cb3d | [
"MIT"
] | permissive | amcolash/ESP8266 | d607814fb2442895ac4e561ab04ee8f973b57755 | 8d5e810c211c27d5983455a7cf5eac5ffd714f8e | refs/heads/master | 2023-07-01T23:25:01.243078 | 2023-06-08T05:15:53 | 2023-06-08T05:15:53 | 77,345,408 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 17,668 | h | // Created by http://oleddisplay.squix.ch/ Consider a donation
// In case of problems make sure that you are using the font file with the correct version!
const uint8_t Orbitron_Bold_22Bitmaps[] PROGMEM = {
// Bitmap Data:
0x00, // ' '
0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0x0E,0xEE, // '!'
0xEE,0xEE,0xEE,0xEE, // '"'
0x07,0x0E,0x03,0x87,0x01,0xC7,0x01,0xC3,0x8F,0xFF,0xF7,0xFF,0xF8,0x70,0xE0,0x38,0x70,0x1C,0x30,0x1C,0x38,0x3F,0xFF,0x9F,0xFF,0xC3,0x0E,0x03,0x87,0x01,0xC3,0x81,0xE3,0x80, // '#'
0x03,0x80,0x03,0x80,0x7F,0xFC,0xFF,0xFE,0xFF,0xFE,0xE3,0x86,0xE3,0x80,0xE3,0x80,0xE3,0x80,0xFF,0xFE,0x7F,0xFE,0x1F,0xFE,0x03,0x86,0x03,0x86,0xE3,0x86,0xFF,0xFE,0xFF,0xFE,0x7F,0xFC,0x03,0x80,0x03,0x80, // '$'
0x3C,0x00,0xC7,0xE0,0x1C,0xFF,0x03,0xCE,0x30,0x78,0xE3,0x0F,0x0E,0x33,0xE0,0xFF,0x7C,0x07,0xEF,0x80,0x01,0xE7,0x80,0x3C,0xFC,0x07,0x9F,0xE1,0xF1,0x8E,0x3E,0x18,0xE3,0x81,0x8E,0x30,0x1F,0xC2,0x00,0xFC, // '%'
0x1F,0xFC,0x03,0xFF,0xE0,0x7F,0xFE,0x07,0x00,0xE0,0x70,0x0E,0x07,0x00,0x00,0x78,0x00,0x07,0xE0,0x00,0xFF,0x87,0x0E,0x7E,0x70,0xE1,0xFF,0x0E,0x07,0xF0,0xE0,0x1F,0x8F,0xFF,0xFE,0x7F,0xFE,0xE3,0xFF,0xE6, // '&'
0xEE,0xEE, // '''
0x33,0xBD,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x79,0xCE, // '('
0xE7,0xBC,0x63,0x18,0xC6,0x31,0x8C,0x63,0x7B,0xDC, // ')'
0x1C,0x03,0x83,0x76,0x7F,0xCF,0xFC,0x7E,0x0F,0x83,0xBC,0x77,0x04,0x40, // '*'
0x1C,0x07,0x01,0xC3,0xFE,0xFF,0xBF,0xE1,0xC0,0x70,0x1C,0x00, // '+'
0xEE,0xEE,0xEC, // ','
0xFF,0xBF,0xEF,0xF8, // '-'
0xEE,0xE0, // '.'
0x00,0x20,0x02,0x00,0x60,0x0E,0x01,0xC0,0x3C,0x07,0x80,0x70,0x0E,0x01,0xC0,0x38,0x07,0x80,0xF0,0x0E,0x00,0xC0,0x08,0x00, // '/'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0xDC,0x03,0xEE,0x03,0xF7,0x03,0xFB,0x83,0xDD,0xC3,0xCE,0xE7,0xC7,0x77,0xC3,0xBF,0x81,0xDF,0x80,0xEF,0x80,0x77,0xFF,0xF9,0xFF,0xF8,0x7F,0xFC, // '0'
0x07,0x07,0x87,0xC7,0xE7,0xF7,0xB8,0x1C,0x0E,0x07,0x03,0x81,0xC0,0xE0,0x70,0x38,0x1C,0x0E, // '1'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0xDC,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x1C,0xFF,0xFE,0x7F,0xFE,0x7F,0xFE,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0xFF,0xFB,0xFF,0xFD,0xFF,0xFE, // '2'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0x9C,0x01,0xC0,0x00,0xE0,0x00,0x70,0x00,0x38,0x3F,0xFC,0x1F,0xFF,0x00,0x03,0x80,0x01,0xC0,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xF8,0x7F,0xFC, // '3'
0x00,0x38,0x00,0x78,0x00,0xF8,0x01,0xF8,0x07,0xF8,0x0F,0xB8,0x1F,0x38,0x3E,0x38,0x78,0x38,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x38, // '4'
0xFF,0xFF,0x7F,0xFF,0xBF,0xFF,0xDC,0x00,0x0E,0x00,0x07,0x00,0x03,0xFF,0xF1,0xFF,0xFC,0xFF,0xFF,0x00,0x03,0x80,0x01,0xC0,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0x7F,0xFC, // '5'
0x3F,0xF8,0x3F,0xFC,0x3F,0xFE,0x1C,0x00,0x0E,0x00,0x07,0x00,0x03,0xFF,0xF1,0xFF,0xFC,0xFF,0xFF,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0x7F,0xFC, // '6'
0xFF,0xF3,0xFF,0xEF,0xFF,0x80,0x0E,0x00,0x38,0x00,0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xE0,0x03,0x80,0x0E, // '7'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xFF,0xFE,0xFF,0xFF,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0x7F,0xFC, // '8'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xFF,0xFE,0x7F,0xFF,0x1F,0xFF,0x80,0x01,0xC0,0x00,0xE0,0x00,0x77,0xFF,0xF9,0xFF,0xF8,0x7F,0xF8, // '9'
0xEE,0xE0,0x00,0x00,0x00,0xEE,0xE0, // ':'
0xEE,0xE0,0x00,0x00,0x00,0xEE,0xEE,0xE8, // ';'
0x00,0x80,0xE0,0x78,0x7E,0x7E,0x3E,0x0F,0x03,0xE0,0x7E,0x07,0xE0,0x78,0x0E,0x00,0x80, // '<'
0xFF,0xF7,0xFF,0xBF,0xFC,0x00,0x0F,0xFF,0x7F,0xFB,0xFF,0xC0, // '='
0x80,0x1C,0x03,0xE0,0x3F,0x03,0xF0,0x1F,0x80,0xF0,0x7E,0x1F,0x0F,0xC3,0xE0,0x70,0x0C,0x00, // '>'
0xFF,0xF3,0xFF,0xEF,0xFF,0x80,0x06,0x00,0x18,0x00,0x60,0x01,0x83,0xFE,0x3F,0xF8,0xFF,0xC3,0x80,0x0E,0x00,0x00,0x00,0xE0,0x03,0x80,0x0E,0x00, // '?'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0xDC,0x00,0xEE,0x3C,0x77,0x3F,0x3B,0xBF,0xDD,0xDC,0x6E,0xEE,0x37,0x77,0xFF,0xB9,0xFF,0xDC,0x7F,0xEE,0x00,0x07,0xFF,0xF9,0xFF,0xFC,0x7F,0xFE, // '@'
0x3F,0xFC,0x3F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E,0xFF,0xFF,0x7F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E, // 'A'
0xFF,0xFC,0x7F,0xFF,0x3F,0xFF,0x9C,0x00,0xEE,0x00,0x77,0x00,0x3B,0xFF,0xF9,0xFF,0xFC,0xFF,0xFF,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xFB,0xFF,0xFD,0xFF,0xFC, // 'B'
0x3F,0xFF,0x3F,0xFF,0xBF,0xFF,0xDC,0x00,0x0E,0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0xFF,0xF9,0xFF,0xFC,0x7F,0xFE, // 'C'
0xFF,0xFC,0x7F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E,0xE0,0x07,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xFB,0xFF,0xFD,0xFF,0xFC, // 'D'
0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xFF,0xF8,0xFF,0xF8,0xFF,0xF8,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE, // 'E'
0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xFF,0xF8,0xFF,0xF8,0xFF,0xF8,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00, // 'F'
0x3F,0xFC,0x3F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x7E,0xE0,0x3F,0x70,0x1F,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0x7F,0xFC, // 'G'
0xE0,0x03,0x70,0x01,0xB8,0x00,0xDC,0x00,0x6E,0x00,0x37,0x00,0x1B,0x80,0x0D,0xFF,0xFE,0xFF,0xFF,0x7F,0xFF,0xB8,0x00,0xDC,0x00,0x6E,0x00,0x37,0x00,0x1B,0x80,0x0D,0xC0,0x06, // 'H'
0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE, // 'I'
0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0x00,0x03,0x80,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0xFF,0xFC, // 'J'
0xE0,0x0F,0x70,0x0F,0x38,0x0F,0x1C,0x07,0x0E,0x07,0x87,0x07,0x83,0x87,0x81,0xFF,0x80,0xFF,0xC0,0x7F,0xF0,0x38,0x3C,0x1C,0x0E,0x0E,0x07,0x87,0x01,0xE3,0x80,0x79,0xC0,0x1E, // 'K'
0xE0,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0xFF,0xFB,0xFF,0xFD,0xFF,0xFE, // 'L'
0xF0,0x01,0xDF,0x00,0x7B,0xE0,0x1F,0x7E,0x07,0xEF,0xE1,0xFD,0xDE,0x7B,0xB9,0xEE,0x77,0x1F,0xCE,0xE1,0xF1,0xDC,0x3C,0x3B,0x83,0x07,0x70,0x20,0xEE,0x00,0x1D,0xC0,0x03,0xB8,0x00,0x77,0x00,0x0E, // 'M'
0xF0,0x07,0x7C,0x03,0xBE,0x01,0xDF,0x80,0xEF,0xE0,0x77,0x78,0x3B,0x9E,0x1D,0xC7,0x8E,0xE1,0xC7,0x70,0xF3,0xB8,0x3D,0xDC,0x0F,0xEE,0x03,0xF7,0x00,0xFB,0x80,0x3D,0xC0,0x1E, // 'N'
0x3F,0xFC,0x3F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E,0xE0,0x07,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0x7F,0xFC, // 'O'
0xFF,0xFC,0x7F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E,0xFF,0xFF,0x7F,0xFF,0x3F,0xFF,0x1C,0x00,0x0E,0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x00, // 'P'
0x3F,0xFC,0x0F,0xFF,0xE3,0xFF,0xFC,0x70,0x03,0x8E,0x00,0x71,0xC0,0x0E,0x38,0x01,0xC7,0x00,0x38,0xE0,0x07,0x1C,0x00,0xE3,0x80,0x1C,0x70,0x03,0x8E,0x00,0x71,0xFF,0xFF,0x9F,0xFF,0xF1,0xFF,0xFE, // 'Q'
0xFF,0xFC,0x7F,0xFF,0xBF,0xFF,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E,0xFF,0xFF,0x7F,0xFF,0x3F,0xFF,0x1C,0x0F,0x0E,0x03,0xC7,0x00,0xF3,0x80,0x39,0xC0,0x1E, // 'R'
0x3F,0xFC,0x3F,0xFF,0x3F,0xFF,0xDC,0x00,0xEE,0x00,0x07,0x00,0x03,0x80,0x01,0xFF,0xFC,0x7F,0xFF,0x0F,0xFF,0x80,0x01,0xC0,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0xFF,0xFC, // 'S'
0xFF,0xFF,0x7F,0xFF,0xBF,0xFF,0xC0,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0x00,0x03,0x80,0x01,0xC0,0x00,0xE0,0x00,0x70,0x00,0x38,0x00,0x1C,0x00,0x0E,0x00,0x07,0x00,0x03,0x80, // 'T'
0xE0,0x07,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0x00,0x3B,0x80,0x1D,0xC0,0x0E,0xE0,0x07,0x70,0x03,0xB8,0x01,0xDC,0x00,0xEE,0x00,0x77,0xFF,0xF9,0xFF,0xFC,0x7F,0xFC, // 'U'
0xE0,0x00,0x79,0xC0,0x01,0xC7,0x00,0x0E,0x0E,0x00,0x78,0x3C,0x01,0xC0,0x70,0x0F,0x01,0xE0,0x38,0x03,0x81,0xC0,0x07,0x07,0x00,0x1E,0x38,0x00,0x39,0xE0,0x00,0xF7,0x00,0x01,0xFC,0x00,0x07,0xE0,0x00,0x0F,0x00,0x00,0x1C,0x00, // 'V'
0xE0,0x38,0x07,0x70,0x1E,0x03,0x9C,0x0F,0x03,0x8E,0x0F,0xC1,0xC7,0x07,0xE1,0xC1,0xC3,0xF0,0xE0,0xE3,0x9C,0x70,0x79,0xCE,0x70,0x1D,0xE7,0x38,0x0E,0xE1,0xDC,0x03,0xF0,0xFC,0x01,0xF0,0x7E,0x00,0xF8,0x1F,0x00,0x3C,0x0F,0x00,0x1C,0x07,0x80,0x0E,0x01,0x80, // 'W'
0xE0,0x0F,0x78,0x07,0x1E,0x07,0x87,0x87,0x81,0xE7,0x80,0x7F,0x80,0x1F,0x80,0x07,0x80,0x03,0xC0,0x03,0xF0,0x03,0xFC,0x03,0xCF,0x03,0xC3,0xC3,0xC0,0xE1,0xC0,0x79,0xE0,0x1E, // 'X'
0xF0,0x03,0xCF,0x00,0xF0,0xF0,0x1C,0x0E,0x07,0x00,0xE1,0xE0,0x1E,0x78,0x01,0xFE,0x00,0x1F,0xC0,0x01,0xF0,0x00,0x3C,0x00,0x03,0x80,0x00,0x70,0x00,0x0E,0x00,0x01,0xC0,0x00,0x38,0x00,0x07,0x00, // 'Y'
0xFF,0xFF,0x7F,0xFF,0xBF,0xFF,0xC0,0x03,0xE0,0x03,0xE0,0x03,0xC0,0x03,0xC0,0x07,0xC0,0x07,0xC0,0x07,0xC0,0x07,0x80,0x07,0x80,0x07,0x80,0x07,0xFF,0xFB,0xFF,0xFD,0xFF,0xFE, // 'Z'
0xF7,0xBD,0xCE,0x73,0x9C,0xE7,0x39,0xCE,0x7B,0xDE, // '['
0x80,0x0C,0x00,0xE0,0x0F,0x00,0x70,0x03,0x80,0x1C,0x00,0xE0,0x0F,0x00,0x78,0x03,0x80,0x1C,0x00,0xE0,0x06,0x00,0x60,0x02, // '\'
0xF7,0xBC,0xE7,0x39,0xCE,0x73,0x9C,0xE7,0x7B,0xDE, // ']'
0x00, // '^'
0xFF,0xFF,0x7F,0xFF,0xBF,0xFF,0xC0, // '_'
0xE7,0x38,0xE0, // '`'
0xFF,0xE3,0xFF,0xEF,0xFF,0x80,0x0E,0x00,0x3B,0xFF,0xEF,0xFF,0xBF,0xFE,0xE0,0x3B,0x80,0xEF,0xFF,0x9F,0xFE,0x3F,0xF8, // 'a'
0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xFF,0xE3,0xFF,0xEF,0xFF,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEF,0xFF,0xBF,0xFE,0xFF,0xF0, // 'b'
0x3F,0xF9,0xFF,0xEF,0xFF,0xB8,0x00,0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xE0,0x03,0x80,0x0F,0xFF,0x9F,0xFE,0x7F,0xF8, // 'c'
0x00,0x30,0x01,0x80,0x0C,0x00,0x67,0xFF,0x7F,0xFB,0xFF,0xD8,0x06,0xC0,0x36,0x01,0xB0,0x0D,0x80,0x6C,0x03,0x60,0x1B,0xFF,0xDF,0xFE,0x7F,0xF0, // 'd'
0x3F,0xE1,0xFF,0xEF,0xFF,0xB8,0x0E,0xE0,0x3B,0xFF,0xEF,0xFF,0xBF,0xFE,0xE0,0x03,0x80,0x0F,0xFF,0x9F,0xFE,0x7F,0xF8, // 'e'
0x3F,0x3F,0xBF,0xDC,0x0F,0xF7,0xFB,0xFD,0xC0,0xE0,0x70,0x38,0x1C,0x0E,0x07,0x03,0x81,0xC0,0xE0,0x00, // 'f'
0x3F,0xE3,0xFF,0xCF,0xFF,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEF,0xFF,0xBF,0xFE,0x7F,0xF8,0x00,0xE0,0x03,0x8F,0xFE,0x3F,0xF0,0xFF,0xC0, // 'g'
0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xFF,0xE3,0xFF,0xEF,0xFF,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x38, // 'h'
0xEE,0xE0,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xE0, // 'i'
0x03,0x01,0x80,0xC0,0x00,0x30,0x18,0x0C,0x06,0x03,0x01,0x80,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x80,0xDF,0xEF,0xF7,0xF0, // 'j'
0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xE0,0x3B,0x81,0xEE,0x0F,0x38,0x78,0xE3,0xC3,0xFE,0x0F,0xF0,0x3F,0xE0,0xE3,0xC3,0x87,0x0E,0x0E,0x38,0x1C,0xE0,0x78, // 'k'
0xE1,0xC3,0x87,0x0E,0x1C,0x38,0x70,0xE1,0xC3,0x87,0x0E,0x1C,0x3F,0x3E,0x3C, // 'l'
0xFF,0xFF,0x8F,0xFF,0xFC,0xFF,0xFF,0xEE,0x0E,0x0E,0xE0,0xE0,0xEE,0x0E,0x0E,0xE0,0xE0,0xEE,0x0E,0x0E,0xE0,0xE0,0xEE,0x0E,0x0E,0xE0,0xE0,0xEE,0x0E,0x0E,0xE0,0xE0,0xE0, // 'm'
0xFF,0xE3,0xFF,0xEF,0xFF,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x38, // 'n'
0x3F,0xE1,0xFF,0xEF,0xFF,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEF,0xFF,0x9F,0xFE,0x7F,0xF0, // 'o'
0xFF,0xE3,0xFF,0xEF,0xFF,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEF,0xFF,0xBF,0xFE,0xFF,0xF3,0x80,0x0E,0x00,0x38,0x00,0xE0,0x03,0x80,0x00, // 'p'
0x3F,0xF9,0xFF,0xE7,0xFF,0xB8,0x06,0xE0,0x1B,0x80,0x6E,0x01,0xB8,0x06,0xE0,0x1B,0x80,0x6F,0xFF,0x9F,0xFE,0x3F,0xF8,0x00,0x60,0x01,0x80,0x06,0x00,0x18,0x00,0x60, // 'q'
0x3F,0xCF,0xFB,0xFF,0x70,0x0E,0x01,0xC0,0x38,0x07,0x00,0xE0,0x1C,0x03,0x80,0x70,0x0E,0x00, // 'r'
0x3F,0xE1,0xFF,0xCF,0xFF,0xB8,0x0E,0xE0,0x03,0xFF,0x8F,0xFF,0x1F,0xFE,0x00,0x3B,0x80,0xEF,0xFF,0xBF,0xFE,0x7F,0xF0, // 's'
0xE0,0x70,0x38,0x1C,0x0F,0xF7,0xFB,0xFD,0xC0,0xE0,0x70,0x38,0x1C,0x0E,0x07,0x03,0xFC,0xFE,0x3F,0x00, // 't'
0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEF,0xFF,0x9F,0xFE,0x3F,0xF0, // 'u'
0xF0,0x03,0x9C,0x01,0xC3,0x80,0x70,0xF0,0x38,0x1C,0x0E,0x07,0x87,0x00,0xE3,0xC0,0x3C,0xE0,0x07,0x78,0x00,0xFC,0x00,0x3F,0x00,0x07,0x80,0x01,0xC0,0x00, // 'v'
0xE0,0x70,0x3D,0xC0,0xF0,0x71,0xC3,0xE0,0xE3,0x87,0xE3,0x87,0x9F,0xC7,0x07,0x3B,0xCE,0x0E,0xF3,0xB8,0x0F,0xC7,0xF0,0x1F,0x87,0xC0,0x3F,0x0F,0x80,0x3C,0x1F,0x00,0x78,0x1C,0x00,0x60,0x38,0x00, // 'w'
0xE0,0x3B,0xC1,0xE7,0x8F,0x0F,0x78,0x1F,0xC0,0x3E,0x00,0x70,0x03,0xE0,0x1F,0xC0,0xF7,0x87,0x8F,0x1C,0x1E,0xF0,0x38, // 'x'
0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEE,0x03,0xB8,0x0E,0xE0,0x3B,0x80,0xEF,0xFF,0xBF,0xFE,0x7F,0xF8,0x00,0xE0,0x03,0x8F,0xFE,0x3F,0xF8,0xFF,0xC0, // 'y'
0xFF,0xFB,0xFF,0xEF,0xFF,0x80,0x3E,0x01,0xF0,0x0F,0x00,0x78,0x07,0xC0,0x3E,0x01,0xE0,0x0F,0xFF,0xBF,0xFE,0xFF,0xF8, // 'z'
0x39,0xE7,0xB8,0xE3,0x8E,0x38,0xE3,0x8E,0x38,0xE3,0xE7,0x8E, // '{'
0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE, // '|'
0xE3,0xCF,0x1C,0x71,0xC7,0x8E,0x39,0xE7,0x1C,0x73,0xCF,0x38 // '}'
};
const GFXglyph Orbitron_Bold_22Glyphs[] PROGMEM = {
// bitmapOffset, width, height, xAdvance, xOffset, yOffset
{ 0, 1, 1, 8, 0, 0 }, // ' '
{ 1, 4, 16, 6, 1, -16 }, // '!'
{ 9, 8, 4, 9, 1, -16 }, // '"'
{ 13, 17, 16, 19, 1, -16 }, // '#'
{ 47, 16, 20, 18, 1, -18 }, // '$'
{ 87, 20, 16, 22, 1, -16 }, // '%'
{ 127, 20, 16, 22, 1, -16 }, // '&'
{ 167, 4, 4, 6, 1, -16 }, // '''
{ 169, 5, 16, 7, 1, -16 }, // '('
{ 179, 5, 16, 7, 1, -16 }, // ')'
{ 189, 11, 10, 12, 1, -16 }, // '*'
{ 203, 10, 9, 11, 0, -11 }, // '+'
{ 215, 4, 6, 6, 1, -3 }, // ','
{ 218, 10, 3, 12, 1, -8 }, // '-'
{ 222, 4, 3, 6, 1, -3 }, // '.'
{ 224, 12, 16, 12, 0, -16 }, // '/'
{ 248, 17, 16, 19, 1, -16 }, // '0'
{ 282, 9, 16, 10, 0, -16 }, // '1'
{ 300, 17, 16, 19, 1, -16 }, // '2'
{ 334, 17, 16, 19, 1, -16 }, // '3'
{ 368, 16, 16, 17, 0, -16 }, // '4'
{ 400, 17, 16, 19, 1, -16 }, // '5'
{ 434, 17, 16, 19, 1, -16 }, // '6'
{ 468, 14, 16, 16, 0, -16 }, // '7'
{ 496, 17, 16, 19, 1, -16 }, // '8'
{ 530, 17, 16, 19, 1, -16 }, // '9'
{ 564, 4, 13, 6, 1, -13 }, // ':'
{ 571, 4, 16, 6, 1, -13 }, // ';'
{ 579, 10, 13, 11, 0, -13 }, // '<'
{ 596, 13, 7, 15, 1, -10 }, // '='
{ 608, 11, 13, 11, 1, -13 }, // '>'
{ 626, 14, 16, 16, 1, -16 }, // '?'
{ 654, 17, 16, 19, 1, -16 }, // '@'
{ 688, 17, 16, 19, 1, -16 }, // 'A'
{ 722, 17, 16, 19, 1, -16 }, // 'B'
{ 756, 17, 16, 19, 1, -16 }, // 'C'
{ 790, 17, 16, 19, 1, -16 }, // 'D'
{ 824, 16, 16, 18, 1, -16 }, // 'E'
{ 856, 16, 16, 17, 1, -16 }, // 'F'
{ 888, 17, 16, 19, 1, -16 }, // 'G'
{ 922, 17, 16, 20, 1, -16 }, // 'H'
{ 956, 4, 16, 6, 1, -16 }, // 'I'
{ 964, 17, 16, 18, 0, -16 }, // 'J'
{ 998, 17, 16, 19, 1, -16 }, // 'K'
{ 1032, 17, 16, 18, 1, -16 }, // 'L'
{ 1066, 19, 16, 21, 1, -16 }, // 'M'
{ 1104, 17, 16, 19, 1, -16 }, // 'N'
{ 1138, 17, 16, 19, 1, -16 }, // 'O'
{ 1172, 17, 16, 18, 1, -16 }, // 'P'
{ 1206, 19, 16, 20, 1, -16 }, // 'Q'
{ 1244, 17, 16, 19, 1, -16 }, // 'R'
{ 1278, 17, 16, 19, 1, -16 }, // 'S'
{ 1312, 17, 16, 18, 0, -16 }, // 'T'
{ 1346, 17, 16, 19, 1, -16 }, // 'U'
{ 1380, 22, 16, 23, 1, -16 }, // 'V'
{ 1424, 25, 16, 27, 1, -16 }, // 'W'
{ 1474, 17, 16, 19, 1, -16 }, // 'X'
{ 1508, 19, 16, 19, 0, -16 }, // 'Y'
{ 1546, 17, 16, 19, 1, -16 }, // 'Z'
{ 1580, 5, 16, 7, 1, -16 }, // '['
{ 1590, 12, 16, 12, 0, -16 }, // '\'
{ 1614, 5, 16, 7, 1, -16 }, // ']'
{ 1624, 1, 1, 1, 0, 0 }, // '^'
{ 1625, 17, 3, 19, 1, 0 }, // '_'
{ 1632, 5, 4, 6, 1, -21 }, // '`'
{ 1635, 14, 13, 16, 1, -13 }, // 'a'
{ 1658, 14, 17, 16, 1, -17 }, // 'b'
{ 1688, 14, 13, 16, 1, -13 }, // 'c'
{ 1711, 13, 17, 16, 1, -17 }, // 'd'
{ 1739, 14, 13, 16, 1, -13 }, // 'e'
{ 1762, 9, 17, 11, 1, -17 }, // 'f'
{ 1782, 14, 18, 16, 1, -13 }, // 'g'
{ 1814, 14, 17, 16, 1, -17 }, // 'h'
{ 1844, 4, 17, 6, 1, -17 }, // 'i'
{ 1853, 9, 22, 6, -4, -17 }, // 'j'
{ 1878, 14, 17, 15, 1, -17 }, // 'k'
{ 1908, 7, 17, 9, 1, -17 }, // 'l'
{ 1923, 20, 13, 23, 1, -13 }, // 'm'
{ 1956, 14, 13, 16, 1, -13 }, // 'n'
{ 1979, 14, 13, 16, 1, -13 }, // 'o'
{ 2002, 14, 18, 16, 1, -13 }, // 'p'
{ 2034, 14, 18, 16, 0, -13 }, // 'q'
{ 2066, 11, 13, 13, 1, -13 }, // 'r'
{ 2084, 14, 13, 16, 1, -13 }, // 's'
{ 2107, 9, 17, 11, 1, -17 }, // 't'
{ 2127, 14, 13, 16, 1, -13 }, // 'u'
{ 2150, 18, 13, 18, 0, -13 }, // 'v'
{ 2180, 23, 13, 24, 1, -13 }, // 'w'
{ 2218, 14, 13, 16, 1, -13 }, // 'x'
{ 2241, 14, 18, 16, 1, -13 }, // 'y'
{ 2273, 14, 13, 16, 1, -13 }, // 'z'
{ 2296, 6, 16, 7, 1, -16 }, // '{'
{ 2308, 4, 20, 6, 1, -18 }, // '|'
{ 2318, 6, 16, 7, 1, -16 } // '}'
};
const GFXfont Orbitron_Bold_22 PROGMEM = {
(uint8_t *)Orbitron_Bold_22Bitmaps,(GFXglyph *)Orbitron_Bold_22Glyphs,0x20, 0x7E, 23};
| [
"amcolash@gmail.com"
] | amcolash@gmail.com |
b850d48e1cc37091751c2cc5c882a431ff562358 | c55d472c09da4d0f62997bcfc7e8bfe7d8be7fdb | /apue/pthread/abcde_cond.c | 23fb87be4cd95d8831eb99dd05eb277609f0faa8 | [] | no_license | zzy0119/emb20210322 | 83492cf990541f98250038118fd804127ba85818 | 7adb8ac29fca551cf2e068f0096a2e0633508577 | refs/heads/master | 2023-05-15T19:52:18.701457 | 2021-06-18T03:47:35 | 2021-06-18T03:47:35 | 357,404,476 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,106 | c | #include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <sched.h>
#define THRNR 5
static int jobid = -1;
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static void *thrJob(void *arg)
{
int selfid = (int)arg;
while (1) {
pthread_mutex_lock(&mut);
while (jobid != selfid) {
pthread_cond_wait(&cond, &mut);
}
fprintf(stdout, "%c", 'a'+selfid);
fflush(NULL);
jobid = -1;
sleep(1);
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mut);
}
}
int main(void)
{
pthread_t tids[THRNR] = {};
int i;
int err;
alarm(50);
for (i = 0; i < THRNR; i++) {
err = pthread_create(tids+i, NULL, thrJob, (void *)i);
if (err) {
fprintf(stderr, "pthread_create():%s\n", \
strerror(err));
exit(1);
}
}
for (i = 0; ; i = (i+1) % THRNR) {
pthread_mutex_lock(&mut);
while (jobid != -1) {
pthread_cond_wait(&cond, &mut);
}
jobid = i;
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mut);
}
pthread_mutex_destroy(&mut);
exit(0);
}
| [
"you@example.com"
] | you@example.com |
ef4d8b76aa95d55682bcb200fd371e515755a4e0 | 061fedbd3274d265ba4923bce29fc17d90ac8d8b | /mr32.h | 557cf593349da3dc7701932edf73594d089dcb14 | [] | no_license | jobanana/urato | 3d1de3be940fca5b6ca7573c17cc717fec65620f | 641248e0aa6e2855371ec464eca9d03f658e777e | refs/heads/master | 2020-12-30T14:00:24.790118 | 2017-05-16T20:35:44 | 2017-05-16T20:35:44 | 91,272,723 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,197 | h | /**
* \file rmi-mr32.h
* \brief The MR32 library used in RMI
*
* \defgroup general General functions
* \defgroup math Math functions
* \defgroup sensors Sensor functions
* \defgroup actuators Actuation functions
* \defgroup times Time functions
*/
// ****************************************************************************
// MR32.H
//
// Current version:
// - 1.6 - 23/10/2014
//
// J.L.Azevedo, DETI-UA
// ****************************************************************************
#ifndef __MR32_H
#define __MR32_H
#define ROBOT 10
#ifndef ROBOT
#error "ROBOT number have to be defined (ex: #define ROBOT 0)"
#endif
#include <detpic32.h>
#define PI 3.141592654
typedef enum bool { false = 0, true } bool;
/** \brief sensor ids
* \anchor sensor_ids
*/
#define OBST_SENSOR_RIGHT 0
#define OBST_SENSOR_FRONT 1
#define OBST_SENSOR_LEFT 2
#define AN6 3
#define AN7 4
#define BATTERY 5
#define waitTick40ms() {while(!tick40ms); tick40ms = 0;}
#define waitTick20ms() {while(!tick20ms); tick20ms = 0;}
/** \brief get start button status
* \return the start button status
*/
#define startButton() (!PORTBbits.RB3)
#define stopButton() (!PORTBbits.RB4) //*! get stop button status
#define enableObstSens() {LATBbits.LATB10=1;}
#define disableObstSens() {LATBbits.LATB10=0;}
#define enableGroundSens() {LATEbits.LATE5=1;}
#define disableGroundSens() {LATEbits.LATE5=0;}
#define readBeaconSens() (PORTBbits.RB9)
#ifdef __cplusplus
extern "C" {
#endif
// ****************************************************************************
// Global variables
typedef union
{
struct
{
int obstSensRight; ///< right obstacle sensor
int obstSensFront; ///< frontal obstacle sensor
int obstSensLeft;
int an6;
int an7;
int batteryVoltage;
};
int array[6];
} MR32_analogSensors;
extern MR32_analogSensors analogSensors;
extern int SERVO_WIDTH_MIN;
extern int SERVO_WIDTH_MAX;
extern volatile bool tick10ms;
extern volatile bool tick20ms;
extern volatile bool tick40ms;
extern volatile bool tick80ms;
extern volatile bool tick160ms;
// ****************************************************************************
// Function prototypes
/** \brief Init the Robot's software
* \details ...
* \ingroup general
*/
void initPIC32(void);
/** \brief Read all analog sensors.
* \details The sensors read are the obstacle sensors and the battery status.
* The measured values are stored in an internal memory.
* \ingroup sensors
*/
void readAnalogSensors(void);
/** \brief Read the frontal line sensors
* \details The integration time of the line sensors can be controlled
* through a gain
* \ingroup sensors
* \param gain A value controlling the integration time of the line sensor:
* if 0, a default value is used; otherwise the given value is used.
* \return A 5-bit value representing the current measurements of the sensors.
*/
unsigned int readLineSensors(int gain); // for default value of gain, pass 0
/** \brief turn on/off leds
* \ingroup actuators
* \param state 4-bit value representing the required on/off state of each led
*/
void leds(int state);
/** \brief turn on/off given led
* \ingroup actuators
* \param ledNr number of led to turn on/off
* \param 1-bit value representing the required on/off state of the led
*/
void led(int ledNr, int value);
/** \brief Set beacon sensor servo position
* \ingroup actuators
* \param pos The servo position in range [-15,+15], clockwise
*/
void setServoPos(int pos);
/** \brief Get dead reckoning robot position/pose
* \param [out] xp Pointer to variable where to store the X coord
* \param [out] yp Pointer to variable where to store the Y coord
* \param [out] hp Pointer to variable where to store the heading
*/
void getRobotPos(double *xx, double *yy, double *tt);
/** \brief suspend execution during a given period
* \ingroup times
* \param time time in tenths of milliseconds
*/
void delay(unsigned int time);
/** \brief suspend execution during a given period
* \ingroup times
* \param time time in tenths of seconds
*/
void wait(unsigned int time);
/** \brief get the last reading of the given obstacle sensor
* \ingroup sensors
* \param sensorId sensor id
* \sa sensor_ids
* \return the last value read
*/
unsigned int obstacleSensor(unsigned int sensorId);
/** \brief get the last reading of the battery status sensor
* \ingroup sensors
* \return the last value read
*/
unsigned int batteryVoltage(void);
/** \brief set control mode
* \ingroup actuators
* \param flag set/reset control mode (true set closed mode)
*/
void closedLoopControl(bool flag);
/** \brief Apply the given velocities to the wheel motors
* \details velocities range from -100 to 100, where 100 roughly represents 0.7 m/s
* \ingroup actuators
* \param velLeft setpoint for left motor, in range [-100, 100]
* \param velRight setpoint for right motor, in range [-100, 100]
*/
void setVel2(int velLeft, int velRight);
/** \brief normalize an angle to range ]-180,+180]
* \ingroup math
* \param angle the angle to normalize
* \return the normalized angle
*/
double normalizeAngle(double angle);
#ifdef __cplusplus
}
#endif
#endif
| [
"easg@ua.pt"
] | easg@ua.pt |
c9f04f786abc00a2a9e1dfb81508921f57fee0ed | a72a706c9fddc1aeccd969ecce4661a7761c7e72 | /inc/controller.h | 22369d14b0de0413bda46f6b58970b1cd85550a8 | [] | no_license | misterdoud/CC3D-CableCam-Controller | ed607902406863695a374e9b2292f6f2ed361025 | 249660f534dcde9e865e97d843cdfaaf2d4af315 | refs/heads/master | 2021-06-24T22:02:49.876812 | 2017-09-03T04:56:15 | 2017-09-03T04:56:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 605 | h | #ifndef CONTROLLER_H_
#define CONTROLLER_H_
#include "stm32f4xx.h"
#define APP_TX_BUF_SIZE 512
void setServoNeutralRange(uint16_t forward, uint16_t reverse);
void initController(void);
void controllercycle(void);
void setPIDValues(double, double, double);
void setPValue(double);
void setIValue(double);
void setDValue(double);
int32_t getTargetPos(void);
int32_t getPos(void);
int16_t getStick(void);
void resetThrottle(void);
void resetPosTarget(void);
uint16_t getProgrammingSwitch(void);
uint16_t getEndPointSwitch(void);
uint16_t getMaxAccelPoti(void);
uint16_t getMaxSpeedPoti(void);
#endif
| [
"werner.daehn@googlemail.com"
] | werner.daehn@googlemail.com |
c77e475478b1b5615d7909948e781fddffc95ea9 | baed6f2ef8b26339af8b4f7a9096c446a9da3b3f | /A025_ESP8266固件/Source/func/func.h | 02ac90acfbeebc21b473b8626bd3264f6100e83e | [] | no_license | 742117806/A025_Plus | b2bbe7fc903418a1e5d11e7853a26240be31b860 | c836b116545837509ca3043e865e1afeb1592f91 | refs/heads/master | 2020-04-11T04:14:20.363457 | 2018-12-12T15:25:29 | 2018-12-12T15:25:29 | 161,505,898 | 0 | 0 | null | null | null | null | GB18030 | C | false | false | 4,158 | h | /************************************************************
Copyright (C), 2013-2015, SOSCI.Co.,Ltd.
@FileName: func.h
@Author : 糊读虫
@Version : 1.0
@Date : 2015-8-12
@Description: 系统操作功能
@Function List:
@History :
<author> <time> <version > <desc>
Lennon 2015/8/12 1.0
***********************************************************/
#ifndef _FUNCTION_H
#define _FUNCTION_H
//#include "include.h"
#include "sys.h"
void NullFucn(void);
void ManualSetMenu(void);
void Help(void);
void SetDataTime(void);
void LoadDefault(void);
void Version(void);
void PreviewTimer(void);
void Desktop(void);
void WifiApModeConfig(void);
void WifiStaModeConfig(void);
void WifiInfo(void);
void ReturnToMenu(void);
//void TimerSetup(void);
void SunriseSet(void);
void SundownSet(void);
void SunlightSet(void);
void MoonlightSet(void);
void TempFan(void);
void ShowCurrentPwmMenu(void);
void ViewFlashEffect(void);
void ViewCloudEffect(void);
void ResetPreviewTimer(void);
void LedOnOff(void);
void Language(void);//语言切换
void saveLanguage(void);
void PilotLight(void); //LED指示灯
void CheckUdataKey(void); //升级按键功能
void ShowUpdataProgress(void);//升级进度
void SetPreveiwTime(u8 hour,u8 minute);
void SystemLoadDefault(void);//系统默认设置
void AdjFanByTmp(void);
void ConfigWifiStaConn(void); //配置STA模式连网
//-----------------------------------
void SetCustomCode(u16 code1);//设置客户代码
u16 GetCustomCode(void);//获取客户代码
void SetPwmNumber(u8 num);//设置调光路数
u8 GetPwmNumber(void);//获取调光路数
u8 GetGUID(u8 index);//获取GUID，index = 0~11
void ReadGUID(void); //读取GUID到数组中
void LedIndicatorFlash(void); //指示灯闪烁
void BeepSong(void);//蜂鸣器发声
void ErasureUserLogo(void);
void DisplayUserLogo(void);
extern void(*ClockFunc)(void);
#define SetClockFun(X) ClockFunc=X //设置每秒要执行的函数
#define START_TMP 38 //风扇启动温度
#define MAX_TMP 46 //上限温度
#define OVER_TMP 68 //过温保护
//系统信息结构体
typedef struct _SysInfo{
u16 ledIndicator; //LED指示灯闪烁方式
u8 workmode; //工作模式
u8 indexTimer; //当前定时点
u8 nextTimer; //下一个定时点
u8 pwmNumber; //调光路数
u8 pwmSpeed; //PWM变化的速度
u8 language; //语言 0:英文 1:中文
u8 updataType; //升级类型
u8 temperature; //灯具温度
u8 OverProtect; //过温保护
u8 MunualFan; //手动测试FAN
u8 Beep_type; //喇叭声音类型
}SYSINFO;
//电机相关信息
typedef struct
{
u8 enable;
u8 s_hour1;
u8 s_minute1;
u8 e_hour1;
u8 e_minute1;
u8 s_hour2;
u8 s_minute2;
u8 e_hour2;
u8 e_minute2;
u8 s_hour3;
u8 s_minute3;
u8 e_hour3;
u8 e_minute3;
u8 angle_h;
u8 angle_l;
u8 speed;
}MotorInfo_s;
//联合体 位标志
typedef union _flag{
u16 bytes;
struct _b{
u16 LED_sta :1; //工作指示灯
// u16 LED_wifi :1; //WIFI指示灯
u16 LED_SAVE :1; //保存指示灯状态
uint16_t WIFI_MODE:2; //WiFi工作模式1STA，2AP，3AP+STA
}Bits;
}SYSFLAG;
extern SYSINFO sysInfo;
extern SYSFLAG sysFlag;
extern MotorInfo_s motorInfo; //电机相关信息
//extern uint8_t connectingWiFiFlag; //正在连接WiFi路由器指示灯
#define SetWorkMode(X) sysInfo.workmode=X
#define SetLedIndicator(X) sysInfo.ledIndicator=X //设置指示灯闪烁方式
#define SetPwmSpeed(X) sysInfo.pwmSpeed=X //设置PWM变化速度
#define SetBeepType(X) sysInfo.Beep_type=X //设置蜂鸣器
#define ENGELISH 0 //英文
#define CHINESE 1 //中文
#define IF_EN() if(sysInfo.language==ENGELISH)
#define IF_CN() if(sysInfo.language==CHINESE)
//LED指示灯闪烁方式
#define LED_ITR_OFF 0x0000 //关闭
#define LED_ITR_ONE 0x0F0F //1秒闪一次
#define LED_ITR_TWO 0x0009 //闪两下,灭1秒
#define LED_ITR_THREE 0x0049 //闪三下,灭一秒
#define LED_ITR_FLASH 0x5555 //狂闪
#define LED_ITR_ON 0xFFFF //一直亮
//蜂鸣器响
#define BEEP_OFF 0x00 //关闭
#define BEEP_ONE 0x80 //响一次
#define BEEP_TWO 0xA0 //响两次
#define BEEP_THREE 0xA8 //响三次
void ShowTwoNum(u8 x,u8 y,u8 num,u8 mode);
#endif
| [
"742117806@qq.com"
] | 742117806@qq.com |
861cf454458785059115c41d93fc88f666477cc3 | 3a0ad8840444ecd1356ac8e1a7126b68b72db1a2 | /android/ringlibsdl/project/jni/ring/src/ring_objfile.c | 108cc990ae0b36de5680a2a29fb4ec013e28c2d1 | [
"MIT"
] | permissive | m-saber/ring | c506bd3480e3fbb2e3fe391a9b0df78a2a620505 | 86868a686284df8eabc9e62f236cdec68c67c767 | refs/heads/master | 2022-04-05T15:43:24.540370 | 2020-01-04T16:11:21 | 2020-01-04T16:11:21 | 226,169,824 | 1 | 0 | MIT | 2019-12-05T19:01:29 | 2019-12-05T19:01:28 | null | UTF-8 | C | false | false | 21,651 | c | /*
** Copyright (c) 2013-2019 Mahmoud Fayed <msfclipper@yahoo.com>
** Include Files
*/
#include "ring.h"
/* Define Functions */
void ring_objfile_writefile ( RingState *pRingState )
{
FILE *fObj;
char cFileName[400] ;
/* Create File */
sprintf( cFileName , "%so" , ring_list_getstring(pRingState->pRingFilesList,1) ) ;
fObj = fopen(cFileName , "w+b" );
fprintf( fObj , "# Ring Object File\n" ) ;
fprintf( fObj , "# Version 1.1\n" ) ;
/* Write Functions Lists */
fprintf( fObj , "# Functions List\n" ) ;
ring_objfile_writelist(pRingState->pRingFunctionsMap,fObj);
/* Write Classes List */
fprintf( fObj , "# Classes List\n" ) ;
ring_objfile_writelist(pRingState->pRingClassesMap,fObj);
/* Write Packages */
fprintf( fObj , "# Packages List\n" ) ;
ring_objfile_writelist(pRingState->pRingPackagesMap,fObj);
/* Write Code */
fprintf( fObj , "# Program Code\n" ) ;
ring_objfile_writelist(pRingState->pRingGenCode,fObj);
/* Close File */
fprintf( fObj , "# End of File\n" ) ;
fclose( fObj ) ;
}
void ring_objfile_writelist ( List *pList,FILE *fObj )
{
List *pList2 ;
int x,x2 ;
char *cString ;
char cKey[11] ;
strcpy(cKey,"ringstring");
fprintf( fObj , "{\n" ) ;
/* Write List Items */
for ( x = 1 ; x <= ring_list_getsize(pList) ; x++ ) {
pList2 = ring_list_getlist(pList,x);
fprintf( fObj , "[T]\n" ) ;
for ( x2 = 1 ; x2 <= ring_list_getsize(pList2) ; x2++ ) {
if ( ring_list_isstring(pList2,x2) ) {
fprintf( fObj , "[S][%d]" , ring_list_getstringsize(pList2,x2) ) ;
/* Encrypt String */
cString = ring_list_getstring(pList2,x2) ;
ring_objfile_xorstring(cString,ring_list_getstringsize(pList2,x2),cKey,10);
fwrite( ring_list_getstring(pList2,x2) , 1 , ring_list_getstringsize(pList2,x2) , fObj );
/* Decrypt String */
ring_objfile_xorstring(cString,ring_list_getstringsize(pList2,x2),cKey,10);
fprintf( fObj , "\n" ) ;
}
else if ( ring_list_isint(pList2,x2) ) {
fprintf( fObj , "[I]%d\n" , ring_list_getint(pList2,x2) ) ;
}
else if ( ring_list_isdouble(pList2,x2) ) {
fprintf( fObj , "[D]%f\n" , ring_list_getdouble(pList2,x2) ) ;
}
else if ( ring_list_ispointer(pList2,x2) ) {
fprintf( fObj , "[P]%p\n" , (void *) ring_list_getpointer(pList2,x2) ) ;
}
else if ( ring_list_islist(pList2,x2) ) {
fprintf( fObj , "[L]\n" ) ;
ring_objfile_writelist(ring_list_getlist(pList2,x2) ,fObj);
}
}
fprintf( fObj , "[E]\n" ) ;
}
fprintf( fObj , "}\n" ) ;
}
int ring_objfile_readfile ( RingState *pRingState,char *cFileName )
{
return ring_objfile_readfromsource(pRingState,cFileName,RING_OBJFILE_READFROMFILE) ;
}
int ring_objfile_readstring ( RingState *pRingState,char *cString )
{
return ring_objfile_readfromsource(pRingState,cString,RING_OBJFILE_READFROMSTRING) ;
}
int ring_objfile_readfromsource ( RingState *pRingState,char *cSource,int nSource )
{
List *pListFunctions, *pListClasses, *pListPackages, *pListCode, *pListStack ;
/* Create Lists */
pListFunctions = ring_list_new_gc(pRingState,0);
pListClasses = ring_list_new_gc(pRingState,0);
pListPackages = ring_list_new_gc(pRingState,0);
pListCode = ring_list_new_gc(pRingState,0);
pListStack = ring_list_new_gc(pRingState,0);
/* Process Content (File or String) */
if ( nSource == RING_OBJFILE_READFROMFILE ) {
if ( ! ring_objfile_processfile(pRingState,cSource,pListFunctions, pListClasses, pListPackages, pListCode, pListStack) ) {
return 0 ;
}
}
else if ( nSource ==RING_OBJFILE_READFROMSTRING ) {
if ( ! ring_objfile_processstring(pRingState,cSource,pListFunctions, pListClasses, pListPackages, pListCode, pListStack) ) {
return 0 ;
}
}
ring_list_delete_gc(pRingState,pListStack);
/* Update Ring State */
#ifdef DEBUG_OBJFILE
puts("Old Code List ");
ring_list_print(pRingState->pRingGenCode);
#endif
/* Update Lists */
pRingState->pRingFunctionsMap = pListFunctions ;
pRingState->pRingClassesMap = pListClasses ;
pRingState->pRingPackagesMap = pListPackages ;
pRingState->pRingGenCode = pListCode ;
#ifdef DEBUG_OBJFILE
puts("Update Done! ");
puts("New Code List ");
ring_list_print(pRingState->pRingGenCode);
#endif
/* Update Classes Pointers */
ring_objfile_updateclassespointers(pRingState);
return 1 ;
}
int ring_objfile_processfile ( RingState *pRingState,char *cFileName,List *pListFunctions,List *pListClasses,List *pListPackages,List *pListCode,List *pListStack )
{
FILE *fObj;
signed char c ;
int nActiveList,nValue,nBraceEnd ;
double dValue ;
char *cString ;
char cKey[11] ;
char cFileType[100] ;
List *pList ;
strcpy(cKey,"ringstring");
/* Set Active List (1=functions 2=classes 3=packages 4=code) */
nActiveList = 0 ;
nBraceEnd = 0 ;
pList = NULL ;
/* Open File */
fObj = fopen(cFileName , "rb" );
if ( fObj==NULL ) {
printf( "Can't open file %s \n ",cFileName ) ;
return 0 ;
}
fread( cFileType , 1 , 18 , fObj );
cFileType[18] = '\0' ;
if ( strcmp(cFileType,"# Ring Object File") != 0 ) {
printf( RING_OBJFILEWRONGTYPE ) ;
return 0 ;
}
c = getc(fObj);
fread( cFileType , 1 , 13 , fObj );
cFileType[13] = '\0' ;
if ( strcmp(cFileType,"# Version 1.1") != 0 ) {
printf( RING_OBJFILEWRONGVERSION ) ;
return 0 ;
}
/* Process File */
c = getc(fObj);
while ( c != EOF ) {
/* Check Char */
switch ( c ) {
case '#' :
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
#ifdef DEBUG_OBJFILE
printf( "%c ",c ) ;
#endif
}
#ifdef DEBUG_OBJFILE
puts("Read Comment ! ");
#endif
break ;
case '{' :
nActiveList++ ;
switch ( nActiveList ) {
case 1 :
pList = pListFunctions ;
break ;
case 2 :
pList = pListClasses ;
break ;
case 3 :
pList = pListPackages ;
break ;
case 4 :
pList = pListCode ;
break ;
}
break ;
case '[' :
c = getc(fObj);
switch ( c ) {
case 'S' :
c = getc(fObj);
fscanf( fObj , "[%d]" , &nValue ) ;
cString = (char *) ring_state_malloc(pRingState,nValue+1);
if ( cString == NULL ) {
printf( RING_OOM ) ;
exit(0);
}
fread( cString , 1 , nValue , fObj );
cString[nValue] = '\0' ;
/* Decrypt String */
ring_objfile_xorstring(cString,nValue,cKey,10);
ring_list_addstring2_gc(pRingState,pList,cString,nValue);
ring_state_free(pRingState,cString);
#ifdef DEBUG_OBJFILE
printf( "Read String %s Size %d \n",cString,nValue ) ;
#endif
break ;
case 'I' :
c = getc(fObj);
fscanf( fObj , "%d" , &nValue ) ;
ring_list_addint_gc(pRingState,pList,nValue);
#ifdef DEBUG_OBJFILE
printf( "Read Number %d \n ",nValue ) ;
#endif
break ;
case 'D' :
c = getc(fObj);
fscanf( fObj , "%lf" , &dValue ) ;
ring_list_adddouble_gc(pRingState,pList,dValue);
#ifdef DEBUG_OBJFILE
printf( "Read Double %d \n",dValue ) ;
#endif
break ;
case 'P' :
ring_list_addpointer_gc(pRingState,pList,NULL);
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
}
#ifdef DEBUG_OBJFILE
puts("Read Pointer ");
#endif
break ;
case 'T' :
ring_list_addpointer_gc(pRingState,pListStack,pList);
pList = ring_list_newlist_gc(pRingState,pList);
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
}
#ifdef DEBUG_OBJFILE
puts("Read T ");
#endif
break ;
case 'E' :
pList = (List *) ring_list_getpointer(pListStack,ring_list_getsize(pListStack)) ;
ring_list_deletelastitem_gc(pRingState,pListStack);
/* Read Line */
while ( c != '\n' ) {
c = getc(fObj);
}
#ifdef DEBUG_OBJFILE
puts("Read E ");
#endif
break ;
case 'L' :
/* Read Until { */
while ( c != '{' ) {
c = getc(fObj);
}
ring_list_addpointer_gc(pRingState,pListStack,pList);
pList = ring_list_newlist_gc(pRingState,pList);
nBraceEnd++ ;
#ifdef DEBUG_OBJFILE
puts("Read L ");
#endif
break ;
}
break ;
case '}' :
if ( nBraceEnd ) {
pList = (List *) ring_list_getpointer(pListStack,ring_list_getsize(pListStack)) ;
ring_list_deletelastitem_gc(pRingState,pListStack);
nBraceEnd-- ;
#ifdef DEBUG_OBJFILE
puts("Read } ");
#endif
}
break ;
}
c = getc(fObj);
}
/* Close File */
fclose( fObj ) ;
return 1 ;
}
int ring_objfile_processstring ( RingState *pRingState,char *cContent,List *pListFunctions,List *pListClasses,List *pListPackages,List *pListCode,List *pListStack )
{
signed char c ;
int nActiveList,nValue,nBraceEnd ;
double dValue ;
char *cString, *cData ;
char cKey[11] ;
char cFileType[100] ;
List *pList ;
strcpy(cKey,"ringstring");
/* Set Active List (1=functions 2=classes 3=packages 4=code) */
nActiveList = 0 ;
nBraceEnd = 0 ;
pList = NULL ;
cData = cContent ;
/* Check Type and Version */
ring_objfile_readc(pRingState,&cData,cFileType,18);
cFileType[18] = '\0' ;
if ( strcmp(cFileType,"# Ring Object File") != 0 ) {
printf( RING_OBJFILEWRONGTYPE ) ;
return 0 ;
}
c = ring_objfile_getc(pRingState,&cData);
ring_objfile_readc(pRingState,&cData,cFileType,13);
cFileType[13] = '\0' ;
if ( strcmp(cFileType,"# Version 1.1") != 0 ) {
printf( RING_OBJFILEWRONGVERSION ) ;
return 0 ;
}
/* Process Content */
c = ring_objfile_getc(pRingState,&cData);
while ( c != EOF ) {
/* Check Char */
switch ( c ) {
case '#' :
/* Read Line */
while ( c != '\n' ) {
c = ring_objfile_getc(pRingState,&cData);
#ifdef DEBUG_OBJFILE
printf( "%c ",c ) ;
#endif
}
#ifdef DEBUG_OBJFILE
puts("Read Comment ! ");
#endif
break ;
case '{' :
nActiveList++ ;
switch ( nActiveList ) {
case 1 :
pList = pListFunctions ;
break ;
case 2 :
pList = pListClasses ;
break ;
case 3 :
pList = pListPackages ;
break ;
case 4 :
pList = pListCode ;
break ;
}
break ;
case '[' :
c = ring_objfile_getc(pRingState,&cData);
switch ( c ) {
case 'S' :
c = ring_objfile_getc(pRingState,&cData);
sscanf(cData,"[%d]",&nValue);
/* Pass Letters */
c = ' ' ;
while ( c != ']' ) {
c = ring_objfile_getc(pRingState,&cData);
}
cString = (char *) ring_state_malloc(pRingState,nValue+1);
if ( cString == NULL ) {
printf( RING_OOM ) ;
exit(0);
}
ring_objfile_readc(pRingState,&cData,cString,nValue);
cString[nValue] = '\0' ;
/* Decrypt String */
ring_objfile_xorstring(cString,nValue,cKey,10);
ring_list_addstring2_gc(pRingState,pList,cString,nValue);
#ifdef DEBUG_OBJFILE
printf( "Read String %s Size %d \n",cString,nValue ) ;
#endif
ring_state_free(pRingState,cString);
break ;
case 'I' :
c = ring_objfile_getc(pRingState,&cData);
sscanf(cData,"%d",&nValue);
/* Pass Letters */
c = '0' ;
while ( isdigit(c) || c=='.' ) {
c = ring_objfile_getc(pRingState,&cData);
}
cData-- ;
ring_list_addint_gc(pRingState,pList,nValue);
#ifdef DEBUG_OBJFILE
printf( "Read Number %d \n ",nValue ) ;
#endif
break ;
case 'D' :
c = ring_objfile_getc(pRingState,&cData);
sscanf(cData,"%lf",&dValue);
/* Pass Letters */
c = '0' ;
while ( isdigit(c) || c=='.' ) {
c = ring_objfile_getc(pRingState,&cData);
}
cData-- ;
ring_list_adddouble_gc(pRingState,pList,dValue);
#ifdef DEBUG_OBJFILE
printf( "Read Double %d \n",dValue ) ;
#endif
break ;
case 'P' :
ring_list_addpointer_gc(pRingState,pList,NULL);
/* Read Line */
while ( c != '\n' ) {
c = ring_objfile_getc(pRingState,&cData);
}
#ifdef DEBUG_OBJFILE
puts("Read Pointer ");
#endif
break ;
case 'T' :
ring_list_addpointer_gc(pRingState,pListStack,pList);
pList = ring_list_newlist_gc(pRingState,pList);
/* Read Line */
while ( c != '\n' ) {
c = ring_objfile_getc(pRingState,&cData);
}
#ifdef DEBUG_OBJFILE
puts("Read T ");
#endif
break ;
case 'E' :
pList = (List *) ring_list_getpointer(pListStack,ring_list_getsize(pListStack)) ;
ring_list_deletelastitem_gc(pRingState,pListStack);
/* Read Line */
while ( c != '\n' ) {
c = ring_objfile_getc(pRingState,&cData);
}
#ifdef DEBUG_OBJFILE
puts("Read E ");
#endif
break ;
case 'L' :
/* Read Until { */
while ( c != '{' ) {
c = ring_objfile_getc(pRingState,&cData);
}
ring_list_addpointer_gc(pRingState,pListStack,pList);
pList = ring_list_newlist_gc(pRingState,pList);
nBraceEnd++ ;
#ifdef DEBUG_OBJFILE
puts("Read L ");
#endif
break ;
}
break ;
case '}' :
if ( nBraceEnd ) {
pList = (List *) ring_list_getpointer(pListStack,ring_list_getsize(pListStack)) ;
ring_list_deletelastitem_gc(pRingState,pListStack);
nBraceEnd-- ;
#ifdef DEBUG_OBJFILE
puts("Read } ");
#endif
}
break ;
}
c = ring_objfile_getc(pRingState,&cData);
}
return 1 ;
}
RING_API void ring_objfile_updateclassespointers ( RingState *pRingState )
{
int x,x2,x3,x4,lFound ;
List *pList, *pList2, *pList3 ;
const char *cString ;
char cPackageName[400] ;
char cClassName[400] ;
/* Update Class Pointer in Code */
lFound = 0 ;
for ( x = 1 ; x <= ring_list_getsize(pRingState->pRingGenCode) ; x++ ) {
pList = ring_list_getlist(pRingState->pRingGenCode,x);
if ( ring_list_getint(pList,1) == ICO_NEWCLASS ) {
cString = ring_list_getstring(pList,2);
for ( x2 = 1 ; x2 <= ring_list_getsize(pRingState->pRingClassesMap) ; x2++ ) {
pList2 = ring_list_getlist(pRingState->pRingClassesMap,x2);
if ( strcmp(cString,ring_list_getstring(pList2,1)) == 0 ) {
lFound = 0 ;
ring_list_setpointer_gc(pRingState,pList,3,pList2);
#ifdef DEBUG_OBJFILE
puts("Pointer Updated ");
#endif
break ;
}
}
/* If we can't find the list (the class is inside a package) */
if ( lFound == 0 ) {
ring_list_setpointer_gc(pRingState,pList,3,NULL);
}
}
}
/*
** Update Class Pointers in Classes Map when the class belong to a Package
** This updates works when the class name is : packagename.classname
*/
for ( x = 1 ; x <= ring_list_getsize(pRingState->pRingClassesMap) ; x++ ) {
pList = ring_list_getlist(pRingState->pRingClassesMap,x);
cString = ring_list_getstring(pList,1);
if ( ring_list_getstringsize(pList,1) > 400 ) {
/* Avoid large names - we have limits (400 letters per package name - 400 letters for class name) */
continue ;
}
for ( x2 = ring_list_getstringsize(pList,1) - 1 ; x2 >= 0 ; x2-- ) {
if ( cString[x2] == '.' ) {
/*
** Now we have a class name stored as packagename.classname
** Get Package Name
*/
for ( x3 = 0 ; x3 < x2 ; x3++ ) {
cPackageName[x3] = cString[x3] ;
}
cPackageName[x2] = '\0' ;
#ifdef DEBUG_OBJFILE
printf( "Package Name %s \n ",cPackageName ) ;
#endif
/* Get Class Name */
for ( x3 = x2+1 ; x3 <= ring_list_getstringsize(pList,1) - 1 ; x3++ ) {
cClassName[x3-x2-1] = cString[x3] ;
}
cClassName[ring_list_getstringsize(pList,1) - 1 - x2] = '\0' ;
#ifdef DEBUG_OBJFILE
printf( "Class Name %s \n ",cClassName ) ;
#endif
/* Get The Package List */
for ( x3 = 1 ; x3 <= ring_list_getsize(pRingState->pRingPackagesMap) ; x3++ ) {
pList2 = ring_list_getlist(pRingState->pRingPackagesMap,x3);
if ( strcmp(ring_list_getstring(pList2,1),cPackageName) == 0 ) {
/* Get The Class List */
pList2 = ring_list_getlist(pList2,2);
for ( x4 = 1 ; x4 <= ring_list_getsize(pList2) ; x4++ ) {
pList3 = ring_list_getlist(pList2,x4);
if ( strcmp(ring_list_getstring(pList3,1),cClassName) == 0 ) {
/* Now We have the Class - Update Pointer */
ring_list_setpointer_gc(pRingState,pList,2,(void *) pList3);
break ;
}
}
break ;
}
}
}
}
}
/* Update Package Pointers in Packages Classes */
for ( x = 1 ; x <= ring_list_getsize(pRingState->pRingPackagesMap) ; x++ ) {
pList = ring_list_getlist(pRingState->pRingPackagesMap,x);
/* Get The Class List */
pList2 = ring_list_getlist(pList,2);
for ( x2 = 1 ; x2 <= ring_list_getsize(pList2) ; x2++ ) {
pList3 = ring_list_getlist(pList2,x2);
ring_list_setpointer_gc(pRingState,pList3,RING_CLASSMAP_POINTERTOPACKAGE,pList);
}
}
}
void ring_objfile_xorstring ( char *cString,int nStringSize,char *cKey,int nKeySize )
{
int x ;
for ( x = 1 ; x <= nStringSize ; x++ ) {
cString[x-1] = cString[x-1] ^ cKey[(x-1)%nKeySize] ;
}
}
void ring_objfile_readc ( RingState *pRingState,char **cSource,char *cDest,int nCount )
{
int x ;
char *cData ;
cData = *cSource ;
for ( x = 0 ; x < nCount ; x++ ) {
cDest[x] = cData[x] ;
}
*cSource += nCount ;
cDest[nCount] = '\0' ;
}
char ring_objfile_getc ( RingState *pRingState,char **cSource )
{
char c ;
char *cData ;
cData = *cSource ;
c = cData[0] ;
*cSource+=1 ;
return c ;
}
void ring_objfile_writeCfile ( RingState *pRingState )
{
FILE *fCode;
char cCodeFileName[400] ;
int nSize ;
/*
** Write C file
** Set the file name
*/
sprintf( cCodeFileName , "%s" , ring_list_getstring(pRingState->pRingFilesList,1) ) ;
nSize = strlen( cCodeFileName ) ;
cCodeFileName[nSize-4] = 'c' ;
cCodeFileName[nSize-3] = '\0' ;
fCode = fopen(cCodeFileName , "w+b" );
/* write the main function */
fprintf( fCode , "#include \"ring.h\" \n\n" ) ;
fprintf( fCode , "void loadRingCode(RingState *pRingState) ;\n\n" ) ;
fprintf( fCode , "int main( int argc, char *argv[])\n" ) ;
fprintf( fCode , "{\n" ) ;
/* main function code */
fprintf( fCode , "\tRingState *pRingState; \n" ) ;
fprintf( fCode , "\tpRingState = ring_state_new(); \n" ) ;
fprintf( fCode , "\tpRingState->argc = argc; \n" ) ;
fprintf( fCode , "\tpRingState->argv = argv; \n" ) ;
fprintf( fCode , "\tpRingState->pRingFilesList = ring_list_new_gc(pRingState,0); \n" ) ;
fprintf( fCode , "\tpRingState->pRingFilesStack = ring_list_new_gc(pRingState,0); \n" ) ;
fprintf( fCode , "\tring_list_addstring_gc(pRingState,pRingState->pRingFilesList,\"%so\"); \n",ring_list_getstring(pRingState->pRingFilesList,1) ) ;
fprintf( fCode , "\tring_list_addstring_gc(pRingState,pRingState->pRingFilesStack,\"%so\"); \n",ring_list_getstring(pRingState->pRingFilesList,1) ) ;
fprintf( fCode , "\tloadRingCode(pRingState); \n" ) ;
fprintf( fCode , "\tring_objfile_updateclassespointers(pRingState); \n" ) ;
fprintf( fCode , "\tring_scanner_runprogram(pRingState); \n" ) ;
fprintf( fCode , "\tring_state_delete(pRingState); \n" ) ;
fprintf( fCode , "\treturn 0; \n" ) ;
fprintf( fCode , "}\n\n" ) ;
fprintf( fCode , "void loadRingCode(RingState *pRingState) {\n" ) ;
fprintf( fCode , "\tList *pList1,*pList2,*pList3,*pList4,*pList5,*pList6 ;\n" ) ;
/* Write Data */
ring_objfile_writelistcode(pRingState->pRingFunctionsMap,fCode,1);
fprintf( fCode , "\tpRingState->pRingFunctionsMap = pList1;\n" ) ;
ring_objfile_writelistcode(pRingState->pRingClassesMap,fCode,1);
fprintf( fCode , "\tpRingState->pRingClassesMap = pList1;\n" ) ;
ring_objfile_writelistcode(pRingState->pRingPackagesMap,fCode,1);
fprintf( fCode , "\tpRingState->pRingPackagesMap = pList1;\n" ) ;
ring_objfile_writelistcode(pRingState->pRingGenCode,fCode,1);
fprintf( fCode , "\tpRingState->pRingGenCode = pList1;\n" ) ;
fprintf( fCode , "}\n" ) ;
/* Close File */
fclose( fCode ) ;
}
void ring_objfile_writelistcode ( List *pList,FILE *fCode,int nList )
{
List *pList2 ;
int x,x2,x3,nMax ;
char cList[7] ;
char *cString ;
sprintf( cList , "pList%d" , nList+1 ) ;
if ( nList == 1 ) {
fprintf( fCode , "\tpList1 = ring_list_new_gc(pRingState,0) ; \n" ) ;
}
/* Write List Items */
for ( x = 1 ; x <= ring_list_getsize(pList) ; x++ ) {
pList2 = ring_list_getlist(pList,x);
fprintf( fCode , "\tpList%d = ring_list_newlist_gc(pRingState,pList%d);\n" , nList+1,nList ) ;
for ( x2 = 1 ; x2 <= ring_list_getsize(pList2) ; x2++ ) {
if ( ring_list_isstring(pList2,x2) ) {
fprintf( fCode , "\tring_list_addstring_gc(pRingState,%s,\"" , cList ) ;
/* Add the string */
cString = ring_list_getstring(pList2,x2) ;
nMax = ring_list_getstringsize(pList2,x2) ;
for ( x3 = 0 ; x3 < nMax ; x3++ ) {
fprintf( fCode , "\\x%02x" , (unsigned char) cString[x3] ) ;
}
fprintf( fCode , "\"); \n" ) ;
}
else if ( ring_list_isint(pList2,x2) ) {
fprintf( fCode , "\tring_list_addint_gc(pRingState,%s," , cList ) ;
fprintf( fCode , "%d" , ring_list_getint(pList2,x2) ) ;
fprintf( fCode , "); \n" ) ;
}
else if ( ring_list_isdouble(pList2,x2) ) {
fprintf( fCode , "\tring_list_adddouble_gc(pRingState,%s," , cList ) ;
fprintf( fCode , "%f" , ring_list_getdouble(pList2,x2) ) ;
fprintf( fCode , "); \n" ) ;
}
else if ( ring_list_ispointer(pList2,x2) ) {
fprintf( fCode , "\tring_list_addpointer_gc(pRingState,%s,NULL);\n" , cList ) ;
}
else if ( ring_list_islist(pList2,x2) ) {
fprintf( fCode , "\tpList%d = ring_list_newlist_gc(pRingState,pList%d);\n" , nList+2,nList+1 ) ;
ring_objfile_writelistcode(ring_list_getlist(pList2,x2) ,fCode,nList+2);
}
}
}
}
| [
"msfclipper@yahoo.com"
] | msfclipper@yahoo.com |
bf06890ab72e935eea215f63cb1e7531c43c9a01 | 20fd55cec00f7212e3361040907b2f0f5fc9f403 | /prbFuzzer/IE/fuzzIBSS.c | 598db58b28f3e70491528166a15767cab84fe8e5 | [] | no_license | b4rt-dev/cfuzz | a5144a4f6932624b4b71ba98d5fd0219e57a2955 | 243e52af0163b476e27f16453ddf3e3acfc42ec9 | refs/heads/master | 2020-12-27T18:14:48.986513 | 2020-01-09T10:17:17 | 2020-01-09T10:17:17 | 238,001,659 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,557 | c | /*
Fuzzes ibss Information element
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "../frameDefinitions.h"
//Indecates whether the ibssFuzzer is running
int ibssRunningState = 0;
//Number of fuzzing states
const int ibssStates = 4;
//Steps of fuzzers for each fuzzing state
const int ibssSteps[] = {1, 2, 16, 16};
//Current state and step of the ibssFuzzer
int fuzzState;
int fuzzStep;
void ibssPrintCurrentState()
{
switch (fuzzState)
{
case 0:
{
printf("\e[33mFuzzing ibss IE\e[39m\n");
printf("Trying 255*0xFF data\n");
break;
}
case 1:
{
printf("Fuzzing ATIM Window\n");
break;
}
case 2:
{
printf("Fuzzing lengths with 0xFF data\n");
break;
}
case 3:
{
printf("Fuzzing lengths with 0x00 data\n");
break;
}
case 4:
{
printf("\e[33mDone with fuzzing ibss\e[39m\n");
break;
}
}
}
//Updates ibssFuzzer
//Status 0 indicates start
//Status 1 indicates increaseStep
//Status 2 indicates stop
//Returns -1 if done with fuzzing
int ibssFuzzUpdate(int status)
{
switch (status)
{
case 0: //start fuzzer
{
ibssRunningState = 1;
fuzzState = 0;
fuzzStep = 0;
ibssPrintCurrentState();
break;
}
case 1: //update fuzzer
{
if (ibssRunningState == 1) //sanity check
{
//increase steps until all steps are done
if (fuzzStep < ibssSteps[fuzzState]-1)
fuzzStep = fuzzStep + 1;
//then increase state and notify
else
{
fuzzStep = 0;
fuzzState = fuzzState + 1;
ibssPrintCurrentState();
}
//when all states are done, stop
if (fuzzState == ibssStates)
{
ibssRunningState = 0;
return -1;
}
}
break;
}
case 2: //stop fuzzer
{
ibssRunningState = 0;
break;
}
}
return 0;
}
//Returns an ibss information element
infoElem ibssFuzz()
{
infoElem ibss;
//What to return when not fuzzed
if (ibssRunningState == 0)
{
ibss.id = 0;
ibss.len = 1;
ibss.len_data = -1;
ibss.data = "\xab";
}
else
{
switch (fuzzState) //update this
{
case 0: //255*0xff
{
ibss.id = 6;
ibss.len = 255;
ibss.len_data = 255;
//create data of 255 times 0xff
u_char *data = malloc(255);
memset(data, 0xff, 255);
ibss.data = data;
break;
}
case 1: //ibss null data
{
if (fuzzStep == 0)
{
ibss.id = 6;
ibss.len = 2;
ibss.len_data = 2;
ibss.data = "\x00\x00";
}
else
{
ibss.id = 6;
ibss.len = 2;
ibss.len_data = 2;
ibss.data = "\xFF\xFF";
}
break;
}
case 2: //length with 0xff data
{
if (fuzzStep < 8)
{
int dataSize = fuzzStep;
ibss.id = 6;
ibss.len = dataSize;
ibss.len_data = dataSize;
//create data of datasize times 0xff
u_char *data = malloc(dataSize);
memset(data, 0xff, dataSize);
ibss.data = data;
}
else
{
int dataSize = 255 - fuzzStep + 8;
ibss.id = 6;
ibss.len = dataSize;
ibss.len_data = dataSize;
//create data of datasize times 0xff
u_char *data = malloc(dataSize);
memset(data, 0xff, dataSize);
ibss.data = data;
}
break;
}
case 3: //length with 0x00 data
{
if (fuzzStep < 8)
{
int dataSize = fuzzStep;
ibss.id = 6;
ibss.len = dataSize;
ibss.len_data = dataSize;
//create data of datasize times 0x00
u_char *data = malloc(dataSize);
memset(data, 0x00, dataSize);
ibss.data = data;
}
else
{
int dataSize = 255 - fuzzStep + 8;
ibss.id = 6;
ibss.len = dataSize;
ibss.len_data = dataSize;
//create data of datasize times 0x00
u_char *data = malloc(dataSize);
memset(data, 0x00, dataSize);
ibss.data = data;
}
break;
}
}
}
return ibss;
} | [
"bart@b4rt.nl"
] | bart@b4rt.nl |
90f8eb9b01e2f1ae10b19bc7da3f6376194915ed | 2dde56a3931d52c48421bb4c002b6b49a569346f | /utils/rw_all.c | 295a0af2fd1d996b8f0d4f05ff7a94e088db87c6 | [] | no_license | Zhou-Zhuo/C-practice | d9fc682ae4e87bdb95dd77009d623ca98fa296d4 | 4c95efa330afbe8649c696f39af7601ae3a90f41 | refs/heads/master | 2020-09-03T00:49:01.071248 | 2017-07-29T09:47:03 | 2017-07-29T09:47:03 | 94,406,655 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,237 | c | #include "common.h"
#include "log.h"
int write_all(int fd, const void *buf, size_t size)
{
int left = size;
int total = 0;
int once = 0;
while (left > 0) {
once = write(fd, (char*)buf + total, left);
if (once < 0) {
if (errno == EINTR) {
continue;
} else if (errno == EAGAIN) {
usleep(1000 * 5);
continue;
} else {
loge("%s: %s\n", __func__, strerror(errno));
return once;
}
}
left -= once;
total += once;
}
return total;
}
int read_all(int fd, void *buf, size_t size)
{
int left = size;
int total = 0;
int once = 0;
while (left > 0) {
once = read(fd, (char*)buf + total, left);
if (once < 0) {
if (errno == EINTR) {
continue;
} else if (errno == EAGAIN) {
usleep(1000 * 5);
continue;
} else {
loge("%s: %s\n", __func__, strerror(errno));
return once;
}
}
if (once == 0)
break;
left -= once;
total += once;
}
return total;
}
| [
"zhouzhuo15@sina.com"
] | zhouzhuo15@sina.com |
6546a4c3de5bd8efa30bfd27686b11493cc5c210 | 68bf1ac641d75511dc4d3eb10dc1968ae3290b12 | /78a.c | 3d6283fb7fb34cedcdc6903d23563b0e77b8983c | [] | no_license | vignesh26946/iiicseb | cbcbf773809f55918758d791c5c64bed3c4e4c1b | 3af738f30bbb167b5de6f6f969507e4c4baf590b | refs/heads/master | 2021-05-10T08:43:11.605872 | 2018-03-20T10:55:11 | 2018-03-20T10:55:11 | 118,899,878 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 327 | c | import java.util.*;
import java.lang.*;
import java.util.ArrayList;
public class po{
public static void main(String aa[]){
int s;
Scanner s=new Scanner(System.in);
s=s.nextInt();
if(s%13==0){
System.out.println("Yes");
}
else{
System.out.println("No");
}
}
}
| [
"noreply@github.com"
] | vignesh26946.noreply@github.com |
471bc2e3310a586c8f32d693075010aa4c6afb52 | 321f7686587796bd6120e37d391c3f292b2ea5ac | /vidisha mam/insertArray.c | dff401e304e45cd55c783ff9e0fb0f6d4d456a61 | [] | no_license | vrushti22/First_project | 2fdf4bf54f50fd8574755674d2994b2ae85c66d6 | a82ea04962f305654aeb4cefbb372dd0b99fd9a0 | refs/heads/master | 2023-09-02T06:38:19.924445 | 2021-11-13T17:08:38 | 2021-11-13T17:08:38 | 427,723,835 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 662 | c | #include<stdio.h>>
int main()
{
int array[20], position, c, n, value;
printf("\n\nEnter number of elements in array:");
scanf("%d", &n);
printf("\n\nEnter %d elements\n", n);
for(c = 0; c < n; c++)
scanf("%d", &array[c]);
printf("\n\nEnter the location where you want to insert new element: ");
scanf("%d", &position);
printf("\n\nEnter the value to insert: ");
scanf("%d", &value);
for(c = n-1; c >= position-1; c--)
array[c+1] = array[c];
array[position - 1] = value;
printf("\n\nResultant array is: ");
for(c = 0; c <= n; c++)
printf("%d ", array[c]);
return 0;
}
| [
"vrushtishah.dme@gmail.com"
] | vrushtishah.dme@gmail.com |
6d149715a076e6e611e9c764bdb30bbbdae9ecff | 67d59ee080c3848768cccbf06d8fd41a65c17278 | /common.c | 4dde6074ecea409330cd555f0deb3aaab3e57ecb | [] | no_license | paboldin/poor-man-bts | 683315d88a7a3bafc3be5a5fa494a87482f702f8 | 019d8be32d7fff0fe16f54a4e12b6a77442ce353 | refs/heads/master | 2020-03-28T13:19:17.243215 | 2019-04-17T08:31:35 | 2019-04-17T08:31:35 | 148,383,279 | 0 | 2 | null | 2019-04-17T08:31:37 | 2018-09-11T21:36:07 | C | UTF-8 | C | false | false | 7,138 | c |
#ifndef __KERNEL__
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include "eflags.h"
#else /* ifndef __KERNEL__ */
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/gfp.h>
#endif /* else ifndef __KERNEL__ */
#include "common.h"
#ifdef __KERNEL__
#define strdup(x) kstrdup(x, GFP_KERNEL)
#endif
int
branch_op_check_condition(struct branch_op *branch,
unsigned long eflags,
unsigned long rcx)
{
#define FLAG(x) (eflags & X86_EFLAGS_ ## x)
switch (branch->opcode) {
case 0x77: /* ja or jnbe */
return !FLAG(CF) && !FLAG(ZF);
case 0x73: /* jae or jnc or jnb */
return !FLAG(CF);
case 0x72: /* jb or jc or jnae */
return FLAG(CF);
case 0x76: /* jbe or jna */
return FLAG(CF) || FLAG(ZF);
case 0x74: /* je or jz */
return FLAG(ZF);
case 0x7f: /* jg or jnle */
return !FLAG(ZF) && FLAG(SF) == FLAG(OF);
case 0x7d: /* jge or jnl */
return FLAG(SF) == FLAG(OF);
case 0x7c: /* jl or jnge */
return FLAG(SF) != FLAG(OF);
case 0x7e: /* jle or jng */
return FLAG(ZF) || FLAG(SF) != FLAG(OF);
case 0x75: /* jne or jnz */
return !FLAG(ZF);
case 0x71: /* jno */
return !FLAG(OF);
case 0xe3: /* jcxz/jecxz/jrcxz */
return !!rcx;
case 0x7b: /* jnp or jpo */
return !FLAG(PF);
case 0x79: /* jns */
return !FLAG(SF);
case 0x7a: /* jp or jpe */
return FLAG(PF);
case 0x78: /* js */
return FLAG(SF);
case 0x70: /* jo */
return FLAG(OF);
case 0xe9:
case 0xeb:
case JUMP_OP_OPCODE_DYNAMIC:
/* unconditional jumps */
return 1;
default:
return -EINVAL;
}
}
long
branch_op_resolve_to(struct branch_op *branch,
long (*read_reg)(int reg, void *arg),
long (*read_mem)(long mem, void *arg),
void *arg)
{
int is_ref = branch->dynamic_reg & JUMP_OP_DYNAMIC_REG_REF;
int is_sib = branch->dynamic_sib_mult;
int reg = branch->dynamic_reg & ~JUMP_OP_DYNAMIC_REG_REF;
if (branch->opcode != JUMP_OP_OPCODE_DYNAMIC) {
return branch->to;
}
if (!is_ref)
return read_reg(reg, arg);
if (!is_sib) {
long off = 0;
if (reg != REG_NONE)
off = read_reg(reg, arg);
off += (long)branch->dynamic_disp32;
return read_mem(off, arg);
} else {
long base = 0, index = 0, off = (long)branch->dynamic_disp32;
if (reg != REG_NONE)
base = read_reg(reg, arg);
if (branch->dynamic_sib_reg != REG_NONE)
index = read_reg(branch->dynamic_sib_reg, arg);
off += base + index * branch->dynamic_sib_mult;
return read_mem(off, arg);
}
#ifndef __KERNEL__
errno = -EINVAL;
#endif
return -1;
}
/* returns -1 on error, 1 when branch op is found, 0 otherwise.
* updates pbuf accordingly, may be used to got through functions */
int branch_op_decode(struct branch_op *branch, const char **pbuf, size_t size)
{
struct insn insn;
unsigned char op1, op2, rex = 0, rex_b = 0, rex_r = 0, rex_w = 0,
rex_x = 0, modrm = 0, modrm_mod = 0, modrm_rm = 0,
modrm_reg = 0, sib = 0;
/* Parsed already! */
if (branch->opcode != 0)
return 1;
insn_init(&insn, *pbuf, size, /* always x86_64 */1);
insn_get_length(&insn);
if (!insn_complete(&insn))
return -1;
(*pbuf) += insn.length;
op1 = insn.opcode.bytes[0];
op2 = insn.opcode.bytes[1];
if (insn.rex_prefix.nbytes) {
rex = insn.rex_prefix.bytes[0];
rex_w = X86_REX_W(rex) >> 3;
rex_r = X86_REX_R(rex) >> 2;
rex_x = X86_REX_X(rex) >> 1;
rex_b = X86_REX_B(rex);
}
if (insn.modrm.nbytes) {
modrm = insn.modrm.bytes[0];
modrm_mod = X86_MODRM_MOD(modrm);
modrm_reg = X86_MODRM_REG(modrm);
modrm_rm = X86_MODRM_RM(modrm);
}
if (insn.sib.nbytes)
sib = insn.sib.bytes[0];
/* defaults */
branch->to = branch->from + insn.length + insn.immediate.value;
branch->opcode = op1;
branch->len = insn.length;
switch (op1) {
case 0xe8: /* call */
branch->type = INSN_CALL;
break;
case 0xe9: /* dumb jumps */
case 0xeb:
branch->type = INSN_JUMP_UNCONDITIONAL;
break;
case 0xe3: /* ecx jumps */
case 0x70 ... 0x7f: /* cond jumps */
branch->type = INSN_JUMP_CONDITIONAL;
break;
case 0x0f:
if (op2 >= 0x80 && op2 <= 0x8f) {
branch->type = INSN_JUMP_CONDITIONAL;
branch->opcode = op2 - 0x10;
break;
}
return 0;
case 0xff:
if (modrm_reg == 2 || modrm_reg == 3) {
branch->type = INSN_CALL_DYNAMIC;
goto dynamic_regs;
} else if (modrm_reg == 4) {
branch->type = INSN_JUMP_DYNAMIC;
goto dynamic_regs;
}
/* fallthrough */
default:
branch->opcode = 0;
return 0;
}
return 1;
dynamic_regs:
branch->to = 0;
branch->dynamic_reg = modrm_rm + (rex_b << 3);
/* SDM Vol. 2, Table 2-2 */
if (modrm_mod != 0x3) {
/* RIP-relative addressing, Table 2-7 */
if (modrm_mod == 0 && modrm_rm == 0x5) {
branch->dynamic_reg = REG_RIP;
}
/* SIB byte, Table 2-3 */
else if (modrm_rm == 0x4) {
branch->dynamic_reg = X86_SIB_BASE(sib) + (rex_b << 3);
if (branch->dynamic_reg == 0x5 && modrm_mod == 0)
branch->dynamic_reg = REG_NONE;
branch->dynamic_sib_reg = X86_SIB_INDEX(sib) + (rex_x << 3);
if (branch->dynamic_sib_reg == 0x4)
branch->dynamic_sib_reg = REG_NONE;
branch->dynamic_sib_mult = 1 << X86_SIB_SCALE(sib);
}
branch->dynamic_reg |= JUMP_OP_DYNAMIC_REG_REF;
}
branch->dynamic_disp32 = insn.displacement.value;
return 1;
}
#ifndef __KERNEL__
/* TODO(pboldin) these are not so common, move them */
static int branch_op_parse(struct branch_op *branch,
const char *in)
{
int ret;
memset(branch, 0, sizeof(*branch));
ret = sscanf(in, "0x%lx+0x%x", &branch->from, &branch->len);
if (ret != 2)
return -1;
return 0;
}
int parse_trace_point_line(const char *buf,
struct pmb_tracepoint *point)
{
char *p;
const char objname_str[] = "objname=";
const size_t objname_str_len = sizeof(objname_str) - 1;
static char *objname;
int ret;
p = strstr(buf, objname_str);
if (p) {
p += objname_str_len;
objname = strdup(p);
}
p = strchr(buf, '#');
if (p == buf)
return 0;
if (p)
*p = '\0';
ret = branch_op_parse(&point->branch, buf);
if (ret < 0) {
return -1;
}
point->objname = objname;
return 1;
}
int branch_op_read_input_file(const char *filename,
struct pmb_tracepoint **points,
size_t *npoints)
{
FILE *fh;
char buf[1024], *p;
struct pmb_tracepoint *t = NULL, tmp;
size_t n = 0, nalloc = 0;
int ret = -1;
tmp.objname = NULL;
*points = NULL;
*npoints = 0;
if (!strcmp(filename, "-"))
fh = stdin;
else
fh = fopen(filename, "r");
if (fh == NULL) {
perror("fopen");
return -1;
}
while (!feof(fh)) {
if (fgets(buf, sizeof(buf), fh) == NULL) {
if (errno == 0)
break;
goto out_err;
}
buf[strlen(buf) - 1] = '\0';
ret = parse_trace_point_line(buf, &tmp);
if (ret < 0)
goto out_err;
if (ret == 0)
continue;
if (n + 1 > nalloc) {
struct pmb_tracepoint *newt;
nalloc += 1024;
newt = realloc(t, sizeof(*t) * nalloc);
if (newt == NULL) {
ret = -1;
goto out_err;
}
t = newt;
}
t[n] = tmp;
n++;
}
*points = t;
*npoints = n;
ret = 0;
out_err:
if (ret < 0)
free(t);
if (fh != stdin)
fclose(fh);
return ret;
}
#endif /* ifndef __KERNEL__ */
| [
"boldin.pavel@gmail.com"
] | boldin.pavel@gmail.com |
1b5e2255b6461c4f8d247bb6e5c10d097cadcbb6 | c9b1d9481663f35a745533e215e512c31f00f945 | /libraries/c_sdk/standard/ble/include/iot_ble_mqtt_transport.h | 4d79123aa7a1bf31c87617e1fa86ce094de247fa | [
"Apache-2.0",
"MIT"
] | permissive | ambiot/amazon-freertos | 199d8c8cfebf7d4ce41cdf0377a6622c56ea3f7c | ef61d5f521de921cc931d9262e3d5af9b75fbd2e | refs/heads/master | 2023-08-24T08:06:28.437220 | 2021-07-08T13:33:49 | 2021-07-08T13:33:49 | 191,755,880 | 14 | 16 | MIT | 2022-09-20T23:47:06 | 2019-06-13T12:09:22 | C | UTF-8 | C | false | false | 3,750 | h | /*
* FreeRTOS BLE V2.2.0
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef IOT_BLE_MQTT_TRANSPORT_H
#define IOT_BLE_MQTT_TRANSPORT_H
/* Standard includes. */
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "FreeRTOS.h"
#include "stream_buffer.h"
#include "iot_ble_mqtt_transport_config.h"
#include "iot_ble_mqtt_serialize.h"
#include "iot_ble_data_transfer.h"
typedef struct NetworkContext
{
IotBleDataTransferChannel_t * pChannel;
StreamBufferHandle_t xStreamBuffer;
StaticStreamBuffer_t xStreamBufferStruct;
MQTTBLEPublishInfo_t publishInfo;
} NetworkContext_t;
/**
* @brief Initiailzes the Circular buffer to store the received data
*
* @param[in] pBuffer Pointer to the buffer allocated by the application and used by the transport interface to
* stream MQTT data.
* @param[in] bufSize The size of the buffer allocated.
* @param[out] pContext An opaque used by transport interface and to be passed to the MQTT library.
* @return status of the initialization.
*/
bool IotBleMqttTransportInit( void * pBuffer,
size_t bufSize,
NetworkContext_t * pContext );
/**
* @brief Cleans up the Circular buffer.
*
* @param[in] pContext An opaque used by transport interface.
*/
void IotBleMqttTransportCleanup( const NetworkContext_t * pContext );
/**
* @brief Function to accept data from the channel
*
* @param[in] pContext An opaque used by transport interface.
* @return the status of the accept
*/
MQTTBLEStatus_t IotBleMqttTransportAcceptData( const NetworkContext_t * pContext );
/**
* @brief Transport interface write function.
*
* @param[in] pContext An opaque used by transport interface.
* @param[in] pBuffer A pointer to a buffer containing data to be sent out.
* @param[in] bytesToWrite number of bytes to write from the buffer.
* @return the number of bytes sent.
*/
int32_t IotBleMqttTransportSend( NetworkContext_t * pContext,
const void * pBuffer,
size_t bytesToWrite );
/**
* @brief Transport interface read function.
*
* @param[in] pContext An opaque used by transport interface.
* @param[in] pBuffer A pointer to a buffer where incoming data will be stored.
* @param[in] bytesToRead number of bytes to read from the transport layer.
* @return the number of bytes successfully read.
*/
int32_t IotBleMqttTransportReceive( NetworkContext_t * pContext,
void * pBuffer,
size_t bytesToRead );
#endif /* ifndef IOT_BLE_MQTT_TRANSPORT_H */
| [
"hungtselee@realtek.com"
] | hungtselee@realtek.com |
8321f4ff911e4048f682f8fdb949e7d0710972b2 | 542d94b905b4c2c4d5891a64afae1b73e86bcb49 | /src/check_tetri.c | 67756a7eba6bb83f443b12a173c221df9bb674fb | [] | no_license | Rodace/testfill | 4a8ce50b4445768aff631be297e3b9314a3026ee | bafcbd56ec2fcc4a7dea52b9697519da175ac686 | refs/heads/master | 2021-01-20T07:48:28.656490 | 2017-05-09T14:19:36 | 2017-05-09T14:19:36 | 90,047,595 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,390 | c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check_tetri.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nadam <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/04/28 10:11:10 by nadam #+# #+# */
/* Updated: 2017/04/28 11:49:35 by nadam ### ########.fr */
/* */
/* ************************************************************************** */
#include "fill.h"
int check_tetri(char *str, int i)
{
return (check_i1(str, i) ||
check_i2(str, i) ||
check_s1(str, i) ||
check_s2(str, i) ||
check_z1(str, i) ||
check_z2(str, i) ||
check_o(str, i) ||
check_l1(str, i) ||
check_l2(str, i) ||
check_l3(str, i) ||
check_l4(str, i) ||
check_j1(str, i) ||
check_j2(str, i) ||
check_j3(str, i) ||
check_j4(str, i) ||
check_t1(str, i) ||
check_t2(str, i) ||
check_t3(str, i) ||
check_t4(str, i));
}
| [
"noreply@github.com"
] | Rodace.noreply@github.com |
90382c41650fb7bf61e12273d1ccc46d7e7cd0c9 | 57091f6b809027a73ab49ecf4931153c93701d6a | /linux/b0d2dcd072cb7b96ea82f65109a94be4f7e3697e.c | f99db0113d3467bd449b1b3ff2f8ee74334a02ed | [
"Apache-2.0"
] | permissive | dvyukov/syzkaller-repros | 660997cfa055d79a552bb9ebeda90b48e1599df3 | 026c8891a19e672bba71481be250080e1a302ed8 | refs/heads/master | 2022-06-01T18:03:25.480964 | 2022-05-16T07:36:42 | 2022-05-16T07:39:01 | 213,603,012 | 39 | 11 | Apache-2.0 | 2022-05-16T07:39:02 | 2019-10-08T09:36:27 | C | UTF-8 | C | false | false | 46,211 | c | // KASAN: stack-out-of-bounds in do_raw_spin_lock
// https://syzkaller.appspot.com/bug?id=b0d2dcd072cb7b96ea82f65109a94be4f7e3697e
// status:fixed
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/futex.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/veth.h>
unsigned long long procid;
static __thread int skip_segv;
static __thread jmp_buf segv_env;
static void segv_handler(int sig, siginfo_t* info, void* ctx)
{
uintptr_t addr = (uintptr_t)info->si_addr;
const uintptr_t prog_start = 1 << 20;
const uintptr_t prog_end = 100 << 20;
if (__atomic_load_n(&skip_segv, __ATOMIC_RELAXED) &&
(addr < prog_start || addr > prog_end)) {
_longjmp(segv_env, 1);
}
exit(sig);
}
static void install_segv_handler(void)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = segv_handler;
sa.sa_flags = SA_NODEFER | SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGBUS, &sa, NULL);
}
#define NONFAILING(...) \
{ \
__atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST); \
if (_setjmp(segv_env) == 0) { \
__VA_ARGS__; \
} \
__atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST); \
}
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static void use_temporary_dir(void)
{
char tmpdir_template[] = "./syzkaller.XXXXXX";
char* tmpdir = mkdtemp(tmpdir_template);
if (!tmpdir)
exit(1);
if (chmod(tmpdir, 0777))
exit(1);
if (chdir(tmpdir))
exit(1);
}
static void thread_start(void* (*fn)(void*), void* arg)
{
pthread_t th;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, 128 << 10);
if (pthread_create(&th, &attr, fn, arg))
exit(1);
pthread_attr_destroy(&attr);
}
#define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off))
#define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len) \
*(type*)(addr) = \
htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) | \
(((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len))))
typedef struct {
int state;
} event_t;
static void event_init(event_t* ev)
{
ev->state = 0;
}
static void event_reset(event_t* ev)
{
ev->state = 0;
}
static void event_set(event_t* ev)
{
if (ev->state)
exit(1);
__atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE);
syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG);
}
static void event_wait(event_t* ev)
{
while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0);
}
static int event_isset(event_t* ev)
{
return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE);
}
static int event_timedwait(event_t* ev, uint64_t timeout)
{
uint64_t start = current_time_ms();
uint64_t now = start;
for (;;) {
uint64_t remain = timeout - (now - start);
struct timespec ts;
ts.tv_sec = remain / 1000;
ts.tv_nsec = (remain % 1000) * 1000 * 1000;
syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts);
if (__atomic_load_n(&ev->state, __ATOMIC_RELAXED))
return 1;
now = current_time_ms();
if (now - start > timeout)
return 0;
}
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static struct {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
} nlmsg;
static void netlink_init(int typ, int flags, const void* data, int size)
{
memset(&nlmsg, 0, sizeof(nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg.pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(int typ, const void* data, int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg.pos += NLMSG_ALIGN(attr->nla_len);
}
static void netlink_nest(int typ)
{
struct nlattr* attr = (struct nlattr*)nlmsg.pos;
attr->nla_type = typ;
nlmsg.pos += sizeof(*attr);
nlmsg.nested[nlmsg.nesting++] = attr;
}
static void netlink_done(void)
{
struct nlattr* attr = nlmsg.nested[--nlmsg.nesting];
attr->nla_len = nlmsg.pos - (char*)attr;
}
static int netlink_send(int sock)
{
if (nlmsg.pos > nlmsg.buf + sizeof(nlmsg.buf) || nlmsg.nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg.buf;
hdr->nlmsg_len = nlmsg.pos - nlmsg.buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg.buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg.buf, sizeof(nlmsg.buf), 0);
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static void netlink_add_device_impl(const char* type, const char* name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
netlink_init(RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
if (name)
netlink_attr(IFLA_IFNAME, name, strlen(name));
netlink_nest(IFLA_LINKINFO);
netlink_attr(IFLA_INFO_KIND, type, strlen(type));
}
static void netlink_add_device(int sock, const char* type, const char* name)
{
netlink_add_device_impl(type, name);
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_veth(int sock, const char* name, const char* peer)
{
netlink_add_device_impl("veth", name);
netlink_nest(IFLA_INFO_DATA);
netlink_nest(VETH_INFO_PEER);
nlmsg.pos += sizeof(struct ifinfomsg);
netlink_attr(IFLA_IFNAME, peer, strlen(peer));
netlink_done();
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_add_hsr(int sock, const char* name, const char* slave1,
const char* slave2)
{
netlink_add_device_impl("hsr", name);
netlink_nest(IFLA_INFO_DATA);
int ifindex1 = if_nametoindex(slave1);
netlink_attr(IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
int ifindex2 = if_nametoindex(slave2);
netlink_attr(IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
netlink_done();
netlink_done();
int err = netlink_send(sock);
(void)err;
}
static void netlink_device_change(int sock, const char* name, bool up,
const char* master, const void* mac,
int macsize)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
netlink_init(RTM_NEWLINK, 0, &hdr, sizeof(hdr));
netlink_attr(IFLA_IFNAME, name, strlen(name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(IFLA_ADDRESS, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int netlink_add_addr(int sock, const char* dev, const void* addr,
int addrsize)
{
struct ifaddrmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
hdr.ifa_scope = RT_SCOPE_UNIVERSE;
hdr.ifa_index = if_nametoindex(dev);
netlink_init(RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr, sizeof(hdr));
netlink_attr(IFA_LOCAL, addr, addrsize);
netlink_attr(IFA_ADDRESS, addr, addrsize);
return netlink_send(sock);
}
static void netlink_add_addr4(int sock, const char* dev, const char* addr)
{
struct in_addr in_addr;
inet_pton(AF_INET, addr, &in_addr);
int err = netlink_add_addr(sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(int sock, const char* dev, const char* addr)
{
struct in6_addr in6_addr;
inet_pton(AF_INET6, addr, &in6_addr);
int err = netlink_add_addr(sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(int sock, const char* name, const void* addr,
int addrsize, const void* mac, int macsize)
{
struct ndmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ndm_ifindex = if_nametoindex(name);
hdr.ndm_state = NUD_PERMANENT;
netlink_init(RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr));
netlink_attr(NDA_DST, addr, addrsize);
netlink_attr(NDA_LLADDR, mac, macsize);
int err = netlink_send(sock);
(void)err;
}
static int tunfd = -1;
static int tun_frags_enabled;
#define SYZ_TUN_MAX_PACKET_SIZE 1000
#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"
#define IFF_NAPI 0x0010
#define IFF_NAPI_FRAGS 0x0020
static void initialize_tun(void)
{
tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (tunfd == -1) {
printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
printf("otherwise fuzzing or reproducing might not work as intended\n");
return;
}
const int kTunFd = 240;
if (dup2(tunfd, kTunFd) < 0)
exit(1);
close(tunfd);
tunfd = kTunFd;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
ifr.ifr_flags = IFF_TAP | IFF_NO_PI | IFF_NAPI | IFF_NAPI_FRAGS;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0)
exit(1);
}
if (ioctl(tunfd, TUNGETIFF, (void*)&ifr) < 0)
exit(1);
tun_frags_enabled = (ifr.ifr_flags & IFF_NAPI_FRAGS) != 0;
char sysctl[64];
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
write_file(sysctl, "0");
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
write_file(sysctl, "0");
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
netlink_add_addr4(sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(sock, TUN_IFACE, LOCAL_IPV6);
uint64_t macaddr = REMOTE_MAC;
struct in_addr in_addr;
inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
netlink_add_neigh(sock, TUN_IFACE, &in_addr, sizeof(in_addr), &macaddr,
ETH_ALEN);
struct in6_addr in6_addr;
inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
netlink_add_neigh(sock, TUN_IFACE, &in6_addr, sizeof(in6_addr), &macaddr,
ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN);
close(sock);
}
#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02hx"
#define DEV_MAC 0x00aaaaaaaaaa
static void initialize_netdevices(void)
{
char netdevsim[16];
sprintf(netdevsim, "netdevsim%d", (int)procid);
struct {
const char* type;
const char* dev;
} devtypes[] = {
{"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"},
{"vcan", "vcan0"}, {"bond", "bond0"},
{"team", "team0"}, {"dummy", "dummy0"},
{"nlmon", "nlmon0"}, {"caif", "caif0"},
{"batadv", "batadv0"}, {"vxcan", "vxcan1"},
{"netdevsim", netdevsim}, {"veth", 0},
};
const char* devmasters[] = {"bridge", "bond", "team"};
struct {
const char* name;
int macsize;
bool noipv6;
} devices[] = {
{"lo", ETH_ALEN},
{"sit0", 0},
{"bridge0", ETH_ALEN},
{"vcan0", 0, true},
{"tunl0", 0},
{"gre0", 0},
{"gretap0", ETH_ALEN},
{"ip_vti0", 0},
{"ip6_vti0", 0},
{"ip6tnl0", 0},
{"ip6gre0", 0},
{"ip6gretap0", ETH_ALEN},
{"erspan0", ETH_ALEN},
{"bond0", ETH_ALEN},
{"veth0", ETH_ALEN},
{"veth1", ETH_ALEN},
{"team0", ETH_ALEN},
{"veth0_to_bridge", ETH_ALEN},
{"veth1_to_bridge", ETH_ALEN},
{"veth0_to_bond", ETH_ALEN},
{"veth1_to_bond", ETH_ALEN},
{"veth0_to_team", ETH_ALEN},
{"veth1_to_team", ETH_ALEN},
{"veth0_to_hsr", ETH_ALEN},
{"veth1_to_hsr", ETH_ALEN},
{"hsr0", 0},
{"dummy0", ETH_ALEN},
{"nlmon0", 0},
{"vxcan1", 0, true},
{"caif0", ETH_ALEN},
{"batadv0", ETH_ALEN},
{netdevsim, ETH_ALEN},
};
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++)
netlink_add_device(sock, devtypes[i].type, devtypes[i].dev);
for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) {
char master[32], slave0[32], veth0[32], slave1[32], veth1[32];
sprintf(slave0, "%s_slave_0", devmasters[i]);
sprintf(veth0, "veth0_to_%s", devmasters[i]);
netlink_add_veth(sock, slave0, veth0);
sprintf(slave1, "%s_slave_1", devmasters[i]);
sprintf(veth1, "veth1_to_%s", devmasters[i]);
netlink_add_veth(sock, slave1, veth1);
sprintf(master, "%s0", devmasters[i]);
netlink_device_change(sock, slave0, false, master, 0, 0);
netlink_device_change(sock, slave1, false, master, 0, 0);
}
netlink_device_change(sock, "bridge_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "bridge_slave_1", true, 0, 0, 0);
netlink_add_veth(sock, "hsr_slave_0", "veth0_to_hsr");
netlink_add_veth(sock, "hsr_slave_1", "veth1_to_hsr");
netlink_add_hsr(sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
netlink_device_change(sock, "hsr_slave_0", true, 0, 0, 0);
netlink_device_change(sock, "hsr_slave_1", true, 0, 0, 0);
for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
char addr[32];
sprintf(addr, DEV_IPV4, i + 10);
netlink_add_addr4(sock, devices[i].name, addr);
if (!devices[i].noipv6) {
sprintf(addr, DEV_IPV6, i + 10);
netlink_add_addr6(sock, devices[i].name, addr);
}
uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
netlink_device_change(sock, devices[i].name, true, 0, &macaddr,
devices[i].macsize);
}
close(sock);
}
static void initialize_netdevices_init(void)
{
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
struct {
const char* type;
int macsize;
bool noipv6;
bool noup;
} devtypes[] = {
{"nr", 7, true}, {"rose", 5, true, true},
};
unsigned i;
for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) {
char dev[32], addr[32];
sprintf(dev, "%s%d", devtypes[i].type, (int)procid);
sprintf(addr, "172.30.%d.%d", i, (int)procid + 1);
netlink_add_addr4(sock, dev, addr);
if (!devtypes[i].noipv6) {
sprintf(addr, "fe88::%02hx:%02hx", i, (int)procid + 1);
netlink_add_addr6(sock, dev, addr);
}
int macsize = devtypes[i].macsize;
uint64_t macaddr = 0xbbbbbb +
((unsigned long long)i << (8 * (macsize - 2))) +
(procid << (8 * (macsize - 1)));
netlink_device_change(sock, dev, !devtypes[i].noup, 0, &macaddr, macsize);
}
close(sock);
}
static int read_tun(char* data, int size)
{
if (tunfd < 0)
return -1;
int rv = read(tunfd, data, size);
if (rv < 0) {
if (errno == EAGAIN)
return -1;
if (errno == EBADFD)
return -1;
exit(1);
}
return rv;
}
static void flush_tun()
{
char data[SYZ_TUN_MAX_PACKET_SIZE];
while (read_tun(&data[0], sizeof(data)) != -1) {
}
}
#define XT_TABLE_SIZE 1536
#define XT_MAX_ENTRIES 10
struct xt_counters {
uint64_t pcnt, bcnt;
};
struct ipt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_entries;
unsigned int size;
};
struct ipt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct ipt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[5];
unsigned int underflow[5];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct ipt_table_desc {
const char* name;
struct ipt_getinfo info;
struct ipt_replace replace;
};
static struct ipt_table_desc ipv4_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
static struct ipt_table_desc ipv6_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "mangle"},
{.name = "raw"}, {.name = "security"},
};
#define IPT_BASE_CTL 64
#define IPT_SO_SET_REPLACE (IPT_BASE_CTL)
#define IPT_SO_GET_INFO (IPT_BASE_CTL)
#define IPT_SO_GET_ENTRIES (IPT_BASE_CTL + 1)
struct arpt_getinfo {
char name[32];
unsigned int valid_hooks;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_entries;
unsigned int size;
};
struct arpt_get_entries {
char name[32];
unsigned int size;
void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};
struct arpt_replace {
char name[32];
unsigned int valid_hooks;
unsigned int num_entries;
unsigned int size;
unsigned int hook_entry[3];
unsigned int underflow[3];
unsigned int num_counters;
struct xt_counters* counters;
char entrytable[XT_TABLE_SIZE];
};
struct arpt_table_desc {
const char* name;
struct arpt_getinfo info;
struct arpt_replace replace;
};
static struct arpt_table_desc arpt_tables[] = {
{.name = "filter"},
};
#define ARPT_BASE_CTL 96
#define ARPT_SO_SET_REPLACE (ARPT_BASE_CTL)
#define ARPT_SO_GET_INFO (ARPT_BASE_CTL)
#define ARPT_SO_GET_ENTRIES (ARPT_BASE_CTL + 1)
static void checkpoint_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct ipt_get_entries entries;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_iptables(struct ipt_table_desc* tables, int num_tables,
int family, int level)
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct ipt_get_entries entries;
struct ipt_getinfo info;
socklen_t optlen;
int fd, i;
fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < num_tables; i++) {
struct ipt_table_desc* table = &tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, level, IPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_arptables(void)
{
struct arpt_get_entries entries;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
strcpy(table->info.name, table->name);
strcpy(table->replace.name, table->name);
optlen = sizeof(table->info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &table->info, &optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->info.size > sizeof(table->replace.entrytable))
exit(1);
if (table->info.num_entries > XT_MAX_ENTRIES)
exit(1);
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
table->replace.valid_hooks = table->info.valid_hooks;
table->replace.num_entries = table->info.num_entries;
table->replace.size = table->info.size;
memcpy(table->replace.hook_entry, table->info.hook_entry,
sizeof(table->replace.hook_entry));
memcpy(table->replace.underflow, table->info.underflow,
sizeof(table->replace.underflow));
memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
}
close(fd);
}
static void reset_arptables()
{
struct xt_counters counters[XT_MAX_ENTRIES];
struct arpt_get_entries entries;
struct arpt_getinfo info;
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
struct arpt_table_desc* table = &arpt_tables[i];
if (table->info.valid_hooks == 0)
continue;
memset(&info, 0, sizeof(info));
strcpy(info.name, table->name);
optlen = sizeof(info);
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
exit(1);
if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
memset(&entries, 0, sizeof(entries));
strcpy(entries.name, table->name);
entries.size = table->info.size;
optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
exit(1);
if (memcmp(table->replace.entrytable, entries.entrytable,
table->info.size) == 0)
continue;
} else {
}
table->replace.num_counters = info.num_entries;
table->replace.counters = counters;
optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
table->replace.size;
if (setsockopt(fd, SOL_IP, ARPT_SO_SET_REPLACE, &table->replace, optlen))
exit(1);
}
close(fd);
}
#define NF_BR_NUMHOOKS 6
#define EBT_TABLE_MAXNAMELEN 32
#define EBT_CHAIN_MAXNAMELEN 32
#define EBT_BASE_CTL 128
#define EBT_SO_SET_ENTRIES (EBT_BASE_CTL)
#define EBT_SO_GET_INFO (EBT_BASE_CTL)
#define EBT_SO_GET_ENTRIES (EBT_SO_GET_INFO + 1)
#define EBT_SO_GET_INIT_INFO (EBT_SO_GET_ENTRIES + 1)
#define EBT_SO_GET_INIT_ENTRIES (EBT_SO_GET_INIT_INFO + 1)
struct ebt_replace {
char name[EBT_TABLE_MAXNAMELEN];
unsigned int valid_hooks;
unsigned int nentries;
unsigned int entries_size;
struct ebt_entries* hook_entry[NF_BR_NUMHOOKS];
unsigned int num_counters;
struct ebt_counter* counters;
char* entries;
};
struct ebt_entries {
unsigned int distinguisher;
char name[EBT_CHAIN_MAXNAMELEN];
unsigned int counter_offset;
int policy;
unsigned int nentries;
char data[0] __attribute__((aligned(__alignof__(struct ebt_replace))));
};
struct ebt_table_desc {
const char* name;
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
};
static struct ebt_table_desc ebt_tables[] = {
{.name = "filter"}, {.name = "nat"}, {.name = "broute"},
};
static void checkpoint_ebtables(void)
{
socklen_t optlen;
unsigned i;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
strcpy(table->replace.name, table->name);
optlen = sizeof(table->replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_INFO, &table->replace,
&optlen)) {
switch (errno) {
case EPERM:
case ENOENT:
case ENOPROTOOPT:
continue;
}
exit(1);
}
if (table->replace.entries_size > sizeof(table->entrytable))
exit(1);
table->replace.num_counters = 0;
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_ENTRIES, &table->replace,
&optlen))
exit(1);
}
close(fd);
}
static void reset_ebtables()
{
struct ebt_replace replace;
char entrytable[XT_TABLE_SIZE];
socklen_t optlen;
unsigned i, j, h;
int fd;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1) {
switch (errno) {
case EAFNOSUPPORT:
case ENOPROTOOPT:
return;
}
exit(1);
}
for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
struct ebt_table_desc* table = &ebt_tables[i];
if (table->replace.valid_hooks == 0)
continue;
memset(&replace, 0, sizeof(replace));
strcpy(replace.name, table->name);
optlen = sizeof(replace);
if (getsockopt(fd, SOL_IP, EBT_SO_GET_INFO, &replace, &optlen))
exit(1);
replace.num_counters = 0;
table->replace.entries = 0;
for (h = 0; h < NF_BR_NUMHOOKS; h++)
table->replace.hook_entry[h] = 0;
if (memcmp(&table->replace, &replace, sizeof(table->replace)) == 0) {
memset(&entrytable, 0, sizeof(entrytable));
replace.entries = entrytable;
optlen = sizeof(replace) + replace.entries_size;
if (getsockopt(fd, SOL_IP, EBT_SO_GET_ENTRIES, &replace, &optlen))
exit(1);
if (memcmp(table->entrytable, entrytable, replace.entries_size) == 0)
continue;
}
for (j = 0, h = 0; h < NF_BR_NUMHOOKS; h++) {
if (table->replace.valid_hooks & (1 << h)) {
table->replace.hook_entry[h] =
(struct ebt_entries*)table->entrytable + j;
j++;
}
}
table->replace.entries = table->entrytable;
optlen = sizeof(table->replace) + table->replace.entries_size;
if (setsockopt(fd, SOL_IP, EBT_SO_SET_ENTRIES, &table->replace, optlen))
exit(1);
}
close(fd);
}
static void checkpoint_net_namespace(void)
{
checkpoint_ebtables();
checkpoint_arptables();
checkpoint_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
checkpoint_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void reset_net_namespace(void)
{
reset_ebtables();
reset_arptables();
reset_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
AF_INET, SOL_IP);
reset_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
AF_INET6, SOL_IPV6);
}
static void setup_cgroups()
{
if (mkdir("/syzcgroup", 0777)) {
}
if (mkdir("/syzcgroup/unified", 0777)) {
}
if (mount("none", "/syzcgroup/unified", "cgroup2", 0, NULL)) {
}
if (chmod("/syzcgroup/unified", 0777)) {
}
write_file("/syzcgroup/unified/cgroup.subtree_control",
"+cpu +memory +io +pids +rdma");
if (mkdir("/syzcgroup/cpu", 0777)) {
}
if (mount("none", "/syzcgroup/cpu", "cgroup", 0,
"cpuset,cpuacct,perf_event,hugetlb")) {
}
write_file("/syzcgroup/cpu/cgroup.clone_children", "1");
if (chmod("/syzcgroup/cpu", 0777)) {
}
if (mkdir("/syzcgroup/net", 0777)) {
}
if (mount("none", "/syzcgroup/net", "cgroup", 0,
"net_cls,net_prio,devices,freezer")) {
}
if (chmod("/syzcgroup/net", 0777)) {
}
}
static void setup_binfmt_misc()
{
if (mount(0, "/proc/sys/fs/binfmt_misc", "binfmt_misc", 0, 0)) {
}
write_file("/proc/sys/fs/binfmt_misc/register", ":syz0:M:0:\x01::./file0:");
write_file("/proc/sys/fs/binfmt_misc/register",
":syz1:M:1:\x02::./file0:POC");
}
static void setup_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
setup_cgroups();
setup_binfmt_misc();
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = 200 << 20;
setrlimit(RLIMIT_AS, &rlim);
rlim.rlim_cur = rlim.rlim_max = 32 << 20;
setrlimit(RLIMIT_MEMLOCK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 136 << 20;
setrlimit(RLIMIT_FSIZE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 1 << 20;
setrlimit(RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 0;
setrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 256;
setrlimit(RLIMIT_NOFILE, &rlim);
if (unshare(CLONE_NEWNS)) {
}
if (unshare(CLONE_NEWIPC)) {
}
if (unshare(0x02000000)) {
}
if (unshare(CLONE_NEWUTS)) {
}
if (unshare(CLONE_SYSVSEM)) {
}
typedef struct {
const char* name;
const char* value;
} sysctl_t;
static const sysctl_t sysctls[] = {
{"/proc/sys/kernel/shmmax", "16777216"},
{"/proc/sys/kernel/shmall", "536870912"},
{"/proc/sys/kernel/shmmni", "1024"},
{"/proc/sys/kernel/msgmax", "8192"},
{"/proc/sys/kernel/msgmni", "1024"},
{"/proc/sys/kernel/msgmnb", "1024"},
{"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
};
unsigned i;
for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
write_file(sysctls[i].name, sysctls[i].value);
}
int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static int do_sandbox_none(void)
{
if (unshare(CLONE_NEWPID)) {
}
int pid = fork();
if (pid != 0)
return wait_for_loop(pid);
setup_common();
sandbox_common();
initialize_netdevices_init();
if (unshare(CLONE_NEWNET)) {
}
initialize_tun();
initialize_netdevices();
loop();
exit(1);
}
#define FS_IOC_SETFLAGS _IOW('f', 2, long)
static void remove_dir(const char* dir)
{
DIR* dp;
struct dirent* ep;
int iter = 0;
retry:
while (umount2(dir, MNT_DETACH) == 0) {
}
dp = opendir(dir);
if (dp == NULL) {
if (errno == EMFILE) {
exit(1);
}
exit(1);
}
while ((ep = readdir(dp))) {
if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
continue;
char filename[FILENAME_MAX];
snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name);
while (umount2(filename, MNT_DETACH) == 0) {
}
struct stat st;
if (lstat(filename, &st))
exit(1);
if (S_ISDIR(st.st_mode)) {
remove_dir(filename);
continue;
}
int i;
for (i = 0;; i++) {
if (unlink(filename) == 0)
break;
if (errno == EPERM) {
int fd = open(filename, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno != EBUSY || i > 100)
exit(1);
if (umount2(filename, MNT_DETACH))
exit(1);
}
}
closedir(dp);
int i;
for (i = 0;; i++) {
if (rmdir(dir) == 0)
break;
if (i < 100) {
if (errno == EPERM) {
int fd = open(dir, O_RDONLY);
if (fd != -1) {
long flags = 0;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0)
close(fd);
continue;
}
}
if (errno == EROFS) {
break;
}
if (errno == EBUSY) {
if (umount2(dir, MNT_DETACH))
exit(1);
continue;
}
if (errno == ENOTEMPTY) {
if (iter < 100) {
iter++;
goto retry;
}
}
}
exit(1);
}
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
#define SYZ_HAVE_SETUP_LOOP 1
static void setup_loop()
{
int pid = getpid();
char cgroupdir[64];
char file[128];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/pids.max", cgroupdir);
write_file(file, "32");
snprintf(file, sizeof(file), "%s/memory.low", cgroupdir);
write_file(file, "%d", 298 << 20);
snprintf(file, sizeof(file), "%s/memory.high", cgroupdir);
write_file(file, "%d", 299 << 20);
snprintf(file, sizeof(file), "%s/memory.max", cgroupdir);
write_file(file, "%d", 300 << 20);
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (mkdir(cgroupdir, 0777)) {
}
snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
write_file(file, "%d", pid);
checkpoint_net_namespace();
}
#define SYZ_HAVE_RESET_LOOP 1
static void reset_loop()
{
reset_net_namespace();
}
#define SYZ_HAVE_SETUP_TEST 1
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
char cgroupdir[64];
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.cpu")) {
}
snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
if (symlink(cgroupdir, "./cgroup.net")) {
}
write_file("/proc/self/oom_score_adj", "1000");
flush_tun();
}
#define SYZ_HAVE_RESET_TEST 1
static void reset_test()
{
int fd;
for (fd = 3; fd < 30; fd++)
close(fd);
}
struct thread_t {
int created, call;
event_t ready, done;
};
static struct thread_t threads[16];
static void execute_call(int call);
static int running;
static void* thr(void* arg)
{
struct thread_t* th = (struct thread_t*)arg;
for (;;) {
event_wait(&th->ready);
event_reset(&th->ready);
execute_call(th->call);
__atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
event_set(&th->done);
}
return 0;
}
static void execute_one(void)
{
int i, call, thread;
for (call = 0; call < 10; call++) {
for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0]));
thread++) {
struct thread_t* th = &threads[thread];
if (!th->created) {
th->created = 1;
event_init(&th->ready);
event_init(&th->done);
event_set(&th->done);
thread_start(thr, th);
}
if (!event_isset(&th->done))
continue;
event_reset(&th->done);
th->call = call;
__atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
event_set(&th->ready);
event_timedwait(&th->done, 45);
break;
}
}
for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
sleep_ms(1);
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
setup_loop();
int iter;
for (iter = 0;; iter++) {
char cwdbuf[32];
sprintf(cwdbuf, "./%d", iter);
if (mkdir(cwdbuf, 0777))
exit(1);
reset_loop();
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
if (chdir(cwdbuf))
exit(1);
setup_test();
execute_one();
reset_test();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
remove_dir(cwdbuf);
}
}
uint64_t r[1] = {0xffffffffffffffff};
void execute_call(int call)
{
long res;
switch (call) {
case 0:
syscall(__NR_ioctl, -1, 0x41007701, 0);
break;
case 1:
res = syscall(__NR_socket, 0xa, 2, 0);
if (res != -1)
r[0] = res;
break;
case 2:
syscall(__NR_ioctl, -1, 0x540a, 0);
break;
case 3:
NONFAILING(*(uint8_t*)0x20000000 = 0);
NONFAILING(*(uint8_t*)0x20000001 = 0);
NONFAILING(*(uint8_t*)0x20000002 = 0);
NONFAILING(*(uint8_t*)0x20000003 = 0);
NONFAILING(*(uint8_t*)0x20000004 = 0);
NONFAILING(*(uint8_t*)0x20000005 = 0);
NONFAILING(*(uint8_t*)0x20000006 = 0);
NONFAILING(*(uint8_t*)0x20000007 = 0);
syscall(__NR_setsockopt, r[0], 0x29, 0x3b, 0x20000000, 8);
break;
case 4:
NONFAILING(*(uint16_t*)0x200000c0 = 0xa);
NONFAILING(*(uint16_t*)0x200000c2 = htobe16(0));
NONFAILING(*(uint32_t*)0x200000c4 = 0);
NONFAILING(*(uint8_t*)0x200000c8 = 0xfe);
NONFAILING(*(uint8_t*)0x200000c9 = 0x80);
NONFAILING(*(uint8_t*)0x200000ca = 0);
NONFAILING(*(uint8_t*)0x200000cb = 0);
NONFAILING(*(uint8_t*)0x200000cc = 0);
NONFAILING(*(uint8_t*)0x200000cd = 0);
NONFAILING(*(uint8_t*)0x200000ce = 0);
NONFAILING(*(uint8_t*)0x200000cf = 0);
NONFAILING(*(uint8_t*)0x200000d0 = 0);
NONFAILING(*(uint8_t*)0x200000d1 = 0);
NONFAILING(*(uint8_t*)0x200000d2 = 0);
NONFAILING(*(uint8_t*)0x200000d3 = 0);
NONFAILING(*(uint8_t*)0x200000d4 = 0);
NONFAILING(*(uint8_t*)0x200000d5 = 0);
NONFAILING(*(uint8_t*)0x200000d6 = 0);
NONFAILING(*(uint8_t*)0x200000d7 = 0);
NONFAILING(*(uint32_t*)0x200000d8 = 4);
syscall(__NR_connect, r[0], 0x200000c0, 0x1c);
break;
case 5:
NONFAILING(*(uint16_t*)0x20000180 = 0x18);
NONFAILING(*(uint32_t*)0x20000182 = 1);
NONFAILING(*(uint32_t*)0x20000186 = 0);
NONFAILING(*(uint32_t*)0x2000018a = -1);
NONFAILING(*(uint16_t*)0x2000018e = 2);
NONFAILING(*(uint16_t*)0x20000190 = htobe16(0));
NONFAILING(*(uint32_t*)0x20000192 = htobe32(0xe0000002));
NONFAILING(*(uint32_t*)0x2000019e = 4);
NONFAILING(*(uint32_t*)0x200001a2 = 0);
NONFAILING(*(uint32_t*)0x200001a6 = 0);
NONFAILING(*(uint32_t*)0x200001aa = 0);
syscall(__NR_connect, -1, 0x20000180, 0x26);
break;
case 6:
syscall(__NR_sendmmsg, r[0], 0x20005fc0, 0x8000000000000fc, 0x8000000);
break;
case 7:
NONFAILING(*(uint32_t*)0x2001d000 = 1);
NONFAILING(*(uint32_t*)0x2001d004 = 0x70);
NONFAILING(*(uint8_t*)0x2001d008 = 0);
NONFAILING(*(uint8_t*)0x2001d009 = 0);
NONFAILING(*(uint8_t*)0x2001d00a = 0);
NONFAILING(*(uint8_t*)0x2001d00b = 0);
NONFAILING(*(uint32_t*)0x2001d00c = 0);
NONFAILING(*(uint64_t*)0x2001d010 = 0x7f);
NONFAILING(*(uint64_t*)0x2001d018 = 0);
NONFAILING(*(uint64_t*)0x2001d020 = 0);
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 0, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 1, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 2, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 3, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 4, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0x81, 5, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 6, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 7, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 8, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 9, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 10, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 11, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 12, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 13, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 14, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 15, 2));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 17, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 18, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 19, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 20, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 21, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 22, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 23, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 24, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 25, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 26, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 27, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 28, 1));
NONFAILING(STORE_BY_BITMASK(uint64_t, , 0x2001d028, 0, 29, 35));
NONFAILING(*(uint32_t*)0x2001d030 = 0);
NONFAILING(*(uint32_t*)0x2001d034 = 0);
NONFAILING(*(uint64_t*)0x2001d038 = 0x20abe000);
NONFAILING(*(uint64_t*)0x2001d040 = 0);
NONFAILING(*(uint64_t*)0x2001d048 = 0);
NONFAILING(*(uint64_t*)0x2001d050 = 0);
NONFAILING(*(uint32_t*)0x2001d058 = 0);
NONFAILING(*(uint32_t*)0x2001d05c = 0);
NONFAILING(*(uint64_t*)0x2001d060 = 0);
NONFAILING(*(uint32_t*)0x2001d068 = 0);
NONFAILING(*(uint16_t*)0x2001d06c = 0);
NONFAILING(*(uint16_t*)0x2001d06e = 0);
syscall(__NR_perf_event_open, 0x2001d000, 0, -1, -1, 0);
break;
case 8:
NONFAILING(memcpy((void*)0x20000240, "./file0\x00", 8));
NONFAILING(*(uint32_t*)0x20000280 = 8);
NONFAILING(*(uint32_t*)0x20000284 = 0x4e);
syscall(__NR_name_to_handle_at, -1, 0x20000240, 0x20000280, 0, 0x1400);
break;
case 9:
NONFAILING(memcpy((void*)0x20000440, "syz1", 4));
syscall(__NR_write, -1, 0x20000440, 0x1200e);
break;
}
}
int main(void)
{
syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
install_segv_handler();
for (procid = 0; procid < 6; procid++) {
if (fork() == 0) {
use_temporary_dir();
do_sandbox_none();
}
}
sleep(1000000);
return 0;
}
| [
"dvyukov@google.com"
] | dvyukov@google.com |
9cafff7c4c1e00891cd7b1cbc522bdedf79792e3 | ff98fd06f2e047f6a1c6ba6089a9aefbc5c3c4f4 | /driver/xdma_ioctl.h | f9b628323514d5016722d27e4aa57ad4c53a1bb4 | [] | no_license | fpgasystems/davos | bf9fee1099ddae3ccf978c6839e6ae38b46d4345 | cb85a3dba0985c7a6efed3d19ec6e3578853b7d4 | refs/heads/master | 2022-05-01T18:10:13.810398 | 2022-04-06T12:00:28 | 2022-04-06T12:00:28 | 209,025,898 | 55 | 24 | null | 2020-07-21T09:41:01 | 2019-09-17T10:33:58 | SystemVerilog | UTF-8 | C | false | false | 396 | h | #ifndef XDMA_IOCTL_H
#define XDMA_IOCTL_H
#include <linux/ioctl.h>
struct xdma_huge {
unsigned long addr;
unsigned long size;
};
struct xdma_huge_mapping {
unsigned long npages;
unsigned long* dma_addr;
};
#define IOCTL_XDMA_BUFFER_SET _IOW('q', 1, struct xdma_huge*)
#define IOCTL_XDMA_MAPPING_GET _IOR('q', 2, struct xdma_huge_mapping*)
#define IOCTL_XDMA_RELEASE _IO ('q', 3)
#endif
| [
"david.sidler@inf.ethz.ch"
] | david.sidler@inf.ethz.ch |
57470872219f0579a3ce9dbb8a1fdcfb8fa0f9d2 | 7eaaa10e3d78c3875441ccf2216a54ce6b4d6261 | /ZLinky/SDK_2_6_4_JN5189DK6/boards/jn5189dk6/project_template/clock_config.h | f52c1e54546ed0c9de41fd1cb39a805eb3adcc0b | [] | no_license | bricodx/Zlinky_TIC | 069eff9ccf1973b8f4e0480fbb474c73b6a81c4b | 161f1577c2531a9cdd3470d4dff105b0f1f64218 | refs/heads/master | 2023-08-28T09:50:37.515687 | 2021-11-13T09:07:02 | 2021-11-13T09:07:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,257 | h | /*
* Copyright 2019-2020 NXP
* All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
/***********************************************************************************************************************
* This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file
* will be overwritten if the respective MCUXpresso Config Tools is used to update this file.
**********************************************************************************************************************/
#ifndef _CLOCK_CONFIG_H_
#define _CLOCK_CONFIG_H_
#include "fsl_common.h"
/*******************************************************************************
* Definitions
******************************************************************************/
/*******************************************************************************
************************ BOARD_InitBootClocks function ************************
******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus*/
/*!
* @brief This function executes default configuration of clocks.
*
*/
void BOARD_InitBootClocks(void);
#if defined(__cplusplus)
}
#endif /* __cplusplus*/
/*******************************************************************************
********************** Configuration BOARD_BootClockRUN ***********************
******************************************************************************/
/*******************************************************************************
* Definitions for BOARD_BootClockRUN configuration
******************************************************************************/
#define BOARD_BOOTCLOCKRUN_CORE_CLOCK 48000000U /*!< Core clock frequency: 48000000Hz */
/*******************************************************************************
* API for BOARD_BootClockRUN configuration
******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus*/
/*!
* @brief This function executes configuration of clocks.
*
*/
void BOARD_BootClockRUN(void);
#if defined(__cplusplus)
}
#endif /* __cplusplus*/
#endif /* _CLOCK_CONFIG_H_ */
| [
"akila@faire-ca-soi-meme.fr"
] | akila@faire-ca-soi-meme.fr |
69aa2d8f88a8044afd1d04c86c1be3dcec5d079e | 1053723697cb4e44e4a4603c258de1dccf600206 | /MSP430/MSP430F5529/MSP430图形库/examples/MSP-EXP430F5438_Grlib_Example/LcdDriver/HAL_MSP_EXP430F5438_HITACHI138x110_HD66753.h | 745ac3bb3bb61763904128741be027c5e7f242dd | [] | no_license | walliak/Control | 9ab9590aefef5006e76318299ad634066b50c3ce | 97d8d8aa1c6c0fc0315ed5217248fc3243d03d09 | refs/heads/master | 2020-04-27T15:59:27.424760 | 2019-07-31T02:45:32 | 2019-07-31T02:45:32 | 174,467,772 | 1 | 1 | null | null | null | null | UTF-8 | C | false | false | 5,327 | h | /* --COPYRIGHT--,BSD
* Copyright (c) 2016, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --/COPYRIGHT--*/
//TODO
//*****************************************************************************
//
// HAL_MSP_EXP430F5438_HITACHI138x110_HD66753.h - Prototypes for the
// Hitachi 138x110 HD66753 LCD display driver.
// There is no output from Sharp96x96 LCD.
//
// MSP430FR5969 LCD HD66753
// ----------------- ------------
// | P9.1/UCB2SIMO|-*-LCD_DATA--> |SDA |
// /|\| P9.2/UCB2SOMI|_| | |
// | | P9.3/UCB2CLK|---LCD_CLK---> |SCL |
// --|RST | | |
// | P9.6|---LCD_CS----> |CS |
// | | | |
// | P9.7|---LCD_RST---> |RESET |
// | | ------------
// | |
// | | TPS61043
// | | ----------
// | | | |
// | P8.3/TA0.4 |----BKLT_EN --> |CTRL |
// | | | |
// | | ----------
// ------------------
//****************************************************************************
#ifndef __HAL_MSP_EXP430F5438_HITACHI138x110_HD66753__
#define __HAL_MSP_EXP430F5438_HITACHI138x110_HD66753__
//*****************************************************************************
//
// User Configuration for the LCD Driver
//
//*****************************************************************************
// Ports from MSP430 connected to LCD
#define LCD_BKLT_EN_PORT GPIO_PORT_P8
#define LCD_CS_PORT GPIO_PORT_P9
#define LCD_RST_PORT GPIO_PORT_P9
#define LCD_SIMO_PORT GPIO_PORT_P9
#define LCD_SOMI_PORT GPIO_PORT_P9
#define LCD_CLK_PORT GPIO_PORT_P9
// Pins from MSP430 connected to LCD
#define LCD_BKLT_EN_PIN GPIO_PIN3
#define LCD_CS_PIN GPIO_PIN6
#define LCD_RST_PIN GPIO_PIN7
#define LCD_SIMO_PIN GPIO_PIN1
#define LCD_SOMI_PIN GPIO_PIN2
#define LCD_CLK_PIN GPIO_PIN3
// Definition of USCI base address to be used for SPI communication
#define LCD_USCI_BASE USCI_B2_BASE
// Definition of TIMER_A base address to be used for backlight control
#define LCD_TIMER_BASE_BKLT TIMER_A0_BASE
//*****************************************************************************
//
// Deprecated names. These definitions ensure backwards compatibility
// but new code should avoid using deprecated struct names since these will
// be removed at some point in the future.
//
//*****************************************************************************
//*****************************************************************************
//
// Prototypes for the globals exported by this driver.
//
//*****************************************************************************
extern void HAL_LCD_initLCD(void);
extern void HAL_LCD_writeCommand(uint8_t *command);
extern void HAL_LCD_clearCS(void);
extern void HAL_LCD_setCS(void);
extern void HAL_LCD_initTimer(uint16_t captureCompareVal);
extern uint16_t HAL_LCD_getTimerCaptureCompare();
extern void HAL_LCD_setTimerDutyCycle(uint16_t dutyCycle);
extern void HAL_LCD_startTimerCounter(void);
extern void HAL_LCD_stopTimerCounter(void);
extern void HAL_LCD_turnOffBackLight(void);
#endif // __HAL_MSP_EXP430F5438_HITACHI138x110_HD66753__
| [
"2430661978@qq.com"
] | 2430661978@qq.com |
b7cfce225f0a4e7d26bf7ec27c4f2483cf7e3586 | 4661d3e878b0919838a57ca7fbee38fa164ab487 | /commission_calculator.c | 038622ee17da4ace5ac1297ce718e7a21e4eb2e7 | [] | no_license | Njengamichugu/Commissions | 10f0c11006a6736ea1bb56b80ced638e9f2ce3fd | e6f6e080622bca44f1be8a49e313868d75f8a4d3 | refs/heads/main | 2023-05-27T23:33:14.809537 | 2021-06-16T13:35:05 | 2021-06-16T13:35:05 | 377,506,795 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,334 | c | /* An application that calculates a brokers comission based on the trade he pulled comparing it with his rival
*copyright 2021
*Developed by Kevin Njenga */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
float trade_made, commission, amountj_traded , jshares_traded;
printf("Enter number of shares traded by Jameson/your trade:");
scanf("%d/%f " , &jshares_traded, &trade_made);
if (jshares_traded > 2000){
amountj_traded = (jshares_traded * 33.02);
}else if (jshares_traded < 2000){
amountj_traded = (jshares_traded * 33.03);
}
if (trade_made < 2500){
commission = (30 + 1.7*trade_made);
}else if (trade_made < 6250){
commission = (56 + 0.66*trade_made);
}else if (trade_made < 20000){
commission = (76 + 0.34*trade_made);
}else if (trade_made < 50000){
commission = (100 + 0.22*trade_made);
}else if (trade_made < 500000){
commission = (155 + 0.11*trade_made);
}else if(trade_made > 500000);{
commission = (76 + 0.34*trade_made);
}
if (commission < 39){
printf("Your commission: 39");
}else {
printf("Your commission: %.2f\n " , commission);
}printf("Jameson made %.2f" , amountj_traded);
return 0;
}
| [
"noreply@github.com"
] | Njengamichugu.noreply@github.com |
83f5b039ee70abc8e17c16d9b69527f09d052bec | a70ea6beb4ce600263a4baeb6539d535864a6987 | /my_char_drive/test.c | 7d22d4624102777b1035248002d99c0aacd94749 | [] | no_license | LostLord/linux-kernel-study | 48f926c1e9dcef3b4998f25a8548c6e1dfe4465e | b4c0f3ba905612dbe171fd684923582f9d874bc6 | refs/heads/master | 2020-08-19T14:33:25.738396 | 2019-10-21T08:47:28 | 2019-10-21T08:47:28 | 215,928,070 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,146 | c | #include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
char line[100] = "aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd";
char out[100] = {"\0"};
int main() {
int fd, num;
int wret, rret;
fd = open("/dev/chardev0", O_RDWR, S_IRUSR | S_IWUSR);
printf("%d\n", sizeof(int));
if (fd != -1) {
// sprintf(line, "%d-%d-%d", 2019, 10, 15);
wret = write(fd, line, 20);
printf("write ret = %d\n", wret);
rret = read(fd, out, 5);
printf("read ret = %d\n", rret);
printf("out ret = %s\n", out);
rret = read(fd, out, 5);
printf("read ret = %d\n", rret);
printf("out ret = %s\n", out);
rret = read(fd, out, 5);
printf("read ret = %d\n", rret);
printf("out ret = %s\n", out);
rret = read(fd, out, 5);
printf("read ret = %d\n", rret);
printf("out ret = %s\n", out);
wret = write(fd, line + 10, 20);
printf("write ret = %d\n", wret);
wret = write(fd, line + 10, 20);
printf("write ret = %d\n", wret);
rret = read(fd, out, 30);
printf("read ret = %d\n", rret);
printf("out ret = %s\n", out);
close(fd);
} else {
printf("Open error\n");
}
return 0;
}
| [
"lordlost19@gmail.com"
] | lordlost19@gmail.com |
9b3f3bf15a5a38146e13ce9e9d0f523077e16970 | d5d57c06d376bd589bd8ec8170bd17f597c85108 | /Pods/Headers/Private/UzysAssetsPickerController+CacheSelect/UzysAssetsPickerController.h | 73628549bd1a6f2510731ff78a31d83469ec68df | [] | no_license | mszren/YiNoteDiary | 026c2f5614d7ddd5c8f6c2e871cfa6ca9aaf3d4f | f79f24cab3d9f81455bd36436ff32f53e99362ad | refs/heads/master | 2021-01-17T17:03:07.443121 | 2016-03-30T05:31:14 | 2016-03-30T05:31:14 | 62,113,698 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 111 | h | ../../../UzysAssetsPickerController+CacheSelect/UzysAssetsPickerController/Library/UzysAssetsPickerController.h | [
"2439398156@qq.com"
] | 2439398156@qq.com |
30fb4b4c70979cf4b413e8d2fa90bee5ef26a510 | c795b4746f21f5b14db01e696efd01e29b16f08f | /Filesystem/shell.c | 8ed84c4661b1d5912801d36e20846f3ee7d70490 | [] | no_license | jerryz-hello/BareMetalOS | 9b993bd04e924513f8fc0298b712f07863b0bd78 | 27fc9dae76bdae308c78e08c673c8ba991f14db9 | refs/heads/master | 2023-01-05T08:03:19.200409 | 2020-11-04T19:50:08 | 2020-11-04T19:50:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,620 | c | #include "shell.h"
#include "kernel.h"
int strlen(char *s);
int memcmp(void *s1, void *s2, int n);
void *memcpy(void *dest, void *src, int n);
void main()
{
char line[MAX_LINE_LEN];
char file_buffer[MAX_PRGM_SIZE];
char *filename;
struct file_entry *cur_file_entry;
char sector_buffer[SECTOR_SIZE];
char cur_filename[7];
char filename1[7];
char *filename1_ptr;
int filename1_len;
while (1)
{
interrupt(0x21, 0, "SHELL> ", 0, 0);
interrupt(0x21, 1, line, 0, 0);
interrupt(0x21, 0, "\n", 0, 0);
/* removing the enter at the end */
line[strlen(line) - 1] = '\0';
if (memcmp(line, "type", 4) == 0)
{
for (filename = line + 4; (*filename == ' ' || *filename == '\t') && *filename != '\0'; filename++)
;
/* clear the buffer */
file_buffer[0] = '\0';
interrupt(0x21, 3, filename, file_buffer, 0);
interrupt(0x21, 0, file_buffer, 0, 0);
}
else if (memcmp(line, "execute", 7) == 0)
{
for (filename = line + 7; (*filename == ' ' || *filename == '\t') && *filename != '\0'; filename++)
;
interrupt(0x21, 4, filename, 0x2000, 0);
}
else if (memcmp(line, "dir", 3) == 0)
{
interrupt(0x21, 2, sector_buffer, DIR_SECTOR, 0);
for (cur_file_entry = sector_buffer; cur_file_entry->filename[0] != 0x0 && cur_file_entry - (struct file_entry *)sector_buffer < FILE_ENTRY_IN_SECTOR; cur_file_entry++)
{
memcpy(cur_filename, cur_file_entry->filename, FILE_ENTRY_FILENAME_SIZE);
cur_filename[FILE_ENTRY_FILENAME_SIZE] = '\0';
interrupt(0x21, 0, cur_filename, 0, 0);
interrupt(0x21, 0, "\n", 0, 0);
}
}
else if (memcmp(line, "copy", 4) == 0)
{
for (filename = line + 4; (*filename == ' ' || *filename == '\t') && *filename != '\0'; filename++)
;
filename1_ptr = filename;
for (; !(*filename == ' ' || *filename == '\t') && *filename != '\0'; filename++)
;
filename1_len = filename - filename1_ptr;
memcpy(filename1, filename1_ptr, filename1_len);
filename1[filename1_len] = '\0';
interrupt(0x21, 3, filename1, file_buffer, 0);
for (; (*filename == ' ' || *filename == '\t') && *filename != '\0'; filename++)
;
filename1_ptr = filename;
for (; !(*filename == ' ' || *filename == '\t') && *filename != '\0'; filename++)
;
filename1_len = filename - filename1_ptr;
memcpy(filename1, filename1_ptr, filename1_len);
filename1[filename1_len] = '\0';
interrupt(0x21, 8, filename1, file_buffer, 3);
}
else
{
interrupt(0x21, 0, "Bad Command!\n", 0, 0);
}
}
}
/* Modified from: https://clc-wiki.net/wiki/memcmp */
int memcmp(void *s1, void *s2, int n)
{
unsigned char *p1 = s1, *p2 = s2;
while (n--)
if (*p1 != *p2)
return *p1 - *p2;
else
p1++, p2++;
return 0;
}
/* Modified from: https://clc-wiki.net/wiki/strlen */
int strlen(char *s)
{
int i;
for (i = 0; s[i] != '\0'; i++)
;
return i;
}
/* Modified from: https://clc-wiki.net/wiki/memcpy */
void *memcpy(void *dest, void *src, int n)
{
char *dp = dest;
char *sp = src;
while (n--)
*dp++ = *sp++;
return dest;
}
| [
"zhengj2@rose-hulman.edu"
] | zhengj2@rose-hulman.edu |
6cd9121353218baec40c49ddbbd4e4f7771c70a9 | 0b56c1fbf2ae26b553c8e710d823ae5efa158ac0 | /exam_papers/ex12_13/students.c | f1f27212a1dcefa6aa3267f848b3a8e87604337d | [] | no_license | zhuangaili/CS1010 | 0feec2f4ec0efd35967f3f359629bf4f6ae1526c | 48de7de5ff0a999967f6bc20696fab6d9834e209 | refs/heads/master | 2021-05-06T00:17:07.858975 | 2017-07-22T16:01:00 | 2017-07-22T16:01:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,211 | c | #include <stdio.h>
#define NAME_LENGTH 30
#define MAX_NUM_COURSES 20
#define MAX_NUM_STUDENTS 100
int readStudents(student_t students[], char *fileName);
int findStudentByName(student_t students[],int numberStudents, char name[]);
float averageScore(student_t stu);
typedef struct {
char name[NAME_LENGTH];
int numCourses;
int scores[MAX_NUM_COURSES];
} student_t;
int main(void){
}
int readStudents(student_t students[], char *fileName){
int counter,int numCourses;
if((fileName=fopen("filename.in"))==NULL){
printf("file could not be opened");
}
else{
while(!feof(fileName)){
for(counter=0;counter<MAX_NUM_STUDENTS;counter++){
fscanf("%s %d %d",students[counter].name,&students[counter].numCourses,&students[counter].score[counter]);
}
}
}
fclose(fileName);
}
int findStudentByName(student_t students[],int numberStudents, char name[]){
int counter;
for(counter=0;counter<numStudents;counter++){
if(strcmp(students[counter].name,name[])==0){
return counter;
}
}
return -1;
}
float averageScore(student_t stu){
int counter
float score=0;
for(counter=0;counter<stu.numCourses;counter++){
score+=stu.scores[counter];
}
return score/stu.numCourses;
} | [
"lee.yi.jie.joel@gmail.com"
] | lee.yi.jie.joel@gmail.com |
c54ec4819d52b106f03643faaa03e4607ac6d28c | 2e1465297cf42e43a8f8dc2de259adedba0106bd | /Include/susiaccess_handler_ex_api.h | 77aa59eec5ec35bb224f031c32a335c76cea157c | [] | no_license | 12019/WISEAgent | cecdc0e384fc96bef74af058f30096ae39e468f1 | 3e0ac013644d38107b4b05a12f3351c8a4b49736 | refs/heads/master | 2021-01-11T22:20:13.852283 | 2016-02-02T07:03:32 | 2016-02-02T07:03:32 | 78,949,980 | 0 | 1 | null | 2017-01-14T16:00:55 | 2017-01-14T16:00:55 | null | UTF-8 | C | false | false | 1,954 | h | #ifndef _CAGENT_HANDLER_EX_H_
#define _CAGENT_HANDLER_EX_H_
#include "susiaccess_handler_api.h"
typedef AGENT_SEND_STATUS (*HandlerConnectServerCbf)(char const * ip, int port, char const * mqttauth, tls_type tlstype, char const * psk);
typedef AGENT_SEND_STATUS (*HandlerDisconnectCbf)();
typedef AGENT_SEND_STATUS (*HandlerRenameCbf)(char const * name);
typedef struct HANDLER_INFO_EX
{
#ifdef _MSC_VER
struct HANDLER_INFO;
#else
char Name[MAX_TOPIC_LEN]; // The handler name
char ServerIP[DEF_MAX_STRING_LENGTH];
int ServerPort;
char WorkDir[DEF_MAX_STRING_LENGTH];
int RequestID;
int ActionID;
//key_t shmKey; // shared memory key
void* loghandle; // log file handler
//GetLibFNP GetLibAPI; // Get the Function Point of comman library api
cagent_agent_info_body_t * agentInfo; // Info of the Agent
HandlerSendCbf sendcbf; // Client Send information (in JSON format) to Cloud Server
HandlerSendCustCbf sendcustcbf; // Client Send information (in JSON format) to Cloud Server with custom topic
HandlerSubscribeCustCbf subscribecustcbf; // Client subscribe the custom topic to receive message from Cloud Server
HandlerSendCapabilityCbf sendcapabilitycbf; // Client Send Spec.Info (in JSON format) to Cloud Server with SpecInfo topic
HandlerAutoReportCbf sendreportcbf; // Client Send report (in JSON format) to Cloud Server with AutoReport topic
HandlerSendEventCbf sendeventcbf; // Client Send Event Notify (in JSON format) to Cloud Server with EventNotify topic
#endif
HandlerConnectServerCbf connectservercbf; // connect to specific server callback function
HandlerDisconnectCbf disconnectcbf; // disconnect callback function
HandlerRenameCbf renamecbf; // rename callback function
char serverAuth[DEF_USER_PASS_LENGTH];
tls_type TLSType;
char PSK[DEF_USER_PASS_LENGTH];
}HANDLER_INFO_EX, Handler_info_ex;
#endif /* _CAGENT_HANDLER_EX_H_ */ | [
"scott68.chang@advantech.com.tw"
] | scott68.chang@advantech.com.tw |
6edc4364e182cd65100cbd57ab7c069dbd1ded48 | 40e3518a9ae5a697c9fcf40e23f1073198b3b1ec | /openwsn/02a-MAClow/IEEE802154E.c | cbc73056cf169545bb1377c4f11845f8e6cdeaf2 | [] | no_license | saharbenyaala/wsnopen | 0b9e3f3f32b03fc365f6393645f8337b0c025cb0 | 240dd0565a18c7e46a92c996e5258c110ddf4e4a | refs/heads/master | 2020-04-15T08:52:24.723359 | 2013-06-16T10:49:31 | 2013-06-16T10:49:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 72,370 | c | #include "openwsn.h"
#include "IEEE802154E.h"
#include "radio.h"
#include "radiotimer.h"
#include "IEEE802154.h"
#include "openqueue.h"
#include "idmanager.h"
#include "openserial.h"
#include "schedule.h"
#include "packetfunctions.h"
#include "scheduler.h"
#include "leds.h"
#include "neighbors.h"
#include "debugpins.h"
#include "res.h"
#include "board.h"
#include "stdlib.h"
//misc include
#include "bbk.h"
#include "noiseprobe.h"
#include "bit2bool.h"
//=========================== variables =======================================
typedef struct {
// misc
asn_t asn; // current absolute slot number
slotOffset_t slotOffset; // current slot offset
slotOffset_t nextActiveSlotOffset; // next active slot offset
PORT_TIMER_WIDTH deSyncTimeout; // how many slots left before looses sync
bool isSync; // TRUE iff mote is synchronized to network
// as shown on the chronogram
ieee154e_state_t state; // state of the FSM
OpenQueueEntry_t* dataToSend; // pointer to the data to send
OpenQueueEntry_t* dataReceived; // pointer to the data received
OpenQueueEntry_t* ackToSend; // pointer to the ack to send
OpenQueueEntry_t* ackReceived; // pointer to the ack received
PORT_TIMER_WIDTH lastCapturedTime; // last captured time
PORT_TIMER_WIDTH syncCapturedTime; // captured time used to sync
//channel hopping
uint8_t freq; // channel of the current slot
uint8_t asnOffset;
/* piggy301a: state vars for blacklisting */
bool anyCast;
uint16_t linkMask;
bool linkArray[16];
uint16_t parentM;
open_addr_t otherEnd;
} ieee154e_vars_t;
ieee154e_vars_t ieee154e_vars;
typedef struct {
PORT_TIMER_WIDTH num_newSlot;
PORT_TIMER_WIDTH num_timer;
PORT_TIMER_WIDTH num_startOfFrame;
PORT_TIMER_WIDTH num_endOfFrame;
//pdu - channel hopping debug
uint8_t chanCtr[16]; //it counts the usage of each channel
uint8_t synckack;
uint8_t synckpkt;
uint8_t numADV;
//pdu
} ieee154e_dbg_t;
ieee154e_dbg_t ieee154e_dbg;
// these statistics are reset every time they are reported
PRAGMA(pack(1));
typedef struct {
uint8_t syncCounter; // how many times we synchronized
PORT_SIGNED_INT_WIDTH minCorrection; // minimum time correction
PORT_SIGNED_INT_WIDTH maxCorrection; // maximum time correction
uint8_t numDeSync; // number of times a desync happened
PORT_SIGNED_INT_WIDTH correction[10];
uint8_t num_sync;
} ieee154e_stats_t;
PRAGMA(pack());
ieee154e_stats_t ieee154e_stats;
/* piggy300: temp vars */
uint8_t syn1st=0;
uint16_t local_t_mask = 0xFFFF;
uint16_t local_TxMask = 0xFFFF;
uint16_t local_RxMask = 0xFFFF;
//=========================== prototypes ======================================
// SYNCHRONIZING
void activity_synchronize_newSlot();
void activity_synchronize_startOfFrame(PORT_TIMER_WIDTH capturedTime);
void activity_synchronize_endOfFrame(PORT_TIMER_WIDTH capturedTime);
// TX
void activity_ti1ORri1();
void activity_ti2();
void activity_tie1();
void activity_ti3();
void activity_tie2();
void activity_ti4(PORT_TIMER_WIDTH capturedTime);
void activity_tie3();
void activity_ti5(PORT_TIMER_WIDTH capturedTime);
void activity_ti6();
void activity_tie4();
void activity_ti7();
void activity_tie5();
void activity_ti8(PORT_TIMER_WIDTH capturedTime);
void activity_tie6();
void activity_ti9(PORT_TIMER_WIDTH capturedTime);
// RX
void activity_ri2();
void activity_rie1();
void activity_ri3();
void activity_rie2();
void activity_ri4(PORT_TIMER_WIDTH capturedTime);
void activity_rie3();
void activity_ri5(PORT_TIMER_WIDTH capturedTime);
void activity_ri6();
void activity_rie4();
void activity_ri7();
void activity_rie5();
void activity_ri8(PORT_TIMER_WIDTH capturedTime);
void activity_rie6();
void activity_ri9(PORT_TIMER_WIDTH capturedTime);
// frame validity check
bool isValidAdv(ieee802154_header_iht* ieee802514_header);
bool isValidRxFrame(ieee802154_header_iht* ieee802514_header);
bool isValidAck(ieee802154_header_iht* ieee802514_header,
OpenQueueEntry_t* packetSent);
// ASN handling
void incrementAsnOffset();
void asnWriteToAdv(OpenQueueEntry_t* advFrame);
void asnStoreFromAdv(OpenQueueEntry_t* advFrame);
// synchronization
void synchronizePacket(PORT_TIMER_WIDTH timeReceived);
void synchronizeAck(PORT_SIGNED_INT_WIDTH timeCorrection);
void changeIsSync(bool newIsSync);
// notifying upper layer
void notif_sendDone(OpenQueueEntry_t* packetSent, error_t error);
void notif_receive(OpenQueueEntry_t* packetReceived);
// statistics
void resetStats();
void updateStats(PORT_SIGNED_INT_WIDTH timeCorrection);
// misc
uint8_t calculateFrequency(uint8_t channelOffset);
void changeState(ieee154e_state_t newstate);
void endSlot();
bool debugPrint_asn();
bool debugPrint_isSync();
//=========================== admin ===========================================
/**
\brief This function initializes this module.
Call this function once before any other function in this module, possibly
during boot-up.
*/
void ieee154e_init() {
// initialize variables
memset(&ieee154e_vars,0,sizeof(ieee154e_vars_t));
memset(&ieee154e_dbg,0,sizeof(ieee154e_dbg_t));
/* piggy301b: init state vars for blacklisting */
ieee154e_vars.linkMask = 0xffff;
ieee154e_vars.parentM = 0xffff;
for(int8_t i=0; i<16; i++)
ieee154e_vars.linkArray[i]=1;
if (idmanager_getIsDAGroot()==TRUE) {
changeIsSync(TRUE);
} else {
changeIsSync(FALSE);
}
resetStats();
ieee154e_stats.numDeSync = 0;
// set callback functions for the radio
radio_setOverflowCb(isr_ieee154e_newSlot);
radio_setCompareCb(isr_ieee154e_timer);
radio_setStartFrameCb(ieee154e_startOfFrame);
radio_setEndFrameCb(ieee154e_endOfFrame);
// have the radio start its timer
radio_startTimer(TsSlotDuration);
// switch radio on
radio_rfOn();
}
//=========================== public ==========================================
/**
/brief Difference between some older ASN and the current ASN.
\param someASN [in] some ASN to compare to the current
\returns The ASN difference, or 0xffff if more than 65535 different
*/
PORT_TIMER_WIDTH ieee154e_asnDiff(asn_t* someASN) {
PORT_TIMER_WIDTH diff;
INTERRUPT_DECLARATION();
DISABLE_INTERRUPTS();
if (ieee154e_vars.asn.byte4 != someASN->byte4) {
ENABLE_INTERRUPTS();
return (PORT_TIMER_WIDTH)0xFFFFFFFF;;
}
diff = 0;
if (ieee154e_vars.asn.bytes2and3 == someASN->bytes2and3) {
ENABLE_INTERRUPTS();
return ieee154e_vars.asn.bytes0and1-someASN->bytes0and1;
} else if (ieee154e_vars.asn.bytes2and3-someASN->bytes2and3==1) {
diff = ieee154e_vars.asn.bytes0and1;
diff += 0xffff-someASN->bytes0and1;
diff += 1;
} else {
diff = (PORT_TIMER_WIDTH)0xFFFFFFFF;;
}
ENABLE_INTERRUPTS();
return diff;
}
//======= events
/**
\brief Indicates a new slot has just started.
This function executes in ISR mode, when the new slot timer fires.
*/
void isr_ieee154e_newSlot() {
radio_setTimerPeriod(TsSlotDuration);
debugpins_slot_toggle();
if (ieee154e_vars.isSync==FALSE) {
activity_synchronize_newSlot();
} else {
activity_ti1ORri1();
}
ieee154e_dbg.num_newSlot++;
}
/**
\brief Indicates the FSM timer has fired.
This function executes in ISR mode, when the FSM timer fires.
*/
void isr_ieee154e_timer() {
switch (ieee154e_vars.state) {
case S_TXDATAOFFSET:
activity_ti2();
break;
case S_TXDATAPREPARE:
activity_tie1();
break;
case S_TXDATAREADY:
activity_ti3();
break;
case S_TXDATADELAY:
activity_tie2();
break;
case S_TXDATA:
activity_tie3();
break;
case S_RXACKOFFSET:
activity_ti6();
break;
case S_RXACKPREPARE:
activity_tie4();
break;
case S_RXACKREADY:
activity_ti7();
break;
case S_RXACKLISTEN:
activity_tie5();
break;
case S_RXACK:
activity_tie6();
break;
case S_RXDATAOFFSET:
activity_ri2();
break;
case S_RXDATAPREPARE:
activity_rie1();
break;
case S_RXDATAREADY:
activity_ri3();
break;
case S_RXDATALISTEN:
activity_rie2();
break;
case S_RXDATA:
activity_rie3();
break;
case S_TXACKOFFSET:
activity_ri6();
break;
case S_TXACKPREPARE:
activity_rie4();
break;
case S_TXACKREADY:
activity_ri7();
break;
case S_TXACKDELAY:
activity_rie5();
break;
case S_TXACK:
activity_rie6();
break;
/* piggy303: noise floor activities invoked by timers */
case S_NFPROBEOFFSET:
activity_np1();
break;
case S_NPPREPARE:
activity_npe1();
break;
case S_NPREADY:
activity_np2();
break;
case S_NPSTART:
break;
default:
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WRONG_STATE_IN_TIMERFIRES,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
break;
}
ieee154e_dbg.num_timer++;
}
/**
\brief Indicates the radio just received the first byte of a packet.
This function executes in ISR mode.
*/
void ieee154e_startOfFrame(PORT_TIMER_WIDTH capturedTime) {
if (ieee154e_vars.isSync==FALSE) {
activity_synchronize_startOfFrame(capturedTime);
} else {
switch (ieee154e_vars.state) {
case S_TXDATADELAY:
activity_ti4(capturedTime);
break;
case S_RXACKLISTEN:
activity_ti8(capturedTime);
break;
case S_RXDATALISTEN:
activity_ri4(capturedTime);
break;
case S_TXACKDELAY:
activity_ri8(capturedTime);
break;
default:
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WRONG_STATE_IN_NEWSLOT,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
break;
}
}
ieee154e_dbg.num_startOfFrame++;
}
/**
\brief Indicates the radio just received the last byte of a packet.
This function executes in ISR mode.
*/
void ieee154e_endOfFrame(PORT_TIMER_WIDTH capturedTime) {
if (ieee154e_vars.isSync==FALSE) {
activity_synchronize_endOfFrame(capturedTime);
} else {
switch (ieee154e_vars.state) {
case S_TXDATA:
activity_ti5(capturedTime);
break;
case S_RXACK:
activity_ti9(capturedTime);
break;
case S_RXDATA:
activity_ri5(capturedTime);
break;
case S_TXACK:
activity_ri9(capturedTime);
break;
default:
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WRONG_STATE_IN_ENDOFFRAME,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
break;
}
}
ieee154e_dbg.num_endOfFrame++;
}
//======= misc
bool debugPrint_asn() {
asn_t output;
output.byte4 = ieee154e_vars.asn.byte4;
output.bytes2and3 = ieee154e_vars.asn.bytes2and3;
output.bytes0and1 = ieee154e_vars.asn.bytes0and1;
openserial_printStatus(STATUS_ASN,(uint8_t*)&output,sizeof(output));
return TRUE;
}
bool debugPrint_isSync() {
uint8_t output=0;
output = ieee154e_vars.isSync;
openserial_printStatus(STATUS_ISSYNC,(uint8_t*)&output,sizeof(uint8_t));
return TRUE;
}
bool debugPrint_macStats() {
// send current stats over serial
openserial_printStatus(STATUS_MACSTATS,(uint8_t*)&ieee154e_stats,sizeof(ieee154e_stats_t));
return TRUE;
}
//=========================== private =========================================
//======= SYNCHRONIZING
port_INLINE void activity_synchronize_newSlot() {
// I'm in the middle of receiving a packet
if (ieee154e_vars.state==S_SYNCRX) {
return;
}
// if this is the first time I call this function while not synchronized,
// switch on the radio in Rx mode
if (ieee154e_vars.state!=S_SYNCLISTEN) {
// change state
changeState(S_SYNCLISTEN);
// turn off the radio (in case it wasn't yet)
radio_rfOff();
// configure the radio to listen to the default synchronizing channel
radio_setFrequency(SYNCHRONIZING_CHANNEL);
// update record of current channel
ieee154e_vars.freq = SYNCHRONIZING_CHANNEL;
// switch on the radio in Rx mode.
radio_rxEnable();
radio_rxNow();
}
// we want to be able to receive and transmist serial even when not synchronized
// take turns every other slot to send or receive
openserial_stop();
if (ieee154e_vars.asn.byte4++%2==0) {
openserial_startOutput();
} else {
openserial_startInput();
}
}
port_INLINE void activity_synchronize_startOfFrame(PORT_TIMER_WIDTH capturedTime) {
// don't care about packet if I'm not listening
if (ieee154e_vars.state!=S_SYNCLISTEN) {
return;
}
// change state
changeState(S_SYNCRX);
// stop the serial
openserial_stop();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// record the captured time (for sync)
ieee154e_vars.syncCapturedTime = capturedTime;
}
port_INLINE void activity_synchronize_endOfFrame(PORT_TIMER_WIDTH capturedTime) {
ieee802154_header_iht ieee802514_header;
// check state
if (ieee154e_vars.state!=S_SYNCRX) {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WRONG_STATE_IN_ENDFRAME_SYNC,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)0);
// abort
endSlot();
}
// change state
changeState(S_SYNCPROC);
// get a buffer to put the (received) frame in
ieee154e_vars.dataReceived = openqueue_getFreePacketBuffer(COMPONENT_IEEE802154E);
if (ieee154e_vars.dataReceived==NULL) {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
// abort
endSlot();
return;
}
// declare ownership over that packet
ieee154e_vars.dataReceived->creator = COMPONENT_IEEE802154E;
ieee154e_vars.dataReceived->owner = COMPONENT_IEEE802154E;
// retrieve the received data frame from the radio's Rx buffer
ieee154e_vars.dataReceived->payload = &(ieee154e_vars.dataReceived->packet[0]);
radio_getReceivedFrame( ieee154e_vars.dataReceived->payload,
&ieee154e_vars.dataReceived->length,
sizeof(ieee154e_vars.dataReceived->packet),
&ieee154e_vars.dataReceived->l1_rssi,
&ieee154e_vars.dataReceived->l1_lqi,
&ieee154e_vars.dataReceived->l1_crc);
// toss CRC (2 last bytes)
packetfunctions_tossFooter( ieee154e_vars.dataReceived, LENGTH_CRC);
/*
The do-while loop that follows is a little parsing trick.
Because it contains a while(0) condition, it gets executed only once.
The behavior is:
- if a break occurs inside the do{} body, the error code below the loop
gets executed. This indicates something is wrong with the packet being
parsed.
- if a return occurs inside the do{} body, the error code below the loop
does not get executed. This indicates the received packet is correct.
*/
do { // this "loop" is only executed once
// break if invalid CRC
if (ieee154e_vars.dataReceived->l1_crc==FALSE) {
// break from the do-while loop and execute abort code below
break;
}
// parse the IEEE802.15.4 header
ieee802154_retrieveHeader(ieee154e_vars.dataReceived,&ieee802514_header);
// store header details in packet buffer
ieee154e_vars.dataReceived->l2_frameType = ieee802514_header.frameType;
ieee154e_vars.dataReceived->l2_dsn = ieee802514_header.dsn;
memcpy(&(ieee154e_vars.dataReceived->l2_nextORpreviousHop),&(ieee802514_header.src),sizeof(open_addr_t));
// toss the IEEE802.15.4 header
packetfunctions_tossHeader(ieee154e_vars.dataReceived,ieee802514_header.headerLength);
// if I just received a valid ADV, handle
if (isValidAdv(&ieee802514_header)==TRUE) {
ieee154e_dbg.numADV++;
// turn off the radio
radio_rfOff();
// record the ASN from the ADV payload
asnStoreFromAdv(ieee154e_vars.dataReceived);
// toss the ADV payload
packetfunctions_tossHeader(ieee154e_vars.dataReceived,ADV_PAYLOAD_LENGTH);
// synchronize (for the first time) to the sender's ADV
synchronizePacket(ieee154e_vars.syncCapturedTime);
// declare synchronized
changeIsSync(TRUE);
// printf("Synch set to TRUE %d \n ",radiotimer_getPeriod());
/* Only then start sending (piggy304) */
if((!idmanager_getIsDAGroot())&&(syn1st==0)){
//if(syn1st==0){ //allow DAGroot to ini dcs so that it can change channel for test
bbk_init();
syn1st++;
}
// log the "error"
openserial_printError(COMPONENT_IEEE802154E,ERR_SYNCHRONIZED,
(errorparameter_t)ieee154e_vars.slotOffset,
(errorparameter_t)0);
// send received ADV up the stack so RES can update statistics (synchronizing)
notif_receive(ieee154e_vars.dataReceived);
// clear local variable
ieee154e_vars.dataReceived = NULL;
// official end of synchronization
endSlot();
// everything went well, return here not to execute the error code below
return;
}
} while (0);
// free the (invalid) received data buffer so RAM memory can be recycled
openqueue_freePacketBuffer(ieee154e_vars.dataReceived);
// clear local variable
ieee154e_vars.dataReceived = NULL;
}
//======= TX
port_INLINE void activity_ti1ORri1() {
cellType_t cellType;
//open_addr_t neighbor;
// increment ASN (do this first so debug pins are in sync)
incrementAsnOffset();
// wiggle debug pins
//debugpins_slot_toggle();
if (ieee154e_vars.slotOffset==0) {
debugpins_frame_toggle();
//debugpins_radio_toggle();
}
// desynchronize if needed
if (idmanager_getIsDAGroot()==FALSE) {
ieee154e_vars.deSyncTimeout--;
if (ieee154e_vars.deSyncTimeout==0) {
// declare myself desynchronized
changeIsSync(FALSE);
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_DESYNCHRONIZED,
(errorparameter_t)ieee154e_vars.slotOffset,
(errorparameter_t)0);
// update the statistics
ieee154e_stats.numDeSync++;
// abort
endSlot();
return;
}
}
// if the previous slot took too long, we will not be in the right state
if (ieee154e_vars.state!=S_SLEEP) {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WRONG_STATE_IN_STARTSLOT,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
return;
}
if (ieee154e_vars.slotOffset==ieee154e_vars.nextActiveSlotOffset) {
// this is the next active slot
// advance the schedule
schedule_advanceSlot();
// find the next one
ieee154e_vars.nextActiveSlotOffset = schedule_getNextActiveSlotOffset();
} else {
// this is NOT the next active slot, abort
// stop using serial
openserial_stop();
// abort the slot
endSlot();
//start outputing serial
openserial_startOutput();
return;
}
// check the schedule to see what type of slot this is
cellType = schedule_getType();
switch (cellType) {
case CELLTYPE_ADV:
// stop using serial
openserial_stop();
// look for an ADV packet in the queue
ieee154e_vars.dataToSend = openqueue_macGetAdvPacket();
if (ieee154e_vars.dataToSend==NULL) { // I will be listening for an ADV
// change state
changeState(S_RXDATAOFFSET);
// arm rt1
radiotimer_schedule(DURATION_rt1);
} else { // I will be sending an ADV
// change state
changeState(S_TXDATAOFFSET);
// change owner
ieee154e_vars.dataToSend->owner = COMPONENT_IEEE802154E;
// fill in the ASN field of the ADV
asnWriteToAdv(ieee154e_vars.dataToSend);
// record that I attempt to transmit this packet
ieee154e_vars.dataToSend->l2_numTxAttempts++;
// arm tt1
radiotimer_schedule(DURATION_tt1);
}
break;
case CELLTYPE_TXRX:
case CELLTYPE_TX:
// stop using serial
openserial_stop();
// check whether we can send
if (schedule_getOkToSend()) {
//schedule_getNeighbor(&neighbor);
/* piggy305: module-wide equivalent to hold the addr of other end */
schedule_getNeighbor(&ieee154e_vars.otherEnd);
ieee154e_vars.dataToSend = openqueue_macGetDataPacket(&ieee154e_vars.otherEnd);
} else {
ieee154e_vars.dataToSend = NULL;
}
if (ieee154e_vars.dataToSend!=NULL) { // I have a packet to send
// change state
changeState(S_TXDATAOFFSET);
// change owner
ieee154e_vars.dataToSend->owner = COMPONENT_IEEE802154E;
// record that I attempt to transmit this packet
ieee154e_vars.dataToSend->l2_numTxAttempts++;
/* piggy306a: set the mask to use based on what kind of neighbour we will send to */
if(ieee154e_vars.otherEnd.type==ADDR_ANYCAST){
ieee154e_vars.anyCast = TRUE;
//because the parent wouldn't know which child is sending
ieee154e_vars.linkMask=ieee154e_vars.parentM;
}
else{
ieee154e_vars.anyCast = FALSE;
//ieee154e_vars.linkMask=local_mask & ieee154e_vars.parentM;
ieee154e_vars.linkMask=local_TxMask & ieee154e_vars.parentM;
}
convert(ieee154e_vars.linkMask, ieee154e_vars.linkArray);
/*********************/
// arm tt1
radiotimer_schedule(DURATION_tt1);
} else if (cellType==CELLTYPE_TX){
// abort
endSlot();
}
if (cellType==CELLTYPE_TX ||
(cellType==CELLTYPE_TXRX && ieee154e_vars.dataToSend!=NULL)) {
break;
}
case CELLTYPE_RX:
// stop using serial
openserial_stop();
// change state
changeState(S_RXDATAOFFSET);
/* piggy306b: set the mask to use based on what kind of neighbour we will hear from */
if(ieee154e_vars.otherEnd.type==ADDR_ANYCAST){
ieee154e_vars.anyCast = TRUE;
//because receivers (such as the parent) don't know which child is sending
ieee154e_vars.linkMask=local_RxMask;
}
else{
ieee154e_vars.anyCast = FALSE;
//local AND the sender(downstream children)'s
ieee154e_vars.linkMask=local_RxMask & neighbors_getMask(&ieee154e_vars.otherEnd);
}
convert(ieee154e_vars.linkMask, ieee154e_vars.linkArray);
/******************/
// arm rt1
radiotimer_schedule(DURATION_rt1);
break;
case CELLTYPE_SERIALRX:
// stop using serial
openserial_stop();
// abort the slot
endSlot();
//start inputting serial data
openserial_startInput();
break;
case CELLTYPE_MORESERIALRX:
// do nothing (not even endSlot())
break;
/* piggy307a: entering NF slots */
case CELLTYPE_NF:
// stop using serial
openserial_stop();
// change state
changeState(S_NFPROBEOFFSET);
//arm rt1(reception timer), triggering np1
radiotimer_schedule(DURATION_rt1);
//endSlot(); //debug
break;
default:
// stop using serial
openserial_stop();
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WRONG_CELLTYPE,
(errorparameter_t)cellType,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
break;
}
}
port_INLINE void activity_ti2() {
// change state
changeState(S_TXDATAPREPARE);
// calculate the frequency to transmit on
ieee154e_vars.freq = calculateFrequency(schedule_getChannelOffset());
/* piggy317a: manipulate outgoing payload if from BBK */
insertOutgoing(ieee154e_vars.dataToSend);
// configure the radio for that frequency
//radio_setFrequency(frequency);
radio_setFrequency(ieee154e_vars.freq);
// load the packet in the radio's Tx buffer
radio_loadPacket(ieee154e_vars.dataToSend->payload,
ieee154e_vars.dataToSend->length);
// enable the radio in Tx mode. This does not send the packet.
radio_txEnable();
// arm tt2
radiotimer_schedule(DURATION_tt2);
// change state
changeState(S_TXDATAREADY);
}
port_INLINE void activity_tie1() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_MAXTXDATAPREPARE_OVERFLOW,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ti3() {
// change state
changeState(S_TXDATADELAY);
// arm tt3
radiotimer_schedule(DURATION_tt3);
// give the 'go' to transmit
radio_txNow();
}
port_INLINE void activity_tie2() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WDRADIO_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ti4(PORT_TIMER_WIDTH capturedTime) {
// change state
changeState(S_TXDATA);
// cancel tt3
radiotimer_cancel();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// arm tt4
radiotimer_schedule(DURATION_tt4);
}
port_INLINE void activity_tie3() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WDDATADURATION_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ti5(PORT_TIMER_WIDTH capturedTime) {
bool listenForAck;
// change state
changeState(S_RXACKOFFSET);
// cancel tt4
radiotimer_cancel();
// turn off the radio
radio_rfOff();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// decides whether to listen for an ACK
if (packetfunctions_isBroadcastMulticast(&ieee154e_vars.dataToSend->l2_nextORpreviousHop)==TRUE) {
listenForAck = FALSE;
} else {
listenForAck = TRUE;
}
if (listenForAck==TRUE) {
// arm tt5
radiotimer_schedule(DURATION_tt5);
} else {
// indicate succesful Tx to schedule to keep statistics
schedule_indicateTx(&ieee154e_vars.asn,TRUE);
// indicate to upper later the packet was sent successfully
notif_sendDone(ieee154e_vars.dataToSend,E_SUCCESS);
// reset local variable
ieee154e_vars.dataToSend = NULL;
// abort
endSlot();
}
}
port_INLINE void activity_ti6() {
// change state
changeState(S_RXACKPREPARE);
// calculate the frequency to transmit on
ieee154e_vars.freq = calculateFrequency(schedule_getChannelOffset());
// configure the radio for that frequency
//radio_setFrequency(frequency);
radio_setFrequency(ieee154e_vars.freq);
// enable the radio in Rx mode. The radio is not actively listening yet.
radio_rxEnable();
// arm tt6
radiotimer_schedule(DURATION_tt6);
// change state
changeState(S_RXACKREADY);
}
port_INLINE void activity_tie4() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_MAXRXACKPREPARE_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ti7() {
// change state
changeState(S_RXACKLISTEN);
// start listening
radio_rxNow();
// arm tt7
radiotimer_schedule(DURATION_tt7);
}
port_INLINE void activity_tie5() {
// indicate transmit failed to schedule to keep stats
schedule_indicateTx(&ieee154e_vars.asn,FALSE);
//piggy309: diables retransmission - if no ACK received, just move on to next one.
notif_sendDone(ieee154e_vars.dataToSend,E_FAIL);
/*
// decrement transmits left counter
ieee154e_vars.dataToSend->l2_retriesLeft--;
if (ieee154e_vars.dataToSend->l2_retriesLeft==0) {
// indicate tx fail if no more retries left
notif_sendDone(ieee154e_vars.dataToSend,E_FAIL);
} else {
// return packet to the virtual COMPONENT_RES_TO_IEEE802154E component
ieee154e_vars.dataToSend->owner = COMPONENT_RES_TO_IEEE802154E;
}
*/
// reset local variable
ieee154e_vars.dataToSend = NULL;
// abort
endSlot();
}
port_INLINE void activity_ti8(PORT_TIMER_WIDTH capturedTime) {
// change state
changeState(S_RXACK);
// cancel tt7
radiotimer_cancel();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// arm tt8
radiotimer_schedule(DURATION_tt8);
}
port_INLINE void activity_tie6() {
// abort
endSlot();
}
port_INLINE void activity_ti9(PORT_TIMER_WIDTH capturedTime) {
ieee802154_header_iht ieee802514_header;
volatile PORT_SIGNED_INT_WIDTH timeCorrection;
uint8_t byte0;
uint8_t byte1;
// change state
changeState(S_TXPROC);
// cancel tt8
radiotimer_cancel();
// turn off the radio
radio_rfOff();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// get a buffer to put the (received) ACK in
ieee154e_vars.ackReceived = openqueue_getFreePacketBuffer(COMPONENT_IEEE802154E);
if (ieee154e_vars.ackReceived==NULL) {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
// abort
endSlot();
return;
}
// declare ownership over that packet
ieee154e_vars.ackReceived->creator = COMPONENT_IEEE802154E;
ieee154e_vars.ackReceived->owner = COMPONENT_IEEE802154E;
// retrieve the received ack frame from the radio's Rx buffer
ieee154e_vars.ackReceived->payload = &(ieee154e_vars.ackReceived->packet[0]);
radio_getReceivedFrame( ieee154e_vars.ackReceived->payload,
&ieee154e_vars.ackReceived->length,
sizeof(ieee154e_vars.ackReceived->packet),
&ieee154e_vars.ackReceived->l1_rssi,
&ieee154e_vars.ackReceived->l1_lqi,
&ieee154e_vars.ackReceived->l1_crc);
// toss CRC (2 last bytes)
packetfunctions_tossFooter( ieee154e_vars.ackReceived, LENGTH_CRC);
/*
The do-while loop that follows is a little parsing trick.
Because it contains a while(0) condition, it gets executed only once.
Below the do-while loop is some code to cleans up the ack variable.
Anywhere in the do-while loop, a break statement can be called to jump to
the clean up code early. If the loop ends without a break, the received
packet was correct. If it got aborted early (through a break), the packet
was faulty.
*/
do { // this "loop" is only executed once
// break if invalid CRC
if (ieee154e_vars.ackReceived->l1_crc==FALSE) {
// break from the do-while loop and execute the clean-up code below
break;
}
// parse the IEEE802.15.4 header
ieee802154_retrieveHeader(ieee154e_vars.ackReceived,&ieee802514_header);
// store header details in packet buffer
ieee154e_vars.ackReceived->l2_frameType = ieee802514_header.frameType;
ieee154e_vars.ackReceived->l2_dsn = ieee802514_header.dsn;
memcpy(&(ieee154e_vars.ackReceived->l2_nextORpreviousHop),&(ieee802514_header.src),sizeof(open_addr_t));
// toss the IEEE802.15.4 header
packetfunctions_tossHeader(ieee154e_vars.ackReceived,ieee802514_header.headerLength);
// if frame is a valid ACK, handle
if (isValidAck(&ieee802514_header,ieee154e_vars.dataToSend)==TRUE) {
// resynchronize if I'm not a DAGroot and ACK from preferred parent
if (idmanager_getIsDAGroot()==FALSE &&
neighbors_isPreferredParent(&(ieee154e_vars.ackReceived->l2_nextORpreviousHop)) ) {
byte0 = ieee154e_vars.ackReceived->payload[0];
byte1 = ieee154e_vars.ackReceived->payload[1];
timeCorrection = (PORT_SIGNED_INT_WIDTH)((PORT_TIMER_WIDTH)byte1<<8 | (PORT_TIMER_WIDTH)byte0);
timeCorrection /= US_PER_TICK;
timeCorrection = -timeCorrection;
synchronizeAck(timeCorrection);
}
// inform schedule of successful transmission
schedule_indicateTx(&ieee154e_vars.asn,TRUE);
// inform upper layer
notif_sendDone(ieee154e_vars.dataToSend,E_SUCCESS);
ieee154e_vars.dataToSend = NULL;
}
// in any case, execute the clean-up code below
} while (0);
// free the received ack so corresponding RAM memory can be recycled
openqueue_freePacketBuffer(ieee154e_vars.ackReceived);
// clear local variable
ieee154e_vars.ackReceived = NULL;
// official end of Tx slot
endSlot();
}
//======= RX
port_INLINE void activity_ri2() {
// change state
changeState(S_RXDATAPREPARE);
// calculate the frequency to transmit on
ieee154e_vars.freq = calculateFrequency(schedule_getChannelOffset());
// configure the radio for that frequency
//radio_setFrequency(frequency);
radio_setFrequency(ieee154e_vars.freq);
// enable the radio in Rx mode. The radio does not actively listen yet.
radio_rxEnable();
// arm rt2
radiotimer_schedule(DURATION_rt2);
// change state
changeState(S_RXDATAREADY);
}
port_INLINE void activity_rie1() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_MAXRXDATAPREPARE_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ri3() {
// change state
changeState(S_RXDATALISTEN);
// give the 'go' to receive
radio_rxNow();
// arm rt3
radiotimer_schedule(DURATION_rt3);
}
port_INLINE void activity_rie2() {
// abort
endSlot();
}
port_INLINE void activity_ri4(PORT_TIMER_WIDTH capturedTime) {
// change state
changeState(S_RXDATA);
// cancel rt3
radiotimer_cancel();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// record the captured time to sync
ieee154e_vars.syncCapturedTime = capturedTime;
// arm rt4
radiotimer_schedule(DURATION_rt4);
}
port_INLINE void activity_rie3() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WDDATADURATION_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ri5(PORT_TIMER_WIDTH capturedTime) {
ieee802154_header_iht ieee802514_header;
// change state
changeState(S_TXACKOFFSET);
// cancel rt4
radiotimer_cancel();
// turn off the radio
radio_rfOff();
// get a buffer to put the (received) data in
ieee154e_vars.dataReceived = openqueue_getFreePacketBuffer(COMPONENT_IEEE802154E);
if (ieee154e_vars.dataReceived==NULL) {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
// abort
endSlot();
return;
}
// declare ownership over that packet
ieee154e_vars.dataReceived->creator = COMPONENT_IEEE802154E;
ieee154e_vars.dataReceived->owner = COMPONENT_IEEE802154E;
// retrieve the received data frame from the radio's Rx buffer
ieee154e_vars.dataReceived->payload = &(ieee154e_vars.dataReceived->packet[0]);
radio_getReceivedFrame( ieee154e_vars.dataReceived->payload,
&ieee154e_vars.dataReceived->length,
sizeof(ieee154e_vars.dataReceived->packet),
&ieee154e_vars.dataReceived->l1_rssi,
&ieee154e_vars.dataReceived->l1_lqi,
&ieee154e_vars.dataReceived->l1_crc);
// toss CRC (2 last bytes)
packetfunctions_tossFooter( ieee154e_vars.dataReceived, LENGTH_CRC);
/*
The do-while loop that follows is a little parsing trick.
Because it contains a while(0) condition, it gets executed only once.
The behavior is:
- if a break occurs inside the do{} body, the error code below the loop
gets executed. This indicates something is wrong with the packet being
parsed.
- if a return occurs inside the do{} body, the error code below the loop
does not get executed. This indicates the received packet is correct.
*/
do { // this "loop" is only executed once
// if CRC doesn't check, stop
if (ieee154e_vars.dataReceived->l1_crc==FALSE) {
// jump to the error code below this do-while loop
break;
}
// parse the IEEE802.15.4 header
ieee802154_retrieveHeader(ieee154e_vars.dataReceived,&ieee802514_header);
// store header details in packet buffer
ieee154e_vars.dataReceived->l2_frameType = ieee802514_header.frameType;
ieee154e_vars.dataReceived->l2_dsn = ieee802514_header.dsn;
memcpy(&(ieee154e_vars.dataReceived->l2_nextORpreviousHop),&(ieee802514_header.src),sizeof(open_addr_t));
// toss the IEEE802.15.4 header
packetfunctions_tossHeader(ieee154e_vars.dataReceived,ieee802514_header.headerLength);
// if I just received a valid ADV, record the ASN and toss the payload
if (isValidAdv(&ieee802514_header)==TRUE) {
if (idmanager_getIsDAGroot()==FALSE) {
asnStoreFromAdv(ieee154e_vars.dataReceived);
/* piggy310: update parent's mask record from a valid ADV from parent */
if(idmanager_getIsDAGroot()==FALSE && neighbors_isPreferredParent(&(ieee154e_vars.dataReceived->l2_nextORpreviousHop)))
{
ieee154e_vars.parentM = (ieee154e_vars.dataReceived->payload[5]) + (uint16_t)(ieee154e_vars.dataReceived->payload[6]<<8);
neighbors_setMask(&(ieee154e_vars.dataReceived->l2_nextORpreviousHop),ieee154e_vars.parentM);
}
}
// toss the ADV payload
packetfunctions_tossHeader(ieee154e_vars.dataReceived,ADV_PAYLOAD_LENGTH);
}
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// if I just received an invalid frame, stop
if (isValidRxFrame(&ieee802514_header)==FALSE) {
// jump to the error code below this do-while loop
break;
}
/* piggy312a: manipulate payload if data */
handleRecvPkt(ieee154e_vars.dataReceived);
// check if ack requested
if (ieee802514_header.ackRequested==1) {
// arm rt5
radiotimer_schedule(DURATION_rt5);
} else {
// synchronize to the received packet iif I'm not a DAGroot and this is my preferred parent
if (idmanager_getIsDAGroot()==FALSE && neighbors_isPreferredParent(&(ieee154e_vars.dataReceived->l2_nextORpreviousHop))) {
synchronizePacket(ieee154e_vars.syncCapturedTime);
}
// indicate reception to upper layer (no ACK asked)
notif_receive(ieee154e_vars.dataReceived);
// reset local variable
ieee154e_vars.dataReceived = NULL;
// abort
endSlot();
}
// everything went well, return here not to execute the error code below
return;
} while(0);
// free the (invalid) received data so RAM memory can be recycled
openqueue_freePacketBuffer(ieee154e_vars.dataReceived);
// clear local variable
ieee154e_vars.dataReceived = NULL;
// abort
endSlot();
}
port_INLINE void activity_ri6() {
PORT_SIGNED_INT_WIDTH timeCorrection;
// change state
changeState(S_TXACKPREPARE);
// get a buffer to put the ack to send in
ieee154e_vars.ackToSend = openqueue_getFreePacketBuffer(COMPONENT_IEEE802154E);
if (ieee154e_vars.ackToSend==NULL) {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
// indicate we received a packet anyway (we don't want to loose any)
notif_receive(ieee154e_vars.dataReceived);
// free local variable
ieee154e_vars.dataReceived = NULL;
// abort
endSlot();
return;
}
// declare ownership over that packet
ieee154e_vars.ackToSend->creator = COMPONENT_IEEE802154E;
ieee154e_vars.ackToSend->owner = COMPONENT_IEEE802154E;
// calculate the time timeCorrection
timeCorrection = (PORT_SIGNED_INT_WIDTH)((PORT_SIGNED_INT_WIDTH)ieee154e_vars.syncCapturedTime-(PORT_SIGNED_INT_WIDTH)TsTxOffset);
// add the payload to the ACK (i.e. the timeCorrection)
packetfunctions_reserveHeaderSize(ieee154e_vars.ackToSend,sizeof(IEEE802154E_ACK_ht));
timeCorrection = -timeCorrection;
timeCorrection *= US_PER_TICK;
ieee154e_vars.ackToSend->payload[0] = (uint8_t)((((PORT_TIMER_WIDTH)timeCorrection) ) & 0xff);
ieee154e_vars.ackToSend->payload[1] = (uint8_t)((((PORT_TIMER_WIDTH)timeCorrection)>>8) & 0xff);
// prepend the IEEE802.15.4 header to the ACK
ieee154e_vars.ackToSend->l2_frameType = IEEE154_TYPE_ACK;
ieee154e_vars.ackToSend->l2_dsn = ieee154e_vars.dataReceived->l2_dsn;
ieee802154_prependHeader(ieee154e_vars.ackToSend,
ieee154e_vars.ackToSend->l2_frameType,
IEEE154_SEC_NO_SECURITY,
ieee154e_vars.dataReceived->l2_dsn,
&(ieee154e_vars.dataReceived->l2_nextORpreviousHop)
);
// space for 2-byte CRC
packetfunctions_reserveFooterSize(ieee154e_vars.ackToSend,2);
// calculate the frequency to transmit on
ieee154e_vars.freq = calculateFrequency(schedule_getChannelOffset());
// configure the radio for that frequency
//radio_setFrequency(frequency);
radio_setFrequency(ieee154e_vars.freq);
// load the packet in the radio's Tx buffer
radio_loadPacket(ieee154e_vars.ackToSend->payload,
ieee154e_vars.ackToSend->length);
// enable the radio in Tx mode. This does not send that packet.
radio_txEnable();
// arm rt6
radiotimer_schedule(DURATION_rt6);
// change state
changeState(S_TXACKREADY);
}
port_INLINE void activity_rie4() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_MAXTXACKPREPARE_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ri7() {
// change state
changeState(S_TXACKDELAY);
// arm rt7
radiotimer_schedule(DURATION_rt7);
// give the 'go' to transmit
radio_txNow();
}
port_INLINE void activity_rie5() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WDRADIOTX_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ri8(PORT_TIMER_WIDTH capturedTime) {
// change state
changeState(S_TXACK);
// cancel rt7
radiotimer_cancel();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// arm rt8
radiotimer_schedule(DURATION_rt8);
}
port_INLINE void activity_rie6() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_WDACKDURATION_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
port_INLINE void activity_ri9(PORT_TIMER_WIDTH capturedTime) {
// change state
changeState(S_RXPROC);
// cancel rt8
radiotimer_cancel();
// record the captured time
ieee154e_vars.lastCapturedTime = capturedTime;
// free the ack we just sent so corresponding RAM memory can be recycled
openqueue_freePacketBuffer(ieee154e_vars.ackToSend);
// clear local variable
ieee154e_vars.ackToSend = NULL;
// synchronize to the received packet
if (idmanager_getIsDAGroot()==FALSE && neighbors_isPreferredParent(&(ieee154e_vars.dataReceived->l2_nextORpreviousHop))) {
synchronizePacket(ieee154e_vars.syncCapturedTime);
}
// inform upper layer of reception (after ACK sent)
notif_receive(ieee154e_vars.dataReceived);
// clear local variable
ieee154e_vars.dataReceived = NULL;
// official end of Rx slot
endSlot();
}
//======= frame validity check
/**
\brief Decides whether the packet I just received is a valid ADV
\param [in] ieee802514_header IEEE802.15.4 header of the packet I just received
\returns TRUE if packet is a valid ADV, FALSE otherwise
*/
port_INLINE bool isValidAdv(ieee802154_header_iht* ieee802514_header) {
return ieee802514_header->valid==TRUE && \
ieee802514_header->frameType==IEEE154_TYPE_BEACON && \
packetfunctions_sameAddress(&ieee802514_header->panid,idmanager_getMyID(ADDR_PANID)) && \
ieee154e_vars.dataReceived->length==ADV_PAYLOAD_LENGTH;
}
/**
\brief Decides whether the packet I just received is valid received frame.
A valid Rx frame satisfies the following constraints:
- its IEEE802.15.4 header is well formatted
- its a DATA of BEACON frame (i.e. not ACK and not COMMAND)
- its sent on the same PANid as mine
- its for me (unicast or broadcast)
-
\param [in] ieee802514_header IEEE802.15.4 header of the packet I just received
\returns TRUE if packet is valid received frame, FALSE otherwise
*/
port_INLINE bool isValidRxFrame(ieee802154_header_iht* ieee802514_header) {
return ieee802514_header->valid==TRUE && \
(
ieee802514_header->frameType==IEEE154_TYPE_DATA ||
ieee802514_header->frameType==IEEE154_TYPE_BEACON
) && \
packetfunctions_sameAddress(&ieee802514_header->panid,idmanager_getMyID(ADDR_PANID)) && \
(
idmanager_isMyAddress(&ieee802514_header->dest) ||
packetfunctions_isBroadcastMulticast(&ieee802514_header->dest)
);
}
/**
\brief Decides whether the packet I just received is a valid ACK.
A packet is a valid ACK if it satisfies the following conditions:
- the IEEE802.15.4 header is valid
- the frame type is 'ACK'
- the sequence number in the ACK matches the sequence number of the packet sent
- the ACK contains my PANid
- the packet is unicast to me
- the packet comes from the neighbor I sent the data to
\param [in] ieee802514_header IEEE802.15.4 header of the packet I just received
\param [in] packetSent points to the packet I just sent
\returns TRUE if packet is a valid ACK, FALSE otherwise.
*/
port_INLINE bool isValidAck(ieee802154_header_iht* ieee802514_header,
OpenQueueEntry_t* packetSent) {
/*
return ieee802514_header->valid==TRUE && \
ieee802514_header->frameType==IEEE154_TYPE_ACK && \
ieee802514_header->dsn==packetSent->l2_dsn && \
packetfunctions_sameAddress(&ieee802514_header->panid,idmanager_getMyID(ADDR_PANID)) && \
idmanager_isMyAddress(&ieee802514_header->dest) && \
packetfunctions_sameAddress(&ieee802514_header->src,&packetSent->l2_nextORpreviousHop);
*/
// poipoi don't check for seq num
return ieee802514_header->valid==TRUE && \
ieee802514_header->frameType==IEEE154_TYPE_ACK && \
packetfunctions_sameAddress(&ieee802514_header->panid,idmanager_getMyID(ADDR_PANID)) && \
idmanager_isMyAddress(&ieee802514_header->dest) && \
packetfunctions_sameAddress(&ieee802514_header->src,&packetSent->l2_nextORpreviousHop);
}
//======= ASN handling
port_INLINE void incrementAsnOffset() {
// increment the asn
ieee154e_vars.asn.bytes0and1++;
if (ieee154e_vars.asn.bytes0and1==0) {
ieee154e_vars.asn.bytes2and3++;
if (ieee154e_vars.asn.bytes2and3==0) {
ieee154e_vars.asn.byte4++;
}
}
// increment the offsets
ieee154e_vars.slotOffset = (ieee154e_vars.slotOffset+1)%schedule_getFrameLength();
ieee154e_vars.asnOffset = (ieee154e_vars.asnOffset+1)%16;
if (ieee154e_vars.slotOffset%2==0){
// printf("SlotOffset %d \n", ieee154e_vars.slotOffset);
}
}
port_INLINE void asnWriteToAdv(OpenQueueEntry_t* advFrame) {
advFrame->l2_payload[0] = (ieee154e_vars.asn.bytes0and1 & 0xff);
advFrame->l2_payload[1] = (ieee154e_vars.asn.bytes0and1/256 & 0xff);
advFrame->l2_payload[2] = (ieee154e_vars.asn.bytes2and3 & 0xff);
advFrame->l2_payload[3] = (ieee154e_vars.asn.bytes2and3/256 & 0xff);
advFrame->l2_payload[4] = ieee154e_vars.asn.byte4;
/* piggy313: insert local_mask to ADV */
advFrame->l2_payload[5] = (uint8_t)(local_t_mask&0x00ff); //lower half
advFrame->l2_payload[6] = (uint8_t)((local_t_mask&0xff00)>>8); //upper half
}
port_INLINE void asnStoreFromAdv(OpenQueueEntry_t* advFrame) {
// store the ASN
ieee154e_vars.asn.bytes0and1 = ieee154e_vars.dataReceived->payload[0]+
256*ieee154e_vars.dataReceived->payload[1];
ieee154e_vars.asn.bytes2and3 = ieee154e_vars.dataReceived->payload[2]+
256*ieee154e_vars.dataReceived->payload[3];
ieee154e_vars.asn.byte4 = ieee154e_vars.dataReceived->payload[4];
// determine the current slotOffset
/*
Note: this is a bit of a hack. Normally, slotOffset=ASN%slotlength. But since
the ADV is exchanged in slot 0, we know that we're currently at slotOffset==0
*/
ieee154e_vars.slotOffset = 0;
schedule_syncSlotOffset(ieee154e_vars.slotOffset);
ieee154e_vars.nextActiveSlotOffset = schedule_getNextActiveSlotOffset();
/*
infer the asnOffset based on the fact that
ieee154e_vars.freq = 11 + (asnOffset + channelOffset)%16
*/
ieee154e_vars.asnOffset = ieee154e_vars.freq - 11 - schedule_getChannelOffset();
}
//======= synchronization
void synchronizePacket(PORT_TIMER_WIDTH timeReceived) {
PORT_SIGNED_INT_WIDTH timeCorrection;
PORT_TIMER_WIDTH newPeriod;
PORT_TIMER_WIDTH currentValue;
PORT_TIMER_WIDTH currentPeriod;
// record the current timer value and period
currentValue = radio_getTimerValue();
currentPeriod = radio_getTimerPeriod();
// calculate new period
timeCorrection = (PORT_SIGNED_INT_WIDTH)((PORT_SIGNED_INT_WIDTH)timeReceived-(PORT_SIGNED_INT_WIDTH)TsTxOffset);
newPeriod = TsSlotDuration;
// detect whether I'm too close to the edge of the slot, in that case,
// skip a slot and increase the temporary slot length to be 2 slots long
if (currentValue<timeReceived || currentPeriod-currentValue<RESYNCHRONIZATIONGUARD) {
newPeriod += TsSlotDuration;
incrementAsnOffset();
}
newPeriod = (PORT_TIMER_WIDTH)((PORT_SIGNED_INT_WIDTH)newPeriod+timeCorrection);
radio_setTimerPeriod(newPeriod);
ieee154e_vars.deSyncTimeout = DESYNCTIMEOUT;
//printf("new period set %d %\n",newPeriod );
// update statistics
ieee154e_dbg.synckpkt++;
updateStats(timeCorrection);
}
void synchronizeAck(PORT_SIGNED_INT_WIDTH timeCorrection) {
PORT_TIMER_WIDTH newPeriod;
PORT_TIMER_WIDTH currentPeriod;
// resynchronize
currentPeriod = radio_getTimerPeriod();
newPeriod = (PORT_TIMER_WIDTH)((PORT_SIGNED_INT_WIDTH)currentPeriod-timeCorrection);
radio_setTimerPeriod(newPeriod);
ieee154e_vars.deSyncTimeout = DESYNCTIMEOUT;
// update statistics
ieee154e_dbg.synckack++;
updateStats(timeCorrection);
}
void changeIsSync(bool newIsSync) {
ieee154e_vars.isSync = newIsSync;
if (ieee154e_vars.isSync==TRUE) {
leds_sync_on();
resetStats();
} else {
leds_sync_off();
//TODO, this is a workaround as while it is not synch the queue does not reset, so it keeps growing.
openqueue_removeAll();//reset the queue to avoid filling it while it is not connected.
}
}
//======= notifying upper layer
void notif_sendDone(OpenQueueEntry_t* packetSent, error_t error) {
// record the outcome of the trasmission attempt
packetSent->l2_sendDoneError = error;
// record the current ASN
memcpy(&packetSent->l2_asn,&ieee154e_vars.asn,sizeof(asn_t));
// associate this packet with the virtual component
// COMPONENT_IEEE802154E_TO_RES so RES can knows it's for it
packetSent->owner = COMPONENT_IEEE802154E_TO_RES;
// post RES's sendDone task
scheduler_push_task(task_resNotifSendDone,TASKPRIO_RESNOTIF_TXDONE);
// wake up the scheduler
SCHEDULER_WAKEUP();
}
void notif_receive(OpenQueueEntry_t* packetReceived) {
// record the current ASN
memcpy(&packetReceived->l2_asn, &ieee154e_vars.asn, sizeof(asn_t));
// indicate reception to the schedule, to keep statistics
schedule_indicateRx(&packetReceived->l2_asn);
// associate this packet with the virtual component
// COMPONENT_IEEE802154E_TO_RES so RES can knows it's for it
packetReceived->owner = COMPONENT_IEEE802154E_TO_RES;
// post RES's Receive task
scheduler_push_task(task_resNotifReceive,TASKPRIO_RESNOTIF_RX);
// wake up the scheduler
SCHEDULER_WAKEUP();
}
//======= stats
port_INLINE void resetStats() {
ieee154e_stats.syncCounter = 0;
ieee154e_stats.minCorrection = 127;
ieee154e_stats.maxCorrection = -127;
// do not reset the number of de-synchronizations
}
void updateStats(PORT_SIGNED_INT_WIDTH timeCorrection) {
ieee154e_stats.correction[ieee154e_stats.num_sync%10]=timeCorrection;
ieee154e_stats.num_sync++;
ieee154e_stats.syncCounter++;
if (timeCorrection<ieee154e_stats.minCorrection) {
ieee154e_stats.minCorrection = timeCorrection;
}
if(timeCorrection>ieee154e_stats.maxCorrection) {
ieee154e_stats.maxCorrection = timeCorrection;
}
}
//======= misc
/**
\brief Calculates the frequency channel to transmit on, based on the
absolute slot number and the channel offset of the requested slot.
During normal operation, the frequency used is a function of the
channelOffset indicating in the schedule, and of the ASN of the
slot. This ensures channel hopping, consecutive packets sent in the same slot
in the schedule are done on a difference frequency channel.
During development, you can force single channel operation by having this
function return a constant channel number (between 11 and 26). This allows you
to use a single-channel sniffer; but you can not schedule two links on two
different channel offsets in the same slot.
\param [in] channelOffset channel offset for the current slot
\returns The calculated frequency channel, an integer between 11 and 26.
*/
port_INLINE uint8_t calculateFrequency(uint8_t channelOffset) {
//return 11+(asn+channelOffset)%16;
// poipoi: no channel hopping
// return 26;
//return 11+(ieee154e_vars.asnOffset+channelOffset)%16; //channel hopping
/* piggy314: check blacklist and generate new channel if neccessary */
uint8_t temp_channel = 11+(ieee154e_vars.asnOffset+channelOffset)%16;
if((schedule_getType()!=CELLTYPE_NF)&&(schedule_getType()!=CELLTYPE_ADV)){
if(!ieee154e_vars.linkArray[temp_channel-11]){
temp_channel=nextAvail(temp_channel-11);
}
}
return temp_channel;
}
/* piggy315: come up with next usable channel */
port_INLINE uint8_t nextAvail(uint8_t channel){
for(int8_t i=1; i<16; i++){
uint8_t temp=(channel+i)%16;
if(ieee154e_vars.linkArray[temp]==1){
return temp+11;
}
}
return SYNCHRONIZING_CHANNEL;
}
/**
\brief Changes the state of the IEEE802.15.4e FSM.
Besides simply updating the state global variable,
this function toggles the FSM debug pin.
\param [in] newstate The state the IEEE802.15.4e FSM is now in.
*/
void changeState(ieee154e_state_t newstate) {
// update the state
ieee154e_vars.state = newstate;
// wiggle the FSM debug pin
switch (ieee154e_vars.state) {
case S_SYNCLISTEN:
case S_TXDATAOFFSET:
debugpins_fsm_set();
// debugpins_frame_toggle();
break;
case S_SLEEP:
case S_RXDATAOFFSET:
debugpins_fsm_clr();
break;
case S_SYNCRX:
case S_SYNCPROC:
case S_TXDATAPREPARE:
case S_TXDATAREADY:
case S_TXDATADELAY:
case S_TXDATA:
case S_RXACKOFFSET:
case S_RXACKPREPARE:
case S_RXACKREADY:
case S_RXACKLISTEN:
case S_RXACK:
case S_TXPROC:
case S_RXDATAPREPARE:
case S_RXDATAREADY:
case S_RXDATALISTEN:
case S_RXDATA:
case S_TXACKOFFSET:
case S_TXACKPREPARE:
case S_TXACKREADY:
case S_TXACKDELAY:
case S_TXACK:
case S_RXPROC:
debugpins_fsm_toggle();
break;
}
}
/**
\brief Housekeeping tasks to do at the end of each slot.
This functions is called once in each slot, when there is nothing more
to do. This might be when an error occured, or when everything went well.
This function resets the state of the FSM so it is ready for the next slot.
Note that by the time this function is called, any received packet should already
have been sent to the upper layer. Similarly, in a Tx slot, the sendDone
function should already have been done. If this is not the case, this function
will do that for you, but assume that something went wrong.
*/
void endSlot() {
// turn off the radio
radio_rfOff();
// clear any pending timer
radiotimer_cancel();
// reset capturedTimes
ieee154e_vars.lastCapturedTime = 0;
ieee154e_vars.syncCapturedTime = 0;
// clean up dataToSend
if (ieee154e_vars.dataToSend!=NULL) {
// if everything went well, dataToSend was set to NULL in ti9
// getting here means transmit failed
// indicate Tx fail to schedule to update stats
schedule_indicateTx(&ieee154e_vars.asn,FALSE);
//decrement transmits left counter
ieee154e_vars.dataToSend->l2_retriesLeft--;
if (ieee154e_vars.dataToSend->l2_retriesLeft==0) {
// indicate tx fail if no more retries left
notif_sendDone(ieee154e_vars.dataToSend,E_FAIL);
} else {
// return packet to the virtual COMPONENT_RES_TO_IEEE802154E component
ieee154e_vars.dataToSend->owner = COMPONENT_RES_TO_IEEE802154E;
}
// reset local variable
ieee154e_vars.dataToSend = NULL;
}
// clean up dataReceived
if (ieee154e_vars.dataReceived!=NULL) {
// assume something went wrong. If everything went well, dataReceived
// would have been set to NULL in ri9.
// indicate "received packet" to upper layer since we don't want to loose packets
notif_receive(ieee154e_vars.dataReceived);
// reset local variable
ieee154e_vars.dataReceived = NULL;
}
// clean up ackToSend
if (ieee154e_vars.ackToSend!=NULL) {
// free ackToSend so corresponding RAM memory can be recycled
openqueue_freePacketBuffer(ieee154e_vars.ackToSend);
// reset local variable
ieee154e_vars.ackToSend = NULL;
}
// clean up ackReceived
if (ieee154e_vars.ackReceived!=NULL) {
// free ackReceived so corresponding RAM memory can be recycled
openqueue_freePacketBuffer(ieee154e_vars.ackReceived);
// reset local variable
ieee154e_vars.ackReceived = NULL;
}
// change state
changeState(S_SLEEP);
}
bool ieee154e_isSynch(){
return ieee154e_vars.isSync;
}
/* piggy307b: triggered NF NF probe activities */
inline void activity_np1(){ //comparable to ri2 - employing Rx up til rxEnable
changeState(S_NPPREPARE); //derived from S_RXDATAPREPARE, triggering npe1
ieee154e_vars.freq = calculateFrequency(schedule_getChannelOffset());
//must be called before RF gets enabled
radio_setFrequency(ieee154e_vars.freq);
// enable the radio in Rx mode. The radio does not actively listen yet.
radio_rxEnable();
// arm rt2
radiotimer_schedule(DURATION_rt2); //triggers npe1
// change state
changeState(S_NPREADY); //S_RXDATAREADY
}
//didn't have enough time to prepare to receive (rie1)
inline void activity_npe1() {
// log the error
openserial_printError(COMPONENT_IEEE802154E,ERR_MAXRXDATAPREPARE_OVERFLOWS,
(errorparameter_t)ieee154e_vars.state,
(errorparameter_t)ieee154e_vars.slotOffset);
// abort
endSlot();
}
inline void activity_np2(){ //ri3
changeState(S_NPSTART);
int8_t size = 6; //blacklist size for debugging
startProbeSlot(ieee154e_vars.freq, size); // 6 is the default bl size
//we hereby assume noise probe always finishes in time
//rie2 not needed because we don't actually want to receive packet at all
//operations later on will be triggered in noiseprobe.c
}
//notified by probe
inline void activity_np3(uint16_t masked){
//piggy34: update local_t_mask (to the negation of masked, comment together with sendUp to disable BL)
local_t_mask = ~masked; //comment to nullify local NF results
//will be transfered to local_mask once ADV has been constructed,
//since next ADV is at most 1 slot before BLKA
endSlot();
}
/* piggy316b: apply downstream temp mask */
void applyRxMask(){
local_RxMask = local_t_mask;
//memcpy(local_arr,local_t_arr,sizeof(local_t_arr));
}
/* piggy312b: manipulate received payload if data */
void handleRecvPkt(OpenQueueEntry_t* pkt){
//only alter payload of APP layer pkts
if((ieee154e_vars.dataReceived->l2_frameType==IEEE154_TYPE_DATA)&&(((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->start==0xED))
{
memcpy(&(((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->asn[0]),(uint8_t*)(&(ieee154e_vars.asn.byte4)),sizeof(uint8_t));
memcpy(&(((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->asn[1]),(uint8_t*)(&(ieee154e_vars.asn.bytes2and3)),sizeof(uint16_t));
memcpy(&(((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->asn[3]),(uint8_t*)(&(ieee154e_vars.asn.bytes0and1)),sizeof(uint16_t));
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->channel = ieee154e_vars.freq;
//((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->rssi = pkt->l1_rssi;
//((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->recasnOffset = ieee154e_vars.asnOffset;
//link-mask (current), for the purpose of display at DAGroot
//if (!idmanager_getIsDAGroot()){ //only replace payload before reaching DAGroot
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->Rmask.pos[0] = (uint8_t)((ieee154e_vars.linkMask & 0xff00)>>8);
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->Rmask.pos[1] = (uint8_t)((ieee154e_vars.linkMask & 0x00ff)>>0);
//}
/* Mask-relate dubug
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->mask.pos[0] = (uint8_t)((local_t_mask & 0xff00)>>8);
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->mask.pos[1] = (uint8_t)((local_t_mask & 0x00ff)>>0);
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->recvlocal.pos[0] = (uint8_t)((local_RxMask & 0xff00)>>8);
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->recvlocal.pos[1] = (uint8_t)((local_RxMask & 0x00ff)>>0);
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->recvlink.pos[0] = (uint8_t)(((neighbors_getMask(&ieee154e_vars.otherEnd)) & 0xff00)>>8);
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->recvlink.pos[1] = (uint8_t)(((neighbors_getMask(&ieee154e_vars.otherEnd)) & 0x00ff)>>0);
*/
/* linkArray
for(int8_t i=0; i<16; i++){
((demo_t*)(pkt->payload + pkt->length - sizeof(demo_t)))->temp.arr[i] = ieee154e_vars.linkArray[i];
}*/
}
}
/* piggy317b: manipulate outgoing payload if from BBK */
//----sending payload insertion (the "2" denote 2-byte footer)----*/
void insertOutgoing(OpenQueueEntry_t* pkt){
switch (pkt->l2_frameType)
{
case IEEE154_TYPE_DATA:
if((pkt->creator==COMPONENT_BBK))
{
/*memcpy(&(((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->asn[0]),(uint8_t*)(&(ieee154e_vars.asn.byte4)),sizeof(uint8_t));
memcpy(&(((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->asn[1]),(uint8_t*)(&(ieee154e_vars.asn.bytes2and3)),sizeof(uint16_t));
memcpy(&(((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->asn[3]),(uint8_t*)(&(ieee154e_vars.asn.bytes0and1)),sizeof(uint16_t));
((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->channel = ieee154e_vars.freq;*/
//((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->sent.pos[0] = (uint8_t)((parentM & 0xff00)>>8);
//((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->sent.pos[1] = (uint8_t)((parentM & 0x00ff)>>0);
/*//linkArray
for(int8_t i=0; i<16; i++){
((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->temp.arr[i] = ieee154e_vars.linkArray[i];
}*/
//((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->sentasnOffset = ieee154e_vars.asnOffset;
((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->parent=neighbors_getMaster()->addr_64b[7];
/* Mask-relate dubug */
//piggy36a: sender's own temp_mask (so that receiver can learn)
((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->Smask.pos[0] = (uint8_t)((ieee154e_vars.linkMask & 0xff00)>>8);
((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->Smask.pos[1] = (uint8_t)((ieee154e_vars.linkMask & 0x00ff)>>0);
//((demo_t*)(pkt->payload + pkt->length -2- sizeof(demo_t)))->Smask.pos[1] = get_temp(); // debug only
//((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->Smask.pos[0] = (uint8_t)((ieee154e_vars.parentM & 0xff00)>>8);
//((demo_t*)(pkt->payload + pkt->length -2 - sizeof(demo_t)))->Smask.pos[1] = (uint8_t)((ieee154e_vars.parentM & 0x00ff)>>0);
}
break;
}
}
| [
"peng@dcs-bbk-ac-uk"
] | peng@dcs-bbk-ac-uk |
f54c2075455dbbae2bebf1dc6bdcb6c15f0e2f4e | 8e1691fa76f47c62bbf6b8d83f5d5f13647aacaf | /GPIO_ThreadX/synergy_cfg/ssp_cfg/bsp/bsp_clock_cfg.h | 47a403f5d281372a9704d146efcf5db92c174ae8 | [] | no_license | dongdong-2009/Renesas_S7G2 | 4c9933a2ef29d1057c4f1493aaed0906b6612501 | 86379eb843825975a3c2f8b01efe91b93f6167ec | refs/heads/master | 2021-07-04T19:02:16.126614 | 2017-09-25T01:15:45 | 2017-09-25T01:15:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,122 | h | /* generated configuration header file - do not edit */
#ifndef BSP_CLOCK_CFG_H_
#define BSP_CLOCK_CFG_H_
#define BSP_CFG_XTAL_HZ (24000000) /* XTAL 24000000Hz */
#define BSP_CFG_PLL_SOURCE (CGC_CLOCK_MAIN_OSC) /* PLL Src: XTAL */
#define BSP_CFG_HOCO_FREQUENCY (0) /* HOCO 16MHz */
#define BSP_CFG_PLL_DIV (CGC_PLL_DIV_2) /* PLL Div /2 */
#define BSP_CFG_PLL_MUL (20.0) /* PLL Mul x20.0 */
#define BSP_CFG_CLOCK_SOURCE (CGC_CLOCK_PLL) /* Clock Src: PLL */
#define BSP_CFG_ICK_DIV (CGC_SYS_CLOCK_DIV_1) /* ICLK Div /1 */
#define BSP_CFG_PCKA_DIV (CGC_SYS_CLOCK_DIV_2) /* PCLKA Div /2 */
#define BSP_CFG_PCKB_DIV (CGC_SYS_CLOCK_DIV_4) /* PCLKB Div /4 */
#define BSP_CFG_PCKC_DIV (CGC_SYS_CLOCK_DIV_4) /* PCLKC Div /4 */
#define BSP_CFG_PCKD_DIV (CGC_SYS_CLOCK_DIV_2) /* PCLKD Div /2 */
#define BSP_CFG_SDCLK_OUTPUT (1) /* SDCLKout On */
#define BSP_CFG_BCK_DIV (CGC_SYS_CLOCK_DIV_2) /* BCLK Div /2 */
#define BSP_CFG_BCLK_OUTPUT (2) /* BCK/2 */
#define BSP_CFG_UCK_DIV (CGC_USB_CLOCK_DIV_5) /* UCLK Div /5 */
#define BSP_CFG_FCK_DIV (CGC_SYS_CLOCK_DIV_4) /* FCLK Div /4 */
#endif /* BSP_CLOCK_CFG_H_ */
| [
"kirti.karan25@gmail.com"
] | kirti.karan25@gmail.com |
69592f2dc75838a09e32f2e4d47432f29a2a9e95 | 8edcb002c921eca7d5ced967dd6dd22ffd224832 | /lib/FunWithLEDs/WS281xLib.cylib/StripLights_v3_0/API/SLights.h | 11baa85f7546f026641d829d4118bae1b53bf4bc | [] | no_license | TranDNNguyen/wonder-wall | c109132e273608106f034f3ff43059de17de9662 | 358e0e6aaf418054e2a567c8463f83dcfac88e1e | refs/heads/master | 2020-03-25T03:39:06.318100 | 2018-08-02T23:03:53 | 2018-08-02T23:03:53 | 143,352,675 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 14,506 | h | /* ========================================
*
* Strip Light Controller
* By Mark Hastings
*
* 05/27/2013 v1.0 Mark Hastings Initial working version
* 12/11/2013 v2.6 Mark Hastings Update for SK2812
*
* ========================================
*/
#if (!defined(CY_SLIGHTS_`$INSTANCE_NAME`_H))
#define CY_SLIGHTS_`$INSTANCE_NAME`_H
#include "cytypes.h"
#include "cyfitter.h"
typedef void(*funcPtr)(void);
/* Function Prototypes */
void `$INSTANCE_NAME`_Start(void);
void `$INSTANCE_NAME`_Stop(void);
void `$INSTANCE_NAME`_WriteColor(uint32 color);
void `$INSTANCE_NAME`_DisplayClear(uint32 color);
void `$INSTANCE_NAME`_MemClear(uint32 color);
void `$INSTANCE_NAME`_Trigger(uint32 rst);
uint32 `$INSTANCE_NAME`_Ready(void);
void `$INSTANCE_NAME`_SetCriticalFuncs(funcPtr EnCriticalFunc, funcPtr ExCriticalFunc);
void `$INSTANCE_NAME`_TriggerWait(uint32 rst);
void `$INSTANCE_NAME`_TriggerWaitDelay(uint32 delay);
void `$INSTANCE_NAME`_DrawRect(int32 x0, int32 y0, int32 x1, int32 y1, int32 fill, uint32 color);
void `$INSTANCE_NAME`_DrawLine(int32 x0, int32 y0, int32 x1, int32 y1, uint32 color);
void `$INSTANCE_NAME`_DrawCircle (int32 x0, int32 y0, int32 radius, uint32 color);
void `$INSTANCE_NAME`_Pixel(int32 x, int32 y, uint32 color);
uint32 `$INSTANCE_NAME`_GetPixel(int32 x, int32 y);
uint32 `$INSTANCE_NAME`_ColorInc(uint32 incValue);
void `$INSTANCE_NAME`_Dim(uint32 dimLevel);
uint32 `$INSTANCE_NAME`_getColor( uint32 color);
void `$INSTANCE_NAME`_Bplot8( int32 x, int32 y, uint8 * bitMap, int32 update);
void `$INSTANCE_NAME`_Bplot32( int32 x, int32 y, uint32 * bitMap, int32 update);
uint32 `$INSTANCE_NAME`_RgbBlend(uint32 fromColor, uint32 toColor, uint32 pct);
#define `$INSTANCE_NAME`_DimLevel_0 0
#define `$INSTANCE_NAME`_DimLevel_1 1
#define `$INSTANCE_NAME`_DimLevel_2 2
#define `$INSTANCE_NAME`_DimLevel_3 3
#define `$INSTANCE_NAME`_DimLevel_4 4
#define `$INSTANCE_NAME`_READY_TIMEOUT 200 // 200 milliseconds (6000 LEDs)
#define `$INSTANCE_NAME`_CIRQ_Enable() CyIntEnable(`$INSTANCE_NAME`_CIRQ__INTC_NUMBER );
#define `$INSTANCE_NAME`_CIRQ_Disable() CyIntDisable(`$INSTANCE_NAME`_CIRQ__INTC_NUMBER );
CY_ISR_PROTO(`$INSTANCE_NAME`_CISR);
#define `$INSTANCE_NAME`_FIRQ_Enable() CyIntEnable(`$INSTANCE_NAME`_FIRQ__INTC_NUMBER );
#define `$INSTANCE_NAME`_FIRQ_Disable() CyIntDisable(`$INSTANCE_NAME`_FIRQ__INTC_NUMBER );
CY_ISR_PROTO(`$INSTANCE_NAME`_FISR);
/* Register Definitions */
#define `$INSTANCE_NAME`_DATA (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_dshifter_u0__F0_REG)
#define `$INSTANCE_NAME`_DATA_PTR ((reg8 *) `$INSTANCE_NAME`_B_WS2811_dshifter_u0__F0_REG)
#define `$INSTANCE_NAME`_CONTROL (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_ctrl__CONTROL_REG)
#define `$INSTANCE_NAME`_STATUS (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_StatusReg__STATUS_REG)
#define `$INSTANCE_NAME`_Period (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__F0_REG)
#define `$INSTANCE_NAME`_Period_PTR ((reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__F0_REG)
#define `$INSTANCE_NAME`_Compare0 (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__D0_REG)
#define `$INSTANCE_NAME`_Compare1 (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__D1_REG)
#define `$INSTANCE_NAME`_Period2 (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__F1_REG)
#define `$INSTANCE_NAME`_Period2_PTR ((reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__F1_REG)
#define `$INSTANCE_NAME`_ACTL0_REG (*(reg8 *) `$INSTANCE_NAME`_B_WS2811_pwm8_u0__DP_AUX_CTL_REG)
#define `$INSTANCE_NAME`_DISABLE_FIFO 0x03
#define `$INSTANCE_NAME`_Channel (*(reg8 *) `$INSTANCE_NAME`_StringSel_Sync_ctrl_reg__CONTROL_REG)
#define `$INSTANCE_NAME`_Channel_PTR ((reg8 *) `$INSTANCE_NAME`_StringSel_Sync_ctrl_reg__CONTROL_REG)
/* Status Register Constants */
#define `$INSTANCE_NAME`_FIFO_EMPTY 0x01
#define `$INSTANCE_NAME`_FIFO_NOT_FULL 0x02
#define `$INSTANCE_NAME`_STATUS_ENABLE 0x80
#define `$INSTANCE_NAME`_STATUS_XFER_CMPT 0x40
/* Control Register Constants */
#define `$INSTANCE_NAME`_ENABLE 0x01
#define `$INSTANCE_NAME`_DISABLE 0x00
#define `$INSTANCE_NAME`_RESTART 0x02
#define `$INSTANCE_NAME`_CNTL 0x04
#define `$INSTANCE_NAME`_FIFO_IRQ_EN 0x08
#define `$INSTANCE_NAME`_XFRCMPT_IRQ_EN 0x10
#define `$INSTANCE_NAME`_ALL_IRQ_EN 0x18
#define `$INSTANCE_NAME`_NEXT_ROW 0x20
#define `$INSTANCE_NAME`_TRANSFER `$Transfer_Method`
#define `$INSTANCE_NAME`_TRANSFER_FIRMWARE 0
#define `$INSTANCE_NAME`_TRANSFER_ISR 1
#define `$INSTANCE_NAME`_TRANSFER_DMA 2
#define `$INSTANCE_NAME`_SPEED `$Speed`
#define `$INSTANCE_NAME`_SPEED_400KHZ 0
#define `$INSTANCE_NAME`_SPEED_800KHZ 1
#define `$INSTANCE_NAME`_MEMORY_TYPE `$Display_Memory`
#define `$INSTANCE_NAME`_MEMORY_RGB 0
#define `$INSTANCE_NAME`_MEMORY_LUT 1
#define `$INSTANCE_NAME`_GAMMA_CORRECTION `$Gamma_Correction`
#define `$INSTANCE_NAME`_GAMMA_ON 1
#define `$INSTANCE_NAME`_GAMMA_OFF 0
#define `$INSTANCE_NAME`_COORD_WRAP `$Coord_Wrap`
#define `$INSTANCE_NAME`_COORD_NONE (0u)
#define `$INSTANCE_NAME`_COORD_XAXIS (1u)
#define `$INSTANCE_NAME`_COORD_YAXIS (2u)
#define `$INSTANCE_NAME`_COORD_XYAXIS (3u)
#define `$INSTANCE_NAME`_LED_LAYOUT `$LED_Config`
#define `$INSTANCE_NAME`_LED_LAYOUT_STANDARD (0u)
#define `$INSTANCE_NAME`_LED_LAYOUT_SPIRAL (1u)
#define `$INSTANCE_NAME`_LED_LAYOUT_GRID16X16 (2u)
#define `$INSTANCE_NAME`_FLIP_X_COORD `$Flip_X_Coord`
#define `$INSTANCE_NAME`_FLIP_Y_COORD `$Flip_Y_Coord`
#define `$INSTANCE_NAME`_FLIP_COORD (1u)
#define `$INSTANCE_NAME`_NOT_FLIP_COORD (0u)
#define `$INSTANCE_NAME`_SWAP_XY_COORD `$Swap_X_Y`
#define `$INSTANCE_NAME`_XY_SWAPED (1u)
#if (`$INSTANCE_NAME`_SPEED_800KHZ)
#define `$INSTANCE_NAME`_BYTE_TIME_US 10u
#define `$INSTANCE_NAME`_WORD_TIME_US 30u
#else
#define `$INSTANCE_NAME`_BYTE_TIME_US 20u
#define `$INSTANCE_NAME`_WORD_TIME_US 60u
#endif
#define `$INSTANCE_NAME`_GRIDMODE_NORMAL 1
#define `$INSTANCE_NAME`_GRIDMODE_WRAP 0
#if (`$INSTANCE_NAME`_LED_LAYOUT == `$INSTANCE_NAME`_LED_LAYOUT_STANDARD)
#define `$INSTANCE_NAME`_COLUMNS `$LEDs_per_Strip`
#define `$INSTANCE_NAME`_ROWS `$LedChannels`
#define `$INSTANCE_NAME`_TOTAL_LEDS (`$INSTANCE_NAME`_COLUMNS*`$INSTANCE_NAME`_ROWS)
#define `$INSTANCE_NAME`_ARRAY_COLS (int32)(`$LEDs_per_Strip`)
#define `$INSTANCE_NAME`_ARRAY_ROWS (int32)(`$LedChannels`)
#define `$INSTANCE_NAME`_MIN_X (int32)0u
#define `$INSTANCE_NAME`_MAX_X (int32)(`$INSTANCE_NAME`_COLUMNS - 1)
#define `$INSTANCE_NAME`_MIN_Y (int32)0u
#define `$INSTANCE_NAME`_MAX_Y (int32)(`$INSTANCE_NAME`_ROWS - 1)
#elif (`$INSTANCE_NAME`_LED_LAYOUT == `$INSTANCE_NAME`_LED_LAYOUT_SPIRAL)
#define `$INSTANCE_NAME`_COLUMNS `$String_Wrap_Length`
#define `$INSTANCE_NAME`_ROWS ((`$LEDs_per_Strip` + (`$String_Wrap_Length` - 1 ))/(`$String_Wrap_Length` ) )
#define `$INSTANCE_NAME`_TOTAL_LEDS `$LEDs_per_Strip`
#define `$INSTANCE_NAME`_ARRAY_COLS (int32)(`$LEDs_per_Strip` + `$String_Wrap_Length`)
#define `$INSTANCE_NAME`_ARRAY_ROWS (int32)(1u)
#define `$INSTANCE_NAME`_MIN_X (int32)0u
#define `$INSTANCE_NAME`_MAX_X (int32)(`$INSTANCE_NAME`_COLUMNS - 1)
#define `$INSTANCE_NAME`_MIN_Y (int32)0u
#define `$INSTANCE_NAME`_MAX_Y (int32)(`$INSTANCE_NAME`_ROWS - 1)
#elif (`$INSTANCE_NAME`_LED_LAYOUT == `$INSTANCE_NAME`_LED_LAYOUT_GRID16X16)
#define `$INSTANCE_NAME`_COLUMNS (int32)((`$Grid_16x16_Columns`) * (uint32)(16u) )
#define `$INSTANCE_NAME`_ROWS (int32)((`$Grid_16x16_Rows`) * (uint32)(16u) )
#define `$INSTANCE_NAME`_TOTAL_LEDS (`$INSTANCE_NAME`_COLUMNS*`$INSTANCE_NAME`_ROWS)
#define `$INSTANCE_NAME`_ARRAY_COLS (int32)(`$Grid_16x16_Columns`*(int32)256)
#define `$INSTANCE_NAME`_ARRAY_ROWS (int32)(`$Grid_16x16_Rows`)
#define `$INSTANCE_NAME`_MIN_X (int32)0
#define `$INSTANCE_NAME`_MAX_X (int32)((`$Grid_16x16_Columns`*(int32)16) - (int32)1)
#define `$INSTANCE_NAME`_MIN_Y (int32)0
#define `$INSTANCE_NAME`_MAX_Y (int32)((`$Grid_16x16_Rows`*(int32)16) - (int32)1)
#endif
#define `$INSTANCE_NAME`_CHIP (`$WS281x_Type`)
#define `$INSTANCE_NAME`_CHIP_WS2811 1
#define `$INSTANCE_NAME`_CHIP_WS2812 2
#define `$INSTANCE_NAME`_CHIP_SF2812RGBW 3
#define `$INSTANCE_NAME`_TIME_TL_TH 1250U // 1250 us period
#if((`$INSTANCE_NAME`_CHIP == `$INSTANCE_NAME`_CHIP_WS2812) || (`$INSTANCE_NAME`_CHIP == `$INSTANCE_NAME`_CHIP_WS2811))
#define `$INSTANCE_NAME`_TIME_T0H 300U // Logic 0 high, 300 us
#define `$INSTANCE_NAME`_TIME_T1H 700U // Logic 1 low, 700 us
#else
#define `$INSTANCE_NAME`_TIME_T0H 300U // Logic 0 high, 300 us
#define `$INSTANCE_NAME`_TIME_T1H 650U // Logic 1 low, 700 us
#endif
#if (CY_PSOC3 || CY_PSOC5LP)
#define `$INSTANCE_NAME`_INPUT_CLOCK BCLK__BUS_CLK__KHZ
#define `$INSTANCE_NAME`_WS281X_CLOCK `$ClockSpeedKhz`
#define `$INSTANCE_NAME`_PERIOD ((`$INSTANCE_NAME`_INPUT_CLOCK)/`$ClockSpeedKhz`)
#elif (CY_PSOC4)
#define `$INSTANCE_NAME`_INPUT_CLOCK ( CYDEV_BCLK__HFCLK__KHZ/2 )
#define `$INSTANCE_NAME`_PERIOD ((`$INSTANCE_NAME`_INPUT_CLOCK)/`$ClockSpeedKhz`)
#define `$INSTANCE_NAME`_DATA_ZERO ((`$INSTANCE_NAME`_PERIOD * `$INSTANCE_NAME`_TIME_T0H)/`$INSTANCE_NAME`_TIME_TL_TH)
#define `$INSTANCE_NAME`_DATA_ONE ((`$INSTANCE_NAME`_PERIOD * `$INSTANCE_NAME`_TIME_T1H)/`$INSTANCE_NAME`_TIME_TL_TH)
#define `$INSTANCE_NAME`_COMPARE_ZERO (`$INSTANCE_NAME`_PERIOD - `$INSTANCE_NAME`_DATA_ZERO)
#define `$INSTANCE_NAME`_COMPARE_ONE (`$INSTANCE_NAME`_PERIOD - `$INSTANCE_NAME`_DATA_ONE)
#endif /* CY_PSOC5A */
#define `$INSTANCE_NAME`_COLOR_WHEEL_SIZE 24
#if(`$INSTANCE_NAME`_CHIP == `$INSTANCE_NAME`_CHIP_WS2812)
#define `$INSTANCE_NAME`_RED_MASK 0x0000FF00
#define `$INSTANCE_NAME`_GREEN_MASK 0x000000FF
#define `$INSTANCE_NAME`_BLUE_MASK 0x00FF0000
#else
#define `$INSTANCE_NAME`_RED_MASK 0x000000FF
#define `$INSTANCE_NAME`_GREEN_MASK 0x0000FF00
#define `$INSTANCE_NAME`_BLUE_MASK 0x00FF0000
#endif
#define `$INSTANCE_NAME`_CWHEEL_SIZE 24
#define `$INSTANCE_NAME`_YELLOW `$INSTANCE_NAME`_getColor(1)
#define `$INSTANCE_NAME`_GREEN `$INSTANCE_NAME`_getColor((70 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_ORANGE `$INSTANCE_NAME`_getColor(20)
#define `$INSTANCE_NAME`_BLACK `$INSTANCE_NAME`_getColor((0 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_OFF `$INSTANCE_NAME`_getColor((0 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_LTBLUE `$INSTANCE_NAME`_getColor((1 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_MBLUE `$INSTANCE_NAME`_getColor((2 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_BLUE `$INSTANCE_NAME`_getColor((3 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_LTGREEN `$INSTANCE_NAME`_getColor((4 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_MGREEN `$INSTANCE_NAME`_getColor((8 + `$INSTANCE_NAME`_CWHEEL_SIZE))
//#define `$INSTANCE_NAME`_GREEN (12 + `$INSTANCE_NAME`_CWHEEL_SIZE)
#define `$INSTANCE_NAME`_LTRED `$INSTANCE_NAME`_getColor((16 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_LTYELLOW `$INSTANCE_NAME`_getColor((20 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_MGRED `$INSTANCE_NAME`_getColor((32 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_RED `$INSTANCE_NAME`_getColor((48 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_MAGENTA `$INSTANCE_NAME`_getColor((51 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_RGB_WHITE `$INSTANCE_NAME`_getColor((63 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_SPRING_GREEN `$INSTANCE_NAME`_getColor((64 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_TURQUOSE `$INSTANCE_NAME`_getColor((65 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_CYAN `$INSTANCE_NAME`_getColor((66 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_OCEAN `$INSTANCE_NAME`_getColor((67 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_VIOLET `$INSTANCE_NAME`_getColor((68 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_RASPBERRY `$INSTANCE_NAME`_getColor((69 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_DIM_WHITE `$INSTANCE_NAME`_getColor((71 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_DIM_BLUE `$INSTANCE_NAME`_getColor((72 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_INVISIBLE `$INSTANCE_NAME`_getColor((73 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_COLD_TEMP `$INSTANCE_NAME`_getColor((80 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_HOT_TEMP `$INSTANCE_NAME`_getColor((95 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_FIRE_DARK `$INSTANCE_NAME`_getColor((74 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_FIRE_LIGHT `$INSTANCE_NAME`_getColor((75 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_FULL_WHITE `$INSTANCE_NAME`_getColor((76 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_WHITE_LED `$INSTANCE_NAME`_getColor((77 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_WHITE_RGB50 `$INSTANCE_NAME`_getColor((78 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_WHITE_RGB25 `$INSTANCE_NAME`_getColor((79 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#define `$INSTANCE_NAME`_CLUT_SIZE (96 + `$INSTANCE_NAME`_CWHEEL_SIZE)
#if(`$INSTANCE_NAME`_CHIP == `$INSTANCE_NAME`_CHIP_SF2812RGBW)
#define `$INSTANCE_NAME`_WHITE `$INSTANCE_NAME`_getColor((77 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#else
#define `$INSTANCE_NAME`_WHITE `$INSTANCE_NAME`_getColor((63 + `$INSTANCE_NAME`_CWHEEL_SIZE))
#endif
#define `$INSTANCE_NAME`_RESET_DELAY_US 55
#endif /* CY_SLIGHTS_`$INSTANCE_NAME`_H */
//[] END OF FILE
| [
"tnxnguyen@ucdavis.edu"
] | tnxnguyen@ucdavis.edu |
eb3fb6c567f172783a80a420497e807dce612365 | 417f92150d503a78747433df8ee1a5d292dc06db | /sysroot/usr/include/sm/cf.h | 2ae87861af736ba1eb4677610efd63780652a626 | [] | no_license | jaykrell/tru64 | 16424e389dded7cb6386b701f4714f720bbbb699 | f4117dfdde98eb05fb5318b20c94bfdd4397b689 | refs/heads/master | 2023-06-15T04:48:06.150828 | 2021-07-10T09:35:09 | 2021-07-10T09:35:09 | 382,783,658 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 814 | h | /*
* @DEC_COPYRIGHT@
*/
/*
* HISTORY
* $Log: cf.h,v $
* Revision 1.1.2.1 2006/07/18 11:15:40 Sunilkumar_Mummigatti
* New for sendmail.v8.13.6
*
* $EndLog$
*/
/*
* @(#)$RCSfile: cf.h,v $ $Revision: 1.1.2.1 $ (DEC) $Date: 2006/07/18 11:15:40 $
*/
/*
* Copyright (c) 2001 Sendmail, Inc. and its suppliers.
* All rights reserved.
*
* By using this file, you agree to the terms and conditions set
* forth in the LICENSE file which can be found at the top level of
* the sendmail distribution.
*
* $Id: cf.h,v 1.1.2.1 2006/07/18 11:15:40 Sunilkumar_Mummigatti Exp $
*/
#ifndef SM_CF_H
# define SM_CF_H
#include <sm/gen.h>
typedef struct
{
char *opt_name;
char *opt_val;
} SM_CF_OPT_T;
extern int
sm_cf_getopt __P((
char *path,
int optc,
SM_CF_OPT_T *optv));
#endif /* ! SM_CF_H */
| [
"jay.krell@cornell.edu"
] | jay.krell@cornell.edu |
3bf632af5649b95ce27447fda133d101733659fd | 07082ae752f0156313d147c37f0186c19790a185 | /11aug8.c | 8707dab24bbac22e8e6658d03e9c8d3a16b0b321 | [] | no_license | Kunal352000/c_program | 47e15aa4ebf4b1a22cb1bb9adbf896e429721389 | 78bc925af4e353ac679992aa0f88439ed40624b9 | refs/heads/main | 2023-07-11T19:35:48.167240 | 2021-08-25T05:01:54 | 2021-08-25T05:01:54 | 376,596,272 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 134 | c | #include<stdio.h>
#define print printf
void main(){
int s[100];
print("Enter your string: ");
scanf("%[^@#$*]",s);
puts(s);
}
| [
"noreply@github.com"
] | Kunal352000.noreply@github.com |
a1456d71b2bc42ca50937f3bd75e6b135bf0d41b | b35247913bd81aeb10397090ce89c65672124c64 | /lab1/NowakAdam/cw01/zad3a/mergeFilesLib.h | 56872b7db759d606e3f8c58d213604e1a2736a6e | [] | no_license | youngdashu/systemy-operacyjne-2020-2021 | 8d1e32061503f64160ed1a3c83248d106b680fe9 | 1bfda432e0c2f3e0f302b32b9406ca8e634ea737 | refs/heads/main | 2023-05-08T14:44:24.700437 | 2021-05-26T17:47:24 | 2021-05-26T17:47:24 | 357,584,283 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,202 | h | #include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct BlockOfLines{
int numberOfLines;
char **arrayOfStrings;
}BlockOfLines;
typedef struct MainArray{
BlockOfLines **blocksOfLines;
int index;
int size;
}MainArray;
typedef struct TemporaryFile
{
FILE *file;
int numberOfLines;
}TemporaryFile;
typedef struct FilesSequence{
char** files;
int numOfPairs;
int * numOfLinesInFile;
} FilesSequence;
MainArray *createArray(int size);
TemporaryFile *mergeFiles(MainArray *mainArray, FILE * file1, FILE * file2);
int createBlockFromFile(MainArray *array, int numberOfLines);
int getNumberOfLinesInBlock(MainArray *array, int index);
void removeBlockOfLines(MainArray * array, int index);
void removeLineFromBlock(MainArray * array, int arrIndex, int lineIndex);
void printMergedFiles(MainArray * array);
void freeBlock(BlockOfLines *block);
void freeMainArray(MainArray *arr);
void freeFilesSequence(FilesSequence * seq);
FilesSequence* createFilesSequence(int numberOfFiles, char** argv , int * argnum);
void saveToTmp(FilesSequence * sequence);
void createBlocksFromFile(MainArray * arr, int numOfBlocks, FilesSequence* seq);
| [
"youngdashu@localhost.localdomain"
] | youngdashu@localhost.localdomain |
669b085dbfffdd6f2fa98f85caa273aa983a278c | 43ed415ad388f0584e76e4598f6be1e0a70fe6b8 | /prebuilts/darwin/include/v8-version.h | c7ad00e264abe8a5efe70bb0e4b909b010381b94 | [
"Apache-2.0"
] | permissive | attackgithub/openrasp-v8 | 1a650782f017ba3657fc7c30adc10b9663ee253d | b209222573e7557cee3df74ab35d5ffbd8da7812 | refs/heads/master | 2020-06-20T18:43:40.140372 | 2019-07-11T08:31:33 | 2019-07-11T08:31:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 772 | h | // Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_INCLUDE_VERSION_H_ // V8_VERSION_H_ conflicts with src/version.h
#define V8_INCLUDE_VERSION_H_
// These macros define the version number for the current version.
// NOTE these macros are used by some of the tool scripts and the build
// system so their names cannot be changed without changing the scripts.
#define V8_MAJOR_VERSION 7
#define V8_MINOR_VERSION 2
#define V8_BUILD_NUMBER 502
#define V8_PATCH_LEVEL 27
// Use 1 for candidates and 0 otherwise.
// (Boolean macro values are not supported by all preprocessors.)
#define V8_IS_CANDIDATE_VERSION 0
#endif // V8_INCLUDE_VERSION_H_
| [
"lanyuhang@baidu.com"
] | lanyuhang@baidu.com |
e157b8e135f3e5e21ebb4321835563aa1cdfedbb | 913a0efa1b36ac741a36b3f94d872562c51ef572 | /Binaries/iOS/Classes/Native/mscorlib_System_Globalization_DateTimeStyles.h | 4f519f026d26a3feaa7fbf00667a892a35a82905 | [
"MIT"
] | permissive | masanori840816/SetMaterialsFromGallery | 41d3a89488c349f54586bfb367eb021ca7356357 | ce6d67874e42706feca5e5a66f9b6785992b9dda | refs/heads/master | 2021-01-18T01:23:54.041302 | 2015-05-21T13:21:44 | 2015-05-21T13:21:44 | 34,765,403 | 5 | 2 | null | null | null | null | UTF-8 | C | false | false | 340 | h | #pragma once
#include <stdint.h>
// System.Enum
#include "mscorlib_System_Enum.h"
// System.Globalization.DateTimeStyles
#include "mscorlib_System_Globalization_DateTimeStyles.h"
// System.Globalization.DateTimeStyles
struct DateTimeStyles_t1312
{
// System.Int32 System.Globalization.DateTimeStyles::value__
int32_t ___value___1;
};
| [
"masanori840816@gmail.com"
] | masanori840816@gmail.com |
36574a4fb995565f933045c4721e83ca5b566392 | 67a8c824902b83f76daf5075e5ddb730980a15e8 | /RevivalPlus/scripts/4_World/RevivalPlus/Classes/Recipes/RPL_SprayPainting/Weapons/Repeater/Recipe_PaintRepeater_White.c | 121e5d0767b92cf69f7a95c53c2d7c1968651d23 | [
"MIT"
] | permissive | benedikz/RevivalPlus | 8004e8ec5f0f9369957e3c412e8afc49626f8397 | b51d90ede21f457d78aba8e175e7c9463678cac1 | refs/heads/master | 2023-07-16T07:20:50.675598 | 2021-09-06T22:26:11 | 2021-09-06T22:26:11 | 294,627,453 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,994 | c | class PaintRepeater_White extends RecipeBase
{
override void Init()
{
/*************************************************************/
m_Name = "#STR_RPL_Recipe_SprayPaint";
m_IsInstaRecipe = false; // NoAnimation [true/false]
m_AnimationLength = 4; // Animation length
m_Specialty = -0.05; // + INCREASE ROUGNESS
// - INCREASE PRECISSION
/*************************************************************/
m_MinDamageIngredient[0] = -1;
m_MaxDamageIngredient[0] = 3;
m_MinQuantityIngredient[0] = 50;
m_MaxQuantityIngredient[0] = -1;
/*************************************************************/
m_MinDamageIngredient[1] = -1;
m_MaxDamageIngredient[1] = 3;
m_MinQuantityIngredient[1] = -1;
m_MaxQuantityIngredient[1] = -1;
/*************************************************************/
InsertIngredient(0, "RPL_SprayCan0_White");
InsertIngredient(0, "RPL_SprayCan1_White");
m_IngredientAddHealth[0] = 0;
m_IngredientSetHealth[0] = -1;
m_IngredientAddQuantity[0] = -50;
m_IngredientDestroy[0] = false;
m_IngredientUseSoftSkills[0] = false;
/*************************************************************/
InsertIngredient(1, "Repeater");
m_IngredientAddHealth[1] = 0;
m_IngredientSetHealth[1] = -1;
m_IngredientAddQuantity[1] = 0;
m_IngredientDestroy[1] = false;
m_IngredientUseSoftSkills[1] = false;
/*************************************************************/
}
// Recipe validity check
override bool CanDo(ItemBase ingredients[], PlayerBase player)
{
return RPL_PaintItem.CanPaintItem(ingredients[0], ingredients[1]);
}
// Called upon completion
override void Do(ItemBase ingredients[], PlayerBase player, array<ItemBase> results, float specialty_weight)
{
RPL_PaintItem.Paint(ingredients[0], ingredients[1], "Repeater", player, specialty_weight);
//Trace.Log(0, "<PaintRepeater_White> Called.");
}
};
| [
"benzeex@gmail.com"
] | benzeex@gmail.com |
1518083b6b8b6d76642912c2fae0ea8631f66967 | e9fd43a04056af5e5d9905dd8497bd2995667911 | /Core/Src/ina219.c | c4875d8415125a701a37a54439edcb904475f579 | [] | no_license | konstantinbsv/scp-controller-firmware-stm32 | 9fadcdab9f44ea4b127ecee41c6d94e4982c184b | 0b365143d36ff80386f32a4eecce17d10f2dab06 | refs/heads/master | 2022-11-15T00:08:29.881767 | 2020-03-09T18:12:44 | 2020-03-09T18:12:44 | 244,171,811 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,894 | c | /*
* ina219.c
*
* Created on: Feb 12, 2020
* Author: Konstantin Borissov
*/
#include <ina219.h>
const uint8_t INA219_ADDRESSES[3] = {INA219_ADDRESS_1, INA219_ADDRESS_2, INA219_ADDRESS_3};
static I2C_HandleTypeDef *ina219_i2c_handle = NULL;
/**
* @brief Initialize I2C handle
*
* @return HAL_OK
*/
HAL_StatusTypeDef InitializeI2C (I2C_HandleTypeDef *i2c_handle) {
ina219_i2c_handle = i2c_handle;
return HAL_OK;
}
/*
* @brief Reads from specified register of specified device and pieces MSB and LSB to form data.
* Note: pass pointer to value into which to read the data.
*
* @return HAL_OK if operation successful
*/
HAL_StatusTypeDef ReadRegister (uint8_t device_address, uint8_t reg_address, uint16_t *read_data) {
uint8_t read_buffer[2];
HAL_StatusTypeDef status = HAL_I2C_Mem_Read(ina219_i2c_handle, device_address, reg_address, I2C_MEMADD_SIZE_8BIT, read_buffer, INA219_REG_BYTES_SIZE, I2C_TIMEOUT);
*read_data = read_buffer[0] << 8 | read_buffer[1];
return status;
}
/*
* @brief Writes data to specified register of specified device.
*
* @return HAL_OK if operation successful.
*/
HAL_StatusTypeDef WriteRegister (uint8_t device_address, uint8_t reg_address, uint16_t write_data) {
uint8_t write_buffer[2] = { (uint8_t) (write_data >> 8), (uint8_t) (write_data) };
return HAL_I2C_Mem_Write(ina219_i2c_handle, device_address, reg_address, I2C_MEMADD_SIZE_8BIT, write_buffer, INA219_REG_BYTES_SIZE, I2C_TIMEOUT);
}
/*
* @brief Sets PGA gain and registers for measuring up to 16V and 1.15A. Calculates and stores current and power LSBs.
* Calculates calibration value and initializes calibration register.
*
* @return HAL_OK if both calibration and configuration initializations are successful.
* HAL_ERROR if either fails
*/
HAL_StatusTypeDef Set_16V_1A55 (uint8_t device_address) {
uint16_t config_reg = INA219_BRNG_16V | INA219_PGA_160mV |
INA219_SADC_12BIT_32SMPL | INA219_BADC_12BIT_32SMPL |
INA219_MODE_S_AND_B_V_CONTINUOUS;
current_lsb = 1.55 / 32768; // max_current / 2^15
power_lsb = current_lsb * 20;
cal_reg = (uint16_t)(0.04096/(current_lsb*RSHUNT));
HAL_StatusTypeDef cal_stat = WriteRegister(device_address, INA219_REG_CAL, cal_reg); // Program calibration register
HAL_StatusTypeDef conf_stat = WriteRegister(device_address, INA219_REG_CONFIG, config_reg); // Set PGA gains and sampling modes in configuration register
return (cal_stat == conf_stat) ? HAL_OK : HAL_ERROR;
}
/*
* @brief Sets PGA gain and registers for measuring up to 32V and 2.6A. Calculates and stores current and power LSBs.
* Calculates calibration value and initializes calibration register.
*
* @return HAL_OK if both calibration and configuration initializations are successful.
* HAL_ERROR if either fails
*/
HAL_StatusTypeDef Set_32V_2A6 (uint8_t device_address) {
uint16_t config_reg = INA219_BRNG_32V | INA219_PGA_320mV |
INA219_SADC_12BIT_32SMPL | INA219_BADC_12BIT_32SMPL |
INA219_MODE_S_AND_B_V_CONTINUOUS;
current_lsb = 2.6 / 32768; // max_current / 2^15
power_lsb = current_lsb * 20;
cal_reg = (uint16_t)(0.04096/(current_lsb*RSHUNT));
HAL_StatusTypeDef cal_stat = WriteRegister(device_address, INA219_REG_CAL, cal_reg); // Program calibration register
HAL_StatusTypeDef conf_stat = WriteRegister(device_address, INA219_REG_CONFIG, config_reg); // Set PGA gains and sampling modes in configuration register
return (cal_stat == conf_stat) ? HAL_OK : HAL_ERROR;
}
/*
* @brief Retrieves and processes raw bus voltage value from register.
*
* @return Bus votlage in volts (V)
*/
float GetBusVoltage_V(uint8_t device_address) {
uint16_t raw_bus_voltage;
ReadRegister(device_address, INA219_REG_BUS_V, &raw_bus_voltage); // get raw bus voltage from INA219
raw_bus_voltage = raw_bus_voltage >> 3; // bit shift 3 right to remove empty bit, CNVR, and OVF
int16_t bus_voltage_mV = (int16_t) raw_bus_voltage * 4; // *4mV (bus voltage LSB) to get actual bus voltage measured my device and convert to signed
float bus_voltage_V = (float)bus_voltage_mV * 0.001; // multiply by 0.001 to convert mV -> V
return bus_voltage_V;
}
/*
* @brief Updates configuration register. Retrieves raw value from current register and performs calculations.
*
* @return Current in milliamps (mA)
*/
float GetCurrent_mA(uint8_t device_address){
uint16_t raw_current;
WriteRegister(device_address, INA219_REG_CAL, cal_reg); // reinitialize calibration register in case of chip reset
ReadRegister(device_address, INA219_REG_CURRENT, &raw_current); // get raw current value from register
float current_mA = (float)((int16_t) raw_current) * current_lsb * 1000; // convert to signed and multiply by LSB value
// and *1000 (register value is in uA) to get current in mA
return current_mA;
}
/*
* @brief Updates configuration register. Retrieves raw value from power register and performs calculations.
*
* @return Power in milliwatts (mW)
*/
float GetPower_mW(uint8_t device_address) {
uint16_t raw_power;
WriteRegister(device_address, INA219_REG_CAL, cal_reg); // reinitialize calibration register in case of chip reset
ReadRegister(device_address, INA219_REG_POWER, &raw_power); // get raw power value from register
float power_mW = (float)((int16_t) raw_power) * power_lsb * 1000; // convert to signed and multiply by LSB value (=20*current_lsb)
// and * 1000 (to convert to mW from uW)
return power_mW;
}
/*
* @brief Calculates Thevenin equivalent resistance of the load connected.
*
* @return Thevenin equivalent resistance in ohms (ohms)
*/
float GetThevenin_R(uint8_t device_address) {
float voltage_V = GetBusVoltage_V(device_address); // get voltage in V
float current_A = GetCurrent_mA(device_address) / 1000; // get current in mA and convert to A
return voltage_V / current_A;
}
| [
"32213296+konstantinbsv@users.noreply.github.com"
] | 32213296+konstantinbsv@users.noreply.github.com |
ca05e8531d2ae49ef9e98e415401da25fe1d52b9 | 4e74d595d5267c05b664d7fca0ba7d41c15dda8b | /nqueen.c | 2533e3edc093680fc7f9c3b1f38b806677241224 | [] | no_license | nivedhashanmugam679/ADA-lab | 0163c6e1267d9b43d71845dd71c64756dc3d5ed4 | 973800e84fe1b7c97309ba8d9fd958fe59fff3ab | refs/heads/master | 2021-09-10T22:16:57.911742 | 2018-04-03T06:37:44 | 2018-04-03T06:37:44 | 120,409,227 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 805 | c | #include<stdio.h>
void nqueens(int);
int place(int[],int);
void printsolution(int,int[]);
void main()
{
int n;
printf("Enter the no.of queens:");
scanf("%d",&n);
nqueens(n);
}
void nqueens(int n)
{
int x[10],count=0,k=1;
x[k]=0;
while(k!=0)
{
x[k]=x[k]+1;
while(x[k]<=n&&(!place(x,k)))
x[k]=x[k]+1;
if(x[k]<=n)
{
if(k==n)
{
count++;
printf("\nSolution %d\n",count);
printsolution(n,x);
}
else
{
k++;
x[k]=0;
}
}
else
{
k--; //backtracking
}
}
return;
}
int place(int x[],int k)
{
int i;
for(i=1;i<k;i++) if(x[i]==x[k]||(abs(x[i]-
x[k]))==abs(i-k))
return 0;
return 1;
}
void printsolution(int n,int x[])
{
int i,j;
char c[10][10];
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
c[i][j]='X';
}
for(i=1;i<=n;i++)
c[i][x[i]]='Q';
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
printf("%c\t",c[i][j]);
}
printf("\n");
}
}
| [
"noreply@github.com"
] | nivedhashanmugam679.noreply@github.com |
096c9024e32e0d8fef6250da1a6b72140fa521c7 | 0d57893c36f0226335577773a7bf99cd98b3e3a3 | /generated/MaximumIntegrityProtectedDataRate.h | 7f3c6a59ce95d99c0beca57c0e56271b8981ab79 | [] | no_license | cakir-enes/ransim | 609c69adf8a3c3928494806ca0db9edd3f1f46ca | 7c7a3de16446c74e4914f48f2f45d7a69d5fa5b6 | refs/heads/master | 2020-07-30T01:07:38.589174 | 2019-09-21T17:49:10 | 2019-09-21T17:49:10 | 210,029,354 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,944 | h | /*
* Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
* From ASN.1 module "NGAP-IEs"
* found in "NGAP-IEs.asn"
* `asn1c -fcompound-names`
*/
#ifndef _MaximumIntegrityProtectedDataRate_H_
#define _MaximumIntegrityProtectedDataRate_H_
#include <asn_application.h>
/* Including external dependencies */
#include <NativeEnumerated.h>
#ifdef __cplusplus
extern "C" {
#endif
/* Dependencies */
typedef enum MaximumIntegrityProtectedDataRate {
MaximumIntegrityProtectedDataRate_bitrate64kbs = 0,
MaximumIntegrityProtectedDataRate_maximum_UE_rate = 1
/*
* Enumeration is extensible
*/
} e_MaximumIntegrityProtectedDataRate;
/* MaximumIntegrityProtectedDataRate */
typedef long MaximumIntegrityProtectedDataRate_t;
/* Implementation */
extern asn_per_constraints_t asn_PER_type_MaximumIntegrityProtectedDataRate_constr_1;
extern asn_TYPE_descriptor_t asn_DEF_MaximumIntegrityProtectedDataRate;
extern const asn_INTEGER_specifics_t asn_SPC_MaximumIntegrityProtectedDataRate_specs_1;
asn_struct_free_f MaximumIntegrityProtectedDataRate_free;
asn_struct_print_f MaximumIntegrityProtectedDataRate_print;
asn_constr_check_f MaximumIntegrityProtectedDataRate_constraint;
ber_type_decoder_f MaximumIntegrityProtectedDataRate_decode_ber;
der_type_encoder_f MaximumIntegrityProtectedDataRate_encode_der;
xer_type_decoder_f MaximumIntegrityProtectedDataRate_decode_xer;
xer_type_encoder_f MaximumIntegrityProtectedDataRate_encode_xer;
oer_type_decoder_f MaximumIntegrityProtectedDataRate_decode_oer;
oer_type_encoder_f MaximumIntegrityProtectedDataRate_encode_oer;
per_type_decoder_f MaximumIntegrityProtectedDataRate_decode_uper;
per_type_encoder_f MaximumIntegrityProtectedDataRate_encode_uper;
per_type_decoder_f MaximumIntegrityProtectedDataRate_decode_aper;
per_type_encoder_f MaximumIntegrityProtectedDataRate_encode_aper;
#ifdef __cplusplus
}
#endif
#endif /* _MaximumIntegrityProtectedDataRate_H_ */
#include <asn_internal.h>
| [
"tinkymortis@gmail.com"
] | tinkymortis@gmail.com |
c88c7774f1907c312bda69977ecf8603793fe4f4 | 25ab64b92e71ebd3da2d0201c231768601a0e226 | /test/api/src/Sorting.c | 9253d8f33ab92842b9fd84d0b16e49c3ca4e7a2f | [
"MIT"
] | permissive | nbrk/flecs | 725ecfd8b76283bf26e7992adbf251e383e27024 | 4c2737949c865e8c79ceafc5220268ba47d50592 | refs/heads/master | 2022-12-24T03:48:43.224315 | 2020-09-30T17:29:02 | 2020-09-30T17:29:02 | 299,996,572 | 0 | 0 | MIT | 2020-09-30T17:19:50 | 2020-09-30T17:19:49 | null | UTF-8 | C | false | false | 29,069 | c | #include <api.h>
int compare_position(
ecs_entity_t e1,
void *ptr1,
ecs_entity_t e2,
void *ptr2)
{
Position *p1 = ptr1;
Position *p2 = ptr2;
return p1->x - p2->x;
}
int compare_entity(
ecs_entity_t e1,
void *ptr1,
ecs_entity_t e2,
void *ptr2)
{
return e1 - e2;
}
void Sorting_sort_by_component() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 5);
test_assert(it.entities[0] == e2);
test_assert(it.entities[1] == e4);
test_assert(it.entities[2] == e1);
test_assert(it.entities[3] == e5);
test_assert(it.entities[4] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_by_component_same_value_1() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {1, 0});
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 5);
test_assert(it.entities[0] == e5);
test_assert(it.entities[1] == e4);
test_assert(it.entities[2] == e3);
test_assert(it.entities[3] == e2);
test_assert(it.entities[4] == e1);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_by_component_same_value_2() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_entity_t e1 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e6 = ecs_set(world, 0, Position, {1, 0});
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 6);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e6);
test_assert(it.entities[2] == e2);
test_assert(it.entities[3] == e1);
test_assert(it.entities[4] == e3);
test_assert(it.entities[5] == e5);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_by_component_2_tables() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e4);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e1);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e5);
test_assert(it.entities[1] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_by_component_3_tables() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Mass);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
ecs_entity_t e6 = ecs_set(world, 0, Position, {5, 0});
ecs_entity_t e7 = ecs_set(world, 0, Position, {7, 0});
ecs_add(world, e5, Velocity);
ecs_add(world, e6, Mass);
ecs_add(world, e7, Mass);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e2);
test_assert(it.entities[1] == e4);
test_assert(it.entities[2] == e1);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e6);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e7);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_by_entity() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
ecs_add(world, e2, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, 0, compare_entity);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e1);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_after_add() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Mass);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_add(world, e3, Mass);
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_add(world, e1, Velocity);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_add(world, e2, Velocity);
ecs_add(world, e2, Mass);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_after_remove() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Mass);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
ecs_add(world, e1, Velocity);
ecs_add(world, e2, Velocity);
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_add(world, e2, Mass);
ecs_add(world, e3, Mass);
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_remove(world, e1, Velocity);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_remove(world, e2, Mass);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e2);
test_assert(it.entities[1] == e4);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_remove(world, e2, Velocity);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_after_delete() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Mass);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
ecs_add(world, e1, Velocity);
ecs_add(world, e2, Velocity);
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_add(world, e2, Mass);
ecs_add(world, e3, Mass);
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_delete(world, e1);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_delete(world, e2);
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_after_set() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Mass);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
ecs_add(world, e1, Velocity);
ecs_add(world, e2, Velocity);
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_add(world, e2, Mass);
ecs_add(world, e3, Mass);
ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_set(world, e1, Position, {7, 0});
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e1);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
static
void FlipP(ecs_iter_t *it) {
Position *p = ecs_column(it, Position, 1);
int32_t i;
for (i = 0; i < it->count; i ++) {
float x = p[i].x;
p[i].x = p[i].y;
p[i].y = x;
}
}
void Sorting_sort_after_system() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Mass);
ECS_SYSTEM(world, FlipP, EcsOnUpdate, Position);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 5});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 2});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 6});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 1});
ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 3});
ecs_add(world, e1, Velocity);
ecs_add(world, e2, Velocity);
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_add(world, e2, Mass);
ecs_add(world, e3, Mass);
ecs_query_t *q = ecs_query_new(world, "Position, [in] Velocity");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_progress(world, 0);
/* First iteration, query will register monitor with table, so table is
* always marked dirty */
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e4);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e5);
test_assert(it.entities[1] == e1);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_progress(world, 0);
/* Second iteration, query now needs to check dirty admin to see if system
* updated component */
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_after_query() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Velocity);
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Mass);
ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 5});
ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 2});
ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 6});
ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 1});
ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 3});
ecs_add(world, e1, Velocity);
ecs_add(world, e2, Velocity);
ecs_add(world, e3, Velocity);
ecs_add(world, e4, Velocity);
ecs_add(world, e5, Velocity);
ecs_add(world, e2, Mass);
ecs_add(world, e3, Mass);
ecs_query_t *flip_q = ecs_query_new(world, "Position");
ecs_query_t *q = ecs_query_new(world, "Position, [in] Velocity");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_iter_t qit = ecs_query_iter(flip_q);
while (ecs_query_next(&qit)) {
FlipP(&qit);
}
/* First iteration, query will register monitor with table, so table is
* always marked dirty */
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e4);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 2);
test_assert(it.entities[0] == e5);
test_assert(it.entities[1] == e1);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
qit = ecs_query_iter(flip_q);
while (ecs_query_next(&qit)) {
FlipP(&qit);
}
/* Second iteration, query now needs to check dirty admin to see if system
* updated component */
it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e2);
test_assert(ecs_query_next(&it));
test_int(it.count, 3);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e1);
test_assert(it.entities[2] == e5);
test_assert(ecs_query_next(&it));
test_int(it.count, 1);
test_assert(it.entities[0] == e3);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_by_component_move_pivot() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_entity_t e1 = ecs_set(world, 0, Position, {5, 0});
ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 0});
ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
ecs_entity_t e4 = ecs_set(world, 0, Position, {1, 0});
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_iter_t it = ecs_query_iter(q);
test_assert(ecs_query_next(&it));
test_int(it.count, 4);
test_assert(it.entities[0] == e4);
test_assert(it.entities[1] == e3);
test_assert(it.entities[2] == e1);
test_assert(it.entities[3] == e2);
test_assert(!ecs_query_next(&it));
ecs_fini(world);
}
void Sorting_sort_1000_entities() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
for (int i = 0; i < 1000; i ++) {
int32_t v = rand();
ecs_set(world, 0, Position, {v});
ecs_iter_t it = ecs_query_iter(q);
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
test_assert(it.count == (i + 1));
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
}
ecs_fini(world);
}
void Sorting_sort_1000_entities_w_duplicates() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
for (int i = 0; i < 500; i ++) {
int32_t v = rand();
ecs_set(world, 0, Position, {v});
ecs_set(world, 0, Position, {v});
ecs_iter_t it = ecs_query_iter(q);
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
test_assert(it.count == (i + 1) * 2);
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
}
ecs_fini(world);
}
void Sorting_sort_1000_entities_again() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_entity_t start = ecs_new(world, 0);
for (int i = 0; i < 1000; i ++) {
int32_t v = rand();
ecs_set(world, i + start, Position, {v});
ecs_iter_t it = ecs_query_iter(q);
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
test_assert(it.count == (i + 1));
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
}
for (int i = 0; i < 1000; i ++) {
int32_t v = rand();
ecs_set(world, i + start, Position, {v});
}
ecs_iter_t it = ecs_query_iter(q);
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
test_assert(it.count == 1000);
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
ecs_fini(world);
}
void Sorting_sort_1000_entities_2_types() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
for (int i = 0; i < 500; i ++) {
int32_t v = rand();
ecs_set(world, 0, Position, {v});
ecs_entity_t e = ecs_set(world, 0, Position, {v});
ecs_add(world, e, Velocity);
ecs_iter_t it = ecs_query_iter(q);
int32_t count = 0;
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
count += it.count;
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
test_int(count, (i + 1) * 2);
}
ecs_fini(world);
}
void Sorting_sort_1000_entities_2_types_again() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_entity_t start = ecs_new(world, 0);
for (int i = 0; i < 1000; i ++) {
int32_t v = rand();
ecs_set(world, i + start, Position, {v});
if (!(i % 2)) {
ecs_add(world, i + start, Velocity);
}
ecs_iter_t it = ecs_query_iter(q);
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
}
for (int i = 0; i < 1000; i ++) {
int32_t v = rand();
ecs_set(world, i + start, Position, {v});
}
ecs_iter_t it = ecs_query_iter(q);
int32_t count = 0;
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
count += it.count;
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
test_int(count, 1000);
ecs_fini(world);
}
void Sorting_sort_1000_entities_add_type_after_sort() {
ecs_world_t *world = ecs_init();
ECS_COMPONENT(world, Position);
ECS_COMPONENT(world, Velocity);
ecs_query_t *q = ecs_query_new(world, "Position");
ecs_query_order_by(world, q, ecs_entity(Position), compare_position);
ecs_entity_t start = ecs_new(world, 0);
for (int i = 0; i < 500; i ++) {
int32_t v = rand();
ecs_set(world, i + start, Position, {v});
ecs_iter_t it = ecs_query_iter(q);
int32_t count = 0;
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
count += it.count;
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
test_int(count, i + 1);
}
for (int i = 0; i < 500; i ++) {
int32_t v = rand();
ecs_set(world, i + start, Position, {v});
}
for (int i = 0; i < 500; i ++) {
int32_t v = rand();
ecs_set(world, i + start + 500, Position, {v});
ecs_add(world, i + start + 500, Velocity);
ecs_iter_t it = ecs_query_iter(q);
int32_t count = 0;
while (ecs_query_next(&it)) {
Position *p = ecs_column(&it, Position, 1);
count += it.count;
int32_t j, x = 0;
for (j = 0; j < it.count; j ++) {
test_assert(x <= p[j].x);
x = p[j].x;
}
}
test_int(count, i + 500 + 1);
}
ecs_fini(world);
}
| [
"sander.mertens8@gmail.com"
] | sander.mertens8@gmail.com |
58df4734d465539806c9bc213b1e1d54028f337d | a153092f42293c811fd6a4b76d620139e1e08f2f | /synergy/ssp/src/framework/tes/dave2d/dave_line.c | d0ca8c3cfc7b11b8fde5ac1eea7a35c216f14a26 | [] | no_license | JPacho/ProyectoIntegrador | 8ee990117c0c2df86485c387f4f1ead9372ca9f7 | 6bb1524874cf0cd00e752d337efdc950ce522e20 | refs/heads/master | 2020-06-16T01:38:34.584753 | 2019-10-31T03:33:23 | 2019-10-31T03:33:23 | 195,445,494 | 0 | 0 | null | 2019-10-19T14:52:50 | 2019-07-05T17:23:58 | C | UTF-8 | C | false | false | 64,924 | c | #ifdef AMS_ENCRYPT_PACKAGE
-----BEGIN ENCRYPTED FILE v0.6-----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-----END ENCRYPTED FILE-----
#else
#error "Secure builder required to compile this file"
#endif
| [
"fcojair.dico@gmail.com"
] | fcojair.dico@gmail.com |
e40a4c9a6b90e09bc05c064ea2f6d4bffd99aa92 | 3242b4524ed78233f4ae1d9004ef6a8b7d8afa0e | /test/MergeFiles/myReduce_9.C | de5eee777a86d1c1c3c967cecdbf6a4b0a42e4de | [] | no_license | nsahoo/FourMuonPAT | 5285d46e3c0cb1598db29afaffdda964ab023d42 | 2fe0cae78fc9bcbe551ce25f41b412ea852313a4 | refs/heads/master | 2020-05-16T15:08:47.253631 | 2018-09-11T02:23:58 | 2018-09-11T02:23:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 335 | c | {
TChain* chain = new TChain("mkcands/X_data");
chain->Add("/eos/uscms/store/user/sdurgut/TrigMatch/Merged/Muonia2012B_5.root");
TFile *f2 = new TFile("/eos/uscms/store/user/sdurgut/TrigMatch/Reduced/Muonia2012B_5.root","recreate");
TTree *T2 = chain->CopyTree("MyFourMuonVtxCL>0.01 && MyFourMuonChg==0");
T2->Write();
}
| [
"suleyman.durgut@gmail.com"
] | suleyman.durgut@gmail.com |
bf34716a70a87be91ddb9fc05fae6dd9210d5ea6 | 97819223f4cbb8e3aeb820574fe8ee8742968380 | /prlpg/src/backend/parser/parse_agg.c | e883e283e0be028c71f23436e9f3e9f6fa778c7d | [
"PostgreSQL"
] | permissive | dnaxxsk/prlpg | 680f1d669c3ccd14d065f9207ec62a5ea6a3ae6f | 881829bac064d58beab86fc02b3ea46533e18562 | refs/heads/master | 2016-09-11T05:47:56.107317 | 2010-12-03T13:16:44 | 2010-12-03T13:16:44 | 32,145,589 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 23,018 | c | /*-------------------------------------------------------------------------
*
* parse_agg.c
* handle aggregates and window functions in parser
*
* Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.91 2010/02/12 17:33:20 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/tlist.h"
#include "optimizer/var.h"
#include "parser/parse_agg.h"
#include "parser/parse_clause.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteManip.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
typedef struct
{
ParseState *pstate;
List *groupClauses;
bool have_non_var_grouping;
int sublevels_up;
} check_ungrouped_columns_context;
static void check_ungrouped_columns(Node *node, ParseState *pstate,
List *groupClauses, bool have_non_var_grouping);
static bool check_ungrouped_columns_walker(Node *node,
check_ungrouped_columns_context *context);
/*
* transformAggregateCall -
* Finish initial transformation of an aggregate call
*
* parse_func.c has recognized the function as an aggregate, and has set
* up all the fields of the Aggref except aggdistinct and agglevelsup.
* However, the args list is just bare expressions, and the aggorder list
* hasn't been transformed at all.
*
* Here we convert the args list into a targetlist by inserting TargetEntry
* nodes, and then transform the aggorder and agg_distinct specifications to
* produce lists of SortGroupClause nodes. (That might also result in adding
* resjunk expressions to the targetlist.)
*
* We must also determine which query level the aggregate actually belongs to,
* set agglevelsup accordingly, and mark p_hasAggs true in the corresponding
* pstate level.
*/
void
transformAggregateCall(ParseState *pstate, Aggref *agg, bool agg_distinct)
{
List *tlist;
List *torder;
List *tdistinct = NIL;
AttrNumber attno;
int save_next_resno;
int min_varlevel;
ListCell *lc;
/*
* Transform the plain list of Exprs into a targetlist. We don't bother
* to assign column names to the entries.
*/
tlist = NIL;
attno = 1;
foreach(lc, agg->args)
{
Expr *arg = (Expr *) lfirst(lc);
TargetEntry *tle = makeTargetEntry(arg, attno++, NULL, false);
tlist = lappend(tlist, tle);
}
/*
* If we have an ORDER BY, transform it. This will add columns to the
* tlist if they appear in ORDER BY but weren't already in the arg list.
* They will be marked resjunk = true so we can tell them apart from
* regular aggregate arguments later.
*
* We need to mess with p_next_resno since it will be used to number any
* new targetlist entries.
*/
save_next_resno = pstate->p_next_resno;
pstate->p_next_resno = attno;
torder = transformSortClause(pstate,
agg->aggorder,
&tlist,
true /* fix unknowns */,
true /* force SQL99 rules */);
/*
* If we have DISTINCT, transform that to produce a distinctList.
*/
if (agg_distinct)
{
tdistinct = transformDistinctClause(pstate, &tlist, torder, true);
/*
* Remove this check if executor support for hashed distinct for
* aggregates is ever added.
*/
foreach(lc, tdistinct)
{
SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
if (!OidIsValid(sortcl->sortop))
{
Node *expr = get_sortgroupclause_expr(sortcl, tlist);
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("could not identify an ordering operator for type %s",
format_type_be(exprType(expr))),
errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
parser_errposition(pstate, exprLocation(expr))));
}
}
}
/* Update the Aggref with the transformation results */
agg->args = tlist;
agg->aggorder = torder;
agg->aggdistinct = tdistinct;
pstate->p_next_resno = save_next_resno;
/*
* The aggregate's level is the same as the level of the lowest-level
* variable or aggregate in its arguments; or if it contains no variables
* at all, we presume it to be local.
*/
min_varlevel = find_minimum_var_level((Node *) agg->args);
/*
* An aggregate can't directly contain another aggregate call of the same
* level (though outer aggs are okay). We can skip this check if we
* didn't find any local vars or aggs.
*/
if (min_varlevel == 0)
{
if (pstate->p_hasAggs &&
checkExprHasAggs((Node *) agg->args))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregate function calls cannot be nested"),
parser_errposition(pstate,
locate_agg_of_level((Node *) agg->args, 0))));
}
/* It can't contain window functions either */
if (pstate->p_hasWindowFuncs &&
checkExprHasWindowFuncs((Node *) agg->args))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregate function calls cannot contain window function calls"),
parser_errposition(pstate,
locate_windowfunc((Node *) agg->args))));
if (min_varlevel < 0)
min_varlevel = 0;
agg->agglevelsup = min_varlevel;
/* Mark the correct pstate as having aggregates */
while (min_varlevel-- > 0)
pstate = pstate->parentParseState;
pstate->p_hasAggs = true;
}
/*
* transformWindowFuncCall -
* Finish initial transformation of a window function call
*
* parse_func.c has recognized the function as a window function, and has set
* up all the fields of the WindowFunc except winref. Here we must (1) add
* the WindowDef to the pstate (if not a duplicate of one already present) and
* set winref to link to it; and (2) mark p_hasWindowFuncs true in the pstate.
* Unlike aggregates, only the most closely nested pstate level need be
* considered --- there are no "outer window functions" per SQL spec.
*/
void
transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
WindowDef *windef)
{
/*
* A window function call can't contain another one (but aggs are OK). XXX
* is this required by spec, or just an unimplemented feature?
*/
if (pstate->p_hasWindowFuncs &&
checkExprHasWindowFuncs((Node *) wfunc->args))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window function calls cannot be nested"),
parser_errposition(pstate,
locate_windowfunc((Node *) wfunc->args))));
/*
* If the OVER clause just specifies a window name, find that WINDOW
* clause (which had better be present). Otherwise, try to match all the
* properties of the OVER clause, and make a new entry in the p_windowdefs
* list if no luck.
*/
if (windef->name)
{
Index winref = 0;
ListCell *lc;
Assert(windef->refname == NULL &&
windef->partitionClause == NIL &&
windef->orderClause == NIL &&
windef->frameOptions == FRAMEOPTION_DEFAULTS);
foreach(lc, pstate->p_windowdefs)
{
WindowDef *refwin = (WindowDef *) lfirst(lc);
winref++;
if (refwin->name && strcmp(refwin->name, windef->name) == 0)
{
wfunc->winref = winref;
break;
}
}
if (lc == NULL) /* didn't find it? */
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("window \"%s\" does not exist", windef->name),
parser_errposition(pstate, windef->location)));
}
else
{
Index winref = 0;
ListCell *lc;
foreach(lc, pstate->p_windowdefs)
{
WindowDef *refwin = (WindowDef *) lfirst(lc);
winref++;
if (refwin->refname && windef->refname &&
strcmp(refwin->refname, windef->refname) == 0)
/* matched on refname */ ;
else if (!refwin->refname && !windef->refname)
/* matched, no refname */ ;
else
continue;
if (equal(refwin->partitionClause, windef->partitionClause) &&
equal(refwin->orderClause, windef->orderClause) &&
refwin->frameOptions == windef->frameOptions &&
equal(refwin->startOffset, windef->startOffset) &&
equal(refwin->endOffset, windef->endOffset))
{
/* found a duplicate window specification */
wfunc->winref = winref;
break;
}
}
if (lc == NULL) /* didn't find it? */
{
pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
wfunc->winref = list_length(pstate->p_windowdefs);
}
}
pstate->p_hasWindowFuncs = true;
}
/*
* parseCheckAggregates
* Check for aggregates where they shouldn't be and improper grouping.
*
* Ideally this should be done earlier, but it's difficult to distinguish
* aggregates from plain functions at the grammar level. So instead we
* check here. This function should be called after the target list and
* qualifications are finalized.
*/
void
parseCheckAggregates(ParseState *pstate, Query *qry)
{
List *groupClauses = NIL;
bool have_non_var_grouping;
ListCell *l;
bool hasJoinRTEs;
bool hasSelfRefRTEs;
PlannerInfo *root;
Node *clause;
/* This should only be called if we found aggregates or grouping */
Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual);
/*
* Scan the range table to see if there are JOIN or self-reference CTE
* entries. We'll need this info below.
*/
hasJoinRTEs = hasSelfRefRTEs = false;
foreach(l, pstate->p_rtable)
{
RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
if (rte->rtekind == RTE_JOIN)
hasJoinRTEs = true;
else if (rte->rtekind == RTE_CTE && rte->self_reference)
hasSelfRefRTEs = true;
}
/*
* Aggregates must never appear in WHERE or JOIN/ON clauses.
*
* (Note this check should appear first to deliver an appropriate error
* message; otherwise we are likely to complain about some innocent
* variable in the target list, which is outright misleading if the
* problem is in WHERE.)
*/
if (checkExprHasAggs(qry->jointree->quals))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregates not allowed in WHERE clause"),
parser_errposition(pstate,
locate_agg_of_level(qry->jointree->quals, 0))));
if (checkExprHasAggs((Node *) qry->jointree->fromlist))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregates not allowed in JOIN conditions"),
parser_errposition(pstate,
locate_agg_of_level((Node *) qry->jointree->fromlist, 0))));
/*
* No aggregates allowed in GROUP BY clauses, either.
*
* While we are at it, build a list of the acceptable GROUP BY expressions
* for use by check_ungrouped_columns().
*/
foreach(l, qry->groupClause)
{
SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
Node *expr;
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
if (expr == NULL)
continue; /* probably cannot happen */
if (checkExprHasAggs(expr))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregates not allowed in GROUP BY clause"),
parser_errposition(pstate,
locate_agg_of_level(expr, 0))));
groupClauses = lcons(expr, groupClauses);
}
/*
* If there are join alias vars involved, we have to flatten them to the
* underlying vars, so that aliased and unaliased vars will be correctly
* taken as equal. We can skip the expense of doing this if no rangetable
* entries are RTE_JOIN kind. We use the planner's flatten_join_alias_vars
* routine to do the flattening; it wants a PlannerInfo root node, which
* fortunately can be mostly dummy.
*/
if (hasJoinRTEs)
{
root = makeNode(PlannerInfo);
root->parse = qry;
root->planner_cxt = CurrentMemoryContext;
root->hasJoinRTEs = true;
groupClauses = (List *) flatten_join_alias_vars(root,
(Node *) groupClauses);
}
else
root = NULL; /* keep compiler quiet */
/*
* Detect whether any of the grouping expressions aren't simple Vars; if
* they're all Vars then we don't have to work so hard in the recursive
* scans. (Note we have to flatten aliases before this.)
*/
have_non_var_grouping = false;
foreach(l, groupClauses)
{
if (!IsA((Node *) lfirst(l), Var))
{
have_non_var_grouping = true;
break;
}
}
/*
* Check the targetlist and HAVING clause for ungrouped variables.
*
* Note: because we check resjunk tlist elements as well as regular ones,
* this will also find ungrouped variables that came from ORDER BY and
* WINDOW clauses. For that matter, it's also going to examine the
* grouping expressions themselves --- but they'll all pass the test ...
*/
clause = (Node *) qry->targetList;
if (hasJoinRTEs)
clause = flatten_join_alias_vars(root, clause);
check_ungrouped_columns(clause, pstate,
groupClauses, have_non_var_grouping);
clause = (Node *) qry->havingQual;
if (hasJoinRTEs)
clause = flatten_join_alias_vars(root, clause);
check_ungrouped_columns(clause, pstate,
groupClauses, have_non_var_grouping);
/*
* Per spec, aggregates can't appear in a recursive term.
*/
if (pstate->p_hasAggs && hasSelfRefRTEs)
ereport(ERROR,
(errcode(ERRCODE_INVALID_RECURSION),
errmsg("aggregate functions not allowed in a recursive query's recursive term"),
parser_errposition(pstate,
locate_agg_of_level((Node *) qry, 0))));
}
/*
* parseCheckWindowFuncs
* Check for window functions where they shouldn't be.
*
* We have to forbid window functions in WHERE, JOIN/ON, HAVING, GROUP BY,
* and window specifications. (Other clauses, such as RETURNING and LIMIT,
* have already been checked.) Transformation of all these clauses must
* be completed already.
*/
void
parseCheckWindowFuncs(ParseState *pstate, Query *qry)
{
ListCell *l;
/* This should only be called if we found window functions */
Assert(pstate->p_hasWindowFuncs);
if (checkExprHasWindowFuncs(qry->jointree->quals))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in WHERE clause"),
parser_errposition(pstate,
locate_windowfunc(qry->jointree->quals))));
if (checkExprHasWindowFuncs((Node *) qry->jointree->fromlist))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in JOIN conditions"),
parser_errposition(pstate,
locate_windowfunc((Node *) qry->jointree->fromlist))));
if (checkExprHasWindowFuncs(qry->havingQual))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in HAVING clause"),
parser_errposition(pstate,
locate_windowfunc(qry->havingQual))));
foreach(l, qry->groupClause)
{
SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
Node *expr;
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
if (checkExprHasWindowFuncs(expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in GROUP BY clause"),
parser_errposition(pstate,
locate_windowfunc(expr))));
}
foreach(l, qry->windowClause)
{
WindowClause *wc = (WindowClause *) lfirst(l);
ListCell *l2;
foreach(l2, wc->partitionClause)
{
SortGroupClause *grpcl = (SortGroupClause *) lfirst(l2);
Node *expr;
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
if (checkExprHasWindowFuncs(expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in window definition"),
parser_errposition(pstate,
locate_windowfunc(expr))));
}
foreach(l2, wc->orderClause)
{
SortGroupClause *grpcl = (SortGroupClause *) lfirst(l2);
Node *expr;
expr = get_sortgroupclause_expr(grpcl, qry->targetList);
if (checkExprHasWindowFuncs(expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in window definition"),
parser_errposition(pstate,
locate_windowfunc(expr))));
}
/* startOffset and limitOffset were checked in transformFrameOffset */
}
}
/*
* check_ungrouped_columns -
* Scan the given expression tree for ungrouped variables (variables
* that are not listed in the groupClauses list and are not within
* the arguments of aggregate functions). Emit a suitable error message
* if any are found.
*
* NOTE: we assume that the given clause has been transformed suitably for
* parser output. This means we can use expression_tree_walker.
*
* NOTE: we recognize grouping expressions in the main query, but only
* grouping Vars in subqueries. For example, this will be rejected,
* although it could be allowed:
* SELECT
* (SELECT x FROM bar where y = (foo.a + foo.b))
* FROM foo
* GROUP BY a + b;
* The difficulty is the need to account for different sublevels_up.
* This appears to require a whole custom version of equal(), which is
* way more pain than the feature seems worth.
*/
static void
check_ungrouped_columns(Node *node, ParseState *pstate,
List *groupClauses, bool have_non_var_grouping)
{
check_ungrouped_columns_context context;
context.pstate = pstate;
context.groupClauses = groupClauses;
context.have_non_var_grouping = have_non_var_grouping;
context.sublevels_up = 0;
check_ungrouped_columns_walker(node, &context);
}
static bool
check_ungrouped_columns_walker(Node *node,
check_ungrouped_columns_context *context)
{
ListCell *gl;
if (node == NULL)
return false;
if (IsA(node, Const) ||
IsA(node, Param))
return false; /* constants are always acceptable */
/*
* If we find an aggregate call of the original level, do not recurse into
* its arguments; ungrouped vars in the arguments are not an error. We can
* also skip looking at the arguments of aggregates of higher levels,
* since they could not possibly contain Vars that are of concern to us
* (see transformAggregateCall). We do need to look into the arguments of
* aggregates of lower levels, however.
*/
if (IsA(node, Aggref) &&
(int) ((Aggref *) node)->agglevelsup >= context->sublevels_up)
return false;
/*
* If we have any GROUP BY items that are not simple Vars, check to see if
* subexpression as a whole matches any GROUP BY item. We need to do this
* at every recursion level so that we recognize GROUPed-BY expressions
* before reaching variables within them. But this only works at the outer
* query level, as noted above.
*/
if (context->have_non_var_grouping && context->sublevels_up == 0)
{
foreach(gl, context->groupClauses)
{
if (equal(node, lfirst(gl)))
return false; /* acceptable, do not descend more */
}
}
/*
* If we have an ungrouped Var of the original query level, we have a
* failure. Vars below the original query level are not a problem, and
* neither are Vars from above it. (If such Vars are ungrouped as far as
* their own query level is concerned, that's someone else's problem...)
*/
if (IsA(node, Var))
{
Var *var = (Var *) node;
RangeTblEntry *rte;
char *attname;
if (var->varlevelsup != context->sublevels_up)
return false; /* it's not local to my query, ignore */
/*
* Check for a match, if we didn't do it above.
*/
if (!context->have_non_var_grouping || context->sublevels_up != 0)
{
foreach(gl, context->groupClauses)
{
Var *gvar = (Var *) lfirst(gl);
if (IsA(gvar, Var) &&
gvar->varno == var->varno &&
gvar->varattno == var->varattno &&
gvar->varlevelsup == 0)
return false; /* acceptable, we're okay */
}
}
/* Found an ungrouped local variable; generate error message */
Assert(var->varno > 0 &&
(int) var->varno <= list_length(context->pstate->p_rtable));
rte = rt_fetch(var->varno, context->pstate->p_rtable);
attname = get_rte_attribute_name(rte, var->varattno);
if (context->sublevels_up == 0)
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("column \"%s.%s\" must appear in the GROUP BY clause or be used in an aggregate function",
rte->eref->aliasname, attname),
parser_errposition(context->pstate, var->location)));
else
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("subquery uses ungrouped column \"%s.%s\" from outer query",
rte->eref->aliasname, attname),
parser_errposition(context->pstate, var->location)));
}
if (IsA(node, Query))
{
/* Recurse into subselects */
bool result;
context->sublevels_up++;
result = query_tree_walker((Query *) node,
check_ungrouped_columns_walker,
(void *) context,
0);
context->sublevels_up--;
return result;
}
return expression_tree_walker(node, check_ungrouped_columns_walker,
(void *) context);
}
/*
* Create expression trees for the transition and final functions
* of an aggregate. These are needed so that polymorphic functions
* can be used within an aggregate --- without the expression trees,
* such functions would not know the datatypes they are supposed to use.
* (The trees will never actually be executed, however, so we can skimp
* a bit on correctness.)
*
* agg_input_types, agg_state_type, agg_result_type identify the input,
* transition, and result types of the aggregate. These should all be
* resolved to actual types (ie, none should ever be ANYELEMENT etc).
*
* transfn_oid and finalfn_oid identify the funcs to be called; the latter
* may be InvalidOid.
*
* Pointers to the constructed trees are returned into *transfnexpr and
* *finalfnexpr. The latter is set to NULL if there's no finalfn.
*/
void
build_aggregate_fnexprs(Oid *agg_input_types,
int agg_num_inputs,
Oid agg_state_type,
Oid agg_result_type,
Oid transfn_oid,
Oid finalfn_oid,
Expr **transfnexpr,
Expr **finalfnexpr)
{
Param *argp;
List *args;
int i;
/*
* Build arg list to use in the transfn FuncExpr node. We really only care
* that transfn can discover the actual argument types at runtime using
* get_fn_expr_argtype(), so it's okay to use Param nodes that don't
* correspond to any real Param.
*/
argp = makeNode(Param);
argp->paramkind = PARAM_EXEC;
argp->paramid = -1;
argp->paramtype = agg_state_type;
argp->paramtypmod = -1;
argp->location = -1;
args = list_make1(argp);
for (i = 0; i < agg_num_inputs; i++)
{
argp = makeNode(Param);
argp->paramkind = PARAM_EXEC;
argp->paramid = -1;
argp->paramtype = agg_input_types[i];
argp->paramtypmod = -1;
argp->location = -1;
args = lappend(args, argp);
}
*transfnexpr = (Expr *) makeFuncExpr(transfn_oid,
agg_state_type,
args,
COERCE_DONTCARE);
/* see if we have a final function */
if (!OidIsValid(finalfn_oid))
{
*finalfnexpr = NULL;
return;
}
/*
* Build expr tree for final function
*/
argp = makeNode(Param);
argp->paramkind = PARAM_EXEC;
argp->paramid = -1;
argp->paramtype = agg_state_type;
argp->paramtypmod = -1;
argp->location = -1;
args = list_make1(argp);
*finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
agg_result_type,
args,
COERCE_DONTCARE);
}
| [
"danielkov@b8b49325-77e1-8e15-c3a2-48206a2107aa"
] | danielkov@b8b49325-77e1-8e15-c3a2-48206a2107aa |
88e23607c2aae3de5af4740d676f58c2d5b09ba5 | def81e1d6a45855342564e2a1c1986967b329397 | /Texas-MSP432-CCS/Implementation_Example/Sensor_Fusion.h | 931d1b6552402930f8583fa2af19cce05c0faa6b | [] | no_license | Davidap041/ARM_Code_MSP432 | 44dba9c2948af533b86a3b5fa8ed21e167b2e30f | d4f8cf8c8ede0c1110a33892796e9c388a7f502a | refs/heads/master | 2023-05-28T03:11:05.954194 | 2021-06-16T10:41:20 | 2021-06-16T10:41:20 | 271,598,779 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,905 | h | #ifndef _Sensor_Fusion_h_
#define _Sensor_Fusion_h_
#include <math.h>
#include <arm_math.h>
#include <arm_const_structs.h>
/***********************************************************
* Luenberger Filter for Sensor Fusion
***********************************************************
*/typedef struct Luenberger_Struct
{
float angle; // The angle calculated by the luenberger filter - part of the 2x1 state vector
float angle_prev;
float bias; // The gyro bias calculated by the luenberger filter - part of the 2x1 state vector
float bias_prev;
float rate; // Unbiased rate calculated from the rate and the calculated bias - you have to call getAngle to update the rate
float residue;
float pole1;
float pole2;
float L1_;
float L2_; // The angle should be in degrees and the rate should be in degrees per second and the delta time in seconds
} Luenberger_data;
float getAngle_Luenberger(Luenberger_data *luenberger, float newAngle,
float newRate, float dt);
void setPoles_Luenberger(Luenberger_data *luenberger, float dt);
/***********************************************************
* Kalman Filter for Sensor Fusion
***********************************************************
Kristian Lauszus, TKJ Electronics
Web : http://www.tkjelectronics.com
e-mail : kristianl@tkjelectronics.com
*/
typedef struct Kalman_Struct
{
float Q_angle; // Process noise variance for the accelerometer
float Q_bias; // Process noise variance for the gyro bias
float R_measure; // Measurement noise variance - this is actually the variance of the measurement noise
float angle; // The angle calculated by the Kalman filter - part of the 2x1 state vector
float bias; // The gyro bias calculated by the Kalman filter - part of the 2x1 state vector
float rate; // Unbiased rate calculated from the rate and the calculated bias - you have to call getAngle to update the rate
float P[2][2]; // Error covariance matrix - This is a 2x2 matrix
// The angle should be in degrees and the rate should be in degrees per second and the delta time in seconds
} Kalman_data;
float getAngle_Kalman(Kalman_data *kalman, float newAngle, float newRate,
float dt);
/********************************
* FFT and SSF for Sensor Fusion
* *****************************
* */
// Supported FFT Lengths are 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192.
//#define BUFFER_SIGNAL_LENGTH 64
#define BUFFER_SIGNAL_LENGTH 64
#define FFT_SIZE 64
float32_t buffered_signal[BUFFER_SIGNAL_LENGTH];
float32_t fft_data_input[BUFFER_SIGNAL_LENGTH * 2];
float32_t fft_data_output[FFT_SIZE];
float32_t fft_filtered[FFT_SIZE];
float32_t eq_sigmoid[FFT_SIZE];
float32_t ifft_data_output[FFT_SIZE];
float calculateSSF_in_realTime(float32_t data_real_time, int sigmoide_a,
int sigmoide_c);
#endif
| [
"davialexandre_dap@hotmail.com"
] | davialexandre_dap@hotmail.com |
b6c46d4598562071ef4f0b8620dbd81baacd5d7e | ee20307acccfb63cff393012bfa2c31fe8143d98 | /simple_rock_paper_scissors.c | ea91dba4d01e43480edb3e29c22288529934df03 | [] | no_license | chawintee/C-Practise | c3d8b505f66cbb55a326ad70262a4eb09d3c8746 | 53d6b28c2e4ff6391dfe41131d861d1d5b4de26e | refs/heads/main | 2023-01-20T00:10:12.314457 | 2020-11-23T13:47:33 | 2020-11-23T13:47:33 | 306,206,288 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,201 | c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
//input
char playerShape()
{
char shape;
printf("(r)ock, (p)aper, (s)cissors, (q)uit : ");
scanf(" %c", &shape);
// return shape;
return tolower(shape);
}
char computerShape()
{
int r;
r = rand() % 3;
// printf("%d", r);
char s[] = {'r', 'p', 's'};
return s[r];
}
int main()
{
// printf("%c\n",playerShape());
srand(time(0));
// printf("%c", computerShape());
// computerShape();
char player, computer;
player = playerShape();
while (player != 'q')
{
computer = computerShape();
printf("player : %c , computer : %c \n", player, computer);
if (player == 'r' || player == 'p' || player == 's') {
if (player == 'r' && computer == 's' || player == 'p' && computer == 'r' || player == 's' && computer == 'p') {
printf("You win\n");
}
else if (player == computer){
printf("You tie\n");
}
else{
printf("You lose\n");
}
player = playerShape();
}
else {
printf("Not Ok");
player = 'q';
}
}
return 0;
} | [
"chawinteetea@gmail.com"
] | chawinteetea@gmail.com |
a7921c5ce79c70d7e49741ac7babd44d860e2007 | f0c9b1e8ac94382cc17d82d14b22ef82a31d1e82 | /SFT1.0v/Design01.cydsn/Generated_Source/PSoC5/CW_CCW_2.h | 9faaef867cdadb79c70cff56de8d45a8864d2ca9 | [] | no_license | dsky7/PSoC | 115b7dfcbf477932e73ce0bb755201133e676b43 | 303e8ada834d22dffc2de1bb5348882645f135ae | refs/heads/master | 2020-05-29T10:33:39.095777 | 2015-08-20T09:54:28 | 2015-08-20T09:54:28 | 34,363,321 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,143 | h | /*******************************************************************************
* File Name: CW_CCW_2.h
* Version 2.5
*
* Description:
* This file containts Control Register function prototypes and register defines
*
* Note:
*
********************************************************************************
* Copyright 2008-2014, Cypress Semiconductor Corporation. All rights reserved.
* You may use this file only in accordance with the license, terms, conditions,
* disclaimers, and limitations in the end user license agreement accompanying
* the software package with which this file was provided.
*******************************************************************************/
#if !defined(CY_PINS_CW_CCW_2_H) /* Pins CW_CCW_2_H */
#define CY_PINS_CW_CCW_2_H
#include "cytypes.h"
#include "cyfitter.h"
#include "cypins.h"
#include "CW_CCW_2_aliases.h"
/* Check to see if required defines such as CY_PSOC5A are available */
/* They are defined starting with cy_boot v3.0 */
#if !defined (CY_PSOC5A)
#error Component cy_pins_v2_5 requires cy_boot v3.0 or later
#endif /* (CY_PSOC5A) */
/* APIs are not generated for P15[7:6] */
#if !(CY_PSOC5A &&\
CW_CCW_2__PORT == 15 && ((CW_CCW_2__MASK & 0xC0) != 0))
/***************************************
* Function Prototypes
***************************************/
void CW_CCW_2_Write(uint8 value) ;
void CW_CCW_2_SetDriveMode(uint8 mode) ;
uint8 CW_CCW_2_ReadDataReg(void) ;
uint8 CW_CCW_2_Read(void) ;
uint8 CW_CCW_2_ClearInterrupt(void) ;
/***************************************
* API Constants
***************************************/
/* Drive Modes */
#define CW_CCW_2_DM_ALG_HIZ PIN_DM_ALG_HIZ
#define CW_CCW_2_DM_DIG_HIZ PIN_DM_DIG_HIZ
#define CW_CCW_2_DM_RES_UP PIN_DM_RES_UP
#define CW_CCW_2_DM_RES_DWN PIN_DM_RES_DWN
#define CW_CCW_2_DM_OD_LO PIN_DM_OD_LO
#define CW_CCW_2_DM_OD_HI PIN_DM_OD_HI
#define CW_CCW_2_DM_STRONG PIN_DM_STRONG
#define CW_CCW_2_DM_RES_UPDWN PIN_DM_RES_UPDWN
/* Digital Port Constants */
#define CW_CCW_2_MASK CW_CCW_2__MASK
#define CW_CCW_2_SHIFT CW_CCW_2__SHIFT
#define CW_CCW_2_WIDTH 1u
/***************************************
* Registers
***************************************/
/* Main Port Registers */
/* Pin State */
#define CW_CCW_2_PS (* (reg8 *) CW_CCW_2__PS)
/* Data Register */
#define CW_CCW_2_DR (* (reg8 *) CW_CCW_2__DR)
/* Port Number */
#define CW_CCW_2_PRT_NUM (* (reg8 *) CW_CCW_2__PRT)
/* Connect to Analog Globals */
#define CW_CCW_2_AG (* (reg8 *) CW_CCW_2__AG)
/* Analog MUX bux enable */
#define CW_CCW_2_AMUX (* (reg8 *) CW_CCW_2__AMUX)
/* Bidirectional Enable */
#define CW_CCW_2_BIE (* (reg8 *) CW_CCW_2__BIE)
/* Bit-mask for Aliased Register Access */
#define CW_CCW_2_BIT_MASK (* (reg8 *) CW_CCW_2__BIT_MASK)
/* Bypass Enable */
#define CW_CCW_2_BYP (* (reg8 *) CW_CCW_2__BYP)
/* Port wide control signals */
#define CW_CCW_2_CTL (* (reg8 *) CW_CCW_2__CTL)
/* Drive Modes */
#define CW_CCW_2_DM0 (* (reg8 *) CW_CCW_2__DM0)
#define CW_CCW_2_DM1 (* (reg8 *) CW_CCW_2__DM1)
#define CW_CCW_2_DM2 (* (reg8 *) CW_CCW_2__DM2)
/* Input Buffer Disable Override */
#define CW_CCW_2_INP_DIS (* (reg8 *) CW_CCW_2__INP_DIS)
/* LCD Common or Segment Drive */
#define CW_CCW_2_LCD_COM_SEG (* (reg8 *) CW_CCW_2__LCD_COM_SEG)
/* Enable Segment LCD */
#define CW_CCW_2_LCD_EN (* (reg8 *) CW_CCW_2__LCD_EN)
/* Slew Rate Control */
#define CW_CCW_2_SLW (* (reg8 *) CW_CCW_2__SLW)
/* DSI Port Registers */
/* Global DSI Select Register */
#define CW_CCW_2_PRTDSI__CAPS_SEL (* (reg8 *) CW_CCW_2__PRTDSI__CAPS_SEL)
/* Double Sync Enable */
#define CW_CCW_2_PRTDSI__DBL_SYNC_IN (* (reg8 *) CW_CCW_2__PRTDSI__DBL_SYNC_IN)
/* Output Enable Select Drive Strength */
#define CW_CCW_2_PRTDSI__OE_SEL0 (* (reg8 *) CW_CCW_2__PRTDSI__OE_SEL0)
#define CW_CCW_2_PRTDSI__OE_SEL1 (* (reg8 *) CW_CCW_2__PRTDSI__OE_SEL1)
/* Port Pin Output Select Registers */
#define CW_CCW_2_PRTDSI__OUT_SEL0 (* (reg8 *) CW_CCW_2__PRTDSI__OUT_SEL0)
#define CW_CCW_2_PRTDSI__OUT_SEL1 (* (reg8 *) CW_CCW_2__PRTDSI__OUT_SEL1)
/* Sync Output Enable Registers */
#define CW_CCW_2_PRTDSI__SYNC_OUT (* (reg8 *) CW_CCW_2__PRTDSI__SYNC_OUT)
#if defined(CW_CCW_2__INTSTAT) /* Interrupt Registers */
#define CW_CCW_2_INTSTAT (* (reg8 *) CW_CCW_2__INTSTAT)
#define CW_CCW_2_SNAP (* (reg8 *) CW_CCW_2__SNAP)
#endif /* Interrupt Registers */
#endif /* CY_PSOC5A... */
#endif /* CY_PINS_CW_CCW_2_H */
/* [] END OF FILE */
| [
"sakai7213@yahoo.co.jp"
] | sakai7213@yahoo.co.jp |
65b0727225ae44aef3171c7c096b1c5977a21a35 | e5699fc9424fba568b4ee5ffc1e3b8b38a9e066e | /motorola_chun/moto_upload.h | e7b08222afb5183db965ee98a4e5ac028d53cea0 | [] | no_license | xfdingustc/smash | 035a1bb894101cb79da833e496c02d504867552c | ba6db5730d4153f3151752e3095b3c1a855e9aa3 | refs/heads/master | 2020-12-02T07:54:37.085011 | 2017-07-10T06:49:06 | 2017-07-10T06:49:06 | 96,732,012 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,124 | h |
#ifndef __MOTO_UPLOAD_H_
#define __MOTO_UPLOAD_H_ 1
#include "elist.h"
#include "moto_manifest.h"
typedef struct chunk_header_item_s
{
char key[128];
char value[128];
list_head_t list_node;
}chunk_header_item_t;
typedef struct chunk_info_s
{
int chunk_start;
int length;
char url[1024];
list_head_t list_node;
list_head_t header_list;
}chunk_info_t;
/*
typedef struct file_info_s
{
char id[40];
char name[64];
int size;
list_head_t chunk_list;
}file_info_t;
typedef struct upload_detail_s
{
file_info_t mp4_file;
file_info_t pic_file;
char complete_url[1024];
}upload_detail_t;
*/
typedef struct moto_upload_des_s moto_upload_des_t;
int moto_camera_query_oauth_token(const char *host, int port, const char *tls_crt, const char *tls_key, char *token, int token_size);
int moto_camera_query_incident(const char *host, int port, const char *tls_crt, const char *tls_key,
const char *incident_id,const char *token, char *json, int json_size);
int moto_camera_upload_request(moto_upload_des_t *pc, int *result);
void moto_camera_free_upload_detail(moto_upload_des_t *pd);
#endif //__MOTO_UPLOAD_H_
| [
"ding.xiaofei@whaley.cn"
] | ding.xiaofei@whaley.cn |
459aa620f35801b7a112f3a6a6644554730345d1 | 5c255f911786e984286b1f7a4e6091a68419d049 | /vulnerable_code/f35deb29-2c46-4c19-b642-88ae78ea0432.c | a149feba1883a4752e9c3d510144be915a9e1217 | [] | no_license | nmharmon8/Deep-Buffer-Overflow-Detection | 70fe02c8dc75d12e91f5bc4468cf260e490af1a4 | e0c86210c86afb07c8d4abcc957c7f1b252b4eb2 | refs/heads/master | 2021-09-11T19:09:59.944740 | 2018-04-06T16:26:34 | 2018-04-06T16:26:34 | 125,521,331 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 561 | c | #include <string.h>
#include <stdio.h>
int main() {
int i=0;
int j=11;
int k;
int l;
k = 53;
l = 64;
k = i/j;
l = i/j;
l = i/j;
l = l%j;
l = j%j;
l = l-j;
k = k-k*i;
//variables
//random
/* START VULNERABILITY */
int a;
char b[94];
char c[45];
a = 0;
while (b[a] != 0) {
/* START BUFFER SET */
*((char *)c + a) = *((char *)b + a);
/* END BUFFER SET */
a++;
}
/* END VULNERABILITY */
printf("%d%d\n",k,l);
return 0;
}
| [
"nharmon8@gmail.com"
] | nharmon8@gmail.com |
5a76fa0761a6b8f7345a1bf05ab1bcba1f996966 | 3957b75b75db4d5bec6ffaba9670a3fdab80e7b9 | /user/mqtt_cb.h | 0b96bda8f67c1953a35017ffd856b699a7272fa3 | [] | no_license | wpawel74/04-ESP8266_IOT_LIGHT_NODE | d59dda0d0887402ab4831e1b7cec49ef5465aac5 | b2c568e27fc1385538bf9b4ab2d3c2d03113c2f3 | refs/heads/master | 2021-01-11T04:08:23.178947 | 2018-01-18T14:51:39 | 2018-01-18T14:51:39 | 71,218,150 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 329 | h | #ifndef MQTT_CB_H
#define MQTT_CB_H
#include "mqtt.h"
extern MQTT_Client mqttClient;
void mqttConnectedCb(uint32_t *args);
void mqttDisconnectedCb(uint32_t *args);
void mqttDataCb(uint32_t *args, const char* topic, uint32_t topic_len, const char *data, uint32_t lengh);
void mqttPublishedCb(uint32_t *args);
#endif // MQTT_CB | [
"wisniewski@bury.com"
] | wisniewski@bury.com |
b47cee8563535115fb1bae97d3bf5608162a16c7 | 4c0b9cb2ea2f2b2ad02f95203cde8c975d6bb4b6 | /C01/ex05/ft_putstr.c | f30fb5cb9ab0c83bc7a4546b9ee3dd3e72b63d4d | [] | no_license | worldii/42SEOUL | 5b6c179b5e989eb99ce99ea34f2a673239d7f72d | a592e4dabf7a3cb5fcee3b639073a5bb0b554d9e | refs/heads/master | 2023-08-23T05:06:23.227548 | 2021-11-01T02:19:31 | 2021-11-01T02:19:31 | 423,310,648 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,074 | c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jonghapa <bbc2788@naver.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/10/10 13:04:35 by jonghapa #+# #+# */
/* Updated: 2021/10/13 23:13:03 by jonghapa ### ########.fr */
/* */
/* ************************************************************************** */
#include<unistd.h>
void ft_putchar(char a)
{
write(1, &a, 1);
}
void ft_putstr(char *str)
{
int idx;
idx = 0;
while (str[idx] != '\0')
{
ft_putchar(str[idx]);
idx++;
}
}
| [
"jongha2788@u.sogang.ac.kr"
] | jongha2788@u.sogang.ac.kr |
f8d5f1fd87747f5bc4a5572e5c88a40246f59b76 | c1a8e75227512a30db772c92973c7b179d4eaa67 | /Test/Classes/Native/mscorlib_System_Array_InternalEnumerator_1_gen_30.h | d52820092a898e9832069637a0a6d3c2a836a339 | [] | no_license | joshtwynham/dissertation | 266f5463d970e15bf5b0842c881ff65c9c85389c | b860fc4ae2b6152d0aea15b36036904b4a88bd15 | refs/heads/master | 2021-01-10T09:20:17.128871 | 2016-04-17T16:07:36 | 2016-04-17T16:07:36 | 49,824,777 | 0 | 0 | null | 2016-02-02T11:36:07 | 2016-01-17T16:14:25 | C++ | UTF-8 | C | false | false | 509 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
// System.Array
struct Array_t;
#include "mscorlib_System_ValueType.h"
// System.Array/InternalEnumerator`1<UnityEngine.Color32>
struct InternalEnumerator_1_t1886
{
// System.Array System.Array/InternalEnumerator`1<UnityEngine.Color32>::array
Array_t * ___array_0;
// System.Int32 System.Array/InternalEnumerator`1<UnityEngine.Color32>::idx
int32_t ___idx_1;
};
| [
"psyjt1@nottingham.ac.uk"
] | psyjt1@nottingham.ac.uk |
2bd5251acc207799b280f673c40282153f0c372d | 6d5436affb79a9311829bc9f805033999f1153e6 | /src/operations/swap.c | 73f9a0955845b2b1065c692469c771f2544a1ce3 | [] | no_license | qypec/push-swap | eb5d11559065e18f5a2fd2c4381975cc4aff70f2 | 41a92b806ef5f1ca2c4ebf5a811fb7de8be76099 | refs/heads/master | 2022-11-18T07:41:17.347719 | 2020-07-07T12:56:58 | 2020-07-07T12:56:58 | 220,012,177 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,437 | c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* swap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: yquaro <yquaro@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/11/09 18:25:43 by yquaro #+# #+# */
/* Updated: 2020/02/06 20:57:25 by yquaro ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
void swap_a(t_stack *stack)
{
size_t tmp;
if (stack->a->used_size < 2)
return ;
tmp = stack->a->num[0];
stack->a->num[0] = stack->a->num[1];
stack->a->num[1] = tmp;
add_operation(&(stack->operation), "sa");
}
void swap_b(t_stack *stack)
{
size_t tmp;
if (stack->b->used_size < 2)
return ;
tmp = stack->b->num[0];
stack->b->num[0] = stack->b->num[1];
stack->b->num[1] = tmp;
add_operation(&(stack->operation), "sb");
}
void swap_ab(t_stack *stack)
{
swap_a(stack);
swap_b(stack);
}
| [
"qypec.prog@yandex.ru"
] | qypec.prog@yandex.ru |
016c154fcf69032ff39b53a878318ce02d79d98a | 43fc37d7211d538eb6681aa871fb99892a7d711a | /unix/errno.c | 6e8166e795c39b05819e0cdf55da858826af7369 | [] | no_license | gyhdtc/Unix_Systems_Programming | 6f9fcaa82eb694e56f01674f44be34ba7920c085 | 95bee106d7d17a754be94e61a55a34569f3cc6db | refs/heads/master | 2020-05-24T22:25:12.807771 | 2019-05-30T17:30:58 | 2019-05-30T17:30:58 | 187,496,659 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 618 | c | #include <unistd.h>
#include <stdio.h>
/* 对应于全局的错误信息变量 */
int errno;
int fildes;
/*
EBADF fildes 无效
EINTR close 信号中断
*/
int close(int fildes);
char *strerror(int errnum)
{
}
void perror(const char *s)
{
int error;
if (s != NULL)
{
error = errno;
fprintf(stderr, "%s descriptor %d: %s\n",s, fildes, strerror(errno));
// 输出对应于 errno 的错误信息
errno = error;
}
}
int main()
{
//while((errno = close(fildes) == -1) && (errno == EINTR));
if (close(fildes) == -1)
perror("Failed to close the file");
} | [
"you@example.com"
] | you@example.com |
fcde30d3d84aa449df8b08861a5dd1f6df2dad4b | de93128179196d92599312c8db3a31a6f556ef35 | /Microchip/SAMR34_DFP/2.1.60/include/samr34j16b.h | 4d2cfbcaa4217f9010ab8ba7bc33404739020739 | [
"Apache-2.0"
] | permissive | marcins1024/dev_packs | 5a6a7b5379856bcf75ee9bc283db6743eca2241a | afa97e11185a60e9bc44e0a3550f0ba3eb818679 | refs/heads/master | 2023-08-04T08:32:16.607078 | 2021-09-22T10:18:05 | 2021-09-22T10:18:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 47,425 | h | /**
* \brief Header file for ATSAMR34J16B
*
* Copyright (c) 2021 Microchip Technology Inc. and its subsidiaries.
*
* Subject to your compliance with these terms, you may use Microchip software and any derivatives
* exclusively with Microchip products. It is your responsibility to comply with third party license
* terms applicable to your use of third party software (including open source software) that may
* accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY,
* APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND
* FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF
* MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT
* EXCEED THE AMOUNT OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
*/
/* file generated from device description version 2021-01-29T16:40:22Z */
#ifndef _SAMR34J16B_H_
#define _SAMR34J16B_H_
// Header version uses Semantic Versioning 2.0.0 (https://semver.org/)
#define HEADER_FORMAT_VERSION "2.0.0"
#define HEADER_FORMAT_VERSION_MAJOR (2)
#define HEADER_FORMAT_VERSION_MINOR (0)
/** \addtogroup SAMR34J16B_definitions SAMR34J16B definitions
This file defines all structures and symbols for SAMR34J16B:
- registers and bitfields
- peripheral base address
- peripheral ID
- PIO definitions
* @{
*/
#ifdef __cplusplus
extern "C" {
#endif
#if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__))
# include <stdint.h>
#endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */
#if !defined(SKIP_INTEGER_LITERALS)
# if defined(_U_) || defined(_L_) || defined(_UL_)
# error "Integer Literals macros already defined elsewhere"
# endif
#if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__))
/* Macros that deal with adding suffixes to integer literal constants for C/C++ */
# define _U_(x) (x ## U) /**< C code: Unsigned integer literal constant value */
# define _L_(x) (x ## L) /**< C code: Long integer literal constant value */
# define _UL_(x) (x ## UL) /**< C code: Unsigned Long integer literal constant value */
#else /* Assembler */
# define _U_(x) x /**< Assembler: Unsigned integer literal constant value */
# define _L_(x) x /**< Assembler: Long integer literal constant value */
# define _UL_(x) x /**< Assembler: Unsigned Long integer literal constant value */
#endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */
#endif /* SKIP_INTEGER_LITERALS */
/** @} end of Atmel Global Defines */
/* ************************************************************************** */
/* CMSIS DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__))
/** Interrupt Number Definition */
typedef enum IRQn
{
/****** CORTEX-M0PLUS Processor Exceptions Numbers ******************************/
Reset_IRQn = -15, /**< -15 Reset Vector, invoked on Power up and warm reset */
NonMaskableInt_IRQn = -14, /**< -14 Non maskable Interrupt, cannot be stopped or preempted */
HardFault_IRQn = -13, /**< -13 Hard Fault, all classes of Fault */
SVCall_IRQn = -5, /**< -5 System Service Call via SVC instruction */
PendSV_IRQn = -2, /**< -2 Pendable request for system service */
SysTick_IRQn = -1, /**< -1 System Tick Timer */
/****** SAMR34J16B specific Interrupt Numbers ***********************************/
OSC32KCTRL_IRQn = 0, /**< 0 Shared between MCLK OSCCTRL OSC32KCTRL PAC PM SUPC (OSC32KCTRL) */
OSCCTRL_IRQn = 0, /**< 0 Shared between MCLK OSCCTRL OSC32KCTRL PAC PM SUPC (OSCCTRL) */
MCLK_IRQn = 0, /**< 0 Shared between MCLK OSCCTRL OSC32KCTRL PAC PM SUPC (MCLK) */
PAC_IRQn = 0, /**< 0 Shared between MCLK OSCCTRL OSC32KCTRL PAC PM SUPC (PAC) */
SUPC_IRQn = 0, /**< 0 Shared between MCLK OSCCTRL OSC32KCTRL PAC PM SUPC (SUPC) */
PM_IRQn = 0, /**< 0 Shared between MCLK OSCCTRL OSC32KCTRL PAC PM SUPC (PM) */
WDT_IRQn = 1, /**< 1 Watchdog Timer (WDT) */
RTC_IRQn = 2, /**< 2 Real-Time Counter (RTC) */
EIC_IRQn = 3, /**< 3 External Interrupt Controller (EIC) */
NVMCTRL_IRQn = 4, /**< 4 Non-Volatile Memory Controller (NVMCTRL) */
DMAC_IRQn = 5, /**< 5 Direct Memory Access Controller (DMAC) */
USB_IRQn = 6, /**< 6 Universal Serial Bus (USB) */
EVSYS_IRQn = 7, /**< 7 Event System Interface (EVSYS) */
SERCOM0_IRQn = 8, /**< 8 Serial Communication Interface (SERCOM0) */
SERCOM1_IRQn = 9, /**< 9 Serial Communication Interface (SERCOM1) */
SERCOM2_IRQn = 10, /**< 10 Serial Communication Interface (SERCOM2) */
SERCOM3_IRQn = 11, /**< 11 Serial Communication Interface (SERCOM3) */
SERCOM4_IRQn = 12, /**< 12 Serial Communication Interface (SERCOM4) */
SERCOM5_IRQn = 13, /**< 13 Serial Communication Interface (SERCOM5) */
TCC0_IRQn = 14, /**< 14 Timer Counter Control (TCC0) */
TCC1_IRQn = 15, /**< 15 Timer Counter Control (TCC1) */
TCC2_IRQn = 16, /**< 16 Timer Counter Control (TCC2) */
TC0_IRQn = 17, /**< 17 Basic Timer Counter (TC0) */
TC1_IRQn = 18, /**< 18 Basic Timer Counter (TC1) */
TC2_IRQn = 19, /**< 19 Basic Timer Counter (TC2) */
TC3_IRQn = 20, /**< 20 Basic Timer Counter (TC3) */
TC4_IRQn = 21, /**< 21 Basic Timer Counter (TC4) */
ADC_IRQn = 22, /**< 22 Analog Digital Converter (ADC) */
AC_IRQn = 23, /**< 23 Analog Comparators (AC) */
PTC_IRQn = 25, /**< 25 Peripheral Touch Controller (PTC) */
AES_IRQn = 26, /**< 26 Advanced Encryption Standard (AES) */
TRNG_IRQn = 27, /**< 27 True Random Generator (TRNG) */
PERIPH_MAX_IRQn = 27 /**< Max peripheral ID */
} IRQn_Type;
#endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */
#if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__))
typedef struct _DeviceVectors
{
/* Stack pointer */
void* pvStack;
/* CORTEX-M0PLUS handlers */
void* pfnReset_Handler; /* -15 Reset Vector, invoked on Power up and warm reset */
void* pfnNonMaskableInt_Handler; /* -14 Non maskable Interrupt, cannot be stopped or preempted */
void* pfnHardFault_Handler; /* -13 Hard Fault, all classes of Fault */
void* pvReservedC12;
void* pvReservedC11;
void* pvReservedC10;
void* pvReservedC9;
void* pvReservedC8;
void* pvReservedC7;
void* pvReservedC6;
void* pfnSVCall_Handler; /* -5 System Service Call via SVC instruction */
void* pvReservedC4;
void* pvReservedC3;
void* pfnPendSV_Handler; /* -2 Pendable request for system service */
void* pfnSysTick_Handler; /* -1 System Tick Timer */
/* Peripheral handlers */
void* pfnSYSTEM_Handler; /* 0 System peripherals shared interrupt (MCLK OSCCTRL OSC32KCTRL PAC PM SUPC) */
void* pfnWDT_Handler; /* 1 Watchdog Timer (WDT) */
void* pfnRTC_Handler; /* 2 Real-Time Counter (RTC) */
void* pfnEIC_Handler; /* 3 External Interrupt Controller (EIC) */
void* pfnNVMCTRL_Handler; /* 4 Non-Volatile Memory Controller (NVMCTRL) */
void* pfnDMAC_Handler; /* 5 Direct Memory Access Controller (DMAC) */
void* pfnUSB_Handler; /* 6 Universal Serial Bus (USB) */
void* pfnEVSYS_Handler; /* 7 Event System Interface (EVSYS) */
void* pfnSERCOM0_Handler; /* 8 Serial Communication Interface (SERCOM0) */
void* pfnSERCOM1_Handler; /* 9 Serial Communication Interface (SERCOM1) */
void* pfnSERCOM2_Handler; /* 10 Serial Communication Interface (SERCOM2) */
void* pfnSERCOM3_Handler; /* 11 Serial Communication Interface (SERCOM3) */
void* pfnSERCOM4_Handler; /* 12 Serial Communication Interface (SERCOM4) */
void* pfnSERCOM5_Handler; /* 13 Serial Communication Interface (SERCOM5) */
void* pfnTCC0_Handler; /* 14 Timer Counter Control (TCC0) */
void* pfnTCC1_Handler; /* 15 Timer Counter Control (TCC1) */
void* pfnTCC2_Handler; /* 16 Timer Counter Control (TCC2) */
void* pfnTC0_Handler; /* 17 Basic Timer Counter (TC0) */
void* pfnTC1_Handler; /* 18 Basic Timer Counter (TC1) */
void* pfnTC2_Handler; /* 19 Basic Timer Counter (TC2) */
void* pfnTC3_Handler; /* 20 Basic Timer Counter (TC3) */
void* pfnTC4_Handler; /* 21 Basic Timer Counter (TC4) */
void* pfnADC_Handler; /* 22 Analog Digital Converter (ADC) */
void* pfnAC_Handler; /* 23 Analog Comparators (AC) */
void* pvReserved24;
void* pfnPTC_Handler; /* 25 Peripheral Touch Controller (PTC) */
void* pfnAES_Handler; /* 26 Advanced Encryption Standard (AES) */
void* pfnTRNG_Handler; /* 27 True Random Generator (TRNG) */
} DeviceVectors;
#endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */
#if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__))
#if !defined DONT_USE_PREDEFINED_CORE_HANDLERS
/* CORTEX-M0PLUS exception handlers */
void Reset_Handler ( void );
void NonMaskableInt_Handler ( void );
void HardFault_Handler ( void );
void SVCall_Handler ( void );
void PendSV_Handler ( void );
void SysTick_Handler ( void );
#endif /* DONT_USE_PREDEFINED_CORE_HANDLERS */
#if !defined DONT_USE_PREDEFINED_PERIPHERALS_HANDLERS
/* Peripherals interrupt handlers */
void SYSTEM_Handler ( void );
void WDT_Handler ( void );
void RTC_Handler ( void );
void EIC_Handler ( void );
void NVMCTRL_Handler ( void );
void DMAC_Handler ( void );
void USB_Handler ( void );
void EVSYS_Handler ( void );
void SERCOM0_Handler ( void );
void SERCOM1_Handler ( void );
void SERCOM2_Handler ( void );
void SERCOM3_Handler ( void );
void SERCOM4_Handler ( void );
void SERCOM5_Handler ( void );
void TCC0_Handler ( void );
void TCC1_Handler ( void );
void TCC2_Handler ( void );
void TC0_Handler ( void );
void TC1_Handler ( void );
void TC2_Handler ( void );
void TC3_Handler ( void );
void TC4_Handler ( void );
void ADC_Handler ( void );
void AC_Handler ( void );
void PTC_Handler ( void );
void AES_Handler ( void );
void TRNG_Handler ( void );
#endif /* DONT_USE_PREDEFINED_PERIPHERALS_HANDLERS */
#endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */
/** \brief Configuration of the CORTEX-M0PLUS Processor and Core Peripherals */
#define __CM0PLUS_REV 0x0001 /**< Cortex-M0+ Core Revision */
#define __MPU_PRESENT 0 /**< MPU present or not */
#define __NVIC_PRIO_BITS 2 /**< Number of Bits used for Priority Levels */
#define __VTOR_PRESENT 1 /**< Vector Table Offset Register present or not */
#define __Vendor_SysTickConfig 0 /**< Set to 1 if different SysTick Config is used */
#define __ARCH_ARM 1
#define __ARCH_ARM_CORTEX_M 1
/*
* \brief CMSIS includes
*/
#include "core_cm0plus.h"
#if defined USE_CMSIS_INIT
#include "system_samr34.h"
#endif /* USE_CMSIS_INIT */
/** \defgroup SAMR34J16B_api Peripheral Software API
* @{
*/
/* ************************************************************************** */
/** SOFTWARE PERIPHERAL API DEFINITION FOR SAMR34J16B */
/* ************************************************************************** */
#include "component/ac.h"
#include "component/adc.h"
#include "component/aes.h"
#include "component/ccl.h"
#include "component/dmac.h"
#include "component/dsu.h"
#include "component/eic.h"
#include "component/evsys.h"
#include "component/gclk.h"
#include "component/mclk.h"
#include "component/mtb.h"
#include "component/nvmctrl.h"
#include "component/osc32kctrl.h"
#include "component/oscctrl.h"
#include "component/pac.h"
#include "component/pm.h"
#include "component/port.h"
#include "component/ptc.h"
#include "component/rstc.h"
#include "component/rtc.h"
#include "component/sercom.h"
#include "component/supc.h"
#include "component/tc.h"
#include "component/tcc.h"
#include "component/trng.h"
#include "component/usb.h"
#include "component/wdt.h"
/** @} end of Peripheral Software API */
/* ************************************************************************** */
/* INSTANCE DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#include "instance/ac.h"
#include "instance/adc.h"
#include "instance/aes.h"
#include "instance/ccl.h"
#include "instance/dmac.h"
#include "instance/dsu.h"
#include "instance/eic.h"
#include "instance/evsys.h"
#include "instance/gclk.h"
#include "instance/mclk.h"
#include "instance/mtb.h"
#include "instance/nvmctrl.h"
#include "instance/osc32kctrl.h"
#include "instance/oscctrl.h"
#include "instance/pac.h"
#include "instance/pm.h"
#include "instance/port.h"
#include "instance/ptc.h"
#include "instance/rstc.h"
#include "instance/rtc.h"
#include "instance/sercom0.h"
#include "instance/sercom1.h"
#include "instance/sercom2.h"
#include "instance/sercom3.h"
#include "instance/sercom4.h"
#include "instance/sercom5.h"
#include "instance/supc.h"
#include "instance/tc0.h"
#include "instance/tc1.h"
#include "instance/tc2.h"
#include "instance/tc3.h"
#include "instance/tc4.h"
#include "instance/tcc0.h"
#include "instance/tcc1.h"
#include "instance/tcc2.h"
#include "instance/trng.h"
#include "instance/usb.h"
#include "instance/wdt.h"
/** \addtogroup SAMR34J16B_id Peripheral Ids Definitions
* @{
*/
/* ************************************************************************** */
/* PERIPHERAL ID DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#define ID_PM ( 0) /**< \brief Power Manager (PM) */
#define ID_MCLK ( 1) /**< \brief Main Clock (MCLK) */
#define ID_RSTC ( 2) /**< \brief Reset Controller (RSTC) */
#define ID_OSCCTRL ( 3) /**< \brief Oscillators Control (OSCCTRL) */
#define ID_OSC32KCTRL ( 4) /**< \brief 32k Oscillators Control (OSC32KCTRL) */
#define ID_SUPC ( 5) /**< \brief Supply Controller (SUPC) */
#define ID_GCLK ( 6) /**< \brief Generic Clock Generator (GCLK) */
#define ID_WDT ( 7) /**< \brief Watchdog Timer (WDT) */
#define ID_RTC ( 8) /**< \brief Real-Time Counter (RTC) */
#define ID_EIC ( 9) /**< \brief External Interrupt Controller (EIC) */
#define ID_PORT ( 10) /**< \brief Port Module (PORT) */
#define ID_USB ( 32) /**< \brief Universal Serial Bus (USB) */
#define ID_DSU ( 33) /**< \brief Device Service Unit (DSU) */
#define ID_NVMCTRL ( 34) /**< \brief Non-Volatile Memory Controller (NVMCTRL) */
#define ID_MTB ( 35) /**< \brief Cortex-M0+ Micro-Trace Buffer (MTB) */
#define ID_SERCOM0 ( 64) /**< \brief Serial Communication Interface (SERCOM0) */
#define ID_SERCOM1 ( 65) /**< \brief Serial Communication Interface (SERCOM1) */
#define ID_SERCOM2 ( 66) /**< \brief Serial Communication Interface (SERCOM2) */
#define ID_SERCOM3 ( 67) /**< \brief Serial Communication Interface (SERCOM3) */
#define ID_SERCOM4 ( 68) /**< \brief Serial Communication Interface (SERCOM4) */
#define ID_TCC0 ( 69) /**< \brief Timer Counter Control (TCC0) */
#define ID_TCC1 ( 70) /**< \brief Timer Counter Control (TCC1) */
#define ID_TCC2 ( 71) /**< \brief Timer Counter Control (TCC2) */
#define ID_TC0 ( 72) /**< \brief Basic Timer Counter (TC0) */
#define ID_TC1 ( 73) /**< \brief Basic Timer Counter (TC1) */
#define ID_TC2 ( 74) /**< \brief Basic Timer Counter (TC2) */
#define ID_TC3 ( 75) /**< \brief Basic Timer Counter (TC3) */
#define ID_AES ( 77) /**< \brief Advanced Encryption Standard (AES) */
#define ID_TRNG ( 78) /**< \brief True Random Generator (TRNG) */
#define ID_EVSYS ( 96) /**< \brief Event System Interface (EVSYS) */
#define ID_SERCOM5 ( 97) /**< \brief Serial Communication Interface (SERCOM5) */
#define ID_TC4 ( 98) /**< \brief Basic Timer Counter (TC4) */
#define ID_ADC ( 99) /**< \brief Analog Digital Converter (ADC) */
#define ID_AC (100) /**< \brief Analog Comparators (AC) */
#define ID_PTC (101) /**< \brief Peripheral Touch Controller (PTC) */
#define ID_CCL (103) /**< \brief Configurable Custom Logic (CCL) */
#define ID_PAC (128) /**< \brief Peripheral Access Controller (PAC) */
#define ID_DMAC (129) /**< \brief Direct Memory Access Controller (DMAC) */
#define ID_PERIPH_MAX (129) /**< \brief Number of peripheral IDs */
/** @} end of Peripheral Ids Definitions */
/** \addtogroup SAMR34J16B_base Peripheral Base Address Definitions
* @{
*/
/* ************************************************************************** */
/* REGISTER STRUCTURE ADDRESS DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__))
#define AC_REGS ((ac_registers_t*)0x43001000) /**< \brief AC Registers Address */
#define ADC_REGS ((adc_registers_t*)0x43000c00) /**< \brief ADC Registers Address */
#define AES_REGS ((aes_registers_t*)0x42003400) /**< \brief AES Registers Address */
#define CCL_REGS ((ccl_registers_t*)0x43001c00) /**< \brief CCL Registers Address */
#define DMAC_REGS ((dmac_registers_t*)0x44000400) /**< \brief DMAC Registers Address */
#define DSU_REGS ((dsu_registers_t*)0x41002000) /**< \brief DSU Registers Address */
#define EIC_REGS ((eic_registers_t*)0x40002400) /**< \brief EIC Registers Address */
#define EVSYS_REGS ((evsys_registers_t*)0x43000000) /**< \brief EVSYS Registers Address */
#define GCLK_REGS ((gclk_registers_t*)0x40001800) /**< \brief GCLK Registers Address */
#define MCLK_REGS ((mclk_registers_t*)0x40000400) /**< \brief MCLK Registers Address */
#define MTB_REGS ((mtb_registers_t*)0x41006000) /**< \brief MTB Registers Address */
#define NVMCTRL_REGS ((nvmctrl_registers_t*)0x41004000) /**< \brief NVMCTRL Registers Address */
#define OSCCTRL_REGS ((oscctrl_registers_t*)0x40000c00) /**< \brief OSCCTRL Registers Address */
#define OSC32KCTRL_REGS ((osc32kctrl_registers_t*)0x40001000) /**< \brief OSC32KCTRL Registers Address */
#define PAC_REGS ((pac_registers_t*)0x44000000) /**< \brief PAC Registers Address */
#define PM_REGS ((pm_registers_t*)0x40000000) /**< \brief PM Registers Address */
#define PORT_REGS ((port_registers_t*)0x40002800) /**< \brief PORT Registers Address */
#define PORT_IOBUS_REGS ((port_registers_t*)0x60000000) /**< \brief PORT Registers Address */
#define PTC_REGS ((ptc_registers_t*)0x43001400) /**< \brief PTC Registers Address */
#define RSTC_REGS ((rstc_registers_t*)0x40000800) /**< \brief RSTC Registers Address */
#define RTC_REGS ((rtc_registers_t*)0x40002000) /**< \brief RTC Registers Address */
#define SERCOM0_REGS ((sercom_registers_t*)0x42000000) /**< \brief SERCOM0 Registers Address */
#define SERCOM1_REGS ((sercom_registers_t*)0x42000400) /**< \brief SERCOM1 Registers Address */
#define SERCOM2_REGS ((sercom_registers_t*)0x42000800) /**< \brief SERCOM2 Registers Address */
#define SERCOM3_REGS ((sercom_registers_t*)0x42000c00) /**< \brief SERCOM3 Registers Address */
#define SERCOM4_REGS ((sercom_registers_t*)0x42001000) /**< \brief SERCOM4 Registers Address */
#define SERCOM5_REGS ((sercom_registers_t*)0x43000400) /**< \brief SERCOM5 Registers Address */
#define SUPC_REGS ((supc_registers_t*)0x40001400) /**< \brief SUPC Registers Address */
#define TC0_REGS ((tc_registers_t*)0x42002000) /**< \brief TC0 Registers Address */
#define TC1_REGS ((tc_registers_t*)0x42002400) /**< \brief TC1 Registers Address */
#define TC2_REGS ((tc_registers_t*)0x42002800) /**< \brief TC2 Registers Address */
#define TC3_REGS ((tc_registers_t*)0x42002c00) /**< \brief TC3 Registers Address */
#define TC4_REGS ((tc_registers_t*)0x43000800) /**< \brief TC4 Registers Address */
#define TCC0_REGS ((tcc_registers_t*)0x42001400) /**< \brief TCC0 Registers Address */
#define TCC1_REGS ((tcc_registers_t*)0x42001800) /**< \brief TCC1 Registers Address */
#define TCC2_REGS ((tcc_registers_t*)0x42001c00) /**< \brief TCC2 Registers Address */
#define TRNG_REGS ((trng_registers_t*)0x42003800) /**< \brief TRNG Registers Address */
#define USB_REGS ((usb_registers_t*)0x41000000) /**< \brief USB Registers Address */
#define WDT_REGS ((wdt_registers_t*)0x40001c00) /**< \brief WDT Registers Address */
#endif /* (defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */
/** @} end of Peripheral Base Address Definitions */
/** \addtogroup SAMR34J16B_base Peripheral Base Address Definitions
* @{
*/
/* ************************************************************************** */
/* BASE ADDRESS DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#define AC_BASE_ADDRESS _UL_(0x43001000) /* AC Base Address */
#define ADC_BASE_ADDRESS _UL_(0x43000c00) /* ADC Base Address */
#define AES_BASE_ADDRESS _UL_(0x42003400) /* AES Base Address */
#define CCL_BASE_ADDRESS _UL_(0x43001c00) /* CCL Base Address */
#define DMAC_BASE_ADDRESS _UL_(0x44000400) /* DMAC Base Address */
#define DSU_BASE_ADDRESS _UL_(0x41002000) /* DSU Base Address */
#define EIC_BASE_ADDRESS _UL_(0x40002400) /* EIC Base Address */
#define EVSYS_BASE_ADDRESS _UL_(0x43000000) /* EVSYS Base Address */
#define GCLK_BASE_ADDRESS _UL_(0x40001800) /* GCLK Base Address */
#define MCLK_BASE_ADDRESS _UL_(0x40000400) /* MCLK Base Address */
#define MTB_BASE_ADDRESS _UL_(0x41006000) /* MTB Base Address */
#define NVMCTRL_BASE_ADDRESS _UL_(0x41004000) /* NVMCTRL Base Address */
#define OSCCTRL_BASE_ADDRESS _UL_(0x40000c00) /* OSCCTRL Base Address */
#define OSC32KCTRL_BASE_ADDRESS _UL_(0x40001000) /* OSC32KCTRL Base Address */
#define PAC_BASE_ADDRESS _UL_(0x44000000) /* PAC Base Address */
#define PM_BASE_ADDRESS _UL_(0x40000000) /* PM Base Address */
#define PORT_BASE_ADDRESS _UL_(0x40002800) /* PORT Base Address */
#define PORT_IOBUS_BASE_ADDRESS _UL_(0x60000000) /* PORT Base Address */
#define PTC_BASE_ADDRESS _UL_(0x43001400) /* PTC Base Address */
#define RSTC_BASE_ADDRESS _UL_(0x40000800) /* RSTC Base Address */
#define RTC_BASE_ADDRESS _UL_(0x40002000) /* RTC Base Address */
#define SERCOM0_BASE_ADDRESS _UL_(0x42000000) /* SERCOM0 Base Address */
#define SERCOM1_BASE_ADDRESS _UL_(0x42000400) /* SERCOM1 Base Address */
#define SERCOM2_BASE_ADDRESS _UL_(0x42000800) /* SERCOM2 Base Address */
#define SERCOM3_BASE_ADDRESS _UL_(0x42000c00) /* SERCOM3 Base Address */
#define SERCOM4_BASE_ADDRESS _UL_(0x42001000) /* SERCOM4 Base Address */
#define SERCOM5_BASE_ADDRESS _UL_(0x43000400) /* SERCOM5 Base Address */
#define SUPC_BASE_ADDRESS _UL_(0x40001400) /* SUPC Base Address */
#define TC0_BASE_ADDRESS _UL_(0x42002000) /* TC0 Base Address */
#define TC1_BASE_ADDRESS _UL_(0x42002400) /* TC1 Base Address */
#define TC2_BASE_ADDRESS _UL_(0x42002800) /* TC2 Base Address */
#define TC3_BASE_ADDRESS _UL_(0x42002c00) /* TC3 Base Address */
#define TC4_BASE_ADDRESS _UL_(0x43000800) /* TC4 Base Address */
#define TCC0_BASE_ADDRESS _UL_(0x42001400) /* TCC0 Base Address */
#define TCC1_BASE_ADDRESS _UL_(0x42001800) /* TCC1 Base Address */
#define TCC2_BASE_ADDRESS _UL_(0x42001c00) /* TCC2 Base Address */
#define TRNG_BASE_ADDRESS _UL_(0x42003800) /* TRNG Base Address */
#define USB_BASE_ADDRESS _UL_(0x41000000) /* USB Base Address */
#define WDT_BASE_ADDRESS _UL_(0x40001c00) /* WDT Base Address */
/** @} end of Peripheral Base Address Definitions */
/** \addtogroup SAMR34J16B_pio Peripheral Pio Definitions
* @{
*/
/* ************************************************************************** */
/* PIO DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#include "pio/samr34j16b.h"
/** @} end of Peripheral Pio Definitions */
/* ************************************************************************** */
/* MEMORY MAPPING DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
#define FLASH_SIZE _UL_(0x00010000) /* 64kB Memory segment type: flash */
#define FLASH_PAGE_SIZE _UL_( 64)
#define FLASH_NB_OF_PAGES _UL_( 1024)
#define CAL_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define LOCKBIT_SIZE _UL_(0x00000004) /* 0kB Memory segment type: fuses */
#define OTP1_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define OTP2_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define OTP3_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define OTP4_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define OTP5_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define TEMP_LOG_SIZE _UL_(0x00000008) /* 0kB Memory segment type: fuses */
#define USER_PAGE_SIZE _UL_(0x00000100) /* 0kB Memory segment type: user_page */
#define USER_PAGE_PAGE_SIZE _UL_( 64)
#define USER_PAGE_NB_OF_PAGES _UL_( 4)
#define RWW_SIZE _UL_(0x00000800) /* 2kB Memory segment type: flash */
#define RWW_PAGE_SIZE _UL_( 64)
#define RWW_NB_OF_PAGES _UL_( 32)
#define HSRAM_SIZE _UL_(0x00002000) /* 8kB Memory segment type: ram */
#define LPRAM_SIZE _UL_(0x00001000) /* 4kB Memory segment type: ram */
#define HPB0_SIZE _UL_(0x00004000) /* 16kB Memory segment type: io */
#define HPB1_SIZE _UL_(0x00010000) /* 64kB Memory segment type: io */
#define HPB2_SIZE _UL_(0x00008000) /* 32kB Memory segment type: io */
#define HPB3_SIZE _UL_(0x00002000) /* 8kB Memory segment type: io */
#define HPB4_SIZE _UL_(0x00001000) /* 4kB Memory segment type: io */
#define PPB_SIZE _UL_(0x00100000) /* 1024kB Memory segment type: io */
#define SCS_SIZE _UL_(0x00001000) /* 4kB Memory segment type: io */
#define PERIPHERALS_SIZE _UL_(0x20000000) /* 524288kB Memory segment type: io */
#define FLASH_ADDR _UL_(0x00000000) /**< FLASH base address (type: flash)*/
#define CAL_ADDR _UL_(0x00800000) /**< CAL base address (type: fuses)*/
#define LOCKBIT_ADDR _UL_(0x00802000) /**< LOCKBIT base address (type: fuses)*/
#define OTP1_ADDR _UL_(0x00806000) /**< OTP1 base address (type: fuses)*/
#define OTP2_ADDR _UL_(0x00806008) /**< OTP2 base address (type: fuses)*/
#define OTP3_ADDR _UL_(0x00806010) /**< OTP3 base address (type: fuses)*/
#define OTP4_ADDR _UL_(0x00806018) /**< OTP4 base address (type: fuses)*/
#define OTP5_ADDR _UL_(0x00806020) /**< OTP5 base address (type: fuses)*/
#define TEMP_LOG_ADDR _UL_(0x00806030) /**< TEMP_LOG base address (type: fuses)*/
#define USER_PAGE_ADDR _UL_(0x00804000) /**< USER_PAGE base address (type: user_page)*/
#define RWW_ADDR _UL_(0x00400000) /**< RWW base address (type: flash)*/
#define HSRAM_ADDR _UL_(0x20000000) /**< HSRAM base address (type: ram)*/
#define LPRAM_ADDR _UL_(0x30000000) /**< LPRAM base address (type: ram)*/
#define HPB0_ADDR _UL_(0x40000000) /**< HPB0 base address (type: io)*/
#define HPB1_ADDR _UL_(0x41000000) /**< HPB1 base address (type: io)*/
#define HPB2_ADDR _UL_(0x42000000) /**< HPB2 base address (type: io)*/
#define HPB3_ADDR _UL_(0x43000000) /**< HPB3 base address (type: io)*/
#define HPB4_ADDR _UL_(0x44000000) /**< HPB4 base address (type: io)*/
#define PPB_ADDR _UL_(0xe0000000) /**< PPB base address (type: io)*/
#define SCS_ADDR _UL_(0xe000e000) /**< SCS base address (type: io)*/
#define PERIPHERALS_ADDR _UL_(0x40000000) /**< PERIPHERALS base address (type: io)*/
/* ************************************************************************** */
/** DEVICE SIGNATURES FOR SAMR34J16B */
/* ************************************************************************** */
#define CHIP_DSU_DID _UL_(0X1081022A)
/* ************************************************************************** */
/** ELECTRICAL DEFINITIONS FOR SAMR34J16B */
/* ************************************************************************** */
/* ************************************************************************** */
/** Event Generator IDs for SAMR34J16B */
/* ************************************************************************** */
#define EVENT_ID_GEN_RTC_CMP_0 1 /**< ID for RTC event generator CMP_0 */
#define EVENT_ID_GEN_RTC_CMP_1 2 /**< ID for RTC event generator CMP_1 */
#define EVENT_ID_GEN_RTC_OVF 3 /**< ID for RTC event generator OVF */
#define EVENT_ID_GEN_RTC_PER_0 4 /**< ID for RTC event generator PER_0 */
#define EVENT_ID_GEN_RTC_PER_1 5 /**< ID for RTC event generator PER_1 */
#define EVENT_ID_GEN_RTC_PER_2 6 /**< ID for RTC event generator PER_2 */
#define EVENT_ID_GEN_RTC_PER_3 7 /**< ID for RTC event generator PER_3 */
#define EVENT_ID_GEN_RTC_PER_4 8 /**< ID for RTC event generator PER_4 */
#define EVENT_ID_GEN_RTC_PER_5 9 /**< ID for RTC event generator PER_5 */
#define EVENT_ID_GEN_RTC_PER_6 10 /**< ID for RTC event generator PER_6 */
#define EVENT_ID_GEN_RTC_PER_7 11 /**< ID for RTC event generator PER_7 */
#define EVENT_ID_GEN_EIC_EXTINT_0 12 /**< ID for EIC event generator EXTINT_0 */
#define EVENT_ID_GEN_EIC_EXTINT_1 13 /**< ID for EIC event generator EXTINT_1 */
#define EVENT_ID_GEN_EIC_EXTINT_2 14 /**< ID for EIC event generator EXTINT_2 */
#define EVENT_ID_GEN_EIC_EXTINT_3 15 /**< ID for EIC event generator EXTINT_3 */
#define EVENT_ID_GEN_EIC_EXTINT_4 16 /**< ID for EIC event generator EXTINT_4 */
#define EVENT_ID_GEN_EIC_EXTINT_5 17 /**< ID for EIC event generator EXTINT_5 */
#define EVENT_ID_GEN_EIC_EXTINT_6 18 /**< ID for EIC event generator EXTINT_6 */
#define EVENT_ID_GEN_EIC_EXTINT_7 19 /**< ID for EIC event generator EXTINT_7 */
#define EVENT_ID_GEN_EIC_EXTINT_8 20 /**< ID for EIC event generator EXTINT_8 */
#define EVENT_ID_GEN_EIC_EXTINT_9 21 /**< ID for EIC event generator EXTINT_9 */
#define EVENT_ID_GEN_EIC_EXTINT_10 22 /**< ID for EIC event generator EXTINT_10 */
#define EVENT_ID_GEN_EIC_EXTINT_11 23 /**< ID for EIC event generator EXTINT_11 */
#define EVENT_ID_GEN_EIC_EXTINT_12 24 /**< ID for EIC event generator EXTINT_12 */
#define EVENT_ID_GEN_EIC_EXTINT_13 25 /**< ID for EIC event generator EXTINT_13 */
#define EVENT_ID_GEN_EIC_EXTINT_14 26 /**< ID for EIC event generator EXTINT_14 */
#define EVENT_ID_GEN_EIC_EXTINT_15 27 /**< ID for EIC event generator EXTINT_15 */
#define EVENT_ID_GEN_DMAC_CH_0 28 /**< ID for DMAC event generator CH_0 */
#define EVENT_ID_GEN_DMAC_CH_1 29 /**< ID for DMAC event generator CH_1 */
#define EVENT_ID_GEN_DMAC_CH_2 30 /**< ID for DMAC event generator CH_2 */
#define EVENT_ID_GEN_DMAC_CH_3 31 /**< ID for DMAC event generator CH_3 */
#define EVENT_ID_GEN_DMAC_CH_4 32 /**< ID for DMAC event generator CH_4 */
#define EVENT_ID_GEN_DMAC_CH_5 33 /**< ID for DMAC event generator CH_5 */
#define EVENT_ID_GEN_DMAC_CH_6 34 /**< ID for DMAC event generator CH_6 */
#define EVENT_ID_GEN_DMAC_CH_7 35 /**< ID for DMAC event generator CH_7 */
#define EVENT_ID_GEN_TCC0_OVF 36 /**< ID for TCC0 event generator OVF */
#define EVENT_ID_GEN_TCC0_TRG 37 /**< ID for TCC0 event generator TRG */
#define EVENT_ID_GEN_TCC0_CNT 38 /**< ID for TCC0 event generator CNT */
#define EVENT_ID_GEN_TCC0_MCX_0 39 /**< ID for TCC0 event generator MCX_0 */
#define EVENT_ID_GEN_TCC0_MCX_1 40 /**< ID for TCC0 event generator MCX_1 */
#define EVENT_ID_GEN_TCC0_MCX_2 41 /**< ID for TCC0 event generator MCX_2 */
#define EVENT_ID_GEN_TCC0_MCX_3 42 /**< ID for TCC0 event generator MCX_3 */
#define EVENT_ID_GEN_TCC1_OVF 43 /**< ID for TCC1 event generator OVF */
#define EVENT_ID_GEN_TCC1_TRG 44 /**< ID for TCC1 event generator TRG */
#define EVENT_ID_GEN_TCC1_CNT 45 /**< ID for TCC1 event generator CNT */
#define EVENT_ID_GEN_TCC1_MCX_0 46 /**< ID for TCC1 event generator MCX_0 */
#define EVENT_ID_GEN_TCC1_MCX_1 47 /**< ID for TCC1 event generator MCX_1 */
#define EVENT_ID_GEN_TCC2_OVF 48 /**< ID for TCC2 event generator OVF */
#define EVENT_ID_GEN_TCC2_TRG 49 /**< ID for TCC2 event generator TRG */
#define EVENT_ID_GEN_TCC2_CNT 50 /**< ID for TCC2 event generator CNT */
#define EVENT_ID_GEN_TCC2_MCX_0 51 /**< ID for TCC2 event generator MCX_0 */
#define EVENT_ID_GEN_TCC2_MCX_1 52 /**< ID for TCC2 event generator MCX_1 */
#define EVENT_ID_GEN_TC0_OVF 53 /**< ID for TC0 event generator OVF */
#define EVENT_ID_GEN_TC0_MCX_0 54 /**< ID for TC0 event generator MCX_0 */
#define EVENT_ID_GEN_TC0_MCX_1 55 /**< ID for TC0 event generator MCX_1 */
#define EVENT_ID_GEN_TC1_OVF 56 /**< ID for TC1 event generator OVF */
#define EVENT_ID_GEN_TC1_MCX_0 57 /**< ID for TC1 event generator MCX_0 */
#define EVENT_ID_GEN_TC1_MCX_1 58 /**< ID for TC1 event generator MCX_1 */
#define EVENT_ID_GEN_TC2_OVF 59 /**< ID for TC2 event generator OVF */
#define EVENT_ID_GEN_TC2_MCX_0 60 /**< ID for TC2 event generator MCX_0 */
#define EVENT_ID_GEN_TC2_MCX_1 61 /**< ID for TC2 event generator MCX_1 */
#define EVENT_ID_GEN_TC3_OVF 62 /**< ID for TC3 event generator OVF */
#define EVENT_ID_GEN_TC3_MCX_0 63 /**< ID for TC3 event generator MCX_0 */
#define EVENT_ID_GEN_TC3_MCX_1 64 /**< ID for TC3 event generator MCX_1 */
#define EVENT_ID_GEN_TC4_OVF 65 /**< ID for TC4 event generator OVF */
#define EVENT_ID_GEN_TC4_MCX_0 66 /**< ID for TC4 event generator MCX_0 */
#define EVENT_ID_GEN_TC4_MCX_1 67 /**< ID for TC4 event generator MCX_1 */
#define EVENT_ID_GEN_ADC_RESRDY 68 /**< ID for ADC event generator RESRDY */
#define EVENT_ID_GEN_ADC_WINMON 69 /**< ID for ADC event generator WINMON */
#define EVENT_ID_GEN_AC_COMP_0 70 /**< ID for AC event generator COMP_0 */
#define EVENT_ID_GEN_AC_COMP_1 71 /**< ID for AC event generator COMP_1 */
#define EVENT_ID_GEN_AC_WIN_0 72 /**< ID for AC event generator WIN_0 */
#define EVENT_ID_GEN_TRNG_READY 77 /**< ID for TRNG event generator READY */
#define EVENT_ID_GEN_CCL_LUTOUT_0 78 /**< ID for CCL event generator LUTOUT_0 */
#define EVENT_ID_GEN_CCL_LUTOUT_1 79 /**< ID for CCL event generator LUTOUT_1 */
#define EVENT_ID_GEN_CCL_LUTOUT_2 80 /**< ID for CCL event generator LUTOUT_2 */
#define EVENT_ID_GEN_CCL_LUTOUT_3 81 /**< ID for CCL event generator LUTOUT_3 */
#define EVENT_ID_GEN_PAC_ACCERR 82 /**< ID for PAC event generator ACCERR */
/* ************************************************************************** */
/** Event User IDs for SAMR34J16B */
/* ************************************************************************** */
#define EVENT_ID_USER_PORT_EV_0 0 /**< ID for PORT event user EV_0 */
#define EVENT_ID_USER_PORT_EV_1 1 /**< ID for PORT event user EV_1 */
#define EVENT_ID_USER_PORT_EV_2 2 /**< ID for PORT event user EV_2 */
#define EVENT_ID_USER_PORT_EV_3 3 /**< ID for PORT event user EV_3 */
#define EVENT_ID_USER_DMAC_CH_0 4 /**< ID for DMAC event user CH_0 */
#define EVENT_ID_USER_DMAC_CH_1 5 /**< ID for DMAC event user CH_1 */
#define EVENT_ID_USER_DMAC_CH_2 6 /**< ID for DMAC event user CH_2 */
#define EVENT_ID_USER_DMAC_CH_3 7 /**< ID for DMAC event user CH_3 */
#define EVENT_ID_USER_DMAC_CH_4 8 /**< ID for DMAC event user CH_4 */
#define EVENT_ID_USER_DMAC_CH_5 9 /**< ID for DMAC event user CH_5 */
#define EVENT_ID_USER_DMAC_CH_6 10 /**< ID for DMAC event user CH_6 */
#define EVENT_ID_USER_DMAC_CH_7 11 /**< ID for DMAC event user CH_7 */
#define EVENT_ID_USER_TCC0_EV_0 12 /**< ID for TCC0 event user EV_0 */
#define EVENT_ID_USER_TCC0_EV_1 13 /**< ID for TCC0 event user EV_1 */
#define EVENT_ID_USER_TCC0_MC_0 14 /**< ID for TCC0 event user MC_0 */
#define EVENT_ID_USER_TCC0_MC_1 15 /**< ID for TCC0 event user MC_1 */
#define EVENT_ID_USER_TCC0_MC_2 16 /**< ID for TCC0 event user MC_2 */
#define EVENT_ID_USER_TCC0_MC_3 17 /**< ID for TCC0 event user MC_3 */
#define EVENT_ID_USER_TCC1_EV_0 18 /**< ID for TCC1 event user EV_0 */
#define EVENT_ID_USER_TCC1_EV_1 19 /**< ID for TCC1 event user EV_1 */
#define EVENT_ID_USER_TCC1_MC_0 20 /**< ID for TCC1 event user MC_0 */
#define EVENT_ID_USER_TCC1_MC_1 21 /**< ID for TCC1 event user MC_1 */
#define EVENT_ID_USER_TCC2_EV_0 22 /**< ID for TCC2 event user EV_0 */
#define EVENT_ID_USER_TCC2_EV_1 23 /**< ID for TCC2 event user EV_1 */
#define EVENT_ID_USER_TCC2_MC_0 24 /**< ID for TCC2 event user MC_0 */
#define EVENT_ID_USER_TCC2_MC_1 25 /**< ID for TCC2 event user MC_1 */
#define EVENT_ID_USER_TC0_EVU 26 /**< ID for TC0 event user EVU */
#define EVENT_ID_USER_TC1_EVU 27 /**< ID for TC1 event user EVU */
#define EVENT_ID_USER_TC2_EVU 28 /**< ID for TC2 event user EVU */
#define EVENT_ID_USER_TC3_EVU 29 /**< ID for TC3 event user EVU */
#define EVENT_ID_USER_TC4_EVU 30 /**< ID for TC4 event user EVU */
#define EVENT_ID_USER_ADC_START 31 /**< ID for ADC event user START */
#define EVENT_ID_USER_ADC_SYNC 32 /**< ID for ADC event user SYNC */
#define EVENT_ID_USER_AC_SOC_0 33 /**< ID for AC event user SOC_0 */
#define EVENT_ID_USER_AC_SOC_1 34 /**< ID for AC event user SOC_1 */
#define EVENT_ID_USER_CCL_LUTIN_0 38 /**< ID for CCL event user LUTIN_0 */
#define EVENT_ID_USER_CCL_LUTIN_1 39 /**< ID for CCL event user LUTIN_1 */
#define EVENT_ID_USER_CCL_LUTIN_2 40 /**< ID for CCL event user LUTIN_2 */
#define EVENT_ID_USER_CCL_LUTIN_3 41 /**< ID for CCL event user LUTIN_3 */
#define EVENT_ID_USER_MTB_START 43 /**< ID for MTB event user START */
#define EVENT_ID_USER_MTB_STOP 44 /**< ID for MTB event user STOP */
#ifdef __cplusplus
}
#endif
/** @} end of SAMR34J16B definitions */
#endif /* _SAMR34J16B_H_ */
| [
"thibaut.viard@microchip.com"
] | thibaut.viard@microchip.com |
310a94b6772f5be7cf04682ae226dc07e6546062 | 8a71a784cb6ef9c18ab3eca16443136054847bd7 | /P1S2TEMP.X/SPI.c | 473801dd0616914117c8ed1597850e1b16cd0588 | [] | no_license | Cue19275/Digital2 | 224573ecf9c65f916498250143f56db7894cd1df | d7e6dd22e36d359542ab4ccacfd28e22b2fde47f | refs/heads/main | 2023-05-09T12:04:54.121723 | 2021-05-28T04:38:16 | 2021-05-28T04:38:16 | 331,773,212 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,119 | c | /*
* File : spi.c
* Author : Ligo George
* Company : electroSome
* Project : SPI Library for MPLAB XC8
* Microcontroller : PIC 16F877A
* Created on April 15, 2017, 5:59 PM
*/
#include "SPI.h"
void spiInit(Spi_Type sType, Spi_Data_Sample sDataSample, Spi_Clock_Idle sClockIdle, Spi_Transmit_Edge sTransmitEdge)
{
TRISC5 = 0;
if(sType & 0b00000100) //If Slave Mode
{
SSPSTAT = sTransmitEdge;
TRISC3 = 1;
}
else //If Master Mode
{
SSPSTAT = sDataSample | sTransmitEdge;
TRISC3 = 0;
}
SSPCON = sType | sClockIdle;
}
static void spiReceiveWait()
{
while ( !SSPSTATbits.BF ); // Wait for Data Receive complete
}
void spiWrite(char dat) //Write data to SPI bus
{
SSPBUF = dat;
}
unsigned spiDataReady() //Check whether the data is ready to read
{
if(SSPSTATbits.BF)
return 1;
else
return 0;
}
char spiRead() //REad the received data
{
spiReceiveWait(); // wait until the all bits receive
return(SSPBUF); // read the received data from the buffer
} | [
"68084828+Cue19275@users.noreply.github.com"
] | 68084828+Cue19275@users.noreply.github.com |
da30077ffa41860da60d5025849485db7501f649 | 2bed6daa750b590cbf2b81fc429add0145d36c7d | /DUMP/Scavenger_struct.h | 6f3f725b021e02a8ed250da7275e17f327d94be1 | [] | no_license | xkp95175333/Scavenger-Win64-Shipping-ok | 31cdc2835c75c698b179e7a523f99359b3a062f0 | b834c2b35852590c5d199fadb4cc58af4c56f72d | refs/heads/main | 2023-06-12T00:47:56.743429 | 2021-07-05T19:26:35 | 2021-07-05T19:26:35 | 383,244,886 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 456,305 | h | // Enum Scavenger.ES_WeaponSlot
enum class ES_WeaponSlot : uint8 {
Primary,
Secondary,
Throwable,
Unarmed,
Special,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PoiseDamageType
enum class ES_PoiseDamageType : uint8 {
Projectile,
Melee,
Explosion,
Generic,
Shock,
Stun,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ShieldLevel
enum class ES_ShieldLevel : uint8 {
L1,
L2,
L3,
L4,
L5,
Count,
Uninitialized,
ES_MAX,
};
// Enum Scavenger.ES_StatsState
enum class ES_StatsState : uint8 {
Alive,
Downed,
Terminal,
Dead,
Cocooned,
Extracting,
Extracted,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StatType
enum class ES_StatType : uint8 {
Armor,
Health,
Shield,
HealthRecoveryLimit,
Cold,
Exhaustion,
Hunger,
Radiation,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StatChangeCauseType
enum class ES_StatChangeCauseType : uint8 {
Drink,
Equipment,
Food,
Medicine,
Nanotech,
Natural,
Bleed,
Disease,
Poison,
Radiation,
Blunt,
Piercing,
Sharp,
Bullet,
Explosive,
Flechette,
Impact,
Laser,
Plasma,
Acid,
Cold,
Electric,
Heat,
Asphyxiation,
Exhaustion,
Hunger,
Thirst,
GameRule,
FellOutOfWorld,
Assassination,
Fall,
VehicleImpact,
DirectAttributeChange,
DependentAttributeChange,
TeamWipe,
AutoRez,
DebugDamagePlayer,
CrushedFromAbove,
Talent,
Ability,
VehicleFire,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_ExhaustionState
enum class ES_ExhaustionState : uint8 {
Exhausted,
Recovered,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ActionQueueRemoveReason
enum class ES_ActionQueueRemoveReason : uint8 {
ExternallyCancelled,
QueueTimeExpired,
ES_MAX,
};
// Enum Scavenger.ES_ActionID
enum class ES_ActionID : uint8 {
Jump,
Dodge,
Mantle,
Sprint,
Crouch,
Cocoon,
FireGun,
MeleeAttack,
Reload,
AutoReload,
SwapWeapon,
ADS,
Slide,
Interact,
UseItem,
Emote,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_OnlineResult
enum class ES_OnlineResult : uint8 {
Success,
Pending,
Failure,
Failure_Retry,
Failure_Reset,
Failure_Reauthenticate,
Failure_Abort,
Failure_ContactSupport,
Failure_AccountBanned,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AbilityTimerIndex
enum class ES_AbilityTimerIndex : uint8 {
Default,
Camo,
Count,
ES_MAX,
};
// Enum Scavenger.ES_EventParameter
enum class ES_EventParameter : uint8 {
Object,
Actor,
Pawn,
PawnBase,
Character,
Vehicle,
Controller,
AIController,
PlayerController,
ES_MAX,
};
// Enum Scavenger.ES_EquipmentSlot
enum class ES_EquipmentSlot : uint8 {
Head,
Eyes,
Face,
Back,
Hands,
ChestInner,
Chest,
ChestOuter,
Legs,
Feet,
WeaponPrimary,
WeaponSecondary,
WeaponThrowable,
QuickItemOne,
QuickItemTwo,
QuickItemThree,
QuickItemFour,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GameplayEvent
enum class ES_GameplayEvent : uint8 {
FlareDetonated,
ES_MAX,
};
// Enum Scavenger.ES_Platform
enum class ES_Platform : uint8 {
Windows,
PS4,
XboxOne,
Linux,
XboxOneScorpio,
PS5,
XSX,
Other,
ES_MAX,
};
// Enum Scavenger.ES_InventoryCategory
enum class ES_InventoryCategory : uint8 {
Weapon_DEPRECATED,
Item_DEPRECATED,
Ammo_DEPRECATED,
Scoring,
Grenade_DEPRECATED,
Currency,
Salvage,
AmmoArrow,
AmmoExplosive,
AmmoHeavy,
AmmoLight,
AmmoMedium,
AmmoShell,
ResurrectionToken,
Count,
ES_MAX,
};
// Enum Scavenger.ES_UIAction
enum class ES_UIAction : uint8 {
Equip,
Activate,
Drop,
Split,
EquipDropCombo,
Ping,
QuickItems,
Count,
ES_MAX,
};
// Enum Scavenger.ES_UIAxis
enum class ES_UIAxis : uint8 {
PadAxisX,
PadAxisY,
MouseAxisX,
MouseAxisY,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GameInputActionType
enum class ES_GameInputActionType : uint8 {
None,
Jump,
Crouch,
Dodge,
Interact,
InteractAndReload,
Reload,
CycleItemSelectionForward,
CycleItemSelectionBackward,
SwitchBetweenQuickItemsAndWeapons,
SelectQuickItem,
UseQuickItem,
CombinedSelectOrUseQuickItem,
StowWeapon,
FreeLook,
MoveForward,
MoveBackward,
MoveLeft,
MoveRight,
TurnLeft,
TurnRight,
LookUp,
LookDown,
Melee,
PlayerAbility,
Fire,
Aim,
SecondaryInteract,
Sprint,
Ping,
SelectPing,
CombinedSelectOrUsePing,
SelectItemOne,
SelectItemTwo,
SelectItemThree,
SelectItemFour,
SelectItemFive,
SelectItemSix,
SelectItemSeven,
SelectItemEight,
CharacterPage,
CraftingPage,
Escape,
GameplayMenu,
MapPage,
PauseMenu,
CloseCurrentMenu,
CycleMenuPageBackward,
CycleMenuPageForward,
ShowLeaderboard,
SummonTextChatMenu,
UI_Equip,
UI_Activate,
UI_Drop,
UI_Scrap_DEPRECATED,
UI_Split,
UI_EquipDropCombo,
UI_SplitScrapCombo_DEPRECATED,
UI_RadialConfirm,
UI_RadialCancel,
DEBUG_ActivateCheatMenu,
FlipKeeperFlashlight,
PushToTalk,
UI_Dismiss,
Menu_Select,
Menu_Dismiss,
Menu_Social,
Menu_Options,
Menu_ResetToDefaults,
Menu_CycleRight,
Menu_CycleLeft,
Menu_MuteAll_DEPRECATED,
Menu_Quit,
Menu_News,
SpectateNextPlayer,
SpectatePreviousPlayer,
Emote1,
Emote2,
Emote3,
Emote4,
Emote5,
Emote6,
Research_Research,
Research_Disassemble,
Research_Track,
Research_Untrack,
Menu_Sort,
Menu_SubCycleRight,
Menu_SubCycleLeft,
EmoteWheel,
Menu_CancelMatchmaking,
Input_AnyKey,
Loadout_Customize,
DEBUG_ToggleFocusDebugOverlay,
Seasons_TierInteract,
Count,
ES_MAX,
};
// Enum Scavenger.ES_Slide
enum class ES_Slide : uint8 {
Dodge,
CustomDodge,
FlatSlide,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_StormSpawnState
enum class ES_StormSpawnState : uint8 {
None,
SkyMaskGrowth,
FunnelPreamble,
FunnelGrowth,
FunnelComplete,
FunnelShrink,
FunnelPostamble,
SkyMaskShrink,
Destroy,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StormSize
enum class ES_StormSize : uint8 {
Small,
Medium,
Large,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StormCategory
enum class ES_StormCategory : uint8 {
None,
Border,
Roaming,
Collapsing,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StormDamageZone
enum class ES_StormDamageZone : uint8 {
Inside,
Outside,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AttackEvent
enum class ES_AttackEvent : uint8 {
None,
TriggerPress,
TriggerRelease,
DoAttack,
DoAttackDeferred,
StartAttack,
StopAttack,
CancelAttack,
Acquired,
Dropped,
Readied,
Stowed,
StartReload,
StopReload,
CancelReload,
Readying,
Stowing,
ADSOn,
ADSOff,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TriggerType
enum class ES_TriggerType : uint8 {
Primary,
Secondary,
Tertiary,
OffHandMelee,
Grenade,
AIGrenade,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_ShelterType
enum class ES_ShelterType : uint8 {
None,
Crater,
Partial,
Full,
Abilities,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CameraOverrideMode
enum class ES_CameraOverrideMode : uint8 {
Add,
Multiply,
Set,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CameraSettings
enum class ES_CameraSettings : uint8 {
ThirdPersonClose,
ThirdPersonFar,
ThirdPersonADS,
ThirdPersonRoll,
ThirdPersonCrouchedClose,
ThirdPersonCrouchedFar,
ThirdPersonCrouchedADS,
ThirdPersonDropPod,
ThirdPersonDowned,
ThirdPersonMantle,
ThirdPersonSprint,
ThirdPersonJump,
ThirdPersonExecute,
FirstPersonADS,
FirstPersonCrouchedADS,
DebugCamera,
EndOfGameCamera,
ThirdPersonSlide,
ThirdPersonSlideADS,
ThirdPersonPassenger,
ThirdPersonPassengerADS,
ThirdPersonEmote,
Count,
Default,
ES_MAX,
};
// Enum Scavenger.ES_ItemRarity
enum class ES_ItemRarity : uint8 {
Common,
Uncommon,
Rare,
Epic,
Legendary,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScavengerResult
enum class ES_ScavengerResult : uint8 {
Succeeded,
Failed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_EnemyInfoType
enum class ES_EnemyInfoType : uint8 {
Player,
Champion,
Behemoth,
ActiveVehicle,
GenericEvent,
ShardHarvest,
SupplyDrop,
VehiclGantry,
Misc,
EnemyVehicle,
AllyVehicle,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ZoomType
enum class ES_ZoomType : uint8 {
World,
Local,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MapIconUse
enum class ES_MapIconUse : uint8 {
Default,
StormIcon,
PingIcon,
EncounterLabel,
NonEncounterLabel,
PlayerIcon,
ShardLocation,
GenericLocation,
EnemyIcon,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SalvageState
enum class ES_SalvageState : uint8 {
Idle,
Inspection,
RequestMade,
RequestSuccess,
Reveal,
Complete,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CosmeticLoadoutSlotType
enum class ES_CosmeticLoadoutSlotType : uint8 {
Generic,
KeeperMesh,
Backpack,
ExplorerMesh,
ExplorerWeapon,
Execution,
WildcardWeapon,
EmoteA,
EmoteB,
EmoteC,
EmoteD,
EmoteE,
EmoteF,
EmoteG,
AccountBanner,
AccountEmblem,
AccountTitle,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineRewardGrantType
enum class ES_OnlineRewardGrantType : uint8 {
None,
Entitlement,
Currency,
CharacterXp,
ES_MAX,
};
// Enum Scavenger.ES_UnseenRewardSource
enum class ES_UnseenRewardSource : uint8 {
None,
AccountLevelUp,
CharacterLevelUp,
Session,
LegacyReward,
ES_MAX,
};
// Enum Scavenger.ES_SavedUserSettingsVersion
enum class ES_SavedUserSettingsVersion : uint8 {
NotSet,
_01_Initial,
_02_ChangeDefaultTabKeybind,
_03_RemoveOldBinds,
_04_QuickItemRadialWheelInput,
_05_PingRadialWheelInput,
_06_ResetAudioSettings,
_07_SubtitlesSize,
_08_ChangeDefaultCloseMenuKeybind,
_09_GlobalMenuInputUpdates,
_10_EmoteWheelSettingsConsistency,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SubtitleSize
enum class ES_SubtitleSize : uint8 {
Small,
Medium,
Large,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DeadzoneSize
enum class ES_DeadzoneSize : uint8 {
None,
Small,
Medium,
Large,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LoadoutSlotType
enum class ES_LoadoutSlotType : uint8 {
Invalid,
Gear,
ClassWeapon,
Item,
Wildcard,
Throwable,
Backpack,
AbilityUpgrade,
Talent,
GearRepair,
Ammo,
AggressiveTalent,
DefensiveTalent,
MovementTalent,
UtilityTalent,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ImprobableTestAccountType
enum class ES_ImprobableTestAccountType : uint8 {
Unspecified,
Developer,
Simplayer,
ES_MAX,
};
// Enum Scavenger.ES_OnlineServiceManagerLoginMethod
enum class ES_OnlineServiceManagerLoginMethod : uint8 {
Invalid,
TestAccountWithAuthToken,
TestAccountAcquireAuthToken,
Platform,
ES_MAX,
};
// Enum Scavenger.ES_LobbyEndpointPingStatus
enum class ES_LobbyEndpointPingStatus : uint8 {
Unknown,
Available,
Unreachable,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NetworkConnectionStatus
enum class ES_NetworkConnectionStatus : uint8 {
Normal,
NotConnected,
Connected,
ConnectionDropped,
NoNetworkConnection,
ServiceUnavailable,
UpdateRequired,
ServersTooBusy,
DuplicateLoginDetected,
InvalidUser,
NotAuthorized,
InvalidSession,
Count,
ES_MAX,
};
// Enum Scavenger.ES_UserPrivilegeResult
enum class ES_UserPrivilegeResult : uint8 {
Success,
Failure,
NotFetched,
PatchRequired,
AgeRestricted,
AccountTypeFailure,
Count,
ES_MAX,
};
// Enum Scavenger.ES_UserPrivilege
enum class ES_UserPrivilege : uint8 {
CanPlay,
CanPlayOnline,
CanCommunicateOnline,
CanUseUserGeneratedContent,
CanUserCrossPlay,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InterfaceColorMode
enum class ES_InterfaceColorMode : uint8 {
Default,
Deuteranopia,
Protanopia,
Tritanopia,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WeaponSlotState
enum class ES_WeaponSlotState : uint8 {
Empty,
ReadyingPreAttachSwap,
ReadyingPostAttachSwap,
Readied,
StowingPreAttachSwap,
StowingPreAttachSwapLocked,
StowingPostAttachSwap,
Stowed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LocationFaction
enum class ES_LocationFaction : uint8 {
None,
Outlander,
Scourge,
Other,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LocationDifficultyTier
enum class ES_LocationDifficultyTier : uint8 {
Trivial,
Easy,
Moderate,
Tough,
Unforgiving,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LocationType
enum class ES_LocationType : uint8 {
SmallCamp,
MediumCamp,
Fortress,
ImpactCrater,
Region,
SpawnPoint,
RoamingBoss,
OrbitalDebris,
Count,
ES_MAX,
};
// Enum Scavenger.ES_Interaction
enum class ES_Interaction : uint8 {
Primary,
Secondary,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CurrencyType
enum class ES_CurrencyType : uint8 {
Scrap,
Alcohol,
Chems,
Electronics,
Fiber,
WeaponParts,
Samples,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PingItemEvent
enum class ES_PingItemEvent : uint8 {
Added,
Repeated,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AutoPingType
enum class ES_AutoPingType : uint8 {
None,
ExtractionSite,
ShardObjective,
Cold,
Stamina,
ScavengeSite,
Downed,
Vehicle,
Chest,
SupplyDrop,
Misc,
ObjectiveEntrance,
SpaceDebris,
ScourgeGrowth,
LooseShard,
Boss,
DataUplink,
LightHearth,
HordeEnemy,
TakingDamage,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PingInfoType
enum class ES_PingInfoType : uint8 {
Location,
Item,
Weapon,
Player,
Enemy,
Status,
Currency,
Vehicle,
InteractableActor,
Container,
Loot,
Attack,
Defend,
Danger,
SomeoneHasBeen,
Destination,
NeedAmmo,
NeedWeapon,
NeedScrap,
NeedThrowables,
VehicleGantry,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TeamGameEndReason
enum class ES_TeamGameEndReason : uint8 {
Invalid,
TeamEliminated,
TeamLeftOnPlanet,
TeamExtracted,
TeamExfiled,
ES_MAX,
};
// Enum Scavenger.ES_InteractIcon
enum class ES_InteractIcon : uint8 {
Default,
GameplayBank,
GameplayEscape,
GameplayInteract,
GameplayResurrect,
GameplayRevive,
ItemAmmo,
ItemConsumableBuff,
ItemConsumableFoodDrink,
ItemConsumableHeal,
ItemGameplayCache,
ItemGameplayEvent1,
ItemGameplayEvent2,
ItemGameplayEvent3,
ItemGameplayEvent4,
ItemGameplayDogTag,
ItemGameplayReserved1,
ItemGameplayReserved2,
ItemGameplayReserved3,
ItemGameplayReserved4,
ItemGameplayShard,
ItemGearCommon,
ItemGearRare,
ItemGearEpic,
ItemGearLegendary,
ItemJunk,
ItemResourceAlcohol,
ItemResourceChems,
ItemResourceElectronics,
ItemResourceFiber,
ItemResourceScrap,
ItemResourceWeaponParts,
ItemWeaponCommon,
ItemWeaponRare,
ItemWeaponEpic,
ItemWeaponLegendary,
ObjectContainer,
ObjectCraft,
ObjectDoor,
ObjectHarvest,
ObjectInteract,
ObjectSearchable,
VehicleHijack,
VehicleRepair,
VehicleSeat,
ItemSalvage01,
ItemSalvage02,
ItemSalvage03,
ItemSalvage04,
ItemWeaponUncommon,
LocationShardAltar,
LocationShardGrowth,
LocationSpaceJunk,
LocationStrategicChest,
LocationDataUplink,
LightFire,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SelectionSet
enum class ES_SelectionSet : uint8 {
QuickItems,
Weapons,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LifecycleState
enum class ES_LifecycleState : uint8 {
Local,
CreatingHost,
WaitingForPlayersToJoin,
WaitingForPlayersToReady,
WaitingForHostToStart,
CountingDownStartTimer,
Searching,
SelectingSession,
Joining,
Loading,
Playing,
Quitting,
ES_MAX,
};
// Enum Scavenger.ES_StageChangeStateHint
enum class ES_StageChangeStateHint : uint8 {
Hint_MoveAndFire,
Hint_MoveOnly,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StageChangeUrgency
enum class ES_StageChangeUrgency : uint8 {
HurryHurry,
Slow,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AIHail
enum class ES_AIHail : uint8 {
Talking,
TargetSpotted,
TargetDamagedMe,
TargetHeard,
FiredGun,
ShieldDown,
Gesture,
ShriekerAlarm,
MyLeaderDied,
FriendlyDied,
None,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AIShriekerState
enum class ES_AIShriekerState : uint8 {
Calm,
Alert,
Alarmed,
Burrow,
Unburrow,
Count,
ES_MAX,
};
// Enum Scavenger.ES_EnemyInfoUpdateMode
enum class ES_EnemyInfoUpdateMode : uint8 {
ShowInSweep,
Immediate,
FollowActor,
GutterInRadar,
FollowInRadar,
Champion,
ES_MAX,
};
// Enum Scavenger.ES_SocialDisconnectReason
enum class ES_SocialDisconnectReason : uint8 {
Clean,
Error_Unreachable,
Error_Unauthorized,
Error_Timeout,
Error_Unknown,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SocialPresenceStatus
enum class ES_SocialPresenceStatus : uint8 {
Unknown,
Disconnected,
InLobby,
InLobbyIdle,
InMatch,
Count,
ES_MAX,
};
// Enum Scavenger.ES_RehydratePartyJoinAction
enum class ES_RehydratePartyJoinAction : uint8 {
ShouldNotJoin,
ShouldJoinPeer,
ShouldJoinPartyLeader,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TextChatMessageTarget
enum class ES_TextChatMessageTarget : uint8 {
Unknown,
Broadcast,
Party,
Team,
Match,
Direct,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TextChatControlCommand
enum class ES_TextChatControlCommand : uint8 {
Unknown,
CrossRegionInvite,
CrossRegionCancelInvite,
CrossRegionJoinRequest,
CrossRegionCancelJoinRequest,
CrossRegionAcceptJoinRequest,
RehydrateParty,
ForceRehydrateParty,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GameLocation
enum class ES_GameLocation : uint8 {
PlaytestWarning,
Eula,
LaunchIntoMenu,
MainMenu,
Tutorial,
SocialHub,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PlayerGameState
enum class ES_PlayerGameState : uint8 {
Default,
Loading,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FriendState
enum class ES_FriendState : uint8 {
NotFriends,
OutgoingRequest,
IncomingRequest,
Friends,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ButtonInteractionState
enum class ES_ButtonInteractionState : uint8 {
Active,
Inactive,
Disabled,
HighlightedForFTUE,
NotDefined,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineItemMetadataType
enum class ES_OnlineItemMetadataType : uint8 {
Generic,
Recipe,
Talent,
Cosmetic,
SalvageItem,
CraftingBlueprint,
TinkerPack,
Character,
Resource,
FeatureKey,
CosmeticTinkerable,
ResearchStation,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SocialHubPhaseState
enum class ES_SocialHubPhaseState : uint8 {
None,
Inactive,
Active,
Paused,
Ended,
Unloading,
ES_MAX,
};
// Enum Scavenger.ES_CosmeticType
enum class ES_CosmeticType : uint8 {
Generic,
KeeperMesh,
Backpack,
ExplorerMesh,
ExplorerWeapon,
Execution,
Emote,
WildcardWeapon,
AccountBanner,
AccountEmblem,
AccountTitle,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CosmeticTitleSize
enum class ES_CosmeticTitleSize : uint8 {
Default,
Small,
Large,
ExtraLarge,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InputActionFlag
enum class ES_InputActionFlag : uint8 {
InputPress,
InputHold,
InputDoublePress,
InputAny,
InputRelease,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AnimationTickMode
enum class ES_AnimationTickMode : uint8 {
InNativeTick,
InEventTick,
InHudTick,
ES_MAX,
};
// Enum Scavenger.ES_SocialType
enum class ES_SocialType : uint8 {
Invalid,
FriendInvite,
PartyInvite,
PartyJoinRequest,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineResearchProjectType
enum class ES_OnlineResearchProjectType : uint8 {
Unknown,
Assembly,
WildcardWeapon,
Throwable,
Equipment,
SignatureWeapon,
Talent,
Salvage,
Cosmetic,
StationUpgrade,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineResourceType
enum class ES_OnlineResourceType : uint8 {
Material,
Component,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LobbyConnectionState
enum class ES_LobbyConnectionState : uint8 {
Unknown,
Disconnected,
Connecting,
Connected,
Unqueued,
Queueing,
WaitingForServer,
ServerFound,
WaitingForServerAnnounce,
WaitingForPlayers,
InGame,
InGameNeedMorePlayers,
ShuttingDown,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LobbyQueueCompatibility
enum class ES_LobbyQueueCompatibility : uint8 {
Unknown,
Compatible,
Incompatible,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GameMode
enum class ES_GameMode : uint8 {
Expedition,
Training,
SocialHub,
Horde,
ES_MAX,
};
// Enum Scavenger.ES_SocialButtonPromptAction
enum class ES_SocialButtonPromptAction : uint8 {
InviteToParty,
AcceptPartyInvite,
RejectPartyInvite,
CancelPartyInvite,
LeaveParty,
AddFriend,
AcceptFriendInvite,
RejectFriendInvite,
CancelFriendInvite,
RemoveFriend,
SendPartyJoinRequest,
AcceptPartyJoinRequest,
RejectPartyJoinRequest,
CancelPartyJoinRequest,
KickFromParty,
AddToFavorites,
AddFriendFavorite,
ViewStats,
ViewGamercard,
ReportPlayer,
BlockPlayer,
UnblockPlayer,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PurchaseRequestResult
enum class ES_PurchaseRequestResult : uint8 {
CanPurchase,
NotEnoughCurrency,
RestrictionFailed,
BoostAlreadyActive,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InputSourceShowMode
enum class ES_InputSourceShowMode : uint8 {
DontShow,
ShowAll,
ShowGamepadOnly,
ShowMouseAndKeyboardOnly,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NavigationInputCategory
enum class ES_NavigationInputCategory : uint8 {
Core,
ScreenSpecific,
Global,
Bound,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VehicleDamageState
enum class ES_VehicleDamageState : uint8 {
Pristine,
Worn,
Critical,
Wreck,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AbilityTimerState
enum class ES_AbilityTimerState : uint8 {
None,
Active,
ActiveDuration,
Cooldown,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GameplayAbilityInputBindings
enum class ES_GameplayAbilityInputBindings : uint8 {
Ability1,
Ability2,
Ability3,
Ability4,
Ability5,
Ability6,
Ability7,
Ability8,
Ability9,
Ability0,
ES_MAX,
};
// Enum Scavenger.ES_UseItemActionOrigin
enum class ES_UseItemActionOrigin : uint8 {
Equipment,
Inventory,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ActionQueueLength
enum class ES_ActionQueueLength : uint8 {
None,
Short,
Medium,
Long,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ActionResponse
enum class ES_ActionResponse : uint8 {
Block,
Simultaneous,
InterruptSelf,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ActionStatus
enum class ES_ActionStatus : uint8 {
Blocked,
Queued,
Active,
Finished,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AIAudioState
enum class ES_AIAudioState : uint8 {
Default,
Idle,
Patrol,
Flee,
Searching,
Combat,
CallForHelp,
Burrow,
Unborrow,
PrepareToSelfDestruct,
ES_MAX,
};
// Enum Scavenger.ES_AIOutlanderRallyBehaviorState
enum class ES_AIOutlanderRallyBehaviorState : uint8 {
MoveToRally,
RallyingIdle,
RequestExitingRallyIdle,
ExitRallyIdle,
NotRallying,
BlockRally,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AIAlertState
enum class ES_AIAlertState : uint8 {
Idle,
Investigating,
Searching,
AcquiringTarget,
InCombat,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AITargetStateFlags
enum class ES_AITargetStateFlags : uint8 {
Unitialized,
Visible,
Lost,
Unknown_Heard,
Unknown_Damage,
Unknown_Partial,
Known_Damage,
ES_MAX,
};
// Enum Scavenger.ES_HostileTarget
enum class ES_HostileTarget : uint8 {
Player,
AI,
All,
ES_MAX,
};
// Enum Scavenger.ES_BrainDeadSource
enum class ES_BrainDeadSource : uint8 {
HardPing,
Blueprint,
AnimNotify,
AnimNotifyState,
Spawner,
Death,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OpportunityState
enum class ES_OpportunityState : uint8 {
None,
SetNew,
MovingTo,
Reached,
StartedUse,
CompleteUse,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CombatTargetAcquisition
enum class ES_CombatTargetAcquisition : uint8 {
Unknown,
AnalyzingStart,
AnalyzingFreshTarget,
AnalyzingInformed,
FullyAcquired,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AIStage
enum class ES_AIStage : uint8 {
Low,
Medium,
High,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AIIntensity
enum class ES_AIIntensity : uint8 {
Low,
Medium,
High,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AILocomotionState
enum class ES_AILocomotionState : uint8 {
Default,
Patrol,
Search,
Flee,
Enraged,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AimAssistCanBeSeenState
enum class ES_AimAssistCanBeSeenState : uint8 {
Unknown,
NotVisible,
Visible,
ES_MAX,
};
// Enum Scavenger.ES_AimAssistSystem
enum class ES_AimAssistSystem : uint8 {
ActorUnderReticle,
AimAssist,
AimFriction,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AimAssistAutoAimWeightingLevel
enum class ES_AimAssistAutoAimWeightingLevel : uint8 {
Lowest,
Lower,
Low,
Default,
High,
Higher,
Highest,
ES_MAX,
};
// Enum Scavenger.ES_AmmoType
enum class ES_AmmoType : uint8 {
Arrow,
Medium,
Battery_DEPRECATED,
Fuel_DEPRECATED,
GrenadeRound_DEPRECATED,
Light,
RailgunRound_DEPRECATED,
Explosive,
Shell,
Heavy,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_AnimAttackEventType
enum class ES_AnimAttackEventType : uint8 {
CanInterrupt,
DeferredAttack,
Finished,
Melee,
ResetMelee,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AnimReadyEvent
enum class ES_AnimReadyEvent : uint8 {
Finished,
WeaponInReadySocket,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AnimReloadEventType
enum class ES_AnimReloadEventType : uint8 {
CanInterrupt,
ShellLoaded,
ClipLoaded,
Finished,
BlockInterrupt,
ChainMontage,
ShellReloadCheck,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AnimStowEvent
enum class ES_AnimStowEvent : uint8 {
Finished,
CannotInterrupt,
WeaponInStowSocket,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AsyncActionState
enum class ES_AsyncActionState : uint8 {
Pending,
Success,
Failure,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AttackEntryClientFlags
enum class ES_AttackEntryClientFlags : uint8 {
StartHandled,
StopHandled,
MontageInfoHandled,
LastBulletInClipHandled,
ES_MAX,
};
// Enum Scavenger.ES_AttackEntryServerFlags
enum class ES_AttackEntryServerFlags : uint8 {
Stopped,
HasMontageInfo,
LastBulletInClip,
ES_MAX,
};
// Enum Scavenger.ES_AttackTargetInfoFlags
enum class ES_AttackTargetInfoFlags : uint8 {
Miss,
HitInActorBoneSpace,
HitInActorSpace,
HasCorrectedStartLocation,
HasRandState,
ES_MAX,
};
// Enum Scavenger.ES_AttributeModification
enum class ES_AttributeModification : uint8 {
AddToBase,
AdditiveBonusMultiplier,
StackingMultiplier,
Override,
ES_MAX,
};
// Enum Scavenger.ES_BlackBoardEntryComparison
enum class ES_BlackBoardEntryComparison : uint8 {
Empty,
NotEmpty,
LessChar,
LessOrEqualChar,
MoreChar,
MoreOrEqualChar,
LessPlayers,
LessOrEqualPlayers,
MorePlayers,
MoreOrEqualPlayers,
LessAI,
LessOrEqualAI,
MoreAI,
MoreOrEqualAI,
ES_MAX,
};
// Enum Scavenger.EEnvQueryPointClumpingMode
enum class EEnvQueryPointClumpingMode : uint8 {
PenalizeClumpyPoints,
CullClumpyPoints,
AIClumpingIsFine,
EEnvQueryPointClumpingMode_MAX,
};
// Enum Scavenger.ES_ScoringDistance
enum class ES_ScoringDistance : uint8 {
Distance3D,
Distance2D,
DistanceZ,
DistanceAbsoluteZ,
ES_MAX,
};
// Enum Scavenger.ES_ChallengeTab
enum class ES_ChallengeTab : uint8 {
Daily,
Career,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ChallengeTrackingSetting
enum class ES_ChallengeTrackingSetting : uint8 {
Solo,
Team,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ProjectileSpawnPointStates
enum class ES_ProjectileSpawnPointStates : uint8 {
Stand,
Crouch,
Slide,
Vehicle,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ExecutionOverride
enum class ES_ExecutionOverride : uint8 {
Custom,
PlayerCharacterID,
Weapon,
Size,
WeaponClass,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ExecutionSize
enum class ES_ExecutionSize : uint8 {
Small,
Medium,
Large,
ES_MAX,
};
// Enum Scavenger.ES_ExecutionDirection
enum class ES_ExecutionDirection : uint8 {
Front,
Back,
Left,
Right,
Count,
ES_MAX,
};
// Enum Scavenger.ES_KungFuAttackerRange
enum class ES_KungFuAttackerRange : uint8 {
Melee,
Medium,
Extended,
Invalid,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LeapState
enum class ES_LeapState : uint8 {
None,
Start,
StartBlendOut,
InAir,
LandingSlide,
Landed,
ES_MAX,
};
// Enum Scavenger.ES_DerivedCharacterBaseState
enum class ES_DerivedCharacterBaseState : uint8 {
Walking,
Crouched,
Prone,
Swimming,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CharacterBodyStance
enum class ES_CharacterBodyStance : uint8 {
Ready,
ADS,
WeaponDown,
WeaponStowed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SlideCurveMode
enum class ES_SlideCurveMode : uint8 {
Absolute,
Additive,
Multiplied,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_CharacterSize
enum class ES_CharacterSize : uint8 {
Small,
Medium,
Large,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CheatMenuItemType
enum class ES_CheatMenuItemType : uint8 {
Folder,
Command,
Toggle,
IntRange,
SpawnItems,
AddRecipes,
AddTalents,
OnlineItemMetadata,
Store,
PlayerInventory,
Characters,
Cosmetics,
Power,
Currency,
Salvage,
ResearchProjects,
Disassembly,
Assembly,
Tinkering,
CosmeticTestTinkering,
WeaponTinkering,
Teleport,
UnseenRewards,
Restrictions,
XpBoost,
Challenges,
Leaderboards,
MatchRecords,
Seasons,
IncreaseSeasonsPoints,
ES_MAX,
};
// Enum Scavenger.ES_CheatMenuExecuteOn
enum class ES_CheatMenuExecuteOn : uint8 {
Client,
Server,
ClientAndServer,
MultiServer,
ES_MAX,
};
// Enum Scavenger.ES_TargetLockSettings
enum class ES_TargetLockSettings : uint8 {
MoveWithTarget,
LookAtTarget,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AxisLockSettings
enum class ES_AxisLockSettings : uint8 {
LockWorldX,
LockRelativeX,
LockWorldY,
LockRelativeY,
LockWorldZ,
LockRelativeZ,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WorldTimeSettings
enum class ES_WorldTimeSettings : uint8 {
TimeOfDay,
TimeScale,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LensSettings
enum class ES_LensSettings : uint8 {
FocalLength,
FocusDistance,
Aperture,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OrientationSettings
enum class ES_OrientationSettings : uint8 {
RollSensitivity,
PanTiltSensitivity,
PanTiltResponseCurve,
PanTiltDeadZone,
RotationLagSpeed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MovementSettings
enum class ES_MovementSettings : uint8 {
MaxSpeed,
Acceleration,
Deceleration,
BoomSensitivity,
BoomDeadZone,
TruckDollySensitivity,
TruckDollyDeadZone,
TurningBoost,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SettingCategory
enum class ES_SettingCategory : uint8 {
Movement,
Orientation,
Lens,
WorldTime,
AxisLock,
TargetLock,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ClientEventType
enum class ES_ClientEventType : uint8 {
UIImportantMessage,
UIStatusMessage,
ES_MAX,
};
// Enum Scavenger.ES_ClientEventParameterType
enum class ES_ClientEventParameterType : uint8 {
Float,
Int32,
ItemName,
PlayerName,
String,
TimeInSeconds,
ES_MAX,
};
// Enum Scavenger.ES_CommandSpecificType
enum class ES_CommandSpecificType : uint8 {
None,
Generic_Revive,
Item_UseQuickItem,
Weapon_Ready,
Weapon_ReloadBegin,
Weapon_UpdateAmmoCount,
Weapon_Stow,
Weapon_TriggerPress,
Weapon_TriggerRelease,
Weapon_Foo,
CommandOp_AbortCommand,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CommandGeneralType
enum class ES_CommandGeneralType : uint8 {
None,
Generic,
Item,
Weapon,
CommandOp,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ConsumablePackageType
enum class ES_ConsumablePackageType : uint8 {
Bandage,
DrinkBottle,
DrinkCan,
Food,
Kit,
Pills,
Reactor,
Syringe,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CharacterType
enum class ES_CharacterType : uint8 {
Default,
Streamer,
ES_MAX,
};
// Enum Scavenger.ES_EmoteGameMode
enum class ES_EmoteGameMode : uint8 {
Scavengers,
SocialHub,
SocialHubStreamer,
All,
ES_MAX,
};
// Enum Scavenger.ES_CosmeticLoadoutType
enum class ES_CosmeticLoadoutType : uint8 {
CharacterCosmeticLoadout,
AccountCosmeticLoadout,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CraftingSlot
enum class ES_CraftingSlot : uint8 {
Output,
InputOne,
InputTwo,
InputThree,
InputFour,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CraftingBlockedReasonsFlag
enum class ES_CraftingBlockedReasonsFlag : uint8 {
None,
InvalidRecipe,
LevelTooLow,
MissingInput,
NoRoomForOutput,
QueueFull,
QueueLimited,
PlayerDownedOrDead,
ES_MAX,
};
// Enum Scavenger.ES_CraftingEvent
enum class ES_CraftingEvent : uint8 {
Queued,
Started,
Completed,
Removed,
Stopped,
Failed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DamageTypeFlag
enum class ES_DamageTypeFlag : uint8 {
ArmorBypassing,
ArmorPiercing,
ArmorShredding,
NegatedByArmor,
WeakAgainstArmor,
HealthBypassing,
PoiseBypassing,
PoiseDamageIgnoresPoiseCooldown,
PoiseDamageIgnoresPoiseLock,
ShieldBypassing,
ShieldPiercing,
ShieldShredding,
NegatedByShield,
WeakAgainstShield,
ES_MAX,
};
// Enum Scavenger.ES_DamageOverTimeType
enum class ES_DamageOverTimeType : uint8 {
Acid,
Bleed,
Fire,
Plasma,
Poison,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_DamageModiferFlag
enum class ES_DamageModiferFlag : uint8 {
ResistanceDecreasedDamage,
BoneDecreasedDamage,
BoneIncreasedDamage,
GameModeDecreasedDamage,
GameModeIncreasedDamage,
ES_MAX,
};
// Enum Scavenger.ES_AutoJoinState
enum class ES_AutoJoinState : uint8 {
Started,
LoggingIn,
LoggedIn,
Joining,
Joined,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DrunkGapModelActions
enum class ES_DrunkGapModelActions : uint8 {
Run,
Strafe,
Turn,
Jump,
Dodge,
Sprint,
PrimaryAttack,
SecondaryAttack,
OffhandMelee,
CycleWeaponForward,
CycleWeaponBackward,
Reload,
ES_MAX,
};
// Enum Scavenger.ES_RayCast
enum class ES_RayCast : uint8 {
OneAxisDivX,
OneAxisDivY,
OneAxisDivZ,
VolumeSpread,
Count,
ES_MAX,
};
// Enum Scavenger.ES_KillExperienceTier
enum class ES_KillExperienceTier : uint8 {
Low,
Mid,
High,
Miniboss,
Boss,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_ExperienceTier
enum class ES_ExperienceTier : uint8 {
Low,
Mid,
High,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_FoleyEvent
enum class ES_FoleyEvent : uint8 {
Crouch,
Walk,
Run,
Sprint,
ActionShort,
ActionLong,
Detail,
LandLight,
LandHeavy,
CustomName,
ES_FoleyEvent_MAX,
};
// Enum Scavenger.ES_FootstepWeight
enum class ES_FootstepWeight : uint8 {
NONE,
Walk,
Run,
Sprint,
LandLight,
LandHeavy,
Crouch,
Slide,
Encumbered,
Downed,
RagdollImpact,
ES_MAX,
};
// Enum Scavenger.ES_FrontEndCharacterState
enum class ES_FrontEndCharacterState : uint8 {
WaitingInMenu,
TravellingToDraft,
Drafting,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FrontEndItemReceiverType
enum class ES_FrontEndItemReceiverType : uint8 {
Salvage,
ResearchProject,
StorefrontItem,
LoadoutItem,
Banner,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ChallengePrerequisiteComparison
enum class ES_ChallengePrerequisiteComparison : uint8 {
Active,
Complete,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FTUEStageCompletionState
enum class ES_FTUEStageCompletionState : uint8 {
Incomplete,
Complete,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AttributeContextADS
enum class ES_AttributeContextADS : uint8 {
Inactive,
Active,
Unset,
ES_MAX,
};
// Enum Scavenger.ES_TeamFillStrategy
enum class ES_TeamFillStrategy : uint8 {
FavorFullTeams,
FavorMoreTeams,
ES_MAX,
};
// Enum Scavenger.ES_GameModeEvent
enum class ES_GameModeEvent : uint8 {
GameStarted,
GameObjectiveCompleted,
GameIsTutorial,
GameEnded,
PlayerJoinedGame,
PlayerAssignedIndex_IntPlayerIndex,
PlayerAssignedToTeam_IntTeamIndex,
PlayerSelectedClass_NameDataClassID,
PlayerAuthenticated_NameDataAccountID,
PlayerDisplayNameSet_NameDataDisplayName,
PlayerBoostStatusActive,
PlayerLeftGame,
PlayerDidDamage_FloatAmount,
PlayerWasDowned_ByOtherPlayer,
PlayerWasRevived_ByOtherPlayer,
PlayerWasKilled_ByOtherPlayer,
PlayerWasResurrected_ByOtherPlayer,
PlayerExtracted,
ShardHarvested_IntAmount,
ShardExtracted_IntAmount,
ShardBanked_IntAmount,
ScrapCollected_IntAmount,
SalvageItemExtractedForPlayer_NameDataOnlineItemID,
SalvageItemExtractedForTeam_NameDataOnlineItemID,
TeamPlacementSet_IntAmount,
TeamObjectiveCompleted,
TeamEliminated,
TeamLeftOnPlanet,
TeamExtracted,
TeamExfiled,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LeaderboardRankingFactorRule
enum class ES_LeaderboardRankingFactorRule : uint8 {
PickHigher,
PickLower,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LeaderboardRankingFactor
enum class ES_LeaderboardRankingFactor : uint8 {
TeamIsAlive,
SamplesHeld,
SamplesBanked,
SamplesHeldOrBanked,
SamplesExtracted,
SamplesHeldOrExtracted,
SamplesHarvested,
ExplorersExtracted,
PlayersKilled,
TeammateDeaths,
TeamExperience,
TeamScore,
ObjectivesCompleted,
TeamHasEliminationTime,
TeamEliminationTime,
TeamExfiled,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ResolutionState
enum class ES_ResolutionState : uint8 {
MatchComplete,
LeftOnPlanet,
SuccessfulExtraction,
Exfiled,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FakeTeamDataMode
enum class ES_FakeTeamDataMode : uint8 {
Disabled,
Debug,
Shippable,
ES_MAX,
};
// Enum Scavenger.ES_TeamGameFlags
enum class ES_TeamGameFlags : uint8 {
NoNewMembers,
ES_MAX,
};
// Enum Scavenger.ES_BankingMethod
enum class ES_BankingMethod : uint8 {
Unknown,
DataUplink,
Extraction,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SpecialItem
enum class ES_SpecialItem : uint8 {
DataPoint,
Scrap,
ResurrectionToken,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DlssMode
enum class ES_DlssMode : uint8 {
Off,
UltraPerformance,
Performance,
Balanced,
Quality,
UltraQuality,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ResolutionScalingMode
enum class ES_ResolutionScalingMode : uint8 {
Disabled,
Auto,
Custom,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SupportedRHIType
enum class ES_SupportedRHIType : uint8 {
DX11,
DX12,
Unsupported,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GPUVendor
enum class ES_GPUVendor : uint8 {
Unrecognized,
Nvidia,
AMD,
Intel,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ToggleDisplayMethod
enum class ES_ToggleDisplayMethod : uint8 {
HideSelected,
HideUnselected,
HideAll,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InsertType
enum class ES_InsertType : uint8 {
SendToFront,
SendToBack,
AddBefore,
AddAfter,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WidgetEffectType
enum class ES_WidgetEffectType : uint8 {
None,
ParabolicEffect,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WidgetHideMethod
enum class ES_WidgetHideMethod : uint8 {
Remove,
RenderOpacity,
Visibility,
None,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InteractableActorType
enum class ES_InteractableActorType : uint8 {
Default,
ShardChest,
ShardBase,
SupplyPod,
VehicleGantry,
WeaponBench,
GearRack,
DropshipOpener,
Container,
Carcass,
ShardAltar,
ShardGrowth,
SpaceJunk,
StrategicChest,
DataUplink,
CookingStation,
Misc,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ItemNotification
enum class ES_ItemNotification : uint8 {
AddedToEquipment,
AddedToInventory,
ChangedEquipment,
ChangedInventory,
Dropped,
RemovedFromEquipment,
RemovedFromInventory,
SwappedWithEquipment,
SwappedWithInventory,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ItemChangeOperation
enum class ES_ItemChangeOperation : uint8 {
Lock,
Unlock,
UnlockAndResetServerTimestamp,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ItemManagerFlag
enum class ES_ItemManagerFlag : uint8 {
None,
AllowItemSwap,
DropExcess,
PartialAddOkay,
ShareWithTeam,
SkipEquipment,
SkipInventory,
ES_MAX,
};
// Enum Scavenger.ES_ItemFlag
enum class ES_ItemFlag : uint8 {
HasLockedCount,
HasServerTimestamp,
HasCosmeticLoadout,
ES_MAX,
};
// Enum Scavenger.ES_ItemType
enum class ES_ItemType : uint8 {
Weapon,
Consumable,
Scoring,
Salvage,
Ammo,
Currency,
Junk_DEPRECATED,
Grenade,
ResurrectionToken,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ItemWidget
enum class ES_ItemWidget : uint8 {
Ammo,
Container,
Crafting,
Currency,
Equipment,
Hotbar,
Inventory,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ItemStatType
enum class ES_ItemStatType : uint8 {
AmmoCount_Primary,
AmmoCount_Secondary,
AmmoCount_Tertiary,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ItemPickupOrDropReason
enum class ES_ItemPickupOrDropReason : uint8 {
Unknown,
Explicit,
Automatic,
Scrapped,
SplitOrCombine,
TeamTrade,
Moved,
GameMode,
Crafting,
Cooked,
Died,
Destroyed,
Spent,
Cheat,
Deprecated,
Count,
ES_MAX,
};
// Enum Scavenger.ES_JwtStatus
enum class ES_JwtStatus : uint8 {
Verified,
FailedMalformedToken,
FailedInvalidBase64,
FailedInvalidHeaderJson,
FailedHeaderParsing,
FailedInvalidPayloadJson,
FailedExpired,
FailedParsingPayload,
FailedInvalidSignature,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LatencyBeacon
enum class ES_LatencyBeacon : uint8 {
Default,
OffloadWorker,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LevelStreamState
enum class ES_LevelStreamState : uint8 {
Disabled,
Unloaded,
ShouldLoad,
Loaded,
Visible,
ES_MAX,
};
// Enum Scavenger.ES_LobbyMessageType
enum class ES_LobbyMessageType : uint8 {
QueueList,
QueueStatus,
ReceivedTextMessage,
TeamState,
PartyState,
PlayerState,
JoinPartyFailed,
JoinQueueFailed,
PartyInvite,
ConnectToServer,
HaveFun,
VoiceChatCredentials,
ChatCredentials,
OnlinePlayers,
StartDraft,
NextDraftingPeriod,
MatchManifest,
MatchAllocated,
ClientHello,
RefreshQueues,
RefreshOnlinePlayersList,
JoinMyPartyToQueue,
ChangeTeam,
UpdatePlayerDetails,
GameJoined,
StartGame,
ReturnToLobby,
RequestVoiceChatCredentials,
RequestChatCredentials,
RequestToJoinParty,
PlayerLeaveCurrentParty,
RemoveMyPartyFromQueue,
PartyLeaveCurrentTeam,
SendPartyInvite,
SendTextMessage,
ServerHello,
ServerJoinQueue,
MatchPhaseUpdate,
RequestTitleNews,
TitleNews,
PlayerReconnectState,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MapMode
enum class ES_MapMode : uint8 {
Default,
MiniMap,
ES_MAX,
};
// Enum Scavenger.ES_DetectionReason
enum class ES_DetectionReason : uint8 {
Unknown,
Shards,
Rogue,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ReloadSound
enum class ES_ReloadSound : uint8 {
Reload1,
Reload2,
Reload3,
Reload4,
Reload5,
Reload6,
Reload7,
Reload8,
Reload9,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_MeleeSoundStrength
enum class ES_MeleeSoundStrength : uint8 {
Light,
Normal,
Strong,
Lunge,
Exhausted_Light,
Exhausted_Heavy,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_PlayerControllerState
enum class ES_PlayerControllerState : uint8 {
OnFoot,
InVehicleDriver,
InVehiclePassenger,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MixStageExclusive
enum class ES_MixStageExclusive : uint8 {
Launch,
MainMenu,
Draft,
PostMatch,
Cascade_DefaultStart,
Cascade_Spectating,
Cascade_Countdown,
Tutorial,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MultiActionCondition
enum class ES_MultiActionCondition : uint8 {
OneInTotal,
OneInQueue,
Unlimited,
ES_MAX,
};
// Enum Scavenger.ES_MusicCue
enum class ES_MusicCue : uint8 {
None,
MainTheme,
FrontEndMusicLoop,
MatchIntro,
NewMissionData,
ShardHarvested,
LevelUp,
ResurrectedByTeammate,
AllShardsHarvested,
StormCollapsing,
DropshipArrivalAndCountdown,
MissionSuccess,
MissionFailureDied,
PostGameMenuWin,
PostGameMenuLoss,
ScourgeEvent,
OutlanderEvent,
OvertimeEvent,
MenuDraftEntering,
MenuDraft,
MenuResearchScreen,
BleedingOut,
PlayerDeath,
WaitingToBeRevived,
TeammateDowned,
TeammateExecuted,
GainedTheLead,
LostTheLead,
OutlanderEventElite,
OutlanderEventBoss,
ScourgeEventElite,
ScourgeEventBoss,
TimeOfDayChange,
MenuLoading,
CountDownBuildUp,
TrinityDropshipsShort,
TrinityDropshipsLong,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DirtiedAreaReason
enum class ES_DirtiedAreaReason : uint8 {
RegisterNavOctreeElement,
UnregisterNavOctreeElement,
UpdateNavOctreeElement,
UpdateNavOctreeParentChain,
UpdateNavOctreeElementBounds,
AddLevelCollisionToOctree,
RemoveLevelCollisionFromOctree,
RebuildAll,
Tick,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NetMode
enum class ES_NetMode : uint8 {
Standalone,
DedicatedServer,
ListenServer,
Client,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ObjectiveFailureReason
enum class ES_ObjectiveFailureReason : uint8 {
None,
ActorDestroyed,
ActorInteraction,
GoalCompleted,
GoalFailed,
InsideAreaTooLong,
OutsideAreaTooLong,
ProgressComplete,
ProgressFailed,
SubGoalCompleted,
SubGoalFailed,
TimeExpired,
Unknown,
ES_MAX,
};
// Enum Scavenger.ES_ObjectiveMarkerFlag
enum class ES_ObjectiveMarkerFlag : uint8 {
HasActor,
UseTeamColor,
ES_MAX,
};
// Enum Scavenger.ES_ObjectiveFlag
enum class ES_ObjectiveFlag : uint8 {
HasActor,
HasArea,
HasProgress,
HasTimer,
MatchAllPawnCheck,
ShowAreaOutline,
ShowMarkerOnActor,
ShowMarkersOnPawnsInRange,
ShowProgressAsBar,
ES_MAX,
};
// Enum Scavenger.ES_ObjectiveOutcomeSelector
enum class ES_ObjectiveOutcomeSelector : uint8 {
None,
OnDestroy,
OnAllGoalsComplete,
OnAnyGoalComplete,
OnAllGoalsFailed,
OnAnyGoalFailed,
OnInteract,
OnInsideAreaTimerExpire,
OnOutsideAreaTimerExpire,
OnProgressComplete,
OnProgressFailed,
OnAllSubGoalsComplete,
OnAnySubGoalComplete,
OnAllSubGoalsFailed,
OnAnySubGoalFailed,
OnTimerExpire,
ES_MAX,
};
// Enum Scavenger.ES_ObjectiveProgressSelector
enum class ES_ObjectiveProgressSelector : uint8 {
None,
OnInteract,
OnItemAcquire,
OnItemDrop,
OnItemUse,
OnPawnKill,
ES_MAX,
};
// Enum Scavenger.ES_CatalogItemContentCalculationMethod
enum class ES_CatalogItemContentCalculationMethod : uint8 {
Minimum,
Maximum,
ES_MAX,
};
// Enum Scavenger.ES_LobbyPingActionState
enum class ES_LobbyPingActionState : uint8 {
Dormant,
Pinging,
Waiting,
Count,
ES_MAX,
};
// Enum Scavenger.ES_EndpointPingActionState
enum class ES_EndpointPingActionState : uint8 {
Dormant,
Pinging,
Waiting,
Count,
ES_MAX,
};
// Enum Scavenger.ES_EndpointPingStatus
enum class ES_EndpointPingStatus : uint8 {
Unknown,
Available,
Unreachable,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScavengersDataApiErrorCode
enum class ES_ScavengersDataApiErrorCode : uint8 {
None,
InternalError,
Banned,
InvalidArgument,
Unauthorized,
InvalidState,
InvalidStateNotEnoughResource,
InvalidOperation,
ES_MAX,
};
// Enum Scavenger.ES_SocialHubSchedulingState
enum class ES_SocialHubSchedulingState : uint8 {
Disabled,
Scheduled,
CountdownActive,
CountdownActiveVIP,
EventActive,
ES_MAX,
};
// Enum Scavenger.ES_PlayerReportReason
enum class ES_PlayerReportReason : uint8 {
Unknown,
CommsAbuse,
Cheating,
LeavingTheGame,
DisrespectfulBehavior,
InappropriateName,
Threats,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StoreOfferFlags
enum class ES_StoreOfferFlags : uint8 {
IsLocked,
IsOwned,
IsBoost,
IsPlatformOffer,
ES_MAX,
};
// Enum Scavenger.ES_OnlineItemResearchState
enum class ES_OnlineItemResearchState : uint8 {
Owned,
Restricted,
Researchable,
ResearchInProgress,
ResearchComplete,
RequirementsNotMet,
InProgressButResearchable,
CompleteButResearchable,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineItemSortMode
enum class ES_OnlineItemSortMode : uint8 {
Rarity,
NameAscending,
NameDescending,
Availability,
Tracked,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineLeaderboardSortOrder
enum class ES_OnlineLeaderboardSortOrder : uint8 {
Ascending,
Descending,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineRestrictionType
enum class ES_OnlineRestrictionType : uint8 {
Invalid,
Entitlement,
EntitlementType,
Restriction,
AccountLevel,
CharacterLevel,
PlayerTag,
ES_MAX,
};
// Enum Scavenger.ES_CharacterPointType
enum class ES_CharacterPointType : uint8 {
CXP,
CRP,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VirtualCurrencyType
enum class ES_VirtualCurrencyType : uint8 {
RM,
VM,
UU,
UR,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlinePlatformType
enum class ES_OnlinePlatformType : uint8 {
Unknown,
Steam,
Epic,
XBox,
Playstation,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OpportunityPointWeatherType
enum class ES_OpportunityPointWeatherType : uint8 {
ValidInAllWeather,
ValidInStorm,
ValidOutsideOfStorm,
ES_MAX,
};
// Enum Scavenger.ES_CombatState
enum class ES_CombatState : uint8 {
Wander,
Patrol,
Combat,
Investigate,
Search,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OverlappingInputState
enum class ES_OverlappingInputState : uint8 {
IdleUp,
DownResolving,
DownPressed,
DownHeld,
DownDoublePressed,
ES_MAX,
};
// Enum Scavenger.ES_OverrideType
enum class ES_OverrideType : uint8 {
String,
Int,
Float,
Vector,
Bool,
None,
ES_MAX,
};
// Enum Scavenger.ES_AuditGPUSelection
enum class ES_AuditGPUSelection : uint8 {
All,
OnlySelected,
SelectedAndChildren,
ES_MAX,
};
// Enum Scavenger.ES_PhysicalSurfaceAttribMod
enum class ES_PhysicalSurfaceAttribMod : uint8 {
AddToBase,
AddToBaseStacking,
MultiplyBase,
MultiplyStacking,
Override,
ES_MAX,
};
// Enum Scavenger.PhysicsQuantityType
enum class PhysicsQuantityType : uint8 {
Angular,
Linear,
PhysicsQuantityType_MAX,
};
// Enum Scavenger.AxisType
enum class AxisType : uint8 {
ModelRight,
ModelUp,
ModelForward,
ModelRightXZ,
ModelForwardXZ,
WorldRight,
WorldUp,
WorldForward,
AxisType_MAX,
};
// Enum Scavenger.ES_AutoPingNotificationType
enum class ES_AutoPingNotificationType : uint8 {
Objective,
Suggestive,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PingItemRequestResult
enum class ES_PingItemRequestResult : uint8 {
Failed,
Added,
Cleared,
Repeated,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PingGutterState
enum class ES_PingGutterState : uint8 {
InnerGutter,
OuterGutter,
Count,
ES_MAX,
};
// Enum Scavenger.ES_KeeperAbilityTaskCompletionFunctions
enum class ES_KeeperAbilityTaskCompletionFunctions : uint8 {
Default,
OnCompleted,
OnBlendOut,
OnInterrupted,
OnCancelled,
Count,
ES_MAX,
};
// Enum Scavenger.ES_KeeperCloakState
enum class ES_KeeperCloakState : uint8 {
Uncloaked,
Cloaking,
Cloaked,
Uncloaking,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CriticalHealthState
enum class ES_CriticalHealthState : uint8 {
Off,
FadingIn,
FadingOut,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScreenDamageDirection
enum class ES_ScreenDamageDirection : uint8 {
TopRight,
Right,
BottomRight,
Bottom,
BottomLeft,
Left,
TopLeft,
Top,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScreenDamageIndicatorState
enum class ES_ScreenDamageIndicatorState : uint8 {
Off,
FadingIn,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DamageCauseActor
enum class ES_DamageCauseActor : uint8 {
None,
Self,
Other,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PlayerClassGender
enum class ES_PlayerClassGender : uint8 {
Male,
Female,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CharacterFlags
enum class ES_CharacterFlags : uint8 {
Locked,
ES_MAX,
};
// Enum Scavenger.ES_ClientErrorCode
enum class ES_ClientErrorCode : uint8 {
Unknown,
Chilalo,
Churchill,
Noshaq,
Snebordet,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_ReplicatedActionResult
enum class ES_ReplicatedActionResult : uint8 {
Completed,
Failed,
Stopped,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TeammateLoadoutItemType
enum class ES_TeammateLoadoutItemType : uint8 {
Unknown,
LoadoutRecipe,
ES_MAX,
};
// Enum Scavenger.ES_MainMenuStartupState
enum class ES_MainMenuStartupState : uint8 {
LoginRewards,
Events,
Done,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PlayerInputContext
enum class ES_PlayerInputContext : uint8 {
None,
MainMenu,
Gameplay,
GameplayMenu,
GameplayFinished,
SystemMenu,
RadialMenu,
Research,
Loadout,
Seasons,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InputPriorityFlag
enum class ES_InputPriorityFlag : uint8 {
Primary,
Secondary,
All,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InputDeviceFlag
enum class ES_InputDeviceFlag : uint8 {
Active,
ControllerOnly,
KeyboardOnly,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TeamFlag
enum class ES_TeamFlag : uint8 {
Team1,
Team2,
Team3,
Team4,
Team5,
Team6,
Team7,
Team8,
Team9,
Team10,
Team11,
Team12,
Team13,
Team14,
Team15,
Team16,
Team17,
Team18,
Team19,
Team20,
Team21,
Team22,
Team23,
Team24,
Team25,
Team26,
Team27,
Team28,
Team29,
Team30,
Team31,
Team32,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PostMatchStatType
enum class ES_PostMatchStatType : uint8 {
Gameplay,
Boost,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ResummonedPhaseState
enum class ES_ResummonedPhaseState : uint8 {
Unavailable,
Skip,
ShowFull,
ShowEndState,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PostMatchContext
enum class ES_PostMatchContext : uint8 {
Session,
MainMenu,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InterruptionUrgency
enum class ES_InterruptionUrgency : uint8 {
ImmediateInterrupt,
SendInterruptTrigger,
WaitPolitely,
ES_MAX,
};
// Enum Scavenger.ES_PrivacyRequestType
enum class ES_PrivacyRequestType : uint8 {
Block,
Unblock,
UnblockAll,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ProjectileImpactResponse
enum class ES_ProjectileImpactResponse : uint8 {
Destroy,
Attach,
Bounce,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ReplicatedAttackEntryType
enum class ES_ReplicatedAttackEntryType : uint8 {
Attack,
Reload,
Swap,
ES_MAX,
};
// Enum Scavenger.ES_ClassRepNodeMapping
enum class ES_ClassRepNodeMapping : uint8 {
NotRouted,
RelevantAllConnections,
Spatialize_Static,
Spatialize_Dynamic,
Spatialize_Dormancy,
ES_MAX,
};
// Enum Scavenger.ES_TierRewardState
enum class ES_TierRewardState : uint8 {
None,
InstantRewardBattlePass,
Skippable,
Locked,
AccomplishedBattlePass,
ReadyToClaim,
Claimed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TierRewardFooterState
enum class ES_TierRewardFooterState : uint8 {
None,
FooterText,
Locked,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TierRewardHeaderState
enum class ES_TierRewardHeaderState : uint8 {
None,
Free,
BattlepassIcon,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ShieldState
enum class ES_ShieldState : uint8 {
Active,
PartialDamage,
Breaking,
Rebooting,
RebootComplete,
Recharging,
RechargeComplete,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SkinMaterialParameter
enum class ES_SkinMaterialParameter : uint8 {
Scalar,
Vector,
Texture,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SmeltState
enum class ES_SmeltState : uint8 {
Begin,
InitRenderTargets,
Smelt,
CreateTextures,
CreateTasks,
CreateTexturesAndCompressionTasks,
ReadSurfaceData,
CompressTextures,
CopyCompressedDataToMipMap,
SetupMaterials,
Done,
None,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SkyMaterialOverride
enum class ES_SkyMaterialOverride : uint8 {
Blend,
Clear,
Stormy,
AlphaMask,
ES_MAX,
};
// Enum Scavenger.ES_BouncerViewMode
enum class ES_BouncerViewMode : uint8 {
All,
Characters,
Players,
ES_MAX,
};
// Enum Scavenger.ES_PickupType
enum class ES_PickupType : uint8 {
Scrap,
Data,
ES_MAX,
};
// Enum Scavenger.ES_SocialHubMILEState
enum class ES_SocialHubMILEState : uint8 {
NoPhaseLoaded,
PhaseLoading,
PhaseLoaded,
PhaseUnloading,
ES_MAX,
};
// Enum Scavenger.ESimPlayerPattern
enum class ESimPlayerPattern : uint8 {
SimPlayerFormation,
SimPlayerWander,
SimPlayerAttack,
ESimPlayerPattern_MAX,
};
// Enum Scavenger.EAIAttackPattern
enum class EAIAttackPattern : uint8 {
AIAttackAll,
AIAttackStreamers,
AIAttackNone,
EAIAttackPattern_MAX,
};
// Enum Scavenger.ESocialHubEvent
enum class ESocialHubEvent : uint8 {
DropshipArrival,
PlayMusic,
EndOfEvent,
ESocialHubEvent_MAX,
};
// Enum Scavenger.ES_SocialHubWidgetCountType
enum class ES_SocialHubWidgetCountType : uint8 {
Players,
SimPlayers,
PlayersAndSimPlayers,
AIClients,
ES_MAX,
};
// Enum Scavenger.ES_SocialHubAbilityButtonState
enum class ES_SocialHubAbilityButtonState : uint8 {
Deactivated,
Idle,
Running,
Cooldown,
ES_MAX,
};
// Enum Scavenger.ES_SocialConnectionState
enum class ES_SocialConnectionState : uint8 {
Disconnected,
Connecting,
Connected,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SpawnDescriptor
enum class ES_SpawnDescriptor : uint8 {
Replenisher,
InitialOnly,
Manual,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AISpawnPhase
enum class ES_AISpawnPhase : uint8 {
AISpawnPhase0,
AISpawnPhase1,
AISpawnPhase2,
AISpawnPhase3,
AISpawnPhase4,
AISpawnPhase5,
AISpawnPhase6,
AISpawnPhase7,
AISpawnPhase8,
AISpawnPhase9,
Count,
ES_MAX,
};
// Enum Scavenger.ES_RecoilImpulseInhertienceType
enum class ES_RecoilImpulseInhertienceType : uint8 {
None,
Add,
Multiply,
Count,
ES_MAX,
};
// Enum Scavenger.ES_RecoilSettings
enum class ES_RecoilSettings : uint8 {
StandingHip,
StandingADS,
CrouchedHip,
CrouchedADS,
Count,
Default,
ES_MAX,
};
// Enum Scavenger.ES_StatsGameplayEvent
enum class ES_StatsGameplayEvent : uint8 {
Assassination,
AssassinationDamage,
ExecutionDamage,
ExtractFailed,
ReviveNotAllowed,
VehicleWrecked,
FreedFromCocoon,
PlayerExtracting,
PlayerExtracted,
PlayerResurrected,
SelfDestruct,
Count,
Debug_Alive,
Debug_Dead,
Debug_Downed,
Debug_Terminal,
ES_MAX,
};
// Enum Scavenger.ES_StatsShieldState
enum class ES_StatsShieldState : uint8 {
Ready,
Rebooting,
Regenerating,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CompassDirection
enum class ES_CompassDirection : uint8 {
North,
NorthEast,
East,
SouthEast,
South,
SouthWest,
West,
NorthWest,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StreamerAbilityRunType
enum class ES_StreamerAbilityRunType : uint8 {
Server,
Client,
Both,
ES_MAX,
};
// Enum Scavenger.ES_StreamerAbilityUnlockType
enum class ES_StreamerAbilityUnlockType : uint8 {
ByCharge,
Explicit,
ES_MAX,
};
// Enum Scavenger.ES_StreamerMenuEntryType
enum class ES_StreamerMenuEntryType : uint8 {
Ability,
GlobalEvent,
Node,
Return,
ES_MAX,
};
// Enum Scavenger.ES_TraitGroup
enum class ES_TraitGroup : uint8 {
Invalid,
Base,
Survivalist,
Defender,
Acrobat,
Soldier,
Engineer,
Sniper,
Ninja,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TraitGroupType
enum class ES_TraitGroupType : uint8 {
Invalid,
Primary,
Secondary,
Tertiary,
Base,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScavAITeams
enum class ES_ScavAITeams : uint8 {
Explorer,
Keeper,
Outlander,
Salient,
Scourge,
ScourgeShrieker,
WildlifePredator,
WildlifePrey,
Count,
NoTeam,
ES_MAX,
};
// Enum Scavenger.ES_TechTreeCategory
enum class ES_TechTreeCategory : uint8 {
Weapon,
Skill,
Consumable,
ES_MAX,
};
// Enum Scavenger.ES_PartyAction
enum class ES_PartyAction : uint8 {
Unknown,
PartyInviteSent,
PartyInviteReceived,
PartyInviteAccepted,
PartyInviteRejected,
PartyInviteOutgoingCanceled,
PartyInviteIncomingCanceled,
PartyJoinRequestSent,
PartyJoinRequestReceived,
PartyJoinRequestAccepted,
PartyJoinRequestRejected,
PartyJoinRequestOutgoingCanceled,
PartyJoinRequestIncomingCanceled,
PartyJoinFailed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SocialAction
enum class ES_SocialAction : uint8 {
Unknown,
FriendRequestSent,
FriendRequestRevoked,
FriendRequestReceived,
FriendRequestAccepted,
FriendRequestRejected,
FriendRemoved,
PlayerBlocked,
PlayerUnblocked,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FTUETelemetryReason
enum class ES_FTUETelemetryReason : uint8 {
Started,
Completed,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PlayerLeftMatchReason
enum class ES_PlayerLeftMatchReason : uint8 {
Unknown,
ClientDisconnect,
ClientError,
ClientIntegrity,
ClientShutdown,
ServerDisconnect,
ServerError,
ServerGameOver,
ServerIntegrity,
ServerShutdown,
UserAction,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PlayerLeftMatchPlayerState
enum class ES_PlayerLeftMatchPlayerState : uint8 {
Unknown,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PlayerTelemetryType
enum class ES_PlayerTelemetryType : uint8 {
Human,
DrunkGapModel,
BotModel,
ES_MAX,
};
// Enum Scavenger.FS_TelemetryHitchEnum
enum class FS_TelemetryHitchEnum : uint8 {
RenderThread,
GameThread,
GPU,
FS_MAX,
};
// Enum Scavenger.ES_MatchEndReason
enum class ES_MatchEndReason : uint8 {
Unknown,
EveryoneDied,
MatchTimerExpired,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MatchmakingAttemptResult
enum class ES_MatchmakingAttemptResult : uint8 {
Unknown,
Success,
Failure,
Cancel,
COUNT,
ES_MAX,
};
// Enum Scavenger.ES_TelemetryAttackType
enum class ES_TelemetryAttackType : uint8 {
HipFire,
ADS,
Melee,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InMatchClientInputFeature
enum class ES_InMatchClientInputFeature : uint8 {
Unknown,
MapScreen,
InventoryScreen,
CraftingScreen,
LeaderboardScreen,
SettingsScreen,
PushToTalkButton,
MapPing,
WorldPing,
ActivateAbility,
Dodge,
Slide,
Mantle,
ExplicitReload,
ExplicitWeaponStow,
Count,
ES_MAX,
};
// Enum Scavenger.ES_HarvestResult
enum class ES_HarvestResult : uint8 {
Unknown,
CompletedSuccessfully,
FailedKeeperInterrupted,
FailedTeamKilled,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TelemetryDeathSource
enum class ES_TelemetryDeathSource : uint8 {
Player,
AI,
Unknown,
ES_MAX,
};
// Enum Scavenger.ETelemetrySource
enum class ETelemetrySource : uint8 {
Disabled,
Server,
Client,
Editor,
Services,
Count,
ETelemetrySource_MAX,
};
// Enum Scavenger.ES_StormCAT
enum class ES_StormCAT : uint8 {
CAT1,
CAT2,
CAT3,
CAT4,
CAT5,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AttachmentParentType
enum class ES_AttachmentParentType : uint8 {
Attachment,
Weapon,
Pawn,
None,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CycleDirection
enum class ES_CycleDirection : uint8 {
Forward,
Backward,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MutatorType
enum class ES_MutatorType : uint8 {
None,
GunFu,
Arsenal,
ES_MAX,
};
// Enum Scavenger.ES_ViewportFadeType
enum class ES_ViewportFadeType : uint8 {
FadeIn,
FadeOut,
Count,
ES_MAX,
};
// Enum Scavenger.ES_RestrictionStateTypes
enum class ES_RestrictionStateTypes : uint8 {
Unrestricted,
RestrictedByTier,
RestrictedByOther,
Count,
ES_MAX,
};
// Enum Scavenger.ES_OnlineItemLoadoutState
enum class ES_OnlineItemLoadoutState : uint8 {
Owned,
Equipped,
Locked,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InGameZOrderCategory
enum class ES_InGameZOrderCategory : uint8 {
Default,
Overlay,
Notifications,
ErrorsAndWarnings,
FTUEOverlay,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MessagePromptMode
enum class ES_MessagePromptMode : uint8 {
Notification,
Warning,
Error,
Confirmation,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NamePlateHealthBarBehavior
enum class ES_NamePlateHealthBarBehavior : uint8 {
AlwaysShow,
ShowIfDamaged,
NeverShow,
ES_MAX,
};
// Enum Scavenger.ES_ButtonFocusSupport
enum class ES_ButtonFocusSupport : uint8 {
Unfocusable,
FocusableUnlessDisabled,
FocusableWhenActive,
AlwaysFocusable,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ButtonVisibility
enum class ES_ButtonVisibility : uint8 {
Visible,
Collapsed,
Hidden,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ButtonType
enum class ES_ButtonType : uint8 {
Repeatable,
Selectable,
Toggleable,
Count,
ES_MAX,
};
// Enum Scavenger.ES_UseItemNotify
enum class ES_UseItemNotify : uint8 {
ConsumeItem,
Finished,
ES_MAX,
};
// Enum Scavenger.ES_ButtonState
enum class ES_ButtonState : uint8 {
Up,
Pressed,
Down,
Released,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CurveType
enum class ES_CurveType : uint8 {
EaseInEaseOut,
EaseIn,
EaseOut,
Linear,
Count,
ES_MAX,
};
// Enum Scavenger.ES_EulerRotation
enum class ES_EulerRotation : uint8 {
Pitch,
Yaw,
Roll,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FilterIfMatch
enum class ES_FilterIfMatch : uint8 {
Include,
Exclude,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AnimationDuration
enum class ES_AnimationDuration : uint8 {
Default,
Looping,
Infinite,
Count,
ES_MAX,
};
// Enum Scavenger.ES_MaterialParameter
enum class ES_MaterialParameter : uint8 {
Scalar,
Vector,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VisualEffect
enum class ES_VisualEffect : uint8 {
Shell,
PostProcess,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VirtualCursorStatus
enum class ES_VirtualCursorStatus : uint8 {
Visible,
Hidden,
ForceHidden,
Count,
ES_MAX,
};
// Enum Scavenger.ES_DisconnectBehavior
enum class ES_DisconnectBehavior : uint8 {
AlwaysRetry,
NeverRetry,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VoiceChannelState
enum class ES_VoiceChannelState : uint8 {
Disconnected,
Disconnecting,
Connecting,
Connected,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VoiceChannelCategory
enum class ES_VoiceChannelCategory : uint8 {
Squad,
Friend,
EchoTest,
Count,
Invalid,
ES_MAX,
};
// Enum Scavenger.ES_SquadJoinPreference
enum class ES_SquadJoinPreference : uint8 {
Autojoin,
Manual,
Disabled,
Count,
ES_MAX,
};
// Enum Scavenger.ES_VoiceConnectionState
enum class ES_VoiceConnectionState : uint8 {
Disconnected,
Disconnecting,
Connecting,
Connected,
PendingLoginToken,
LoggingIn,
LoggedIn,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CameraSettingsFlag
enum class ES_CameraSettingsFlag : uint8 {
ThirdPersonClose,
ThirdPersonFar,
ThirdPersonADS,
ThirdPersonRoll,
ThirdPersonCrouchedClose,
ThirdPersonCrouchedFar,
ThirdPersonCrouchedADS,
ThirdPersonDropPod,
ThirdPersonDowned,
ThirdPersonMantle,
ThirdPersonSprint,
ES_MAX,
};
// Enum Scavenger.ES_AIRange
enum class ES_AIRange : uint8 {
CloseRange,
MediumRange,
LongRange,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ProjectileWindupFiringType
enum class ES_ProjectileWindupFiringType : uint8 {
NONE,
ARC_BASED,
VELOCITY_BASED,
VELOCITY_BASED_WITH_AIM_PITCH,
VELOCITY_DERIVED_HIGH_LOW_ARC,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SpreadSlots
enum class ES_SpreadSlots : uint8 {
SP_Sprint,
SP_Reload,
SP_Walk,
SP_Jump,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WeaponMontageEvent
enum class ES_WeaponMontageEvent : uint8 {
None,
Fire,
Reload,
Ready,
Stow,
Windup,
OffHandMelee,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TriggerableWeaponAttachmentClass
enum class ES_TriggerableWeaponAttachmentClass : uint8 {
BaseAttachment,
Chainsaw,
GrenadeLauncher,
OffhandMelee,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WeaponGripType
enum class ES_WeaponGripType : uint8 {
Default,
Angled,
Dropped,
Horizontal,
Vertical,
CustomHyena,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WeaponModifier
enum class ES_WeaponModifier : uint8 {
Accuracy,
AttackExitDelayBeforeSprint,
CameraArmLength,
CameraArmLengthTransitionSpeed,
CameraFieldOfView,
CameraFieldOfViewTransitionSpeed,
CameraRecoilMultiplier,
CameraTargetOffsetX,
CameraTargetOffsetY,
CameraTargetOffsetZ,
CameraTargetOffsetTransitionSpeed,
CameraSocketOffsetX,
CameraSocketOffsetY,
CameraSocketOffsetZ,
CameraSocketOffsetTransitionSpeed,
CameraLagSpeedFwd,
CameraLagSpeedSide,
CameraLagSpeedUp,
CameraLagSpeedDown,
CriticalChance,
CriticalMultiplier,
Damage,
FireRate,
Flinch,
MeleeSpeed,
InputPitchMultiplier,
InputYawMultiplier,
MagazineSize,
MovementSpeedADSMultiplier,
MovementSpeedCrouched,
MovementSpeedSprintBonus,
MovementSpeedWalk,
ReloadSpeed,
StowSpeed,
ReadySpeed,
StaminaCost,
SpreadCosmeticBloomMultiplier,
SpreadMaxAngle,
SpreadMinAngle,
SpreadRecoilMultiplier,
SpreadReloadStartTarget,
SpreadReloadStopTarget,
SpreadWalkStartTarget,
SpreadWalkStopTarget,
SprintExitAttackDelay,
Zoom,
AutoAimAngle,
AutoAimFalloffNearStart,
AutoAimFalloffNearEnd,
AutoAimFalloffStart,
AutoAimFalloffEnd,
AimFrictionAngle,
AimFrictionFalloffNearStart,
AimFrictionFalloffNearEnd,
AimFrictionFalloffStart,
AimFrictionFalloffEnd,
ActorUnderReticleMaxDistance,
ActorUnderReticleInnerBaseFOV,
ActorUnderReticleOuterBaseFOV,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CosmeticWeaponClass
enum class ES_CosmeticWeaponClass : uint8 {
None,
Bow,
Crossbow,
Heavy,
Handgun,
Melee,
Rifle,
Shotgun,
SMG,
Sniper,
Grenade,
GrenadeLauncher,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WeaponClass
enum class ES_WeaponClass : uint8 {
Unarmed,
Blade,
Club,
Staff,
Minigun,
Pistol,
Rifle,
Railgun,
Shotgun,
SMG,
Flamethrower,
GrenadeLauncher,
RocketLauncher,
Bow,
Crossbow,
DualShield,
Grenade,
Halberd,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AttackTag
enum class ES_AttackTag : uint8 {
Bow,
Explosive,
Pistol,
Rifle,
Shotgun,
ArmorBypassing,
ArmorPiercing,
ArmorShredding,
WeakAgainstArmor,
ES_MAX,
};
// Enum Scavenger.ES_AudioEventEndAction
enum class ES_AudioEventEndAction : uint8 {
None,
Stop,
Break,
FadeOut,
ES_MAX,
};
// Enum Scavenger.ES_AttackSlotState
enum class ES_AttackSlotState : uint8 {
Ready,
AttackWindup,
Attacking,
AttackingBurst,
Reloading,
Count,
ES_MAX,
};
// Enum Scavenger.ES_AttackBehavior
enum class ES_AttackBehavior : uint8 {
OnceOnPress,
RepeatWhileHeld,
OnceOnRelease,
Count,
ES_MAX,
};
// Enum Scavenger.ES_WidgetAnimationDataType
enum class ES_WidgetAnimationDataType : uint8 {
Float,
Vector,
LinearColor,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ChallengeWidgetState
enum class ES_ChallengeWidgetState : uint8 {
Uninitialized,
Active,
Complete,
Count,
ES_MAX,
};
// Enum Scavenger.ES_CompassMode
enum class ES_CompassMode : uint8 {
Default,
Radial,
ES_MAX,
};
// Enum Scavenger.ES_CustomizationItemEntryType
enum class ES_CustomizationItemEntryType : uint8 {
Uninitialized,
CosmeticType,
CosmeticItem,
SubmaterialAndColorOptionPair,
SubmaterialSlot,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SocialWidgetSorting
enum class ES_SocialWidgetSorting : uint8 {
Alphabetical,
AlphabeticalOnlineFirst,
Count,
ES_MAX,
};
// Enum Scavenger.ES_FriendListTabs
enum class ES_FriendListTabs : uint8 {
FriendsTab,
RecentPlayersTab,
InvitesTab,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScoreboardDataContext
enum class ES_ScoreboardDataContext : uint8 {
Session,
PreTakeoff,
PostTakeoff,
Count,
ES_MAX,
};
// Enum Scavenger.ES_GutterStatus
enum class ES_GutterStatus : uint8 {
Inside_Gutter_Shape,
Outside_Gutter,
InGutter_Left,
InGutter_Top,
InGutter_Right,
InGutter_Bottom,
ES_MAX,
};
// Enum Scavenger.ES_GutterShape
enum class ES_GutterShape : uint8 {
Square,
Elipse,
SubWidget,
ES_MAX,
};
// Enum Scavenger.ES_ResultOfEquipping
enum class ES_ResultOfEquipping : uint8 {
CannotEquip,
DropsExistingItem,
EquipsIntoEmptySlot,
MergesIntoExistingItem,
SwapsWithExistingItem,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InventoryToastAction
enum class ES_InventoryToastAction : uint8 {
Added,
Removed,
Swapped,
Converted,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InventoryScreenArea
enum class ES_InventoryScreenArea : uint8 {
None,
Currency_DEPRECATED,
Equipment_DEPRECATED,
Inventory,
QuickItem,
Teammate_DEPRECATED,
Vicinity,
Weapon,
Resources,
Ammo,
Count,
ES_MAX,
};
// Enum Scavenger.ES_RecipeCardType
enum class ES_RecipeCardType : uint8 {
Crafting,
Loadout,
Count,
ES_MAX,
};
// Enum Scavenger.ES_LobbyEventTimerMode
enum class ES_LobbyEventTimerMode : uint8 {
Disabled,
TimerAndStatus,
TimerAndStatusIfNotSilent,
TimerOnly,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NameplateType
enum class ES_NameplateType : uint8 {
Disabled,
Default,
Social,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NavBarType
enum class ES_NavBarType : uint8 {
Primary,
Secondary,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NavBarCycleMode
enum class ES_NavBarCycleMode : uint8 {
Wrap,
Clamp,
Count,
ES_MAX,
};
// Enum Scavenger.ES_NavBarCycleDirection
enum class ES_NavBarCycleDirection : uint8 {
Left,
Right,
Count,
ES_MAX,
};
// Enum Scavenger.ES_RewardGrantContext
enum class ES_RewardGrantContext : uint8 {
None,
SessionReward,
AccountProgressionReward,
ContentGrant,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StaminaThresholdEvent
enum class ES_StaminaThresholdEvent : uint8 {
Critical,
Low,
Normal,
Count,
ES_MAX,
};
// Enum Scavenger.ES_StaminaChangeEvent
enum class ES_StaminaChangeEvent : uint8 {
Decreasing,
Increasing,
Stable,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PostMatchStatDisplayType
enum class ES_PostMatchStatDisplayType : uint8 {
Time,
Value,
Percentage,
Multiplier,
Count,
ES_MAX,
};
// Enum Scavenger.ES_InGameRadialMenuSlot
enum class ES_InGameRadialMenuSlot : uint8 {
Quick,
Enemy,
LootingHere,
AttackingHere,
DefendingHere,
GoingHere,
Danger,
SomeoneHasBeen,
ClearAll,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ResearchStationId
enum class ES_ResearchStationId : uint8 {
k_research_2,
k_research_3,
k_research_4,
k_research_5,
k_research_6,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ResearchStationStatus
enum class ES_ResearchStationStatus : uint8 {
Available,
Locked,
InProgress,
Pending,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SalvageStatus
enum class ES_SalvageStatus : uint8 {
Ready,
Complete,
InProgress,
Pending,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ScoreboardRecapStep
enum class ES_ScoreboardRecapStep : uint8 {
Initialized,
PreTakeoff,
PostTakeoff,
PlacementDisplay,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SeasonsOverlay
enum class ES_SeasonsOverlay : uint8 {
Main,
BattlePassPurchase,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SocialNotificationType
enum class ES_SocialNotificationType : uint8 {
PartyMemberKicked,
PartyMemberJoined,
PartyMemberLeft,
PartyInviteReceived,
PartyInviteSent,
PartyJoinRequestReceived,
PartyJoinRequestSent,
FriendRequestReceived,
FriendRequestAccepted,
FriendRequestSent,
YouJoinedParty,
YouLeftParty,
Count,
ES_MAX,
};
// Enum Scavenger.ES_ThreatLevel
enum class ES_ThreatLevel : uint8 {
None,
Alerted,
Aggro,
Count,
ES_MAX,
};
// Enum Scavenger.ES_TempTierState
enum class ES_TempTierState : uint8 {
AvailableTier,
NextTier,
HiddenTier,
Count,
ES_MAX,
};
// Enum Scavenger.ES_PrimitiveNetCode
enum class ES_PrimitiveNetCode : uint8 {
LocallySimulatedWithReplicatedInputWithForces,
LocallySimulatedWithReplicatedInputWithTeleportation,
Count,
ES_MAX,
};
// Enum Scavenger.ES_SeatType
enum class ES_SeatType : uint8 {
Driver,
Passenger,
Count,
None,
ES_MAX,
};
// Enum Scavenger.ES_SkeletalMeshTickCondition
enum class ES_SkeletalMeshTickCondition : uint8 {
Never,
StartDisabled,
OnlyIfTheresAViewport,
Always,
AlwaysForRealEvenOfServersWithoutAuthority,
ES_MAX,
};
// Enum Scavenger.ES_SteeringMode
enum class ES_SteeringMode : uint8 {
Warthog,
Ghost,
WarthogGhostHybrid,
ES_MAX,
};
// Enum Scavenger.RestState
enum class RestState : uint8 {
AT_REST,
JUST_STARTED_MOVING,
MOVING,
RestState_MAX,
};
// Enum Scavenger.ExtrapolationMode
enum class ExtrapolationMode : uint8 {
UNLIMITED,
LIMITED,
NONE,
ExtrapolationMode_MAX,
};
// Enum Scavenger.SyncMode
enum class SyncMode : uint8 {
XYZ,
XY,
XZ,
YZ,
X,
Y,
Z,
NONE,
SyncMode_MAX,
};
// ScriptStruct Scavenger.S_PreTakeDamageInfo
// Size: 0x02 (Inherited: 0x00)
struct FS_PreTakeDamageInfo {
char pad_0[0x2]; // 0x00(0x02)
};
// ScriptStruct Scavenger.S_PointDamageEvent
// Size: 0xe8 (Inherited: 0xb0)
struct FS_PointDamageEvent : FPointDamageEvent {
bool Critical; // 0xb0(0x01)
bool HeadShot; // 0xb1(0x01)
char pad_B2[0x2]; // 0xb2(0x02)
struct FS_DamagePushBackInfo PushBackInfo; // 0xb4(0x1c)
float PoiseDamage; // 0xd0(0x04)
char pad_D4[0x4]; // 0xd4(0x04)
struct FS_DamagePredictionID PredictionID; // 0xd8(0x10)
};
// ScriptStruct Scavenger.S_DamagePredictionID
// Size: 0x10 (Inherited: 0x00)
struct FS_DamagePredictionID {
struct APawn* PredictingPlayerPawn; // 0x00(0x08)
uint32_t PredictionID; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_DamagePushBackInfo
// Size: 0x1c (Inherited: 0x00)
struct FS_DamagePushBackInfo {
struct FVector Direction; // 0x00(0x0c)
float GroundForce; // 0x0c(0x04)
float AirForce; // 0x10(0x04)
float GroundDuration; // 0x14(0x04)
float AirDuration; // 0x18(0x04)
};
// ScriptStruct Scavenger.BoneHitInfo
// Size: 0x10 (Inherited: 0x00)
struct FBoneHitInfo {
struct FName BoneDescription; // 0x00(0x08)
float m_damageMultiplier; // 0x08(0x04)
bool m_bHeadShot; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
};
// ScriptStruct Scavenger.S_ActionHandle
// Size: 0x04 (Inherited: 0x00)
struct FS_ActionHandle {
char pad_0[0x4]; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_ActionPayload
// Size: 0x20 (Inherited: 0x00)
struct FS_ActionPayload {
enum class ES_ActionID m_actionID; // 0x00(0x01)
char pad_1[0x1f]; // 0x01(0x1f)
};
// ScriptStruct Scavenger.S_EventParameterVariant
// Size: 0x30 (Inherited: 0x00)
struct FS_EventParameterVariant {
struct TWeakObjectPtr<struct UObject> Object; // 0x00(0x08)
struct UObject* Class; // 0x08(0x08)
enum class ES_EventParameter Type; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct TArray<struct FName> Tags; // 0x18(0x10)
char TeamId; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.S_EventParameterControllerVariant
// Size: 0x80 (Inherited: 0x30)
struct FS_EventParameterControllerVariant : FS_EventParameterVariant {
struct FS_EventParameterVariant ControlledPawn; // 0x30(0x30)
int32_t AIIndex; // 0x60(0x04)
char pad_64[0x4]; // 0x64(0x04)
struct US_PlayerClassData* ClassData; // 0x68(0x08)
int32_t TeamIndex; // 0x70(0x04)
char pad_74[0x4]; // 0x74(0x04)
int64_t TotalExperiencePoints; // 0x78(0x08)
};
// ScriptStruct Scavenger.S_ActorDownedParameters
// Size: 0x01 (Inherited: 0x00)
struct FS_ActorDownedParameters {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_ActorTerminalParameters
// Size: 0x20 (Inherited: 0x00)
struct FS_ActorTerminalParameters {
enum class ES_StatChangeCauseType StatChangeCauseType; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString InstigatorDisplayName; // 0x08(0x10)
struct UObject* TerminalObjectClass; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_ActorStatsStateChangedParameters
// Size: 0x18 (Inherited: 0x00)
struct FS_ActorStatsStateChangedParameters {
struct TArray<struct FS_EventParameterArrayOfPlayerFloatPairs> PlayerDamagePerStatsState; // 0x00(0x10)
enum class ES_StatChangeCauseType StatChangeCauseType; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
};
// ScriptStruct Scavenger.S_EventParameterArrayOfPlayerFloatPairs
// Size: 0x10 (Inherited: 0x00)
struct FS_EventParameterArrayOfPlayerFloatPairs {
struct TArray<struct FS_EventParameterPlayerFloatPair> PlayerFloatPairs; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_EventParameterPlayerFloatPair
// Size: 0x88 (Inherited: 0x00)
struct FS_EventParameterPlayerFloatPair {
struct FS_EventParameterControllerVariant PlayerController; // 0x00(0x80)
float Value; // 0x80(0x04)
char pad_84[0x4]; // 0x84(0x04)
};
// ScriptStruct Scavenger.S_ItemState
// Size: 0x40 (Inherited: 0x00)
struct FS_ItemState {
int32_t Flags; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct US_ItemData* ItemData; // 0x08(0x08)
int32_t Count; // 0x10(0x04)
struct FS_ItemStats ItemStats; // 0x14(0x10)
int32_t LockedCount; // 0x24(0x04)
float ServerTimestamp; // 0x28(0x04)
char pad_2C[0x14]; // 0x2c(0x14)
};
// ScriptStruct Scavenger.S_ItemStats
// Size: 0x10 (Inherited: 0x00)
struct FS_ItemStats {
bool bHasAtLeastOneValue; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float Stats[0x3]; // 0x04(0x0c)
};
// ScriptStruct Scavenger.S_DeathRecap
// Size: 0x28 (Inherited: 0x00)
struct FS_DeathRecap {
char PlayerKillerIndex; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct UObject* KillerClassData; // 0x08(0x08)
struct US_ItemData* KillerItem; // 0x10(0x08)
struct UObject* KillerObjectClass; // 0x18(0x08)
enum class ES_StatChangeCauseType DeathCauseType; // 0x20(0x01)
char pad_21[0x7]; // 0x21(0x07)
};
// ScriptStruct Scavenger.S_PlayerCocoonedParameters
// Size: 0x01 (Inherited: 0x00)
struct FS_PlayerCocoonedParameters {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_PlayerFreedFromCocoonParameters
// Size: 0x01 (Inherited: 0x00)
struct FS_PlayerFreedFromCocoonParameters {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_PlayerKilledInCocoonParameters
// Size: 0x01 (Inherited: 0x00)
struct FS_PlayerKilledInCocoonParameters {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_PlayerExtractingParameters
// Size: 0x01 (Inherited: 0x00)
struct FS_PlayerExtractingParameters {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_PlayerExtractedParameters
// Size: 0x01 (Inherited: 0x00)
struct FS_PlayerExtractedParameters {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_StormData
// Size: 0x110 (Inherited: 0x00)
struct FS_StormData {
bool bDirty; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector WorldLocationRealtime; // 0x04(0x0c)
struct FVector WorldLocationReplicated; // 0x10(0x0c)
float SpawnRadius; // 0x1c(0x04)
float Radius; // 0x20(0x04)
enum class ES_StormDamageZone DamageZone; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
int32_t StormId; // 0x28(0x04)
enum class ES_StormCategory StormCategory; // 0x2c(0x01)
enum class ES_StormSize StormSize; // 0x2d(0x01)
char pad_2E[0x2]; // 0x2e(0x02)
float TerrainZIntersection; // 0x30(0x04)
float Randomization; // 0x34(0x04)
struct FVector Direction; // 0x38(0x0c)
struct FVector TargetDirection; // 0x44(0x0c)
float TargetDirectionTransitionDuration; // 0x50(0x04)
float TargetRadius; // 0x54(0x04)
float DeltaRadiusDeltaTime; // 0x58(0x04)
float GroundSpeedRealtime; // 0x5c(0x04)
float GroundSpeedReplicated; // 0x60(0x04)
float TargetGroundSpeed; // 0x64(0x04)
float DeltaGroundSpeedDeltaTimeRealtime; // 0x68(0x04)
float DeltaGroundSpeedDeltaTimeReplicated; // 0x6c(0x04)
float RotationalSpeedRealtime; // 0x70(0x04)
float RotationalSpeedReplicated; // 0x74(0x04)
float TargetRotationalSpeed; // 0x78(0x04)
float DeltaRotationalSpeedDeltaTimeRealtime; // 0x7c(0x04)
float DeltaRotationalSpeedDeltaTimeReplicated; // 0x80(0x04)
float Turbulence; // 0x84(0x04)
float TargetTurbulence; // 0x88(0x04)
float DeltaTurbulenceDeltaTime; // 0x8c(0x04)
struct FLinearColor Tint; // 0x90(0x10)
struct FLinearColor TargetTint; // 0xa0(0x10)
float TargetTintTransitionDuration; // 0xb0(0x04)
struct FVector OutlineColor; // 0xb4(0x0c)
struct FVector TargetOutlineColor; // 0xc0(0x0c)
float TargetOutlineColorTransitionDuration; // 0xcc(0x04)
float OutlineStrokeSize; // 0xd0(0x04)
float TargetOutlineStrokeSize; // 0xd4(0x04)
float DeltaOutlineStrokeSizeDeltaTime; // 0xd8(0x04)
float TerrainSamplingTimer; // 0xdc(0x04)
enum class ES_StormSpawnState SpawnState; // 0xe0(0x01)
char pad_E1[0x3]; // 0xe1(0x03)
float SpawnStateTime; // 0xe4(0x04)
float SkyMaskGrowthDuration; // 0xe8(0x04)
float PreambleDuration; // 0xec(0x04)
float GrowthDuration; // 0xf0(0x04)
float ShrinkDuration; // 0xf4(0x04)
float PostambleDuration; // 0xf8(0x04)
float SkyMaskShrinkDuration; // 0xfc(0x04)
char pad_100[0x10]; // 0x100(0x10)
};
// ScriptStruct Scavenger.S_ExecutionMontageTableRow
// Size: 0x140 (Inherited: 0x08)
struct FS_ExecutionMontageTableRow : FTableRowBase {
struct FS_ExecutionMontageEntry Montages[0x4]; // 0x08(0x60)
int32_t ExecutionTargetCharacterSize; // 0x68(0x04)
char pad_6C[0x4]; // 0x6c(0x04)
struct AS_WeaponBase* WeaponOverride; // 0x70(0x08)
struct FName PlayerCharacterExecutorNameID; // 0x78(0x08)
struct TArray<struct AS_CharacterBase*> ExecutorCharacterTypeOverride; // 0x80(0x10)
int32_t WeaponClassOverride; // 0x90(0x04)
bool IsCosmeticPlayerOverride; // 0x94(0x01)
bool bOverrideCameraSettings; // 0x95(0x01)
char pad_96[0xa]; // 0x96(0x0a)
struct FS_CameraSettingOverride CameraSettingsOverrides; // 0xa0(0xa0)
};
// ScriptStruct Scavenger.S_CameraSettingOverride
// Size: 0xa0 (Inherited: 0x08)
struct FS_CameraSettingOverride : FTableRowBase {
enum class ES_CameraSettings Setting; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FS_CameraOverrideFloat SpringArmTargetLength; // 0x0c(0x08)
struct FS_CameraOverrideFloat TargetFOV; // 0x14(0x08)
struct FS_CameraOverrideVector SocketOffsetTranslation; // 0x1c(0x10)
char pad_2C[0x4]; // 0x2c(0x04)
struct FS_CameraOverrideQuat SocketOffsetRotation; // 0x30(0x20)
struct FS_CameraOverrideVector TargetOffset; // 0x50(0x10)
struct FS_CameraOverrideBool AimKeepOnCameraCollision; // 0x60(0x02)
struct FS_CameraOverrideBool HideBlockingCharacters; // 0x62(0x02)
struct FS_CameraOverrideBool EnableCameraLag; // 0x64(0x02)
char pad_66[0x2]; // 0x66(0x02)
struct FS_CameraOverrideNoise NoiseTranslation; // 0x68(0x18)
struct FS_CameraOverrideNoise NoiseRotation; // 0x80(0x18)
char pad_98[0x8]; // 0x98(0x08)
};
// ScriptStruct Scavenger.S_CameraOverrideNoise
// Size: 0x18 (Inherited: 0x00)
struct FS_CameraOverrideNoise {
bool bApplyOverride; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FS_CameraNoiseSettings OverrideValue; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_CameraNoiseSettings
// Size: 0x10 (Inherited: 0x00)
struct FS_CameraNoiseSettings {
struct UCurveVector* Frequency; // 0x00(0x08)
struct UCurveVector* Magnitude; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_CameraOverrideBool
// Size: 0x02 (Inherited: 0x00)
struct FS_CameraOverrideBool {
bool bApplyOverride; // 0x00(0x01)
bool OverrideValue; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_CameraOverrideVector
// Size: 0x10 (Inherited: 0x00)
struct FS_CameraOverrideVector {
bool bApplyOverride; // 0x00(0x01)
enum class ES_CameraOverrideMode Mode; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
struct FVector OverrideValue; // 0x04(0x0c)
};
// ScriptStruct Scavenger.S_CameraOverrideQuat
// Size: 0x20 (Inherited: 0x00)
struct FS_CameraOverrideQuat {
bool bApplyOverride; // 0x00(0x01)
enum class ES_CameraOverrideMode Mode; // 0x01(0x01)
char pad_2[0xe]; // 0x02(0x0e)
struct FQuat OverrideValue; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_CameraOverrideFloat
// Size: 0x08 (Inherited: 0x00)
struct FS_CameraOverrideFloat {
bool bApplyOverride; // 0x00(0x01)
enum class ES_CameraOverrideMode Mode; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
float OverrideValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_ExecutionMontageEntry
// Size: 0x18 (Inherited: 0x00)
struct FS_ExecutionMontageEntry {
struct UAnimMontage* ExecutorMontage; // 0x00(0x08)
struct UAnimMontage* TargetMontage; // 0x08(0x08)
float Separation; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_MetadataTableRowBase
// Size: 0x10 (Inherited: 0x08)
struct FS_MetadataTableRowBase : FTableRowBase {
struct FName ID; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_DisplayableItemMetadata
// Size: 0x58 (Inherited: 0x10)
struct FS_DisplayableItemMetadata : FS_MetadataTableRowBase {
struct FDataTableRowHandle LocalizedNameHandle; // 0x10(0x10)
struct FDataTableRowHandle LocalizedDescriptionHandle; // 0x20(0x10)
struct TSoftObjectPtr<struct UTexture2D> Icon; // 0x30(0x28)
};
// ScriptStruct Scavenger.S_DisplayableItemWithRarityMetadata
// Size: 0x60 (Inherited: 0x58)
struct FS_DisplayableItemWithRarityMetadata : FS_DisplayableItemMetadata {
enum class ES_ItemRarity Rarity; // 0x58(0x01)
char pad_59[0x7]; // 0x59(0x07)
};
// ScriptStruct Scavenger.S_EmoteMontageTableRow
// Size: 0x150 (Inherited: 0x60)
struct FS_EmoteMontageTableRow : FS_DisplayableItemWithRarityMetadata {
struct UAnimMontage* EmoteMontage; // 0x60(0x08)
bool bUsableInScavengers; // 0x68(0x01)
bool bUsableInSocialHub; // 0x69(0x01)
bool bUsableInSocialHubStreamerMode; // 0x6a(0x01)
bool bOverrideCameraSettings; // 0x6b(0x01)
char pad_6C[0x4]; // 0x6c(0x04)
struct FS_CameraSettingOverride CameraSettingsOverrides; // 0x70(0xa0)
bool bLockCharacterRotation; // 0x110(0x01)
bool bCancelEmoteOnMovement; // 0x111(0x01)
char pad_112[0x2]; // 0x112(0x02)
float MontageBlendOutTime; // 0x114(0x04)
float EndOfEmoteRotationBlendTime; // 0x118(0x04)
char pad_11C[0x4]; // 0x11c(0x04)
struct UAnimMontage* EndOfEmoteBlendOutMontage; // 0x120(0x08)
bool bIgnoreLoadoutCheck; // 0x128(0x01)
char pad_129[0x3]; // 0x129(0x03)
float VATScaleX; // 0x12c(0x04)
float VATScaleY; // 0x130(0x04)
int32_t GlowstickColor; // 0x134(0x04)
struct FName CrowdAudioOneShotName; // 0x138(0x08)
float VelocityModifier; // 0x140(0x04)
char pad_144[0xc]; // 0x144(0x0c)
};
// ScriptStruct Scavenger.S_MapDisplayData
// Size: 0x78 (Inherited: 0x00)
struct FS_MapDisplayData {
struct UTexture2D* Texture; // 0x00(0x08)
struct UTexture2D* AltTexture; // 0x08(0x08)
float AltTextureSize; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct UMaterialInstance* MaterialOverride; // 0x18(0x08)
struct FVector2D WorldLocation; // 0x20(0x08)
char Direction; // 0x28(0x01)
char pad_29[0x3]; // 0x29(0x03)
float WorldSize; // 0x2c(0x04)
struct FLinearColor Color; // 0x30(0x10)
struct FName DisplayText; // 0x40(0x08)
struct FS_LocationLabel LocationLabel; // 0x48(0x04)
enum class ES_MapIconUse MapIconUse; // 0x4c(0x01)
char pad_4D[0x3]; // 0x4d(0x03)
int32_t SlotIndex; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
enum class ES_ZoomType ZoomType; // 0x58(0x01)
char TeamIndex; // 0x59(0x01)
char pad_5A[0x2]; // 0x5a(0x02)
float ZoomLevel; // 0x5c(0x04)
char ZOrder; // 0x60(0x01)
char pad_61[0x3]; // 0x61(0x03)
int32_t PlayerId; // 0x64(0x04)
enum class ES_EnemyInfoType EnemyInfoType; // 0x68(0x01)
bool bAllowGuttering; // 0x69(0x01)
char pad_6A[0x2]; // 0x6a(0x02)
struct FS_PingItemHandle PingHandle; // 0x6c(0x04)
enum class ES_StatsState StatsState; // 0x70(0x01)
char pad_71[0x3]; // 0x71(0x03)
float IconOpacity; // 0x74(0x04)
};
// ScriptStruct Scavenger.S_PingItemHandle
// Size: 0x04 (Inherited: 0x00)
struct FS_PingItemHandle {
char pad_0[0x4]; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_LocationLabel
// Size: 0x04 (Inherited: 0x00)
struct FS_LocationLabel {
uint32_t LocationLabelIndexField; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_OnlineServiceManagerPlayerState
// Size: 0x9a8 (Inherited: 0x00)
struct FS_OnlineServiceManagerPlayerState {
bool bIsLoggedIn; // 0x00(0x01)
bool bServerExtendedPlayerInfoReceived; // 0x01(0x01)
char pad_2[0x6]; // 0x02(0x06)
struct FS_OnlineServiceManagerLoginMethod LoginMethod; // 0x08(0x50)
struct FString PlayerPlatform; // 0x58(0x10)
struct FText AccountName; // 0x68(0x18)
int32_t AccountLevel; // 0x80(0x04)
char pad_84[0x4]; // 0x84(0x04)
struct TMap<struct FString, struct FS_OnlineCharacterState> MapOfCharacterIdToCharacterState; // 0x88(0x50)
struct TArray<struct FS_OnlineInventoryItem> InventoryItems; // 0xd8(0x10)
struct TMap<struct FString, struct FS_OnlineFileMetadata> PlayerFiles; // 0xe8(0x50)
struct FS_UserSettings UserSettings; // 0x138(0x1b8)
struct TMap<struct FName, int32_t> MapOfCurrencyIdToBalance; // 0x2f0(0x50)
struct FS_OnlineServiceAuthenticationData AuthenticationData; // 0x340(0x4f0)
struct FS_OnlinePowerGenerationState PowerGenerationState; // 0x830(0x18)
struct TArray<struct FString> OwnedResearchStationIds; // 0x848(0x10)
struct TArray<struct FS_OnlineResearchProjectState> ResearchProjectStates; // 0x858(0x10)
struct TMap<struct FName, int32_t> PlayerFlags; // 0x868(0x50)
struct TArray<struct FS_OnlineUnseenRewardGrants> UnseenRewards; // 0x8b8(0x10)
struct FS_CosmeticLoadout AccountCosmeticLoadout; // 0x8c8(0x50)
struct TArray<struct FS_OnlineChallengeInstance> ChallengeInstances; // 0x918(0x10)
struct TArray<struct FS_OnlineSeasonState> SeasonStates; // 0x928(0x10)
char pad_938[0x70]; // 0x938(0x70)
};
// ScriptStruct Scavenger.S_OnlineSeasonState
// Size: 0x30 (Inherited: 0x00)
struct FS_OnlineSeasonState {
struct FName ID; // 0x00(0x08)
int32_t Progress; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
struct TArray<int32_t> TiersPendingClaim; // 0x10(0x10)
struct TArray<int32_t> BattlePassTiersPendingClaim; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_OnlineChallengeInstance
// Size: 0x40 (Inherited: 0x00)
struct FS_OnlineChallengeInstance {
struct FString ID; // 0x00(0x10)
struct FName SlotType; // 0x10(0x08)
struct FName ChallengeDefinitionId; // 0x18(0x08)
struct FDateTime ExpiresOn; // 0x20(0x08)
int32_t Progress; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct TArray<int32_t> PendingClaim; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_CosmeticLoadout
// Size: 0x50 (Inherited: 0x00)
struct FS_CosmeticLoadout {
struct TMap<enum class ES_CosmeticLoadoutSlotType, struct FS_CosmeticLoadoutSlot> SlotTypeToSelectedItems; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_CosmeticLoadoutSlot
// Size: 0x28 (Inherited: 0x00)
struct FS_CosmeticLoadoutSlot {
struct FName ItemMetadataId; // 0x00(0x08)
struct FString ItemInstanceId; // 0x08(0x10)
struct TArray<struct FS_CosmeticLoadoutSubMaterialSelection> SubMaterialSelections; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_CosmeticLoadoutSubMaterialSelection
// Size: 0x08 (Inherited: 0x00)
struct FS_CosmeticLoadoutSubMaterialSelection {
struct FName SubMaterialMetadataId; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_OnlineUnseenRewardGrants
// Size: 0x50 (Inherited: 0x00)
struct FS_OnlineUnseenRewardGrants {
struct FString ID; // 0x00(0x10)
struct FString MatchID; // 0x10(0x10)
enum class ES_UnseenRewardSource Source; // 0x20(0x01)
char pad_21[0x7]; // 0x21(0x07)
struct FString ContextString; // 0x28(0x10)
int32_t ContextInt; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
struct TArray<struct FS_OnlineRewardGrant> Grants; // 0x40(0x10)
};
// ScriptStruct Scavenger.S_OnlineRewardGrant
// Size: 0x20 (Inherited: 0x00)
struct FS_OnlineRewardGrant {
enum class ES_OnlineRewardGrantType GrantType; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString GrantId; // 0x08(0x10)
int32_t GrantAmount; // 0x18(0x04)
int32_t GrantStartingValue; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_OnlineResearchProjectState
// Size: 0x38 (Inherited: 0x00)
struct FS_OnlineResearchProjectState {
struct FName ProjectID; // 0x00(0x08)
struct FString ResearchStationId; // 0x08(0x10)
int64_t StartTimeSeconds; // 0x18(0x08)
int64_t CompletionTimeSeconds; // 0x20(0x08)
struct FDateTime StartTime; // 0x28(0x08)
struct FDateTime CompletionTime; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_OnlinePowerGenerationState
// Size: 0x18 (Inherited: 0x00)
struct FS_OnlinePowerGenerationState {
int32_t LastNotifiedBalance; // 0x00(0x04)
int32_t PowerCap; // 0x04(0x04)
struct FDateTime LastGenerationTime; // 0x08(0x08)
struct FTimespan GenerationTimespan; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_OnlineServiceAuthenticationData
// Size: 0x4f0 (Inherited: 0x00)
struct FS_OnlineServiceAuthenticationData {
char pad_0[0x4a0]; // 0x00(0x4a0)
struct FString PlayerId; // 0x4a0(0x10)
struct FString AuthenticationToken; // 0x4b0(0x10)
struct FString AccountLogin; // 0x4c0(0x10)
struct FString PlayerEntityId; // 0x4d0(0x10)
struct FString PlayerEntityType; // 0x4e0(0x10)
};
// ScriptStruct Scavenger.S_UserSettings
// Size: 0x1b8 (Inherited: 0x00)
struct FS_UserSettings {
struct FS_UserGameSettings GameSettings; // 0x00(0x38)
struct FS_UserInputSettings InputSettings; // 0x38(0x88)
struct FS_UserAudioSettings AudioSettings; // 0xc0(0x30)
struct FS_UserAccessibilitySettings AccessibilitySettings; // 0xf0(0x14)
char pad_104[0x4]; // 0x104(0x04)
struct FS_UserOnlineClientSettings OnlineClientSettings; // 0x108(0xa0)
struct FDateTime OnlineStorageTimestamp; // 0x1a8(0x08)
enum class ES_SavedUserSettingsVersion Version; // 0x1b0(0x01)
char pad_1B1[0x7]; // 0x1b1(0x07)
};
// ScriptStruct Scavenger.S_UserOnlineClientSettings
// Size: 0xa0 (Inherited: 0x00)
struct FS_UserOnlineClientSettings {
struct TMap<struct FString, int32_t> UserFlags; // 0x00(0x50)
struct TMap<struct FString, struct FString> UserStrings; // 0x50(0x50)
};
// ScriptStruct Scavenger.S_UserAccessibilitySettings
// Size: 0x14 (Inherited: 0x00)
struct FS_UserAccessibilitySettings {
int32_t ColorblindMode; // 0x00(0x04)
int32_t SubtitleMode; // 0x04(0x04)
enum class ES_SubtitleSize SubtitleSize; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
int32_t MenuWrapMode; // 0x0c(0x04)
int32_t MenuNarrationMode; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_UserAudioSettings
// Size: 0x30 (Inherited: 0x00)
struct FS_UserAudioSettings {
float MasterVolume; // 0x00(0x04)
float MusicVolume; // 0x04(0x04)
float SoundFXVolume; // 0x08(0x04)
float VoiceVolume; // 0x0c(0x04)
struct FString VoiceInputDevice; // 0x10(0x10)
int32_t ChatInputMode; // 0x20(0x04)
int32_t ChatJoinMode; // 0x24(0x04)
float ChatInputVolume; // 0x28(0x04)
float ChatOutputVolume; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_UserInputSettings
// Size: 0x88 (Inherited: 0x00)
struct FS_UserInputSettings {
struct TMap<enum class ES_GameInputActionType, struct FS_UserKeybindSetting> Keybinds; // 0x00(0x50)
bool bMouseInvertY; // 0x50(0x01)
char pad_51[0x3]; // 0x51(0x03)
float MousePitchSensitivity; // 0x54(0x04)
float MouseTurnSensitivity; // 0x58(0x04)
float MousePitchRelativeSensitivity; // 0x5c(0x04)
struct FName GamepadLayoutName; // 0x60(0x08)
struct FName GamepadResponseCurveName; // 0x68(0x08)
int32_t GamepadSensitivitySelection; // 0x70(0x04)
enum class ES_DeadzoneSize GamepadMoveDeadzone; // 0x74(0x01)
enum class ES_DeadzoneSize GamepadAimDeadzone; // 0x75(0x01)
char pad_76[0x2]; // 0x76(0x02)
float GamepadPitchRelativeSensitivity; // 0x78(0x04)
float GamepadADSSensitivityMultiplier; // 0x7c(0x04)
bool bGamepadInvertY; // 0x80(0x01)
char pad_81[0x7]; // 0x81(0x07)
};
// ScriptStruct Scavenger.S_UserKeybindSetting
// Size: 0x30 (Inherited: 0x00)
struct FS_UserKeybindSetting {
struct FKey PrimaryKey; // 0x00(0x18)
struct FKey SecondaryKey; // 0x18(0x18)
};
// ScriptStruct Scavenger.S_UserGameSettings
// Size: 0x38 (Inherited: 0x00)
struct FS_UserGameSettings {
struct FString PreferredRegion; // 0x00(0x10)
int32_t DamageNumberMode; // 0x10(0x04)
int32_t CrouchMode; // 0x14(0x04)
float FOV; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct FString Culture; // 0x20(0x10)
int32_t StreamerMode; // 0x30(0x04)
int32_t CrossPlatformPlay; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_OnlineFileMetadata
// Size: 0x40 (Inherited: 0x00)
struct FS_OnlineFileMetadata {
struct FString Checksum; // 0x00(0x10)
struct FString DownloadUrl; // 0x10(0x10)
struct FString Filename; // 0x20(0x10)
struct FDateTime LastModified; // 0x30(0x08)
int32_t Size; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_OnlineInventoryItem
// Size: 0x70 (Inherited: 0x00)
struct FS_OnlineInventoryItem {
struct FName ID; // 0x00(0x08)
struct FString InstanceID; // 0x08(0x10)
int32_t Count; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct TMap<struct FString, struct FString> customData; // 0x20(0x50)
};
// ScriptStruct Scavenger.S_OnlineCharacterState
// Size: 0xe0 (Inherited: 0x00)
struct FS_OnlineCharacterState {
struct FString CharacterId; // 0x00(0x10)
struct FName ClassId; // 0x10(0x08)
struct FS_CharacterLoadout Loadout; // 0x18(0x50)
struct FS_CosmeticLoadout CosmeticLoadout; // 0x68(0x50)
struct TArray<struct FS_OnlineInventoryItem> InventoryItems; // 0xb8(0x10)
struct TArray<int32_t> CharacterPoints; // 0xc8(0x10)
int32_t CharacterLevel; // 0xd8(0x04)
char pad_DC[0x4]; // 0xdc(0x04)
};
// ScriptStruct Scavenger.S_CharacterLoadout
// Size: 0x50 (Inherited: 0x00)
struct FS_CharacterLoadout {
struct TMap<enum class ES_LoadoutSlotType, struct FS_CharacterLoadoutSlot> SlotTypeToSelectedItems; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_CharacterLoadoutSlot
// Size: 0x20 (Inherited: 0x00)
struct FS_CharacterLoadoutSlot {
struct TArray<struct FName> ItemMetadataIds; // 0x00(0x10)
struct TArray<struct FString> ItemInstanceIds; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_OnlineServiceManagerLoginMethod
// Size: 0x50 (Inherited: 0x00)
struct FS_OnlineServiceManagerLoginMethod {
enum class ES_OnlineServiceManagerLoginMethod MethodType; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString Identifier; // 0x08(0x10)
struct FString Password; // 0x18(0x10)
struct FString AccountId; // 0x28(0x10)
enum class ES_ImprobableTestAccountType AccountType; // 0x38(0x01)
char pad_39[0x7]; // 0x39(0x07)
struct FString AccountAccessToken; // 0x40(0x10)
};
// ScriptStruct Scavenger.S_OnlineAssemblyRecipe
// Size: 0x38 (Inherited: 0x10)
struct FS_OnlineAssemblyRecipe : FS_MetadataTableRowBase {
struct TArray<struct FS_OnlineAssemblyRecipeComponent> Inputs; // 0x10(0x10)
int32_t InputPowerAmount; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct TArray<struct FS_OnlineAssemblyRecipeComponent> Outputs; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_OnlineAssemblyRecipeComponent
// Size: 0x18 (Inherited: 0x00)
struct FS_OnlineAssemblyRecipeComponent {
struct FString CurrencyTypeName; // 0x00(0x10)
int32_t Amount; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_LobbyEndpoint
// Size: 0x50 (Inherited: 0x00)
struct FS_LobbyEndpoint {
struct FString EndpointUri; // 0x00(0x10)
struct FString EndpointPingRegionCode; // 0x10(0x10)
struct FString EndpointRegionTitle; // 0x20(0x10)
struct FString EndpointDisplayTitle; // 0x30(0x10)
bool bIsEnabled; // 0x40(0x01)
char pad_41[0x3]; // 0x41(0x03)
int32_t MedianPingTimeMs; // 0x44(0x04)
enum class ES_LobbyEndpointPingStatus PingStatus; // 0x48(0x01)
char pad_49[0x7]; // 0x49(0x07)
};
// ScriptStruct Scavenger.S_OnlineTitleNewsItem
// Size: 0x28 (Inherited: 0x00)
struct FS_OnlineTitleNewsItem {
struct FString Title; // 0x00(0x10)
struct FString Body; // 0x10(0x10)
struct FDateTime Timestamp; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_OnlinePlayerInventoryDelta
// Size: 0x60 (Inherited: 0x00)
struct FS_OnlinePlayerInventoryDelta {
struct TArray<struct FS_OnlinePlayerInventoryItemDelta> OnlineItemDeltas; // 0x00(0x10)
struct TMap<struct FName, int32_t> CurrencyIdToDelta; // 0x10(0x50)
};
// ScriptStruct Scavenger.S_OnlinePlayerInventoryItemDelta
// Size: 0x20 (Inherited: 0x00)
struct FS_OnlinePlayerInventoryItemDelta {
struct FName OnlineItemId; // 0x00(0x08)
struct FString ItemInstanceId; // 0x08(0x10)
int32_t CountDelta; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_NamedLocationMetadata
// Size: 0x28 (Inherited: 0x10)
struct FS_NamedLocationMetadata : FS_MetadataTableRowBase {
struct FName LocationDisplayName; // 0x10(0x08)
struct FName LocationDescription; // 0x18(0x08)
enum class ES_LocationType LocationType; // 0x20(0x01)
enum class ES_LocationDifficultyTier LocationDifficulty; // 0x21(0x01)
enum class ES_LocationFaction LocationFaction; // 0x22(0x01)
char pad_23[0x5]; // 0x23(0x05)
};
// ScriptStruct Scavenger.S_PlayerObjectiveBase
// Size: 0x4c (Inherited: 0x00)
struct FS_PlayerObjectiveBase {
uint32_t ReplicationKey; // 0x00(0x04)
int32_t UniqueId; // 0x04(0x04)
int32_t ParentUniqueId; // 0x08(0x04)
struct FName LabelId; // 0x0c(0x08)
struct FName DescriptionId; // 0x14(0x08)
uint32_t InternalFlags; // 0x1c(0x04)
int32_t Flags; // 0x20(0x04)
int32_t ProgressCompleteValue; // 0x24(0x04)
int32_t ProgressFailureValue; // 0x28(0x04)
int32_t ProgressInitialValue; // 0x2c(0x04)
struct FVector AreaCenter; // 0x30(0x0c)
float AreaRadius; // 0x3c(0x04)
float AreaTimeLimitInSeconds; // 0x40(0x04)
float TimeLimitInSeconds; // 0x44(0x04)
int32_t RewardScore; // 0x48(0x04)
};
// ScriptStruct Scavenger.S_PlayerObjectiveDelta
// Size: 0x0c (Inherited: 0x00)
struct FS_PlayerObjectiveDelta {
int32_t UniqueId; // 0x00(0x04)
bool bIsInvalid; // 0x04(0x01)
bool bIsComplete; // 0x05(0x01)
bool bIsFailed; // 0x06(0x01)
char pad_7[0x1]; // 0x07(0x01)
int32_t ProgressValue; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_TeammateInfo
// Size: 0x120 (Inherited: 0x00)
struct FS_TeammateInfo {
struct TArray<struct FS_PingItemInstance> PingItemInstances; // 0x00(0x10)
struct FS_TeammateInfoGroupCore TeammateInfoGroupCore; // 0x10(0x70)
char pad_80[0xa0]; // 0x80(0xa0)
};
// ScriptStruct Scavenger.S_TeammateInfoGroupCore
// Size: 0x70 (Inherited: 0x00)
struct FS_TeammateInfoGroupCore {
bool bIsInStorm; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float Direction; // 0x04(0x04)
float HealthPercentage; // 0x08(0x04)
float HealthRecoveryLimitMaximumPercentage; // 0x0c(0x04)
float HealthRecoveryLimitPercentage; // 0x10(0x04)
int32_t HeldPointCount; // 0x14(0x04)
float NextExperienceLevelProgressPercentage; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct APawn* Pawn; // 0x20(0x08)
struct US_PlayerClassData* PlayerClassData; // 0x28(0x08)
struct AS_PlayerController* PlayerController; // 0x30(0x08)
struct AS_PlayerState* PlayerState; // 0x38(0x08)
float RespawnTimestamp; // 0x40(0x04)
enum class ES_ShieldLevel ShieldLevel; // 0x44(0x01)
char pad_45[0x3]; // 0x45(0x03)
float ShieldPercentage; // 0x48(0x04)
float StaminaPercentage; // 0x4c(0x04)
enum class ES_StatsState StatsState; // 0x50(0x01)
char pad_51[0x3]; // 0x51(0x03)
float TemperaturePercentage; // 0x54(0x04)
struct FVector_NetQuantize WorldLocation; // 0x58(0x0c)
int32_t HeldResurrectionTokenCount; // 0x64(0x04)
uint32_t m_replicationKey; // 0x68(0x04)
char pad_6C[0x4]; // 0x6c(0x04)
};
// ScriptStruct Scavenger.S_PingItemInstance
// Size: 0x60 (Inherited: 0x00)
struct FS_PingItemInstance {
struct APlayerController* NetOwningPlayerController; // 0x00(0x08)
uint32_t PingReplicationKey; // 0x08(0x04)
enum class ES_PingInfoType PingType; // 0x0c(0x01)
enum class ES_AutoPingType AutoPingType; // 0x0d(0x01)
enum class ES_PingItemEvent PingEvent; // 0x0e(0x01)
enum class ES_StatType StatType; // 0x0f(0x01)
enum class ES_CurrencyType CurrencyType; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
struct FVector PingLocation; // 0x14(0x0c)
float Lifetime; // 0x20(0x04)
float StartTimestamp; // 0x24(0x04)
bool FollowPingedActor; // 0x28(0x01)
bool bCanSendActor; // 0x29(0x01)
bool bSerializeActor; // 0x2a(0x01)
char pad_2B[0x1]; // 0x2b(0x01)
float OffscreenTracking; // 0x2c(0x04)
struct AActor* PingedActor; // 0x30(0x08)
struct US_ItemData* PingedItemData; // 0x38(0x08)
struct UTexture2D* PingTexture; // 0x40(0x08)
struct UMaterialInterface* PingMaterial; // 0x48(0x08)
char pad_50[0x10]; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_GameReportCardForPlayer
// Size: 0x118 (Inherited: 0x00)
struct FS_GameReportCardForPlayer {
bool bValid; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FS_PlayerReportCard MyReportCard; // 0x08(0x60)
struct FS_TeamReportCard MyTeamReportCard; // 0x68(0x38)
struct TArray<struct FS_PlayerReportCard> MyTeammateReportCards; // 0xa0(0x10)
struct FS_GameModeReportCard GameModeReportCard; // 0xb0(0x20)
struct FS_GameRewardReceipt GameRewardReceipt; // 0xd0(0x48)
};
// ScriptStruct Scavenger.S_GameRewardReceipt
// Size: 0x48 (Inherited: 0x00)
struct FS_GameRewardReceipt {
struct FString MatchID; // 0x00(0x10)
bool bValid; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
struct FName PlayerClass; // 0x14(0x08)
int32_t AwardCXP; // 0x1c(0x04)
float BoostMultiplierGlobal; // 0x20(0x04)
float BoostMultiplierPersonal; // 0x24(0x04)
struct TArray<struct FS_BoostMultiplierContext> BoostMultiplierTeam; // 0x28(0x10)
struct TArray<struct FName> SalvageItemRewards; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_BoostMultiplierContext
// Size: 0x18 (Inherited: 0x00)
struct FS_BoostMultiplierContext {
struct FString Context; // 0x00(0x10)
float Value; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_GameModeReportCard
// Size: 0x20 (Inherited: 0x00)
struct FS_GameModeReportCard {
bool bValid; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t TeamsInSession; // 0x04(0x04)
int32_t TeamsExtracted; // 0x08(0x04)
int32_t ExplorerCount; // 0x0c(0x04)
int32_t ExplorersExtracted; // 0x10(0x04)
int32_t ShardsHarvested; // 0x14(0x04)
int32_t ShardsExtracted; // 0x18(0x04)
bool bTutorialGame; // 0x1c(0x01)
bool bObjectiveComplete; // 0x1d(0x01)
char pad_1E[0x2]; // 0x1e(0x02)
};
// ScriptStruct Scavenger.S_PlayerReportCard
// Size: 0x60 (Inherited: 0x00)
struct FS_PlayerReportCard {
bool bValid; // 0x00(0x01)
char pad_1[0xb]; // 0x01(0x0b)
struct FName AccountId; // 0x0c(0x08)
struct FName PlayerClass; // 0x14(0x08)
char pad_1C[0x4]; // 0x1c(0x04)
struct FString DisplayName; // 0x20(0x10)
bool BoostStatusActive; // 0x30(0x01)
char pad_31[0x3]; // 0x31(0x03)
int32_t TeamIndex; // 0x34(0x04)
int32_t PlayerIndex; // 0x38(0x04)
float TimeSurvived; // 0x3c(0x04)
float LifestreakSeconds; // 0x40(0x04)
float LifestreakGameLengthFraction; // 0x44(0x04)
float DamageDone; // 0x48(0x04)
bool bExtracted; // 0x4c(0x01)
bool bExitedEarly; // 0x4d(0x01)
bool bStayedUntilEndOfGame; // 0x4e(0x01)
char pad_4F[0x1]; // 0x4f(0x01)
struct TArray<struct FName> ExtractedSalvage; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_TeamReportCard
// Size: 0x38 (Inherited: 0x00)
struct FS_TeamReportCard {
bool bValid; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t ShardsHarvested; // 0x04(0x04)
int32_t ScrapCollected; // 0x08(0x04)
int32_t ExplorersExtracted; // 0x0c(0x04)
int32_t ObjectivesCompleted; // 0x10(0x04)
int32_t ShardsExtracted; // 0x14(0x04)
int32_t ShardsBanked; // 0x18(0x04)
bool bTeamExtracted; // 0x1c(0x01)
char pad_1D[0x3]; // 0x1d(0x03)
struct TArray<struct FName> ExtractedSalvage; // 0x20(0x10)
int32_t TeamPlacement; // 0x30(0x04)
bool TeamVictory; // 0x34(0x01)
enum class ES_TeamGameEndReason GameEndReason; // 0x35(0x01)
char pad_36[0x2]; // 0x36(0x02)
};
// ScriptStruct Scavenger.S_KRADLRadarClientData
// Size: 0xd8 (Inherited: 0x00)
struct FS_KRADLRadarClientData {
char pad_0[0xd8]; // 0x00(0xd8)
};
// ScriptStruct Scavenger.S_KRADLRadarSettings
// Size: 0x28 (Inherited: 0x00)
struct FS_KRADLRadarSettings {
float UpdateFrequency; // 0x00(0x04)
float UpdateDistance; // 0x04(0x04)
float PersistTime; // 0x08(0x04)
float FadeTime; // 0x0c(0x04)
bool bIsActive; // 0x10(0x01)
bool bShowInStorms; // 0x11(0x01)
bool bSyncPingTime; // 0x12(0x01)
char pad_13[0x1]; // 0x13(0x01)
float StartTime; // 0x14(0x04)
struct FVector_NetQuantize WorldPosition; // 0x18(0x0c)
int32_t RadarID; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_InteractableItem
// Size: 0x40 (Inherited: 0x00)
struct FS_InteractableItem {
struct TWeakObjectPtr<struct AActor> Actor; // 0x00(0x08)
struct TWeakObjectPtr<struct UPrimitiveComponent> Component; // 0x08(0x08)
int32_t instanceIndex; // 0x10(0x04)
enum class ES_InteractIcon IconType; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
struct UTexture2D* Icon; // 0x18(0x08)
struct FVector DebugLocation; // 0x20(0x0c)
char pad_2C[0x4]; // 0x2c(0x04)
struct TArray<struct UPrimitiveComponent*> ComponentsToHighlight; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_LobbyQueue
// Size: 0x70 (Inherited: 0x00)
struct FS_LobbyQueue {
struct FString QueueId; // 0x00(0x10)
struct FString Name; // 0x10(0x10)
struct FString Status; // 0x20(0x10)
int32_t NumPlayers; // 0x30(0x04)
bool IsCustomQueue; // 0x34(0x01)
char pad_35[0x3]; // 0x35(0x03)
int32_t AutoStartSeconds; // 0x38(0x04)
int32_t AutoStartTimeLeft; // 0x3c(0x04)
int32_t EstimatedQueueTime; // 0x40(0x04)
int32_t MinGameSessionSize; // 0x44(0x04)
int32_t MaxGameSessionSize; // 0x48(0x04)
char pad_4C[0x4]; // 0x4c(0x04)
struct FJsonObjectWrapper MetaData; // 0x50(0x20)
};
// ScriptStruct Scavenger.S_TrackedResearchProject
// Size: 0x28 (Inherited: 0x00)
struct FS_TrackedResearchProject {
char pad_0[0x28]; // 0x00(0x28)
};
// ScriptStruct Scavenger.S_RecipeMetadata
// Size: 0x150 (Inherited: 0x58)
struct FS_RecipeMetadata : FS_DisplayableItemMetadata {
enum class ES_LoadoutSlotType LoadoutSlot; // 0x58(0x01)
char pad_59[0x7]; // 0x59(0x07)
struct FDataTableRowHandle NextTierRecipeData; // 0x60(0x10)
struct TSoftObjectPtr<struct US_RecipeData> RecipeData; // 0x70(0x28)
struct TArray<struct FString> LabelIds; // 0x98(0x10)
struct TArray<struct TSoftObjectPtr<struct US_PlayerClassData>> RestrictedToCharacters; // 0xa8(0x10)
int32_t RequiredLevel; // 0xb8(0x04)
char pad_BC[0x4]; // 0xbc(0x04)
struct TArray<struct FS_RecipeInput> Inputs; // 0xc0(0x10)
struct FDataTableRowHandle OutputItemMetadata; // 0xd0(0x10)
struct TSoftObjectPtr<struct US_ItemData> OutputItemHandle; // 0xe0(0x28)
int32_t OutputItemCount; // 0x108(0x04)
float CreationTimeInSeconds; // 0x10c(0x04)
struct FS_AbilitySet GrantedAbilities; // 0x110(0x10)
struct TArray<struct UGameplayEffect*> GrantedEffects; // 0x120(0x10)
int32_t CraftingLimit; // 0x130(0x04)
struct FS_ItemViewerSettings FrontEndItemViewerSettings; // 0x134(0x1c)
};
// ScriptStruct Scavenger.S_ItemViewerSettings
// Size: 0x1c (Inherited: 0x00)
struct FS_ItemViewerSettings {
struct FRotator RotationOffset; // 0x00(0x0c)
struct FVector PositionOffset; // 0x0c(0x0c)
float SizeScalar; // 0x18(0x04)
};
// ScriptStruct Scavenger.S_AbilitySet
// Size: 0x10 (Inherited: 0x00)
struct FS_AbilitySet {
struct TArray<struct FS_AbilitySpecifier> Abilities; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_AbilitySpecifier
// Size: 0x38 (Inherited: 0x00)
struct FS_AbilitySpecifier {
char bIsTriggerable : 1; // 0x00(0x01)
char bActivateOnceOnGive : 1; // 0x00(0x01)
char pad_0_2 : 6; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FName AbilityTriggerID; // 0x04(0x08)
int32_t AbilityLevel; // 0x0c(0x04)
SoftClassProperty AbilityClass; // 0x10(0x28)
};
// ScriptStruct Scavenger.S_RecipeInput
// Size: 0x40 (Inherited: 0x00)
struct FS_RecipeInput {
struct FDataTableRowHandle InputItemMetadata; // 0x00(0x10)
struct TSoftObjectPtr<struct US_ItemData> InputItemData; // 0x10(0x28)
int32_t InputItemQuantity; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_ObjectiveHandle
// Size: 0x08 (Inherited: 0x00)
struct FS_ObjectiveHandle {
char pad_0[0x8]; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_KRADLEnemyInfo
// Size: 0x40 (Inherited: 0x00)
struct FS_KRADLEnemyInfo {
struct AActor* Actor; // 0x00(0x08)
struct FVector_NetQuantize WorldPosition; // 0x08(0x0c)
float FadeTime; // 0x14(0x04)
float DetectionDistance; // 0x18(0x04)
float PersistTime; // 0x1c(0x04)
enum class ES_EnemyInfoType EnemyInfoType; // 0x20(0x01)
enum class ES_EnemyInfoUpdateMode EnemyInfoUpdateMode; // 0x21(0x01)
char pad_22[0x6]; // 0x22(0x06)
int32_t EnemyIconID; // 0x28(0x04)
char pad_2C[0x14]; // 0x2c(0x14)
};
// ScriptStruct Scavenger.S_PlayerPresenceStatus
// Size: 0x88 (Inherited: 0x00)
struct FS_PlayerPresenceStatus {
struct FString PlayerId; // 0x00(0x10)
struct FS_PlatformInformation PlatformInformation; // 0x10(0x18)
struct FString DisplayName; // 0x28(0x10)
struct FString PartyId; // 0x38(0x10)
int32_t CurrentPartyPlayerCount; // 0x48(0x04)
bool IsPartyLeader; // 0x4c(0x01)
char pad_4D[0x3]; // 0x4d(0x03)
int32_t PlayerLevel; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
struct FString LobbyEndpointUri; // 0x58(0x10)
bool CrossplayEnabled; // 0x68(0x01)
enum class ES_SocialPresenceStatus PresenceStatus; // 0x69(0x01)
char pad_6A[0x6]; // 0x6a(0x06)
struct FString ClientChangelist; // 0x70(0x10)
bool HasBeenSent; // 0x80(0x01)
char pad_81[0x7]; // 0x81(0x07)
};
// ScriptStruct Scavenger.S_PlatformInformation
// Size: 0x18 (Inherited: 0x00)
struct FS_PlatformInformation {
enum class ES_Platform Platform; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString PlatformId; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ReceivedTextChatMessage
// Size: 0x48 (Inherited: 0x00)
struct FS_ReceivedTextChatMessage {
char pad_0[0x48]; // 0x00(0x48)
};
// ScriptStruct Scavenger.S_FriendEntry
// Size: 0xb0 (Inherited: 0x00)
struct FS_FriendEntry {
struct FString PlayerId; // 0x00(0x10)
struct FString DisplayName; // 0x10(0x10)
enum class ES_FriendState FriendState; // 0x20(0x01)
char pad_21[0x7]; // 0x21(0x07)
struct FS_PlayerPresenceStatus Presence; // 0x28(0x88)
};
// ScriptStruct Scavenger.S_OnlineItemMetadata
// Size: 0x88 (Inherited: 0x58)
struct FS_OnlineItemMetadata : FS_DisplayableItemMetadata {
enum class ES_OnlineItemMetadataType ItemType; // 0x58(0x01)
char pad_59[0x7]; // 0x59(0x07)
struct FDataTableRowHandle ItemMetadataHandle; // 0x60(0x10)
bool AllowUnrestrictedAccess; // 0x70(0x01)
char pad_71[0x7]; // 0x71(0x07)
struct TArray<struct FDataTableRowHandle> AvailableCosmetics; // 0x78(0x10)
};
// ScriptStruct Scavenger.S_ActiveGameplayEffect
// Size: 0x3c8 (Inherited: 0x00)
struct FS_ActiveGameplayEffect {
struct FActiveGameplayEffect ActiveGameplayEffect; // 0x00(0x370)
char bIsMetadataValid : 1; // 0x370(0x01)
char pad_370_1 : 7; // 0x370(0x01)
char pad_371[0x7]; // 0x371(0x07)
struct FS_GameplayEffectMetadata GameplayEffectMetadata; // 0x378(0x50)
};
// ScriptStruct Scavenger.S_GameplayEffectMetadata
// Size: 0x50 (Inherited: 0x00)
struct FS_GameplayEffectMetadata {
struct FText Name; // 0x00(0x18)
struct FText NameCapitalized; // 0x18(0x18)
struct FText Description; // 0x30(0x18)
struct UTexture2D* Icon; // 0x48(0x08)
};
// ScriptStruct Scavenger.S_CrowdStats
// Size: 0xe0 (Inherited: 0x00)
struct FS_CrowdStats {
struct US_SocialHubCrowdAudioData* CrowdAudioData; // 0x00(0x08)
struct TArray<struct FS_CrowdMemberGroup> MemberGroups; // 0x08(0x10)
struct TArray<struct FS_CrowdStatsDirectionalBin> NearDirectionalBins; // 0x18(0x10)
struct TArray<struct FS_CrowdStatsDirectionalBin> FarDirectionalBins; // 0x28(0x10)
struct TMap<struct FName, struct FS_CrowdStatsForLoopingState> LoopingStateStats; // 0x38(0x50)
struct TMap<struct FName, struct FS_CrowdOneShotClusterArray> OneShotClusters; // 0x88(0x50)
char pad_D8[0x8]; // 0xd8(0x08)
};
// ScriptStruct Scavenger.S_CrowdOneShotClusterArray
// Size: 0x10 (Inherited: 0x00)
struct FS_CrowdOneShotClusterArray {
struct TArray<struct FS_CrowdOneShotCluster> Clusters; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_CrowdOneShotCluster
// Size: 0x58 (Inherited: 0x00)
struct FS_CrowdOneShotCluster {
struct FBox BoundingBox; // 0x00(0x1c)
int32_t Count; // 0x1c(0x04)
struct FVector AverageLocation; // 0x20(0x0c)
char pad_2C[0x1c]; // 0x2c(0x1c)
float CreationTime; // 0x48(0x04)
char pad_4C[0x4]; // 0x4c(0x04)
int64_t ClusterId; // 0x50(0x08)
};
// ScriptStruct Scavenger.S_CrowdStatsForLoopingState
// Size: 0x28 (Inherited: 0x00)
struct FS_CrowdStatsForLoopingState {
int32_t Count; // 0x00(0x04)
struct FVector AverageLocation; // 0x04(0x0c)
char pad_10[0x18]; // 0x10(0x18)
};
// ScriptStruct Scavenger.S_CrowdStatsDirectionalBin
// Size: 0x60 (Inherited: 0x00)
struct FS_CrowdStatsDirectionalBin {
int32_t Count; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct TMap<struct FName, int32_t> LoopingStateCounts; // 0x08(0x50)
char pad_58[0x8]; // 0x58(0x08)
};
// ScriptStruct Scavenger.S_CrowdMemberGroup
// Size: 0x18 (Inherited: 0x00)
struct FS_CrowdMemberGroup {
char pad_0[0x8]; // 0x00(0x08)
struct TArray<struct US_SocialHubCrowdAudioComponent*> CrowdMembers; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_MILEDataBank
// Size: 0x20 (Inherited: 0x00)
struct FS_MILEDataBank {
int32_t TotalMILEData; // 0x00(0x04)
int32_t TotalPhaseData; // 0x04(0x04)
int32_t CurrentDataTarget; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
struct TArray<struct FS_DataScore> HighScores; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_DataScore
// Size: 0x18 (Inherited: 0x00)
struct FS_DataScore {
int32_t Score; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString PlayerName; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_CosmeticItemMetadata
// Size: 0x1c8 (Inherited: 0x60)
struct FS_CosmeticItemMetadata : FS_DisplayableItemWithRarityMetadata {
enum class ES_CosmeticType CosmeticType; // 0x60(0x01)
char pad_61[0x7]; // 0x61(0x07)
struct TArray<struct TSoftObjectPtr<struct USkeletalMesh>> ReplacementMeshes; // 0x68(0x10)
struct TMap<struct TSoftObjectPtr<struct US_ItemData>, struct FS_CosmeticItemMetadataItemSpecificCustomization> MapOfItemDataToAdditionalCustomization; // 0x78(0x50)
struct TArray<struct FS_CosmeticItemSubMaterialSlotMetadata> SubMaterialSlots; // 0xc8(0x10)
struct TArray<struct FDataTableRowHandle> TinkerPacks; // 0xd8(0x10)
struct TArray<struct FString> CharacterRestriction; // 0xe8(0x10)
struct FName MontageTableID; // 0xf8(0x08)
struct TMap<enum class ES_CosmeticTitleSize, struct FDataTableRowHandle> TitleStyleSetHandles; // 0x100(0x50)
struct TMap<enum class ES_CosmeticTitleSize, struct FSlateBrush> TitleBackerBrushes; // 0x150(0x50)
struct TSoftObjectPtr<struct UTexture2D> BannerEmblemTexture; // 0x1a0(0x28)
};
// ScriptStruct Scavenger.S_CosmeticItemSubMaterialSlotMetadata
// Size: 0x40 (Inherited: 0x00)
struct FS_CosmeticItemSubMaterialSlotMetadata {
struct FName SlotId; // 0x00(0x08)
struct FText DisplayName; // 0x08(0x18)
struct FDataTableRowHandle LocalizedNameHandle; // 0x20(0x10)
struct TArray<struct FS_CosmeticItemSubMaterialSlotTargetMetadata> MaterialTargets; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_CosmeticItemSubMaterialSlotTargetMetadata
// Size: 0x18 (Inherited: 0x00)
struct FS_CosmeticItemSubMaterialSlotTargetMetadata {
struct FName MaterialSlotName; // 0x00(0x08)
struct FString MaterialParamPrefix; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_CosmeticItemMetadataItemSpecificCustomization
// Size: 0x88 (Inherited: 0x00)
struct FS_CosmeticItemMetadataItemSpecificCustomization {
struct TSoftObjectPtr<struct USkeletalMesh> AdditionalAttachmentMesh; // 0x00(0x28)
struct TMap<struct TSoftObjectPtr<struct USkeletalMesh>, struct FS_CosmeticItemMetadataSkeletalMeshSpecificCustomization> SkeletalMeshToAdditionalCustomization; // 0x28(0x50)
struct TArray<struct FS_CosmeticItemMetadataItemSocketAttachmentCustomization> SocketAttachmentCustomizations; // 0x78(0x10)
};
// ScriptStruct Scavenger.S_CosmeticItemMetadataItemSocketAttachmentCustomization
// Size: 0x40 (Inherited: 0x00)
struct FS_CosmeticItemMetadataItemSocketAttachmentCustomization {
struct FName SocketName; // 0x00(0x08)
bool HideOriginalSocketAttachment; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct TSoftObjectPtr<struct USkeletalMesh> AdditionalAttachmentMesh; // 0x10(0x28)
struct FName SocketToAttachToOnTargetComponent; // 0x38(0x08)
};
// ScriptStruct Scavenger.S_CosmeticItemMetadataSkeletalMeshSpecificCustomization
// Size: 0x60 (Inherited: 0x00)
struct FS_CosmeticItemMetadataSkeletalMeshSpecificCustomization {
struct FName MaskTextureParameter; // 0x00(0x08)
struct TSoftObjectPtr<struct UTexture2D> MaskTexture; // 0x08(0x28)
struct FName NormalTextureParameter; // 0x30(0x08)
struct TSoftObjectPtr<struct UTexture2D> NormalTexture; // 0x38(0x28)
};
// ScriptStruct Scavenger.S_UnseenObjectBadgeConfig
// Size: 0xc0 (Inherited: 0x00)
struct FS_UnseenObjectBadgeConfig {
bool bManuallySetMetadataTypes; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct TArray<enum class ES_OnlineItemMetadataType> MetadataTypes; // 0x08(0x10)
bool bManuallySetResourceTypes; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
struct TArray<enum class ES_OnlineResourceType> ResourceTypes; // 0x20(0x10)
bool bManuallySetResearchProjectTypes; // 0x30(0x01)
char pad_31[0x7]; // 0x31(0x07)
struct TArray<enum class ES_OnlineResearchProjectType> ResearchProjectTypes; // 0x38(0x10)
bool bManuallySetLoadoutSlotTypes; // 0x48(0x01)
char pad_49[0x7]; // 0x49(0x07)
struct TArray<enum class ES_LoadoutSlotType> LoadoutSlotTypes; // 0x50(0x10)
struct TArray<struct FName> OnlineItemIds; // 0x60(0x10)
struct TArray<struct FName> ResearchProjectIds; // 0x70(0x10)
bool bManuallySetCosmeticTypes; // 0x80(0x01)
char pad_81[0x7]; // 0x81(0x07)
struct TArray<enum class ES_CosmeticType> CosmeticTypes; // 0x88(0x10)
bool bManuallySetSocialTypes; // 0x98(0x01)
char pad_99[0x7]; // 0x99(0x07)
struct TArray<enum class ES_SocialType> SocialTypes; // 0xa0(0x10)
struct TArray<struct FName> SeasonsTierIds; // 0xb0(0x10)
};
// ScriptStruct Scavenger.S_LobbyPlayer
// Size: 0x108 (Inherited: 0x00)
struct FS_LobbyPlayer {
struct FString PlayerId; // 0x00(0x10)
struct FString DisplayName; // 0x10(0x10)
struct FString PlatformDisplayName; // 0x20(0x10)
struct FString Platform; // 0x30(0x10)
struct FString PlatformId; // 0x40(0x10)
struct FString CurrentPartyId; // 0x50(0x10)
int32_t DraftState; // 0x60(0x04)
int32_t DraftPeriodStartTime; // 0x64(0x04)
struct FS_LobbyPlayerCharacter SelectedCharacter; // 0x68(0x80)
struct TArray<struct FS_LobbyCustomizationItem> AccountCustomizationItems; // 0xe8(0x10)
int32_t PlayerLevel; // 0xf8(0x04)
int32_t PartySlotsAvailable; // 0xfc(0x04)
bool IsLocked; // 0x100(0x01)
char pad_101[0x7]; // 0x101(0x07)
};
// ScriptStruct Scavenger.S_LobbyCustomizationItem
// Size: 0x48 (Inherited: 0x00)
struct FS_LobbyCustomizationItem {
int32_t SlotType; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString SlotTypeName; // 0x08(0x10)
struct FString ItemInstanceId; // 0x18(0x10)
struct FString ItemId; // 0x28(0x10)
struct TArray<struct FS_LobbyCustomizationItemSubMaterialSelection> SubMaterials; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_LobbyCustomizationItemSubMaterialSelection
// Size: 0x28 (Inherited: 0x00)
struct FS_LobbyCustomizationItemSubMaterialSelection {
struct FString SubMaterialId; // 0x00(0x10)
struct FString PaletteId; // 0x10(0x10)
int32_t ColorIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_LobbyPlayerCharacter
// Size: 0x80 (Inherited: 0x00)
struct FS_LobbyPlayerCharacter {
struct FString Character; // 0x00(0x10)
struct TArray<struct FS_LobbyInventoryItem> LoadoutItems; // 0x10(0x10)
struct TArray<struct FS_LobbyCustomizationItem> CustomizationItems; // 0x20(0x10)
struct TMap<struct FString, int32_t> CharacterPoints; // 0x30(0x50)
};
// ScriptStruct Scavenger.S_LobbyInventoryItem
// Size: 0x38 (Inherited: 0x00)
struct FS_LobbyInventoryItem {
int32_t SlotType; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString SlotTypeName; // 0x08(0x10)
struct FString ItemInstanceId; // 0x18(0x10)
struct FString ItemId; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_LobbyConnectToServer
// Size: 0x58 (Inherited: 0x00)
struct FS_LobbyConnectToServer {
struct FString ServerIp; // 0x00(0x10)
struct FString Protocol; // 0x10(0x10)
int32_t TeamIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FJsonObjectWrapper MetaData; // 0x28(0x20)
struct FString ChatRoom; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_LobbyStartDraft
// Size: 0x20 (Inherited: 0x00)
struct FS_LobbyStartDraft {
int32_t DraftPeriodTime; // 0x00(0x04)
int32_t DraftInitialCountdownTimeMs; // 0x04(0x04)
int32_t DraftTransitionFadeTimeMs; // 0x08(0x04)
int32_t DraftStartingCountdownTimeMs; // 0x0c(0x04)
struct TArray<struct FString> TeamDraftOrder; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_LobbyTeamState
// Size: 0x68 (Inherited: 0x00)
struct FS_LobbyTeamState {
struct FS_LobbyTeam TeamState; // 0x00(0x48)
int32_t AutoStartSeconds; // 0x48(0x04)
int32_t SpawnIndex; // 0x4c(0x04)
struct FString CurrentQueueId; // 0x50(0x10)
int32_t SpawnScenario; // 0x60(0x04)
int32_t ServerPlayerCount; // 0x64(0x04)
};
// ScriptStruct Scavenger.S_LobbyTeam
// Size: 0x48 (Inherited: 0x00)
struct FS_LobbyTeam {
struct FString TeamId; // 0x00(0x10)
struct FString ServerName; // 0x10(0x10)
struct TArray<struct FS_LobbyParty> Parties; // 0x20(0x10)
int32_t TeamIndex; // 0x30(0x04)
int32_t SpawnIndex; // 0x34(0x04)
struct FString ChatRoom; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_LobbyParty
// Size: 0x60 (Inherited: 0x00)
struct FS_LobbyParty {
struct FString PartyId; // 0x00(0x10)
struct FString LeaderId; // 0x10(0x10)
struct TArray<struct FS_LobbyPlayer> Members; // 0x20(0x10)
struct FString QueueId; // 0x30(0x10)
struct FString TeamId; // 0x40(0x10)
struct FString ChatRoom; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_PendingPartyInvite
// Size: 0x70 (Inherited: 0x00)
struct FS_PendingPartyInvite {
struct FString PlayerId; // 0x00(0x10)
struct FString PartyId; // 0x10(0x10)
struct FS_LobbyEndpoint lobbyEndpoint; // 0x20(0x50)
};
// ScriptStruct Scavenger.S_NavigationInputData
// Size: 0x40 (Inherited: 0x08)
struct FS_NavigationInputData : FTableRowBase {
enum class ES_GameInputActionType InputAction; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FText DisplayText; // 0x10(0x18)
enum class ES_InputActionFlag ActionFlag; // 0x28(0x01)
enum class ES_NavigationInputCategory NavigationCategory; // 0x29(0x01)
enum class ES_InputSourceShowMode InputSourceShowMode; // 0x2a(0x01)
char pad_2B[0x5]; // 0x2b(0x05)
struct UAkAudioEvent* InputAudioEvent; // 0x30(0x08)
bool EnabledByDefault; // 0x38(0x01)
char pad_39[0x7]; // 0x39(0x07)
};
// ScriptStruct Scavenger.S_AbilityTimer
// Size: 0x0c (Inherited: 0x00)
struct FS_AbilityTimer {
float RemainingTime; // 0x00(0x04)
float MaxTime; // 0x04(0x04)
enum class ES_AbilityTimerState State; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
};
// ScriptStruct Scavenger.S_AbilityHandleNamePair
// Size: 0x0c (Inherited: 0x00)
struct FS_AbilityHandleNamePair {
struct FName AbilityKey; // 0x00(0x08)
struct FGameplayAbilitySpecHandle AbilityHandle; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_GameplayEffectMetadataTableRow
// Size: 0x60 (Inherited: 0x08)
struct FS_GameplayEffectMetadataTableRow : FTableRowBase {
struct FGameplayTag Tag; // 0x08(0x08)
struct FS_GameplayEffectMetadata MetaData; // 0x10(0x50)
};
// ScriptStruct Scavenger.S_ActionActivationMetadata
// Size: 0x01 (Inherited: 0x00)
struct FS_ActionActivationMetadata {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_ActionConfig
// Size: 0x20 (Inherited: 0x00)
struct FS_ActionConfig {
enum class ES_ActionResponse m_responseList[0x10]; // 0x00(0x10)
float m_maxQueueTime; // 0x10(0x04)
float m_maxRemoteQueueTime; // 0x14(0x04)
enum class ES_MultiActionCondition m_multiActionCondition; // 0x18(0x01)
char pad_19[0x3]; // 0x19(0x03)
float m_cooldownTime; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_SlideActionData
// Size: 0x03 (Inherited: 0x00)
struct FS_SlideActionData {
char pad_0[0x3]; // 0x00(0x03)
};
// ScriptStruct Scavenger.S_EmoteActionData
// Size: 0x08 (Inherited: 0x00)
struct FS_EmoteActionData {
char pad_0[0x8]; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_UseItemActionData
// Size: 0x18 (Inherited: 0x00)
struct FS_UseItemActionData {
char pad_0[0x8]; // 0x00(0x08)
struct US_ItemData* m_itemData; // 0x08(0x08)
char pad_10[0x8]; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_ActionTableRow
// Size: 0x20 (Inherited: 0x08)
struct FS_ActionTableRow : FTableRowBase {
char pad_8[0x1]; // 0x08(0x01)
enum class ES_ActionResponse Jump; // 0x09(0x01)
enum class ES_ActionResponse Dodge; // 0x0a(0x01)
enum class ES_ActionResponse Mantle; // 0x0b(0x01)
enum class ES_ActionResponse Sprint; // 0x0c(0x01)
enum class ES_ActionResponse Crouch; // 0x0d(0x01)
enum class ES_ActionResponse Cocoon; // 0x0e(0x01)
enum class ES_ActionResponse FireGun; // 0x0f(0x01)
enum class ES_ActionResponse MeleeAttack; // 0x10(0x01)
enum class ES_ActionResponse Reload; // 0x11(0x01)
enum class ES_ActionResponse AutoReload; // 0x12(0x01)
enum class ES_ActionResponse SwapWeapon; // 0x13(0x01)
enum class ES_ActionResponse ADS; // 0x14(0x01)
enum class ES_ActionResponse Slide; // 0x15(0x01)
enum class ES_ActionResponse Interact; // 0x16(0x01)
enum class ES_ActionResponse UseItem; // 0x17(0x01)
enum class ES_ActionResponse Emote; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
};
// ScriptStruct Scavenger.S_ActiveAction
// Size: 0x98 (Inherited: 0x00)
struct FS_ActiveAction {
char pad_0[0x8]; // 0x00(0x08)
struct FS_ActionPayload m_actionPayload; // 0x08(0x20)
char pad_28[0x70]; // 0x28(0x70)
};
// ScriptStruct Scavenger.S_AISound
// Size: 0x30 (Inherited: 0x00)
struct FS_AISound {
struct UAkAudioEvent* Event; // 0x00(0x08)
int32_t Priority; // 0x08(0x04)
uint32_t IsManaged; // 0x0c(0x04)
float TriggerProbability; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<struct US_AIAudioManagedGroup*> ManagedGroups; // 0x18(0x10)
int32_t RepetitionLimitNum; // 0x28(0x04)
float RepetitionLimitTimeWindowS; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_AIStateSound
// Size: 0x40 (Inherited: 0x30)
struct FS_AIStateSound : FS_AISound {
enum class ES_AIAudioState State; // 0x30(0x01)
char pad_31[0x3]; // 0x31(0x03)
float MinLoopOffsetS; // 0x34(0x04)
float MaxLoopOffsetS; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_EventSoundGroup
// Size: 0x18 (Inherited: 0x00)
struct FS_EventSoundGroup {
enum class ES_AIAudioState State; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct TArray<struct FS_AIEventSound> Sounds; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_AIEventSound
// Size: 0x38 (Inherited: 0x30)
struct FS_AIEventSound : FS_AISound {
struct US_AIAudioEventType* Type; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_AITransitionStateSound
// Size: 0x38 (Inherited: 0x30)
struct FS_AITransitionStateSound : FS_AISound {
enum class ES_AIAudioState From; // 0x30(0x01)
enum class ES_AIAudioState To; // 0x31(0x01)
char pad_32[0x6]; // 0x32(0x06)
};
// ScriptStruct Scavenger.S_PlayingAISound
// Size: 0x38 (Inherited: 0x30)
struct FS_PlayingAISound : FS_AISound {
char pad_30[0x8]; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_ClientQueuedAISound
// Size: 0x38 (Inherited: 0x30)
struct FS_ClientQueuedAISound : FS_AISound {
char pad_30[0x8]; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_ServerQueuedAISound
// Size: 0x40 (Inherited: 0x30)
struct FS_ServerQueuedAISound : FS_AISound {
uint64_t SoundId; // 0x30(0x08)
float triggerTime; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_GroupPlayingSound
// Size: 0x38 (Inherited: 0x00)
struct FS_GroupPlayingSound {
char pad_0[0x8]; // 0x00(0x08)
struct FS_AISound Sound; // 0x08(0x30)
};
// ScriptStruct Scavenger.S_DirectionlessHardPingTableRow
// Size: 0x18 (Inherited: 0x08)
struct FS_DirectionlessHardPingTableRow : FTableRowBase {
enum class ES_PoiseDamageType PoiseDamageType; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FName MontageKeyName; // 0x0c(0x08)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_AITargetingWeights
// Size: 0x20 (Inherited: 0x00)
struct FS_AITargetingWeights {
float ScoringBonusForCurrentTarget; // 0x00(0x04)
float ThreatFromEnemyAIInMyMinWeaponRange; // 0x04(0x04)
float ThreatFromMeBeingInEnemyWeaponRange; // 0x08(0x04)
float ThreatFromPlayerDamagedMe; // 0x0c(0x04)
float ThreatFromLastAIToDamageMe; // 0x10(0x04)
float ThreatFromDistanceBetweenus; // 0x14(0x04)
float ThreatFromAvailableKungFu; // 0x18(0x04)
float ThreatFromPerExecutionBonus; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_DebugAIHitData
// Size: 0x8c (Inherited: 0x00)
struct FS_DebugAIHitData {
struct FS_DebugDoAttackWillLikelyHitTargetData m_likelyHitData; // 0x00(0x5c)
bool m_isInWeaponRange; // 0x5c(0x01)
char pad_5D[0x3]; // 0x5d(0x03)
float m_weaponMaxRange; // 0x60(0x04)
struct FVector m_characterEyeLoc; // 0x64(0x0c)
struct FVector m_bulletStart; // 0x70(0x0c)
struct FVector m_targetLocation; // 0x7c(0x0c)
bool m_likelyHit; // 0x88(0x01)
char pad_89[0x3]; // 0x89(0x03)
};
// ScriptStruct Scavenger.S_DebugDoAttackWillLikelyHitTargetData
// Size: 0x5c (Inherited: 0x00)
struct FS_DebugDoAttackWillLikelyHitTargetData {
struct FVector m_startLocationSphere; // 0x00(0x0c)
struct FVector m_targetLocationSphere; // 0x0c(0x0c)
struct FVector m_targetTestLocationSphere; // 0x18(0x0c)
struct FVector m_targetTestLocationLineStart; // 0x24(0x0c)
bool m_isArcWeapon; // 0x30(0x01)
char pad_31[0x3]; // 0x31(0x03)
struct FVector m_traceHitResultStart; // 0x34(0x0c)
struct FVector m_traceHitResultEnd; // 0x40(0x0c)
bool m_traceHitSuccessful; // 0x4c(0x01)
char pad_4D[0x3]; // 0x4d(0x03)
struct FVector m_impactPoint; // 0x50(0x0c)
};
// ScriptStruct Scavenger.S_DebugAIData
// Size: 0x100 (Inherited: 0x00)
struct FS_DebugAIData {
struct FString m_behaviorTreeStr; // 0x00(0x10)
float m_oldestSightQuery; // 0x10(0x04)
float m_youngestSightQuery; // 0x14(0x04)
float m_damageAge; // 0x18(0x04)
float m_sightAge; // 0x1c(0x04)
float m_hearingAge; // 0x20(0x04)
float m_threat; // 0x24(0x04)
float m_distToTarget; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct FString m_targetName; // 0x30(0x10)
struct FString m_targetAcquisitionState; // 0x40(0x10)
struct FString m_squadName; // 0x50(0x10)
struct FString m_squadStageName; // 0x60(0x10)
float m_visibility; // 0x70(0x04)
char pad_74[0x4]; // 0x74(0x04)
struct TArray<struct FVector> m_navPoints; // 0x78(0x10)
int32_t m_currentSegment; // 0x88(0x04)
bool m_isUsingHeadLook; // 0x8c(0x01)
char pad_8D[0x3]; // 0x8d(0x03)
int32_t m_headLookSegment; // 0x90(0x04)
float m_headLookYaw; // 0x94(0x04)
float m_headLookPitch; // 0x98(0x04)
bool m_isCalcVelSpineBend; // 0x9c(0x01)
bool m_isCalcPathFindSpineBend; // 0x9d(0x01)
char pad_9E[0x2]; // 0x9e(0x02)
float m_velSpineBendAngle; // 0xa0(0x04)
float m_pathFindSpinePreBendAngle; // 0xa4(0x04)
float m_pathFindSpinePostBendAngle; // 0xa8(0x04)
float m_acceptanceRadius; // 0xac(0x04)
bool m_isCurrentSegmentNavigationLink; // 0xb0(0x01)
bool m_hasNavData; // 0xb1(0x01)
char pad_B2[0x6]; // 0xb2(0x06)
struct FString m_navDataName; // 0xb8(0x10)
struct FString m_currentMovementMode; // 0xc8(0x10)
struct FVector m_pawnRotation; // 0xd8(0x0c)
struct FVector m_controllerRotation; // 0xe4(0x0c)
uint64_t m_actorServerAddress; // 0xf0(0x08)
int32_t m_numNearbyFiringPoints; // 0xf8(0x04)
char pad_FC[0x4]; // 0xfc(0x04)
};
// ScriptStruct Scavenger.S_AIAndWeaponInteraction
// Size: 0x48 (Inherited: 0x00)
struct FS_AIAndWeaponInteraction {
SoftClassProperty WeaponClass; // 0x00(0x28)
int32_t m_currentPatternIndex; // 0x28(0x04)
char pad_2C[0xc]; // 0x2c(0x0c)
struct TArray<struct FS_AIFiringPattern> FiringPatterns; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_AIFiringPattern
// Size: 0x10 (Inherited: 0x00)
struct FS_AIFiringPattern {
struct FVector2D TimeRange; // 0x00(0x08)
char pad_8[0x4]; // 0x08(0x04)
bool TriggerDown; // 0x0c(0x01)
bool OnlyExecuteFirstTime; // 0x0d(0x01)
enum class ES_TriggerType triggerType; // 0x0e(0x01)
char pad_F[0x1]; // 0x0f(0x01)
};
// ScriptStruct Scavenger.S_AIAndHeadInteraction
// Size: 0x18 (Inherited: 0x00)
struct FS_AIAndHeadInteraction {
struct TArray<struct FS_AIHeadLookPattern> m_headLookPatterns; // 0x00(0x10)
char pad_10[0x4]; // 0x10(0x04)
bool m_loop; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
};
// ScriptStruct Scavenger.S_AIHeadLookPattern
// Size: 0x28 (Inherited: 0x00)
struct FS_AIHeadLookPattern {
struct FVector2D m_timeToReachDestination; // 0x00(0x08)
struct FVector2D m_timeToStay; // 0x08(0x08)
float m_finalRotationAngle; // 0x10(0x04)
char pad_14[0x14]; // 0x14(0x14)
};
// ScriptStruct Scavenger.S_AimAssistRelevantPawnRecord
// Size: 0x10 (Inherited: 0x00)
struct FS_AimAssistRelevantPawnRecord {
struct AS_CharacterBase* Character; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_AimAssistCameraTransform
// Size: 0x18 (Inherited: 0x00)
struct FS_AimAssistCameraTransform {
char pad_0[0x18]; // 0x00(0x18)
};
// ScriptStruct Scavenger.S_AimAssistSystemRanges
// Size: 0x18 (Inherited: 0x00)
struct FS_AimAssistSystemRanges {
char pad_0[0x18]; // 0x00(0x18)
};
// ScriptStruct Scavenger.S_AimAssistTargetRaycastRecord
// Size: 0x20 (Inherited: 0x00)
struct FS_AimAssistTargetRaycastRecord {
char pad_0[0x20]; // 0x00(0x20)
};
// ScriptStruct Scavenger.S_WeaponAimAssistSettings
// Size: 0x5c (Inherited: 0x00)
struct FS_WeaponAimAssistSettings {
struct FS_WeaponAimAssistValues AimAssistValues; // 0x00(0x2c)
bool bADSScaleByMagnification; // 0x2c(0x01)
bool bADSOverrideEnabled; // 0x2d(0x01)
char pad_2E[0x2]; // 0x2e(0x02)
struct FS_WeaponAimAssistValues ADSOverrideAimAssistValues; // 0x30(0x2c)
};
// ScriptStruct Scavenger.S_WeaponAimAssistValues
// Size: 0x2c (Inherited: 0x00)
struct FS_WeaponAimAssistValues {
float AutoAimAngle; // 0x00(0x04)
float AutoAimFalloffNearStart; // 0x04(0x04)
float AutoAimFalloffNearEnd; // 0x08(0x04)
float AutoAimFalloffStart; // 0x0c(0x04)
float AutoAimFalloffEnd; // 0x10(0x04)
float AimFrictionAngle; // 0x14(0x04)
float AimFrictionFalloffNearStart; // 0x18(0x04)
float AimFrictionFalloffNearEnd; // 0x1c(0x04)
float AimFrictionFalloffStart; // 0x20(0x04)
float AimFrictionFalloffEnd; // 0x24(0x04)
bool bEnableLeadVectorCalculation; // 0x28(0x01)
char pad_29[0x3]; // 0x29(0x03)
};
// ScriptStruct Scavenger.S_AimAssistGlobalSettings
// Size: 0x5c (Inherited: 0x00)
struct FS_AimAssistGlobalSettings {
float AngleFalloffRatio; // 0x00(0x04)
float AimFrictionFactor; // 0x04(0x04)
float AimFriction_TurnAccelerationDampingFactor; // 0x08(0x04)
float MovementStickiness_MaxYawScale; // 0x0c(0x04)
float MovementStickiness_MaxPitchScale; // 0x10(0x04)
float MovementStickiness_MaxYawDeltaRate; // 0x14(0x04)
float MovementStickiness_MaxPitchDeltaRate; // 0x18(0x04)
float ActorUnderReticle_MaxDistance; // 0x1c(0x04)
float ActorUnderReticle_InnerBaseFOV; // 0x20(0x04)
float ActorUnderReticle_OuterBaseFOV; // 0x24(0x04)
float ActorUnderReticle_BaseFOV_MagnificationExponent; // 0x28(0x04)
float ActorUnderReticle_MaxDistance_MagnificationExponent; // 0x2c(0x04)
float ActorUnderReticle_SelectionFactor_OverlapAmount; // 0x30(0x04)
float ActorUnderReticle_SelectionFactor_DistanceFromCamera; // 0x34(0x04)
float ActorUnderReticle_SelectionFactor_DownedMultiplier; // 0x38(0x04)
float ActorUnderReticle_SelectionFactor_HostileMultiplier; // 0x3c(0x04)
bool AutoAim_EnabledOnMouse; // 0x40(0x01)
char pad_41[0x3]; // 0x41(0x03)
float AutoAimSelectionFactor_DistanceFromCamera; // 0x44(0x04)
float AutoAimSelectionFactor_OverlapAmount; // 0x48(0x04)
float AutoAimSelectionFactor_AngularDistance; // 0x4c(0x04)
float AutoAimSelectionFactor_SphereWeighting; // 0x50(0x04)
float AutoAimEdgeSnappingFudgeFactor; // 0x54(0x04)
float LeadVectorMaxOffset; // 0x58(0x04)
};
// ScriptStruct Scavenger.S_AimAssistSphereConfig
// Size: 0x08 (Inherited: 0x00)
struct FS_AimAssistSphereConfig {
float SphereRadius; // 0x00(0x04)
enum class ES_AimAssistAutoAimWeightingLevel AutoAimWeighting; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
};
// ScriptStruct Scavenger.S_OverlordReference
// Size: 0x10 (Inherited: 0x00)
struct FS_OverlordReference {
struct FName OverlordName; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_OverlordSquad
// Size: 0x70 (Inherited: 0x00)
struct FS_OverlordSquad {
struct FName SquadName; // 0x00(0x08)
struct TArray<struct FS_SpawnerReference> SpawnerReferences; // 0x08(0x10)
struct FS_StageReference InitialStage; // 0x18(0x08)
struct FString CurrentStage; // 0x20(0x10)
char pad_30[0x10]; // 0x30(0x10)
int32_t AliveCount_HighWatermark; // 0x40(0x04)
int32_t CurrentLivingCount; // 0x44(0x04)
float LastSquadLeapTime; // 0x48(0x04)
struct FVector2D SquadLeapBlockTimer; // 0x4c(0x08)
char pad_54[0x4]; // 0x54(0x04)
float LastSquadGrenadeTime; // 0x58(0x04)
struct FVector2D SquadGrenadeBlockTimer; // 0x5c(0x08)
char pad_64[0x4]; // 0x64(0x04)
float MaxPatrolsRatio; // 0x68(0x04)
char pad_6C[0x4]; // 0x6c(0x04)
};
// ScriptStruct Scavenger.S_StageReference
// Size: 0x08 (Inherited: 0x00)
struct FS_StageReference {
struct FName StageName; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_SpawnerReference
// Size: 0x10 (Inherited: 0x00)
struct FS_SpawnerReference {
struct FName SpawnerName; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_OverlordSquadStage
// Size: 0x28 (Inherited: 0x00)
struct FS_OverlordSquadStage {
struct FName StageName; // 0x00(0x08)
struct TArray<struct FS_AreaReference> AreaReference; // 0x08(0x10)
int32_t m_maxAiCount; // 0x18(0x04)
int32_t m_currentAiCount; // 0x1c(0x04)
int32_t MaxDeadAiCount; // 0x20(0x04)
int32_t CurrentDeadAiCount; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_AreaReference
// Size: 0x10 (Inherited: 0x00)
struct FS_AreaReference {
struct FName AreaName; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_OverlordSmatterAudioVolume
// Size: 0x50 (Inherited: 0x00)
struct FS_OverlordSmatterAudioVolume {
struct FName TriggerName; // 0x00(0x08)
struct TWeakObjectPtr<struct AS_AISmatterVolume> TriggerVolume; // 0x08(0x08)
struct FS_SmatterReference SmatterVolume; // 0x10(0x10)
struct FVector2D OnEnterCooldownTime; // 0x20(0x08)
struct US_AIAudioEventType* OnEnterAudioEvent; // 0x28(0x08)
struct FVector2D PeriodicCooldownTime; // 0x30(0x08)
struct US_AIAudioEventType* PeriodicAudioEvent; // 0x38(0x08)
char pad_40[0x10]; // 0x40(0x10)
};
// ScriptStruct Scavenger.S_SmatterReference
// Size: 0x10 (Inherited: 0x00)
struct FS_SmatterReference {
struct FName SmatterName; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_TriggerReference
// Size: 0x10 (Inherited: 0x00)
struct FS_TriggerReference {
struct FName TriggerName; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_SquadReference
// Size: 0x08 (Inherited: 0x00)
struct FS_SquadReference {
struct FName SquadName; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_AIPoint
// Size: 0x40 (Inherited: 0x00)
struct FS_AIPoint {
struct TArray<struct FName> TagsDeprecatedToBeRemoved; // 0x00(0x10)
struct FVector Location; // 0x10(0x0c)
char pad_1C[0x8]; // 0x1c(0x08)
float QueryScore; // 0x24(0x04)
bool bLowCover; // 0x28(0x01)
bool bHighCover; // 0x29(0x01)
char pad_2A[0x2]; // 0x2a(0x02)
struct FVector CoverDirection; // 0x2c(0x0c)
float DistanceToCover; // 0x38(0x04)
float LockOutTimeInSeconds; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_AIHailEvent
// Size: 0x18 (Inherited: 0x00)
struct FS_AIHailEvent {
struct AActor* m_instigator; // 0x00(0x08)
char pad_8[0x10]; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_EQSExecutionRequest
// Size: 0x20 (Inherited: 0x00)
struct FS_EQSExecutionRequest {
struct UEnvQuery* QueryTemplate; // 0x00(0x08)
enum class EEnvQueryRunMode RunMode; // 0x08(0x01)
char pad_9[0x17]; // 0x09(0x17)
};
// ScriptStruct Scavenger.S_AmbianceEmitterData
// Size: 0x10 (Inherited: 0x00)
struct FS_AmbianceEmitterData {
struct UAkAudioEvent* m_EmitterAudioEvent; // 0x00(0x08)
float m_EmitFrequencyMin; // 0x08(0x04)
float m_EmitFrequencyMax; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_AmbianceBedData
// Size: 0x10 (Inherited: 0x00)
struct FS_AmbianceBedData {
struct UAkAudioEvent* m_BedAudioEvent; // 0x00(0x08)
struct UAkAudioEvent* m_BedStopEvent; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_MontageCatalogue
// Size: 0x50 (Inherited: 0x00)
struct FS_MontageCatalogue {
struct TMap<struct FName, struct FS_MontageVariationContainer> AnimCatalogue; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_MontageVariationContainer
// Size: 0x10 (Inherited: 0x00)
struct FS_MontageVariationContainer {
struct TArray<struct UAnimMontage*> AnimVariations; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_OriginalMagazineAttachInfo
// Size: 0x60 (Inherited: 0x00)
struct FS_OriginalMagazineAttachInfo {
struct AS_WeaponMagazineAttachment* Magazine; // 0x00(0x08)
struct USceneComponent* OriginalParent; // 0x08(0x08)
char pad_10[0x50]; // 0x10(0x50)
};
// ScriptStruct Scavenger.S_WeaponAssassinationMontages
// Size: 0x58 (Inherited: 0x00)
struct FS_WeaponAssassinationMontages {
struct UAnimMontage* AttackerMontage; // 0x00(0x08)
struct TMap<SoftClassProperty, struct UAnimMontage*> VictimMontages; // 0x08(0x50)
};
// ScriptStruct Scavenger.S_AttackArray
// Size: 0x28 (Inherited: 0x00)
struct FS_AttackArray {
struct TArray<struct FS_AttackEntry> Entries; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
uint32_t LastServerId; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_AttackEntry
// Size: 0x30 (Inherited: 0x00)
struct FS_AttackEntry {
enum class ES_ReplicatedAttackEntryType AttackType; // 0x00(0x01)
char ServerFlags; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
uint32_t ServerEntryId; // 0x04(0x04)
enum class ES_WeaponSlot weaponSlot; // 0x08(0x01)
enum class ES_TriggerType triggerType; // 0x09(0x01)
char pad_A[0x2]; // 0x0a(0x02)
uint32_t StartID; // 0x0c(0x04)
struct TArray<struct FS_DoAttackEntry> Attacks; // 0x10(0x10)
struct UAnimMontage* StartMontage; // 0x20(0x08)
bool attackCanceled; // 0x28(0x01)
char shellsLoaded; // 0x29(0x01)
bool StopReloadAnimation; // 0x2a(0x01)
char pad_2B[0x1]; // 0x2b(0x01)
float ServerTimestamp; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_DoAttackEntry
// Size: 0x88 (Inherited: 0x00)
struct FS_DoAttackEntry {
struct FS_AttackTargetInfo TargetInfo; // 0x00(0x70)
char DoAttackID; // 0x70(0x01)
char pad_71[0x3]; // 0x71(0x03)
struct TWeakObjectPtr<struct UAnimMontage> OwnerMontage; // 0x74(0x08)
struct TWeakObjectPtr<struct UAnimMontage> WeaponMontage; // 0x7c(0x08)
float ServerTimestamp; // 0x84(0x04)
};
// ScriptStruct Scavenger.S_AttackTargetInfo
// Size: 0x70 (Inherited: 0x00)
struct FS_AttackTargetInfo {
char Flags; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector HitPoint; // 0x04(0x0c)
struct FVector HitNormal; // 0x10(0x0c)
struct FVector HitPointWS; // 0x1c(0x0c)
struct FVector HitNormalWS; // 0x28(0x0c)
char HitSurfaceTypeIndex; // 0x34(0x01)
char pad_35[0x3]; // 0x35(0x03)
struct AActor* HitActor; // 0x38(0x08)
uint32_t HitBoneIndex; // 0x40(0x04)
struct FVector CorrectedStartLocation; // 0x44(0x0c)
struct FS_RandState RandState; // 0x50(0x18)
char pad_68[0x8]; // 0x68(0x08)
};
// ScriptStruct Scavenger.S_RandState
// Size: 0x18 (Inherited: 0x00)
struct FS_RandState {
char pad_0[0x8]; // 0x00(0x08)
bool m_initialized; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
uint32_t m_randCount; // 0x0c(0x04)
int32_t m_seed; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_AttackDataQueue
// Size: 0x10 (Inherited: 0x00)
struct FS_AttackDataQueue {
struct TArray<struct FS_AttackDataQueueEntry> AttackDataQueue; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_AttackDataQueueEntry
// Size: 0xa8 (Inherited: 0x00)
struct FS_AttackDataQueueEntry {
struct FS_AttackTargetInfo AttackTargetInfo; // 0x00(0x70)
struct TArray<struct FS_QueuedDamageRequest> QueuedDamageRequests; // 0x70(0x10)
struct TArray<struct FS_QueuedExplosionRequest> QueuedExplosionRequests; // 0x80(0x10)
char pad_90[0x18]; // 0x90(0x18)
};
// ScriptStruct Scavenger.S_QueuedExplosionRequest
// Size: 0xc8 (Inherited: 0x00)
struct FS_QueuedExplosionRequest {
char pad_0[0x20]; // 0x00(0x20)
struct UObject* DamageType; // 0x20(0x08)
char pad_28[0xa0]; // 0x28(0xa0)
};
// ScriptStruct Scavenger.S_QueuedDamageRequest
// Size: 0x30 (Inherited: 0x00)
struct FS_QueuedDamageRequest {
char pad_0[0x18]; // 0x00(0x18)
struct TArray<struct FS_PointDamageRequest> PointDamageRequests; // 0x18(0x10)
char pad_28[0x8]; // 0x28(0x08)
};
// ScriptStruct Scavenger.S_PointDamageRequest
// Size: 0x128 (Inherited: 0x00)
struct FS_PointDamageRequest {
struct AActor* m_damagedActor; // 0x00(0x08)
struct FS_PointDamageEvent m_damageEvent; // 0x08(0xe8)
struct FS_PointDamageValidation m_validationData; // 0xf0(0x38)
};
// ScriptStruct Scavenger.S_PointDamageValidation
// Size: 0x38 (Inherited: 0x00)
struct FS_PointDamageValidation {
struct FVector m_victimHitOffset; // 0x00(0x0c)
char pad_C[0x4]; // 0x0c(0x04)
struct AS_WeaponBase* m_causeWeapon; // 0x10(0x08)
enum class ES_TriggerType m_triggerType; // 0x18(0x01)
bool m_bCritical; // 0x19(0x01)
char pad_1A[0x6]; // 0x1a(0x06)
struct FS_RandState m_criticalRandState; // 0x20(0x18)
};
// ScriptStruct Scavenger.S_CharacterBaseMontagePackage
// Size: 0x50 (Inherited: 0x00)
struct FS_CharacterBaseMontagePackage {
struct TMap<enum class ES_WeaponMontageEvent, struct FS_WeaponAttachmentOverridePackages> EventMontagePackages; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_WeaponAttachmentOverridePackages
// Size: 0xf8 (Inherited: 0x00)
struct FS_WeaponAttachmentOverridePackages {
struct TMap<SoftClassProperty, struct US_AttackEventMontagePackage*> TriggerableAttachmentOverride; // 0x00(0x50)
struct TMap<enum class ES_TriggerableWeaponAttachmentClass, struct US_AttackEventMontagePackage*> TriggerableAttachmentClassOverride; // 0x50(0x50)
struct TMap<SoftClassProperty, struct US_AttackEventMontagePackage*> WeaponAttachmentOverride; // 0xa0(0x50)
struct US_AttackEventMontagePackage* DefaultMontagePackage; // 0xf0(0x08)
};
// ScriptStruct Scavenger.S_WeaponBaseMontagePackage
// Size: 0x50 (Inherited: 0x00)
struct FS_WeaponBaseMontagePackage {
struct TMap<enum class ES_WeaponMontageEvent, struct FS_WeaponAttachmentOverridePackages> EventMontagePackages; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_CharacterStanceContainer
// Size: 0x40 (Inherited: 0x00)
struct FS_CharacterStanceContainer {
struct FS_AttackEventMontageVariationContainer Stances[0x4]; // 0x00(0x40)
};
// ScriptStruct Scavenger.S_AttackEventMontageVariationContainer
// Size: 0x10 (Inherited: 0x00)
struct FS_AttackEventMontageVariationContainer {
struct TArray<struct UAnimMontage*> MontageVariations; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_AttackParameters
// Size: 0x38 (Inherited: 0x00)
struct FS_AttackParameters {
char pad_0[0x38]; // 0x00(0x38)
};
// ScriptStruct Scavenger.S_SwapWeaponPayload
// Size: 0x04 (Inherited: 0x00)
struct FS_SwapWeaponPayload {
char pad_0[0x4]; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_CancelReloadPayload
// Size: 0x10 (Inherited: 0x00)
struct FS_CancelReloadPayload {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_StopReloadPayload
// Size: 0x10 (Inherited: 0x00)
struct FS_StopReloadPayload {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_StartReloadPayload
// Size: 0x0c (Inherited: 0x00)
struct FS_StartReloadPayload {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_CancelAttackPayload
// Size: 0x0c (Inherited: 0x00)
struct FS_CancelAttackPayload {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_StopAttackPayload
// Size: 0x0c (Inherited: 0x00)
struct FS_StopAttackPayload {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_DoAttackPayload
// Size: 0xc8 (Inherited: 0x00)
struct FS_DoAttackPayload {
char pad_0[0xc8]; // 0x00(0xc8)
};
// ScriptStruct Scavenger.S_StartAttackPayload
// Size: 0x0c (Inherited: 0x00)
struct FS_StartAttackPayload {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_AttackSlotState
// Size: 0xc0 (Inherited: 0x00)
struct FS_AttackSlotState {
char pad_0[0x18]; // 0x00(0x18)
struct FS_AttackDataQueueEntry AttackDataQueueEntry; // 0x18(0xa8)
};
// ScriptStruct Scavenger.S_AttributeSetTickFunction
// Size: 0x30 (Inherited: 0x28)
struct FS_AttributeSetTickFunction : FTickFunction {
char pad_28[0x8]; // 0x28(0x08)
};
// ScriptStruct Scavenger.S_GameplayAttributeData
// Size: 0x90 (Inherited: 0x10)
struct FS_GameplayAttributeData : FGameplayAttributeData {
char pad_10[0x68]; // 0x10(0x68)
bool m_replicates; // 0x78(0x01)
char pad_79[0x17]; // 0x79(0x17)
};
// ScriptStruct Scavenger.S_AttributeData
// Size: 0x30 (Inherited: 0x00)
struct FS_AttributeData {
char pad_0[0x30]; // 0x00(0x30)
};
// ScriptStruct Scavenger.S_IsUsingADSAttributeModifiers
// Size: 0x50 (Inherited: 0x00)
struct FS_IsUsingADSAttributeModifiers {
struct TMap<bool, struct FS_AttributeModifierContainer> MapOfIsUsingADSToModifierContainer; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_AttributeModifierContainer
// Size: 0x10 (Inherited: 0x00)
struct FS_AttributeModifierContainer {
struct TArray<struct FS_AttributeModifier> Modifiers; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_AttributeModifier
// Size: 0x0c (Inherited: 0x00)
struct FS_AttributeModifier {
enum class ES_AttributeModification ModificationType; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FName ModifyingAttributeName; // 0x04(0x08)
};
// ScriptStruct Scavenger.S_ChangeCauseAttributeModifiers
// Size: 0x50 (Inherited: 0x00)
struct FS_ChangeCauseAttributeModifiers {
struct TMap<enum class ES_StatChangeCauseType, struct FS_AttributeModifierContainer> MapOfChangeCauseToModifierContainer; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_WeaponClassAttributeModifiers
// Size: 0x50 (Inherited: 0x00)
struct FS_WeaponClassAttributeModifiers {
struct TMap<enum class ES_WeaponClass, struct FS_AttributeModifierContainer> MapOfWeaponClassToModifierContainer; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_AttributeInitialization
// Size: 0x30 (Inherited: 0x08)
struct FS_AttributeInitialization : FTableRowBase {
float InitialValue; // 0x08(0x04)
bool bShouldClampMinimum; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
struct FName MinimumAttributeName; // 0x10(0x08)
float MinimumValue; // 0x18(0x04)
bool bShouldClampMaximum; // 0x1c(0x01)
char pad_1D[0x3]; // 0x1d(0x03)
struct FName MaximumAttributeName; // 0x20(0x08)
float MaximumValue; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_AudioImpactRow
// Size: 0x10 (Inherited: 0x08)
struct FS_AudioImpactRow : FTableRowBase {
struct UAkAudioEvent* Event; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_AutoPingReprocessData
// Size: 0xa0 (Inherited: 0x00)
struct FS_AutoPingReprocessData {
char pad_0[0xa0]; // 0x00(0xa0)
};
// ScriptStruct Scavenger.S_AutoPingCounts
// Size: 0xa0 (Inherited: 0x00)
struct FS_AutoPingCounts {
char pad_0[0xa0]; // 0x00(0xa0)
};
// ScriptStruct Scavenger.S_AutoPingChannel
// Size: 0x58 (Inherited: 0x00)
struct FS_AutoPingChannel {
struct TMap<enum class ES_AutoPingType, int32_t> MaxAutoPingCounts; // 0x00(0x50)
int32_t MaxPingCount; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
};
// ScriptStruct Scavenger.S_AutoPingPriorityContainer
// Size: 0x68 (Inherited: 0x00)
struct FS_AutoPingPriorityContainer {
char pad_0[0x8]; // 0x00(0x08)
struct TMap<enum class ES_AutoPingType, struct FS_AutoPingTypeContainer> m_mapOfAutoPingTypeToAutoPingTypeContainer; // 0x08(0x50)
char pad_58[0x10]; // 0x58(0x10)
};
// ScriptStruct Scavenger.S_AutoPingTypeContainer
// Size: 0xa8 (Inherited: 0x00)
struct FS_AutoPingTypeContainer {
char pad_0[0x8]; // 0x00(0x08)
struct TMap<struct AS_PlayerController*, struct FS_AutoPingCollection> m_mapOfPlayerControllerToAutoPingCollection; // 0x08(0x50)
struct TMap<int32_t, struct FS_AutoPingCollection> m_mapOfTeamIndexToAutoPingCollection; // 0x58(0x50)
};
// ScriptStruct Scavenger.S_AutoPingCollection
// Size: 0x20 (Inherited: 0x00)
struct FS_AutoPingCollection {
char pad_0[0x10]; // 0x00(0x10)
struct TArray<struct FS_AutoPingDistancePair> m_sortedAutoPingDistancePairs; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_AutoPingDistancePair
// Size: 0x10 (Inherited: 0x00)
struct FS_AutoPingDistancePair {
char pad_0[0x8]; // 0x00(0x08)
struct US_AutoPingComponent* m_autoPingComponent; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_BloodSplat
// Size: 0x18 (Inherited: 0x00)
struct FS_BloodSplat {
struct UDecalComponent* Decal; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
struct UMaterialInstanceDynamic* MaterialInstance; // 0x10(0x08)
};
// ScriptStruct Scavenger.BodyPingRegion
// Size: 0xb0 (Inherited: 0x00)
struct FBodyPingRegion {
struct FTransform BoundsTransform; // 0x00(0x30)
struct TMap<struct FName, struct FVector> BoundsDirection; // 0x30(0x50)
struct FName RegionName; // 0x80(0x08)
struct FName ForwardsAnimDirectionMontageKey; // 0x88(0x08)
struct FName BackwardsAnimDirectionMontageKey; // 0x90(0x08)
struct FName RightAnimDirectionMontageKey; // 0x98(0x08)
struct FName LeftAnimDirectionMontageKey; // 0xa0(0x08)
char pad_A8[0x8]; // 0xa8(0x08)
};
// ScriptStruct Scavenger.AimAssistInfo
// Size: 0x14 (Inherited: 0x00)
struct FAimAssistInfo {
struct FName BoneDescription; // 0x00(0x08)
float m_radius; // 0x08(0x04)
float m_attraction; // 0x0c(0x04)
float m_friction; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_DerezVisualGuidesData
// Size: 0x10 (Inherited: 0x00)
struct FS_DerezVisualGuidesData {
bool bIsAnEnd; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float StartingLength; // 0x04(0x04)
float EndingLength; // 0x08(0x04)
float Width; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_SplineBoxData
// Size: 0x1c (Inherited: 0x00)
struct FS_SplineBoxData {
struct FVector WorldStartLocation; // 0x00(0x0c)
struct FVector WorldEndLocation; // 0x0c(0x0c)
float Width; // 0x18(0x04)
};
// ScriptStruct Scavenger.S_OpenSpanwerObjectBool
// Size: 0x02 (Inherited: 0x00)
struct FS_OpenSpanwerObjectBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_InactiveRadiusFloat
// Size: 0x08 (Inherited: 0x00)
struct FS_InactiveRadiusFloat {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_ActiveRadiusFloat
// Size: 0x08 (Inherited: 0x00)
struct FS_ActiveRadiusFloat {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_FallbackSpawnHeightFloat
// Size: 0x08 (Inherited: 0x00)
struct FS_FallbackSpawnHeightFloat {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_FallbackSpawnRadiusFloat
// Size: 0x08 (Inherited: 0x00)
struct FS_FallbackSpawnRadiusFloat {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_AllowSpawnWithPlayersInsideBool
// Size: 0x02 (Inherited: 0x00)
struct FS_AllowSpawnWithPlayersInsideBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_MaxReplenishmentCountInt
// Size: 0x08 (Inherited: 0x00)
struct FS_MaxReplenishmentCountInt {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_ReplenishmentActiveBool
// Size: 0x02 (Inherited: 0x00)
struct FS_ReplenishmentActiveBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_MinimumTimeAfterInitalSpawnsFVector2D
// Size: 0x0c (Inherited: 0x00)
struct FS_MinimumTimeAfterInitalSpawnsFVector2D {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector2D NewValues; // 0x04(0x08)
};
// ScriptStruct Scavenger.S_MinimumTimeBetweenSpawnsFVector2D
// Size: 0x0c (Inherited: 0x00)
struct FS_MinimumTimeBetweenSpawnsFVector2D {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector2D NewValues; // 0x04(0x08)
};
// ScriptStruct Scavenger.S_MaximumNumberInitiallySpawnedActorsInt
// Size: 0x08 (Inherited: 0x00)
struct FS_MaximumNumberInitiallySpawnedActorsInt {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_MaximumNumberOfSpawnedActorsInt
// Size: 0x08 (Inherited: 0x00)
struct FS_MaximumNumberOfSpawnedActorsInt {
bool UpdateThis; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t NewValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_OnlyUsePointsForReplenishBool
// Size: 0x02 (Inherited: 0x00)
struct FS_OnlyUsePointsForReplenishBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_OnlyUsePointsForSpawningBool
// Size: 0x02 (Inherited: 0x00)
struct FS_OnlyUsePointsForSpawningBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_SpawnOneByOneBool
// Size: 0x02 (Inherited: 0x00)
struct FS_SpawnOneByOneBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_SleepingBool
// Size: 0x02 (Inherited: 0x00)
struct FS_SleepingBool {
bool UpdateThis; // 0x00(0x01)
bool Set; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_CarouselMetadata
// Size: 0x110 (Inherited: 0x10)
struct FS_CarouselMetadata : FS_MetadataTableRowBase {
struct FDataTableRowHandle TitleFormatHandle; // 0x10(0x10)
struct FDataTableRowHandle LocalizedTitleHandle; // 0x20(0x10)
struct FDataTableRowHandle SubtitleFormatHandle; // 0x30(0x10)
struct FDataTableRowHandle LocalizedSubtitleHandle; // 0x40(0x10)
struct FDataTableRowHandle DescriptionFormatHandle; // 0x50(0x10)
struct FDataTableRowHandle LocalizedDescriptionHandle; // 0x60(0x10)
struct TSoftObjectPtr<struct UTexture2D> CarouselImage; // 0x70(0x28)
struct US_WidgetCarouselItem* CarouselClass; // 0x98(0x08)
struct US_WidgetCarouselItem* CarouselDetailsClass; // 0xa0(0x08)
struct FDataTableRowHandle DetailsDescriptionFormatHandle; // 0xa8(0x10)
struct FDataTableRowHandle LocalizedDetailsDescription; // 0xb8(0x10)
struct FDataTableRowHandle DetailsTitleFormatHandle; // 0xc8(0x10)
struct FDataTableRowHandle LocalizedDetailsTitle; // 0xd8(0x10)
struct TSoftObjectPtr<struct UTexture2D> DetailsImage; // 0xe8(0x28)
};
// ScriptStruct Scavenger.S_WeaponScaleTableRow
// Size: 0x20 (Inherited: 0x08)
struct FS_WeaponScaleTableRow : FTableRowBase {
struct AS_WeaponBase* weapon; // 0x08(0x08)
struct FVector Scale; // 0x10(0x0c)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_ProjectileSpawnPointInfo
// Size: 0x30 (Inherited: 0x00)
struct FS_ProjectileSpawnPointInfo {
struct FVector PivotPoint; // 0x00(0x0c)
struct FVector OffsetHipFire; // 0x0c(0x0c)
struct FVector OffsetADS; // 0x18(0x0c)
struct FVector OffsetGrenade; // 0x24(0x0c)
};
// ScriptStruct Scavenger.S_TimeBasedDamageTracker
// Size: 0x28 (Inherited: 0x00)
struct FS_TimeBasedDamageTracker {
float TimeInterval; // 0x00(0x04)
char pad_4[0x24]; // 0x04(0x24)
};
// ScriptStruct Scavenger.S_Visibility
// Size: 0x14 (Inherited: 0x00)
struct FS_Visibility {
float CloakedVisibilty; // 0x00(0x04)
float DayNightVisibilty; // 0x04(0x04)
float MovementVisibilty; // 0x08(0x04)
float StormVisibilty; // 0x0c(0x04)
float TotalVisibilty; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_CachedLastDamageInfo
// Size: 0xa8 (Inherited: 0x00)
struct FS_CachedLastDamageInfo {
struct AController* m_instigatorController; // 0x00(0x08)
struct AActor* m_causeActor; // 0x08(0x08)
char pad_10[0x98]; // 0x10(0x98)
};
// ScriptStruct Scavenger.S_LookAtInfo
// Size: 0x10 (Inherited: 0x00)
struct FS_LookAtInfo {
bool ShouldLookAtTarget; // 0x00(0x01)
bool ShouldLookTargetActor; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
struct FVector LookAtTargetPosition; // 0x04(0x0c)
};
// ScriptStruct Scavenger.S_RepMontageState
// Size: 0x18 (Inherited: 0x00)
struct FS_RepMontageState {
struct UAnimMontage* MontagePlaying; // 0x00(0x08)
char AnimPlayCount; // 0x08(0x01)
char AnimStopCount; // 0x09(0x01)
char pad_A[0x2]; // 0x0a(0x02)
float AbortBlendTime; // 0x0c(0x04)
float PlayRate; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_LeapCache
// Size: 0x18 (Inherited: 0x00)
struct FS_LeapCache {
enum class ES_LeapState State; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector trajectory; // 0x04(0x0c)
char pad_10[0x8]; // 0x10(0x08)
};
// ScriptStruct Scavenger.AnimMontages
// Size: 0x500 (Inherited: 0x00)
struct FAnimMontages {
struct FStateData StateData[0x4]; // 0x00(0x500)
};
// ScriptStruct Scavenger.StateData
// Size: 0x140 (Inherited: 0x00)
struct FStateData {
struct FMontageContainer MontageContainer[0x4]; // 0x00(0x140)
};
// ScriptStruct Scavenger.MontageContainer
// Size: 0x50 (Inherited: 0x00)
struct FMontageContainer {
struct TMap<struct AS_CharacterBase*, struct UAnimMontage*> Montages; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_CharacterMontageTableRow
// Size: 0xb8 (Inherited: 0x08)
struct FS_CharacterMontageTableRow : FTableRowBase {
struct TArray<struct UAnimMontage*> DefaultMontageVariations; // 0x08(0x10)
struct TMap<enum class ES_WeaponClass, struct FS_WeaponClassMontageContainer> WeaponClassOverrides; // 0x18(0x50)
struct TMap<SoftClassProperty, struct FS_WeaponClassMontageContainer> WeaponOverrides; // 0x68(0x50)
};
// ScriptStruct Scavenger.S_WeaponClassMontageContainer
// Size: 0x60 (Inherited: 0x00)
struct FS_WeaponClassMontageContainer {
struct TArray<struct UAnimMontage*> DefaultMontageVariations; // 0x00(0x10)
struct TMap<enum class ES_DerivedCharacterBaseState, struct FS_BodyStateMontageContainer> StateOverrides; // 0x10(0x50)
};
// ScriptStruct Scavenger.S_BodyStateMontageContainer
// Size: 0x60 (Inherited: 0x00)
struct FS_BodyStateMontageContainer {
struct TArray<struct UAnimMontage*> DefaultMontageVariations; // 0x00(0x10)
struct TMap<enum class ES_CharacterBodyStance, struct FS_BodyStanceMontageContainer> StanceOverrides; // 0x10(0x50)
};
// ScriptStruct Scavenger.S_BodyStanceMontageContainer
// Size: 0x10 (Inherited: 0x00)
struct FS_BodyStanceMontageContainer {
struct TArray<struct UAnimMontage*> MontageVariations; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_SlideState
// Size: 0x40 (Inherited: 0x00)
struct FS_SlideState {
enum class ES_Slide CurrentSlide; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t CurrentCustomSlideIdx; // 0x04(0x04)
char pad_8[0x38]; // 0x08(0x38)
};
// ScriptStruct Scavenger.CharMoveDebugInfo
// Size: 0x54 (Inherited: 0x00)
struct FCharMoveDebugInfo {
char pad_0[0x4]; // 0x00(0x04)
int32_t ID; // 0x04(0x04)
bool wantToSprint; // 0x08(0x01)
bool canSprint; // 0x09(0x01)
bool movementCanSprint; // 0x0a(0x01)
bool movementWantsToSprint; // 0x0b(0x01)
bool movementIsSprinting; // 0x0c(0x01)
bool movementAdsActive; // 0x0d(0x01)
char pad_E[0x2]; // 0x0e(0x02)
struct FS_MoveSpeed movementCurrSpeed; // 0x10(0x18)
struct FS_MoveSpeed movementRepSpeed; // 0x28(0x18)
enum class EPhysicalSurface movementSurfaceType; // 0x40(0x01)
bool movementSlideActive; // 0x41(0x01)
enum class ES_Slide movementCurrentSlide; // 0x42(0x01)
char pad_43[0x1]; // 0x43(0x01)
int32_t movementCurrentSlideIdx; // 0x44(0x04)
int32_t movementNumCustomDodges; // 0x48(0x04)
float movementCurrentSlideSpeed; // 0x4c(0x04)
float movementCurrentSlideTimer; // 0x50(0x04)
};
// ScriptStruct Scavenger.S_MoveSpeed
// Size: 0x18 (Inherited: 0x00)
struct FS_MoveSpeed {
float m_walkSpeed; // 0x00(0x04)
float m_sprintSpeed; // 0x04(0x04)
float m_crouchedSpeed; // 0x08(0x04)
float m_walkSpeedADS; // 0x0c(0x04)
float m_sprintSpeedADS; // 0x10(0x04)
float m_crouchedSpeedADS; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_CharacterMovementOverrides
// Size: 0x168 (Inherited: 0x00)
struct FS_CharacterMovementOverrides {
struct UCurveFloat* ClientMaxAcceleration; // 0x00(0x08)
struct UCurveFloat* ClientMaxInAirAcceleration; // 0x08(0x08)
bool OverrideDodge; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct FS_SlideSettings Dodge; // 0x18(0x98)
bool OverrideFlatSlide; // 0xb0(0x01)
char pad_B1[0x7]; // 0xb1(0x07)
struct FS_SlideSettings FlatSlide; // 0xb8(0x98)
bool OverrideCustomDodge; // 0x150(0x01)
char pad_151[0x7]; // 0x151(0x07)
struct TArray<struct FS_SlideSettings> CustomDodge; // 0x158(0x10)
};
// ScriptStruct Scavenger.S_SlideSettings
// Size: 0x98 (Inherited: 0x00)
struct FS_SlideSettings {
float CooldownTime; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct UCurveFloat* SlideCurve; // 0x08(0x08)
struct UCurveFloat* FallingSlideCurve; // 0x10(0x08)
struct UCurveFloat* JumpSlideCurve; // 0x18(0x08)
struct UCurveFloat* PerfectSlideCurve; // 0x20(0x08)
enum class ES_SlideCurveMode SlideCurveMode; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
struct UCurveFloat* SteerCurve; // 0x30(0x08)
struct UCurveFloat* SpeedMultiCurve; // 0x38(0x08)
struct UCurveFloat* PlaybackSpeedMultiplierCurve; // 0x40(0x08)
bool bCrouchDuringSlide; // 0x48(0x01)
bool bAbortIfStuck; // 0x49(0x01)
char pad_4A[0x2]; // 0x4a(0x02)
float TimeFacingSlideDirection; // 0x4c(0x04)
float FaceDirOffset; // 0x50(0x04)
float SlideDirBlendTime; // 0x54(0x04)
bool bLoopingSlide; // 0x58(0x01)
char pad_59[0x3]; // 0x59(0x03)
float LoopStartTime; // 0x5c(0x04)
float LoopStopTime; // 0x60(0x04)
float LoopBreakOutAngle; // 0x64(0x04)
float LoopBreakOutSpeed; // 0x68(0x04)
float LoopBreakOutSpeedFraction; // 0x6c(0x04)
bool bLoopBreakOutWhenEitherAngleOrSpeedFails; // 0x70(0x01)
bool bLoopInAir; // 0x71(0x01)
char pad_72[0x2]; // 0x72(0x02)
float SlideBreakOutSpeed; // 0x74(0x04)
float MinSlideTime; // 0x78(0x04)
float SlideSpeedMultiStartBlendTime; // 0x7c(0x04)
float SlideSpeedMultiEndBlendTime; // 0x80(0x04)
float SlideAccLerpSpeed; // 0x84(0x04)
float SlideBreakLerpSpeed; // 0x88(0x04)
bool bAllowJumpDuringSlide; // 0x8c(0x01)
bool bNoMoveInputAbortSlide; // 0x8d(0x01)
char pad_8E[0x2]; // 0x8e(0x02)
float TimeToSlideAfterAbort; // 0x90(0x04)
char pad_94[0x4]; // 0x94(0x04)
};
// ScriptStruct Scavenger.S_MantleSettings
// Size: 0x40 (Inherited: 0x00)
struct FS_MantleSettings {
float MantleHeight; // 0x00(0x04)
float MaxSpeedForMantling; // 0x04(0x04)
float MinSpeedForMantling; // 0x08(0x04)
float MaxHorizontalDistToLedge; // 0x0c(0x04)
struct UAnimMontage* MontageLedge; // 0x10(0x08)
struct TArray<struct FS_MantleMontage> ConditionalLedgeMontages; // 0x18(0x10)
struct UAnimMontage* MontageFence; // 0x28(0x08)
struct TArray<struct FS_MantleMontage> ConditionalFenceMontages; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_MantleMontage
// Size: 0x20 (Inherited: 0x00)
struct FS_MantleMontage {
struct UAnimMontage* Montage; // 0x00(0x08)
struct TArray<struct FS_MantleMontageCondition> ProbeConditions; // 0x08(0x10)
bool DebugMe; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
};
// ScriptStruct Scavenger.S_MantleMontageCondition
// Size: 0x10 (Inherited: 0x00)
struct FS_MantleMontageCondition {
float ProbeOffset; // 0x00(0x04)
float ProbeDistance; // 0x04(0x04)
float ProbeRadius; // 0x08(0x04)
bool ProbeMissForSucess; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
};
// ScriptStruct Scavenger.S_CharacterWeaponMontageTableRow
// Size: 0x48 (Inherited: 0x08)
struct FS_CharacterWeaponMontageTableRow : FTableRowBase {
enum class ES_WeaponMontageEvent WeaponEvent; // 0x08(0x01)
enum class ES_DerivedCharacterBaseState CharacterState; // 0x09(0x01)
enum class ES_CharacterBodyStance CharacterStance; // 0x0a(0x01)
char pad_B[0x5]; // 0x0b(0x05)
SoftClassProperty CharacterClass; // 0x10(0x28)
struct TArray<struct UAnimMontage*> MontageVariations; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_CheatMenuConfigEntry
// Size: 0x38 (Inherited: 0x00)
struct FS_CheatMenuConfigEntry {
struct FString Path; // 0x00(0x10)
enum class ES_CheatMenuItemType Type; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct FString Command; // 0x18(0x10)
int32_t MinValue; // 0x28(0x04)
int32_t MaxValue; // 0x2c(0x04)
enum class ES_CheatMenuExecuteOn ExecuteOn; // 0x30(0x01)
char pad_31[0x7]; // 0x31(0x07)
};
// ScriptStruct Scavenger.S_CheatMenuHUDConfig
// Size: 0x64 (Inherited: 0x00)
struct FS_CheatMenuHUDConfig {
struct FLinearColor LineColor; // 0x00(0x10)
struct FLinearColor CursorLineColor; // 0x10(0x10)
struct FLinearColor FolderColor; // 0x20(0x10)
struct FLinearColor CursorFolderColor; // 0x30(0x10)
struct FLinearColor FlashColor; // 0x40(0x10)
float FlashTime; // 0x50(0x04)
float DrawXStart; // 0x54(0x04)
float DrawYStart; // 0x58(0x04)
int32_t WindowSize; // 0x5c(0x04)
int32_t PageLineCount; // 0x60(0x04)
};
// ScriptStruct Scavenger.S_CheatMenuHUDLayout
// Size: 0x50 (Inherited: 0x00)
struct FS_CheatMenuHUDLayout {
char pad_0[0x50]; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_CheatMenuHUDLayoutItem
// Size: 0x48 (Inherited: 0x00)
struct FS_CheatMenuHUDLayoutItem {
char pad_0[0x48]; // 0x00(0x48)
};
// ScriptStruct Scavenger.S_CheatMenuHUDItem
// Size: 0x08 (Inherited: 0x00)
struct FS_CheatMenuHUDItem {
char pad_0[0x8]; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_CheatMenuHUDItem_Favorite
// Size: 0x20 (Inherited: 0x08)
struct FS_CheatMenuHUDItem_Favorite : FS_CheatMenuHUDItem {
char pad_8[0x18]; // 0x08(0x18)
};
// ScriptStruct Scavenger.S_CheatMenuHUDItem_CVarIntRange
// Size: 0x30 (Inherited: 0x08)
struct FS_CheatMenuHUDItem_CVarIntRange : FS_CheatMenuHUDItem {
char pad_8[0x28]; // 0x08(0x28)
};
// ScriptStruct Scavenger.S_CheatMenuHUDItem_CVarToggle
// Size: 0x28 (Inherited: 0x08)
struct FS_CheatMenuHUDItem_CVarToggle : FS_CheatMenuHUDItem {
char pad_8[0x20]; // 0x08(0x20)
};
// ScriptStruct Scavenger.S_CheatMenuHUDItem_ConsoleCommand
// Size: 0x20 (Inherited: 0x08)
struct FS_CheatMenuHUDItem_ConsoleCommand : FS_CheatMenuHUDItem {
char pad_8[0x18]; // 0x08(0x18)
};
// ScriptStruct Scavenger.S_CheatMenuHUDState
// Size: 0x78 (Inherited: 0x00)
struct FS_CheatMenuHUDState {
struct FString CursorLocation; // 0x00(0x10)
int32_t WindowStartLine; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TSet<struct FString> ExpandedFolders; // 0x18(0x50)
struct TArray<struct FString> Favorites; // 0x68(0x10)
};
// ScriptStruct Scavenger.S_CineCamSnapshot
// Size: 0x38 (Inherited: 0x00)
struct FS_CineCamSnapshot {
struct FString Name; // 0x00(0x10)
struct FVector SnapLoc; // 0x10(0x0c)
struct FRotator SnapRot; // 0x1c(0x0c)
float FocalLength; // 0x28(0x04)
float FocusDistance; // 0x2c(0x04)
float Aperture; // 0x30(0x04)
char pad_34[0x4]; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_CineCamConfigToggleSetting
// Size: 0x10 (Inherited: 0x00)
struct FS_CineCamConfigToggleSetting {
struct FString Name; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_CineCamConfigScalarSetting
// Size: 0x20 (Inherited: 0x00)
struct FS_CineCamConfigScalarSetting {
struct FString Name; // 0x00(0x10)
float InitVal; // 0x10(0x04)
float Min; // 0x14(0x04)
float Max; // 0x18(0x04)
float ChangeRate; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_ClientEvent
// Size: 0x28 (Inherited: 0x08)
struct FS_ClientEvent : FTableRowBase {
enum class ES_ClientEventType Type; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FText MessageWithFormatting; // 0x10(0x18)
};
// ScriptStruct Scavenger.S_ClientEventParameters
// Size: 0x10 (Inherited: 0x00)
struct FS_ClientEventParameters {
struct TArray<struct FS_ClientEventParameter> Parameters; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ClientEventParameter
// Size: 0x28 (Inherited: 0x00)
struct FS_ClientEventParameter {
enum class ES_ClientEventParameterType ParameterType; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float FloatValue; // 0x04(0x04)
int32_t Int32Value; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
struct FString StringValue; // 0x10(0x10)
struct TWeakObjectPtr<struct UObject> ObjectValue; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_CommandContainer
// Size: 0x1a4 (Inherited: 0x00)
struct FS_CommandContainer {
uint32_t Timeline[0x8]; // 0x00(0x20)
struct FS_CommandEntry Entries[0x8]; // 0x20(0x180)
char pad_1A0[0x4]; // 0x1a0(0x04)
};
// ScriptStruct Scavenger.S_Command
// Size: 0x24 (Inherited: 0x00)
struct FS_Command {
float ServerTimestamp; // 0x00(0x04)
struct FS_CommandHandle Handle; // 0x04(0x04)
char pad_8[0x1]; // 0x08(0x01)
enum class ES_CommandSpecificType Type; // 0x09(0x01)
char pad_A[0x1a]; // 0x0a(0x1a)
};
// ScriptStruct Scavenger.S_CommandHandle
// Size: 0x04 (Inherited: 0x00)
struct FS_CommandHandle {
int32_t m_ID; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_CommandEntry
// Size: 0x30 (Inherited: 0x24)
struct FS_CommandEntry : FS_Command {
char pad_24[0x4]; // 0x24(0x04)
uint32_t ServerReplicationKey; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_CommandBase
// Size: 0x10 (Inherited: 0x00)
struct FS_CommandBase {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_CommandOpCommand
// Size: 0x18 (Inherited: 0x10)
struct FS_CommandOpCommand : FS_CommandBase {
char pad_10[0x8]; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_CosmeticBlueprintMetadata
// Size: 0x58 (Inherited: 0x58)
struct FS_CosmeticBlueprintMetadata : FS_DisplayableItemMetadata {
};
// ScriptStruct Scavenger.S_SalvageItemMetadata
// Size: 0x98 (Inherited: 0x60)
struct FS_SalvageItemMetadata : FS_DisplayableItemWithRarityMetadata {
struct TArray<struct FS_SalvageItemDropTable> Tables; // 0x60(0x10)
struct TSoftObjectPtr<struct UStaticMesh> Mesh; // 0x70(0x28)
};
// ScriptStruct Scavenger.S_SalvageItemDropTable
// Size: 0x10 (Inherited: 0x00)
struct FS_SalvageItemDropTable {
struct TArray<struct FS_SalvageItemDropType> Drops; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_SalvageItemDropType
// Size: 0x18 (Inherited: 0x00)
struct FS_SalvageItemDropType {
int32_t Weight; // 0x00(0x04)
int32_t DropCount; // 0x04(0x04)
struct FDataTableRowHandle DropType; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_CosmeticSkinningComponentRecord
// Size: 0x150 (Inherited: 0x00)
struct FS_CosmeticSkinningComponentRecord {
struct TArray<struct UMeshComponent*> MeshComponents; // 0x00(0x10)
struct TMap<struct TSoftObjectPtr<struct USkeletalMesh>, struct FS_CosmeticSkinningComponentMeshSpecificOverrides> MeshSpecificOverrides; // 0x10(0x50)
struct FS_CosmeticLoadoutSlot CosmeticLoadout; // 0x60(0x28)
struct TArray<struct UMeshComponent*> MeshComponentsWithSkinId; // 0x88(0x10)
struct TArray<struct UMeshComponent*> MeshComponentsPendingSkinId; // 0x98(0x10)
char pad_A8[0xa8]; // 0xa8(0xa8)
};
// ScriptStruct Scavenger.S_CosmeticSkinningComponentMeshSpecificOverrides
// Size: 0x50 (Inherited: 0x00)
struct FS_CosmeticSkinningComponentMeshSpecificOverrides {
struct TMap<struct FName, struct TSoftObjectPtr<struct UTexture2D>> ParameterNameToTextureParameterValue; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_CosmeticSetMetadata
// Size: 0x70 (Inherited: 0x60)
struct FS_CosmeticSetMetadata : FS_DisplayableItemWithRarityMetadata {
struct TArray<struct FDataTableRowHandle> AvailableCosmetics; // 0x60(0x10)
};
// ScriptStruct Scavenger.S_CustomizationStagingObject
// Size: 0x2d0 (Inherited: 0x00)
struct FS_CustomizationStagingObject {
enum class ES_CosmeticType CosmeticType; // 0x00(0x01)
enum class ES_CosmeticLoadoutSlotType CosmeticLoadoutSlotType; // 0x01(0x01)
char pad_2[0x6]; // 0x02(0x06)
struct FS_CosmeticItemMetadata CosmeticItemMetadata; // 0x08(0x1c8)
int32_t SubmaterialSlotIndex; // 0x1d0(0x04)
char pad_1D4[0x4]; // 0x1d4(0x04)
struct FS_CosmeticItemSubMaterialMetadata SubMaterialMetadata; // 0x1d8(0xf8)
};
// ScriptStruct Scavenger.S_CosmeticItemSubMaterialMetadata
// Size: 0xf8 (Inherited: 0x60)
struct FS_CosmeticItemSubMaterialMetadata : FS_DisplayableItemWithRarityMetadata {
struct FLinearColor Color; // 0x60(0x10)
struct TSoftObjectPtr<struct UTexture2D> DiffuseTexture; // 0x70(0x28)
struct TSoftObjectPtr<struct UTexture2D> PackedNormalMap; // 0x98(0x28)
float Roughness; // 0xc0(0x04)
float Metallic; // 0xc4(0x04)
float Tiling; // 0xc8(0x04)
char pad_CC[0x4]; // 0xcc(0x04)
struct TSoftObjectPtr<struct UMaterialInstance> SourceMaterialInstance; // 0xd0(0x28)
};
// ScriptStruct Scavenger.S_CosmeticItemTinkerPackMetadata
// Size: 0xb8 (Inherited: 0x60)
struct FS_CosmeticItemTinkerPackMetadata : FS_DisplayableItemWithRarityMetadata {
struct TMap<struct FName, struct FName> SubMaterialSlotToSubMaterialId; // 0x60(0x50)
bool Development; // 0xb0(0x01)
char pad_B1[0x7]; // 0xb1(0x07)
};
// ScriptStruct Scavenger.S_CosmeticLoadoutForReplication
// Size: 0x10 (Inherited: 0x00)
struct FS_CosmeticLoadoutForReplication {
struct TArray<struct FS_CosmeticLoadoutSelectionForReplication> Selections; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_CosmeticLoadoutSelectionForReplication
// Size: 0x18 (Inherited: 0x00)
struct FS_CosmeticLoadoutSelectionForReplication {
enum class ES_CosmeticLoadoutSlotType SlotType; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
uint32_t OnlineItemMetadataReplicationKey; // 0x04(0x04)
struct TArray<uint32_t> SubMaterialSelectionReplicationKeys; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ReplicatedCraftingEvent
// Size: 0x10 (Inherited: 0x00)
struct FS_ReplicatedCraftingEvent {
enum class ES_CraftingEvent CraftingEvent; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
uint32_t ReplicationKey; // 0x04(0x04)
float ServerTimestamp; // 0x08(0x04)
uint32_t ID; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_CraftingRecipeData
// Size: 0x10 (Inherited: 0x00)
struct FS_CraftingRecipeData {
struct US_RecipeData* RecipeData; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_CraftingQueueEntry
// Size: 0x28 (Inherited: 0x00)
struct FS_CraftingQueueEntry {
struct US_RecipeData* RecipeData; // 0x00(0x08)
int32_t RecipeIndex; // 0x08(0x04)
char pad_C[0xc]; // 0x0c(0x0c)
uint32_t ReplicationKey; // 0x18(0x04)
float TimeRemaining; // 0x1c(0x04)
float TimeTotal; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_PointDamageMulticast
// Size: 0x108 (Inherited: 0x00)
struct FS_PointDamageMulticast {
float m_damageAmount; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FS_PointDamageEvent m_damageEvent; // 0x08(0xe8)
struct APawn* m_instigatorPawn; // 0xf0(0x08)
struct AActor* m_causeActor; // 0xf8(0x08)
enum class ES_TriggerType m_triggerType; // 0x100(0x01)
char pad_101[0x7]; // 0x101(0x07)
};
// ScriptStruct Scavenger.S_DamageParameters
// Size: 0xa8 (Inherited: 0x00)
struct FS_DamageParameters {
uint32_t ReplicationKey; // 0x00(0x04)
char pad_4[0xa4]; // 0x04(0xa4)
};
// ScriptStruct Scavenger.S_TeamBelongingDamageMultipliers
// Size: 0x2c (Inherited: 0x00)
struct FS_TeamBelongingDamageMultipliers {
float PlayerVsSelfMultiplier; // 0x00(0x04)
float PlayerVsPlayerSameTeamMultiplier; // 0x04(0x04)
float PlayerVsPlayerDifferentTeamMultiplier; // 0x08(0x04)
float PlayerVsAIMultiplier; // 0x0c(0x04)
float AIVsPlayerMultiplier; // 0x10(0x04)
float AIVsAISameTeamMultiplier; // 0x14(0x04)
float AIVsAISameTeamGrenadeMultiplier; // 0x18(0x04)
float AIVsAIDifferentTeamMultiplier; // 0x1c(0x04)
float AIVsBotTeamMultiplier; // 0x20(0x04)
float BotVsAITeamMultiplier; // 0x24(0x04)
float BotVsPlayerDifferentTeamMultiplier; // 0x28(0x04)
};
// ScriptStruct Scavenger.S_DataTableReplicationKeyMap
// Size: 0xa0 (Inherited: 0x00)
struct FS_DataTableReplicationKeyMap {
char pad_0[0xa0]; // 0x00(0xa0)
};
// ScriptStruct Scavenger.S_DefaultWeaponMontageTableRow
// Size: 0x20 (Inherited: 0x08)
struct FS_DefaultWeaponMontageTableRow : FTableRowBase {
enum class ES_WeaponClass WeaponClass; // 0x08(0x01)
enum class ES_WeaponMontageEvent WeaponEvent; // 0x09(0x01)
enum class ES_DerivedCharacterBaseState CharacterState; // 0x0a(0x01)
enum class ES_CharacterBodyStance CharacterStance; // 0x0b(0x01)
char pad_C[0x4]; // 0x0c(0x04)
struct TArray<struct UAnimMontage*> MontageVariations; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_DialogueEntryRow
// Size: 0x78 (Inherited: 0x08)
struct FS_DialogueEntryRow : FTableRowBase {
struct FS_DialogueVoiceValue DialogueVoice; // 0x08(0x08)
struct FS_DialogueEventValue DialogueEvent; // 0x10(0x08)
struct FString WwiseEventName; // 0x18(0x10)
struct FS_DialogueEntryContext Context; // 0x28(0x50)
};
// ScriptStruct Scavenger.S_DialogueEntryContext
// Size: 0x50 (Inherited: 0x00)
struct FS_DialogueEntryContext {
struct TSet<struct FS_DialogueContextValue> ContextSet; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_DialogueValueBase
// Size: 0x08 (Inherited: 0x00)
struct FS_DialogueValueBase {
struct FName Value; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_DialogueContextValue
// Size: 0x08 (Inherited: 0x08)
struct FS_DialogueContextValue : FS_DialogueValueBase {
};
// ScriptStruct Scavenger.S_DialogueEventValue
// Size: 0x08 (Inherited: 0x08)
struct FS_DialogueEventValue : FS_DialogueValueBase {
};
// ScriptStruct Scavenger.S_DialogueVoiceValue
// Size: 0x08 (Inherited: 0x08)
struct FS_DialogueVoiceValue : FS_DialogueValueBase {
};
// ScriptStruct Scavenger.S_DialogueContext
// Size: 0x50 (Inherited: 0x00)
struct FS_DialogueContext {
struct TSet<struct FS_DialogueContextValue> ContextSet; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_ComponentOverlapData
// Size: 0x50 (Inherited: 0x00)
struct FS_ComponentOverlapData {
char pad_0[0x50]; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_ComponentPair
// Size: 0x10 (Inherited: 0x00)
struct FS_ComponentPair {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_RayCastSettings
// Size: 0x0c (Inherited: 0x00)
struct FS_RayCastSettings {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_DynamicallySpawnedClass
// Size: 0x18 (Inherited: 0x00)
struct FS_DynamicallySpawnedClass {
struct AS_AICharacter* AICharacterClass; // 0x00(0x08)
struct UBehaviorTree* BehaviourTree; // 0x08(0x08)
float normalizedChance; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_EquipmentStateComponent
// Size: 0x228 (Inherited: 0x00)
struct FS_EquipmentStateComponent {
struct FS_EquipmentSlotState Slots[0x11]; // 0x00(0x220)
char pad_220[0x8]; // 0x220(0x08)
};
// ScriptStruct Scavenger.S_EquipmentSlotState
// Size: 0x20 (Inherited: 0x00)
struct FS_EquipmentSlotState {
struct US_ItemData* EquipmentData; // 0x00(0x08)
struct TArray<int32_t> EquippedEffectHandles; // 0x08(0x10)
struct AActor* EquippedActor; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_EventDelegateDummyBugWorkaround
// Size: 0x01 (Inherited: 0x00)
struct FS_EventDelegateDummyBugWorkaround {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_AITeamExperienceData
// Size: 0x18 (Inherited: 0x00)
struct FS_AITeamExperienceData {
float ExperienceOnKill[0x5]; // 0x00(0x14)
float EliteExperienceMultiplier; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_FeatureFlagConfigEntry
// Size: 0x0c (Inherited: 0x00)
struct FS_FeatureFlagConfigEntry {
struct FName Name; // 0x00(0x08)
int32_t Value; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_FlinchInterpolator
// Size: 0xc8 (Inherited: 0x00)
struct FS_FlinchInterpolator {
struct FS_FlinchRotationalInterpolator Rotation; // 0x00(0x60)
struct FS_FlinchTranslationalInterpolator Translation; // 0x60(0x60)
char pad_C0[0x8]; // 0xc0(0x08)
};
// ScriptStruct Scavenger.S_FlinchTranslationalInterpolator
// Size: 0x60 (Inherited: 0x00)
struct FS_FlinchTranslationalInterpolator {
struct FS_FlinchTranslationAxisInterpolator XAxis; // 0x00(0x20)
struct FS_FlinchTranslationAxisInterpolator YAxis; // 0x20(0x20)
struct FS_FlinchTranslationAxisInterpolator ZAxis; // 0x40(0x20)
};
// ScriptStruct Scavenger.S_FlinchTranslationAxisInterpolator
// Size: 0x20 (Inherited: 0x00)
struct FS_FlinchTranslationAxisInterpolator {
struct UCurveFloat* TimeIntensityCurve; // 0x00(0x08)
float Scale; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
float BaseTranslationUnits; // 0x10(0x04)
struct FFloatInterval MaxTranslationInterval; // 0x14(0x08)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_FlinchRotationalInterpolator
// Size: 0x60 (Inherited: 0x00)
struct FS_FlinchRotationalInterpolator {
struct FS_FlinchRotationAxisInterpolator Yaw; // 0x00(0x20)
struct FS_FlinchRotationAxisInterpolator Pitch; // 0x20(0x20)
struct FS_FlinchRotationAxisInterpolator Roll; // 0x40(0x20)
};
// ScriptStruct Scavenger.S_FlinchRotationAxisInterpolator
// Size: 0x20 (Inherited: 0x00)
struct FS_FlinchRotationAxisInterpolator {
struct UCurveFloat* TimeIntensityCurve; // 0x00(0x08)
float Scale; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
float BaseRotationDegrees; // 0x10(0x04)
struct FFloatInterval MaxRotationInterval; // 0x14(0x08)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_FoleyTaggedAudioEvent
// Size: 0x18 (Inherited: 0x00)
struct FS_FoleyTaggedAudioEvent {
struct UAkAudioEvent* Event; // 0x00(0x08)
enum class ES_FoleyEvent FoleyType; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FName CustomName; // 0x0c(0x08)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_MaterialTaggedAudioEvent
// Size: 0x20 (Inherited: 0x00)
struct FS_MaterialTaggedAudioEvent {
struct UAkAudioEvent* Event; // 0x00(0x08)
enum class EPhysicalSurface SurfaceType; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FString WwiseSurfaceSwitch; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_FrontEndCameraTarget
// Size: 0x68 (Inherited: 0x00)
struct FS_FrontEndCameraTarget {
struct AActor* Target; // 0x00(0x08)
struct FDataTableRowHandle ConfigHandle; // 0x08(0x10)
struct TMap<struct FName, struct FS_FrontEndCameraOverride> TargetOverrides; // 0x18(0x50)
};
// ScriptStruct Scavenger.S_FrontEndCameraOverride
// Size: 0x18 (Inherited: 0x00)
struct FS_FrontEndCameraOverride {
struct AActor* Target; // 0x00(0x08)
struct FDataTableRowHandle ConfigHandle; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_FrontEndCameraConfig
// Size: 0x30 (Inherited: 0x08)
struct FS_FrontEndCameraConfig : FTableRowBase {
bool bShouldBlend; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
float BlendTime; // 0x0c(0x04)
enum class EViewTargetBlendFunction Blend; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
float BlendExponent; // 0x14(0x04)
bool bLockOutgoing; // 0x18(0x01)
bool bOverrideCharacterRotator; // 0x19(0x01)
char pad_1A[0x2]; // 0x1a(0x02)
struct FRotator CharacterRotatorOverride; // 0x1c(0x0c)
bool TeammateLightsEnabled; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.S_ItemViewerObject
// Size: 0x60 (Inherited: 0x00)
struct FS_ItemViewerObject {
struct FS_ItemState ItemState; // 0x00(0x40)
struct FS_ItemViewerSettings ViewerSettings; // 0x40(0x1c)
char pad_5C[0x4]; // 0x5c(0x04)
};
// ScriptStruct Scavenger.S_FTUEStageData
// Size: 0x30 (Inherited: 0x08)
struct FS_FTUEStageData : FTableRowBase {
SoftClassProperty FTUEStage; // 0x08(0x28)
};
// ScriptStruct Scavenger.S_FTUEOverlayData
// Size: 0xa8 (Inherited: 0x00)
struct FS_FTUEOverlayData {
bool OverlayMaskVisible; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector2D MaskPosition; // 0x04(0x08)
struct FVector2D MaskSize; // 0x0c(0x08)
struct FVector2D ViewportSize; // 0x14(0x08)
char pad_1C[0x4]; // 0x1c(0x04)
struct FSlateBrush MaskBrush; // 0x20(0x88)
};
// ScriptStruct Scavenger.S_ResponseCurveInfo
// Size: 0x20 (Inherited: 0x00)
struct FS_ResponseCurveInfo {
struct FText DisplayName; // 0x00(0x18)
struct UCurveFloat* ResponseCurve; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_GameInputTable
// Size: 0x50 (Inherited: 0x08)
struct FS_GameInputTable : FTableRowBase {
enum class ES_GameInputActionType GameInputAction; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FText DisplayName; // 0x10(0x18)
struct TArray<struct FName> Actions; // 0x28(0x10)
bool bKeyboardBind; // 0x38(0x01)
bool bGamepadBind; // 0x39(0x01)
bool bShowOnKeyboardSettings; // 0x3a(0x01)
enum class ES_PlayerInputContext KeybindContext; // 0x3b(0x01)
bool bIsAxisMapping; // 0x3c(0x01)
char pad_3D[0x3]; // 0x3d(0x03)
float AxisMappingValue; // 0x40(0x04)
struct FName FeatureFlag; // 0x44(0x08)
char pad_4C[0x4]; // 0x4c(0x04)
};
// ScriptStruct Scavenger.S_PlatformCultureCodes
// Size: 0x48 (Inherited: 0x08)
struct FS_PlatformCultureCodes : FTableRowBase {
struct FString SteamId; // 0x08(0x10)
struct FString EgsId; // 0x18(0x10)
struct FString PsnId; // 0x28(0x10)
struct FString XblId; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_DamageOverTimeConfigurationData
// Size: 0x50 (Inherited: 0x08)
struct FS_DamageOverTimeConfigurationData : FTableRowBase {
enum class ES_DamageOverTimeType DamageOverTimeType; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
float DamagePerTick; // 0x0c(0x04)
struct UCurveFloat* DamagePerTickCurve; // 0x10(0x08)
struct US_DamageTypeBase* DamageTypeClass; // 0x18(0x08)
SoftClassProperty GameplayAbility; // 0x20(0x28)
float MaximumPendingDamage; // 0x48(0x04)
float TickIntervalInSeconds; // 0x4c(0x04)
};
// ScriptStruct Scavenger.S_SpawnLocationData
// Size: 0x18 (Inherited: 0x08)
struct FS_SpawnLocationData : FTableRowBase {
struct FVector Location; // 0x08(0x0c)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_PerLevelPlayerData
// Size: 0x04 (Inherited: 0x00)
struct FS_PerLevelPlayerData {
int32_t ScrapInventoryCapacity; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_ArmorGlobals
// Size: 0x10 (Inherited: 0x00)
struct FS_ArmorGlobals {
struct TArray<float> DamageResistance; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_WeaponGlobals
// Size: 0xa8 (Inherited: 0x00)
struct FS_WeaponGlobals {
float SoftRecoverAngle; // 0x00(0x04)
float softRecoverVelocityThreshold; // 0x04(0x04)
float SoftRecoverExponent; // 0x08(0x04)
float BounceElasticity; // 0x0c(0x04)
float RecenterDivisor; // 0x10(0x04)
float FightRecoilResetThreshold; // 0x14(0x04)
float FollowRecoilResetThreshold; // 0x18(0x04)
float AimKeepRecoilThreshold; // 0x1c(0x04)
struct FS_WeaponAimAssistValues DefaultAimAssistValues; // 0x20(0x2c)
struct FS_AimAssistGlobalSettings GlobalAimAssistSettings; // 0x4c(0x5c)
};
// ScriptStruct Scavenger.S_SoftPingSkeletonSetup
// Size: 0x120 (Inherited: 0x00)
struct FS_SoftPingSkeletonSetup {
int32_t AffectedBoneRange; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct TArray<struct FName> RequiredPinnedBones; // 0x08(0x10)
struct UCurveFloat* BlendWeightTrack; // 0x18(0x08)
float ImpulseMagnitudeAI; // 0x20(0x04)
float ImpulseMagnitudePlayer; // 0x24(0x04)
struct UCurveFloat* BoneRangeImpulseBlend; // 0x28(0x08)
struct TSet<struct FName> ForceAppliedBones; // 0x30(0x50)
struct TSet<struct FName> FullPhysicsBlendedBones; // 0x80(0x50)
struct TSet<struct FName> NoPhysicsBlendedBones; // 0xd0(0x50)
};
// ScriptStruct Scavenger.S_CollisionPair
// Size: 0x10 (Inherited: 0x00)
struct FS_CollisionPair {
struct AActor* m_lowActor; // 0x00(0x08)
struct AActor* m_highActor; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_AttributeContext
// Size: 0x04 (Inherited: 0x00)
struct FS_AttributeContext {
enum class ES_StatChangeCauseType ChangeCauseType; // 0x00(0x01)
enum class ES_AttributeContextADS ADS; // 0x01(0x01)
enum class ES_CameraSettings CameraSettings; // 0x02(0x01)
enum class ES_TriggerType triggerType; // 0x03(0x01)
};
// ScriptStruct Scavenger.S_BotNameTableRow
// Size: 0x18 (Inherited: 0x08)
struct FS_BotNameTableRow : FTableRowBase {
struct FString Name; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_StatStatesCountedAsLiving
// Size: 0x04 (Inherited: 0x00)
struct FS_StatStatesCountedAsLiving {
bool DownedIsLiving; // 0x00(0x01)
bool CocoonedIsLiving; // 0x01(0x01)
bool ExtractingIsLiving; // 0x02(0x01)
bool ExtractedIsLiving; // 0x03(0x01)
};
// ScriptStruct Scavenger.S_ReviveExecuteInteractableData
// Size: 0x120 (Inherited: 0x00)
struct FS_ReviveExecuteInteractableData {
struct FS_InteractableData ReviveData; // 0x00(0x90)
struct FS_InteractableData ExecuteData; // 0x90(0x90)
};
// ScriptStruct Scavenger.S_InteractableData
// Size: 0x90 (Inherited: 0x00)
struct FS_InteractableData {
char bIsTimedInteraction : 1; // 0x00(0x01)
char bPartialActivationIsOkay : 1; // 0x00(0x01)
char bRequireMinimumTimeForPartialActivation : 1; // 0x00(0x01)
char bStopDistanceChecksOnceStarted : 1; // 0x00(0x01)
char bCalculateInteractionPercentageBetweenMinimumAndMaximumTimes : 1; // 0x00(0x01)
char bConsumesRequiredItems : 1; // 0x00(0x01)
char bUseReticuleAimTestForInteraction : 1; // 0x00(0x01)
char bFullSphereInteraction : 1; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t InteractionPriority; // 0x04(0x04)
float MinimumInteractionTimeRequired; // 0x08(0x04)
float MaximumInteractionTimeAllowed; // 0x0c(0x04)
enum class ES_InteractIcon IconType; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct UTexture2D* Icon; // 0x18(0x08)
struct FName InitialInteractTextId; // 0x20(0x08)
struct FName InProgressTextId; // 0x28(0x08)
struct US_ItemData* RequiredItemData; // 0x30(0x08)
int32_t RequiredItemCount; // 0x38(0x04)
struct FDelegate DoInteractDelegate; // 0x3c(0x10)
char pad_4C[0x4]; // 0x4c(0x04)
struct TArray<struct UPrimitiveComponent*> ComponentsToHighlight; // 0x50(0x10)
char pad_60[0x30]; // 0x60(0x30)
};
// ScriptStruct Scavenger.S_AISpawnPhaseTable
// Size: 0x18 (Inherited: 0x00)
struct FS_AISpawnPhaseTable {
char pad_0[0x10]; // 0x00(0x10)
int32_t m_currentPhaseIdx; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_AISpawnRow
// Size: 0x0c (Inherited: 0x00)
struct FS_AISpawnRow {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_AISpawnPhaseDescriptorTableRow
// Size: 0x10 (Inherited: 0x08)
struct FS_AISpawnPhaseDescriptorTableRow : FTableRowBase {
enum class ES_AISpawnPhase SpawnPhase; // 0x08(0x01)
bool UseDuration; // 0x09(0x01)
char pad_A[0x2]; // 0x0a(0x02)
float PhaseDurationInMinutes; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_OnlineGameModePlayerSessionData
// Size: 0x38 (Inherited: 0x00)
struct FS_OnlineGameModePlayerSessionData {
struct FString ClientTelemetrySessionId; // 0x00(0x10)
struct FString PlayerType; // 0x10(0x10)
int32_t ClientMatchIndex; // 0x20(0x04)
int32_t DraftOrder; // 0x24(0x04)
struct FString PartyId; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_SquadInfo
// Size: 0x04 (Inherited: 0x00)
struct FS_SquadInfo {
int32_t MaxSquadCount; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_PawnAndPlayerControllerWeakObjectWrapper
// Size: 0x10 (Inherited: 0x00)
struct FS_PawnAndPlayerControllerWeakObjectWrapper {
struct TWeakObjectPtr<struct APawn> Pawn; // 0x00(0x08)
struct TWeakObjectPtr<struct APlayerController> PlayerController; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_GameModeEvent
// Size: 0x24 (Inherited: 0x00)
struct FS_GameModeEvent {
enum class ES_GameModeEvent EventType; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FName PlayerId; // 0x04(0x08)
int32_t TeamIndex; // 0x0c(0x04)
float ServerTimestamp; // 0x10(0x04)
float FloatData; // 0x14(0x04)
int32_t IntData; // 0x18(0x04)
struct FName NameData; // 0x1c(0x08)
};
// ScriptStruct Scavenger.S_LeaderboardRankingRequirement
// Size: 0x20 (Inherited: 0x00)
struct FS_LeaderboardRankingRequirement {
struct TArray<enum class ES_LeaderboardRankingFactor> RequiredToBeScored_AcceptAny; // 0x00(0x10)
struct TArray<enum class ES_LeaderboardRankingFactor> RequiredToBeScored_RequireAll; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_LeaderboardRankingRule
// Size: 0x02 (Inherited: 0x00)
struct FS_LeaderboardRankingRule {
enum class ES_LeaderboardRankingFactor Factor; // 0x00(0x01)
enum class ES_LeaderboardRankingFactorRule Rule; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_GameModeMetadata
// Size: 0xc8 (Inherited: 0x58)
struct FS_GameModeMetadata : FS_DisplayableItemMetadata {
enum class ES_GameMode GameMode; // 0x58(0x01)
char pad_59[0x3]; // 0x59(0x03)
struct FName MapName; // 0x5c(0x08)
bool ShowCountdownTimer; // 0x64(0x01)
char pad_65[0x3]; // 0x65(0x03)
struct FDataTableRowHandle LocalizedBriefHandle; // 0x68(0x10)
struct TSoftObjectPtr<struct UTexture2D> BackgroundSmall; // 0x78(0x28)
struct TSoftObjectPtr<struct UTexture2D> BackgroundLarge; // 0xa0(0x28)
};
// ScriptStruct Scavenger.S_GamepadMultiButtonToGameActionMapping
// Size: 0x18 (Inherited: 0x00)
struct FS_GamepadMultiButtonToGameActionMapping {
struct TArray<struct FKey> Buttons; // 0x00(0x10)
enum class ES_GameInputActionType action; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
int32_t RequiredButtonCount; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_GamepadButtonToGameActionMapping
// Size: 0x10 (Inherited: 0x00)
struct FS_GamepadButtonToGameActionMapping {
enum class ES_GameInputActionType PressAction; // 0x00(0x01)
enum class ES_GameInputActionType HoldAction; // 0x01(0x01)
bool AllowPressActionInHoldWindow; // 0x02(0x01)
char pad_3[0x1]; // 0x03(0x01)
float HoldTimeOverride; // 0x04(0x04)
enum class ES_GameInputActionType DoublePressAction; // 0x08(0x01)
bool AllowPressActionInDoublePressFirstTap; // 0x09(0x01)
char pad_A[0x2]; // 0x0a(0x02)
float DoublePressTimeOverride; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_GameplayEffectVolumeState
// Size: 0x10 (Inherited: 0x00)
struct FS_GameplayEffectVolumeState {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_GameplayEffectVolumeParameters
// Size: 0x18 (Inherited: 0x00)
struct FS_GameplayEffectVolumeParameters {
char bApplyToFriendlyActors : 1; // 0x00(0x01)
char bApplyToNeutralActors : 1; // 0x00(0x01)
char bApplyToHostileActors : 1; // 0x00(0x01)
char bApplyToAICharacters : 1; // 0x00(0x01)
char bApplyToPlayerCharacters : 1; // 0x00(0x01)
char pad_0_5 : 3; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct TArray<struct FS_GameplayEffectClassAndSettings> GameplayEffectsToApply; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_GameplayEffectClassAndSettings
// Size: 0x10 (Inherited: 0x00)
struct FS_GameplayEffectClassAndSettings {
struct UGameplayEffect* GameplayEffectClass; // 0x00(0x08)
float Level; // 0x08(0x04)
char bApplyOnExitInsteadOfEnter : 1; // 0x0c(0x01)
char bRemoveOnExit : 1; // 0x0c(0x01)
char pad_C_2 : 6; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
};
// ScriptStruct Scavenger.S_GameScoreSnapshot
// Size: 0x10 (Inherited: 0x00)
struct FS_GameScoreSnapshot {
struct TArray<struct FS_TeamScoreSnapshot> TeamScores; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_TeamScoreSnapshot
// Size: 0x20 (Inherited: 0x00)
struct FS_TeamScoreSnapshot {
int8_t TeamIndex; // 0x00(0x01)
char Placement; // 0x01(0x01)
uint16_t HeldDataPoints; // 0x02(0x02)
uint16_t BankedDataPoints; // 0x04(0x02)
uint16_t ExtractedDataPoints; // 0x06(0x02)
float TeamEliminationTime; // 0x08(0x04)
bool TeamExfiled; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
struct TArray<struct FS_PlayerScoreSnapshot> PlayerScoreSnapshots; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_PlayerScoreSnapshot
// Size: 0x10 (Inherited: 0x00)
struct FS_PlayerScoreSnapshot {
int32_t PlayerIndex; // 0x00(0x04)
bool IsDisconnected; // 0x04(0x01)
bool IsAlive; // 0x05(0x01)
enum class ES_StatsState StatsState; // 0x06(0x01)
bool Extracted; // 0x07(0x01)
uint16_t HeldDataPoints; // 0x08(0x02)
uint16_t TotalBankedDataPoints; // 0x0a(0x02)
uint16_t ExtractedDataPoints; // 0x0c(0x02)
uint16_t LostDataPointsAfterExtraction; // 0x0e(0x02)
};
// ScriptStruct Scavenger.S_TeamGameStaticState
// Size: 0x10 (Inherited: 0x00)
struct FS_TeamGameStaticState {
struct TArray<struct FS_PlayerGameStaticState> PlayerStates; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_PlayerGameStaticState
// Size: 0x40 (Inherited: 0x00)
struct FS_PlayerGameStaticState {
struct FString DisplayName; // 0x00(0x10)
char PlayerIndex; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct FString PlayerId; // 0x18(0x10)
enum class ES_OnlinePlatformType Platform; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
struct FString PlatformId; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_TeamGameState
// Size: 0xa8 (Inherited: 0x00)
struct FS_TeamGameState {
int32_t ShardsBanked; // 0x00(0x04)
int32_t ShardsHeld; // 0x04(0x04)
int32_t ShardsExtracted; // 0x08(0x04)
int32_t ExplorersExtracted; // 0x0c(0x04)
int32_t ObjectivesCompleted; // 0x10(0x04)
int32_t TeamPlacement; // 0x14(0x04)
int32_t TotalTeamXP; // 0x18(0x04)
int32_t OtherExplorersKilled; // 0x1c(0x04)
int32_t TeammateDeaths; // 0x20(0x04)
float TeamEliminationTimeSeconds; // 0x24(0x04)
int32_t LiveCount; // 0x28(0x04)
bool TeamExfiled; // 0x2c(0x01)
char pad_2D[0x3]; // 0x2d(0x03)
int32_t TeamResurrectionTokensEarned; // 0x30(0x04)
char Flags; // 0x34(0x01)
char pad_35[0x3]; // 0x35(0x03)
struct TArray<struct AS_PlayerStateBase*> PlayerStates; // 0x38(0x10)
struct TSet<struct AS_PlayerController*> PlayerControllers; // 0x48(0x50)
struct TArray<struct FS_TeamPlayerGameState> PlayerGameState; // 0x98(0x10)
};
// ScriptStruct Scavenger.S_TeamPlayerGameState
// Size: 0x10 (Inherited: 0x00)
struct FS_TeamPlayerGameState {
int32_t ShardsBankedTotal; // 0x00(0x04)
int32_t ShardsBankedAtUplink; // 0x04(0x04)
int32_t ShardsExtracted; // 0x08(0x04)
int32_t ShardsLeftOnPlanet; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_TeamDefinition
// Size: 0x38 (Inherited: 0x00)
struct FS_TeamDefinition {
struct FText Name; // 0x00(0x18)
struct FLinearColor PrimaryColor; // 0x18(0x10)
struct FLinearColor SecondaryColor; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ResolutionLock
// Size: 0x28 (Inherited: 0x00)
struct FS_ResolutionLock {
char pad_0[0x28]; // 0x00(0x28)
};
// ScriptStruct Scavenger.S_HarvestedFoliageArray
// Size: 0x120 (Inherited: 0x108)
struct FS_HarvestedFoliageArray : FFastArraySerializer {
struct TArray<struct FS_HarvestedFoliageItem> Items; // 0x108(0x10)
bool pendingProcessAdd; // 0x118(0x01)
char pad_119[0x7]; // 0x119(0x07)
};
// ScriptStruct Scavenger.S_HarvestedFoliageItem
// Size: 0x80 (Inherited: 0x0c)
struct FS_HarvestedFoliageItem : FFastArraySerializerItem {
char pad_C[0x4]; // 0x0c(0x04)
struct ULevel* Level; // 0x10(0x08)
struct FName LevelStreamingPackageName; // 0x18(0x08)
int32_t ComponentIndex; // 0x20(0x04)
bool pendingProcessAdd; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
struct FVector InstanceLocation; // 0x28(0x0c)
char pad_34[0xc]; // 0x34(0x0c)
struct FTransform OriginalInstanceTransform; // 0x40(0x30)
struct AActor* ReplacementActor; // 0x70(0x08)
char pad_78[0x8]; // 0x78(0x08)
};
// ScriptStruct Scavenger.S_HarvestConfiguration
// Size: 0x128 (Inherited: 0x00)
struct FS_HarvestConfiguration {
struct UFoliageType* HarvestableFoliageType; // 0x00(0x08)
struct FText DisplayName; // 0x08(0x18)
struct FS_InteractableData InteractableData; // 0x20(0x90)
struct FS_ItemState HarvestOutput; // 0xb0(0x40)
char SkipCreationOfAutoHarvestedFoliageActor : 1; // 0xf0(0x01)
char pad_F0_1 : 7; // 0xf0(0x01)
char pad_F1[0x7]; // 0xf1(0x07)
struct AActor* HarvestedActorClass; // 0xf8(0x08)
float HarvestedActorZAdjustment; // 0x100(0x04)
char pad_104[0x4]; // 0x104(0x04)
struct AActor* ReplacementActorClass; // 0x108(0x08)
float ReplacementActorZAdjustment; // 0x110(0x04)
char pad_114[0x4]; // 0x114(0x04)
struct UFoliageType* ReplacementFoliageType; // 0x118(0x08)
float ReplacementFoliageZAdjustment; // 0x120(0x04)
float XPBonusAward; // 0x124(0x04)
};
// ScriptStruct Scavenger.S_WeakLevelReferenceWrapper
// Size: 0x08 (Inherited: 0x00)
struct FS_WeakLevelReferenceWrapper {
char pad_0[0x8]; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_FeedbackAudio
// Size: 0x100 (Inherited: 0x00)
struct FS_FeedbackAudio {
struct FS_FeedbackAudioEvents MeleeFeedback; // 0x00(0x40)
struct FS_FeedbackAudioEvents ProjectileFeedback; // 0x40(0x40)
struct FS_FeedbackAudioEvents ExplosionFeedback; // 0x80(0x40)
struct FS_FeedbackAudioEvents FallDamageFeedback; // 0xc0(0x40)
};
// ScriptStruct Scavenger.S_FeedbackAudioEvents
// Size: 0x40 (Inherited: 0x00)
struct FS_FeedbackAudioEvents {
struct UAkAudioEvent* NoArmorHitEvent; // 0x00(0x08)
struct UAkAudioEvent* ArmorHitEvent; // 0x08(0x08)
struct UAkAudioEvent* ArmorBreakEvent; // 0x10(0x08)
struct UAkAudioEvent* ShieldHitEvent; // 0x18(0x08)
struct UAkAudioEvent* ShieldBreakEvent; // 0x20(0x08)
struct UAkAudioEvent* CriticalHitEvent; // 0x28(0x08)
struct UAkAudioEvent* HeadShotEvent; // 0x30(0x08)
struct UAkAudioEvent* KilledEvent; // 0x38(0x08)
};
// ScriptStruct Scavenger.S_3PFeedbackAudio
// Size: 0x140 (Inherited: 0x100)
struct FS_3PFeedbackAudio : FS_FeedbackAudio {
struct FS_FeedbackAudioEvents AcidFeedback; // 0x100(0x40)
};
// ScriptStruct Scavenger.S_HordeWaveDefinition
// Size: 0x10 (Inherited: 0x00)
struct FS_HordeWaveDefinition {
struct TArray<struct FS_HordeSquadDefinition> SquadDefinitions; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_HordeSquadDefinition
// Size: 0x28 (Inherited: 0x00)
struct FS_HordeSquadDefinition {
struct FName SpawnerName; // 0x00(0x08)
struct FString SquadName; // 0x08(0x10)
struct UDataTable* SpawnTable; // 0x18(0x08)
struct AS_AIOverlordActor* OverlordType; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_NotificationQueue
// Size: 0x18 (Inherited: 0x00)
struct FS_NotificationQueue {
char pad_0[0x8]; // 0x00(0x08)
struct TArray<struct FS_NotificationCenterItem> Notifications; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_NotificationCenterItem
// Size: 0x10 (Inherited: 0x00)
struct FS_NotificationCenterItem {
struct US_WidgetNotificationCenterItem* NotificationWidget; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.SRankIcon
// Size: 0x10 (Inherited: 0x08)
struct FSRankIcon : FTableRowBase {
struct UTexture2D* RankIcon; // 0x08(0x08)
};
// ScriptStruct Scavenger.STargetIcon
// Size: 0x18 (Inherited: 0x08)
struct FSTargetIcon : FTableRowBase {
struct FScavengerTeamID TeamId; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct UTexture2D* TeamIcon; // 0x10(0x08)
};
// ScriptStruct Scavenger.ScavengerTeamID
// Size: 0x01 (Inherited: 0x00)
struct FScavengerTeamID {
enum class ES_ScavAITeams ScavengerTeam; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_HudToggleDisplayMethod
// Size: 0x08 (Inherited: 0x00)
struct FS_HudToggleDisplayMethod {
enum class ES_WidgetHideMethod WidgetHideMethod; // 0x00(0x01)
enum class ES_ToggleDisplayMethod ToggleDisplayMethod; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
int32_t SortOrderToHide; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_HudInsertMethod
// Size: 0x10 (Inherited: 0x00)
struct FS_HudInsertMethod {
enum class ES_InsertType InsertType; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct US_UMGHUD* InsertAroundThisHudClass; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_ImpactEffectTemplateTableRow
// Size: 0x150 (Inherited: 0x08)
struct FS_ImpactEffectTemplateTableRow : FTableRowBase {
struct FName Default; // 0x08(0x08)
struct FName Bone; // 0x10(0x08)
struct FName Brick; // 0x18(0x08)
struct FName Cloth; // 0x20(0x08)
struct FName Concrete; // 0x28(0x08)
struct FName Dirt; // 0x30(0x08)
struct FName Drywall; // 0x38(0x08)
struct FName Electronics_Generic; // 0x40(0x08)
struct FName Electronics_Monitor; // 0x48(0x08)
struct FName Flesh_Human; // 0x50(0x08)
struct FName Flesh_Keeper; // 0x58(0x08)
struct FName Flesh_Scourge; // 0x60(0x08)
struct FName Fur; // 0x68(0x08)
struct FName Glass_Breakable; // 0x70(0x08)
struct FName Glass_Unbreakable; // 0x78(0x08)
struct FName Ice; // 0x80(0x08)
struct FName Leather; // 0x88(0x08)
struct FName Metal_Heavy; // 0x90(0x08)
struct FName Metal_Light; // 0x98(0x08)
struct FName Metal_Medium; // 0xa0(0x08)
struct FName Mud; // 0xa8(0x08)
struct FName Paper; // 0xb0(0x08)
struct FName Plaster; // 0xb8(0x08)
struct FName Plastic_Heavy; // 0xc0(0x08)
struct FName Plastic_Light; // 0xc8(0x08)
struct FName Plastic_Medium; // 0xd0(0x08)
struct FName Rock; // 0xd8(0x08)
struct FName Sand; // 0xe0(0x08)
struct FName Snow_Heavy; // 0xe8(0x08)
struct FName Snow_Light; // 0xf0(0x08)
struct FName Snow_Medium; // 0xf8(0x08)
struct FName Water; // 0x100(0x08)
struct FName Wood_Heavy; // 0x108(0x08)
struct FName Wood_Light; // 0x110(0x08)
struct FName Wood_Medium; // 0x118(0x08)
struct FName Projectile; // 0x120(0x08)
struct FName Melee; // 0x128(0x08)
struct FName Flesh_Scourge_Critical; // 0x130(0x08)
struct FName Flesh_Spitter_Stomach; // 0x138(0x08)
struct FName Aegis_Shield_Incoming; // 0x140(0x08)
struct FName Aegis_Shield_Outgoing; // 0x148(0x08)
};
// ScriptStruct Scavenger.S_ImpactEffectTemplate
// Size: 0x40 (Inherited: 0x00)
struct FS_ImpactEffectTemplate {
struct UAkAudioEvent* Event; // 0x00(0x08)
bool particleSystemShouldAttach; // 0x08(0x01)
bool AllowParticleFrustumCulling; // 0x09(0x01)
char pad_A[0x6]; // 0x0a(0x06)
struct UParticleSystem* ParticleSystemTemplate; // 0x10(0x08)
struct UMaterialInterface* DecalMaterialA; // 0x18(0x08)
struct UMaterialInterface* DecalMaterialB; // 0x20(0x08)
float DecalRollRandomOffset; // 0x28(0x04)
struct FVector DecalSize; // 0x2c(0x0c)
float DecalSizeRandomScaleFactor; // 0x38(0x04)
float DecalFadeScreenSize; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_InteractionFeedbackState
// Size: 0x30 (Inherited: 0x00)
struct FS_InteractionFeedbackState {
char bConsumesRequiredItems : 1; // 0x00(0x01)
char bHasCompletedLocally : 1; // 0x00(0x01)
char pad_0_2 : 6; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
uint32_t ReplicationKey; // 0x04(0x04)
int32_t InteractableIndex; // 0x08(0x04)
struct FName InteractTextId; // 0x0c(0x08)
struct FName InProgressTextId; // 0x14(0x08)
float MaximumInteractionTime; // 0x1c(0x04)
struct US_ItemData* RequiredItemData; // 0x20(0x08)
int32_t RequiredItemCount; // 0x28(0x04)
float InteractionTime; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_PotentialInteractionData
// Size: 0x30 (Inherited: 0x00)
struct FS_PotentialInteractionData {
char pad_0[0x30]; // 0x00(0x30)
};
// ScriptStruct Scavenger.S_InteractionPlayerState
// Size: 0xd0 (Inherited: 0x00)
struct FS_InteractionPlayerState {
char pad_0[0x30]; // 0x00(0x30)
struct FS_InteractableData InteractableData; // 0x30(0x90)
char pad_C0[0x10]; // 0xc0(0x10)
};
// ScriptStruct Scavenger.S_InteractableDataWrapper
// Size: 0x98 (Inherited: 0x00)
struct FS_InteractableDataWrapper {
struct FS_InteractableData Data; // 0x00(0x90)
char pad_90[0x8]; // 0x90(0x08)
};
// ScriptStruct Scavenger.S_InteractableTuple
// Size: 0x24 (Inherited: 0x00)
struct FS_InteractableTuple {
char pad_0[0x24]; // 0x00(0x24)
};
// ScriptStruct Scavenger.S_FlashpointSettings
// Size: 0x18 (Inherited: 0x08)
struct FS_FlashpointSettings : FTableRowBase {
float DetectionDistance; // 0x08(0x04)
float PersistTime; // 0x0c(0x04)
float FadeTime; // 0x10(0x04)
bool AllowBlipFromUse; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
};
// ScriptStruct Scavenger.S_ItemMetadata
// Size: 0x320 (Inherited: 0x60)
struct FS_ItemMetadata : FS_DisplayableItemWithRarityMetadata {
struct TSet<struct FName> Tags; // 0x60(0x50)
enum class ES_ItemType Type; // 0xb0(0x01)
enum class ES_InteractIcon InteractIcon; // 0xb1(0x01)
char pad_B2[0x6]; // 0xb2(0x06)
struct TSoftObjectPtr<struct US_ItemData> ItemDataAsset; // 0xb8(0x28)
SoftClassProperty ItemPickupClass; // 0xe0(0x28)
struct FS_DialogueContext DialogueContext; // 0x108(0x50)
bool bStackable; // 0x158(0x01)
char pad_159[0x3]; // 0x159(0x03)
int32_t MaximumStackSize; // 0x15c(0x04)
int32_t StackDropSize; // 0x160(0x04)
bool bSharedWithTeam; // 0x164(0x01)
enum class ES_AmmoType AmmoType; // 0x165(0x01)
enum class ES_ConsumablePackageType ConsumablePackageType; // 0x166(0x01)
char pad_167[0x1]; // 0x167(0x01)
float ConsumableApplicationTime; // 0x168(0x04)
enum class ES_StatChangeCauseType ConsumableStatsEffectChangeCauseType; // 0x16c(0x01)
char pad_16D[0x3]; // 0x16d(0x03)
SoftClassProperty ConsumableStatsEffectArrayClass; // 0x170(0x28)
struct TSoftObjectPtr<struct UAnimMontage> ConsumableMontage; // 0x198(0x28)
struct TArray<SoftClassProperty> GameplayEffectsOnConsume; // 0x1c0(0x10)
enum class ES_CurrencyType CurrencyType; // 0x1d0(0x01)
char pad_1D1[0x7]; // 0x1d1(0x07)
SoftClassProperty EquipmentClass; // 0x1d8(0x28)
int32_t WeaponBackpackAmmoCount; // 0x200(0x04)
char pad_204[0x4]; // 0x204(0x04)
struct TSoftObjectPtr<struct USkeletalMesh> EquipmentMesh; // 0x208(0x28)
struct FName EquipmentSocketName; // 0x230(0x08)
struct TMap<struct FName, struct TSoftObjectPtr<struct UPhysicalMaterial>> EquippedBonePhysicsMaterialOverrides; // 0x238(0x50)
SoftClassProperty EquippedStatsEffectArrayClass; // 0x288(0x28)
SoftClassProperty GrenadeProjectileAttachment; // 0x2b0(0x28)
bool bConvertsOnPickup; // 0x2d8(0x01)
char pad_2D9[0x7]; // 0x2d9(0x07)
struct TSoftObjectPtr<struct US_ItemData> ConvertedIntoItemData; // 0x2e0(0x28)
int32_t NumberOfConvertedItemsPerOriginalItem; // 0x308(0x04)
char pad_30C[0x4]; // 0x30c(0x04)
struct FDataTableRowHandle ExtractionOnlineItemReward; // 0x310(0x10)
};
// ScriptStruct Scavenger.S_ScrapDescriptorSoft
// Size: 0x30 (Inherited: 0x00)
struct FS_ScrapDescriptorSoft {
struct TSoftObjectPtr<struct US_ItemData> ScrapResourceItemData; // 0x00(0x28)
int32_t ResourceAmount; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_ScrapDescriptor
// Size: 0x10 (Inherited: 0x00)
struct FS_ScrapDescriptor {
struct US_ItemData* ScrapResourceItemData; // 0x00(0x08)
int32_t ResourceAmount; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_ItemPickupAdditionalMeshRecord
// Size: 0x10 (Inherited: 0x00)
struct FS_ItemPickupAdditionalMeshRecord {
struct TArray<struct USkeletalMeshComponent*> SkeletalMeshComponents; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_SkeletalMeshAndSocketNamePair
// Size: 0x10 (Inherited: 0x00)
struct FS_SkeletalMeshAndSocketNamePair {
struct USkeletalMesh* SkeletalMesh; // 0x00(0x08)
struct FName SocketName; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_ItemMetadataTableRowReference
// Size: 0x20 (Inherited: 0x00)
struct FS_ItemMetadataTableRowReference {
struct FDataTableRowHandle TableRowHandle; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_TurnAccelerationParams
// Size: 0x18 (Inherited: 0x00)
struct FS_TurnAccelerationParams {
float PitchFactor; // 0x00(0x04)
float YawFactor; // 0x04(0x04)
float DegreesFromHorizontalThreshold; // 0x08(0x04)
float InputThreshold; // 0x0c(0x04)
float StartTime; // 0x10(0x04)
float RampUpTime; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_JoystickProcessingParams
// Size: 0x58 (Inherited: 0x00)
struct FS_JoystickProcessingParams {
struct FName InputXAxisName; // 0x00(0x08)
struct FName InputYAxisName; // 0x08(0x08)
bool bInputInvertX; // 0x10(0x01)
bool bInputInvertY; // 0x11(0x01)
char pad_12[0x2]; // 0x12(0x02)
struct FName OutputXAxisName; // 0x14(0x08)
struct FName OutputYAxisName; // 0x1c(0x08)
float OutputScaleX; // 0x24(0x04)
float OutputScaleY; // 0x28(0x04)
bool bOutputInvertX; // 0x2c(0x01)
bool bOutputInvertY; // 0x2d(0x01)
bool bEnableRadialDeadzone; // 0x2e(0x01)
char pad_2F[0x1]; // 0x2f(0x01)
float InnerDeadzone; // 0x30(0x04)
float OuterDeadzone; // 0x34(0x04)
bool bEnableAngularDeadzone; // 0x38(0x01)
char pad_39[0x3]; // 0x39(0x03)
float AngularDeadzoneInDegrees; // 0x3c(0x04)
bool bAngularDeadzoneTop; // 0x40(0x01)
bool bAngularDeadzoneBottom; // 0x41(0x01)
bool bAngularDeadzoneLeft; // 0x42(0x01)
bool bAngularDeadzoneRight; // 0x43(0x01)
bool bEnableMagnitudeCurve; // 0x44(0x01)
char pad_45[0x3]; // 0x45(0x03)
struct UCurveFloat* MagnitudeCurve; // 0x48(0x08)
float DirectionBlockAngleThresholdDegrees; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
};
// ScriptStruct Scavenger.S_LandscapeDeformationTrace
// Size: 0x130 (Inherited: 0x00)
struct FS_LandscapeDeformationTrace {
char pad_0[0x130]; // 0x00(0x130)
};
// ScriptStruct Scavenger.S_LandscapeDeformationAgentBone
// Size: 0x28 (Inherited: 0x00)
struct FS_LandscapeDeformationAgentBone {
struct FName BoneName; // 0x00(0x08)
float FootprintSize; // 0x08(0x04)
float ZOffset; // 0x0c(0x04)
int32_t DrawPriority; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
bool bGenerateParticleEffects; // 0x18(0x01)
char pad_19[0xf]; // 0x19(0x0f)
};
// ScriptStruct Scavenger.S_SnowLayer
// Size: 0x10 (Inherited: 0x00)
struct FS_SnowLayer {
struct UPhysicalMaterial* Material; // 0x00(0x08)
float SnowHeight; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_LandscapeDeformerGaitData
// Size: 0x20 (Inherited: 0x08)
struct FS_LandscapeDeformerGaitData : FTableRowBase {
struct FS_LandscapeDeformerGait Gait; // 0x08(0x14)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_LandscapeDeformerGait
// Size: 0x14 (Inherited: 0x00)
struct FS_LandscapeDeformerGait {
float Stride; // 0x00(0x04)
float FootSeparation; // 0x04(0x04)
float FootprintSize; // 0x08(0x04)
float FootprintTrailLength; // 0x0c(0x04)
int32_t FootprintsPerTrail; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_LandscapeDeformerQuantizedPath
// Size: 0x20 (Inherited: 0x00)
struct FS_LandscapeDeformerQuantizedPath {
struct FVector2D CellOriginXY; // 0x00(0x08)
struct TArray<uint16_t> QuantizedPositions; // 0x08(0x10)
char GaitID; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
};
// ScriptStruct Scavenger.S_LandscapeDeformerPath
// Size: 0x18 (Inherited: 0x00)
struct FS_LandscapeDeformerPath {
struct TArray<struct FVector> Positions; // 0x00(0x10)
char GaitID; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
};
// ScriptStruct Scavenger.S_LandscapeDeformerFootprint
// Size: 0x10 (Inherited: 0x00)
struct FS_LandscapeDeformerFootprint {
struct FVector2D Position; // 0x00(0x08)
float Size; // 0x08(0x04)
float Depth; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_StreamingLevelDebugInfo
// Size: 0x68 (Inherited: 0x00)
struct FS_StreamingLevelDebugInfo {
char pad_0[0x18]; // 0x00(0x18)
int32_t NumActors; // 0x18(0x04)
struct FBox2D LevelBounds; // 0x1c(0x14)
struct FString TileLayer; // 0x30(0x10)
int32_t TotalLevelSize; // 0x40(0x04)
int32_t LevelTextureSize; // 0x44(0x04)
int32_t LevelMeshSize; // 0x48(0x04)
int32_t LevelPhysicsSize; // 0x4c(0x04)
struct TArray<struct FS_StreamingLevelBorderDebugInfo> BorderLevels; // 0x50(0x10)
enum class ES_LevelStreamState StreamingState; // 0x60(0x01)
char pad_61[0x7]; // 0x61(0x07)
};
// ScriptStruct Scavenger.S_StreamingLevelBorderDebugInfo
// Size: 0x08 (Inherited: 0x00)
struct FS_StreamingLevelBorderDebugInfo {
int32_t LevelIndex; // 0x00(0x04)
int32_t AdditionalLevelLoadCost; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_LevelStreamingDebugTableRow
// Size: 0x10 (Inherited: 0x08)
struct FS_LevelStreamingDebugTableRow : FTableRowBase {
int32_t WarningSize; // 0x08(0x04)
int32_t ErrorSize; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_LoadingScreenTemplateRow
// Size: 0x37d0 (Inherited: 0x08)
struct FS_LoadingScreenTemplateRow : FTableRowBase {
char pad_8[0x8]; // 0x08(0x08)
struct FVector4 GlobalPadding; // 0x10(0x10)
float GradientOpacity; // 0x20(0x04)
float FooterGlobalHeight; // 0x24(0x04)
struct FSlateBrush MainBackgroundImage; // 0x28(0x88)
struct TSoftObjectPtr<struct UTexture2D> MainBackgroundImageAsset; // 0xb0(0x28)
struct FSlateBrush MainBackgroundGradient; // 0xd8(0x88)
struct TSoftObjectPtr<struct UMaterialInstance> MainBackgroundGradientAsset; // 0x160(0x28)
enum class EStretch MainBackgroundStretchType; // 0x188(0x01)
char pad_189[0x7]; // 0x189(0x07)
struct FSlateBrush TutorialBackgroundImage; // 0x190(0x88)
struct TSoftObjectPtr<struct UTexture2D> TutorialBackgroundImageAsset; // 0x218(0x28)
struct FSlateBrush TutorialBackgroundGradient; // 0x240(0x88)
struct TSoftObjectPtr<struct UMaterialInstance> TutorialBackgroundGradientAsset; // 0x2c8(0x28)
struct FSlateBrush OptionalOverlayImage; // 0x2f0(0x88)
struct TSoftObjectPtr<struct UTexture2D> OptionalOverlayImageAsset; // 0x378(0x28)
struct FDataTableRowHandle Objective1_TitleHandle; // 0x3a0(0x10)
struct FDataTableRowHandle Objective1_DescriptionHandle; // 0x3b0(0x10)
struct FSlateBrush Objective1_Image; // 0x3c0(0x88)
struct TSoftObjectPtr<struct UTexture2D> Objective1_ImageAsset; // 0x448(0x28)
struct FDataTableRowHandle Objective2_TitleHandle; // 0x470(0x10)
struct FDataTableRowHandle Objective2_DescriptionHandle; // 0x480(0x10)
struct FSlateBrush Objective2_Image; // 0x490(0x88)
struct TSoftObjectPtr<struct UTexture2D> Objective2_ImageAsset; // 0x518(0x28)
struct FDataTableRowHandle Objective3_TitleHandle; // 0x540(0x10)
struct FDataTableRowHandle Objective3_DescriptionHandle; // 0x550(0x10)
struct FSlateBrush Objective3_Image; // 0x560(0x88)
struct TSoftObjectPtr<struct UTexture2D> Objective3_ImageAsset; // 0x5e8(0x28)
struct FSlateBrush ScavengersLogo; // 0x610(0x88)
struct TSoftObjectPtr<struct UTexture2D> ScavengersLogoAsset; // 0x698(0x28)
float ScavengersLogoHeight; // 0x6c0(0x04)
enum class EHorizontalAlignment ScavengersLogoHorizontalAlignment; // 0x6c4(0x01)
enum class EVerticalAlignment ScavengersLogoVerticalAlignment; // 0x6c5(0x01)
char pad_6C6[0xa]; // 0x6c6(0x0a)
struct FVector4 ScavengersLogoPadding; // 0x6d0(0x10)
struct FDataTableRowHandle NoRecordingMessageHandle; // 0x6e0(0x10)
struct FTextBlockStyle NoRecordingNoteStyle; // 0x6f0(0x270)
struct FVector4 NoRecordingNotePadding; // 0x960(0x10)
enum class ETextJustify NoRecordingNoteJustification; // 0x970(0x01)
enum class EHorizontalAlignment NoRecordingNoteHorizontalAlignment; // 0x971(0x01)
enum class EVerticalAlignment NoRecordingNoteVerticalAlignment; // 0x972(0x01)
char pad_973[0x5]; // 0x973(0x05)
struct FSlateBrush Throbber; // 0x978(0x88)
struct TSoftObjectPtr<struct UMaterialInstance> ThrobberAsset; // 0xa00(0x28)
float ThrobberSlotWidth; // 0xa28(0x04)
enum class EHorizontalAlignment ThrobberHorizontalAlignment; // 0xa2c(0x01)
enum class EVerticalAlignment ThrobberVerticalAlignment; // 0xa2d(0x01)
char pad_A2E[0x2]; // 0xa2e(0x02)
struct FVector4 ThrobberPadding; // 0xa30(0x10)
struct FDataTableRowHandle LoadingTextHandle; // 0xa40(0x10)
struct FTextBlockStyle LoadingMessageStyle; // 0xa50(0x270)
struct FVector4 LoadingMessagePadding; // 0xcc0(0x10)
enum class ETextJustify LoadingMessageJustification; // 0xcd0(0x01)
enum class EHorizontalAlignment LoadingMessageHorizontalAlignment; // 0xcd1(0x01)
enum class EVerticalAlignment LoadingMessageVerticalAlignment; // 0xcd2(0x01)
char pad_CD3[0x1]; // 0xcd3(0x01)
float LoadingMessageSlotWidth; // 0xcd4(0x04)
struct FDataTableRowHandle BuildNameHandle; // 0xcd8(0x10)
struct FTextBlockStyle BuildNameStyle; // 0xce8(0x270)
char pad_F58[0x8]; // 0xf58(0x08)
struct FVector4 BuildNamePadding; // 0xf60(0x10)
enum class ETextJustify BuildNameJustification; // 0xf70(0x01)
enum class EHorizontalAlignment BuildNameHorizontalAlignment; // 0xf71(0x01)
enum class EVerticalAlignment BuildNameVerticalAlignment; // 0xf72(0x01)
char pad_F73[0x5]; // 0xf73(0x05)
struct FDataTableRowHandle BuildNoteHandle; // 0xf78(0x10)
struct FTextBlockStyle BuildNoteStyle; // 0xf88(0x270)
char pad_11F8[0x8]; // 0x11f8(0x08)
struct FVector4 BuildNotePadding; // 0x1200(0x10)
enum class ETextJustify BuildNoteJustification; // 0x1210(0x01)
enum class EHorizontalAlignment BuildNoteHorizontalAlignment; // 0x1211(0x01)
enum class EVerticalAlignment BuildNoteVerticalAlignment; // 0x1212(0x01)
char pad_1213[0x1]; // 0x1213(0x01)
int32_t CountdownTimer; // 0x1214(0x04)
struct FTextBlockStyle CountdownStyle; // 0x1218(0x270)
char pad_1488[0x8]; // 0x1488(0x08)
struct FVector4 CountdownPadding; // 0x1490(0x10)
enum class ETextJustify CountdownJustification; // 0x14a0(0x01)
enum class EHorizontalAlignment CountdownHorizontalAlignment; // 0x14a1(0x01)
enum class EVerticalAlignment CountdownVerticalAlignment; // 0x14a2(0x01)
char pad_14A3[0x1]; // 0x14a3(0x01)
float ObjectivesGlobalHeight; // 0x14a4(0x04)
float ObjectiveImageHeight; // 0x14a8(0x04)
float ObjectiveTitleHeight; // 0x14ac(0x04)
float ObjectiveDescriptionHeight; // 0x14b0(0x04)
char pad_14B4[0x4]; // 0x14b4(0x04)
struct FTextBlockStyle ObjectiveTitleStyle; // 0x14b8(0x270)
char pad_1728[0x8]; // 0x1728(0x08)
struct FVector4 ObjectiveTitlePadding; // 0x1730(0x10)
enum class ETextJustify ObjectiveTitleJustification; // 0x1740(0x01)
char pad_1741[0x3]; // 0x1741(0x03)
float ObjectiveTitleMinWidth; // 0x1744(0x04)
struct FTextBlockStyle ObjectiveDescriptionStyle; // 0x1748(0x270)
char pad_19B8[0x8]; // 0x19b8(0x08)
struct FVector4 ObjectiveDescriptionPadding; // 0x19c0(0x10)
enum class ETextJustify ObjectiveDescriptionJustification; // 0x19d0(0x01)
bool ObjectiveDescriptionAutoWrapText; // 0x19d1(0x01)
char pad_19D2[0x2]; // 0x19d2(0x02)
float ObjectiveDescriptionWrapTextWidth; // 0x19d4(0x04)
struct FDataTableRowHandle TutorialTitleHandle; // 0x19d8(0x10)
struct FTextBlockStyle TutorialTitleStyle; // 0x19e8(0x270)
char pad_1C58[0x8]; // 0x1c58(0x08)
struct FVector4 TutorialTitlePadding; // 0x1c60(0x10)
enum class EHorizontalAlignment TutorialTitleHorizontalAlignment; // 0x1c70(0x01)
enum class EVerticalAlignment TutorialTitleVerticalAlignment; // 0x1c71(0x01)
char pad_1C72[0x6]; // 0x1c72(0x06)
struct FSlateBrush SocialHubBackgroundImage; // 0x1c78(0x88)
struct TSoftObjectPtr<struct UTexture2D> SocialHubBackgroundImageAsset; // 0x1d00(0x28)
struct FSlateBrush SocialHubBackgroundGradient; // 0x1d28(0x88)
struct TSoftObjectPtr<struct UMaterialInstance> SocialHubBackgroundGradientAsset; // 0x1db0(0x28)
struct FDataTableRowHandle SocialHubObjective1_TitleHandle; // 0x1dd8(0x10)
struct FDataTableRowHandle SocialHubObjective1_DescriptionHandle; // 0x1de8(0x10)
struct FSlateBrush SocialHubObjective1_Image; // 0x1df8(0x88)
struct TSoftObjectPtr<struct UTexture2D> SocialHubObjective1_ImageAsset; // 0x1e80(0x28)
struct FDataTableRowHandle SocialHubObjective2_TitleHandle; // 0x1ea8(0x10)
struct FDataTableRowHandle SocialHubObjective2_DescriptionHandle; // 0x1eb8(0x10)
struct FSlateBrush SocialHubObjective2_Image; // 0x1ec8(0x88)
struct TSoftObjectPtr<struct UTexture2D> SocialHubObjective2_ImageAsset; // 0x1f50(0x28)
struct FDataTableRowHandle SocialHubObjective3_TitleHandle; // 0x1f78(0x10)
struct FDataTableRowHandle SocialHubObjective3_DescriptionHandle; // 0x1f88(0x10)
struct FSlateBrush SocialHubObjective3_Image; // 0x1f98(0x88)
struct TSoftObjectPtr<struct UTexture2D> SocialHubObjective3_ImageAsset; // 0x2020(0x28)
struct FSlateBrush LoadingScreenBackground_Image; // 0x2048(0x88)
struct TSoftObjectPtr<struct UTexture2D> LoadingScreenBackground_ImageAsset; // 0x20d0(0x28)
struct FSlateBrush MutatorArsenalBackground_Image; // 0x20f8(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorArsenalBackground_ImageAsset; // 0x2180(0x28)
struct FSlateBrush MutatorGunFuBackground_Image; // 0x21a8(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorGunFuBackground_ImageAsset; // 0x2230(0x28)
struct FSlateBrush LoadingScreenGradient_Image; // 0x2258(0x88)
struct TSoftObjectPtr<struct UMaterialInstance> LoadingScreenGradient_ImageAsset; // 0x22e0(0x28)
char pad_2308[0x8]; // 0x2308(0x08)
struct FVector4 LoadingScreen_MutatorRow_Padding; // 0x2310(0x10)
struct FSlateBrush MutatorPanel_Image; // 0x2320(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorPanel_ImageAsset; // 0x23a8(0x28)
struct FSlateBrush ObjectivesPanel_Image; // 0x23d0(0x88)
struct TSoftObjectPtr<struct UTexture2D> ObjectivesPanel_ImageAsset; // 0x2458(0x28)
struct FSlateBrush TutorialPanel_Image; // 0x2480(0x88)
struct TSoftObjectPtr<struct UTexture2D> TutorialPanel_ImageAsset; // 0x2508(0x28)
struct FVector4 TutorialPanel_Padding; // 0x2530(0x10)
struct FVector4 MutatorPanel_Padding; // 0x2540(0x10)
struct FVector4 ObjectivesPanel_Padding; // 0x2550(0x10)
struct FVector4 ObjectivesRow_Padding; // 0x2560(0x10)
struct FSlateBrush MutatorDNAIcon_Image; // 0x2570(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorDNAIcon_ImageAsset; // 0x25f8(0x28)
struct FVector4 LoadingScreen_DNAIconLeft_Padding; // 0x2620(0x10)
struct FVector4 LoadingScreen_DNAIconRight_Padding; // 0x2630(0x10)
float LoadingScreen_DNAIcon_SlotWidth; // 0x2640(0x04)
char pad_2644[0x4]; // 0x2644(0x04)
struct FDataTableRowHandle MutatorTutorialTitleHandle; // 0x2648(0x10)
struct FTextBlockStyle MutatorTutorialTitleStyle; // 0x2658(0x270)
char pad_28C8[0x8]; // 0x28c8(0x08)
struct FVector4 MutatorTutorialTitlePadding; // 0x28d0(0x10)
enum class ETextJustify MutatorTutorialTitleJustification; // 0x28e0(0x01)
char pad_28E1[0x3]; // 0x28e1(0x03)
float MutatorTutorialTitleMinWidth; // 0x28e4(0x04)
struct FDataTableRowHandle MutatorTitleHandle_Arsenal; // 0x28e8(0x10)
struct FDataTableRowHandle MutatorTitleHandle_GunFu; // 0x28f8(0x10)
struct FTextBlockStyle MutatorTitleStyle; // 0x2908(0x270)
char pad_2B78[0x8]; // 0x2b78(0x08)
struct FVector4 MutatorTitlePadding; // 0x2b80(0x10)
enum class ETextJustify MutatorTitleJustification; // 0x2b90(0x01)
char pad_2B91[0x3]; // 0x2b91(0x03)
float MutatorTitleMinWidth; // 0x2b94(0x04)
struct FDataTableRowHandle MutatorDescriptionHandle_GunFu; // 0x2b98(0x10)
struct FDataTableRowHandle MutatorDescriptionHandle_Arsenal; // 0x2ba8(0x10)
struct FTextBlockStyle MutatorDescriptionStyle; // 0x2bb8(0x270)
char pad_2E28[0x8]; // 0x2e28(0x08)
struct FVector4 MutatorDescriptionPadding; // 0x2e30(0x10)
enum class ETextJustify MutatorDescriptionJustification; // 0x2e40(0x01)
bool MutatorDescriptionAutoWrapText; // 0x2e41(0x01)
char pad_2E42[0x2]; // 0x2e42(0x02)
float MutatorDescriptionWrapTextWidth; // 0x2e44(0x04)
struct FSlateBrush MutatorObjective1Icon_Image; // 0x2e48(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorObjective1Icon_ImageAsset; // 0x2ed0(0x28)
struct FSlateBrush MutatorObjective2Icon_Image; // 0x2ef8(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorObjective2Icon_ImageAsset; // 0x2f80(0x28)
struct FSlateBrush MutatorObjective3Icon_Image; // 0x2fa8(0x88)
struct TSoftObjectPtr<struct UTexture2D> MutatorObjective3Icon_ImageAsset; // 0x3030(0x28)
char pad_3058[0x8]; // 0x3058(0x08)
struct FVector4 MutatorObjectiveIcon_Padding; // 0x3060(0x10)
float MutatorObjectiveIconHeight; // 0x3070(0x04)
char pad_3074[0x4]; // 0x3074(0x04)
struct FTextBlockStyle GameplayHintStyle; // 0x3078(0x270)
char pad_32E8[0x8]; // 0x32e8(0x08)
struct FVector4 GameplayHintPadding; // 0x32f0(0x10)
enum class ETextJustify GameplayHintJustification; // 0x3300(0x01)
bool GameplayHintAutoWrapText; // 0x3301(0x01)
char pad_3302[0x2]; // 0x3302(0x02)
float GameplayHintWrapTextWidth; // 0x3304(0x04)
float GameplayHintSlotWidth; // 0x3308(0x04)
char pad_330C[0x4]; // 0x330c(0x04)
struct FText MutatorTitle_GunFu; // 0x3310(0x18)
struct FText MutatorTitle_Arsenal; // 0x3328(0x18)
bool MutatorTitle_ForceUppercase; // 0x3340(0x01)
char pad_3341[0x7]; // 0x3341(0x07)
struct FText MutatorDescription_Arsenal; // 0x3348(0x18)
struct FText MutatorDescription_GunFu; // 0x3360(0x18)
bool MutatorDescription_ForceUppercase; // 0x3378(0x01)
char pad_3379[0x7]; // 0x3379(0x07)
struct FSlateBrush ScavengersLogo_Image; // 0x3380(0x88)
struct TSoftObjectPtr<struct UTexture2D> ScavengersLogo_ImageAsset; // 0x3408(0x28)
struct FVector4 ScavengersLogo_Padding; // 0x3430(0x10)
struct TArray<struct FText> GameplayHintList; // 0x3440(0x10)
char pad_3450[0x20]; // 0x3450(0x20)
bool Objective1_Title_ForceUppercase; // 0x3470(0x01)
char pad_3471[0x1f]; // 0x3471(0x1f)
bool Objective1_Description_ForceUppercase; // 0x3490(0x01)
char pad_3491[0x1f]; // 0x3491(0x1f)
bool Objective2_Title_ForceUppercase; // 0x34b0(0x01)
char pad_34B1[0x1f]; // 0x34b1(0x1f)
bool Objective2_Description_ForceUppercase; // 0x34d0(0x01)
char pad_34D1[0x1f]; // 0x34d1(0x1f)
bool Objective3_Title_ForceUppercase; // 0x34f0(0x01)
char pad_34F1[0x1f]; // 0x34f1(0x1f)
bool Objective3_Description_ForceUppercase; // 0x3510(0x01)
char pad_3511[0x1f]; // 0x3511(0x1f)
bool NoRecordingMessage_ForceUppercase; // 0x3530(0x01)
char pad_3531[0x1f]; // 0x3531(0x1f)
bool LoadingText_ForceUppercase; // 0x3550(0x01)
char pad_3551[0x7]; // 0x3551(0x07)
struct FText BuildName; // 0x3558(0x18)
bool BuildName_ForceUppercase; // 0x3570(0x01)
char pad_3571[0x1f]; // 0x3571(0x1f)
bool BuildNote_ForceUppercase; // 0x3590(0x01)
char pad_3591[0x1f]; // 0x3591(0x1f)
bool TutorialTitle_ForceUppercase; // 0x35b0(0x01)
char pad_35B1[0x3]; // 0x35b1(0x03)
float FadeIn; // 0x35b4(0x04)
float HoldOnBackground; // 0x35b8(0x04)
float FadeInContent; // 0x35bc(0x04)
float HoldOnContent; // 0x35c0(0x04)
float FadeOut; // 0x35c4(0x04)
float FadeInTutorial; // 0x35c8(0x04)
float HoldOnTutorial; // 0x35cc(0x04)
float FadeOutTutorial; // 0x35d0(0x04)
float TimeBetweenHints; // 0x35d4(0x04)
char pad_35D8[0x1f8]; // 0x35d8(0x1f8)
};
// ScriptStruct Scavenger.S_LoadoutSlotData
// Size: 0x48 (Inherited: 0x08)
struct FS_LoadoutSlotData : FTableRowBase {
enum class ES_LoadoutSlotType SlotType; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FText DisplayName; // 0x10(0x18)
struct FText SlotDescription; // 0x28(0x18)
int32_t ItemCount; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
};
// ScriptStruct Scavenger.S_LoadoutForReplication
// Size: 0x10 (Inherited: 0x00)
struct FS_LoadoutForReplication {
struct TArray<struct FS_LoadoutSelectionForReplication> Selections; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LoadoutSelectionForReplication
// Size: 0x0c (Inherited: 0x00)
struct FS_LoadoutSelectionForReplication {
int32_t SlotType; // 0x00(0x04)
struct FName ItemMetadataId; // 0x04(0x08)
};
// ScriptStruct Scavenger.S_LobbyPlayerReconnectState
// Size: 0x240 (Inherited: 0x00)
struct FS_LobbyPlayerReconnectState {
struct FS_LobbyPlayerState PlayerState; // 0x00(0x118)
struct FS_LobbyPartyState PartyState; // 0x118(0x60)
struct FS_LobbyTeamState TeamState; // 0x178(0x68)
struct FS_LobbyVoiceChatCredentials VoiceChatCredentials; // 0x1e0(0x50)
struct FS_LobbyQueueList QueueList; // 0x230(0x10)
};
// ScriptStruct Scavenger.S_LobbyQueueList
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyQueueList {
struct TArray<struct FS_LobbyQueue> Queues; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyVoiceChatCredentials
// Size: 0x50 (Inherited: 0x00)
struct FS_LobbyVoiceChatCredentials {
struct FString LoginToken; // 0x00(0x10)
struct FString ChannelName; // 0x10(0x10)
struct FString ChannelJoinToken; // 0x20(0x10)
struct TArray<struct FString> BackupLoginTokens; // 0x30(0x10)
struct TArray<struct FString> BackupChannelJoinTokens; // 0x40(0x10)
};
// ScriptStruct Scavenger.S_LobbyPartyState
// Size: 0x60 (Inherited: 0x00)
struct FS_LobbyPartyState {
struct FS_LobbyParty party; // 0x00(0x60)
};
// ScriptStruct Scavenger.S_LobbyPlayerState
// Size: 0x118 (Inherited: 0x00)
struct FS_LobbyPlayerState {
struct FS_LobbyPlayer Player; // 0x00(0x108)
struct FString State; // 0x108(0x10)
};
// ScriptStruct Scavenger.S_LobbyTitleNews
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyTitleNews {
struct TArray<struct FS_LobbyTitleNewsItem> NewsItems; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyTitleNewsItem
// Size: 0x48 (Inherited: 0x00)
struct FS_LobbyTitleNewsItem {
struct FString Title; // 0x00(0x10)
struct FString Body; // 0x10(0x10)
struct FDateTime Timestamp; // 0x20(0x08)
struct FString Locale; // 0x28(0x10)
struct FString ImageUrl; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_LobbyRequestTitleNews
// Size: 0x18 (Inherited: 0x00)
struct FS_LobbyRequestTitleNews {
int32_t Count; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString Locale; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_LobbyMatchPhaseUpdate
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyMatchPhaseUpdate {
struct FString Phase; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyServerJoinQueue
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyServerJoinQueue {
struct FString QueueId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyServerHello
// Size: 0x48 (Inherited: 0x00)
struct FS_LobbyServerHello {
struct FString ServerDisplayName; // 0x00(0x10)
struct FString OverrideIpAddress; // 0x10(0x10)
struct FString ServerVersion; // 0x20(0x10)
struct FString SpatialDeploymentName; // 0x30(0x10)
int32_t MaxPlayers; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
};
// ScriptStruct Scavenger.S_LobbySendTextMessage
// Size: 0x20 (Inherited: 0x00)
struct FS_LobbySendTextMessage {
struct FString Message; // 0x00(0x10)
struct FString Context; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_LobbySendPartyInvite
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbySendPartyInvite {
struct FString PlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyPartyLeaveCurrentTeam
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyPartyLeaveCurrentTeam {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_RemoveMyPartyFromQueue
// Size: 0x01 (Inherited: 0x00)
struct FS_RemoveMyPartyFromQueue {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyPlayerLeaveCurrentParty
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyPlayerLeaveCurrentParty {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyRequestToJoinParty
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyRequestToJoinParty {
struct FString PartyId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyRequestChatCredentials
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyRequestChatCredentials {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyRequestVoiceChatCredentials
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyRequestVoiceChatCredentials {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyReturnToLobby
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyReturnToLobby {
struct FString Reason; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyStartGame
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyStartGame {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyGameJoined
// Size: 0x108 (Inherited: 0x00)
struct FS_LobbyGameJoined {
struct FS_LobbyPlayer Player; // 0x00(0x108)
};
// ScriptStruct Scavenger.S_LobbyUpdatePlayerDetails
// Size: 0x110 (Inherited: 0x00)
struct FS_LobbyUpdatePlayerDetails {
struct FS_LobbyPlayer Player; // 0x00(0x108)
bool LockedIn; // 0x108(0x01)
char pad_109[0x7]; // 0x109(0x07)
};
// ScriptStruct Scavenger.S_LobbyChangeTeam
// Size: 0x04 (Inherited: 0x00)
struct FS_LobbyChangeTeam {
int32_t NewTeamIndex; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_LobbyJoinMyPartyToQueue
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyJoinMyPartyToQueue {
struct FString QueueId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyRefreshOnlinePlayersList
// Size: 0x18 (Inherited: 0x00)
struct FS_LobbyRefreshOnlinePlayersList {
int32_t MaxResults; // 0x00(0x04)
int32_t Offset; // 0x04(0x04)
struct FString Search; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_LobbyRefreshQueues
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyRefreshQueues {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyClientHello
// Size: 0x148 (Inherited: 0x00)
struct FS_LobbyClientHello {
struct FString Platform; // 0x00(0x10)
struct FString ClientVersion; // 0x10(0x10)
struct FString KeyFingerprint; // 0x20(0x10)
struct FString ChallengeResponse; // 0x30(0x10)
struct FS_LobbyPlayer Player; // 0x40(0x108)
};
// ScriptStruct Scavenger.S_LobbyMatchAllocated
// Size: 0x18 (Inherited: 0x00)
struct FS_LobbyMatchAllocated {
int32_t TeamIndex; // 0x00(0x04)
int32_t expectedPlayerCount; // 0x04(0x04)
int32_t expectedTeamCount; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
int64_t RandomSeed; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_LobbyMatchManifest
// Size: 0x40 (Inherited: 0x00)
struct FS_LobbyMatchManifest {
int32_t expectedPlayerCount; // 0x00(0x04)
int32_t expectedTeamCount; // 0x04(0x04)
int64_t RandomSeed; // 0x08(0x08)
struct TArray<struct FS_LobbyTeam> AllTeams; // 0x10(0x10)
struct FJsonObjectWrapper MetaData; // 0x20(0x20)
};
// ScriptStruct Scavenger.S_LobbyNextDraftingPeriod
// Size: 0x10 (Inherited: 0x00)
struct FS_LobbyNextDraftingPeriod {
struct FString draftingPlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LobbyOnlinePlayers
// Size: 0x18 (Inherited: 0x00)
struct FS_LobbyOnlinePlayers {
int32_t TotalOnlinePlayers; // 0x00(0x04)
int32_t Offset; // 0x04(0x04)
struct TArray<struct FS_LobbyPlayer> OnlinePlayerResults; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_LobbyChatCredentials
// Size: 0x80 (Inherited: 0x00)
struct FS_LobbyChatCredentials {
struct FString Host; // 0x00(0x10)
struct FString XmppEndpoint; // 0x10(0x10)
struct FString WsEndpoint; // 0x20(0x10)
struct FString Jid; // 0x30(0x10)
struct FString Username; // 0x40(0x10)
struct FString Password; // 0x50(0x10)
struct FString LobbyChatRoom; // 0x60(0x10)
struct FString Resource; // 0x70(0x10)
};
// ScriptStruct Scavenger.S_LobbyHaveFun
// Size: 0x01 (Inherited: 0x00)
struct FS_LobbyHaveFun {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_LobbyPartyInvite
// Size: 0x168 (Inherited: 0x00)
struct FS_LobbyPartyInvite {
struct FS_LobbyParty party; // 0x00(0x60)
struct FS_LobbyPlayer InviteSentBy; // 0x60(0x108)
};
// ScriptStruct Scavenger.S_LobbyJoinQueueFailed
// Size: 0x20 (Inherited: 0x00)
struct FS_LobbyJoinQueueFailed {
struct FString QueueId; // 0x00(0x10)
struct FString ErrorCode; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_LobbyJoinPartyFailed
// Size: 0x20 (Inherited: 0x00)
struct FS_LobbyJoinPartyFailed {
struct FString PartyId; // 0x00(0x10)
struct FString ErrorCode; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_LobbyReceivedTextMessage
// Size: 0x40 (Inherited: 0x00)
struct FS_LobbyReceivedTextMessage {
struct FString fromPlayerId; // 0x00(0x10)
struct FString FromPlayerDisplayName; // 0x10(0x10)
struct FString Message; // 0x20(0x10)
struct FString Context; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_LobbyQueueStatus
// Size: 0x78 (Inherited: 0x00)
struct FS_LobbyQueueStatus {
struct FS_LobbyQueue queue; // 0x00(0x70)
int32_t PlayersSearching; // 0x70(0x04)
char pad_74[0x4]; // 0x74(0x04)
};
// ScriptStruct Scavenger.S_LocalGameJoinParameters
// Size: 0x120 (Inherited: 0x00)
struct FS_LocalGameJoinParameters {
struct FName ClassName; // 0x00(0x08)
struct FString DisplayName; // 0x08(0x10)
int32_t TeamIndex; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct FString PlayerId; // 0x20(0x10)
struct FS_CharacterLoadout GameplayLoadout; // 0x30(0x50)
struct FS_CosmeticLoadout CosmeticLoadout; // 0x80(0x50)
struct FS_CosmeticLoadout AccountCosmeticLoadout; // 0xd0(0x50)
};
// ScriptStruct Scavenger.S_LocalizedTextTableRow
// Size: 0x20 (Inherited: 0x08)
struct FS_LocalizedTextTableRow : FTableRowBase {
struct FText Text; // 0x08(0x18)
};
// ScriptStruct Scavenger.S_LootAudioTypeInfo
// Size: 0x30 (Inherited: 0x00)
struct FS_LootAudioTypeInfo {
int32_t Priority; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct UAkAudioEvent* AudioEventsByRarity[0x5]; // 0x08(0x28)
};
// ScriptStruct Scavenger.S_LootAudioEvent
// Size: 0x10 (Inherited: 0x00)
struct FS_LootAudioEvent {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LootSpawnSettings
// Size: 0x30 (Inherited: 0x00)
struct FS_LootSpawnSettings {
char bEvenlyDistributeImpulseVectors : 1; // 0x00(0x01)
char pad_0_1 : 7; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector ConeDirection; // 0x04(0x0c)
struct FVector ConeOffsetLocation; // 0x10(0x0c)
float ConeRadius; // 0x1c(0x04)
float ImpulseStrength; // 0x20(0x04)
float ImpulseStrengthRandomVariance; // 0x24(0x04)
float TimeBetweenSpawns; // 0x28(0x04)
float TimeBetweenSpawnsRandomVariance; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_LootDescriptor
// Size: 0x28 (Inherited: 0x08)
struct FS_LootDescriptor : FTableRowBase {
char bDuplicateItemsOkay : 1; // 0x08(0x01)
char bDuplicateLootSelectorsOkay : 1; // 0x08(0x01)
char pad_8_2 : 6; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
int32_t MinimumNumberOfSelections; // 0x0c(0x04)
int32_t MaximumNumberOfSelections; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<struct FS_LootSelector> LootSelectors; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_SelectorBase
// Size: 0x04 (Inherited: 0x00)
struct FS_SelectorBase {
float RelativeChance; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_LootSelector
// Size: 0x28 (Inherited: 0x04)
struct FS_LootSelector : FS_SelectorBase {
char bDuplicateTableSelectorsOkay : 1; // 0x04(0x01)
char pad_4_1 : 7; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
struct TArray<struct FS_LootQuantitySelector> ItemQuantitySelectors; // 0x08(0x10)
struct TArray<struct FS_LootTableSelector> LootTableSelectors; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_LootTableSelector
// Size: 0x48 (Inherited: 0x04)
struct FS_LootTableSelector : FS_SelectorBase {
char pad_4[0x4]; // 0x04(0x04)
struct TSoftObjectPtr<struct US_LootTableDescriptorData> LootTableDescriptorData; // 0x08(0x28)
struct FS_LootTableDescriptor LootTableDescriptor; // 0x30(0x10)
struct US_LootTableDescriptorData* LoadedLootTableDescriptorData; // 0x40(0x08)
};
// ScriptStruct Scavenger.S_LootTableDescriptor
// Size: 0x10 (Inherited: 0x00)
struct FS_LootTableDescriptor {
struct TArray<struct FS_LootTableEntry> Entries; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_LootTableEntry
// Size: 0x40 (Inherited: 0x04)
struct FS_LootTableEntry : FS_SelectorBase {
char pad_4[0x4]; // 0x04(0x04)
struct TSoftObjectPtr<struct US_ItemData> ItemData; // 0x08(0x28)
int32_t MinimumQuantity; // 0x30(0x04)
int32_t MaximumQuantity; // 0x34(0x04)
struct US_ItemData* LoadedItemData; // 0x38(0x08)
};
// ScriptStruct Scavenger.S_LootQuantitySelector
// Size: 0x0c (Inherited: 0x04)
struct FS_LootQuantitySelector : FS_SelectorBase {
int32_t MinimumNumberOfItems; // 0x04(0x04)
int32_t MaximumNumberOfItems; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_InternalMapServerData
// Size: 0x10 (Inherited: 0x00)
struct FS_InternalMapServerData {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_NamedLocationMetadataTableRowReference
// Size: 0x20 (Inherited: 0x00)
struct FS_NamedLocationMetadataTableRowReference {
struct FDataTableRowHandle TableRowHandle; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_OverrideMapDisplayDataTableRowReference
// Size: 0x20 (Inherited: 0x00)
struct FS_OverrideMapDisplayDataTableRowReference {
struct FDataTableRowHandle TableRowHandle; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_OverrideMapDisplayData
// Size: 0x68 (Inherited: 0x08)
struct FS_OverrideMapDisplayData : FTableRowBase {
struct UTexture2D* Texture; // 0x08(0x08)
bool OverrideTexture; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct UTexture2D* AltTexture; // 0x18(0x08)
bool OverrideAltTexture; // 0x20(0x01)
char pad_21[0x3]; // 0x21(0x03)
float AltTextureSize; // 0x24(0x04)
bool OverrideAltTextureSize; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
struct UMaterialInstance* MaterialOverride; // 0x30(0x08)
bool OverrideMaterialOverride; // 0x38(0x01)
char pad_39[0x3]; // 0x39(0x03)
struct FLinearColor Color; // 0x3c(0x10)
bool OverrideColor; // 0x4c(0x01)
char pad_4D[0x3]; // 0x4d(0x03)
struct FName DisplayText; // 0x50(0x08)
bool OverrideDisplayText; // 0x58(0x01)
enum class ES_ZoomType ZoomType; // 0x59(0x01)
bool OverrideZoomType; // 0x5a(0x01)
char pad_5B[0x1]; // 0x5b(0x01)
float ZoomLevel; // 0x5c(0x04)
bool OverrideZoomLevel; // 0x60(0x01)
char ZOrder; // 0x61(0x01)
bool OverrideZOrder; // 0x62(0x01)
enum class ES_EnemyInfoType EnemyInfoType; // 0x63(0x01)
bool OverrideEnemyInfoType; // 0x64(0x01)
bool bAllowGuttering; // 0x65(0x01)
bool OverrideAllowGuttering; // 0x66(0x01)
char pad_67[0x1]; // 0x67(0x01)
};
// ScriptStruct Scavenger.S_DetectedActorLocationData
// Size: 0x20 (Inherited: 0x00)
struct FS_DetectedActorLocationData {
struct FVector2D WorldLocation2D; // 0x00(0x08)
enum class ES_DetectionReason DetectionReason; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
float PingSizeWorldUnits; // 0x0c(0x04)
float SpawnGameTime; // 0x10(0x04)
float Lifetime; // 0x14(0x04)
struct US_MapDetectableComponent* Owner; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_DetectionTypeConfigItem
// Size: 0x14 (Inherited: 0x00)
struct FS_DetectionTypeConfigItem {
int32_t Score; // 0x00(0x04)
float DetectionDistance; // 0x04(0x04)
float UpdatePeriodSeconds; // 0x08(0x04)
float PingSizeWorldUnits; // 0x0c(0x04)
float JitterRadius; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_MatchRecordHolder
// Size: 0x10 (Inherited: 0x00)
struct FS_MatchRecordHolder {
struct TArray<struct FS_MatchRecord> MatchRecords; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_MatchRecord
// Size: 0x180 (Inherited: 0x00)
struct FS_MatchRecord {
char pad_0[0x180]; // 0x00(0x180)
};
// ScriptStruct Scavenger.S_StartOfMatchRecord
// Size: 0x18 (Inherited: 0x00)
struct FS_StartOfMatchRecord {
struct FString MatchID; // 0x00(0x10)
int32_t PlayerIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_MeleeAttackerInfo
// Size: 0x20 (Inherited: 0x00)
struct FS_MeleeAttackerInfo {
struct AActor* AttackerTargetingMe; // 0x00(0x08)
char pad_8[0x18]; // 0x08(0x18)
};
// ScriptStruct Scavenger.S_MeleeAttackState
// Size: 0x50 (Inherited: 0x00)
struct FS_MeleeAttackState {
struct AActor* CurrentTarget; // 0x00(0x08)
char pad_8[0x20]; // 0x08(0x20)
struct FS_MeleeHitPlaybackState meleeHitPlaybackState; // 0x28(0x28)
};
// ScriptStruct Scavenger.S_MeleeHitPlaybackState
// Size: 0x28 (Inherited: 0x00)
struct FS_MeleeHitPlaybackState {
struct US_MeleeHitPlaybackSettings* playbackSettings; // 0x00(0x08)
struct UAnimMontage* meleeMontage; // 0x08(0x08)
struct UMatineeCameraShake* meleeCameraShake; // 0x10(0x08)
struct UCameraAnimInst* meleeCameraAnim; // 0x18(0x08)
char pad_20[0x8]; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_MeleeMontageData
// Size: 0x50 (Inherited: 0x00)
struct FS_MeleeMontageData {
struct TMap<struct AS_CharacterBase*, struct FS_MeleeCatalogue> Catalogues; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_MeleeCatalogue
// Size: 0xd0 (Inherited: 0x00)
struct FS_MeleeCatalogue {
struct TMap<struct FName, struct FS_MeleeMontage> MontageMasterList; // 0x00(0x50)
struct FS_CharacterStateMontageContainer StateTree; // 0x50(0x80)
};
// ScriptStruct Scavenger.S_CharacterStateMontageContainer
// Size: 0x80 (Inherited: 0x00)
struct FS_CharacterStateMontageContainer {
struct FS_CharacterStanceMontageContainer StateContainers[0x4]; // 0x00(0x80)
};
// ScriptStruct Scavenger.S_CharacterStanceMontageContainer
// Size: 0x20 (Inherited: 0x00)
struct FS_CharacterStanceMontageContainer {
struct FName StanceMontages[0x4]; // 0x00(0x20)
};
// ScriptStruct Scavenger.S_MeleeMontage
// Size: 0x28 (Inherited: 0x00)
struct FS_MeleeMontage {
struct UAnimMontage* WindupMontage; // 0x00(0x08)
struct UAnimMontage* LightMontage; // 0x08(0x08)
struct UAnimMontage* HeavyMontage; // 0x10(0x08)
struct UAnimMontage* LightRecoil; // 0x18(0x08)
struct UAnimMontage* HeavyRecoil; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_MeleeMontageStateMachine
// Size: 0x50 (Inherited: 0x00)
struct FS_MeleeMontageStateMachine {
struct TMap<struct FName, struct FS_MeleeMontage> MeleeMontages; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_DryFireSound
// Size: 0x08 (Inherited: 0x00)
struct FS_DryFireSound {
struct UAkAudioEvent* Event; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_WhizBySound
// Size: 0x28 (Inherited: 0x00)
struct FS_WhizBySound {
bool Enabled; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct UAkAudioEvent* EnterEvent; // 0x08(0x08)
struct UAkAudioEvent* ClosestEvent; // 0x10(0x08)
struct UAkAudioEvent* ExitEvent; // 0x18(0x08)
bool TestWhizByOnTick; // 0x20(0x01)
char pad_21[0x7]; // 0x21(0x07)
};
// ScriptStruct Scavenger.S_ReloadSound
// Size: 0x08 (Inherited: 0x00)
struct FS_ReloadSound {
struct UAkAudioEvent* Event; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_MeleeSound
// Size: 0x08 (Inherited: 0x00)
struct FS_MeleeSound {
struct UAkAudioEvent* Event; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_MessengerAbilityInfo
// Size: 0x10 (Inherited: 0x00)
struct FS_MessengerAbilityInfo {
struct UTexture2D* Icon; // 0x00(0x08)
struct AS_StreamerAbility* AbilityClass; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_MixStateManager
// Size: 0x410 (Inherited: 0x00)
struct FS_MixStateManager {
char pad_0[0x410]; // 0x00(0x410)
};
// ScriptStruct Scavenger.S_MontageCatalogueIndex
// Size: 0x0c (Inherited: 0x00)
struct FS_MontageCatalogueIndex {
struct FName Key; // 0x00(0x08)
int32_t VariationIndex; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_MontageCatalogueTableRow
// Size: 0x18 (Inherited: 0x08)
struct FS_MontageCatalogueTableRow : FTableRowBase {
struct TArray<struct UAnimMontage*> Montage; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_MusicEvent
// Size: 0x20 (Inherited: 0x00)
struct FS_MusicEvent {
struct UAkAudioEvent* Event; // 0x00(0x08)
struct UAkAudioEvent* StopEvent; // 0x08(0x08)
enum class ES_MusicCue Cue; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
int32_t Priority; // 0x14(0x04)
bool bStinger; // 0x18(0x01)
bool bIgnoreLevelChangeStop; // 0x19(0x01)
char pad_1A[0x6]; // 0x1a(0x06)
};
// ScriptStruct Scavenger.S_TrackedDirtiedAreaInfo
// Size: 0x18 (Inherited: 0x00)
struct FS_TrackedDirtiedAreaInfo {
char pad_0[0x18]; // 0x00(0x18)
};
// ScriptStruct Scavenger.S_ObjectiveState
// Size: 0x128 (Inherited: 0x00)
struct FS_ObjectiveState {
struct FS_ObjectiveSharedState ObjectiveState; // 0x00(0x108)
struct TArray<struct FS_GoalState> GoalStates; // 0x108(0x10)
struct TArray<struct FS_MarkerState> MarkerStates; // 0x118(0x10)
};
// ScriptStruct Scavenger.S_MarkerState
// Size: 0x48 (Inherited: 0x00)
struct FS_MarkerState {
char pad_0[0x18]; // 0x00(0x18)
struct AActor* Actor; // 0x18(0x08)
char pad_20[0x28]; // 0x20(0x28)
};
// ScriptStruct Scavenger.S_GoalState
// Size: 0x128 (Inherited: 0x00)
struct FS_GoalState {
char pad_0[0x10]; // 0x00(0x10)
struct FS_ObjectiveSharedState GoalState; // 0x10(0x108)
struct TArray<struct FS_SubGoalState> SubGoalStates; // 0x118(0x10)
};
// ScriptStruct Scavenger.S_SubGoalState
// Size: 0x120 (Inherited: 0x00)
struct FS_SubGoalState {
char pad_0[0x18]; // 0x00(0x18)
struct FS_ObjectiveSharedState SubGoalState; // 0x18(0x108)
};
// ScriptStruct Scavenger.S_ObjectiveSharedState
// Size: 0x108 (Inherited: 0x00)
struct FS_ObjectiveSharedState {
char pad_0[0x20]; // 0x00(0x20)
struct AS_PlayerController* PlayerController; // 0x20(0x08)
char pad_28[0x50]; // 0x28(0x50)
struct UObject* PawnClass; // 0x78(0x08)
char pad_80[0x10]; // 0x80(0x10)
struct AActor* Actor; // 0x90(0x08)
char pad_98[0x70]; // 0x98(0x70)
};
// ScriptStruct Scavenger.S_SubGoalHandle
// Size: 0x14 (Inherited: 0x00)
struct FS_SubGoalHandle {
char pad_0[0x14]; // 0x00(0x14)
};
// ScriptStruct Scavenger.S_GoalHandle
// Size: 0x0c (Inherited: 0x00)
struct FS_GoalHandle {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_GoalDescriptor
// Size: 0xe8 (Inherited: 0x00)
struct FS_GoalDescriptor {
struct FS_ObjectiveDescriptor Descriptor; // 0x00(0xd8)
struct TArray<struct FS_ObjectiveDescriptor> SubGoalDescriptors; // 0xd8(0x10)
};
// ScriptStruct Scavenger.S_ObjectiveDescriptor
// Size: 0xd8 (Inherited: 0x00)
struct FS_ObjectiveDescriptor {
struct FName LabelId; // 0x00(0x08)
struct FName DescriptionId; // 0x08(0x08)
int32_t Flags; // 0x10(0x04)
enum class ES_ObjectiveOutcomeSelector AutoCompleteType; // 0x14(0x01)
enum class ES_ObjectiveOutcomeSelector AutoFailureType; // 0x15(0x01)
enum class ES_ObjectiveProgressSelector ProgressAutoIncrementType; // 0x16(0x01)
enum class ES_ObjectiveProgressSelector ProgressAutoDecrementType; // 0x17(0x01)
int32_t ProgressCompleteValue; // 0x18(0x04)
int32_t ProgressFailureValue; // 0x1c(0x04)
int32_t ProgressInitialValue; // 0x20(0x04)
struct FName InteractActorTag; // 0x24(0x08)
char pad_2C[0x4]; // 0x2c(0x04)
struct TSoftObjectPtr<struct US_ItemData> ItemData; // 0x30(0x28)
struct APawn* PawnClass; // 0x58(0x08)
struct FName PawnTag; // 0x60(0x08)
enum class ES_ScavAITeams PawnTeamId; // 0x68(0x01)
char pad_69[0x3]; // 0x69(0x03)
float PawnMarkerRange; // 0x6c(0x04)
struct AActor* Actor; // 0x70(0x08)
struct FVector AreaCenter; // 0x78(0x0c)
float AreaRadius; // 0x84(0x04)
float AreaTimeLimitInSeconds; // 0x88(0x04)
float TimeLimitInSeconds; // 0x8c(0x04)
struct FS_MarkerDescriptor MarkerDescriptor; // 0x90(0x40)
int32_t RewardScore; // 0xd0(0x04)
char pad_D4[0x4]; // 0xd4(0x04)
};
// ScriptStruct Scavenger.S_MarkerDescriptor
// Size: 0x40 (Inherited: 0x00)
struct FS_MarkerDescriptor {
struct FName LabelId; // 0x00(0x08)
int32_t Flags; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
struct AActor* Actor; // 0x10(0x08)
struct FLinearColor Color; // 0x18(0x10)
struct FVector Location; // 0x28(0x0c)
struct FVector Offset; // 0x34(0x0c)
};
// ScriptStruct Scavenger.S_MarkerHandle
// Size: 0x0c (Inherited: 0x00)
struct FS_MarkerHandle {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_ObjectiveContainer
// Size: 0x68 (Inherited: 0x00)
struct FS_ObjectiveContainer {
char pad_0[0x8]; // 0x00(0x08)
struct TSet<struct AS_PlayerController*> SetOfPlayersNotifiedAboutStart; // 0x08(0x50)
char pad_58[0x8]; // 0x58(0x08)
struct US_Objective* objective; // 0x60(0x08)
};
// ScriptStruct Scavenger.S_OnlineCatalogItemContents
// Size: 0xa0 (Inherited: 0x00)
struct FS_OnlineCatalogItemContents {
struct TMap<struct FName, int32_t> CurrencyIdToCount; // 0x00(0x50)
struct TMap<struct FName, int32_t> EntitlementIdToCount; // 0x50(0x50)
};
// ScriptStruct Scavenger.S_OnlineEventMetadata
// Size: 0x50 (Inherited: 0x10)
struct FS_OnlineEventMetadata : FS_MetadataTableRowBase {
struct FDataTableRowHandle CarouselMetadata; // 0x10(0x10)
struct FText Name; // 0x20(0x18)
struct FText Description; // 0x38(0x18)
};
// ScriptStruct Scavenger.S_OnlineGameTuningValues
// Size: 0x14 (Inherited: 0x00)
struct FS_OnlineGameTuningValues {
struct FName SalvageTypeNameAwardedForExtraction; // 0x00(0x08)
int32_t CloneBackupAmount3man; // 0x08(0x04)
int32_t CloneBackupAmount2man; // 0x0c(0x04)
int32_t CloneBackupIncrement; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_LobbyMessageHistoryEntry
// Size: 0x20 (Inherited: 0x00)
struct FS_LobbyMessageHistoryEntry {
char pad_0[0x20]; // 0x00(0x20)
};
// ScriptStruct Scavenger.S_SteamTokenInfo
// Size: 0x428 (Inherited: 0x00)
struct FS_SteamTokenInfo {
char pad_0[0x428]; // 0x00(0x428)
};
// ScriptStruct Scavenger.S_OnlineResearchProjectDefinition
// Size: 0x80 (Inherited: 0x00)
struct FS_OnlineResearchProjectDefinition {
struct FName ID; // 0x00(0x08)
bool IsAssembly; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct TMap<struct FName, int32_t> ResourceCost; // 0x10(0x50)
int32_t PowerCost; // 0x60(0x04)
int32_t ResearchTimeSecs; // 0x64(0x04)
struct FName OutputOnlineItemId; // 0x68(0x08)
struct FName RestrictionId; // 0x70(0x08)
struct FName ViewRestrictionId; // 0x78(0x08)
};
// ScriptStruct Scavenger.S_OnlineResearchProjectMetadata
// Size: 0x60 (Inherited: 0x58)
struct FS_OnlineResearchProjectMetadata : FS_DisplayableItemMetadata {
enum class ES_OnlineResearchProjectType Type; // 0x58(0x01)
char pad_59[0x7]; // 0x59(0x07)
};
// ScriptStruct Scavenger.S_OnlineDisassemblyProjectDefinition
// Size: 0x10 (Inherited: 0x00)
struct FS_OnlineDisassemblyProjectDefinition {
struct FName InputOnlineItemId; // 0x00(0x08)
struct FName OutputOnlineItemId; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_OnlineServiceManagerDataApiClientConnectionState
// Size: 0x128 (Inherited: 0x00)
struct FS_OnlineServiceManagerDataApiClientConnectionState {
struct US_OnlineClientRequestQueue* RequestQueue; // 0x00(0x08)
char pad_8[0x120]; // 0x08(0x120)
};
// ScriptStruct Scavenger.S_OnlineServiceEndpointConfigs
// Size: 0x10 (Inherited: 0x00)
struct FS_OnlineServiceEndpointConfigs {
struct TArray<struct FS_OnlineServiceEndpointConfig> Endpoints; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_OnlineServiceEndpointConfig
// Size: 0x88 (Inherited: 0x00)
struct FS_OnlineServiceEndpointConfig {
struct FString Identifier; // 0x00(0x10)
struct FString EndpointPingAddress; // 0x10(0x10)
struct FString ClientDataApiEndpointAddress; // 0x20(0x10)
struct FString ServerDataApiEndpointAddress; // 0x30(0x10)
struct FString ClientStaticContentBaseUrl; // 0x40(0x10)
struct FString AuthEndpointUrl; // 0x50(0x10)
int32_t MedianPingTimeMs; // 0x60(0x04)
enum class ES_EndpointPingStatus PingStatus; // 0x64(0x01)
char pad_65[0x23]; // 0x65(0x23)
};
// ScriptStruct Scavenger.S_ScavengersDataApiEmptyRequest
// Size: 0x01 (Inherited: 0x00)
struct FS_ScavengersDataApiEmptyRequest {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseAck
// Size: 0x01 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseAck {
char pad_0[0x1]; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_PlatformPurchaseRequest
// Size: 0x20 (Inherited: 0x00)
struct FS_PlatformPurchaseRequest {
struct TArray<struct FString> SDAOfferIds; // 0x00(0x10)
struct TArray<struct FString> PlatformSKUs; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_OnlineItemSortModeMetadata
// Size: 0x20 (Inherited: 0x08)
struct FS_OnlineItemSortModeMetadata : FTableRowBase {
enum class ES_OnlineItemSortMode SortMode; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FDataTableRowHandle LocalizedActionHandle; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_PlayerInstanceState
// Size: 0x150 (Inherited: 0x00)
struct FS_PlayerInstanceState {
struct FString PlayerId; // 0x00(0x10)
struct US_PlayerClassData* ClassData; // 0x10(0x08)
struct FString DisplayName; // 0x18(0x10)
enum class ES_OnlinePlatformType Platform; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
struct FString PlatformId; // 0x30(0x10)
int32_t TeamIndex; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
struct FS_CharacterLoadout GameplayLoadout; // 0x48(0x50)
struct FS_CosmeticLoadout CosmeticLoadout; // 0x98(0x50)
struct FS_CosmeticLoadout AccountCosmeticLoadout; // 0xe8(0x50)
struct FString PartyId; // 0x138(0x10)
bool bIsPartyLeader; // 0x148(0x01)
char pad_149[0x7]; // 0x149(0x07)
};
// ScriptStruct Scavenger.S_FeedbackQuestionContainer
// Size: 0x70 (Inherited: 0x00)
struct FS_FeedbackQuestionContainer {
struct TArray<struct FS_FeedbackQuestionFivePoint> DetailedFeedbackFivePointQuestions; // 0x00(0x10)
struct TArray<struct FS_FeedbackQuestionFreeText> DetailedFeedbackFreeTextQuestions; // 0x10(0x10)
struct TArray<struct FS_FeedbackQuestionFivePoint> PostMatchFivePointQuestions; // 0x20(0x10)
struct FS_FeedbackQuestionFreeText PostMatchFreeTextQuestion; // 0x30(0x10)
struct TArray<struct FS_FeedbackQuestionMultiChoice> PostMatchMultiChoiceQuestions; // 0x40(0x10)
struct TArray<struct FS_FeedbackQuestionFreeText> SocialHubFreeTextQuestions; // 0x50(0x10)
struct TArray<struct FS_FeedbackQuestionMultiChoice> SocialHubMultiChoiceQuestions; // 0x60(0x10)
};
// ScriptStruct Scavenger.S_FeedbackQuestionMultiChoice
// Size: 0x20 (Inherited: 0x00)
struct FS_FeedbackQuestionMultiChoice {
struct FString Question; // 0x00(0x10)
struct TArray<struct FString> Choices; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_FeedbackQuestionFreeText
// Size: 0x10 (Inherited: 0x00)
struct FS_FeedbackQuestionFreeText {
struct FString Question; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_FeedbackQuestionFivePoint
// Size: 0x30 (Inherited: 0x00)
struct FS_FeedbackQuestionFivePoint {
struct FString Question; // 0x00(0x10)
struct FString LowRatingLabel; // 0x10(0x10)
struct FString HighRatingLabel; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_PingEndpoint
// Size: 0x48 (Inherited: 0x00)
struct FS_PingEndpoint {
struct FString RegionCode; // 0x00(0x10)
struct FString EndpointAddress; // 0x10(0x10)
int32_t MedianPingTimeMs; // 0x20(0x04)
enum class ES_LobbyEndpointPingStatus PingStatus; // 0x24(0x01)
char pad_25[0x23]; // 0x25(0x23)
};
// ScriptStruct Scavenger.S_OnlinePlayerDataForceStateUpdateParams
// Size: 0x06 (Inherited: 0x00)
struct FS_OnlinePlayerDataForceStateUpdateParams {
char pad_0[0x6]; // 0x00(0x06)
};
// ScriptStruct Scavenger.S_OnlineCosmeticSelectionHistory
// Size: 0x50 (Inherited: 0x00)
struct FS_OnlineCosmeticSelectionHistory {
struct TMap<struct FName, struct FS_OnlineCosmeticSelectionHistoryForCharacter> CharacterIdToCosmeticSelectionHistory; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_OnlineCosmeticSelectionHistoryForCharacter
// Size: 0xf0 (Inherited: 0x00)
struct FS_OnlineCosmeticSelectionHistoryForCharacter {
struct TMap<enum class ES_LoadoutSlotType, struct FName> LoadoutSlotTypeToCosmeticSelections; // 0x00(0x50)
struct TMap<struct FName, struct FName> LoadoutItemIdToCosmeticItemId; // 0x50(0x50)
struct TMap<struct FName, struct FS_OnlineCosmeticSelectionHistoryForCosmeticItem> CosmeticItemIdToSubmaterialSelections; // 0xa0(0x50)
};
// ScriptStruct Scavenger.S_OnlineCosmeticSelectionHistoryForCosmeticItem
// Size: 0x10 (Inherited: 0x00)
struct FS_OnlineCosmeticSelectionHistoryForCosmeticItem {
struct TArray<struct FS_CosmeticLoadoutSubMaterialSelection> SubMaterialSelections; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_OnlineSeasonRewardDefinition
// Size: 0x70 (Inherited: 0x00)
struct FS_OnlineSeasonRewardDefinition {
struct FName ID; // 0x00(0x08)
struct FName entitlementId; // 0x08(0x08)
struct FString BaseAssetPath; // 0x10(0x10)
struct TMap<struct FString, struct FS_OnlineSeasonRewardLocalizationStrings> LocaleIdToLocalizationStrings; // 0x20(0x50)
};
// ScriptStruct Scavenger.S_OnlineSeasonRewardLocalizationStrings
// Size: 0x60 (Inherited: 0x00)
struct FS_OnlineSeasonRewardLocalizationStrings {
struct FText Name; // 0x00(0x18)
struct FText Description; // 0x18(0x18)
struct FText Subtitle; // 0x30(0x18)
struct FText Detail; // 0x48(0x18)
};
// ScriptStruct Scavenger.S_OnlineSeasonDefinition
// Size: 0x80 (Inherited: 0x00)
struct FS_OnlineSeasonDefinition {
struct FName ID; // 0x00(0x08)
struct FDateTime SeasonStart; // 0x08(0x08)
struct FDateTime SeasonEnd; // 0x10(0x08)
int32_t PointsPerTier; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct TArray<struct FS_OnlineSeasonTierDefinition> Tiers; // 0x20(0x10)
struct TMap<struct FString, struct FS_OnlineSeasonLocalizationStrings> LocaleIdToLocalizationStrings; // 0x30(0x50)
};
// ScriptStruct Scavenger.S_OnlineSeasonLocalizationStrings
// Size: 0x30 (Inherited: 0x00)
struct FS_OnlineSeasonLocalizationStrings {
struct FText Title; // 0x00(0x18)
struct FText Subtitle; // 0x18(0x18)
};
// ScriptStruct Scavenger.S_OnlineSeasonTierDefinition
// Size: 0x14 (Inherited: 0x00)
struct FS_OnlineSeasonTierDefinition {
int32_t Tier; // 0x00(0x04)
struct FName RewardId; // 0x04(0x08)
struct FName BattlePassRewardId; // 0x0c(0x08)
};
// ScriptStruct Scavenger.S_OnlineLeaderboardContents
// Size: 0x30 (Inherited: 0x00)
struct FS_OnlineLeaderboardContents {
struct FString ID; // 0x00(0x10)
struct FName StatName; // 0x10(0x08)
struct FDateTime LastUpdated; // 0x18(0x08)
struct TArray<struct FS_OnlineLeaderboardEntry> Entries; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_OnlineLeaderboardEntry
// Size: 0x28 (Inherited: 0x00)
struct FS_OnlineLeaderboardEntry {
struct FString PlayerId; // 0x00(0x10)
struct FString playerDisplayName; // 0x10(0x10)
int32_t Position; // 0x20(0x04)
int32_t Score; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_OnlineLeaderboardDefinition
// Size: 0x28 (Inherited: 0x00)
struct FS_OnlineLeaderboardDefinition {
struct FString ID; // 0x00(0x10)
struct FName StatName; // 0x10(0x08)
enum class ES_OnlineLeaderboardSortOrder OrderAscDec; // 0x18(0x01)
char pad_19[0x3]; // 0x19(0x03)
int32_t NumEntries; // 0x1c(0x04)
int32_t TimespanHours; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_OnlineChallengeDefinition
// Size: 0x30 (Inherited: 0x00)
struct FS_OnlineChallengeDefinition {
struct FName ID; // 0x00(0x08)
struct FName LocalizationID; // 0x08(0x08)
struct TArray<struct FS_OnlineChallengeCriteriaDefinition> Criteria; // 0x10(0x10)
struct TArray<struct FS_OnlineChallengeMilestoneDefinition> Milestones; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_OnlineChallengeMilestoneDefinition
// Size: 0x18 (Inherited: 0x00)
struct FS_OnlineChallengeMilestoneDefinition {
int32_t Target; // 0x00(0x04)
struct FName RewardEntitlementId; // 0x04(0x08)
struct FName BattlePassRewardEntitlementId; // 0x0c(0x08)
int32_t SeasonPoints; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_OnlineChallengeCriteriaDefinition
// Size: 0x20 (Inherited: 0x00)
struct FS_OnlineChallengeCriteriaDefinition {
struct FName CriteriaScope; // 0x00(0x08)
struct FName CriteriaType; // 0x08(0x08)
struct FName ParamId; // 0x10(0x08)
int32_t ParamMin; // 0x18(0x04)
int32_t ParamMax; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_OnlineRestrictionMetadata
// Size: 0x58 (Inherited: 0x58)
struct FS_OnlineRestrictionMetadata : FS_DisplayableItemMetadata {
};
// ScriptStruct Scavenger.S_OnlineRestrictionDefinition
// Size: 0x18 (Inherited: 0x00)
struct FS_OnlineRestrictionDefinition {
struct FName ID; // 0x00(0x08)
struct TArray<struct FS_OnlineRestrictionTerm> Terms; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_OnlineRestrictionTerm
// Size: 0x30 (Inherited: 0x00)
struct FS_OnlineRestrictionTerm {
enum class ES_OnlineRestrictionType Type; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString ParamId; // 0x08(0x10)
struct FString ParamTag; // 0x18(0x10)
int32_t ParamMin; // 0x28(0x04)
int32_t ParamMax; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_EquippedRecipe
// Size: 0x0c (Inherited: 0x00)
struct FS_EquippedRecipe {
int32_t Index; // 0x00(0x04)
struct FName ID; // 0x04(0x08)
};
// ScriptStruct Scavenger.S_OnlineCharacterDefinition
// Size: 0xc8 (Inherited: 0x00)
struct FS_OnlineCharacterDefinition {
struct FName ClassId; // 0x00(0x08)
struct TArray<struct FName> ValidUnlocks; // 0x08(0x10)
struct TArray<struct FName> CosmeticDefaults; // 0x18(0x10)
struct FS_CosmeticLoadout DefaultCosmeticLoadout; // 0x28(0x50)
struct TMap<int32_t, struct FName> CharacterLevelToCatalogItemId; // 0x78(0x50)
};
// ScriptStruct Scavenger.S_OnlineStoreFrontMetadata
// Size: 0x48 (Inherited: 0x10)
struct FS_OnlineStoreFrontMetadata : FS_MetadataTableRowBase {
struct FDataTableRowHandle LocalizedTitleHandle; // 0x10(0x10)
struct TSoftObjectPtr<struct UTexture2D> Icon; // 0x20(0x28)
};
// ScriptStruct Scavenger.S_OnlineStoreOfferMetadata
// Size: 0x48 (Inherited: 0x10)
struct FS_OnlineStoreOfferMetadata : FS_MetadataTableRowBase {
struct FDataTableRowHandle LocalizedTitleHandle; // 0x10(0x10)
struct FDataTableRowHandle LocalizedSubtitleHandle; // 0x20(0x10)
struct FDataTableRowHandle LocalizedDescriptionHandle; // 0x30(0x10)
struct FName PurchaseRestrictionId; // 0x40(0x08)
};
// ScriptStruct Scavenger.S_OnlineStoreFrontDefinition
// Size: 0x88 (Inherited: 0x00)
struct FS_OnlineStoreFrontDefinition {
struct FName ID; // 0x00(0x08)
struct TArray<struct FName> SortedOfferIds; // 0x08(0x10)
int32_t SortOrder; // 0x18(0x04)
struct FName ViewRestrictionId; // 0x1c(0x08)
char pad_24[0x4]; // 0x24(0x04)
struct TMap<struct FString, struct FS_OnlineStoreFrontLocalizationStrings> LocaleIdToLocalizationStrings; // 0x28(0x50)
struct FString Layout; // 0x78(0x10)
};
// ScriptStruct Scavenger.S_OnlineStoreFrontLocalizationStrings
// Size: 0x18 (Inherited: 0x00)
struct FS_OnlineStoreFrontLocalizationStrings {
struct FText Title; // 0x00(0x18)
};
// ScriptStruct Scavenger.S_OnlineStoreOfferDefinition
// Size: 0x100 (Inherited: 0x00)
struct FS_OnlineStoreOfferDefinition {
struct FName ID; // 0x00(0x08)
bool IsOfferBundle; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FName CatalogEntryId; // 0x0c(0x08)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<struct FName> OfferBundleOfferList; // 0x18(0x10)
struct TMap<struct FName, int32_t> CurrencyCost; // 0x28(0x50)
int32_t DisplayWeight; // 0x78(0x04)
char pad_7C[0x4]; // 0x7c(0x04)
struct FString BaseAssetPath; // 0x80(0x10)
struct FString PlatformSku; // 0x90(0x10)
struct TMap<struct FString, struct FS_OnlineStoreOfferLocalizationStrings> LocaleIdToLocalizationStrings; // 0xa0(0x50)
struct FName PurchaseRestrictionId; // 0xf0(0x08)
struct FName ViewRestrictionId; // 0xf8(0x08)
};
// ScriptStruct Scavenger.S_OnlineStoreOfferLocalizationStrings
// Size: 0x60 (Inherited: 0x00)
struct FS_OnlineStoreOfferLocalizationStrings {
struct FText Name; // 0x00(0x18)
struct FText Description; // 0x18(0x18)
struct FText Subtitle; // 0x30(0x18)
struct FText Detail; // 0x48(0x18)
};
// ScriptStruct Scavenger.S_OnlineDropTableDefinition
// Size: 0x18 (Inherited: 0x00)
struct FS_OnlineDropTableDefinition {
struct FName ID; // 0x00(0x08)
struct TArray<struct FS_OnlineDropTableDropEntry> Entries; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_OnlineDropTableDropEntry
// Size: 0x10 (Inherited: 0x00)
struct FS_OnlineDropTableDropEntry {
int32_t DropWeight; // 0x00(0x04)
struct FName OutputOnlineItemId; // 0x04(0x08)
int32_t Quantity; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_OnlineResourceItemMetadata
// Size: 0x68 (Inherited: 0x60)
struct FS_OnlineResourceItemMetadata : FS_DisplayableItemWithRarityMetadata {
enum class ES_OnlineResourceType Type; // 0x60(0x01)
char pad_61[0x7]; // 0x61(0x07)
};
// ScriptStruct Scavenger.S_OnlineCurrencyDefinition
// Size: 0x08 (Inherited: 0x00)
struct FS_OnlineCurrencyDefinition {
struct FName ID; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_OnlineCurrencyMetadata
// Size: 0x60 (Inherited: 0x60)
struct FS_OnlineCurrencyMetadata : FS_DisplayableItemWithRarityMetadata {
};
// ScriptStruct Scavenger.S_OnlineCatalogItemDefinition
// Size: 0x68 (Inherited: 0x00)
struct FS_OnlineCatalogItemDefinition {
struct FName ID; // 0x00(0x08)
struct FString BackendId; // 0x08(0x10)
struct TArray<struct FString> Tags; // 0x18(0x10)
struct FName ItemClass; // 0x28(0x08)
bool IsBundle; // 0x30(0x01)
bool IsUnique; // 0x31(0x01)
bool IsStackable; // 0x32(0x01)
char pad_33[0x5]; // 0x33(0x05)
struct FS_OnlineCatalogBundleDefinition BundleContents; // 0x38(0x30)
};
// ScriptStruct Scavenger.S_OnlineCatalogBundleDefinition
// Size: 0x30 (Inherited: 0x00)
struct FS_OnlineCatalogBundleDefinition {
struct TArray<struct FS_OnlineCatalogBundleCurrencyDraw> CurrencyDraws; // 0x00(0x10)
struct TArray<struct FS_OnlineCatalogBundleOnlineItemDraw> FixedDraws; // 0x10(0x10)
struct TArray<struct FS_OnlineCatalogBundleDropTableDraw> DropTableDraws; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_OnlineCatalogBundleDropTableDraw
// Size: 0x0c (Inherited: 0x00)
struct FS_OnlineCatalogBundleDropTableDraw {
struct FName DropTableId; // 0x00(0x08)
float Draws; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_OnlineCatalogBundleOnlineItemDraw
// Size: 0x0c (Inherited: 0x00)
struct FS_OnlineCatalogBundleOnlineItemDraw {
struct FName OnlineItemId; // 0x00(0x08)
float Draws; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_OnlineCatalogBundleCurrencyDraw
// Size: 0x10 (Inherited: 0x00)
struct FS_OnlineCatalogBundleCurrencyDraw {
struct FName CurrencyId; // 0x00(0x08)
int32_t QuantityGranted; // 0x08(0x04)
float Draws; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_BakedOpportunityPointPtrWrapper
// Size: 0x08 (Inherited: 0x00)
struct FS_BakedOpportunityPointPtrWrapper {
char pad_0[0x8]; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_BakedOpportunityPoint
// Size: 0xc0 (Inherited: 0x00)
struct FS_BakedOpportunityPoint {
struct FS_OpportunityPointInfo OpportunityPoint; // 0x00(0x70)
struct FTransform PointTransform; // 0x70(0x30)
float LastUsedGameTimeSeconds; // 0xa0(0x04)
struct TWeakObjectPtr<struct AS_AIController> ReservedByController; // 0xa4(0x08)
struct TWeakObjectPtr<struct UObject> UserData; // 0xac(0x08)
bool HasBeenUsedEver; // 0xb4(0x01)
char pad_B5[0x3]; // 0xb5(0x03)
int32_t OpportunityPointID; // 0xb8(0x04)
char pad_BC[0x4]; // 0xbc(0x04)
};
// ScriptStruct Scavenger.S_OpportunityPointInfo
// Size: 0x70 (Inherited: 0x00)
struct FS_OpportunityPointInfo {
bool NeedsMontageKey; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FName MontageKey; // 0x04(0x08)
char pad_C[0x4]; // 0x0c(0x04)
struct FString TextOpportunityType; // 0x10(0x10)
enum class ES_OpportunityPointWeatherType OpportunityPointWeather; // 0x20(0x01)
char pad_21[0x3]; // 0x21(0x03)
float CooldownTime; // 0x24(0x04)
float TimeBeforeActive; // 0x28(0x04)
float UseRadius; // 0x2c(0x04)
bool OnlyActiveDuringTimeOfDay; // 0x30(0x01)
char pad_31[0x3]; // 0x31(0x03)
float TimeOfDayStartActive; // 0x34(0x04)
float TimeOfDayStopActive; // 0x38(0x04)
bool LoopForever; // 0x3c(0x01)
bool UseOnce; // 0x3d(0x01)
bool AbortOnDamage; // 0x3e(0x01)
bool CharacterShouldRunToUse; // 0x3f(0x01)
bool NonStateMachine; // 0x40(0x01)
bool ForceStowWeapon; // 0x41(0x01)
bool OverlordMustAssign; // 0x42(0x01)
bool Enabled; // 0x43(0x01)
char pad_44[0x4]; // 0x44(0x04)
struct TArray<enum class ES_CombatState> ValidCombatStates; // 0x48(0x10)
int32_t Priority; // 0x58(0x04)
bool StoreParentInUserData; // 0x5c(0x01)
char pad_5D[0x3]; // 0x5d(0x03)
struct TArray<SoftClassProperty> AllowedCharacterList; // 0x60(0x10)
};
// ScriptStruct Scavenger.S_OverrideConfig
// Size: 0x68 (Inherited: 0x08)
struct FS_OverrideConfig : FTableRowBase {
struct FString TableName; // 0x08(0x10)
struct FString TableRow; // 0x18(0x10)
struct FString ColumnName; // 0x28(0x10)
enum class ES_OverrideType ValueType; // 0x38(0x01)
char pad_39[0x3]; // 0x39(0x03)
float asFloat; // 0x3c(0x04)
int32_t asInt; // 0x40(0x04)
struct FVector asVector; // 0x44(0x0c)
struct FString AsString; // 0x50(0x10)
bool AsBool; // 0x60(0x01)
char pad_61[0x7]; // 0x61(0x07)
};
// ScriptStruct Scavenger.S_PhysicalSurfaceData
// Size: 0x40 (Inherited: 0x08)
struct FS_PhysicalSurfaceData : FTableRowBase {
enum class EPhysicalSurface PhysicalSurface; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FS_PhysicalSurfaceAttribute CharacterSprintSpeedMax; // 0x0c(0x08)
struct FS_PhysicalSurfaceAttribute CharacterWalkSpeedMax; // 0x14(0x08)
struct FS_PhysicalSurfaceAttribute CharacterWalkSpeedCrouchedMax; // 0x1c(0x08)
struct FS_PhysicalSurfaceAttribute CharacterSlideSpeedMultiplier; // 0x24(0x08)
struct FS_PhysicalSurfaceAttribute CharacterSlideAccLerpSpeed; // 0x2c(0x08)
struct FS_PhysicalSurfaceAttribute CharacterSlideBreakLerpSpeed; // 0x34(0x08)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_PhysicalSurfaceAttribute
// Size: 0x08 (Inherited: 0x00)
struct FS_PhysicalSurfaceAttribute {
bool bApplyAttribute; // 0x00(0x01)
enum class ES_PhysicalSurfaceAttribMod ModType; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
float Value; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_AutoPingDisplayData
// Size: 0xc8 (Inherited: 0x00)
struct FS_AutoPingDisplayData {
struct FS_PingDisplayData PingDisplayData; // 0x00(0x78)
struct TMap<enum class ES_PingInfoType, struct FS_PingDisplayData> PingDisplayDataOverrides; // 0x78(0x50)
};
// ScriptStruct Scavenger.S_PingDisplayData
// Size: 0x78 (Inherited: 0x00)
struct FS_PingDisplayData {
struct FVector2D Scale[0x2]; // 0x00(0x10)
struct UMaterialInterface* Materials[0x2]; // 0x10(0x10)
struct FText PingMessageOverride; // 0x20(0x18)
bool AlwaysDisplayIcon; // 0x38(0x01)
bool bShouldSendToMessageFeed; // 0x39(0x01)
bool bShouldDisplayOnMap; // 0x3a(0x01)
bool bShouldGutterOnMap; // 0x3b(0x01)
char pad_3C[0x4]; // 0x3c(0x04)
struct FDataTableRowHandle LocalizedPingNameHandle; // 0x40(0x10)
struct TSoftObjectPtr<struct UTexture2D> PingMenuIcon; // 0x50(0x28)
};
// ScriptStruct Scavenger.S_PingChannel
// Size: 0x38 (Inherited: 0x00)
struct FS_PingChannel {
struct TArray<enum class ES_PingInfoType> PingTypes; // 0x00(0x10)
struct TArray<enum class ES_AutoPingType> AutoPingTypes; // 0x10(0x10)
float Lifetime; // 0x20(0x04)
bool FollowActor; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
int32_t MaxPingCount; // 0x28(0x04)
float RepeatPingDelay; // 0x2c(0x04)
bool SameTargetClearsPing; // 0x30(0x01)
char pad_31[0x7]; // 0x31(0x07)
};
// ScriptStruct Scavenger.S_PingItemInfo
// Size: 0x28 (Inherited: 0x00)
struct FS_PingItemInfo {
struct FVector PingLocation; // 0x00(0x0c)
enum class ES_PingInfoType PingType; // 0x0c(0x01)
enum class ES_AutoPingType AutoPingType; // 0x0d(0x01)
bool bCanSendActor; // 0x0e(0x01)
char pad_F[0x1]; // 0x0f(0x01)
float OffscreenTracking; // 0x10(0x04)
float LifetimeOverride; // 0x14(0x04)
struct AActor* PingedActor; // 0x18(0x08)
enum class ES_StatType StatType; // 0x20(0x01)
enum class ES_CurrencyType CurrencyType; // 0x21(0x01)
char pad_22[0x6]; // 0x22(0x06)
};
// ScriptStruct Scavenger.S_KeeperAbilityTaskState
// Size: 0x18 (Inherited: 0x00)
struct FS_KeeperAbilityTaskState {
struct FString TaskInstanceName; // 0x00(0x10)
bool HasFinished; // 0x10(0x01)
enum class ES_KeeperAbilityTaskCompletionFunctions OutgoingFunctionDelegate; // 0x11(0x01)
char pad_12[0x6]; // 0x12(0x06)
};
// ScriptStruct Scavenger.S_KeeperStateInfo
// Size: 0x20 (Inherited: 0x00)
struct FS_KeeperStateInfo {
struct UActorComponent* attachmentComponent; // 0x00(0x08)
struct FName attachmentSocketName; // 0x08(0x08)
struct AS_InteractableActor* itemInteractingWith; // 0x10(0x08)
bool usingAbility; // 0x18(0x01)
char pad_19[0x1]; // 0x19(0x01)
enum class ES_KeeperCloakState CloakState; // 0x1a(0x01)
char pad_1B[0x5]; // 0x1b(0x05)
};
// ScriptStruct Scavenger.S_CriticalHealth
// Size: 0x0c (Inherited: 0x00)
struct FS_CriticalHealth {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_CriticalHealthConfig
// Size: 0x18 (Inherited: 0x00)
struct FS_CriticalHealthConfig {
float CriticalThreshold; // 0x00(0x04)
float FadeInDuration; // 0x04(0x04)
float HoldDuration; // 0x08(0x04)
float FadeOutDuration; // 0x0c(0x04)
struct UMaterialParameterCollection* ParameterCollection; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_ScreenDamageIndicators
// Size: 0x80 (Inherited: 0x00)
struct FS_ScreenDamageIndicators {
char pad_0[0x60]; // 0x00(0x60)
float FadeInDuration; // 0x60(0x04)
float HoldDuration; // 0x64(0x04)
float FadeOutDuration; // 0x68(0x04)
char pad_6C[0x4]; // 0x6c(0x04)
struct UMaterialParameterCollection* SeepCollection; // 0x70(0x08)
struct UMaterialParameterCollection* FadeCollection; // 0x78(0x08)
};
// ScriptStruct Scavenger.S_InteractableSound
// Size: 0x18 (Inherited: 0x00)
struct FS_InteractableSound {
enum class ES_InteractIcon interactionType; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct UAkAudioEvent* StartInteractionSound; // 0x08(0x08)
struct UAkAudioEvent* StopInteractionSound; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_InputQueue
// Size: 0x08 (Inherited: 0x00)
struct FS_InputQueue {
char pad_0[0x4]; // 0x00(0x04)
float QueueMaxTime; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_InteractionState
// Size: 0x48 (Inherited: 0x00)
struct FS_InteractionState {
struct FS_InteractableItem InteractableItem; // 0x00(0x40)
enum class ES_Interaction interactionType; // 0x40(0x01)
bool isTimedInteraction; // 0x41(0x01)
char pad_42[0x6]; // 0x42(0x06)
};
// ScriptStruct Scavenger.S_PlayerClassMetadataTableRowReference
// Size: 0x20 (Inherited: 0x00)
struct FS_PlayerClassMetadataTableRowReference {
struct FDataTableRowHandle Handle; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_PlayerClassMetadata
// Size: 0x2d0 (Inherited: 0x08)
struct FS_PlayerClassMetadata : FTableRowBase {
struct FName ID; // 0x08(0x08)
struct FText ClassName; // 0x10(0x18)
struct FText ClassNameCapitalized; // 0x28(0x18)
struct FText CharacterName; // 0x40(0x18)
struct FText CharacterNameCapitalized; // 0x58(0x18)
struct FText Description; // 0x70(0x18)
int32_t CharacterFlags; // 0x88(0x04)
char pad_8C[0x4]; // 0x8c(0x04)
struct FDataTableRowHandle AbilityMetadataHandle; // 0x90(0x10)
struct FS_RecipeMetadataHandle RecipeMetadata; // 0xa0(0x20)
struct FS_RecipeMetadataHandle ClassWeaponRecipeMetadata; // 0xc0(0x20)
struct UTexture2D* ActiveTalentPanelBackgroundImage; // 0xe0(0x08)
struct TSoftObjectPtr<struct US_PlayerClassData> PlayerClassData; // 0xe8(0x28)
struct FS_CharacterMovementOverrides CharacterMovement; // 0x110(0x168)
struct TMap<enum class ES_TraitGroupType, enum class ES_TraitGroup> Traits; // 0x278(0x50)
struct US_PlayerClassAvatarData* PlayerClassAvatarData; // 0x2c8(0x08)
};
// ScriptStruct Scavenger.S_RecipeMetadataHandle
// Size: 0x20 (Inherited: 0x00)
struct FS_RecipeMetadataHandle {
struct FDataTableRowHandle Handle; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_KeeperInteractionState
// Size: 0x0c (Inherited: 0x00)
struct FS_KeeperInteractionState {
struct TWeakObjectPtr<struct AS_InteractableActor> InteractableActor; // 0x00(0x08)
float ServerEndTime; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_ReplicatedActionResult
// Size: 0x08 (Inherited: 0x00)
struct FS_ReplicatedActionResult {
uint32_t ReplicationKey; // 0x00(0x04)
enum class ES_ReplicatedActionResult ReplicatedActionResult; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
};
// ScriptStruct Scavenger.S_ActorUnderReticle
// Size: 0x18 (Inherited: 0x00)
struct FS_ActorUnderReticle {
struct AActor* Actor; // 0x00(0x08)
float Strength; // 0x08(0x04)
float Distance; // 0x0c(0x04)
float CylinderOverlap; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ServerHeartbeatResponse
// Size: 0x08 (Inherited: 0x00)
struct FS_ServerHeartbeatResponse {
int32_t m_echoedHeartbeatValue; // 0x00(0x04)
float m_serverRealTimeAtSend; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_CinematicCameraSettings
// Size: 0x08 (Inherited: 0x00)
struct FS_CinematicCameraSettings {
struct ASpectatorPawn* PawnClass; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_ReviveState
// Size: 0x14 (Inherited: 0x00)
struct FS_ReviveState {
struct TWeakObjectPtr<struct APawn> ReviverPawn; // 0x00(0x08)
struct TWeakObjectPtr<struct AS_PlayerState> ReviverPlayerState; // 0x08(0x08)
float ReviveTimeLeft; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_PlayerObjectiveMarkerBase
// Size: 0x48 (Inherited: 0x00)
struct FS_PlayerObjectiveMarkerBase {
int32_t UniqueId; // 0x00(0x04)
int32_t ParentUniqueId; // 0x04(0x04)
struct FName LabelId; // 0x08(0x08)
uint32_t InternalFlags; // 0x10(0x04)
int32_t Flags; // 0x14(0x04)
struct AActor* Actor; // 0x18(0x08)
struct FLinearColor Color; // 0x20(0x10)
struct FVector Location; // 0x30(0x0c)
struct FVector Offset; // 0x3c(0x0c)
};
// ScriptStruct Scavenger.S_PlayerObjective
// Size: 0x58 (Inherited: 0x00)
struct FS_PlayerObjective {
struct FS_PlayerObjectiveBase Base; // 0x00(0x4c)
struct FS_PlayerObjectiveDelta Delta; // 0x4c(0x0c)
};
// ScriptStruct Scavenger.S_TeammateState
// Size: 0x30 (Inherited: 0x00)
struct FS_TeammateState {
struct APlayerState* PlayerState; // 0x00(0x08)
struct US_PlayerClassData* ClassData; // 0x08(0x08)
struct TArray<struct FS_TeammateLoadoutItem> Loadout; // 0x10(0x10)
struct FString AccountId; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_TeammateLoadoutItem
// Size: 0x0c (Inherited: 0x00)
struct FS_TeammateLoadoutItem {
enum class ES_TeammateLoadoutItemType Type; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FName ID; // 0x04(0x08)
};
// ScriptStruct Scavenger.S_PlayerSpawnPoint
// Size: 0x40 (Inherited: 0x00)
struct FS_PlayerSpawnPoint {
char pad_0[0x10]; // 0x00(0x10)
struct FTransform SpawnTransform; // 0x10(0x30)
};
// ScriptStruct Scavenger.S_PostMatchStatRowData
// Size: 0x40 (Inherited: 0x00)
struct FS_PostMatchStatRowData {
struct FDataTableRowHandle TextHandle; // 0x00(0x10)
struct FS_RewardPresentationStatScore StatScore; // 0x10(0x28)
enum class ES_PostMatchStatType StatType; // 0x38(0x01)
char pad_39[0x7]; // 0x39(0x07)
};
// ScriptStruct Scavenger.S_RewardPresentationStatScore
// Size: 0x28 (Inherited: 0x00)
struct FS_RewardPresentationStatScore {
struct FString StatId; // 0x00(0x10)
int32_t DisplayedCount; // 0x10(0x04)
int32_t TotalReward; // 0x14(0x04)
struct FString Context; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_PostMatchPhases
// Size: 0x10 (Inherited: 0x00)
struct FS_PostMatchPhases {
struct TArray<SoftClassProperty> PostMatchPhases; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_EndOfGameRankRecord
// Size: 0x08 (Inherited: 0x00)
struct FS_EndOfGameRankRecord {
int32_t TeamPlacement; // 0x00(0x04)
int32_t ScoredDataPoints; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_TestPostMatchSummaryScreenParams
// Size: 0x98 (Inherited: 0x00)
struct FS_TestPostMatchSummaryScreenParams {
int32_t NumTeams; // 0x00(0x04)
int32_t NumPlayersPerTeam; // 0x04(0x04)
int32_t GameShards; // 0x08(0x04)
int32_t ForceStartingLevel; // 0x0c(0x04)
struct FName PlayerCharacterClass; // 0x10(0x08)
float DamageDoneMin; // 0x18(0x04)
float DamageDoneMax; // 0x1c(0x04)
float TimeSurvivedMin; // 0x20(0x04)
float TimeSurvivedMax; // 0x24(0x04)
float LifestreakPercentageMin; // 0x28(0x04)
float LifestreakPercentageMax; // 0x2c(0x04)
bool PlayerExtracted; // 0x30(0x01)
bool PlayerLeftEarly; // 0x31(0x01)
char pad_32[0x2]; // 0x32(0x02)
float TeamShardsHarvestedFractionMin; // 0x34(0x04)
float TeamShardsHarvestedFractionMax; // 0x38(0x04)
float TeamShardsExtractedFractionMin; // 0x3c(0x04)
float TeamShardsExtractedFractionMax; // 0x40(0x04)
int32_t TeamScrapCollectedMin; // 0x44(0x04)
int32_t TeamScrapCollectedMax; // 0x48(0x04)
int32_t TeamObjectivesCompletedMin; // 0x4c(0x04)
int32_t TeamObjectivesCompletedMax; // 0x50(0x04)
bool TeamVictory; // 0x54(0x01)
bool ShardTargetReached; // 0x55(0x01)
bool GlobalBoostMultiplierActive; // 0x56(0x01)
char pad_57[0x1]; // 0x57(0x01)
struct FName GlobalBoostId; // 0x58(0x08)
bool PersonalBoostMultiplierActive; // 0x60(0x01)
char pad_61[0x3]; // 0x61(0x03)
int32_t NumTeammateBoostMultipliers; // 0x64(0x04)
struct TArray<struct FString> TeammateNames; // 0x68(0x10)
struct TArray<struct FName> ExtractedSalvageItemRewards; // 0x78(0x10)
struct TArray<struct FS_OnlineUnseenRewardGrants> UnseenRewardGrantsOverride; // 0x88(0x10)
};
// ScriptStruct Scavenger.S_RewardPresentation
// Size: 0x78 (Inherited: 0x00)
struct FS_RewardPresentation {
struct TArray<struct FS_RewardPresentationStatScore> StatScores; // 0x00(0x10)
struct TArray<struct FS_RewardPresentationChallengeProgress> ChallengeCompletion; // 0x10(0x10)
struct TArray<struct FS_RewardPresentationProgressBarFill> ProgressBarFills; // 0x20(0x10)
int32_t TeamPlacement; // 0x30(0x04)
int32_t TeamCount; // 0x34(0x04)
int32_t BaseScore; // 0x38(0x04)
int32_t TotalScore; // 0x3c(0x04)
float BoostMultiplierGlobal; // 0x40(0x04)
float BoostMultiplierPersonal; // 0x44(0x04)
struct TArray<struct FS_BoostMultiplierContext> BoostMultiplierTeam; // 0x48(0x10)
struct TArray<struct FName> ExtractedSalvage; // 0x58(0x10)
struct TArray<struct FS_OnlineRewardGrant> SessionRewards; // 0x68(0x10)
};
// ScriptStruct Scavenger.S_RewardPresentationProgressBarFill
// Size: 0x40 (Inherited: 0x00)
struct FS_RewardPresentationProgressBarFill {
int32_t StartingLevel; // 0x00(0x04)
int32_t LevelStartingCXP; // 0x04(0x04)
int32_t NextLevelStartingCXP; // 0x08(0x04)
int32_t PlayerStartingCXP; // 0x0c(0x04)
int32_t PlayerFinalCXP; // 0x10(0x04)
bool LeveledUp; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
int32_t NewAccountLevel; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct TArray<struct FS_OnlineRewardGrant> CharacterLevelUpRewards; // 0x20(0x10)
struct TArray<struct FS_OnlineRewardGrant> AccountLevelUpRewards; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_RewardPresentationChallengeProgress
// Size: 0x28 (Inherited: 0x00)
struct FS_RewardPresentationChallengeProgress {
struct FText ChallengeName; // 0x00(0x18)
int32_t CXPReward; // 0x18(0x04)
int32_t StartingCompletion; // 0x1c(0x04)
int32_t TargetCompletion; // 0x20(0x04)
int32_t CompletedThisGame; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_PlayingEventInfo
// Size: 0x78 (Inherited: 0x00)
struct FS_PlayingEventInfo {
struct FS_QueuedEventSettings Settings; // 0x00(0x58)
char pad_58[0x10]; // 0x58(0x10)
struct UMovieSceneSequencePlayer* SequencePlayer; // 0x68(0x08)
struct ALevelSequenceActor* SequenceActor; // 0x70(0x08)
};
// ScriptStruct Scavenger.S_QueuedEventSettings
// Size: 0x58 (Inherited: 0x00)
struct FS_QueuedEventSettings {
struct FString EventName; // 0x00(0x10)
struct ULevelSequence* Sequence; // 0x10(0x08)
int32_t Priority; // 0x18(0x04)
struct TWeakObjectPtr<struct AActor> Instigator; // 0x1c(0x08)
char pad_24[0x4]; // 0x24(0x04)
struct FString Tag; // 0x28(0x10)
struct FDateTime ExpireTime; // 0x38(0x08)
int32_t MaxPlayCount; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
struct FDateTime DesiredStartTime; // 0x48(0x08)
float SnoozeTime; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
};
// ScriptStruct Scavenger.S_PriorityAudioTrim
// Size: 0x30 (Inherited: 0x00)
struct FS_PriorityAudioTrim {
int32_t TeamIndex; // 0x00(0x04)
bool TeamOnly; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
struct FString Tag; // 0x08(0x10)
bool ByTag; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
struct AActor* Instigator; // 0x20(0x08)
bool ByInstigator; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.S_PriorityAudioSettings
// Size: 0x40 (Inherited: 0x00)
struct FS_PriorityAudioSettings {
enum class ES_InterruptionUrgency Urgency; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t Priority; // 0x04(0x04)
struct FString Tag; // 0x08(0x10)
float MaxQueueTimeSeconds; // 0x18(0x04)
bool UseMaxQueueTime; // 0x1c(0x01)
char pad_1D[0x3]; // 0x1d(0x03)
int32_t MaxQueueLength; // 0x20(0x04)
bool UseMaxQueueLength; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
float MaxDistance; // 0x28(0x04)
bool UseMaxDistance; // 0x2c(0x01)
char pad_2D[0x3]; // 0x2d(0x03)
float StartDelaySeconds; // 0x30(0x04)
float PlayProbability; // 0x34(0x04)
float SnoozeTime; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_ProceduralLandmarkProp
// Size: 0x30 (Inherited: 0x00)
struct FS_ProceduralLandmarkProp {
struct AActor* ActorClass; // 0x00(0x08)
struct UStaticMesh* StaticMesh; // 0x08(0x08)
struct FVector WorldOffset; // 0x10(0x0c)
struct FVector RandomRotationLimits; // 0x1c(0x0c)
bool AdhereToSurfaceNormal; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.ProgressionTableRow
// Size: 0x10 (Inherited: 0x08)
struct FProgressionTableRow : FTableRowBase {
int32_t XPToNextLevel; // 0x08(0x04)
int32_t ScrapInventoryCapacity; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_ActorContainer
// Size: 0x10 (Inherited: 0x00)
struct FS_ActorContainer {
struct TArray<struct AS_ProjectileBase*> Actors; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_QueuedAction
// Size: 0xd0 (Inherited: 0x00)
struct FS_QueuedAction {
char pad_0[0x8]; // 0x00(0x08)
struct FS_ActionPayload m_actionPayload; // 0x08(0x20)
char pad_28[0xa8]; // 0x28(0xa8)
};
// ScriptStruct Scavenger.S_LoadedRecipes
// Size: 0x50 (Inherited: 0x00)
struct FS_LoadedRecipes {
struct TMap<enum class ES_LoadoutSlotType, struct FS_LoadedRecipesForSlot> LoadedRecipesForSlots; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_LoadedRecipesForSlot
// Size: 0x10 (Inherited: 0x00)
struct FS_LoadedRecipesForSlot {
struct TArray<struct US_RecipeData*> Data; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_GameScoreCardForPlayer
// Size: 0x60 (Inherited: 0x00)
struct FS_GameScoreCardForPlayer {
struct FS_PlayerScoreCard PlayerScoreCard; // 0x00(0x10)
int32_t TeamShardsHarvested; // 0x10(0x04)
int32_t TeamScrapCollected; // 0x14(0x04)
int32_t TeamExplorersExtracted; // 0x18(0x04)
int32_t TeamObjectivesCompleted; // 0x1c(0x04)
int32_t TeamShardsExtracted; // 0x20(0x04)
int32_t TeamShardsBanked; // 0x24(0x04)
int32_t TeamPlacement; // 0x28(0x04)
int32_t TeamVictory; // 0x2c(0x04)
int32_t CollectiveObjectiveComplete; // 0x30(0x04)
int32_t Total; // 0x34(0x04)
int32_t BoostedTotal; // 0x38(0x04)
float BoostMultiplierGlobal; // 0x3c(0x04)
struct FName GlobalBoostId; // 0x40(0x08)
float BoostMultiplierPersonal; // 0x48(0x04)
char pad_4C[0x4]; // 0x4c(0x04)
struct TArray<struct FS_BoostMultiplierContext> BoostMultiplierTeam; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_PlayerScoreCard
// Size: 0x10 (Inherited: 0x00)
struct FS_PlayerScoreCard {
int32_t PersonalTimeSurvived; // 0x00(0x04)
int32_t PersonalLifestreak; // 0x04(0x04)
int32_t PersonalDamageDone; // 0x08(0x04)
bool LeftEarly; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
};
// ScriptStruct Scavenger.S_GameScoringCondition
// Size: 0x08 (Inherited: 0x00)
struct FS_GameScoringCondition {
int32_t FailedCondition; // 0x00(0x04)
int32_t MetCondition; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_GameScoringMap
// Size: 0x58 (Inherited: 0x00)
struct FS_GameScoringMap {
struct TMap<int32_t, int32_t> ScoringMap; // 0x00(0x50)
int32_t DefaultScore; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
};
// ScriptStruct Scavenger.S_GameScoringMultiplier
// Size: 0x0c (Inherited: 0x00)
struct FS_GameScoringMultiplier {
int32_t Base; // 0x00(0x04)
float Multiplier; // 0x04(0x04)
int32_t Cap; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_PlatformToKeyMetadata
// Size: 0x58 (Inherited: 0x08)
struct FS_PlatformToKeyMetadata : FTableRowBase {
struct TMap<enum class ES_Platform, struct FSlateBrush> imageSetByPlatform; // 0x08(0x50)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlatformLoginData
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiPlatformLoginData {
struct FS_ScavengersDataApiPlatformXboxData Xbox; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlatformXboxData
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiPlatformXboxData {
struct FString UserToken; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseLeaderboardDefinitions
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseLeaderboardDefinitions {
struct TArray<struct FS_ScavengersDataApiLeaderboardDefinition> Leaderboards; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiLeaderboardDefinition
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiLeaderboardDefinition {
struct FString ID; // 0x00(0x10)
struct FString StatName; // 0x10(0x10)
struct FString OrderAscDec; // 0x20(0x10)
int32_t NumEntries; // 0x30(0x04)
int32_t TimespanHours; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseEvaluation
// Size: 0x01 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseEvaluation {
bool Pass; // 0x00(0x01)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientAnalyticsEventResponse
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientAnalyticsEventResponse {
struct FString EventId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseDeletionRequest
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseDeletionRequest {
struct FString DeletionRequestId; // 0x00(0x10)
struct FString PlayerId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseAuth
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseAuth {
struct FString PlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponsePlayer
// Size: 0x128 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponsePlayer {
struct FS_ScavengersDataApiPlayerState PlayerState; // 0x00(0xf0)
struct FS_ScavengersDataApiBanInfo Ban; // 0xf0(0x28)
struct FString PlayerSettings; // 0x118(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiBanInfo
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiBanInfo {
struct FString Reason; // 0x00(0x10)
int32_t Created; // 0x10(0x04)
int32_t Expires; // 0x14(0x04)
struct FString RequestorId; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlayerState
// Size: 0xf0 (Inherited: 0x00)
struct FS_ScavengersDataApiPlayerState {
struct FString PlayerId; // 0x00(0x10)
int32_t AccountCreatedTime; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString DisplayName; // 0x18(0x10)
int32_t Level; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct FString LastPlayedMatchId; // 0x30(0x10)
struct FS_ScavengersDataApiDailyOfferTemp DailyOfferTemp; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
struct TArray<struct FS_ScavengersDataApiKvpInt> PlayerFlags; // 0x48(0x10)
struct TArray<struct FS_ScavengersDataApiCosmeticSlot> PlayerCosmeticLoadout; // 0x58(0x10)
struct TArray<struct FS_ScavengersDataApiInventoryItem> Inventory; // 0x68(0x10)
struct TArray<struct FS_ScavengersDataApiPlayerCurrencyStatus> CurrencyStatus; // 0x78(0x10)
struct TArray<struct FS_ScavengersDataApiCharacterState> Characters; // 0x88(0x10)
struct TArray<struct FS_ScavengersDataApiResearchProjectInstance> ResearchProjects; // 0x98(0x10)
struct TArray<struct FS_ScavengersDataApiPlayerRewardInstance> UnseenRewards; // 0xa8(0x10)
struct FS_ScavengersDataApiXpBoosterStatus XpBooster; // 0xb8(0x18)
struct TArray<struct FS_ScavengersDataApiChallengeInstance> Challenges; // 0xd0(0x10)
struct TArray<struct FS_ScavengersDataApiSeasonState> seasons; // 0xe0(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiSeasonState
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiSeasonState {
struct FString ID; // 0x00(0x10)
int32_t Progress; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<int32_t> TiersPendingClaim; // 0x18(0x10)
struct TArray<int32_t> BattlePassTiersPendingClaim; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiChallengeInstance
// Size: 0x48 (Inherited: 0x00)
struct FS_ScavengersDataApiChallengeInstance {
struct FString ID; // 0x00(0x10)
struct FString SlotType; // 0x10(0x10)
struct FString ChallengeDefId; // 0x20(0x10)
int32_t ExpiresOn; // 0x30(0x04)
int32_t Progress; // 0x34(0x04)
struct TArray<int32_t> PendingClaim; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiXpBoosterStatus
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiXpBoosterStatus {
struct FString ID; // 0x00(0x10)
int32_t ExpiresOn; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlayerRewardInstance
// Size: 0x58 (Inherited: 0x00)
struct FS_ScavengersDataApiPlayerRewardInstance {
struct FString ID; // 0x00(0x10)
struct FString Source; // 0x10(0x10)
struct FString ContextStr; // 0x20(0x10)
int32_t ContextInt; // 0x30(0x04)
char pad_34[0x4]; // 0x34(0x04)
struct FString MatchID; // 0x38(0x10)
struct TArray<struct FS_ScavengersDataApiPlayerRewardGrant> Grants; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlayerRewardGrant
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiPlayerRewardGrant {
struct FString GrantType; // 0x00(0x10)
struct FString GrantId; // 0x10(0x10)
int32_t GrantAmount; // 0x20(0x04)
int32_t GrantStartingValue; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiResearchProjectInstance
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiResearchProjectInstance {
struct FString ResearchStationId; // 0x00(0x10)
struct FString ProjectDefinitionId; // 0x10(0x10)
int32_t StartTimeStampMs; // 0x20(0x04)
int32_t CompletionTimeStampMs; // 0x24(0x04)
struct TArray<struct FS_ScavengersDataApiKvpInt> ResourcesSpent; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiKvpInt
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiKvpInt {
struct FString Key; // 0x00(0x10)
int32_t Value; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCharacterState
// Size: 0x60 (Inherited: 0x00)
struct FS_ScavengersDataApiCharacterState {
struct FString ClassId; // 0x00(0x10)
struct FString CharacterId; // 0x10(0x10)
bool IsOwned; // 0x20(0x01)
char pad_21[0x3]; // 0x21(0x03)
int32_t CharacterXP; // 0x24(0x04)
int32_t CharacterLevel; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct TArray<struct FS_ScavengersDataApiInventoryItem> Inventory; // 0x30(0x10)
struct TArray<struct FS_ScavengersDataApiLoadoutSlot> Loadout; // 0x40(0x10)
struct TArray<struct FS_ScavengersDataApiCosmeticSlot> CosmeticLoadout; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCosmeticSlot
// Size: 0x40 (Inherited: 0x00)
struct FS_ScavengersDataApiCosmeticSlot {
struct FString ItemSlot; // 0x00(0x10)
struct FString CatalogEntryId; // 0x10(0x10)
struct FString ItemInstanceId; // 0x20(0x10)
struct TArray<struct FS_ScavengersDataApiCosmeticSubMaterialSelection> SubMaterialSelections; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCosmeticSubMaterialSelection
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiCosmeticSubMaterialSelection {
struct FString SubMaterialMetaId; // 0x00(0x10)
struct FString PaletteMetadataId; // 0x10(0x10)
int32_t ColorIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiLoadoutSlot
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiLoadoutSlot {
struct FString SlotId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiLoadoutSlotEntry> Entries; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiLoadoutSlotEntry
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiLoadoutSlotEntry {
struct FString CatalogEntryId; // 0x00(0x10)
struct FString InstanceID; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiInventoryItem
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiInventoryItem {
struct FString CatalogEntryId; // 0x00(0x10)
struct FString InstanceID; // 0x10(0x10)
int32_t Count; // 0x20(0x04)
int32_t ExpirationDate; // 0x24(0x04)
struct TArray<struct FS_ScavengersDataApiKvpString> ItemStrings; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiKvpString
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiKvpString {
struct FString Key; // 0x00(0x10)
struct FString Value; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlayerCurrencyStatus
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiPlayerCurrencyStatus {
struct FString CurrencyId; // 0x00(0x10)
int32_t Quantity; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<struct FS_ScavengersDataApiPlatformBalance> PlatformBalance; // 0x18(0x10)
int32_t RechargeMax; // 0x28(0x04)
int32_t RechargeRatePerDay; // 0x2c(0x04)
int32_t LastGrantTime; // 0x30(0x04)
int32_t LifetimeSpend; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlatformBalance
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiPlatformBalance {
int32_t Quantity; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString Platform; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiDailyOfferTemp
// Size: 0x04 (Inherited: 0x00)
struct FS_ScavengersDataApiDailyOfferTemp {
int32_t NextAvailableTime; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseLookupPlayer
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseLookupPlayer {
struct FString PlayerId; // 0x00(0x10)
int32_t AccountCreatedTime; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString DisplayName; // 0x18(0x10)
int32_t Level; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseCharacters
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseCharacters {
struct TArray<struct FS_ScavengersDataApiCosmeticSlot> PlayerCosmeticLoadout; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiCharacterState> Characters; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> PlayerFlags; // 0x20(0x10)
bool XpBoosterActive; // 0x30(0x01)
char pad_31[0x7]; // 0x31(0x07)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseLeaderboard
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseLeaderboard {
struct FString leaderboardId; // 0x00(0x10)
struct FString StatName; // 0x10(0x10)
int32_t TimeLastRefreshed; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct TArray<struct FS_ScavengersDataApiLeaderboardEntry> Entries; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiLeaderboardEntry
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiLeaderboardEntry {
struct FString PlayerId; // 0x00(0x10)
struct FString playerDisplayName; // 0x10(0x10)
int32_t Position; // 0x20(0x04)
int32_t Score; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseSetDisplayName
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseSetDisplayName {
struct FString DisplayName; // 0x00(0x10)
struct FString PlayerStateHash; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseImportData
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseImportData {
struct FString Error; // 0x00(0x10)
struct FString SheetTitle; // 0x10(0x10)
struct TArray<struct FString> Log; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseRefreshPlatformLogin
// Size: 0x04 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseRefreshPlatformLogin {
int32_t Expiry; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseGetPrivateConfigFile
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseGetPrivateConfigFile {
struct TArray<struct FS_ScavengersDataApiConfigEntry> ConfigEntries; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiConfigEntry
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiConfigEntry {
struct FString ConfigEntryName; // 0x00(0x10)
struct TArray<struct FString> Config; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseClaimChallenge
// Size: 0x50 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseClaimChallenge {
struct TArray<struct FS_ScavengersDataApiChallengeInstance> Challenges; // 0x00(0x10)
struct FS_ScavengersDataApiStateUpdate StateUpdate; // 0x10(0x40)
};
// ScriptStruct Scavenger.S_ScavengersDataApiStateUpdate
// Size: 0x40 (Inherited: 0x00)
struct FS_ScavengersDataApiStateUpdate {
struct TArray<struct FS_ScavengersDataApiInventoryItemTransaction> Items; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiCurrencyTransaction> Currencies; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiChallengeInstance> ChallengesUpdate; // 0x20(0x10)
struct FString PlayerStateHash; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCurrencyTransaction
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiCurrencyTransaction {
struct FString CurrencyId; // 0x00(0x10)
int32_t BalanceDelta; // 0x10(0x04)
int32_t NewBalance; // 0x14(0x04)
int32_t Rate; // 0x18(0x04)
int32_t Max; // 0x1c(0x04)
int32_t LastGrantTime; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiInventoryItemTransaction
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiInventoryItemTransaction {
struct FString CatalogEntryId; // 0x00(0x10)
struct FString InstanceID; // 0x10(0x10)
int32_t BalanceDelta; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseActivateXpBooster
// Size: 0x58 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseActivateXpBooster {
struct FS_ScavengersDataApiXpBoosterStatus XpBoosterState; // 0x00(0x18)
struct FS_ScavengersDataApiStateUpdate StateUpdate; // 0x18(0x40)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseResearchProjectHurry
// Size: 0x78 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseResearchProjectHurry {
struct FS_ScavengersDataApiResearchProjectInstance ProjectInstance; // 0x00(0x38)
struct FS_ScavengersDataApiStateUpdate StateUpdate; // 0x38(0x40)
};
// ScriptStruct Scavenger.S_ScavengersDataApiItemUnlock
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiItemUnlock {
int32_t Level; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct TArray<struct FString> ItemList; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientTitlePlayerEvent
// Size: 0x90 (Inherited: 0x00)
struct FS_ScavengersDataApiClientTitlePlayerEvent {
struct FString PlayerId; // 0x00(0x10)
struct FString PlayerInternalId; // 0x10(0x10)
struct FString Platform; // 0x20(0x10)
struct FString PlatformId; // 0x30(0x10)
struct FString LastPlayedMatchId; // 0x40(0x10)
int32_t AccountLevel; // 0x50(0x04)
char pad_54[0x4]; // 0x54(0x04)
struct FString Body; // 0x58(0x10)
struct FString EventName; // 0x68(0x10)
struct FString Timestamp; // 0x78(0x10)
bool IsSda; // 0x88(0x01)
char pad_89[0x7]; // 0x89(0x07)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientTitleEvent
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiClientTitleEvent {
struct FString Body; // 0x00(0x10)
struct FString EventName; // 0x10(0x10)
struct FString Timestamp; // 0x20(0x10)
bool IsSda; // 0x30(0x01)
char pad_31[0x7]; // 0x31(0x07)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientPlayerEvent
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiClientPlayerEvent {
struct FString Body; // 0x00(0x10)
struct FString EventName; // 0x10(0x10)
struct FString Timestamp; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerUpgradeAccount
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerUpgradeAccount {
struct FString PlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerDeleteStats
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerDeleteStats {
struct FString StatName; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerInvalidateLeaderboard
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerInvalidateLeaderboard {
struct FString leaderboardId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerUnbanPlayer
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerUnbanPlayer {
struct FString PlayerId; // 0x00(0x10)
struct FString Reason; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerBanPlayer
// Size: 0x40 (Inherited: 0x00)
struct FS_ScavengersDataApiServerBanPlayer {
struct FString PlayerId; // 0x00(0x10)
struct FString RequestorId; // 0x10(0x10)
int32_t DurationInHours; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString Reason; // 0x28(0x10)
struct FS_ScavengersDataApiBanOptions BanOptions; // 0x38(0x02)
char pad_3A[0x6]; // 0x3a(0x06)
};
// ScriptStruct Scavenger.S_ScavengersDataApiBanOptions
// Size: 0x02 (Inherited: 0x00)
struct FS_ScavengersDataApiBanOptions {
bool IpAddress; // 0x00(0x01)
bool DeviceID; // 0x01(0x01)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerUpdateDisplayName
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerUpdateDisplayName {
struct FString PlayerId; // 0x00(0x10)
struct FString DisplayName; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerSetPlayerTags
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerSetPlayerTags {
struct FString PlayerId; // 0x00(0x10)
struct FString Tags; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerDeletePlayerForever
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerDeletePlayerForever {
struct FString PlayerId; // 0x00(0x10)
struct FString DeletionRequestId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerRequestPlayerDeletion
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerRequestPlayerDeletion {
struct FString PlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerGetPlayer
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerGetPlayer {
struct FString PlayerId; // 0x00(0x10)
struct FString DisplayName; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerImportData
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiServerImportData {
struct FString SheetId; // 0x00(0x10)
struct FString DataJson; // 0x10(0x10)
struct FS_ScavengersDataApiImportDataOptions Params; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiImportDataOptions
// Size: 0x04 (Inherited: 0x00)
struct FS_ScavengersDataApiImportDataOptions {
bool ValidateOnly; // 0x00(0x01)
bool MacrogameData; // 0x01(0x01)
bool ConfigData; // 0x02(0x01)
bool LocalizationData; // 0x03(0x01)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerEvaluateRestriction
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerEvaluateRestriction {
struct FString PlayerId; // 0x00(0x10)
struct FString RestrictionId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerMigrateImprobableAccount
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerMigrateImprobableAccount {
struct FString CurrentImprobableId; // 0x00(0x10)
struct FString NewImprobableId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerGetCharacterStateForPlayer
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiServerGetCharacterStateForPlayer {
struct FString PlayerId; // 0x00(0x10)
struct FString characterClassId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerGetCharactersForPlayer
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerGetCharactersForPlayer {
struct FString PlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerValidateLoadout
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerValidateLoadout {
struct FString Todo; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerReportMatchEndResult
// Size: 0x58 (Inherited: 0x00)
struct FS_ScavengersDataApiServerReportMatchEndResult {
struct FString MatchID; // 0x00(0x10)
struct FString PlayerId; // 0x10(0x10)
struct FString CharacterId; // 0x20(0x10)
int32_t Xp; // 0x30(0x04)
char pad_34[0x4]; // 0x34(0x04)
struct TArray<struct FS_ScavengersDataApiKvpInt> ItemsToGrant; // 0x38(0x10)
struct TArray<struct FS_ScavengersDataApiPlayerStat> Stats; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlayerStat
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiPlayerStat {
struct FString Name; // 0x00(0x10)
int32_t Value; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerGrantCurrency
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiServerGrantCurrency {
struct FString PlayerId; // 0x00(0x10)
struct FString CurrencyId; // 0x10(0x10)
int32_t Amount; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString Reason; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerGrantItems
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiServerGrantItems {
struct FString PlayerId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> ItemsToGrant; // 0x10(0x10)
struct FString Reason; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerValidateAuth
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiServerValidateAuth {
struct FString Token; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerResponseConfigurationData
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiServerResponseConfigurationData {
struct TArray<struct FS_ScavengersDataApiKvpInt> FeatureFlags; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> TitleStrings; // 0x10(0x10)
struct TArray<struct FString> CharacterRoster; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiServerGetConfigurationData
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiServerGetConfigurationData {
struct FString Build; // 0x00(0x10)
struct FString Version; // 0x10(0x10)
struct FString VersionApi; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiErrorResponse
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiErrorResponse {
struct FString ID; // 0x00(0x10)
int32_t Code; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString ActionHint; // 0x18(0x10)
struct FString Description; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseAck
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseAck {
struct FString PlayerStateHash; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponse
// Size: 0x338 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponse {
struct FS_ScavengersDataApiLoginResult LoginResult; // 0x00(0x30)
struct FS_ScavengersDataApiStateHashes StateHashes; // 0x30(0x60)
struct FS_ScavengersDataApiConfigData ConfigData; // 0x90(0x20)
struct FS_ScavengersDataApiTitleData TitleData; // 0xb0(0xf0)
struct FS_ScavengersDataApiCatalogDefinition CatalogData; // 0x1a0(0x30)
struct FS_ScavengersDataApiStoreData StoreData; // 0x1d0(0x30)
struct FS_ScavengersDataApiPlayerState PlayerState; // 0x200(0xf0)
struct TArray<struct FS_ScavengersDataApiProgressRewardInstance> ProgressRewards; // 0x2f0(0x10)
struct TArray<struct FS_ScavengersDataApiLeaderboardDefinition> LeaderboardDefinitions; // 0x300(0x10)
struct TArray<struct FS_ScavengersDataApiReportReasonDefinition> ReportReasonDefinitions; // 0x310(0x10)
int32_t CurrentTimeMs; // 0x320(0x04)
char pad_324[0x4]; // 0x324(0x04)
struct FString PlayerPlatform; // 0x328(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiReportReasonDefinition
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiReportReasonDefinition {
struct FString Reason; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiProgressRewardInstance
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiProgressRewardInstance {
struct FString InstanceID; // 0x00(0x10)
struct FString Source; // 0x10(0x10)
struct FString RewardType; // 0x20(0x10)
int32_t Amount; // 0x30(0x04)
char pad_34[0x4]; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiStoreData
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiStoreData {
struct TArray<struct FS_ScavengersDataApiStoreOffer> Offers; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiStoreOfferBundle> OfferBundles; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiStoreFront> StoreFronts; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiStoreFront
// Size: 0x58 (Inherited: 0x00)
struct FS_ScavengersDataApiStoreFront {
struct FString storefrontId; // 0x00(0x10)
int32_t SortOrder; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<struct FString> OfferTags; // 0x18(0x10)
struct FString Layout; // 0x28(0x10)
struct FString ViewRestriction; // 0x38(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedTitle; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiStoreOfferBundle
// Size: 0xb8 (Inherited: 0x00)
struct FS_ScavengersDataApiStoreOfferBundle {
struct FString OfferBundleId; // 0x00(0x10)
struct TArray<struct FString> OfferList; // 0x10(0x10)
int32_t Weight; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct TArray<struct FS_ScavengersDataApiKvpInt> Price; // 0x28(0x10)
struct TArray<struct FString> Tags; // 0x38(0x10)
struct FString VisibilityRestriction; // 0x48(0x10)
struct FString PurchaseRestriction; // 0x58(0x10)
struct FString BaseAssetPath; // 0x68(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedDescriptions; // 0x78(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedNames; // 0x88(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedSubtitles; // 0x98(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedDetail; // 0xa8(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiStoreOffer
// Size: 0xc8 (Inherited: 0x00)
struct FS_ScavengersDataApiStoreOffer {
struct FString OfferId; // 0x00(0x10)
struct FString CatalogEntryId; // 0x10(0x10)
int32_t Weight; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct TArray<struct FS_ScavengersDataApiKvpInt> Price; // 0x28(0x10)
struct TArray<struct FString> Tags; // 0x38(0x10)
struct FString VisibilityRestriction; // 0x48(0x10)
struct FString PurchaseRestriction; // 0x58(0x10)
struct FString BaseAssetPath; // 0x68(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedDescriptions; // 0x78(0x10)
struct FString PlatformSku; // 0x88(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedNames; // 0x98(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedSubtitles; // 0xa8(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedDetail; // 0xb8(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCatalogDefinition
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiCatalogDefinition {
struct TArray<struct FS_ScavengersDataApiCatalogEntry> Entries; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiDropTable> DropTables; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiCurrency> Currencies; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCurrency
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiCurrency {
struct FString CurrencyCode; // 0x00(0x10)
struct FString DisplayName; // 0x10(0x10)
int32_t BaseRatePerDay; // 0x20(0x04)
int32_t BaseRechargeMax; // 0x24(0x04)
int32_t InitialLoad; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiDropTable
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiDropTable {
struct FString DropTableId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiDropTableEntry> Drops; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiDropTableEntry
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiDropTableEntry {
int32_t DropWeight; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString CatalogEntryId; // 0x08(0x10)
int32_t Quantity; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCatalogEntry
// Size: 0x110 (Inherited: 0x00)
struct FS_ScavengersDataApiCatalogEntry {
struct FString CatalogEntryId; // 0x00(0x10)
struct FString CatalogVersion; // 0x10(0x10)
struct FString LocalizedDisplayName; // 0x20(0x10)
struct FString LocalizedDescription; // 0x30(0x10)
struct TArray<struct FString> Tags; // 0x40(0x10)
struct FString Image; // 0x50(0x10)
struct FString ItemClass; // 0x60(0x10)
struct FString DisplayName; // 0x70(0x10)
struct FString Description; // 0x80(0x10)
struct FS_ScavengersDataApiConsumableInfo ConsumableInfo; // 0x90(0x18)
struct TArray<struct FS_ScavengersDataApiKvpInt> Prices; // 0xa8(0x10)
bool Stackable; // 0xb8(0x01)
bool Bundle; // 0xb9(0x01)
bool Unique; // 0xba(0x01)
char pad_BB[0x5]; // 0xbb(0x05)
struct FS_ScavengersDataApiCatalogContents Contents; // 0xc0(0x30)
struct TArray<struct FString> RestrictionDefinitions; // 0xf0(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> AdditionalProperties; // 0x100(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCatalogContents
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiCatalogContents {
struct TArray<struct FS_ScavengersDataApiCurrencyDraw> CurrencyDraws; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiFixedDraw> FixedDraws; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiDropTableDraw> DropTableDraws; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiDropTableDraw
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiDropTableDraw {
struct FString DropTableId; // 0x00(0x10)
int32_t Draws; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiFixedDraw
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiFixedDraw {
struct FString CatalogEntryId; // 0x00(0x10)
int32_t Draws; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCurrencyDraw
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiCurrencyDraw {
struct FString CurrencyCode; // 0x00(0x10)
int32_t QuantityGranted; // 0x10(0x04)
int32_t Draws; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiConsumableInfo
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiConsumableInfo {
int32_t UsageCount; // 0x00(0x04)
int32_t UsagePeriod; // 0x04(0x04)
struct FString UsagePeriodGroup; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiTitleData
// Size: 0xf0 (Inherited: 0x00)
struct FS_ScavengersDataApiTitleData {
struct TArray<struct FS_ScavengersDataApiKvpString> TitleStrings; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiLevelDefinition> AccountLevels; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiCharacterDefinition> CharacterDefinitions; // 0x20(0x10)
struct TArray<struct FS_ScavengersDataApiResearchProjectDefinition> ResearchProjectDefinitions; // 0x30(0x10)
struct TArray<struct FS_ScavengersDataApiResearchProjectHurryCost> ResearchProjectHurryCosts; // 0x40(0x10)
struct TArray<struct FS_ScavengersDataApiRestrictionDefinition> RestrictionDefinitions; // 0x50(0x10)
struct TArray<struct FS_ScavengersDataApiCurrency> Currencies; // 0x60(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> DisassemblyDefinitions; // 0x70(0x10)
struct TArray<struct FS_ScavengersDataApiAssemblyDefinition> AssemblyDefinitions; // 0x80(0x10)
struct TArray<struct FS_ScavengersDataApiXpBoosterDefinition> XpBoosterDefinitions; // 0x90(0x10)
struct FS_ScavengersDataApiTinkerData TinkerDefinitions; // 0xa0(0x20)
struct TArray<struct FS_ScavengersDataApiChallengeDefinition> ChallengeDefinitions; // 0xc0(0x10)
struct TArray<struct FS_ScavengersDataApiSeasonDefinition> SeasonDefinitions; // 0xd0(0x10)
struct TArray<struct FS_ScavengersDataApiSeasonRewardDefinition> SeasonRewardDefinitions; // 0xe0(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiSeasonRewardDefinition
// Size: 0x70 (Inherited: 0x00)
struct FS_ScavengersDataApiSeasonRewardDefinition {
struct FString ID; // 0x00(0x10)
struct FString entitlementId; // 0x10(0x10)
struct FString BaseAssetPath; // 0x20(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedDescriptions; // 0x30(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedNames; // 0x40(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedSubtitles; // 0x50(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedDetail; // 0x60(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiSeasonDefinition
// Size: 0x60 (Inherited: 0x00)
struct FS_ScavengersDataApiSeasonDefinition {
struct FString SeasonId; // 0x00(0x10)
int32_t SeasonStart; // 0x10(0x04)
int32_t SeasonEnd; // 0x14(0x04)
int32_t PointsPerTier; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct FString BattlePassCatalogEntryId; // 0x20(0x10)
struct TArray<struct FS_ScavengersDataApiSeasonTierDefinition> Tiers; // 0x30(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedTitles; // 0x40(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> LocalizedSubtitles; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiSeasonTierDefinition
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiSeasonTierDefinition {
int32_t Tier; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString RewardId; // 0x08(0x10)
struct FString BattlePassRewardId; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiChallengeDefinition
// Size: 0x40 (Inherited: 0x00)
struct FS_ScavengersDataApiChallengeDefinition {
struct FString ChallengeID; // 0x00(0x10)
struct FString LocalizationID; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiChallengeCriteriaDefinition> Criteria; // 0x20(0x10)
struct TArray<struct FS_ScavengersDataApiChallengeMilestoneDefinition> Milestones; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiChallengeMilestoneDefinition
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiChallengeMilestoneDefinition {
int32_t Target; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct FString RewardEntitlementId; // 0x08(0x10)
struct FString BattlePassRewardEntitlementId; // 0x18(0x10)
int32_t SeasonPoints; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiChallengeCriteriaDefinition
// Size: 0x38 (Inherited: 0x00)
struct FS_ScavengersDataApiChallengeCriteriaDefinition {
struct FString CriteriaScope; // 0x00(0x10)
struct FString CriteriaType; // 0x10(0x10)
struct FString ParamId; // 0x20(0x10)
int32_t ParamMin; // 0x30(0x04)
int32_t ParamMax; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiTinkerData
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiTinkerData {
struct TArray<struct FS_ScavengersDataApiTinkerAssignment> TinkerAssignments; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiTinkerPack> TinkerPacks; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiTinkerPack
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiTinkerPack {
struct FString TinkerPackId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiTinkerPackSlot> Slots; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiTinkerPackSlot
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiTinkerPackSlot {
struct FString SlotId; // 0x00(0x10)
struct FString SubMatId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiTinkerAssignment
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiTinkerAssignment {
struct FString entitlementId; // 0x00(0x10)
struct FString DefaultTinkerPackId; // 0x10(0x10)
struct TArray<struct FString> AllowedTinkerPackIdList; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiXpBoosterDefinition
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiXpBoosterDefinition {
struct FString ID; // 0x00(0x10)
int32_t DurationSeconds; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiAssemblyDefinition
// Size: 0x58 (Inherited: 0x00)
struct FS_ScavengersDataApiAssemblyDefinition {
struct FString RecipeId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> ResourceCost; // 0x10(0x10)
int32_t PowerCost; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString OutputCatalogEntryId; // 0x28(0x10)
struct FString RestrictionId; // 0x38(0x10)
struct FString ViewRestrictionId; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiRestrictionDefinition
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiRestrictionDefinition {
struct FString RestrictionId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiRestrictionTerm> Terms; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiRestrictionTerm
// Size: 0x50 (Inherited: 0x00)
struct FS_ScavengersDataApiRestrictionTerm {
struct FString RestrictionType; // 0x00(0x10)
bool ClientVisible; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct FString StringId; // 0x18(0x10)
struct FString ParamId; // 0x28(0x10)
struct FString ParamTag; // 0x38(0x10)
int32_t ParamMin; // 0x48(0x04)
int32_t ParamMax; // 0x4c(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiResearchProjectHurryCost
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiResearchProjectHurryCost {
int32_t TimePeriodSeconds; // 0x00(0x04)
int32_t Cost; // 0x04(0x04)
struct FString Currency; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiResearchProjectDefinition
// Size: 0x58 (Inherited: 0x00)
struct FS_ScavengersDataApiResearchProjectDefinition {
struct FString RecipeId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> ResourceCost; // 0x10(0x10)
int32_t PowerCost; // 0x20(0x04)
int32_t ResearchTimeSecs; // 0x24(0x04)
struct FString OutputCatalogEntryId; // 0x28(0x10)
struct FString RestrictionId; // 0x38(0x10)
struct FString ViewRestrictionId; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiCharacterDefinition
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiCharacterDefinition {
struct FString ClassId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpString> CharacterStrings; // 0x10(0x10)
struct TArray<struct FS_ScavengersDataApiLevelDefinition> CharacterLevels; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiLevelDefinition
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiLevelDefinition {
int32_t Level; // 0x00(0x04)
int32_t LevelUpXp; // 0x04(0x04)
struct FString CatalogEntryId; // 0x08(0x10)
int32_t MaxPower; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiConfigData
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiConfigData {
struct TArray<struct FS_ScavengersDataApiKvpString> TitleStrings; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> FeatureFlags; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiStateHashes
// Size: 0x60 (Inherited: 0x00)
struct FS_ScavengersDataApiStateHashes {
struct FString PlayerStateHash; // 0x00(0x10)
struct FString ConfigDataHash; // 0x10(0x10)
struct FString TitleDataHash; // 0x20(0x10)
struct FString CatalogDataHash; // 0x30(0x10)
struct FString StoreDataHash; // 0x40(0x10)
struct FString DownloadableDataHash; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiLoginResult
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiLoginResult {
struct FString PlayerId; // 0x00(0x10)
struct FString AuthenticationToken; // 0x10(0x10)
struct FString UserSettings; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientGetLeaderboard
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientGetLeaderboard {
struct FString leaderboardId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatSetXpBoosterExpiration
// Size: 0x04 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatSetXpBoosterExpiration {
int32_t NewExpirationTime; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSetUserSettings
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSetUserSettings {
struct FString Settings; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatProgressSeason
// Size: 0x04 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatProgressSeason {
int32_t ProgressInc; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatProgressChallenge
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatProgressChallenge {
struct FString ChallengeInstanceId; // 0x00(0x10)
int32_t ProgressInc; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatSpeedResearch
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatSpeedResearch {
struct FString ResearchStationId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatAddPlayerCurrency
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatAddPlayerCurrency {
struct FString CurrencyId; // 0x00(0x10)
int32_t Value; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatRevokeItems
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatRevokeItems {
struct TArray<struct FS_ScavengersDataApiKvpInt> ItemsToRevoke; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatGrantPlatformPurchases
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatGrantPlatformPurchases {
struct TArray<struct FS_ScavengersDataApiPlatformPurchaseItem> ItemsToGrant; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiPlatformPurchaseItem
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiPlatformPurchaseItem {
struct FString ItemId; // 0x00(0x10)
struct FString InstanceID; // 0x10(0x10)
int32_t Count; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatGrantItems
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatGrantItems {
struct TArray<struct FS_ScavengersDataApiKvpInt> ItemsToGrant; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientCheatSetCharacterXp
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiClientCheatSetCharacterXp {
struct FString CharacterId; // 0x00(0x10)
int32_t Xp; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSubmitPlayerReport
// Size: 0x40 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSubmitPlayerReport {
struct FString MatchID; // 0x00(0x10)
struct TArray<struct FString> MatchTeam; // 0x10(0x10)
struct FString ReportedPlayerId; // 0x20(0x10)
struct FString ReportReasonCategory; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSubmitChallengeStats
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSubmitChallengeStats {
struct TArray<struct FS_ScavengersDataApiPlayerStat> Stats; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientClaimChallenge
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiClientClaimChallenge {
struct FString ChallengeInstanceId; // 0x00(0x10)
int32_t ClaimTarget; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientActivateXpBooster
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientActivateXpBooster {
struct FString XpBoosterInstanceId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResearchProjectHurry
// Size: 0x28 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResearchProjectHurry {
struct FString ResearchStationId; // 0x00(0x10)
int32_t ExpectedCost; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString ExpectedCurrency; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResearchProjectComplete
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResearchProjectComplete {
struct FString ResearchStationId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResearchProjectCancel
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResearchProjectCancel {
struct FString ResearchStationId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseResearchProjectStart
// Size: 0x78 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseResearchProjectStart {
struct FS_ScavengersDataApiResearchProjectInstance ProjectInstance; // 0x00(0x38)
struct FS_ScavengersDataApiStateUpdate StateUpdate; // 0x38(0x40)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResearchProjectStart
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResearchProjectStart {
struct FString ResearchStationId; // 0x00(0x10)
struct FString ProjectDefinitionId; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseStateUpdate
// Size: 0x40 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseStateUpdate {
struct FS_ScavengersDataApiStateUpdate StateUpdate; // 0x00(0x40)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientItemAssembly
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiClientItemAssembly {
struct FString AssemblyRecipeId; // 0x00(0x10)
int32_t Quantity; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientItemDisassembly
// Size: 0x18 (Inherited: 0x00)
struct FS_ScavengersDataApiClientItemDisassembly {
struct FString ItemInstanceId; // 0x00(0x10)
int32_t Quantity; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientOpenBundle
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientOpenBundle {
struct FString ItemInstanceId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientPurchaseDetails
// Size: 0x48 (Inherited: 0x00)
struct FS_ScavengersDataApiClientPurchaseDetails {
struct FString PlatformTransactionId; // 0x00(0x10)
struct FString OfferId; // 0x10(0x10)
struct FString PlayerCurrencyCode; // 0x20(0x10)
int32_t PlayerCurrencyValue; // 0x30(0x04)
bool Failure; // 0x34(0x01)
char pad_35[0x3]; // 0x35(0x03)
struct FString FailureReason; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSyncPlatformPurchases
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSyncPlatformPurchases {
struct FString TransactionId; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientPurchaseOfferBundle
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientPurchaseOfferBundle {
struct FString StoreOfferBundleId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> ExpectedPrice; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientPurchaseOffer
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientPurchaseOffer {
struct FString StoreOfferId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiKvpInt> ExpectedPrice; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSetCosmeticLoadoutForCharacter
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSetCosmeticLoadoutForCharacter {
struct FString CharacterId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiCosmeticSlot> Loadout; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSetCosmeticLoadoutForPlayer
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSetCosmeticLoadoutForPlayer {
struct TArray<struct FS_ScavengersDataApiCosmeticSlot> Loadout; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSetLoadoutForCharacter
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSetLoadoutForCharacter {
struct FString CharacterId; // 0x00(0x10)
struct TArray<struct FS_ScavengersDataApiLoadoutSlot> Loadout; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientSetDisplayName
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientSetDisplayName {
struct FString DisplayName; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientUnseenRewardAck
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientUnseenRewardAck {
struct TArray<struct FString> RewardList; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientHeartbeat
// Size: 0x60 (Inherited: 0x00)
struct FS_ScavengersDataApiClientHeartbeat {
struct FS_ScavengersDataApiStateHashes StateHashes; // 0x00(0x60)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientLoginWithImprobable
// Size: 0x20 (Inherited: 0x00)
struct FS_ScavengersDataApiClientLoginWithImprobable {
struct FString AccessToken; // 0x00(0x10)
struct FString DeviceID; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientResponseConfiguration
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientResponseConfiguration {
struct TArray<struct FS_ScavengersDataApiKvpInt> FeatureFlags; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientRefreshPlatformLogin
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientRefreshPlatformLogin {
struct FString PlatformToken; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientGetPrivateConfigFile
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientGetPrivateConfigFile {
struct FString Filename; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientGetConfiguration
// Size: 0x30 (Inherited: 0x00)
struct FS_ScavengersDataApiClientGetConfiguration {
struct FString Build; // 0x00(0x10)
struct FString Version; // 0x10(0x10)
struct FString VersionApi; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ScavengersDataApiClientGetCatalog
// Size: 0x10 (Inherited: 0x00)
struct FS_ScavengersDataApiClientGetCatalog {
struct FString Version; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ShelterInterfaceData
// Size: 0x98 (Inherited: 0x00)
struct FS_ShelterInterfaceData {
char pad_0[0x10]; // 0x00(0x10)
bool CameraInShelter; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
struct TArray<struct AS_ShelterVolume*> m_ShelterVolumes; // 0x18(0x10)
struct TArray<struct US_ShelterVolumeComponent*> m_ShelterVolumeComponents; // 0x28(0x10)
struct TMap<uint32_t, struct FS_StencilEntry> m_StencilEntries; // 0x38(0x50)
struct TArray<struct AS_StormShellActor*> m_StormShellActors; // 0x88(0x10)
};
// ScriptStruct Scavenger.S_StencilEntry
// Size: 0x10 (Inherited: 0x00)
struct FS_StencilEntry {
struct TWeakObjectPtr<struct UPrimitiveComponent> primComponent; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_ShieldLevelConfig
// Size: 0x38 (Inherited: 0x00)
struct FS_ShieldLevelConfig {
enum class ES_ShieldLevel ShieldLevel; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FLinearColor ShellColor; // 0x04(0x10)
struct FLinearColor ShellImpactColor; // 0x14(0x10)
float TransitionDurationFromPreviousLevel; // 0x24(0x04)
struct UAkAudioEvent* UpgradeAudioEvent; // 0x28(0x08)
struct UParticleSystem* UpgradeParticles; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_ShieldStateConfig
// Size: 0x30 (Inherited: 0x00)
struct FS_ShieldStateConfig {
struct UMaterialInterface* ShellMaterial; // 0x00(0x08)
struct UAkAudioEvent* AudioEvent; // 0x08(0x08)
struct UParticleSystem* Particles; // 0x10(0x08)
struct UCurveFloat* Curve; // 0x18(0x08)
float ShieldStateSampleTime; // 0x20(0x04)
float ShieldStateValue; // 0x24(0x04)
struct UParticleSystemComponent* ActiveParticleSystemComponent; // 0x28(0x08)
};
// ScriptStruct Scavenger.S_Skin
// Size: 0x80 (Inherited: 0x00)
struct FS_Skin {
int32_t SkinId; // 0x00(0x04)
int32_t CompoundSkinId; // 0x04(0x04)
struct TWeakObjectPtr<struct AActor> BaseObject; // 0x08(0x08)
struct FName BaseObjectName; // 0x10(0x08)
struct TWeakObjectPtr<struct UMeshComponent> TargetMeshComp; // 0x18(0x08)
struct FName MeshName; // 0x20(0x08)
struct TMap<struct FName, struct FS_SkinMaterial> SkinMaterials; // 0x28(0x50)
bool bNeedsSmelting; // 0x78(0x01)
bool bHasBeenSmelted; // 0x79(0x01)
bool bIsSmeltingInProgress; // 0x7a(0x01)
bool bDirty; // 0x7b(0x01)
bool bStale; // 0x7c(0x01)
char pad_7D[0x3]; // 0x7d(0x03)
};
// ScriptStruct Scavenger.S_SkinMaterial
// Size: 0x1a8 (Inherited: 0x00)
struct FS_SkinMaterial {
struct FName MaterialName; // 0x00(0x08)
struct FName MaterialSlotName; // 0x08(0x08)
int32_t MaterialIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TMap<struct FName, struct FS_SkinMaterialParameter> MaterialParms; // 0x18(0x50)
struct TSoftObjectPtr<struct UMaterialInterface> MaterialOverride; // 0x68(0x28)
struct UMaterialInstanceDynamic* Mid; // 0x90(0x08)
struct UMaterialInstanceDynamic* SmeltingMID; // 0x98(0x08)
struct TSoftObjectPtr<struct UMaterialInterface> SmeltingMasterLiveMaterial; // 0xa0(0x28)
struct TArray<struct FMaterialSmelterRuntimeLayer> SmeltingLayerStack; // 0xc8(0x10)
struct TMap<enum class EPackedMaterialProperty, struct FMaterialSmelterRuntimeOutput> SmeltingRuntimeOutputs; // 0xd8(0x50)
struct TArray<struct FS_SkinMaterialSmeltingTask> SmeltingCompressionTasks; // 0x128(0x10)
struct TArray<struct FS_SkinMaterialSmeltingTask> SmeltingMipMemcpyTasks; // 0x138(0x10)
struct TMap<enum class EPackedMaterialProperty, struct UTexture2D*> SmeltingCompressedTextures; // 0x148(0x50)
enum class ES_SmeltState SmeltState; // 0x198(0x01)
char pad_199[0x3]; // 0x199(0x03)
uint32_t SmeltStateTimeStamp; // 0x19c(0x04)
bool bSupportsSmelting; // 0x1a0(0x01)
bool bNeedsSmelting; // 0x1a1(0x01)
bool bHasBeenSmelted; // 0x1a2(0x01)
bool bUsingCachedSmeltedMaterial; // 0x1a3(0x01)
bool bDirty; // 0x1a4(0x01)
bool bStale; // 0x1a5(0x01)
char pad_1A6[0x2]; // 0x1a6(0x02)
};
// ScriptStruct Scavenger.S_SkinMaterialSmeltingTask
// Size: 0x58 (Inherited: 0x00)
struct FS_SkinMaterialSmeltingTask {
int32_t TaskId; // 0x00(0x04)
enum class EPackedMaterialProperty TextureProperty; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
struct UTexture2D* Texture; // 0x08(0x08)
struct TArray<struct FColor> ColorData; // 0x10(0x10)
struct TArray<char> CompressedData; // 0x20(0x10)
int32_t CompressedDataSize; // 0x30(0x04)
int32_t MipIndex; // 0x34(0x04)
int32_t NumMips; // 0x38(0x04)
int32_t Width; // 0x3c(0x04)
int32_t Height; // 0x40(0x04)
int32_t AlphaMultiplier; // 0x44(0x04)
struct UTextureRenderTarget2D* RenderTarget; // 0x48(0x08)
char pad_50[0x8]; // 0x50(0x08)
};
// ScriptStruct Scavenger.S_SkinMaterialParameter
// Size: 0x50 (Inherited: 0x00)
struct FS_SkinMaterialParameter {
struct FName ParameterName; // 0x00(0x08)
enum class ES_SkinMaterialParameter ParameterType; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
float ScalarValue; // 0x0c(0x04)
struct FLinearColor VectorValue; // 0x10(0x10)
struct TSoftObjectPtr<struct UTexture2D> TexValue; // 0x20(0x28)
bool bIsReady; // 0x48(0x01)
bool bDirty; // 0x49(0x01)
char pad_4A[0x6]; // 0x4a(0x06)
};
// ScriptStruct Scavenger.S_ToDIntervalDefinitionNative
// Size: 0x1490 (Inherited: 0x00)
struct FS_ToDIntervalDefinitionNative {
struct FString DislpayName; // 0x00(0x10)
float StartTime; // 0x10(0x04)
float BlendLength; // 0x14(0x04)
float Dayness; // 0x18(0x04)
bool EaseIn; // 0x1c(0x01)
bool EaseOut; // 0x1d(0x01)
char pad_1E[0x2]; // 0x1e(0x02)
struct FS_ToDIntervalSettingsNative Settings; // 0x20(0x1470)
};
// ScriptStruct Scavenger.S_ToDIntervalSettingsNative
// Size: 0x1470 (Inherited: 0x00)
struct FS_ToDIntervalSettingsNative {
struct FS_ToDIntervalSunSettingsNative SunSettings; // 0x00(0x190)
struct FS_ToDIntervalSkylightSettingsNative SkylightSettings; // 0x190(0x120)
struct FS_ToDIntervalFogSettingsNative FogSettings; // 0x2b0(0x300)
struct FS_ToDIntervalPostProcessSettingsNative PostProcessSettings; // 0x5b0(0x240)
struct FS_ToDIntervalMaterialSettingsNative MaterialSettings; // 0x7f0(0xa10)
struct FS_ToDIntervalRimLightSettingsNative RimLightSettings; // 0x1200(0x270)
};
// ScriptStruct Scavenger.S_ToDIntervalRimLightSettingsNative
// Size: 0x270 (Inherited: 0x00)
struct FS_ToDIntervalRimLightSettingsNative {
struct FS_ToDIntervalProp_Color RimLightPlayerRadience; // 0x00(0x9c)
struct FS_ToDIntervalProp_Color RimLightNPCRadience; // 0x9c(0x9c)
struct FS_ToDIntervalProp_Color RimLightWeaponRadience; // 0x138(0x9c)
struct FS_ToDIntervalProp_Color FillLightRadience; // 0x1d4(0x9c)
};
// ScriptStruct Scavenger.S_ToDIntervalProp_Color
// Size: 0x9c (Inherited: 0x00)
struct FS_ToDIntervalProp_Color {
struct FLinearColor BaseValue; // 0x00(0x10)
struct FS_ToDIntervalPropOverride_Color Storm; // 0x10(0x14)
struct FS_ToDIntervalPropOverride_Color Shelter; // 0x24(0x14)
struct FS_ToDIntervalPropOverride_Color ShelterStorm; // 0x38(0x14)
struct FS_ToDIntervalPropOverride_Color PartialShelter; // 0x4c(0x14)
struct FS_ToDIntervalPropOverride_Color PartialShelterStorm; // 0x60(0x14)
struct FS_ToDIntervalPropOverride_Color Crater; // 0x74(0x14)
struct FS_ToDIntervalPropOverride_Color CraterStorm; // 0x88(0x14)
};
// ScriptStruct Scavenger.S_ToDIntervalPropOverride_Color
// Size: 0x14 (Inherited: 0x00)
struct FS_ToDIntervalPropOverride_Color {
bool Override; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FLinearColor Value; // 0x04(0x10)
};
// ScriptStruct Scavenger.S_ToDIntervalMaterialSettingsNative
// Size: 0xa10 (Inherited: 0x00)
struct FS_ToDIntervalMaterialSettingsNative {
struct FS_ToDIntervalProp_Color HorizonBaseColor; // 0x00(0x9c)
struct FS_ToDIntervalProp_Color ZenithBaseColor; // 0x9c(0x9c)
struct FS_ToDIntervalProp_Color CloudLightColor; // 0x138(0x9c)
struct FS_ToDIntervalProp_Color CloudDarkColor; // 0x1d4(0x9c)
struct FS_ToDIntervalProp_Float CloudOpacity; // 0x270(0x3c)
struct FS_ToDIntervalProp_Float CloudDensity; // 0x2ac(0x3c)
struct FS_ToDIntervalProp_Float BaseCloudSpeed; // 0x2e8(0x3c)
struct FS_ToDIntervalProp_Float BaseCloudiness; // 0x324(0x3c)
struct FS_ToDIntervalProp_Float StormyIntensity; // 0x360(0x3c)
struct FS_ToDIntervalProp_Float FogStormyDesaturationFractionDensity; // 0x39c(0x3c)
struct FS_ToDIntervalProp_Color StormyColorMultiply; // 0x3d8(0x9c)
struct FS_ToDIntervalProp_Float ShineIntensity; // 0x474(0x3c)
struct FS_ToDIntervalProp_Rotator SunPosition; // 0x4b0(0x7c)
struct FS_ToDIntervalProp_Color SunColor; // 0x52c(0x9c)
struct FS_ToDIntervalProp_Float SunHighlightRadius; // 0x5c8(0x3c)
struct FS_ToDIntervalProp_Rotator MoonPosition; // 0x604(0x7c)
struct FS_ToDIntervalProp_Float SunDiscBrightness; // 0x680(0x3c)
struct FS_ToDIntervalProp_Float MoonRotation; // 0x6bc(0x3c)
struct FS_ToDIntervalProp_Float MoonOpacity; // 0x6f8(0x3c)
struct FS_ToDIntervalProp_Color MoonColorMultiply; // 0x734(0x9c)
struct FS_ToDIntervalProp_Float MoonBrightnessExponent; // 0x7d0(0x3c)
struct FS_ToDIntervalProp_Float MoonGlowScale; // 0x80c(0x3c)
struct FS_ToDIntervalProp_Color MoonGlowColor; // 0x848(0x9c)
struct FS_ToDIntervalProp_Float MoonGlowIntensity; // 0x8e4(0x3c)
struct FS_ToDIntervalProp_Float MoonHighlightRadius; // 0x920(0x3c)
struct FS_ToDIntervalProp_Float StarsIntensity; // 0x95c(0x3c)
struct FS_ToDIntervalProp_Float AuroraSpeed; // 0x998(0x3c)
struct FS_ToDIntervalProp_Float AuroraIntensity; // 0x9d4(0x3c)
};
// ScriptStruct Scavenger.S_ToDIntervalProp_Float
// Size: 0x3c (Inherited: 0x00)
struct FS_ToDIntervalProp_Float {
float BaseValue; // 0x00(0x04)
struct FS_ToDIntervalPropOverride_Float Storm; // 0x04(0x08)
struct FS_ToDIntervalPropOverride_Float Shelter; // 0x0c(0x08)
struct FS_ToDIntervalPropOverride_Float ShelterStorm; // 0x14(0x08)
struct FS_ToDIntervalPropOverride_Float PartialShelter; // 0x1c(0x08)
struct FS_ToDIntervalPropOverride_Float PartialShelterStorm; // 0x24(0x08)
struct FS_ToDIntervalPropOverride_Float Crater; // 0x2c(0x08)
struct FS_ToDIntervalPropOverride_Float CraterStorm; // 0x34(0x08)
};
// ScriptStruct Scavenger.S_ToDIntervalPropOverride_Float
// Size: 0x08 (Inherited: 0x00)
struct FS_ToDIntervalPropOverride_Float {
bool Override; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float Value; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_ToDIntervalProp_Rotator
// Size: 0x7c (Inherited: 0x00)
struct FS_ToDIntervalProp_Rotator {
struct FRotator BaseValue; // 0x00(0x0c)
struct FS_ToDIntervalPropOverride_Rotator Storm; // 0x0c(0x10)
struct FS_ToDIntervalPropOverride_Rotator Shelter; // 0x1c(0x10)
struct FS_ToDIntervalPropOverride_Rotator ShelterStorm; // 0x2c(0x10)
struct FS_ToDIntervalPropOverride_Rotator PartialShelter; // 0x3c(0x10)
struct FS_ToDIntervalPropOverride_Rotator PartialShelterStorm; // 0x4c(0x10)
struct FS_ToDIntervalPropOverride_Rotator Crater; // 0x5c(0x10)
struct FS_ToDIntervalPropOverride_Rotator CraterStorm; // 0x6c(0x10)
};
// ScriptStruct Scavenger.S_ToDIntervalPropOverride_Rotator
// Size: 0x10 (Inherited: 0x00)
struct FS_ToDIntervalPropOverride_Rotator {
bool Override; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FRotator Value; // 0x04(0x0c)
};
// ScriptStruct Scavenger.S_ToDIntervalPostProcessSettingsNative
// Size: 0x240 (Inherited: 0x00)
struct FS_ToDIntervalPostProcessSettingsNative {
struct FS_ToDIntervalProp_Float ExposureMin; // 0x00(0x3c)
struct FS_ToDIntervalProp_Float ExposureMax; // 0x3c(0x3c)
struct FS_ToDIntervalProp_Float WhiteBalanceTemp; // 0x78(0x3c)
struct FS_ToDIntervalProp_Color ShadowsGain; // 0xb4(0x9c)
struct FS_ToDIntervalProp_Float Slope; // 0x150(0x3c)
struct FS_ToDIntervalProp_Float Shoulder; // 0x18c(0x3c)
struct FS_ToDIntervalProp_Float BloomIntensity; // 0x1c8(0x3c)
struct FS_ToDIntervalProp_Float DirtMaskIntensity; // 0x204(0x3c)
};
// ScriptStruct Scavenger.S_ToDIntervalFogSettingsNative
// Size: 0x300 (Inherited: 0x00)
struct FS_ToDIntervalFogSettingsNative {
struct FS_ToDIntervalProp_Float FogDensity; // 0x00(0x3c)
struct FS_ToDIntervalProp_Float FogHeightFalloff; // 0x3c(0x3c)
struct FS_ToDIntervalProp_Color FogInscatterColor; // 0x78(0x9c)
struct FS_ToDIntervalProp_Float DirectionalInscatterExponent; // 0x114(0x3c)
struct FS_ToDIntervalProp_Color DirectionalInscatterColor; // 0x150(0x9c)
struct FS_ToDIntervalProp_Float VolumetricScatteringDistribution; // 0x1ec(0x3c)
struct FS_ToDIntervalProp_Color VolumetricAlbedo; // 0x228(0x9c)
struct FS_ToDIntervalProp_Float VolumetricExtinctionScale; // 0x2c4(0x3c)
};
// ScriptStruct Scavenger.S_ToDIntervalSkylightSettingsNative
// Size: 0x120 (Inherited: 0x00)
struct FS_ToDIntervalSkylightSettingsNative {
struct UTextureCube* Cubemap; // 0x00(0x08)
struct FS_ToDIntervalProp_Float Intensity; // 0x08(0x3c)
struct FS_ToDIntervalProp_Color Color; // 0x44(0x9c)
struct FS_ToDIntervalProp_Float DFAOExponent; // 0xe0(0x3c)
char pad_11C[0x4]; // 0x11c(0x04)
};
// ScriptStruct Scavenger.S_ToDIntervalSunSettingsNative
// Size: 0x190 (Inherited: 0x00)
struct FS_ToDIntervalSunSettingsNative {
struct FS_ToDIntervalProp_Float Intensity; // 0x00(0x3c)
struct FS_ToDIntervalProp_Color LightColor; // 0x3c(0x9c)
struct FS_ToDIntervalProp_Rotator Rotation; // 0xd8(0x7c)
struct FS_ToDIntervalProp_Float VolumetricScatteringIntensity; // 0x154(0x3c)
};
// ScriptStruct Scavenger.S_ToDIntervalProp_Vector
// Size: 0x7c (Inherited: 0x00)
struct FS_ToDIntervalProp_Vector {
struct FVector BaseValue; // 0x00(0x0c)
struct FS_ToDIntervalPropOverride_Vector Storm; // 0x0c(0x10)
struct FS_ToDIntervalPropOverride_Vector Shelter; // 0x1c(0x10)
struct FS_ToDIntervalPropOverride_Vector ShelterStorm; // 0x2c(0x10)
struct FS_ToDIntervalPropOverride_Vector PartialShelter; // 0x3c(0x10)
struct FS_ToDIntervalPropOverride_Vector PartialShelterStorm; // 0x4c(0x10)
struct FS_ToDIntervalPropOverride_Vector Crater; // 0x5c(0x10)
struct FS_ToDIntervalPropOverride_Vector CraterStorm; // 0x6c(0x10)
};
// ScriptStruct Scavenger.S_ToDIntervalPropOverride_Vector
// Size: 0x10 (Inherited: 0x00)
struct FS_ToDIntervalPropOverride_Vector {
bool Override; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FVector Value; // 0x04(0x0c)
};
// ScriptStruct Scavenger.SocialHubAnalyticsEventBase
// Size: 0x10 (Inherited: 0x00)
struct FSocialHubAnalyticsEventBase {
struct FString PlayerId; // 0x00(0x10)
};
// ScriptStruct Scavenger.SocialHubAnalyticsEndOfMatch
// Size: 0x18 (Inherited: 0x10)
struct FSocialHubAnalyticsEndOfMatch : FSocialHubAnalyticsEventBase {
int32_t OutroCinematicIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.SocialHubAnalyticsLoggedIn
// Size: 0x28 (Inherited: 0x10)
struct FSocialHubAnalyticsLoggedIn : FSocialHubAnalyticsEventBase {
struct FString ClientTelemetrySessionId; // 0x10(0x10)
int32_t ClientMatchIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_CrowdStatsForDirection
// Size: 0x60 (Inherited: 0x00)
struct FS_CrowdStatsForDirection {
int32_t Count; // 0x00(0x04)
char pad_4[0x4]; // 0x04(0x04)
struct TMap<struct FName, int32_t> LoopingStateCounts; // 0x08(0x50)
float AverageDistance; // 0x58(0x04)
float ApproximateAverageAngularDistance; // 0x5c(0x04)
};
// ScriptStruct Scavenger.S_PickupTypeData
// Size: 0x28 (Inherited: 0x00)
struct FS_PickupTypeData {
struct AS_SocialHubPickupBase* PickupClass; // 0x00(0x08)
float RespawnTime; // 0x08(0x04)
enum class ES_PickupType ValueToScaleFrom; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
float ScaleAtMinimumValue; // 0x10(0x04)
float ScaleAtMaximumValue; // 0x14(0x04)
int32_t MinimumScrapValue; // 0x18(0x04)
int32_t MaximumScrapValue; // 0x1c(0x04)
int32_t MinimumDataValue; // 0x20(0x04)
int32_t MaximumDataValue; // 0x24(0x04)
};
// ScriptStruct Scavenger.PlayerTypeInfo
// Size: 0x48 (Inherited: 0x00)
struct FPlayerTypeInfo {
struct FString Name; // 0x00(0x10)
struct FString ID; // 0x10(0x10)
struct FString DefaultAccessCodeHash; // 0x20(0x10)
struct AScavengersHubCharacterObject* CharacterEntityObjectClass; // 0x30(0x08)
struct TArray<struct US_SocialHubPlayerClassData*> PlayerClassDatas; // 0x38(0x10)
};
// ScriptStruct Scavenger.GrenadeSetWrapper
// Size: 0x50 (Inherited: 0x00)
struct FGrenadeSetWrapper {
char pad_0[0x50]; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_MILEPhaseLevelsTableRow
// Size: 0x18 (Inherited: 0x08)
struct FS_MILEPhaseLevelsTableRow : FTableRowBase {
struct TArray<struct FName> SubLevels; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_SocialHubOutroData
// Size: 0x18 (Inherited: 0x00)
struct FS_SocialHubOutroData {
struct FName Name; // 0x00(0x08)
struct ULevelSequence* OutroCinematic; // 0x08(0x08)
struct US_WidgetMinimal* ExtractionWidget; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_SocialHubPhaseAbilityAssignment
// Size: 0x30 (Inherited: 0x00)
struct FS_SocialHubPhaseAbilityAssignment {
SoftClassProperty MessengerType; // 0x00(0x28)
struct US_MessengerAbilitySet* AbilitySet; // 0x28(0x08)
};
// ScriptStruct Scavenger.S_ScriptedOscillation
// Size: 0x1c (Inherited: 0x00)
struct FS_ScriptedOscillation {
float Speed; // 0x00(0x04)
float Range; // 0x04(0x04)
struct FVector MovementAxis; // 0x08(0x0c)
bool bLocalToInitialRotation; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
float TimeOffset; // 0x18(0x04)
};
// ScriptStruct Scavenger.S_ScriptedRotation
// Size: 0x14 (Inherited: 0x00)
struct FS_ScriptedRotation {
float Speed; // 0x00(0x04)
struct FVector RotateAroundAxis; // 0x04(0x0c)
float TimeOffset; // 0x10(0x04)
};
// ScriptStruct Scavenger.BoardedPlayersWrapper
// Size: 0x10 (Inherited: 0x00)
struct FBoardedPlayersWrapper {
struct TArray<struct AS_SocialHubPlayerEntityObject*> BoardedPlayers; // 0x00(0x10)
};
// ScriptStruct Scavenger.ScheduledEvent
// Size: 0x10 (Inherited: 0x00)
struct FScheduledEvent {
enum class ESocialHubEvent EventType; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float ScheduledWorldTime; // 0x04(0x04)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_MontagePlayrateTableRow
// Size: 0x20 (Inherited: 0x08)
struct FS_MontagePlayrateTableRow : FTableRowBase {
struct UAnimMontage* Montage; // 0x08(0x08)
struct TArray<float> PlayrateArray; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_AnimVariableModifierTableRow
// Size: 0x58 (Inherited: 0x08)
struct FS_AnimVariableModifierTableRow : FTableRowBase {
enum class ES_CharacterType CharacterType; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct TArray<float> SpeedModifier; // 0x10(0x10)
struct TArray<float> AccelerationModifier; // 0x20(0x10)
struct UDataTable* MontagePlayrateTable; // 0x30(0x08)
struct TArray<float> AnimationPlayrateModifier; // 0x38(0x10)
struct TArray<float> ForceSpeedModifierForBlendSpace; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_TelemetryEvent
// Size: 0x10 (Inherited: 0x00)
struct FS_TelemetryEvent {
char pad_0[0x10]; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_SocialHubTelemetryEvent
// Size: 0x10 (Inherited: 0x10)
struct FS_SocialHubTelemetryEvent : FS_TelemetryEvent {
};
// ScriptStruct Scavenger.S_SocialHubBinaryTelemetryEvent
// Size: 0x30 (Inherited: 0x10)
struct FS_SocialHubBinaryTelemetryEvent : FS_SocialHubTelemetryEvent {
char pad_10[0x20]; // 0x10(0x20)
};
// ScriptStruct Scavenger.S_SocialEventHistoryEntry
// Size: 0x18 (Inherited: 0x00)
struct FS_SocialEventHistoryEntry {
char pad_0[0x18]; // 0x00(0x18)
};
// ScriptStruct Scavenger.S_SpawnPoints
// Size: 0xb0 (Inherited: 0x00)
struct FS_SpawnPoints {
struct FTransform Point; // 0x00(0x30)
struct FName EditorOnlyArrowPositionOverride; // 0x30(0x08)
bool OverrideFitPointToGround; // 0x38(0x01)
bool ReplenishPoint; // 0x39(0x01)
bool NoInitialSpawns; // 0x3a(0x01)
bool OneSpawnOnly; // 0x3b(0x01)
struct FName MontageKey; // 0x3c(0x08)
struct FVector2D m_minimumTimeBetweenSpawns; // 0x44(0x08)
char pad_4C[0x4]; // 0x4c(0x04)
struct FSoftObjectPath OverrideDataTableAssetReference; // 0x50(0x18)
struct TSoftObjectPtr<struct UDataTable> OverrideSpawnDataTable; // 0x68(0x28)
struct UDataTable* m_overrideSpawnDataTable; // 0x90(0x08)
bool Sleeping; // 0x98(0x01)
char pad_99[0x3]; // 0x99(0x03)
float BlockingRadius; // 0x9c(0x04)
char pad_A0[0x10]; // 0xa0(0x10)
};
// ScriptStruct Scavenger.SpawnTable
// Size: 0x18 (Inherited: 0x00)
struct FSpawnTable {
struct TArray<struct FProcessedSpawnDescriptorItem> ProcessedSpawnData; // 0x00(0x10)
char pad_10[0x8]; // 0x10(0x08)
};
// ScriptStruct Scavenger.ProcessedSpawnDescriptorItem
// Size: 0x28 (Inherited: 0x00)
struct FProcessedSpawnDescriptorItem {
char pad_0[0x10]; // 0x00(0x10)
struct AActor* actorClassToSpawn; // 0x10(0x08)
char pad_18[0x8]; // 0x18(0x08)
struct US_ItemData* WeaponPrimaryItemData; // 0x20(0x08)
};
// ScriptStruct Scavenger.SpawnDescriptorTableRow
// Size: 0x30 (Inherited: 0x08)
struct FSpawnDescriptorTableRow : FTableRowBase {
struct FName GroupName; // 0x08(0x08)
float RelativeSpawnChance; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct AActor* actorClassToSpawn; // 0x18(0x08)
struct US_ItemData* WeaponPrimaryItemData; // 0x20(0x08)
float GlobalAISpawnPercentageCutoff; // 0x28(0x04)
enum class ES_AISpawnPhase StartSpawnPhase; // 0x2c(0x01)
enum class ES_AISpawnPhase EndSpawnPhase; // 0x2d(0x01)
char pad_2E[0x2]; // 0x2e(0x02)
};
// ScriptStruct Scavenger.S_SpottingInstance
// Size: 0x18 (Inherited: 0x00)
struct FS_SpottingInstance {
int32_t TeamIndex; // 0x00(0x04)
float CritChanceModForTeam; // 0x04(0x04)
float CritChanceModForSpotter; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
struct AActor* SpottingInstigator; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_BlendRule
// Size: 0x28 (Inherited: 0x08)
struct FS_BlendRule : FTableRowBase {
enum class ES_CameraSettings From; // 0x08(0x01)
enum class ES_CameraSettings To; // 0x09(0x01)
char pad_A[0x2]; // 0x0a(0x02)
float FovInterpSpeed; // 0x0c(0x04)
float SpringArmInterpSpeed; // 0x10(0x04)
float SocketTranslationInterpSpeed; // 0x14(0x04)
float SocketRotationInterpSpeed; // 0x18(0x04)
float TargetInterpSpeed; // 0x1c(0x04)
float LagInterpSpeed; // 0x20(0x04)
bool DoAimKeep; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
};
// ScriptStruct Scavenger.S_CameraArmSettings
// Size: 0x170 (Inherited: 0x08)
struct FS_CameraArmSettings : FTableRowBase {
enum class ES_CameraSettings CameraSettingEnum; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FS_InheritanceSettings InheritanceSettings; // 0x10(0xb0)
struct FS_CameraArmFOVSettings FovSettings; // 0xc0(0x04)
struct FS_CameraArmLengthSettings LengthSettings; // 0xc4(0x04)
char pad_C8[0x8]; // 0xc8(0x08)
struct FS_CamerArmSocketOffsetSettings SocketOffsetSetting; // 0xd0(0x20)
struct FS_CamerArmTranslationOffsetSettings TargetOffsetSetting; // 0xf0(0x0c)
struct FS_CameraArmLagSettings LagSettings; // 0xfc(0x14)
struct FS_CameraRotationClampSettings RotationClamp; // 0x110(0x2c)
bool DisablePerWeaponOverrides; // 0x13c(0x01)
bool AimKeepOnCameraCollision; // 0x13d(0x01)
bool UseProjectileSpawnPointAsCameraLocation; // 0x13e(0x01)
enum class ES_RecoilSettings RecoilSettingToUse; // 0x13f(0x01)
bool HideBlockingCharacters; // 0x140(0x01)
bool CollideWithBlockingCharacters; // 0x141(0x01)
bool OnlyCollideOnFoliageOverlap; // 0x142(0x01)
char pad_143[0x1]; // 0x143(0x01)
float ScavFoliageMaxAngleToIgnoreCollision; // 0x144(0x04)
float VanillaFoliageVisibilitySidePadding; // 0x148(0x04)
bool DisableCollisionWithAttachedParents; // 0x14c(0x01)
char pad_14D[0x3]; // 0x14d(0x03)
struct FS_CameraNoiseSettings NoiseTranslation; // 0x150(0x10)
struct FS_CameraNoiseSettings NoiseRotation; // 0x160(0x10)
};
// ScriptStruct Scavenger.S_CameraRotationClampSettings
// Size: 0x2c (Inherited: 0x00)
struct FS_CameraRotationClampSettings {
struct FS_RotationClamp RotationClamp; // 0x00(0x28)
bool bOverrideRotationClamp; // 0x28(0x01)
char pad_29[0x3]; // 0x29(0x03)
};
// ScriptStruct Scavenger.S_RotationClamp
// Size: 0x28 (Inherited: 0x00)
struct FS_RotationClamp {
struct FS_ClampValue Yaw; // 0x00(0x0c)
struct FS_ClampValue Pitch; // 0x0c(0x0c)
struct FS_ClampValue Roll; // 0x18(0x0c)
bool bWorldSpaceClamp; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
};
// ScriptStruct Scavenger.S_ClampValue
// Size: 0x0c (Inherited: 0x00)
struct FS_ClampValue {
float Min; // 0x00(0x04)
float Max; // 0x04(0x04)
bool bApplyClamp; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
};
// ScriptStruct Scavenger.S_CameraArmLagSettings
// Size: 0x14 (Inherited: 0x00)
struct FS_CameraArmLagSettings {
bool bEnableCameraLag; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float CameraLagFwdSpeed; // 0x04(0x04)
float CameraLagSideSpeed; // 0x08(0x04)
float CameraLagUpSpeed; // 0x0c(0x04)
float CameraLagDownSpeed; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_CamerArmTranslationOffsetSettings
// Size: 0x0c (Inherited: 0x00)
struct FS_CamerArmTranslationOffsetSettings {
struct FVector Translation; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_CamerArmSocketOffsetSettings
// Size: 0x20 (Inherited: 0x00)
struct FS_CamerArmSocketOffsetSettings {
struct FVector Translation; // 0x00(0x0c)
char pad_C[0x4]; // 0x0c(0x04)
struct FQuat Rotation; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_CameraArmLengthSettings
// Size: 0x04 (Inherited: 0x00)
struct FS_CameraArmLengthSettings {
float SpringArmTargetLength; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_CameraArmFOVSettings
// Size: 0x04 (Inherited: 0x00)
struct FS_CameraArmFOVSettings {
float FOVTarget; // 0x00(0x04)
};
// ScriptStruct Scavenger.S_InheritanceSettings
// Size: 0xb0 (Inherited: 0x00)
struct FS_InheritanceSettings {
bool bInheritCameraSettings; // 0x00(0x01)
enum class ES_CameraSettings InheritCameraSettingFrom; // 0x01(0x01)
char pad_2[0xe]; // 0x02(0x0e)
struct FS_CameraSettingOverride InheritanceOverrides; // 0x10(0xa0)
};
// ScriptStruct Scavenger.S_RecoilWeaponSettings
// Size: 0x2c (Inherited: 0x00)
struct FS_RecoilWeaponSettings {
float CenterAcceleration; // 0x00(0x04)
float RollCenterAcceleration; // 0x04(0x04)
float PushVelocity; // 0x08(0x04)
float WindupScaleMin; // 0x0c(0x04)
float WindupScaleMax; // 0x10(0x04)
float BoundsMin[0x3]; // 0x14(0x0c)
float BoundsMax[0x3]; // 0x20(0x0c)
};
// ScriptStruct Scavenger.S_RecoilImpulseSettings3D
// Size: 0x4c (Inherited: 0x00)
struct FS_RecoilImpulseSettings3D {
struct FS_RecoilImpulseSettings AxisSettings[0x3]; // 0x00(0x48)
enum class ES_RecoilImpulseInhertienceType InheritenceType; // 0x48(0x01)
enum class ES_RecoilSettings RecoilSettingToInheritFrom; // 0x49(0x01)
char pad_4A[0x2]; // 0x4a(0x02)
};
// ScriptStruct Scavenger.S_RecoilImpulseSettings
// Size: 0x18 (Inherited: 0x00)
struct FS_RecoilImpulseSettings {
float ImpulseMin; // 0x00(0x04)
float ImpulseMax; // 0x04(0x04)
float ImpulseMinAmplitude; // 0x08(0x04)
float PushMin; // 0x0c(0x04)
float PushMax; // 0x10(0x04)
float PushMinAmplitude; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_StoredStatState
// Size: 0x08 (Inherited: 0x00)
struct FS_StoredStatState {
float StatValueOnEnter; // 0x00(0x04)
float GameTimeSecondsOnEnter; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_StatChangeParameters
// Size: 0x1c (Inherited: 0x00)
struct FS_StatChangeParameters {
enum class ES_StatType StatType; // 0x00(0x01)
enum class ES_StatChangeCauseType StatChangeCauseType; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
float ChangePerSecond; // 0x04(0x04)
bool ChangeInPercent; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
char bHasMinimumStatValue : 1; // 0x0c(0x01)
char pad_C_1 : 7; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
float MinimumStatValue; // 0x10(0x04)
char bHasMaximumStatValue : 1; // 0x14(0x01)
char pad_14_1 : 7; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
float MaximumStatValue; // 0x18(0x04)
};
// ScriptStruct Scavenger.S_DamageOverTimeState
// Size: 0x40 (Inherited: 0x00)
struct FS_DamageOverTimeState {
char pad_0[0x8]; // 0x00(0x08)
struct UCurveFloat* DamagePerTickCurve; // 0x08(0x08)
char pad_10[0x20]; // 0x10(0x20)
struct TArray<struct FS_DamageOverTimeEvent> Events; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_DamageOverTimeEvent
// Size: 0x18 (Inherited: 0x00)
struct FS_DamageOverTimeEvent {
struct AActor* CauseActor; // 0x00(0x08)
struct AController* InstigatorController; // 0x08(0x08)
float PendingDamageRemaining; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_PredictedDamageInfo
// Size: 0x20 (Inherited: 0x00)
struct FS_PredictedDamageInfo {
struct FS_DamagePredictionID PredictionID; // 0x00(0x10)
char pad_10[0x10]; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_Stat
// Size: 0x0c (Inherited: 0x00)
struct FS_Stat {
float InitialValue; // 0x00(0x04)
float CurrentValue; // 0x04(0x04)
float MaximumValue; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_DerivedStatChange
// Size: 0x10 (Inherited: 0x00)
struct FS_DerivedStatChange {
enum class ES_StatType SourceStat; // 0x00(0x01)
enum class ES_StatType TargetStat; // 0x01(0x01)
char pad_2[0x6]; // 0x02(0x06)
struct UCurveFloat* SourceStatValueToTargetStatDeltaCurve; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_InitialCondition
// Size: 0x0c (Inherited: 0x00)
struct FS_InitialCondition {
enum class ES_StatType Stat; // 0x00(0x01)
enum class ES_StatChangeCauseType Cause; // 0x01(0x01)
char pad_2[0x2]; // 0x02(0x02)
float ChangePerSecond; // 0x04(0x04)
float DurationInSeconds; // 0x08(0x04)
};
// ScriptStruct Scavenger.S_InitialStatData
// Size: 0x08 (Inherited: 0x00)
struct FS_InitialStatData {
float InitialValue; // 0x00(0x04)
float MaximumValue; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_DamageDealtPerPlayer
// Size: 0x10 (Inherited: 0x00)
struct FS_DamageDealtPerPlayer {
struct TArray<struct FS_PerPlayerDamage> DamageDealtPerPlayer; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_PerPlayerDamage
// Size: 0x10 (Inherited: 0x00)
struct FS_PerPlayerDamage {
struct AS_PlayerController* PlayerController; // 0x00(0x08)
float DamageDealt; // 0x08(0x04)
float LastDamageTime; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_StreamerMenuEntry
// Size: 0x20 (Inherited: 0x00)
struct FS_StreamerMenuEntry {
enum class ES_StreamerMenuEntryType Type; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString Name; // 0x08(0x10)
struct AS_StreamerAbility* Ability; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_ActiveTalent
// Size: 0x28 (Inherited: 0x00)
struct FS_ActiveTalent {
char pad_0[0x28]; // 0x00(0x28)
};
// ScriptStruct Scavenger.S_TalentMetadata
// Size: 0xa8 (Inherited: 0x58)
struct FS_TalentMetadata : FS_DisplayableItemMetadata {
enum class ES_LoadoutSlotType LoadoutSlot; // 0x58(0x01)
enum class ES_TraitGroup TraitGroup; // 0x59(0x01)
enum class ES_AbilityTimerIndex AbilityTimerIndex; // 0x5a(0x01)
char pad_5B[0x5]; // 0x5b(0x05)
struct FS_AbilitySet GameplayAbilities; // 0x60(0x10)
struct TArray<struct UGameplayEffect*> GameplayEffects; // 0x70(0x10)
struct TSoftObjectPtr<struct UTexture2D> SupportIcon; // 0x80(0x28)
};
// ScriptStruct Scavenger.S_TargetInfoManager
// Size: 0x28 (Inherited: 0x00)
struct FS_TargetInfoManager {
struct US_TargetInfoSettings* m_targetInfoSettings; // 0x00(0x08)
char pad_8[0x20]; // 0x08(0x20)
};
// ScriptStruct Scavenger.S_TeamPlayer
// Size: 0x10 (Inherited: 0x00)
struct FS_TeamPlayer {
struct AS_PlayerController* PlayerController; // 0x00(0x08)
char pad_8[0x8]; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_TeammateInfoManagerTickFunction
// Size: 0x30 (Inherited: 0x28)
struct FS_TeammateInfoManagerTickFunction : FTickFunction {
char pad_28[0x8]; // 0x28(0x08)
};
// ScriptStruct Scavenger.S_TeammateData
// Size: 0x130 (Inherited: 0x00)
struct FS_TeammateData {
char pad_0[0x8]; // 0x00(0x08)
struct FS_TeammateInfo TeammateInfo; // 0x08(0x120)
struct US_TeammateInfoDelegateProxy* TeammateInfoDelegateProxy; // 0x128(0x08)
};
// ScriptStruct Scavenger.S_TeamData
// Size: 0x10 (Inherited: 0x00)
struct FS_TeamData {
struct TArray<struct AS_PlayerController*> PlayerControllers; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_TechTreeMetadata
// Size: 0x88 (Inherited: 0x08)
struct FS_TechTreeMetadata : FTableRowBase {
struct FName ID; // 0x08(0x08)
struct FText Name; // 0x10(0x18)
struct FText NameCapitalized; // 0x28(0x18)
enum class ES_TechTreeCategory TechTreeCategory; // 0x40(0x01)
char pad_41[0x7]; // 0x41(0x07)
struct FText Description; // 0x48(0x18)
struct UTexture2D* Icon; // 0x60(0x08)
struct UTexture2D* Background; // 0x68(0x08)
int32_t RequiredMinimumLevel; // 0x70(0x04)
char pad_74[0x4]; // 0x74(0x04)
struct TArray<struct FDataTableRowHandle> UpgradeIds; // 0x78(0x10)
};
// ScriptStruct Scavenger.S_UpgradeMetadata
// Size: 0x88 (Inherited: 0x08)
struct FS_UpgradeMetadata : FTableRowBase {
struct FName ID; // 0x08(0x08)
struct FText Name; // 0x10(0x18)
struct FText NameCapitalized; // 0x28(0x18)
struct FText Description; // 0x40(0x18)
struct UTexture2D* Icon; // 0x58(0x08)
int32_t Tier; // 0x60(0x04)
int32_t Column; // 0x64(0x04)
struct TArray<struct FName> RequiredAllTalentIds; // 0x68(0x10)
struct TArray<struct FS_UpgradeRank> Ranks; // 0x78(0x10)
};
// ScriptStruct Scavenger.S_UpgradeRank
// Size: 0x20 (Inherited: 0x00)
struct FS_UpgradeRank {
struct FText Description; // 0x00(0x18)
float Value; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_PartyAction
// Size: 0x50 (Inherited: 0x10)
struct FS_PartyAction : FS_TelemetryEvent {
int32_t PartyActionIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString TargetPartyId; // 0x18(0x10)
struct FString InviterPlayerId; // 0x28(0x10)
struct FString InviteePlayerId; // 0x38(0x10)
bool AmITargetPartyInviter; // 0x48(0x01)
bool AmITargetPartyLeader; // 0x49(0x01)
enum class ES_PartyAction action; // 0x4a(0x01)
char pad_4B[0x5]; // 0x4b(0x05)
};
// ScriptStruct Scavenger.S_SocialAction
// Size: 0x30 (Inherited: 0x10)
struct FS_SocialAction : FS_TelemetryEvent {
int32_t SocialActionIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString targetPlayerId; // 0x18(0x10)
enum class ES_SocialAction action; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.S_PlayerSearchComplete
// Size: 0x30 (Inherited: 0x10)
struct FS_PlayerSearchComplete : FS_TelemetryEvent {
int32_t PlayerSearchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString SearchString; // 0x18(0x10)
int32_t SearchResultCount; // 0x28(0x04)
bool Succeeded; // 0x2c(0x01)
char pad_2D[0x3]; // 0x2d(0x03)
};
// ScriptStruct Scavenger.S_ClientPingResults
// Size: 0x28 (Inherited: 0x10)
struct FS_ClientPingResults : FS_TelemetryEvent {
int32_t PingAttemptIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TArray<struct FS_PingResultEntry> PingResults; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_PingResultEntry
// Size: 0x18 (Inherited: 0x00)
struct FS_PingResultEntry {
struct FString EndpointAddress; // 0x00(0x10)
enum class ES_LobbyEndpointPingStatus Status; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
int32_t MedianPingTimeSeconds; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_ClientGameNetworkingError
// Size: 0x38 (Inherited: 0x10)
struct FS_ClientGameNetworkingError : FS_TelemetryEvent {
struct FString MapName; // 0x10(0x10)
int32_t MatchIndex; // 0x20(0x04)
enum class ENetworkFailure FailureType; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
struct FString ErrorDetails; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_FTUEStageUpdate
// Size: 0x20 (Inherited: 0x10)
struct FS_FTUEStageUpdate : FS_TelemetryEvent {
struct FName FTUEStageID; // 0x10(0x08)
enum class ES_FTUETelemetryReason ReportReason; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
};
// ScriptStruct Scavenger.S_PlayerReportedAbuse
// Size: 0x40 (Inherited: 0x10)
struct FS_PlayerReportedAbuse : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString ReportedPlayerId; // 0x18(0x10)
struct FString ReportedPlayerDisplayName; // 0x28(0x10)
enum class ES_PlayerReportReason ReportReason; // 0x38(0x01)
char pad_39[0x7]; // 0x39(0x07)
};
// ScriptStruct Scavenger.S_DropshipArrivalTelemetryEvent
// Size: 0x20 (Inherited: 0x10)
struct FS_DropshipArrivalTelemetryEvent : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
struct FVector ArrivalLocation; // 0x14(0x0c)
};
// ScriptStruct Scavenger.S_ClientPurchaseFailed
// Size: 0x20 (Inherited: 0x10)
struct FS_ClientPurchaseFailed : FS_TelemetryEvent {
enum class ES_PurchaseRequestResult FailureReason; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
struct FName ItemId; // 0x14(0x08)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_ClientCultureChanged
// Size: 0x30 (Inherited: 0x10)
struct FS_ClientCultureChanged : FS_TelemetryEvent {
struct FString NewCulture; // 0x10(0x10)
struct FString OldCulture; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_ClientChatUsage
// Size: 0xf0 (Inherited: 0x10)
struct FS_ClientChatUsage : FS_TelemetryEvent {
struct FString LevelName; // 0x10(0x10)
struct FString GameMode; // 0x20(0x10)
int32_t LastClientMatchIndex; // 0x30(0x04)
float ConnectedToVoiceChatTotalSeconds; // 0x34(0x04)
float VoiceChatSendSeconds; // 0x38(0x04)
float VoiceChatReceiveSeconds; // 0x3c(0x04)
bool HasPushToTalk; // 0x40(0x01)
bool HasMic; // 0x41(0x01)
char pad_42[0x2]; // 0x42(0x02)
float ConnectedToTextChatTotalSeconds; // 0x44(0x04)
int32_t TextChatTotalMessagesSent; // 0x48(0x04)
int32_t TextChatTotalMessagesReceived; // 0x4c(0x04)
struct TMap<enum class ES_TextChatMessageTarget, int32_t> TextChatChannelMessagesSent; // 0x50(0x50)
struct TMap<enum class ES_TextChatMessageTarget, int32_t> TextChatChannelMessagesReceived; // 0xa0(0x50)
};
// ScriptStruct Scavenger.S_ClientJoinedRemoteMatch
// Size: 0x40 (Inherited: 0x10)
struct FS_ClientJoinedRemoteMatch : FS_TelemetryEvent {
int32_t ClientMatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString ServerTelemetrySessionId; // 0x18(0x10)
int32_t ServerMatchIndex; // 0x28(0x04)
int32_t ServerPlayerIndex; // 0x2c(0x04)
struct FString MatchID; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_NavMeshGenPerformancePercentage
// Size: 0x28 (Inherited: 0x10)
struct FS_NavMeshGenPerformancePercentage : FS_TelemetryEvent {
int32_t StartFrameNumber; // 0x10(0x04)
int32_t EndFrameNumber; // 0x14(0x04)
int32_t NumSamples; // 0x18(0x04)
int32_t FramesBuilding; // 0x1c(0x04)
float PercentageBuildingNavMesh; // 0x20(0x04)
float CaptureDurationGameTimeMs; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ServerAgonesReady
// Size: 0x10 (Inherited: 0x10)
struct FS_ServerAgonesReady : FS_TelemetryEvent {
};
// ScriptStruct Scavenger.S_NavMeshDirtyAreaCleaned
// Size: 0x48 (Inherited: 0x10)
struct FS_NavMeshDirtyAreaCleaned : FS_TelemetryEvent {
struct FBox AreaBounds; // 0x10(0x1c)
float DurationInSeconds; // 0x2c(0x04)
struct FString InstigatorName; // 0x30(0x10)
enum class ES_DirtiedAreaReason DirtiedReason; // 0x40(0x01)
char pad_41[0x3]; // 0x41(0x03)
int32_t MatchIndex; // 0x44(0x04)
};
// ScriptStruct Scavenger.S_NavMeshGenerationEnd
// Size: 0x18 (Inherited: 0x10)
struct FS_NavMeshGenerationEnd : FS_TelemetryEvent {
char pad_10[0x8]; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_NavMeshGenerationStart
// Size: 0x10 (Inherited: 0x10)
struct FS_NavMeshGenerationStart : FS_TelemetryEvent {
};
// ScriptStruct Scavenger.S_TelemetryEventStatsComponentGameplayEvent
// Size: 0x20 (Inherited: 0x10)
struct FS_TelemetryEventStatsComponentGameplayEvent : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
enum class ES_StatsState StatsState; // 0x18(0x01)
enum class ES_StatsGameplayEvent GameplayEvent; // 0x19(0x01)
char pad_1A[0x6]; // 0x1a(0x06)
};
// ScriptStruct Scavenger.S_ClientInputUsage
// Size: 0x28 (Inherited: 0x10)
struct FS_ClientInputUsage : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
float CapturePeriodSeconds; // 0x14(0x04)
bool IsGamepadAttached; // 0x18(0x01)
char pad_19[0x3]; // 0x19(0x03)
float GamepadInputProportion; // 0x1c(0x04)
char pad_20[0x8]; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_LobbyMatchmakingAttempt
// Size: 0x48 (Inherited: 0x10)
struct FS_LobbyMatchmakingAttempt : FS_TelemetryEvent {
int32_t LobbyConnectionIndex; // 0x10(0x04)
int32_t MatchmakingAttemptIndex; // 0x14(0x04)
int32_t ClientMatchIndex; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct FString QueueId; // 0x20(0x10)
struct FString QueueName; // 0x30(0x10)
float QueueTimeSeconds; // 0x40(0x04)
enum class ES_MatchmakingAttemptResult Result; // 0x44(0x01)
char pad_45[0x3]; // 0x45(0x03)
};
// ScriptStruct Scavenger.S_LobbyConnectionStateChanged
// Size: 0x20 (Inherited: 0x10)
struct FS_LobbyConnectionStateChanged : FS_TelemetryEvent {
int32_t LobbyConnectionIndex; // 0x10(0x04)
int32_t StateChangeIndex; // 0x14(0x04)
float PreviousStateTimeSeconds; // 0x18(0x04)
enum class ES_LobbyConnectionState PreviousState; // 0x1c(0x01)
enum class ES_LobbyConnectionState NewState; // 0x1d(0x01)
char pad_1E[0x2]; // 0x1e(0x02)
};
// ScriptStruct Scavenger.S_LobbyConnectionAttempt
// Size: 0x28 (Inherited: 0x10)
struct FS_LobbyConnectionAttempt : FS_TelemetryEvent {
int32_t LobbyConnectionIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString LobbyHost; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_WeaponUsageSummary
// Size: 0x70 (Inherited: 0x10)
struct FS_WeaponUsageSummary : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
float CapturePeriodSeconds; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct TMap<struct FName, struct FS_WeaponUsage> WeaponUsage; // 0x20(0x50)
};
// ScriptStruct Scavenger.S_WeaponUsage
// Size: 0x80 (Inherited: 0x00)
struct FS_WeaponUsage {
struct FString ItemName; // 0x00(0x10)
int32_t NumEquipped; // 0x10(0x04)
float TimeEquippedSeconds; // 0x14(0x04)
float TimeUnholsteredSeconds; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct TArray<int32_t> AttackCount; // 0x20(0x10)
struct TArray<int32_t> HitCount; // 0x30(0x10)
struct TArray<int32_t> CritCount; // 0x40(0x10)
struct TArray<float> HitDamage; // 0x50(0x10)
struct TArray<int32_t> CritDamage; // 0x60(0x10)
char pad_70[0x10]; // 0x70(0x10)
};
// ScriptStruct Scavenger.S_InMatchClientFeatureEngagementSummary
// Size: 0x68 (Inherited: 0x10)
struct FS_InMatchClientFeatureEngagementSummary : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct TMap<enum class ES_InMatchClientInputFeature, struct FS_InMatchClientFeature> EngagementData; // 0x18(0x50)
};
// ScriptStruct Scavenger.S_InMatchClientFeature
// Size: 0x08 (Inherited: 0x00)
struct FS_InMatchClientFeature {
float FirstUsedAtSeconds; // 0x00(0x04)
int32_t Count; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_HarvestCompleted
// Size: 0x58 (Inherited: 0x10)
struct FS_HarvestCompleted : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
int32_t InitiatingPlayerLevel; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct FString EncounterName; // 0x20(0x10)
struct FString EncounterType; // 0x30(0x10)
struct FVector EncounterWorldLocation; // 0x40(0x0c)
enum class ES_HarvestResult HarvestResult; // 0x4c(0x01)
char pad_4D[0x3]; // 0x4d(0x03)
float TimeToHarvestCompletionSeconds; // 0x50(0x04)
int32_t HarvestShardYield; // 0x54(0x04)
};
// ScriptStruct Scavenger.S_PlayerStatChangedByVolume
// Size: 0x48 (Inherited: 0x10)
struct FS_PlayerStatChangedByVolume : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
enum class ES_StatType StatType; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
struct FString VolumeName; // 0x20(0x10)
struct FVector VolumeWorldLocation; // 0x30(0x0c)
float ChangeAmount; // 0x3c(0x04)
float TimeSpentInVolumeSeconds; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
};
// ScriptStruct Scavenger.S_ClientQualitySettings
// Size: 0x60 (Inherited: 0x10)
struct FS_ClientQualitySettings : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
bool CurrentlyInMatch; // 0x14(0x01)
bool AreDefaultSettings; // 0x15(0x01)
char pad_16[0x2]; // 0x16(0x02)
struct FIntPoint ScreenResolution; // 0x18(0x08)
struct FString FullscreenMode; // 0x20(0x10)
bool IsVSyncEnabled; // 0x30(0x01)
char pad_31[0x3]; // 0x31(0x03)
int32_t ViewDistanceQuality; // 0x34(0x04)
int32_t ShadowDistanceQuality; // 0x38(0x04)
int32_t AntiAliasingQuality; // 0x3c(0x04)
int32_t TextureQuality; // 0x40(0x04)
int32_t VisualEffectQuality; // 0x44(0x04)
int32_t PostProcessingQuality; // 0x48(0x04)
int32_t FoliageQuality; // 0x4c(0x04)
float LastCPUBenchmarkResult; // 0x50(0x04)
float LastGPUBenchmarkResult; // 0x54(0x04)
int32_t ResolutionScale; // 0x58(0x04)
enum class ES_SupportedRHIType PreferredRHIType; // 0x5c(0x01)
enum class ES_ResolutionScalingMode ResolutionScalingMode; // 0x5d(0x01)
char pad_5E[0x2]; // 0x5e(0x02)
};
// ScriptStruct Scavenger.S_ClientCascadeLoadFinished
// Size: 0x28 (Inherited: 0x10)
struct FS_ClientCascadeLoadFinished : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
struct FVector ViewTargetLocation; // 0x14(0x0c)
float LoadTimeSeconds; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_VoiceChatChannelUpdated
// Size: 0x40 (Inherited: 0x10)
struct FS_VoiceChatChannelUpdated : FS_TelemetryEvent {
struct FString ChannelName; // 0x10(0x10)
int32_t ChannelType; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString PlayerName; // 0x28(0x10)
int32_t PlayerCount; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_TutorialExited
// Size: 0x20 (Inherited: 0x10)
struct FS_TutorialExited : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
bool WasCompleted; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
float TutorialDurationSeconds; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_DojoMatchPhaseChanged
// Size: 0x60 (Inherited: 0x10)
struct FS_DojoMatchPhaseChanged : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString MapName; // 0x18(0x10)
struct FString DojoStateMachineId; // 0x28(0x10)
struct FString PreviousPhaseName; // 0x38(0x10)
float PreviousPhaseDurationSeconds; // 0x48(0x04)
char pad_4C[0x4]; // 0x4c(0x04)
struct FString NewPhaseName; // 0x50(0x10)
};
// ScriptStruct Scavenger.S_MatchPhaseChanged
// Size: 0x60 (Inherited: 0x10)
struct FS_MatchPhaseChanged : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString PreviousPhaseName; // 0x18(0x10)
float PreviousPhaseDurationSeconds; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct FString NewPhaseName; // 0x30(0x10)
bool IsInitialValue; // 0x40(0x01)
char pad_41[0x7]; // 0x41(0x07)
struct FString ChangeReason; // 0x48(0x10)
float ChangeReasonDetail; // 0x58(0x04)
char pad_5C[0x4]; // 0x5c(0x04)
};
// ScriptStruct Scavenger.S_TrainingVideoWatched
// Size: 0x18 (Inherited: 0x10)
struct FS_TrainingVideoWatched : FS_TelemetryEvent {
int32_t SecondsWatched; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_MessagePromptReceived
// Size: 0x38 (Inherited: 0x10)
struct FS_MessagePromptReceived : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString MessageId; // 0x18(0x10)
struct FString PromptMode; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_CraftingItemQueued
// Size: 0x38 (Inherited: 0x10)
struct FS_CraftingItemQueued : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
struct FString RecipeId; // 0x18(0x10)
float TimeToCraft; // 0x28(0x04)
int32_t QueueIndex; // 0x2c(0x04)
bool HasCorrectResourceQuantity; // 0x30(0x01)
char pad_31[0x7]; // 0x31(0x07)
};
// ScriptStruct Scavenger.S_InventoryLedger
// Size: 0x30 (Inherited: 0x10)
struct FS_InventoryLedger : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
int32_t InventoryLedgerIndex; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct TArray<struct FS_InventoryLedgerItem> Items; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_InventoryLedgerItem
// Size: 0x20 (Inherited: 0x00)
struct FS_InventoryLedgerItem {
struct FString ItemName; // 0x00(0x10)
struct TArray<struct FS_InventoryLedgerEntry> Entries; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_InventoryLedgerEntry
// Size: 0x20 (Inherited: 0x00)
struct FS_InventoryLedgerEntry {
bool IsCredit; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FString Reason; // 0x08(0x10)
int32_t Quantity; // 0x18(0x04)
int32_t Count; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_DebugLogTelemetryEvent
// Size: 0x38 (Inherited: 0x10)
struct FS_DebugLogTelemetryEvent : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
struct FString Tag; // 0x18(0x10)
struct FString Text; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_GameModeEventTelemetry
// Size: 0x58 (Inherited: 0x10)
struct FS_GameModeEventTelemetry : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
float EventTimeStamp; // 0x14(0x04)
struct FString EventType; // 0x18(0x10)
struct FString PlayerId; // 0x28(0x10)
int32_t PlayerIndex; // 0x38(0x04)
int32_t TeamIndex; // 0x3c(0x04)
float FloatData; // 0x40(0x04)
int32_t IntData; // 0x44(0x04)
struct FString NameData; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_EndOfGameReportCard
// Size: 0x130 (Inherited: 0x10)
struct FS_EndOfGameReportCard : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
struct FS_GameReportCardForPlayer reportCard; // 0x18(0x118)
};
// ScriptStruct Scavenger.S_EndOfGameScoreCard
// Size: 0x78 (Inherited: 0x10)
struct FS_EndOfGameScoreCard : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
struct FS_GameScoreCardForPlayer Scorecard; // 0x18(0x60)
};
// ScriptStruct Scavenger.S_BugReport_Temp
// Size: 0x38 (Inherited: 0x10)
struct FS_BugReport_Temp : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
bool CurrentlyInMatch; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
struct FString Title; // 0x18(0x10)
struct FString Description; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_DetailedRatingReport_Temp
// Size: 0x40 (Inherited: 0x10)
struct FS_DetailedRatingReport_Temp : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
bool CurrentlyInMatch; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
struct FString Context; // 0x18(0x10)
struct FString Question; // 0x28(0x10)
int32_t Rating; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
};
// ScriptStruct Scavenger.S_DetailedFeedbackReport_Temp
// Size: 0x48 (Inherited: 0x10)
struct FS_DetailedFeedbackReport_Temp : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
bool CurrentlyInMatch; // 0x14(0x01)
char pad_15[0x3]; // 0x15(0x03)
struct FString Context; // 0x18(0x10)
struct FString Question; // 0x28(0x10)
struct FString response; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_EulaResult
// Size: 0x18 (Inherited: 0x10)
struct FS_EulaResult : FS_TelemetryEvent {
bool EulaWasAccepted; // 0x10(0x01)
char pad_11[0x7]; // 0x11(0x07)
};
// ScriptStruct Scavenger.S_TeamEliminated
// Size: 0x20 (Inherited: 0x10)
struct FS_TeamEliminated : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t TeamIndex; // 0x14(0x04)
float TeamAliveSeconds; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_PlayerDownedOrKilled
// Size: 0xc8 (Inherited: 0x10)
struct FS_PlayerDownedOrKilled : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
struct FString NewState; // 0x18(0x10)
int32_t LastDamageInstigatorPlayerIndex; // 0x28(0x04)
int32_t LastDamageInstigatorAIIndex; // 0x2c(0x04)
struct FVector LastDamageInstigatorLocation; // 0x30(0x0c)
char pad_3C[0x4]; // 0x3c(0x04)
struct FString LastDamageType; // 0x40(0x10)
struct FVector WorldLocation; // 0x50(0x0c)
char pad_5C[0x4]; // 0x5c(0x04)
struct FString NamedLocation; // 0x60(0x10)
int32_t PlayerLevel; // 0x70(0x04)
char pad_74[0x4]; // 0x74(0x04)
struct TMap<struct FString, int32_t> PlayerInventory; // 0x78(0x50)
};
// ScriptStruct Scavenger.S_AILeftNavmesh
// Size: 0x58 (Inherited: 0x10)
struct FS_AILeftNavmesh : FS_TelemetryEvent {
int32_t AIIndex; // 0x10(0x04)
int32_t MatchIndex; // 0x14(0x04)
struct FString OverlordName; // 0x18(0x10)
struct FString AIName; // 0x28(0x10)
struct FString AIClassName; // 0x38(0x10)
struct FVector Location; // 0x48(0x0c)
bool OccuredOnSpawn; // 0x54(0x01)
char pad_55[0x3]; // 0x55(0x03)
};
// ScriptStruct Scavenger.S_AIDiedOrKilled
// Size: 0x50 (Inherited: 0x10)
struct FS_AIDiedOrKilled : FS_TelemetryEvent {
int32_t AIIndex; // 0x10(0x04)
int32_t MatchIndex; // 0x14(0x04)
struct FString CauseOfDeath; // 0x18(0x10)
int32_t LastDamageInstigatorPlayerIndex; // 0x28(0x04)
int32_t LastDamageInstigatorAIIndex; // 0x2c(0x04)
struct FString LastDamageType; // 0x30(0x10)
struct FVector DeathLocation; // 0x40(0x0c)
char pad_4C[0x4]; // 0x4c(0x04)
};
// ScriptStruct Scavenger.S_AISpawned
// Size: 0x58 (Inherited: 0x10)
struct FS_AISpawned : FS_TelemetryEvent {
int32_t AIIndex; // 0x10(0x04)
int32_t MatchIndex; // 0x14(0x04)
struct FString OverlordName; // 0x18(0x10)
struct FString AIName; // 0x28(0x10)
struct FString AIClassName; // 0x38(0x10)
struct FVector SpawnLocation; // 0x48(0x0c)
char pad_54[0x4]; // 0x54(0x04)
};
// ScriptStruct Scavenger.S_OverlordLocationInfo
// Size: 0x38 (Inherited: 0x10)
struct FS_OverlordLocationInfo : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
char pad_14[0x4]; // 0x14(0x04)
struct FString OverlordName; // 0x18(0x10)
struct TArray<struct FS_AILocationInfo> AILocationInfo; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_AILocationInfo
// Size: 0x10 (Inherited: 0x00)
struct FS_AILocationInfo {
int32_t AIIndex; // 0x00(0x04)
struct FVector WorldLocation; // 0x04(0x0c)
};
// ScriptStruct Scavenger.S_PlayerLeveledUp
// Size: 0x28 (Inherited: 0x10)
struct FS_PlayerLeveledUp : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
int32_t NewLevel; // 0x18(0x04)
int32_t PlayerXp; // 0x1c(0x04)
float PreviousLevelTimeSeconds; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_TeamLocationInfo
// Size: 0x38 (Inherited: 0x10)
struct FS_TeamLocationInfo : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t TeamIndex; // 0x14(0x04)
struct TArray<struct FS_PlayerLocationInfo> PlayerLocationInfo; // 0x18(0x10)
struct TArray<int32_t> TeamSquadSizes; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_PlayerLocationInfo
// Size: 0x30 (Inherited: 0x00)
struct FS_PlayerLocationInfo {
int32_t PlayerIndex; // 0x00(0x04)
int32_t TeamSquadIndex; // 0x04(0x04)
struct FVector WorldLocation; // 0x08(0x0c)
char pad_14[0x4]; // 0x14(0x04)
struct FString NamedLocation; // 0x18(0x10)
bool IsInVehicle; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.S_PlayerLeftMatch
// Size: 0x30 (Inherited: 0x10)
struct FS_PlayerLeftMatch : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
enum class ES_PlayerLeftMatchPlayerState PlayerState; // 0x18(0x01)
enum class ES_PlayerLeftMatchReason Reason; // 0x19(0x01)
char pad_1A[0x6]; // 0x1a(0x06)
struct FString Details; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_PlayerSpawned
// Size: 0x38 (Inherited: 0x10)
struct FS_PlayerSpawned : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
int32_t PlayerIndex; // 0x14(0x04)
int32_t SpawnIndex; // 0x18(0x04)
float RespawnTimeSeconds; // 0x1c(0x04)
struct FVector SpawnLocation; // 0x20(0x0c)
float DistanceToNearestTeammate; // 0x2c(0x04)
float DistanceToNearestEnemyPlayer; // 0x30(0x04)
float DistanceToNearestHostileAI; // 0x34(0x04)
};
// ScriptStruct Scavenger.S_PlayerJoinedMatch
// Size: 0xe8 (Inherited: 0x10)
struct FS_PlayerJoinedMatch : FS_TelemetryEvent {
struct FString ClientTelemetrySessionId; // 0x10(0x10)
int32_t ClientMatchIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString AccountId; // 0x28(0x10)
int32_t PlayerIndex; // 0x38(0x04)
int32_t MatchIndex; // 0x3c(0x04)
int32_t TeamIndex; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
struct FString CharacterClass; // 0x48(0x10)
int32_t CharacterLevel; // 0x58(0x04)
char pad_5C[0x4]; // 0x5c(0x04)
struct TMap<struct FString, struct FS_CharacterLoadoutSlotForTelemetry> Loadout; // 0x60(0x50)
struct FString SpawnLocationName; // 0xb0(0x10)
struct FVector SpawnLocation; // 0xc0(0x0c)
enum class ES_PlayerTelemetryType PlayerTelemetryType; // 0xcc(0x01)
char pad_CD[0x3]; // 0xcd(0x03)
int32_t DraftOrder; // 0xd0(0x04)
char pad_D4[0x4]; // 0xd4(0x04)
struct FString PartyId; // 0xd8(0x10)
};
// ScriptStruct Scavenger.S_CharacterLoadoutSlotForTelemetry
// Size: 0x10 (Inherited: 0x00)
struct FS_CharacterLoadoutSlotForTelemetry {
struct TArray<struct FString> ItemIds; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_MatchEnd
// Size: 0x20 (Inherited: 0x10)
struct FS_MatchEnd : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
float TotalMatchDurationSeconds; // 0x14(0x04)
enum class ES_MatchEndReason EndReason; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
};
// ScriptStruct Scavenger.S_MatchStart
// Size: 0x18 (Inherited: 0x10)
struct FS_MatchStart : FS_TelemetryEvent {
int32_t MatchIndex; // 0x10(0x04)
float GameTimeElapsedSeconds; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_OffloadedMatchCreated
// Size: 0x38 (Inherited: 0x10)
struct FS_OffloadedMatchCreated : FS_TelemetryEvent {
struct FString WorkerTelemetrySessionId; // 0x10(0x10)
int32_t MatchIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString MatchID; // 0x28(0x10)
};
// ScriptStruct Scavenger.S_MatchCreated
// Size: 0x48 (Inherited: 0x10)
struct FS_MatchCreated : FS_TelemetryEvent {
struct FString MatchID; // 0x10(0x10)
int32_t MatchIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
struct FString GameModeName; // 0x28(0x10)
struct FString LevelName; // 0x38(0x10)
};
// ScriptStruct Scavenger.S_TelemetryDeviceInfo
// Size: 0x100 (Inherited: 0x10)
struct FS_TelemetryDeviceInfo : FS_TelemetryEvent {
struct FString Platform; // 0x10(0x10)
struct FString OsVersion; // 0x20(0x10)
struct FString OsSubVersion; // 0x30(0x10)
int32_t OsBits; // 0x40(0x04)
char pad_44[0x4]; // 0x44(0x04)
struct FString OsLanguage; // 0x48(0x10)
struct FString RenderingAPI; // 0x58(0x10)
int32_t HardDriveGb; // 0x68(0x04)
int32_t MemoryMb; // 0x6c(0x04)
float CpuPerformanceIndex; // 0x70(0x04)
float GpuPerformanceIndex; // 0x74(0x04)
float RamPerformanceIndex; // 0x78(0x04)
bool IsLaptopComputer; // 0x7c(0x01)
char pad_7D[0x3]; // 0x7d(0x03)
int32_t CpuCount; // 0x80(0x04)
float CpuClockGhz; // 0x84(0x04)
struct FString CpuBrand; // 0x88(0x10)
struct FString CpuNameString; // 0x98(0x10)
int32_t DisplayCount; // 0xa8(0x04)
char pad_AC[0x4]; // 0xac(0x04)
struct TArray<struct FString> Displays; // 0xb0(0x10)
struct FString RhiName; // 0xc0(0x10)
struct FString RhiInternalDriverVersion; // 0xd0(0x10)
struct FString RhiUserDriverVersion; // 0xe0(0x10)
struct FString RhiUserDriverDate; // 0xf0(0x10)
};
// ScriptStruct Scavenger.S_TelemetryMemoryReport
// Size: 0x20 (Inherited: 0x10)
struct FS_TelemetryMemoryReport : FS_TelemetryEvent {
int32_t FrameNumber; // 0x10(0x04)
float PhysicalMemoryUsed; // 0x14(0x04)
int32_t MatchIndex; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_TelemetryPerformanceHitches
// Size: 0x28 (Inherited: 0x10)
struct FS_TelemetryPerformanceHitches : FS_TelemetryEvent {
struct TArray<struct FS_TelemetryHitch> Hitches; // 0x10(0x10)
bool HitchStorageExceeded; // 0x20(0x01)
char pad_21[0x3]; // 0x21(0x03)
int32_t MatchIndex; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_TelemetryHitch
// Size: 0x0c (Inherited: 0x00)
struct FS_TelemetryHitch {
int32_t FrameNumber; // 0x00(0x04)
float FrameTime; // 0x04(0x04)
enum class FS_TelemetryHitchEnum HitchType; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
};
// ScriptStruct Scavenger.S_TelemetryPerformanceHistogramFlyCamera
// Size: 0xc0 (Inherited: 0x10)
struct FS_TelemetryPerformanceHistogramFlyCamera : FS_TelemetryEvent {
struct FString CounterName; // 0x10(0x10)
int32_t StartFrameNumber; // 0x20(0x04)
int32_t EndFrameNumber; // 0x24(0x04)
int32_t NumSamples; // 0x28(0x04)
float CaptureDurationGameTimeMs; // 0x2c(0x04)
float BucketSize; // 0x30(0x04)
float MinBucketValue; // 0x34(0x04)
float MaxBucketValue; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
struct TMap<float, int32_t> SampleHistogram; // 0x40(0x50)
struct FVector CameraLocation; // 0x90(0x0c)
struct FVector CameraDirection; // 0x9c(0x0c)
float StepDistance; // 0xa8(0x04)
float TimeBeforeTestStartSec; // 0xac(0x04)
float TimeAfterTeleportSec; // 0xb0(0x04)
float TimeAfterRotationSec; // 0xb4(0x04)
float CameraTerrainHeight; // 0xb8(0x04)
bool WaitForShaderCompilation; // 0xbc(0x01)
bool WaitForLevelLoaded; // 0xbd(0x01)
char pad_BE[0x2]; // 0xbe(0x02)
};
// ScriptStruct Scavenger.S_TelemetryPerformanceHistogram
// Size: 0x98 (Inherited: 0x10)
struct FS_TelemetryPerformanceHistogram : FS_TelemetryEvent {
struct FString CounterName; // 0x10(0x10)
int32_t StartFrameNumber; // 0x20(0x04)
int32_t EndFrameNumber; // 0x24(0x04)
int32_t NumSamples; // 0x28(0x04)
float CaptureDurationGameTimeMs; // 0x2c(0x04)
float BucketSize; // 0x30(0x04)
float MinBucketValue; // 0x34(0x04)
float MaxBucketValue; // 0x38(0x04)
char pad_3C[0x4]; // 0x3c(0x04)
struct TMap<float, int32_t> SampleHistogram; // 0x40(0x50)
int32_t MatchIndex; // 0x90(0x04)
char pad_94[0x4]; // 0x94(0x04)
};
// ScriptStruct Scavenger.S_TelemetryGameStateObjectCount
// Size: 0x28 (Inherited: 0x10)
struct FS_TelemetryGameStateObjectCount : FS_TelemetryEvent {
int32_t FrameNumber; // 0x10(0x04)
int32_t TotalActorCount; // 0x14(0x04)
int32_t TotalControllerCount; // 0x18(0x04)
int32_t TotalPlayerControllerCount; // 0x1c(0x04)
int32_t TotalAiControllerCount; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_TelemetrySessionStart
// Size: 0xc0 (Inherited: 0x10)
struct FS_TelemetrySessionStart : FS_TelemetryEvent {
struct FString PlatformId; // 0x10(0x10)
struct FString MachineName; // 0x20(0x10)
int32_t Changelist; // 0x30(0x04)
bool IsServer; // 0x34(0x01)
char pad_35[0x3]; // 0x35(0x03)
struct FString DeviceID; // 0x38(0x10)
struct FString CommandLine; // 0x48(0x10)
struct FString UnrealNetworkVersion; // 0x58(0x10)
struct FString BuildType; // 0x68(0x10)
struct FString ServerPodId; // 0x78(0x10)
struct FString ServerNodeName; // 0x88(0x10)
struct FString clusterName; // 0x98(0x10)
struct FString ContainerName; // 0xa8(0x10)
int32_t TimezoneUtcOffsetMinutes; // 0xb8(0x04)
char pad_BC[0x4]; // 0xbc(0x04)
};
// ScriptStruct Scavenger.S_MatchTelemetryIds
// Size: 0x28 (Inherited: 0x00)
struct FS_MatchTelemetryIds {
struct FString WorkerTelemetrySessionId; // 0x00(0x10)
struct FString MatchID; // 0x10(0x10)
int32_t MatchIndex; // 0x20(0x04)
char pad_24[0x4]; // 0x24(0x04)
};
// ScriptStruct Scavenger.S_ThreatLevelMidnight
// Size: 0x1c (Inherited: 0x00)
struct FS_ThreatLevelMidnight {
float CharacterThreat; // 0x00(0x04)
float HealthThreat; // 0x04(0x04)
float WeaponThreat; // 0x08(0x04)
float MinEffectiveWeaponRange; // 0x0c(0x04)
float MaxEffectiveWeaponRange; // 0x10(0x04)
float GlobalThreat; // 0x14(0x04)
bool bDowned; // 0x18(0x01)
char pad_19[0x3]; // 0x19(0x03)
};
// ScriptStruct Scavenger.S_InStormQualitySettings
// Size: 0x14 (Inherited: 0x00)
struct FS_InStormQualitySettings {
int32_t ShadowQuality; // 0x00(0x04)
int32_t MaxShadowCascades; // 0x04(0x04)
float ViewDistanceScale; // 0x08(0x04)
int32_t LensFlareQuality; // 0x0c(0x04)
int32_t AmbientOcclusionQuality; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_StormClientData
// Size: 0x198 (Inherited: 0x00)
struct FS_StormClientData {
char pad_0[0x90]; // 0x00(0x90)
struct US_StormMeshComponent* StaticMeshComponentOccluder; // 0x90(0x08)
struct US_StormMeshComponent* StaticMeshComponentFunnelInner[0x2]; // 0x98(0x10)
struct US_StormMeshComponent* StaticMeshComponentFunnelMiddle[0x2]; // 0xa8(0x10)
struct US_StormMeshComponent* StaticMeshComponentFunnelOuter[0x2]; // 0xb8(0x10)
struct US_StormMeshComponent* StaticMeshComponentMistInner; // 0xc8(0x08)
struct US_StormMeshComponent* StaticMeshComponentMistOuter; // 0xd0(0x08)
struct US_StormMeshComponent* StaticMeshComponentFinProfileLeft; // 0xd8(0x08)
struct US_StormMeshComponent* StaticMeshComponentFinProfileRight; // 0xe0(0x08)
struct UMaterialInstanceDynamic* MaterialInstOccluder; // 0xe8(0x08)
struct UMaterialInstanceDynamic* MaterialInstMeshInner; // 0xf0(0x08)
struct UMaterialInstanceDynamic* MaterialInstMeshMiddle; // 0xf8(0x08)
struct UMaterialInstanceDynamic* MaterialInstMeshOuter; // 0x100(0x08)
struct UMaterialInstanceDynamic* MaterialInstMistInner; // 0x108(0x08)
struct UMaterialInstanceDynamic* MaterialInstMistOuter; // 0x110(0x08)
struct UMaterialInstanceDynamic* MaterialInstFinProfileLeft; // 0x118(0x08)
struct UMaterialInstanceDynamic* MaterialInstFinProfileRight; // 0x120(0x08)
struct UParticleSystem* ParticleSystemDebris; // 0x128(0x08)
struct UParticleSystem* ParticleSystemBurst; // 0x130(0x08)
struct UParticleSystemComponent* ParticleSystemComponentDebris; // 0x138(0x08)
char pad_140[0x28]; // 0x140(0x28)
struct UParticleSystem* ParticleSystemPreamble; // 0x168(0x08)
struct UParticleSystemComponent* ParticleSystemComponentPreamble; // 0x170(0x08)
struct UParticleSystem* ParticleSystemGrowth; // 0x178(0x08)
struct UParticleSystemComponent* ParticleSystemComponentGrowth; // 0x180(0x08)
struct UParticleSystem* ParticleSystemShrink; // 0x188(0x08)
struct UParticleSystemComponent* ParticleSystemComponentShrink; // 0x190(0x08)
};
// ScriptStruct Scavenger.S_CollapsingStormOccluderSegment
// Size: 0x50 (Inherited: 0x00)
struct FS_CollapsingStormOccluderSegment {
struct UStaticMeshComponent* StaticMeshComponent; // 0x00(0x08)
char pad_8[0x48]; // 0x08(0x48)
};
// ScriptStruct Scavenger.S_CollapsingStormSegment
// Size: 0x28 (Inherited: 0x00)
struct FS_CollapsingStormSegment {
struct UStaticMeshComponent* StaticMeshComponent; // 0x00(0x08)
struct UParticleSystemComponent* AmbientParticleSystemComponent; // 0x08(0x08)
struct UParticleSystemComponent* RollingParticleSystemComponent; // 0x10(0x08)
char pad_18[0x10]; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_CollapsingStormData
// Size: 0x88 (Inherited: 0x00)
struct FS_CollapsingStormData {
struct FVector WorldLocationRealtime; // 0x00(0x0c)
struct FVector WorldLocationReplicated; // 0x0c(0x0c)
struct FVector ClientWorldLocation; // 0x18(0x0c)
struct FVector LastKnownServerWorldLocation; // 0x24(0x0c)
struct FVector NextWorldLocation; // 0x30(0x0c)
float WorldLocationTransitionDurationRealtime; // 0x3c(0x04)
float WorldLocationTransitionDurationReplicated; // 0x40(0x04)
float RadiusRealtime; // 0x44(0x04)
float RadiusReplicated; // 0x48(0x04)
float LastKnownServerRadius; // 0x4c(0x04)
float ClientRadius; // 0x50(0x04)
float NextRadius; // 0x54(0x04)
float RadiusTransitionPerSecondRealtime; // 0x58(0x04)
float RadiusTransitionPerSecondReplicated; // 0x5c(0x04)
struct FVector RadiusMaxMinFraction; // 0x60(0x0c)
struct FVector OutlineColor; // 0x6c(0x0c)
float ReplicationTimer; // 0x78(0x04)
bool bTransformDirty; // 0x7c(0x01)
char pad_7D[0x3]; // 0x7d(0x03)
int32_t NumActiveSegments; // 0x80(0x04)
int32_t SegmentSampleIndex; // 0x84(0x04)
};
// ScriptStruct Scavenger.S_CollapsingStormIncludeLocation
// Size: 0x14 (Inherited: 0x00)
struct FS_CollapsingStormIncludeLocation {
struct FVector Location; // 0x00(0x0c)
float SafeRadius; // 0x0c(0x04)
float Weight; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_BorderStormData
// Size: 0x80 (Inherited: 0x00)
struct FS_BorderStormData {
struct FVector WorldLocationRealtime; // 0x00(0x0c)
struct FVector WorldLocationReplicated; // 0x0c(0x0c)
struct FVector ClientWorldLocation; // 0x18(0x0c)
struct FVector LastKnownServerWorldLocation; // 0x24(0x0c)
struct FVector NextWorldLocation; // 0x30(0x0c)
float WorldLocationTransitionDurationRealtime; // 0x3c(0x04)
float WorldLocationTransitionDurationReplicated; // 0x40(0x04)
struct FVector2D ExtentsRealtime; // 0x44(0x08)
struct FVector2D ExtentsReplicated; // 0x4c(0x08)
struct FVector2D LastKnownServerExtents; // 0x54(0x08)
struct FVector2D ClientExtents; // 0x5c(0x08)
struct FVector2D NextExtents; // 0x64(0x08)
struct FVector2D ExtentsTransitionPerSecondRealtime; // 0x6c(0x08)
struct FVector2D ExtentsTransitionPerSecondReplicated; // 0x74(0x08)
float ReplicationTimer; // 0x7c(0x04)
};
// ScriptStruct Scavenger.S_TryActionResult
// Size: 0x08 (Inherited: 0x00)
struct FS_TryActionResult {
struct FS_ActionHandle m_handle; // 0x00(0x04)
enum class ES_ActionStatus m_actionStatus; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
};
// ScriptStruct Scavenger.S_FilteredResearchOptions
// Size: 0x60 (Inherited: 0x00)
struct FS_FilteredResearchOptions {
struct TArray<struct FS_OnlineItemMetadata> FilteredMetadata; // 0x00(0x10)
char pad_10[0x50]; // 0x10(0x50)
};
// ScriptStruct Scavenger.S_TalentOptions
// Size: 0xb0 (Inherited: 0x60)
struct FS_TalentOptions : FS_FilteredResearchOptions {
char pad_60[0x50]; // 0x60(0x50)
};
// ScriptStruct Scavenger.S_SpawnableHUD
// Size: 0x10 (Inherited: 0x00)
struct FS_SpawnableHUD {
struct US_UMGHUD* HUD; // 0x00(0x08)
bool ShouldShowOnSpawn; // 0x08(0x01)
enum class ES_InGameZOrderCategory ZOrder; // 0x09(0x01)
char pad_A[0x6]; // 0x0a(0x06)
};
// ScriptStruct Scavenger.S_HUDMessage
// Size: 0x20 (Inherited: 0x00)
struct FS_HUDMessage {
struct FText Message; // 0x00(0x18)
float AgeInSeconds; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
};
// ScriptStruct Scavenger.S_SpawnableWidget
// Size: 0x30 (Inherited: 0x00)
struct FS_SpawnableWidget {
struct US_WidgetMinimal* Widget; // 0x00(0x08)
bool Override_UsePositioningData; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FS_WidgetPositioningData WidgetPositioning; // 0x0c(0x20)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_WidgetPositioningData
// Size: 0x20 (Inherited: 0x00)
struct FS_WidgetPositioningData {
struct FVector2D Position; // 0x00(0x08)
struct FVector2D Alignment; // 0x08(0x08)
struct FAnchors Anchors; // 0x10(0x10)
};
// ScriptStruct Scavenger.S_NavigationInputSettings
// Size: 0x40 (Inherited: 0x08)
struct FS_NavigationInputSettings : FTableRowBase {
SoftClassProperty WidgetClass; // 0x08(0x28)
struct TArray<struct FDataTableRowHandle> AcceptedInputs; // 0x30(0x10)
};
// ScriptStruct Scavenger.S_MessagePromptArguments
// Size: 0x80 (Inherited: 0x00)
struct FS_MessagePromptArguments {
struct TMap<struct FString, struct FText> MessagePromptArguments; // 0x00(0x50)
struct FText AcceptText; // 0x50(0x18)
struct FText RejectText; // 0x68(0x18)
};
// ScriptStruct Scavenger.S_MessagePrompt
// Size: 0x58 (Inherited: 0x08)
struct FS_MessagePrompt : FTableRowBase {
enum class ES_MessagePromptMode PromptMode; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FText DisplayName; // 0x10(0x18)
struct FText Body; // 0x28(0x18)
struct FText StatusCode; // 0x40(0x18)
};
// ScriptStruct Scavenger.S_RecipeLabelRow
// Size: 0x30 (Inherited: 0x08)
struct FS_RecipeLabelRow : FTableRowBase {
struct FString LabelId; // 0x08(0x10)
struct FText LocalizedLabel; // 0x18(0x18)
};
// ScriptStruct Scavenger.S_NewTierIdentification
// Size: 0x58 (Inherited: 0x00)
struct FS_NewTierIdentification {
struct FS_TonedInterfaceColors TonedTierColorHandles; // 0x00(0x30)
bool NameplateShowName; // 0x30(0x01)
enum class ES_NamePlateHealthBarBehavior NameplateShowHealthBar; // 0x31(0x01)
bool NameplateShowArmor; // 0x32(0x01)
enum class ES_ItemRarity Rarity; // 0x33(0x01)
enum class ES_LocationDifficultyTier LocationDifficultyTier; // 0x34(0x01)
char pad_35[0x3]; // 0x35(0x03)
struct FInt32Range ArmorRange; // 0x38(0x10)
struct FInt32Range EnemyRankRange; // 0x48(0x10)
};
// ScriptStruct Scavenger.S_TonedInterfaceColors
// Size: 0x30 (Inherited: 0x00)
struct FS_TonedInterfaceColors {
struct FDataTableRowHandle HighlightInterfaceColor; // 0x00(0x10)
struct FDataTableRowHandle MidtoneInterfaceColor; // 0x10(0x10)
struct FDataTableRowHandle ShadowInterfaceColor; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_InterfaceColorRow
// Size: 0x48 (Inherited: 0x08)
struct FS_InterfaceColorRow : FTableRowBase {
struct FLinearColor Colors[0x4]; // 0x08(0x40)
};
// ScriptStruct Scavenger.S_ParabolicHUDEffectData
// Size: 0x10 (Inherited: 0x00)
struct FS_ParabolicHUDEffectData {
float DistortionScalar; // 0x00(0x04)
float CenterWidth; // 0x04(0x04)
struct FVector2D HudOffset; // 0x08(0x08)
};
// ScriptStruct Scavenger.S_TeamMiniscoreboardStatus
// Size: 0x30 (Inherited: 0x00)
struct FS_TeamMiniscoreboardStatus {
bool IsAlive; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t TeamIndex; // 0x04(0x04)
struct FText TeamName; // 0x08(0x18)
int32_t TeamScore; // 0x20(0x04)
int32_t TeamShardsBanked; // 0x24(0x04)
int32_t TeanShardsHeld; // 0x28(0x04)
float TeamScoreAsPercentageOfWinningScore; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_WidgetData
// Size: 0x28 (Inherited: 0x00)
struct FS_WidgetData {
struct UUserWidget* Widget; // 0x00(0x08)
char pad_8[0x20]; // 0x08(0x20)
};
// ScriptStruct Scavenger.S_ProgressBarHandleData
// Size: 0x98 (Inherited: 0x00)
struct FS_ProgressBarHandleData {
struct US_WidgetCommonProgressBarHandle* Class; // 0x00(0x08)
float StartingValue; // 0x08(0x04)
enum class EOrientation HandleOrientation; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
struct FSlateBrush Style; // 0x10(0x88)
};
// ScriptStruct Scavenger.S_ProgressBarData
// Size: 0x1c8 (Inherited: 0x00)
struct FS_ProgressBarData {
struct FName Name; // 0x00(0x08)
struct FProgressBarStyle Style; // 0x08(0x1a0)
struct FMargin Padding; // 0x1a8(0x10)
float StartingPercent; // 0x1b8(0x04)
enum class EProgressBarFillType BarFillType; // 0x1bc(0x01)
char pad_1BD[0x3]; // 0x1bd(0x03)
struct US_UMGProgressBar* ProgressBar; // 0x1c0(0x08)
};
// ScriptStruct Scavenger.S_RichTextMetadata
// Size: 0x18 (Inherited: 0x08)
struct FS_RichTextMetadata : FTableRowBase {
struct FString RichTextIdentifier; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_ButtonStateStyle
// Size: 0xc48 (Inherited: 0x00)
struct FS_ButtonStateStyle {
enum class ES_ButtonVisibility Visibility; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct FS_ButtonStyle DefaultButtonStyle; // 0x08(0x200)
struct FS_ButtonStyle HoveredButtonStyle; // 0x208(0x200)
struct FS_ButtonStyle PressedButtonStyle; // 0x408(0x200)
struct FS_ButtonStyle SelectedButtonStyle; // 0x608(0x200)
struct FS_ButtonStyle SelectedHoveredButtonStyle; // 0x808(0x200)
struct FS_ButtonStyle SelectedPressedButtonStyle; // 0xa08(0x200)
struct UAkAudioEvent* HoveredAkEvent; // 0xc08(0x08)
struct UAkAudioEvent* UnhoveredAkEvent; // 0xc10(0x08)
struct UAkAudioEvent* ClickedAkEvent; // 0xc18(0x08)
struct UAkAudioEvent* ReleasedAkEvent; // 0xc20(0x08)
struct FMargin NormalPadding; // 0xc28(0x10)
struct FMargin PressedPadding; // 0xc38(0x10)
};
// ScriptStruct Scavenger.S_ButtonStyle
// Size: 0x200 (Inherited: 0x00)
struct FS_ButtonStyle {
struct FSlateBrush ButtonStyle; // 0x00(0x88)
struct FSlateBrush BorderStyle; // 0x88(0x88)
struct FMargin BorderMargin; // 0x110(0x10)
float RenderOpacity; // 0x120(0x04)
char pad_124[0x4]; // 0x124(0x04)
struct UDataTable* TextStyleSet; // 0x128(0x08)
struct FText richTextLabel; // 0x130(0x18)
bool bOverridePaddingValue; // 0x148(0x01)
char pad_149[0x3]; // 0x149(0x03)
struct FMargin TextPaddingOverride; // 0x14c(0x10)
char pad_15C[0x4]; // 0x15c(0x04)
struct FSlateBrush ButtonImage; // 0x160(0x88)
struct FMargin ButtonImagePadding; // 0x1e8(0x10)
enum class EHorizontalAlignment ButtonImageHorizontalAlignment; // 0x1f8(0x01)
enum class EVerticalAlignment ButtonImageVerticalAlignment; // 0x1f9(0x01)
char pad_1FA[0x6]; // 0x1fa(0x06)
};
// ScriptStruct Scavenger.S_UseItemAction
// Size: 0x30 (Inherited: 0x00)
struct FS_UseItemAction {
struct FS_UseItemActionData m_actionData; // 0x00(0x18)
char pad_18[0x8]; // 0x18(0x08)
struct UAnimMontage* m_useItemMontage; // 0x20(0x08)
struct AS_PlayerCharacter* m_playerCharacter; // 0x28(0x08)
};
// ScriptStruct Scavenger.S_BaseUserSettingConfig
// Size: 0x38 (Inherited: 0x08)
struct FS_BaseUserSettingConfig : FTableRowBase {
struct FText Name; // 0x08(0x18)
struct FText Description; // 0x20(0x18)
};
// ScriptStruct Scavenger.S_SliderSettingConfig
// Size: 0x98 (Inherited: 0x38)
struct FS_SliderSettingConfig : FS_BaseUserSettingConfig {
bool bLockInRange; // 0x38(0x01)
char pad_39[0x3]; // 0x39(0x03)
struct FFloatRange Range; // 0x3c(0x10)
bool bUseDifferentDisplayRange; // 0x4c(0x01)
char pad_4D[0x3]; // 0x4d(0x03)
struct FFloatRange DisplayRange; // 0x50(0x10)
bool bUsesFractionalUnits; // 0x60(0x01)
char pad_61[0x3]; // 0x61(0x03)
struct FInt32Range FractionalUnits; // 0x64(0x10)
bool bHasSuffix; // 0x74(0x01)
char pad_75[0x3]; // 0x75(0x03)
struct FText suffix; // 0x78(0x18)
float StepSize; // 0x90(0x04)
char pad_94[0x4]; // 0x94(0x04)
};
// ScriptStruct Scavenger.S_ToggleSettingConfig
// Size: 0x68 (Inherited: 0x38)
struct FS_ToggleSettingConfig : FS_BaseUserSettingConfig {
struct FText ActiveText; // 0x38(0x18)
struct FText InactiveText; // 0x50(0x18)
};
// ScriptStruct Scavenger.S_MultiOptionSettingConfig
// Size: 0x58 (Inherited: 0x38)
struct FS_MultiOptionSettingConfig : FS_BaseUserSettingConfig {
bool bLockInConfigOptions; // 0x38(0x01)
char pad_39[0x7]; // 0x39(0x07)
struct TArray<struct FText> Options; // 0x40(0x10)
bool bDisplayNavBar; // 0x50(0x01)
char pad_51[0x7]; // 0x51(0x07)
};
// ScriptStruct Scavenger.S_SoftDataTableRowHandle
// Size: 0x38 (Inherited: 0x00)
struct FS_SoftDataTableRowHandle {
struct TSoftObjectPtr<struct UDataTable> SoftDataTable; // 0x00(0x28)
struct FName RowName; // 0x28(0x08)
struct UDataTable* LoadedDataTable; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_RandStateWithHistory
// Size: 0x1a0 (Inherited: 0x18)
struct FS_RandStateWithHistory : FS_RandState {
char pad_18[0x188]; // 0x18(0x188)
};
// ScriptStruct Scavenger.S_IntPair
// Size: 0x08 (Inherited: 0x00)
struct FS_IntPair {
int32_t Key; // 0x00(0x04)
int32_t Value; // 0x04(0x04)
};
// ScriptStruct Scavenger.S_StatefulInterpolationValue
// Size: 0x50 (Inherited: 0x00)
struct FS_StatefulInterpolationValue {
float AlphaConstantUp; // 0x00(0x04)
float AlphaConstantDown; // 0x04(0x04)
float MinValue; // 0x08(0x04)
float MaxValue; // 0x0c(0x04)
float Exponent; // 0x10(0x04)
bool EvaluateDTAutomatically; // 0x14(0x01)
enum class ES_CurveType UpCurve; // 0x15(0x01)
enum class ES_CurveType DownCurve; // 0x16(0x01)
char pad_17[0x1]; // 0x17(0x01)
struct FDebugFloatHistory FloatHistory; // 0x18(0x20)
char pad_38[0x18]; // 0x38(0x18)
};
// ScriptStruct Scavenger.S_VehicleEmitterDef
// Size: 0x28 (Inherited: 0x00)
struct FS_VehicleEmitterDef {
struct FVector EmitterOffset; // 0x00(0x0c)
char pad_C[0x4]; // 0x0c(0x04)
struct UAkAudioEvent* StartAndLoopEvent; // 0x10(0x08)
struct UAkAudioEvent* LoopEvent; // 0x18(0x08)
struct UAkAudioEvent* StopEvent; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_EffectPostProcessClient
// Size: 0x68 (Inherited: 0x00)
struct FS_EffectPostProcessClient {
char pad_0[0x30]; // 0x00(0x30)
struct TArray<struct UCameraComponent*> CameraComponents; // 0x30(0x10)
struct UMaterialInstanceDynamic* MaterialInst; // 0x40(0x08)
struct UStaticMeshComponent* StaticMeshComponent; // 0x48(0x08)
char pad_50[0x18]; // 0x50(0x18)
};
// ScriptStruct Scavenger.S_EffectPostProcess
// Size: 0x68 (Inherited: 0x00)
struct FS_EffectPostProcess {
int32_t EffectId; // 0x00(0x04)
struct TWeakObjectPtr<struct AActor> BaseObject; // 0x04(0x08)
bool IsActive; // 0x0c(0x01)
char pad_D[0x3]; // 0x0d(0x03)
struct TSoftObjectPtr<struct UMaterialInterface> Material; // 0x10(0x28)
struct TSoftObjectPtr<struct UStaticMesh> StaticMesh; // 0x38(0x28)
bool bFadeInOut; // 0x60(0x01)
char pad_61[0x7]; // 0x61(0x07)
};
// ScriptStruct Scavenger.S_EffectShellClient
// Size: 0xe0 (Inherited: 0x00)
struct FS_EffectShellClient {
char pad_0[0x4]; // 0x00(0x04)
struct TWeakObjectPtr<struct AActor> BaseObject; // 0x04(0x08)
char pad_C[0x34]; // 0x0c(0x34)
struct TMap<struct FName, struct TWeakObjectPtr<struct UPrimitiveComponent>> Components; // 0x40(0x50)
struct UMaterialInstanceDynamic* MaterialInst; // 0x90(0x08)
char pad_98[0x48]; // 0x98(0x48)
};
// ScriptStruct Scavenger.S_EffectShell
// Size: 0x68 (Inherited: 0x00)
struct FS_EffectShell {
int32_t ShellId; // 0x00(0x04)
struct TWeakObjectPtr<struct AActor> BaseObject; // 0x04(0x08)
char pad_C[0x4]; // 0x0c(0x04)
struct TSoftObjectPtr<struct UMaterialInterface> Material; // 0x10(0x28)
struct TArray<struct FString> MaterialFilters; // 0x38(0x10)
enum class ES_FilterIfMatch MaterialFiltersType; // 0x48(0x01)
char pad_49[0x7]; // 0x49(0x07)
struct TArray<struct FString> MeshFilters; // 0x50(0x10)
enum class ES_FilterIfMatch MeshFiltersType; // 0x60(0x01)
bool bFadeInOut; // 0x61(0x01)
char pad_62[0x6]; // 0x62(0x06)
};
// ScriptStruct Scavenger.S_EffectMaterialAnimation
// Size: 0x30 (Inherited: 0x00)
struct FS_EffectMaterialAnimation {
int32_t EffectId; // 0x00(0x04)
enum class ES_VisualEffect EffectType; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
struct FName ParameterName; // 0x08(0x08)
struct UCurveFloat* FloatCurve; // 0x10(0x08)
struct UCurveLinearColor* ColorCurve; // 0x18(0x08)
float Duration; // 0x20(0x04)
float CurrTime; // 0x24(0x04)
enum class ES_AnimationDuration AnimDurationType; // 0x28(0x01)
char pad_29[0x7]; // 0x29(0x07)
};
// ScriptStruct Scavenger.S_EffectParameter
// Size: 0x28 (Inherited: 0x00)
struct FS_EffectParameter {
int32_t EffectId; // 0x00(0x04)
enum class ES_VisualEffect EffectType; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
struct FName ParameterName; // 0x08(0x08)
enum class ES_MaterialParameter ParameterType; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
float FValue; // 0x14(0x04)
struct FLinearColor VValue; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_VisibilityWeights
// Size: 0x3c (Inherited: 0x00)
struct FS_VisibilityWeights {
float DawnStartTime; // 0x00(0x04)
float DawnEndTime; // 0x04(0x04)
float DuskStartTime; // 0x08(0x04)
float DuskEndTime; // 0x0c(0x04)
float InTheStormVisibility; // 0x10(0x04)
float InTheDayVisibiliy; // 0x14(0x04)
float InTheDuskDawnVisibilty; // 0x18(0x04)
float InTheNightVisibility; // 0x1c(0x04)
float InTheDarkByLight; // 0x20(0x04)
float CrouchingVisibility; // 0x24(0x04)
float CrouchingWalkingVisibility; // 0x28(0x04)
float SprintingVisibility; // 0x2c(0x04)
float StandingVisibility; // 0x30(0x04)
float WalkingVisibility; // 0x34(0x04)
int32_t PlayerToTimeSliceEachFrame; // 0x38(0x04)
};
// ScriptStruct Scavenger.S_PerModifierSettings
// Size: 0x10 (Inherited: 0x00)
struct FS_PerModifierSettings {
struct TArray<struct FS_ModifierValueSettings> ValueModifiers; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ModifierValueSettings
// Size: 0x14 (Inherited: 0x00)
struct FS_ModifierValueSettings {
char bApplyRegardlessOfCurrentCameraSetting : 1; // 0x00(0x01)
char pad_0_1 : 7; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
uint32_t ActiveCameraSettings; // 0x04(0x04)
char bOverrideValue : 1; // 0x08(0x01)
char pad_8_1 : 7; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
float ValueOverride; // 0x0c(0x04)
float ValueMultiplier; // 0x10(0x04)
};
// ScriptStruct Scavenger.S_WeaponAttachmentArrayContainer
// Size: 0x10 (Inherited: 0x00)
struct FS_WeaponAttachmentArrayContainer {
struct TArray<struct AS_WeaponAttachment*> WeaponAttachments; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_WeaponMoveSpeedMultipliers
// Size: 0x18 (Inherited: 0x00)
struct FS_WeaponMoveSpeedMultipliers {
float ADSWalkSpeedMultiplier; // 0x00(0x04)
float ReloadWalkSpeedMultiplier; // 0x04(0x04)
float ReloadSprintSpeedMultiplier; // 0x08(0x04)
float WalkSpeedMultiplier; // 0x0c(0x04)
float SprintSpeedMultiplier; // 0x10(0x04)
float CrouchSpeedMultiplier; // 0x14(0x04)
};
// ScriptStruct Scavenger.S_WeaponCriticalSettings
// Size: 0x28 (Inherited: 0x00)
struct FS_WeaponCriticalSettings {
bool bCanPerformCritical; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
uint32_t TriggerTypeAllowCritical; // 0x04(0x04)
float BaseChance; // 0x08(0x04)
float HeadshotBonus; // 0x0c(0x04)
float CooldownTime; // 0x10(0x04)
float DamageMultiplier; // 0x14(0x04)
struct TArray<struct FS_DamageConfiguration> BonusDamageConfigurations; // 0x18(0x10)
};
// ScriptStruct Scavenger.S_DamageConfiguration
// Size: 0x18 (Inherited: 0x00)
struct FS_DamageConfiguration {
float DamageAmount; // 0x00(0x04)
float DamageAmountAIMin; // 0x04(0x04)
float DamageAmountAIMax; // 0x08(0x04)
float PoiseDamageAmount; // 0x0c(0x04)
struct US_DamageTypeBase* DamageTypeClass; // 0x10(0x08)
};
// ScriptStruct Scavenger.S_WeaponSpread
// Size: 0x248 (Inherited: 0x00)
struct FS_WeaponSpread {
float MinSpreadAngle; // 0x00(0x04)
float MinSpreadAngleADS; // 0x04(0x04)
float MaxSpreadAngle; // 0x08(0x04)
float MaxSpreadAngleADS; // 0x0c(0x04)
float MaxMovementPenatly; // 0x10(0x04)
float SpreadPerShot; // 0x14(0x04)
struct UCurveFloat* SpreadPerShotCurve; // 0x18(0x08)
float ADSSpreadPerShotScale; // 0x20(0x04)
float CrouchSpreadPerShotScale; // 0x24(0x04)
float SpreadDecreasePerSecond; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct UCurveFloat* SpreadSpeedScaleCurve; // 0x30(0x08)
bool FirstShotOnMinAngle; // 0x38(0x01)
bool FirstShotOnCooldownAfterAttack; // 0x39(0x01)
char pad_3A[0x2]; // 0x3a(0x02)
float FirstShotCooldownDuration; // 0x3c(0x04)
float FirstShotSpreadAngle; // 0x40(0x04)
char pad_44[0x1c]; // 0x44(0x1c)
struct FS_StatefulInterpolationValue Sprint; // 0x60(0x50)
struct FS_StatefulInterpolationValue Walk; // 0xb0(0x50)
struct FS_StatefulInterpolationValue WalkADS; // 0x100(0x50)
struct FS_StatefulInterpolationValue Reload; // 0x150(0x50)
struct FS_StatefulInterpolationValue Jump; // 0x1a0(0x50)
struct FS_StatefulInterpolationValue InterpolationTestView; // 0x1f0(0x50)
char pad_240[0x8]; // 0x240(0x08)
};
// ScriptStruct Scavenger.S_WeaponCommand
// Size: 0x28 (Inherited: 0x10)
struct FS_WeaponCommand : FS_CommandBase {
char pad_10[0x18]; // 0x10(0x18)
};
// ScriptStruct Scavenger.S_WeaponID
// Size: 0x0c (Inherited: 0x00)
struct FS_WeaponID {
char pad_0[0xc]; // 0x00(0x0c)
};
// ScriptStruct Scavenger.S_WeaponSlotData
// Size: 0x10 (Inherited: 0x00)
struct FS_WeaponSlotData {
struct AS_WeaponBase* weapon; // 0x00(0x08)
enum class ES_WeaponSlotState State; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
float AttachmentBlendTimeRemaining; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_WeaponState
// Size: 0x480 (Inherited: 0x00)
struct FS_WeaponState {
struct FS_AttackSlotState attackSlotStates[0x6]; // 0x00(0x480)
};
// ScriptStruct Scavenger.S_AttackEventMontageInfo
// Size: 0x140 (Inherited: 0x00)
struct FS_AttackEventMontageInfo {
char pad_0[0x8]; // 0x00(0x08)
struct UAnimMontage* OwnerMontage; // 0x08(0x08)
struct AS_WeaponBase* weapon; // 0x10(0x08)
char pad_18[0x8]; // 0x18(0x08)
struct UAnimMontage* WeaponMontage; // 0x20(0x08)
char pad_28[0xc8]; // 0x28(0xc8)
struct FS_MeleeAttackState meleeAttackState; // 0xf0(0x50)
};
// ScriptStruct Scavenger.S_DoAttackParams
// Size: 0xac (Inherited: 0x00)
struct FS_DoAttackParams {
char pad_0[0xac]; // 0x00(0xac)
};
// ScriptStruct Scavenger.S_WeaponTuningsTableRow
// Size: 0x60 (Inherited: 0x08)
struct FS_WeaponTuningsTableRow : FTableRowBase {
float ProjectileSpeedScalar; // 0x08(0x04)
float DamageScalar; // 0x0c(0x04)
float WeaponTriggerUpScalar; // 0x10(0x04)
float WeaponTriggerDownScalar; // 0x14(0x04)
float RateOfFireScalar; // 0x18(0x04)
float StartLeadValue; // 0x1c(0x04)
float EndLeadValue; // 0x20(0x04)
float LeadTransitionTime; // 0x24(0x04)
float AlphaConstantUp; // 0x28(0x04)
float AlphaConstantDown; // 0x2c(0x04)
float MinValue; // 0x30(0x04)
float MaxValue; // 0x34(0x04)
float Exponent; // 0x38(0x04)
bool EvaluateDTAutomatically; // 0x3c(0x01)
enum class ES_CurveType UpCurve; // 0x3d(0x01)
enum class ES_CurveType DownCurve; // 0x3e(0x01)
char pad_3F[0x1]; // 0x3f(0x01)
float DistanceSpreadModifierAngle; // 0x40(0x04)
float SpreadModifierMaxDistance; // 0x44(0x04)
float SpreadStormScaleFactor; // 0x48(0x04)
float SpreadAccuracyReducingSmokeScaleFactor; // 0x4c(0x04)
float MinSpreadSingleShotWindup; // 0x50(0x04)
float MaxSpreadSingleShotWindup; // 0x54(0x04)
float CharacterMeleeImpulseScalar; // 0x58(0x04)
char pad_5C[0x4]; // 0x5c(0x04)
};
// ScriptStruct Scavenger.S_WeaponModifiers
// Size: 0x10 (Inherited: 0x00)
struct FS_WeaponModifiers {
struct TArray<enum class ES_WeaponModifier> Modifiers; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_ReactionIntervalRecord
// Size: 0x08 (Inherited: 0x00)
struct FS_ReactionIntervalRecord {
char pad_0[0x8]; // 0x00(0x08)
};
// ScriptStruct Scavenger.S_TrackedAudioComponent
// Size: 0x50 (Inherited: 0x00)
struct FS_TrackedAudioComponent {
char pad_0[0x50]; // 0x00(0x50)
};
// ScriptStruct Scavenger.S_TrackedParticleSystemComponent
// Size: 0x38 (Inherited: 0x00)
struct FS_TrackedParticleSystemComponent {
char pad_0[0x30]; // 0x00(0x30)
struct UParticleSystemComponent* ParticleSystemComponent; // 0x30(0x08)
};
// ScriptStruct Scavenger.S_AttackConfiguration
// Size: 0x90 (Inherited: 0x00)
struct FS_AttackConfiguration {
char bUsesAmmo : 1; // 0x00(0x01)
char bCanBeReloaded : 1; // 0x00(0x01)
char bUseAnimationScaling : 1; // 0x00(0x01)
char bUsesDeferredDoAttack : 1; // 0x00(0x01)
char pad_0_4 : 4; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
enum class ES_AttackBehavior AttackBehavior; // 0x04(0x01)
char pad_5[0x3]; // 0x05(0x03)
float AttackBlockTimeInSeconds; // 0x08(0x04)
int32_t BurstLength; // 0x0c(0x04)
float AttackQueuingAllowedDuringEndOfBlockTime; // 0x10(0x04)
bool UseAllAttachmentsEndOfBlockTimerForAttackQueuingAllowed; // 0x14(0x01)
bool AttackQueuingAllowedDuringReload; // 0x15(0x01)
bool CanHeadshot; // 0x16(0x01)
char pad_17[0x1]; // 0x17(0x01)
float HeadshotMultiplier; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct UCurveFloat* DamageFalloffMultiplier; // 0x20(0x08)
struct TArray<enum class ES_AttackTag> AttackTags; // 0x28(0x10)
struct TArray<struct FS_DamageConfiguration> DamageConfigurations; // 0x38(0x10)
float FireRate; // 0x48(0x04)
float FireRateAIMin; // 0x4c(0x04)
float FireRateAIMax; // 0x50(0x04)
enum class ES_AmmoType AmmoType; // 0x54(0x01)
char pad_55[0x3]; // 0x55(0x03)
int32_t AmmoCountWhenFullyLoaded; // 0x58(0x04)
int32_t AmmoConsumedPerAttack; // 0x5c(0x04)
float NoiseLoudness; // 0x60(0x04)
char pad_64[0x4]; // 0x64(0x04)
struct TArray<struct FS_AttackEventReaction> AttackEventReactions; // 0x68(0x10)
float DamageAmount; // 0x78(0x04)
float DamageAmountAIMin; // 0x7c(0x04)
float DamageAmountAIMax; // 0x80(0x04)
float PoiseDamageAmount; // 0x84(0x04)
struct US_DamageTypeBase* DamageTypeClass; // 0x88(0x08)
};
// ScriptStruct Scavenger.S_AttackEventReaction
// Size: 0xf0 (Inherited: 0x00)
struct FS_AttackEventReaction {
enum class ES_AttackEvent TriggerEvent; // 0x00(0x01)
char pad_1[0x7]; // 0x01(0x07)
struct TArray<enum class ES_AttackEvent> CompletionEvents; // 0x08(0x10)
enum class ES_AttackEvent CompletionEvent; // 0x18(0x01)
char pad_19[0x7]; // 0x19(0x07)
struct UMatineeCameraShake* CameraShakeClass; // 0x20(0x08)
float CameraShakeScale; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
struct FS_AttackEventReactionParticleSystem ParticleSystem; // 0x30(0x50)
struct FS_AttackEventReactionSound Sound; // 0x80(0x50)
uint32_t SpawnInterval; // 0xd0(0x04)
float SpawnIntervalResetTime; // 0xd4(0x04)
float MinDistanceForParticleSpawn; // 0xd8(0x04)
float ParticleForwardOffset; // 0xdc(0x04)
char bSpawnAtBulletExitPoint : 1; // 0xe0(0x01)
char bSetDirectionToBulletDirection : 1; // 0xe0(0x01)
char bScaleParticleLifetimeToEndAtImpactPoint : 1; // 0xe0(0x01)
char pad_E0_3 : 5; // 0xe0(0x01)
char pad_E1[0x3]; // 0xe1(0x03)
float AttachAndDelayVisibilityTimer; // 0xe4(0x04)
struct FName EmitterNameForLifetimeToEndAtImpactPoint; // 0xe8(0x08)
};
// ScriptStruct Scavenger.S_AttackEventReactionSound
// Size: 0x50 (Inherited: 0x00)
struct FS_AttackEventReactionSound {
struct UAkAudioEvent* Event; // 0x00(0x08)
enum class ES_AudioEventEndAction EndAction; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
int32_t FadeOutTimeMs; // 0x0c(0x04)
struct FS_AttackEventReactionLocationData SpawnData; // 0x10(0x40)
};
// ScriptStruct Scavenger.S_AttackEventReactionLocationData
// Size: 0x40 (Inherited: 0x00)
struct FS_AttackEventReactionLocationData {
char bAttached : 1; // 0x00(0x01)
char pad_0_1 : 7; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
struct FName SocketName; // 0x04(0x08)
struct FVector Location; // 0x0c(0x0c)
struct FRotator Rotation; // 0x18(0x0c)
char bCameraRelativeIfFirstPersonADS : 1; // 0x24(0x01)
char pad_24_1 : 7; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
struct FVector CameraRelativeIfFirstPersonADSLocation; // 0x28(0x0c)
struct FRotator CameraRelativeIfFirstPersonADSRotation; // 0x34(0x0c)
};
// ScriptStruct Scavenger.S_AttackEventReactionParticleSystem
// Size: 0x50 (Inherited: 0x00)
struct FS_AttackEventReactionParticleSystem {
struct UParticleSystem* ParticleSystemTemplate; // 0x00(0x08)
char bIsBeam : 1; // 0x08(0x01)
char bNeverFrustumCullCreation : 1; // 0x08(0x01)
char pad_8_2 : 6; // 0x08(0x01)
char pad_9[0x3]; // 0x09(0x03)
struct FS_AttackEventReactionLocationData SpawnData; // 0x0c(0x40)
char pad_4C[0x4]; // 0x4c(0x04)
};
// ScriptStruct Scavenger.S_PlayingStormSound
// Size: 0x20 (Inherited: 0x00)
struct FS_PlayingStormSound {
char pad_0[0x8]; // 0x00(0x08)
struct UAkComponent* Component; // 0x08(0x08)
struct UAkAudioEvent* Event; // 0x10(0x08)
char pad_18[0x8]; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_WeatherState
// Size: 0x10 (Inherited: 0x00)
struct FS_WeatherState {
char bIsSnowing : 1; // 0x00(0x01)
char pad_0_1 : 7; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float DesiredSnowDensity; // 0x04(0x04)
float SnowDensityRateOfChange; // 0x08(0x04)
float CurrentSnowDensity; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_WidgetAnimationData
// Size: 0xc0 (Inherited: 0x00)
struct FS_WidgetAnimationData {
struct UCurveBase* EvaluationCurve; // 0x00(0x08)
float Scalar; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
struct UCurveFloat* InputToTimeCurve; // 0x10(0x08)
bool bUseInputToTimeCurve; // 0x18(0x01)
char pad_19[0x3]; // 0x19(0x03)
struct FName SubWidgetName; // 0x1c(0x08)
char pad_24[0x4]; // 0x24(0x04)
struct TArray<struct FName> FieldName; // 0x28(0x10)
bool bInWidgetCanvasSlot; // 0x38(0x01)
char pad_39[0x3]; // 0x39(0x03)
struct FName MaterialParameterName; // 0x3c(0x08)
char pad_44[0x4]; // 0x44(0x04)
struct UWidget* Widget; // 0x48(0x08)
char pad_50[0x8]; // 0x50(0x08)
struct UVisual* BaseAddress; // 0x58(0x08)
struct UObject* OwnerClass; // 0x60(0x08)
char pad_68[0x8]; // 0x68(0x08)
struct UMaterialInstanceDynamic* MaterialProperty; // 0x70(0x08)
char pad_78[0x4]; // 0x78(0x04)
float StartFloatValue; // 0x7c(0x04)
float EndFloatValue; // 0x80(0x04)
struct FVector StartVectorValue; // 0x84(0x0c)
struct FVector EndVectorValue; // 0x90(0x0c)
struct FLinearColor StartLinearColorValue; // 0x9c(0x10)
struct FLinearColor EndLinearColorValue; // 0xac(0x10)
char pad_BC[0x4]; // 0xbc(0x04)
};
// ScriptStruct Scavenger.S_ArmorThreshold
// Size: 0x20 (Inherited: 0x08)
struct FS_ArmorThreshold : FTableRowBase {
struct FFloatRange ArmorRange; // 0x08(0x10)
struct UTexture2D* ArmorIndicator; // 0x18(0x08)
};
// ScriptStruct Scavenger.S_DefaultClassLoadout
// Size: 0x90 (Inherited: 0x08)
struct FS_DefaultClassLoadout : FTableRowBase {
struct TSoftObjectPtr<struct US_PlayerClassData> PlayerClass; // 0x08(0x28)
struct TArray<struct FS_DefaultClassLoadoutSlot> DefaultLoadoutSlots; // 0x30(0x10)
struct FS_CharacterLoadout DefaultLoadout; // 0x40(0x50)
};
// ScriptStruct Scavenger.S_DefaultClassLoadoutSlot
// Size: 0x18 (Inherited: 0x00)
struct FS_DefaultClassLoadoutSlot {
enum class ES_LoadoutSlotType SlotType; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
int32_t SlotSize; // 0x04(0x04)
struct TArray<struct FDataTableRowHandle> OnlineItemMetadataIds; // 0x08(0x10)
};
// ScriptStruct Scavenger.S_FlipbookBrush
// Size: 0x18 (Inherited: 0x00)
struct FS_FlipbookBrush {
struct UPaperFlipbook* flipbook; // 0x00(0x08)
float PlayRate; // 0x08(0x04)
int32_t StartingKeyFrame; // 0x0c(0x04)
bool Autoplay; // 0x10(0x01)
bool Loop; // 0x11(0x01)
bool RestoreState; // 0x12(0x01)
char pad_13[0x5]; // 0x13(0x05)
};
// ScriptStruct Scavenger.S_InventoryToastItem
// Size: 0x50 (Inherited: 0x00)
struct FS_InventoryToastItem {
struct FS_ItemState ItemState; // 0x00(0x40)
char pad_40[0x10]; // 0x40(0x10)
};
// ScriptStruct Scavenger.S_MapIconFreeSlotsArray
// Size: 0x10 (Inherited: 0x00)
struct FS_MapIconFreeSlotsArray {
struct TArray<int32_t> FreeSlots; // 0x00(0x10)
};
// ScriptStruct Scavenger.S_RewardGrantMetadata
// Size: 0x40 (Inherited: 0x10)
struct FS_RewardGrantMetadata : FS_MetadataTableRowBase {
struct FText Header; // 0x10(0x18)
struct FText Description; // 0x28(0x18)
};
// ScriptStruct Scavenger.S_PlayerStatusState
// Size: 0x60 (Inherited: 0x00)
struct FS_PlayerStatusState {
char pad_0[0x60]; // 0x00(0x60)
};
// ScriptStruct Scavenger.S_PostMatchStatMetadata
// Size: 0x78 (Inherited: 0x58)
struct FS_PostMatchStatMetadata : FS_DisplayableItemMetadata {
struct FText StatFormat; // 0x58(0x18)
enum class ES_PostMatchStatDisplayType StatDisplayType; // 0x70(0x01)
char pad_71[0x7]; // 0x71(0x07)
};
// ScriptStruct Scavenger.S_RadialPanelItemSelectionInfo
// Size: 0x10 (Inherited: 0x00)
struct FS_RadialPanelItemSelectionInfo {
struct UCanvasPanelSlot* ItemSlot; // 0x00(0x08)
int32_t SelectionIdentifier; // 0x08(0x04)
char pad_C[0x4]; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_SocialNotification
// Size: 0x14 (Inherited: 0x00)
struct FS_SocialNotification {
struct FName PlayerName; // 0x00(0x08)
struct FName PlayerId; // 0x08(0x08)
enum class ES_SocialNotificationType NotificationType; // 0x10(0x01)
char pad_11[0x3]; // 0x11(0x03)
};
// ScriptStruct Scavenger.S_TextChatMessage
// Size: 0x28 (Inherited: 0x20)
struct FS_TextChatMessage : FS_HUDMessage {
enum class ES_TextChatMessageTarget roomType; // 0x20(0x01)
char pad_21[0x7]; // 0x21(0x07)
};
// ScriptStruct Scavenger.S_TimedInteractionDisplayData
// Size: 0x30 (Inherited: 0x08)
struct FS_TimedInteractionDisplayData : FTableRowBase {
enum class ES_InteractableActorType ActorType; // 0x08(0x01)
char pad_9[0x7]; // 0x09(0x07)
struct FText DisplayName; // 0x10(0x18)
int32_t NearnessThreshold; // 0x28(0x04)
char pad_2C[0x4]; // 0x2c(0x04)
};
// ScriptStruct Scavenger.S_ActionLockInstruction
// Size: 0x03 (Inherited: 0x00)
struct FS_ActionLockInstruction {
enum class ES_ActionID ActionID; // 0x00(0x01)
bool InterruptExistingActiveActions; // 0x01(0x01)
bool InterruptExistingQueuedActions; // 0x02(0x01)
};
// ScriptStruct Scavenger.PrimitiveState
// Size: 0x50 (Inherited: 0x00)
struct FPrimitiveState {
struct FTransform trans; // 0x00(0x30)
struct FVector linVel; // 0x30(0x0c)
struct FVector angVel; // 0x3c(0x0c)
float Timestamp; // 0x48(0x04)
char pad_4C[0x4]; // 0x4c(0x04)
};
// ScriptStruct Scavenger.S_SecondaryState
// Size: 0x38 (Inherited: 0x00)
struct FS_SecondaryState {
struct TArray<struct FS_SpringInfo> HoverSpringsInfo; // 0x00(0x10)
float LocalSteeringAngle; // 0x10(0x04)
int32_t GroundedSpringCount; // 0x14(0x04)
bool bHasGroundedCollision; // 0x18(0x01)
char pad_19[0x3]; // 0x19(0x03)
int32_t Gear; // 0x1c(0x04)
struct FVector AvgSurfaceNormal; // 0x20(0x0c)
struct FVector SurfaceDownhillNormal; // 0x2c(0x0c)
};
// ScriptStruct Scavenger.S_SpringInfo
// Size: 0x28 (Inherited: 0x00)
struct FS_SpringInfo {
struct FVector From; // 0x00(0x0c)
struct FVector To; // 0x0c(0x0c)
struct FVector HitPos; // 0x18(0x0c)
bool bVerThrusterActive; // 0x24(0x01)
char pad_25[0x3]; // 0x25(0x03)
};
// ScriptStruct Scavenger.S_PrimaryState
// Size: 0x30 (Inherited: 0x00)
struct FS_PrimaryState {
struct FS_SnowRacerInputState InputState; // 0x00(0x1c)
bool ParkingMode; // 0x1c(0x01)
bool UserInputEnabled; // 0x1d(0x01)
char pad_1E[0x2]; // 0x1e(0x02)
struct FS_BoostState BoostState; // 0x20(0x10)
};
// ScriptStruct Scavenger.S_BoostState
// Size: 0x10 (Inherited: 0x00)
struct FS_BoostState {
bool Active; // 0x00(0x01)
char pad_1[0x3]; // 0x01(0x03)
float FuelLeft; // 0x04(0x04)
float ActiveTimer; // 0x08(0x04)
float RecoverCooldownTimer; // 0x0c(0x04)
};
// ScriptStruct Scavenger.S_SnowRacerInputState
// Size: 0x1c (Inherited: 0x00)
struct FS_SnowRacerInputState {
float throttle; // 0x00(0x04)
float desiredHeading; // 0x04(0x04)
float strafe; // 0x08(0x04)
float boost; // 0x0c(0x04)
float Roll; // 0x10(0x04)
float Pitch; // 0x14(0x04)
float verticalThrottle; // 0x18(0x04)
};
// ScriptStruct Scavenger.S_FrictionPoint
// Size: 0x28 (Inherited: 0x00)
struct FS_FrictionPoint {
struct FVector Offset; // 0x00(0x0c)
float MaxSpeedForStaticFriction; // 0x0c(0x04)
float StaticFriction; // 0x10(0x04)
float DynamicFriction; // 0x14(0x04)
struct UCurveFloat* ForwardFriction; // 0x18(0x08)
struct UCurveFloat* ForwardFrictionBreaking; // 0x20(0x08)
};
// ScriptStruct Scavenger.S_HoverSpring
// Size: 0x40 (Inherited: 0x00)
struct FS_HoverSpring {
struct FVector RayOffset; // 0x00(0x0c)
struct FVector ForceOffset; // 0x0c(0x0c)
float SpringLength; // 0x18(0x04)
char pad_1C[0x4]; // 0x1c(0x04)
struct UCurveFloat* HoverSpringStrength; // 0x20(0x08)
struct UCurveFloat* HoverSpringDamp; // 0x28(0x08)
struct UCurveFloat* ExtraGravityMulti; // 0x30(0x08)
struct UCurveFloat* VerticalThrusterCurve; // 0x38(0x08)
};
| [
"68745798+xkp95175333@users.noreply.github.com"
] | 68745798+xkp95175333@users.noreply.github.com |
e5c153ced71500b5a21e398bf524cf4584ae8034 | 24d856d98c85a319d53be2768ccc176a50873fa3 | /linux-lts-quantal-3.5.0/arch/sparc/kernel/prom_64.c | 340c5b976d280ba9948dd5b4774759d4baf401be | [
"GPL-1.0-or-later",
"Linux-syscall-note",
"GPL-2.0-only",
"BSD-2-Clause"
] | permissive | dozenow/shortcut | a4803b59c95e72a01d73bb30acaae45cf76b0367 | b140082a44c58f05af3495259c1beaaa9a63560b | refs/heads/jumpstart-php | 2020-06-29T11:41:05.842760 | 2019-03-28T17:28:56 | 2019-03-28T17:28:56 | 200,405,626 | 2 | 2 | BSD-2-Clause | 2019-08-03T19:45:44 | 2019-08-03T17:57:58 | C | UTF-8 | C | false | false | 13,561 | c | /*
* Procedures for creating, accessing and interpreting the device tree.
*
* Paul Mackerras August 1996.
* Copyright (C) 1996-2005 Paul Mackerras.
*
* Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
* {engebret|bergner}@us.ibm.com
*
* Adapted for sparc64 by David S. Miller davem@davemloft.net
*
* This program 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
* 2 of the License, or (at your option) any later version.
*/
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/memblock.h>
#include <linux/of.h>
#include <asm/prom.h>
#include <asm/oplib.h>
#include <asm/irq.h>
#include <asm/asi.h>
#include <asm/upa.h>
#include <asm/smp.h>
#include "prom.h"
void * __init prom_early_alloc(unsigned long size)
{
unsigned long paddr = memblock_alloc(size, SMP_CACHE_BYTES);
void *ret;
if (!paddr) {
prom_printf("prom_early_alloc(%lu) failed\n");
prom_halt();
}
ret = __va(paddr);
memset(ret, 0, size);
prom_early_allocated += size;
return ret;
}
/* The following routines deal with the black magic of fully naming a
* node.
*
* Certain well known named nodes are just the simple name string.
*
* Actual devices have an address specifier appended to the base name
* string, like this "foo@addr". The "addr" can be in any number of
* formats, and the platform plus the type of the node determine the
* format and how it is constructed.
*
* For children of the ROOT node, the naming convention is fixed and
* determined by whether this is a sun4u or sun4v system.
*
* For children of other nodes, it is bus type specific. So
* we walk up the tree until we discover a "device_type" property
* we recognize and we go from there.
*
* As an example, the boot device on my workstation has a full path:
*
* /pci@1e,600000/ide@d/disk@0,0:c
*/
static void __init sun4v_path_component(struct device_node *dp, char *tmp_buf)
{
struct linux_prom64_registers *regs;
struct property *rprop;
u32 high_bits, low_bits, type;
rprop = of_find_property(dp, "reg", NULL);
if (!rprop)
return;
regs = rprop->value;
if (!of_node_is_root(dp->parent)) {
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
(unsigned int) (regs->phys_addr >> 32UL),
(unsigned int) (regs->phys_addr & 0xffffffffUL));
return;
}
type = regs->phys_addr >> 60UL;
high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL;
low_bits = (regs->phys_addr & 0xffffffffUL);
if (type == 0 || type == 8) {
const char *prefix = (type == 0) ? "m" : "i";
if (low_bits)
sprintf(tmp_buf, "%s@%s%x,%x",
dp->name, prefix,
high_bits, low_bits);
else
sprintf(tmp_buf, "%s@%s%x",
dp->name,
prefix,
high_bits);
} else if (type == 12) {
sprintf(tmp_buf, "%s@%x",
dp->name, high_bits);
}
}
static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf)
{
struct linux_prom64_registers *regs;
struct property *prop;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
if (!of_node_is_root(dp->parent)) {
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
(unsigned int) (regs->phys_addr >> 32UL),
(unsigned int) (regs->phys_addr & 0xffffffffUL));
return;
}
prop = of_find_property(dp, "upa-portid", NULL);
if (!prop)
prop = of_find_property(dp, "portid", NULL);
if (prop) {
unsigned long mask = 0xffffffffUL;
if (tlb_type >= cheetah)
mask = 0x7fffff;
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
*(u32 *)prop->value,
(unsigned int) (regs->phys_addr & mask));
}
}
/* "name@slot,offset" */
static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
{
struct linux_prom_registers *regs;
struct property *prop;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
regs->which_io,
regs->phys_addr);
}
/* "name@devnum[,func]" */
static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
{
struct linux_prom_pci_registers *regs;
struct property *prop;
unsigned int devfn;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
devfn = (regs->phys_hi >> 8) & 0xff;
if (devfn & 0x07) {
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
devfn >> 3,
devfn & 0x07);
} else {
sprintf(tmp_buf, "%s@%x",
dp->name,
devfn >> 3);
}
}
/* "name@UPA_PORTID,offset" */
static void __init upa_path_component(struct device_node *dp, char *tmp_buf)
{
struct linux_prom64_registers *regs;
struct property *prop;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
prop = of_find_property(dp, "upa-portid", NULL);
if (!prop)
return;
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
*(u32 *) prop->value,
(unsigned int) (regs->phys_addr & 0xffffffffUL));
}
/* "name@reg" */
static void __init vdev_path_component(struct device_node *dp, char *tmp_buf)
{
struct property *prop;
u32 *regs;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
sprintf(tmp_buf, "%s@%x", dp->name, *regs);
}
/* "name@addrhi,addrlo" */
static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
{
struct linux_prom64_registers *regs;
struct property *prop;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
sprintf(tmp_buf, "%s@%x,%x",
dp->name,
(unsigned int) (regs->phys_addr >> 32UL),
(unsigned int) (regs->phys_addr & 0xffffffffUL));
}
/* "name@bus,addr" */
static void __init i2c_path_component(struct device_node *dp, char *tmp_buf)
{
struct property *prop;
u32 *regs;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
/* This actually isn't right... should look at the #address-cells
* property of the i2c bus node etc. etc.
*/
sprintf(tmp_buf, "%s@%x,%x",
dp->name, regs[0], regs[1]);
}
/* "name@reg0[,reg1]" */
static void __init usb_path_component(struct device_node *dp, char *tmp_buf)
{
struct property *prop;
u32 *regs;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
if (prop->length == sizeof(u32) || regs[1] == 1) {
sprintf(tmp_buf, "%s@%x",
dp->name, regs[0]);
} else {
sprintf(tmp_buf, "%s@%x,%x",
dp->name, regs[0], regs[1]);
}
}
/* "name@reg0reg1[,reg2reg3]" */
static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf)
{
struct property *prop;
u32 *regs;
prop = of_find_property(dp, "reg", NULL);
if (!prop)
return;
regs = prop->value;
if (regs[2] || regs[3]) {
sprintf(tmp_buf, "%s@%08x%08x,%04x%08x",
dp->name, regs[0], regs[1], regs[2], regs[3]);
} else {
sprintf(tmp_buf, "%s@%08x%08x",
dp->name, regs[0], regs[1]);
}
}
static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
{
struct device_node *parent = dp->parent;
if (parent != NULL) {
if (!strcmp(parent->type, "pci") ||
!strcmp(parent->type, "pciex")) {
pci_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->type, "sbus")) {
sbus_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->type, "upa")) {
upa_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->type, "ebus")) {
ebus_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->name, "usb") ||
!strcmp(parent->name, "hub")) {
usb_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->type, "i2c")) {
i2c_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->type, "firewire")) {
ieee1394_path_component(dp, tmp_buf);
return;
}
if (!strcmp(parent->type, "virtual-devices")) {
vdev_path_component(dp, tmp_buf);
return;
}
/* "isa" is handled with platform naming */
}
/* Use platform naming convention. */
if (tlb_type == hypervisor) {
sun4v_path_component(dp, tmp_buf);
return;
} else {
sun4u_path_component(dp, tmp_buf);
}
}
char * __init build_path_component(struct device_node *dp)
{
char tmp_buf[64], *n;
tmp_buf[0] = '\0';
__build_path_component(dp, tmp_buf);
if (tmp_buf[0] == '\0')
strcpy(tmp_buf, dp->name);
n = prom_early_alloc(strlen(tmp_buf) + 1);
strcpy(n, tmp_buf);
return n;
}
static const char *get_mid_prop(void)
{
return (tlb_type == spitfire ? "upa-portid" : "portid");
}
static void *of_iterate_over_cpus(void *(*func)(struct device_node *, int, int), int arg)
{
struct device_node *dp;
const char *mid_prop;
mid_prop = get_mid_prop();
for_each_node_by_type(dp, "cpu") {
int cpuid = of_getintprop_default(dp, mid_prop, -1);
const char *this_mid_prop = mid_prop;
void *ret;
if (cpuid < 0) {
this_mid_prop = "cpuid";
cpuid = of_getintprop_default(dp, this_mid_prop, -1);
}
if (cpuid < 0) {
prom_printf("OF: Serious problem, cpu lacks "
"%s property", this_mid_prop);
prom_halt();
}
#ifdef CONFIG_SMP
if (cpuid >= NR_CPUS) {
printk(KERN_WARNING "Ignoring CPU %d which is "
">= NR_CPUS (%d)\n",
cpuid, NR_CPUS);
continue;
}
#endif
ret = func(dp, cpuid, arg);
if (ret)
return ret;
}
return NULL;
}
static void *check_cpu_node(struct device_node *dp, int cpuid, int id)
{
if (id == cpuid)
return dp;
return NULL;
}
struct device_node *of_find_node_by_cpuid(int cpuid)
{
return of_iterate_over_cpus(check_cpu_node, cpuid);
}
static void *record_one_cpu(struct device_node *dp, int cpuid, int arg)
{
ncpus_probed++;
#ifdef CONFIG_SMP
set_cpu_present(cpuid, true);
set_cpu_possible(cpuid, true);
#endif
return NULL;
}
void __init of_populate_present_mask(void)
{
if (tlb_type == hypervisor)
return;
ncpus_probed = 0;
of_iterate_over_cpus(record_one_cpu, 0);
}
static void *fill_in_one_cpu(struct device_node *dp, int cpuid, int arg)
{
struct device_node *portid_parent = NULL;
int portid = -1;
if (of_find_property(dp, "cpuid", NULL)) {
int limit = 2;
portid_parent = dp;
while (limit--) {
portid_parent = portid_parent->parent;
if (!portid_parent)
break;
portid = of_getintprop_default(portid_parent,
"portid", -1);
if (portid >= 0)
break;
}
}
#ifndef CONFIG_SMP
/* On uniprocessor we only want the values for the
* real physical cpu the kernel booted onto, however
* cpu_data() only has one entry at index 0.
*/
if (cpuid != real_hard_smp_processor_id())
return NULL;
cpuid = 0;
#endif
cpu_data(cpuid).clock_tick =
of_getintprop_default(dp, "clock-frequency", 0);
if (portid_parent) {
cpu_data(cpuid).dcache_size =
of_getintprop_default(dp, "l1-dcache-size",
16 * 1024);
cpu_data(cpuid).dcache_line_size =
of_getintprop_default(dp, "l1-dcache-line-size",
32);
cpu_data(cpuid).icache_size =
of_getintprop_default(dp, "l1-icache-size",
8 * 1024);
cpu_data(cpuid).icache_line_size =
of_getintprop_default(dp, "l1-icache-line-size",
32);
cpu_data(cpuid).ecache_size =
of_getintprop_default(dp, "l2-cache-size", 0);
cpu_data(cpuid).ecache_line_size =
of_getintprop_default(dp, "l2-cache-line-size", 0);
if (!cpu_data(cpuid).ecache_size ||
!cpu_data(cpuid).ecache_line_size) {
cpu_data(cpuid).ecache_size =
of_getintprop_default(portid_parent,
"l2-cache-size",
(4 * 1024 * 1024));
cpu_data(cpuid).ecache_line_size =
of_getintprop_default(portid_parent,
"l2-cache-line-size", 64);
}
cpu_data(cpuid).core_id = portid + 1;
cpu_data(cpuid).proc_id = portid;
#ifdef CONFIG_SMP
sparc64_multi_core = 1;
#endif
} else {
cpu_data(cpuid).dcache_size =
of_getintprop_default(dp, "dcache-size", 16 * 1024);
cpu_data(cpuid).dcache_line_size =
of_getintprop_default(dp, "dcache-line-size", 32);
cpu_data(cpuid).icache_size =
of_getintprop_default(dp, "icache-size", 16 * 1024);
cpu_data(cpuid).icache_line_size =
of_getintprop_default(dp, "icache-line-size", 32);
cpu_data(cpuid).ecache_size =
of_getintprop_default(dp, "ecache-size",
(4 * 1024 * 1024));
cpu_data(cpuid).ecache_line_size =
of_getintprop_default(dp, "ecache-line-size", 64);
cpu_data(cpuid).core_id = 0;
cpu_data(cpuid).proc_id = -1;
}
return NULL;
}
void __init of_fill_in_cpu_data(void)
{
if (tlb_type == hypervisor)
return;
of_iterate_over_cpus(fill_in_one_cpu, 0);
smp_fill_in_sib_core_maps();
}
void __init of_console_init(void)
{
char *msg = "OF stdout device is: %s\n";
struct device_node *dp;
const char *type;
phandle node;
of_console_path = prom_early_alloc(256);
if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
prom_printf("Cannot obtain path of stdout.\n");
prom_halt();
}
of_console_options = strrchr(of_console_path, ':');
if (of_console_options) {
of_console_options++;
if (*of_console_options == '\0')
of_console_options = NULL;
}
node = prom_inst2pkg(prom_stdout);
if (!node) {
prom_printf("Cannot resolve stdout node from "
"instance %08x.\n", prom_stdout);
prom_halt();
}
dp = of_find_node_by_phandle(node);
type = of_get_property(dp, "device_type", NULL);
if (!type) {
prom_printf("Console stdout lacks device_type property.\n");
prom_halt();
}
if (strcmp(type, "display") && strcmp(type, "serial")) {
prom_printf("Console device_type is neither display "
"nor serial.\n");
prom_halt();
}
of_console_device = dp;
printk(msg, of_console_path);
}
| [
"jflinn"
] | jflinn |
9bf98715cce5b8f09ab74baf66658b74d53d9daf | 09d8ded814a489d3ed62f467beb535cc8d17d3f5 | /Dorks/src/basetypes.h | 5e57ca82c37735b643a213a8780bdb696a8e0654 | [
"MIT"
] | permissive | fengjixuchui/WinDorks | 7f93dc308fa167b0bde8d9c09f1824d1491347a7 | 55d3adadea12bb17516b12f9ec600e3d7c344754 | refs/heads/master | 2020-04-27T01:25:46.154909 | 2017-06-20T17:11:02 | 2017-06-20T17:11:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 8,610 | h | #pragma once
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: basetyps.h
//
//----------------------------------------------------------------------------
#if !defined( _BASETYPS_H_ )
#define _BASETYPS_H_
#if _MSC_VER > 1000
#pragma once
#endif
// Common macros gleamed from COMPOBJ.H
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
#endif
#ifdef _WIN32
// Win32 doesn't support __export
#define STDMETHODCALLTYPE __stdcall
#define STDMETHODVCALLTYPE __cdecl
#define STDAPICALLTYPE __stdcall
#define STDAPIVCALLTYPE __cdecl
#else
#define STDMETHODCALLTYPE __export __stdcall
#define STDMETHODVCALLTYPE __export __cdecl
#define STDAPICALLTYPE __export __stdcall
#define STDAPIVCALLTYPE __export __cdecl
#endif
#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE
#define STDAPI_(type) EXTERN_C type STDAPICALLTYPE
#define STDMETHODIMP HRESULT STDMETHODCALLTYPE
#define STDMETHODIMP_(type) type STDMETHODCALLTYPE
// The 'V' versions allow Variable Argument lists.
#define STDAPIV EXTERN_C HRESULT STDAPIVCALLTYPE
#define STDAPIV_(type) EXTERN_C type STDAPIVCALLTYPE
#define STDMETHODIMPV HRESULT STDMETHODVCALLTYPE
#define STDMETHODIMPV_(type) type STDMETHODVCALLTYPE
/****** Interface Declaration ***********************************************/
/*
* These are macros for declaring interfaces. They exist so that
* a single definition of the interface is simulataneously a proper
* declaration of the interface structures (C++ abstract classes)
* for both C and C++.
*
* DECLARE_INTERFACE(iface) is used to declare an interface that does
* not derive from a base interface.
* DECLARE_INTERFACE_(iface, baseiface) is used to declare an interface
* that does derive from a base interface.
*
* By default if the source file has a .c extension the C version of
* the interface declaratations will be expanded; if it has a .cpp
* extension the C++ version will be expanded. if you want to force
* the C version expansion even though the source file has a .cpp
* extension, then define the macro "CINTERFACE".
* eg. cl -DCINTERFACE file.cpp
*
* Example Interface declaration:
*
* #undef INTERFACE
* #define INTERFACE IClassFactory
*
* DECLARE_INTERFACE_(IClassFactory, IUnknown)
* {
* // *** IUnknown methods ***
* STDMETHOD(QueryInterface) (THIS_
* REFIID riid,
* LPVOID FAR* ppvObj) PURE;
* STDMETHOD_(ULONG,AddRef) (THIS) PURE;
* STDMETHOD_(ULONG,Release) (THIS) PURE;
*
* // *** IClassFactory methods ***
* STDMETHOD(CreateInstance) (THIS_
* LPUNKNOWN pUnkOuter,
* REFIID riid,
* LPVOID FAR* ppvObject) PURE;
* };
*
* Example C++ expansion:
*
* struct FAR IClassFactory : public IUnknown
* {
* virtual HRESULT STDMETHODCALLTYPE QueryInterface(
* IID FAR& riid,
* LPVOID FAR* ppvObj) = 0;
* virtual HRESULT STDMETHODCALLTYPE AddRef(void) = 0;
* virtual HRESULT STDMETHODCALLTYPE Release(void) = 0;
* virtual HRESULT STDMETHODCALLTYPE CreateInstance(
* LPUNKNOWN pUnkOuter,
* IID FAR& riid,
* LPVOID FAR* ppvObject) = 0;
* };
*
* NOTE: Our documentation says '#define interface class' but we use
* 'struct' instead of 'class' to keep a lot of 'public:' lines
* out of the interfaces. The 'FAR' forces the 'this' pointers to
* be far, which is what we need.
*
* Example C expansion:
*
* typedef struct IClassFactory
* {
* const struct IClassFactoryVtbl FAR* lpVtbl;
* } IClassFactory;
*
* typedef struct IClassFactoryVtbl IClassFactoryVtbl;
*
* struct IClassFactoryVtbl
* {
* HRESULT (STDMETHODCALLTYPE * QueryInterface) (
* IClassFactory FAR* This,
* IID FAR* riid,
* LPVOID FAR* ppvObj) ;
* HRESULT (STDMETHODCALLTYPE * AddRef) (IClassFactory FAR* This) ;
* HRESULT (STDMETHODCALLTYPE * Release) (IClassFactory FAR* This) ;
* HRESULT (STDMETHODCALLTYPE * CreateInstance) (
* IClassFactory FAR* This,
* LPUNKNOWN pUnkOuter,
* IID FAR* riid,
* LPVOID FAR* ppvObject);
* HRESULT (STDMETHODCALLTYPE * LockServer) (
* IClassFactory FAR* This,
* BOOL fLock);
* };
*/
#if defined(__cplusplus) && !defined(CINTERFACE)
//#define interface struct FAR
#ifdef COM_STDMETHOD_CAN_THROW
#define COM_DECLSPEC_NOTHROW
#else
#define COM_DECLSPEC_NOTHROW DECLSPEC_NOTHROW
#endif
#define __STRUCT__ struct
#define interface __STRUCT__
#define STDMETHOD(method) virtual COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE method
#define STDMETHOD_(type,method) virtual COM_DECLSPEC_NOTHROW type STDMETHODCALLTYPE method
#define STDMETHODV(method) virtual COM_DECLSPEC_NOTHROW HRESULT STDMETHODVCALLTYPE method
#define STDMETHODV_(type,method) virtual COM_DECLSPEC_NOTHROW type STDMETHODVCALLTYPE method
#define PURE = 0
#define THIS_
#define THIS void
#define DECLARE_INTERFACE(iface) interface DECLSPEC_NOVTABLE iface
#define DECLARE_INTERFACE_(iface, baseiface) interface DECLSPEC_NOVTABLE iface : public baseiface
#define IFACEMETHOD(method) __override STDMETHOD(method)
#define IFACEMETHOD_(type,method) __override STDMETHOD_(type,method)
#define IFACEMETHODV(method) __override STDMETHODV(method)
#define IFACEMETHODV_(type,method) __override STDMETHODV_(type,method)
#else
#define interface struct
#define STDMETHOD(method) HRESULT (STDMETHODCALLTYPE * method)
#define STDMETHOD_(type,method) type (STDMETHODCALLTYPE * method)
#define STDMETHODV(method) HRESULT (STDMETHODVCALLTYPE * method)
#define STDMETHODV_(type,method) type (STDMETHODVCALLTYPE * method)
#define IFACEMETHOD(method) __override STDMETHOD(method)
#define IFACEMETHOD_(type,method) __override STDMETHOD_(type,method)
#define IFACEMETHODV(method) __override STDMETHODV(method)
#define IFACEMETHODV_(type,method) __override STDMETHODV_(type,method)
#define PURE
#define THIS_ INTERFACE FAR* This,
#define THIS INTERFACE FAR* This
#ifdef CONST_VTABLE
#define DECLARE_INTERFACE(iface) typedef interface iface { \
const struct iface##Vtbl FAR* lpVtbl; \
} iface; \
typedef const struct iface##Vtbl iface##Vtbl; \
const struct iface##Vtbl
#else
#define DECLARE_INTERFACE(iface) typedef interface iface { \
struct iface##Vtbl FAR* lpVtbl; \
} iface; \
typedef struct iface##Vtbl iface##Vtbl; \
struct iface##Vtbl
#endif
#define DECLARE_INTERFACE_(iface, baseiface) DECLARE_INTERFACE(iface)
#endif
#include "guiddef.h"
#ifndef _ERROR_STATUS_T_DEFINED
typedef unsigned long error_status_t;
#define _ERROR_STATUS_T_DEFINED
#endif
#ifndef _WCHAR_T_DEFINED
typedef unsigned short wchar_t;
#define _WCHAR_T_DEFINED
#endif
#endif | [
"noreply@github.com"
] | fengjixuchui.noreply@github.com |
4fb8ceb3a5cb68ae6781e4f1378edbb1a25f0447 | d3a910f49e0883f260a509738723cbf9be52eddc | /MITgcm_configurations/global_ocean.90x40x15/build_newPkg/W2_EXCH2_PARAMS.h | 0aa44c13af09b329cdf1b5119b765a38255d003f | [] | no_license | aprilhgshin/JPL_SHIN2020 | 003d432d7e58f80e7a917ea05a455ea6807fc9aa | beb73c2a7d8903ee44cd29c523d534bceff38f86 | refs/heads/master | 2022-07-26T11:19:17.419237 | 2020-09-02T00:00:42 | 2020-09-02T00:00:42 | 271,874,996 | 3 | 1 | null | 2020-08-21T05:56:08 | 2020-06-12T19:27:51 | Fortran | UTF-8 | C | false | false | 52 | h | /home/mitgcm/Work/MITgcm/pkg/exch2/W2_EXCH2_PARAMS.h | [
"aprilhgshin@gmail.com"
] | aprilhgshin@gmail.com |
8aa7d21c9d379997a385c4f1486ac45603fc53ad | ee0bf7d3c95ded2c0bbc1f1aae9fa5f773cd3373 | /11EC10001.c | 2208a217690b4c8443738e395c6895b36cc5fceb | [] | no_license | aashish2894/tic_tac_toe | 86356d50bf9bdf66978e935999555d00c58ae4a3 | ea5cd309ae229c3c2f6a4eff46926fc57e89dcb2 | refs/heads/master | 2021-06-25T20:01:56.577399 | 2017-09-11T00:08:40 | 2017-09-11T00:08:40 | 103,070,672 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 14,905 | c | //Made by
//11EC10001
#include <stdio.h>
#include <stdlib.h>
#define MAXCHILD 9
#define NULL 0
//here MAXLEVEL=100 means that the code will form as many nodes as it can, till the board is full or someone has won
//if you want upto certain level, say level = 4 then set MAXLEVEL=4
#define MAXLEVEL 100
struct nodetype
{
char board[3][3];
struct nodetype *child[MAXCHILD];
};
typedef struct nodetype *NODEPTR;
NODEPTR getnode();
void initialize_board(char board[3][3]);
void printboard(char board[3][3]);
void copyboard(char dest_board[3][3],char source_board[3][3]);
int computer_play(NODEPTR root,char board[3][3],int level,char player);
void create_all_child(NODEPTR root,char symbol);
int evaluate_function(NODEPTR node,char player);
int game_is_not_over(char board[3][3]);
int someone_has_won(char board[3][3]);
int main()
{
int i,j,flag;
char main_board[3][3];
NODEPTR root;
initialize_board(main_board);
printboard(main_board);
do
{
do
{
flag = 0;
printf("User move. Enter the coordinates of your move. The coordinate should be separated by space and then hit enter\n");
scanf("%d",&i);
scanf("%d",&j);
printf("i = %d j = %d\n",i,j);
if (main_board[i][j] == 'e')
{
main_board[i][j] = 'X';
printboard(main_board);
flag = 1;
}
else
{
printf("Error. Target area already occupied. Try again\n");
}
}
while(flag == 0);
if(game_is_not_over(main_board))
{
root = getnode();
copyboard(root->board,main_board);
computer_play(root,main_board,1,'O'); //level = 1,computer move = 'O'
printf("Computer's move\n");
printboard(main_board);
}
}
while(game_is_not_over(main_board));
return 0;
}
NODEPTR getnode()
{
NODEPTR p;
p = (NODEPTR)malloc(sizeof(struct nodetype));
return(p);
}
void initialize_board(char board[3][3])
{
int i,j;
for(i = 0; i<3; i++)
{
for(j = 0; j<3; j++)
{
board[i][j] = 'e'; //'e' represents empty
}
}
}
void printboard(char board[3][3])
{
int i,j;
printf("+------+\n");
for(i = 0; i<3; i++)
{
printf("|");
for(j = 0; j<3; j++)
{
if (board[i][j] == 'e')
{
printf(" |");
}
else
{
printf("%c|",board[i][j]);
}
}
printf("\n");
printf("+------+\n");
}
}
void copyboard(char dest_board[3][3],char source_board[3][3])
{
int i,j;
for(i = 0; i<3; i++)
{
for(j = 0; j<3 ; j++)
{
dest_board[i][j] = source_board[i][j];
}
}
}
int computer_play(NODEPTR root,char main_board[3][3],int level,char player)
{
if(level==(MAXLEVEL+1))
{
return 200;
}
int k = 0;
int worst_case,best_case,val,num;
char sec_player = 'X';
if(player=='X')
{
sec_player = 'O';
}
NODEPTR saved_node;
worst_case = 1000;
best_case = -1000;
if(someone_has_won(root->board)) //no child should be created after this
{
return 200;
}
create_all_child(root,player);//create child with player as the new entry
while(root->child[k]!=NULL)
{
num = computer_play(root->child[k],main_board,level+1,sec_player);
if(num==200 && level%2==1) //if no more child can be created
{
num = evaluate_function(root->child[k],player);//if level is odd then we will do best case
}
if(num==200 && level%2==0) //if no more child can be created
{
num = evaluate_function(root->child[k],sec_player);//if level is even then we will do worst case
}
if (level%2==1) //odd level so best case
{
if(num>best_case)
{
best_case = num;
if(level==1)
{
saved_node = root->child[k]; //save the node to be displayed from the first level
}
}
}
else //even level so worst case
{
if(num<worst_case)
{
worst_case = num;
best_case = num;
}
}
k++;
}
if(level==1)
{
copyboard(main_board,saved_node->board); //copy the computer move to main_board
}
if(k==0)
{
return(200); //this represents that we have reached the leaf, no more child can be created
}
else
{
return(best_case);
}
}
void create_all_child(NODEPTR root,char symbol)
{
int i,j,k;
k = 0;
for(i = 0; i<3; i++)
{
for(j = 0; j<3; j++)
{
if(root->board[i][j] == 'e')
{
root->child[k] = getnode();
copyboard(root->child[k]->board,root->board);
root->child[k]->board[i][j] = symbol;
k = k + 1;
}
}
}
root->child[k] = NULL;
}
int evaluate_function(NODEPTR node,char player)
{
int i,j,sum_player,sum_sec_player;//sum_player stores the number of lines for player and sec_player for second player
int count_player,count_sec_player;
count_player = 0;
count_sec_player = 0;
sum_player = 0;
sum_sec_player = 0;
char second_player = 'O';
if(player == 'O')
{
second_player = 'X';
}
//horizontal and vertical scan
for(i = 0; i<3; i++)
{
for(j = 0; j<3; j++)
{
if(node->board[i][j] == player)
{
if((node->board[i][(j+1)%3]!=second_player) && (node->board[i][(j+2)%3]!=second_player))
{
sum_player = sum_player + 1;
}
if((node->board[(i+1)%3][j]!=second_player) && (node->board[(i+2)%3][j]!=second_player))
{
sum_player = sum_player + 1;
}
}
if(node->board[i][j] == second_player)
{
if((node->board[i][(j+1)%3]!=player) && (node->board[i][(j+2)%3]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
if((node->board[(i+1)%3][j]!=player) && (node->board[(i+2)%3][j]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
}
}
//diagonal scan
if(node->board[0][0] == player)
{
if((node->board[1][1]!=second_player) && (node->board[2][2]!=second_player))
{
sum_player = sum_player + 1;
}
}
else if(node->board[1][1] == player)
{
if((node->board[0][0]!=second_player) && (node->board[2][2]!=second_player))
{
sum_player = sum_player + 1;
}
}
else if(node->board[2][2] == player)
{
if((node->board[0][0]!=second_player) && (node->board[1][1]!=second_player))
{
sum_player = sum_player + 1;
}
}
else if(node->board[0][0] == second_player)
{
if((node->board[1][1]!=player) && (node->board[2][2]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
else if(node->board[1][1] == second_player)
{
if((node->board[0][0]!=player) && (node->board[2][2]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
else if(node->board[2][2] == second_player)
{
if((node->board[0][0]!=player) && (node->board[1][1]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
if(node->board[0][2] == player)
{
if((node->board[1][1]!=second_player) && (node->board[2][0]!=second_player))
{
sum_player = sum_player + 1;
}
}
else if(node->board[1][1] == player)
{
if((node->board[2][0]!=second_player) && (node->board[0][2]!=second_player))
{
sum_player = sum_player + 1;
}
}
else if(node->board[2][0] == player)
{
if((node->board[1][1]!=second_player) && (node->board[0][2]!=second_player))
{
sum_player = sum_player + 1;
}
}
else if(node->board[0][2] == second_player)
{
if((node->board[1][1]!=player) && (node->board[2][0]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
else if(node->board[1][1] == second_player)
{
if((node->board[0][2]!=player) && (node->board[2][0]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
else if(node->board[2][0] == second_player)
{
if((node->board[0][2]!=player) && (node->board[1][1]!=player))
{
sum_sec_player = sum_sec_player + 1;
}
}
//remove extra occurences during horizontal and vertical scan
for(i = 0; i<3; i++)
{
count_player = 0;
count_sec_player = 0;
for(j = 0; j<3; j++)
{
if(node->board[i][j]==player)
{
count_player = count_player + 1;
}
if(node->board[i][j]==second_player)
{
count_sec_player = count_sec_player + 1;
}
}
if(count_sec_player==0 && count_player==3)
{
sum_player = sum_player - 2;
}
if(count_sec_player==0 && count_player==2)
{
sum_player = sum_player - 1;
}
if(count_player==0 && count_sec_player==3)
{
sum_sec_player = sum_sec_player - 2;
}
if(count_player==0 && count_sec_player==2)
{
sum_sec_player = sum_sec_player - 1;
}
}
for(j = 0; j<3; j++)
{
count_player = 0;
count_sec_player = 0;
for(i = 0; i<3; i++)
{
if(node->board[i][j]==player)
{
count_player = count_player + 1;
}
if(node->board[i][j]==second_player)
{
count_sec_player = count_sec_player + 1;
}
}
if(count_sec_player==0 && count_player==3)
{
sum_player = sum_player - 2;
}
if(count_sec_player==0 && count_player==2)
{
sum_player = sum_player - 1;
}
if(count_player==0 && count_sec_player==3)
{
sum_sec_player = sum_sec_player - 2;
}
if(count_player==0 && count_sec_player==2)
{
sum_sec_player = sum_sec_player - 1;
}
}
//if the game is over then assign most positive or most negative
for(i = 0; i<3; i++)
{
if((node->board[i][0]==node->board[i][1]) && (node->board[i][0] == node->board[i][2]) && (node->board[i][0]==player))
{
return 10;
}
if((node->board[i][0]==node->board[i][1]) && (node->board[i][0] == node->board[i][2]) && (node->board[i][0]==second_player))
{
return -10;
}
}
for(j = 0; j<3; j++)
{
if((node->board[0][j]==node->board[1][j]) && (node->board[0][j]==node->board[2][j]) && (node->board[0][j]==player))
{
return 10;
}
if((node->board[0][j]==node->board[1][j]) && (node->board[0][j]==node->board[2][j]) && (node->board[0][j]==second_player))
{
return -10;
}
}
if((node->board[0][0]==node->board[1][1]) && (node->board[0][0]==node->board[2][2]) && (node->board[0][0]==player))
{
return 10;
}
if((node->board[0][0]==node->board[1][1]) && (node->board[0][0]==node->board[2][2]) && (node->board[0][0]==second_player))
{
return -10;
}
if((node->board[0][2]==node->board[1][1]) && (node->board[0][2]==node->board[2][0]) && (node->board[0][2]==player))
{
return 10;
}
if((node->board[0][2]==node->board[1][1]) && (node->board[0][2]==node->board[2][0]) && (node->board[0][2]==second_player))
{
return -10;
}
return(sum_player-sum_sec_player);
}
int game_is_not_over(char board[3][3])
{
int i,j;
//horizontal check
for(i = 0; i<3; i++)
{
if((board[i][0]==board[i][1]) && (board[i][0] == board[i][2]) && (board[i][0]=='X'))
{
printf("Player wins\n\n");
return 0;
}
if((board[i][0]==board[i][1]) && (board[i][0] == board[i][2]) && (board[i][0]=='O'))
{
printf("Computer wins\n\n");
return 0;
}
}
//vertical check
for(j = 0; j<3; j++)
{
if((board[0][j]==board[1][j]) && (board[0][j]==board[2][j]) && (board[0][j]=='X'))
{
printf("Player wins\n\n");
return 0;
}
if((board[0][j]==board[1][j]) && (board[0][j]==board[2][j]) && (board[0][j]=='O'))
{
printf("Computer wins\n\n");
return 0;
}
}
//diagonal check
if((board[0][0]==board[1][1]) && (board[0][0]==board[2][2]) && (board[0][0]=='X'))
{
printf("Player wins\n\n");
return 0;
}
if((board[0][0]==board[1][1]) && (board[0][0]==board[2][2]) && (board[0][0]=='O'))
{
printf("Computer wins\n\n");
return 0;
}
if((board[0][2]==board[1][1]) && (board[0][2]==board[2][0]) && (board[0][2]=='X'))
{
printf("Player wins\n\n");
return 0;
}
if((board[0][2]==board[1][1]) && (board[0][2]==board[2][0]) && (board[0][2]=='O'))
{
printf("Computer wins\n\n");
return 0;
}
//check if the game can still continue
for(i = 0; i<3; i++)
{
for(j = 0; j<3; j++)
{
if(board[i][j]=='e') //'e' represent empty
{
return 1;
}
}
}
printf("Game Draw\n\n");
return 0;
}
int someone_has_won(char board[3][3])
{
int i,j;
//horizontal check
for(i = 0; i<3; i++)
{
if((board[i][0]==board[i][1]) && (board[i][0] == board[i][2]) && (board[i][0]!='e'))
{
return 1;
}
}
//vertical check
for(j = 0; j<3; j++)
{
if((board[0][j]==board[1][j]) && (board[0][j]==board[2][j]) && (board[0][j]!='e'))
{
return 1;
}
}
//diagonal check
if((board[0][0]==board[1][1]) && (board[0][0]==board[2][2]) && (board[0][0]!='e'))
{
return 1;
}
if((board[0][2]==board[1][1]) && (board[0][2]==board[2][0]) && (board[0][2]!='e'))
{
return 1;
}
return 0;
}
| [
"anshu.2894@gmail.com"
] | anshu.2894@gmail.com |
168023a39a19083ffbf87635afd4ddcec691c1b6 | 259c101b7bbeef9efcc25134e7e21f037a7a4092 | /DTSEmbed_LSC_solve_path/testcase/gcc/gcc.dg/asm-4.c | 0e58c851f44791449c0eb0ac31df307449037bd9 | [] | no_license | 13001090108/dts-solve-path | a95c71c31d38afb2c55d85884b931f2938c1f75d | 649b92eddcc76705bbb4926b33da00009303c04a | refs/heads/master | 2020-04-16T23:17:21.340218 | 2019-01-24T09:34:50 | 2019-01-24T09:37:09 | 166,005,614 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 607 | c | /* { dg-do compile } */
/* { dg-options "" } */
int main()
{
int x, y, z;
asm volatile ("test0 X%0Y%[arg]Z" : [arg] "=g" (x));
asm volatile ("test1 X%[out]Y%[in]Z" : [out] "=g" (y) : [in] "0"(y));
asm volatile ("test2 X%a0Y%a[arg]Z" : : [arg] "p" (&z));
asm volatile ("test3 %[in]" : [inout] "=g"(x) : "[inout]" (x), [in] "g" (y));
}
/* ??? Someone explain why the back reference dosn't work. */
/* { dontdg-final { scan-assembler "test0 X(.*)Y\1Z" } } */
/* { dontdg-final { scan-assembler "test1 X(.*)Y\1Z" } } */
/* { dontdg-final { scan-assembler "test2 X(.*)Y\1Z" } } */
| [
"lishaochun@bupt.edu.cn"
] | lishaochun@bupt.edu.cn |
b8de5534e71cf46ff6f2ac017666f85d18dbeee6 | 640cc3c15ab2fc667875e6453e955c5750ec7bee | /gnl/libft/ft_strtrim.c | 3ab06ceda296d66e6a676fa2c65590a724bb6a42 | [] | no_license | Zabilya/school_projects | d99b723547ebb58e43e0d0ea652f8a242024470c | bb12b3c963817770b06ee9ec62ecd3e108eb705e | refs/heads/master | 2020-04-16T04:25:14.448941 | 2019-03-07T14:47:32 | 2019-03-07T14:47:32 | 165,266,343 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,739 | c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtrim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cschuste <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/26 12:23:59 by cschuste #+# #+# */
/* Updated: 2018/11/26 12:24:00 by cschuste ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
#include <stdlib.h>
static int check_start(char const *s, int *start, int *end, int *j)
{
int i;
i = 0;
*j = 0;
*start = 0;
*end = 0;
while (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')
i++;
return (i);
}
static int check_end(char const *s, int end)
{
while (s[end])
++end;
--end;
while (s[end] == ' ' || s[end] == '\n' || s[end] == '\t')
end--;
end++;
return (end);
}
char *ft_strtrim(char const *s)
{
int start;
int end;
char *str;
int i;
if (!s)
return (NULL);
start = check_start(s, &start, &end, &i);
if (start == (int)ft_strlen(s))
{
str = (char *)malloc(1);
*str = '\0';
return (str);
}
end = check_end(s, end);
if (!(str = (char *)(malloc(sizeof(char) * (end - start + 1)))))
return (NULL);
while ((end - start))
str[i++] = s[start++];
str[i] = '\0';
return (str);
}
| [
"cschuste@e4r4p5.21-school.ru"
] | cschuste@e4r4p5.21-school.ru |
e1b8e618a6ad27a60021ad10513122f28ea92f59 | 8345c273f7e47bd70fa9f2b67a6adfe5964ba4a9 | /LuaNode_Esp8266/components/apps/wifilister/user_main.c | 66894964ae79388f17bb2adbc47637954c2e7131 | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | guneemwelloeux/LuaNode | 1164c7d9e81da470a5cedf1eec46c58ecf8b7d38 | 1b39c18e286301c89bb5bc6334ee3d089f9f7474 | refs/heads/master | 2020-09-30T15:02:05.506205 | 2019-12-11T19:53:26 | 2019-12-11T20:18:23 | 227,311,681 | 0 | 0 | NOASSERTION | 2019-12-11T08:16:28 | 2019-12-11T08:16:27 | null | UTF-8 | C | false | false | 12,838 | c | /*
The MIT License (MIT)
Copyright (c) 2015 Jason Pruitt
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include "esp8266.h"
#include "stdout.h"
#include "scanning.h"
#include "FreeRTOS.h"
#include "task.h"
//#define AP_CHANNELS_ONLY
#define HIDDEN "Hidden"
#define MAX_APS 64
#define MAX_CLIENTS 32
#define EXPIRES 3
#define SNIFF_TIME 3000 // per channel
#define CHANNEL_COUNT 15 // plus 1
static ETSTimer prScanTimer;
static int sniff_channel = 0;
static bool channels_used[CHANNEL_COUNT] = { false };
struct scan_config sconfig = {NULL, NULL, 0, 1};
struct orphan {
u8 mac[6];
u8 bssid[6];
s8 rssi;
s8 expires;
};
struct orphan orphans_list[MAX_CLIENTS];
struct client {
u8 mac[6];
s8 rssi;
s8 expires;
};
struct ap {
u8 bssid[6];
char ssid[32];
u8 channel;
s8 rssi;
u8 authmode;
s8 expires;
struct client clients[MAX_CLIENTS];
};
struct ap ap_list[MAX_APS];
struct RxControl {
signed rssi:8;
unsigned rate:4;
unsigned is_group:1;
unsigned:1;
unsigned sig_mode:2;
unsigned legacy_length:12;
unsigned damatch0:1;
unsigned damatch1:1;
unsigned bssidmatch0:1;
unsigned bssidmatch1:1;
unsigned MCS:7;
unsigned CWB:1;
unsigned HT_length:16;
unsigned Smoothing:1;
unsigned Not_Sounding:1;
unsigned:1;
unsigned Aggregation:1;
unsigned STBC:2;
unsigned FEC_CODING:1;
unsigned SGI:1;
unsigned rxend_state:8;
unsigned ampdu_cnt:8;
unsigned channel:4;
unsigned:12;
};
struct Ampdu_Info
{
uint16 length;
uint16 seq;
uint8 address3[6];
};
struct sniffer_buf {
struct RxControl rx_ctrl;
uint8_t buf[36];
uint16_t cnt;
struct Ampdu_Info ampdu_info[1];
};
struct sniffer_buf2{
struct RxControl rx_ctrl;
u8 buf[112];
u16 cnt;
u16 len;
};
struct framectrl_80211
{
u8 Protocol:2;
u8 Type:2;
u8 Subtype:4;
u8 ToDS:1;
u8 FromDS:1;
u8 MoreFlag:1;
u8 Retry:1;
u8 PwrMgmt:1;
u8 MoreData:1;
u8 Protectedframe:1;
u8 Order:1;
};
struct probe_request_80211
{
struct framectrl_80211 framectrl;
uint16 duration;
uint8 rdaddr[6];
uint8 tsaddr[6];
uint8 bssid[6];
uint16 sequencectrl;
uint8 addr4[6];
uint16 qos;
uint32 htctrl;
};
static bool ICACHE_FLASH_ATTR
add_ap(struct bss_info *bss_link)
{
int next_ap = -1;
char *ssid;
u8 bssid[6];
memcpy(bssid, bss_link->bssid, 6);
int i;
for ( i = 0; i < MAX_APS; i++ ) {
if ( memcmp(ap_list[i].bssid, bssid, 6) == 0 ) {
ap_list[i].rssi = bss_link->rssi;
ap_list[i].channel = bss_link->channel;
ap_list[i].expires = EXPIRES;
channels_used[ap_list[i].channel] = true;
return true;
}
if ( ap_list[i].ssid[0] == 0 && next_ap == -1 )
next_ap = i;
}
if ( bss_link->is_hidden ) {
ssid = HIDDEN;
} else {
ssid = (char *)bss_link->ssid;
}
if ( next_ap >= MAX_APS || next_ap < 0 )
return false;
memcpy(ap_list[next_ap].bssid, bss_link->bssid, 6);
strcpy(ap_list[next_ap].ssid, ssid);
ap_list[next_ap].channel = bss_link->channel;
channels_used[ap_list[next_ap].channel] = true;
ap_list[next_ap].authmode = bss_link->authmode;
ap_list[next_ap].rssi = bss_link->rssi;
ap_list[next_ap].expires = EXPIRES;
ets_bzero(ap_list[next_ap].clients, sizeof(ap_list[next_ap].clients));
return true;
}
static bool ICACHE_FLASH_ATTR
add_client(int ap_idx, uint8 *mac, s8 rssi)
{
int next_client = -1;
int i;
for ( i = 0; i < MAX_CLIENTS; i++ ) {
if ( memcmp(ap_list[ap_idx].clients[i].mac, mac, 6) == 0 ) {
//ets_printf("Updated Client:"MACSTR"\n", MAC2STR(mac));
ap_list[ap_idx].clients[i].rssi = rssi;
ap_list[ap_idx].clients[i].expires = EXPIRES;
return true;
}
if ( ap_list[ap_idx].clients[i].expires == 0 && next_client == -1 )
next_client = i;
}
if ( next_client >= MAX_CLIENTS || next_client < 0 )
return false;
//ets_printf("Added Client:"MACSTR"\n", MAC2STR(mac));
memcpy(ap_list[ap_idx].clients[next_client].mac, mac, 6);
ap_list[ap_idx].clients[next_client].expires = EXPIRES;
ap_list[ap_idx].clients[next_client].rssi = rssi;
return true;
}
static bool ICACHE_FLASH_ATTR
add_orphan(uint8 *mac, uint8 *bssid, s8 rssi)
{
int next_orphan = -1;
int i;
for ( i = 0; i < MAX_CLIENTS; i++ ) {
if ( memcmp(orphans_list[i].mac, mac, 6) == 0 ) {
//ets_printf("Updated Orphan:"MACSTR"\n", MAC2STR(mac));
orphans_list[i].rssi = rssi;
orphans_list[i].expires = EXPIRES;
return true;
}
if ( orphans_list[i].expires == 0 && next_orphan == -1 )
next_orphan = i;
}
if ( next_orphan >= MAX_CLIENTS || next_orphan < 0 )
return false;
//ets_printf("Added Orphan:"MACSTR"\n", MAC2STR(mac));
memcpy(orphans_list[next_orphan].mac, mac, 6);
memcpy(orphans_list[next_orphan].bssid, bssid, 6);
orphans_list[next_orphan].rssi = rssi;
orphans_list[next_orphan].expires = EXPIRES;
return true;
}
static void ICACHE_FLASH_ATTR
wifidata_cleaner(void)
{
int ap_idx;
struct ap ap_holder;
const u8 blank[6] = { 0 };
int i;
for ( i = 0; i < MAX_APS; i++ ) {
if ( ap_list[i].ssid[0] == 0 )
continue;
ap_list[i].expires -= 1;
if ( ap_list[i].expires < 0 ){
//ets_printf("Deleted: %s\n", ap_list[i].ssid);
ap_list[i].ssid[0] = 0;
ap_list[i].rssi = 0;
}
int c;
for ( c = 0; c < MAX_CLIENTS; c++ ) {
if ( memcmp(ap_list[i].clients[c].mac, blank, 6) == 0 )
continue;
ap_list[i].clients[c].expires -= 1;
if ( ap_list[i].clients[c].expires <= 0 ) {
//ets_printf("Deleted Client:"MACSTR"\n", MAC2STR(ap_list[i].clients[c].mac));
ets_bzero(&ap_list[i].clients[c], sizeof(struct client));
}
}
}
int o;
for ( o = 0; o < MAX_CLIENTS; o++ ) {
if ( memcmp(orphans_list[o].mac, blank, 6) == 0 )
continue;
orphans_list[o].expires -= 1;
if ( orphans_list[o].expires <= 0 ) {
//ets_printf("Deleted Orphan:"MACSTR"\n", MAC2STR(orphans_list[o].mac));
ets_bzero(&orphans_list[o], sizeof(struct orphan));
}
}
// Sort APs by rssi
for (i = 1 ; i < MAX_APS; i++) {
ap_idx = i;
while ( ap_idx > 0 && ap_list[ap_idx].rssi > ap_list[ap_idx-1].rssi) {
ap_holder = ap_list[ap_idx];
ap_list[ap_idx] = ap_list[ap_idx-1];
ap_list[ap_idx-1] = ap_holder;
ap_idx--;
}
}
}
static void ICACHE_FLASH_ATTR
wifidata_printer(void)
{
char *authmode;
uint8 counter = 0;
//ets_printf("\033[2J"); // Clear terminal screen before print.
ets_printf("\n");
ets_printf("##########################################\n");
int i;
for ( i = 0; i < MAX_APS; i++ ) {
if ( ap_list[i].ssid[0] == 0 )
continue;
//ets_printf(" Expires: %d \t", ap_list[i].expires);
ets_printf("%-32s", ap_list[i].ssid);
ets_printf("\tBSSID: "MACSTR, MAC2STR(ap_list[i].bssid));
ets_printf("\tChannel: %d", ap_list[i].channel);
ets_printf("\tRSSI: %ddbm", ap_list[i].rssi);
switch ( ap_list[i].authmode ) {
case 0:
authmode = "OPEN";
break;
case 1:
authmode = "WEP";
break;
case 2:
authmode = "WPA_PAK";
break;
case 3:
authmode = "WPA2_PAK";
break;
case 4:
authmode = "WPA_WPA2_PSK";
break;
default:
authmode = "Unknown";
break;
}
ets_printf("\tAuthMode: %s\n", authmode);
int c;
for ( c = 0; c < MAX_CLIENTS; c++ ) {
if ( ap_list[i].clients[c].expires == 0 )
continue;
//ets_printf(" Expires: %d \t", ap_list[i].clients[c].expires);
ets_printf("\tClient MAC: " MACSTR, MAC2STR(ap_list[i].clients[c].mac));
ets_printf("\tRSSI: %ddbm", ap_list[i].clients[c].rssi);
int z;
for ( z = 0; z < MAX_APS; z++ ) {
if ( ap_list[i].expires == 0 )
continue;
if ( memcmp(ap_list[i].clients[c].mac, ap_list[z].bssid, 6) == 0 )
ets_printf("\tSSID: %s ", ap_list[z].ssid);
}
ets_printf("\n");
}
counter++;
}
ets_printf("\nTotal APs: %d\n", counter);
ets_printf("---------------------------\n");
ets_printf("Orphan Clients\n");
int o;
for ( o = 0; o < MAX_CLIENTS; o++ ) {
if ( orphans_list[o].expires == 0 )
continue;
//ets_printf(" Expires: %d \t", orphans_list[o].expires);
ets_printf("\tClient MAC: "MACSTR" BSSID: "MACSTR" RSSI: %ddbm\n",
MAC2STR(orphans_list[o].mac),
MAC2STR(orphans_list[o].bssid),
orphans_list[o].rssi);
}
ets_printf("##########################################\n");
}
static void ICACHE_FLASH_ATTR
apscan_done(void *arg, STATUS status)
{
//ets_printf("STATUS: %d\n", status);
if ( status == OK ) {
struct bss_info *bss_link = (struct bss_info *)arg;
bss_link = bss_link->next.stqe_next;
while((bss_link = bss_link->next.stqe_next) != NULL)
add_ap(bss_link);
wifidata_cleaner();
sniffing_start();
}
}
static void ICACHE_FLASH_ATTR
apscan_start(void)
{
os_timer_disarm(&prScanTimer);
wifi_station_scan(&sconfig, apscan_done);
}
static int ICACHE_FLASH_ATTR
get_next_channel(void)
{
#ifdef AP_CHANNELS_ONLY
int i;
for ( i = sniff_channel+1; i < CHANNEL_COUNT; i++ ) {
if ( channels_used[i] ) {
//ets_printf("Channel: %d\n", i);
sniff_channel = i;
return sniff_channel;
}
}
sniff_channel = 0;
#else
sniff_channel++;
if ( sniff_channel >= CHANNEL_COUNT )
sniff_channel = 0;
//ets_printf("Channel: %d\n", sniff_channel);
#endif
return sniff_channel;
}
static void ICACHE_FLASH_ATTR
packet_processor(uint8 *buf, uint16 len)
{
struct sniffer_buf *sbuf;
int ap_idx;
uint8 server[6];
uint8 client[6];
uint8 full[6];
full[0] = 0xFF;
full[1] = 0xFF;
full[2] = 0xFF;
full[3] = 0xFF;
full[4] = 0xFF;
full[5] = 0xFF;
if ( len == 60 ) {
sbuf = (struct sniffer_buf *)buf;
struct probe_request_80211 *probe_request = (struct probe_request_80211*) sbuf->buf;
if ( probe_request->framectrl.ToDS == probe_request->framectrl.FromDS )
return;
if ( (probe_request->framectrl.ToDS == 1 && probe_request->framectrl.FromDS == 0) ) {
memcpy(server, probe_request->rdaddr, 6);
memcpy(client, probe_request->tsaddr, 6);
} else {
memcpy(server, probe_request->tsaddr, 6);
memcpy(client, probe_request->rdaddr, 6);
}
if ( memcmp(client, full, 6) == 0 )
return;
if ( client[0] == 0x33 && client[1] == 0x33 )
return;
if ( client[0] == 0x01 && client[1] == 0x00 && client[2] == 0x5e )
return;
/*
ets_printf("ToDS: %d FromDS:%d ", probe_request->framectrl.ToDS, probe_request->framectrl.FromDS);
ets_printf("client: "MACSTR" server: "MACSTR" BSSID: "MACSTR"\n",
MAC2STR(client),
MAC2STR(server),
MAC2STR(probe_request->bssid));
*/
ap_idx = 0;
while ( ap_idx < MAX_APS ) {
if ( memcmp(server, ap_list[ap_idx].bssid, 6) == 0 )
break;
ap_idx++;
}
if ( ap_idx >= MAX_APS ) {
add_orphan(client, server, sbuf->rx_ctrl.rssi);
} else {
add_client(ap_idx, client, sbuf->rx_ctrl.rssi);
}
}
}
static void ICACHE_FLASH_ATTR
sniffing_start(void)
{
wifi_station_disconnect();
wifi_set_channel(sniff_channel);
wifi_promiscuous_enable(1);
os_timer_disarm(&prScanTimer);
os_timer_setfn(&prScanTimer, sniffing_stop, NULL);
os_timer_arm(&prScanTimer, SNIFF_TIME, 1);
wifi_set_promiscuous_rx_cb((wifi_promiscuous_cb_t)packet_processor);
}
static void ICACHE_FLASH_ATTR
sniffing_stop(void *arg)
{
wifi_promiscuous_enable(0);
if ( get_next_channel() != 0 ) {
sniffing_start();
} else {
int i;
for ( i = 0; i <= CHANNEL_COUNT; i++ )
channels_used[i] = false;
wifidata_printer();
apscan_start();
}
}
static void ICACHE_FLASH_ATTR
apscan_init(void)
{
ets_bzero(ap_list, sizeof(ap_list));
//ets_printf("Heap: %ld\n", (unsigned long)system_get_free_heap_size());
apscan_start();
}
void
my_task(void *pvParameters) {
printf("task init\n");
//vTaskDelay(1000);
apscan_init();
vTaskDelete(NULL);
}
void user_init(void)
{
system_update_cpu_freq(SYS_CPU_160MHZ);
//system_set_os_print(0);
wifi_set_opmode(STATION_MODE);
stdoutInit();
ets_printf("\nReady\n");
//system_init_done_cb(apscan_init);
xTaskCreate(my_task, "my_task", 128, NULL, 4, NULL);
}
/*
void user_rf_pre_init(void)
{
}
*/
| [
"tulip-wangwei@163.com"
] | tulip-wangwei@163.com |
27dc3c42edbdba70974a57014a5bed94c7f30cbb | 54b08b28b8c1724499975f12acb690f0df19854e | /exercise/silsup_04/ssu_stat_1.c | 2f987671fbbe0c543631319ffb60f1e795dbadbd | [] | no_license | ynifamily3/lsp_2019 | 6105a8b294bf8f6cb7f2e20e1ca309078e6615ff | 0092b8ff852fd224601d6a555b3b9f2d9f49adc3 | refs/heads/master | 2021-06-11T22:48:52.648320 | 2021-04-11T12:31:27 | 2021-04-11T12:31:27 | 176,196,391 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 577 | c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include "ssu_runtime.h"
int main(int argc, char *argv[]) {
struct timeval begin_t, end_t;
struct stat statbuf;
gettimeofday(&begin_t, NULL);
if (argc != 2) {
fprintf(stderr, "usage: %s <file>\n", argv[0]);
exit(1);
}
if ((stat(argv[1], &statbuf)) < 0 ) {
fprintf(stderr, "stat error\n");
exit(1);
}
printf("%s is %ld bytes\n", argv[1], statbuf.st_size);
gettimeofday(&end_t, NULL);
ssu_runtime(&begin_t, &end_t);
exit(0);
}
| [
"ynifamily3@gmail.com"
] | ynifamily3@gmail.com |
424fde5367ac30dce0733820ae17141f93ddc15d | e4ed69431c8c6adc8fd195372d084b3b3c3d6315 | /common/esp8266.c | ffe4c34c7ad0dfe866e6e7789492944b82c3b6ec | [] | no_license | kehribar/ESP8266-AT-examples | cc142e88607de563c40fd13d46c98caaf41e1b2a | f41be76fcc99307df0a8fc047b9e561f6192b873 | refs/heads/master | 2020-05-18T13:44:53.365430 | 2015-06-26T21:29:08 | 2015-06-26T21:29:08 | 37,946,281 | 6 | 1 | null | null | null | null | UTF-8 | C | false | false | 11,981 | c | /*-----------------------------------------------------------------------------
/
/
/----------------------------------------------------------------------------*/
#include "esp8266.h"
/*---------------------------------------------------------------------------*/
static uint32_t m_timeoutCounter;
/*---------------------------------------------------------------------------*/
static void esp8266_flushBuffer();
static uint8_t esp8266_getMessageID();
static uint16_t StrTo16Uint(char* str);
static uint16_t esp8266_getMessageLength();
static int8_t esp8266_waitForChar(uint32_t timeoutLimit);
static int8_t esp8266_checkOkError(uint32_t timeoutLimit);
static int8_t esp8266_waitForMessage(const char* checkmsg, uint32_t timeoutLimit);
/*---------------------------------------------------------------------------*/
int8_t esp8266_init()
{
esp8266_hal_init();
/* Wait for the powerup */
esp8266_waitForMessage("ready\r\n",ESP8266_10SecTimeout);
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_connectWifiNetwork(char* ssidName, char* password)
{
uint8_t ipTrial = 0;
/* Change operating mode */
xfprintf(esp8266_hal_sendChar,"AT+CWMODE=1\r\n");
/* Fixed delay ... */
esp8266_hal_delayMiliseconds(100);
/* Reset the wifi module */
xfprintf(esp8266_hal_sendChar,"AT+RST\r\n");
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
/* Wait for the powerup */
esp8266_waitForMessage("ready\r\n",ESP8266_10SecTimeout);
/* SSID details */
xfprintf(esp8266_hal_sendChar,"AT+CWJAP=\"%s\",\"%s\"\r\n",ssidName,password);
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
/* Wait until system gets IP */
do
{
ipTrial++;
esp8266_hal_delayMiliseconds(10);
xfprintf(esp8266_hal_sendChar,"AT+CIFSR\r\n");
}
while((esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK) && (ipTrial < 50));
/* Reboot if neccessary */
if(ipTrial == 50)
{
esp8266_hal_rebootSystem();
}
xfprintf(esp8266_hal_sendChar,"AT+CIPMUX=1\r\n");
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_createWifiNetwork(char* ssidName, char* password)
{
uint8_t ipTrial = 0;
/* Change operating mode */
xfprintf(esp8266_hal_sendChar,"AT+CWMODE=2\r\n");
/* Fixed delay ... */
esp8266_hal_delayMiliseconds(100);
/* Reset the wifi module */
xfprintf(esp8266_hal_sendChar,"AT+RST\r\n");
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
/* Wait for the powerup */
esp8266_waitForMessage("ready\r\n",ESP8266_10SecTimeout);
/* SSID details */
xfprintf(esp8266_hal_sendChar,"AT+CWSAP=\"%s\",\"%s\",1,3\r\n",ssidName,password);
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
/* Wait until system gets IP */
do
{
ipTrial++;
esp8266_hal_delayMiliseconds(10);
xfprintf(esp8266_hal_sendChar,"AT+CIFSR\r\n");
}
while((esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK) && (ipTrial < 50));
/* Reboot if neccessary */
if(ipTrial == 50)
{
esp8266_hal_rebootSystem();
}
xfprintf(esp8266_hal_sendChar,"AT+CIPMUX=1\r\n");
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_openTCPSocket(uint8_t sockId, char* address, uint16_t port)
{
/* TCP socket details */
xfprintf(esp8266_hal_sendChar,"AT+CIPSTART=%d,\"TCP\",\"%s\",%d\r\n",sockId,address,port);
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
esp8266_waitForMessage("Linked\r\n",ESP8266_10SecTimeout);
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_createTCPSocket(uint16_t port)
{
/* Host a TCP server at a specific port */
xfprintf(esp8266_hal_sendChar,"AT+CIPSERVER=1,%u\r\n",port);
/* Reboot if neccessary */
if(esp8266_checkOkError(ESP8266_10SecTimeout) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_closeTCPLink(uint8_t sockId)
{
xfprintf(esp8266_hal_sendChar,"AT+CIPCLOSE=%d\r\n",sockId);
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_sendTCPData(uint32_t timeoutLimit, uint8_t sockId, uint8_t* buf, uint16_t len)
{
uint16_t t16;
/* Prepare to send data ... */
xfprintf(esp8266_hal_sendChar,"AT+CIPSEND=%d,%d\r\n",sockId,len);
if(esp8266_waitForMessage("> ",timeoutLimit) != ESP8266_OK)
{
return ESP8266_ERROR;
}
/* Send the data ... */
for(t16=0;t16<len;t16++)
{
esp8266_hal_sendChar(buf[t16]);
}
/* Reboot if neccessary */
if(esp8266_checkOkError(timeoutLimit) != ESP8266_OK)
{
esp8266_hal_rebootSystem();
}
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
int8_t esp8266_getTCPData(uint32_t timeoutLimit, uint8_t* buf, uint16_t maxSize, uint16_t* actualDataLen, uint8_t* sockId)
{
uint16_t len;
uint16_t t16;
memset(buf,0x00,maxSize);
if(esp8266_waitForMessage("+IPD,",timeoutLimit) == ESP8266_TIMEOUT)
{
*actualDataLen = 0;
return ESP8266_TIMEOUT;
}
*sockId = esp8266_getMessageID();
len = esp8266_getMessageLength();
/* Handle the overflow silently ... */
if(len > maxSize)
{
len = maxSize;
}
/* Fetch the data ... */
for(t16=0;t16<len;t16++)
{
m_timeoutCounter = 0;
if(esp8266_waitForChar(ESP8266_1SecTimeout) == ESP8266_TIMEOUT)
{
esp8266_hal_rebootSystem();
}
buf[t16] = RingBuffer_Remove(&esp8266_ringBuf);
}
*actualDataLen = len;
return ESP8266_OK;
}
/*-----------------------------------------------------------------------------
/ fill a binary string of len data into the tcp packet
/ taken from tuxgraphics ip stack
/----------------------------------------------------------------------------*/
uint16_t esp8266_fill_tcp_data_len(uint8_t *buf,uint16_t pos, const uint8_t *s, uint8_t len)
{
// fill in tcp data at position pos
while (len)
{
buf[pos]=*s;
pos++;
s++;
len--;
}
return(pos);
}
/*-----------------------------------------------------------------------------
/ fill in tcp data at position pos. pos=0 means start of
/ tcp data. Returns the position at which the string after
/ this string could be filled.
/ taken from tuxgraphics ip stack
/----------------------------------------------------------------------------*/
uint16_t esp8266_fill_tcp_data(uint8_t *buf,uint16_t pos, const char *s)
{
return (esp8266_fill_tcp_data_len(buf,pos,(uint8_t*)s,strlen(s)));
}
/*---------------------------------------------------------------------------*/
uint16_t esp8266_create_GetRequest(const uint8_t* urlBase, uint8_t* urlSuffix, uint8_t* respBuff, uint16_t tcpLen)
{
tcpLen = esp8266_fill_tcp_data(respBuff,tcpLen,"GET ");
tcpLen = esp8266_fill_tcp_data(respBuff,tcpLen,urlSuffix);
tcpLen = esp8266_fill_tcp_data(respBuff,tcpLen," HTTP/1.1\r\nUser-Agent: curl/7.37.1\r\nHost: ");
tcpLen = esp8266_fill_tcp_data(respBuff,tcpLen,urlBase);
tcpLen = esp8266_fill_tcp_data(respBuff,tcpLen,"\r\nAccept: */*\r\n\r\n");
return tcpLen;
}
/*---------------------------------------------------------------------------*/
static int8_t esp8266_waitForChar(uint32_t timeoutLimit)
{
while(RingBuffer_GetCount(&esp8266_ringBuf) == 0)
{
esp8266_hal_delayMicroseconds(100);
if(m_timeoutCounter++ > timeoutLimit)
{
return ESP8266_TIMEOUT;
}
}
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
static int8_t esp8266_waitForMessage(const char* checkmsg, uint32_t timeoutLimit)
{
uint8_t ch;
uint8_t run = 1;
uint16_t in = 0;
m_timeoutCounter = 0;
while(run == 1)
{
if(esp8266_waitForChar(timeoutLimit) == ESP8266_TIMEOUT)
{
return ESP8266_TIMEOUT;
}
ch = RingBuffer_Remove(&esp8266_ringBuf);
if(checkmsg[in] == ch)
{
in++;
}
else
{
if(ch == checkmsg[0])
{
in = 1;
}
else
{
in = 0;
}
}
if(checkmsg[in] == '\0')
{
run = 0;
}
}
return ESP8266_OK;
}
/*---------------------------------------------------------------------------*/
static int8_t esp8266_checkOkError(uint32_t timeoutLimit)
{
uint8_t ch;
uint8_t ok_in = 0;
uint8_t err_in = 0;
uint8_t ok_buf[4] = {'O','K','\r','\n'};
uint8_t err_buf[7] = {'E','R','R','O','R','\r','\n'};
m_timeoutCounter = 0;
while(1)
{
if(esp8266_waitForChar(timeoutLimit) == ESP8266_TIMEOUT)
{
return ESP8266_TIMEOUT;
}
ch = RingBuffer_Remove(&esp8266_ringBuf);
if(ok_buf[ok_in] == ch)
{
ok_in++;
}
else
{
if(ch == ok_buf[0])
{
ok_in = 1;
}
else
{
ok_in = 0;
}
}
if(err_buf[err_in] == ch)
{
err_in++;
}
else
{
if(ch == err_buf[0])
{
err_in = 1;
}
else
{
err_in = 0;
}
}
if(ok_in == sizeof(ok_buf))
{
return ESP8266_OK;
}
else if(err_in == sizeof(err_buf))
{
return ESP8266_ERROR;
}
}
return ESP8266_UNKNOWN;
}
/*---------------------------------------------------------------------------*/
static void esp8266_flushBuffer()
{
while(!RingBuffer_IsEmpty(&esp8266_ringBuf))
{
RingBuffer_Remove(&esp8266_ringBuf);
}
}
/*---------------------------------------------------------------------------*/
static uint8_t esp8266_getMessageID()
{
uint8_t run;
uint8_t in = 0;
uint8_t lenbuf[8];
run = 1;
while(run)
{
m_timeoutCounter = 0;
if(esp8266_waitForChar(ESP8266_1SecTimeout) == ESP8266_TIMEOUT)
{
esp8266_hal_rebootSystem();
}
lenbuf[in] = RingBuffer_Remove(&esp8266_ringBuf);
if(lenbuf[in] == ',')
{
lenbuf[in] = '\0';
run = 0;
}
else
{
in++;
}
}
return StrTo16Uint(lenbuf);
}
/*---------------------------------------------------------------------------*/
static uint16_t esp8266_getMessageLength()
{
uint8_t run;
uint8_t in = 0;
uint8_t lenbuf[8];
/* Get the data length */
run = 1;
while(run)
{
m_timeoutCounter = 0;
if(esp8266_waitForChar(ESP8266_1SecTimeout) == ESP8266_TIMEOUT)
{
esp8266_hal_rebootSystem();
}
lenbuf[in] = RingBuffer_Remove(&esp8266_ringBuf);
if(lenbuf[in] == ':')
{
run = 0;
lenbuf[in] = '\0';
}
else
{
in++;
}
}
return StrTo16Uint(lenbuf);
}
/*---------------------------------------------------------------------------*/
static uint16_t StrTo16Uint(char* str)
{
/* taken from: https://github.com/cnlohr/wi07clight/ */
uint16_t ret = 0;
uint8_t yet = 0;
char c;
while(c = (*(str++)))
{
if((c >= '0')&&(c <= '9'))
{
yet = 1;
ret = ret * 10 + (c - '0');
}
else if( yet )
{
//Chars in the middle of the number.
return ret;
}
}
return ret;
}
/*---------------------------------------------------------------------------*/ | [
"ihsan@kehribar.me"
] | ihsan@kehribar.me |
f0058b4c23954c43f1ed1ef9a049d99c3a591ff2 | 64bf8db5fcd72024dc158a4f46cf07b5010eb280 | /Negotiation.c | cd7d63bb1f7849a4f24ddc839c1400dd34ef08f1 | [] | no_license | AribAhmed/BattleBoats | 0f3e775a0ec1de8c899283fb1c67d7f8e6873db4 | 278c1b075cee12f7c2c0bd6e9a2f72a1e214b103 | refs/heads/master | 2023-01-12T00:55:59.899498 | 2020-11-07T00:16:27 | 2020-11-07T00:16:27 | 308,481,565 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,530 | c | #include "Negotiation.h"
#include "BOARD.H"
#include <xc.h>
#include <stdio.h>
#include <math.h>
/**
* This function implements a one-way hash. It maps its input, A,
* into an image, #a, in a way that is hard to reverse, but easy
* to reproduce.
* @param secret //A number that a challenger commits to
* @return hash //the hashed value of the secret commitment.
*
* This function implements the "Beef Hash," a variant of a Rabin hash.
* The result is ((the square of the input) modulo the constant key 0xBEEF).
* So, for example,
*
* NegotiationHash(3) == 9
* NegotiationHash(12345) == 42182
*/
NegotiationData NegotiationHash(NegotiationData secret) {
NegotiationData hashsecret;
hashsecret = (secret * secret) % PUBLIC_KEY;//formula for hash
return hashsecret;
}
/**
* Detect cheating. An accepting agent will receive both a commitment hash
* and a secret number from the challenging agent. This function
* verifies that the secret and the commitment hash agree, hopefully
* detecting cheating by the challenging agent.
*
* @param secret //the previously secret number that the challenging agent has revealed
* @param commitment //the hash of the secret number
* @return TRUE if the commitment validates the revealed secret, FALSE otherwise
*/
int NegotiationVerify(NegotiationData secret, NegotiationData commitment) {
NegotiationData secretHash;
secretHash = NegotiationHash(secret); //hashes the secret number
if (secretHash == commitment) { //if the secret == committment
return TRUE;
} else {
return FALSE;
}
}
/**
* The coin-flip protocol uses random numbers generated by both
* agents to determine the outcome of the coin flip.
*
* The parity of a bitstring is 1 if there are an odd number of one bits,
* and 0 otherwise.
* So, for example, the number 0b01101011 has 5 ones. If the parity of
* A XOR B is 1, then the outcome is HEADS. Otherwise, the outcome is TAILS.
*/
NegotiationOutcome NegotiateCoinFlip(NegotiationData A, NegotiationData B) {
NegotiationData C;
C = A ^ B; //xor the two values
int parity = 0;
while(C){ //parity loop
parity = !parity;
C = C & (C-1);
}
if (parity == 1) { //if odd, then heads
return HEADS;
} else if (parity == 0){ //if even, then heads
return TAILS;
}
else {
return TAILS;
}
}
| [
"airarib@gmail.com"
] | airarib@gmail.com |
007c18ba4a6e8da13363e19aca338c35fb60f965 | 7aa75215614411567b89382cd79e076b3360b654 | /.history/tpfinal-estructuras1/libs/shell_20201207105634.c | a29f0f98b644db9a7bb5e8aa3c6348badfc6043e | [
"Apache-2.0"
] | permissive | IgnacioKase/estructura-datos-1 | 7060173b2ddb7853bd68f199bd3b39048242c482 | 2a0be56a6546a214c011ccc38774b7625885cfd5 | refs/heads/master | 2021-04-17T11:29:00.419081 | 2020-12-10T02:06:21 | 2020-12-10T02:06:21 | 249,441,692 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,067 | c | #include "shell.h"
/* Funcion auxiliar para switch sobre los comandos
de longitud mayor a 1 */
SimpleCommands match_simple_command(char* comando) {
if (!strcmp(comando, "cargar_dataset"))
return DFS;
if (!strcmp(comando, "imprimir_dataset"))
return BFS;
if (!strcmp(comando, "imprimir_dataset"))
return BFS;
if (!strcmp(comando, "agregar_registro"))
return BFS;
if (!strcmp(comando, "eliminar_registro"))
return BFS;
if (!strcmp(comando, "buscar_pico"))
return BFS;
if (!strcmp(comando, "salir"))
return SALIR;
if (!strcmp(comando, "help"))
return HELP;
if (!strcmp(comando, "print"))
return IMPRIMIR2D;
return -1;
}
/* Funcion auxiliar para switch sobre los comandos
de longitud 1 */
IntervalCommands match_interval_command(char comando) {
if (comando == 'i')
return INSERTAR;
if (comando == 'e')
return ELIMINAR;
if (comando == '?')
return INTERSECAR;
return -1;
}
// Informacion sobre los comandos posibles
void help() {
printf("\nComandos:\n");
printf("i [a,b]: inserta el intervalo [a,b] en el arbol\n");
printf("e [a,b]: elimina el intervalo [a,b] del arbol\n");
printf("? [a,b]: interseca el intervalo [a,b] ");
printf("con los intervalos del arbol\n");
printf("dfs: imprime los intervalos del arbol ");
printf("con recorrido primero en profundidad\n");
printf("bfs: imprime los intervalos del arbol ");
printf("con recorrido primero a lo ancho\n");
printf("print: imprime los intervalos en forma de arbol\n");
printf("salir: destruye el arbol y termina el programa\n\n");
printf("Recuerde que los intervalos deben contener numeros\n\n");
}
// Procesamiento de los comandos que no reciben intervalo
int shell_simple_command(char comando[6], ITree itree) {
int continuar = 1;
switch (match_simple_command(comando)) {
case DFS:
itree_recorrer_dfs(itree, ITREE_RECORRIDO_IN, intervalo_imprimir);
puts("");
break;
case BFS:
itree_recorrer_bfs(itree, intervalo_imprimir);
puts("");
break;
case SALIR:
continuar = 0;
break;
case HELP:
help();
break;
case IMPRIMIR2D:
itree_imprimir_2d(itree);
break;
default:
printf("ERROR: comando invalido.\n");
printf("Ingrese 'help' para informacion sobre los comandos.\n");
break;
}
return continuar;
}
// Procesamiento de los comandos que reciben intervalo
ITree shell_interval_command(char comando[6], double* arg, ITree itree) {
/* los comandos que reciben intervalo tienen 1 caracter
y se debe chequear que el intervalo sea valido
(que el final no sea menor al comienzo) */
if (!intervalo_es_valido(arg)) {
printf("ERROR: intervalo invalido.\n");
printf("El extremo izquierdo no puede superar al derecho\n");
return itree;
}
if (strlen(comando) != 1) {
printf("ERROR: comando invalido.\n");
printf("Ingrese 'help' para informacion sobre los comandos.\n");
return itree;
}
switch (match_interval_command(comando[0])) {
case INSERTAR:
itree = itree_insertar(itree, arg);
break;
case ELIMINAR:
itree = itree_eliminar(itree, arg);
break;
case INTERSECAR:
if (itree_intersecar(itree, arg))
printf("Si\n");
else
printf("No\n");
break;
default:
printf("ERROR: comando invalido.\n");
printf("Ingrese 'help' para informacion sobre los comandos.\n");
break;
}
return itree;
}
/* Identifica el comando guardado en buf
(recibido por interprete o test_shell),
ejecuta la operacion (o el error) correspondiente
y retorna 0 si el comando indica salir del programa
o 1 en otro caso, y se usa en loop en los programas anteriores */
int loop_shell(char buf[MAX_STDIN], ITree* itree) {
int continuar = 1;
char comando[MAX_STDIN];
/* no hay comandos tan largos pero esto
previene fallas cuando se ingresa
un comando incorrecto largo */
double arg[2];
int args;
args = sscanf(buf, "%s [%lf, %lf]", comando, arg, &arg[1]);
// args = cant de elementos escaneados
switch (args) {
/* Se debe recibir 1 comando y para algunos casos
2 numeros correspondientes al intervalo,
por lo tanto debe haber 1 o 3 argumentos */
case 1:
continuar = shell_simple_command(comando, *itree);
break;
case 3:
*itree = shell_interval_command(comando, arg, *itree);
break;
default:
printf("ERROR: cantidad invalida de argumentos.\n");
printf("Ingrese 'help' para informacion sobre los comandos.\n");
break;
}
return continuar;
}
| [
"ignacio@kasevich.com.ar"
] | ignacio@kasevich.com.ar |
7dea70dae29279436c890a7492f8b36ec0e63c03 | 38ab8326bddcc4ff30dd89cefa3a0c22ef365df2 | /DuinOS/projdefs.h | be61dd3729a684ae25d3a6350889403e7e48e07f | [] | no_license | rsanders/DuinOS_teensy | 34371bdf37e5897b992ed70fc7e85f70ce53a5e7 | 7cce31545868c840d081e92d812f24f39e86e15a | refs/heads/master | 2018-12-29T00:02:58.993000 | 2010-02-09T04:02:49 | 2010-02-09T04:02:49 | 508,187 | 0 | 1 | null | null | null | null | UTF-8 | C | false | false | 2,651 | h | /*
FreeRTOS V5.4.2 - Copyright (C) 2009 Real Time Engineers Ltd.
This file is part of the FreeRTOS distribution.
FreeRTOS is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License (version 2) as published by the
Free Software Foundation and modified by the FreeRTOS exception.
**NOTE** The exception to the GPL is included to allow you to distribute a
combined work that includes FreeRTOS without being obliged to provide the
source code for proprietary components outside of the FreeRTOS kernel.
Alternative commercial license and support terms are also available upon
request. See the licensing section of http://www.FreeRTOS.org for full
license details.
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
You should have received a copy of the GNU General Public License along
with FreeRTOS; if not, write to the Free Software Foundation, Inc., 59
Temple Place, Suite 330, Boston, MA 02111-1307 USA.
***************************************************************************
* *
* Looking for a quick start? Then check out the FreeRTOS eBook! *
* See http://www.FreeRTOS.org/Documentation for details *
* *
***************************************************************************
1 tab == 4 spaces!
Please ensure to read the configuration and relevant port sections of the
online documentation.
http://www.FreeRTOS.org - Documentation, latest information, license and
contact details.
http://www.SafeRTOS.com - A version that is certified for use in safety
critical systems.
http://www.OpenRTOS.com - Commercial support, development, porting,
licensing and training services.
*/
#ifndef PROJDEFS_H
#define PROJDEFS_H
/* Defines the prototype to which task functions must conform. */
typedef void (*pdTASK_CODE)( void * );
#define pdTRUE ( 1 )
#define pdFALSE ( 0 )
#define pdPASS ( 1 )
#define pdFAIL ( 0 )
#define errQUEUE_EMPTY ( 0 )
#define errQUEUE_FULL ( 0 )
/* Error definitions. */
#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY ( -1 )
#define errNO_TASK_TO_RUN ( -2 )
#define errQUEUE_BLOCKED ( -4 )
#define errQUEUE_YIELD ( -5 )
#endif /* PROJDEFS_H */
| [
"robert@esquimaux.org"
] | robert@esquimaux.org |
9c35a3a7f4cd15da9170af7613e86e7fd9484d24 | 9ee564c7022f5c2bc5715e153d66829d2e706e3e | /gyros/rt1020_gyro_test/cdh_prototype - Copy/gnc_build/FSW_Lib_ert_rtw/mrdivide_helper_23K2DU9e.c | 7b523d211c8a8f2ea03c8f10c0a6fa565ab376d5 | [] | no_license | william-pope/soci_gnc_capstone | cc974ed1fb52d258f7cfd209382f3a8c6dfe323e | a31e2061095960eabf6afd201c64375c5288c2f0 | refs/heads/main | 2023-05-26T14:21:54.361159 | 2021-06-11T06:57:49 | 2021-06-11T06:57:49 | 375,930,018 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,070 | c | /*
* Academic License - for use in teaching, academic research, and meeting
* course requirements at degree granting institutions only. Not for
* government, commercial, or other organizational use.
*
* File: mrdivide_helper_23K2DU9e.c
*
* Code generated for Simulink model 'FSW_Lib'.
*
* Model version : 1.319
* Simulink Coder version : 9.0 (R2018b) 24-May-2018
* C/C++ source code generated on : Wed Feb 17 22:19:10 2021
*/
#include "rtwtypes.h"
#include <math.h>
#include <string.h>
#include "mrdivide_helper_23K2DU9e.h"
/* Function for MATLAB Function: '<S19>/QR_factorization' */
void mrdivide_helper_23K2DU9e(real_T A[36], const real_T B_0[36])
{
real_T b_A[36];
int8_T ipiv[6];
int32_T j;
int32_T ix;
real_T smax;
real_T s;
int32_T iy;
int32_T c_ix;
int32_T d;
int32_T ijA;
int32_T jBcol;
int32_T kBcol;
memcpy(&b_A[0], &B_0[0], 36U * sizeof(real_T));
for (d = 0; d < 6; d++) {
ipiv[d] = (int8_T)(1 + d);
}
for (j = 0; j < 5; j++) {
jBcol = j * 7;
iy = 0;
ix = jBcol;
smax = fabs(b_A[jBcol]);
for (kBcol = 2; kBcol <= 6 - j; kBcol++) {
ix++;
s = fabs(b_A[ix]);
if (s > smax) {
iy = kBcol - 1;
smax = s;
}
}
if (b_A[jBcol + iy] != 0.0) {
if (iy != 0) {
iy += j;
ipiv[j] = (int8_T)(iy + 1);
ix = j;
for (kBcol = 0; kBcol < 6; kBcol++) {
smax = b_A[ix];
b_A[ix] = b_A[iy];
b_A[iy] = smax;
ix += 6;
iy += 6;
}
}
iy = (jBcol - j) + 6;
for (ix = jBcol + 1; ix < iy; ix++) {
b_A[ix] /= b_A[jBcol];
}
}
iy = jBcol;
ix = jBcol + 6;
for (kBcol = 0; kBcol <= 4 - j; kBcol++) {
if (b_A[ix] != 0.0) {
smax = -b_A[ix];
c_ix = jBcol + 1;
d = (iy - j) + 12;
for (ijA = 7 + iy; ijA < d; ijA++) {
b_A[ijA] += b_A[c_ix] * smax;
c_ix++;
}
}
ix += 6;
iy += 6;
}
}
for (j = 0; j < 6; j++) {
jBcol = 6 * j;
iy = 6 * j;
for (ix = 0; ix < j; ix++) {
kBcol = 6 * ix;
smax = b_A[ix + iy];
if (smax != 0.0) {
for (c_ix = 0; c_ix < 6; c_ix++) {
d = c_ix + jBcol;
A[d] -= smax * A[c_ix + kBcol];
}
}
}
smax = 1.0 / b_A[j + iy];
for (iy = 0; iy < 6; iy++) {
d = iy + jBcol;
A[d] *= smax;
}
}
for (j = 5; j >= 0; j--) {
jBcol = 6 * j;
iy = 6 * j - 1;
for (ix = j + 2; ix < 7; ix++) {
kBcol = (ix - 1) * 6;
smax = b_A[ix + iy];
if (smax != 0.0) {
for (c_ix = 0; c_ix < 6; c_ix++) {
A[c_ix + jBcol] -= smax * A[c_ix + kBcol];
}
}
}
}
for (j = 4; j >= 0; j--) {
if (j + 1 != ipiv[j]) {
jBcol = ipiv[j] - 1;
for (iy = 0; iy < 6; iy++) {
smax = A[6 * j + iy];
A[iy + 6 * j] = A[6 * jBcol + iy];
A[iy + 6 * jBcol] = smax;
}
}
}
}
/*
* File trailer for generated code.
*
* [EOF]
*/
| [
"jiapiz@uw.edu"
] | jiapiz@uw.edu |
3aa4f53ef01c2368012edbbc83ed974c2767c17c | 5e28f7133403b69a6f39e24720c37e4c868ca835 | /state_finished.c | 5de23df56b8d792fbfea55e271e7ead9bff3887c | [] | no_license | tpokalch/Won-Kar-Wai | c74f110123abc573626ab38ac8c0436cea7ae0ee | 5b92475a83bd4dcd7a6b13bdd437652ee370aa53 | refs/heads/master | 2021-01-26T03:39:36.514832 | 2020-02-26T15:17:51 | 2020-02-26T15:17:51 | 243,293,919 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,845 | c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* state_finished.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: elyahove <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/12 19:38:26 by elyahove #+# #+# */
/* Updated: 2019/01/13 23:24:20 by elyahove ### ########.fr */
/* */
/* ************************************************************************** */
#include "game_2048.h"
void state_finished_update(t_2048 *ctx_2048, int ch)
{
t_window *win;
win = ctx_2048->state_priv[GAME_STATE_FINISHED];
if (!win)
return ;
if (ch != 0)
{
SET_STATE(ctx_2048, GAME_STATE_EXIT);
delwin(win);
ctx_2048->state_priv[GAME_STATE_FINISHED] = NULL;
}
refresh();
}
void state_finished_render(t_2048 *ctx_2048)
{
t_window *win;
int x;
int y;
win = ctx_2048->state_priv[GAME_STATE_FINISHED];
if (!win)
{
win = newwin((ctx_2048->screen.height / 3),
(ctx_2048->screen.width / 3),
(ctx_2048->screen.height - (ctx_2048->screen.height / 3)) / 2,
(ctx_2048->screen.width - (ctx_2048->screen.width / 3)) / 2);
ctx_2048->state_priv[GAME_STATE_FINISHED] = win;
}
getmaxyx(win, y, x);
mvwprintw(win, y / 2 ? y / 2 - 1 : 0, 3, ctx_2048->player_won ?
"You won!" : "You've lost!");
mvwprintw(win, y / 2 ? y / 2 : 0, 3, "Press any button to continue.");
box(win, 0, 0);
wrefresh(win);
}
| [
"tpokalch@e1r2p13.unit.ua"
] | tpokalch@e1r2p13.unit.ua |
2b94b40d921b903524062f002d17411d93232920 | debc33e87107b37356c74236f1b4aa0310b0f979 | /worker.h | 9a753791e9b21a5f8a82b2c44966884a42ef01b1 | [] | no_license | benben240085/threaded-sample-sort | b52fb43f13a605d88375f9581fcf3bc09fba7a99 | ca7b315864a85fc984cbf6e68339645c59e71ee2 | refs/heads/main | 2023-02-15T05:24:05.392024 | 2021-01-13T04:07:19 | 2021-01-13T04:07:19 | 328,903,364 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 300 | h | #ifndef WORKER_H
#define WORKER_h
#include "barrier.h"
#include "float_vec.h"
typedef struct worker {
int fd;
int pnum;
float* data;
long size;
long* sizes;
int P;
floats* samps;
barrier* bb;
} worker;
worker* make_worker();
void free_worker(worker* ww);
#endif
| [
"newfield.b@northeastern.edu"
] | newfield.b@northeastern.edu |
d29a8b623415e99f933a035efa718a6dca9d55b1 | acb8d4c4f974d872f31997f591fea4d748f94b93 | /p/fystreet/street5101.c | 017e49202366e7868fd02ae99bd11e660847308d | [] | no_license | MudRen/SZMUD | 8ae6b05718b1a83363478469185e0d776b0fda5c | e3b46e6efa6d353f7f0d00ef676f97d5c0ec3949 | refs/heads/master | 2023-05-27T16:04:35.845610 | 2021-06-18T12:47:19 | 2021-06-18T12:47:19 | 361,736,744 | 1 | 2 | null | null | null | null | GB18030 | C | false | false | 582 | c | #define ID 5101
#include <ansi.h>
inherit ROOM;
void create()
{ set("short",HIW"空地"NOR);
set("long",@LONG
这是拥挤的城市中难得一见的开阔地，不过，这里已经被打扫干净，
看上去正在寻找买家呢。想在这里拥有一套自己的房间可不容易，必须要
缴纳一大笔的购地款。
LONG );
set("roomid",ID);
if(ID%2) set("exits",(["east":__DIR__"street"+(string)(ID/100),]));
else set("exits",(["west":__DIR__"street"+(string)(ID/100),]));
set("coor/x",40+(ID%2)*20);
set("coor/y",20+(ID/100)*10);
set("coor/z",0);
setup();
} | [
"i@oiuv.cn"
] | i@oiuv.cn |
e54005ae7d6ad092263f5b9a5f48125cbc585e21 | 32c0eaf5741db2aaea24459542e0a655a4df39f6 | /src/error.c | 04f8f5b318611ee0818b661626c6dae89ce4a67f | [] | no_license | yeaFern/foxc | 5b54d800e5395aff290ec8d00cd3ac4fba222aae | 1f6ae64827b3c502258d2a484844a2da1e04aab6 | refs/heads/master | 2022-07-17T12:19:21.156249 | 2020-05-20T12:58:44 | 2020-05-20T12:58:44 | 264,565,071 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 166 | c | #include "error.h"
_Noreturn void error(char* fmt, ...)
{
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
exit(EXIT_FAILURE);
}
| [
"54524320+yeaFern@users.noreply.github.com"
] | 54524320+yeaFern@users.noreply.github.com |
84784feef251800edf5947205dbd8bb0d74d8ef2 | 109c2487947a17a74c6dd74b9feda01aed34d8d1 | /Scott-DFT/ATLAS/Dev1/include/atlas_cNCmm.h | 5754fc208718c7fa36d6aee88185213653704cd0 | [] | no_license | ebylaska/NWPW-C- | 93afad2309483d1dd9fe59546b71e1167926de58 | ea4da7c46fa604fe5de87eb90929c13071110148 | refs/heads/master | 2021-01-12T11:39:32.328672 | 2017-08-31T00:54:16 | 2017-08-31T00:54:16 | 72,255,209 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 454 | h | #ifndef CMM_H
#define CMM_H
#define ATL_mmMULADD
#define ATL_mmLAT 4
#define ATL_mmMU 4
#define ATL_mmNU 2
#define ATL_mmKU 72
#define MB 44
#define NB 44
#define KB 44
#define NBNB 1936
#define MBNB 1936
#define MBKB 1936
#define NBKB 1936
#define NB2 88
#define NBNB2 3872
#define ATL_MulByNB(N_) ((N_) * 44)
#define ATL_DivByNB(N_) ((N_) / 44)
#define ATL_MulByNBNB(N_) ((N_) * 1936)
#endif
| [
"eric.bylaska@pnnl.gov"
] | eric.bylaska@pnnl.gov |
8e67a19b5e5128b11fcbae5c7501691937b36997 | c776476e9d06b3779d744641e758ac3a2c15cddc | /examples/litmus/c/c-litmus-CSEQ/_cs_2+2W+dmb.st+dmb.sylp.c | a1378b58a37cdd0552f8c3d8436a1b41a45a9d04 | [] | no_license | ashutosh0gupta/llvm_bmc | aaac7961c723ba6f7ffd77a39559e0e52432eade | 0287c4fb180244e6b3c599a9902507f05c8a7234 | refs/heads/master | 2023-08-02T17:14:06.178723 | 2023-07-31T10:46:53 | 2023-07-31T10:46:53 | 143,100,825 | 3 | 4 | null | 2023-05-25T05:50:55 | 2018-08-01T03:47:00 | C++ | UTF-8 | C | false | false | 24,633 | c | /*
* generated by CSeq [ 0000 / 0000 ]
*
* instance version {}
*
* 2023-06-04 11:21:39
*
* params:
* -i /home/osboxes/llvm_bmc/llvm_bmc/examples/litmus/c/run-scripts/../c-litmus-CSEQ/2+2W+dmb.st+dmb.sylp.c,
*
*/
#define __cs_MUTEX_INITIALIZER -1
#define __cs_COND_INITIALIZER -1
#define __cs_RWLOCK_INITIALIZER -1
#define __cs_BARRIER_SERIAL_THREAD 0
#define __cs_CANCEL_ASYNCHRONOUS 0
#define __cs_CANCEL_ENABLE 0
#define __cs_CANCEL_DEFERRED 0
#define __cs_CANCEL_DISABLE 0
#define __cs_CANCELED 0
#define __cs_CREATE_DETACHED 0
#define __cs_CREATE_JOINABLE 0
#define __cs_EXPLICIT_SCHED 0
#define __cs_INHERIT_SCHED 0
#define __cs_MUTEX_DEFAULT 0
#define __cs_MUTEX_ERRORCHECK 0
#define __cs_MUTEX_NORMAL 0
#define __cs_MUTEX_RECURSIVE 0
#define __cs_MUTEX_ROBUST 0
#define __cs_MUTEX_STALLED 0
#define __cs_ONCE_INIT 0
#define __cs_PRIO_INHERIT 0
#define __cs_PRIO_NONE 0
#define __cs_PRIO_PROTECT 0
#define __cs_PROCESS_SHARED 0
#define __cs_PROCESS_PRIVATE 0
#define __cs_SCOPE_PROCESS 0
#define __cs_SCOPE_SYSTEM 0
#include <assert.h>
int __VERIFIER_nondet_int();
int nondet_int();
unsigned int __VERIFIER_nondet_uint();
unsigned int nondet_uint();
_Bool __VERIFIER_nondet_bool();
_Bool nondet_bool();
char __VERIFIER_nondet_char();
char nondet_char();
unsigned char __VERIFIER_nondet_uchar();
unsigned char nondet_uchar();
#define THREADS 2
#define ROUNDS 1
#define STOP_VOID(A) return;
#define STOP_NONVOID(A) return 0;
#define IF(T,A,B) if ((__cs_pc[T] > A) | (A >= __cs_pc_cs[T])) goto B;
unsigned __CPROVER_bitvector[1] __cs_active_thread[3] = {1};
unsigned __CPROVER_bitvector[3] __cs_pc[3];
unsigned __CPROVER_bitvector[4] __cs_pc_cs[3];
unsigned __CPROVER_bitvector[2] __cs_last_thread;
unsigned __CPROVER_bitvector[3] __cs_thread_lines[3] = {6, 3, 3};
void *__cs_safe_malloc(unsigned int __cs_size)
{
void *__cs_ptr = (malloc(__cs_size));
return __cs_ptr;
}
void __cs_init_scalar(void *__cs_var, unsigned int __cs_size)
{
if (__cs_size == (sizeof(int)))
*((int *) __cs_var) = nondet_int();
else
{
__cs_var = malloc(__cs_size);
}
}
void __CSEQ_message(char *__cs_message)
{
;
}
typedef int __cs_t;
void *__cs_threadargs[3];
void *__cs_thread_joinargs[3];
int __cs_create(__cs_t *__cs_new_thread_id, void *__cs_attr, void *(*__cs_thread_function)(void *), void *__cs_arg, int __cs_threadID)
{
if (__cs_threadID > THREADS)
return 0;
*__cs_new_thread_id = __cs_threadID;
__cs_active_thread[__cs_threadID] = 1;
__cs_threadargs[__cs_threadID] = __cs_arg;
__CSEQ_message("thread spawned");
return 0;
}
int __cs_join(__cs_t __cs_id, void **__cs_value_ptr)
{
__CPROVER_assume(__cs_pc[__cs_id] == __cs_thread_lines[__cs_id]);
*__cs_value_ptr = __cs_thread_joinargs[__cs_id];
return 0;
}
int __cs_exit(void *__cs_value_ptr, unsigned int __cs_thread_index)
{
__cs_thread_joinargs[__cs_thread_index] = __cs_value_ptr;
return 0;
}
int __cs_self(void)
{
return 1;
}
typedef int __cs_mutex_t;
int __cs_mutex_init(__cs_mutex_t *__cs_m, int __cs_val)
{
*__cs_m = -1;
return 0;
}
int __cs_mutex_destroy(__cs_mutex_t *__cs_mutex_to_destroy)
{
__CPROVER_assert((*__cs_mutex_to_destroy) != 0, "attempt to destroy an uninitialized mutex");
__CPROVER_assert((*__cs_mutex_to_destroy) != (-2), "attempt to destroy a previously destroyed mutex");
__CPROVER_assert((*__cs_mutex_to_destroy) == (-1), "attempt to destroy a locked mutex");
*__cs_mutex_to_destroy = -2;
__CSEQ_message("lock destroyed");
return 0;
}
int __cs_mutex_lock(__cs_mutex_t *__cs_mutex_to_lock, unsigned __CPROVER_bitvector[2] __cs_thread_index)
{
__CPROVER_assert((*__cs_mutex_to_lock) != 0, "attempt to lock an uninitialized mutex");
__CPROVER_assert((*__cs_mutex_to_lock) != (-2), "attempt to lock a destroyed mutex");
__CPROVER_assume((*__cs_mutex_to_lock) == (-1));
*__cs_mutex_to_lock = __cs_thread_index + 1;
__CSEQ_message("lock acquired");
return 0;
}
int __cs_mutex_unlock(__cs_mutex_t *__cs_mutex_to_unlock, unsigned __CPROVER_bitvector[2] __cs_thread_index)
{
__CPROVER_assert((*__cs_mutex_to_unlock) != 0, "attempt to unlock an uninitialized mutex");
__CPROVER_assert((*__cs_mutex_to_unlock) != (-2), "attempt to unlock a destroyed mutex");
__CPROVER_assume((*__cs_mutex_to_unlock) == (__cs_thread_index + 1));
*__cs_mutex_to_unlock = -1;
__CSEQ_message("lock released");
return 0;
}
typedef int __cs_cond_t;
int __cs_cond_init(__cs_cond_t *__cs_cond_to_init, void *__cs_attr)
{
*__cs_cond_to_init = -1;
return 0;
}
int __cs_cond_destroy(__cs_cond_t *__cs_cond_to_destroy)
{
*__cs_cond_to_destroy = -2;
return 0;
}
int __cs_cond_wait_1(__cs_cond_t *__cs_cond_to_wait_for, __cs_mutex_t *__cs_m, unsigned int __cs_thread_index)
{
__CPROVER_assert((*__cs_cond_to_wait_for) != 0, "attempt to use an uninitialized conditional variable");
__CPROVER_assert((*__cs_cond_to_wait_for) != (-2), "attempt to use a destroyed conditional variable");
__cs_mutex_unlock(__cs_m, __cs_thread_index);
return 0;
}
int __cs_cond_wait_2(__cs_cond_t *__cs_cond_to_wait_for, __cs_mutex_t *__cs_m, unsigned int __cs_thread_index)
{
__CPROVER_assume((*__cs_cond_to_wait_for) == 1);
__cs_mutex_lock(__cs_m, __cs_thread_index);
return 0;
}
int __cs_cond_signal(__cs_cond_t *__cs_cond_to_signal)
{
*__cs_cond_to_signal = 1;
__CSEQ_message("conditional variable signal");
return 0;
}
int __cs_cond_broadcast(__cs_cond_t *__cs_cond_to_broadcast)
{
*__cs_cond_to_broadcast = 1;
__CSEQ_message("conditional variable broadcast");
return 0;
}
typedef struct __cs_barrier_t
{
unsigned int init;
unsigned int current;
} __cs_barrier_t;
int __cs_barrier_init(__cs_barrier_t *__cs_barrier_to_init, void *__cs_attr, unsigned int count)
{
__CPROVER_assert(count > 0, "count must be greater than 0");
__cs_barrier_to_init->current = count;
__cs_barrier_to_init->init = count;
return 0;
}
int __cs_barrier_destroy(__cs_barrier_t *__cs_barrier_to_destroy)
{
__cs_barrier_to_destroy->init = -1;
__cs_barrier_to_destroy->current = -1;
return 0;
}
int __cs_barrier_wait_1(__cs_barrier_t *__cs_barrier_to_wait)
{
__CPROVER_assert(__cs_barrier_to_wait->init > 0, "attempt to use an uninitialized barrier variable");
__cs_barrier_to_wait->current--;
return 0;
}
int __cs_barrier_wait_2(__cs_barrier_t *__cs_barrier_to_wait)
{
__CPROVER_assert(__cs_barrier_to_wait->init > 0, "attempt to use an uninitialized barrier variable");
__CPROVER_assume(__cs_barrier_to_wait->current == 0);
__cs_barrier_to_wait->current = __cs_barrier_to_wait->init;
return 0;
}
typedef int __cs_attr_t;
struct sched_param
{
int sched_priority;
};
int __cs_attr_init(__cs_attr_t *t)
{
return 0;
}
int __cs_attr_destroy(__cs_attr_t *t)
{
return 0;
}
int __cs_attr_getdetachstate(const __cs_attr_t *t, int *s)
{
return 0;
}
int __cs_attr_getguardsize(const __cs_attr_t *t, unsigned int *s)
{
return 0;
}
int __cs_attr_getinheritsched(const __cs_attr_t *t, int *s)
{
return 0;
}
int __cs_attr_getschedparam(const __cs_attr_t *t, struct sched_param *s)
{
return 0;
}
int __cs_attr_getschedpolicy(const __cs_attr_t *t, int *s)
{
return 0;
}
int __cs_attr_getscope(const __cs_attr_t *t, int *s)
{
return 0;
}
int __cs_attr_getstackaddr(const __cs_attr_t *t, void **s)
{
return 0;
}
int __cs_attr_getstacksize(const __cs_attr_t *t, unsigned int *s)
{
return 0;
}
int __cs_attr_setdetachstate(__cs_attr_t *t, int s)
{
return 0;
}
int __cs_attr_setguardsize(__cs_attr_t *t, unsigned int s)
{
return 0;
}
int __cs_attr_setinheritsched(__cs_attr_t *t, int s)
{
return 0;
}
int __cs_attr_setschedparam(__cs_attr_t *t, const struct sched_param *s)
{
return 0;
}
int __cs_attr_setschedpolicy(__cs_attr_t *t, int s)
{
return 0;
}
int __cs_attr_setscope(__cs_attr_t *t, int s)
{
return 0;
}
int __cs_attr_setstackaddr(__cs_attr_t *t, void *s)
{
return 0;
}
int __cs_attr_setstacksize(__cs_attr_t *t, unsigned int s)
{
return 0;
}
int vars[2];
void *t0_0(void *__cs_param_t0_arg)
{
label_1_t0_0:
__CPROVER_assume(__cs_pc_cs[1] >= 1);
IF(1,0,tt0_0_1)
;
;
tt0_0_1: IF(1,1,tt0_0_2)
vars[0] = 2;
;
;
tt0_0_2: IF(1,2,tt0_0_3)
vars[1] = 1;
goto __exit_t0;
;
__exit_t0:
__CPROVER_assume(__cs_pc_cs[1] >= 3);
;
;
tt0_0_3:
__cs_exit(0, 1);
}
void *t1_0(void *__cs_param_t1_arg)
{
label_2_t1_0:
__CPROVER_assume(__cs_pc_cs[2] >= 1);
IF(2,0,tt1_0_1)
;
;
;
;
tt1_0_1: IF(2,1,tt1_0_2)
vars[1] = 2;
;
;
tt1_0_2: IF(2,2,tt1_0_3)
vars[0] = 1;
goto __exit_t1;
;
__exit_t1:
__CPROVER_assume(__cs_pc_cs[2] >= 3);
;
;
tt1_0_3:
__cs_exit(0, 2);
}
int main_thread(void)
{
int __cs_param_main_argc;
char **__cs_param_main_argv;
IF(0,0,tmain_1)
static __cs_t __cs_local_main_thr0;
;
;
static __cs_t __cs_local_main_thr1;
;
;
vars[1] = 0;
vars[0] = 0;
__cs_create(&__cs_local_main_thr0, 0, t0_0, 0, 1);
tmain_1: IF(0,1,tmain_2)
__cs_create(&__cs_local_main_thr1, 0, t1_0, 0, 2);
tmain_2: IF(0,2,tmain_3)
__cs_join(__cs_local_main_thr0, 0);
tmain_3: IF(0,3,tmain_4)
__cs_join(__cs_local_main_thr1, 0);
static int __cs_local_main_v1;
tmain_4: IF(0,4,tmain_5)
__cs_local_main_v1 = vars[0];
static int __cs_local_main_v2;
__cs_local_main_v2 = __cs_local_main_v1 == 2;
static int __cs_local_main_v3;
tmain_5: IF(0,5,tmain_6)
__cs_local_main_v3 = vars[1];
static int __cs_local_main_v4;
__cs_local_main_v4 = __cs_local_main_v3 == 2;
static int __cs_local_main_v5_conj;
__cs_local_main_v5_conj = __cs_local_main_v2 & __cs_local_main_v4;
;
;
static _Bool __cs_local_main___cs_tmp_if_cond_0;
__cs_local_main___cs_tmp_if_cond_0 = __cs_local_main_v5_conj == 1;
if (__cs_local_main___cs_tmp_if_cond_0)
{
assert(0);
}
;
goto __exit_main;
;
__exit_main:
__CPROVER_assume(__cs_pc_cs[0] >= 6);
;
;
tmain_6:
__cs_exit(0, 0);
}
int main(void)
{
/* round 0 */
/* main */
unsigned __CPROVER_bitvector[3] __cs_tmp_t0_r0;
__cs_pc_cs[0] = __cs_tmp_t0_r0;
__CPROVER_assume(__cs_pc_cs[0] > 0);
__CPROVER_assume(__cs_pc_cs[0] <= 6);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
/* t0_0 */
unsigned __CPROVER_bitvector[2] __cs_tmp_t1_r0;
if (__cs_active_thread[1])
{
__cs_pc_cs[1] = __cs_tmp_t1_r0;
__CPROVER_assume(__cs_pc_cs[1] <= 3);
t0_0(__cs_threadargs[1]);
__cs_pc[1] = __cs_pc_cs[1];
}
/* t1_0 */
unsigned __CPROVER_bitvector[2] __cs_tmp_t2_r0;
if (__cs_active_thread[2])
{
__cs_pc_cs[2] = __cs_tmp_t2_r0;
__CPROVER_assume(__cs_pc_cs[2] <= 3);
t1_0(__cs_threadargs[2]);
__cs_pc[2] = __cs_pc_cs[2];
}
unsigned __CPROVER_bitvector[3] __cs_tmp_t0_r1;
if (__cs_active_thread[0] == 1)
{
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r1;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 6);
main_thread();
}
return 0;
}
| [
"tuan-phong.ngo@it.uu.se"
] | tuan-phong.ngo@it.uu.se |
2331c2ddd9726d18fd7f715acc75208c18b301af | 2bf71fc26de3486ca7a05b9dc645fc47ecd78679 | /libs/cooker/token.c | 5c9e442d3e9ddaeb0b80e7875360cb0ce86171df | [] | no_license | anpaza/cook | 7dc56d3d911341078597433607502c3f1fae71dc | d416e693098e03e553a16bcd153b19ce786a6d73 | refs/heads/master | 2020-03-25T08:16:20.183828 | 2018-08-05T11:16:46 | 2018-08-05T11:16:46 | 143,605,170 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 823 | c | /* The Cook project
* The token object API.
*
* Copyright (c) 2018 Andrey Zabolotnyi <zapparello@ya.ru>
* See file docs/COPYING for copying conditions
*/
#include "token.h"
#include <string.h>
static const char *token_names [] =
{
"error",
"space",
"next",
"comment",
"word",
"assign",
"append",
"exclude",
"conditional assign",
"unveil",
"simple unveil",
"open brace",
"closed brace",
"comma"
};
void token_init (token_t *token)
{
memset (token, 0, sizeof (token_t));
}
void token_done (token_t *token)
{
str_done (&token->text);
}
const char *token_name (token_code_t code)
{
return token_names [code];
}
void token_copy (token_t *to, token_t *from)
{
token_done (to);
str_set (&to->text, &from->text);
to->code = from->code;
}
| [
"zapparello@ya.ru"
] | zapparello@ya.ru |
82d05a10e3b38a3fd8ecaf075227be57fd79df9d | 46eb4a693c5150fb9467d54c34901967482003a3 | /ProtecoC/Cadena.c | 17c37474d37ef36d451f4684fd28801820ed5b64 | [] | no_license | dulcoral/ProyectosPrebe | ab727c86a752973445f27c087f109afdeb1df44a | 7f908134435997edba62f8a97f8538eed8c7dd8c | refs/heads/master | 2021-01-18T23:00:37.692882 | 2017-04-17T04:58:42 | 2017-04-17T04:58:42 | 87,083,774 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 2,678 | c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
void ingresacadena (void **cadenas);
void ordenar (void **cadenas);
void modificar (void **cadenas);
void borrar (void **cadenas);
int main(){
int opcion;
void **cadenas;
cadenas=(void**) calloc (10,sizeof(char*));
ingresacadena(cadenas);
do{
printf("Puedes realizar las siguientes acciones: \n");
printf("1.Listar cadenas\n");
printf("2.Ordenas cadenas\n");
printf("3.Modificar cadenas\n");
printf("4.Borrar cadenas\n");
printf("5.Salir\n");
printf("Ingresa la opción que desees realizar:");
scanf("%d",&opcion);
switch (opcion){
case 1:
for (int i = 0; i < 10; i++)
{
printf("Cadena numero %d: %s\n",i , (char *)cadenas[i] );
}
break;
case 2:
ordenar(cadenas);
for (int i = 0; i < 10; i++)
{
printf("%s\n", (char *)cadenas[i] );
}
break;
case 3:
modificar(cadenas);
break;
case 4:
borrar(cadenas);
break;
case 5:
printf("bye!");
break;
default:
printf("Opcion invalida\n");
}
}while(opcion != 5);
for (int i = 0; i < 10; i++)
free (cadenas[i]);
free(cadenas);
return 0;
}
void ingresacadena (void **cadenas) {
for (int i = 0; i < 10; i++){
char cadena[100];
printf("Ingresa la cadena numero %d : ", i+1 );
gets(cadena);
cadenas[i] = (void*) calloc(strlen(cadena),sizeof(char));
strcpy ((char *)cadenas [i], cadena);
}
}
void ordenar (void **cadenas){
for (int i = 1; i < 10; i++){
int j=i;
while(j>0 && (strcmp((char *)cadenas[j-1],(char *)cadenas[j])>0)){
void *temporal=cadenas[j];
cadenas[j]=cadenas[j-1];
cadenas[j-1]=temporal;
j=j-1;
}
}
}
void borrar (void **cadenas){
int n;
printf("Que cadena quieres borrar?\n");
for (int i = 0; i < 10; i++)
printf("%i. %s\n",i+1,(char *)cadenas[i] );
printf("\n\nIngresa el numero: ");
scanf("%d",&n);
free (cadenas[n-1]);
cadenas[n-1]=NULL;
printf("Cadena borrada:\n");
for (int i = 0; i < 10; i++)
{
if (cadenas[i]!=NULL)
{
printf("%i. %s\n",i+1, (char *)cadenas[i] );
}
}
}
void modificar (void **cadenas){
int n;
printf("Que cadena quieres modificar?\n");
for (int i = 0; i < 10; i++)
{
printf("%i. %s\n",i+1, (char *)cadenas[i] );
}
printf("\n\nIngresa el numero: ");
scanf("%d",&n);
free (cadenas[n-1]);
cadenas[n-1]=NULL;
char mod[100];
printf("Ingresa el nuevo contenido:\n");
scanf("%s",mod);
cadenas[n-1] = (void*) calloc(strlen(mod),sizeof(char));
strcpy ((char *)cadenas [n-1], mod);
printf("Cadena modificada:\n");
for (int i = 0; i < 10; i++)
{
printf("%i. %s\n",i+1,(char *)cadenas[i] );
}
}
| [
"dulcoral20@gmail.com"
] | dulcoral20@gmail.com |
90ffd3755862dce6ab0551d1a25dcd00d5ff02de | 588cb180dc517c72a6a8d90798f6f1c36c20a1af | /list.h | 2edd1d53df320c5c77b2a16535d6dad2910b3803 | [] | no_license | quizywiz/linked-list | a80f35b6124b38f9322605908e65fe33dd333c8a | 0cb83e29d89ee8bec34450386abd10dd6ec1c6dd | refs/heads/master | 2016-08-08T13:32:38.723433 | 2014-01-28T14:46:51 | 2014-01-28T14:46:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 293 | h | #ifndef _LIST_H
#define _LIST_H
//typdef node* nodep
struct node
{
int data;
struct node* next;
};
typedef struct node node;
node* get_2last(node*);
void list_init(node**);
int list_push(node**,const int*);
int list_pop(node**);
int list_length(node*);
int list_delete(node**);
#endif
| [
"quizywiz@ubuntu.ubuntu-domain"
] | quizywiz@ubuntu.ubuntu-domain |
9b750c1689d632c0c6d64e8ab092418e22594713 | 56576b96d8fa41c5ea11d966349fd9aab0c95b6f | /dominion/mutanttesting/notkilled/mutant100807_dominion.c | 2ec704d7386dd8724d4e74a253226730c01c1507 | [] | no_license | cs362sp16/cs362sp16_minnerp | 9f45847caa77acb4f390e07478139ac7dd681203 | 12cba30f398c2e18aa4b7138c6034503fba8624f | refs/heads/master | 2021-01-21T11:40:18.310073 | 2016-06-06T18:01:45 | 2016-06-06T18:01:45 | 55,734,691 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 32,223 | c | #include "dominion.h"
#include "dominion_helpers.h"
#include "rngs.h"
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int compare(const void* a, const void* b) {
if (*(int*)a > *(int*)b)
return 1;
/* MUTANT (rep_op) */ if (*(int*)a <= *(int*)b)
return -1;
return 0;
}
struct gameState* newGame() {
struct gameState* g = malloc(sizeof(struct gameState));
return g;
}
int* kingdomCards(int k1, int k2, int k3, int k4, int k5, int k6, int k7,
int k8, int k9, int k10) {
int* k = malloc(10 * sizeof(int));
k[0] = k1;
k[1] = k2;
k[2] = k3;
k[3] = k4;
k[4] = k5;
k[5] = k6;
k[6] = k7;
k[7] = k8;
k[8] = k9;
k[9] = k10;
return k;
}
int initializeGame(int numPlayers, int kingdomCards[10], int randomSeed,
struct gameState *state) {
int i;
int j;
int it;
//set up random number generator
SelectStream(1);
PutSeed((long)randomSeed);
//check number of players
if (numPlayers > MAX_PLAYERS || numPlayers < 2)
{
return -1;
}
//set number of players
state->numPlayers = numPlayers;
//check selected kingdom cards are different
for (i = 0; i < 10; i++)
{
for (j = 0; j < 10; j++)
{
if (j != i && kingdomCards[j] == kingdomCards[i])
{
return -1;
}
}
}
//initialize supply
///////////////////////////////
//set number of Curse cards
if (numPlayers == 2)
{
state->supplyCount[curse] = 10;
}
else if (numPlayers == 3)
{
state->supplyCount[curse] = 20;
}
else
{
state->supplyCount[curse] = 30;
}
//set number of Victory cards
if (numPlayers == 2)
{
state->supplyCount[estate] = 8;
state->supplyCount[duchy] = 8;
state->supplyCount[province] = 8;
}
else
{
state->supplyCount[estate] = 12;
state->supplyCount[duchy] = 12;
state->supplyCount[province] = 12;
}
//set number of Treasure cards
state->supplyCount[copper] = 60 - (7 * numPlayers);
state->supplyCount[silver] = 40;
state->supplyCount[gold] = 30;
//set number of Kingdom cards
for (i = adventurer; i <= treasure_map; i++) //loop all cards
{
for (j = 0; j < 10; j++) //loop chosen cards
{
if (kingdomCards[j] == i)
{
//check if card is a 'Victory' Kingdom card
if (kingdomCards[j] == great_hall || kingdomCards[j] == gardens)
{
if (numPlayers == 2){
state->supplyCount[i] = 8;
}
else{ state->supplyCount[i] = 12; }
}
else
{
state->supplyCount[i] = 10;
}
break;
}
else //card is not in the set choosen for the game
{
state->supplyCount[i] = -1;
}
}
}
////////////////////////
//supply intilization complete
//set player decks
for (i = 0; i < numPlayers; i++)
{
state->deckCount[i] = 0;
for (j = 0; j < 3; j++)
{
state->deck[i][j] = estate;
state->deckCount[i]++;
}
for (j = 3; j < 10; j++)
{
state->deck[i][j] = copper;
state->deckCount[i]++;
}
}
//shuffle player decks
for (i = 0; i < numPlayers; i++)
{
if ( shuffle(i, state) < 0 )
{
return -1;
}
}
//draw player hands
for (i = 0; i < numPlayers; i++)
{
//initialize hand size to zero
state->handCount[i] = 0;
state->discardCount[i] = 0;
//draw 5 cards
// for (j = 0; j < 5; j++)
// {
// drawCard(i, state);
// }
}
//set embargo tokens to 0 for all supply piles
for (i = 0; i <= treasure_map; i++)
{
state->embargoTokens[i] = 0;
}
//initialize first player's turn
state->outpostPlayed = 0;
state->phase = 0;
state->numActions = 1;
state->numBuys = 1;
state->playedCardCount = 0;
state->whoseTurn = 0;
state->handCount[state->whoseTurn] = 0;
//int it; move to top
//Moved draw cards to here, only drawing at the start of a turn
for (it = 0; it < 5; it++){
drawCard(state->whoseTurn, state);
}
updateCoins(state->whoseTurn, state, 0);
return 0;
}
int shuffle(int player, struct gameState *state) {
int newDeck[MAX_DECK];
int newDeckPos = 0;
int card;
int i;
//Add discard to deck if empty
if (state->deckCount[player] < 1) {
return -1;
}
qsort ((void*)(state->deck[player]), state->deckCount[player], sizeof(int), compare);
/* SORT CARDS IN DECK TO ENSURE DETERMINISM! */
while (state->deckCount[player] > 0) {
card = floor(Random() * state->deckCount[player]);
newDeck[newDeckPos] = state->deck[player][card];
newDeckPos++;
for (i = card; i < state->deckCount[player]-1; i++) {
state->deck[player][i] = state->deck[player][i+1];
}
state->deckCount[player]--;
}
for (i = 0; i < newDeckPos; i++) {
state->deck[player][i] = newDeck[i];
state->deckCount[player]++;
}
return 0;
}
int playCard(int handPos, int choice1, int choice2, int choice3, struct gameState *state)
{
int card;
int coin_bonus = 0; //tracks coins gain from actions
//check if it is the right phase
if (state->phase != 0)
{
return -1;
}
//check if player has enough actions
if ( state->numActions < 1 )
{
return -1;
}
//get card played
card = handCard(handPos, state);
//check if selected card is an action
if ( card < adventurer || card > treasure_map )
{
return -1;
}
//play card
if ( cardEffect(card, choice1, choice2, choice3, state, handPos, &coin_bonus) < 0 )
{
return -1;
}
//reduce number of actions
state->numActions--;
//update coins (Treasure cards may be added with card draws)
updateCoins(state->whoseTurn, state, coin_bonus);
return 0;
}
int buyCard(int supplyPos, struct gameState *state) {
int who;
if (DEBUG){
printf("Entering buyCard...\n");
}
// I don't know what to do about the phase thing.
who = state->whoseTurn;
if (state->numBuys < 1){
if (DEBUG)
printf("You do not have any buys left\n");
return -1;
} else if (supplyCount(supplyPos, state) <1){
if (DEBUG)
printf("There are not any of that type of card left\n");
return -1;
} else if (state->coins < getCost(supplyPos)){
if (DEBUG)
printf("You do not have enough money to buy that. You have %d coins.\n", state->coins);
return -1;
} else {
state->phase=1;
//state->supplyCount[supplyPos]--;
gainCard(supplyPos, state, 0, who); //card goes in discard, this might be wrong.. (2 means goes into hand, 0 goes into discard)
state->coins = (state->coins) - (getCost(supplyPos));
state->numBuys--;
if (DEBUG)
printf("You bought card number %d for %d coins. You now have %d buys and %d coins.\n", supplyPos, getCost(supplyPos), state->numBuys, state->coins);
}
//state->discard[who][state->discardCount[who]] = supplyPos;
//state->discardCount[who]++;
return 0;
}
int numHandCards(struct gameState *state) {
return state->handCount[ whoseTurn(state) ];
}
int handCard(int handPos, struct gameState *state) {
int currentPlayer = whoseTurn(state);
return state->hand[currentPlayer][handPos];
}
int supplyCount(int card, struct gameState *state) {
return state->supplyCount[card];
}
int fullDeckCount(int player, int card, struct gameState *state) {
int i;
int count = 0;
for (i = 0; i < state->deckCount[player]; i++)
{
if (state->deck[player][i] == card) count++;
}
for (i = 0; i < state->handCount[player]; i++)
{
if (state->hand[player][i] == card) count++;
}
for (i = 0; i < state->discardCount[player]; i++)
{
if (state->discard[player][i] == card) count++;
}
return count;
}
int whoseTurn(struct gameState *state) {
return state->whoseTurn;
}
int endTurn(struct gameState *state) {
int k;
int i;
int currentPlayer = whoseTurn(state);
//Discard hand
for (i = 0; i < state->handCount[currentPlayer]; i++){
state->discard[currentPlayer][state->discardCount[currentPlayer]++] = state->hand[currentPlayer][i];//Discard
state->hand[currentPlayer][i] = -1;//Set card to -1
}
state->handCount[currentPlayer] = 0;//Reset hand count
//Code for determining the player
if (currentPlayer < (state->numPlayers - 1)){
state->whoseTurn = currentPlayer + 1;//Still safe to increment
}
else{
state->whoseTurn = 0;//Max player has been reached, loop back around to player 1
}
state->outpostPlayed = 0;
state->phase = 0;
state->numActions = 1;
state->coins = 0;
state->numBuys = 1;
state->playedCardCount = 0;
state->handCount[state->whoseTurn] = 0;
//int k; move to top
//Next player draws hand
for (k = 0; k < 5; k++){
drawCard(state->whoseTurn, state);//Draw a card
}
//Update money
updateCoins(state->whoseTurn, state , 0);
return 0;
}
int isGameOver(struct gameState *state) {
int i;
int j;
//if stack of Province cards is empty, the game ends
if (state->supplyCount[province] == 0)
{
return 1;
}
//if three supply pile are at 0, the game ends
j = 0;
for (i = 0; i < 25; i++)
{
if (state->supplyCount[i] == 0)
{
j++;
}
}
if ( j >= 3)
{
return 1;
}
return 0;
}
int scoreFor (int player, struct gameState *state) {
int i;
int score = 0;
//score from hand
for (i = 0; i < state->handCount[player]; i++)
{
/* MUTANT (rep_const) */ if (state->hand[player][i] == curse) { score = score - -1; };
if (state->hand[player][i] == estate) { score = score + 1; };
if (state->hand[player][i] == duchy) { score = score + 3; };
if (state->hand[player][i] == province) { score = score + 6; };
if (state->hand[player][i] == great_hall) { score = score + 1; };
if (state->hand[player][i] == gardens) { score = score + ( fullDeckCount(player, 0, state) / 10 ); };
}
//score from discard
for (i = 0; i < state->discardCount[player]; i++)
{
if (state->discard[player][i] == curse) { score = score - 1; };
if (state->discard[player][i] == estate) { score = score + 1; };
if (state->discard[player][i] == duchy) { score = score + 3; };
if (state->discard[player][i] == province) { score = score + 6; };
if (state->discard[player][i] == great_hall) { score = score + 1; };
if (state->discard[player][i] == gardens) { score = score + ( fullDeckCount(player, 0, state) / 10 ); };
}
//score from deck
for (i = 0; i < state->discardCount[player]; i++)
{
if (state->deck[player][i] == curse) { score = score - 1; };
if (state->deck[player][i] == estate) { score = score + 1; };
if (state->deck[player][i] == duchy) { score = score + 3; };
if (state->deck[player][i] == province) { score = score + 6; };
if (state->deck[player][i] == great_hall) { score = score + 1; };
if (state->deck[player][i] == gardens) { score = score + ( fullDeckCount(player, 0, state) / 10 ); };
}
return score;
}
int getWinners(int players[MAX_PLAYERS], struct gameState *state) {
int i;
int j;
int highScore;
int currentPlayer;
//get score for each player
for (i = 0; i < MAX_PLAYERS; i++)
{
//set unused player scores to -9999
if (i >= state->numPlayers)
{
players[i] = -9999;
}
else
{
players[i] = scoreFor (i, state);
}
}
//find highest score
j = 0;
for (i = 0; i < MAX_PLAYERS; i++)
{
if (players[i] > players[j])
{
j = i;
}
}
highScore = players[j];
//add 1 to players who had less turns
currentPlayer = whoseTurn(state);
for (i = 0; i < MAX_PLAYERS; i++)
{
if ( players[i] == highScore && i > currentPlayer )
{
players[i]++;
}
}
//find new highest score
j = 0;
for (i = 0; i < MAX_PLAYERS; i++)
{
if ( players[i] > players[j] )
{
j = i;
}
}
highScore = players[j];
//set winners in array to 1 and rest to 0
for (i = 0; i < MAX_PLAYERS; i++)
{
if ( players[i] == highScore )
{
players[i] = 1;
}
else
{
players[i] = 0;
}
}
return 0;
}
int drawCard(int player, struct gameState *state)
{ int count;
int deckCounter;
if (state->deckCount[player] <= 0){//Deck is empty
//Step 1 Shuffle the discard pile back into a deck
int i;
//Move discard to deck
for (i = 0; i < state->discardCount[player];i++){
state->deck[player][i] = state->discard[player][i];
state->discard[player][i] = -1;
}
state->deckCount[player] = state->discardCount[player];
state->discardCount[player] = 0;//Reset discard
//Shufffle the deck
shuffle(player, state);//Shuffle the deck up and make it so that we can draw
if (DEBUG){//Debug statements
printf("Deck count now: %d\n", state->deckCount[player]);
}
state->discardCount[player] = 0;
//Step 2 Draw Card
count = state->handCount[player];//Get current player's hand count
if (DEBUG){//Debug statements
printf("Current hand count: %d\n", count);
}
deckCounter = state->deckCount[player];//Create a holder for the deck count
if (deckCounter == 0)
return -1;
state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to hand
state->deckCount[player]--;
state->handCount[player]++;//Increment hand count
}
else{
int count = state->handCount[player];//Get current hand count for player
int deckCounter;
if (DEBUG){//Debug statements
printf("Current hand count: %d\n", count);
}
deckCounter = state->deckCount[player];//Create holder for the deck count
state->hand[player][count] = state->deck[player][deckCounter - 1];//Add card to the hand
state->deckCount[player]--;
state->handCount[player]++;//Increment hand count
}
return 0;
}
int getCost(int cardNumber)
{
switch( cardNumber )
{
case curse:
return 0;
case estate:
return 2;
case duchy:
return 5;
case province:
return 8;
case copper:
return 0;
case silver:
return 3;
case gold:
return 6;
case adventurer:
return 6;
case council_room:
return 5;
case feast:
return 4;
case gardens:
return 4;
case mine:
return 5;
case remodel:
return 4;
case smithy:
return 4;
case village:
return 3;
case baron:
return 4;
case great_hall:
return 3;
case minion:
return 5;
case steward:
return 3;
case tribute:
return 5;
case ambassador:
return 3;
case cutpurse:
return 4;
case embargo:
return 2;
case outpost:
return 5;
case salvager:
return 4;
case sea_hag:
return 4;
case treasure_map:
return 4;
}
return -1;
}
int cardEffect(int card, int choice1, int choice2, int choice3, struct gameState *state, int handPos, int *bonus)
{
int i;
int j;
int k;
int index;
int currentPlayer = whoseTurn(state);
int nextPlayer = currentPlayer + 1;
int tributeRevealedCards[2] = {-1, -1};
int drawntreasure=0;
if (nextPlayer > (state->numPlayers - 1)){
nextPlayer = 0;
}
//uses switch to select card and perform actions
switch( card )
{
case adventurer:
return adventurerCard (drawntreasure, state, currentPlayer);
case council_room:
return councilRoomCard (currentPlayer, state, handPos);
case feast:
return feastCard (currentPlayer, state, choice1);
case gardens:
return -1;
case mine:
return mineCard (currentPlayer, state, choice1, choice2, handPos);
case remodel:
return remodelCard (currentPlayer, state, choice1, choice2, handPos);
case smithy:
//+3 Cards
for (i = 0; i < 3; i++)
{
drawCard(currentPlayer, state);
}
//discard card from hand
discardCard(handPos, currentPlayer, state, 0);
return 0;
case village:
//+1 Card
drawCard(currentPlayer, state);
//+2 Actions
state->numActions = state->numActions + 2;
//discard played card from hand
discardCard(handPos, currentPlayer, state, 0);
return 0;
case baron:
state->numBuys++;//Increase buys by 1!
if (choice1 > 0){//Boolean true or going to discard an estate
int p = 0;//Iterator for hand!
int card_not_discarded = 1;//Flag for discard set!
while(card_not_discarded){
if (state->hand[currentPlayer][p] == estate){//Found an estate card!
state->coins += 4;//Add 4 coins to the amount of coins
state->discard[currentPlayer][state->discardCount[currentPlayer]] = state->hand[currentPlayer][p];
state->discardCount[currentPlayer]++;
for (;p < state->handCount[currentPlayer]; p++){
state->hand[currentPlayer][p] = state->hand[currentPlayer][p+1];
}
state->hand[currentPlayer][state->handCount[currentPlayer]] = -1;
state->handCount[currentPlayer]--;
card_not_discarded = 0;//Exit the loop
}
else if (p > state->handCount[currentPlayer]){
if(DEBUG) {
printf("No estate cards in your hand, invalid choice\n");
printf("Must gain an estate if there are any\n");
}
if (supplyCount(estate, state) > 0){
gainCard(estate, state, 0, currentPlayer);
state->supplyCount[estate]--;//Decrement estates
if (supplyCount(estate, state) == 0){
isGameOver(state);
}
}
card_not_discarded = 0;//Exit the loop
}
else{
p++;//Next card
}
}
}
else{
if (supplyCount(estate, state) > 0){
gainCard(estate, state, 0, currentPlayer);//Gain an estate
state->supplyCount[estate]--;//Decrement Estates
if (supplyCount(estate, state) == 0){
isGameOver(state);
}
}
}
return 0;
case great_hall:
//+1 Card
drawCard(currentPlayer, state);
//+1 Actions
state->numActions++;
//discard card from hand
discardCard(handPos, currentPlayer, state, 0);
return 0;
case minion:
//+1 action
state->numActions++;
//discard card from hand
discardCard(handPos, currentPlayer, state, 0);
if (choice1) //+2 coins
{
state->coins = state->coins + 2;
}
else if (choice2) //discard hand, redraw 4, other players with 5+ cards discard hand and draw 4
{
//discard hand
while(numHandCards(state) > 0)
{
discardCard(handPos, currentPlayer, state, 0);
}
//draw 4
for (i = 0; i < 4; i++)
{
drawCard(currentPlayer, state);
}
//other players discard hand and redraw if hand size > 4
for (i = 0; i < state->numPlayers; i++)
{
if (i != currentPlayer)
{
if ( state->handCount[i] > 4 )
{
//discard hand
while( state->handCount[i] > 0 )
{
discardCard(handPos, i, state, 0);
}
//draw 4
for (j = 0; j < 4; j++)
{
drawCard(i, state);
}
}
}
}
}
return 0;
case steward:
if (choice1 == 1)
{
//+2 cards
drawCard(currentPlayer, state);
drawCard(currentPlayer, state);
}
else if (choice1 == 2)
{
//+2 coins
state->coins = state->coins + 2;
}
else
{
//trash 2 cards in hand
discardCard(choice2, currentPlayer, state, 1);
discardCard(choice3, currentPlayer, state, 1);
}
//discard card from hand
discardCard(handPos, currentPlayer, state, 0);
return 0;
case tribute:
if ((state->discardCount[nextPlayer] + state->deckCount[nextPlayer]) <= 1){
if (state->deckCount[nextPlayer] > 0){
tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1];
state->deckCount[nextPlayer]--;
}
else if (state->discardCount[nextPlayer] > 0){
tributeRevealedCards[0] = state->discard[nextPlayer][state->discardCount[nextPlayer]-1];
state->discardCount[nextPlayer]--;
}
else{
//No Card to Reveal
if (DEBUG){
printf("No cards to reveal\n");
}
}
}
else{
if (state->deckCount[nextPlayer] == 0){
for (i = 0; i < state->discardCount[nextPlayer]; i++){
state->deck[nextPlayer][i] = state->discard[nextPlayer][i];//Move to deck
state->deckCount[nextPlayer]++;
state->discard[nextPlayer][i] = -1;
state->discardCount[nextPlayer]--;
}
shuffle(nextPlayer,state);//Shuffle the deck
}
tributeRevealedCards[0] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1];
state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1;
state->deckCount[nextPlayer]--;
tributeRevealedCards[1] = state->deck[nextPlayer][state->deckCount[nextPlayer]-1];
state->deck[nextPlayer][state->deckCount[nextPlayer]--] = -1;
state->deckCount[nextPlayer]--;
}
if (tributeRevealedCards[0] == tributeRevealedCards[1]){//If we have a duplicate card, just drop one
state->playedCards[state->playedCardCount] = tributeRevealedCards[1];
state->playedCardCount++;
tributeRevealedCards[1] = -1;
}
for (i = 0; i <= 2; i ++){
if (tributeRevealedCards[i] == copper || tributeRevealedCards[i] == silver || tributeRevealedCards[i] == gold){//Treasure cards
state->coins += 2;
}
else if (tributeRevealedCards[i] == estate || tributeRevealedCards[i] == duchy || tributeRevealedCards[i] == province || tributeRevealedCards[i] == gardens || tributeRevealedCards[i] == great_hall){//Victory Card Found
drawCard(currentPlayer, state);
drawCard(currentPlayer, state);
}
else{//Action Card
state->numActions = state->numActions + 2;
}
}
return 0;
case ambassador:
j = 0; //used to check if player has enough cards to discard
if (choice2 > 2 || choice2 < 0)
{
return -1;
}
if (choice1 == handPos)
{
return -1;
}
for (i = 0; i < state->handCount[currentPlayer]; i++)
{
if (i != handPos && i == state->hand[currentPlayer][choice1] && i != choice1)
{
j++;
}
}
if (j < choice2)
{
return -1;
}
if (DEBUG)
printf("Player %d reveals card number: %d\n", currentPlayer, state->hand[currentPlayer][choice1]);
//increase supply count for choosen card by amount being discarded
state->supplyCount[state->hand[currentPlayer][choice1]] += choice2;
//each other player gains a copy of revealed card
for (i = 0; i < state->numPlayers; i++)
{
if (i != currentPlayer)
{
gainCard(state->hand[currentPlayer][choice1], state, 0, i);
}
}
//discard played card from hand
discardCard(handPos, currentPlayer, state, 0);
//trash copies of cards returned to supply
for (j = 0; j < choice2; j++)
{
for (i = 0; i < state->handCount[currentPlayer]; i++)
{
if (state->hand[currentPlayer][i] == state->hand[currentPlayer][choice1])
{
discardCard(i, currentPlayer, state, 1);
break;
}
}
}
return 0;
case cutpurse:
updateCoins(currentPlayer, state, 2);
for (i = 0; i < state->numPlayers; i++)
{
if (i != currentPlayer)
{
for (j = 0; j < state->handCount[i]; j++)
{
if (state->hand[i][j] == copper)
{
discardCard(j, i, state, 0);
break;
}
if (j == state->handCount[i])
{
for (k = 0; k < state->handCount[i]; k++)
{
if (DEBUG)
printf("Player %d reveals card number %d\n", i, state->hand[i][k]);
}
break;
}
}
}
}
//discard played card from hand
discardCard(handPos, currentPlayer, state, 0);
return 0;
case embargo:
//+2 Coins
state->coins = state->coins + 2;
//see if selected pile is in play
if ( state->supplyCount[choice1] == -1 )
{
return -1;
}
//add embargo token to selected supply pile
state->embargoTokens[choice1]++;
//trash card
discardCard(handPos, currentPlayer, state, 1);
return 0;
case outpost:
//set outpost flag
state->outpostPlayed++;
//discard card
discardCard(handPos, currentPlayer, state, 0);
return 0;
case salvager:
//+1 buy
state->numBuys++;
if (choice1)
{
//gain coins equal to trashed card
state->coins = state->coins + getCost( handCard(choice1, state) );
//trash card
discardCard(choice1, currentPlayer, state, 1);
}
//discard card
discardCard(handPos, currentPlayer, state, 0);
return 0;
case sea_hag:
for (i = 0; i < state->numPlayers; i++){
if (i != currentPlayer){
state->discard[i][state->discardCount[i]] = state->deck[i][state->deckCount[i]-1];
state->discardCount[i]++;
state->deck[i][state->deckCount[i]-1] = curse;//Top card now a curse
}
}
return 0;
case treasure_map:
//search hand for another treasure_map
index = -1;
for (i = 0; i < state->handCount[currentPlayer]; i++)
{
if (state->hand[currentPlayer][i] == treasure_map && i != handPos)
{
index = i;
break;
}
}
if (index > -1)
{
//trash both treasure cards
discardCard(handPos, currentPlayer, state, 1);
discardCard(index, currentPlayer, state, 1);
//gain 4 Gold cards
for (i = 0; i < 4; i++)
{
gainCard(gold, state, 1, currentPlayer);
}
//return success
return 1;
}
//no second treasure_map found in hand
return -1;
}
return -1;
}
int discardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag)
{
//if card is not trashed, added to Played pile
if (trashFlag < 1)
{
//add card to played pile
state->playedCards[state->playedCardCount] = state->hand[currentPlayer][handPos];
state->playedCardCount++;
}
//set played card to -1
state->hand[currentPlayer][handPos] = -1;
//remove card from player's hand
if ( handPos == (state->handCount[currentPlayer] - 1) ) //last card in hand array is played
{
//reduce number of cards in hand
state->handCount[currentPlayer]--;
}
else if ( state->handCount[currentPlayer] == 1 ) //only one card in hand
{
//reduce number of cards in hand
state->handCount[currentPlayer]--;
}
else
{
//replace discarded card with last card in hand
state->hand[currentPlayer][handPos] = state->hand[currentPlayer][ (state->handCount[currentPlayer] - 1)];
//set last card to -1
state->hand[currentPlayer][state->handCount[currentPlayer] - 1] = -1;
//reduce number of cards in hand
state->handCount[currentPlayer]--;
}
return 0;
}
int gainCard(int supplyPos, struct gameState *state, int toFlag, int player)
{
//Note: supplyPos is enum of choosen card
//check if supply pile is empty (0) or card is not used in game (-1)
if ( supplyCount(supplyPos, state) < 1 )
{
return -1;
}
//added card for [whoseTurn] current player:
// toFlag = 0 : add to discard
// toFlag = 1 : add to deck
// toFlag = 2 : add to hand
if (toFlag == 1)
{
state->deck[ player ][ state->deckCount[player] ] = supplyPos;
state->deckCount[player]++;
}
else if (toFlag == 2)
{
state->hand[ player ][ state->handCount[player] ] = supplyPos;
state->handCount[player]++;
}
else
{
state->discard[player][ state->discardCount[player] ] = supplyPos;
state->discardCount[player]++;
}
//decrease number in supply pile
state->supplyCount[supplyPos]--;
return 0;
}
int updateCoins(int player, struct gameState *state, int bonus)
{
int i;
//reset coin count
state->coins = 0;
//add coins for each Treasure card in player's hand
for (i = 0; i < state->handCount[player]; i++)
{
if (state->hand[player][i] == copper)
{
state->coins += 1;
}
else if (state->hand[player][i] == silver)
{
state->coins += 2;
}
else if (state->hand[player][i] == gold)
{
state->coins += 3;
}
}
//add bonus
state->coins += bonus;
return 0;
}
//end of dominion.c
int adventurerCard (int drawntreasure, struct gameState *state, int currentPlayer) {
int z = 0;
int temphand[MAX_HAND];
int cardDrawn;
int i;
while(drawntreasure<2){
if (state->deckCount[currentPlayer] <1){//if the deck is empty we need to shuffle discard and add to deck
for (i = 0; i < state->discardCount[currentPlayer]; i++){
state->hand[currentPlayer][i] =
state->discard[currentPlayer][i];
state->discard[currentPlayer][i] = 0;
}
state->handCount[currentPlayer] =
state->discardCount[currentPlayer];
state->discardCount[currentPlayer] = 0;
shuffle(currentPlayer, state);
}
drawCard(currentPlayer, state);
cardDrawn = state->hand[currentPlayer][state->handCount[currentPlayer]-1];//top card of hand is most recently drawn card.
if (cardDrawn == copper || cardDrawn == silver || cardDrawn == gold)
drawntreasure++;
else{
temphand[z]=cardDrawn;
state->handCount[currentPlayer]--; //this should just remove the top card (the most recently drawn one).
z++;
}
}
while(z-1>=0){
state->discard[currentPlayer][state->discardCount[currentPlayer]++]=temphand[z-1]; // discard all cards in play that have been drawn
z=z-1;
}
return 0;
}
int councilRoomCard (int currentPlayer, struct gameState *state, int handPos) {
int i;
//+4 Cards
for (i = 0; i < 4; i++) {
drawCard(currentPlayer, state);
}
//+1 Buy
state->numBuys++;
//Each other player draws a card
for (i = 0; i < state->numPlayers; i++) {
if ( i != currentPlayer ) {
drawCard(i, state);
}
}
//put played card in played card pile
discardCard(handPos, currentPlayer, state, 0);
return 0;
}
int feastCard (int currentPlayer, struct gameState *state, int choice1) {
int temphand[MAX_HAND];
int i;
int x;
//gain card with cost up to 5
//Backup hand
for (i = 0; i <= state->handCount[currentPlayer]; i++){
temphand[i] = state->hand[currentPlayer][i];//Backup card
state->hand[currentPlayer][i] = -1;//Set to nothing
}
//Backup hand
//Update Coins for Buy
updateCoins(currentPlayer, state, 5);
x = 1;//Condition to loop on
while( x == 1) {//Buy one card
if (supplyCount(choice1, state) <= 0){
if (DEBUG)
printf("None of that card left, sorry!\n");
if (DEBUG){
printf("Cards Left: %d\n", supplyCount(choice1, state));
}
}
else if (state->coins < getCost(choice1)){
printf("That card is too expensive!\n");
if (DEBUG){
printf("Coins: %d < %d\n", state->coins, getCost(choice1));
}
}
else{
if (DEBUG){
printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]);
}
gainCard(choice1, state, 0, currentPlayer);//Gain the card
x = 0;//No more buying cards
if (DEBUG){
printf("Deck Count: %d\n", state->handCount[currentPlayer] + state->deckCount[currentPlayer] + state->discardCount[currentPlayer]);
}
}
}
//Reset Hand
for (i = 0; i <= state->handCount[currentPlayer]; i++){
state->hand[currentPlayer][i] = temphand[i];
temphand[i] = -1;
}
//Reset Hand
return 0;
}
int mineCard (int currentPlayer, struct gameState *state, int choice1, int choice2, int handPos) {
int i;
int j;
j = state->hand[currentPlayer][choice1]; //store card we will trash
if (state->hand[currentPlayer][choice1] < copper || state->hand[currentPlayer][choice1] > gold)
{
return -1;
}
if (choice2 > treasure_map || choice2 < curse)
{
return -1;
}
if ( (getCost(state->hand[currentPlayer][choice1]) + 3) > getCost(choice2) )
{
return -1;
}
gainCard(choice2, state, 2, currentPlayer);
//discard card from hand
discardCard(handPos, currentPlayer, state, 0);
//discard trashed card
for (i = 0; i < state->handCount[currentPlayer]; i++)
{
if (state->hand[currentPlayer][i] == j)
{
discardCard(i, currentPlayer, state, 0);
break;
}
}
return 0;
}
int remodelCard (int currentPlayer, struct gameState *state, int choice1, int choice2, int handPos) {
int i;
int j;
j = state->hand[currentPlayer][choice1]; //store card we will trash
if ( (getCost(state->hand[currentPlayer][choice1]) + 2) > getCost(choice2) )
{
return -1;
}
gainCard(choice2, state, 0, currentPlayer);
//discard card from hand
discardCard(handPos, currentPlayer, state, 0);
//discard trashed card
for (i = 0; i < state->handCount[currentPlayer]; i++)
{
if (state->hand[currentPlayer][j] == j) //Note: changed from [i]
{
discardCard(i, currentPlayer, state, 0);
break;
}
}
return 0;
}
| [
"minner.paul@gmail.com"
] | minner.paul@gmail.com |
5f276c889afb5c8eef45b1ba9ebf65168cbc8fd3 | 2485f380b5e32ee950fb84e3ae4e1698e7c7eeb2 | /rt-smart/kernel/bsp/imx6ull/libs/lvgl/driver/lv_port_disp.c | 241d4c05bee04b35fad6065ee0127e6a99b5c560 | [
"Apache-2.0"
] | permissive | lkdingbao/rt_smart_imx6ull | e3ccade131125d92bced1bb3cabe963af7b393f8 | 4d9879e3d543a4e4ddd4b73ce0d30668127f5c5a | refs/heads/master | 2023-04-20T18:05:40.788109 | 2021-05-01T05:07:41 | 2021-05-01T05:07:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 5,810 | c | /**
* @file lv_port_disp_templ.c
*
*/
/*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/
#if 1
/*********************
* INCLUDES
*********************/
#include "lv_port_disp.h"
#include "bsp_lcdapi.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static void disp_init(void);
static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
#if LV_USE_GPU
static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
const lv_area_t * fill_area, lv_color_t color);
#endif
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_port_disp_init(void)
{
/*-------------------------
* Initialize your display
* -----------------------*/
disp_init();
/*-----------------------------
* Create a buffer for drawing
*----------------------------*/
/* LVGL requires a buffer where it internally draws the widgets.
* Later this buffer will passed your display drivers `flush_cb` to copy its content to your display.
* The buffer has to be greater than 1 display row
*
* There are three buffering configurations:
* 1. Create ONE buffer with some rows:
* LVGL will draw the display's content here and writes it to your display
*
* 2. Create TWO buffer with some rows:
* LVGL will draw the display's content to a buffer and writes it your display.
* You should use DMA to write the buffer's content to the display.
* It will enable LVGL to draw the next part of the screen to the other buffer while
* the data is being sent form the first buffer. It makes rendering and flushing parallel.
*
* 3. Create TWO screen-sized buffer:
* Similar to 2) but the buffer have to be screen sized. When LVGL is ready it will give the
* whole frame to display. This way you only need to change the frame buffer's address instead of
* copying the pixels.
* */
static lv_disp_buf_t draw_buf;
static uint32_t frame_swap_buf[2][LV_HOR_RES_MAX*LV_VER_RES_MAX];
lv_disp_buf_init(&draw_buf, &frame_swap_buf[0], &frame_swap_buf[1], LV_HOR_RES_MAX*LV_VER_RES_MAX);
/*-----------------------------------
* Register the display in LVGL
*----------------------------------*/
lv_disp_drv_t disp_drv; /*Descriptor of a display driver*/
lv_disp_drv_init(&disp_drv); /*Basic initialization*/
/*Set up the functions to access to your display*/
/*Set the resolution of the display*/
disp_drv.hor_res = _g_lcd_info.width;
disp_drv.ver_res = _g_lcd_info.height;
/*Used to copy the buffer's content to the display*/
disp_drv.flush_cb = disp_flush;
/*Set a display buffer*/
disp_drv.buffer = &draw_buf;
#if LV_USE_GPU
/*Optionally add functions to access the GPU. (Only in buffered mode, LV_VDB_SIZE != 0)*/
/*Blend two color array using opacity*/
disp_drv.gpu_blend_cb = gpu_blend;
/*Fill a memory array with a color*/
disp_drv.gpu_fill_cb = gpu_fill;
#endif
/*Finally register the driver*/
lv_disp_drv_register(&disp_drv);
}
/**********************
* STATIC FUNCTIONS
**********************/
/* Initialize your display and the required peripherals. */
static void disp_init(void)
{
/*You code here*/
}
/* Flush the content of the internal buffer the specific area on the display
* You can use DMA or any hardware acceleration to do this operation in the background but
* 'lv_disp_flush_ready()' has to be called when finished. */
static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
lcd_fill((uint32_t*)color_p, (uint32_t*)_g_lcd_info.fb_virt, _g_lcd_info.width*_g_lcd_info.height*_g_lcd_info.pxsz);
/* IMPORTANT!!!
* Inform the graphics library that you are ready with the flushing*/
lv_disp_flush_ready(disp_drv);
}
/*OPTIONAL: GPU INTERFACE*/
#if LV_USE_GPU
/* If your MCU has hardware accelerator (GPU) then you can use it to blend to memories using opacity
* It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
{
/*It's an example code which should be done by your GPU*/
uint32_t i;
for(i = 0; i < length; i++) {
dest[i] = lv_color_mix(dest[i], src[i], opa);
}
}
/* If your MCU has hardware accelerator (GPU) then you can use it to fill a memory with a color
* It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
const lv_area_t * fill_area, lv_color_t color)
{
/*It's an example code which should be done by your GPU*/
int32_t x, y;
dest_buf += dest_width * fill_area->y1; /*Go to the first line*/
for(y = fill_area->y1; y <= fill_area->y2; y++) {
for(x = fill_area->x1; x <= fill_area->x2; x++) {
dest_buf[x] = color;
}
dest_buf+=dest_width; /*Go to the next line*/
}
}
#endif /*LV_USE_GPU*/
#else /* Enable this file at the top */
/* This dummy typedef exists purely to silence -Wpedantic. */
typedef int keep_pedantic_happy;
#endif
| [
"ytesliang@163.com"
] | ytesliang@163.com |
f8399a4b5ef1c3f7b9f7ccbd2d5c9e71610d0ab7 | 243af6f697c16c54af3613988ddaef62a2b29212 | /firmware/uvc_controller/mbed-os/targets/TARGET_Analog_Devices/TARGET_ADUCM4X50/TARGET_ADUCM4050/api/pinmap.c | e95ca501625a5ae4f9b1b09267b97ac22b382440 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"MIT"
] | permissive | davewhiiite/uvc | 0020fcc99d279a70878baf7cdc5c02c19b08499a | fd45223097eed5a824294db975b3c74aa5f5cc8f | refs/heads/main | 2023-05-29T10:18:08.520756 | 2021-06-12T13:06:40 | 2021-06-12T13:06:40 | 376,287,264 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 4,254 | c | /*******************************************************************************
* Copyright (c) 2010-2017 Analog Devices, Inc.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Modified versions of the software must be conspicuously marked as such.
* - This software is licensed solely and exclusively for use with processors
* manufactured by or for Analog Devices, Inc.
* - This software may not be combined or merged with other code in any manner
* that would cause the software to become subject to terms and conditions
* which differ from those listed here.
* - Neither the name of Analog Devices, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* - The use of this software may or may not infringe the patent rights of one
* or more patent holders. This license does not release you from the
* requirement that you obtain separate licenses from these patent holders
* to use this software.
*
* THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES, INC. AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-
* INFRINGEMENT, TITLE, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ANALOG DEVICES, INC. OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, DAMAGES ARISING OUT OF
* CLAIMS OF INTELLECTUAL PROPERTY RIGHTS INFRINGEMENT; PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
******************************************************************************/
#include "mbed_assert.h"
#include "pinmap.h"
#include "mbed_error.h"
#include "PinNames.h"
#include "adi_gpio.h"
void pin_function(PinName pin, int function)
{
// pin is composed of port and pin
// function is the function number (the mux selection number shifted by the pin value
// and written to pin mux register, each pin mux takes 2 bits hence multiplying by 2)
MBED_ASSERT(pin != (PinName)NC);
uint8_t port = pin >> GPIO_PORT_SHIFT;
uint32_t cfg_reg, mask;
volatile uint32_t *pGPIO_CFG;
switch (port) {
case 0:
pGPIO_CFG = (volatile uint32_t *)REG_GPIO0_CFG;
break;
case 1:
pGPIO_CFG = (volatile uint32_t *)REG_GPIO1_CFG;
break;
case 2:
pGPIO_CFG = (volatile uint32_t *)REG_GPIO2_CFG;
break;
default:
return;
}
cfg_reg = *pGPIO_CFG;
// clear the corresponding 2 bit field first before writing the function
// bits
mask = ~(3 << (pin * 2));
cfg_reg = cfg_reg & mask | (function << (pin*2));
*pGPIO_CFG = cfg_reg;
}
void pin_mode(PinName pin, PinMode mode)
{
MBED_ASSERT(pin != (PinName)NC);
uint8_t port = pin >> GPIO_PORT_SHIFT;
uint32_t pin_reg_value = 2 ^ (0xFF & pin);
switch (mode) {
case PullNone:
adi_gpio_PullUpEnable((ADI_GPIO_PORT)port, (ADI_GPIO_DATA) pin_reg_value,false);
break;
case PullDown:
case PullUp:
adi_gpio_PullUpEnable((ADI_GPIO_PORT)port, (ADI_GPIO_DATA) pin_reg_value,true);
break;
default:
break;
}
}
| [
"13125501+davewhiiite@users.noreply.github.com"
] | 13125501+davewhiiite@users.noreply.github.com |
0369ec7e7989c9bfef4d09e25ce6d5cfbb78acc1 | 54f352a242a8ad6ff5516703e91da61e08d9a9e6 | /Source Codes/AtCoder/agc011/A/2180127.c | 19db9ab1ca647faad766049b025a4a9e09860608 | [] | no_license | Kawser-nerd/CLCDSA | 5cbd8a4c3f65173e4e8e0d7ed845574c4770c3eb | aee32551795763b54acb26856ab239370cac4e75 | refs/heads/master | 2022-02-09T11:08:56.588303 | 2022-01-26T18:53:40 | 2022-01-26T18:53:40 | 211,783,197 | 23 | 9 | null | null | null | null | WINDOWS-1250 | C | false | false | 942 | c | #include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
typedef long long ll;
int cmp(const void*a,const void*b)
{
return *(ll *)a-*(ll *)b;
}
int main(void)
{
int n,i;
ll c,k;
ll s[101000];
ll count=1,l=1,start;
scanf("%d %lld %lld",&n,&c,&k);
for(i=0;i<n;i++)
scanf("%lld",&s[i]);
qsort(s,n,sizeof(s[0]),cmp);
start=s[0];
for(i=1;i<n;i++)
{
if(s[i]<=(start+k)&&l<c)
l++;
else if(l==c)
{
count++;
l=1;
start=s[i];
}
else if(s[i]>(start+k))
{
count++;
l=1;
start=s[i];
}
}
printf("%lld\n",count);
} ./Main.c: In function ‘main’:
./Main.c:17:4: warning: ignoring return value of ‘scanf’, declared with attribute warn_unused_result [-Wunused-result]
scanf("%d %lld %lld",&n,&c,&k);
^
./Main.c:19:4: warning: ignoring return value of ‘scanf’, declared with attribute warn_unused_result [-Wunused-result]
scanf("%lld",&s[i]);
^ | [
"kwnafi@yahoo.com"
] | kwnafi@yahoo.com |
c14353fd2f4c8378f6d5435225f02b0316f9acdb | dc64327f2ca2be476014c1abb08c950546755880 | /examples/mss-ethernet-mac/pse-mss-mac-mcc-stack/src/modules/mcc_tcpip_lite/dhcp_client.c | 5f72e91c888fdf7ab5bdc1c5f820ebd59c7153c2 | [] | no_license | z1042410188/polarfire-soc-bare-metal-library | 23781e5399991e6dcbb5d78ee2e3ff10cb6dd178 | 78a6b5e82c4b184e6c7ea794185f02f5aa6a1ac5 | refs/heads/master | 2022-09-24T04:59:57.086186 | 2020-06-02T09:44:08 | 2020-06-02T09:44:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 24,638 | c | /**
DHCP v4 client implementation
Company:
Microchip Technology Inc.
File Name:
dhcp_client.c
Summary:
This is the implementation of DHCP client.
Description:
This source file provides the implementation of the DHCP client protocol.
*/
/*
© [2015] Microchip Technology Inc. and its subsidiaries. You may use this
software and any derivatives exclusively with Microchip products.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER EXPRESS,
IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES
OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE, OR
ITS INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION WITH ANY OTHER PRODUCTS, OR
USE IN ANY APPLICATION.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER
RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF
THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT ALLOWED
BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY RELATED TO THIS
SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY
TO MICROCHIP FOR THIS SOFTWARE.
MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE
TERMS.
*/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>
#include <limits.h>
#include "log.h"
#include "ethernet_driver.h"
#include "mac_address.h"
#include "network.h"
#include "udpv4.h"
#include "udpv4_port_handler_table.h"
#include "ipv4.h"
#include "arpv4.h"
#include "dhcp_client.h"
#include "ip_database.h"
#include "lfsr.h"
#ifdef ENABLE_NETWORK_DEBUG
#define logMsg(msg, msgSeverity, msgLogDest) logMessage(msg, LOG_DHCP, msgSeverity, msgLogDest)
#else
#define logMsg(msg, msgSeverity, msgLogDest)
#endif
#define DHCP_HEADER_SIZE 240
/* PMCS: DHCP_PACKET_SIZE is not defined and DHCP_REQUEST_LENGTH is not used... */
#if ( DHCP_PACKET_SIZE & 1)
#define ZERO_PAD_DHCP
#define DHCP_REQUEST_LENGTH (DHCP_PACKET_SIZE + 1)
#else
#undef ZERO_PAD_DHCP
#define DHCP_REQUEST_LENGTH DHCP_PACKET_SIZE
#endif
const char dhcpName[] = DHCP_NAME;
static mac48Address_t ethMAC;
/**
Section: Enumeration Definition
*/
typedef enum
{
DHCP_DISCOVER = 1,
DHCP_OFFER,
DHCP_REQUEST,
DHCP_DECLINE,
DHCP_ACK,
DHCP_NACK,
DHCP_RELEASE,
DHCP_INFORM,
DHCP_FORCERENEW,
DHCP_LEASEQUERY,
DHCP_LEASEUNASSIGNED,
DHCP_LEASEUNKNOWN,
DHCP_LEASEACTIVE,
DHCP_BULKLEASEQUERY,
DHCP_LEASEQUERYDONE
}dhcp_type;
typedef enum
{
SELECTING,
REQUESTING,
RENEWLEASE,
BOUND
}dhcp_rx_client_state;
typedef enum
{
INIT_TIMER,
WAITFORTIMER,
STARTDISCOVER,
STARTREQUEST
}dhcp_timer_client_state;
typedef struct
{
/* option data */
uint32_t dhcpIPAddress;
uint32_t subnetMask;
uint32_t routerAddress;
uint32_t dnsAddress[2]; /* only capture 2 DNS addresses */
uint32_t ntpAddress[2];
uint32_t gatewayAddress;
uint32_t xidValue;
uint32_t t1; /* name per the RFC page 35 */
uint32_t t2; /* name per the specification page 35 */
uint32_t dhcpServerIdentifier;
} dhcp_data_t;
typedef struct
{
/* state data */
dhcp_rx_client_state rxClientState;
dhcp_timer_client_state tmrClientState;
} dhcp_state_t;
dhcp_data_t dhcpData = {0,0,0,{0,0},{0,0},0,0,10,3600,0};
dhcp_state_t dhcpState = {SELECTING,INIT_TIMER};
uint8_t dhcp_request[512]; /* PMCS: Todo need to look at size of buffer */
bool sendRequest(dhcp_type type);
bool sendDHCPDISCOVER(void);
bool sendDHCPDISCOVER(void)
{
dhcpData.dhcpIPAddress = ipdb_getAddress();
dhcpData.xidValue = lfsrWithSeed(ethMAC.mac_array[2]);
dhcpData.xidValue <<= 8;
dhcpData.xidValue |= lfsrWithSeed(ethMAC.mac_array[3]);
dhcpData.xidValue <<= 8;
dhcpData.xidValue |= lfsrWithSeed(ethMAC.mac_array[4]);
dhcpData.xidValue <<= 8;
dhcpData.xidValue |= lfsrWithSeed(ethMAC.mac_array[5]);
return sendRequest(DHCP_DISCOVER);
}
bool sendDHCPREQUEST(void);
bool sendDHCPREQUEST(void)
{
logMsg("requesting", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
return sendRequest(DHCP_REQUEST);
}
bool sendDHCPDECLINE(void);
bool sendDHCPDECLINE(void)
{
return sendRequest(DHCP_DECLINE);
}
bool sendRequest(dhcp_type type)
{
/* creating a DHCP request */
error_msg started;
uint8_t *pkt_ptr = dhcp_request;
started = UDP_Start(dhcp_request, &pkt_ptr, 0xFFFFFFFF, 68, 67);
if(started == NET_SUCCESS)
{
IP_WRITE_LWORD_OUT(pkt_ptr, 0x01010600); /* OP, HTYPE, HLEN, HOPS */
IP_WRITE_LWORD_OUT(pkt_ptr, dhcpData.xidValue); /* XID : made up number... */
IP_WRITE_LWORD_OUT(pkt_ptr, 0x00008000); /* SECS, FLAGS (broadcast) */
if(type == DHCP_REQUEST)
{
IP_WRITE_LWORD_OUT(pkt_ptr, 0);
}
else
{
IP_WRITE_LWORD_OUT(pkt_ptr, dhcpData.dhcpIPAddress); /* CIADDR */
}
IP_WRITE_LWORD_OUT(pkt_ptr, 0); /* YIADDR */
IP_WRITE_LWORD_OUT(pkt_ptr, 0); /* SIADDR */
IP_WRITE_LWORD_OUT(pkt_ptr, 0); /* GIADDR */
IP_MOVE_BYTES_OUT(pkt_ptr, hostMacAddress,6); /* Hardware Address */
IP_WRITE_BYTES_OUT(pkt_ptr, 0, 202); /* 0 padding + 192 bytes of BOOTP padding */
IP_WRITE_LWORD_OUT(pkt_ptr, 0x63825363); /* MAGIC COOKIE - Options to Follow */
/* send the options */
IP_WRITE_BYTE_OUT(pkt_ptr, 12); /* option 12 - DHCP Name */
IP_WRITE_BYTE_OUT(pkt_ptr, strlen(dhcpName));
IP_MOVE_BYTES_OUT(pkt_ptr, dhcpName, strlen(dhcpName));
IP_WRITE_BYTE_OUT(pkt_ptr, 42); /* option 42 - NTP server name */
IP_WRITE_BYTE_OUT(pkt_ptr, 4);
IP_WRITE_LWORD_OUT(pkt_ptr, 0);
IP_WRITE_BYTE_OUT(pkt_ptr, 53); /* option 53 - Request type */
IP_WRITE_BYTE_OUT(pkt_ptr, 1);
IP_WRITE_BYTE_OUT(pkt_ptr, type);
if(type == DHCP_REQUEST)
{
/* option 50 - requested IP address... DO this if we have a valid one to re-request */
IP_WRITE_BYTE_OUT(pkt_ptr, 50);
IP_WRITE_BYTE_OUT(pkt_ptr, 4);
IP_WRITE_LWORD_OUT(pkt_ptr, dhcpData.dhcpIPAddress);
IP_WRITE_BYTE_OUT(pkt_ptr, 54); /* option 54 - Server identifier */
IP_WRITE_BYTE_OUT(pkt_ptr, 4);
IP_WRITE_LWORD_OUT(pkt_ptr, dhcpData.dhcpServerIdentifier); // JIRA: CAE_MCU8-5661
}
//
IP_WRITE_BYTE_OUT(pkt_ptr, 55); /* option 55 - parameter request list */
IP_WRITE_BYTE_OUT(pkt_ptr, 4);
IP_WRITE_BYTE_OUT(pkt_ptr, 1);
IP_WRITE_BYTE_OUT(pkt_ptr, 3);
IP_WRITE_BYTE_OUT(pkt_ptr, 6);
IP_WRITE_BYTE_OUT(pkt_ptr, 15);
//
IP_WRITE_BYTE_OUT(pkt_ptr, 57); /* option 57 - Maximum DHCP Packet */
IP_WRITE_BYTE_OUT(pkt_ptr, 2);
IP_WRITE_WORD_OUT(pkt_ptr, 512);
//
IP_WRITE_BYTE_OUT(pkt_ptr, 61); /* send option 61 (MAC address) */
IP_WRITE_BYTE_OUT(pkt_ptr, 7);
IP_WRITE_BYTE_OUT(pkt_ptr, 1);
IP_MOVE_BYTES_OUT(pkt_ptr, hostMacAddress, 6);
IP_WRITE_BYTE_OUT(pkt_ptr, 255); /* finished */
#ifdef ZERO_PAD_DHCP
UDP_Write8(0); /* add a byte of padding to make the total length even */
#endif
UDP_Send(dhcp_request, (uint16_t)(pkt_ptr - dhcp_request));
return true;
}
return false;
}
void DHCP_init(void)
{
memcpy((uint8_t *) ðMAC, g_tcp_mac->mac_addr, sizeof(g_tcp_mac->mac_addr));
}
void DHCP_Manage(void)
{
static time_t managementTimer = 0;
time_t now;
now = time(0);
if(managementTimer <= now)
{
switch(dhcpState.tmrClientState)
{
case INIT_TIMER:
dhcpData.t1 = 4;
dhcpData.t2 = 2;
dhcpState.tmrClientState = WAITFORTIMER;
break;
case WAITFORTIMER:
if(!ethData.up)
{
dhcpData.t1 = 2;
dhcpData.t2 = 4;
}
if(dhcpData.t1 == 2)
{
ipdb_setAddress(0);
dhcpState.tmrClientState = STARTREQUEST;
}
else
{
dhcpData.t1 --;
}
if(dhcpData.t2 == 2)
{
dhcpState.tmrClientState = STARTDISCOVER;
}
else
{
dhcpData.t2 --;
}
break;
case STARTDISCOVER:
if(sendDHCPDISCOVER())
{
dhcpData.t2 = 10; /* retry in 10 seconds */
dhcpData.t1 = LONG_MAX;
dhcpState.rxClientState = SELECTING;
dhcpState.tmrClientState = WAITFORTIMER;
}
break;
case STARTREQUEST:
if(ethData.up)
{
if(sendDHCPREQUEST())
{
dhcpData.t1 = 15;
if(dhcpState.rxClientState == BOUND )
{
dhcpState.rxClientState = RENEWLEASE;
}
else
{
dhcpState.rxClientState = REQUESTING;
}
dhcpState.tmrClientState = WAITFORTIMER;
}
}
break;
default:
logMsg("why am I at default", LOG_WARNING, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
dhcpState.tmrClientState = INIT_TIMER;
break;
}
}
managementTimer = now + 1;
}
void DHCP_Handler(uint8_t *packet, int16_t length)
{
/* this function gets called by the UDP port handler for port 67 */
uint8_t chaddr[16];
uint8_t messageType=0;
uint8_t temp_byte;
uint16_t temp_word;
uint32_t temp_lword;
uint8_t *pkt_ptr = packet;
uint32_t count;
bool acceptOffers = false;
bool declineOffers = false;
bool acceptNACK = false;
bool acceptACK = false;
uint32_t siaddr;
logMsg("DHCP Handler", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
switch(dhcpState.rxClientState)
{
default:
case SELECTING: /* we can accept offers... drop the rest. */
logMsg("DHCP SELECTING", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
acceptOffers = true;
declineOffers = false;
acceptNACK = false;
acceptACK = false;
break;
case REQUESTING: /* we can accept an ACK or NACK... decline offers and drop the rest */
logMsg("DHCP REQUESTING", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
acceptOffers = false;
declineOffers = true; /* db */
acceptNACK = true;
acceptACK = true;
break;
case RENEWLEASE:
logMsg("DHCP RENEW LEASE", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
acceptOffers = false;
acceptNACK = true;/* a bound lease renewal can have a Nack back */
acceptACK = true;/* a bound lease renewal can have an ack back */
break;
case BOUND: /* drop everything... the timer will pull us out of here. */
logMsg("DHCP BOUND", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
acceptOffers = false;
acceptNACK = false;
acceptACK = false;
break;
}
if(acceptOffers || declineOffers || acceptNACK || acceptACK)
{
dhcp_data_t localData = {0,0,0,{0,0},{0,0},0,0,3600,3600,0};
localData.xidValue = dhcpData.xidValue;
if(length > DHCP_HEADER_SIZE)
{
logMsg("DHCP PROCESSING", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
IP_READ_WORD_IN(temp_word, pkt_ptr);
if(0x0201 == temp_word)
{
IP_READ_BYTE_IN(temp_byte, pkt_ptr);
if(0x06 == temp_byte) /* HLEN - is set to 6 because an Ethernet address is 6 Octets long */
{
IP_READ_BYTE_IN(temp_byte, pkt_ptr); /* HOPS */
IP_READ_LWORD_IN(temp_lword, pkt_ptr);
if(dhcpData.xidValue == temp_lword) /* xid check */
{
IP_READ_WORD_IN(temp_word, pkt_ptr); /* SECS */
IP_READ_WORD_IN(temp_word, pkt_ptr); /* FLAGS */
IP_READ_LWORD_IN(temp_lword, pkt_ptr); /* CIADDR */
IP_READ_LWORD_IN(localData.dhcpIPAddress, pkt_ptr); /* YIADDR */
if((localData.dhcpIPAddress != SPECIAL_IPV4_BROADCAST_ADDRESS) && (localData.dhcpIPAddress != LOCAL_HOST_ADDRESS))
{
IP_READ_LWORD_IN(siaddr, pkt_ptr); /* SIADDR */
if((siaddr != SPECIAL_IPV4_BROADCAST_ADDRESS) && (siaddr != LOCAL_HOST_ADDRESS))
{
IP_READ_LWORD_IN(temp_lword, pkt_ptr); /* GIADDR */
IP_MOVE_BYTES_IN(chaddr, pkt_ptr, sizeof(chaddr)); /* read chaddr */
if(memcmp(chaddr, &hostMacAddress.s, 6)== 0 || memcmp(chaddr, &broadcastMAC.s, 6)== 0 || (strlen((char *)chaddr)== 0)) // only compare 6 bytes of MAC address.
{
pkt_ptr += 64; /* drop SNAME */
pkt_ptr += 128; /* drop the filename */
IP_READ_LWORD_IN(temp_lword, pkt_ptr);
if(temp_lword == 0x63825363)
{
length -= (int16_t)DHCP_HEADER_SIZE;
while(length>0)
{
/* options are here!!! */
uint8_t option, optionLength;
IP_READ_BYTE_IN(option, pkt_ptr);
IP_READ_BYTE_IN(optionLength, pkt_ptr);
length -= (int16_t)(2U + optionLength);
switch(option)
{
case 1: /* subnet mask */
logMsg("DHCP option 1", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
IP_READ_LWORD_IN(localData.subnetMask, pkt_ptr);
break;
case 3: /* router */
logMsg("DHCP option 3", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
IP_READ_LWORD_IN(localData.routerAddress, pkt_ptr);
break;
case 6: // DNS List
count = 0;
logMsg("DHCP option 6", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
while(optionLength >= 4)
{
IP_READ_LWORD_IN(temp_lword, pkt_ptr);
if(count < 2)
localData.dnsAddress[count++] = temp_lword;
optionLength -= (uint8_t)4U;
}
break;
case 42: // NTP server
count = 0;
logMsg("DHCP option 42", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
while(optionLength >= 4)
{
IP_READ_LWORD_IN(temp_lword, pkt_ptr);
if(count < 2)
localData.ntpAddress[count++] = temp_lword;
optionLength -= (uint8_t)4U;
}
break;
case 51: // lease time
logMsg("DHCP option 51", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
if(optionLength >= 4)
{
uint32_t origLeaseTime;
IP_READ_LWORD_IN(origLeaseTime, pkt_ptr);
/* localData.t2 = localData.t1 - 100; // 100 seconds faster for requests */
localData.t1 = origLeaseTime >> 1; /* be default set to 1/2 the lease length */
localData.t2 = localData.t1; /* be default set to 1/2 the lease length */
origLeaseTime = localData.t1 >> 1;
localData.t2 += origLeaseTime;
localData.t2 += origLeaseTime >> 1;
optionLength -= (uint8_t)4U;
}
break;
case 54: /* DHCP server */
logMsg("DHCP option 54", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
IP_READ_LWORD_IN(localData.dhcpServerIdentifier, pkt_ptr);
/* printf("case54:%u\r\n",localData.dhcpServerIdentifier); */
optionLength -= (uint8_t)4U;
break;
case 53:
logMsg("DHCP option 53", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
IP_READ_BYTE_IN(messageType, pkt_ptr);
optionLength -= (uint8_t)1U;
break;
default:
pkt_ptr += optionLength; /* dump any unused bytes */
break;
} /* option switch */
} /* length loop */
} /* magic number test */
else
{
logMsg("DHCP fail Magic Number check", LOG_WARNING, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
}
} /* mac address test */
else
{
logMsg("DHCP fail MAC address check", LOG_WARNING, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
return;
}
} /* SIADDR test */
else
{
logMsg("DHCP fail SIADDR check", LOG_WARNING, (LOG_DEST_CONSOLE));
}
} /* YIADDR test */
else
{
logMsg("DHCP fail YIADDR check", LOG_WARNING, (LOG_DEST_CONSOLE));
}
} /* xid test */
else
{
logMsg("DHCP fail XID check", LOG_WARNING, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
}
} /* HLEN test */
else
{
logMsg("DHCP fail Hardware Length", LOG_WARNING, (LOG_DEST_CONSOLE));
}
} /* 201 test */
else
{
logMsg("DHCP fail 201 check", LOG_WARNING, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
}
} /* short packet test */
else
{
logMsg("DHCP fail short packet check", LOG_WARNING, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
}
switch(messageType)
{
case DHCP_OFFER:
if(acceptOffers)
{
dhcpData = localData; /* capture the data in the offer */
sendDHCPREQUEST();
dhcpState.rxClientState = REQUESTING;
}
if(declineOffers)
{
sendDHCPDECLINE();
}
break;
case DHCP_ACK:
if(acceptACK)
{
dhcpData.t1 = localData.t1;
dhcpData.t2 = localData.t2;
ipdb_setAddress(dhcpData.dhcpIPAddress);
ipdb_setDNS(0,dhcpData.dnsAddress[0]);
ipdb_setDNS(1,dhcpData.dnsAddress[1]);
ipdb_setRouter(dhcpData.routerAddress);
ipdb_setGateway(dhcpData.gatewayAddress);
ipdb_setSubNetMASK(dhcpData.subnetMask);
if(dhcpData.ntpAddress[0])
{
ipdb_setNTP(0,dhcpData.ntpAddress[0]);
if(dhcpData.ntpAddress[1])
{
ipdb_setNTP(1,dhcpData.ntpAddress[1]);
}
}
dhcpState.rxClientState = BOUND;
}
break;
case DHCP_NACK:
if(acceptNACK)
{
dhcpData.t1 = 4;
dhcpData.t2 = 2;
dhcpState.rxClientState = SELECTING;
}
break;
default:
break;
}
} /* accept types test */
else
{
logMsg("DHCP fail accept types check", LOG_INFO, (LOG_DEST_CONSOLE|LOG_DEST_ETHERNET));
}
}
#if 0
/* PMCS: Todo - not used? */
void DHCP_WriteZeros(uint16_t length)
{
while(length--)
{
UDP_Write8(0);
}
}
#endif
| [
"cyril.jean@microchip.com"
] | cyril.jean@microchip.com |
ed0855fb7302f29f7e5019e5ea0c4d4c5305165a | a955a6034ff1a1f6cfd0ca8206a3d01117bfbd3f | /Filter_PD/Tests/Benchmarking/old_benchmark_tests.h | 2f0e2ab80516de858e02363cd457cdd5deff4153 | [
"Apache-2.0"
] | permissive | adam-morrison/Comparing_Filters | 4e15965493ad17856b902ce9387a6b81e85262b2 | 8a2f2d3c664678723e48a11a3fab5da2a2c8e4cb | refs/heads/master | 2022-12-02T23:10:10.231017 | 2020-06-07T09:21:24 | 2020-06-07T09:21:24 | 277,656,020 | 0 | 0 | Apache-2.0 | 2020-07-06T21:50:04 | 2020-07-06T21:50:03 | null | UTF-8 | C | false | false | 2,989 | h | /*
//
// Created by tomer on 10/29/19.
//
#ifndef CLION_CODE_OLD_BENCHMARK_TESTS_H
#define CLION_CODE_OLD_BENCHMARK_TESTS_H
//
// Created by tomer on 4/15/19.
//
#include <set>
#include <fstream>
#include "../Global_functions/basic_functions.h"
#include "../PD/PD.h"
#include "../Safe_PD/safe_PD.h"
#define MIN_ELEMENT_LENGTH 8
#define MIN_CHAR_RANGE 32
#define MIN_LENGTH_RANGE 8
string rand_string(int minLength, int charsNum, int numOfDiffLength = MIN_LENGTH_RANGE);
void set_init(size_t size, set<string> *mySet, int minLength = MIN_ELEMENT_LENGTH, int charsNum = MIN_CHAR_RANGE);
bool naive_true_positive_validation(GeneralBF *vbp, size_t reps);
bool empty_true_negative_validation(GeneralBF *vbp, size_t reps);
ostream &validate(size_t expected_el_num, double eps, size_t insertion_num, size_t lookup_reps, bool is_adaptive,
bool call_adapt, ostream &os);
ostream &
validate_adaptiveness(size_t expected_el_num, double eps, size_t insertion_num, size_t lookup_reps, size_t fp_reps,
ostream &os);
*/
/**
*
* @param n maximal number of elements expected to be in the filter.
* @param eps expected false positive rate
* @param insertion_reps Actual number of elements that will be inserted.
* @param lookup_reps Number of lookups that will be performed.
* @param is_adaptive Is filter adaptive.
* @param call_adapt Determine whether adapt operation will be called or not (only on adaptive filter)
* @param remote_opt An attempt to improve Remote use.
* @param naive_check Performs test without using the Remote.
* @param to_cout Print the full test results to cout or to files in Output directory.
*//*
void auto_rates(size_t n, double eps, size_t insertion_reps, size_t lookup_reps, bool is_adaptive, bool call_adapt,
bool remote_opt, bool naive_check, Remote_name remote_name, bool to_cout);
ostream &
rates(size_t n, double eps, size_t insertion_reps, size_t lookup_reps, bool is_adaptive, bool call_adapt,
Remote_name remote_name, ostream &os);
ostream &
rates_attempt(size_t n, double eps, size_t insertion_reps, size_t lookup_reps, bool is_adaptive, bool call_adapt,
Remote_name remote_name, ostream &os);
ostream &
naive_rates(size_t n, double eps, size_t insertion_reps, size_t lookup_reps, bool is_adaptive, bool call_adapt,
Remote_name remote_name, ostream &os);
ostream &
test_printer(size_t n, double eps, size_t lookups_num, bool is_adaptive, double set_ratio, int *counter,
double member_set_init_time,
double nom_set_init_time, double init_time, double insertion_time, double lookup_time,
double total_run_time, ostream &os);
ostream &counter_printer(ostream &os, int *counter);
double get_relative_deviation(double act_res, double exp_res);
string test_get_output_file_path(bool is_adaptive, bool call_adapt);
size_t test_count_files(const string &path);
#endif //CLION_CODE_OLD_BENCHMARK_TESTS_H
*/
| [
"jokereven@gmail.com"
] | jokereven@gmail.com |
c343e8bb1cd220c306e96a3d3b5d5002cf2cff75 | 93f635bbef282f8dcfbbfa682aec2c206e68f7b7 | /beginner_level_and_uva/13-3a-ii.c | e5f97af4c4e284d6babbcade47b2973648b2cbb2 | [] | no_license | Alimurrazi/Programming | 6ba828ea15e640f70311fab33cce1a6e9190db45 | cd4354616596d6c7865f4ccd835b1c0712f41c45 | refs/heads/master | 2023-08-01T14:23:31.342302 | 2021-09-14T03:53:50 | 2021-09-14T03:53:50 | 107,748,091 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 356 | c | #include<stdio.h>
#include<string.h>
int main()
{
int ara[30];
char str[30];
char str1[30];
int length,i,j,count=0;
gets(str);
length=strlen(str);
strcpy(str1,str);
for(i=0;i<length;i++)
{
if (str[i]=='a'||str[i]=='e'||str[i]=='i'||str[i]=='o'||str[i]=='u')
ara[i]++;}
printf(" %d",ara);
//str1[i]=str[i];
//count++;}
return 0;
}
| [
"alimurrazi570@gmail.com"
] | alimurrazi570@gmail.com |
0fed038d2656a986ee24403e3d4fe1f384a2715a | 71238494c72380e6f605724228aa8499b3e108b8 | /MPI/Es7.c | 6d666b567ca0da9ada7cb4f9385da198424c938d | [] | no_license | AndreaGiardini/Cineca_MPI_2013 | be0e6c1da8180bfaedac475858d98db2e2b5ad24 | 71023c7de56c2449b5f6c240af61a39e3577d724 | refs/heads/master | 2021-01-18T14:22:18.987694 | 2013-11-20T16:30:32 | 2013-11-20T16:30:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,175 | c | /*
* Task 0 initializes a variable to a given value,then modifies the variable
* (for example, by calculating the square of its value) and finally broadcasts it to all the others tasks.
*/
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include <string.h>
#include <math.h>
int main (int argc, char * argv[]){
int me, nprocs;
double value;
/* Initialize MPI environment */
MPI_Init(&argc, &argv) ;
/* Get the size of the MPI_COMM_WORLD communicator */
MPI_Comm_size(MPI_COMM_WORLD, &nprocs) ;
/* Get my rank... */
MPI_Comm_rank(MPI_COMM_WORLD, &me) ;
/* Parameters check */
if(argc != 2){
if(me==0){
printf("\nThis program needs one parameter\n\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
return 1;
}
/* Rank 0 has a different behaviour */
if(me==0){
/* Rank 0 process */
value = atof(argv[1]);
value = sqrt(value);
} else {
/* All others */
value=0;
}
/* Broadcast */
printf("Process %d: had %f\n", me, value);
MPI_Bcast(&value, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
printf("Process %d: received %f\n", me, value);
/* Finalize MPI environment */
MPI_Finalize() ;
return 0;
}
| [
"contact@andreagiardini.com"
] | contact@andreagiardini.com |
16684a209671c46648d92c2df9a3371fcfbbf724 | a556c07ecfa1031dae46fd3433762941ceca68b1 | /kungfu/skill/backup/zimu-zhen/dinhun.c | 760432bbec855c0e8cba9da7dd1c911404573958 | [] | no_license | yqzcabao/pkuxkx-utf8 | 53c3c24f4e3a9125372bca72b6a4b10aa6293a7f | 0eaf237c9970795a51aa4cc04b5b762003300cbd | refs/heads/main | 2023-04-01T21:16:23.894845 | 2021-04-09T13:33:24 | 2021-04-09T13:33:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,288 | c | // 定魂 子母针特殊技
#include <ansi.h>
inherit F_SSERVER;
int perform(object me, object target)
{
object weapon;
string msg;
if( !target ) target = offensive_target(me);
if( !target
|| !target->is_character()
|| !me->is_fighting(target) )
return notify_fail("「定魂」只能对战斗中的对手使用。\n");
if (!objectp(weapon = me->query_temp("weapon"))
|| (string)weapon->query("skill_type") != "throwing")
return notify_fail("你使用的武器不对。\n");
if( target->is_busy() )
return notify_fail(target->name() + "已经神志恍惚，放胆攻击吧.\n");
if( (int)me->query_skill("zimu-zhen", 1) < 30 )
return notify_fail("你的子母针法不够娴熟，不会使用「定魂」。\n");
msg = HIG "$N双目突然泛过怪异绿光,中指在不易察觉间微微一动,一点银星悄无声息打向$n眉心。\n"NOR;
me->start_busy(1);
if( random(me->query("combat_exp")) > (int)target->query("combat_exp")/2 ) {
msg += HIR " 结果$p被$P的「定魂」打个正着，瞬间神志开始迷糊起来！\n" NOR;
target->start_busy( (int)me->query_skill("zimu-zhen") / 20 );
} else {
msg += "可是$p在千钧一发之间闪身躲过了这一击。\n" NOR;
}
message_vision(msg, me, target);
return 1;
}
| [
"i@oiuv.cn"
] | i@oiuv.cn |
29644e415697a78b9b77cfd574c2105549e2f831 | 969e05f2195804d343db2835e5c2456c205f6984 | /Robocon_Test/Hardware/Robocon_TIM.h | 651788b7bf599ea2560c31db8fc3979996f8349d | [] | no_license | HanayoKoizumi/Robo2017 | d88965d27ef49665e9b56604c09132f0d2489c63 | d065981e26dc242c20fddbc383f3cfc79fabf97f | refs/heads/master | 2020-07-23T01:47:04.558184 | 2016-12-12T13:25:00 | 2016-12-12T13:25:00 | 73,699,918 | 0 | 0 | null | 2016-11-14T11:52:31 | 2016-11-14T11:52:31 | null | UTF-8 | C | false | false | 611 | h | #ifndef __TIM_H__
#define __TIM_H__
#include "stm32f10x.h"
void Quadrature_decode_TIM1_Init(void);
void Quadrature_decode_TIM8_Init(void);
void Quadrature_decode_TIM4_Init(void);
#define Motor1_Z(DUTY) TIM2->CCR3 = DUTY;
#define Motor1_F(DUTY) TIM2->CCR4 = DUTY;
#define Motor2_Z(DUTY) TIM2->CCR1 = DUTY;
#define Motor2_F(DUTY) TIM2->CCR2 = DUTY;
#define Motor3_Z(DUTY) TIM3->CCR1 = DUTY;
#define Motor3_F(DUTY) TIM3->CCR2 = DUTY;
void PWMout_TIM2_TIM3_Init(u16 CCR11, u16 CCR12, u16 CCR21, u16 CCR22, u16 CCR31, u16 CCR32);
void Interrupt_TIM5_Init(void);
extern u16 Encode[3];
#endif
| [
"m_l_w@icloud.com"
] | m_l_w@icloud.com |
9222b8300c93e39e115db94e558bd104978f2fa5 | 5c3ebfa1ff33d6987b64b7f2e41370ce2c0b3f1b | /aws-phone-screen/may31/linked.c | 1352533b14f003ad7b40ef3fa41ed00303d8bf71 | [] | no_license | alpiepho/code_challenges | c10d4a4320a820a43f517c210c7b75db72eeb7de | 058cd29712d443f8334dcd5e933800b9d4ef2bf4 | refs/heads/master | 2020-06-12T19:32:45.929869 | 2020-03-21T16:43:55 | 2020-03-21T16:43:55 | 194,403,400 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 4,438 | c | // gcc linked.c -o runme ; ./runme
// TODO
// given list of numbers:
// - create linked list
// - show linked list
// - insert element to list
// - delete element
// - destroy linked list
#include <stdio.h>
#include <stdlib.h>
//#define NULL 0
struct Node {
int val;
struct Node *next; // single list
};
struct Node *createNode(int value) {
struct Node *node = malloc(sizeof(struct Node));
node->val = value;
node->next = NULL;
return node;
}
struct Node *deleteNode(struct Node *node) {
struct Node *next = node->next;
free(node);
return next;
}
struct Node *createList(int size, int *list) {
int i;
struct Node *linked, *next, *end;
linked = NULL;
for (i = 0; i < size; i++) {
next = createNode(list[i]);
if (linked == NULL) {
linked = next;
end = next; // keep track of end
}
else {
end->next = next;
end = next;
}
}
return linked;
}
void deleteList(struct Node **linked) {
struct Node *p, *last;
p = *linked;
while (p) {
printf("delete %d\n", p->val);
p = deleteNode(p);
}
*linked = NULL;
}
void showList(struct Node *list) {
int i;
struct Node *p;
i = 1;
p = list;
while (p) {
printf("%d: %d\n", i, p->val);
i++;
p = p->next;
}
}
void insertVal(struct Node **linked, int value) {
struct Node *p, *temp;
p = *linked;
// test empty linked
if (!linked || !*linked) {
*linked = createNode(value);
return;
}
temp = createNode(value);
// test if before first node
if (value < (*linked)->val) {
temp->next = (*linked);
*linked = temp;
}
else {
// find node before (p) and node after (next)
p = *linked;
while (p) {
if (value >= p->val) {
if (!p->next) {
// after last node, drop out
p->next = temp;
break;
}
if (value < p->next->val) {
// found slot
temp->next = p->next;
p->next = temp;
break;
}
}
p = p->next;
}
}
}
void removeVal(struct Node **linked, int value) {
struct Node *p, *prev;
// is value the first
if ((*linked)->val == value) {
p = (*linked);
(*linked) = (*linked)->next;
deleteNode(p);
return;
}
prev = *linked;
p = prev->next;
while (p) {
if (p && p->val == value) {
prev->next = p->next;
deleteNode(p);
break;
}
p = p->next;
}
}
int main(void) {
int list[] = { 2, 4, 6, 7, 8, 9 };
struct Node *linked = NULL;
printf("linked.c:\n");
// - create linked list
linked = createList(6, list);
// - show linked list
printf("createList\n");
showList(linked);
// - insert element to list
printf("insertVal\n");
insertVal(&linked, 5);
showList(linked);
// - delete element
printf("removeVal\n");
removeVal(&linked, 2);
showList(linked);
// - destroy linked list
printf("deleteList\n");
deleteList(&linked);
showList(linked);
}
/*
How will you check if Bit5 of a memory mapped register is on or not?
0xE000E034
volatile int *addr = (int *)0xE000E034;
if ((*addr) & 0x00000020) {
// is privaledege
}
Merge two given sorted linked lists into one:
Input:
1 --> 4 --> 5 --> NULL
2 --> 6 --> 8 --> NULL
Output:
1 --> 2 --> 4 --> 5 --> 6 --> 8 --> NULL
struct Node {
int val;
struct Node *next;
}
struct Node *base = 0;
struct Node *next = 0;
void add_to_result_list( struct Node* node) {
if (!base) {
base = node;
next = base;
} else {
next->next = node;
next = node;
}
}
void merge(struct Node *one, struct Node *two) {
struct Node *both, *bPtr;
struct Node *p1, *p2;
p1 = one;
p2 = two;
while (p1 && p2) {
if (p1->val < p2->val) {
add_to_result(p1);
p1 = p1->next;
}
else {
add_to_result(p2);
p2 = p2->next;
}
}
if (!p1 & p2) {
add_to_result(p2);
}
if (p1 & !p2) {
add_to_result(p1);
}
}
*/ | [
"alpiepho@gmail.com"
] | alpiepho@gmail.com |
c96c8ae8c09900a7861cc40c0625924948045aac | 3347ea67ee22543358f3db6e9adb91919ef77f44 | /sim5360/comport.c | b3f42c4165552080919b2a89e3ecb10b67cf6343 | [] | no_license | pcode-world/The-learning-code-of-Unix | 7e59b8c6f7df748ed56cd09a3b56dc9ec7717289 | 17c59192e6786cafd15ea535814530385db2cdd3 | refs/heads/master | 2020-04-26T07:53:12.862398 | 2019-08-06T10:13:01 | 2019-08-06T10:13:01 | 173,406,973 | 1 | 0 | null | null | null | null | UTF-8 | C | false | false | 7,778 | c | #include "comport.h"
comport *initComport()
{
comport *comport_info = NULL;
if((comport_info = (comport *)malloc(sizeof(comport))) == NULL)
{
return NULL;
}
memset(comport_info,0,sizeof(comport));
comport_info->paritybit='N';
comport_info->com_fd = -1;
comport_info->databit = 8;
comport_info->baudrate =115200;
comport_info->stopbit = 1;
comport_info->isopen = 0;
comport_info->flowctl = 1;
return comport_info;
}
void Comport_term(comport *pcomport)
{
if(NULL == pcomport)
{
return;
}
if(!pcomport->isopen)
{
close(pcomport->com_fd);
}
free(pcomport);
pcomport = NULL;
}
int _set_baudrate(struct termios *term,speed_t baudrate)
{
if(cfsetispeed(term,baudrate) < 0)
{
printf("cfsetispeed failure:%s\n",strerror(errno));
return -1;
}
if(cfsetospeed(term,baudrate) < 0)
{
printf("cfsetospeed failure:%s\n",strerror(errno));
return -2;
}
return 0;
}
void set_baudrate(int baudrate,struct termios *term)
{
/*0 50 75 110 134 150 200 300 600 1200 1800 2400 4800 9600 19200 38400 57600 115200 230400*/
switch(baudrate)
{
case 0:
_set_baudrate(term, B0);
break;
case 50:
_set_baudrate(term, B50);
break;
case 75:
_set_baudrate(term, B75);
break;
case 110:
_set_baudrate(term, B110);
break;
case 134:
_set_baudrate(term, B134);
break;
case 150:
_set_baudrate(term, B150);
break;
case 200:
_set_baudrate(term, B200);
break;
case 300:
_set_baudrate(term, B300);
break;
case 600:
_set_baudrate(term, B600);
break;
case 1200:
_set_baudrate(term, B1200);
break;
case 1800:
_set_baudrate(term, B1800);
break;
case 2400:
_set_baudrate(term, B2400);
break;
case 4800:
_set_baudrate(term, B4800);
break;
case 9600:
_set_baudrate(term, B9600);
break;
case 19200:
_set_baudrate(term, B19200);
break;
case 38400:
_set_baudrate(term, B38400);
break;
case 57600:
_set_baudrate(term, B57600);
break;
case 115200:
_set_baudrate(term, B115200);
break;
case 230400:
_set_baudrate(term, B230400);
break;
default:
_set_baudrate(term, B115200);
break;
}
}
void set_data_bit(int databit,struct termios *term)
{
term->c_cflag &= ~CSIZE;
switch (databit)
{
case 8:
term->c_cflag |= CS8;
break;
case 7:
term->c_cflag |= CS7;
break;
case 6:
term->c_cflag |= CS6;
break;
case 5:
term->c_cflag |= CS5;
break;
default:
term->c_cflag |= CS8;
break;
}
}
void set_parity(char paritybit,struct termios *term)
{
switch (paritybit)
{
case 'N':
case 'n':
/* no parity check */
term->c_cflag &= ~PARENB;
break;
case 'E':
case 'e':
/* 偶检验 */
term->c_cflag |= PARENB;
term->c_cflag &= ~PARODD;
break;
case 'O':
case 'o':
/* 奇校验 */
term->c_cflag |= PARENB;
term->c_cflag |= PARODD;
break;
default:
/* no parity check */
term->c_cflag &= ~PARENB;
break;
}
}
void set_flowctr(struct termios *term,int c_flow)
{
switch(c_flow)
{
case 0://不进行流控制
term->c_cflag &= ~CRTSCTS;
break;
case 1://进行硬件流控制
term->c_cflag |= CRTSCTS;
break;
case 2://进行软件流控制
term->c_cflag |= IXON|IXOFF|IXANY;
break;
default:
term->c_cflag &= ~CRTSCTS;
}
}
void set_stopbit(int stopbit,struct termios *term)
{
if (2 == stopbit)
{
term->c_cflag |= CSTOPB; /* 2 stop bits */
}
else
{
term->c_cflag &= ~CSTOPB; /* 1 stop bit */
}
}
int setComport(comport *p_comport,struct termios *term)
{
term->c_oflag &= ~OPOST;
term->c_cflag |= CLOCAL | CREAD;//用于本地连接和接收使用
term->c_oflag = 0; //输出模式
term->c_lflag = 0; //不激活终端模式
set_stopbit(p_comport->stopbit,term);
set_parity(p_comport->paritybit,term);
set_data_bit(p_comport->databit,term);
set_baudrate(p_comport->baudrate,term);
set_flowctr(term,p_comport->flowctl);
tcflush(p_comport->com_fd,TCIOFLUSH);
if((tcsetattr(p_comport->com_fd,TCSANOW,term)) != 0)
{
printf("tcsetattr failure:%s\n",strerror(errno));
return -1;
}
printf("set comport ok!\n");
//printf("The details are printed below\n");
//system("sudo sudo stty -F /dev/ttyUSB0 -a");
return 0;
}
int openComport(comport *p_comport,struct termios *old_term)
{
struct termios new_term;
int serial_fd = -1;
if((NULL == p_comport) && (NULL == old_term))
{
return -1;
}
if(p_comport->isopen)
{
closeComport(p_comport,old_term);
}
if((serial_fd = open(p_comport->path,O_RDWR | O_NOCTTY | O_NDELAY)) < 0)
{
printf("open a serialport failure:%s\n",strerror(errno));
return -1;
}
if(isatty(serial_fd) == 0)
{
printf("open fd is not a terminal device\n");
close(serial_fd);
return -1;
}
p_comport->com_fd = serial_fd;
p_comport->isopen = 1;
if(tcgetattr(serial_fd,old_term) < 0)
{
printf("tcgetattr failure:%s\n",strerror(errno));
return -3;
}
memset(&new_term,0,sizeof(new_term));
if(tcgetattr(serial_fd,&new_term) < 0)
{
printf("tcgetattr failure:%s\n",strerror(errno));
return -3;
}
setComport(p_comport,&new_term);
return 0;
}
int readComport(int fd,char *buff,int buffsize)
{
struct timeval time;
fd_set rfds;
int rv = -1;
int ret;
FD_ZERO(&rfds);
FD_SET(fd,&rfds);
time.tv_sec = 30;
time.tv_usec = 0;
if(buff == NULL)
{
printf("Cannot pass in null pointer\n");
return -1;
}
if((ret = select(fd+1,&rfds,NULL,NULL,&time)) < 0)
{
printf("select failure:%s\n",strerror(errno));
return -1;
}
else if(ret == 0)
{
printf("select get time out\n");
return -1;
}
else
{
memset(buff,0,buffsize);
if((rv = read(fd,buff,buffsize)) < 0)
{
printf("read failure:%s\n",strerror(errno));
return -1;
}
}
return rv;
}
int writeComport(int fd,char *buff,int buffsize)
{
int rv = -1;
if(buff == NULL)
{
printf("Cannot pass in null pointer\n");
return -1;
}
if((rv = write(fd,buff,buffsize)) < 0)
{
printf("write failure:%s\n",strerror(errno));
return -1;
}
usleep(10*1000);
return rv;
}
int closeComport(comport *pcomport,struct termios *old_term)
{
if(pcomport == NULL && old_term == NULL)
{
return -1;
}
tcflush(pcomport->com_fd,TCIOFLUSH);
if((tcsetattr(pcomport->com_fd,TCSANOW,old_term)) != 0)
{
printf("Set to the original property failure:%s\n",strerror(errno));
return -1;
}
pcomport->isopen = 0;
close(pcomport->com_fd);
free(pcomport);
return 0;
}
int readComport_notime(int fd,char *buff,int buffsize)
{
fd_set rfds;
int rv = -1;
int ret;
FD_ZERO(&rfds);
FD_SET(fd,&rfds);
if(buff == NULL)
{
printf("Cannot pass in null pointer\n");
return -1;
}
memset(buff,0,buffsize);
if((ret = select(fd+1,&rfds,NULL,NULL,NULL)) < 0)
{
printf("select failure:%s\n",strerror(errno));
return -1;
}
else if(ret == 0)
{
printf("select get time out\n");
return -1;
}
else
{
if((rv = read(fd,buff,buffsize)) < 0)
{
printf("read failure:%s\n",strerror(errno));
return -1;
}
}
return rv;
}
| [
"547124558@qq.com"
] | 547124558@qq.com |
14d71faadf002285065e29edae6e3c04dd323fc8 | ba14b9b4fbc663ef9aa877e935f05d00a53b0318 | /Microcontroller/FRDM KL25Z/FRDM_KL25Z_Shell_Test/Generated_Code/BitIoLdd1.h | 597b74391a23ced35cf567df53c592597519c6d0 | [] | no_license | ItsKev/PREN | 0fb62c2b61ec2b79eadfdd7f9df37d96d1d492ec | f95546b8461f09ab142b854c6b9d2ff1fda2e62c | refs/heads/master | 2018-07-15T13:18:57.875788 | 2018-07-03T16:55:46 | 2018-07-03T16:55:46 | 106,662,436 | 2 | 1 | null | null | null | null | UTF-8 | C | false | false | 10,202 | h | /* ###################################################################
** This component module is generated by Processor Expert. Do not modify it.
** Filename : BitIoLdd1.h
** Project : FRDM_KL25Z_Shell_Test
** Processor : MKL25Z128VLK4
** Component : BitIO_LDD
** Version : Component 01.033, Driver 01.03, CPU db: 3.00.000
** Compiler : GNU C Compiler
** Date/Time : 2018-03-06, 23:01, # CodeGen: 4
** Abstract :
** The HAL BitIO component provides a low level API for unified
** access to general purpose digital input/output pins across
** various device designs.
**
** RTOS drivers using HAL BitIO API are simpler and more
** portable to various microprocessors.
** Settings :
** Component name : BitIoLdd1
** Pin for I/O : TSI0_CH11/PTB18/TPM2_CH0
** Pin signal :
** Direction : Output
** Initialization :
** Init. direction : Output
** Init. value : 0
** Auto initialization : yes
** Safe mode : yes
** Contents :
** Init - LDD_TDeviceData* BitIoLdd1_Init(LDD_TUserData *UserDataPtr);
** GetVal - bool BitIoLdd1_GetVal(LDD_TDeviceData *DeviceDataPtr);
** ClrVal - void BitIoLdd1_ClrVal(LDD_TDeviceData *DeviceDataPtr);
** SetVal - void BitIoLdd1_SetVal(LDD_TDeviceData *DeviceDataPtr);
** NegVal - void BitIoLdd1_NegVal(LDD_TDeviceData *DeviceDataPtr);
**
** Copyright : 1997 - 2014 Freescale Semiconductor, Inc.
** All Rights Reserved.
**
** Redistribution and use in source and binary forms, with or without modification,
** are permitted provided that the following conditions are met:
**
** o Redistributions of source code must retain the above copyright notice, this list
** of conditions and the following disclaimer.
**
** o Redistributions in binary form must reproduce the above copyright notice, this
** list of conditions and the following disclaimer in the documentation and/or
** other materials provided with the distribution.
**
** o Neither the name of Freescale Semiconductor, Inc. nor the names of its
** contributors may be used to endorse or promote products derived from this
** software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
** DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
** ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
** ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
** http: www.freescale.com
** mail: support@freescale.com
** ###################################################################*/
/*!
** @file BitIoLdd1.h
** @version 01.03
** @brief
** The HAL BitIO component provides a low level API for unified
** access to general purpose digital input/output pins across
** various device designs.
**
** RTOS drivers using HAL BitIO API are simpler and more
** portable to various microprocessors.
*/
/*!
** @addtogroup BitIoLdd1_module BitIoLdd1 module documentation
** @{
*/
#ifndef __BitIoLdd1_H
#define __BitIoLdd1_H
/* MODULE BitIoLdd1. */
/* Include shared modules, which are used for whole project */
#include "PE_Types.h"
#include "PE_Error.h"
#include "PE_Const.h"
#include "IO_Map.h"
/* Include inherited beans */
#include "IO_Map.h"
#include "GPIO_PDD.h"
#include "Cpu.h"
#ifdef __cplusplus
extern "C" {
#endif
/*! Peripheral base address of a device allocated by the component. This constant can be used directly in PDD macros. */
#define BitIoLdd1_PRPH_BASE_ADDRESS 0x400FF040U
/*! Device data structure pointer used when auto initialization property is enabled. This constant can be passed as a first parameter to all component's methods. */
#define BitIoLdd1_DeviceData ((LDD_TDeviceData *)PE_LDD_GetDeviceStructure(PE_LDD_COMPONENT_BitIoLdd1_ID))
/* Methods configuration constants - generated for all enabled component's methods */
#define BitIoLdd1_Init_METHOD_ENABLED /*!< Init method of the component BitIoLdd1 is enabled (generated) */
#define BitIoLdd1_GetVal_METHOD_ENABLED /*!< GetVal method of the component BitIoLdd1 is enabled (generated) */
#define BitIoLdd1_ClrVal_METHOD_ENABLED /*!< ClrVal method of the component BitIoLdd1 is enabled (generated) */
#define BitIoLdd1_SetVal_METHOD_ENABLED /*!< SetVal method of the component BitIoLdd1 is enabled (generated) */
#define BitIoLdd1_NegVal_METHOD_ENABLED /*!< NegVal method of the component BitIoLdd1 is enabled (generated) */
/* Definition of implementation constants */
#define BitIoLdd1_MODULE_BASE_ADDRESS FPTB_BASE_PTR /*!< Name of macro used as the base address */
#define BitIoLdd1_PORTCONTROL_BASE_ADDRESS PORTB_BASE_PTR /*!< Name of macro used as the base address */
#define BitIoLdd1_PORT_MASK 0x00040000U /*!< Mask of the allocated pin from the port */
/*
** ===================================================================
** Method : BitIoLdd1_Init (component BitIO_LDD)
*/
/*!
** @brief
** Initializes the device. Allocates memory for the device data
** structure, allocates interrupt vectors and sets interrupt
** priority, sets pin routing, sets timing, etc. If the "Enable
** in init. code" is set to "yes" value then the device is also
** enabled(see the description of the Enable() method). In this
** case the Enable() method is not necessary and needn't to be
** generated.
** @param
** UserDataPtr - Pointer to the user or
** RTOS specific data. This pointer will be
** passed as an event or callback parameter.
** @return
** - Pointer to the dynamically allocated private
** structure or NULL if there was an error.
*/
/* ===================================================================*/
LDD_TDeviceData* BitIoLdd1_Init(LDD_TUserData *UserDataPtr);
/*
** ===================================================================
** Method : BitIoLdd1_GetVal (component BitIO_LDD)
*/
/*!
** @brief
** Returns the input/output value. If the direction is [input]
** then the input value of the pin is read and returned. If the
** direction is [output] then the last written value is read
** and returned (see <Safe mode> property for limitations).
** This method cannot be disabled if direction is [input].
** @param
** DeviceDataPtr - Device data structure
** pointer returned by <Init> method.
** @return
** - Input or output value. Possible values:
** <false> - logical "0" (Low level)
** <true> - logical "1" (High level)
*/
/* ===================================================================*/
bool BitIoLdd1_GetVal(LDD_TDeviceData *DeviceDataPtr);
/*
** ===================================================================
** Method : BitIoLdd1_ClrVal (component BitIO_LDD)
*/
/*!
** @brief
** Clears (set to zero) the output value. It is equivalent to
** the [PutVal(FALSE)]. This method is available only if the
** direction = _[output]_ or _[input/output]_.
** @param
** DeviceDataPtr - Pointer to device data
** structure returned by <Init> method.
*/
/* ===================================================================*/
void BitIoLdd1_ClrVal(LDD_TDeviceData *DeviceDataPtr);
/*
** ===================================================================
** Method : BitIoLdd1_SetVal (component BitIO_LDD)
*/
/*!
** @brief
** Sets (to one) the output value. It is equivalent to the
** [PutVal(TRUE)]. This method is available only if the
** direction = _[output]_ or _[input/output]_.
** @param
** DeviceDataPtr - Pointer to device data
** structure returned by <Init> method.
*/
/* ===================================================================*/
void BitIoLdd1_SetVal(LDD_TDeviceData *DeviceDataPtr);
/*
** ===================================================================
** Method : BitIoLdd1_NegVal (component BitIO_LDD)
*/
/*!
** @brief
** Negates (inverts) the output value. It is equivalent to the
** [PutVal(!GetVal())]. This method is available only if the
** direction = _[output]_ or _[input/output]_.
** @param
** DeviceDataPtr - Pointer to device data
** structure returned by <Init> method.
*/
/* ===================================================================*/
void BitIoLdd1_NegVal(LDD_TDeviceData *DeviceDataPtr);
/* END BitIoLdd1. */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif
/* ifndef __BitIoLdd1_H */
/*!
** @}
*/
/*
** ###################################################################
**
** This file was created by Processor Expert 10.3 [05.09]
** for the Freescale Kinetis series of microcontrollers.
**
** ###################################################################
*/
| [
"buri@github.com"
] | buri@github.com |
34020f3bcdb83587c9b18405c019e1b1f29b69f0 | 7197b89cd690dea9114928cbbc84a1c5213eedb8 | /cdg/cdginc-locosto/p_l1test.h | daae1b2230a13ff5cd94c52fd143d2f779031277 | [] | no_license | brchiu/citrine | fe29b7a86ca45b8c32c00c5bef8c78a7643ccfc4 | 8f63a2e98841e53fa1d54f2cc0b0b6cd90c42093 | refs/heads/master | 2021-04-07T06:56:38.171840 | 2016-11-26T01:03:01 | 2016-11-26T01:03:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 10,671 | h | /*
+--------------------------------------------------------------------------+
| PROJECT : PROTOCOL STACK |
| FILE : p_l1test.h |
| SOURCE : "sap\l1test.pdf" |
| LastModified : "2003-06-06" |
| IdAndVersion : "8010.148.03.003" |
| SrcFileTime : "Thu Nov 29 09:44:08 2007" |
| Generated by CCDGEN_2.5.5A on Thu Sep 25 09:18:53 2014 |
| !!DO NOT MODIFY!!DO NOT MODIFY!!DO NOT MODIFY!! |
+--------------------------------------------------------------------------+
*/
/* PRAGMAS
* PREFIX : L1TEST
* COMPATIBILITY_DEFINES : NO
* ALWAYS_ENUM_IN_VAL_FILE: NO
* ENABLE_GROUP: NO
* CAPITALIZE_TYPENAME: NO
*/
#ifndef P_L1TEST_H
#define P_L1TEST_H
#define CDG_ENTER__P_L1TEST_H
#define CDG_ENTER__FILENAME _P_L1TEST_H
#define CDG_ENTER__P_L1TEST_H__FILE_TYPE CDGINC
#define CDG_ENTER__P_L1TEST_H__LAST_MODIFIED _2003_06_06
#define CDG_ENTER__P_L1TEST_H__ID_AND_VERSION _8010_148_03_003
#define CDG_ENTER__P_L1TEST_H__SRC_FILE_TIME _Thu_Nov_29_09_44_08_2007
#include "CDG_ENTER.h"
#undef CDG_ENTER__P_L1TEST_H
#undef CDG_ENTER__FILENAME
#include "p_l1test.val"
#include "p_mphc.h"
#include "p_mac.h"
/*
* End of substructure section, begin of primitive definition section
*/
#ifndef __T_L1TEST_CALL_MPHC_READ_DCCH__
#define __T_L1TEST_CALL_MPHC_READ_DCCH__
/*
*
* CCDGEN:WriteStruct_Count==1679
*/
typedef struct
{
U8 chn_mode; /*< 0: 1> Channel mode */
U8 _align0; /*< 1: 1> alignment */
U8 _align1; /*< 2: 1> alignment */
U8 _align2; /*< 3: 1> alignment */
} T_L1TEST_CALL_MPHC_READ_DCCH;
#endif
#ifndef __T_L1TEST_RETURN_MPHC_READ_DCCH__
#define __T_L1TEST_RETURN_MPHC_READ_DCCH__
/*
*
* CCDGEN:WriteStruct_Count==1680
*/
typedef struct
{
T_l2_frame l2_frame; /*< 0: 24> layer 2 frame (type defined in "p_mphc.h") */
} T_L1TEST_RETURN_MPHC_READ_DCCH;
#endif
#ifndef __T_L1TEST_CALL_MPHC_DCCH_DOWNLINK__
#define __T_L1TEST_CALL_MPHC_DCCH_DOWNLINK__
/*
*
* CCDGEN:WriteStruct_Count==1681
*/
typedef struct
{
T_l2_frame l2_frame; /*< 0: 24> layer 2 frame (type defined in "p_mphc.h") */
U8 valid_flag; /*< 24: 1> Valid flag for received data */
U8 _align0; /*< 25: 1> alignment */
U8 _align1; /*< 26: 1> alignment */
U8 _align2; /*< 27: 1> alignment */
} T_L1TEST_CALL_MPHC_DCCH_DOWNLINK;
#endif
#ifndef __T_L1TEST_RETURN_MPHC_DCCH_DOWNLINK__
#define __T_L1TEST_RETURN_MPHC_DCCH_DOWNLINK__
/*
*
* CCDGEN:WriteStruct_Count==1682
*/
typedef struct
{
U8 dummy; /*< 0: 1> no parameters */
} T_L1TEST_RETURN_MPHC_DCCH_DOWNLINK;
#endif
#ifndef __T_L1TEST_CALL_MPHC_DATA_UL__
#define __T_L1TEST_CALL_MPHC_DATA_UL__
/*
*
* CCDGEN:WriteStruct_Count==1683
*/
typedef struct
{
U8 dummy; /*< 0: 1> no parameters */
} T_L1TEST_CALL_MPHC_DATA_UL;
#endif
#ifndef __T_L1TEST_RETURN_MPHC_DATA_UL__
#define __T_L1TEST_RETURN_MPHC_DATA_UL__
/*
*
* CCDGEN:WriteStruct_Count==1684
*/
typedef struct
{
T_l2_frame l2_frame; /*< 0: 24> layer 2 frame (type defined in "p_mphc.h") */
U16 d_ra_conf; /*< 24: 2> Traffic control register */
U16 d_ra_act; /*< 26: 2> Activity word */
U16 d_ra_statu; /*< 28: 2> Rate adaptation status word for uplink */
U16 d_fax; /*< 30: 2> Fax status and parameter word */
} T_L1TEST_RETURN_MPHC_DATA_UL;
#endif
#ifndef __T_L1TEST_CALL_MPHC_DATA_DL__
#define __T_L1TEST_CALL_MPHC_DATA_DL__
/*
*
* CCDGEN:WriteStruct_Count==1685
*/
typedef struct
{
T_l2_frame l2_frame; /*< 0: 24> layer 2 frame (type defined in "p_mphc.h") */
U16 d_ra_act; /*< 24: 2> Activity word */
U16 d_ra_statd; /*< 26: 2> Rate adaptation status word for downlink */
} T_L1TEST_CALL_MPHC_DATA_DL;
#endif
#ifndef __T_L1TEST_RETURN_MPHC_DATA_DL__
#define __T_L1TEST_RETURN_MPHC_DATA_DL__
/*
*
* CCDGEN:WriteStruct_Count==1686
*/
typedef struct
{
U8 dummy; /*< 0: 1> no parameters */
} T_L1TEST_RETURN_MPHC_DATA_DL;
#endif
#ifndef __T_L1TEST_CALL_MPHP_POWER_CONTROL__
#define __T_L1TEST_CALL_MPHP_POWER_CONTROL__
/*
*
* CCDGEN:WriteStruct_Count==1687
*/
typedef struct
{
U8 assignment_id; /*< 0: 1> Assignment Id */
U8 crc_error; /*< 1: 1> CRC error */
S8 bcch_level; /*< 2: 1> BCCH level */
U8 _align0; /*< 3: 1> alignment */
U16 radio_freq[L1TEST_BURST_PER_BLOCK]; /*< 4: 8> Radio frequency */
S8 burst_level[L1TEST_BURST_PER_BLOCK]; /*< 12: 4> Burst level */
} T_L1TEST_CALL_MPHP_POWER_CONTROL;
#endif
#ifndef __T_L1TEST_RETURN_MPHP_POWER_CONTROL__
#define __T_L1TEST_RETURN_MPHP_POWER_CONTROL__
/*
*
* CCDGEN:WriteStruct_Count==1688
*/
typedef struct
{
U8 pch[L1TEST_MAX_TIMESLOTS]; /*< 0: 8> PCH */
} T_L1TEST_RETURN_MPHP_POWER_CONTROL;
#endif
#ifndef __T_L1TEST_CALL_MPHP_UPLINK__
#define __T_L1TEST_CALL_MPHP_UPLINK__
/*
*
* CCDGEN:WriteStruct_Count==1689
*/
typedef struct
{
U8 assignment_id; /*< 0: 1> Assignment Id */
U8 tx_data_no; /*< 1: 1> Tx data number */
U8 _align0; /*< 2: 1> alignment */
U8 _align1; /*< 3: 1> alignment */
U32 fn; /*< 4: 4> Frame number */
U8 timing_advance_value; /*< 8: 1> Timing advance value */
U8 allocation_exhausted; /*< 9: 1> Allocation exhausted */
U8 _align2; /*< 10: 1> alignment */
U8 _align3; /*< 11: 1> alignment */
} T_L1TEST_CALL_MPHP_UPLINK;
#endif
#ifndef __T_L1TEST_RETURN_MPHP_UPLINK__
#define __T_L1TEST_RETURN_MPHP_UPLINK__
/*
*
* CCDGEN:WriteStruct_Count==1690
*/
typedef struct
{
T_ul_poll_resp ul_poll_resp[4]; /*< 0:128> Uplink Poll Response (type defined in "p_mac.h") */
T_ul_data ul_data[4]; /*<128:240> Uplink Data (type defined in "p_mac.h") */
} T_L1TEST_RETURN_MPHP_UPLINK;
#endif
#ifndef __T_L1TEST_CALL_MPHP_DOWNLINK__
#define __T_L1TEST_CALL_MPHP_DOWNLINK__
/*
*
* CCDGEN:WriteStruct_Count==1691
*/
typedef struct
{
U8 assignment_id; /*< 0: 1> Assignment Id */
U8 _align0; /*< 1: 1> alignment */
U8 _align1; /*< 2: 1> alignment */
U8 _align2; /*< 3: 1> alignment */
U32 fn; /*< 4: 4> Frame number */
U8 _align3; /*< 8: 1> alignment */
U8 _align4; /*< 9: 1> alignment */
U8 _align5; /*< 10: 1> alignment */
U8 c_dl_data; /*< 11: 1> counter */
T_dl_data dl_data[4]; /*< 12:256> Downlink Data (type defined in "p_mac.h") */
U8 rlc_blocks_sent; /*<268: 1> RLC blocks sent */
U8 last_poll_response; /*<269: 1> Last poll response */
U8 _align6; /*<270: 1> alignment */
U8 _align7; /*<271: 1> alignment */
} T_L1TEST_CALL_MPHP_DOWNLINK;
#endif
#ifndef __T_L1TEST_RETURN_MPHP_DOWNLINK__
#define __T_L1TEST_RETURN_MPHP_DOWNLINK__
/*
*
* CCDGEN:WriteStruct_Count==1692
*/
typedef struct
{
U8 dummy; /*< 0: 1> no parameters */
} T_L1TEST_RETURN_MPHP_DOWNLINK;
#endif
#include "CDG_LEAVE.h"
#endif
| [
"falcon@freecalypso.org"
] | falcon@freecalypso.org |
aa9b3681f5c0b65b5378919da596dc93a447ea8a | a7f82fd27bfd4221dac9620cbac38102c4d2d70a | /src/malloc.h | 4b43ae3cb32f38e799a15cbe90ba87508e669411 | [] | no_license | nikolk1/malloc | cc60363527576a07e748f5b1373d3216db62e00d | c397d7e660c39db99e0cdc8c88889ac1d75bc76a | refs/heads/master | 2023-02-03T07:46:42.774461 | 2020-12-23T19:26:16 | 2020-12-23T19:26:16 | 320,859,380 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 699 | h | #include <assert.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <math.h>
struct block_meta
{
size_t size;
struct block_meta *next;
int free;
int magic; // For debugging only. TODO: remove
};
typedef struct block_meta block_meta;
block_meta *get_block_ptr(void *ptr);
block_meta *find_free_block(block_meta **last, size_t size);
block_meta *request_space(block_meta *last, size_t size);
void split_block(size_t req_size, block_meta *block);
void *malloc(size_t size);
void free(void *ptr);
void *realloc(void *ptr, size_t size);
void *calloc(size_t nelem, size_t elsize);
unsigned int align_block_size(size_t block_size);
void merge_consecutive_blocks(); | [
"nikolk202@gmail.com"
] | nikolk202@gmail.com |
56d370c182d0116eea50b4e8aec00b27a73be5ae | 5577f8bb3fb4887388eaf3eb74a922918fbe2436 | /Lab 12/contador0a3/isim/contador0a3_TB_isim_beh.exe.sim/work/contador0a3_TB_isim_beh.exe_main.c | 2d21f1f9d634e035d1a21c2c81a6627d92dcc879 | [] | no_license | mokuzaru/vhdl_labs | 6d295f066ded70ae3db513b2a9c4f433be9cfeb6 | 8dee58e443e8670ea3c6fb433d14e9329cca670e | refs/heads/master | 2020-12-25T14:39:15.272742 | 2016-06-23T12:17:13 | 2016-06-23T12:17:13 | 61,801,105 | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,429 | c | /**********************************************************************/
/* ____ ____ */
/* / /\/ / */
/* /___/ \ / */
/* \ \ \/ */
/* \ \ Copyright (c) 2003-2009 Xilinx, Inc. */
/* / / All Right Reserved. */
/* /---/ /\ */
/* \ \ / \ */
/* \___\/\___\ */
/***********************************************************************/
#include "xsi.h"
struct XSI_INFO xsi_info;
char *IEEE_P_2592010699;
char *STD_STANDARD;
int main(int argc, char **argv)
{
xsi_init_design(argc, argv);
xsi_register_info(&xsi_info);
xsi_register_min_prec_unit(-12);
ieee_p_2592010699_init();
work_a_0745403839_1448934769_init();
work_a_0487815577_2372691052_init();
xsi_register_tops("work_a_0487815577_2372691052");
IEEE_P_2592010699 = xsi_get_engine_memory("ieee_p_2592010699");
xsi_register_ieee_std_logic_1164(IEEE_P_2592010699);
STD_STANDARD = xsi_get_engine_memory("std_standard");
return xsi_run_simulation(argc, argv);
}
| [
"kenny.otoya@pucp.pe"
] | kenny.otoya@pucp.pe |
c78f624e06c447901685b7db15e8ffe2ce01aab9 | e1bc46edbe00f261282cb798eb59a25ad5227eff | /lte/gateway/c/oai/tasks/nas/ies/GprsTimer.h | 746eb26036dea8b0a9b53517a0e364315431e377 | [
"BSD-3-Clause",
"Apache-2.0",
"LicenseRef-scancode-unknown",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | 119Vik/magma-1 | 57f9a69036c742fcfcb97e84c59be78dec650609 | 107a7b374466a837fc0a49b283ba9d6ff1d702e3 | refs/heads/master | 2022-12-14T14:03:53.841221 | 2020-07-24T10:46:09 | 2020-07-24T11:29:37 | 279,833,292 | 0 | 0 | BSD-3-Clause | 2020-07-15T12:12:30 | 2020-07-15T10:05:13 | Go | UTF-8 | C | false | false | 1,814 | h | /*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#ifndef GPRS_TIMER_H_
#define GPRS_TIMER_H_
#include <stdint.h>
#define GPRS_TIMER_MINIMUM_LENGTH 2
#define GPRS_TIMER_MAXIMUM_LENGTH 2
typedef struct GprsTimer_tag {
#define GPRS_TIMER_UNIT_2S 0b000 /* 2 seconds */
#define GPRS_TIMER_UNIT_60S 0b001 /* 1 minute */
#define GPRS_TIMER_UNIT_360S 0b010 /* decihours */
#define GPRS_TIMER_UNIT_0S 0b111 /* deactivated */
uint8_t unit : 3;
uint8_t timervalue : 5;
} GprsTimer;
int encode_gprs_timer(
GprsTimer *gprstimer,
uint8_t iei,
uint8_t *buffer,
uint32_t len);
void dump_gprs_timer_xml(GprsTimer *gprstimer, uint8_t iei);
int decode_gprs_timer(
GprsTimer *gprstimer,
uint8_t iei,
uint8_t *buffer,
uint32_t len);
long gprs_timer_value(GprsTimer *gprstimer);
#endif /* GPRS TIMER_H_ */
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
17b7f66ad043abbeeaa5133f5c7e924951c6ff9d | 6deb2cbeec70ac6eb1aee9496d7c5b07a1d7f7f5 | /Example/Pods/Headers/Public/NIMKit/NIMSessionListCell.h | 917b8a92afd75f2531b6af93747247cdfa42d3d5 | [
"MIT"
] | permissive | hejunm/NIM_iOS_UIKit | 3be6d51ee7849b4a127af9d6f23f876bb6db8f24 | 8d966b47b64ce70f6f6f860b2bcf98cbe51ecb68 | refs/heads/master | 2020-03-31T13:30:25.612628 | 2019-01-28T14:36:14 | 2019-01-28T14:36:14 | 152,258,640 | 0 | 0 | null | 2018-10-09T13:45:53 | 2018-10-09T13:45:52 | null | UTF-8 | C | false | false | 83 | h | ../../../../../NIMKit/NIMKit/Classes/Sections/SessionList/View/NIMSessionListCell.h | [
"jmhe@Ctrip.com"
] | jmhe@Ctrip.com |
6574babbddbabd28263c5527d8e353e3628fe0b7 | 8ad162102111f5f011d9604a9e71854191806778 | /include/widgets/window.h | 0bbd20cce7b94f3315e55ab872fca93095048b5f | [] | no_license | Happy-Ferret/Claro | 4381de909d8735d22adfeba943554c62272a5fbb | ef2ae283ec7a32d5f6cdef7205dcb402f9c9e47b | refs/heads/master | 2021-01-17T05:36:53.261301 | 2015-08-20T22:23:59 | 2015-08-20T22:23:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C | false | false | 3,047 | h | /* Claro Graphics - an abstraction layer for native UI libraries
*
* $Id$
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
* License for the specific language governing rights and limitations
* under the License.
*
* See the LICENSE file for more details.
*/
#ifndef _CLARO_GRAPHICS_WIDGETS_WINDOW_H
#define _CLARO_GRAPHICS_WIDGETS_WINDOW_H
/** \defgroup window_widget_t Window Widget
* \brief The Window Widget
* @{
*/
#define assert_only_window_widget(o,n) assert_type_check( o, n, "claro.graphics.widgets.window" )
#define assert_valid_window_widget(o,n) assert_not_null( o, n, "Window" ); \
assert_only_window_widget( o, n )
typedef struct window_widget_ window_widget_t;
struct layout_;
#define cWindowModalDialog 1
#define cWindowCenterParent 2
#define cWindowNoResizing 4
struct window_widget_
{
widget_t widget;
char title[512];
image_t *icon;
widget_t *menubar;
widget_t *workspace;
int exsp_tools, exsp_status, exsp_init;
};
enum
{
cWindowFixedSize = 1,
};
/* functions */
/**
* \brief Creates a Window widget
*
* \param parent The parent widget of this widget, NOT NULL.
* \param bounds The initial bounds of this widget, or NO_BOUNDS.
* \param flags Widget flags.
* \return A new Window widget object.
*/
CLFEXP object_t *window_widget_create( object_t *parent, bounds_t *bounds, int flags );
/**
* \brief Sets a Window's title
*
* \param w A valid Window widget object
* \param title The new title for the window
*/
CLFEXP void window_set_title( object_t *w, const char *title );
/**
* \brief Makes a window visible
*
* \param w A valid Window widget object
*/
CLFEXP void window_show( object_t *w );
/**
* \brief Makes a window invisible
*
* \param w A valid Window widget object
*/
CLFEXP void window_hide( object_t *w );
/**
* \brief Gives focus to a window
*
* \param w A valid Window widget object
*/
CLFEXP void window_focus( object_t *w );
/**
* \brief Maximises a window
*
* \param w A valid Window widget object
*/
CLFEXP void window_maximise( object_t *w );
/**
* \brief Minimises a window
*
* \param w A valid Window widget object
*/
CLFEXP void window_minimise( object_t *w );
/**
* \brief Restores a window
*
* \param w A valid Window widget object
*/
CLFEXP void window_restore( object_t *w );
/**
* \brief Sets a window's icon
*
* \param w A valid Window widget object
* \param icon A valid Image object
*/
CLFEXP void window_set_icon( object_t *w, image_t *icon );
#define window_maximize window_maximise
#define window_minimize window_minimise
/*\@}*/
#endif
| [
"rumpf_a@web.de"
] | rumpf_a@web.de |
890d190885125c358bb171b8f515899f4e86a61c | 773561dffbed0d900118dc008b9e6d83ff1c7b3a | /ldd1/ldd_practice/dynamic_cdd/dynamic_cdd.mod.c | b479049fc50d35181faafb412f36458d9505dbb9 | [] | no_license | taraninomula/backup | 92fc46c7acb78241b707a1d0fc4ab98e992f34e8 | 3fc56435f0072b2a90ccbe19d58119741c9536c1 | refs/heads/master | 2020-07-23T10:44:21.974756 | 2019-09-20T06:03:41 | 2019-09-20T06:03:41 | 207,532,705 | 3 | 0 | null | null | null | null | UTF-8 | C | false | false | 1,055 | c | #include <linux/module.h>
#include <linux/vermagic.h>
#include <linux/compiler.h>
MODULE_INFO(vermagic, VERMAGIC_STRING);
__visible struct module __this_module
__attribute__((section(".gnu.linkonce.this_module"))) = {
.name = KBUILD_MODNAME,
.init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
.exit = cleanup_module,
#endif
.arch = MODULE_ARCH_INIT,
};
static const struct modversion_info ____versions[]
__used
__attribute__((section("__versions"))) = {
{ 0x25701227, __VMLINUX_SYMBOL_STR(module_layout) },
{ 0x559f5aa, __VMLINUX_SYMBOL_STR(device_destroy) },
{ 0x7485e15e, __VMLINUX_SYMBOL_STR(unregister_chrdev_region) },
{ 0x2b08fecb, __VMLINUX_SYMBOL_STR(class_destroy) },
{ 0x5c5c9ac4, __VMLINUX_SYMBOL_STR(device_create) },
{ 0xb4b7177e, __VMLINUX_SYMBOL_STR(__class_create) },
{ 0x27e1a049, __VMLINUX_SYMBOL_STR(printk) },
{ 0x29537c9e, __VMLINUX_SYMBOL_STR(alloc_chrdev_region) },
};
static const char __module_depends[]
__used
__attribute__((section(".modinfo"))) =
"depends=";
MODULE_INFO(srcversion, "53471C29DD1B3C8DCED822A");
| [
"tarani.nomula@votarytech.com"
] | tarani.nomula@votarytech.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.