hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
sequencelengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
sequencelengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
sequencelengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
c7b91e3142328590d0a305e58709326aa002a521 | 38,426 | cc | C++ | src/paths/AssemblyCleanupTools.cc | bayolau/discovar | 9e472aca13670e40ab2234b89c8afd64875c58bf | [
"MIT"
] | null | null | null | src/paths/AssemblyCleanupTools.cc | bayolau/discovar | 9e472aca13670e40ab2234b89c8afd64875c58bf | [
"MIT"
] | null | null | null | src/paths/AssemblyCleanupTools.cc | bayolau/discovar | 9e472aca13670e40ab2234b89c8afd64875c58bf | [
"MIT"
] | 1 | 2021-11-28T21:35:27.000Z | 2021-11-28T21:35:27.000Z | ///////////////////////////////////////////////////////////////////////////////
// SOFTWARE COPYRIGHT NOTICE AGREEMENT //
// This software and its documentation are copyright (2011) by the //
// Broad Institute. All rights are reserved. This software is supplied //
// without any warranty or guaranteed support whatsoever. The Broad //
// Institute is not responsible for its use, misuse, or functionality. //
///////////////////////////////////////////////////////////////////////////////
// MakeDepend: library OMP
// MakeDepend: cflags OMP_FLAGS
#include "CoreTools.h"
#include "VecUtilities.h"
#include "ParallelVecUtilities.h"
#include "lookup/LookAlign.h"
#include "efasta/EfastaTools.h"
#include "paths/AssemblyCleanupTools.h"
#include "pairwise_aligners/SmithWatBandedA.h"
struct scompare : public std::binary_function<superb,superb,bool>
{
bool operator()( const superb& s1, const superb& s2 ) const
{ return s1.FullLength() > s2.FullLength(); }
};
Assembly::Assembly( const String in_superb_file, const String in_contigs_file, const String in_scaff_graph_file ){
// Loading scaffolds
cout << Date( ) << ": loading superb file" << endl;
ReadSuperbs( in_superb_file, scaffolds_ );
// reading contig information
if ( in_contigs_file.Contains(".efasta") ) {
LoadEfastaIntoStrings(in_contigs_file, efastas_);
fastgs_.resize( efastas_.size() );
for ( size_t i = 0; i < efastas_.size(); i++ )
fastgs_[i] = recfastg( ToString(i), basefastg( efastas_[i] ) );
}else if ( in_contigs_file.Contains(".fastg") ) {
LoadFastg(in_contigs_file, fastgs_);
efastas_.resize( fastgs_.size() );
efasta tmp;
for ( size_t i = 0; i < fastgs_.size(); i++ )
{
tmp.clear();
fastgs_[i].AsEfasta( tmp , fastg_meta::MODE_2);
efastas_[i] = tmp;
}
}
tigMap_.resize( efastas_.size() );
for ( size_t tid = 0; tid != efastas_.size(); tid++ )
tigMap_[tid] = ToString(tid);
scaffMap_.resize( scaffolds_.size() );
for ( int sid = 0; sid < scaffolds_.isize(); sid++ )
scaffMap_[sid] = ToString(sid);
if ( in_scaff_graph_file.nonempty() )
BinaryReader::readFile( in_scaff_graph_file, &SG_ );
else{
SG_.Initialize( scaffolds_.isize() );
}
}
Assembly::Assembly( const vec<superb>& scaffoldsIn, const VecEFasta& efastasIn, const vec<String>* scaffMap, const vec<String>* tigMap, const digraphE<sepdev>* SGin ){
scaffolds_ = scaffoldsIn;
efastas_ = efastasIn;
fastgs_.resize( efastas_.size() );
for ( size_t i = 0; i < efastas_.size(); i++ )
fastgs_[i] = recfastg( ToString(i), basefastg( efastas_[i] ) );
if ( tigMap == 0 ){
tigMap_.resize( efastas_.size() );
for ( size_t tid = 0; tid != efastas_.size(); tid++ )
tigMap_[tid] = ToString(tid);
}else tigMap_ = *tigMap;
if ( scaffMap == 0 ){
scaffMap_.resize( scaffolds_.size() );
for ( int sid = 0; sid < scaffolds_.isize(); sid++ )
scaffMap_[sid] = ToString(sid);
}else scaffMap_ = *scaffMap;
if ( SGin != 0 ){
SG_ = *SGin;
}else{
SG_.Initialize( scaffolds_.isize() );
}
}
Assembly::Assembly( const vec<superb>& scaffoldsIn, const vec<recfastg>& fastgsIn, const vec<String>* scaffMap, const vec<String>* tigMap, const digraphE<sepdev>* SGin ){
scaffolds_ = scaffoldsIn;
fastgs_ = fastgsIn;
efastas_.resize( fastgs_.size() );
efasta tmp;
for ( size_t i = 0; i < fastgs_.size(); i++ )
{
tmp.clear();
fastgs_[i].AsEfasta( tmp , fastg_meta::MODE_2);
efastas_[i] = tmp;
}
if ( tigMap == 0 ){
tigMap_.resize( efastas_.size() );
for ( size_t tid = 0; tid != efastas_.size(); tid++ )
tigMap_[tid] = ToString(tid);
}else tigMap_ = *tigMap;
if ( scaffMap == 0 ){
scaffMap_.resize( scaffolds_.size() );
for ( int sid = 0; sid < scaffolds_.isize(); sid++ )
scaffMap_[sid] = ToString(sid);
}else scaffMap_ = *scaffMap;
if ( SGin != 0 ){
SG_ = *SGin;
}else{
SG_.Initialize( scaffolds_.isize() );
}
}
size_t Assembly::scaffoldsTotLen() const{
size_t len = 0;
for ( size_t is = 0; is < scaffolds_.size(); is++ )
len += scaffolds_[is].FullLength();
return len;
}
size_t Assembly::scaffoldsRedLen() const{
size_t len = 0;
for ( size_t is = 0; is < scaffolds_.size(); is++ )
len += scaffolds_[is].ReducedLength();
return len;
}
size_t Assembly::scaffoldsNtigs() const{
size_t ntigs = 0;
for ( size_t is = 0; is < scaffolds_.size(); is++ )
ntigs += scaffolds_[is].Ntigs();
return ntigs;
}
// check integrity of scafolds and contigs data: contig size in superb == contig size in efasta,
// each contig used once and only once
void Assembly::check_integrity() const{
cout << Date() << ": checking integrity" << endl;
ForceAssertEq( efastas_.size(), fastgs_.size() );
vec<int> tigs_used( efastas_.size(), 0);
for ( size_t i = 0; i < efastas_.size( ); i++ ){
vec<String> s(1);
s[0] = efastas_[i];
ValidateEfastaRecord(s);
ForceAssert( fastgs_[i].IsGapless() );
ForceAssertEq( fastgs_[i].Length1(), efastas_[i].Length1() );
ForceAssertEq( fastgs_[i].MinLength(fastg_meta::MODE_2), efastas_[i].MinLength() );
ForceAssertEq( fastgs_[i].MaxLength(fastg_meta::MODE_2), efastas_[i].MaxLength() );
efasta fe;
fastgs_[i].AsEfasta( fe ,fastg_meta::MODE_2);
basevector b1, b2;
fe.FlattenTo( b1 );
efastas_[i].FlattenTo( b2 );
ForceAssertEq( b1, b2 );
ForceAssertEq( fe.Length1(), efastas_[i].Length1() );
ForceAssertEq( fe.MinLength(), efastas_[i].MinLength() );
ForceAssertEq( fe.MaxLength(), efastas_[i].MaxLength() );
}
for ( size_t si = 0; si < scaffolds_.size(); si++ ){
const superb & s = scaffolds_[si];
ForceAssertGt( s.Ntigs(), 0 );
for ( int tpos = 0; tpos < s.Ntigs(); tpos++ ){
size_t tid = s.Tig(tpos);
ForceAssertLt( tid, efastas_.size() );
if ( efastas_[tid].Length1() != s.Len(tpos) ){
DPRINT5( si, tpos, tid, s.Len(tpos), efastas_[tid].Length1() );
ForceAssertEq( efastas_[tid].Length1(), s.Len(tpos) );
}
tigs_used[tid]++;
}
}
vec<size_t> unused_tigs, overused_tigs;
for ( size_t tid = 0; tid < tigs_used.size(); tid++ ){
if ( tigs_used[tid] == 0 )
unused_tigs.push_back( tid );
else if ( tigs_used[tid] > 1 )
overused_tigs.push_back(tid);
}
if ( unused_tigs.size() > 0 || overused_tigs.size() > 0 ){
if ( unused_tigs.size() > 0 ){
int max_un_size = efastas_.at( unused_tigs[0] ).Length1();
for ( size_t i = 0; i < unused_tigs.size(); i++ )
if ( efastas_.at( unused_tigs[i] ).Length1() > max_un_size )
max_un_size = efastas_.at( unused_tigs[i] ).Length1();
cout << Date() << ": maximum size of unused contig is : " << max_un_size << endl;
}
DPRINT2( unused_tigs.size(), overused_tigs.size() );
ForceAssert( unused_tigs.size() == 0 && overused_tigs.size() == 0 );
}
ForceAssertEq( scaffolds_.isize(), SG_.N() );
return;
}
void Assembly::remove_small_scaffolds(const int min_scaffold_size) {
cout << Date() << ": removing small scaffolds: " << endl;
vec<int> verts_to_remove;
for ( int si = 0; si < scaffolds_.isize(); si++ )
if ( scaffolds_.at(si).ReducedLength() < min_scaffold_size )
verts_to_remove.push_back(si);
remove_scaffolds(verts_to_remove);
}
void Assembly::remove_scaffolds( const vec<Bool>& to_remove ) {
cout << Date() << ": initial number of scaffolds = " << scaffolds_.size() << endl;
ForceAssertEq( scaffolds_.size(), to_remove.size() );
ForceAssertEq( efastas_.size(), fastgs_.size() );
vec<int> verts_to_remove;
for ( size_t i = 0; i < to_remove.size(); i++ )
if ( to_remove[i] ) {
verts_to_remove.push_back(i);
SG_.DeleteEdgesAtVertex( i );
}
EraseIf( scaffolds_, to_remove );
EraseIf( scaffMap_, to_remove );
SG_.RemoveEdgelessVertices( verts_to_remove );
ForceAssertEq( scaffolds_.isize(), SG_.N() );
ForceAssertEq( efastas_.size(), fastgs_.size() );
cout << Date() << ": final number of scaffolds = " << scaffolds_.size() << endl;
}
void Assembly::remove_scaffolds( const vec<int>& s_to_remove ) {
if ( s_to_remove.size() == 0 ) return;
ForceAssertGe( Min(s_to_remove), 0 );
ForceAssertLt( Max(s_to_remove), scaffolds_.isize() );
vec<Bool> to_remove( scaffolds_.size(), False );
for ( size_t i = 0; i < s_to_remove.size(); i++ )
to_remove[ s_to_remove[i] ] = True;
remove_scaffolds( to_remove );
}
void Assembly::remove_contigs( const vec<Bool>& to_remove )
{
ForceAssertEq( efastas_.size(), fastgs_.size() );
vec<int> offsets( efastas_.size(), 0 );
int offset = 0;
for ( size_t tid = 0; tid < efastas_.size(); tid++ ){
if ( to_remove[tid] ){
offsets[tid] = -1;
offset++;
}
else{ offsets[tid] = offset; }
}
ForceAssertEq( offsets.size(), efastas_.size() );
for ( int tid = 0; tid < offsets.isize(); tid++ ){
if ( offsets[tid] > 0 ){
efastas_[ tid - offsets[tid] ] = efastas_[tid];
fastgs_[ tid - offsets[tid] ] = fastgs_[tid];
tigMap_[tid - offsets[tid] ] = tigMap_[tid];
}
}
efastas_.resize( efastas_.size() - offset );
fastgs_.resize( fastgs_.size() - offset );
tigMap_.resize( tigMap_.size() - offset );
ForceAssertEq( efastas_.size(), tigMap_.size() );
for ( size_t si = 0; si < scaffolds_.size(); si++ ){
for ( int tpos = 0; tpos < scaffolds_[si].Ntigs(); tpos++ ){
int tid = scaffolds_[si].Tig(tpos);
if ( offsets[tid] >= 0 ){
int newtid = tid - offsets[tid];
ForceAssertGe( newtid, 0 );
scaffolds_[si].SetTig( tpos, newtid );
}
else{
scaffolds_[si].RemoveTigByPos( tpos );
tpos--;
}
}
}
ForceAssertEq( efastas_.size(), fastgs_.size() );
}
void Assembly::remove_small_contigs( const int min_size_solo, const int min_size_in ){
cout << Date() << ": removing small contigs and renumbering" << endl;
vec<int> offsets( efastas_.size(), 0 );
vec<Bool> tigsToRemove( efastas_.size(), False);
for ( size_t si = 0; si < scaffolds_.size(); si++ ){
if ( scaffolds_[si].Ntigs() == 1 ){
if ( scaffolds_[si].Len(0) < min_size_solo )
tigsToRemove[ scaffolds_[si].Tig(0) ] = True;
}
else{
for ( int tpos = 0; tpos < scaffolds_[si].Ntigs(); tpos++ ){
if ( scaffolds_[si].Len(tpos) < min_size_in )
tigsToRemove[ scaffolds_[si].Tig(tpos) ] = True;
}
}
}
remove_contigs(tigsToRemove);
}
void Assembly::remove_unused_contigs(){
cout << Date() << ": removing unused contigs and renumbering" << endl;
ForceAssertEq( efastas_.size(), fastgs_.size() );
//ForceAssertEq( scaffolds_.isize(), SG_.N() );
vec<int> tigs_used( efastas_.size(), 0);
for ( size_t si = 0; si < scaffolds_.size(); si++ ){
const superb & s = scaffolds_[si];
ForceAssertGt( s.Ntigs(), 0 );
for ( int tpos = 0; tpos < s.Ntigs(); tpos++ ){
size_t tid = s.Tig(tpos);
ForceAssertLt( tid, efastas_.size() );
if ( efastas_[tid].Length1() != s.Len(tpos) ){
DPRINT5( si, tpos, tid, s.Len(tpos), efastas_[tid].Length1() );
ForceAssertEq( efastas_[tid].Length1(), s.Len(tpos) );
}
tigs_used[tid]++;
}
}
size_t unusedCt = 0;
vec<int> offsets( efastas_.size(), 0 );
int offset = 0;
for ( size_t tid = 0; tid < efastas_.size(); tid++ ){
if ( ! tigs_used[tid] ){
offsets[tid] = -1;
offset++;
unusedCt++;
}
else{ offsets[tid] = offset; }
}
cout << Date( ) << ": found " << unusedCt << " unused contigs, removing" << endl;
ForceAssertEq( offsets.size(), efastas_.size() );
for ( int tid = 0; tid < offsets.isize(); tid++ ){
if ( offsets[tid] > 0 ){
efastas_[ tid - offsets[tid] ] = efastas_[tid];
fastgs_[ tid - offsets[tid] ] = fastgs_[tid];
tigMap_[tid - offsets[tid] ] = tigMap_[tid];
}
}
efastas_.resize( efastas_.size() - offset );
fastgs_.resize( fastgs_.size() - offset );
tigMap_.resize( tigMap_.size() - offset );
ForceAssertEq( efastas_.size(), tigMap_.size() );
ForceAssertEq( efastas_.size(), fastgs_.size() );
cout << Date() << ": updating scaffolds tig ids" << endl;
for ( size_t si = 0; si < scaffolds_.size(); si++ ){
for ( int tpos = 0; tpos < scaffolds_[si].Ntigs(); tpos++ ){
int tid = scaffolds_[si].Tig(tpos);
if ( offsets[tid] >= 0 ){
int newtid = tid - offsets[tid];
ForceAssertGe( newtid, 0 );
scaffolds_[si].SetTig( tpos, newtid );
}
else{
scaffolds_[si].RemoveTigByPos( tpos );
tpos--;
}
}
}
cout << Date() << ": done with removing unused contigs" << endl;
}
void Assembly::reorder(){
// Sorting scaffolds according to size and renumbering contigs according
// to sequential appearance in scaffolds
cout << Date() << ": sorting scaffolds" << endl;
vec<int> neworder( scaffolds_.size(), vec<int>::IDENTITY );
SortSync( scaffolds_, neworder, scompare() );
PermuteVec( scaffMap_, neworder );
SG_.ReorderVertices( neworder );
renumber();
}
// renumber all the contigs sequentially according to the scaffold
void Assembly::renumber(){
cout << Date() << ": renumbering contigs for ordered scaffolds" << endl;
vec<String> otigMap;
vec<superb> oscaffolds = scaffolds_;
VecEFasta oefastas;
vec<recfastg> ofastgs;
int cTid = -1;
for ( size_t is = 0; is < scaffolds_.size(); is++ ){
for ( int tpos = 0; tpos < scaffolds_[is].Ntigs(); tpos++ ){
cTid++;
int oTid = scaffolds_[is].Tig(tpos);
oscaffolds.at(is).SetTig( tpos, cTid );
oefastas.push_back( efastas_.at(oTid) );
ofastgs.push_back( fastgs_.at(oTid) );
otigMap.push_back( tigMap_.at(oTid) );
}
}
efastas_.resize(0);
fastgs_.resize(0);
tigMap_.resize(0);
size_t newScaffoldsTotLen = 0, newScaffoldsRedLen = 0;
for ( size_t is = 0; is < scaffolds_.size(); is++ ){
newScaffoldsTotLen += scaffolds_[is].FullLength();
newScaffoldsRedLen += scaffolds_[is].ReducedLength();
}
scaffolds_ = oscaffolds;
oscaffolds.resize(0);
efastas_ = oefastas;
fastgs_ = ofastgs;
oefastas.resize(0);
ofastgs.resize(0);
tigMap_ = otigMap;
}
struct sData{
sData() : AmbEventCount_(0), MaxAmbCount_(0), RedLen_(0), MinRedLen_(0), MaxRedLen_(0),
FullLen_(0), MinFullLen_(0), MaxFullLen_(0) {};
int AmbEventCount_, MaxAmbCount_;
int RedLen_, MinRedLen_, MaxRedLen_;
int FullLen_, MinFullLen_, MaxFullLen_;
basevector seq_, minseq_, maxseq_;
basevector seq_rc_, minseq_rc_, maxseq_rc_;
};
void Assembly::dedup( const Bool Exact ) {
// Remove duplicate scaffolds.
cout << Date() << ": removing duplicate scaffolds: " << endl;
cout << Date() << ": initial number of scaffolds = " << scaffolds_.size() << endl;
// cononicalize efastas
VecEFasta cefastas( efastas_.size() );
VecEFasta cefastas_rc( efastas_.size() );
for ( size_t ci = 0; ci < efastas_.size(); ci++ ){
efastas_[ci].Canonicalize( cefastas[ci] );
ValidateEfastaRecord( cefastas[ci] );
efasta eseq_rc = efastas_[ci];
eseq_rc.ReverseComplement();
eseq_rc.Canonicalize( cefastas_rc[ci] );
ValidateEfastaRecord( cefastas_rc[ci] );
}
// compute scaffold data
vec< vec< vec<basevector> > > s2altTigs( scaffolds_.size() );
vec<sData> s2data( scaffolds_.size() );
for ( int si = 0; si < scaffolds_.isize(); si++ ){
s2altTigs[si].resize( scaffolds_[si].Ntigs() );
for ( int i = 0; i < scaffolds_[si].Ntigs(); i++ ){
int ti = scaffolds_[si].Tig(i);
efasta& tigi = cefastas[ ti ];
s2data[si].AmbEventCount_ += tigi.AmbEventCount();
s2data[si].MaxAmbCount_ += tigi.AmbCount();
s2data[si].MinRedLen_ += tigi.MinLength();
s2data[si].MaxRedLen_ += tigi.MaxLength();
s2data[si].MinFullLen_ += tigi.MinLength();
s2data[si].MaxFullLen_ += tigi.MaxLength();
s2data[si].RedLen_ += tigi.Length1();
s2data[si].FullLen_ += tigi.Length1();
if ( i < scaffolds_[si].Ntigs() -1 ){
s2data[si].MinFullLen_ += scaffolds_[si].Gap(i) - scaffolds_[si].Dev(i);
s2data[si].MaxFullLen_ += scaffolds_[si].Gap(i) + scaffolds_[si].Dev(i);
s2data[si].FullLen_ += scaffolds_[si].Gap(i);
}
fastavector fseq;
tigi.FlattenMinTo( fseq );
s2altTigs[si][i].push_back( fseq.ToBasevector() );
if ( tigi.Ambiguities() > 0 ){
tigi.FlattenTo( fseq );
s2altTigs[si][i].push_back( fseq.ToBasevector() );
tigi.FlattenMaxTo( fseq );
s2altTigs[si][i].push_back( fseq.ToBasevector() );
}else{
s2altTigs[si][i].push_back( fseq.ToBasevector() );
s2altTigs[si][i].push_back( fseq.ToBasevector() );
}
}
DPRINT3( si, s2data[si].AmbEventCount_, s2data[si].MaxAmbCount_ );
}
for ( int si = 0; si < scaffolds_.isize(); si++ ) {
int Ni = scaffolds_[si].Ntigs();
basevector seq, minseq, maxseq;
for ( int ci = 0; ci < Ni; ci++ ){
minseq = Cat( minseq, s2altTigs[si][ci][0] );
seq = Cat( seq, s2altTigs[si][ci][1] );
maxseq = Cat( maxseq, s2altTigs[si][ci][2] );
if ( ci < Ni -1 )
for ( int pi = 0; pi < scaffolds_[si].Gap(ci); pi++ ){
seq.push_back(0); minseq.push_back(0); maxseq.push_back(0);
}
}
s2data[si].seq_ = seq; s2data[si].minseq_ = minseq; s2data[si].maxseq_ = maxseq;
basevector seq_rc, minseq_rc, maxseq_rc;
for ( int i = 0; i < Ni; i++ ){
int ci = Ni -1 -i;
basevector ci_minseq_rc = s2altTigs[si][ci][0]; ci_minseq_rc.ReverseComplement();
basevector ci_seq_rc = s2altTigs[si][ci][1]; ci_seq_rc.ReverseComplement();
basevector ci_maxseq_rc = s2altTigs[si][ci][2]; ci_maxseq_rc.ReverseComplement();
minseq_rc = Cat( minseq_rc, ci_minseq_rc );
seq_rc = Cat( seq_rc, ci_seq_rc );
maxseq_rc = Cat( maxseq_rc, ci_maxseq_rc );
if ( ci > 0 )
for ( int pi = 0; pi < scaffolds_[si].Gap(ci-1); pi++ ){
seq_rc.push_back(0); minseq_rc.push_back(0); maxseq_rc.push_back(0);
}
}
ForceAssertEq( minseq.size(), minseq_rc.size() );
ForceAssertEq( seq.size(), seq_rc.size() );
ForceAssertEq( maxseq.size(), maxseq_rc.size() );
s2data[si].seq_rc_ = seq_rc; s2data[si].minseq_rc_ = minseq_rc; s2data[si].maxseq_rc_ = maxseq_rc;
}
int removed_count = 0;
int removed_size = 0;
vec <Bool> to_remove ( scaffolds_.size(), False );
for ( int si = 0; si < scaffolds_.isize(); si++ ) {
if ( to_remove[si] ) continue;
int Ni = scaffolds_[si].Ntigs();
for ( int sj = si + 1; sj < scaffolds_.isize(); sj++ ) {
if ( to_remove[sj] ) continue;
int Nj = scaffolds_[sj].Ntigs();
ForceAssertEq( Nj, s2altTigs[sj].isize() );
// roughly check if scaffolds could be duplicates of each other
if ( Ni != Nj )
continue;
if ( s2data[si].FullLen_ != s2data[sj].FullLen_ &&
( s2data[si].MaxFullLen_ < s2data[sj].MinFullLen_ ||
s2data[sj].MaxFullLen_ < s2data[si].MinFullLen_ ) )
continue;
if ( s2data[si].RedLen_ != s2data[sj].RedLen_ &&
( s2data[si].MaxRedLen_ < s2data[sj].MinRedLen_ ||
s2data[sj].MaxRedLen_ < s2data[si].MinRedLen_ ) )
continue;
cout << "\n\n\n";
cout << Date() << ": --------- comparing scaffolds:" << endl;
DPRINT2( si, sj );
DPRINT2( s2data[si].AmbEventCount_, s2data[sj].AmbEventCount_ );
DPRINT2( s2data[si].MaxAmbCount_, s2data[sj].MaxAmbCount_ );
DPRINT2( s2data[si].seq_.size(), s2data[sj].seq_.size());
// more detailed check
vec<int> areRcs( Ni, 0 );
vec<int> areEqual( Ni, 0 );
for ( int ci = 0; ci < Ni; ci++ ){
if ( ci > 0 && areEqual[ci-1] != 1 && areRcs[ci-1] != 1 ) continue;
int ti = scaffolds_[si].Tig(ci);
vec< vec<String> > iblocks;
cefastas[ti].GetBlocks( iblocks );
if ( ci == 0 || areEqual[ci-1] == 1 ){
// checking duplication
int cje = ci;
int tje = scaffolds_[sj].Tig(cje);
if ( cefastas[ti] == cefastas[tje] ){
areEqual[ci] = 1;
}else if ( cefastas[ti].AmbEventCount() == cefastas[tje].AmbEventCount() ){
vec< vec<String> > eblocks;
cefastas[tje].GetBlocks( eblocks );
Bool pathEqual = True;
for ( int ib = 0; ib < iblocks.isize(); ib++ ){
if ( iblocks[ib].size() == 1 && eblocks[ib].size() == 1 ){
if ( iblocks[ib][0] != eblocks[ib][0] ){
pathEqual =False;
break;
}
}else{
Bool foundEqualRoute = False;
for ( int ir1 = 0; ir1 < iblocks[ib].isize(); ir1++ )
for ( int ir2 = 0; ir2 < eblocks[ib].isize(); ir2++ )
if ( iblocks[ib][ir1] == eblocks[ib][ir2] ){
foundEqualRoute = True;
break;
}
if ( ! foundEqualRoute ){
pathEqual = False;
break;
}
}
}
if ( pathEqual ) areEqual[ci] = 1;
}
}
if ( ci == 0 || areRcs[ci-1] == 1 ){
// checking reverse duplication
int cjr = Nj -ci -1;
int tjr = scaffolds_[sj].Tig(cjr);
efasta eseq_rc = cefastas_rc[tjr];
if ( cefastas[ti] == eseq_rc ){
areRcs[ci] = 1;
}else if ( cefastas[ti].AmbEventCount() == eseq_rc.AmbEventCount() ){
vec< vec<String> > rblocks;
eseq_rc.GetBlocks( rblocks );
Bool pathEqual = True;
for ( int ib = 0; ib < iblocks.isize(); ib++ ){
if ( iblocks[ib].size() == 1 && rblocks[ib].size() == 1 ){
if ( iblocks[ib][0] != rblocks[ib][0] ){
pathEqual =False;
break;
}
}else{
Bool foundEqualRoute = False;
for ( int ir1 = 0; ir1 < iblocks[ib].isize(); ir1++ )
for ( int ir2 = 0; ir2 < rblocks[ib].isize(); ir2++ )
if ( iblocks[ib][ir1] == rblocks[ib][ir2] ){
foundEqualRoute = True;
break;
}
if ( ! foundEqualRoute ){
pathEqual = False;
break;
}
}
}
if ( pathEqual ) areRcs[ci] = 1;
}
}
}
if ( Sum( areRcs ) > 0 || Sum( areEqual ) > 0 )
DPRINT4( areRcs.size(), Sum( areRcs ), areEqual.size(), Sum( areEqual ) );
if ( Sum( areRcs ) == areRcs.isize() || Sum( areEqual ) == areEqual.isize() ){
String type = Sum( areRcs ) == areRcs.isize() ? "reverse complement" : "duplicate";
cout << Date() << ": scaffold " << sj << "(l=" << scaffolds_[si].FullLength() << ") is " << type << " of " << si
<< " (length " << scaffolds_[si].FullLength() << ")" << endl;
to_remove[sj] = True;
removed_count++;
removed_size += scaffolds_[sj].ReducedLength();
}else if ( ! Exact) {
cout << "\n";
cout << Date() << ": ------------- RUNNING BANDED SMITH-WATERMAN -------------------\n\n";
int amb_diff_count = Max( s2data[si].maxseq_.isize() - s2data[si].minseq_.isize(),
s2data[sj].maxseq_.isize() - s2data[sj].minseq_.isize() );
int amb_event_count = Max( s2data[si].AmbEventCount_, s2data[sj].AmbEventCount_ );
int amb_max_count = Max( s2data[si].MaxAmbCount_, s2data[sj].MaxAmbCount_ );
DPRINT3( amb_diff_count, amb_event_count, amb_max_count );
// no exact match, check alignment
for ( int iter = 0; iter < 3; iter++ ){
if ( to_remove[sj] ) continue;
basevector si_seq;
if ( iter == 0 ) si_seq = s2data[si].seq_;
else if ( iter == 1 ) si_seq = s2data[si].minseq_;
else if ( iter == 2 ) si_seq = s2data[si].maxseq_;
basevector sj_seq;
if ( iter == 0 ) sj_seq = s2data[sj].seq_;
else if ( iter == 1 ) sj_seq = s2data[sj].minseq_;
else if ( iter == 2 ) sj_seq = s2data[sj].maxseq_;
// flank sequences with the same ends for the case where efasta amibugity is at the edge
Bool FlankSequences = False;
if ( efastas_[ scaffolds_[si].Tig(0) ].front() == '{' || efastas_[ scaffolds_[sj].Tig(0) ].front() == '{' ||
efastas_[ scaffolds_[si].Tig(0) ].back() == '}' || efastas_[ scaffolds_[sj].Tig(0) ].back() == '}' )
FlankSequences = True;
basevector flank;
flank.SetFromString("AAAAAAAAAA");
if ( FlankSequences ){
cout << Date() << " Flanking" << endl;
si_seq = Cat( flank, si_seq, flank );
sj_seq = Cat( flank, sj_seq, flank );
}
align aF;
int min_overlap = Min( si_seq.size(), sj_seq.size() );
DPRINT( min_overlap );
int errorsF = 0;
int lenDiff = abs( si_seq.isize() - sj_seq.isize() );
int bandwidth = 2 * lenDiff;
int maxErr = amb_max_count + amb_event_count + lenDiff + 1 + round( 0.0001 * (double)si_seq.isize() );
DPRINT( maxErr );
bandwidth = Max( bandwidth, 10 );
DPRINT( bandwidth );
cout << Date() << ": aligning forward" << endl;
float scoreF =
SmithWatBandedA2<unsigned short>(si_seq, sj_seq, 0, bandwidth, aF, errorsF );
look_align laF;
laF.ResetFromAlign( aF, si_seq, sj_seq );
DPRINT5( scoreF, laF.a.extent1(), laF.a.extent2(), errorsF, maxErr );
if ( ( laF.a.extent1() >= min_overlap || laF.a.extent2() >= min_overlap ) &&
errorsF <= maxErr && laF.Fw1() ){
cout << Date() << ": scaffold " << sj << "(l=" << scaffolds_[si].FullLength() << ") is a copy of " << si
<< " (length " << scaffolds_[si].FullLength() << ")" << endl;
to_remove[sj] = True;
removed_count++;
removed_size += scaffolds_[sj].ReducedLength();
}else{
basevector sj_seq_rc;
if ( iter == 0 ) sj_seq_rc = s2data[sj].seq_rc_;
else if ( iter == 1 ) sj_seq_rc = s2data[sj].minseq_rc_;
else if ( iter == 2 ) sj_seq_rc = s2data[sj].maxseq_rc_;
if ( FlankSequences )
sj_seq_rc = Cat( flank, si_seq, flank );
align aR;
int errorsR = 0;
cout << Date() << ": aligning reverse" << endl;
int scoreR =
SmithWatBandedA2<unsigned short>(si_seq, sj_seq_rc, 0, bandwidth, aR, errorsR );
look_align laR;
laR.ResetFromAlign( aR, si_seq, sj_seq_rc );
DPRINT5( scoreR, laR.a.extent1(), laR.a.extent2(), errorsR, maxErr );
if ( ( laR.a.extent1() >= min_overlap || laR.a.extent2() >= min_overlap ) &&
errorsR <= maxErr && laR.Fw1() ){
cout << Date() << ": scaffold " << sj << "(l=" << scaffolds_[si].FullLength() << ") is reverse-complement of " << si
<< " (length " << scaffolds_[si].FullLength() << ")" << endl;
to_remove[sj] = True;
removed_count++;
removed_size += scaffolds_[sj].ReducedLength();
}
}
cout << Date() << ": vvvvvvvvvvvvvv DONE WIHT ALIGNMENT vvvvvvvvvvvvvvv\n\n\n" << endl;
}
}
}
}
EraseIf( scaffolds_, to_remove );
EraseIf( scaffMap_, to_remove );
EraseIf( s2data, to_remove );
EraseIf( s2altTigs, to_remove );
vec<int> verts_to_remove;
for ( int i = 0; i < to_remove.isize(); i++ )
if ( to_remove[i] ){
SG_.DeleteEdgesAtVertex( i );
verts_to_remove.push_back( i );
}
SG_.RemoveEdgelessVertices( verts_to_remove );
cout << Date() << ": removed " << removed_count << " duplicate scaffolds"
<< " (" << removed_size << " bases)" << endl;
cout << Date() << ": final number of scaffolds = " << scaffolds_.size() << endl;
remove_unused_contigs();
}
void Assembly::dedup2() {
// Remove scaffolds that are possibly duplicate
// The criteria are:
// 1. two scaffolds have same number of contigs (n_contig)
// 2. n_contig >= 2
// 3. Each contig and gap much match
// - Gaps are matched whan [ gap_size +/- 3 * std ] overlap
// - Contigs are matched when
// - perfect efasta match for contig size < 50,000
// - 1/100 mismatch kmer rate for contig size >= 50,000 (!!!!! this is only meant to be temporary fix to the problem)
// 4. Both rc and fw duplicates are checked
int VERBOSITY = 0;
const int EfastaMatchSize = 50 * 1000;
const int MaxDev = 3;
const double MaxMismatchRate = 0.01;
cout << Date() << ": " << "Remove possible duplicate scaffolds" << endl;
cout << Date() << ": " << "initial number of scaffolds = " << scaffolds_.size() << endl;
int removed_count = 0;
int removed_size = 0;
vec <Bool> to_remove ( scaffolds_.size(), False );
for ( int si = 0; si < scaffolds_.isize(); si++ ) {
if ( to_remove[si] ) continue;
int Ni = scaffolds_[si].Ntigs();
//if ( Ni < 2 ) continue;
for ( int sj = si + 1; sj < scaffolds_.isize(); sj++ ) {
if ( to_remove[sj] ) continue;
int Nj = scaffolds_[sj].Ntigs();
if ( Nj != Ni ) continue;
//VERBOSITY = ( si == 1 && sj == 6 ? 1: 0 );
// check scaffolds duplicate in two passes: fw in pass=0, rc in pass=1
for( int pass = 0; pass < 2; pass++ ) {
if ( VERBOSITY >= 1 )
cout << Date() << ": " << "pass= " << pass << endl;
if ( VERBOSITY >= 1 )
cout << Date() << ": " << "check gap " << endl ;
// compare the gap of two scaffolds
bool gap_match = true;
for ( int igap = 0; igap < Ni-1; ++igap ) {
int gap1 = scaffolds_[si].Gap(igap);
int dev1 = scaffolds_[si].Dev(igap);
int gap2 = scaffolds_[sj].Gap( pass == 0 ? igap : Ni -2 - igap);
int dev2 = scaffolds_[sj].Dev( pass == 0 ? igap : Ni -2 - igap);
if ( IntervalOverlap( gap1 - MaxDev * dev1, gap1 + MaxDev * dev1 + 1,
gap2 - MaxDev * dev2, gap2 + MaxDev * dev2 + 1) == 0 ) {
gap_match = false;
break;
}
}
if ( !gap_match) continue;
if ( VERBOSITY >= 1 )
cout << Date() << ": " << "check contigs " << endl ;
// check if the contigs matchs
bool tig_match = true;
if ( VERBOSITY >= 1 )
cout<< Date() << " ncontigs= " << Ni << endl;
for ( int itig = 0; itig < Ni; ++itig) {
if ( VERBOSITY >= 1 )
cout << Date() << ": check contig " << itig << ": "
<< " vs " << scaffolds_[sj].Tig( pass == 0 ? itig : Nj -1 -itig ) << endl;
efasta &tigi = efastas_[ scaffolds_[si].Tig(itig) ];
efasta &tigj = efastas_[ scaffolds_[sj].Tig( pass == 0 ? itig : Nj -1 -itig ) ] ;
if ( VERBOSITY >= 1 )
cout << Date() << ": tigi.size()= " << tigi.size() << endl;
if ( VERBOSITY >= 1 )
cout << Date() << ": tigj.size()= " << tigj.size() << endl;
// check if contig sizes match
int tig_size = ( tigi.size() + tigj.size() ) /2;
int MaxMismatch = tig_size * MaxMismatchRate ;
if ( abs( (int)tigi.size() - (int)tigj.size() ) > MaxMismatch ) { tig_match = false; break; }
// require perfect efasta match if contig size less than EfastaMatchSize
if ( tig_size < EfastaMatchSize ) {
if ( VERBOSITY >= 1 )
cout << Date() << ": check efasta " << endl;
vec<basevector> v_ibases, v_jbases;
tigi.ExpandTo(v_ibases);
tigj.ExpandTo(v_jbases);
if ( pass == 1 )
for ( size_t k = 0; k < v_jbases.size(); ++k ) { v_jbases[k].ReverseComplement(); }
bool foundEqual = False;
for ( size_t vi = 0; vi < v_ibases.size() && ! foundEqual; vi++ ){
for ( size_t vj = 0; vj < v_jbases.size(); vj++ ){
if ( v_jbases[vj].size() != v_ibases[vi].size() )
continue;
basevector jbases = v_jbases[vj];
if ( jbases == v_ibases[vi] ){
foundEqual = True;
break;
}
}
}
if ( ! foundEqual ) {
tig_match = false;
break;
}
}
// larger contig size. do kmer matching
else {
if ( VERBOSITY >= 1 )
cout << Date() << ": check kmers " << endl;
basevector base1, base2;
tigi.FlattenTo( base1 );
tigj.FlattenTo( base2 );
if ( pass == 1 ) base2.ReverseComplement();
const int K = 24;
ForceAssertGt( base1.isize( ), K );
vec< basevector > kmers1( base1.isize( ) - K + 1);
#pragma omp parallel for
for ( int jz = 0; jz <= base1.isize( ) - K; jz += 1000 )
for ( int j = jz; j <= Min( base1.isize( ) - K, jz + 1000 ); j++ )
kmers1[j].SetToSubOf( base1, j, K );
ParallelUniqueSort(kmers1);
ForceAssertGt( base2.isize( ), K );
vec< basevector > kmers2( base2.isize( ) - K + 1);
#pragma omp parallel for
for ( int jz = 0; jz <= base2.isize( ) - K; jz += 1000 )
for ( int j = jz; j <= Min( base2.isize( ) - K, jz + 1000 ); j++ )
kmers2[j].SetToSubOf( base2, j, K );
ParallelUniqueSort(kmers2);
// compare how many kmers are identical for the two sorted list
int nkmer1 = kmers1.size(), nkmer2 = kmers2.size();
int nkmer = (nkmer1 + nkmer2)/2;
int count = 0;
for( size_t i = 0, j = 0; i < kmers1.size() && j < kmers2.size(); ) {
if ( kmers1[i] > kmers2[j] ) j++;
else if ( kmers1[i] < kmers2[j] ) i++;
else count++, i++, j++;
}
if ( VERBOSITY >= 1 ) {
cout << Date() << ": nkmer= " << nkmer << endl;
cout << Date() << ": duplicate= " << count << endl;
}
if ( abs(nkmer - count) > int( nkmer * MaxMismatchRate) ) {
tig_match = false;
break;
}
}
} // for itig
if ( !tig_match ) continue;
// ---------------------------------------------------------------------------
// Now we concluded that the two scaffolds are duplicate. Remove the later one
// --------------------------------------------------------------------------
{
String type = pass == 0 ? "fw duplicate" : "rc duplicate";
cout << Date() << ": scaffold " << sj << " is " << type << " of " << si
<< " (length " << scaffolds_[si].FullLength() << ")" << endl;
to_remove[sj] = True;
removed_count++;
removed_size += scaffolds_[sj].ReducedLength();
break; // do not go second pass
}
} // end pass 2
} // end for sj
} // end for si
// now remove the duplicate scaffolds
{
EraseIf( scaffolds_, to_remove );
EraseIf( scaffMap_, to_remove );
vec<int> verts_to_remove;
for ( int i = 0; i < to_remove.isize(); i++ )
if ( to_remove[i] ){
SG_.DeleteEdgesAtVertex( to_remove[i] );
verts_to_remove.push_back( i );
}
SG_.RemoveEdgelessVertices( verts_to_remove );
}
cout << Date() << ": removed " << removed_count << " duplicate scaffolds"
<< " (" << removed_size << " bases)" << endl;
cout << Date() << ": final number of scaffolds = " << scaffolds_.size() << endl;
remove_unused_contigs();
}
void Assembly::dedup_exact() {
// Remove duplicate scaffolds...currently only handles case of singleton contigs
// which are duplicates fw or rc. --bruce 8 Jun 2011
cout << Date() << ": removing duplicate scaffolds: " << endl;
cout << Date() << ": initial number of scaffolds = " << scaffolds_.size() << endl;
int removed_count = 0;
int removed_size = 0;
vec<int> remaining( scaffolds_.size(), vec<int>::IDENTITY );
vec<int> verts_to_remove;
for ( int si = 0; si < scaffolds_.isize(); si++ ) {
if (scaffolds_[si].Ntigs() != 1) continue;
for ( int sj = si + 1; sj < scaffolds_.isize(); sj++ ) {
if (scaffolds_[sj].Ntigs() != 1) continue;
efasta &tigi = efastas_[scaffolds_[si].Tig(0)];
efasta &tigj = efastas_[scaffolds_[sj].Tig(0)];
if (tigi.size() != tigj.size()) continue;
basevector ibases, jbases;
tigi.FlattenTo(ibases);
tigj.FlattenTo(jbases);
bool rc = False;
if (ibases != jbases) {
jbases.ReverseComplement();
rc = True;
if (ibases != jbases) continue;
}
/*
cout << "scaffold " << sj << " duplicate of " << si
<< " (length " << scaffolds_[si].FullLength()
<< (rc ? " rc" : "") << ")" << endl;
*/
scaffolds_.erase( scaffolds_.begin() + sj );
scaffMap_.erase( scaffMap_.begin() + sj );
verts_to_remove.push_back( remaining[sj] );
SG_.DeleteEdgesAtVertex( remaining[sj] );
remaining.erase( remaining.begin() + sj );
sj--;
removed_count++;
removed_size += ibases.size();
}
}
SG_.RemoveEdgelessVertices( verts_to_remove );
cout << Date() << ": removed " << removed_count << " duplicate scaffolds"
<< " (" << removed_size << " bases)" << endl;
cout << Date() << ": final number of scaffolds = " << scaffolds_.size() << endl;
remove_unused_contigs();
}
void Assembly::set_min_gaps( const int min_gap ){
cout << Date() << ": resetting gaps < " << min_gap << endl;
for ( size_t is = 0; is < scaffolds_.size(); is++ )
for ( int tpos = 0; tpos < scaffolds_[is].Ntigs() -1; tpos++ )
if ( scaffolds_[is].Gap(tpos) < min_gap ) {
scaffolds_[is].SetGap( tpos, min_gap );
scaffolds_[is].SetDev( tpos, 0 );
}
}
void Assembly::WriteFastg( const String head_out ) const {
// fastg_meta FGM;
Ofstream(out_g, head_out + ".assembly.fastg");
// out_g << FGM.GetFileHeader( head_out ) << "\n";
out_g << fastg_meta::GetFileHeader( head_out ) << "\n";
for (size_t is = 0; is < scaffolds_.size(); is++) {
const superb& S = scaffolds_[is];
headfastg hfg( ToString(is), SG_.From(is) );
basefastg bfg;
for ( int it = 0; it < S.Ntigs(); it++) {
int tigId = S.Tig( it );
bfg += basefastg( efastas_[tigId] );
if ( it < S.Ntigs() -1 )
bfg += basefastg( S.Gap(it), S.Dev(it) );
}
recfastg rfg( hfg, bfg );
rfg.Print( out_g );
}
// out_g << FGM.GetFileFooter() << "\n";
out_g << fastg_meta::GetFileFooter() << "\n";
}
void Assembly::Write( const String head_out ) const {
// writing output
cout << Date() << ": writing output files" << endl;
WriteSuperbs( head_out + ".superb", scaffolds_ );
WriteSummary( head_out + ".summary", scaffolds_ );
Ofstream( efout, head_out + ".contigs.efasta" );
for ( size_t id = 0; id < efastas_.size(); id++ )
efastas_[id].Print(efout, "contig_" + ToString(id) );
}
void Assembly::WriteExtra( const String head_out ) const{
vec<fastavector> fastas(efastas_.size());
for ( size_t id = 0; id < efastas_.size(); id++ )
efastas_[id].FlattenTo( fastas[id] );
Ofstream( fout, head_out + ".contigs.fasta" );
for ( size_t id = 0; id < fastas.size(); id++ )
fastas[id].Print(fout, "contig_" + ToString(id) );
{
vecfastavector vec_tigs;
for ( size_t i = 0; i < fastas.size( ); i++ )
vec_tigs.push_back_reserve( fastas[i] );
vec_tigs.WriteAll( head_out + ".contigs.vecfasta" );
}
vecbasevector bases( efastas_.size() );
for ( size_t id = 0; id < efastas_.size(); id++ )
efastas_[id].FlattenTo( bases[id] );
bases.WriteAll( head_out + ".contigs.fastb" );
Ofstream( cmout, head_out + ".contigs.mapping" );
for ( size_t id = 0; id < tigMap_.size(); id++ )
cmout << ToString(id) + " from " + ToString( tigMap_[id] ) << "\n";
Ofstream( smout, head_out + ".superb.mapping" );
for ( size_t is = 0; is < scaffMap_.size(); is++ )
smout << ToString(is) + " from " + ToString( scaffMap_[is] ) << "\n";
WriteScaffoldedEFasta( head_out + ".assembly.efasta", efastas_, scaffolds_ );
WriteScaffoldedFasta( head_out + ".assembly.fasta", fastas, scaffolds_ );
BinaryWriter::writeFile( head_out + ".scaffold_graph.", SG_ );
}
| 35.253211 | 170 | 0.592463 | bayolau |
c7bbb0a147bc75aa65e0234f9b46e003970d8cda | 9,058 | cpp | C++ | src/GenModel.cpp | StebQC/GenModel | 6590293cd541ebb3bba1e73b04c6d014dfc633f2 | [
"MIT"
] | null | null | null | src/GenModel.cpp | StebQC/GenModel | 6590293cd541ebb3bba1e73b04c6d014dfc633f2 | [
"MIT"
] | null | null | null | src/GenModel.cpp | StebQC/GenModel | 6590293cd541ebb3bba1e73b04c6d014dfc633f2 | [
"MIT"
] | null | null | null | #include "GenModel.h"
//#include "SqlCaller.h"
#include <math.h>
#include <time.h>
GenModel::GenModel()
{
version = "genmodellean-0.0.15 build 0001";
hassolution = false;
bcreated = false;
binit = false;
nc = 0;
nr = 0;
solverdata = NULL;
}
double GenModel::FindConstraintMaxLhs(long row)
{
double total = 0.0;
for(int i = 0; i < int(consts[row].cols.size()); i++)
total += (consts[row].coefs[i] >= 0 ? vars.ub[consts[row].cols[i]] : vars.lb[consts[row].cols[i]])*consts[row].coefs[i];
return total;
}
double GenModel::FindConstraintMinLhs(long row)
{
double total = 0.0;
for(int i = 0; i < int(consts[row].cols.size()); i++)
total += (consts[row].coefs[i] >= 0 ? vars.lb[consts[row].cols[i]] : vars.ub[consts[row].cols[i]])*consts[row].coefs[i];
return total;
}
long GenModel::MakeConstraintFeasible(long row)
{
if(consts[row].sense == 'L')
{
double min = FindConstraintMinLhs(row);
if(min > consts[row].lrhs)
consts[row].lrhs = min;
}
else if(consts[row].sense == 'G')
{
double max = FindConstraintMaxLhs(row);
if(max < consts[row].lrhs)
consts[row].lrhs = max;
}
else if(consts[row].sense == 'R')
{
double min = FindConstraintMinLhs(row);
double max = FindConstraintMaxLhs(row);
if(max < consts[row].lrhs)
consts[row].lrhs = max;
else if(min > consts[row].urhs)
consts[row].urhs = min;
}
return 0;
}
long GenModel::SetLongParam(string param, long val)
{
longParam[param] = val;
return 0;
}
long GenModel::SetDblParam(string param, double val)
{
dblParam[param] = val;
return 0;
}
long GenModel::SetBoolParam(string param, bool val)
{
boolParam[param] = val;
return 0;
}
long GenModel::SetStrParam(string param, string val)
{
strParam[param] = val;
return 0;
}
long GenModel::ThrowError(string error)
{
printf("%s\n", error.c_str());
throw error;
}
long GenModel::PrintObjVal()
{
printf("obj : %f\n", objval);
return 0;
}
long GenModel::PrintSol()
{
//printf("obj : %f\n", objval);
for(long i = 0; i < long(vars.n); i++)
{
printf("%s : %f\n", vars.name[i].c_str(), vars.sol[i]);
}
return 0;
}
long GenModel::PrintModel()
{
return 0;
}
long GenModel::PrintSol(string v)
{
//printf("obj : %f\n", objval);
if(vars.offset.count(v) == 0)
return 0;
map<string, long>::iterator it = vars.offset.find(v);
long deb = it->second;
long fin = vars.n;
for(it = vars.offset.begin(); it != vars.offset.end(); it++)
{
if(it->second > deb && it->second < fin)
fin = it->second;
}
for(long i = deb; i < fin; i++)
{
printf("%s : %f\n", vars.name[i].c_str(), vars.sol[i]);
}
return 0;
}
long GenModel::PrintSolNz()
{
//printf("obj : %f\n", objval);
for(long i = 0; i < long(vars.n); i++)
{
if(fabs(vars.sol[i]) > 0.000001)
printf("%s : %f\n", vars.name[i].c_str(), vars.sol[i]);
}
return 0;
}
long GenModel::PrintSolNz(string v)
{
//printf("obj : %f\n", objval);
if(vars.offset.count(v) == 0)
return 0;
map<string, long>::iterator it = vars.offset.find(v);
long deb = it->second;
long fin = vars.n;
for(it = vars.offset.begin(); it != vars.offset.end(); it++)
{
if(it->second > deb && it->second < fin)
fin = it->second;
}
for(long i = deb; i < fin; i++)
{
if(fabs(vars.sol[i]) > 0.000001)
printf("%s : %f\n", vars.name[i].c_str(), vars.sol[i]);
}
return 0;
}
long ModConsts::AddNz(long c, double v)
{
cols.push_back(c);
coefs.push_back(v);
nz++;
return 0;
}
long GenModel::AddConst(string cname)
{
ci[cname] = nc;
consts.push_back(ModConsts());
consts.back().name = cname;
nc++;
return 0;
}
long GenModel::AddConst(string cname, double rhs, char sense)
{
AddConst(cname);
consts.back().lrhs = rhs;
consts.back().sense = sense;
return 0;
}
long GenModel::AddNz(long row, long col, double val)
{
consts[row].AddNz(col, val);
return 0;
}
long GenModel::AddNzToLast(long col, double val)
{
consts.back().AddNz(col, val);
return 0;
}
long GenModel::SetNumbers()
{
nr = consts.size();
nc = vars.n; //vars.obj.size();
nz = 0;
for(long i = 0; i < long(nr); i++)
{
consts[i].nz = consts[i].cols.size();
nz+=consts[i].nz;
}
return 0;
}
long GenModel::AddVar(string nn, double o, double l, double u, char t)
{
vars.AddVar(nn, o, l, u, t);
return 0;
}
long GenModel::AddVars(string nn, long size, double o, double l, double u, char t)
{
vars.AddVars(nn, size, o, l, u, t);
return 0;
}
long GenModel::SetQpCoef(long i, long j, double val)
{
vars.SetQpCoef(i, j, val);
return 0;
}
long GenModel::AddModelColumn(int count, int* ind, double* val, double obj, double lb, double ub, string name, char type)
{
AddVar(name, obj, lb, ub, type);
for(long i = 0; i < count; i++)
AddNz(ind[i], vars.n-1, val[i]);
return 0;
}
long GenModel::AddModelCol(vector<int>& ind, vector<double>& val, double obj, double lb, double ub, string name, char type)
{
AddVar(name, obj, lb, ub, type);
for(long i = 0; i < long(ind.size()); i++)
AddNz(ind[i], vars.n-1, val[i]);
return 0;
}
long GenModel::AddModelRow(vector<int>& ind, vector<double>& val, double rhs, char sense, string name)
{
AddConst(name, rhs, sense);
for(long i = 0; i < long(ind.size()); i++)
AddNzToLast(ind[i], val[i]);
return 0;
}
long GenModel::AddSolverColumn(int count, int* ind, double* val, double obj, double lb, double ub, string name, char type)
{
return 0;
}
long GenModel::ChangeBulkBounds(int count, int * ind, char * type, double * vals)
{
throw string("ChangeBulkBounds() Not implemented");
return 0;
}
long GenModel::ChangeBulkObjectives(int count, int * ind, double * vals)
{
throw string("ChangeBulkObjectives() Not implemented");
return 0;
}
long GenModel::ChangeBulkNz(int count, int* rind, int* cind, double* vals)
{
throw string("ChangeBulkNz() Not implemented");
return 0;
}
long GenModel::SetObjUpperCutoff(double value)
{
return 0;
}
long GenModel::WriteProblemToLpFile(string filename)
{
throw string("WriteProblemToLpFile() Not implemented");
return 0;
}
long GenModel::WriteSolutionToFile(string filename)
{
throw string("WriteSolutionToFile() Not implemented");
return 0;
}
void GenModel::AttachCallback(bool(*callbackFunction) (double obj, double bestBound, bool feasibleSolution))
{
return;
}
double GenModel::GetMIPBestBound()
{
return 0;
}
long GenModel::ChangeBulkRHS(int count, int* ind, double* vals)
{
return 0;
}
long GenModel::DeleteMipStarts()
{
throw string("DeleteMipStarts() Not implemented");
return 0;
}
double GenModel::GetMIPRelativeGap()
{
throw string("GetMIPRelativeGap() Not implemented");
return 0.0;
}
long GenModel::ExportModel(string cname)
{
return 0;
}
long GenModel::ExportConflict(string cname)
{
return 0;
}
long ModVars::AddVar(string nn, double o, double l, double u, char t)
{
//offset[nn] = n;
name.push_back(nn);
obj.push_back(o);
ub.push_back(u);
lb.push_back(l);
type.push_back(t);
n++;
return 0;
}
long ModVars::AddVars(string nn, long size, double o, double l, double u, char t)
{
offset[nn] = n;
char c[4096];
for(long i = 0; i < size; i++)
{
snprintf(c, 4096, "%s_%ld", nn.c_str(), i);
AddVar(string(c), o, l, u, t);
}
return 0;
}
long ModVars::SetQpCoef(long i, long j, double val)
{
qi.push_back(i);
qj.push_back(j);
qobj.push_back(val);
return 0;
}
long ModVars::Print()
{
for(long i = 0; i < long(n); i++)
{
printf("%ld: %s obj=%f [%c]\n", i, name[i].c_str(), obj[i], type[i]);
}
return 0;
}
template <typename T>
void _freeall(T& t)
{
T tmp;
t.swap(tmp);
}
long GenModel::ClearStructure()
{
consts.clear();
_freeall(consts);
ci.clear();
_freeall(ci);
vars.name.clear();
_freeall(vars.name);
vars.obj.clear();
_freeall(vars.obj);
vars.type.clear();
_freeall(vars.type);
vars.offset.clear();
_freeall(vars.offset);
vars.ub.clear();
_freeall(vars.ub);
vars.lb.clear();
_freeall(vars.lb);
vars.sol.clear();
_freeall(vars.sol);
vars.rc.clear();
_freeall(vars.rc);
vars.qobj.clear();
_freeall(vars.qobj);
vars.qi.clear();
_freeall(vars.qi);
vars.qj.clear();
_freeall(vars.qj);
return 0;
}
genmodel_param dbl2param(double val)
{
genmodel_param ret;
ret.dblval = val;
return ret;
}
genmodel_param long2param(long val)
{
genmodel_param ret;
ret.longval = val;
return ret;
}
genmodel_param str2param(string val)
{
genmodel_param ret;
ret.strval = val.c_str();
return ret;
}
| 20.493213 | 128 | 0.596048 | StebQC |
c7c44bed3f2564f4702ed6c4515175a6825623c5 | 7,900 | cpp | C++ | src/stan/language/ast_def.cpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | 1 | 2019-09-06T15:53:17.000Z | 2019-09-06T15:53:17.000Z | src/stan/language/ast_def.cpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | 8 | 2019-01-17T18:51:16.000Z | 2019-01-17T18:51:39.000Z | src/stan/language/ast_def.cpp | alashworth/stan-monorepo | 75596bc1f860ededd7b3e9ae9002aea97ee1cd46 | [
"BSD-3-Clause"
] | null | null | null | #ifndef STAN_LANG_AST_DEF_CPP
#define STAN_LANG_AST_DEF_CPP
#include "stan/language/ast.hpp"
#include "stan/language/ast/fun/bare_type_is_data_vis_def.hpp"
#include "stan/language/ast/fun/bare_type_order_id_vis_def.hpp"
#include "stan/language/ast/fun/bare_type_set_is_data_vis_def.hpp"
#include "stan/language/ast/fun/bare_type_total_dims_vis_def.hpp"
#include "stan/language/ast/fun/bare_type_vis_def.hpp"
#include "stan/language/ast/fun/block_type_bounds_vis_def.hpp"
#include "stan/language/ast/fun/block_type_is_specialized_vis_def.hpp"
#include "stan/language/ast/fun/block_type_offset_multiplier_vis_def.hpp"
#include "stan/language/ast/fun/block_type_params_total_vis_def.hpp"
#include "stan/language/ast/fun/ends_with_def.hpp"
#include "stan/language/ast/fun/expression_bare_type_vis_def.hpp"
#include "stan/language/ast/fun/fun_name_exists_def.hpp"
#include "stan/language/ast/fun/get_ccdf_def.hpp"
#include "stan/language/ast/fun/get_cdf_def.hpp"
#include "stan/language/ast/fun/get_prob_fun_def.hpp"
#include "stan/language/ast/fun/has_ccdf_suffix_def.hpp"
#include "stan/language/ast/fun/has_cdf_suffix_def.hpp"
#include "stan/language/ast/fun/has_lp_suffix_def.hpp"
#include "stan/language/ast/fun/has_non_param_var_def.hpp"
#include "stan/language/ast/fun/has_non_param_var_vis_def.hpp"
#include "stan/language/ast/fun/has_prob_fun_suffix_def.hpp"
#include "stan/language/ast/fun/has_rng_suffix_def.hpp"
#include "stan/language/ast/fun/has_var_def.hpp"
#include "stan/language/ast/fun/has_var_vis_def.hpp"
#include "stan/language/ast/fun/indexed_type_def.hpp"
#include "stan/language/ast/fun/infer_type_indexing_def.hpp"
#include "stan/language/ast/fun/is_assignable_def.hpp"
#include "stan/language/ast/fun/is_multi_index_def.hpp"
#include "stan/language/ast/fun/is_multi_index_vis_def.hpp"
#include "stan/language/ast/fun/is_nil_def.hpp"
#include "stan/language/ast/fun/is_nil_vis_def.hpp"
#include "stan/language/ast/fun/is_no_op_statement_vis_def.hpp"
#include "stan/language/ast/fun/is_nonempty_def.hpp"
#include "stan/language/ast/fun/is_space_def.hpp"
#include "stan/language/ast/fun/is_user_defined_def.hpp"
#include "stan/language/ast/fun/is_user_defined_prob_function_def.hpp"
#include "stan/language/ast/fun/num_index_op_dims_def.hpp"
#include "stan/language/ast/fun/print_scope_def.hpp"
#include "stan/language/ast/fun/promote_primitive_def.hpp"
#include "stan/language/ast/fun/returns_type_def.hpp"
#include "stan/language/ast/fun/returns_type_vis_def.hpp"
#include "stan/language/ast/fun/strip_ccdf_suffix_def.hpp"
#include "stan/language/ast/fun/strip_cdf_suffix_def.hpp"
#include "stan/language/ast/fun/strip_prob_fun_suffix_def.hpp"
#include "stan/language/ast/fun/var_occurs_vis_def.hpp"
#include "stan/language/ast/fun/var_type_arg1_vis_def.hpp"
#include "stan/language/ast/fun/var_type_arg2_vis_def.hpp"
#include "stan/language/ast/fun/var_type_name_vis_def.hpp"
#include "stan/language/ast/fun/write_bare_expr_type_def.hpp"
#include "stan/language/ast/fun/write_block_var_type_def.hpp"
#include "stan/language/ast/fun/write_expression_vis_def.hpp"
#include "stan/language/ast/fun/write_idx_vis_def.hpp"
#include "stan/language/ast/node/algebra_solver_control_def.hpp"
#include "stan/language/ast/node/algebra_solver_def.hpp"
#include "stan/language/ast/node/array_expr_def.hpp"
#include "stan/language/ast/node/assgn_def.hpp"
#include "stan/language/ast/node/binary_op_def.hpp"
#include "stan/language/ast/node/block_var_decl_def.hpp"
#include "stan/language/ast/node/break_continue_statement_def.hpp"
#include "stan/language/ast/node/conditional_op_def.hpp"
#include "stan/language/ast/node/conditional_statement_def.hpp"
#include "stan/language/ast/node/double_literal_def.hpp"
#include "stan/language/ast/node/expression_def.hpp"
#include "stan/language/ast/node/for_array_statement_def.hpp"
#include "stan/language/ast/node/for_matrix_statement_def.hpp"
#include "stan/language/ast/node/for_statement_def.hpp"
#include "stan/language/ast/node/fun_def.hpp"
#include "stan/language/ast/node/function_decl_def_def.hpp"
#include "stan/language/ast/node/function_decl_defs_def.hpp"
#include "stan/language/ast/node/idx_def.hpp"
#include "stan/language/ast/node/increment_log_prob_statement_def.hpp"
#include "stan/language/ast/node/index_op_def.hpp"
#include "stan/language/ast/node/index_op_sliced_def.hpp"
#include "stan/language/ast/node/int_literal_def.hpp"
#include "stan/language/ast/node/integrate_1d_def.hpp"
#include "stan/language/ast/node/integrate_ode_control_def.hpp"
#include "stan/language/ast/node/integrate_ode_def.hpp"
#include "stan/language/ast/node/lb_idx_def.hpp"
#include "stan/language/ast/node/local_var_decl_def.hpp"
#include "stan/language/ast/node/lub_idx_def.hpp"
#include "stan/language/ast/node/map_rect_def.hpp"
#include "stan/language/ast/node/matrix_expr_def.hpp"
#include "stan/language/ast/node/multi_idx_def.hpp"
#include "stan/language/ast/node/offset_multiplier_def.hpp"
#include "stan/language/ast/node/omni_idx_def.hpp"
#include "stan/language/ast/node/print_statement_def.hpp"
#include "stan/language/ast/node/printable_def.hpp"
#include "stan/language/ast/node/program_def.hpp"
#include "stan/language/ast/node/range_def.hpp"
#include "stan/language/ast/node/reject_statement_def.hpp"
#include "stan/language/ast/node/return_statement_def.hpp"
#include "stan/language/ast/node/row_vector_expr_def.hpp"
#include "stan/language/ast/node/sample_def.hpp"
#include "stan/language/ast/node/statement_def.hpp"
#include "stan/language/ast/node/statements_def.hpp"
#include "stan/language/ast/node/ub_idx_def.hpp"
#include "stan/language/ast/node/unary_op_def.hpp"
#include "stan/language/ast/node/uni_idx_def.hpp"
#include "stan/language/ast/node/var_decl_def.hpp"
#include "stan/language/ast/node/variable_def.hpp"
#include "stan/language/ast/node/variable_dims_def.hpp"
#include "stan/language/ast/node/while_statement_def.hpp"
#include "stan/language/ast/scope_def.hpp"
#include "stan/language/ast/sigs/function_signatures_def.hpp"
#include "stan/language/ast/type/bare_array_type_def.hpp"
#include "stan/language/ast/type/bare_expr_type_def.hpp"
#include "stan/language/ast/type/block_array_type_def.hpp"
#include "stan/language/ast/type/block_var_type_def.hpp"
#include "stan/language/ast/type/cholesky_factor_corr_block_type_def.hpp"
#include "stan/language/ast/type/cholesky_factor_cov_block_type_def.hpp"
#include "stan/language/ast/type/corr_matrix_block_type_def.hpp"
#include "stan/language/ast/type/cov_matrix_block_type_def.hpp"
#include "stan/language/ast/type/double_block_type_def.hpp"
#include "stan/language/ast/type/double_type_def.hpp"
#include "stan/language/ast/type/ill_formed_type_def.hpp"
#include "stan/language/ast/type/int_block_type_def.hpp"
#include "stan/language/ast/type/int_type_def.hpp"
#include "stan/language/ast/type/local_array_type_def.hpp"
#include "stan/language/ast/type/local_var_type_def.hpp"
#include "stan/language/ast/type/matrix_block_type_def.hpp"
#include "stan/language/ast/type/matrix_local_type_def.hpp"
#include "stan/language/ast/type/matrix_type_def.hpp"
#include "stan/language/ast/type/ordered_block_type_def.hpp"
#include "stan/language/ast/type/positive_ordered_block_type_def.hpp"
#include "stan/language/ast/type/row_vector_block_type_def.hpp"
#include "stan/language/ast/type/row_vector_local_type_def.hpp"
#include "stan/language/ast/type/row_vector_type_def.hpp"
#include "stan/language/ast/type/simplex_block_type_def.hpp"
#include "stan/language/ast/type/unit_vector_block_type_def.hpp"
#include "stan/language/ast/type/vector_block_type_def.hpp"
#include "stan/language/ast/type/vector_local_type_def.hpp"
#include "stan/language/ast/type/vector_type_def.hpp"
#include "stan/language/ast/type/void_type_def.hpp"
#include "stan/language/ast/variable_map_def.hpp"
#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/recursive_variant.hpp>
#endif
| 55.244755 | 73 | 0.826329 | alashworth |
c7c9ca4378f7e79de21c67be42dea9eb9a293b84 | 1,809 | hpp | C++ | MineClone/src/World/Blocks/Block.hpp | Harry09/MineClone | ee893640b7570c38b5930569e2e67a18a5afce53 | [
"MIT"
] | null | null | null | MineClone/src/World/Blocks/Block.hpp | Harry09/MineClone | ee893640b7570c38b5930569e2e67a18a5afce53 | [
"MIT"
] | null | null | null | MineClone/src/World/Blocks/Block.hpp | Harry09/MineClone | ee893640b7570c38b5930569e2e67a18a5afce53 | [
"MIT"
] | 1 | 2020-09-02T10:36:39.000Z | 2020-09-02T10:36:39.000Z | #pragma once
#include <memory>
#include <vector>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include "BlockMesh.hpp"
#include "Maths/Coords.hpp"
class ChunkSegment;
class Block
{
public:
static constexpr int BlockFaceCount = static_cast<int>(BlockFace::Size);
protected:
ChunkSegment& _chunk;
coords::LocalPos _localPos = { 0.f, 0.f, 0.f };
Blocks _blockType;
TextureId _faceTexture[BlockFaceCount] = { TextureId::None };
public:
Block(ChunkSegment& chunk, const coords::LocalPos& localPos, Blocks blockType) noexcept;
Block(const Block& other) noexcept;
Block& operator=(const Block& other) noexcept;
Block(Block&& other) noexcept;
Block& operator=(Block&& other) noexcept;
~Block() = default;
const coords::LocalPos& getLocalPos() const { return _localPos; }
coords::WorldPos getWorldPos() const;
Block* getNeighbor(BlockFace face) const;
bool hasNeighbor(BlockFace face) const { return getNeighbor(face) != nullptr; }
template<BlockFace... Faces>
const auto getVertices(TextureAtlas& textureAtlas) const
{
std::vector<Vertex> vertices;
int offset = 0;
((getVerticesImp<Faces>(vertices, offset, textureAtlas), offset++), ...);
return vertices;
}
protected:
template<BlockFace... Faces>
constexpr void setTexture(TextureId textureId)
{
((_faceTexture[static_cast<int>(Faces)] = textureId), ...);
}
private:
template<BlockFace Face>
const void getVerticesImp(std::vector<Vertex>& vertices, int offset, TextureAtlas& textureAtlas) const
{
if (!hasNeighbor(Face))
{
unsigned faceValue = static_cast<unsigned>(Face);
std::array<Vertex, 6> mesh = getSingleBlockMesh<Face>(_localPos, _faceTexture[faceValue], textureAtlas);
vertices.reserve(vertices.size() + 6);
vertices.insert(vertices.end(), mesh.begin(), mesh.end());
}
}
};
| 22.333333 | 107 | 0.722499 | Harry09 |
c7cfc4d8a7c98de1980110212c8fd4f4f656f25a | 4,927 | cpp | C++ | osrm-backend/src/engine/engine.cpp | shiyuan/osrm | ce730ce5e471870b86b460c09051cd301476ef07 | [
"MIT"
] | 1 | 2017-04-15T22:58:23.000Z | 2017-04-15T22:58:23.000Z | src/engine/engine.cpp | zummach/osrm | 7ab1b0893729064aa35b29d78cec605eb9831433 | [
"BSD-2-Clause"
] | 1 | 2019-11-21T09:59:27.000Z | 2019-11-21T09:59:27.000Z | osrm-ch/src/engine/engine.cpp | dingchunda/osrm-backend | 8750749b83bd9193ca3481c630eefda689ecb73c | [
"BSD-2-Clause"
] | null | null | null | #include "engine/api/route_parameters.hpp"
#include "engine/engine.hpp"
#include "engine/engine_config.hpp"
#include "engine/status.hpp"
#include "engine/plugins/match.hpp"
#include "engine/plugins/nearest.hpp"
#include "engine/plugins/table.hpp"
#include "engine/plugins/tile.hpp"
#include "engine/plugins/trip.hpp"
#include "engine/plugins/viaroute.hpp"
#include "engine/datafacade/datafacade_base.hpp"
#include "engine/datafacade/internal_datafacade.hpp"
#include "engine/datafacade/shared_datafacade.hpp"
#include "storage/shared_barriers.hpp"
#include "util/make_unique.hpp"
#include "util/simple_logger.hpp"
#include <boost/assert.hpp>
#include <boost/interprocess/sync/named_condition.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/sync/sharable_lock.hpp>
#include <boost/thread/lock_types.hpp>
#include <algorithm>
#include <fstream>
#include <utility>
#include <vector>
namespace
{
// Abstracted away the query locking into a template function
// Works the same for every plugin.
template <typename ParameterT, typename PluginT, typename ResultT>
osrm::engine::Status
RunQuery(const std::unique_ptr<osrm::storage::SharedBarriers> &lock,
osrm::engine::datafacade::BaseDataFacade &facade,
const ParameterT ¶meters,
PluginT &plugin,
ResultT &result)
{
if (!lock)
{
return plugin.HandleRequest(parameters, result);
}
BOOST_ASSERT(lock);
// this locks aquires shared ownership of the query mutex: other requets are allowed
// to run, but data updates need to wait for all queries to finish until they can aquire an exclusive lock
boost::interprocess::sharable_lock<boost::interprocess::named_sharable_mutex> query_lock(
lock->query_mutex);
auto &shared_facade = static_cast<osrm::engine::datafacade::SharedDataFacade &>(facade);
shared_facade.CheckAndReloadFacade();
// Get a shared data lock so that other threads won't update
// things while the query is running
boost::shared_lock<boost::shared_mutex> data_lock{shared_facade.data_mutex};
osrm::engine::Status status = plugin.HandleRequest(parameters, result);
return status;
}
template <typename Plugin, typename Facade, typename... Args>
std::unique_ptr<Plugin> create(Facade &facade, Args... args)
{
return osrm::util::make_unique<Plugin>(facade, std::forward<Args>(args)...);
}
} // anon. ns
namespace osrm
{
namespace engine
{
Engine::Engine(const EngineConfig &config)
: lock(config.use_shared_memory ? std::make_unique<storage::SharedBarriers>()
: std::unique_ptr<storage::SharedBarriers>())
{
if (config.use_shared_memory)
{
query_data_facade = util::make_unique<datafacade::SharedDataFacade>();
}
else
{
if (!config.storage_config.IsValid())
{
throw util::exception("Invalid file paths given!");
}
query_data_facade =
util::make_unique<datafacade::InternalDataFacade>(config.storage_config);
}
// Register plugins
using namespace plugins;
route_plugin = create<ViaRoutePlugin>(*query_data_facade, config.max_locations_viaroute);
table_plugin = create<TablePlugin>(*query_data_facade, config.max_locations_distance_table);
nearest_plugin = create<NearestPlugin>(*query_data_facade, config.max_results_nearest);
trip_plugin = create<TripPlugin>(*query_data_facade, config.max_locations_trip);
match_plugin = create<MatchPlugin>(*query_data_facade, config.max_locations_map_matching);
tile_plugin = create<TilePlugin>(*query_data_facade);
}
// make sure we deallocate the unique ptr at a position where we know the size of the plugins
Engine::~Engine() = default;
Engine::Engine(Engine &&) noexcept = default;
Engine &Engine::operator=(Engine &&) noexcept = default;
Status Engine::Route(const api::RouteParameters ¶ms, util::json::Object &result) const
{
return RunQuery(lock, *query_data_facade, params, *route_plugin, result);
}
Status Engine::Table(const api::TableParameters ¶ms, util::json::Object &result) const
{
return RunQuery(lock, *query_data_facade, params, *table_plugin, result);
}
Status Engine::Nearest(const api::NearestParameters ¶ms, util::json::Object &result) const
{
return RunQuery(lock, *query_data_facade, params, *nearest_plugin, result);
}
Status Engine::Trip(const api::TripParameters ¶ms, util::json::Object &result) const
{
return RunQuery(lock, *query_data_facade, params, *trip_plugin, result);
}
Status Engine::Match(const api::MatchParameters ¶ms, util::json::Object &result) const
{
return RunQuery(lock, *query_data_facade, params, *match_plugin, result);
}
Status Engine::Tile(const api::TileParameters ¶ms, std::string &result) const
{
return RunQuery(lock, *query_data_facade, params, *tile_plugin, result);
}
} // engine ns
} // osrm ns
| 33.97931 | 110 | 0.733509 | shiyuan |
c7d021bca8c0f014831ab539c537d48241ef27ec | 855 | cpp | C++ | Old Files/SingleRoad_Square/alpha_sq.cpp | karenl7/stlhj | c3f35aefe81e2f6c721e4723ba4d07930b2661e7 | [
"MIT"
] | 6 | 2019-01-30T00:11:55.000Z | 2022-03-09T02:44:51.000Z | Old Files/SingleRoad_Square/alpha_sq.cpp | StanfordASL/stlhj | c3f35aefe81e2f6c721e4723ba4d07930b2661e7 | [
"MIT"
] | null | null | null | Old Files/SingleRoad_Square/alpha_sq.cpp | StanfordASL/stlhj | c3f35aefe81e2f6c721e4723ba4d07930b2661e7 | [
"MIT"
] | 4 | 2018-09-08T00:16:55.000Z | 2022-03-09T02:44:54.000Z | void alpha_sq(
beacls::FloatVec& alpha,
beacls::FloatVec xs,
FLOAT_TYPE dim,
const size_t numel,
FLOAT_TYPE alpha_offset,
FLOAT_TYPE length){
if (dim == 0){
std::transform(xs.cbegin(), xs.cend(), alpha.begin(),
[alpha_offset, length](const auto &xs_i) {
return 1- std::pow(((xs_i - alpha_offset)/length),2); });
}
else if (dim == 1) {
beacls::FloatVec alpha_temp;
alpha_temp.assign(numel, 0.);
std::transform(xs.cbegin(), xs.cend(), alpha_temp.begin(),
[alpha_offset, length](const auto &xs_i) {
return 1- std::pow(((xs_i - alpha_offset)/length),2); });
std::transform(alpha_temp.cbegin(), alpha_temp.cend(), alpha.begin(), alpha.begin(),
[](const auto &alpha_temp_i, const auto &alpha_i) {
return std::min(alpha_temp_i,alpha_i); });
}
}
| 31.666667 | 88 | 0.604678 | karenl7 |
c7d413983e1c4fa4031ac193ad74a471a07255e1 | 31,837 | cpp | C++ | share/prototypes/bootstrap-redux/basecode/language/core/parser/parser.cpp | basecode-lang/bootstrap | 8e787e4fa66438e01897a67a026557f9fe7d5b57 | [
"MIT"
] | 32 | 2018-05-14T23:26:54.000Z | 2020-06-14T10:13:20.000Z | basecode/language/core/parser/parser.cpp | blockspacer/bootstrap-redux | 2d0e0d7d2b1f6f203c3dd01f6929805042db8ec7 | [
"MIT"
] | 79 | 2018-08-01T11:50:45.000Z | 2020-11-17T13:40:06.000Z | basecode/language/core/parser/parser.cpp | blockspacer/bootstrap-redux | 2d0e0d7d2b1f6f203c3dd01f6929805042db8ec7 | [
"MIT"
] | 14 | 2021-01-08T05:05:19.000Z | 2022-03-27T14:56:56.000Z | // ----------------------------------------------------------------------------
// ____ _
// | _\ | |
// | |_)| __ _ ___ ___ ___ ___ __| | ___ TM
// | _< / _` / __|/ _ \/ __/ _ \ / _` |/ _ \
// | |_)| (_| \__ \ __/ (_| (_) | (_| | __/
// |____/\__,_|___/\___|\___\___/ \__,_|\___|
//
// C O M P I L E R P R O J E C T
//
// Copyright (C) 2019 Jeff Panici
// All rights reserved.
//
// This software source file is licensed under the terms of MIT license.
// For details, please read the LICENSE file.
//
// ----------------------------------------------------------------------------
#include <utility>
#include <basecode/defer.h>
#include <basecode/adt/hashable.h>
#include <basecode/errors/errors.h>
#include "parser.h"
namespace basecode::language::core::parser {
parser_t::parser_t(
workspace::session_t& session,
utf8::source_buffer_t& buffer,
entity_list_t tokens) : _tokens(std::move(tokens)),
_session(session),
_buffer(buffer),
_scopes(session.allocator()),
_blocks(session.allocator()),
_parents(session.allocator()),
_rules(session.allocator()),
_frame_allocator(session.allocator()),
_rule_table(session.allocator()) {
}
bool parser_t::has_more() const {
return _token_index < _tokens.size()
&& _rules[_token_index]->id != lexer::token_type_t::end_of_input;
}
entity_t parser_t::token() const {
return _tokens[_token_index];
}
production_rule_t* parser_t::infix(
lexer::token_type_t token_type,
int32_t bp,
const led_callback_t& led) {
auto s = terminal(token_type, bp);
if (led) {
s->led = led;
} else {
s->led = [](context_t& ctx, entity_t lhs) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::binary_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::binary_operator_t>(
ast_node,
lhs,
ctx.parser->expression(*ctx.r, ctx.rule->lbp));
return ast_node;
};
}
return s;
}
production_rule_t* parser_t::prefix(
lexer::token_type_t token_type,
const nud_callback_t& nud) {
auto s = terminal(token_type);
if (nud) {
s->nud = nud;
} else {
s->nud = [](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::unary_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::unary_operator_t>(
ast_node,
ctx.parser->expression(*ctx.r, 80));
return ast_node;
};
}
return s;
}
production_rule_t* parser_t::postfix(
lexer::token_type_t token_type,
int32_t bp,
const led_callback_t& led) {
auto s = terminal(token_type, bp);
if (led) {
s->led = led;
} else {
s->led = [](context_t& ctx, entity_t lhs) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::unary_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::unary_operator_t>(ast_node, lhs);
return ast_node;
};
}
return s;
}
production_rule_t* parser_t::terminal(
lexer::token_type_t token_type,
int32_t bp) {
auto s = _rule_table.find(token_type);
if (s) {
if (bp >= s->lbp)
s->lbp = bp;
} else {
auto p = _frame_allocator.allocate(
sizeof(production_rule_t),
alignof(production_rule_t));
s = new (p) production_rule_t {
.id = token_type,
.lbp = bp,
.nud = [](context_t& ctx) {
const auto& loc = ctx.registry->get<source_location_t>(ctx.token);
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::undefined_production_rule,
loc);
return null_entity;
},
.led = [](context_t& ctx, entity_t lhs) {
const auto& loc = ctx.registry->get<source_location_t>(ctx.token);
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::missing_operator_production_rule,
loc);
return null_entity;
},
};
_rule_table.insert(token_type, s);
}
return s;
}
production_rule_t* parser_t::literal(
lexer::token_type_t token_type,
ast::node_type_t node_type) {
auto literal = prefix(
token_type,
[](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ctx.rule->detail.node_type,
ctx.token,
ctx.parent);
return ast_node;
});
literal->detail.node_type = node_type;
return literal;
}
production_rule_t* parser_t::constant(
lexer::token_type_t token_type,
ast::node_type_t node_type) {
auto constant = prefix(
token_type,
[](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ctx.rule->detail.node_type,
ctx.token,
ctx.parent);
return ast_node;
});
constant->detail.node_type = node_type;
return constant;
}
production_rule_t* parser_t::infix_right(
lexer::token_type_t token_type,
int32_t bp,
const led_callback_t& led) {
auto s = terminal(token_type, bp);
if (led) {
s->led = led;
} else {
s->led = [](context_t& ctx, entity_t lhs) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::binary_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::binary_operator_t>(
ast_node,
lhs,
ctx.parser->expression(*ctx.r, ctx.rule->lbp - 1));
return ast_node;
};
}
return s;
}
bool parser_t::apply(result_t& r) {
_rules.reserve(_tokens.size());
auto& registry = _session.registry();
for (auto entity : _tokens) {
const auto& token = registry.get<lexer::token_t>(entity);
auto s = _rule_table.find(token.type);
if (!s) {
const auto& loc = registry.get<source_location_t>(entity);
add_source_highlighted_error(
r,
errors::parser::invalid_token,
loc);
return false;
}
_rules.add(s);
}
return true;
}
entity_t parser_t::parse(result_t& r) {
auto& registry = _session.registry();
auto module_node = registry.create();
registry.assign<ast::node_t>(
module_node,
_session.allocator(),
ast::node_type_t::module,
null_entity,
null_entity);
auto scope_node = registry.create();
registry.assign<ast::node_t>(
scope_node,
_session.allocator(),
ast::node_type_t::scope,
null_entity,
module_node);
registry.assign<ast::scope_t>(
scope_node,
_session.allocator(),
null_entity);
auto block_node = registry.create();
registry.assign<ast::node_t>(
block_node,
_session.allocator(),
ast::node_type_t::block,
null_entity,
module_node);
registry.assign<ast::block_t>(
block_node,
_session.allocator(),
null_entity,
scope_node);
std::string_view name;
if (_buffer.path().empty()) {
name = _session.intern_pool().intern("(anonymous source)"sv);
} else {
auto base_filename = _buffer
.path()
.filename()
.replace_extension("");
name = _session.intern_pool().intern(base_filename.string());
}
registry.assign<ast::module_t>(
module_node,
_session.allocator(),
_buffer.path(),
name,
block_node);
_scopes.push(scope_node);
_blocks.push(block_node);
_parents.push(block_node);
while (has_more()) {
auto stmt_entity = registry.create();
registry.assign<ast::node_t>(
stmt_entity,
_session.allocator(),
ast::node_type_t::statement,
null_entity,
*_parents.top());
_parents.push(stmt_entity);
defer(_parents.pop());
_comma_rule->lbp = 25; // binding power for statements
auto expr = null_entity;
auto terminator_token = null_entity;
while (true) {
expr = expression(r);
if (expr == null_entity) {
const auto& loc = registry.get<source_location_t>(token());
add_source_highlighted_error(
r,
errors::parser::expected_expression,
loc);
return null_entity;
}
auto& expr_node = registry.get<ast::node_t>(expr);
auto& stmt_node = registry.get<ast::node_t>(stmt_entity);
switch (expr_node.type) {
case ast::node_type_t::directive: {
stmt_node.directives.add(expr);
expr = null_entity;
break;
}
case ast::node_type_t::annotation: {
stmt_node.annotations.add(expr);
expr = null_entity;
break;
}
case ast::node_type_t::line_comment:
case ast::node_type_t::block_comment: {
stmt_node.comments.add(expr);
expr = null_entity;
break;
}
default: {
break;
}
}
terminator_token = token();
const auto& t = registry.get<lexer::token_t>(terminator_token);
if (t.type == lexer::token_type_t::semicolon)
break;
}
if (!advance(r, lexer::token_type_t::semicolon))
break;
auto& stmt_node = registry.get<ast::node_t>(stmt_entity);
stmt_node.token = terminator_token;
registry.assign<ast::statement_t>(
stmt_entity,
_session.allocator(),
expr);
auto& block = registry.get<ast::block_t>(*_blocks.top());
block.children.add(stmt_entity);
}
_scopes.pop();
assert(_scopes.empty());
_blocks.pop();
assert(_blocks.empty());
_parents.pop();
assert(_parents.empty());
return module_node;
}
bool parser_t::initialize(result_t& r) {
terminal(lexer::token_type_t::comma);
terminal(lexer::token_type_t::semicolon);
terminal(lexer::token_type_t::right_paren);
terminal(lexer::token_type_t::right_bracket);
terminal(lexer::token_type_t::else_keyword);
terminal(lexer::token_type_t::end_of_input);
terminal(lexer::token_type_t::right_curly_brace);
postfix(lexer::token_type_t::caret, 80);
prefix(lexer::token_type_t::minus);
prefix(lexer::token_type_t::binary_not_operator);
prefix(lexer::token_type_t::logical_not_operator);
prefix(
lexer::token_type_t::line_comment,
[](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::line_comment,
ctx.token,
ctx.parent);
return ast_node;
});
prefix(
lexer::token_type_t::block_comment,
[](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::block_comment,
ctx.token,
ctx.parent);
return ast_node;
});
literal(lexer::token_type_t::block_literal, ast::node_type_t::block_literal);
literal(lexer::token_type_t::number_literal, ast::node_type_t::number_literal);
literal(lexer::token_type_t::string_literal, ast::node_type_t::string_literal);
constant(lexer::token_type_t::nil_keyword, ast::node_type_t::nil_literal);
constant(lexer::token_type_t::true_keyword, ast::node_type_t::boolean_literal);
constant(lexer::token_type_t::false_keyword, ast::node_type_t::boolean_literal);
constant(lexer::token_type_t::value_sink, ast::node_type_t::value_sink_literal);
constant(lexer::token_type_t::uninitialized, ast::node_type_t::uninitialized_literal);
infix_right(lexer::token_type_t::exponent_operator, 75);
infix_right(lexer::token_type_t::logical_or_operator, 30);
infix_right(lexer::token_type_t::logical_and_operator, 30);
infix(lexer::token_type_t::less_than, 40);
infix(lexer::token_type_t::in_operator, 40);
infix(lexer::token_type_t::greater_than, 40);
infix(lexer::token_type_t::equal_operator, 40);
infix(lexer::token_type_t::not_equal_operator, 40);
infix(lexer::token_type_t::inclusive_range_operator, 40);
infix(lexer::token_type_t::exclusive_range_operator, 40);
infix(lexer::token_type_t::less_than_equal_operator, 40);
infix(lexer::token_type_t::greater_than_equal_operator, 40);
infix(lexer::token_type_t::minus, 50);
infix(lexer::token_type_t::xor_operator, 70);
infix(lexer::token_type_t::shl_operator, 70);
infix(lexer::token_type_t::shr_operator, 70);
infix(lexer::token_type_t::rol_operator, 70);
infix(lexer::token_type_t::ror_operator, 70);
infix(lexer::token_type_t::add_operator, 50);
infix(lexer::token_type_t::divide_operator, 60);
infix(lexer::token_type_t::modulo_operator, 60);
infix(lexer::token_type_t::multiply_operator, 60);
infix(lexer::token_type_t::binary_or_operator, 70);
infix(lexer::token_type_t::binary_and_operator, 70);
// infix(
// lexer::token_type_t::block_comment,
// 10,
// [](context_t& ctx, entity_t lhs) {
// auto& node = ctx.registry->get<ast::node_t>(lhs);
// auto ast_node = ctx.registry->create();
// ctx.registry->assign<ast::node_t>(
// ast_node,
// ctx.allocator,
// ast::node_type_t::block_comment,
// ctx.token,
// ctx.parent);
// node.comments.add(ast_node);
// return ctx.parser->expression(*ctx.r, ctx.rule->lbp);
// });
assignment(lexer::token_type_t::bind_operator);
assignment(lexer::token_type_t::assignment_operator);
compound_assignment(
lexer::token_type_t::subtract_assignment_operator,
lexer::token_type_t::minus);
compound_assignment(
lexer::token_type_t::add_assignment_operator,
lexer::token_type_t::add_operator);
compound_assignment(
lexer::token_type_t::divide_assignment_operator,
lexer::token_type_t::divide_operator);
compound_assignment(
lexer::token_type_t::modulo_assignment_operator,
lexer::token_type_t::modulo_operator);
compound_assignment(
lexer::token_type_t::multiply_assignment_operator,
lexer::token_type_t::multiply_operator);
compound_assignment(
lexer::token_type_t::binary_or_assignment_operator,
lexer::token_type_t::binary_or_operator);
compound_assignment(
lexer::token_type_t::binary_and_assignment_operator,
lexer::token_type_t::binary_and_operator);
infix_right(lexer::token_type_t::lambda_operator, 20);
infix_right(lexer::token_type_t::associative_operator, 20);
_comma_rule = infix_right(lexer::token_type_t::comma, 25);
infix(
lexer::token_type_t::left_bracket,
90,
[](context_t& ctx, entity_t lhs) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::binary_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::binary_operator_t>(
ast_node,
lhs,
ctx.parser->expression(*ctx.r));
if (!ctx.parser->advance(*ctx.r, lexer::token_type_t::right_bracket))
return null_entity;
return ast_node;
});
infix(
lexer::token_type_t::member_select_operator,
90,
[](context_t& ctx, entity_t lhs) {
source_location_t loc;
if (!ctx.parser->is_node_valid_lvalue(lhs, loc)) {
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::member_select_operator_requires_identifier_lvalue,
loc);
return null_entity;
}
auto rhs_token = ctx.parser->token();
if (!ctx.parser->advance(*ctx.r, lexer::token_type_t::identifier))
return null_entity;
auto rhs_ident_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
rhs_ident_node,
ctx.allocator,
ast::node_type_t::identifier,
rhs_token,
ctx.parent);
ctx.registry->assign<ast::identifier_t>(
rhs_ident_node,
ctx.scope,
ctx.block);
auto& token = ctx.registry->get<lexer::token_t>(rhs_token);
auto& scope = ctx.registry->get<ast::scope_t>(ctx.scope);
scope.identifiers.insert(token.value, rhs_ident_node);
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::binary_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::binary_operator_t>(ast_node, lhs, rhs_ident_node);
return ast_node;
});
prefix(
lexer::token_type_t::left_paren,
[](context_t& ctx) {
auto expr = ctx.parser->expression(*ctx.r);
if (!ctx.parser->advance(*ctx.r, lexer::token_type_t::right_paren))
return null_entity;
return expr;
});
prefix(
lexer::token_type_t::identifier,
[](context_t& ctx) {
auto& scope = ctx.registry->get<ast::scope_t>(ctx.scope);
auto& token = ctx.registry->get<lexer::token_t>(ctx.token);
auto var = scope.identifiers.search(token.value);
if (var) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::identifier_reference,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::identifier_ref_t>(ast_node, *var);
return ast_node;
}
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::identifier,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::identifier_t>(
ast_node,
ctx.scope,
ctx.block);
scope.identifiers.insert(token.value, ast_node);
return ast_node;
});
prefix(
lexer::token_type_t::annotation,
[](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::annotation,
ctx.token,
ctx.parent);
auto& annotation = ctx.registry->assign<ast::annotation_t>(ast_node);
annotation.lhs = ctx.parser->expression(*ctx.r, 0);
annotation.rhs = ctx.parser->expression(*ctx.r, 0);
return ast_node;
});
prefix(
lexer::token_type_t::directive,
[](context_t& ctx) {
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::directive,
ctx.token,
ctx.parent);
auto& directive = ctx.registry->assign<ast::directive_t>(ast_node);
directive.lhs = ctx.parser->expression(*ctx.r, 0);
directive.rhs = ctx.parser->expression(*ctx.r, 0);
return ast_node;
});
return apply(r);
}
production_rule_t* parser_t::rule() const {
return _rules[_token_index];
}
void parser_t::comma_binding_power(int32_t bp) {
_comma_rule->lbp = bp;
}
production_rule_t* parser_t::compound_assignment(
lexer::token_type_t token_type,
lexer::token_type_t op_type) {
auto rule = infix(
token_type,
20,
[](context_t& ctx, entity_t lhs) {
{
source_location_t loc;
if (!ctx.parser->is_node_valid_lvalue(lhs, loc)) {
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::assignment_requires_valid_lvalue,
loc);
return null_entity;
}
}
auto rhs = ctx.parser->expression(
*ctx.r,
ctx.rule->lbp - 1);
if (rhs == null_entity)
return null_entity;
const auto& rhs_node = ctx.registry->get<ast::node_t>(rhs);
if (rhs_node.type == ast::node_type_t::assignment_operator) {
const auto& loc = ctx.registry->get<source_location_t>(rhs_node.token);
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::invalid_assignment_expression,
loc);
return null_entity;
}
const auto& token = ctx.registry->get<lexer::token_t>(ctx.token);
auto bin_op_token = ctx.registry->create();
ctx.registry->assign<lexer::token_t>(
bin_op_token,
ctx.rule->detail.op_type,
std::string_view(token.value.data(), 1));
auto bin_op_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
bin_op_node,
ctx.allocator,
ast::node_type_t::binary_operator,
bin_op_token,
ctx.parent);
ctx.registry->assign<ast::binary_operator_t>(bin_op_node, lhs, rhs);
auto assignment_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
assignment_node,
ctx.allocator,
ast::node_type_t::assignment_operator,
ctx.token,
ctx.parent);
ctx.registry->assign<ast::assignment_operator_t>(assignment_node, lhs, bin_op_node);
return assignment_node;
});
rule->detail.op_type = op_type;
return rule;
}
entity_t parser_t::expression(result_t& r, int32_t rbp) {
if (!has_more()) return null_entity;
auto current_rule = rule();
auto current_token = token();
context_t ctx{
.r = &r,
.parser = this,
.rule = current_rule,
.token = current_token,
.scope = *_scopes.top(),
.block = *_blocks.top(),
.parent = *_parents.top(),
.registry = &_session.registry(),
.allocator = _session.allocator()
};
if (!advance(r))
return null_entity;
auto lhs = current_rule->nud(ctx);
auto next_rule = rule();
while (rbp < next_rule->lbp) {
ctx.token = token();
ctx.rule = next_rule;
ctx.scope = *_scopes.top();
ctx.block = *_blocks.top();
ctx.parent = *_parents.top();
if (!advance(r)) return null_entity;
lhs = next_rule->led(ctx, lhs);
next_rule = rule();
}
return lhs;
}
bool parser_t::expect(result_t& r, lexer::token_type_t type) {
if (type == lexer::token_type_t::none) return true;
auto entity = token();
auto& registry = _session.registry();
const auto& t = registry.get<lexer::token_t>(entity);
if (type != t.type) {
const auto& loc = registry.get<source_location_t>(entity);
add_source_highlighted_error(
r,
errors::parser::unexpected_token,
loc,
lexer::token_type_to_name(type),
lexer::token_type_to_name(t.type));
return false;
}
return true;
}
bool parser_t::advance(result_t& r, lexer::token_type_t type) {
if (type != lexer::token_type_t::none && !expect(r, type))
return false;
if (_token_index < _tokens.size()) {
++_token_index;
return true;
} else {
return false;
}
}
production_rule_t* parser_t::assignment(lexer::token_type_t token_type) {
return infix(
token_type,
20,
[](context_t& ctx, entity_t lhs) {
{
source_location_t loc;
if (!ctx.parser->is_node_valid_lvalue(lhs, loc)) {
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::assignment_requires_valid_lvalue,
loc);
return null_entity;
}
}
auto ast_node = ctx.registry->create();
ctx.registry->assign<ast::node_t>(
ast_node,
ctx.allocator,
ast::node_type_t::assignment_operator,
ctx.token,
ctx.parent);
auto rhs = ctx.parser->expression(
*ctx.r,
ctx.rule->lbp - 1);
if (rhs == null_entity)
return null_entity;
const auto& node = ctx.registry->get<ast::node_t>(rhs);
if (node.type == ast::node_type_t::assignment_operator) {
const auto& loc = ctx.registry->get<source_location_t>(node.token);
ctx.parser->add_source_highlighted_error(
*ctx.r,
errors::parser::invalid_assignment_expression,
loc);
return null_entity;
}
ctx.registry->assign<ast::assignment_operator_t>(
ast_node,
lhs,
rhs);
return ast_node;
});
}
bool parser_t::is_node_valid_lvalue(entity_t expr, source_location_t& loc) {
auto& registry = _session.registry();
const auto node = registry.try_get<ast::node_t>(expr);
if (!node) return false;
if (node->type == ast::node_type_t::identifier
|| node->type == ast::node_type_t::identifier_reference) {
return true;
}
if (node->type == ast::node_type_t::binary_operator) {
const auto& token = registry.get<lexer::token_t>(node->token);
if (token.type == lexer::token_type_t::comma
|| token.type == lexer::token_type_t::left_bracket
|| token.type == lexer::token_type_t::member_select_operator) {
return true;
}
}
if (node->type == ast::node_type_t::unary_operator) {
const auto& token = registry.get<lexer::token_t>(node->token);
if (token.type == lexer::token_type_t::caret) {
return true;
}
}
loc = registry.get<source_location_t>(node->token);
return false;
}
}
| 36.385143 | 100 | 0.493106 | basecode-lang |
93a87647d6418306fc902f4418cb4125cef44ff0 | 1,683 | hpp | C++ | System.Windows.Forms/include/Switch/System/Windows/Forms/FormBorderStyle.hpp | kkptm/CppLikeCSharp | b2d8d9da9973c733205aa945c9ba734de0c734bc | [
"MIT"
] | 4 | 2021-10-14T01:43:00.000Z | 2022-03-13T02:16:08.000Z | System.Windows.Forms/include/Switch/System/Windows/Forms/FormBorderStyle.hpp | kkptm/CppLikeCSharp | b2d8d9da9973c733205aa945c9ba734de0c734bc | [
"MIT"
] | null | null | null | System.Windows.Forms/include/Switch/System/Windows/Forms/FormBorderStyle.hpp | kkptm/CppLikeCSharp | b2d8d9da9973c733205aa945c9ba734de0c734bc | [
"MIT"
] | 2 | 2022-03-13T02:16:06.000Z | 2022-03-14T14:32:57.000Z | /// @file
/// @brief Contains Switch::System::Windows::Forms::BorderStyle enum.
#pragma once
#include <Switch/System/Enum.hpp>
namespace Switch {
namespace System {
namespace Windows {
namespace Forms {
/// @brief Specifies the border styles for a form.
enum class FormBorderStyle {
/// @brief No border.
None,
/// @brief A fixed, single-line border.
FixedSingle,
/// @brief A fixed, three-dimensional border.
Fixed3D,
/// @brief A thick, fixed dialog-style border.
FixedDialog = 3,
/// @brief A resizable border.
Sizable = 4,
/// @brief A tool window border
FixedToolWindow = 5,
/// @brief A resizable tool window border.
SizableToolWindow = 6,
};
}
}
}
}
/// @cond
template<>
struct EnumRegister<System::Windows::Forms::FormBorderStyle> {
void operator()(System::Collections::Generic::IDictionary<System::Windows::Forms::FormBorderStyle, string>& values, bool& flags) {
values[System::Windows::Forms::FormBorderStyle::None] = "None";
values[System::Windows::Forms::FormBorderStyle::FixedSingle] = "FixedSingle";
values[System::Windows::Forms::FormBorderStyle::Fixed3D] = "Fixed3D";
values[System::Windows::Forms::FormBorderStyle::FixedDialog] = "FixedDialog";
values[System::Windows::Forms::FormBorderStyle::Sizable] = "Sizable";
values[System::Windows::Forms::FormBorderStyle::FixedToolWindow] = "FixedToolWindow";
values[System::Windows::Forms::FormBorderStyle::Fixed3D] = "SizableToolWindow";
flags = false;
}
};
/// @endcond
using namespace Switch;
| 33.66 | 132 | 0.639929 | kkptm |
93aed6408e1594864ceb8cde169762462cd38966 | 5,248 | cpp | C++ | SDK/PUBG_ReplayEditorStepperWidget_functions.cpp | realrespecter/PUBG-FULL-SDK | 5e2b0f103c74c95d2329c4c9dfbfab48aa0da737 | [
"MIT"
] | 7 | 2019-03-06T11:04:52.000Z | 2019-07-10T20:00:51.000Z | SDK/PUBG_ReplayEditorStepperWidget_functions.cpp | realrespecter/PUBG-FULL-SDK | 5e2b0f103c74c95d2329c4c9dfbfab48aa0da737 | [
"MIT"
] | null | null | null | SDK/PUBG_ReplayEditorStepperWidget_functions.cpp | realrespecter/PUBG-FULL-SDK | 5e2b0f103c74c95d2329c4c9dfbfab48aa0da737 | [
"MIT"
] | 10 | 2019-03-06T11:53:46.000Z | 2021-02-18T14:01:11.000Z | // PUBG FULL SDK - Generated By Respecter (5.3.4.11 [06/03/2019]) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "PUBG_ReplayEditorStepperWidget_parameters.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.AddItem
// ()
// Parameters:
// class FString* KeyItem (Parm, ZeroConstructor)
void UReplayEditorStepperWidget_C::AddItem(class FString* KeyItem)
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.AddItem");
UReplayEditorStepperWidget_C_AddItem_Params params;
params.KeyItem = KeyItem;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.SetItem
// ()
// Parameters:
// class FString* KeyItem (Parm, ZeroConstructor)
void UReplayEditorStepperWidget_C::SetItem(class FString* KeyItem)
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.SetItem");
UReplayEditorStepperWidget_C_SetItem_Params params;
params.KeyItem = KeyItem;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.GetSelectedItem
// ()
// Parameters:
// class FString CurItem (Parm, OutParm, ZeroConstructor)
void UReplayEditorStepperWidget_C::GetSelectedItem(class FString* CurItem)
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.GetSelectedItem");
UReplayEditorStepperWidget_C_GetSelectedItem_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
if (CurItem != nullptr)
*CurItem = params.CurItem;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.ShowCurString
// ()
void UReplayEditorStepperWidget_C::ShowCurString()
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.ShowCurString");
UReplayEditorStepperWidget_C_ShowCurString_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.Construct
// (BlueprintCosmetic, Event)
void UReplayEditorStepperWidget_C::Construct()
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.Construct");
UReplayEditorStepperWidget_C_Construct_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.BndEvt__ButtonLeft_K2Node_ComponentBoundEvent_155_OnButtonClickedEvent__DelegateSignature
// ()
void UReplayEditorStepperWidget_C::BndEvt__ButtonLeft_K2Node_ComponentBoundEvent_155_OnButtonClickedEvent__DelegateSignature()
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.BndEvt__ButtonLeft_K2Node_ComponentBoundEvent_155_OnButtonClickedEvent__DelegateSignature");
UReplayEditorStepperWidget_C_BndEvt__ButtonLeft_K2Node_ComponentBoundEvent_155_OnButtonClickedEvent__DelegateSignature_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.BndEvt__ButtonRight_K2Node_ComponentBoundEvent_177_OnButtonClickedEvent__DelegateSignature
// ()
void UReplayEditorStepperWidget_C::BndEvt__ButtonRight_K2Node_ComponentBoundEvent_177_OnButtonClickedEvent__DelegateSignature()
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.BndEvt__ButtonRight_K2Node_ComponentBoundEvent_177_OnButtonClickedEvent__DelegateSignature");
UReplayEditorStepperWidget_C_BndEvt__ButtonRight_K2Node_ComponentBoundEvent_177_OnButtonClickedEvent__DelegateSignature_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.ExecuteUbergraph_ReplayEditorStepperWidget
// ()
// Parameters:
// int* EntryPoint (Parm, ZeroConstructor, IsPlainOldData)
void UReplayEditorStepperWidget_C::ExecuteUbergraph_ReplayEditorStepperWidget(int* EntryPoint)
{
static auto fn = UObject::FindObject<UFunction>("Function ReplayEditorStepperWidget.ReplayEditorStepperWidget_C.ExecuteUbergraph_ReplayEditorStepperWidget");
UReplayEditorStepperWidget_C_ExecuteUbergraph_ReplayEditorStepperWidget_Params params;
params.EntryPoint = EntryPoint;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| 30.870588 | 206 | 0.780869 | realrespecter |
93b19508039e9c7acd3fd32dae05e5fd7cf2933f | 35 | cpp | C++ | src/gui/gui.cpp | lchsk/knight-libs | 14cb06e4092bf78abd7a5d0d5313b10236ee8926 | [
"MIT"
] | null | null | null | src/gui/gui.cpp | lchsk/knight-libs | 14cb06e4092bf78abd7a5d0d5313b10236ee8926 | [
"MIT"
] | null | null | null | src/gui/gui.cpp | lchsk/knight-libs | 14cb06e4092bf78abd7a5d0d5313b10236ee8926 | [
"MIT"
] | null | null | null | #include "gui.hpp"
namespace K {}
| 8.75 | 18 | 0.657143 | lchsk |
93b6cd6f6932802b8424570691e10e609b4f97ed | 10,715 | hpp | C++ | include/memoria/prototypes/bt/container/bt_c_leaf_variable.hpp | victor-smirnov/memoria | c36a957c63532176b042b411b1646c536e71a658 | [
"BSL-1.0",
"Apache-2.0",
"OLDAP-2.8",
"BSD-3-Clause"
] | 2 | 2021-07-30T16:54:24.000Z | 2021-09-08T15:48:17.000Z | include/memoria/prototypes/bt/container/bt_c_leaf_variable.hpp | victor-smirnov/memoria | c36a957c63532176b042b411b1646c536e71a658 | [
"BSL-1.0",
"Apache-2.0",
"OLDAP-2.8",
"BSD-3-Clause"
] | null | null | null | include/memoria/prototypes/bt/container/bt_c_leaf_variable.hpp | victor-smirnov/memoria | c36a957c63532176b042b411b1646c536e71a658 | [
"BSL-1.0",
"Apache-2.0",
"OLDAP-2.8",
"BSD-3-Clause"
] | 2 | 2020-03-14T15:15:25.000Z | 2020-06-15T11:26:56.000Z |
// Copyright 2015 Victor Smirnov
//
// Licensed 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.
#pragma once
#include <memoria/prototypes/bt/tools/bt_tools.hpp>
#include <memoria/prototypes/bt/bt_macros.hpp>
#include <memoria/core/container/macros.hpp>
#include <memoria/prototypes/bt/nodes/leaf_node_so.hpp>
#include <memoria/prototypes/bt/nodes/branch_node_so.hpp>
#include <vector>
namespace memoria {
MEMORIA_V1_CONTAINER_PART_BEGIN(bt::LeafVariableName)
using typename Base::TreeNodePtr;
using typename Base::TreeNodeConstPtr;
using typename Base::Iterator;
using typename Base::Position;
using typename Base::TreePathT;
using typename Base::CtrSizeT;
using typename Base::BranchNodeEntry;
using typename Base::BlockUpdateMgr;
// TODO: noexcept
template <int32_t Stream>
struct InsertStreamEntryFn
{
template <
int32_t Idx,
typename SubstreamType,
typename Entry
>
VoidResult stream(SubstreamType&& obj, int32_t idx, const Entry& entry) noexcept
{
if (obj)
{
return obj.insert_entries(idx, 1, [&](psize_t block, psize_t row) -> const auto& {
return entry.get(bt::StreamTag<Stream>(), bt::StreamTag<Idx>(), block);
});
}
else {
return make_generic_error("Substream {} is empty", Idx);
}
}
template <typename CtrT, typename NTypes, typename... Args>
VoidResult treeNode(LeafNodeSO<CtrT, NTypes>& node, int32_t idx, Args&&... args) noexcept
{
MEMORIA_TRY_VOID(node.layout(255));
return node.template processSubstreams<IntList<Stream>>(*this, idx, std::forward<Args>(args)...);
}
};
template <int32_t Stream, typename Entry>
VoidResult ctr_try_insert_stream_entry_no_mgr(const TreeNodePtr& leaf, int32_t idx, const Entry& entry) noexcept
{
InsertStreamEntryFn<Stream> fn;
return self().leaf_dispatcher().dispatch(leaf, fn, idx, entry);
}
template <int32_t Stream, typename Entry>
bool ctr_try_insert_stream_entry(
Iterator& iter,
int32_t idx,
const Entry& entry
)
{
auto& self = this->self();
self.ctr_cow_clone_path(iter.path(), 0);
BlockUpdateMgr mgr(self);
self.ctr_update_block_guard(iter.iter_leaf());
mgr.add(iter.iter_leaf().as_mutable());
auto status = self.template ctr_try_insert_stream_entry_no_mgr<Stream>(iter.iter_leaf().as_mutable(), idx, entry);
if (status.is_error()) {
if (status.is_packed_error())
{
mgr.rollback();
return false;
}
else {
MEMORIA_PROPAGATE_ERROR(status).do_throw();
}
}
return true;
}
bool ctr_with_block_manager(
TreeNodePtr& leaf,
int structure_idx,
int stream_idx,
const std::function<VoidResult (int, int)>& insert_fn
)
{
auto& self = this->self();
BlockUpdateMgr mgr(self);
self.ctr_update_block_guard(leaf);
mgr.add(leaf);
VoidResult status = insert_fn(structure_idx, stream_idx);
if (status.is_ok()) {
return true;
}
else if (status.memoria_error()->error_category() == ErrorCategory::PACKED)
{
mgr.rollback();
return false;
}
else {
status.get_or_throw();
return false;
}
}
template <int32_t Stream>
struct RemoveFromLeafFn
{
template <
int32_t Idx,
typename SubstreamType
>
VoidResult stream(SubstreamType&& obj, int32_t idx) noexcept
{
return obj.remove_entries(idx, 1);
}
template <typename CtrT, typename NTypes>
VoidResult treeNode(LeafNodeSO<CtrT, NTypes>& node, int32_t idx) noexcept
{
MEMORIA_TRY_VOID(node.layout(255));
return node.template processSubstreams<IntList<Stream>>(*this, idx);
}
};
template <int32_t Stream>
bool ctr_try_remove_stream_entry(TreePathT& path, int32_t idx)
{
auto& self = this->self();
self.ctr_cow_clone_path(path, 0);
BlockUpdateMgr mgr(self);
self.ctr_update_block_guard(path.leaf());
mgr.add(path.leaf().as_mutable());
RemoveFromLeafFn<Stream> fn;
VoidResult status = self.leaf_dispatcher().dispatch(path.leaf().as_mutable(), fn, idx);
if (status.is_ok()) {
return true;
}
else if (status.is_packed_error()) {
mgr.rollback();
return false;
}
else {
status.get_or_throw();
return false;
}
}
//=========================================================================================
template <typename SubstreamsList>
struct UpdateStreamEntryBufferFn
{
template <
int32_t StreamIdx,
int32_t AllocatorIdx,
int32_t Idx,
typename SubstreamType,
typename Entry
>
VoidResult stream(SubstreamType&& obj, int32_t idx, const Entry& entry) noexcept
{
return obj.update_entries(idx, 1, [&](auto block, auto){
return entry.get(bt::StreamTag<StreamIdx>(), bt::StreamTag<Idx>(), block);
});
}
template <typename CtrT, typename NTypes, typename... Args>
VoidResult treeNode(LeafNodeSO<CtrT, NTypes>& node, int32_t idx, Args&&... args) noexcept
{
return node.template processSubstreams<
SubstreamsList
>(
*this,
idx,
std::forward<Args>(args)...
);
}
};
template <typename SubstreamsList, typename Entry>
bool ctr_try_update_stream_entry(Iterator& iter, int32_t idx, const Entry& entry)
{
auto& self = this->self();
self.ctr_cow_clone_path(iter.path(), 0);
BlockUpdateMgr mgr(self);
self.ctr_update_block_guard(iter.iter_leaf().as_mutable());
mgr.add(iter.iter_leaf().as_mutable());
UpdateStreamEntryBufferFn<SubstreamsList> fn;
VoidResult status = self.leaf_dispatcher().dispatch(
iter.iter_leaf().as_mutable(),
fn,
idx,
entry
);
if (status.is_ok()) {
return true;
}
else if (status.memoria_error()->error_category() == ErrorCategory::PACKED)
{
mgr.rollback();
return false;
}
else {
status.get_or_throw();
return false;
}
}
template <typename Fn, typename... Args>
bool update(Iterator& iter, Fn&& fn, Args&&... args)
{
auto& self = this->self();
return self.ctr_update_atomic(iter, std::forward<Fn>(fn), VLSelector(), std::forward<Fn>(args)...);
}
MEMORIA_V1_DECLARE_NODE_FN(TryMergeNodesFn, mergeWith);
bool ctr_try_merge_leaf_nodes(TreePathT& tgt_path, TreePathT& src_path);
bool ctr_merge_leaf_nodes(TreePathT& tgt, TreePathT& src, bool only_if_same_parent = false);
bool ctr_merge_current_leaf_nodes(TreePathT& tgt, TreePathT& src);
MEMORIA_V1_CONTAINER_PART_END
#define M_TYPE MEMORIA_V1_CONTAINER_TYPE(bt::LeafVariableName)
#define M_PARAMS MEMORIA_V1_CONTAINER_TEMPLATE_PARAMS
M_PARAMS
bool M_TYPE::ctr_try_merge_leaf_nodes(TreePathT& tgt_path, TreePathT& src_path)
{
auto& self = this->self();
self.ctr_check_same_paths(tgt_path, src_path, 1);
auto src_parent = self.ctr_get_node_parent(src_path, 0);
auto parent_idx = self.ctr_get_child_idx(src_parent, src_path.leaf()->id());
self.ctr_cow_clone_path(tgt_path, 0);
BlockUpdateMgr mgr(self);
TreeNodeConstPtr tgt = tgt_path.leaf();
TreeNodeConstPtr src = src_path.leaf();
self.ctr_update_block_guard(tgt);
// FIXME: Need to leave src node untouched on merge.
mgr.add(tgt.as_mutable());
//MEMORIA_TRY(tgt_sizes, self.ctr_get_node_sizes(tgt));
VoidResult res = self.leaf_dispatcher().dispatch_1st_const(src, tgt.as_mutable(), TryMergeNodesFn());
if (res.is_error())
{
if (res.is_packed_error())
{
mgr.rollback();
return false;
}
else {
MEMORIA_PROPAGATE_ERROR(res).do_throw();
}
}
self.ctr_remove_non_leaf_node_entry(tgt_path, 1, parent_idx).get_or_throw();
self.ctr_update_path(tgt_path, 0);
self.ctr_cow_ref_children_after_merge(src.as_mutable());
self.ctr_unref_block(src->id());
self.ctr_check_path(tgt_path, 0);
return true;
}
M_PARAMS
bool M_TYPE::ctr_merge_leaf_nodes(TreePathT& tgt_path, TreePathT& src_path, bool only_if_same_parent)
{
auto& self = this->self();
auto same_parent = self.ctr_is_the_same_parent(tgt_path, src_path, 0);
if (same_parent)
{
auto merged = self.ctr_merge_current_leaf_nodes(tgt_path, src_path);
if (!merged)
{
self.ctr_assign_path_nodes(tgt_path, src_path);
self.ctr_expect_next_node(src_path, 0);
}
return merged;
}
else if (!only_if_same_parent)
{
auto merged = self.ctr_merge_branch_nodes(tgt_path, src_path, 1, only_if_same_parent);
self.ctr_assign_path_nodes(tgt_path, src_path, 0);
self.ctr_expect_next_node(src_path, 0);
if (merged)
{
return self.ctr_merge_current_leaf_nodes(tgt_path, src_path);
}
}
return false;
}
M_PARAMS
bool M_TYPE::ctr_merge_current_leaf_nodes(TreePathT& tgt, TreePathT& src)
{
auto& self = this->self();
auto merged = self.ctr_try_merge_leaf_nodes(tgt, src);
if (merged)
{
self.ctr_remove_redundant_root(tgt, 0);
return true;
}
else {
return false;
}
}
#undef M_TYPE
#undef M_PARAMS
}
| 26.522277 | 122 | 0.602706 | victor-smirnov |
93b8ae2ccb30914bf41e94c39d0ab0d2910f05d0 | 818 | cpp | C++ | codeforces/D - Minimum Triangulation/Accepted.cpp | kzvd4729/Problem-Solving | 13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab | [
"MIT"
] | 1 | 2022-02-11T16:55:36.000Z | 2022-02-11T16:55:36.000Z | codeforces/D - Minimum Triangulation/Accepted.cpp | kzvd4729/Problem-Solving | 13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab | [
"MIT"
] | null | null | null | codeforces/D - Minimum Triangulation/Accepted.cpp | kzvd4729/Problem-Solving | 13b105e725a4c2f8db7fecc5d7a8f932b9fef4ab | [
"MIT"
] | null | null | null | /****************************************************************************************
* @author: kzvd4729 created: Mar/22/2019 21:42
* solution_verdict: Accepted language: GNU C++14
* run_time: 31 ms memory_used: 0 KB
* problem: https://codeforces.com/contest/1140/problem/D
****************************************************************************************/
#include<bits/stdc++.h>
#define long long long
using namespace std;
const int N=1e6;
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);
int n;cin>>n;long ans=0;
for(long i=2;i<n;i++)
ans+=(i*(i+1));
cout<<ans<<endl;
return 0;
} | 43.052632 | 111 | 0.360636 | kzvd4729 |
93b9f51c946aa792d1050b0463bb5d673cc7ac2a | 6,155 | cpp | C++ | src/dio.cpp | johnsonjason/RVDbg | 63790440d3089bf74985171947483f5bfbcbe06b | [
"MIT"
] | 16 | 2019-09-05T01:12:21.000Z | 2022-01-10T12:33:31.000Z | src/dio.cpp | longmode/RVDbg | 63790440d3089bf74985171947483f5bfbcbe06b | [
"MIT"
] | null | null | null | src/dio.cpp | longmode/RVDbg | 63790440d3089bf74985171947483f5bfbcbe06b | [
"MIT"
] | 3 | 2018-09-07T08:51:26.000Z | 2019-01-06T07:39:13.000Z | #include "stdafx.h"
#include "dio.h"
/*++
Routine Description:
Initializes WSA data / Winsock
Parameters:
None
Return Value:
None
--*/
void dio::InitializeNetwork()
{
WSAData WsaData;
WSAStartup(MAKEWORD(2, 2), &WsaData);
}
/*++
Routine Description:
Starts the Debug Server, which interfaces with the Debug Client
The Debug Server is what receives user input while the Debug Client is the actual debugger that manipulates the process
Parameters:
Ip - The IP address for the debug server, typically loopback
Port - The port number to use for the debug server
Return Value:
None
--*/
dio::Server::Server(std::string Ip, std::uint16_t Port)
{
SOCKADDR_IN SocketAddress = { 0 };
SocketAddress.sin_addr.s_addr = inet_addr(Ip.c_str());
SocketAddress.sin_port = htons(Port);
SocketAddress.sin_family = AF_INET;
ServerSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
bind(ServerSocket, reinterpret_cast<SOCKADDR*>(&SocketAddress), sizeof(SocketAddress));
listen(ServerSocket, 1);
BoundDebugger = accept(ServerSocket, NULL, NULL);
}
dio::Server::~Server()
{
closesocket(this->ServerSocket);
closesocket(this->BoundDebugger);
}
/*++
Routine Description:
Sends a command to the debug client
Parameters:
ControlCode - A single byte-sized value that represents the type of command operation
CommandParamOne - Optional command parameter
CommandParamTwo - Optional command parameter
Return Value:
None
--*/
void dio::Server::SendCommand(BYTE ControlCode, DWORD_PTR CommandParamOne, DWORD_PTR CommandParamTwo)
{
//
// Create a buffer that can store ControlCode, CommandParamOne, and CommandParamTwo
//
const size_t ControlSize = sizeof(ControlCode) + sizeof(CommandParamOne) + sizeof(CommandParamTwo);
BYTE Buffer[ControlSize] = { 0 };
//
// Set each value in the buffer, separated and parsed by size
//
memset(Buffer, ControlCode, sizeof(ControlCode));
memcpy(Buffer + sizeof(ControlCode), &CommandParamOne, sizeof(CommandParamOne));
memcpy(Buffer + sizeof(ControlCode) + sizeof(CommandParamOne), &CommandParamTwo, sizeof(CommandParamTwo));
//
// Send the buffer's data to the debugger
//
send(BoundDebugger, reinterpret_cast<char*>(Buffer), sizeof(Buffer), 0);
}
/*++
Routine Description:
Receives a command from a debug client
Parameters:
None
Return Value:
None
--*/
std::tuple<BYTE, DWORD_PTR, DWORD_PTR> dio::Server::ReceiveCommand()
{
BYTE ControlCode = NULL;
DWORD_PTR CommandParamOne = NULL;
DWORD_PTR CommandParamTwo = NULL;
const size_t ControlSize = sizeof(BYTE) + sizeof(DWORD_PTR) + sizeof(DWORD_PTR);
BYTE Buffer[ControlSize] = { 0 };
DWORD Status = recv(BoundDebugger, reinterpret_cast<char*>(Buffer), sizeof(Buffer), 0);
if (Status == SOCKET_ERROR || Status == NULL)
{
return { CTL_ERROR_CON, 0, 0 };
}
//
// Parse the buffer into each individual command attribute
// Convert each individual command attribute into a tuple
//
memcpy(&ControlCode, Buffer, sizeof(ControlCode));
memcpy(&CommandParamOne, Buffer + sizeof(ControlCode), sizeof(CommandParamOne));
memcpy(&CommandParamTwo, Buffer + sizeof(ControlCode) + sizeof(CommandParamOne), sizeof(CommandParamTwo));
std::tuple<BYTE, DWORD_PTR, DWORD_PTR> Command(ControlCode, CommandParamOne, CommandParamTwo);
//
// If the control code is greater than 16...TBA
//
if (std::get<0>(Command) > 16)
{
}
return Command;
}
std::string dio::Server::ReceiveString()
{
char Buffer[2048] = { 0 };
recv(BoundDebugger, Buffer, sizeof(Buffer), 0);
return std::string(Buffer);
}
dio::Client::Client(std::string Ip, std::uint16_t Port)
{
SOCKADDR_IN SocketAddress = { 0 };
SocketAddress.sin_addr.s_addr = inet_addr(Ip.c_str());
SocketAddress.sin_port = htons(Port);
SocketAddress.sin_family = AF_INET;
ClientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
connect(ClientSocket, reinterpret_cast<SOCKADDR*>(&SocketAddress), sizeof(SocketAddress));
}
/*++
Routine Description:
Sends a command to the debug server
Parameters:
ControlCode - A single byte-sized value that represents the type of command operation
CommandParamOne - Optional command parameter
CommandParamTwo - Optional command parameter
Return Value:
None
--*/
void dio::Client::SendCommand(BYTE ControlCode, DWORD_PTR CommandParamOne, DWORD_PTR CommandParamTwo)
{
//
// Create a buffer that can store ControlCode, CommandParamOne, and CommandParamTwo
//
const size_t ControlSize = sizeof(ControlCode) + sizeof(CommandParamOne) + sizeof(CommandParamTwo);
BYTE Buffer[ControlSize] = { 0 };
//
// Set each value in the buffer, separated and parsed by size
//
memset(Buffer, ControlCode, sizeof(ControlCode));
memset(Buffer + sizeof(ControlCode), CommandParamOne, sizeof(CommandParamOne));
memset(Buffer + sizeof(ControlCode) + sizeof(CommandParamOne), CommandParamTwo, sizeof(CommandParamTwo));
//
// Send the buffer's data to the debugger
//
send(ClientSocket, reinterpret_cast<char*>(Buffer), sizeof(Buffer), 0);
}
/*++
Routine Description:
Receives a command from a debug server
Parameters:
None
Return Value:
None
--*/
std::tuple<BYTE, DWORD_PTR, DWORD_PTR> dio::Client::ReceiveCommand()
{
BYTE ControlCode = NULL;
DWORD_PTR CommandParamOne = NULL;
DWORD_PTR CommandParamTwo = NULL;
const size_t ControlSize = sizeof(BYTE) + sizeof(DWORD_PTR) + sizeof(DWORD_PTR);
BYTE Buffer[ControlSize] = { 0 };
DWORD Status = recv(ClientSocket, reinterpret_cast<char*>(Buffer), sizeof(Buffer), 0);
if (Status == SOCKET_ERROR || Status == NULL)
{
return { CTL_ERROR_CON, 0, 0 };
}
//
// Parse the buffer into each individual command attribute
// Convert each individual command attribute into a tuple
//
memcpy(&ControlCode, Buffer, sizeof(ControlCode));
memcpy(&CommandParamOne, Buffer + sizeof(ControlCode), sizeof(CommandParamOne));
memcpy(&CommandParamTwo, Buffer + sizeof(ControlCode) + sizeof(CommandParamOne), sizeof(CommandParamTwo));
std::tuple<BYTE, DWORD_PTR, DWORD_PTR> Command(ControlCode, CommandParamOne, CommandParamTwo);
return Command;
}
void dio::Client::SendString(std::string Data)
{
send(ClientSocket, Data.c_str(), Data.size(), 0);
}
| 23.314394 | 120 | 0.740374 | johnsonjason |
93bf148cd21c563abccc25de1deed48e7822c07d | 1,142 | cpp | C++ | gui/shapes/Line.cpp | TrapGameStudio/MouseTraps | 1160f8b6ef865b180f418bd6d83f40d59d938130 | [
"MIT"
] | null | null | null | gui/shapes/Line.cpp | TrapGameStudio/MouseTraps | 1160f8b6ef865b180f418bd6d83f40d59d938130 | [
"MIT"
] | null | null | null | gui/shapes/Line.cpp | TrapGameStudio/MouseTraps | 1160f8b6ef865b180f418bd6d83f40d59d938130 | [
"MIT"
] | 1 | 2020-04-19T23:20:25.000Z | 2020-04-19T23:20:25.000Z | #include "Line.h"
/// <summary>
/// Construct a line from 2 Points.
/// </summary>
/// <param name="p1">point 1</param>
/// <param name="p2">point 2</param>
Line::Line(Point* p1, Point* p2) {
this->p1 = p1;
this->p2 = p2;
}
/// <summary>
/// Construct a line from the coordinate of 2 points.
/// </summary>
/// <param name="x1">x coordinate of the first point</param>
/// <param name="y1">y coordinate of the first point</param>
/// <param name="x2">x coordinate of the second point</param>
/// <param name="y2">y coordinate of the second point</param>
Line::Line(float x1, float y1, float x2, float y2) {
p1 = new Point(x1, y1);
p2 = new Point(x2, y2);
}
/// <summary>
/// Get the length of the line.
/// </summary>
/// <returns>the length</returns>
float Line::length() {
return p1->getDistanceTo(p2);
}
int Line::compareTo(const Line* l) const {
float diff = this->p1->getDistanceSquareTo(this->p2) - l->p1->getDistanceSquareTo(l->p2);
if (diff == 0) {
return 0;
} else if (diff > 0) {
return 1;
} else {
return -1;
}
}
Line::~Line() {
delete p1;
delete p2;
}
| 22.84 | 93 | 0.595447 | TrapGameStudio |
93bf946d7e2beedad2beb2e86aceadfcfc7eaa1d | 1,385 | cpp | C++ | tutorial/more_basics/Expressions.cpp | luanics/cpp-illustrated | 6049de2119a53d656a63b65d9441e680355ef196 | [
"MIT"
] | null | null | null | tutorial/more_basics/Expressions.cpp | luanics/cpp-illustrated | 6049de2119a53d656a63b65d9441e680355ef196 | [
"MIT"
] | null | null | null | tutorial/more_basics/Expressions.cpp | luanics/cpp-illustrated | 6049de2119a53d656a63b65d9441e680355ef196 | [
"MIT"
] | null | null | null | #include "luanics/testing/Tutorial.hpp"
#include <type_traits>
BEGIN_CHAPTER(Expressions)
// As a reminder...
// Decltype
//
// X (input) -> decltype(X) (output)
// =================================================
// identifier of type T -> T
// -------------------------------------------------
// xvalue expression of type T -> T&&
// lvalue expression of type T -> T&
// prvalue expression of type T -> T
// =================================================
SECTION(Decltype) {
int x = 1;
int const y = 2;
int const & z = x;
// From Introspection.cpp: Variable names as identifiers
EXPECT_TRUE((std::is_same<FIX(bool), decltype(x)>::value));
EXPECT_TRUE((std::is_same<FIX(bool), decltype(y)>::value));
EXPECT_TRUE((std::is_same<FIX(bool), decltype(z)>::value));
// Variable names as expressions
EXPECT_TRUE((std::is_same<FIX(bool), decltype((x))>::value));
EXPECT_TRUE((std::is_same<FIX(bool), decltype((y))>::value));
EXPECT_TRUE((std::is_same<FIX(bool), decltype((z))>::value));
// Other expressions
EXPECT_TRUE((std::is_same<FIX(bool), decltype(std::move(x))>::value));
EXPECT_TRUE((std::is_same<FIX(bool), decltype(x + x)>::value));
}
SECTION(Literals) {
// What is the type of a literal expression? Note that it is NOT const
EXPECT_TRUE((std::is_same<FIX(int const), decltype(4)>::value));
}
END_CHAPTER(Expressions)
| 31.477273 | 71 | 0.587004 | luanics |
93c1749c635261908f933ed879fa893a9326b5b1 | 1,539 | cpp | C++ | apps/opencs/model/world/idtableproxymodel.cpp | Bodillium/openmw | 5fdd264d0704e33b44b1ccf17ab4fb721f362e34 | [
"Unlicense"
] | null | null | null | apps/opencs/model/world/idtableproxymodel.cpp | Bodillium/openmw | 5fdd264d0704e33b44b1ccf17ab4fb721f362e34 | [
"Unlicense"
] | null | null | null | apps/opencs/model/world/idtableproxymodel.cpp | Bodillium/openmw | 5fdd264d0704e33b44b1ccf17ab4fb721f362e34 | [
"Unlicense"
] | null | null | null |
#include "idtableproxymodel.hpp"
#include <vector>
#include "idtablebase.hpp"
void CSMWorld::IdTableProxyModel::updateColumnMap()
{
mColumnMap.clear();
if (mFilter)
{
std::vector<int> columns = mFilter->getReferencedColumns();
const IdTableBase& table = dynamic_cast<const IdTableBase&> (*sourceModel());
for (std::vector<int>::const_iterator iter (columns.begin()); iter!=columns.end(); ++iter)
mColumnMap.insert (std::make_pair (*iter,
table.searchColumnIndex (static_cast<CSMWorld::Columns::ColumnId> (*iter))));
}
}
bool CSMWorld::IdTableProxyModel::filterAcceptsRow (int sourceRow, const QModelIndex& sourceParent)
const
{
if (!mFilter)
return true;
return mFilter->test (
dynamic_cast<IdTableBase&> (*sourceModel()), sourceRow, mColumnMap);
}
CSMWorld::IdTableProxyModel::IdTableProxyModel (QObject *parent)
: QSortFilterProxyModel (parent)
{
setSortCaseSensitivity (Qt::CaseInsensitive);
}
QModelIndex CSMWorld::IdTableProxyModel::getModelIndex (const std::string& id, int column) const
{
return mapFromSource (dynamic_cast<IdTableBase&> (*sourceModel()).getModelIndex (id, column));
}
void CSMWorld::IdTableProxyModel::setFilter (const boost::shared_ptr<CSMFilter::Node>& filter)
{
mFilter = filter;
updateColumnMap();
invalidateFilter();
}
bool CSMWorld::IdTableProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
{
return QSortFilterProxyModel::lessThan(left, right);
}
| 27.482143 | 99 | 0.708902 | Bodillium |
93c3aaaf2f479fd8e17c86dc5e96d16e699a4d43 | 1,197 | cpp | C++ | Source/Windows/GithubIssuesWindow.cpp | humdingerb/Issues | 115ac2c3bc04e2f967fc884fa3fd7eb46aea6bbf | [
"MIT"
] | null | null | null | Source/Windows/GithubIssuesWindow.cpp | humdingerb/Issues | 115ac2c3bc04e2f967fc884fa3fd7eb46aea6bbf | [
"MIT"
] | null | null | null | Source/Windows/GithubIssuesWindow.cpp | humdingerb/Issues | 115ac2c3bc04e2f967fc884fa3fd7eb46aea6bbf | [
"MIT"
] | null | null | null | /*
* Copyright 2015 Your Name <[email protected]>
* All rights reserved. Distributed under the terms of the MIT license.
*/
#include "GithubIssuesWindow.h"
#include "GithubRepository.h"
#include "Constants.h"
#include "IssuesContainerView.h"
#include <interface/MenuBar.h>
#include <interface/MenuItem.h>
#include <interface/StringItem.h>
#include <interface/GroupLayout.h>
#include <interface/LayoutBuilder.h>
#include <posix/stdio.h>
GithubIssuesWindow::GithubIssuesWindow(GithubRepository *repository)
:BWindow(BRect(0,0,1,1), "Issues", B_TITLED_WINDOW, B_FRAME_EVENTS | B_AUTO_UPDATE_SIZE_LIMITS)
,fRepository(repository)
,fIssuesContainerView(NULL)
{
SetTitle(fRepository->name.String());
SetupViews();
CenterOnScreen();
}
GithubIssuesWindow::~GithubIssuesWindow()
{
}
void
GithubIssuesWindow::SetupViews()
{
fIssuesContainerView = new IssuesContainerView(fRepository->name, fRepository->owner);
fIssuesContainerView->SetExplicitMinSize(BSize(380, B_SIZE_UNSET));
fIssuesContainerView->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
SetLayout(new BGroupLayout(B_VERTICAL));
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.Add(fIssuesContainerView);
}
| 25.468085 | 96 | 0.785297 | humdingerb |
93c3ea338ec81545bc85c39ee99a047e03304c99 | 4,013 | cpp | C++ | test/separator_test.cpp | thm-mni-ii/sea | 3d3f63c3d17ab91f0aaada3c4315ba98367a3460 | [
"MIT"
] | 17 | 2019-01-03T11:17:31.000Z | 2021-10-31T19:19:41.000Z | test/separator_test.cpp | thm-mni-ii/sea | 3d3f63c3d17ab91f0aaada3c4315ba98367a3460 | [
"MIT"
] | 106 | 2018-03-03T16:37:17.000Z | 2020-08-31T09:24:52.000Z | test/separator_test.cpp | thm-mni-ii/sea | 3d3f63c3d17ab91f0aaada3c4315ba98367a3460 | [
"MIT"
] | 4 | 2018-05-21T13:30:01.000Z | 2019-06-12T07:43:43.000Z | #include <sealib/flow/separator.h>
#include <gtest/gtest.h>
#include <sealib/iterator/dfs.h>
#include <cstdio>
#include <cstdlib>
#include <random>
#include <sealib/collection/bitset.h>
#include <sealib/graph/graphcreator.h>
namespace Sealib {
static uint64_t n = 50;
static uint64_t deg = 4;
TEST(SeparatorTest, VSeparator) {
Bitset<> s = Bitset<>(n);
Bitset<> t = Bitset<>(n);
UndirectedGraph g = GraphCreator::kRegular(n, deg);
for (uint64_t i = 0; i < 5; i++) {
s.insert(i, true);
}
// finding 5 separate vertices from all s vertices
uint64_t nt = 5;
for (uint64_t i = 5; i < n; i++) {
bool align = false;
for (uint64_t j = 0; j < 5; j++) {
for (uint64_t k = 0; k < g.deg(j); k++) {
if (g.head(j, k) == i) align = true;
}
}
if (!align && nt > 0) {
t.insert(i, true);
nt--;
} else {
t.insert(i, false);
}
}
Bitset<> vs = Bitset<>(n);
vs = Separator::standardVSeparate(s, t, g, 50, DFS::getStandardDFSIterator);
// erase connections from other vertices to vertices in vs
for (uint64_t i = 0; i < n; i++) {
if (vs.get(i)) {
for (uint64_t j = 0; j < g.getNode(i).getDegree(); j++) {
g.getNode(g.getNode(i).getAdj()[j].first)
.getAdj()[g.getNode(i).getAdj()[j].second]
.first = g.getNode(i).getAdj()[j].first;
g.getNode(g.getNode(i).getAdj()[j].first)
.getAdj()[g.getNode(i).getAdj()[j].second]
.second = g.getNode(i).getAdj()[j].second;
}
}
}
// searching t vertices starting at all vertices in s
for (uint64_t i = 0; i < n; i++) {
if (s.get(i)) {
Iterator<UserCall> *iter = DFS::getStandardDFSIterator(g, i);
UserCall x = iter->next();
while (x.type != UserCall::postexplore || x.u != i) {
switch (x.type) {
case UserCall::preexplore:
if (t.get(x.u)) FAIL();
break;
}
x = iter->next();
}
free(iter);
}
}
SUCCEED();
}
TEST(SeparatorTest, ESeparator) {
Bitset<> s = Bitset<>(n);
Bitset<> t = Bitset<>(n);
UndirectedGraph g = GraphCreator::kRegular(n, deg);
for (uint64_t i = 0; i < 5; i++) {
s.insert(i, true);
}
// finding 5 separate vertices from all s vertices
uint64_t nt = 5;
for (uint64_t i = 5; i < n; i++) {
bool align = false;
for (uint64_t j = 0; j < 5; j++) {
for (uint64_t k = 0; k < g.deg(j); k++) {
if (g.head(j, k) == i) align = true;
}
}
if (!align && nt > 0) {
t.insert(i, true);
nt--;
} else {
t.insert(i, false);
}
}
std::vector<std::pair<uint64_t, uint64_t>> es;
es = Separator::standardESeparate(s, t, g, 50, DFS::getStandardDFSIterator);
// erase edges (make u = k)
for (uint64_t i = 0; i < es.size(); i++) {
for (uint64_t j = 0; j < g.getNode(es[i].first).getDegree(); j++) {
if (g.head(es[i].first, j) == es[i].second) {
g.getNode(es[i].first).getAdj()[j].first = es[i].first;
}
}
}
// searching t vertices starting at all vertices in s
for (uint64_t i = 0; i < n; i++) {
if (s.get(i)) {
Iterator<UserCall> *iter = DFS::getStandardDFSIterator(g, i);
UserCall x = iter->next();
while (x.type != UserCall::postexplore || x.u != i) {
switch (x.type) {
case UserCall::preexplore:
if (t.get(x.u)) FAIL();
break;
}
x = iter->next();
}
free(iter);
}
}
SUCCEED();
}
} // namespace Sealib
| 31.108527 | 80 | 0.468727 | thm-mni-ii |
93cbf0c0d0f9d7ce039184dff6cd44601027bdcf | 2,818 | cpp | C++ | dependencies-include/nxogre/src/NxOgreSimpleShape.cpp | bach74/Lisa | 6f79b909f734883cd05a0ccf8679199ae2e301cf | [
"MIT",
"Unlicense"
] | 2 | 2016-06-23T21:20:19.000Z | 2020-03-25T15:01:07.000Z | dependencies-include/nxogre/src/NxOgreSimpleShape.cpp | bach74/Lisa | 6f79b909f734883cd05a0ccf8679199ae2e301cf | [
"MIT",
"Unlicense"
] | null | null | null | dependencies-include/nxogre/src/NxOgreSimpleShape.cpp | bach74/Lisa | 6f79b909f734883cd05a0ccf8679199ae2e301cf | [
"MIT",
"Unlicense"
] | null | null | null | /** \file NxOgreSimpleShape.cpp
* \see NxOgreSimpleShape.h
* \version 1.0-21
*
* \licence NxOgre a wrapper for the PhysX physics library.
* Copyright (C) 2005-8 Robin Southern of NxOgre.org http://www.nxogre.org
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "NxOgreStable.h"
#include "NxOgreSimpleShape.h"
#include "NxOgreHelpers.h"
#include "OgreStringVector.h"
namespace NxOgre {
//////////////////////////////////////////////////////////////////////////////////////
SimpleShape* SimpleShape::createFromString(const NxString& str) {
Ogre::StringVector strings = Ogre::StringUtil::split(str, ":", 2);
SimpleShape* shape = 0;
if (strings.size() != 2)
return shape;
Ogre::StringUtil::toLowerCase(strings[0]);
Ogre::StringUtil::trim(strings[0]);
Ogre::StringUtil::trim(strings[1]);
if (strings[0] == "cube" || strings[0] == "box") {
NxVec3 size(1,1,1);
size = NxFromString<NxVec3>(strings[1]);
shape = new SimpleBox(size);
}
return shape;
}
//////////////////////////////////////////////////////////////////////////////////////
SimpleBox* SimpleShape::getAsBox() {
return static_cast<SimpleBox*>(this);
}
//////////////////////////////////////////////////////////////////////////////////////
SimpleSphere* SimpleShape::getAsSphere() {
return static_cast<SimpleSphere*>(this);
}
//////////////////////////////////////////////////////////////////////////////////////
SimpleCapsule* SimpleShape::getAsCapsule() {
return static_cast<SimpleCapsule*>(this);
}
//////////////////////////////////////////////////////////////////////////////////////
SimpleConvex* SimpleShape::getAsConvex() {
return static_cast<SimpleConvex*>(this);
}
//////////////////////////////////////////////////////////////////////////////////////
SimplePlane* SimpleShape::getAsPlane() {
return static_cast<SimplePlane*>(this);
}
//////////////////////////////////////////////////////////////////////////////////////
}; //End of NxOgre namespace.
| 32.767442 | 87 | 0.529808 | bach74 |
93d0c017e4c6a664c47d05878b8e336acba64bb3 | 762 | cpp | C++ | chtho/logging/tests/LogFile_test.cpp | WineChord/chtho | f43c56a1c2faf83e5f48361ca1b06366ce061aab | [
"MIT"
] | null | null | null | chtho/logging/tests/LogFile_test.cpp | WineChord/chtho | f43c56a1c2faf83e5f48361ca1b06366ce061aab | [
"MIT"
] | null | null | null | chtho/logging/tests/LogFile_test.cpp | WineChord/chtho | f43c56a1c2faf83e5f48361ca1b06366ce061aab | [
"MIT"
] | null | null | null | // Copyright (c) 2021 Qizhou Guo
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "chtho/logging/Logger.h"
#include "chtho/logging/LogFile.h"
#include <memory>
#include <unistd.h>
std::unique_ptr<chtho::LogFile> logfile;
void outputFunc(const char* msg, int len) { logfile->append(msg, len); }
void flushFunc() { logfile->flush(); }
int main(int argc, char* argv[]) {
// roll size is 200 KB
logfile.reset(new chtho::LogFile(::basename(argv[0]), 200*1000));
chtho::Logger::setOutput(outputFunc);
chtho::Logger::setFlush(flushFunc);
std::string line = "qwertyuioplkjhgfdsazxcvbnm0987654321";
for(int i = 0; i < 10000; ++i)
{
LOG_INFO << line << i;
usleep(1000); // sleep 1ms
}
} | 27.214286 | 72 | 0.678478 | WineChord |
93d6a97b2033a24daea2f1994741410bf62ec338 | 27,263 | cpp | C++ | DesktopSharing/xop/RtmpConnection.cpp | JungleZy/DesktopSharing | b8d551a50a3abad8f54db9e5a74d778725422f22 | [
"MIT"
] | 502 | 2018-06-12T14:48:54.000Z | 2022-03-31T07:33:00.000Z | DesktopSharing/xop/RtmpConnection.cpp | JungleZy/DesktopSharing | b8d551a50a3abad8f54db9e5a74d778725422f22 | [
"MIT"
] | 37 | 2018-11-23T20:43:27.000Z | 2021-12-24T07:39:17.000Z | DesktopSharing/xop/RtmpConnection.cpp | JungleZy/DesktopSharing | b8d551a50a3abad8f54db9e5a74d778725422f22 | [
"MIT"
] | 198 | 2018-06-13T13:19:05.000Z | 2022-03-30T07:32:20.000Z | #include "RtmpConnection.h"
#include "RtmpServer.h"
#include "RtmpPublisher.h"
#include "RtmpClient.h"
#include "net/Logger.h"
#include <random>
using namespace xop;
RtmpConnection::RtmpConnection(std::shared_ptr<RtmpServer> rtmp_server, TaskScheduler *task_scheduler, SOCKET sockfd)
: RtmpConnection(task_scheduler, sockfd, rtmp_server.get())
{
handshake_.reset(new RtmpHandshake(RtmpHandshake::HANDSHAKE_C0C1));
rtmp_server_ = rtmp_server;
connection_mode_ = RTMP_SERVER;
}
RtmpConnection::RtmpConnection(std::shared_ptr<RtmpPublisher> rtmp_publisher, TaskScheduler *task_scheduler, SOCKET sockfd)
: RtmpConnection(task_scheduler, sockfd, rtmp_publisher.get())
{
handshake_.reset(new RtmpHandshake(RtmpHandshake::HANDSHAKE_S0S1S2));
rtmp_publisher_ = rtmp_publisher;
connection_mode_ = RTMP_PUBLISHER;
}
RtmpConnection::RtmpConnection(std::shared_ptr<RtmpClient> rtmp_client, TaskScheduler *task_scheduler, SOCKET sockfd)
: RtmpConnection(task_scheduler, sockfd, rtmp_client.get())
{
handshake_.reset(new RtmpHandshake(RtmpHandshake::HANDSHAKE_S0S1S2));
rtmp_client_ = rtmp_client;
connection_mode_ = RTMP_CLIENT;
}
RtmpConnection::RtmpConnection(TaskScheduler *task_scheduler, SOCKET sockfd, Rtmp* rtmp)
: TcpConnection(task_scheduler, sockfd)
, task_scheduler_(task_scheduler)
, channel_(new Channel(sockfd))
, rtmp_chunk_(new RtmpChunk)
, connection_state_(HANDSHAKE)
{
peer_bandwidth_ = rtmp->GetPeerBandwidth();
acknowledgement_size_ = rtmp->GetAcknowledgementSize();
max_gop_cache_len_ = rtmp->GetGopCacheLen();
max_chunk_size_ = rtmp->GetChunkSize();
stream_path_ = rtmp->GetStreamPath();
stream_name_ = rtmp->GetStreamName();
app_ = rtmp->GetApp();
this->SetReadCallback([this](std::shared_ptr<TcpConnection> conn, xop::BufferReader& buffer) {
return this->OnRead(buffer);
});
this->SetCloseCallback([this](std::shared_ptr<TcpConnection> conn) {
this->OnClose();
});
}
RtmpConnection::~RtmpConnection()
{
}
bool RtmpConnection::OnRead(BufferReader& buffer)
{
bool ret = true;
if (handshake_->IsCompleted()) {
ret = HandleChunk(buffer);
}
else {
std::shared_ptr<char> res(new char[4096], std::default_delete<char[]>());
int res_size = handshake_->Parse(buffer, res.get(), 4096);
if (res_size < 0) {
ret = false;
}
if (res_size > 0) {
this->Send(res.get(), res_size);
}
if (handshake_->IsCompleted()) {
if(buffer.ReadableBytes() > 0) {
ret = HandleChunk(buffer);
}
if (connection_mode_ == RTMP_PUBLISHER ||
connection_mode_ == RTMP_CLIENT) {
this->SetChunkSize();
this->Connect();
}
}
}
return ret;
}
void RtmpConnection::OnClose()
{
if (connection_mode_ == RTMP_SERVER) {
this->HandleDeleteStream();
}
else if (connection_mode_ == RTMP_PUBLISHER) {
this->DeleteStream();
}
}
bool RtmpConnection::HandleChunk(BufferReader& buffer)
{
int ret = -1;
do
{
RtmpMessage rtmp_msg;
ret = rtmp_chunk_->Parse(buffer, rtmp_msg);
if (ret >= 0) {
if (rtmp_msg.IsCompleted()) {
if (!HandleMessage(rtmp_msg)) {
return false;
}
}
if (ret == 0) {
break;
}
}
else if (ret < 0) {
return false;
}
} while (buffer.ReadableBytes() > 0);
return true;
}
bool RtmpConnection::HandleMessage(RtmpMessage& rtmp_msg)
{
bool ret = true;
switch(rtmp_msg.type_id)
{
case RTMP_VIDEO:
ret = HandleVideo(rtmp_msg);
break;
case RTMP_AUDIO:
ret = HandleAudio(rtmp_msg);
break;
case RTMP_INVOKE:
ret = HandleInvoke(rtmp_msg);
break;
case RTMP_NOTIFY:
ret = HandleNotify(rtmp_msg);
break;
case RTMP_FLEX_MESSAGE:
LOG_INFO("unsupported rtmp flex message.\n");
ret = false;
break;
case RTMP_SET_CHUNK_SIZE:
rtmp_chunk_->SetInChunkSize(ReadUint32BE(rtmp_msg.payload.get()));
break;
case RTMP_BANDWIDTH_SIZE:
break;
case RTMP_FLASH_VIDEO:
LOG_INFO("unsupported rtmp flash video.\n");
ret = false;
break;
case RTMP_ACK:
break;
case RTMP_ACK_SIZE:
break;
case RTMP_USER_EVENT:
break;
default:
LOG_INFO("unkonw message type : %d\n", rtmp_msg.type_id);
break;
}
if (!ret) {
//printf("rtmp_msg.type_id:%x\n", rtmp_msg.type_id);
}
return ret;
}
bool RtmpConnection::HandleInvoke(RtmpMessage& rtmp_msg)
{
bool ret = true;
amf_decoder_.reset();
int bytes_used = amf_decoder_.decode((const char *)rtmp_msg.payload.get(), rtmp_msg.length, 1);
if (bytes_used < 0) {
return false;
}
std::string method = amf_decoder_.getString();
//LOG_INFO("[Method] %s\n", method.c_str());
if (connection_mode_ == RTMP_PUBLISHER || connection_mode_ == RTMP_CLIENT) {
bytes_used += amf_decoder_.decode(rtmp_msg.payload.get() + bytes_used, rtmp_msg.length - bytes_used);
if (method == "_result") {
ret = HandleResult(rtmp_msg);
}
else if (method == "onStatus") {
ret = HandleOnStatus(rtmp_msg);
}
}
else if (connection_mode_ == RTMP_SERVER) {
if(rtmp_msg.stream_id == 0) {
bytes_used += amf_decoder_.decode(rtmp_msg.payload.get()+bytes_used, rtmp_msg.length-bytes_used);
if(method == "connect") {
ret = HandleConnect();
}
else if(method == "createStream") {
ret = HandleCreateStream();
}
}
else if(rtmp_msg.stream_id == stream_id_) {
bytes_used += amf_decoder_.decode((const char *)rtmp_msg.payload.get()+bytes_used, rtmp_msg.length-bytes_used, 3);
stream_name_ = amf_decoder_.getString();
stream_path_ = "/" + app_ + "/" + stream_name_;
if((int)rtmp_msg.length > bytes_used) {
bytes_used += amf_decoder_.decode((const char *)rtmp_msg.payload.get()+bytes_used, rtmp_msg.length-bytes_used);
}
if(method == "publish") {
ret = HandlePublish();
}
else if(method == "play") {
ret = HandlePlay();
}
else if(method == "play2") {
ret = HandlePlay2();
}
else if(method == "DeleteStream") {
ret = HandleDeleteStream();
}
else if (method == "releaseStream") {
}
}
}
return ret;
}
bool RtmpConnection::HandleNotify(RtmpMessage& rtmp_msg)
{
amf_decoder_.reset();
int bytes_used = amf_decoder_.decode((const char *)rtmp_msg.payload.get(), rtmp_msg.length, 1);
if(bytes_used < 0) {
return false;
}
if(amf_decoder_.getString() == "@setDataFrame")
{
amf_decoder_.reset();
bytes_used = amf_decoder_.decode((const char *)rtmp_msg.payload.get()+bytes_used, rtmp_msg.length-bytes_used, 1);
if(bytes_used < 0) {
return false;
}
if(amf_decoder_.getString() == "onMetaData") {
amf_decoder_.decode((const char *)rtmp_msg.payload.get()+bytes_used, rtmp_msg.length-bytes_used);
meta_data_ = amf_decoder_.getObjects();
auto server = rtmp_server_.lock();
if (!server) {
return false;
}
auto session = server->GetSession(stream_path_);
if(session) {
session->SetMetaData(meta_data_);
session->SendMetaData(meta_data_);
}
}
}
return true;
}
bool RtmpConnection::HandleVideo(RtmpMessage& rtmp_msg)
{
uint8_t type = RTMP_VIDEO;
uint8_t *payload = (uint8_t *)rtmp_msg.payload.get();
uint32_t length = rtmp_msg.length;
uint8_t frame_type = (payload[0] >> 4) & 0x0f;
uint8_t codec_id = payload[0] & 0x0f;
if (connection_mode_ == RTMP_CLIENT) {
if (is_playing_ && connection_state_ == START_PLAY) {
if (play_cb_) {
play_cb_(payload, length, codec_id, (uint32_t)rtmp_msg._timestamp);
}
}
}
else if(connection_mode_ == RTMP_SERVER)
{
auto server = rtmp_server_.lock();
if (!server) {
return false;
}
auto session = server->GetSession(stream_path_);
if (session == nullptr) {
return false;
}
if (frame_type == 1 && codec_id == RTMP_CODEC_ID_H264) {
if (payload[1] == 0) {
avc_sequence_header_size_ = length;
avc_sequence_header_.reset(new char[length], std::default_delete<char[]>());
memcpy(avc_sequence_header_.get(), rtmp_msg.payload.get(), length);
session->SetAvcSequenceHeader(avc_sequence_header_, avc_sequence_header_size_);
type = RTMP_AVC_SEQUENCE_HEADER;
}
}
session->SendMediaData(type, rtmp_msg._timestamp, rtmp_msg.payload, rtmp_msg.length);
}
return true;
}
bool RtmpConnection::HandleAudio(RtmpMessage& rtmp_msg)
{
uint8_t type = RTMP_AUDIO;
uint8_t *payload = (uint8_t *)rtmp_msg.payload.get();
uint32_t length = rtmp_msg.length;
uint8_t sound_format = (payload[0] >> 4) & 0x0f;
//uint8_t sound_size = (payload[0] >> 1) & 0x01;
//uint8_t sound_rate = (payload[0] >> 2) & 0x03;
uint8_t codec_id = payload[0] & 0x0f;
if (connection_mode_ == RTMP_CLIENT) {
if (connection_state_ == START_PLAY && is_playing_) {
if (play_cb_) {
play_cb_(payload, length, codec_id, (uint32_t)rtmp_msg._timestamp);
}
}
}
else
{
auto server = rtmp_server_.lock();
if (!server) {
return false;
}
auto session = server->GetSession(stream_path_);
if (session == nullptr) {
return false;
}
if (sound_format == RTMP_CODEC_ID_AAC && payload[1] == 0) {
aac_sequence_header_size_ = rtmp_msg.length;
aac_sequence_header_.reset(new char[rtmp_msg.length], std::default_delete<char[]>());
memcpy(aac_sequence_header_.get(), rtmp_msg.payload.get(), rtmp_msg.length);
session->SetAacSequenceHeader(aac_sequence_header_, aac_sequence_header_size_);
type = RTMP_AAC_SEQUENCE_HEADER;
}
session->SendMediaData(type, rtmp_msg._timestamp, rtmp_msg.payload, rtmp_msg.length);
}
return true;
}
bool RtmpConnection::Handshake()
{
uint32_t req_size = 1 + 1536; //COC1
std::shared_ptr<char> req(new char[req_size], std::default_delete<char[]>());
handshake_->BuildC0C1(req.get(), req_size);
this->Send(req.get(), req_size);
return true;
}
bool RtmpConnection::Connect()
{
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("connect", 7);
amf_encoder_.encodeNumber((double)(++number_));
objects["app"] = AmfObject(app_);
objects["type"] = AmfObject(std::string("nonprivate"));
if (connection_mode_ == RTMP_PUBLISHER) {
auto publisher = rtmp_publisher_.lock();
if (!publisher) {
return false;
}
objects["swfUrl"] = AmfObject(publisher->GetSwfUrl());
objects["tcUrl"] = AmfObject(publisher->GetTcUrl());
}
else if (connection_mode_ == RTMP_CLIENT)
{
auto client = rtmp_client_.lock();
if (!client) {
return false;
}
objects["swfUrl"] = AmfObject(client->GetSwfUrl());
objects["tcUrl"] = AmfObject(client->GetTcUrl());
}
amf_encoder_.encodeObjects(objects);
connection_state_ = START_CONNECT;
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
return true;
}
bool RtmpConnection::CretaeStream()
{
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("createStream", 12);
amf_encoder_.encodeNumber((double)(++number_));
amf_encoder_.encodeObjects(objects);
connection_state_ = START_CREATE_STREAM;
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
return true;
}
bool RtmpConnection::Publish()
{
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("publish", 7);
amf_encoder_.encodeNumber((double)(++number_));
amf_encoder_.encodeObjects(objects);
amf_encoder_.encodeString(stream_name_.c_str(), (int)stream_name_.size());
connection_state_ = START_PUBLISH;
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
return true;
}
bool RtmpConnection::Play()
{
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("play", 4);
amf_encoder_.encodeNumber((double)(++number_));
amf_encoder_.encodeObjects(objects);
amf_encoder_.encodeString(stream_name_.c_str(), (int)stream_name_.size());
connection_state_ = START_PLAY;
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
return true;
}
bool RtmpConnection::DeleteStream()
{
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("DeleteStream", 12);
amf_encoder_.encodeNumber((double)(++number_));
amf_encoder_.encodeObjects(objects);
amf_encoder_.encodeNumber(stream_id_);
connection_state_ = START_DELETE_STREAM;
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
return true;
}
bool RtmpConnection::HandleConnect()
{
if(!amf_decoder_.hasObject("app")) {
return false;
}
AmfObject amfObj = amf_decoder_.getObject("app");
app_ = amfObj.amf_string;
if(app_ == "") {
return false;
}
SendAcknowledgement();
SetPeerBandwidth();
SetChunkSize();
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("_result", 7);
amf_encoder_.encodeNumber(amf_decoder_.getNumber());
objects["fmsVer"] = AmfObject(std::string("FMS/4,5,0,297"));
objects["capabilities"] = AmfObject(255.0);
objects["mode"] = AmfObject(1.0);
amf_encoder_.encodeObjects(objects);
objects.clear();
objects["level"] = AmfObject(std::string("status"));
objects["code"] = AmfObject(std::string("NetConnection.Connect.Success"));
objects["description"] = AmfObject(std::string("Connection succeeded."));
objects["objectEncoding"] = AmfObject(0.0);
amf_encoder_.encodeObjects(objects);
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
return true;
}
bool RtmpConnection::HandleCreateStream()
{
int stream_id = rtmp_chunk_->GetStreamId();
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("_result", 7);
amf_encoder_.encodeNumber(amf_decoder_.getNumber());
amf_encoder_.encodeObjects(objects);
amf_encoder_.encodeNumber(stream_id);
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
stream_id_ = stream_id;
return true;
}
bool RtmpConnection::HandlePublish()
{
LOG_INFO("[Publish] app: %s, stream name: %s, stream path: %s\n", app_.c_str(), stream_name_.c_str(), stream_path_.c_str());
auto server = rtmp_server_.lock();
if (!server) {
return false;
}
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("onStatus", 8);
amf_encoder_.encodeNumber(0);
amf_encoder_.encodeObjects(objects);
bool is_error = false;
if(server->HasPublisher(stream_path_)) {
is_error = true;
objects["level"] = AmfObject(std::string("error"));
objects["code"] = AmfObject(std::string("NetStream.Publish.BadName"));
objects["description"] = AmfObject(std::string("Stream already publishing."));
}
else if(connection_state_ == START_PUBLISH) {
is_error = true;
objects["level"] = AmfObject(std::string("error"));
objects["code"] = AmfObject(std::string("NetStream.Publish.BadConnection"));
objects["description"] = AmfObject(std::string("Connection already publishing."));
}
/* else if(0) {
// 认证处理
} */
else {
objects["level"] = AmfObject(std::string("status"));
objects["code"] = AmfObject(std::string("NetStream.Publish.Start"));
objects["description"] = AmfObject(std::string("Start publising."));
server->AddSession(stream_path_);
}
amf_encoder_.encodeObjects(objects);
SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size());
if(is_error) {
// Close ?
}
else {
connection_state_ = START_PUBLISH;
is_publishing_ = true;
}
auto session = server->GetSession(stream_path_);
if(session) {
session->SetGopCache(max_gop_cache_len_);
session->AddRtmpClient(std::dynamic_pointer_cast<RtmpConnection>(shared_from_this()));
}
return true;
}
bool RtmpConnection::HandlePlay()
{
LOG_INFO("[Play] app: %s, stream name: %s, stream path: %s\n", app_.c_str(), stream_name_.c_str(), stream_path_.c_str());
auto server = rtmp_server_.lock();
if (!server) {
return false;
}
AmfObjects objects;
amf_encoder_.reset();
amf_encoder_.encodeString("onStatus", 8);
amf_encoder_.encodeNumber(0);
amf_encoder_.encodeObjects(objects);
objects["level"] = AmfObject(std::string("status"));
objects["code"] = AmfObject(std::string("NetStream.Play.Reset"));
objects["description"] = AmfObject(std::string("Resetting and playing stream."));
amf_encoder_.encodeObjects(objects);
if(!SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size())) {
return false;
}
objects.clear();
amf_encoder_.reset();
amf_encoder_.encodeString("onStatus", 8);
amf_encoder_.encodeNumber(0);
amf_encoder_.encodeObjects(objects);
objects["level"] = AmfObject(std::string("status"));
objects["code"] = AmfObject(std::string("NetStream.Play.Start"));
objects["description"] = AmfObject(std::string("Started playing."));
amf_encoder_.encodeObjects(objects);
if(!SendInvokeMessage(RTMP_CHUNK_INVOKE_ID, amf_encoder_.data(), amf_encoder_.size())) {
return false;
}
amf_encoder_.reset();
amf_encoder_.encodeString("|RtmpSampleAccess", 17);
amf_encoder_.encodeBoolean(true);
amf_encoder_.encodeBoolean(true);
if(!this->SendNotifyMessage(RTMP_CHUNK_DATA_ID, amf_encoder_.data(), amf_encoder_.size())) {
return false;
}
connection_state_ = START_PLAY;
auto session = server->GetSession(stream_path_);
if(session) {
session->AddRtmpClient(std::dynamic_pointer_cast<RtmpConnection>(shared_from_this()));
}
return true;
}
bool RtmpConnection::HandlePlay2()
{
HandlePlay();
//printf("[Play2] stream path: %s\n", stream_path_.c_str());
return false;
}
bool RtmpConnection::HandleDeleteStream()
{
auto server = rtmp_server_.lock();
if (!server) {
return false;
}
if(stream_path_ != "") {
auto session = server->GetSession(stream_path_);
if(session != nullptr) {
auto conn = std::dynamic_pointer_cast<RtmpConnection>(shared_from_this());
task_scheduler_->AddTimer([session, conn] {
session->RemoveRtmpClient(conn);
return false;
}, 1);
}
is_playing_ = false;
is_publishing_ = false;
has_key_frame_ = false;
rtmp_chunk_->Clear();
}
return true;
}
bool RtmpConnection::HandleResult(RtmpMessage& rtmp_msg)
{
bool ret = false;
if (connection_state_ == START_CONNECT) {
if (amf_decoder_.hasObject("code")) {
AmfObject amfObj = amf_decoder_.getObject("code");
if (amfObj.amf_string == "NetConnection.Connect.Success") {
CretaeStream();
ret = true;
}
}
}
else if (connection_state_ == START_CREATE_STREAM) {
if (amf_decoder_.getNumber() > 0) {
stream_id_ = (uint32_t)amf_decoder_.getNumber();
if (connection_mode_ == RTMP_PUBLISHER) {
this->Publish();
}
else if (connection_mode_ == RTMP_CLIENT) {
this->Play();
}
ret = true;
}
}
return ret;
}
bool RtmpConnection::HandleOnStatus(RtmpMessage& rtmp_msg)
{
bool ret = true;
if (connection_state_ == START_PUBLISH || connection_state_ == START_PLAY) {
if (amf_decoder_.hasObject("code"))
{
AmfObject amfObj = amf_decoder_.getObject("code");
status_ = amfObj.amf_string;
if (connection_mode_ == RTMP_PUBLISHER) {
if (status_ == "NetStream.Publish.Start") {
is_publishing_ = true;
}
else if(status_ == "NetStream.publish.Unauthorized"
|| status_ == "NetStream.Publish.BadConnection" /*"Connection already publishing"*/
|| status_ == "NetStream.Publish.BadName") /*Stream already publishing*/
{
ret = false;
}
}
else if (connection_mode_ == RTMP_CLIENT) {
if (/*amfObj.amf_string == "NetStream.Play.Reset" || */
status_ == "NetStream.Play.Start") {
is_playing_ = true;
}
else if(status_ == "NetStream.play.Unauthorized"
|| status_ == "NetStream.Play.UnpublishNotify" /*"stream is now unpublished."*/
|| status_ == "NetStream.Play.BadConnection") /*"Connection already playing"*/
{
ret = false;
}
}
}
}
if (connection_state_ == START_DELETE_STREAM) {
if (amf_decoder_.hasObject("code")) {
AmfObject amfObj = amf_decoder_.getObject("code");
if (amfObj.amf_string != "NetStream.Unpublish.Success") {
ret = false;
}
}
}
return ret;
}
bool RtmpConnection::SendMetaData(AmfObjects metaData)
{
if(this->IsClosed()) {
return false;
}
if (metaData.size() == 0) {
return false;
}
amf_encoder_.reset();
amf_encoder_.encodeString("onMetaData", 10);
amf_encoder_.encodeECMA(metaData);
if(!this->SendNotifyMessage(RTMP_CHUNK_DATA_ID, amf_encoder_.data(), amf_encoder_.size())) {
return false;
}
return true;
}
void RtmpConnection::SetPeerBandwidth()
{
std::shared_ptr<char> data(new char[5], std::default_delete<char[]>());
WriteUint32BE(data.get(), peer_bandwidth_);
data.get()[4] = 2;
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_BANDWIDTH_SIZE;
rtmp_msg.payload = data;
rtmp_msg.length = 5;
SendRtmpChunks(RTMP_CHUNK_CONTROL_ID, rtmp_msg);
}
void RtmpConnection::SendAcknowledgement()
{
std::shared_ptr<char> data(new char[4], std::default_delete<char[]>());
WriteUint32BE(data.get(), acknowledgement_size_);
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_ACK_SIZE;
rtmp_msg.payload = data;
rtmp_msg.length = 4;
SendRtmpChunks(RTMP_CHUNK_CONTROL_ID, rtmp_msg);
}
void RtmpConnection::SetChunkSize()
{
rtmp_chunk_->SetOutChunkSize(max_chunk_size_);
std::shared_ptr<char> data(new char[4], std::default_delete<char[]>());
WriteUint32BE((char*)data.get(), max_chunk_size_);
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_SET_CHUNK_SIZE;
rtmp_msg.payload = data;
rtmp_msg.length = 4;
SendRtmpChunks(RTMP_CHUNK_CONTROL_ID, rtmp_msg);
}
void RtmpConnection::setPlayCB(const PlayCallback& cb)
{
play_cb_ = cb;
}
bool RtmpConnection::SendInvokeMessage(uint32_t csid, std::shared_ptr<char> payload, uint32_t payload_size)
{
if(this->IsClosed()) {
return false;
}
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_INVOKE;
rtmp_msg.timestamp = 0;
rtmp_msg.stream_id = stream_id_;
rtmp_msg.payload = payload;
rtmp_msg.length = payload_size;
SendRtmpChunks(csid, rtmp_msg);
return true;
}
bool RtmpConnection::SendNotifyMessage(uint32_t csid, std::shared_ptr<char> payload, uint32_t payload_size)
{
if(this->IsClosed()) {
return false;
}
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_NOTIFY;
rtmp_msg.timestamp = 0;
rtmp_msg.stream_id = stream_id_;
rtmp_msg.payload = payload;
rtmp_msg.length = payload_size;
SendRtmpChunks(csid, rtmp_msg);
return true;
}
bool RtmpConnection::IsKeyFrame(std::shared_ptr<char> payload, uint32_t payload_size)
{
uint8_t frame_type = (payload.get()[0] >> 4) & 0x0f;
uint8_t codec_id = payload.get()[0] & 0x0f;
return (frame_type == 1 && codec_id == RTMP_CODEC_ID_H264);
}
bool RtmpConnection::SendMediaData(uint8_t type, uint64_t timestamp, std::shared_ptr<char> payload, uint32_t payload_size)
{
if(this->IsClosed()) {
return false;
}
if (payload_size == 0) {
return false;
}
is_playing_ = true;
if (type == RTMP_AVC_SEQUENCE_HEADER) {
avc_sequence_header_ = payload;
avc_sequence_header_size_ = payload_size;
}
else if (type == RTMP_AAC_SEQUENCE_HEADER) {
aac_sequence_header_ = payload;
aac_sequence_header_size_ = payload_size;
}
auto conn = std::dynamic_pointer_cast<RtmpConnection>(shared_from_this());
task_scheduler_->AddTriggerEvent([conn, type, timestamp, payload, payload_size] {
if (!conn->has_key_frame_ && conn->avc_sequence_header_size_ > 0
&& (type != RTMP_AVC_SEQUENCE_HEADER)
&& (type != RTMP_AAC_SEQUENCE_HEADER)) {
if (conn->IsKeyFrame(payload, payload_size)) {
conn->has_key_frame_ = true;
}
else {
return ;
}
}
RtmpMessage rtmp_msg;
rtmp_msg._timestamp = timestamp;
rtmp_msg.stream_id = conn->stream_id_;
rtmp_msg.payload = payload;
rtmp_msg.length = payload_size;
if (type == RTMP_VIDEO || type == RTMP_AVC_SEQUENCE_HEADER) {
rtmp_msg.type_id = RTMP_VIDEO;
conn->SendRtmpChunks(RTMP_CHUNK_VIDEO_ID, rtmp_msg);
}
else if (type == RTMP_AUDIO || type == RTMP_AAC_SEQUENCE_HEADER) {
rtmp_msg.type_id = RTMP_AUDIO;
conn->SendRtmpChunks(RTMP_CHUNK_AUDIO_ID, rtmp_msg);
}
});
return true;
}
bool RtmpConnection::SendVideoData(uint64_t timestamp, std::shared_ptr<char> payload, uint32_t payload_size)
{
if (payload_size == 0) {
return false;
}
auto conn = std::dynamic_pointer_cast<RtmpConnection>(shared_from_this());
task_scheduler_->AddTriggerEvent([conn, timestamp, payload, payload_size] {
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_VIDEO;
rtmp_msg._timestamp = timestamp;
rtmp_msg.stream_id = conn->stream_id_;
rtmp_msg.payload = payload;
rtmp_msg.length = payload_size;
conn->SendRtmpChunks(RTMP_CHUNK_VIDEO_ID, rtmp_msg);
});
return true;
}
bool RtmpConnection::SendAudioData(uint64_t timestamp, std::shared_ptr<char> payload, uint32_t payload_size)
{
if (payload_size == 0) {
return false;
}
auto conn = std::dynamic_pointer_cast<RtmpConnection>(shared_from_this());
task_scheduler_->AddTriggerEvent([conn, timestamp, payload, payload_size] {
RtmpMessage rtmp_msg;
rtmp_msg.type_id = RTMP_AUDIO;
rtmp_msg._timestamp = timestamp;
rtmp_msg.stream_id = conn->stream_id_;
rtmp_msg.payload = payload;
rtmp_msg.length = payload_size;
conn->SendRtmpChunks(RTMP_CHUNK_VIDEO_ID, rtmp_msg);
});
return true;
}
void RtmpConnection::SendRtmpChunks(uint32_t csid, RtmpMessage& rtmp_msg)
{
uint32_t capacity = rtmp_msg.length + rtmp_msg.length/ max_chunk_size_ *5 + 1024;
std::shared_ptr<char> buffer(new char[capacity], std::default_delete<char[]>());
int size = rtmp_chunk_->CreateChunk(csid, rtmp_msg, buffer.get(), capacity);
if (size > 0) {
this->Send(buffer.get(), size);
}
}
| 28.788807 | 138 | 0.658732 | JungleZy |
93de959e2074203e27e6365e684acc22f4415261 | 1,320 | cc | C++ | test/lazy_string_unittest.cc | Mercy1101/my_log | 593dddc9cc4d7b6f2fa51176c7f83429fe43c266 | [
"MIT"
] | null | null | null | test/lazy_string_unittest.cc | Mercy1101/my_log | 593dddc9cc4d7b6f2fa51176c7f83429fe43c266 | [
"MIT"
] | null | null | null | test/lazy_string_unittest.cc | Mercy1101/my_log | 593dddc9cc4d7b6f2fa51176c7f83429fe43c266 | [
"MIT"
] | null | null | null | /// Copyright (c) 2019,2020 Lijiancong. All rights reserved.
///
/// Use of this source code is governed by a MIT license
/// that can be found in the License file.
#include "my_log/lazy_string.hpp"
#include <catch2/catch.hpp>
#include "profiler.hpp"
TEST_CASE("lazy_string", "[my_log][lazy_string]") {
{
PROFILER_F();
for (int i = 0; i < 10000; ++i) {
lee::lazy_string_concat_helper<> lazy_concat;
std::string str_log =
lazy_concat + lee::get_time_string() + " " + std::to_string(i) + " " +
" <In Function: " + std::to_string(0.0 + i) + "," +
", File: " + "lksjdflksdjflkdsjlkdsfjldskfjsdlkfjslkdfjlksddjfsl" +
" Line: " + std::to_string(__LINE__) + ", PID: " + __FILE__ + ">\n";
std::cout << str_log << std::endl;
}
}
}
TEST_CASE("string", "[my_log][lazy_string]") {
{
PROFILER_F();
for (int i = 0; i < 10000; ++i) {
std::string lazy_concat;
std::string str_log =
lazy_concat + lee::get_time_string() + " " + std::to_string(i) + " " +
" <In Function: " + std::to_string(0.0 + i) + "," +
", File: " + "lksjdflksdjflkdsjlkdsfjldskfjsdlkfjslkdfjlksddjfsl" +
" Line: " + std::to_string(__LINE__) + ", PID: " + __FILE__ + ">\n";
std::cout << str_log << std::endl;
}
}
}
| 32.195122 | 80 | 0.567424 | Mercy1101 |
93ded1ddca3b29d61cdea4317793aac8c7ebece8 | 4,247 | cpp | C++ | src/Solver/g2oEdgeSE3Self.cpp | zjcs/PKVIO | 7e26df3f3ee5bf0f44624c2ce94e15d33bb5544b | [
"Unlicense"
] | null | null | null | src/Solver/g2oEdgeSE3Self.cpp | zjcs/PKVIO | 7e26df3f3ee5bf0f44624c2ce94e15d33bb5544b | [
"Unlicense"
] | null | null | null | src/Solver/g2oEdgeSE3Self.cpp | zjcs/PKVIO | 7e26df3f3ee5bf0f44624c2ce94e15d33bb5544b | [
"Unlicense"
] | null | null | null | #include "g2oEdgeSE3Self.h"
#include "g2o/core/factory.h"
#include "g2o/stuff/macros.h"
namespace g2o
{
using namespace std;
using namespace Eigen;
//G2O_REGISTER_TYPE_GROUP(expmap2);
//G2O_REGISTER_TYPE(EDGE_SE3:EXPMAP2, EdgeSE3ProjectXYZRight2);
//G2O_REGISTER_TYPE(EDGE_SE3:EXPMAP2, EdgeSE3ProjectXYZRight);
//EdgeSE3ProjectXYZ2
Vector2 project2d(const Vector3& v) {
Vector2 res;
res(0) = v(0)/v(2);
res(1) = v(1)/v(2);
return res;
}
void EdgeSE3ProjectXYZ2::computeError() {
EdgeSE3ProjectXYZ::computeError();
//cout << _error << endl;
}
void EdgeSE3ProjectXYZ2::linearizeOplus() {
EdgeSE3ProjectXYZ::linearizeOplus();
//cout << _jacobianOplusXj <<endl;
}
void EdgeSE3ProjectXYZRight2::computeError() {
const VertexSE3Expmap *v1 = static_cast<const VertexSE3Expmap *>(_vertices[1]);
const VertexSBAPointXYZ *v2 = static_cast<const VertexSBAPointXYZ *>(_vertices[0]);
Vector2 obs(_measurement);
SE3Quat nPrTPw = mPrTPl*v1->estimate();
_error = obs - cam_project(nPrTPw.map(v2->estimate()));
//cout << _error <<endl;
}
void EdgeSE3ProjectXYZRight2::linearizeOplus() {
VertexSE3Expmap *vj = static_cast<VertexSE3Expmap *>(_vertices[1]);
SE3Quat T(vj->estimate());
VertexSBAPointXYZ *vi = static_cast<VertexSBAPointXYZ *>(_vertices[0]);
Vector3 xyz = vi->estimate();
Vector3 xyz_cl = T.map(xyz);
Vector3 xyz_cr = mPrTPl.map(xyz_cl);
Vector3 xyz_trans = xyz_cr;
number_t x = xyz_trans[0];
number_t y = xyz_trans[1];
number_t z = xyz_trans[2];
number_t z_2 = z * z;
Matrix<number_t, 2, 3> tmp;
tmp(0, 0) = fx;
tmp(0, 1) = 0;
tmp(0, 2) = -x / z * fx;
tmp(1, 0) = 0;
tmp(1, 1) = fy;
tmp(1, 2) = -y / z * fy;
_jacobianOplusXi = -1. / z * tmp * T.rotation().toRotationMatrix();
Matrix<number_t, 3, 6> tmp2;
tmp2.topLeftCorner(3,3) << 0, xyz_cl(2), -xyz_cl(1),
-xyz_cl(2), 0, xyz_cl(0),
xyz_cl(1), -xyz_cl(0), 0;
tmp2.topRightCorner(3,3) = Matrix<number_t, 3, 3>::Identity();
_jacobianOplusXj = -1./z * tmp * mPrTPl.rotation().toRotationMatrix() * tmp2;
//cout << xyz_cl<<endl;
//cout << _jacobianOplusXj <<endl;
}
Vector2 EdgeSE3ProjectXYZRight::cam_project(const Vector3& trans_xyz) const {
Vector2 proj = project2d(trans_xyz);
Vector2 res;
res[0] = proj[0] * fx + cx;
res[1] = proj[1] * fy + cy;
return res;
}
bool EdgeSE3ProjectXYZRight::write(std::ostream& os) const {
for (int i = 0; i < 2; i++) {
os << measurement()[i] << " ";
}
for (int i = 0; i < 2; i++)
for (int j = i; j < 2; j++) {
os << " " << information()(i, j);
}
return os.good();
}
bool EdgeSE3ProjectXYZRight::read(std::istream& is) {
for (int i = 0; i < 2; i++) {
is >> _measurement[i];
}
for (int i = 0; i < 2; i++)
for (int j = i; j < 2; j++) {
is >> information()(i, j);
if (i != j)
information()(j, i) = information()(i, j);
}
return true;
}
void EdgeSE3ProjectXYZRight::linearizeOplus() {
VertexSE3Expmap *vj = static_cast<VertexSE3Expmap *>(_vertices[1]);
SE3Quat T(vj->estimate());
VertexSBAPointXYZ *vi = static_cast<VertexSBAPointXYZ *>(_vertices[0]);
Vector3 xyz = vi->estimate();
Vector3 xyz_cl = T.map(xyz);
Vector3 xyz_cr = mPrTPl.map(xyz_cl);
Vector3 xyz_trans = xyz_cr;
number_t x = xyz_trans[0];
number_t y = xyz_trans[1];
number_t z = xyz_trans[2];
number_t z_2 = z * z;
Matrix<number_t, 2, 3> tmp;
tmp(0, 0) = fx;
tmp(0, 1) = 0;
tmp(0, 2) = -x / z * fx;
tmp(1, 0) = 0;
tmp(1, 1) = fy;
tmp(1, 2) = -y / z * fy;
_jacobianOplusXi = -1. / z * tmp * T.rotation().toRotationMatrix();
Matrix<number_t, 3, 6> tmp2;
tmp2.topLeftCorner(3,3) << 0, xyz_cl(2), -xyz_cl(1),
-xyz_cl(2), 0, xyz_cl(0),
xyz_cl(1), -xyz_cl(0), 0;
tmp2.topRightCorner(3,3) = Matrix<number_t, 3, 3>::Identity();
_jacobianOplusXj = -1./z * tmp * mPrTPl.rotation().toRotationMatrix() * tmp2;
}
/*
*/
}
| 26.879747 | 87 | 0.579703 | zjcs |
93e0c4ff2741f421254fd37d5e6b3a1d59563211 | 17,835 | cpp | C++ | src/interpreter/library/fn_d3d.cpp | Grossley/opengml | bc3494aae64092f1c32a16361fd781249e2ea630 | [
"MIT"
] | 26 | 2019-07-18T04:45:08.000Z | 2022-03-13T09:52:04.000Z | src/interpreter/library/fn_d3d.cpp | Grossley/opengml | bc3494aae64092f1c32a16361fd781249e2ea630 | [
"MIT"
] | 6 | 2021-09-10T00:48:00.000Z | 2021-11-27T22:00:48.000Z | src/interpreter/library/fn_d3d.cpp | Grossley/opengml | bc3494aae64092f1c32a16361fd781249e2ea630 | [
"MIT"
] | 9 | 2019-07-26T06:32:53.000Z | 2022-01-12T14:38:59.000Z | #include "libpre.h"
#include "fn_d3d.h"
#include "libpost.h"
#include "ogm/interpreter/Variable.hpp"
#include "ogm/common/error.hpp"
#include "ogm/common/util.hpp"
#include "ogm/interpreter/Executor.hpp"
#include "ogm/interpreter/execute.hpp"
#include "ogm/interpreter/display/Display.hpp"
#include "ogm/geometry/Vector.hpp"
#include "ogm/common/error.hpp"
#include <string>
#include <cctype>
#include <cstdlib>
using namespace ogm::interpreter;
using namespace ogm::interpreter::fn;
#define frame staticExecutor.m_frame
#define display frame.m_display
namespace
{
const std::array<real_t, 16> k_identity =
{
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
};
}
void ogm::interpreter::fn::d3d_set_fog(VO out, V enable, V colour, V start, V end)
{
display->set_fog(enable.castCoerce<bool>(), start.castCoerce<real_t>(), end.castCoerce<real_t>(), colour.castCoerce<int32_t>());
}
void ogm::interpreter::fn::d3d_start(VO out)
{
display->set_depth_test(true);
display->set_culling(false); // TODO: true?
display->set_zwrite(true);
}
void ogm::interpreter::fn::d3d_end(VO out)
{
display->set_depth_test(false);
display->set_culling(false);
display->set_zwrite(false);
display->set_matrix_projection(k_identity);
}
void ogm::interpreter::fn::d3d_set_hidden(VO out, V enable)
{
display->set_depth_test(enable.cond());
}
void ogm::interpreter::fn::d3d_set_culling(VO out, V enable)
{
display->set_culling(enable.cond());
}
void ogm::interpreter::fn::d3d_set_zwriteenable(VO out, V enable)
{
display->set_zwrite(enable.cond());
}
void ogm::interpreter::fn::d3d_set_projection(VO out, V xfrom, V yfrom, V zfrom, V xto, V yto, V zto, V xup, V yup, V zup)
{
display->set_camera(
xfrom.castCoerce<real_t>(),
yfrom.castCoerce<real_t>(),
zfrom.castCoerce<real_t>(),
xto.castCoerce<real_t>(),
yto.castCoerce<real_t>(),
zto.castCoerce<real_t>(),
xup.castCoerce<real_t>(),
yup.castCoerce<real_t>(),
zup.castCoerce<real_t>(),
45.0,
display->get_window_dimensions().x / display->get_window_dimensions().y,
0.5,
100000.0
);
}
void ogm::interpreter::fn::d3d_set_projection_ext(VO out, V xfrom, V yfrom, V zfrom, V xto, V yto, V zto, V xup, V yup, V zup, V fovangle, V aspect, V znear, V zfar)
{
display->set_camera(
xfrom.castCoerce<real_t>(),
yfrom.castCoerce<real_t>(),
zfrom.castCoerce<real_t>(),
xto.castCoerce<real_t>(),
yto.castCoerce<real_t>(),
zto.castCoerce<real_t>(),
xup.castCoerce<real_t>(),
yup.castCoerce<real_t>(),
zup.castCoerce<real_t>(),
fovangle.castCoerce<real_t>() * TAU / 360.0,
aspect.castCoerce<real_t>(),
znear.castCoerce<real_t>(),
zfar.castCoerce<real_t>()
);
}
void ogm::interpreter::fn::d3d_set_projection_ortho(VO out, V x, V y, V width, V height, V angle)
{
display->set_camera_ortho(
x.castCoerce<real_t>(),
y.castCoerce<real_t>(),
width.castCoerce<real_t>(),
height.castCoerce<real_t>(),
angle.castCoerce<real_t>() * TAU / 360.0
);
}
// NOTE: NOT CURRENTLY SERIALIZED
namespace
{
TextureView* g_view = nullptr;
std::vector<float> g_vertices;
uint32_t g_vertex_type;
bool active = false;
}
void ogm::interpreter::fn::d3d_primitive_begin(VO out, V type)
{
if (active)
{
throw MiscError("cannot begin d3d_vertex while already in progress.");
}
else
{
active = true;
}
g_vertices.clear();
g_view = nullptr;
g_vertex_type = type.castCoerce<uint32_t>();
}
void ogm::interpreter::fn::d3d_primitive_begin_texture(VO out, V type, V tex)
{
if (active)
{
throw MiscError("cannot begin d3d_vertex while already in progress.");
}
else
{
active = true;
}
g_vertices.clear();
g_view = static_cast<TextureView*>(tex.castExact<void*>());
g_vertex_type = type.castCoerce<uint32_t>();
}
namespace
{
void push_colour(std::vector<float>& vertices, uint32_t colour, float alpha)
{
vertices.push_back((colour & (0xff0000) >> 16) / 255.0);
vertices.push_back((colour & (0x00ff00) >> 8) / 255.0);
vertices.push_back((colour & (0x0000ff) >> 0) / 255.0);
vertices.push_back(alpha);
}
}
void ogm::interpreter::fn::d3d_vertex(VO out, V x, V y, V z)
{
if (!active)
{
throw MiscError("d3d_vertex requires d3d_primitive_begin.");
}
else
{
// vertex
g_vertices.push_back(x.castCoerce<real_t>());
g_vertices.push_back(y.castCoerce<real_t>());
g_vertices.push_back(z.castCoerce<real_t>());
// colour
push_colour(g_vertices, 0xffffff, 1.0);
// texture coordinates
g_vertices.push_back(0.0f);
g_vertices.push_back(0.0f);
}
}
void ogm::interpreter::fn::d3d_vertex_colour(VO out, V x, V y, V z, V c, V alpha)
{
if (!active)
{
throw MiscError("d3d_vertex requires d3d_primitive_begin.");
}
else
{
// vertex
g_vertices.push_back(x.castCoerce<real_t>());
g_vertices.push_back(y.castCoerce<real_t>());
g_vertices.push_back(z.castCoerce<real_t>());
// colour
push_colour(g_vertices, 0xffffff, 1.0);
// texture coordinates
g_vertices.push_back(0.0f);
g_vertices.push_back(0.0f);
}
}
void ogm::interpreter::fn::d3d_vertex_texture(VO out, V x, V y, V z, V u, V v)
{
if (!active)
{
throw MiscError("d3d_vertex requires d3d_primitive_begin.");
}
else
{
// vertex
g_vertices.push_back(x.castCoerce<real_t>());
g_vertices.push_back(y.castCoerce<real_t>());
g_vertices.push_back(z.castCoerce<real_t>());
// colour
push_colour(g_vertices, 0xffffff, 1.0);
// texture coordinates
g_vertices.push_back(g_view->u_global(u.castCoerce<real_t>()));
g_vertices.push_back(g_view->v_global(v.castCoerce<real_t>()));
}
}
void ogm::interpreter::fn::d3d_vertex_texture_colour(VO out, V x, V y, V z, V u, V v, V c, V alpha)
{
if (!active)
{
throw MiscError("d3d_vertex requires d3d_primitive_begin.");
}
else
{
std::array<real_t, 3> vertices = {
x.castCoerce<real_t>(),
y.castCoerce<real_t>(),
z.castCoerce<real_t>(),
};
// vertex
g_vertices.push_back(vertices[0]);
g_vertices.push_back(vertices[1]);
g_vertices.push_back(vertices[2]);
// colour
push_colour(g_vertices, c.castCoerce<real_t>(), alpha.castCoerce<real_t>());
// texture coordinates
g_vertices.push_back(g_view->u_global(u.castCoerce<real_t>()));
g_vertices.push_back(g_view->v_global(v.castCoerce<real_t>()));
}
}
void ogm::interpreter::fn::d3d_primitive_end(VO out)
{
if (!active)
{
throw MiscError("d3d_primitive_end requires d3d_primitive_begin.");
}
else
{
display->render_array(
g_vertices.size(),
&g_vertices.at(0),
nullptr,
g_vertex_type
);
g_vertices.clear();
g_view = nullptr;
active = false;
}
}
void ogm::interpreter::fn::d3d_transform_set_identity(VO out)
{
display->transform_identity();
}
void ogm::interpreter::fn::d3d_transform_set_translation(VO out, V x, V y, V z)
{
display->transform_identity();
std::array<float, 16> mat = {
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
static_cast<float>(x.castCoerce<real_t>()),
static_cast<float>(y.castCoerce<real_t>()),
static_cast<float>(z.castCoerce<real_t>()),
1.0
};
display->transform_apply(mat);
}
void ogm::interpreter::fn::d3d_transform_set_scaling(VO out, V x, V y, V z)
{
display->transform_identity();
std::array<float, 16> mat = {
static_cast<float>(x.castCoerce<real_t>()), 0.0, 0.0, 0.0,
0.0, static_cast<float>(y.castCoerce<real_t>()), 0.0, 0.0,
0.0, 0.0, static_cast<float>(z.castCoerce<real_t>()), 0.0,
0.0, 0.0, 0.0, 1.0
};
display->transform_apply(mat);
}
void ogm::interpreter::fn::d3d_transform_set_rotation_x(VO out, V theta)
{
display->transform_identity();
display->transform_apply_rotation(theta.castCoerce<real_t>(), 1, 0, 0);
}
void ogm::interpreter::fn::d3d_transform_set_rotation_y(VO out, V theta)
{
display->transform_identity();
display->transform_apply_rotation(theta.castCoerce<real_t>(), 0, 1, 0);
}
void ogm::interpreter::fn::d3d_transform_set_rotation_z(VO out, V theta)
{
display->transform_identity();
display->transform_apply_rotation(theta.castCoerce<real_t>(), 0, 0, 1);
}
void ogm::interpreter::fn::d3d_transform_set_rotation_axis(VO out, V theta, V x, V y, V z)
{
if (x != 0 || y != 0 || z != 0)
{
display->transform_apply_rotation(theta.castCoerce<real_t>(),
x.castCoerce<real_t>(),
y.castCoerce<real_t>(),
z.castCoerce<real_t>()
);
}
}
void ogm::interpreter::fn::d3d_transform_add_translation(VO out, V x, V y, V z)
{
std::array<float, 16> mat = {
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
static_cast<float>(x.castCoerce<real_t>()),
static_cast<float>(y.castCoerce<real_t>()),
static_cast<float>(z.castCoerce<real_t>()),
1.0
};
display->transform_apply(mat);
}
void ogm::interpreter::fn::d3d_transform_add_scaling(VO out, V x, V y, V z)
{
std::array<float, 16> mat = {
static_cast<float>(x.castCoerce<real_t>()), 0.0, 0.0, 0.0,
0.0, static_cast<float>(y.castCoerce<real_t>()), 0.0, 0.0,
0.0, 0.0, static_cast<float>(z.castCoerce<real_t>()), 0.0,
0.0, 0.0, 0.0, 1.0
};
display->transform_apply(mat);
}
void ogm::interpreter::fn::d3d_transform_add_rotation_x(VO out, V theta)
{
display->transform_apply_rotation(theta.castCoerce<real_t>(), 1, 0, 0);
}
void ogm::interpreter::fn::d3d_transform_add_rotation_y(VO out, V theta)
{
display->transform_apply_rotation(theta.castCoerce<real_t>(), 0, 1, 0);
}
void ogm::interpreter::fn::d3d_transform_add_rotation_z(VO out, V theta)
{
display->transform_apply_rotation(theta.castCoerce<real_t>(), 0, 0, 1);
}
void ogm::interpreter::fn::d3d_transform_add_rotation_axis(VO out, V theta, V x, V y, V z)
{
if (x != 0 || y != 0 || z != 0)
{
display->transform_apply_rotation(theta.castCoerce<real_t>(),
x.castCoerce<real_t>(),
y.castCoerce<real_t>(),
z.castCoerce<real_t>()
);
}
}
void ogm::interpreter::fn::d3d_transform_stack_clear(VO out)
{
display->transform_stack_clear();
}
void ogm::interpreter::fn::d3d_transform_stack_empty(VO out)
{
out = display->transform_stack_empty();
}
void ogm::interpreter::fn::d3d_transform_stack_push(VO out)
{
out = display->transform_stack_push();
}
void ogm::interpreter::fn::d3d_transform_stack_pop(VO out)
{
out = display->transform_stack_pop();
}
void ogm::interpreter::fn::d3d_transform_stack_top(VO out)
{
out = display->transform_stack_top();
}
void ogm::interpreter::fn::d3d_transform_stack_discard(VO out)
{
out = display->transform_stack_discard();
}
void ogm::interpreter::fn::d3d_transform_vertex(VO out, V x, V y, V z)
{
std::array<real_t, 3> a;
a[0] = x.castCoerce<real_t>();
a[1] = y.castCoerce<real_t>();
a[2] = z.castCoerce<real_t>();
display->transform_vertex(a);
out.array_ensure();
out.array_get(OGM_2DARRAY_DEFAULT_ROW 2) = a[2];
out.array_get(OGM_2DARRAY_DEFAULT_ROW 1) = a[1];
out.array_get(OGM_2DARRAY_DEFAULT_ROW 0) = a[0];
}
void ogm::interpreter::fn::d3d_transform_vertex_model_view(VO out, V x, V y, V z)
{
std::array<real_t, 3> a;
a[0] = x.castCoerce<real_t>();
a[1] = y.castCoerce<real_t>();
a[2] = z.castCoerce<real_t>();
display->transform_vertex_mv(a);
out.array_ensure();
out.array_get(OGM_2DARRAY_DEFAULT_ROW 2) = a[2];
out.array_get(OGM_2DARRAY_DEFAULT_ROW 1) = a[1];
out.array_get(OGM_2DARRAY_DEFAULT_ROW 0) = a[0];
}
void ogm::interpreter::fn::d3d_transform_vertex_model_view_projection(VO out, V x, V y, V z)
{
std::array<real_t, 3> a;
a[0] = x.castCoerce<real_t>();
a[1] = y.castCoerce<real_t>();
a[2] = z.castCoerce<real_t>();
display->transform_vertex_mvp(a);
out.array_ensure();
out.array_get(OGM_2DARRAY_DEFAULT_ROW 2) = a[2];
out.array_get(OGM_2DARRAY_DEFAULT_ROW 1) = a[1];
out.array_get(OGM_2DARRAY_DEFAULT_ROW 0) = a[0];
}
void ogm::interpreter::fn::d3d_draw_floor(VO out, V x1, V y1, V z1, V x2, V y2, V z2, V vtex, V hrepeat, V vrepeat)
{
if (active) throw MiscError("Cannot draw d3d_* while primitive in progress.");
display->set_matrix_pre_model();
real_t x[2], y[2], z[2];
x[0] = x1.castCoerce<real_t>();
y[0] = y1.castCoerce<real_t>();
z[0] = z1.castCoerce<real_t>();
x[1] = x2.castCoerce<real_t>();
y[1] = y2.castCoerce<real_t>();
z[1] = z2.castCoerce<real_t>();
TextureView* tv = nullptr;
if (vtex.get_type() == VT_PTR)
{
tv = static_cast<TextureView*>(vtex.castExact<void*>());
}
int32_t hrep = 1, vrep = 1;
if (tv)
{
hrep = hrepeat.castCoerce<int32_t>();
vrep = vrepeat.castCoerce<int32_t>();
if (hrep < 1) hrep = 1;
if (vrep < 1) vrep = 1;
}
// add vertices
for (int h = 0; h < hrep; ++h)
{
for (int v = 0; v < vrep; ++v)
{
// OPTIMIZE: use fewer vertices
for (int a=0; a < 6; ++a)
{
int ah = 0, av = 0;
if (a == 1 || a == 3 || a == 4) ah = 1;
if (a == 2 || a == 4 || a == 5) av = 1;
float hp = ((h + ah) / static_cast<float>(hrep));
float vp = ((v + av) / static_cast<float>(vrep));
float _x = x[0] * (1 - hp) + x[1] * hp;
float _y = y[0] * (1 - vp) + y[1] * vp;
float _z = z[0] * (1 - hp) + z[1] * hp;
g_vertices.push_back(_x);
g_vertices.push_back(_y);
g_vertices.push_back(_z);
// colour
push_colour(g_vertices, 0xffffff, 1.0);
// texture
if (tv)
{
g_vertices.push_back(tv->u_global(ah));
g_vertices.push_back(tv->v_global(av));
}
else
{
g_vertices.push_back(ah);
g_vertices.push_back(av);
}
}
}
}
display->render_array(
g_vertices.size(),
&g_vertices.at(0),
tv ? tv->m_tpage : nullptr,
4 // pr_trianglelist
);
g_vertices.clear();
g_view = nullptr;
}
void ogm::interpreter::fn::d3d_draw_wall(VO out, V x1, V y1, V z1, V x2, V y2, V z2, V vtex, V hrepeat, V vrepeat)
{
if (active) throw MiscError("Cannot draw d3d_* while primitive in progress.");
display->set_matrix_pre_model();
real_t x[2], y[2], z[2];
x[0] = x1.castCoerce<real_t>();
y[0] = y1.castCoerce<real_t>();
z[0] = z1.castCoerce<real_t>();
x[1] = x2.castCoerce<real_t>();
y[1] = y2.castCoerce<real_t>();
z[1] = z2.castCoerce<real_t>();
TextureView* tv = nullptr;
if (vtex.get_type() == VT_PTR)
{
tv = static_cast<TextureView*>(vtex.castExact<void*>());
}
int32_t hrep = 1, vrep = 1;
if (tv)
{
hrep = hrepeat.castCoerce<int32_t>();
vrep = vrepeat.castCoerce<int32_t>();
if (hrep < 1) hrep = 1;
if (vrep < 1) vrep = 1;
}
// add vertices
for (int h = 0; h < hrep; ++h)
{
for (int v = 0; v < vrep; ++v)
{
// OPTIMIZE: use fewer vertices
for (int a = 0; a < 6; ++a)
{
int ah = 0, av = 0;
if (a == 1 || a == 3 || a == 4) ah = 1;
if (a == 2 || a == 4 || a == 5) av = 1;
float hp = ((h + ah) / static_cast<float>(hrep));
float vp = ((v + av) / static_cast<float>(vrep));
float _x = x[0] * (1 - hp) + x[1] * hp;
float _y = y[0] * (1 - hp) + y[1] * hp;
float _z = z[0] * (1 - vp) + z[1] * vp;
g_vertices.push_back(_x);
g_vertices.push_back(_y);
g_vertices.push_back(_z);
// colour
push_colour(g_vertices, 0xffffff, 1.0);
// texture
if (tv)
{
g_vertices.push_back(tv->u_global(ah));
g_vertices.push_back(tv->v_global(av));
}
else
{
g_vertices.push_back(ah);
g_vertices.push_back(av);
}
}
}
}
display->render_array(
g_vertices.size(),
&g_vertices.at(0),
tv ? tv->m_tpage : nullptr,
4 // pr_trianglelist
);
g_vertices.clear();
g_view = nullptr;
}
void ogm::interpreter::fn::d3d_draw_block(VO out, V x1, V y1, V z1, V x2, V y2, V z2, V t, V h, V v)
{
d3d_draw_floor(out, x1, y2, z1, x2, y1, z1, t, v, h);
d3d_draw_wall(out, x1, y2, z1, x1, y1, z2, t, v, h);
d3d_draw_wall(out, x2, y1, z1, x2, y2, z2, t, v, h);
d3d_draw_wall(out, x1, y1, z1, x2, y1, z2, t, v, h);
d3d_draw_wall(out, x2, y2, z1, x1, y2, z2, t, v, h);
d3d_draw_floor(out, x1, y1, z2, x2, y2, z2, t, v, h);
}
| 28.309524 | 165 | 0.579591 | Grossley |
93e29e69d75f79963091765e46bd1442850b7342 | 9,026 | cpp | C++ | TerrainApps/mfcSimple/mfcSimpleView.cpp | nakijun/vtp | 7bd2b2abd3a3f778a32ba30be099cfba9b892922 | [
"MIT"
] | 4 | 2019-02-08T13:51:26.000Z | 2021-12-07T13:11:06.000Z | TerrainApps/mfcSimple/mfcSimpleView.cpp | nakijun/vtp | 7bd2b2abd3a3f778a32ba30be099cfba9b892922 | [
"MIT"
] | null | null | null | TerrainApps/mfcSimple/mfcSimpleView.cpp | nakijun/vtp | 7bd2b2abd3a3f778a32ba30be099cfba9b892922 | [
"MIT"
] | 7 | 2017-12-03T10:13:17.000Z | 2022-03-29T09:51:18.000Z | // mfcSimpleView.cpp : implementation of the CSimpleView class
//
// Copyright (c) 2001-2011 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//
#include "stdafx.h"
#include "mfcSimple.h"
#include "mfcSimpleDoc.h"
#include "mfcSimpleView.h"
bool CreateScene();
void CleanupScene();
// Header for the vtlib library
#include "vtlib/vtlib.h"
#include "vtlib/core/Terrain.h"
#include "vtlib/core/TerrainScene.h"
#include "vtlib/core/NavEngines.h"
#include "vtdata/DataPath.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CSimpleView
IMPLEMENT_DYNCREATE(CSimpleView, CView)
BEGIN_MESSAGE_MAP(CSimpleView, CView)
//{{AFX_MSG_MAP(CSimpleView)
ON_WM_DESTROY()
ON_WM_CREATE()
ON_WM_SIZE()
ON_WM_PAINT()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_MOUSEMOVE()
ON_WM_RBUTTONDOWN()
ON_WM_RBUTTONUP()
ON_WM_MBUTTONDOWN()
ON_WM_MBUTTONUP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CSimpleView construction/destruction
CSimpleView::CSimpleView()
{
m_hGLContext = NULL;
m_GLPixelIndex = 0;
}
CSimpleView::~CSimpleView()
{
}
BOOL CSimpleView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CSimpleView diagnostics
#ifdef _DEBUG
void CSimpleView::AssertValid() const
{
CView::AssertValid();
}
void CSimpleView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CSimpleDoc* CSimpleView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CSimpleDoc)));
return (CSimpleDoc*)m_pDocument;
}
#endif //_DEBUG
void CSimpleView::OnDraw(CDC* pDC)
{
CSimpleDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
}
/////////////////////////////////////////////////////////////////////////////
// CSimpleView message handlers
// set Windows Pixel Format
BOOL CSimpleView::SetWindowPixelFormat(HDC hDC)
{
PIXELFORMATDESCRIPTOR pixelDesc;
pixelDesc.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pixelDesc.nVersion = 1;
pixelDesc.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER | PFD_STEREO_DONTCARE;
pixelDesc.iPixelType = PFD_TYPE_RGBA;
pixelDesc.cColorBits = 32;
pixelDesc.cRedBits = 8;
pixelDesc.cRedShift = 16;
pixelDesc.cGreenBits = 8;
pixelDesc.cGreenShift = 8;
pixelDesc.cBlueBits = 8;
pixelDesc.cBlueShift = 0;
pixelDesc.cAlphaBits = 0;
pixelDesc.cAlphaShift = 0;
pixelDesc.cAccumBits = 64;
pixelDesc.cAccumRedBits = 16;
pixelDesc.cAccumGreenBits = 16;
pixelDesc.cAccumBlueBits = 16;
pixelDesc.cAccumAlphaBits = 0;
pixelDesc.cDepthBits = 32;
pixelDesc.cStencilBits = 8;
pixelDesc.cAuxBuffers = 0;
pixelDesc.iLayerType = PFD_MAIN_PLANE;
pixelDesc.bReserved = 0;
pixelDesc.dwLayerMask = 0;
pixelDesc.dwVisibleMask = 0;
pixelDesc.dwDamageMask = 0;
m_GLPixelIndex = ChoosePixelFormat(hDC,&pixelDesc);
if (m_GLPixelIndex == 0) // Choose default
{
m_GLPixelIndex = 1;
if (DescribePixelFormat(hDC,m_GLPixelIndex,
sizeof(PIXELFORMATDESCRIPTOR),&pixelDesc)==0)
return FALSE;
}
if (!SetPixelFormat(hDC,m_GLPixelIndex,&pixelDesc))
return FALSE;
return TRUE;
}
//********************************************
// CreateViewGLContext
// Create an OpenGL rendering context
//********************************************
BOOL CSimpleView::CreateViewGLContext(HDC hDC)
{
m_hGLContext = wglCreateContext(hDC);
if (m_hGLContext==NULL)
return FALSE;
if (wglMakeCurrent(hDC,m_hGLContext)==FALSE)
return FALSE;
return TRUE;
}
void CSimpleView::OnDestroy()
{
CleanupScene();
if (wglGetCurrentContext() != NULL)
wglMakeCurrent(NULL,NULL);
if (m_hGLContext != NULL)
{
wglDeleteContext(m_hGLContext);
m_hGLContext = NULL;
}
CView::OnDestroy();
}
int CSimpleView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;
HWND hWnd = GetSafeHwnd();
HDC hDC = ::GetDC(hWnd);
if (SetWindowPixelFormat(hDC)==FALSE)
return 0;
if (CreateViewGLContext(hDC)==FALSE)
return 0;
int dummy_argc = 1;
char *dummy_argv = "mfcSimple.exe";
// Get a handle to the vtScene - one is already created for you
vtScene *pScene = vtGetScene();
pScene->Init(dummy_argc, &dummy_argv);
pScene->getViewer()->setThreadingModel(osgViewer::Viewer::SingleThreaded);
pScene->SetGraphicsContext(new osgViewer::GraphicsWindowEmbedded(0, 0, 800, 600));
return CreateScene();
}
void CSimpleView::OnSize(UINT nType, int cx, int cy)
{
CView::OnSize(nType, cx, cy);
glViewport(0,0,cx, cy);
vtGetScene()->SetWindowSize(cx, cy);
}
void CSimpleView::OnPaint()
{
CPaintDC dc(this); // device context for painting
// Render the scene
vtGetScene()->DoUpdate();
//this would occur, for example, after your call to glClear() and before calling SwapBuffers()
SwapBuffers(dc.m_ps.hdc);
InvalidateRect(NULL,FALSE); //for Continuous Rendering
}
//-----------------------The Following is VTerrain Code-----------------
vtTerrainScene *ts = NULL;
//
// Create the 3d scene
//
bool CreateScene()
{
// Look up the camera
vtScene *pScene = vtGetScene();
vtCamera *pCamera = pScene->GetCamera();
pCamera->SetHither(10);
pCamera->SetYon(150000);
// The terrain scene will contain all the terrains that are created.
ts = new vtTerrainScene;
// Get the global data path
char user_config_dir[MAX_PATH];
SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, user_config_dir);
vtLoadDataPath(user_config_dir, NULL);
// And look locally too, just in case the global path isn't set yet
vtGetDataPath().push_back("../Data/");
// Begin creating the scene, including the sun and sky
vtGroup *pTopGroup = ts->BeginTerrainScene();
// Tell the scene graph to point to this terrain scene
pScene->SetRoot(pTopGroup);
// Create a new vtTerrain, read its paramters from a file
vtTerrain *pTerr = new vtTerrain;
pTerr->SetParamFile("Data/Simple.xml");
pTerr->LoadParams();
// Add the terrain to the scene, and contruct it
ts->AppendTerrain(pTerr);
if (!ts->BuildTerrain(pTerr))
{
AfxMessageBox("Terrain creation failed.");
return false;
}
ts->SetCurrentTerrain(pTerr);
// Create a navigation engine to move around on the terrain
// Get flight speed from terrain parameters
float fSpeed = pTerr->GetParams().GetValueFloat(STR_NAVSPEED);
vtTerrainFlyer *pFlyer = new vtTerrainFlyer(fSpeed);
pFlyer->SetTarget(pCamera);
pFlyer->SetHeightField(pTerr->GetHeightField());
pScene->AddEngine(pFlyer);
// Minimum height over terrain is 100 m
vtHeightConstrain *pConstrain = new vtHeightConstrain(100);
pConstrain->SetTarget(pCamera);
pConstrain->SetHeightField(pTerr->GetHeightField());
pScene->AddEngine(pConstrain);
return true;
}
void CleanupScene()
{
vtGetScene()->SetRoot(NULL);
if (ts)
{
ts->CleanupScene();
delete ts;
}
vtGetScene()->Shutdown();
}
//--------------Mouse EVENTS-----------------
//
// turn MFC events flags in VT flags
//
int MFCFlagsToVT(int nFlags)
{
int flags = 0;
if ( (nFlags & MK_CONTROL)!=0 )
flags |= VT_CONTROL;
if ( (nFlags & MK_SHIFT)!=0 )
flags |= VT_SHIFT;
return flags;
}
//
// turn MFC mouse events into VT mouse events
//
void CSimpleView::OnMouseMove(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_MOVE;
event.button = VT_NONE;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
void CSimpleView::OnLButtonUp(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_UP;
event.button = VT_LEFT;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
void CSimpleView::OnLButtonDown(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_DOWN;
event.button = VT_LEFT;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
void CSimpleView::OnRButtonDown(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_DOWN;
event.button = VT_RIGHT;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
void CSimpleView::OnRButtonUp(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_UP;
event.button = VT_RIGHT;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
void CSimpleView::OnMButtonDown(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_DOWN;
event.button = VT_MIDDLE;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
void CSimpleView::OnMButtonUp(UINT nFlags, CPoint point)
{
vtMouseEvent event;
event.type = VT_UP;
event.button = VT_MIDDLE;
event.flags = MFCFlagsToVT(nFlags);
event.pos.Set(point.x,point.y);
vtGetScene()->OnMouse(event);
}
| 22.341584 | 95 | 0.697762 | nakijun |
93e41e4c8ed8de172b7afef1dc5f178b4cb946b7 | 61 | cpp | C++ | source/UI/ui_test.cpp | JakobEliasWagner/pomodoro-timer | a5ebda06645d135af4258e9b814ef364f5685541 | [
"Unlicense"
] | null | null | null | source/UI/ui_test.cpp | JakobEliasWagner/pomodoro-timer | a5ebda06645d135af4258e9b814ef364f5685541 | [
"Unlicense"
] | null | null | null | source/UI/ui_test.cpp | JakobEliasWagner/pomodoro-timer | a5ebda06645d135af4258e9b814ef364f5685541 | [
"Unlicense"
] | null | null | null | //
// Created by jakob on 09.03.22.
//
#include "ui_test.h"
| 10.166667 | 32 | 0.606557 | JakobEliasWagner |
93ee5c32a90cbbca01bd8e10ead090cb35bca096 | 2,547 | cpp | C++ | source/lib/src/mohansella/serial/Writer.cpp | mohansella/simple-kvstore | af9948f0a0e4247526ae03f4d639c548c9474837 | [
"MIT"
] | null | null | null | source/lib/src/mohansella/serial/Writer.cpp | mohansella/simple-kvstore | af9948f0a0e4247526ae03f4d639c548c9474837 | [
"MIT"
] | null | null | null | source/lib/src/mohansella/serial/Writer.cpp | mohansella/simple-kvstore | af9948f0a0e4247526ae03f4d639c548c9474837 | [
"MIT"
] | null | null | null | #include <mohansella/serial/Writer.hpp>
#include <mohansella/serial/ByteSerialType.hpp>
namespace mohansella::serial
{
Writer::Writer()
{
}
Writer::~Writer()
{
}
Writer & Writer::putNull()
{
std::uint8_t nullEnVal = ByteSerialType::BSTYPE_NULL;
return this->putRaw(&nullEnVal, sizeof(nullEnVal));
}
Writer & Writer::putByte(std::uint8_t val)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_BYTE, &val, sizeof(val));
return *this;
}
Writer & Writer::putShort(std::int16_t val)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_SHORT, (std::uint8_t *) &val, sizeof(val));
return *this;
}
Writer & Writer::putInteger(std::int32_t val)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_INTEGER, (std::uint8_t *) &val, sizeof(val));
return *this;
}
Writer & Writer::putFloat(float val)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_FLOAT, (std::uint8_t *) &val, sizeof(val));
return *this;
}
Writer & Writer::putLong(std::int64_t val)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_LONG, (std::uint8_t *) &val, sizeof(val));
return *this;
}
Writer & Writer::putDouble(double val)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_DOUBLE, (std::uint8_t *) &val, sizeof(val));
return *this;
}
Writer & Writer::putString(const std::string & val)
{
return this->putCharArray(val.c_str(), val.length());
}
Writer & Writer::putCharArray(const char * dataPtr, std::int32_t len)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_STRING, (std::uint8_t *) &len, sizeof(len));
return this->putRaw((const std::uint8_t *) dataPtr, len);
}
Writer & Writer::putBytes(const std::uint8_t * dataPtr, std::int32_t len)
{
this->writeSyntaxAndLen(ByteSerialType::BSTYPE_BLOB, (std::uint8_t *) &len, sizeof(len));
return this->putRaw(dataPtr, len);
}
Writer & Writer::startObject()
{
this->writeSyntax(ByteSerialType::BSTYPE_OBJECT_START);
return *this;
}
Writer & Writer::endObject()
{
this->writeSyntax(ByteSerialType::BSTYPE_OBJECT_END);
return *this;
}
Writer & Writer::startArray()
{
this->writeSyntax(ByteSerialType::BSTYPE_ARRAY_START);
return *this;
}
Writer & Writer::endArray()
{
this->writeSyntax(ByteSerialType::BSTYPE_ARRAY_END);
return *this;
}
void Writer::writeSyntax(ByteSerialType type)
{
std::uint8_t data = type;
this->putRaw(&data, sizeof(data));
}
void Writer::writeSyntaxAndLen(ByteSerialType type, const std::uint8_t * ptr, std::int32_t len)
{
this->writeSyntax(type);
this->putRawInReverse(ptr, len);
}
}
| 22.147826 | 96 | 0.699647 | mohansella |
93fbd1cd77defbec19e6d6eca525cbf1fd17a207 | 1,142 | cpp | C++ | Source/Parser/CursorType.cpp | JoinCAD/CPP-Reflection | 61163369b6b3b370c4ce726dbf8e60e441723821 | [
"MIT"
] | 540 | 2015-09-18T09:44:57.000Z | 2022-03-25T07:23:09.000Z | Source/Parser/CursorType.cpp | yangzhengxing/CPP-Reflection | 43ec755b7a5c62e3252c174815c2e44727e11e72 | [
"MIT"
] | 16 | 2015-09-23T06:37:43.000Z | 2020-04-10T15:40:08.000Z | Source/Parser/CursorType.cpp | yangzhengxing/CPP-Reflection | 43ec755b7a5c62e3252c174815c2e44727e11e72 | [
"MIT"
] | 88 | 2015-09-21T15:12:32.000Z | 2021-11-30T14:07:34.000Z | /* ----------------------------------------------------------------------------
** Copyright (c) 2016 Austin Brunkhorst, All Rights Reserved.
**
** CursorType.cpp
** --------------------------------------------------------------------------*/
#include "Precompiled.h"
#include "CursorType.h"
CursorType::CursorType(const CXType &handle)
: m_handle( handle )
{
}
std::string CursorType::GetDisplayName(void) const
{
std::string displayName;
utils::ToString( clang_getTypeSpelling( m_handle ), displayName );
return displayName;
}
int CursorType::GetArgumentCount(void) const
{
return clang_getNumArgTypes( m_handle );
}
CursorType CursorType::GetArgument(unsigned index) const
{
return clang_getArgType( m_handle, index );
}
CursorType CursorType::GetCanonicalType(void) const
{
return clang_getCanonicalType( m_handle );
}
Cursor CursorType::GetDeclaration(void) const
{
return clang_getTypeDeclaration( m_handle );
}
CXTypeKind CursorType::GetKind(void) const
{
return m_handle.kind;
}
bool CursorType::IsConst(void) const
{
return clang_isConstQualifiedType( m_handle ) ? true : false;
} | 21.148148 | 79 | 0.636602 | JoinCAD |
93fe47ce8471d35d96cef8d98a26a89b7ffeee5d | 6,890 | hpp | C++ | Tools/RegistersGenerator/Msp432P401Y/fpbregisters.hpp | snorkysnark/CortexLib | 0db035332ebdfbebf21ca36e5e04b78a5a908a49 | [
"MIT"
] | 22 | 2019-09-07T22:38:01.000Z | 2022-01-31T21:35:55.000Z | Tools/RegistersGenerator/Msp432P401Y/fpbregisters.hpp | snorkysnark/CortexLib | 0db035332ebdfbebf21ca36e5e04b78a5a908a49 | [
"MIT"
] | null | null | null | Tools/RegistersGenerator/Msp432P401Y/fpbregisters.hpp | snorkysnark/CortexLib | 0db035332ebdfbebf21ca36e5e04b78a5a908a49 | [
"MIT"
] | 9 | 2019-09-22T11:26:24.000Z | 2022-03-21T10:53:15.000Z | /*******************************************************************************
* Filename : fpbregisters.hpp
*
* Details : FPB. This header file is auto-generated for MSP432P401Y
* device.
*
*
*******************************************************************************/
#if !defined(FPBREGISTERS_HPP)
#define FPBREGISTERS_HPP
#include "fpbfieldvalues.hpp" //for Bits Fields defs
#include "registerbase.hpp" //for RegisterBase
#include "register.hpp" //for Register
#include "accessmode.hpp" //for ReadMode, WriteMode, ReadWriteMode
struct FPB
{
struct FPBFP_CTRLBase {} ;
struct FP_CTRL : public RegisterBase<0xE0002000, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_CTRL_ENABLE_Values<FPB::FP_CTRL, 0, 1, ReadWriteMode, FPBFP_CTRLBase> ;
using KEY = FPB_FP_CTRL_KEY_Values<FPB::FP_CTRL, 1, 1, WriteMode, FPBFP_CTRLBase> ;
using NUM_CODE1 = FPB_FP_CTRL_NUM_CODE1_Values<FPB::FP_CTRL, 4, 4, ReadMode, FPBFP_CTRLBase> ;
using NUM_LIT = FPB_FP_CTRL_NUM_LIT_Values<FPB::FP_CTRL, 8, 4, ReadMode, FPBFP_CTRLBase> ;
using NUM_CODE2 = FPB_FP_CTRL_NUM_CODE2_Values<FPB::FP_CTRL, 12, 2, ReadMode, FPBFP_CTRLBase> ;
using FieldValues = FPB_FP_CTRL_NUM_CODE2_Values<FPB::FP_CTRL, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_CTRLPack = Register<0xE0002000, 32, ReadWriteMode, FPBFP_CTRLBase, T...> ;
struct FPBFP_REMAPBase {} ;
struct FP_REMAP : public RegisterBase<0xE0002004, 32, ReadWriteMode>
{
using REMAP = FPB_FP_REMAP_REMAP_Values<FPB::FP_REMAP, 5, 24, ReadWriteMode, FPBFP_REMAPBase> ;
using FieldValues = FPB_FP_REMAP_REMAP_Values<FPB::FP_REMAP, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_REMAPPack = Register<0xE0002004, 32, ReadWriteMode, FPBFP_REMAPBase, T...> ;
struct FPBFP_COMP0Base {} ;
struct FP_COMP0 : public RegisterBase<0xE0002008, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP0_ENABLE_Values<FPB::FP_COMP0, 0, 1, ReadWriteMode, FPBFP_COMP0Base> ;
using COMP = FPB_FP_COMP0_COMP_Values<FPB::FP_COMP0, 2, 27, ReadWriteMode, FPBFP_COMP0Base> ;
using REPLACE = FPB_FP_COMP0_REPLACE_Values<FPB::FP_COMP0, 30, 2, ReadWriteMode, FPBFP_COMP0Base> ;
using FieldValues = FPB_FP_COMP0_REPLACE_Values<FPB::FP_COMP0, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP0Pack = Register<0xE0002008, 32, ReadWriteMode, FPBFP_COMP0Base, T...> ;
struct FPBFP_COMP1Base {} ;
struct FP_COMP1 : public RegisterBase<0xE000200C, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP1_ENABLE_Values<FPB::FP_COMP1, 0, 1, ReadWriteMode, FPBFP_COMP1Base> ;
using COMP = FPB_FP_COMP1_COMP_Values<FPB::FP_COMP1, 2, 27, ReadWriteMode, FPBFP_COMP1Base> ;
using REPLACE = FPB_FP_COMP1_REPLACE_Values<FPB::FP_COMP1, 30, 2, ReadWriteMode, FPBFP_COMP1Base> ;
using FieldValues = FPB_FP_COMP1_REPLACE_Values<FPB::FP_COMP1, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP1Pack = Register<0xE000200C, 32, ReadWriteMode, FPBFP_COMP1Base, T...> ;
struct FPBFP_COMP2Base {} ;
struct FP_COMP2 : public RegisterBase<0xE0002010, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP2_ENABLE_Values<FPB::FP_COMP2, 0, 1, ReadWriteMode, FPBFP_COMP2Base> ;
using COMP = FPB_FP_COMP2_COMP_Values<FPB::FP_COMP2, 2, 27, ReadWriteMode, FPBFP_COMP2Base> ;
using REPLACE = FPB_FP_COMP2_REPLACE_Values<FPB::FP_COMP2, 30, 2, ReadWriteMode, FPBFP_COMP2Base> ;
using FieldValues = FPB_FP_COMP2_REPLACE_Values<FPB::FP_COMP2, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP2Pack = Register<0xE0002010, 32, ReadWriteMode, FPBFP_COMP2Base, T...> ;
struct FPBFP_COMP3Base {} ;
struct FP_COMP3 : public RegisterBase<0xE0002014, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP3_ENABLE_Values<FPB::FP_COMP3, 0, 1, ReadWriteMode, FPBFP_COMP3Base> ;
using COMP = FPB_FP_COMP3_COMP_Values<FPB::FP_COMP3, 2, 27, ReadWriteMode, FPBFP_COMP3Base> ;
using REPLACE = FPB_FP_COMP3_REPLACE_Values<FPB::FP_COMP3, 30, 2, ReadWriteMode, FPBFP_COMP3Base> ;
using FieldValues = FPB_FP_COMP3_REPLACE_Values<FPB::FP_COMP3, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP3Pack = Register<0xE0002014, 32, ReadWriteMode, FPBFP_COMP3Base, T...> ;
struct FPBFP_COMP4Base {} ;
struct FP_COMP4 : public RegisterBase<0xE0002018, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP4_ENABLE_Values<FPB::FP_COMP4, 0, 1, ReadWriteMode, FPBFP_COMP4Base> ;
using COMP = FPB_FP_COMP4_COMP_Values<FPB::FP_COMP4, 2, 27, ReadWriteMode, FPBFP_COMP4Base> ;
using REPLACE = FPB_FP_COMP4_REPLACE_Values<FPB::FP_COMP4, 30, 2, ReadWriteMode, FPBFP_COMP4Base> ;
using FieldValues = FPB_FP_COMP4_REPLACE_Values<FPB::FP_COMP4, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP4Pack = Register<0xE0002018, 32, ReadWriteMode, FPBFP_COMP4Base, T...> ;
struct FPBFP_COMP5Base {} ;
struct FP_COMP5 : public RegisterBase<0xE000201C, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP5_ENABLE_Values<FPB::FP_COMP5, 0, 1, ReadWriteMode, FPBFP_COMP5Base> ;
using COMP = FPB_FP_COMP5_COMP_Values<FPB::FP_COMP5, 2, 27, ReadWriteMode, FPBFP_COMP5Base> ;
using REPLACE = FPB_FP_COMP5_REPLACE_Values<FPB::FP_COMP5, 30, 2, ReadWriteMode, FPBFP_COMP5Base> ;
using FieldValues = FPB_FP_COMP5_REPLACE_Values<FPB::FP_COMP5, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP5Pack = Register<0xE000201C, 32, ReadWriteMode, FPBFP_COMP5Base, T...> ;
struct FPBFP_COMP6Base {} ;
struct FP_COMP6 : public RegisterBase<0xE0002020, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP6_ENABLE_Values<FPB::FP_COMP6, 0, 1, ReadWriteMode, FPBFP_COMP6Base> ;
using COMP = FPB_FP_COMP6_COMP_Values<FPB::FP_COMP6, 2, 27, ReadWriteMode, FPBFP_COMP6Base> ;
using REPLACE = FPB_FP_COMP6_REPLACE_Values<FPB::FP_COMP6, 30, 2, ReadWriteMode, FPBFP_COMP6Base> ;
using FieldValues = FPB_FP_COMP6_REPLACE_Values<FPB::FP_COMP6, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP6Pack = Register<0xE0002020, 32, ReadWriteMode, FPBFP_COMP6Base, T...> ;
struct FPBFP_COMP7Base {} ;
struct FP_COMP7 : public RegisterBase<0xE0002024, 32, ReadWriteMode>
{
using ENABLE = FPB_FP_COMP7_ENABLE_Values<FPB::FP_COMP7, 0, 1, ReadWriteMode, FPBFP_COMP7Base> ;
using COMP = FPB_FP_COMP7_COMP_Values<FPB::FP_COMP7, 2, 27, ReadWriteMode, FPBFP_COMP7Base> ;
using REPLACE = FPB_FP_COMP7_REPLACE_Values<FPB::FP_COMP7, 30, 2, ReadWriteMode, FPBFP_COMP7Base> ;
using FieldValues = FPB_FP_COMP7_REPLACE_Values<FPB::FP_COMP7, 0, 0, NoAccess, NoAccess> ;
} ;
template<typename... T>
using FP_COMP7Pack = Register<0xE0002024, 32, ReadWriteMode, FPBFP_COMP7Base, T...> ;
} ;
#endif //#if !defined(FPBREGISTERS_HPP)
| 45.03268 | 103 | 0.720755 | snorkysnark |
9e04e6a1bc1c0c4ccca074bc22c05654112324e0 | 1,286 | cpp | C++ | SDK/ARKSurvivalEvolved_ProjPoop_functions.cpp | 2bite/ARK-SDK | c38ca9925309516b2093ad8c3a70ed9489e1d573 | [
"MIT"
] | 10 | 2020-02-17T19:08:46.000Z | 2021-07-31T11:07:19.000Z | SDK/ARKSurvivalEvolved_ProjPoop_functions.cpp | 2bite/ARK-SDK | c38ca9925309516b2093ad8c3a70ed9489e1d573 | [
"MIT"
] | 9 | 2020-02-17T18:15:41.000Z | 2021-06-06T19:17:34.000Z | SDK/ARKSurvivalEvolved_ProjPoop_functions.cpp | 2bite/ARK-SDK | c38ca9925309516b2093ad8c3a70ed9489e1d573 | [
"MIT"
] | 3 | 2020-07-22T17:42:07.000Z | 2021-06-19T17:16:13.000Z | // ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_ProjPoop_parameters.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
// Function ProjPoop.ProjPoop_C.UserConstructionScript
// ()
void AProjPoop_C::UserConstructionScript()
{
static auto fn = UObject::FindObject<UFunction>("Function ProjPoop.ProjPoop_C.UserConstructionScript");
AProjPoop_C_UserConstructionScript_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function ProjPoop.ProjPoop_C.ExecuteUbergraph_ProjPoop
// ()
// Parameters:
// int EntryPoint (Parm, ZeroConstructor, IsPlainOldData)
void AProjPoop_C::ExecuteUbergraph_ProjPoop(int EntryPoint)
{
static auto fn = UObject::FindObject<UFunction>("Function ProjPoop.ProjPoop_C.ExecuteUbergraph_ProjPoop");
AProjPoop_C_ExecuteUbergraph_ProjPoop_Params params;
params.EntryPoint = EntryPoint;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| 22.561404 | 107 | 0.657076 | 2bite |
9e19d40f52f3c9036579b96e536cb9f6b674affe | 6,670 | cc | C++ | src/circuit/circuit_data.cc | hyraxZK/libpws | cc1b7dfdafb3d01b025cdb72ed83379d205a0147 | [
"Apache-2.0"
] | null | null | null | src/circuit/circuit_data.cc | hyraxZK/libpws | cc1b7dfdafb3d01b025cdb72ed83379d205a0147 | [
"Apache-2.0"
] | null | null | null | src/circuit/circuit_data.cc | hyraxZK/libpws | cc1b7dfdafb3d01b025cdb72ed83379d205a0147 | [
"Apache-2.0"
] | 1 | 2020-01-16T07:49:03.000Z | 2020-01-16T07:49:03.000Z | #include <cassert>
#include <sstream>
#include <stdint.h>
#include <iostream>
#include <cerrno>
#include <stdexcept>
#include "circuit_data.hh"
#include "debug_utils.hh"
#include "mpnops.hh"
#include "prng.hh"
#include "utility.hh"
using namespace std;
static Prng &prng = Prng::global;
#define RETURN_IF_FALSE(file, statement) { if (!statement) { fclose(f); return false; } }
template<typename T> bool
write(FILE* f, const T& val)
{
return fwrite(&val, sizeof(val), 1, f) == 1;
}
template<> bool
write<mpz_t>(FILE* f, const mpz_t& val)
{
return mpz_out_raw(f, val) != 0;
}
template<> bool
write<mpq_t>(FILE* f, const mpq_t& val)
{
return (mpz_out_raw(f, mpq_numref(val)) != 0) && (mpz_out_raw(f, mpq_denref(val)) != 0);
}
template<typename T> bool
read(T& val, FILE* f)
{
return fread(&val, sizeof(val), 1, f) == 1;
}
template<> bool
read<mpz_t>(mpz_t& val, FILE* f)
{
return mpz_inp_raw(val, f) != 0;
}
template<> bool
read<mpq_t>(mpq_t& val, FILE* f)
{
return (mpz_inp_raw(mpq_numref(val), f) != 0) && (mpz_inp_raw(mpq_denref(val), f) != 0);
}
template<typename T> size_t
sizeOf(const T& obj)
{
return sizeof(obj);
}
template<> size_t
sizeOf<mpz_t>(const mpz_t& val)
{
return mpz_sizeinbase(val, 2) / 8 + sizeof(val);
}
template<> size_t
sizeOf<mpq_t>(const mpq_t& val)
{
return sizeOf(mpq_numref(val)) + sizeOf(mpq_denref(val));
}
template<typename T> T
getRandom(Prng& prng)
{
T out;
prng.get_randomb(reinterpret_cast<char*>(&out), sizeof(out) * 8);
return out;
}
static FILE *
open_file(const string& filename, const string& mode, const string& directory, bool createDir = true)
{
if (createDir)
recursive_mkdir(directory);
string fname(directory);
fname += '/';
fname += filename;
return fopen(fname.c_str(), mode.c_str());
}
template<typename T>
bool LayerData<T>::
save(const string& directory) const
{
if (shouldSave())
{
string name = layerName();
FILE* f;
if (!(f = open_file(layerName(), "wb", directory)))
return false;
RETURN_IF_FALSE(f, write(f, LAYER_DATA_HEADER));
RETURN_IF_FALSE(f, write(f, gates.size()));
for (size_t i = 0; i < gates.size(); i++)
RETURN_IF_FALSE(f, write(f, gates[i]));
fflush(f);
fclose(f);
}
return true;
}
template<typename T>
bool LayerData<T>::
load(const string& directory)
{
string name = layerName();
FILE* f;
uint32_t header;
size_t size;
if (!(f = open_file(layerName(), "rb", directory, false)))
return false;
RETURN_IF_FALSE(f, read(header, f));
RETURN_IF_FALSE(f, read(size, f));
gates.resize(size);
isDirty = false;
for (size_t i = 0; i < gates.size(); i++)
RETURN_IF_FALSE(f, read(gates[i], f));
fclose(f);
return true;
}
template<typename T>
void LayerData<T>::
tryLoad(const string& directory, size_t size)
{
if (!load(directory))
{
if (gates.size() != size)
gates.resize(size);
assert(gates.size() == size);
for (size_t i = 0; i < size; i++)
mpn_ops<T>::init(gates[i]);
}
}
template<typename T>
size_t LayerData<T>::
dataSize() const
{
double avg = 0;
const uint32_t numSamples = 4;
if (gates.size() > 0)
{
for (uint32_t i = 0; i < numSamples; i++)
{
size_t idx = getRandom<size_t>(prng) % gates.size();
avg = sizeOf(gates[idx]);
}
avg /= numSamples;
}
return size_t(avg * gates.size()) + sizeof(this);
}
template<typename T>
string LayerData<T>::
layerName() const
{
stringstream ss;
ss << "layer_" << index();
return ss.str();
}
template<typename T> string
circuitPrefix()
{ //TODO: Use static_assert.
throw runtime_error("Does not work.");
}
template<> string
circuitPrefix<mpz_t>()
{ return "circuit"; }
template<> string
circuitPrefix<mpq_t>()
{ return "circuitq"; }
template<typename T>
CircuitData<T>::
CircuitData(size_t memBudget, const std::vector<size_t>& sizes, const string& suffix)
: blocks(), blockSizes(sizes), circuitDir(), budget(memBudget), usage(0)
{
stringstream ss;
ss << FOLDER_STATE << "/" << circuitPrefix<T>() << "_";
if (suffix.empty())
{
struct stat sb;
do
{
stringstream testDir;
uint64_t randNumber = getRandom<uint64_t>(prng);
testDir << ss.str() << hex << randNumber;
circuitDir = testDir.str();
} while (stat(circuitDir.c_str(), &sb) == 0);
}
else
{
ss << suffix;
circuitDir = ss.str();
}
// Reserve circuit directory.
if (!recursive_mkdir(circuitDir))
throw runtime_error("Could not create new directory for circuit.");
}
template<typename T>
LayerData<T>& CircuitData<T>::
operator [](int layerIdx)
{
assert(inRange<int>(layerIdx, 0, blockSizes.size()));
typedef typename deque<LayerData<T> >::iterator LayerDataIt;
for (LayerDataIt it = blocks.begin(); it != blocks.end(); ++it)
{
if (it->index() == layerIdx)
return *it;
}
LayerData<T>& newLayer = load(layerIdx);
assert(newLayer.index() == layerIdx);
return newLayer;
}
template<typename T>
void CircuitData<T>::
setBudget(size_t newBudget)
{
budget = newBudget;
}
template<typename T>
void CircuitData<T>::
setSizes(const std::vector<size_t>& newSizes)
{
this->blockSizes = newSizes;
}
template<typename T>
bool CircuitData<T>::
save() const
{
bool success = true;
typedef typename deque<LayerData<T> >::const_iterator LayerDataCIt;
for (LayerDataCIt it = blocks.begin(); it != blocks.end(); ++it)
success = it->save(circuitDir) && success;
return success;
}
template<typename T>
LayerData<T>& CircuitData<T>::
load(int layerIdx)
{
assert(inRange<int>(layerIdx, 0, blockSizes.size()));
updateUsage();
while (shouldEvict(true))
{
LayerData<T>& layer = blocks.front();
assert(usage >= layer.dataSize());
//cout << "Evicting Layer: " << layer.index() << " Usage: " << usage << endl;
layer.save(circuitDir);
usage -= layer.dataSize();
blocks.pop_front();
}
//cout << "Load Layer: " << layerIdx << " Usage: " << usage << endl;
blocks.push_back(LayerData<T>(layerIdx));
LayerData<T>& newLayer = blocks.back();
newLayer.tryLoad(circuitDir, blockSizes[layerIdx]);
usage += newLayer.dataSize();
return newLayer;
}
template<typename T>
void CircuitData<T>::
updateUsage()
{
usage = 0;
typedef typename deque<LayerData<T> >::const_iterator LayerDataCIt;
for (LayerDataCIt it = blocks.begin(); it != blocks.end(); ++it)
usage += it->dataSize();
}
template<typename T>
bool CircuitData<T>::
shouldEvict(bool evictToAdd) const
{
size_t minNumLayers = 2 + (evictToAdd ? -1 : 0);
return (minNumLayers < blocks.size()) && (usage > budget);
}
template class CircuitData<mpz_t>;
template class CircuitData<mpq_t>;
| 20.778816 | 101 | 0.651724 | hyraxZK |
9e1a6c046f4714f9791f3fe5c29602670e14269b | 2,596 | cpp | C++ | engine/graphics/graphics_bootstrapper.cpp | JellevanCampen/pugvania | 1f964f70b05565adea6c5c55c2c2bae5cac52d53 | [
"MIT"
] | null | null | null | engine/graphics/graphics_bootstrapper.cpp | JellevanCampen/pugvania | 1f964f70b05565adea6c5c55c2c2bae5cac52d53 | [
"MIT"
] | 24 | 2016-09-26T14:54:31.000Z | 2017-02-16T14:01:58.000Z | engine/graphics/graphics_bootstrapper.cpp | JellevanCampen/pugvania | 1f964f70b05565adea6c5c55c2c2bae5cac52d53 | [
"MIT"
] | null | null | null | #include "graphics_bootstrapper.h"
#include "engine.h"
#include "graphics_glfw.h"
namespace engine {
void GraphicsBootstrapper::CameraMove(Point2Df position)
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
void GraphicsBootstrapper::Draw2DPoint(Point2Df point, float z, cRGBAf color) const
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
void GraphicsBootstrapper::Draw2DLine(Line2Df line, float z, cRGBAf color) const
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
void GraphicsBootstrapper::Draw2DRectangle(Rectangle2Df rectangle, float z, bool filled, cRGBAf color) const
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
void GraphicsBootstrapper::Draw2DCircle(Circle2Df circle, float z, bool filled, cRGBAf color) const
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
EngineSubsystem* GraphicsBootstrapper::Initialize()
{
std::string graphics_subsystem;
ConfigFile engine_config((*g_engine->path)["config"] + "engine_config.ini", ConfigFile::WARN_COUT, ConfigFile::WARN_COUT);
engine_config.ReadProperty<std::string>("subsystems.graphics", &graphics_subsystem, "glfw");
// Bootstrap a graphics subsystem implementation based on the config settings
if (graphics_subsystem.compare("glfw") == 0)
{
Graphics* graphics = new GraphicsGLFW();
g_engine->graphics = graphics;
return graphics->Initialize();
}
g_log("The graphics subsystem specified in the config file was not recognized: " + graphics_subsystem, log::kError);
return NULL;
}
void GraphicsBootstrapper::Terminate()
{
g_log("Calling bootstrapper terminator (graphics subsystem bootcaller is terminated, meaning it failed to bootstrap the graphics subsystem during initialization): " __FUNCTION__, log::kError);
}
void GraphicsBootstrapper::Update()
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
void GraphicsBootstrapper::Draw()
{
g_log("Calling bootstrapper function (graphics subsystem call before the graphics subsystem was bootstrapped): " __FUNCTION__, log::kError);
}
}; // namespace | 39.938462 | 194 | 0.780046 | JellevanCampen |
9e23bf60256db25ca0e0d7bcff0e5d946ea581d3 | 2,262 | cpp | C++ | using-cpp-standard-template-libraries-master/Chapter 10/Ex10_02.cpp | ai-chen2050/book-code | 74676efa50ef9e8a4a40b97978d9d42f18070102 | [
"MIT"
] | null | null | null | using-cpp-standard-template-libraries-master/Chapter 10/Ex10_02.cpp | ai-chen2050/book-code | 74676efa50ef9e8a4a40b97978d9d42f18070102 | [
"MIT"
] | null | null | null | using-cpp-standard-template-libraries-master/Chapter 10/Ex10_02.cpp | ai-chen2050/book-code | 74676efa50ef9e8a4a40b97978d9d42f18070102 | [
"MIT"
] | null | null | null | // Ex10_02.cpp
// Dropping bricks safely from a tall building using valarray objects
#include <numeric> // For iota()
#include <iostream> // For standard streams
#include <iomanip> // For stream manipulators
#include <algorithm> // For for_each()
#include <valarray> // For valarray
const static double g {32.0}; // Acceleration due to gravity ft/sec/sec
int main()
{
double height {}; // Building height
std::cout << "Enter the approximate height of the building in feet: ";
std::cin >> height;
// Calculate brick flight time in seconds
double end_time {std::sqrt(2 * height / g)};
size_t max_time {1 + static_cast<size_t>(end_time + 0.5)};
std::valarray<double> times(max_time + 1); // Array to accommodate times
std::iota(std::begin(times), std::end(times), 0); // Initialize: 0 to max_time
*(std::end(times) - 1) = end_time; // Set the last time value
// Calculate distances each second
auto distances = times.apply([](double t) { return 0.5*g*t*t; });
// Calculate speed each second
auto v_fps = sqrt(distances.apply([](double d) { return 2 * g*d; }));
// Lambda expression to output results
auto print = [](double v) { std::cout << std::setw(5) << static_cast<int>(std::round(v)); };
// Output the times - the last is a special case...
std::cout << "Time (seconds): ";
std::for_each(std::begin(times), std::end(times) - 1, print);
std::cout << std::setw(5) << std::fixed << std::setprecision(2) << *(std::end(times) - 1);
std::cout << "\nDistances(feet):";
std::for_each(std::begin(distances), std::end(distances), print);
std::cout << "\nVelocity(fps): ";
std::for_each(std::begin(v_fps), std::end(v_fps), print);
// Get velocities in mph and output them
auto v_mph = v_fps.apply([](double v) { return v * 60 / 88; });
std::cout << "\nVelocity(mph): ";
std::for_each(std::begin(v_mph), std::end(v_mph), print);
std::cout << std::endl;
} | 46.163265 | 98 | 0.549514 | ai-chen2050 |
9e278f92c4dfe47b1b62a04badfa953a67cb3cb1 | 8,336 | cpp | C++ | SFMLTemplate/Model.cpp | Altelus/Monkey-Racers | 421529bf4084f53485750041ccde6f6b96f6a861 | [
"Xnet",
"X11"
] | 2 | 2015-10-27T08:36:36.000Z | 2020-03-28T12:59:24.000Z | SFMLTemplate/Model.cpp | Altelus/Monkey-Racers | 421529bf4084f53485750041ccde6f6b96f6a861 | [
"Xnet",
"X11"
] | null | null | null | SFMLTemplate/Model.cpp | Altelus/Monkey-Racers | 421529bf4084f53485750041ccde6f6b96f6a861 | [
"Xnet",
"X11"
] | null | null | null | #include "Engine.h"
#include <exception>
Model::Model()
{
isLoaded = false;
scale = Vec3 (1,1,1);
originOffsetPos = Vec3 (0,0,0);
forward = Vec3 (0,0,-1);
strafe = Vec3 (1,0,0);
up = Vec3 (0,1,0);
azemuth = elevation = 0;
vbo = new cbmini::cbfw::VertexBuffer;
SetModelType(MODEL_TYPE_VTN);
}
Model::Model(const char* filename, const int type, bool compCollision)
{
isLoaded = false;
scale = Vec3 (1,1,1);
originOffsetPos = Vec3 (0,0,0);
forward = Vec3 (0,0,-1);
strafe = Vec3 (1,0,0);
up = Vec3 (0,1,0);
azemuth = elevation = 0;
vbo = new cbmini::cbfw::VertexBuffer;
SetModelType(type);
loadObj(filename);
if (compCollision)
generateBoundingBox();
}
void Model::SetModelType(int type)
{
if (0 <= type && type <= MODEL_TYPE_VTN)
modelType = type;
}
bool Model::loadObj(const char* filename)
{
float tempSize = 3;
bool result = false;
float vertA, uvA, normA, vertB, uvB, normB, vertC, uvC, normC;
vertA = uvA = normA = vertB = uvB = normB = vertC = uvC = normC = 0;
float x, y, z, u, v, a, b, c;
char line[255];
char header[3];
FILE* file = fopen(filename, "r");
if (file == nullptr)
return false;
try
{
while (!feof(file))
{
readLine(file, line);
sscanf (line, "%s", &header);
if (strcmp(header, "v") == 0)
{
sscanf(line, "%*s %f %f %f", &x, &y, &z);
tempVertices.push_back(x);
tempVertices.push_back(y);
tempVertices.push_back(z);
}
else if (strcmp(header, "vt") == 0)
{
sscanf(line, "%*s %f %f", &u, &v);
tempUVs.push_back(u);
tempUVs.push_back(v);
}
else if (strcmp(header, "vn") == 0)
{
sscanf(line, "%*s %f %f %f", &a, &b, &c);
tempNormals.push_back(a);
tempNormals.push_back(b);
tempNormals.push_back(c);
}
else if(strcmp(header, "f") == 0)
{
if (modelType == MODEL_TYPE_V)
{
sscanf(line, "%*s %f %f %f", &vertA, &vertB, &vertC);
}
else if (modelType == MODEL_TYPE_VT)
{
sscanf(line, "%*s %f/%f %f/%f %f/%f", &vertA, &uvA, &vertB, &uvB, &vertC, &uvC);
}
else if (modelType == MODEL_TYPE_VTN)
{
sscanf(line, "%*s %f/%f/%f %f/%f/%f %f/%f/%f", &vertA, &uvA, &normA, &vertB, &uvB, &normB, &vertC, &uvC, &normC);
}
tempIndices.push_back(vertA);
tempIndices.push_back(uvA);
tempIndices.push_back(normA);
tempIndices.push_back(vertB);
tempIndices.push_back(uvB);
tempIndices.push_back(normB);
tempIndices.push_back(vertC);
tempIndices.push_back(uvC);
tempIndices.push_back(normC);
}
}
fclose(file);
setupVAO();
setupVBO();
isLoaded = result = true;
}
catch(...)
{
tempVertices.clear();
tempUVs.clear();
tempNormals.clear();
tempIndices.clear();
vertices.clear();
uvs.clear();
normals.clear();
}
return result;
}
void Model::draw()
{
if (isLoaded)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glEnable(GL_RESCALE_NORMAL);
vbo->ActivateAndRender();
glDisable(GL_RESCALE_NORMAL);
glDisable(GL_TEXTURE_2D);
}
}
void Model::drawNoTextures()
{
if (isLoaded)
{
glEnable(GL_RESCALE_NORMAL);
vbo->ActivateAndRender();
glDisable(GL_RESCALE_NORMAL);
}
}
void Model::drawBoundingBox()
{
if (isLoaded)
{
glPushMatrix();
glTranslatef(pos.x, pos.y, pos.z);
glScalef(scale.x, scale.y, scale.z);
//boundingBox.RotateX(rot.x);
//boundingBox.RotateY(rot.y);
//boundingBox.RotateZ(rot.z);
glRotatef(rot.x, 1, 0, 0);
glRotatef(rot.y, 0, 1, 0);
glRotatef(rot.z, 0, 0, 1);
glRotatef(-elevation, 1.0f, 0.0f, 0.0f);
glRotatef(-azemuth, 0.0f, 1.0f, 0.0f);
glEnable(GL_RESCALE_NORMAL);
glBegin(GL_QUADS);
glVertex3f(-boundingBox.x, -boundingBox.y, boundingBox.z);
glVertex3f(-boundingBox.x, boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, -boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, -boundingBox.y, -boundingBox.z);
glVertex3f(boundingBox.x, boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, -boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, boundingBox.y, boundingBox.z);
glVertex3f(-boundingBox.x, -boundingBox.y, boundingBox.z);
glVertex3f(-boundingBox.x, -boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, boundingBox.y, -boundingBox.z);
glVertex3f(boundingBox.x, -boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, boundingBox.y, -boundingBox.z);
glVertex3f(boundingBox.x, -boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, -boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, -boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, -boundingBox.y, boundingBox.z);
glVertex3f(boundingBox.x, -boundingBox.y, -boundingBox.z);
glVertex3f(-boundingBox.x, boundingBox.y, -boundingBox.z);
glVertex3f(boundingBox.x, boundingBox.y, -boundingBox.z);
glVertex3f(boundingBox.x, boundingBox.y, boundingBox.z);
glVertex3f(-boundingBox.x, boundingBox.y, boundingBox.z);
glEnd();
glDisable(GL_RESCALE_NORMAL);
glPopMatrix();
}
}
void Model::readLine(FILE * fp, char * string)
{
do
{
fgets(string, 255, fp);
} while (string[0] == '\n');
return;
}
Model::~Model()
{
tempVertices.clear();
tempUVs.clear();
tempNormals.clear();
tempIndices.clear();
vertices.clear();
uvs.clear();
normals.clear();
vbo->Release();
delete vbo;
}
bool Model::generateBoundingBox()
{
bool result = false;
if (isLoaded)
{
float minX, maxX;
float minY, maxY;
float minZ, maxZ;
minX = maxX = tempVertices[0];
minY = maxY = tempVertices[1];
minZ = maxZ = tempVertices[2];
for(unsigned int i = 0; i < tempVertices.size(); i+=3)
{
if (tempVertices[i] < minX)
minX = tempVertices[i];
else if (tempVertices[i] > maxX)
maxX = tempVertices[i];
if (tempVertices[i+1] < minY)
minY = tempVertices[i+1];
else if (tempVertices[i+1] > maxY)
maxY = tempVertices[i+1];
if (tempVertices[i+2] < minZ)
minZ = tempVertices[i+2];
else if (tempVertices[i+2] > maxZ)
maxZ = tempVertices[i+2];
}
// create bounding box based on min/max values of each axis
boundingBox.x = ((maxX - minX) / 2)*scale.x;
boundingBox.y = ((maxY - minY) / 2)*scale.y;
boundingBox.z = ((maxZ - minZ) / 2)*scale.z;
// calculate offset of object from origin 0,0,0 (for objs not in the center)
originOffsetPos.x = minX + boundingBox.x;
originOffsetPos.y = minY + boundingBox.y;
originOffsetPos.z = minZ + boundingBox.z;
result = true;
}
return result;
}
// lerp from cur model to target
Model* Model::morph( Model* target, float dt)
{
Model* result;
if (tempVertices.size() == target->tempVertices.size())
{
result = new Model();
result->isLoaded = true;
result->copyAllAttributes(target);
for (unsigned int i = 0; i < tempVertices.size(); i++)
{
result->tempVertices.push_back(LERP(tempVertices[i], target->tempVertices[i], dt));
}
result->tempUVs = tempUVs;
result->tempNormals = tempNormals;
result->tempIndices = tempIndices;
result->setupVAO();
result->setupVBO();
}
return result;
}
void Model::copyAllAttributes( Model* target )
{
texture = target->texture;
boundingBox = target->boundingBox;
pos = target->pos;
rot = target->rot;
scale = target->scale;
forward = target->forward;
up = target->up;
strafe = target->strafe;
azemuth = target->azemuth;
elevation = target->elevation;
originOffsetPos = target->originOffsetPos;
}
void Model::setupVAO()
{
vertices.clear();
uvs.clear();
normals.clear();
for (unsigned int i = 0; i < tempIndices.size(); i+=3)
{
vertices.push_back(tempVertices[((tempIndices[i]-1)*3)]);
vertices.push_back(tempVertices[((tempIndices[i]-1)*3)+1]);
vertices.push_back(tempVertices[((tempIndices[i]-1)*3)+2]);
uvs.push_back(tempUVs[((tempIndices[i+1]-1)*2)]);
uvs.push_back(-tempUVs[((tempIndices[i+1]-1)*2)+1]);
normals.push_back(tempNormals[((tempIndices[i+2]-1)*3)]);
normals.push_back(tempNormals[((tempIndices[i+2]-1)*3)+1]);
normals.push_back(tempNormals[((tempIndices[i+2]-1)*3)+2]);
}
}
void Model::setupVBO()
{
vbo->Initialize(vertices.size()/3, true, true);
vbo->AddVertices(&vertices[0]);
vbo->AddNormals(&normals[0]);
vbo->AddTexcoords(&uvs[0]);
}
| 22.408602 | 118 | 0.65547 | Altelus |
9e27eff4653398d4b0f1275a816157112be950ae | 2,540 | hpp | C++ | sm_value_store/include/sm/value_store/VerboseValueStore.hpp | christian-rauch/schweizer_messer | 9b8f99f4387e7a8f4105e54b27f22ecee5ea0cd0 | [
"BSD-3-Clause"
] | 35 | 2017-12-07T15:13:02.000Z | 2021-11-07T19:51:05.000Z | sm_value_store/include/sm/value_store/VerboseValueStore.hpp | christian-rauch/schweizer_messer | 9b8f99f4387e7a8f4105e54b27f22ecee5ea0cd0 | [
"BSD-3-Clause"
] | 48 | 2015-01-01T21:18:18.000Z | 2017-07-30T08:43:05.000Z | sm_value_store/include/sm/value_store/VerboseValueStore.hpp | christian-rauch/schweizer_messer | 9b8f99f4387e7a8f4105e54b27f22ecee5ea0cd0 | [
"BSD-3-Clause"
] | 13 | 2015-02-03T15:54:40.000Z | 2017-10-08T17:10:43.000Z | #ifndef VALUE_STORE_VERBOSEVALUESTORE_HPP_
#define VALUE_STORE_VERBOSEVALUESTORE_HPP_
#include <memory>
#include <functional>
#include "ValueStore.hpp"
namespace sm {
namespace value_store {
namespace internal {
template <typename Base>
class VerboseValueStoreT : public Base {
public:
VerboseValueStoreT(std::shared_ptr<Base> vs, std::function<void(const std::string &)> log) : vs_(vs), log_(log) {}
ValueHandle<bool> getBool(const std::string & path, boost::optional<bool> def = boost::optional<bool>()) const override;
ValueHandle<int> getInt(const std::string & path, boost::optional<int> def = boost::optional<int>()) const override;
ValueHandle<double> getDouble(const std::string & path, boost::optional<double> def = boost::optional<double>()) const override;
ValueHandle<std::string> getString(const std::string & path, boost::optional<std::string> def = boost::optional<std::string>()) const override;
bool hasKey(const std::string & path) const override;
bool isChildSupported() const override;
KeyValueStorePair getChild(const std::string & key) const override;
std::vector<KeyValueStorePair> getChildren() const override;
std::shared_ptr<Base> getUnderlyingValueStore() const {
return vs_;
}
protected:
std::shared_ptr<Base> vs_;
std::function<void(const std::string &)> log_;
private:
template <typename T, typename O = bool>
T logValue(const char * func, const std::string & path, T && v, O o = false) const;
};
extern template class VerboseValueStoreT<ValueStore>;
extern template class VerboseValueStoreT<ExtendibleValueStore>;
}
using VerboseValueStore = internal::VerboseValueStoreT<ValueStore>;
class VerboseExtendibleValueStore : public internal::VerboseValueStoreT<ExtendibleValueStore> {
public:
using internal::VerboseValueStoreT<ExtendibleValueStore>::VerboseValueStoreT;
ValueHandle<bool> addBool(const std::string & path, bool initialValue) override;
ValueHandle<int> addInt(const std::string & path, int initialValue) override;
ValueHandle<double> addDouble(const std::string & path, double initialValue) override;
ValueHandle<std::string> addString(const std::string & path, std::string initialValue) override;
ExtendibleKeyValueStorePair getExtendibleChild(const std::string & key) const override;
std::vector<ExtendibleKeyValueStorePair> getExtendibleChildren() const override;
private:
template <typename T>
T logAddValue(const char * func, const std::string & path, T && v) const;
};
}
}
#endif /* VALUE_STORE_VERBOSEVALUESTORE_HPP_ */
| 39.076923 | 145 | 0.761811 | christian-rauch |
9e28b647d6be0108ec5cf3b748952e7cba7ccf33 | 1,184 | cpp | C++ | src/PeerPluginStatus.cpp | JoystreamClassic/joystream-node | 2450382bb937abdd959b460791c25f2d8f127168 | [
"MIT"
] | null | null | null | src/PeerPluginStatus.cpp | JoystreamClassic/joystream-node | 2450382bb937abdd959b460791c25f2d8f127168 | [
"MIT"
] | 9 | 2017-11-14T06:05:50.000Z | 2018-07-08T18:21:17.000Z | src/PeerPluginStatus.cpp | JoystreamClassic/joystream-node | 2450382bb937abdd959b460791c25f2d8f127168 | [
"MIT"
] | 4 | 2017-11-14T06:04:17.000Z | 2018-08-24T07:39:00.000Z | /**
* Copyright (C) JoyStream - All Rights Reserved
* Unauthorized copying of this file, via any medium is strictly prohibited
* Proprietary and confidential
* Written by Bedeho Mender <[email protected]>, February 3 2017
*/
#include "PeerPluginStatus.hpp"
#include "libtorrent-node/utils.hpp"
#include "libtorrent-node/endpoint.hpp"
#include "libtorrent-node/peer_id.hpp"
#include "BEPSupportStatus.hpp"
#include "Connection.hpp"
namespace joystream {
namespace node {
namespace peer_plugin_status {
NAN_MODULE_INIT(Init) {
bep_support_status::Init(target);
connection::Init(target);
}
v8::Local<v8::Object> encode(const extension::status::PeerPlugin & s) {
v8::Local<v8::Object> o = Nan::New<v8::Object>();
SET_VAL(o, "pid", libtorrent::node::peer_id::encode(s.peerId));
SET_VAL(o, "endPoint", libtorrent::node::endpoint::encode(s.endPoint));
SET_VAL(o, "peerBEP10SupportStatus", bep_support_status::encode(s.peerBEP10SupportStatus));
SET_VAL(o, "peerBitSwaprBEPSupportStatus", bep_support_status::encode(s.peerBitSwaprBEPSupportStatus));
if(s.connection)
SET_VAL(o, "connection", connection::encode(s.connection.get()));
return o;
}
}
}
}
| 28.190476 | 105 | 0.743243 | JoystreamClassic |
9e2a2ebc48b598f7e024e3c514d81206030298da | 1,046 | cpp | C++ | Rozi/UchitelskiSustav/main.cpp | slaviborisov/shu.bg | 1ed9a65fff1512d18a3e4cde90030abb450f0d9f | [
"Apache-2.0"
] | null | null | null | Rozi/UchitelskiSustav/main.cpp | slaviborisov/shu.bg | 1ed9a65fff1512d18a3e4cde90030abb450f0d9f | [
"Apache-2.0"
] | null | null | null | Rozi/UchitelskiSustav/main.cpp | slaviborisov/shu.bg | 1ed9a65fff1512d18a3e4cde90030abb450f0d9f | [
"Apache-2.0"
] | null | null | null | #include "uchitelski-sustav.h"
#include <iostream>
using namespace std;
int main()
{
system("chcp 1251");
CUSustav uchSustav;
int c;
do {
cout <<endl;
cout << "0. Изход от програмата"<<endl;
cout << "1. Добавяне на нов учител"<<endl;
cout << "2. Покажи учител"<<endl;
cout << "3. Покажи учителския състав"<<endl;
cout << "4. Изтриване на учител"<<endl;
cout << "5. Показване всички учители по зададена дисциплина"<<endl;
cout << "6. Показване на водената дисциплина на учителя с най-голям стаж"<<endl;
cin >> c;
switch(c)
{
case 0: break;
case 1: uchSustav.AddUchitel(); break;
case 2: uchSustav.PrintUchitel(); break;
case 3: uchSustav.PrintUchSustav(); break;
case 4: uchSustav.DeleteUchitel(); break;
case 5: uchSustav.PrintUchiteliPoDisciplina(); break;
case 6: uchSustav.PrintDiscplinaPoStaj(); break;
default: cout << "Грешен избор!"<<endl; break;
}
} while(c);
system("pause");
return 0;
}
| 28.27027 | 85 | 0.607075 | slaviborisov |
9e2f7022a5c361fccb22e9da1eef03fc9bd9f980 | 570,872 | cpp | C++ | src/server/game/Entities/Unit/Unit.cpp | Zone-Emu/ZoneEmuCataclysm | 6277efff6cb5adfe8b7a718bf376e81609fa9a6c | [
"OpenSSL"
] | 1 | 2019-03-23T19:32:57.000Z | 2019-03-23T19:32:57.000Z | src/server/game/Entities/Unit/Unit.cpp | Zone-Emu/ZoneEmuCataclysm | 6277efff6cb5adfe8b7a718bf376e81609fa9a6c | [
"OpenSSL"
] | null | null | null | src/server/game/Entities/Unit/Unit.cpp | Zone-Emu/ZoneEmuCataclysm | 6277efff6cb5adfe8b7a718bf376e81609fa9a6c | [
"OpenSSL"
] | null | null | null | /*
* Copyright (C) 2005 - 2012 MaNGOS <http://www.getmangos.com/>
*
* Copyright (C) 2008 - 2012 Trinity <http://www.trinitycore.org/>
*
* Copyright (C) 2010 - 2012 ArkCORE <http://www.arkania.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.
*
* 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "gamePCH.h"
#include "Common.h"
#include "CreatureAIImpl.h"
#include "Log.h"
#include "Opcodes.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "World.h"
#include "ObjectMgr.h"
#include "SpellMgr.h"
#include "Unit.h"
#include "QuestDef.h"
#include "Player.h"
#include "Creature.h"
#include "Spell.h"
#include "Group.h"
#include "SpellAuras.h"
#include "SpellAuraEffects.h"
#include "MapManager.h"
#include "ObjectAccessor.h"
#include "CreatureAI.h"
#include "Formulas.h"
#include "Pet.h"
#include "Util.h"
#include "Totem.h"
#include "Battleground.h"
#include "OutdoorPvP.h"
#include "InstanceSaveMgr.h"
#include "GridNotifiersImpl.h"
#include "CellImpl.h"
#include "Path.h"
#include "CreatureGroups.h"
#include "PetAI.h"
#include "PassiveAI.h"
#include "Traveller.h"
#include "TemporarySummon.h"
#include "Vehicle.h"
#include "Transport.h"
#include <math.h>
float baseMoveSpeed [MAX_MOVE_TYPE] =
{ 2.5f, // MOVE_WALK
7.0f, // MOVE_RUN
2.5f, // MOVE_RUN_BACK
4.722222f, // MOVE_SWIM
4.5f, // MOVE_SWIM_BACK
3.141594f, // MOVE_TURN_RATE
7.0f, // MOVE_FLIGHT
4.5f, // MOVE_FLIGHT_BACK
3.14f // MOVE_PITCH_RATE
};
float playerBaseMoveSpeed [MAX_MOVE_TYPE] =
{ 2.5f, // MOVE_WALK
7.0f, // MOVE_RUN
2.5f, // MOVE_RUN_BACK
4.722222f, // MOVE_SWIM
4.5f, // MOVE_SWIM_BACK
3.141594f, // MOVE_TURN_RATE
7.0f, // MOVE_FLIGHT
4.5f, // MOVE_FLIGHT_BACK
3.14f // MOVE_PITCH_RATE
};
// Used for prepare can/can`t triggr aura
static bool InitTriggerAuraData();
// Define can trigger auras
static bool isTriggerAura [TOTAL_AURAS];
// Define can`t trigger auras (need for disable second trigger)
static bool isNonTriggerAura [TOTAL_AURAS];
// Triggered always, even from triggered spells
static bool isAlwaysTriggeredAura [TOTAL_AURAS];
// Prepare lists
static bool procPrepared = InitTriggerAuraData();
// we can disable this warning for this since it only
// causes undefined behavior when passed to the base class constructor
#ifdef _MSC_VER
#pragma warning(disable:4355)
#endif
Unit::Unit() :
WorldObject(), m_movedPlayer(NULL), IsAIEnabled(false), NeedChangeAI(
false), m_ControlledByPlayer(false), i_AI(NULL), i_disabledAI(
NULL), m_procDeep(0), m_removedAurasCount(0), i_motionMaster(
this), m_ThreatManager(this), m_vehicle(NULL), m_vehicleKit(
NULL), m_unitTypeMask(UNIT_MASK_NONE), m_HostileRefManager(
this), m_lastSanctuaryTime(0)
{
#ifdef _MSC_VER
#pragma warning(default:4355)
#endif
m_objectType |= TYPEMASK_UNIT;
m_objectTypeId = TYPEID_UNIT;
m_updateFlag = (UPDATEFLAG_LIVING | UPDATEFLAG_HAS_POSITION);
DmgandHealDoneTimer = 0;
m_attackTimer [BASE_ATTACK] = 0;
m_attackTimer [OFF_ATTACK] = 0;
m_attackTimer [RANGED_ATTACK] = 0;
m_modAttackSpeedPct [BASE_ATTACK] = 1.0f;
m_modAttackSpeedPct [OFF_ATTACK] = 1.0f;
m_modAttackSpeedPct [RANGED_ATTACK] = 1.0f;
m_extraAttacks = 0;
m_canDualWield = false;
m_rootTimes = 0;
m_state = 0;
m_deathState = ALIVE;
for (uint8 i = 0; i < CURRENT_MAX_SPELL; ++i)
m_currentSpells [i] = NULL;
m_addDmgOnce = 0;
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
m_SummonSlot [i] = 0;
m_ObjectSlot [0] = m_ObjectSlot [1] = m_ObjectSlot [2] = m_ObjectSlot [3] =
0;
m_auraUpdateIterator = m_ownedAuras.end();
m_interruptMask = 0;
m_transform = 0;
m_canModifyStats = false;
for (uint8 i = 0; i < MAX_SPELL_IMMUNITY; ++i)
m_spellImmune [i].clear();
for (uint8 i = 0; i < UNIT_MOD_END; ++i)
{
m_auraModifiersGroup [i] [BASE_VALUE] = 0.0f;
m_auraModifiersGroup [i] [BASE_PCT] = 1.0f;
m_auraModifiersGroup [i] [TOTAL_VALUE] = 0.0f;
m_auraModifiersGroup [i] [TOTAL_PCT] = 1.0f;
}
// implement 50% base damage from offhand
m_auraModifiersGroup [UNIT_MOD_DAMAGE_OFFHAND] [TOTAL_PCT] = 0.5f;
for (uint8 i = 0; i < MAX_ATTACK; ++i)
{
m_weaponDamage [i] [MINDAMAGE] = BASE_MINDAMAGE;
m_weaponDamage [i] [MAXDAMAGE] = BASE_MAXDAMAGE;
}
for (uint8 i = 0; i < MAX_STATS; ++i)
m_createStats [i] = 0.0f;
m_attacking = NULL;
m_modMeleeHitChance = 0.0f;
m_modRangedHitChance = 0.0f;
m_modSpellHitChance = 0.0f;
m_baseSpellCritChance = 5;
m_CombatTimer = 0;
m_lastManaUse = 0;
//m_victimThreat = 0.0f;
for (uint8 i = 0; i < MAX_SPELL_SCHOOL; ++i)
m_threatModifier [i] = 1.0f;
m_isSorted = true;
for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
m_speed_rate [i] = 1.0f;
m_charmInfo = NULL;
//m_unit_movement_flags = 0;
m_reducedThreatPercent = 0;
m_misdirectionTargetGUID = 0;
// remove aurastates allowing special moves
for (uint8 i = 0; i < MAX_REACTIVE; ++i)
m_reactiveTimer [i] = 0;
m_cleanupDone = false;
m_duringRemoveFromWorld = false;
m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST,
GHOST_VISIBILITY_ALIVE);
for (uint32 i = 0; i < 120; ++i)
m_damage_done [i] = 0;
for (uint32 i = 0; i < 120; ++i)
m_heal_done [i] = 0;
for (uint32 i = 0; i < 120; ++i)
m_damage_taken [i] = 0;
m_AbsorbHeal = 0.0f;
}
Unit::~Unit()
{
// set current spells as deletable
for (uint8 i = 0; i < CURRENT_MAX_SPELL; ++i)
{
if (m_currentSpells [i])
{
m_currentSpells [i]->SetReferencedFromCurrent(false);
m_currentSpells [i] = NULL;
}
}
_DeleteRemovedAuras();
delete m_charmInfo;
delete m_vehicleKit;
ASSERT(!m_duringRemoveFromWorld);
ASSERT(!m_attacking);
ASSERT(m_attackers.empty());
ASSERT(m_sharedVision.empty());
ASSERT(m_Controlled.empty());
ASSERT(m_appliedAuras.empty());
ASSERT(m_ownedAuras.empty());
ASSERT(m_removedAuras.empty());
ASSERT(m_gameObj.empty());
ASSERT(m_dynObj.empty());
}
void Unit::Update(uint32 p_time)
{
// WARNING! Order of execution here is important, do not change.
// Spells must be processed with event system BEFORE they go to _UpdateSpells.
// Or else we may have some SPELL_STATE_FINISHED spells stalled in pointers, that is bad.
m_Events.Update(p_time);
if (!IsInWorld()) return;
// This is required for GetHealingDoneInPastSecs(), GetDamageDoneInPastSecs() and GetDamageTakenInPastSecs()!
DmgandHealDoneTimer -= p_time;
if (DmgandHealDoneTimer <= 0)
{
for (uint32 i = 119; i > 0; i--)
{
m_damage_done [i] = m_damage_done [i - 1];
}
m_damage_done [0] = 0;
for (uint32 i = 119; i > 0; i--)
{
m_heal_done [i] = m_heal_done [i - 1];
}
m_heal_done [0] = 0;
for (uint32 i = 119; i > 0; i--)
{
m_damage_taken [i] = m_damage_taken [i - 1];
}
m_damage_taken [0] = 0;
DmgandHealDoneTimer = 1000;
}
_UpdateSpells(p_time);
// If this is set during update SetCantProc(false) call is missing somewhere in the code
// Having this would prevent spells from being proced, so let's crash
ASSERT(!m_procDeep);
if (CanHaveThreatList() && getThreatManager().isNeedUpdateToClient(p_time)) SendThreatListUpdate();
// update combat timer only for players and pets (only pets with PetAI)
if (isInCombat()
&& (GetTypeId() == TYPEID_PLAYER
|| (ToCreature()->isPet() && IsControlledByPlayer())))
{
// Check UNIT_STAT_MELEE_ATTACKING or UNIT_STAT_CHASE (without UNIT_STAT_FOLLOW in this case) so pets can reach far away
// targets without stopping half way there and running off.
// These flags are reset after target dies or another command is given.
if (m_HostileRefManager.isEmpty())
{
// m_CombatTimer set at aura start and it will be freeze until aura removing
if (m_CombatTimer <= p_time) ClearInCombat();
else m_CombatTimer -= p_time;
}
}
//not implemented before 3.0.2
//if (!HasUnitState(UNIT_STAT_CASTING))
{
if (uint32 base_att = getAttackTimer(BASE_ATTACK)) setAttackTimer(
BASE_ATTACK, (p_time >= base_att ? 0 : base_att - p_time));
if (uint32 ranged_att = getAttackTimer(RANGED_ATTACK)) setAttackTimer(
RANGED_ATTACK,
(p_time >= ranged_att ? 0 : ranged_att - p_time));
if (uint32 off_att = getAttackTimer(OFF_ATTACK)) setAttackTimer(
OFF_ATTACK, (p_time >= off_att ? 0 : off_att - p_time));
}
// update abilities available only for fraction of time
UpdateReactives(p_time);
if (isAlive())
{
ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, HealthBelowPct(20));
ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, HealthBelowPct(35));
ModifyAuraState(AURA_STATE_HEALTH_ABOVE_75_PERCENT, HealthAbovePct(75));
}
i_motionMaster.UpdateMotion(p_time);
}
bool Unit::haveOffhandWeapon() const
{
if (GetTypeId() == TYPEID_PLAYER) return this->ToPlayer()->GetWeaponForAttack(
OFF_ATTACK, true);
else return m_canDualWield;
}
void Unit::SendMonsterMoveWithSpeedToCurrentDestination(Player* player)
{
float x, y, z;
if (GetMotionMaster()->GetDestination(x, y, z)) SendMonsterMoveWithSpeed(x,
y, z, 0, player);
}
void Unit::SendMonsterMoveWithSpeed(float x, float y, float z,
uint32 transitTime, Player* player)
{
if (!transitTime)
{
if (GetTypeId() == TYPEID_PLAYER)
{
Traveller <Player> traveller(*(Player*) this);
transitTime = traveller.GetTotalTrevelTimeTo(x, y, z);
}
else
{
Traveller <Creature> traveller(*this->ToCreature());
transitTime = traveller.GetTotalTrevelTimeTo(x, y, z);
}
}
//float orientation = (float)atan2((double)dy, (double)dx);
SendMonsterMove(x, y, z, transitTime, player);
}
void Unit::SetFacing(float ori, WorldObject* obj)
{
SetOrientation(obj ? GetAngle(obj) : ori);
WorldPacket data(
SMSG_MONSTER_MOVE,
(1 + 12 + 4 + 1 + (obj ? 8 : 4) + 4 + 4 + 4 + 12
+ GetPackGUID().size()));
data.append(GetPackGUID());
data << uint8(0); //unk
data << GetPositionX() << GetPositionY() << GetPositionZ();
data << getMSTime();
if (obj)
{
data << uint8(SPLINETYPE_FACING_TARGET);
data << uint64(obj->GetGUID());
}
else
{
data << uint8(SPLINETYPE_FACING_ANGLE);
data << ori;
}
data << uint32(SPLINEFLAG_NONE);
data << uint32(0); //move time 0
data << uint32(1); //one point
data << GetPositionX() << GetPositionY() << GetPositionZ();
SendMessageToSet(&data, true);
}
void Unit::SendMonsterStop(bool on_death)
{
WorldPacket data(SMSG_MONSTER_MOVE, (17 + GetPackGUID().size()));
data.append(GetPackGUID());
data << uint8(0); // new in 3.1
data << GetPositionX() << GetPositionY() << GetPositionZ();
data << getMSTime();
if (on_death == true)
{
data << uint8(0);
data
<< uint32(
(GetUnitMovementFlags() & MOVEMENTFLAG_LEVITATING) ?
SPLINEFLAG_FLYING : SPLINEFLAG_WALKING);
data << uint32(0); // Time in between points
data << uint32(1); // 1 single waypoint
data << GetPositionX() << GetPositionY() << GetPositionZ();
}
else data << uint8(1);
SendMessageToSet(&data, true);
ClearUnitState(UNIT_STAT_MOVE);
}
void Unit::SendMonsterMove(float NewPosX, float NewPosY, float NewPosZ,
uint32 Time, Player* player)
{
WorldPacket data(SMSG_MONSTER_MOVE,
1 + 12 + 4 + 1 + 4 + 4 + 4 + 12 + GetPackGUID().size());
data.append(GetPackGUID());
data << uint8(0); // new in 3.1
data << GetPositionX() << GetPositionY() << GetPositionZ();
data << getMSTime();
data << uint8(0);
data
<< uint32(
(GetUnitMovementFlags() & MOVEMENTFLAG_LEVITATING) ?
SPLINEFLAG_FLYING : SPLINEFLAG_WALKING);
data << Time; // Time in between points
data << uint32(1); // 1 single waypoint
data << NewPosX << NewPosY << NewPosZ; // the single waypoint Point B
if (player) player->GetSession()->SendPacket(&data);
else SendMessageToSet(&data, true);
AddUnitState(UNIT_STAT_MOVE);
}
void Unit::SendMonsterMove(float NewPosX, float NewPosY, float NewPosZ,
uint32 MoveFlags, uint32 time, float speedZ, Player *player)
{
WorldPacket data(SMSG_MONSTER_MOVE,
12 + 4 + 1 + 4 + 4 + 4 + 12 + GetPackGUID().size());
data.append(GetPackGUID());
data << uint8(0); // new in 3.1
data << GetPositionX() << GetPositionY() << GetPositionZ();
data << getMSTime();
data << uint8(0);
data << MoveFlags;
if (MoveFlags & SPLINEFLAG_TRAJECTORY)
{
data << time;
data << speedZ;
data << (uint32) 0; // walk time after jump
}
else data << time;
data << uint32(1); // 1 single waypoint
data << NewPosX << NewPosY << NewPosZ; // the single waypoint Point B
if (player) player->GetSession()->SendPacket(&data);
else SendMessageToSet(&data, true);
}
void Unit::SendMonsterMove(MonsterMoveData const& moveData, Player* player)
{
WorldPacket data(SMSG_MONSTER_MOVE,
GetPackGUID().size() + 1 + 12 + 4 + 1 + 4 + 8 + 4 + 4 + 12);
data.append(GetPackGUID());
data << uint8(0); // new in 3.1
data << GetPositionX() << GetPositionY() << GetPositionZ();
data << getMSTime();
data << uint8(0);
data << moveData.SplineFlag;
if (moveData.SplineFlag & SPLINEFLAG_ANIMATIONTIER)
{
data << uint8(moveData.AnimationState);
data << uint32(0);
}
data << moveData.Time;
if (moveData.SplineFlag & SPLINEFLAG_TRAJECTORY)
{
data << moveData.SpeedZ;
data << uint32(0); // walk time after jump
}
data << uint32(1); // waypoint count
data << moveData.DestLocation.GetPositionX();
data << moveData.DestLocation.GetPositionY();
data << moveData.DestLocation.GetPositionZ();
if (player) player->GetSession()->SendPacket(&data);
else SendMessageToSet(&data, true);
}
void Unit::SendMonsterMoveTransport(Unit *vehicleOwner)
{
// TODO: Turn into BuildMonsterMoveTransport packet and allow certain variables (for npc movement aboard vehicles)
WorldPacket data(SMSG_MONSTER_MOVE_TRANSPORT,
GetPackGUID().size() + vehicleOwner->GetPackGUID().size() + 47);
data.append(GetPackGUID());
data.append(vehicleOwner->GetPackGUID());
data << int8(GetTransSeat());
data << uint8(0); // unk boolean
data << GetPositionX() - vehicleOwner->GetPositionX();
data << GetPositionY() - vehicleOwner->GetPositionY();
data << GetPositionZ() - vehicleOwner->GetPositionZ();
data << uint32(getMSTime()); // should be an increasing constant that indicates movement packet count
data << uint8(SPLINETYPE_FACING_ANGLE);
data << GetOrientation(); // facing angle?
data << uint32(SPLINEFLAG_TRANSPORT);
data << uint32(GetTransTime()); // move time
data << uint32(1); // amount of waypoints
data << GetTransOffsetX();
data << GetTransOffsetY();
data << GetTransOffsetZ();
SendMessageToSet(&data, true);
}
void Unit::resetAttackTimer(WeaponAttackType type)
{
m_attackTimer [type] = uint32(
GetAttackTime(type) * m_modAttackSpeedPct [type]);
}
bool Unit::IsWithinCombatRange(const Unit *obj, float dist2compare) const
{
if (!obj || !IsInMap(obj)) return false;
float dx = GetPositionX() - obj->GetPositionX();
float dy = GetPositionY() - obj->GetPositionY();
float dz = GetPositionZ() - obj->GetPositionZ();
float distsq = dx * dx + dy * dy + dz * dz;
float sizefactor = GetCombatReach() + obj->GetCombatReach();
float maxdist = dist2compare + sizefactor;
return distsq < maxdist * maxdist;
}
bool Unit::IsWithinMeleeRange(const Unit *obj, float dist) const
{
if (!obj || !IsInMap(obj)) return false;
float dx = GetPositionX() - obj->GetPositionX();
float dy = GetPositionY() - obj->GetPositionY();
float dz = GetPositionZ() - obj->GetPositionZ();
float distsq = dx * dx + dy * dy + dz * dz;
float sizefactor = GetMeleeReach() + obj->GetMeleeReach();
float maxdist = dist + sizefactor;
return distsq < maxdist * maxdist;
}
void Unit::GetRandomContactPoint(const Unit* obj, float &x, float &y, float &z,
float distance2dMin, float distance2dMax) const
{
float combat_reach = GetCombatReach();
if (combat_reach < 0.1) // sometimes bugged for players
{
//sLog->outError("Unit %u (Type: %u) has invalid combat_reach %f", GetGUIDLow(), GetTypeId(), combat_reach);
//if (GetTypeId() == TYPEID_UNIT)
// sLog->outError("Creature entry %u has invalid combat_reach", this->ToCreature()->GetEntry());
combat_reach = DEFAULT_COMBAT_REACH;
}
uint32 attacker_number = getAttackers().size();
if (attacker_number > 0) --attacker_number;
GetNearPoint(
obj,
x,
y,
z,
obj->GetCombatReach(),
distance2dMin
+ (distance2dMax - distance2dMin) * (float) rand_norm(),
GetAngle(obj)
+ (attacker_number ?
(static_cast <float>(M_PI / 2)
- static_cast <float>(M_PI)
* (float) rand_norm())
* float(attacker_number) / combat_reach
* 0.3f :
0));
}
void Unit::UpdateInterruptMask()
{
m_interruptMask = 0;
for (AuraApplicationList::const_iterator i = m_interruptableAuras.begin();
i != m_interruptableAuras.end(); ++i)
m_interruptMask |= (*i)->GetBase()->GetSpellProto()->AuraInterruptFlags;
if (Spell* spell = m_currentSpells[CURRENT_CHANNELED_SPELL]) if (spell->getState()
== SPELL_STATE_CASTING) m_interruptMask |=
spell->m_spellInfo->ChannelInterruptFlags;
}
bool Unit::HasAuraTypeWithFamilyFlags(AuraType auraType, uint32 familyName,
uint32 familyFlags) const
{
if (!HasAuraType(auraType)) return false;
AuraEffectList const &auras = GetAuraEffectsByType(auraType);
for (AuraEffectList::const_iterator itr = auras.begin(); itr != auras.end();
++itr)
if (SpellEntry const *iterSpellProto = (*itr)->GetSpellProto()) if (iterSpellProto->SpellFamilyName
== familyName
&& iterSpellProto->SpellFamilyFlags [0] & familyFlags) return true;
return false;
}
void Unit::DealDamageMods(Unit *pVictim, uint32 &damage, uint32* absorb)
{
if (!pVictim->isAlive() || pVictim->HasUnitState(UNIT_STAT_IN_FLIGHT)
|| (pVictim->HasUnitState(UNIT_STAT_ONVEHICLE)
&& pVictim->GetVehicleBase() != this)
|| (pVictim->GetTypeId() == TYPEID_UNIT
&& pVictim->ToCreature()->IsInEvadeMode()))
{
if (absorb) *absorb += damage;
damage = 0;
return;
}
uint32 originalDamage = damage;
if (absorb && originalDamage > damage) *absorb += (originalDamage - damage);
}
uint32 Unit::DealDamage(Unit *pVictim, uint32 damage,
CleanDamage const* cleanDamage, DamageEffectType damagetype,
SpellSchoolMask damageSchoolMask, SpellEntry const *spellProto,
bool durabilityLoss)
{
if (pVictim->IsAIEnabled) pVictim->GetAI()->DamageTaken(this, damage);
if (IsAIEnabled) GetAI()->DamageDealt(pVictim, damage, damagetype);
if (damagetype == DIRECT_DAMAGE || damagetype == SPELL_DIRECT_DAMAGE)
{
m_damage_done [0] += damage;
pVictim->m_damage_taken [0] += damage;
}
if (this->GetTypeId() == TYPEID_PLAYER)
{
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
Player *attacker = this->ToPlayer();
Player *victim = pVictim->ToPlayer();
sScriptMgr->OnPlayerDamageDealt(attacker, victim, damage,
damagetype, spellProto);
}
else if (pVictim->GetTypeId() == TYPEID_UNIT)
{
Player *attacker = this->ToPlayer();
Creature *victim = pVictim->ToCreature();
sScriptMgr->OnPlayerDamageDealt(attacker, victim, damage,
damagetype, spellProto);
}
}
if (damagetype != NODAMAGE)
{
// interrupting auras with AURA_INTERRUPT_FLAG_DAMAGE before checking !damage (absorbed damage breaks that type of auras)
pVictim->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TAKE_DAMAGE,
spellProto ? spellProto->Id : 0);
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
AuraEffectList vCopyDamageCopy(
pVictim->GetAuraEffectsByType(SPELL_AURA_SHARE_DAMAGE_PCT));
// copy damage to casters of this aura
for (AuraEffectList::iterator i = vCopyDamageCopy.begin();
i != vCopyDamageCopy.end(); ++i)
{
// Check if aura was removed during iteration - we don't need to work on such auras
if (!((*i)->GetBase()->IsAppliedOnTarget(pVictim->GetGUID()))) continue;
// check damage school mask
if (((*i)->GetMiscValue() & damageSchoolMask) == 0) continue;
Unit * shareDamageTarget = (*i)->GetCaster();
if (!shareDamageTarget) continue;
SpellEntry const * spell = (*i)->GetSpellProto();
uint32 share = uint32(damage * (float((*i)->GetAmount()) / 100.0f));
// TODO: check packets if damage is done by pVictim, or by attacker of pVictim
DealDamageMods(shareDamageTarget, share, NULL);
DealDamage(shareDamageTarget, share, NULL, NODAMAGE,
GetSpellSchoolMask(spell), spell, false);
}
}
// Rage from Damage made (only from direct weapon damage)
if (cleanDamage && damagetype == DIRECT_DAMAGE && this != pVictim
&& getPowerType() == POWER_RAGE)
{
uint32 weaponSpeedHitFactor;
uint32 rage_damage = damage + cleanDamage->absorbed_damage;
switch (cleanDamage->attackType)
{
case BASE_ATTACK:
{
weaponSpeedHitFactor = uint32(
GetAttackTime(cleanDamage->attackType) / 1000.0f
* 3.5f);
if (cleanDamage->hitOutCome == MELEE_HIT_CRIT) weaponSpeedHitFactor *=
2;
RewardRage(rage_damage, weaponSpeedHitFactor, true);
break;
}
case OFF_ATTACK:
{
weaponSpeedHitFactor = uint32(
GetAttackTime(cleanDamage->attackType) / 1000.0f
* 1.75f);
if (cleanDamage->hitOutCome == MELEE_HIT_CRIT) weaponSpeedHitFactor *=
2;
RewardRage(rage_damage, weaponSpeedHitFactor, true);
break;
}
case RANGED_ATTACK:
break;
default:
break;
}
}
if (!damage)
{
// Rage from absorbed damage
if (cleanDamage && cleanDamage->absorbed_damage
&& pVictim->getPowerType() == POWER_RAGE) pVictim->RewardRage(
cleanDamage->absorbed_damage, 0, false);
return 0;
}
sLog->outStaticDebug("DealDamageStart");
uint32 health = pVictim->GetHealth();
sLog->outDetail("deal dmg:%d to health:%d ", damage, health);
// duel ends when player has 1 or less hp
bool duel_hasEnded = false;
if (pVictim->GetTypeId() == TYPEID_PLAYER && pVictim->ToPlayer()->duel
&& damage >= (health - 1))
{
// prevent kill only if killed in duel and killed by opponent or opponent controlled creature
if (pVictim->ToPlayer()->duel->opponent == this
|| pVictim->ToPlayer()->duel->opponent->GetGUID()
== GetOwnerGUID()) damage = health - 1;
duel_hasEnded = true;
}
if (GetTypeId() == TYPEID_PLAYER && this != pVictim)
{
Player *killer = this->ToPlayer();
// in bg, count dmg if victim is also a player
if (pVictim->GetTypeId() == TYPEID_PLAYER) if (Battleground *bg = killer->GetBattleground()) bg->UpdatePlayerScore(
killer, SCORE_DAMAGE_DONE, damage);
killer->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DAMAGE_DONE,
damage, 0, pVictim);
killer->UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_DEALT, damage);
}
if (pVictim->GetTypeId() == TYPEID_PLAYER) pVictim->ToPlayer()->UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HIT_RECEIVED, damage);
else if (!pVictim->IsControlledByPlayer() || pVictim->IsVehicle())
{
if (!pVictim->ToCreature()->hasLootRecipient()) pVictim->ToCreature()->SetLootRecipient(
this);
if (IsControlledByPlayer()) pVictim->ToCreature()->LowerPlayerDamageReq(
health < damage ? health : damage);
}
if (health <= damage)
{
sLog->outStaticDebug("DealDamage: victim just died");
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
pVictim->ToPlayer()->UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, health);
// call before auras are removed
if (Player* killer = this->ToPlayer()) // keep the this-> for clarity
killer->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL, 1, 0, pVictim);
}
if (this->ToPlayer() && this->isAlive()) // Trinkets Heirloom
if (this->ToPlayer()->isHonorOrXPTarget(pVictim))
{
AuraEffectList const& heirloom = GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator j = heirloom.begin();
j != heirloom.end(); ++j)
{
if ((*j)->GetId() == 59915
&& this->getPowerType() == POWER_MANA) this->CastSpell(
this, 59914, true);
if ((*j)->GetId() == 59906)
{
int32 bonushealth = this->GetMaxHealth()
* this->GetAura(59906)->GetEffect(0)->GetAmount()
/ 100;
this->CastCustomSpell(this, 59913, &bonushealth, 0, 0,
true);
}
}
}
Kill(pVictim, durabilityLoss);
}
else
{
sLog->outStaticDebug("DealDamageAlive");
if (pVictim->GetTypeId() == TYPEID_PLAYER) pVictim->ToPlayer()->UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_TOTAL_DAMAGE_RECEIVED, damage);
// Brain Freeze
if (GetTypeId() == TYPEID_PLAYER)
{
if (damagetype == SPELL_DIRECT_DAMAGE)
{
if (GetSpellSchoolMask(spellProto) == SPELL_SCHOOL_MASK_FROST)
{
if (this->ToPlayer()->HasAura(44546)) if (roll_chance_f(
5.0f)) this->CastSpell(this, 57761, true);
if (this->ToPlayer()->HasAura(44548)) if (roll_chance_f(
10.0f)) this->CastSpell(this, 57761, true);
if (this->ToPlayer()->HasAura(44549)) if (roll_chance_f(
15.0f)) this->CastSpell(this, 57761, true);
}
}
}
// Maelstrom Weapon
if (GetTypeId() == TYPEID_PLAYER)
{
if (damagetype == DIRECT_DAMAGE)
{
if (this->ToPlayer()->HasAura(51528)) if (roll_chance_f(10.0f)) this->CastSpell(
this, 53817, true);
if (this->ToPlayer()->HasAura(51529)) if (roll_chance_f(20.0f)) this->CastSpell(
this, 53817, true);
if (this->ToPlayer()->HasAura(51530)) if (roll_chance_f(30.0f)) this->CastSpell(
this, 53817, true);
}
}
pVictim->ModifyHealth(-(int32) damage);
if (damagetype == DIRECT_DAMAGE || damagetype == SPELL_DIRECT_DAMAGE) pVictim->RemoveAurasWithInterruptFlags(
AURA_INTERRUPT_FLAG_DIRECT_DAMAGE,
spellProto ? spellProto->Id : 0);
if (pVictim->GetTypeId() != TYPEID_PLAYER)
{
if (spellProto && IsDamageToThreatSpell(spellProto)) pVictim->AddThreat(
this, damage * 2.0f, damageSchoolMask, spellProto);
else pVictim->AddThreat(this, (float) damage, damageSchoolMask,
spellProto);
}
else // victim is a player
{
// random durability for items (HIT TAKEN)
if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
{
EquipmentSlots slot = EquipmentSlots(
urand(0, EQUIPMENT_SLOT_END - 1));
pVictim->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
}
}
// Rage from damage received
if (this != pVictim && pVictim->getPowerType() == POWER_RAGE)
{
uint32 rage_damage = damage
+ (cleanDamage ? cleanDamage->absorbed_damage : 0);
pVictim->RewardRage(rage_damage, 0, false);
}
if (GetTypeId() == TYPEID_PLAYER)
{
// random durability for items (HIT DONE)
if (roll_chance_f(sWorld->getRate(RATE_DURABILITY_LOSS_DAMAGE)))
{
EquipmentSlots slot = EquipmentSlots(
urand(0, EQUIPMENT_SLOT_END - 1));
this->ToPlayer()->DurabilityPointLossForEquipSlot(slot);
}
}
if (damagetype != NODAMAGE && damage)
{
if (pVictim != this && pVictim->GetTypeId() == TYPEID_PLAYER) // does not support creature push_back
{
if (damagetype != DOT)
{
if (Spell* spell = pVictim->m_currentSpells[CURRENT_GENERIC_SPELL])
{
if (spell->getState() == SPELL_STATE_PREPARING)
{
uint32 interruptFlags =
spell->m_spellInfo->InterruptFlags;
if (interruptFlags
& SPELL_INTERRUPT_FLAG_ABORT_ON_DMG) pVictim->InterruptNonMeleeSpells(
false);
else if (interruptFlags
& SPELL_INTERRUPT_FLAG_PUSH_BACK) spell->Delayed();
}
}
}
if (Spell* spell = pVictim->m_currentSpells[CURRENT_CHANNELED_SPELL])
{
if (spell->getState() == SPELL_STATE_CASTING)
{
uint32 channelInterruptFlags =
spell->m_spellInfo->ChannelInterruptFlags;
if (((channelInterruptFlags & CHANNEL_FLAG_DELAY) != 0)
&& (damagetype != DOT)) spell->DelayedChannel();
}
}
}
}
// last damage from duel opponent
if (duel_hasEnded)
{
ASSERT(pVictim->GetTypeId() == TYPEID_PLAYER);
Player *he = pVictim->ToPlayer();
ASSERT(he->duel);
he->SetHealth(1);
he->duel->opponent->CombatStopWithPets(true);
he->CombatStopWithPets(true);
he->CastSpell(he, 7267, true); // beg
he->DuelComplete(DUEL_WON);
}
}
sLog->outStaticDebug("DealDamageEnd returned %d damage", damage);
return damage;
}
void Unit::CastStop(uint32 except_spellid)
{
for (uint32 i = CURRENT_FIRST_NON_MELEE_SPELL; i < CURRENT_MAX_SPELL; i++)
if (m_currentSpells [i]
&& m_currentSpells [i]->m_spellInfo->Id != except_spellid) InterruptSpell(
CurrentSpellTypes(i), false);
}
void Unit::CastSpell(Unit* Victim, uint32 spellId, bool triggered,
Item *castItem, AuraEffect const * triggeredByAura,
uint64 originalCaster)
{
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
{
sLog->outError(
"CastSpell: unknown spell id %i by caster: %s %u)",
spellId,
(GetTypeId() == TYPEID_PLAYER ?
"player (GUID:" : "creature (Entry:"),
(GetTypeId() == TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
return;
}
CastSpell(Victim, spellInfo, triggered, castItem, triggeredByAura,
originalCaster);
}
void Unit::CastSpell(Unit* Victim, SpellEntry const *spellInfo, bool triggered,
Item *castItem, AuraEffect const * triggeredByAura,
uint64 originalCaster)
{
if (!spellInfo)
{
sLog->outError(
"CastSpell: unknown spell by caster: %s %u)",
(GetTypeId() == TYPEID_PLAYER ?
"player (GUID:" : "creature (Entry:"),
(GetTypeId() == TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
return;
}
if (!originalCaster && GetTypeId() == TYPEID_UNIT
&& this->ToCreature()->isTotem() && IsControlledByPlayer()) if (Unit * owner = GetOwner()) originalCaster =
owner->GetGUID();
SpellCastTargets targets;
targets.setUnitTarget(Victim);
if (castItem)
sLog->outStaticDebug("WORLD: cast Item spellId - %i", spellInfo->Id);
if (!originalCaster && triggeredByAura) originalCaster =
triggeredByAura->GetCasterGUID();
Spell *spell = new Spell(this, spellInfo, triggered, originalCaster);
spell->m_CastItem = castItem;
spell->prepare(&targets, triggeredByAura);
}
void Unit::CastCustomSpell(Unit* target, uint32 spellId, int32 const* bp0,
int32 const* bp1, int32 const* bp2, bool triggered, Item *castItem,
AuraEffect const * triggeredByAura, uint64 originalCaster)
{
CustomSpellValues values;
if (bp0) values.AddSpellMod(SPELLVALUE_BASE_POINT0, *bp0);
if (bp1) values.AddSpellMod(SPELLVALUE_BASE_POINT1, *bp1);
if (bp2) values.AddSpellMod(SPELLVALUE_BASE_POINT2, *bp2);
CastCustomSpell(spellId, values, target, triggered, castItem,
triggeredByAura, originalCaster);
}
void Unit::CastCustomSpell(uint32 spellId, SpellValueMod mod, int32 value,
Unit* target, bool triggered, Item *castItem,
AuraEffect const * triggeredByAura, uint64 originalCaster)
{
CustomSpellValues values;
values.AddSpellMod(mod, value);
CastCustomSpell(spellId, values, target, triggered, castItem,
triggeredByAura, originalCaster);
}
void Unit::CastCustomSpell(uint32 spellId, CustomSpellValues const &value,
Unit* Victim, bool triggered, Item *castItem,
AuraEffect const * triggeredByAura, uint64 originalCaster)
{
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
{
sLog->outError(
"CastSpell: unknown spell id %i by caster: %s %u)",
spellId,
(GetTypeId() == TYPEID_PLAYER ?
"player (GUID:" : "creature (Entry:"),
(GetTypeId() == TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
return;
}
SpellCastTargets targets;
targets.setUnitTarget(Victim);
if (!originalCaster && triggeredByAura) originalCaster =
triggeredByAura->GetCasterGUID();
Spell *spell = new Spell(this, spellInfo, triggered, originalCaster);
if (castItem)
{
sLog->outStaticDebug("WORLD: cast Item spellId - %i", spellInfo->Id);
spell->m_CastItem = castItem;
}
for (CustomSpellValues::const_iterator itr = value.begin();
itr != value.end(); ++itr)
spell->SetSpellValue(itr->first, itr->second);
spell->prepare(&targets, triggeredByAura);
}
// used for scripting
void Unit::CastSpell(float x, float y, float z, uint32 spellId, bool triggered,
Item *castItem, AuraEffect const * triggeredByAura,
uint64 originalCaster, Unit* OriginalVictim)
{
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
{
sLog->outError(
"CastSpell(x, y, z): unknown spell id %i by caster: %s %u)",
spellId,
(GetTypeId() == TYPEID_PLAYER ?
"player (GUID:" : "creature (Entry:"),
(GetTypeId() == TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
return;
}
if (castItem)
sLog->outStaticDebug("WORLD: cast Item spellId - %i", spellInfo->Id);
if (!originalCaster && triggeredByAura) originalCaster =
triggeredByAura->GetCasterGUID();
Spell *spell = new Spell(this, spellInfo, triggered, originalCaster);
SpellCastTargets targets;
targets.setDst(x, y, z, GetOrientation());
if (OriginalVictim) targets.setUnitTarget(OriginalVictim);
spell->m_CastItem = castItem;
spell->prepare(&targets, triggeredByAura);
}
// used for scripting
void Unit::CastSpell(GameObject *go, uint32 spellId, bool triggered,
Item *castItem, AuraEffect* triggeredByAura, uint64 originalCaster)
{
if (!go) return;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
{
sLog->outError(
"CastSpell(x, y, z): unknown spell id %i by caster: %s %u)",
spellId,
(GetTypeId() == TYPEID_PLAYER ?
"player (GUID:" : "creature (Entry:"),
(GetTypeId() == TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
return;
}
if (!(spellInfo->Targets & (TARGET_FLAG_OBJECT | TARGET_FLAG_OBJECT_CASTER)))
{
sLog->outError(
"CastSpell: spell id %i by caster: %s %u) is not gameobject spell",
spellId,
(GetTypeId() == TYPEID_PLAYER ?
"player (GUID:" : "creature (Entry:"),
(GetTypeId() == TYPEID_PLAYER ? GetGUIDLow() : GetEntry()));
return;
}
if (castItem)
sLog->outStaticDebug("WORLD: cast Item spellId - %i", spellInfo->Id);
if (!originalCaster && triggeredByAura) originalCaster =
triggeredByAura->GetCasterGUID();
Spell *spell = new Spell(this, spellInfo, triggered, originalCaster);
SpellCastTargets targets;
targets.setGOTarget(go);
spell->m_CastItem = castItem;
spell->prepare(&targets, triggeredByAura);
}
// Obsolete func need remove, here only for comotability vs another patches
uint32 Unit::SpellNonMeleeDamageLog(Unit *pVictim, uint32 spellID,
uint32 damage)
{
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellID);
SpellNonMeleeDamage damageInfo(this, pVictim, spellInfo->Id,
spellInfo->SchoolMask);
damage = SpellDamageBonus(pVictim, spellInfo, 0, damage,
SPELL_DIRECT_DAMAGE);
CalculateSpellDamageTaken(&damageInfo, damage, spellInfo);
DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
SendSpellNonMeleeDamageLog(&damageInfo);
DealSpellDamage(&damageInfo, true);
return damageInfo.damage;
}
void Unit::CalculateSpellDamageTaken(SpellNonMeleeDamage *damageInfo,
int32 damage, SpellEntry const *spellInfo, WeaponAttackType attackType,
bool crit)
{
if (damage < 0) return;
if (spellInfo->AttributesEx4 & SPELL_ATTR4_FIXED_DAMAGE)
{
Unit *pVictim = damageInfo->target;
if (!pVictim || !pVictim->isAlive()) return;
SpellSchoolMask damageSchoolMask = SpellSchoolMask(
damageInfo->schoolMask);
// Calculate absorb resist
if (damage > 0)
{
CalcAbsorbResist(pVictim, damageSchoolMask, SPELL_DIRECT_DAMAGE,
damage, &damageInfo->absorb, &damageInfo->resist,
spellInfo);
damage -= damageInfo->absorb + damageInfo->resist;
}
else damage = 0;
damageInfo->damage = damage;
return;
}
Unit *pVictim = damageInfo->target;
if (!pVictim || !pVictim->isAlive()) return;
SpellSchoolMask damageSchoolMask = SpellSchoolMask(damageInfo->schoolMask);
uint32 crTypeMask = pVictim->GetCreatureTypeMask();
if (IsDamageReducedByArmor(damageSchoolMask, spellInfo)) damage =
CalcArmorReducedDamage(pVictim, damage, spellInfo, attackType);
bool blocked = false;
// Per-school calc
switch (spellInfo->DmgClass)
{
// Melee and Ranged Spells
case SPELL_DAMAGE_CLASS_RANGED:
case SPELL_DAMAGE_CLASS_MELEE:
{
// Physical Damage
if (damageSchoolMask & SPELL_SCHOOL_MASK_NORMAL)
{
// Get blocked status
blocked = isSpellBlocked(pVictim, spellInfo, attackType);
}
if (crit)
{
damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
// Calculate crit bonus
uint32 crit_bonus = damage;
// Apply crit_damage bonus for melee spells
if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellInfo->Id, SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
damage += crit_bonus;
// Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
int32 critPctDamageMod = 0;
if (attackType == RANGED_ATTACK) critPctDamageMod +=
pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
else
{
critPctDamageMod += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
critPctDamageMod += GetTotalAuraModifier(
SPELL_AURA_MOD_CRIT_DAMAGE_BONUS);
}
// Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
critPctDamageMod += GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
if (critPctDamageMod != 0) damage = int32(
damage * float((100.0f + critPctDamageMod) / 100.0f));
}
// Spell weapon based damage CAN BE crit & blocked at same time
if (blocked)
{
damageInfo->blocked = pVictim->GetShieldBlockValue();
//double blocked amount if block is critical
if (pVictim->isBlockCritical()) damageInfo->blocked +=
damageInfo->blocked;
if (damage < int32(damageInfo->blocked)) damageInfo->blocked =
uint32(damage);
damage -= damageInfo->blocked;
}
ApplyResilience(pVictim, &damage);
}
break;
// Magical Attacks
case SPELL_DAMAGE_CLASS_NONE:
case SPELL_DAMAGE_CLASS_MAGIC:
{
// If crit add critical bonus
if (crit)
{
damageInfo->HitInfo |= SPELL_HIT_TYPE_CRIT;
damage = SpellCriticalDamageBonus(spellInfo, damage, pVictim);
}
ApplyResilience(pVictim, &damage);
}
break;
}
// Calculate absorb resist
if (damage > 0)
{
CalcAbsorbResist(pVictim, damageSchoolMask, SPELL_DIRECT_DAMAGE, damage,
&damageInfo->absorb, &damageInfo->resist, spellInfo);
damage -= damageInfo->absorb + damageInfo->resist;
}
else damage = 0;
damageInfo->damage = damage;
}
void Unit::DealSpellDamage(SpellNonMeleeDamage *damageInfo, bool durabilityLoss)
{
if (damageInfo == 0) return;
Unit *pVictim = damageInfo->target;
if (!pVictim) return;
if (!pVictim->isAlive() || pVictim->HasUnitState(UNIT_STAT_IN_FLIGHT)
|| (pVictim->HasUnitState(UNIT_STAT_ONVEHICLE)
&& pVictim->GetVehicleBase() != this)
|| (pVictim->GetTypeId() == TYPEID_UNIT
&& pVictim->ToCreature()->IsInEvadeMode())) return;
SpellEntry const *spellProto = sSpellStore.LookupEntry(damageInfo->SpellID);
if (spellProto == NULL)
{
sLog->outDebug(LOG_FILTER_UNITS,
"Unit::DealSpellDamage have wrong damageInfo->SpellID: %u",
damageInfo->SpellID);
return;
}
// Call default DealDamage
CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb,
BASE_ATTACK, MELEE_HIT_NORMAL);
DealDamage(pVictim, damageInfo->damage, &cleanDamage, SPELL_DIRECT_DAMAGE,
SpellSchoolMask(damageInfo->schoolMask), spellProto,
durabilityLoss);
}
//TODO for melee need create structure as in
void Unit::CalculateMeleeDamage(Unit *pVictim, uint32 damage,
CalcDamageInfo *damageInfo, WeaponAttackType attackType)
{
damageInfo->attacker = this;
damageInfo->target = pVictim;
damageInfo->damageSchoolMask = GetMeleeDamageSchoolMask();
damageInfo->attackType = attackType;
damageInfo->damage = 0;
damageInfo->cleanDamage = 0;
damageInfo->absorb = 0;
damageInfo->resist = 0;
damageInfo->blocked_amount = 0;
damageInfo->TargetState = 0;
damageInfo->HitInfo = 0;
damageInfo->procAttacker = PROC_FLAG_NONE;
damageInfo->procVictim = PROC_FLAG_NONE;
damageInfo->procEx = PROC_EX_NONE;
damageInfo->hitOutCome = MELEE_HIT_EVADE;
if (!pVictim) return;
if (!isAlive() || !pVictim->isAlive()) return;
// Select HitInfo/procAttacker/procVictim flag based on attack type
switch (attackType)
{
case BASE_ATTACK:
damageInfo->procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK
| PROC_FLAG_DONE_MAINHAND_ATTACK;
damageInfo->procVictim = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
damageInfo->HitInfo = HITINFO_NORMALSWING2;
break;
case OFF_ATTACK:
damageInfo->procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK
| PROC_FLAG_DONE_OFFHAND_ATTACK;
damageInfo->procVictim = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
damageInfo->HitInfo = HITINFO_LEFTSWING;
break;
default:
return;
}
// Physical Immune check
if (damageInfo->target->IsImmunedToDamage(
SpellSchoolMask(damageInfo->damageSchoolMask)))
{
damageInfo->HitInfo |= HITINFO_NORMALSWING;
damageInfo->TargetState = VICTIMSTATE_IS_IMMUNE;
damageInfo->procEx |= PROC_EX_IMMUNE;
damageInfo->damage = 0;
damageInfo->cleanDamage = 0;
return;
}
damage += CalculateDamage(damageInfo->attackType, false, true);
// Add melee damage bonus
MeleeDamageBonus(damageInfo->target, &damage, damageInfo->attackType);
// Calculate armor reduction
if (IsDamageReducedByArmor(
(SpellSchoolMask) (damageInfo->damageSchoolMask)))
{
damageInfo->damage = CalcArmorReducedDamage(damageInfo->target, damage,
NULL, damageInfo->attackType);
damageInfo->cleanDamage += damage - damageInfo->damage;
}
else damageInfo->damage = damage;
damageInfo->hitOutCome = RollMeleeOutcomeAgainst(damageInfo->target,
damageInfo->attackType);
switch (damageInfo->hitOutCome)
{
case MELEE_HIT_EVADE:
{
damageInfo->HitInfo |= HITINFO_MISS | HITINFO_SWINGNOHITSOUND;
damageInfo->TargetState = VICTIMSTATE_EVADES;
damageInfo->procEx |= PROC_EX_EVADE;
damageInfo->damage = 0;
damageInfo->cleanDamage = 0;
}
return;
case MELEE_HIT_MISS:
{
damageInfo->HitInfo |= HITINFO_MISS;
damageInfo->TargetState = VICTIMSTATE_INTACT;
damageInfo->procEx |= PROC_EX_MISS;
damageInfo->damage = 0;
damageInfo->cleanDamage = 0;
}
break;
case MELEE_HIT_NORMAL:
damageInfo->TargetState = VICTIMSTATE_HIT;
damageInfo->procEx |= PROC_EX_NORMAL_HIT;
break;
case MELEE_HIT_CRIT:
{
damageInfo->HitInfo |= HITINFO_CRITICALHIT;
damageInfo->TargetState = VICTIMSTATE_HIT;
damageInfo->procEx |= PROC_EX_CRITICAL_HIT;
// Crit bonus calc
damageInfo->damage += damageInfo->damage;
int32 mod = 0;
// Apply SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE or SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE
if (damageInfo->attackType == RANGED_ATTACK) mod +=
damageInfo->target->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE);
else
{
mod += damageInfo->target->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE);
mod += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_DAMAGE_BONUS);
}
uint32 crTypeMask = damageInfo->target->GetCreatureTypeMask();
// Increase crit damage from SPELL_AURA_MOD_CRIT_PERCENT_VERSUS
mod += GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_CRIT_PERCENT_VERSUS, crTypeMask);
if (mod != 0) damageInfo->damage = int32(
(damageInfo->damage) * float((100.0f + mod) / 100.0f));
}
break;
case MELEE_HIT_PARRY:
damageInfo->TargetState = VICTIMSTATE_PARRY;
damageInfo->procEx |= PROC_EX_PARRY;
damageInfo->cleanDamage += damageInfo->damage;
damageInfo->damage = 0;
break;
case MELEE_HIT_DODGE:
damageInfo->TargetState = VICTIMSTATE_DODGE;
damageInfo->procEx |= PROC_EX_DODGE;
damageInfo->cleanDamage += damageInfo->damage;
damageInfo->damage = 0;
break;
case MELEE_HIT_BLOCK:
{
damageInfo->TargetState = VICTIMSTATE_HIT;
damageInfo->HitInfo |= HITINFO_BLOCK;
damageInfo->procEx |= PROC_EX_BLOCK;
damageInfo->blocked_amount =
damageInfo->target->GetShieldBlockValue();
//double blocked amount if block is critical
if (damageInfo->target->isBlockCritical()) damageInfo->blocked_amount +=
damageInfo->blocked_amount;
if (damageInfo->blocked_amount >= damageInfo->damage)
{
damageInfo->TargetState = VICTIMSTATE_BLOCKS;
damageInfo->blocked_amount = damageInfo->damage;
damageInfo->procEx |= PROC_EX_FULL_BLOCK;
}
else damageInfo->procEx |= PROC_EX_NORMAL_HIT;
damageInfo->damage -= damageInfo->blocked_amount;
damageInfo->cleanDamage += damageInfo->blocked_amount;
}
break;
case MELEE_HIT_GLANCING:
{
damageInfo->HitInfo |= HITINFO_GLANCING;
damageInfo->TargetState = VICTIMSTATE_HIT;
damageInfo->procEx |= PROC_EX_NORMAL_HIT;
int32 leveldif = int32(pVictim->getLevel()) - int32(getLevel());
if (leveldif > 3) leveldif = 3;
float reducePercent = 1 - leveldif * 0.1f;
damageInfo->cleanDamage += damageInfo->damage
- uint32(reducePercent * damageInfo->damage);
damageInfo->damage = uint32(reducePercent * damageInfo->damage);
}
break;
case MELEE_HIT_CRUSHING:
{
damageInfo->HitInfo |= HITINFO_CRUSHING;
damageInfo->TargetState = VICTIMSTATE_HIT;
damageInfo->procEx |= PROC_EX_NORMAL_HIT;
// 150% normal damage
damageInfo->damage += (damageInfo->damage / 2);
}
break;
default:
break;
}
int32 resilienceReduction = damageInfo->damage;
ApplyResilience(pVictim, &resilienceReduction);
resilienceReduction = damageInfo->damage - resilienceReduction;
damageInfo->damage -= resilienceReduction;
damageInfo->cleanDamage += resilienceReduction;
// Calculate absorb resist
if (int32(damageInfo->damage) > 0)
{
damageInfo->procVictim |= PROC_FLAG_TAKEN_DAMAGE;
// Calculate absorb & resists
CalcAbsorbResist(damageInfo->target,
SpellSchoolMask(damageInfo->damageSchoolMask), DIRECT_DAMAGE,
damageInfo->damage, &damageInfo->absorb, &damageInfo->resist);
damageInfo->damage -= damageInfo->absorb + damageInfo->resist;
if (damageInfo->absorb)
{
damageInfo->HitInfo |= HITINFO_ABSORB;
damageInfo->procEx |= PROC_EX_ABSORB;
}
if (damageInfo->resist) damageInfo->HitInfo |= HITINFO_RESIST;
}
else
// Impossible get negative result but....
damageInfo->damage = 0;
}
void Unit::DealMeleeDamage(CalcDamageInfo *damageInfo, bool durabilityLoss)
{
Unit *pVictim = damageInfo->target;
if (!pVictim->isAlive() || pVictim->HasUnitState(UNIT_STAT_IN_FLIGHT)
|| (pVictim->HasUnitState(UNIT_STAT_ONVEHICLE)
&& pVictim->GetVehicleBase() != this)
|| (pVictim->GetTypeId() == TYPEID_UNIT
&& pVictim->ToCreature()->IsInEvadeMode())) return;
// Hmmmm dont like this emotes client must by self do all animations
if (damageInfo->HitInfo & HITINFO_CRITICALHIT) pVictim->HandleEmoteCommand(
EMOTE_ONESHOT_WOUNDCRITICAL);
if (damageInfo->blocked_amount
&& damageInfo->TargetState != VICTIMSTATE_BLOCKS) pVictim->HandleEmoteCommand(
EMOTE_ONESHOT_PARRYSHIELD);
if (damageInfo->TargetState == VICTIMSTATE_PARRY)
{
// Get attack timers
float offtime = float(pVictim->getAttackTimer(OFF_ATTACK));
float basetime = float(pVictim->getAttackTimer(BASE_ATTACK));
// Reduce attack time
if (pVictim->haveOffhandWeapon() && offtime < basetime)
{
float percent20 = pVictim->GetAttackTime(OFF_ATTACK) * 0.20f;
float percent60 = 3.0f * percent20;
if (offtime > percent20 && offtime <= percent60) pVictim->setAttackTimer(
OFF_ATTACK, uint32(percent20));
else if (offtime > percent60)
{
offtime -= 2.0f * percent20;
pVictim->setAttackTimer(OFF_ATTACK, uint32(offtime));
}
}
else
{
float percent20 = pVictim->GetAttackTime(BASE_ATTACK) * 0.20f;
float percent60 = 3.0f * percent20;
if (basetime > percent20 && basetime <= percent60) pVictim->setAttackTimer(
BASE_ATTACK, uint32(percent20));
else if (basetime > percent60)
{
basetime -= 2.0f * percent20;
pVictim->setAttackTimer(BASE_ATTACK, uint32(basetime));
}
}
}
// Call default DealDamage
CleanDamage cleanDamage(damageInfo->cleanDamage, damageInfo->absorb,
damageInfo->attackType, damageInfo->hitOutCome);
DealDamage(pVictim, damageInfo->damage, &cleanDamage, DIRECT_DAMAGE,
SpellSchoolMask(damageInfo->damageSchoolMask), NULL,
durabilityLoss);
// If this is a creature and it attacks from behind it has a probability to daze it's victim
if ((damageInfo->hitOutCome == MELEE_HIT_CRIT
|| damageInfo->hitOutCome == MELEE_HIT_CRUSHING
|| damageInfo->hitOutCome == MELEE_HIT_NORMAL
|| damageInfo->hitOutCome == MELEE_HIT_GLANCING)
&& GetTypeId() != TYPEID_PLAYER
&& !this->ToCreature()->IsControlledByPlayer()
&& !pVictim->HasInArc(M_PI, this)
&& (pVictim->GetTypeId() == TYPEID_PLAYER
|| !pVictim->ToCreature()->isWorldBoss()))
{
// -probability is between 0% and 40%
// 20% base chance
float Probability = 20.0f;
//there is a newbie protection, at level 10 just 7% base chance; assuming linear function
if (pVictim->getLevel() < 30) Probability = 0.65f * pVictim->getLevel()
+ 0.5f;
uint32 VictimDefense = pVictim->GetDefenseSkillValue();
uint32 AttackerMeleeSkill = GetUnitMeleeSkill();
Probability *= AttackerMeleeSkill / (float) VictimDefense;
if (Probability > 40.0f) Probability = 40.0f;
if (roll_chance_f(Probability)) CastSpell(pVictim, 1604, true);
}
if (GetTypeId() == TYPEID_PLAYER) ToPlayer()->CastItemCombatSpell(pVictim,
damageInfo->attackType, damageInfo->procVictim, damageInfo->procEx);
// Do effect if any damage done to target
if (damageInfo->damage)
{
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
AuraEffectList vDamageShieldsCopy(
pVictim->GetAuraEffectsByType(SPELL_AURA_DAMAGE_SHIELD));
for (AuraEffectList::const_iterator dmgShieldItr =
vDamageShieldsCopy.begin();
dmgShieldItr != vDamageShieldsCopy.end(); ++dmgShieldItr)
{
SpellEntry const *i_spellProto = (*dmgShieldItr)->GetSpellProto();
// Damage shield can be resisted...
if (SpellMissInfo missInfo = pVictim->SpellHitResult(this, i_spellProto , false))
{
pVictim->SendSpellMiss(this, i_spellProto->Id, missInfo);
continue;
}
// ...or immuned
if (IsImmunedToDamage(i_spellProto))
{
pVictim->SendSpellDamageImmune(this, i_spellProto->Id);
continue;
}
uint32 damage = (*dmgShieldItr)->GetAmount();
// No Unit::CalcAbsorbResist here - opcode doesn't send that data - this damage is probably not affected by that
pVictim->DealDamageMods(this, damage, NULL);
// TODO: Move this to a packet handler
WorldPacket data(SMSG_SPELLDAMAGESHIELD, (8 + 8 + 4 + 4 + 4 + 4));
data << uint64(pVictim->GetGUID());
data << uint64(GetGUID());
data << uint32(i_spellProto->Id);
data << uint32(damage); // Damage
int32 overkill = int32(damage) - int32(GetHealth());
data << uint32(overkill > 0 ? overkill : 0); // Overkill
data << uint32(i_spellProto->SchoolMask);
data << uint32(0); // 4.0.6
pVictim->SendMessageToSet(&data, true);
pVictim->DealDamage(this, damage, 0, SPELL_DIRECT_DAMAGE,
GetSpellSchoolMask(i_spellProto), i_spellProto, true);
}
}
}
void Unit::HandleEmoteCommand(uint32 anim_id)
{
WorldPacket data(SMSG_EMOTE, 4 + 8);
data << uint32(anim_id);
data << uint64(GetGUID());
SendMessageToSet(&data, true);
}
bool Unit::IsDamageReducedByArmor(SpellSchoolMask schoolMask,
SpellEntry const *spellInfo, uint8 effIndex)
{
// only physical spells damage gets reduced by armor
if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL) == 0) return false;
if (spellInfo)
{
// there are spells with no specific attribute but they have "ignores armor" in tooltip
if (sSpellMgr->GetSpellCustomAttr(spellInfo->Id)
& SPELL_ATTR0_CU_IGNORE_ARMOR) return false;
// bleeding effects are not reduced by armor
if (effIndex != MAX_SPELL_EFFECTS
&& spellInfo->EffectApplyAuraName [effIndex]
== SPELL_AURA_PERIODIC_DAMAGE) if (GetSpellMechanicMask(
spellInfo, effIndex) & (1 << MECHANIC_BLEED)) return false;
}
return true;
}
uint32 Unit::CalcArmorReducedDamage(Unit* pVictim, const uint32 damage,
SpellEntry const *spellInfo, WeaponAttackType /*attackType*/)
{
uint32 newdamage = 0;
float armor = float(pVictim->GetArmor());
// decrease enemy armor effectiveness by SPELL_AURA_BYPASS_ARMOR_FOR_CASTER
int32 auraEffectivenessReduction = 0;
AuraEffectList const & reductionAuras = pVictim->GetAuraEffectsByType(
SPELL_AURA_BYPASS_ARMOR_FOR_CASTER);
for (AuraEffectList::const_iterator i = reductionAuras.begin();
i != reductionAuras.end(); ++i)
if ((*i)->GetCasterGUID() == GetGUID()) auraEffectivenessReduction +=
(*i)->GetAmount();
armor = CalculatePctN(armor,
100 - std::min(auraEffectivenessReduction, 100));
// Ignore enemy armor by SPELL_AURA_MOD_TARGET_RESISTANCE aura
armor += GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE,
SPELL_SCHOOL_MASK_NORMAL);
if (spellInfo) if (Player *modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellInfo->Id, SPELLMOD_IGNORE_ARMOR, armor);
AuraEffectList const& ResIgnoreAurasAb = GetAuraEffectsByType(
SPELL_AURA_MOD_ABILITY_IGNORE_TARGET_RESIST);
for (AuraEffectList::const_iterator j = ResIgnoreAurasAb.begin();
j != ResIgnoreAurasAb.end(); ++j)
{
if ((*j)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL
&& (*j)->IsAffectedOnSpell(spellInfo)) armor = floor(
float(armor) * (float(100 - (*j)->GetAmount()) / 100.0f));
}
AuraEffectList const& ResIgnoreAuras = GetAuraEffectsByType(
SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
for (AuraEffectList::const_iterator j = ResIgnoreAuras.begin();
j != ResIgnoreAuras.end(); ++j)
{
if ((*j)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL) armor = floor(
float(armor) * (float(100 - (*j)->GetAmount()) / 100.0f));
}
if (GetTypeId() == TYPEID_PLAYER)
{
AuraEffectList const& ResIgnoreAuras = GetAuraEffectsByType(
SPELL_AURA_MOD_ARMOR_PENETRATION_PCT);
for (AuraEffectList::const_iterator itr = ResIgnoreAuras.begin();
itr != ResIgnoreAuras.end(); ++itr)
{
// item neutral spell
if ((*itr)->GetSpellProto()->EquippedItemClass == -1)
{
armor = floor(
float(armor)
* (float(100 - (*itr)->GetAmount()) / 100.0f));
continue;
}
// item dependent spell - check curent weapons
for (int i = 0; i < MAX_ATTACK; ++i)
{
Item *weapon = ToPlayer()->GetWeaponForAttack(
WeaponAttackType(i), true);
if (weapon
&& weapon->IsFitToSpellRequirements(
(*itr)->GetSpellProto()))
{
armor =
floor(
float(armor)
* (float(100 - (*itr)->GetAmount())
/ 100.0f));
break;
}
}
}
}
// Apply Player CR_ARMOR_PENETRATION rating
if (GetTypeId() == TYPEID_PLAYER)
{
float maxArmorPen = 0;
if (getLevel() < 60) maxArmorPen = float(
400 + 85 * pVictim->getLevel());
else maxArmorPen = 400 + 85 * pVictim->getLevel()
+ 4.5f * 85 * (pVictim->getLevel() - 59);
// Cap armor penetration to this number
maxArmorPen = std::min(((armor + maxArmorPen) / 3), armor);
// Figure out how much armor do we ignore
float armorPen = maxArmorPen
* this->ToPlayer()->GetRatingBonusValue(CR_ARMOR_PENETRATION)
/ 100.0f;
// Got the value, apply it
armor -= armorPen;
}
if (armor < 0.0f) armor = 0.0f;
float armorReduction = armor / (armor + 85.f * getLevel() + 400.f);
if (getLevel() > 59) armorReduction = armor
/ (armor + 467.5f * getLevel() - 22167.5f);
if (getLevel() > 80) armorReduction = armor
/ (armor + 2167.5f * getLevel() - 158167.5f);
if (armorReduction < 0.0f) armorReduction = 0.0f;
if (armorReduction > 0.75f) armorReduction = 0.75f;
newdamage = uint32(damage - (damage * armorReduction));
return (newdamage > 1) ? newdamage : 1;
}
void Unit::CalcAbsorbResist(Unit *pVictim, SpellSchoolMask schoolMask,
DamageEffectType damagetype, const uint32 damage, uint32 *absorb,
uint32 *resist, SpellEntry const *spellInfo)
{
if (!pVictim || !pVictim->isAlive() || !damage) return;
DamageInfo dmgInfo = DamageInfo(this, pVictim, damage, spellInfo,
schoolMask, damagetype);
// Magic damage, check for resists
if ((schoolMask & SPELL_SCHOOL_MASK_NORMAL) == 0)
{
float baseVictimResistance = float(pVictim->GetResistance(GetFirstSchoolInMask(schoolMask)));
float ignoredResistance = float(GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
float victimResistance = baseVictimResistance + ignoredResistance;
if (Player* player = ToPlayer())
ignoredResistance += float(player->GetSpellPenetrationItemMod());
if (Player* player = ToPlayer())
victimResistance -= float(player->GetSpellPenetrationItemMod());
// Resistance can't be lower then 0.
if (victimResistance < 0.0f)
victimResistance = 0.0f;
static const uint32 BOSS_LEVEL = 88;
static const float BOSS_RESISTANCE_CONSTANT = 510.0f;
uint32 level = pVictim->getLevel();
float resistanceConstant = 0.0f;
if (level == BOSS_LEVEL) resistanceConstant = BOSS_RESISTANCE_CONSTANT;
else resistanceConstant = level * 5.0f;
float averageResist = victimResistance
/ (victimResistance + resistanceConstant);
float discreteResistProbability [11];
for (uint32 i = 0; i < 11; ++i)
{
discreteResistProbability [i] = 0.5f
- 2.5f * fabs(0.1f * i - averageResist);
if (discreteResistProbability [i] < 0.0f) discreteResistProbability [i] =
0.0f;
}
if (averageResist <= 0.1f)
{
discreteResistProbability [0] = 1.0f - 7.5f * averageResist;
discreteResistProbability [1] = 5.0f * averageResist;
discreteResistProbability [2] = 2.5f * averageResist;
}
float r = float(rand_norm());
uint32 i = 0;
float probabilitySum = discreteResistProbability [0];
while (r >= probabilitySum && i < 10)
probabilitySum += discreteResistProbability [++i];
float damageResisted = float(damage * i / 10);
AuraEffectList const &ResIgnoreAurasAb = GetAuraEffectsByType(
SPELL_AURA_MOD_ABILITY_IGNORE_TARGET_RESIST);
for (AuraEffectList::const_iterator j = ResIgnoreAurasAb.begin();
j != ResIgnoreAurasAb.end(); ++j)
if (((*j)->GetMiscValue() & schoolMask)
&& (*j)->IsAffectedOnSpell(spellInfo)) AddPctN(
damageResisted, -(*j)->GetAmount());
AuraEffectList const &ResIgnoreAuras = GetAuraEffectsByType(
SPELL_AURA_MOD_IGNORE_TARGET_RESIST);
for (AuraEffectList::const_iterator j = ResIgnoreAuras.begin();
j != ResIgnoreAuras.end(); ++j)
if ((*j)->GetMiscValue() & schoolMask) AddPctN(damageResisted,
-(*j)->GetAmount());
dmgInfo.ResistDamage(uint32(damageResisted));
}
// Ignore Absorption Auras
float auraAbsorbMod = 0;
AuraEffectList const & AbsIgnoreAurasA = GetAuraEffectsByType(
SPELL_AURA_MOD_TARGET_ABSORB_SCHOOL);
for (AuraEffectList::const_iterator itr = AbsIgnoreAurasA.begin();
itr != AbsIgnoreAurasA.end(); ++itr)
{
if (!((*itr)->GetMiscValue() & schoolMask)) continue;
if ((*itr)->GetAmount() > auraAbsorbMod) auraAbsorbMod = float(
(*itr)->GetAmount());
}
AuraEffectList const & AbsIgnoreAurasB = GetAuraEffectsByType(
SPELL_AURA_MOD_TARGET_ABILITY_ABSORB_SCHOOL);
for (AuraEffectList::const_iterator itr = AbsIgnoreAurasB.begin();
itr != AbsIgnoreAurasB.end(); ++itr)
{
if (!((*itr)->GetMiscValue() & schoolMask)) continue;
if (((*itr)->GetAmount() > auraAbsorbMod)
&& (*itr)->IsAffectedOnSpell(spellInfo)) auraAbsorbMod = float(
(*itr)->GetAmount());
}
RoundToInterval(auraAbsorbMod, 0.0f, 100.0f);
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
AuraEffectList vSchoolAbsorbCopy(
pVictim->GetAuraEffectsByType(SPELL_AURA_SCHOOL_ABSORB));
vSchoolAbsorbCopy.sort(Trinity::AbsorbAuraOrderPred());
// absorb without mana cost
for (AuraEffectList::iterator itr = vSchoolAbsorbCopy.begin();
(itr != vSchoolAbsorbCopy.end()) && (dmgInfo.GetDamage() > 0);
++itr)
{
AuraEffect * absorbAurEff = (*itr);
// Check if aura was removed during iteration - we don't need to work on such auras
AuraApplication const * aurApp =
absorbAurEff->GetBase()->GetApplicationOfTarget(
pVictim->GetGUID());
if (!aurApp) continue;
if (!(absorbAurEff->GetMiscValue() & schoolMask)) continue;
// get amount which can be still absorbed by the aura
int32 currentAbsorb = absorbAurEff->GetAmount();
// aura with infinite absorb amount - let the scripts handle absorbtion amount, set here to 0 for safety
if (currentAbsorb < 0) currentAbsorb = 0;
uint32 absorb = currentAbsorb;
bool defaultPrevented = false;
absorbAurEff->GetBase()->CallScriptEffectAbsorbHandlers(absorbAurEff,
aurApp, dmgInfo, absorb, defaultPrevented);
currentAbsorb = absorb;
if (defaultPrevented) continue;
// Apply absorb mod auras
AddPctF(currentAbsorb, -auraAbsorbMod);
// absorb must be smaller than the damage itself
currentAbsorb = RoundToInterval(currentAbsorb, 0,
int32(dmgInfo.GetDamage()));
dmgInfo.AbsorbDamage(currentAbsorb);
absorb = currentAbsorb;
absorbAurEff->GetBase()->CallScriptEffectAfterAbsorbHandlers(
absorbAurEff, aurApp, dmgInfo, absorb);
// Check if our aura is using amount to count damage
if (absorbAurEff->GetAmount() >= 0)
{
// Reduce shield amount
absorbAurEff->SetAmount(absorbAurEff->GetAmount() - currentAbsorb);
// Aura cannot absorb anything more - remove it
if (absorbAurEff->GetAmount() <= 0) absorbAurEff->GetBase()->Remove(
AURA_REMOVE_BY_ENEMY_SPELL);
}
}
// absorb by mana cost
AuraEffectList vManaShieldCopy(
pVictim->GetAuraEffectsByType(SPELL_AURA_MANA_SHIELD));
for (AuraEffectList::const_iterator itr = vManaShieldCopy.begin();
(itr != vManaShieldCopy.end()) && (dmgInfo.GetDamage() > 0); ++itr)
{
AuraEffect * absorbAurEff = (*itr);
// Check if aura was removed during iteration - we don't need to work on such auras
AuraApplication const * aurApp =
absorbAurEff->GetBase()->GetApplicationOfTarget(
pVictim->GetGUID());
if (!aurApp) continue;
// check damage school mask
if (!(absorbAurEff->GetMiscValue() & schoolMask)) continue;
// get amount which can be still absorbed by the aura
int32 currentAbsorb = absorbAurEff->GetAmount();
// aura with infinite absorb amount - let the scripts handle absorbtion amount, set here to 0 for safety
if (currentAbsorb < 0) currentAbsorb = 0;
uint32 absorb = currentAbsorb;
bool defaultPrevented = false;
absorbAurEff->GetBase()->CallScriptEffectManaShieldHandlers(
absorbAurEff, aurApp, dmgInfo, absorb, defaultPrevented);
currentAbsorb = absorb;
if (defaultPrevented) continue;
AddPctF(currentAbsorb, -auraAbsorbMod);
// absorb must be smaller than the damage itself
currentAbsorb = RoundToInterval(currentAbsorb, 0,
int32(dmgInfo.GetDamage()));
int32 manaReduction = currentAbsorb;
// lower absorb amount by talents
if (float manaMultiplier = SpellMgr::CalculateSpellEffectValueMultiplier(absorbAurEff->GetSpellProto(), absorbAurEff->GetEffIndex(), absorbAurEff->GetCaster())) manaReduction =
int32(float(manaReduction) * manaMultiplier);
int32 manaTaken = -pVictim->ModifyPower(POWER_MANA, -manaReduction);
// take case when mana has ended up into account
currentAbsorb =
currentAbsorb ?
int32(
float(currentAbsorb)
* (float(manaTaken)
/ float(manaReduction))) :
0;
dmgInfo.AbsorbDamage(currentAbsorb);
absorb = currentAbsorb;
absorbAurEff->GetBase()->CallScriptEffectAfterManaShieldHandlers(
absorbAurEff, aurApp, dmgInfo, absorb);
// Check if our aura is using amount to count damage
if (absorbAurEff->GetAmount() >= 0)
{
absorbAurEff->SetAmount(absorbAurEff->GetAmount() - currentAbsorb);
if ((absorbAurEff->GetAmount() <= 0)) absorbAurEff->GetBase()->Remove(
AURA_REMOVE_BY_ENEMY_SPELL);
}
}
// split damage auras - only when not damaging self
if (pVictim != this)
{
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
AuraEffectList vSplitDamageFlatCopy(
pVictim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_FLAT));
for (AuraEffectList::iterator itr = vSplitDamageFlatCopy.begin();
(itr != vSplitDamageFlatCopy.end()) && (dmgInfo.GetDamage() > 0);
++itr)
{
// Check if aura was removed during iteration - we don't need to work on such auras
if (!((*itr)->GetBase()->IsAppliedOnTarget(pVictim->GetGUID()))) continue;
// check damage school mask
if (!((*itr)->GetMiscValue() & schoolMask)) continue;
// Damage can be splitted only if aura has an alive caster
Unit * caster = (*itr)->GetCaster();
if (!caster || (caster == pVictim) || !caster->IsInWorld()
|| !caster->isAlive()) continue;
int32 splitDamage = (*itr)->GetAmount();
// absorb must be smaller than the damage itself
splitDamage = RoundToInterval(splitDamage, 0,
int32(dmgInfo.GetDamage()));
dmgInfo.ModifyDamage(splitDamage);
uint32 splitted = splitDamage;
uint32 splitted_absorb = 0;
DealDamageMods(caster, splitted, &splitted_absorb);
SendSpellNonMeleeDamageLog(caster, (*itr)->GetSpellProto()->Id,
splitted, schoolMask, splitted_absorb, 0, false, 0, false);
CleanDamage cleanDamage = CleanDamage(splitted, 0, BASE_ATTACK,
MELEE_HIT_NORMAL);
DealDamage(caster, splitted, &cleanDamage, DIRECT_DAMAGE,
schoolMask, (*itr)->GetSpellProto(), false);
}
// We're going to call functions which can modify content of the list during iteration over it's elements
// Let's copy the list so we can prevent iterator invalidation
AuraEffectList vSplitDamagePctCopy(
pVictim->GetAuraEffectsByType(SPELL_AURA_SPLIT_DAMAGE_PCT));
for (AuraEffectList::iterator itr = vSplitDamagePctCopy.begin(), next;
(itr != vSplitDamagePctCopy.end()) && (dmgInfo.GetDamage() > 0);
++itr)
{
// Check if aura was removed during iteration - we don't need to work on such auras
if (!((*itr)->GetBase()->IsAppliedOnTarget(pVictim->GetGUID()))) continue;
// check damage school mask
if (!((*itr)->GetMiscValue() & schoolMask)) continue;
// Damage can be splitted only if aura has an alive caster
Unit * caster = (*itr)->GetCaster();
if (!caster || (caster == pVictim) || !caster->IsInWorld()
|| !caster->isAlive()) continue;
int32 splitDamage = CalculatePctN(dmgInfo.GetDamage(),
(*itr)->GetAmount());
// absorb must be smaller than the damage itself
splitDamage = RoundToInterval(splitDamage, 0,
int32(dmgInfo.GetDamage()));
dmgInfo.ModifyDamage(splitDamage);
uint32 splitted = splitDamage;
uint32 split_absorb = 0;
DealDamageMods(caster, splitted, &split_absorb);
SendSpellNonMeleeDamageLog(caster, (*itr)->GetSpellProto()->Id,
splitted, schoolMask, split_absorb, 0, false, 0, false);
CleanDamage cleanDamage = CleanDamage(splitted, 0, BASE_ATTACK,
MELEE_HIT_NORMAL);
DealDamage(caster, splitted, &cleanDamage, DIRECT_DAMAGE,
schoolMask, (*itr)->GetSpellProto(), false);
}
}
*resist = dmgInfo.GetResist();
*absorb = dmgInfo.GetAbsorb();
}
void Unit::CalcHealAbsorb(Unit *pVictim, const SpellEntry *healSpell,
uint32 &healAmount, uint32 &absorb)
{
if (!healAmount) return;
int32 RemainingHeal = healAmount;
// Need remove expired auras after
bool existExpired = false;
// absorb without mana cost
AuraEffectList const& vHealAbsorb = pVictim->GetAuraEffectsByType(
SPELL_AURA_SCHOOL_HEAL_ABSORB);
for (AuraEffectList::const_iterator i = vHealAbsorb.begin();
i != vHealAbsorb.end() && RemainingHeal > 0; ++i)
{
if (!((*i)->GetMiscValue() & healSpell->SchoolMask)) continue;
// Max Amount can be absorbed by this aura
int32 currentAbsorb = (*i)->GetAmount();
// Found empty aura (impossible but..)
if (currentAbsorb <= 0)
{
existExpired = true;
continue;
}
// currentAbsorb - damage can be absorbed by shield
// If need absorb less damage
if (RemainingHeal < currentAbsorb) currentAbsorb = RemainingHeal;
RemainingHeal -= currentAbsorb;
// Reduce shield amount
(*i)->SetAmount((*i)->GetAmount() - currentAbsorb);
// Need remove it later
if ((*i)->GetAmount() <= 0) existExpired = true;
}
// Necrotic Strike
if (pVictim->HasAura(73975))
{
int32 heal = int32(pVictim->GetAbsorbHeal());
RemainingHeal -= heal;
}
// No negative heal
if (RemainingHeal < 0) RemainingHeal = 0;
// Remove all expired absorb auras
if (existExpired)
{
for (AuraEffectList::const_iterator i = vHealAbsorb.begin();
i != vHealAbsorb.end();)
{
AuraEffect *auraEff = *i;
++i;
if (auraEff->GetAmount() <= 0)
{
uint32 removedAuras = pVictim->m_removedAurasCount;
auraEff->GetBase()->Remove(AURA_REMOVE_BY_ENEMY_SPELL);
if (removedAuras + 1 < pVictim->m_removedAurasCount) i =
vHealAbsorb.begin();
}
}
}
absorb = RemainingHeal > 0 ? (healAmount - RemainingHeal) : healAmount;
healAmount = RemainingHeal;
}
void Unit::AttackerStateUpdate(Unit *pVictim, WeaponAttackType attType,
bool extra)
{
if (HasUnitState(UNIT_STAT_CANNOT_AUTOATTACK)
|| HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED)) return;
if (!pVictim->isAlive()) return;
if ((attType == BASE_ATTACK || attType == OFF_ATTACK)
&& !IsWithinLOSInMap(pVictim) && !isPet()) return;
CombatStart(pVictim);
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MELEE_ATTACK);
uint32 hitInfo;
if (attType == BASE_ATTACK) hitInfo = HITINFO_NORMALSWING2;
else if (attType == OFF_ATTACK) hitInfo = HITINFO_LEFTSWING;
else return; // ignore ranged case
// melee attack spell casted at main hand attack only - no normal melee dmg dealt
if (attType == BASE_ATTACK && m_currentSpells [CURRENT_MELEE_SPELL]) m_currentSpells [CURRENT_MELEE_SPELL]->cast();
else
{
// attack can be redirected to another target
pVictim = SelectMagnetTarget(pVictim);
CalcDamageInfo damageInfo;
CalculateMeleeDamage(pVictim, 0, &damageInfo, attType);
// Send log damage message to client
DealDamageMods(pVictim, damageInfo.damage, &damageInfo.absorb);
SendAttackStateUpdate(&damageInfo);
ProcDamageAndSpell(damageInfo.target, damageInfo.procAttacker,
damageInfo.procVictim, damageInfo.procEx, damageInfo.damage,
damageInfo.attackType);
DealMeleeDamage(&damageInfo, true);
if (GetTypeId() == TYPEID_PLAYER)
sLog->outStaticDebug(
"AttackerStateUpdate: (Player) %u attacked %u (TypeId: %u) for %u dmg, absorbed %u, blocked %u, resisted %u.",
GetGUIDLow(), pVictim->GetGUIDLow(), pVictim->GetTypeId(),
damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount,
damageInfo.resist);
else
sLog->outStaticDebug(
"AttackerStateUpdate: (NPC) %u attacked %u (TypeId: %u) for %u dmg, absorbed %u, blocked %u, resisted %u.",
GetGUIDLow(), pVictim->GetGUIDLow(), pVictim->GetTypeId(),
damageInfo.damage, damageInfo.absorb, damageInfo.blocked_amount,
damageInfo.resist);
}
if (!extra && m_extraAttacks)
{
while (m_extraAttacks)
{
AttackerStateUpdate(pVictim, BASE_ATTACK, true);
if (m_extraAttacks > 0) --m_extraAttacks;
}
}
}
MeleeHitOutcome Unit::RollMeleeOutcomeAgainst(const Unit *pVictim,
WeaponAttackType attType) const
{
// This is only wrapper
// Miss chance based on melee
//float miss_chance = MeleeMissChanceCalc(pVictim, attType);
float miss_chance = MeleeSpellMissChance(
pVictim,
attType,
int32(GetWeaponSkillValue(attType, pVictim))
- int32(pVictim->GetDefenseSkillValue(this)), 0);
// Critical hit chance
float crit_chance = GetUnitCriticalChance(attType, pVictim);
// stunned target cannot dodge and this is check in GetUnitDodgeChance() (returned 0 in this case)
float dodge_chance = pVictim->GetUnitDodgeChance();
float block_chance = pVictim->GetUnitBlockChance();
float parry_chance = pVictim->GetUnitParryChance();
// Useful if want to specify crit & miss chances for melee, else it could be removed
sLog->outStaticDebug(
"MELEE OUTCOME: miss %f crit %f dodge %f parry %f block %f",
miss_chance, crit_chance, dodge_chance, parry_chance, block_chance);
return RollMeleeOutcomeAgainst(pVictim, attType, int32(crit_chance * 100),
int32(miss_chance * 100), int32(dodge_chance * 100),
int32(parry_chance * 100), int32(block_chance * 100));
}
MeleeHitOutcome Unit::RollMeleeOutcomeAgainst(const Unit *pVictim,
WeaponAttackType attType, int32 crit_chance, int32 miss_chance,
int32 dodge_chance, int32 parry_chance, int32 block_chance) const
{
if (pVictim->GetTypeId() == TYPEID_UNIT
&& pVictim->ToCreature()->IsInEvadeMode()) return MELEE_HIT_EVADE;
int32 attackerMaxSkillValueForLevel = GetMaxSkillValueForLevel(pVictim);
int32 victimMaxSkillValueForLevel = pVictim->GetMaxSkillValueForLevel(this);
int32 attackerWeaponSkill = GetWeaponSkillValue(attType, pVictim);
int32 victimDefenseSkill = pVictim->GetDefenseSkillValue(this);
// bonus from skills is 0.04%
int32 skillBonus = 4 * (attackerWeaponSkill - victimMaxSkillValueForLevel);
int32 sum = 0, tmp = 0;
int32 roll = urand(0, 10000);
sLog->outStaticDebug(
"RollMeleeOutcomeAgainst: skill bonus of %d for attacker",
skillBonus);
sLog->outStaticDebug(
"RollMeleeOutcomeAgainst: rolled %d, miss %d, dodge %d, parry %d, block %d, crit %d",
roll, miss_chance, dodge_chance, parry_chance, block_chance,
crit_chance);
tmp = miss_chance;
if (tmp > 0 && roll < (sum += tmp))
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: MISS");
return MELEE_HIT_MISS;
}
// always crit against a sitting target (except 0 crit chance)
if (pVictim->GetTypeId() == TYPEID_PLAYER && crit_chance > 0
&& !pVictim->IsStandState())
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: CRIT (sitting victim)");
return MELEE_HIT_CRIT;
}
// Dodge chance
// only players can't dodge if attacker is behind
if (pVictim->GetTypeId() == TYPEID_PLAYER && !pVictim->HasInArc(M_PI, this)
&& !pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
sLog->outStaticDebug(
"RollMeleeOutcomeAgainst: attack came from behind and victim was a player.");
}
else
{
// Reduce dodge chance by attacker expertise rating
if (GetTypeId() == TYPEID_PLAYER) dodge_chance -= int32(
this->ToPlayer()->GetExpertiseDodgeOrParryReduction(attType)
* 100);
else dodge_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE)
* 25;
// Modify dodge chance by attacker SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
dodge_chance += GetTotalAuraModifierByMiscValue(
SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
dodge_chance = int32(
float(dodge_chance)
* GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
tmp = dodge_chance;
if ((tmp > 0) // check if unit _can_ dodge
&& ((tmp -= skillBonus) > 0) && roll < (sum += tmp))
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: DODGE <%d, %d)",
sum - tmp, sum);
return MELEE_HIT_DODGE;
}
}
// parry & block chances
// check if attack comes from behind, nobody can parry or block if attacker is behind
if (!pVictim->HasInArc(M_PI, this)
&& !pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
sLog->outStaticDebug("RollMeleeOutcomeAgainst: attack came from behind.");
else
{
// Reduce parry chance by attacker expertise rating
if (GetTypeId() == TYPEID_PLAYER) parry_chance -= int32(
this->ToPlayer()->GetExpertiseDodgeOrParryReduction(attType)
* 100);
else parry_chance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE)
* 25;
if (pVictim->GetTypeId() == TYPEID_PLAYER
|| !(pVictim->ToCreature()->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_NO_PARRY))
{
int32 tmp2 = int32(parry_chance);
if (tmp2 > 0 // check if unit _can_ parry
&& (tmp2 -= skillBonus) > 0 && roll < (sum += tmp2))
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: PARRY <%d, %d)",
sum - tmp2, sum);
return MELEE_HIT_PARRY;
}
}
if (pVictim->GetTypeId() == TYPEID_PLAYER
|| !(pVictim->ToCreature()->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_NO_BLOCK))
{
tmp = block_chance;
if (tmp > 0 // check if unit _can_ block
&& (tmp -= skillBonus) > 0 && roll < (sum += tmp))
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: BLOCK <%d, %d)",
sum - tmp, sum);
return MELEE_HIT_BLOCK;
}
}
}
// Critical chance
tmp = crit_chance;
if (tmp > 0 && roll < (sum += tmp))
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: CRIT <%d, %d)",
sum - tmp, sum);
if (GetTypeId() == TYPEID_UNIT
&& (this->ToCreature()->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_NO_CRIT))
sLog->outStaticDebug("RollMeleeOutcomeAgainst: CRIT DISABLED)");
else return MELEE_HIT_CRIT;
}
// Max 40% chance to score a glancing blow against mobs that are higher level (can do only players and pets and not with ranged weapon)
if (attType != RANGED_ATTACK
&& (GetTypeId() == TYPEID_PLAYER || this->ToCreature()->isPet())
&& pVictim->GetTypeId() != TYPEID_PLAYER
&& !pVictim->ToCreature()->isPet()
&& getLevel() < pVictim->getLevelForTarget(this))
{
// cap possible value (with bonuses > max skill)
int32 skill = attackerWeaponSkill;
int32 maxskill = attackerMaxSkillValueForLevel;
skill = (skill > maxskill) ? maxskill : skill;
tmp = (10 + (victimDefenseSkill - skill)) * 100;
tmp = tmp > 4000 ? 4000 : tmp;
if (roll < (sum += tmp))
{
sLog->outStaticDebug("RollMeleeOutcomeAgainst: GLANCING <%d, %d)",
sum - 4000, sum);
return MELEE_HIT_GLANCING;
}
}
// mobs can score crushing blows if they're 4 or more levels above victim
if (getLevelForTarget(pVictim) >= pVictim->getLevelForTarget(this) + 4 &&
// can be from by creature (if can) or from controlled player that considered as creature
!IsControlledByPlayer()
&& !(GetTypeId() == TYPEID_UNIT
&& this->ToCreature()->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_NO_CRUSH))
{
// when their weapon skill is 15 or more above victim's defense skill
tmp = victimDefenseSkill;
int32 tmpmax = victimMaxSkillValueForLevel;
// having defense above your maximum (from items, talents etc.) has no effect
tmp = tmp > tmpmax ? tmpmax : tmp;
// tmp = mob's level * 5 - player's current defense skill
tmp = attackerMaxSkillValueForLevel - tmp;
if (tmp >= 15)
{
// add 2% chance per lacking skill point, min. is 15%
tmp = tmp * 200 - 1500;
if (roll < (sum += tmp))
{
sLog->outStaticDebug(
"RollMeleeOutcomeAgainst: CRUSHING <%d, %d)", sum - tmp,
sum);
return MELEE_HIT_CRUSHING;
}
}
}
sLog->outStaticDebug("RollMeleeOutcomeAgainst: NORMAL");
return MELEE_HIT_NORMAL;
}
uint32 Unit::CalculateDamage(WeaponAttackType attType, bool normalized,
bool addTotalPct)
{
float min_damage, max_damage;
if (GetTypeId() == TYPEID_PLAYER && (normalized || !addTotalPct)) this->ToPlayer()->CalculateMinMaxDamage(
attType, normalized, addTotalPct, min_damage, max_damage);
else
{
switch (attType)
{
case RANGED_ATTACK:
min_damage = GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE);
max_damage = GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE);
break;
case BASE_ATTACK:
min_damage = GetFloatValue(UNIT_FIELD_MINDAMAGE);
max_damage = GetFloatValue(UNIT_FIELD_MAXDAMAGE);
break;
case OFF_ATTACK:
min_damage = GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE);
max_damage = GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE);
break;
// Just for good manner
default:
min_damage = 0.0f;
max_damage = 0.0f;
break;
}
}
if (min_damage > max_damage) std::swap(min_damage, max_damage);
if (max_damage == 0.0f) max_damage = 5.0f;
return urand((uint32) min_damage, (uint32) max_damage);
}
float Unit::CalculateLevelPenalty(SpellEntry const* spellProto) const
{
if (spellProto->spellLevel <= 0
|| spellProto->spellLevel >= spellProto->maxLevel) return 1.0f;
float LvlPenalty = 0.0f;
if (spellProto->spellLevel < 20) LvlPenalty = 20.0f
- spellProto->spellLevel * 3.75f;
float LvlFactor = (float(spellProto->spellLevel) + 6.0f)
/ float(getLevel());
if (LvlFactor > 1.0f) LvlFactor = 1.0f;
return (100.0f - LvlPenalty) * LvlFactor / 100.0f;
}
void Unit::SendMeleeAttackStart(Unit* pVictim)
{
WorldPacket data(SMSG_ATTACKSTART, 8 + 8);
data << uint64(GetGUID());
data << uint64(pVictim->GetGUID());
SendMessageToSet(&data, true);
sLog->outStaticDebug("WORLD: Sent SMSG_ATTACKSTART");
}
void Unit::SendMeleeAttackStop(Unit* victim)
{
if (!victim) return;
WorldPacket data(SMSG_ATTACKSTOP, (8 + 8 + 4)); // we guess size
data.append(GetPackGUID());
data.append(victim->GetPackGUID()); // can be 0x00...
data << uint32(0); // can be 0x1
SendMessageToSet(&data, true);
sLog->outDetail("%s %u stopped attacking %s %u",
(GetTypeId() == TYPEID_PLAYER ? "player" : "creature"),
GetGUIDLow(),
(victim->GetTypeId() == TYPEID_PLAYER ? "player" : "creature"),
victim->GetGUIDLow());
}
bool Unit::isSpellBlocked(Unit *pVictim, SpellEntry const * spellProto,
WeaponAttackType attackType)
{
if (pVictim->HasInArc(M_PI, this)
|| pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
// Check creatures flags_extra for disable block
if (pVictim->GetTypeId() == TYPEID_UNIT
&& pVictim->ToCreature()->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_NO_BLOCK) return false;
// These spells shouldn't be blocked
if (spellProto
&& spellProto->Attributes
& SPELL_ATTR0_IMPOSSIBLE_DODGE_PARRY_BLOCK) return false;
float blockChance = pVictim->GetUnitBlockChance();
blockChance += (int32(GetWeaponSkillValue(attackType))
- int32(pVictim->GetMaxSkillValueForLevel())) * 0.04f;
if (roll_chance_f(blockChance)) return true;
}
return false;
}
bool Unit::isBlockCritical()
{
if (roll_chance_i(GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_CRIT_CHANCE))) return true;
return false;
}
int32 Unit::GetMechanicResistChance(const SpellEntry *spell)
{
if (!spell) return 0;
int32 resist_mech = 0;
for (uint8 eff = 0; eff < MAX_SPELL_EFFECTS; ++eff)
{
if (spell->Effect [eff] == 0) break;
int32 effect_mech = GetEffectMechanic(spell, eff);
if (effect_mech)
{
int32 temp = GetTotalAuraModifierByMiscValue(
SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
if (resist_mech < temp) resist_mech = temp;
}
}
return resist_mech;
}
// Melee based spells hit result calculations
SpellMissInfo Unit::MeleeSpellHitResult(Unit *pVictim, SpellEntry const *spell)
{
WeaponAttackType attType = BASE_ATTACK;
// Check damage class instead of attack type to correctly handle judgements
// - they are meele, but can't be dodged/parried/deflected because of ranged dmg class
if (spell->DmgClass == SPELL_DAMAGE_CLASS_RANGED) attType = RANGED_ATTACK;
int32 attackerWeaponSkill;
// skill value for these spells (for example judgements) is 5* level
if (spell->DmgClass == SPELL_DAMAGE_CLASS_RANGED
&& !IsRangedWeaponSpell(spell)) attackerWeaponSkill = getLevel()
* 5;
// bonus from skills is 0.04% per skill Diff
else attackerWeaponSkill = int32(GetWeaponSkillValue(attType, pVictim));
int32 skillDiff = attackerWeaponSkill
- int32(pVictim->GetMaxSkillValueForLevel(this));
int32 fullSkillDiff = attackerWeaponSkill
- int32(pVictim->GetDefenseSkillValue(this));
uint32 roll = urand(0, 10000);
uint32 missChance = uint32(
MeleeSpellMissChance(pVictim, attType, fullSkillDiff, spell->Id)
* 100.0f);
// Roll miss
uint32 tmp = missChance;
if (roll < tmp) return SPELL_MISS_MISS;
// Chance resist mechanic (select max value from every mechanic spell effect)
int32 resist_mech = 0;
// Get effects mechanic and chance
for (uint8 eff = 0; eff < MAX_SPELL_EFFECTS; ++eff)
{
int32 effect_mech = GetEffectMechanic(spell, eff);
if (effect_mech)
{
int32 temp = pVictim->GetTotalAuraModifierByMiscValue(
SPELL_AURA_MOD_MECHANIC_RESISTANCE, effect_mech);
if (resist_mech < temp * 100) resist_mech = temp * 100;
}
}
// Roll chance
tmp += resist_mech;
if (roll < tmp) return SPELL_MISS_RESIST;
bool canDodge = true;
bool canParry = true;
bool canBlock = spell->AttributesEx3 & SPELL_ATTR3_BLOCKABLE_SPELL;
// Same spells cannot be parry/dodge
if (spell->Attributes & SPELL_ATTR0_IMPOSSIBLE_DODGE_PARRY_BLOCK) return SPELL_MISS_NONE;
// Chance resist mechanic
int32 resist_chance = pVictim->GetMechanicResistChance(spell) * 100;
tmp += resist_chance;
if (roll < tmp) return SPELL_MISS_RESIST;
// Ranged attacks can only miss, resist and deflect
if (attType == RANGED_ATTACK)
{
// only if in front
if (pVictim->HasInArc(M_PI, this)
|| pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
int32 deflect_chance = pVictim->GetTotalAuraModifier(
SPELL_AURA_DEFLECT_SPELLS) * 100;
tmp += deflect_chance;
if (roll < tmp) return SPELL_MISS_DEFLECT;
}
return SPELL_MISS_NONE;
}
// Check for attack from behind
if (!pVictim->HasInArc(M_PI, this)
&& !pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
// Can`t dodge from behind in PvP (but its possible in PvE)
if (pVictim->GetTypeId() == TYPEID_PLAYER) canDodge = false;
// Can`t parry or block
canParry = false;
canBlock = false;
}
// Check creatures flags_extra for disable parry
if (pVictim->GetTypeId() == TYPEID_UNIT)
{
uint32 flagEx = pVictim->ToCreature()->GetCreatureInfo()->flags_extra;
if (flagEx & CREATURE_FLAG_EXTRA_NO_PARRY) canParry = false;
// Check creatures flags_extra for disable block
if (flagEx & CREATURE_FLAG_EXTRA_NO_BLOCK) canBlock = false;
}
// Ignore combat result aura
AuraEffectList const &ignore = GetAuraEffectsByType(
SPELL_AURA_IGNORE_COMBAT_RESULT);
for (AuraEffectList::const_iterator i = ignore.begin(); i != ignore.end();
++i)
{
if (!(*i)->IsAffectedOnSpell(spell)) continue;
switch ((*i)->GetMiscValue())
{
case MELEE_HIT_DODGE:
canDodge = false;
break;
case MELEE_HIT_BLOCK:
canBlock = false;
break;
case MELEE_HIT_PARRY:
canParry = false;
break;
default:
sLog->outStaticDebug(
"Spell %u SPELL_AURA_IGNORE_COMBAT_RESULT have unhandled state %d",
(*i)->GetId(), (*i)->GetMiscValue());
break;
}
}
if (canDodge)
{
// Roll dodge
int32 dodgeChance = int32(pVictim->GetUnitDodgeChance() * 100.0f)
- skillDiff * 4;
// Reduce enemy dodge chance by SPELL_AURA_MOD_COMBAT_RESULT_CHANCE
dodgeChance += GetTotalAuraModifierByMiscValue(
SPELL_AURA_MOD_COMBAT_RESULT_CHANCE, VICTIMSTATE_DODGE) * 100;
dodgeChance = int32(
float(dodgeChance)
* GetTotalAuraMultiplier(SPELL_AURA_MOD_ENEMY_DODGE));
// Reduce dodge chance by attacker expertise rating
if (GetTypeId() == TYPEID_PLAYER) dodgeChance -= int32(
this->ToPlayer()->GetExpertiseDodgeOrParryReduction(attType)
* 100.0f);
else dodgeChance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
if (dodgeChance < 0) dodgeChance = 0;
if (roll < (tmp += dodgeChance)) return SPELL_MISS_DODGE;
}
if (canParry)
{
// Roll parry
int32 parryChance = int32(pVictim->GetUnitParryChance() * 100.0f)
- skillDiff * 4;
// Reduce parry chance by attacker expertise rating
if (GetTypeId() == TYPEID_PLAYER) parryChance -= int32(
this->ToPlayer()->GetExpertiseDodgeOrParryReduction(attType)
* 100.0f);
else parryChance -= GetTotalAuraModifier(SPELL_AURA_MOD_EXPERTISE) * 25;
if (parryChance < 0) parryChance = 0;
tmp += parryChance;
if (roll < tmp) return SPELL_MISS_PARRY;
}
if (canBlock)
{
int32 blockChance = int32(pVictim->GetUnitBlockChance() * 100.0f)
- skillDiff * 4;
if (blockChance < 0) blockChance = 0;
tmp += blockChance;
if (roll < tmp) return SPELL_MISS_BLOCK;
}
return SPELL_MISS_NONE;
}
// TODO need use unit spell resistances in calculations
SpellMissInfo Unit::MagicSpellHitResult(Unit *pVictim, SpellEntry const *spell)
{
// Can`t miss on dead target (on skinning for example)
if (!pVictim->isAlive() && pVictim->GetTypeId() != TYPEID_PLAYER) return SPELL_MISS_NONE;
SpellSchoolMask schoolMask = GetSpellSchoolMask(spell);
// PvP - PvE spell misschances per leveldif > 2
int32 lchance = pVictim->GetTypeId() == TYPEID_PLAYER ? 7 : 11;
int32 leveldif = int32(pVictim->getLevelForTarget(this))
- int32(getLevelForTarget(pVictim));
// Base hit chance from attacker and victim levels
int32 modHitChance;
if (leveldif < 3) modHitChance = 96 - leveldif;
else modHitChance = 94 - (leveldif - 2) * lchance;
// Spellmod from SPELLMOD_RESIST_MISS_CHANCE
if (Player *modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spell->Id, SPELLMOD_RESIST_MISS_CHANCE, modHitChance);
// Increase from attacker SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT auras
modHitChance += GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT, schoolMask);
// Chance hit from victim SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE auras
modHitChance += pVictim->GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE, schoolMask);
// Reduce spell hit chance for Area of effect spells from victim SPELL_AURA_MOD_AOE_AVOIDANCE aura
if (IsAreaOfEffectSpell(spell)) modHitChance -=
pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_AOE_AVOIDANCE);
int32 HitChance = modHitChance * 100;
// Increase hit chance from attacker SPELL_AURA_MOD_SPELL_HIT_CHANCE and attacker ratings
HitChance += int32(m_modSpellHitChance * 100.0f);
// Decrease hit chance from victim rating bonus
if (pVictim->GetTypeId() == TYPEID_PLAYER) HitChance -= int32(
pVictim->ToPlayer()->GetRatingBonusValue(CR_HIT_TAKEN_SPELL)
* 100.0f);
if (HitChance < 100) HitChance = 100;
else if (HitChance > 10000) HitChance = 10000;
int32 tmp = 10000 - HitChance;
int32 rand = irand(0, 10000);
if (rand < tmp) return SPELL_MISS_MISS;
// Chance resist mechanic (select max value from every mechanic spell effect)
int32 resist_chance = pVictim->GetMechanicResistChance(spell) * 100;
tmp += resist_chance;
// Chance resist debuff
if (!IsPositiveSpell(spell->Id))
{
bool bNegativeAura = false;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (spell->EffectApplyAuraName [i] != 0)
{
bNegativeAura = true;
break;
}
}
if (bNegativeAura)
{
tmp += pVictim->GetMaxPositiveAuraModifierByMiscValue(
SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel))
* 100;
tmp += pVictim->GetMaxNegativeAuraModifierByMiscValue(
SPELL_AURA_MOD_DEBUFF_RESISTANCE, int32(spell->Dispel))
* 100;
}
}
// Roll chance
if (rand < tmp) return SPELL_MISS_RESIST;
// cast by caster in front of victim
if (pVictim->HasInArc(M_PI, this)
|| pVictim->HasAuraType(SPELL_AURA_IGNORE_HIT_DIRECTION))
{
int32 deflect_chance = pVictim->GetTotalAuraModifier(
SPELL_AURA_DEFLECT_SPELLS) * 100;
tmp += deflect_chance;
if (rand < tmp) return SPELL_MISS_DEFLECT;
}
return SPELL_MISS_NONE;
}
// Calculate spell hit result can be:
// Every spell can: Evade/Immune/Reflect/Sucesful hit
// For melee based spells:
// Miss
// Dodge
// Parry
// For spells
// Resist
SpellMissInfo Unit::SpellHitResult(Unit *pVictim, SpellEntry const *spell,
bool CanReflect)
{
// Return evade for units in evade mode
if (pVictim->GetTypeId() == TYPEID_UNIT
&& pVictim->ToCreature()->IsInEvadeMode() && this != pVictim) return SPELL_MISS_EVADE;
// Check for immune
if (pVictim->IsImmunedToSpell(spell)) return SPELL_MISS_IMMUNE;
// All positive spells can`t miss
// TODO: client not show miss log for this spells - so need find info for this in dbc and use it!
if (IsPositiveSpell(spell->Id) && (!IsHostileTo(pVictim))) //prevent from affecting enemy by "positive" spell
return SPELL_MISS_NONE;
// Check for immune
if (pVictim->IsImmunedToDamage(spell)) return SPELL_MISS_IMMUNE;
if (this == pVictim) return SPELL_MISS_NONE;
// Try victim reflect spell
if (CanReflect)
{
int32 reflectchance = pVictim->GetTotalAuraModifier(
SPELL_AURA_REFLECT_SPELLS);
Unit::AuraEffectList const& mReflectSpellsSchool =
pVictim->GetAuraEffectsByType(SPELL_AURA_REFLECT_SPELLS_SCHOOL);
for (Unit::AuraEffectList::const_iterator i =
mReflectSpellsSchool.begin(); i != mReflectSpellsSchool.end();
++i)
if ((*i)->GetMiscValue() & GetSpellSchoolMask(spell)) reflectchance +=
(*i)->GetAmount();
if (reflectchance > 0 && roll_chance_i(reflectchance))
{
// Start triggers for remove charges if need (trigger only for victim, and mark as active spell)
ProcDamageAndSpell(pVictim, PROC_FLAG_NONE,
PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_EX_REFLECT,
1, BASE_ATTACK, spell);
return SPELL_MISS_REFLECT;
}
}
switch (spell->DmgClass)
{
case SPELL_DAMAGE_CLASS_RANGED:
case SPELL_DAMAGE_CLASS_MELEE:
return MeleeSpellHitResult(pVictim, spell);
case SPELL_DAMAGE_CLASS_NONE:
return SPELL_MISS_NONE;
case SPELL_DAMAGE_CLASS_MAGIC:
return MagicSpellHitResult(pVictim, spell);
}
return SPELL_MISS_NONE;
}
uint32 Unit::GetDefenseSkillValue(Unit const* target) const
{
if (GetTypeId() == TYPEID_PLAYER)
{
// in PvP use full skill instead current skill value
uint32 value =
(target && target->GetTypeId() == TYPEID_PLAYER) ?
this->ToPlayer()->GetMaxSkillValue(SKILL_DEFENSE) :
this->ToPlayer()->GetSkillValue(SKILL_DEFENSE);
value += uint32(
this->ToPlayer()->GetRatingBonusValue(CR_DEFENSE_SKILL));
return value;
}
else return GetUnitMeleeSkill(target);
}
float Unit::GetUnitDodgeChance() const
{
if (IsNonMeleeSpellCasted(false) || HasUnitState(UNIT_STAT_STUNNED)) return 0.0f;
if (GetTypeId() == TYPEID_PLAYER) return GetFloatValue(
PLAYER_DODGE_PERCENTAGE);
else
{
if (((Creature const*) this)->isTotem()) return 0.0f;
else
{
float dodge = 5.0f;
dodge += GetTotalAuraModifier(SPELL_AURA_MOD_DODGE_PERCENT);
return dodge > 0.0f ? dodge : 0.0f;
}
}
}
float Unit::GetUnitParryChance() const
{
if (IsNonMeleeSpellCasted(false) || HasUnitState(UNIT_STAT_STUNNED)) return 0.0f;
float chance = 0.0f;
if (GetTypeId() == TYPEID_PLAYER)
{
Player const* player = (Player const*) this;
if (player->CanParry())
{
Item *tmpitem = player->GetWeaponForAttack(BASE_ATTACK, true);
if (!tmpitem) tmpitem = player->GetWeaponForAttack(OFF_ATTACK,
true);
if (tmpitem) chance = GetFloatValue(PLAYER_PARRY_PERCENTAGE);
}
}
else if (GetTypeId() == TYPEID_UNIT)
{
if (GetCreatureType() == CREATURE_TYPE_HUMANOID)
{
chance = 5.0f;
chance += GetTotalAuraModifier(SPELL_AURA_MOD_PARRY_PERCENT);
}
}
return chance > 0.0f ? chance : 0.0f;
}
float Unit::GetUnitBlockChance() const
{
if (IsNonMeleeSpellCasted(false) || HasUnitState(UNIT_STAT_STUNNED)) return 0.0f;
if (GetTypeId() == TYPEID_PLAYER)
{
Player const* player = (Player const*) this;
if (player->CanBlock())
{
Item *tmpitem = player->GetUseableItemByPos(INVENTORY_SLOT_BAG_0,
EQUIPMENT_SLOT_OFFHAND);
if (tmpitem && !tmpitem->IsBroken()) return GetFloatValue(
PLAYER_BLOCK_PERCENTAGE);
}
// is player but has no block ability or no not broken shield equipped
return 0.0f;
}
else
{
if (((Creature const*) this)->isTotem()) return 0.0f;
else
{
float block = 5.0f;
block += GetTotalAuraModifier(SPELL_AURA_MOD_BLOCK_PERCENT);
return block > 0.0f ? block : 0.0f;
}
}
}
float Unit::GetUnitCriticalChance(WeaponAttackType attackType,
const Unit *pVictim) const
{
float crit;
if (GetTypeId() == TYPEID_PLAYER)
{
switch (attackType)
{
case BASE_ATTACK:
crit = GetFloatValue(PLAYER_CRIT_PERCENTAGE);
break;
case OFF_ATTACK:
crit = GetFloatValue(PLAYER_OFFHAND_CRIT_PERCENTAGE);
break;
case RANGED_ATTACK:
crit = GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE);
break;
// Just for good manner
default:
crit = 0.0f;
break;
}
}
else
{
crit = 5.0f;
crit += GetTotalAuraModifier(SPELL_AURA_MOD_WEAPON_CRIT_PERCENT);
crit += GetTotalAuraModifier(SPELL_AURA_MOD_CRIT_PCT);
}
// flat aura mods
if (attackType == RANGED_ATTACK) crit += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_CHANCE);
else crit += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_CHANCE);
crit += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
// reduce crit chance from Rating for players
if (attackType != RANGED_ATTACK)
{
// Glyph of barkskin
if (pVictim->HasAura(63057) && pVictim->HasAura(22812)) crit -= 25.0f;
}
// Apply crit chance from defence skill
crit += (int32(GetMaxSkillValueForLevel(pVictim))
- int32(pVictim->GetDefenseSkillValue(this))) * 0.04f;
if (crit < 0.0f) crit = 0.0f;
return crit;
}
uint32 Unit::GetWeaponSkillValue(WeaponAttackType attType,
Unit const* target) const
{
uint32 value = 0;
if (GetTypeId() == TYPEID_PLAYER)
{
Item* item = this->ToPlayer()->GetWeaponForAttack(attType, true);
// feral or unarmed skill only for base attack
if (attType != BASE_ATTACK && !item) return 0;
if (IsInFeralForm()) return GetMaxSkillValueForLevel(); // always maximized SKILL_FERAL_COMBAT in fact
// weapon skill or (unarmed for base attack and fist weapons)
uint32 skill;
if (item && item->GetSkill() != SKILL_FIST_WEAPONS) skill =
item->GetSkill();
else skill = SKILL_UNARMED;
// in PvP use full skill instead current skill value
value = (target && target->IsControlledByPlayer()) ?
this->ToPlayer()->GetMaxSkillValue(skill) :
this->ToPlayer()->GetSkillValue(skill);
// Modify value from ratings
value += uint32(this->ToPlayer()->GetRatingBonusValue(CR_WEAPON_SKILL));
switch (attType)
{
case BASE_ATTACK:
value += uint32(
this->ToPlayer()->GetRatingBonusValue(
CR_WEAPON_SKILL_MAINHAND));
break;
case OFF_ATTACK:
value += uint32(
this->ToPlayer()->GetRatingBonusValue(
CR_WEAPON_SKILL_OFFHAND));
break;
case RANGED_ATTACK:
value += uint32(
this->ToPlayer()->GetRatingBonusValue(
CR_WEAPON_SKILL_RANGED));
break;
default:
break;
}
}
else value = GetUnitMeleeSkill(target);
return value;
}
void Unit::_DeleteRemovedAuras()
{
while (!m_removedAuras.empty())
{
delete m_removedAuras.front();
m_removedAuras.pop_front();
}
}
void Unit::_UpdateSpells(uint32 time)
{
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL]) _UpdateAutoRepeatSpell();
// remove finished spells from current pointers
for (uint32 i = 0; i < CURRENT_MAX_SPELL; ++i)
{
if (m_currentSpells [i]
&& m_currentSpells [i]->getState() == SPELL_STATE_FINISHED)
{
m_currentSpells [i]->SetReferencedFromCurrent(false);
m_currentSpells [i] = NULL; // remove pointer
}
}
// m_auraUpdateIterator can be updated in indirect called code at aura remove to skip next planned to update but removed auras
for (m_auraUpdateIterator = m_ownedAuras.begin();
m_auraUpdateIterator != m_ownedAuras.end();)
{
Aura * i_aura = m_auraUpdateIterator->second;
++m_auraUpdateIterator; // need shift to next for allow update if need into aura update
i_aura->UpdateOwner(time, this);
}
// remove expired auras - do that after updates(used in scripts?)
for (AuraMap::iterator i = m_ownedAuras.begin(); i != m_ownedAuras.end();)
{
if (i->second->IsExpired()) RemoveOwnedAura(i, AURA_REMOVE_BY_EXPIRE);
else ++i;
}
for (VisibleAuraMap::iterator itr = m_visibleAuras.begin();
itr != m_visibleAuras.end(); ++itr)
if (itr->second->IsNeedClientUpdate()) itr->second->ClientUpdate();
_DeleteRemovedAuras();
if (!m_gameObj.empty())
{
GameObjectList::iterator itr;
for (itr = m_gameObj.begin(); itr != m_gameObj.end();)
{
if (!(*itr)->isSpawned())
{
(*itr)->SetOwnerGUID(0);
(*itr)->SetRespawnTime(0);
(*itr)->Delete();
m_gameObj.erase(itr++);
}
else ++itr;
}
}
}
void Unit::_UpdateAutoRepeatSpell()
{
//check "realtime" interrupts
if ((GetTypeId() == TYPEID_PLAYER && ((Player*) this)->isMoving())
|| IsNonMeleeSpellCasted(
false,
false,
true,
m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id
== 75))
{
// cancel wand shoot
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id != 75) InterruptSpell(
CURRENT_AUTOREPEAT_SPELL);
m_AutoRepeatFirstCast = true;
return;
}
//apply delay (Auto Shot (spellID 75) not affected)
if (m_AutoRepeatFirstCast && getAttackTimer(RANGED_ATTACK) < 500
&& m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id != 75) setAttackTimer(
RANGED_ATTACK, 500);
m_AutoRepeatFirstCast = false;
//castroutine
if (isAttackReady(RANGED_ATTACK))
{
// Check if able to cast
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->CheckCast(true)
!= SPELL_CAST_OK)
{
InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
return;
}
// we want to shoot
Spell* spell = new Spell(this,
m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo, true);
spell->prepare(
&(m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_targets));
// all went good, reset attack
resetAttackTimer(RANGED_ATTACK);
}
}
void Unit::SetCurrentCastedSpell(Spell * pSpell)
{
ASSERT(pSpell); // NULL may be never passed here, use InterruptSpell or InterruptNonMeleeSpells
CurrentSpellTypes CSpellType = pSpell->GetCurrentContainer();
if (pSpell == m_currentSpells [CSpellType]) return; // avoid breaking self
// break same type spell if it is not delayed
InterruptSpell(CSpellType, false);
// special breakage effects:
switch (CSpellType)
{
case CURRENT_GENERIC_SPELL:
{
// generic spells always break channeled not delayed spells
InterruptSpell(CURRENT_CHANNELED_SPELL, false);
// autorepeat breaking
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL])
{
// break autorepeat if not Auto Shot
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id
!= 75) InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
m_AutoRepeatFirstCast = true;
}
AddUnitState(UNIT_STAT_CASTING);
}
break;
case CURRENT_CHANNELED_SPELL:
{
// channel spells always break generic non-delayed and any channeled spells
InterruptSpell(CURRENT_GENERIC_SPELL, false);
InterruptSpell(CURRENT_CHANNELED_SPELL);
// it also does break autorepeat if not Auto Shot
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL]
&& m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id
!= 75) InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
AddUnitState(UNIT_STAT_CASTING);
}
break;
case CURRENT_AUTOREPEAT_SPELL:
{
// only Auto Shoot does not break anything
if (pSpell->m_spellInfo->Id != 75)
{
// generic autorepeats break generic non-delayed and channeled non-delayed spells
InterruptSpell(CURRENT_GENERIC_SPELL, false);
InterruptSpell(CURRENT_CHANNELED_SPELL, false);
}
// special action: set first cast flag
m_AutoRepeatFirstCast = true;
}
break;
default:
{
// other spell types don't break anything now
}
break;
}
// current spell (if it is still here) may be safely deleted now
if (m_currentSpells [CSpellType]) m_currentSpells [CSpellType]->SetReferencedFromCurrent(
false);
// set new current spell
m_currentSpells [CSpellType] = pSpell;
pSpell->SetReferencedFromCurrent(true);
pSpell->m_selfContainer =
&(m_currentSpells [pSpell->GetCurrentContainer()]);
}
void Unit::InterruptSpell(CurrentSpellTypes spellType, bool withDelayed,
bool withInstant)
{
ASSERT(spellType < CURRENT_MAX_SPELL);
//sLog->outDebug(LOG_FILTER_UNITS, "Interrupt spell for unit %u.", GetEntry());
Spell *spell = m_currentSpells [spellType];
if (spell && (withDelayed || spell->getState() != SPELL_STATE_DELAYED)
&& (withInstant || spell->GetCastTime() > 0))
{
// for example, do not let self-stun aura interrupt itself
if (!spell->IsInterruptable()) return;
// send autorepeat cancel message for autorepeat spells
if (spellType == CURRENT_AUTOREPEAT_SPELL)
if (GetTypeId() == TYPEID_PLAYER) ToPlayer()->SendAutoRepeatCancel(
this);
if (spell->getState() != SPELL_STATE_FINISHED) spell->cancel();
m_currentSpells [spellType] = NULL;
spell->SetReferencedFromCurrent(false);
}
}
void Unit::FinishSpell(CurrentSpellTypes spellType, bool ok /*= true*/)
{
Spell* spell = m_currentSpells [spellType];
if (!spell) return;
if (spellType == CURRENT_CHANNELED_SPELL) spell->SendChannelUpdate(0);
spell->finish(ok);
}
bool Unit::IsNonMeleeSpellCasted(bool withDelayed, bool skipChanneled,
bool skipAutorepeat, bool isAutoshoot, bool skipInstant) const
{
// We don't do loop here to explicitly show that melee spell is excluded.
// Maybe later some special spells will be excluded too.
// if checkInstant then instant spells shouldn't count as being casted
if (!skipInstant && m_currentSpells [CURRENT_GENERIC_SPELL]
&& !m_currentSpells [CURRENT_GENERIC_SPELL]->GetCastTime()) return false;
// generic spells are casted when they are not finished and not delayed
if (m_currentSpells [CURRENT_GENERIC_SPELL]
&& (m_currentSpells [CURRENT_GENERIC_SPELL]->getState()
!= SPELL_STATE_FINISHED)
&& (withDelayed
|| m_currentSpells [CURRENT_GENERIC_SPELL]->getState()
!= SPELL_STATE_DELAYED))
{
if (!isAutoshoot
|| !(m_currentSpells [CURRENT_GENERIC_SPELL]->m_spellInfo->AttributesEx2
& SPELL_ATTR2_NOT_RESET_AUTO_ACTIONS)) return (true);
}
// channeled spells may be delayed, but they are still considered casted
else if (!skipChanneled && m_currentSpells [CURRENT_CHANNELED_SPELL]
&& (m_currentSpells [CURRENT_CHANNELED_SPELL]->getState()
!= SPELL_STATE_FINISHED))
{
if (!isAutoshoot
|| !(m_currentSpells [CURRENT_CHANNELED_SPELL]->m_spellInfo->AttributesEx2
& SPELL_ATTR2_NOT_RESET_AUTO_ACTIONS)) return (true);
}
// autorepeat spells may be finished or delayed, but they are still considered casted
else if (!skipAutorepeat && m_currentSpells [CURRENT_AUTOREPEAT_SPELL]) return (true);
return (false);
}
void Unit::InterruptNonMeleeSpells(bool withDelayed, uint32 spell_id,
bool withInstant)
{
// generic spells are interrupted if they are not finished or delayed
if (m_currentSpells [CURRENT_GENERIC_SPELL]
&& (!spell_id
|| m_currentSpells [CURRENT_GENERIC_SPELL]->m_spellInfo->Id
== spell_id)) InterruptSpell(CURRENT_GENERIC_SPELL,
withDelayed, withInstant);
// autorepeat spells are interrupted if they are not finished or delayed
if (m_currentSpells [CURRENT_AUTOREPEAT_SPELL]
&& (!spell_id
|| m_currentSpells [CURRENT_AUTOREPEAT_SPELL]->m_spellInfo->Id
== spell_id)) InterruptSpell(
CURRENT_AUTOREPEAT_SPELL, withDelayed, withInstant);
// channeled spells are interrupted if they are not finished, even if they are delayed
if (m_currentSpells [CURRENT_CHANNELED_SPELL]
&& (!spell_id
|| m_currentSpells [CURRENT_CHANNELED_SPELL]->m_spellInfo->Id
== spell_id)) InterruptSpell(
CURRENT_CHANNELED_SPELL, true, true);
}
bool Unit::CanCastWhileWalking(const SpellEntry * const sp)
{
AuraEffectList alist = GetAuraEffectsByType(SPELL_AURA_CAST_WHILE_WALKING);
for (AuraEffectList::const_iterator i = alist.begin(); i != alist.end();
++i)
{
// check that spell mask matches
if (!((*i)->GetSpellProto()->EffectSpellClassMask [(*i)->GetEffIndex()]
& sp->SpellFamilyFlags)) continue;
return true;
}
return false;
}
Spell* Unit::FindCurrentSpellBySpellId(uint32 spell_id) const
{
for (uint32 i = 0; i < CURRENT_MAX_SPELL; i++)
if (m_currentSpells [i]
&& m_currentSpells [i]->m_spellInfo->Id == spell_id) return m_currentSpells [i];
return NULL;
}
int32 Unit::GetCurrentSpellCastTime(uint32 spell_id) const
{
if (Spell const * spell = FindCurrentSpellBySpellId(spell_id)) return spell->GetCastTime();
return 0;
}
bool Unit::isInFrontInMap(Unit const* target, float distance, float arc) const
{
return IsWithinDistInMap(target, distance) && HasInArc(arc, target);
}
bool Unit::isInBackInMap(Unit const* target, float distance, float arc) const
{
return IsWithinDistInMap(target, distance)
&& !HasInArc(2 * M_PI - arc, target);
}
void Unit::SetFacingToObject(WorldObject* pObject)
{
// update orientation at server
SetOrientation(GetAngle(pObject));
// and client
WorldPacket data;
BuildHeartBeatMsg(&data);
SendMessageToSet(&data, false);
}
bool Unit::isInAccessiblePlaceFor(Creature const* c) const
{
if (IsInWater()) return c->canSwim();
else return c->canWalk() || c->canFly();
}
bool Unit::IsInWater() const
{
return GetBaseMap()->IsInWater(GetPositionX(), GetPositionY(),
GetPositionZ());
}
bool Unit::IsUnderWater() const
{
return GetBaseMap()->IsUnderWater(GetPositionX(), GetPositionY(),
GetPositionZ());
}
void Unit::DeMorph()
{
SetDisplayId(GetNativeDisplayId());
}
void Unit::_AddAura(UnitAura * aura, Unit * caster)
{
ASSERT(!m_cleanupDone);
m_ownedAuras.insert(AuraMap::value_type(aura->GetId(), aura));
// passive and Incanter's Absorption and auras with different type can stack with themselves any number of times
if (!aura->IsPassive() && aura->GetId() != 44413)
{
// find current aura from spell and change it's stackamount
if (Aura * foundAura = GetOwnedAura(aura->GetId(), aura->GetCasterGUID(), (sSpellMgr->GetSpellCustomAttr(aura->GetId()) & SPELL_ATTR0_CU_ENCHANT_PROC) ? aura->GetCastItemGUID() : 0, 0, aura))
{
if (aura->GetSpellProto()->StackAmount)
{
aura->ModStackAmount(foundAura->GetStackAmount());
}
// Update periodic timers from the previous aura
// ToDo Fix me
/*for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
AuraEffect *existingEff = foundAura->GetEffect(i);
AuraEffect *newEff = aura->GetEffect(i);
if (!existingEff || !newEff)
continue;
newEff->SetPeriodicTimer(existingEff->GetPeriodicTimer());
}*/
// Use the new one to replace the old one
// This is the only place where AURA_REMOVE_BY_STACK should be used
RemoveOwnedAura(foundAura, AURA_REMOVE_BY_STACK);
}
}
_RemoveNoStackAurasDueToAura(aura);
if (aura->IsRemoved()) return;
aura->SetIsSingleTarget(
caster && IsSingleTargetSpell(aura->GetSpellProto()));
if (aura->IsSingleTarget())
{
ASSERT((IsInWorld() && !IsDuringRemoveFromWorld()) || (aura->GetCasterGUID() == GetGUID()));
// register single target aura
caster->GetSingleCastAuras().push_back(aura);
// remove other single target auras
Unit::AuraList& scAuras = caster->GetSingleCastAuras();
for (Unit::AuraList::iterator itr = scAuras.begin();
itr != scAuras.end();)
{
if ((*itr) != aura
&& IsSingleTargetSpells((*itr)->GetSpellProto(),
aura->GetSpellProto()))
{
(*itr)->Remove();
itr = scAuras.begin();
}
else ++itr;
}
}
}
// creates aura application instance and registers it in lists
// aura application effects are handled separately to prevent aura list corruption
AuraApplication * Unit::_CreateAuraApplication(Aura * aura, uint8 effMask)
{
// can't apply aura on unit which is going to be deleted - to not create a memory leak
ASSERT(!m_cleanupDone);
// aura musn't be removed
ASSERT(!aura->IsRemoved());
SpellEntry const* aurSpellInfo = aura->GetSpellProto();
uint32 aurId = aurSpellInfo->Id;
// ghost spell check, allow apply any auras at player loading in ghost mode (will be cleanup after load)
if (!isAlive() && !IsDeathPersistentSpell(aurSpellInfo)
&& (GetTypeId() != TYPEID_PLAYER
|| !this->ToPlayer()->GetSession()->PlayerLoading())) return NULL;
Unit * caster = aura->GetCaster();
AuraApplication * aurApp = new AuraApplication(this, caster, aura, effMask);
m_appliedAuras.insert(AuraApplicationMap::value_type(aurId, aurApp));
if (aurSpellInfo->AuraInterruptFlags)
{
m_interruptableAuras.push_back(aurApp);
AddInterruptMask(aurSpellInfo->AuraInterruptFlags);
}
if (AuraState aState = GetSpellAuraState(aura->GetSpellProto())) m_auraStateAuras.insert(
AuraStateAurasMap::value_type(aState, aurApp));
aura->_ApplyForTarget(this, caster, aurApp);
return aurApp;
}
void Unit::_ApplyAuraEffect(Aura * aura, uint8 effIndex)
{
ASSERT(aura);
ASSERT(aura->HasEffect(effIndex));
AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID());
ASSERT(aurApp);
if (!aurApp->GetEffectMask()) _ApplyAura(aurApp, 1 << effIndex);
else aurApp->_HandleEffect(effIndex, true);
}
// handles effects of aura application
// should be done after registering aura in lists
void Unit::_ApplyAura(AuraApplication * aurApp, uint8 effMask)
{
Aura * aura = aurApp->GetBase();
_RemoveNoStackAurasDueToAura(aura);
if (aurApp->GetRemoveMode()) return;
// Update target aura state flag
if (AuraState aState = GetSpellAuraState(aura->GetSpellProto())) ModifyAuraState(
aState, true);
if (aurApp->GetRemoveMode()) return;
// Sitdown on apply aura req seated
if (aura->GetSpellProto()->AuraInterruptFlags
& AURA_INTERRUPT_FLAG_NOT_SEATED && !IsSitState()) SetStandState(
UNIT_STAND_STATE_SIT);
Unit * caster = aura->GetCaster();
if (aurApp->GetRemoveMode()) return;
aura->HandleAuraSpecificMods(aurApp, caster, true, false);
// apply effects of the aura
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (effMask & 1 << i && (!aurApp->GetRemoveMode())) aurApp->_HandleEffect(
i, true);
}
}
// removes aura application from lists and unapplies effects
void Unit::_UnapplyAura(AuraApplicationMap::iterator &i,
AuraRemoveMode removeMode)
{
AuraApplication * aurApp = i->second;
ASSERT(aurApp);
ASSERT(!aurApp->GetRemoveMode());
ASSERT(aurApp->GetTarget() == this);
aurApp->SetRemoveMode(removeMode);
Aura * aura = aurApp->GetBase();
sLog->outDebug(LOG_FILTER_UNITS, "Aura %u now is remove mode %d",
aura->GetId(), removeMode);
// dead loop is killing the server probably
ASSERT(m_removedAurasCount < 0xFFFFFFFF);
++m_removedAurasCount;
Unit * caster = aura->GetCaster();
// Remove all pointers from lists here to prevent possible pointer invalidation on spellcast/auraapply/auraremove
m_appliedAuras.erase(i);
if (aura->GetSpellProto()->AuraInterruptFlags)
{
m_interruptableAuras.remove(aurApp);
UpdateInterruptMask();
}
bool auraStateFound = false;
AuraState auraState = GetSpellAuraState(aura->GetSpellProto());
if (auraState)
{
bool canBreak = false;
// Get mask of all aurastates from remaining auras
for (AuraStateAurasMap::iterator itr = m_auraStateAuras.lower_bound(
auraState);
itr != m_auraStateAuras.upper_bound(auraState)
&& !(auraStateFound && canBreak);)
{
if (itr->second == aurApp)
{
m_auraStateAuras.erase(itr);
itr = m_auraStateAuras.lower_bound(auraState);
canBreak = true;
continue;
}
auraStateFound = true;
++itr;
}
}
aurApp->_Remove();
aura->_UnapplyForTarget(this, caster, aurApp);
// remove effects of the spell - needs to be done after removing aura from lists
for (uint8 itr = 0; itr < MAX_SPELL_EFFECTS; ++itr)
{
if (aurApp->HasEffect(itr)) aurApp->_HandleEffect(itr, false);
}
// all effect mustn't be applied
ASSERT(!aurApp->GetEffectMask());
// Remove totem at next update if totem looses its aura
if (aurApp->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE
&& GetTypeId() == TYPEID_UNIT && this->ToCreature()->isTotem()
&& this->ToTotem()->GetSummonerGUID() == aura->GetCasterGUID())
{
if (this->ToTotem()->GetSpell() == aura->GetId()
&& this->ToTotem()->GetTotemType() == TOTEM_PASSIVE) this->ToTotem()->setDeathState(
JUST_DIED);
}
// Remove aurastates only if were not found
if (!auraStateFound) ModifyAuraState(auraState, false);
aura->HandleAuraSpecificMods(aurApp, caster, false, false);
// only way correctly remove all auras from list
//if (removedAuras != m_removedAurasCount) new aura may be added
i = m_appliedAuras.begin();
}
void Unit::_UnapplyAura(AuraApplication * aurApp, AuraRemoveMode removeMode)
{
// aura can be removed from unit only if it's applied on it, shouldn't happen
ASSERT(aurApp->GetBase()->GetApplicationOfTarget(GetGUID()) == aurApp);
uint32 spellId = aurApp->GetBase()->GetId();
for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(
spellId); iter != m_appliedAuras.upper_bound(spellId);)
{
if (iter->second == aurApp)
{
_UnapplyAura(iter, removeMode);
return;
}
else ++iter;
}
ASSERT(false);
}
void Unit::_RemoveNoStackAuraApplicationsDueToAura(Aura * aura)
{
// dynobj auras can stack infinite number of times
if (aura->GetType() == DYNOBJ_AURA_TYPE) return;
SpellEntry const* spellProto = aura->GetSpellProto();
uint32 spellId = spellProto->Id;
// passive spell special case (only non stackable with ranks)
if (IsPassiveSpell(spellId) && IsPassiveSpellStackableWithRanks(spellProto)) return;
bool remove = false;
for (AuraApplicationMap::iterator i = m_appliedAuras.begin();
i != m_appliedAuras.end(); ++i)
{
if (remove)
{
remove = false;
i = m_appliedAuras.begin();
}
if (!_IsNoStackAuraDueToAura(aura, i->second->GetBase())) continue;
RemoveAura(i, AURA_REMOVE_BY_DEFAULT);
if (i == m_appliedAuras.end()) break;
remove = true;
}
}
void Unit::_RemoveNoStackAurasDueToAura(Aura * aura)
{
SpellEntry const* spellProto = aura->GetSpellProto();
uint32 spellId = spellProto->Id;
// passive spell special case (only non stackable with ranks)
if (IsPassiveSpell(spellId) && IsPassiveSpellStackableWithRanks(spellProto)) return;
bool remove = false;
for (AuraMap::iterator i = m_ownedAuras.begin(); i != m_ownedAuras.end();
++i)
{
if (remove)
{
remove = false;
i = m_ownedAuras.begin();
}
if (!_IsNoStackAuraDueToAura(aura, i->second)) continue;
RemoveOwnedAura(i, AURA_REMOVE_BY_DEFAULT);
if (i == m_ownedAuras.end()) break;
remove = true;
}
}
bool Unit::_IsNoStackAuraDueToAura(Aura * appliedAura,
Aura * existingAura) const
{
SpellEntry const* spellProto = appliedAura->GetSpellProto();
// Do not check already applied aura
if (existingAura == appliedAura) return false;
// Do not check dynobj auras for stacking
if (existingAura->GetType() != UNIT_AURA_TYPE) return false;
SpellEntry const* i_spellProto = existingAura->GetSpellProto();
uint32 i_spellId = i_spellProto->Id;
bool sameCaster = appliedAura->GetCasterGUID()
== existingAura->GetCasterGUID();
if (IsPassiveSpell(i_spellId))
{
// passive non-stackable spells not stackable only for same caster
if (!sameCaster) return false;
// passive non-stackable spells not stackable only with another rank of same spell
if (!sSpellMgr->IsRankSpellDueToSpell(spellProto, i_spellId)) return false;
}
bool is_triggered_by_spell = false;
// prevent triggering aura of removing aura that triggered it
// prevent triggered aura of removing aura that triggering it (triggered effect early some aura of parent spell
for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
{
if (i_spellProto->EffectTriggerSpell [j] == spellProto->Id
|| spellProto->EffectTriggerSpell [j] == i_spellProto->Id) // I do not know what is this for
{
is_triggered_by_spell = true;
break;
}
}
if (is_triggered_by_spell) return false;
if (sSpellMgr->CanAurasStack(appliedAura, existingAura, sameCaster)) return false;
return true;
}
void Unit::_RegisterAuraEffect(AuraEffect * aurEff, bool apply)
{
if (apply) m_modAuras [aurEff->GetAuraType()].push_back(aurEff);
else m_modAuras [aurEff->GetAuraType()].remove(aurEff);
}
// All aura base removes should go threw this function!
void Unit::RemoveOwnedAura(AuraMap::iterator &i, AuraRemoveMode removeMode)
{
Aura * aura = i->second;
ASSERT(!aura->IsRemoved());
// if unit currently update aura list then make safe update iterator shift to next
if (m_auraUpdateIterator == i) ++m_auraUpdateIterator;
m_ownedAuras.erase(i);
m_removedAuras.push_back(aura);
// Unregister single target aura
if (aura->IsSingleTarget()) aura->UnregisterSingleTarget();
aura->_Remove(removeMode);
i = m_ownedAuras.begin();
}
void Unit::RemoveOwnedAura(uint32 spellId, uint64 caster, uint8 reqEffMask,
AuraRemoveMode removeMode)
{
for (AuraMap::iterator itr = m_ownedAuras.lower_bound(spellId);
itr != m_ownedAuras.upper_bound(spellId);)
if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask)
&& (!caster || itr->second->GetCasterGUID() == caster))
{
RemoveOwnedAura(itr, removeMode);
itr = m_ownedAuras.lower_bound(spellId);
}
else ++itr;
}
void Unit::RemoveOwnedAura(Aura * aura, AuraRemoveMode removeMode)
{
if (aura->IsRemoved()) return;
ASSERT(aura->GetOwner() == this);
uint32 spellId = aura->GetId();
for (AuraMap::iterator itr = m_ownedAuras.lower_bound(spellId);
itr != m_ownedAuras.upper_bound(spellId); ++itr)
if (itr->second == aura)
{
RemoveOwnedAura(itr, removeMode);
return;
}
ASSERT(false);
}
Aura * Unit::GetOwnedAura(uint32 spellId, uint64 casterGUID,
uint64 itemCasterGUID, uint8 reqEffMask, Aura* except) const
{
for (AuraMap::const_iterator itr = m_ownedAuras.lower_bound(spellId);
itr != m_ownedAuras.upper_bound(spellId); ++itr)
if (((itr->second->GetEffectMask() & reqEffMask) == reqEffMask)
&& (!casterGUID || itr->second->GetCasterGUID() == casterGUID)
&& (!itemCasterGUID
|| itr->second->GetCastItemGUID() == itemCasterGUID)
&& (!except || except != itr->second)) return itr->second;
return NULL;
}
void Unit::RemoveAura(AuraApplicationMap::iterator &i, AuraRemoveMode mode)
{
AuraApplication * aurApp = i->second;
// Do not remove aura which is already being removed
if (aurApp->GetRemoveMode()) return;
Aura * aura = aurApp->GetBase();
_UnapplyAura(i, mode);
// Remove aura - for Area and Target auras
if (aura->GetOwner() == this) aura->Remove(mode);
}
void Unit::RemoveAura(uint32 spellId, uint64 caster, uint8 reqEffMask,
AuraRemoveMode removeMode)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(
spellId); iter != m_appliedAuras.upper_bound(spellId);)
{
Aura const * aura = iter->second->GetBase();
if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
&& (!caster || aura->GetCasterGUID() == caster))
{
RemoveAura(iter, removeMode);
return;
}
else ++iter;
}
}
void Unit::RemoveAura(AuraApplication * aurApp, AuraRemoveMode mode)
{
ASSERT(aurApp->GetBase()->GetApplicationOfTarget(GetGUID()) == aurApp);
// no need to remove
if (aurApp->GetRemoveMode() || aurApp->GetBase()->IsRemoved()) return;
uint32 spellId = aurApp->GetBase()->GetId();
for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(
spellId); iter != m_appliedAuras.upper_bound(spellId);)
{
if (aurApp == iter->second)
{
RemoveAura(iter, mode);
return;
}
else ++iter;
}
}
void Unit::RemoveAura(Aura * aura, AuraRemoveMode mode)
{
if (aura->IsRemoved()) return;
if (AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID())) RemoveAura(
aurApp, mode);
else
ASSERT(false);
}
void Unit::RemoveAurasDueToSpell(uint32 spellId, uint64 caster,
uint8 reqEffMask, AuraRemoveMode removeMode)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(
spellId); iter != m_appliedAuras.upper_bound(spellId);)
{
Aura const * aura = iter->second->GetBase();
if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
&& (!caster || aura->GetCasterGUID() == caster))
{
RemoveAura(iter, removeMode);
iter = m_appliedAuras.lower_bound(spellId);
}
else ++iter;
}
}
void Unit::RemoveAuraFromStack(uint32 spellId, uint64 caster,
AuraRemoveMode removeMode)
{
for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId);
iter != m_ownedAuras.upper_bound(spellId);)
{
Aura const * aura = iter->second;
if ((aura->GetType() == UNIT_AURA_TYPE)
&& (!caster || aura->GetCasterGUID() == caster))
{
RemoveAuraFromStack(iter, removeMode);
return;
}
else ++iter;
}
}
inline void Unit::RemoveAuraFromStack(AuraMap::iterator &iter,
AuraRemoveMode removeMode)
{
if (iter->second->ModStackAmount(-1)) RemoveOwnedAura(iter, removeMode);
}
void Unit::RemoveAurasDueToSpellByDispel(uint32 spellId, uint64 casterGUID,
Unit *dispeller)
{
for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId);
iter != m_ownedAuras.upper_bound(spellId);)
{
Aura * aura = iter->second;
if (aura->GetCasterGUID() == casterGUID)
{
if (aura->GetSpellProto()->AttributesEx7
& SPELL_ATTR7_DISPEL_CHARGES) aura->DropCharge();
else RemoveAuraFromStack(iter, AURA_REMOVE_BY_ENEMY_SPELL);
// Unstable Affliction (crash if before removeaura?)
if (aura->GetSpellProto()->SpellFamilyName == SPELLFAMILY_WARLOCK
&& (aura->GetSpellProto()->SpellFamilyFlags [1] & 0x0100))
{
if (AuraEffect const * aurEff = aura->GetEffect(0))
{
int32 damage = aurEff->GetAmount() * 9;
// backfire damage and silence
dispeller->CastCustomSpell(dispeller, 31117, &damage, NULL,
NULL, true, NULL, NULL, aura->GetCasterGUID());
}
}
// Flame Shock
if (aura->GetSpellProto()->SpellFamilyName == SPELLFAMILY_SHAMAN
&& (aura->GetSpellProto()->SpellFamilyFlags [0] & 0x10000000))
{
Unit * caster = aura->GetCaster();
if (caster)
{
uint32 triggeredSpellId = 0;
// Lava Flows
if (AuraEffect const * aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, 3087, 0))
{
switch (aurEff->GetId())
{
case 51482: // Rank 3
triggeredSpellId = 65264;
break;
case 51481: // Rank 2
triggeredSpellId = 65263;
break;
case 51480: // Rank 1
triggeredSpellId = 64694;
break;
default:
sLog->outError(
"Aura::HandleAuraSpecificMods: Unknown rank of Lava Flows (%d) found",
aurEff->GetId());
}
}
if (triggeredSpellId) caster->CastSpell(caster,
triggeredSpellId, true);
}
}
// Wyvern Sting
if (aura->GetSpellProto()->SpellFamilyName == SPELLFAMILY_HUNTER
&& (aura->GetSpellProto()->SpellFamilyFlags [1] & 0x1000))
{
Unit * caster = aura->GetCaster();
if (caster
&& !(dispeller->GetTypeId() == TYPEID_UNIT
&& dispeller->ToCreature()->isTotem()))
// Noxious Stings
if (AuraEffect * auraEff = caster->GetAuraEffect(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, SPELLFAMILY_HUNTER, 3521, 1)) if (Aura * newAura = caster->AddAura(aura->GetId(), dispeller)) newAura->SetDuration(
aura->GetDuration() / 100 * auraEff->GetAmount());
}
return;
}
else ++iter;
}
}
void Unit::RemoveAurasDueToSpellBySteal(uint32 spellId, uint64 casterGUID,
Unit *stealer)
{
for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId);
iter != m_ownedAuras.upper_bound(spellId);)
{
Aura * aura = iter->second;
if (aura->GetCasterGUID() == casterGUID)
{
int32 damage [MAX_SPELL_EFFECTS];
int32 baseDamage [MAX_SPELL_EFFECTS];
uint8 effMask = 0;
uint8 recalculateMask = 0;
Unit * caster = aura->GetCaster();
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (aura->GetEffect(i))
{
baseDamage [i] = aura->GetEffect(i)->GetBaseAmount();
damage [i] = aura->GetEffect(i)->GetAmount();
effMask |= (1 << i);
if (aura->GetEffect(i)->CanBeRecalculated()) recalculateMask |=
(1 << i);
}
else
{
baseDamage [i] = NULL;
damage [i] = NULL;
}
}
bool stealCharge = aura->GetSpellProto()->AttributesEx7
& SPELL_ATTR7_DISPEL_CHARGES;
bool stealStack = aura->GetSpellProto()->StackAmount > 1;
int32 dur =
(2 * MINUTE * IN_MILLISECONDS < aura->GetDuration()
|| aura->GetDuration() < 0) ?
2 * MINUTE * IN_MILLISECONDS : aura->GetDuration();
if (Aura * newAura = (stealCharge || stealStack) ? stealer->GetAura(aura->GetId(), aura->GetCasterGUID()) : NULL)
{
if (stealCharge)
{
uint8 newCharges = newAura->GetCharges() + 1;
uint8 maxCharges = newAura->GetSpellProto()->procCharges;
// We must be able to steal as much charges as original caster can have
if (caster) if (Player* modOwner = caster->GetSpellModOwner()) modOwner->ApplySpellMod(
aura->GetId(), SPELLMOD_CHARGES, maxCharges);
newAura->SetCharges(
maxCharges < newCharges ? maxCharges : newCharges);
}
else
{
uint8 newStacks = newAura->GetStackAmount() + 1;
uint8 maxStacks = newAura->GetSpellProto()->StackAmount;
newAura->SetStackAmount(
maxStacks < newStacks ? maxStacks : newStacks);
}
newAura->SetDuration(dur);
}
else
{
bool isSingleTarget = aura->IsSingleTarget() && caster;
if (isSingleTarget) aura->UnregisterSingleTarget();
newAura = Aura::TryCreate(aura->GetSpellProto(), effMask,
stealer, NULL, &baseDamage [0], NULL,
aura->GetCasterGUID());
// strange but intended behaviour: Stolen single target auras won't be treated as single targeted
if (newAura && isSingleTarget)
{
aura->SetIsSingleTarget(true);
caster->GetSingleCastAuras().push_back(aura);
newAura->UnregisterSingleTarget();
}
if (!newAura) return;
newAura->SetLoadedState(dur, dur,
stealCharge ? 1 : aura->GetCharges(), 1,
recalculateMask, &damage [0]);
newAura->ApplyForTargets();
}
if (stealCharge) aura->DropCharge();
else RemoveAuraFromStack(iter, AURA_REMOVE_BY_ENEMY_SPELL);
return;
}
else ++iter;
}
}
void Unit::RemoveAurasDueToItemSpell(Item* castItem, uint32 spellId)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.lower_bound(
spellId); iter != m_appliedAuras.upper_bound(spellId);)
{
if (!castItem
|| iter->second->GetBase()->GetCastItemGUID()
== castItem->GetGUID())
{
RemoveAura(iter);
iter = m_appliedAuras.upper_bound(spellId); // overwrite by more appropriate
}
else ++iter;
}
}
void Unit::RemoveAurasByType(AuraType auraType, uint64 casterGUID,
Aura * except, bool negative, bool positive)
{
for (AuraEffectList::iterator iter = m_modAuras [auraType].begin();
iter != m_modAuras [auraType].end();)
{
Aura * aura = (*iter)->GetBase();
AuraApplication * aurApp = aura->GetApplicationOfTarget(GetGUID());
++iter;
if (aura != except
&& (!casterGUID || aura->GetCasterGUID() == casterGUID)
&& ((negative && !aurApp->IsPositive())
|| (positive && aurApp->IsPositive())))
{
uint32 removedAuras = m_removedAurasCount;
RemoveAura(aurApp);
if (m_removedAurasCount > removedAuras + 1) iter =
m_modAuras [auraType].begin();
}
}
}
void Unit::RemoveAurasWithAttribute(uint32 flags)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
SpellEntry const *spell = iter->second->GetBase()->GetSpellProto();
if (spell->Attributes & flags) RemoveAura(iter);
else ++iter;
}
}
void Unit::RemoveNotOwnSingleTargetAuras(uint32 newPhase)
{
// single target auras from other casters
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
AuraApplication const * aurApp = iter->second;
Aura const * aura = aurApp->GetBase();
if (aura->GetCasterGUID() != GetGUID()
&& IsSingleTargetSpell(aura->GetSpellProto()))
{
if (!newPhase) RemoveAura(iter);
else
{
Unit* caster = aura->GetCaster();
if (!caster || !caster->InSamePhase(newPhase)) RemoveAura(iter);
else ++iter;
}
}
else ++iter;
}
// single target auras at other targets
AuraList& scAuras = GetSingleCastAuras();
for (AuraList::iterator iter = scAuras.begin(); iter != scAuras.end();)
{
Aura * aura = *iter;
if (aura->GetUnitOwner() != this
&& !aura->GetUnitOwner()->InSamePhase(newPhase))
{
aura->Remove();
iter = scAuras.begin();
}
else ++iter;
}
}
void Unit::RemoveAurasWithInterruptFlags(uint32 flag, uint32 except)
{
if (!(m_interruptMask & flag)) return;
// interrupt auras
for (AuraApplicationList::iterator iter = m_interruptableAuras.begin();
iter != m_interruptableAuras.end();)
{
Aura * aura = (*iter)->GetBase();
++iter;
if ((aura->GetSpellProto()->AuraInterruptFlags & flag)
&& (!except || aura->GetId() != except))
{
uint32 removedAuras = m_removedAurasCount;
RemoveAura(aura);
if (m_removedAurasCount > removedAuras + 1) iter =
m_interruptableAuras.begin();
}
}
// interrupt channeled spell
if (Spell* spell = m_currentSpells[CURRENT_CHANNELED_SPELL]) if (spell->getState()
== SPELL_STATE_CASTING
&& (spell->m_spellInfo->ChannelInterruptFlags & flag)
&& spell->m_spellInfo->Id != except) InterruptNonMeleeSpells(false);
UpdateInterruptMask();
}
void Unit::RemoveAurasWithFamily(SpellFamilyNames family, uint32 familyFlag1,
uint32 familyFlag2, uint32 familyFlag3, uint64 casterGUID)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
Aura const * aura = iter->second->GetBase();
if (!casterGUID || aura->GetCasterGUID() == casterGUID)
{
SpellEntry const *spell = aura->GetSpellProto();
if (spell->SpellFamilyName == uint32(family)
&& spell->SpellFamilyFlags.HasFlag(familyFlag1, familyFlag2,
familyFlag3))
{
RemoveAura(iter);
continue;
}
}
++iter;
}
}
void Unit::RemoveMovementImpairingAuras()
{
RemoveAurasWithMechanic((1 << MECHANIC_SNARE) | (1 << MECHANIC_ROOT));
}
void Unit::RemoveAurasWithMechanic(uint32 mechanic_mask,
AuraRemoveMode removemode, uint32 except, int32 count)
{
int32 auracount = 0;
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
Aura const * aura = iter->second->GetBase();
if (!except || aura->GetId() != except)
{
if (GetAllSpellMechanicMask(aura->GetSpellProto()) & mechanic_mask)
{
RemoveAura(iter, removemode);
auracount++;
if (count && auracount == count) break;
continue;
}
}
++iter;
}
}
void Unit::RemoveAreaAurasDueToLeaveWorld()
{
// make sure that all area auras not applied on self are removed - prevent access to deleted pointer later
for (AuraMap::iterator iter = m_ownedAuras.begin();
iter != m_ownedAuras.end();)
{
Aura * aura = iter->second;
++iter;
Aura::ApplicationMap const & appMap = aura->GetApplicationMap();
for (Aura::ApplicationMap::const_iterator itr = appMap.begin();
itr != appMap.end();)
{
AuraApplication * aurApp = itr->second;
++itr;
Unit * target = aurApp->GetTarget();
if (target == this) continue;
target->RemoveAura(aurApp);
// things linked on aura remove may apply new area aura - so start from the beginning
iter = m_ownedAuras.begin();
}
}
// remove area auras owned by others
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
if (iter->second->GetBase()->GetOwner() != this)
{
RemoveAura(iter);
}
else ++iter;
}
}
void Unit::RemoveAllAuras()
{
// this may be a dead loop if some events on aura remove will continiously apply aura on remove
// we want to have all auras removed, so use your brain when linking events
while (!m_appliedAuras.empty() || !m_ownedAuras.empty())
{
AuraApplicationMap::iterator aurAppIter;
for (aurAppIter = m_appliedAuras.begin();
aurAppIter != m_appliedAuras.end();)
_UnapplyAura(aurAppIter, AURA_REMOVE_BY_DEFAULT);
AuraMap::iterator aurIter;
for (aurIter = m_ownedAuras.begin(); aurIter != m_ownedAuras.end();)
RemoveOwnedAura(aurIter);
}
}
void Unit::RemoveArenaAuras(bool onleave)
{
// in join, remove positive buffs, on end, remove negative
// used to remove positive visible auras in arenas
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
AuraApplication const * aurApp = iter->second;
Aura const * aura = aurApp->GetBase();
if (!(aura->GetSpellProto()->AttributesEx4 & SPELL_ATTR4_UNK21) // don't remove stances, shadowform, pally/hunter auras
&& !aura->IsPassive() // don't remove passive auras
&& (!(aura->GetSpellProto()->Attributes
& SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY)
|| !(aura->GetSpellProto()->Attributes
& SPELL_ATTR0_UNK8)) // not unaffected by invulnerability auras or not having that unknown flag (that seemed the most probable)
&& (aurApp->IsPositive() ^ onleave)) // remove positive buffs on enter, negative buffs on leave
RemoveAura(iter);
else ++iter;
}
}
void Unit::RemoveAllAurasOnDeath()
{
// used just after dieing to remove all visible auras
// and disable the mods for the passive ones
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
Aura const * aura = iter->second->GetBase();
if (!aura->IsPassive() && !aura->IsDeathPersistent()) _UnapplyAura(iter,
AURA_REMOVE_BY_DEATH);
else ++iter;
}
for (AuraMap::iterator iter = m_ownedAuras.begin();
iter != m_ownedAuras.end();)
{
Aura * aura = iter->second;
if (!aura->IsPassive() && !aura->IsDeathPersistent()) RemoveOwnedAura(
iter, AURA_REMOVE_BY_DEATH);
else ++iter;
}
}
void Unit::RemoveAllAurasRequiringDeadTarget()
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end();)
{
Aura const * aura = iter->second->GetBase();
if (!aura->IsPassive()
&& IsRequiringDeadTargetSpell(aura->GetSpellProto())) _UnapplyAura(
iter, AURA_REMOVE_BY_DEFAULT);
else ++iter;
}
for (AuraMap::iterator iter = m_ownedAuras.begin();
iter != m_ownedAuras.end();)
{
Aura * aura = iter->second;
if (!aura->IsPassive()
&& IsRequiringDeadTargetSpell(aura->GetSpellProto())) RemoveOwnedAura(
iter, AURA_REMOVE_BY_DEFAULT);
else ++iter;
}
}
void Unit::DelayOwnedAuras(uint32 spellId, uint64 caster, int32 delaytime)
{
for (AuraMap::iterator iter = m_ownedAuras.lower_bound(spellId);
iter != m_ownedAuras.upper_bound(spellId); ++iter)
{
Aura * aura = iter->second;
if (!caster || aura->GetCasterGUID() == caster)
{
if (aura->GetDuration() < delaytime) aura->SetDuration(0);
else aura->SetDuration(aura->GetDuration() - delaytime);
// update for out of range group members (on 1 slot use)
aura->SetNeedClientUpdateForTargets();
sLog->outDebug(
LOG_FILTER_UNITS,
"Aura %u partially interrupted on unit %u, new duration: %u ms",
aura->GetId(), GetGUIDLow(), aura->GetDuration());
}
}
}
void Unit::_RemoveAllAuraStatMods()
{
for (AuraApplicationMap::iterator i = m_appliedAuras.begin();
i != m_appliedAuras.end(); ++i)
(*i).second->GetBase()->HandleAllEffects(i->second,
AURA_EFFECT_HANDLE_STAT, false);
}
void Unit::_ApplyAllAuraStatMods()
{
for (AuraApplicationMap::iterator i = m_appliedAuras.begin();
i != m_appliedAuras.end(); ++i)
(*i).second->GetBase()->HandleAllEffects(i->second,
AURA_EFFECT_HANDLE_STAT, true);
}
AuraEffect * Unit::GetAuraEffect(uint32 spellId, uint8 effIndex,
uint64 caster) const
{
for (AuraApplicationMap::const_iterator itr = m_appliedAuras.lower_bound(
spellId); itr != m_appliedAuras.upper_bound(spellId); ++itr)
if (itr->second->HasEffect(effIndex)
&& (!caster || itr->second->GetBase()->GetCasterGUID() == caster)) return itr->second->GetBase()->GetEffect(
effIndex);
return NULL;
}
AuraEffect * Unit::GetAuraEffectOfRankedSpell(uint32 spellId, uint8 effIndex,
uint64 caster) const
{
uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
while (true)
{
if (AuraEffect * aurEff = GetAuraEffect(rankSpell, effIndex, caster)) return aurEff;
SpellChainNode const * chainNode = sSpellMgr->GetSpellChainNode(
rankSpell);
if (!chainNode) break;
else rankSpell = chainNode->next;
}
return NULL;
}
AuraEffect* Unit::GetAuraEffect(AuraType type, SpellFamilyNames name,
uint32 iconId, uint8 effIndex) const
{
AuraEffectList const& auras = GetAuraEffectsByType(type);
for (Unit::AuraEffectList::const_iterator itr = auras.begin();
itr != auras.end(); ++itr)
{
if (effIndex != (*itr)->GetEffIndex()) continue;
SpellEntry const * spell = (*itr)->GetSpellProto();
if (spell->SpellIconID == iconId
&& spell->SpellFamilyName == uint32(name)
&& !spell->SpellFamilyFlags) return *itr;
}
return NULL;
}
AuraEffect* Unit::GetAuraEffect(AuraType type, SpellFamilyNames family,
uint32 familyFlag1, uint32 familyFlag2, uint32 familyFlag3,
uint64 casterGUID)
{
AuraEffectList const& auras = GetAuraEffectsByType(type);
for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end();
++i)
{
SpellEntry const *spell = (*i)->GetSpellProto();
if (spell->SpellFamilyName == uint32(family)
&& spell->SpellFamilyFlags.HasFlag(familyFlag1, familyFlag2,
familyFlag3))
{
if (casterGUID && (*i)->GetCasterGUID() != casterGUID) continue;
return (*i);
}
}
return NULL;
}
AuraApplication * Unit::GetAuraApplication(uint32 spellId, uint64 casterGUID,
uint64 itemCasterGUID, uint8 reqEffMask, AuraApplication * except) const
{
for (AuraApplicationMap::const_iterator itr = m_appliedAuras.lower_bound(
spellId); itr != m_appliedAuras.upper_bound(spellId); ++itr)
{
Aura const * aura = itr->second->GetBase();
if (((aura->GetEffectMask() & reqEffMask) == reqEffMask)
&& (!casterGUID || aura->GetCasterGUID() == casterGUID)
&& (!itemCasterGUID || aura->GetCastItemGUID() == itemCasterGUID)
&& (!except || except != itr->second)) return itr->second;
}
return NULL;
}
Aura * Unit::GetAura(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID,
uint8 reqEffMask) const
{
AuraApplication * aurApp = GetAuraApplication(spellId, casterGUID,
itemCasterGUID, reqEffMask);
return aurApp ? aurApp->GetBase() : NULL;
}
AuraApplication * Unit::GetAuraApplicationOfRankedSpell(uint32 spellId,
uint64 casterGUID, uint64 itemCasterGUID, uint8 reqEffMask,
AuraApplication* except) const
{
uint32 rankSpell = sSpellMgr->GetFirstSpellInChain(spellId);
while (true)
{
if (AuraApplication * aurApp = GetAuraApplication(rankSpell, casterGUID, itemCasterGUID, reqEffMask, except)) return aurApp;
SpellChainNode const * chainNode = sSpellMgr->GetSpellChainNode(
rankSpell);
if (!chainNode) break;
else rankSpell = chainNode->next;
}
return NULL;
}
Aura * Unit::GetAuraOfRankedSpell(uint32 spellId, uint64 casterGUID,
uint64 itemCasterGUID, uint8 reqEffMask) const
{
AuraApplication * aurApp = GetAuraApplicationOfRankedSpell(spellId,
casterGUID, itemCasterGUID, reqEffMask);
return aurApp ? aurApp->GetBase() : NULL;
}
bool Unit::HasAuraEffect(uint32 spellId, uint8 effIndex, uint64 caster) const
{
for (AuraApplicationMap::const_iterator itr = m_appliedAuras.lower_bound(
spellId); itr != m_appliedAuras.upper_bound(spellId); ++itr)
if (itr->second->HasEffect(effIndex)
&& (!caster || itr->second->GetBase()->GetCasterGUID() == caster)) return true;
return false;
}
uint32 Unit::GetAuraCount(uint32 spellId) const
{
uint32 count = 0;
for (AuraApplicationMap::const_iterator itr = m_appliedAuras.lower_bound(
spellId); itr != m_appliedAuras.upper_bound(spellId); ++itr)
{
if (!itr->second->GetBase()->GetStackAmount()) count++;
else count += (uint32) itr->second->GetBase()->GetStackAmount();
}
return count;
}
bool Unit::HasAura(uint32 spellId, uint64 casterGUID, uint64 itemCasterGUID,
uint8 reqEffMask) const
{
if (GetAuraApplication(spellId, casterGUID, itemCasterGUID, reqEffMask)) return true;
return false;
}
bool Unit::HasAuraType(AuraType auraType) const
{
return (!m_modAuras [auraType].empty());
}
bool Unit::HasAuraTypeWithCaster(AuraType auratype, uint64 caster) const
{
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
if (caster == (*i)->GetCasterGUID()) return true;
return false;
}
bool Unit::HasAuraTypeWithMiscvalue(AuraType auratype, int32 miscvalue) const
{
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
if (miscvalue == (*i)->GetMiscValue()) return true;
return false;
}
bool Unit::HasAuraTypeWithAffectMask(AuraType auratype,
SpellEntry const * affectedSpell) const
{
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
if ((*i)->IsAffectedOnSpell(affectedSpell)) return true;
return false;
}
bool Unit::HasAuraTypeWithValue(AuraType auratype, int32 value) const
{
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
if (value == (*i)->GetAmount()) return true;
return false;
}
bool Unit::HasNegativeAuraWithInterruptFlag(uint32 flag, uint64 guid)
{
if (!(m_interruptMask & flag)) return false;
for (AuraApplicationList::iterator iter = m_interruptableAuras.begin();
iter != m_interruptableAuras.end(); ++iter)
{
if (!(*iter)->IsPositive()
&& (*iter)->GetBase()->GetSpellProto()->AuraInterruptFlags
& flag
&& (!guid || (*iter)->GetBase()->GetCasterGUID() == guid)) return true;
}
return false;
}
bool Unit::HasNegativeAuraWithAttribute(uint32 flag, uint64 guid)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin();
iter != m_appliedAuras.end(); ++iter)
{
Aura const *aura = iter->second->GetBase();
if (!iter->second->IsPositive()
&& aura->GetSpellProto()->Attributes & flag
&& (!guid || aura->GetCasterGUID() == guid)) return true;
}
return false;
}
bool Unit::HasAuraWithMechanic(uint32 mechanicMask)
{
for (AuraApplicationMap::iterator iter = m_appliedAuras.begin(); iter != m_appliedAuras.end(); ++iter)
{
SpellEntry const* spellInfo = iter->second->GetBase()->GetSpellProto();
if (spellInfo->Mechanic && (mechanicMask & (1 << spellInfo->Mechanic)))
return true;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
if (iter->second->HasEffect(i) && spellInfo->Effect[i] && spellInfo->EffectMechanic[i])
if (mechanicMask & (1 << spellInfo->EffectMechanic[i]))
return true;
}
return false;
}
AuraEffect * Unit::IsScriptOverriden(SpellEntry const * spell,
int32 script) const
{
AuraEffectList const& auras = GetAuraEffectsByType(
SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end();
++i)
{
if ((*i)->GetMiscValue() == script) if ((*i)->IsAffectedOnSpell(spell)) return (*i);
}
return NULL;
}
uint32 Unit::GetDiseasesByCaster(uint64 casterGUID, bool remove)
{
static const AuraType diseaseAuraTypes [] =
{ SPELL_AURA_PERIODIC_DAMAGE, // Frost Fever and Blood Plague
SPELL_AURA_LINKED, // Crypt Fever and Ebon Plague
SPELL_AURA_NONE };
uint32 diseases = 0;
for (AuraType const* itr = &diseaseAuraTypes [0];
itr && itr [0] != SPELL_AURA_NONE; ++itr)
{
for (AuraEffectList::iterator i = m_modAuras [*itr].begin();
i != m_modAuras [*itr].end();)
{
// Get auras with disease dispel type by caster
if ((*i)->GetSpellProto()->Dispel == DISPEL_DISEASE
&& (*i)->GetCasterGUID() == casterGUID)
{
++diseases;
if (remove)
{
RemoveAura((*i)->GetId(), (*i)->GetCasterGUID());
i = m_modAuras [*itr].begin();
continue;
}
}
++i;
}
}
return diseases;
}
uint32 Unit::GetDoTsByCaster(uint64 casterGUID) const
{
static const AuraType diseaseAuraTypes [] =
{ SPELL_AURA_PERIODIC_DAMAGE, SPELL_AURA_PERIODIC_DAMAGE_PERCENT,
SPELL_AURA_NONE };
uint32 dots = 0;
for (AuraType const* itr = &diseaseAuraTypes [0];
itr && itr [0] != SPELL_AURA_NONE; ++itr)
{
Unit::AuraEffectList const& auras = GetAuraEffectsByType(*itr);
for (AuraEffectList::const_iterator i = auras.begin(); i != auras.end();
++i)
{
// Get auras by caster
if ((*i)->GetCasterGUID() == casterGUID) ++dots;
}
}
return dots;
}
int32 Unit::GetTotalAuraModifier(AuraType auratype) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
modifier += (*i)->GetAmount();
return modifier;
}
float Unit::GetTotalAuraMultiplier(AuraType auratype) const
{
float multiplier = 1.0f;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
multiplier *= (100.0f + (*i)->GetAmount()) / 100.0f;
return multiplier;
}
int32 Unit::GetMaxPositiveAuraModifier(AuraType auratype)
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetAmount() > modifier) modifier = (*i)->GetAmount();
}
return modifier;
}
int32 Unit::GetMaxNegativeAuraModifier(AuraType auratype) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
if ((*i)->GetAmount() < modifier) modifier = (*i)->GetAmount();
return modifier;
}
int32 Unit::GetTotalAuraModifierByMiscMask(AuraType auratype,
uint32 misc_mask) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() & misc_mask) modifier += (*i)->GetAmount();
}
return modifier;
}
float Unit::GetTotalAuraMultiplierByMiscMask(AuraType auratype,
uint32 misc_mask) const
{
float multiplier = 1.0f;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() & misc_mask) multiplier *= (100.0f
+ (*i)->GetAmount()) / 100.0f;
}
return multiplier;
}
int32 Unit::GetMaxPositiveAuraModifierByMiscMask(AuraType auratype,
uint32 misc_mask, const AuraEffect* except) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if (except != (*i) && (*i)->GetMiscValue() & misc_mask
&& (*i)->GetAmount() > modifier) modifier = (*i)->GetAmount();
}
return modifier;
}
int32 Unit::GetMaxNegativeAuraModifierByMiscMask(AuraType auratype,
uint32 misc_mask) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() & misc_mask && (*i)->GetAmount() < modifier) modifier =
(*i)->GetAmount();
}
return modifier;
}
int32 Unit::GetTotalAuraModifierByMiscValue(AuraType auratype,
int32 misc_value) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() == misc_value) modifier += (*i)->GetAmount();
}
return modifier;
}
float Unit::GetTotalAuraMultiplierByMiscValue(AuraType auratype,
int32 misc_value) const
{
float multiplier = 1.0f;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() == misc_value) multiplier *= (100.0f
+ (*i)->GetAmount()) / 100.0f;
}
return multiplier;
}
int32 Unit::GetMaxPositiveAuraModifierByMiscValue(AuraType auratype,
int32 misc_value) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() == misc_value && (*i)->GetAmount() > modifier) modifier =
(*i)->GetAmount();
}
return modifier;
}
int32 Unit::GetMaxNegativeAuraModifierByMiscValue(AuraType auratype,
int32 misc_value) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->GetMiscValue() == misc_value && (*i)->GetAmount() < modifier) modifier =
(*i)->GetAmount();
}
return modifier;
}
int32 Unit::GetTotalAuraModifierByAffectMask(AuraType auratype,
SpellEntry const * affectedSpell) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->IsAffectedOnSpell(affectedSpell)) modifier +=
(*i)->GetAmount();
}
return modifier;
}
float Unit::GetTotalAuraMultiplierByAffectMask(AuraType auratype,
SpellEntry const * affectedSpell) const
{
float multiplier = 1.0f;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->IsAffectedOnSpell(affectedSpell)) multiplier *= (100.0f
+ (*i)->GetAmount()) / 100.0f;
}
return multiplier;
}
int32 Unit::GetMaxPositiveAuraModifierByAffectMask(AuraType auratype,
SpellEntry const * affectedSpell) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->IsAffectedOnSpell(affectedSpell)
&& (*i)->GetAmount() > modifier) modifier = (*i)->GetAmount();
}
return modifier;
}
int32 Unit::GetMaxNegativeAuraModifierByAffectMask(AuraType auratype,
SpellEntry const * affectedSpell) const
{
int32 modifier = 0;
AuraEffectList const& mTotalAuraList = GetAuraEffectsByType(auratype);
for (AuraEffectList::const_iterator i = mTotalAuraList.begin();
i != mTotalAuraList.end(); ++i)
{
if ((*i)->IsAffectedOnSpell(affectedSpell)
&& (*i)->GetAmount() < modifier) modifier = (*i)->GetAmount();
}
return modifier;
}
void Unit::_RegisterDynObject(DynamicObject* dynObj)
{
m_dynObj.push_back(dynObj);
}
void Unit::_UnregisterDynObject(DynamicObject* dynObj)
{
m_dynObj.remove(dynObj);
}
DynamicObject * Unit::GetDynObject(uint32 spellId)
{
if (m_dynObj.empty()) return NULL;
for (DynObjectList::const_iterator i = m_dynObj.begin();
i != m_dynObj.end(); ++i)
{
DynamicObject* dynObj = *i;
if (dynObj->GetSpellId() == spellId) return dynObj;
}
return NULL;
}
void Unit::RemoveDynObject(uint32 spellId)
{
if (m_dynObj.empty()) return;
for (DynObjectList::iterator i = m_dynObj.begin(); i != m_dynObj.end();)
{
DynamicObject* dynObj = *i;
if (dynObj->GetSpellId() == spellId)
{
dynObj->Remove();
i = m_dynObj.begin();
}
else ++i;
}
}
void Unit::RemoveAllDynObjects()
{
while (!m_dynObj.empty())
m_dynObj.front()->Remove();
}
GameObject* Unit::GetGameObject(uint32 spellId) const
{
for (GameObjectList::const_iterator i = m_gameObj.begin();
i != m_gameObj.end(); ++i)
if ((*i)->GetSpellId() == spellId) return *i;
return NULL;
}
void Unit::AddGameObject(GameObject* gameObj)
{
if (!gameObj || !gameObj->GetOwnerGUID() == 0) return;
m_gameObj.push_back(gameObj);
gameObj->SetOwnerGUID(GetGUID());
if (GetTypeId() == TYPEID_PLAYER && gameObj->GetSpellId())
{
SpellEntry const* createBySpell = sSpellStore.LookupEntry(
gameObj->GetSpellId());
// Need disable spell use for owner
if (createBySpell
&& createBySpell->Attributes & SPELL_ATTR0_DISABLED_WHILE_ACTIVE)
// note: item based cooldowns and cooldown spell mods with charges ignored (unknown existed cases)
this->ToPlayer()->AddSpellAndCategoryCooldowns(createBySpell, 0, NULL,
true);
}
}
void Unit::RemoveGameObject(GameObject* gameObj, bool del)
{
if (!gameObj || !gameObj->GetOwnerGUID() == GetGUID()) return;
gameObj->SetOwnerGUID(0);
for (uint32 i = 0; i < 4; ++i)
{
if (m_ObjectSlot [i] == gameObj->GetGUID())
{
m_ObjectSlot [i] = 0;
break;
}
}
// GO created by some spell
if (uint32 spellid = gameObj->GetSpellId())
{
RemoveAurasDueToSpell(spellid);
if (GetTypeId() == TYPEID_PLAYER)
{
SpellEntry const* createBySpell = sSpellStore.LookupEntry(spellid);
// Need activate spell use for owner
if (createBySpell
&& createBySpell->Attributes
& SPELL_ATTR0_DISABLED_WHILE_ACTIVE)
// note: item based cooldowns and cooldown spell mods with charges ignored (unknown existed cases)
this->ToPlayer()->SendCooldownEvent(createBySpell);
}
}
m_gameObj.remove(gameObj);
if (del)
{
gameObj->SetRespawnTime(0);
gameObj->Delete();
}
}
void Unit::RemoveGameObject(uint32 spellid, bool del)
{
if (m_gameObj.empty()) return;
GameObjectList::iterator i, next;
for (i = m_gameObj.begin(); i != m_gameObj.end(); i = next)
{
next = i;
if (spellid == 0 || (*i)->GetSpellId() == spellid)
{
(*i)->SetOwnerGUID(0);
if (del)
{
(*i)->SetRespawnTime(0);
(*i)->Delete();
}
next = m_gameObj.erase(i);
}
else ++next;
}
}
void Unit::RemoveAllGameObjects()
{
// remove references to unit
for (GameObjectList::iterator i = m_gameObj.begin(); i != m_gameObj.end();)
{
(*i)->SetOwnerGUID(0);
(*i)->SetRespawnTime(0);
(*i)->Delete();
i = m_gameObj.erase(i);
}
}
void Unit::SendSpellNonMeleeDamageLog(SpellNonMeleeDamage *log)
{
WorldPacket data(SMSG_SPELLNONMELEEDAMAGELOG,
(16 + 4 + 4 + 4 + 1 + 4 + 4 + 1 + 1 + 4 + 4 + 1)); // we guess size
data.append(log->target->GetPackGUID());
data.append(log->attacker->GetPackGUID());
data << uint32(log->SpellID);
data << uint32(log->damage); // damage amount
int32 overkill = log->damage - log->target->GetHealth();
data << uint32(overkill > 0 ? overkill : 0); // overkill
data << uint8(log->schoolMask); // damage school
data << uint32(log->absorb); // AbsorbedDamage
data << uint32(log->resist); // resist
data << uint8(log->physicalLog); // if 1, then client show spell name (example: %s's ranged shot hit %s for %u school or %s suffers %u school damage from %s's spell_name
data << uint8(log->unused); // unused
data << uint32(log->blocked); // blocked
data << uint32(log->HitInfo);
data << uint8(0); // flag to use extend data
SendMessageToSet(&data, true);
}
void Unit::SendSpellNonMeleeDamageLog(Unit *target, uint32 SpellID,
uint32 Damage, SpellSchoolMask damageSchoolMask, uint32 AbsorbedDamage,
uint32 Resist, bool PhysicalDamage, uint32 Blocked, bool CriticalHit)
{
SpellNonMeleeDamage log(this, target, SpellID, damageSchoolMask);
log.damage = Damage - AbsorbedDamage - Resist - Blocked;
log.absorb = AbsorbedDamage;
log.resist = Resist;
log.physicalLog = PhysicalDamage;
log.blocked = Blocked;
log.HitInfo = SPELL_HIT_TYPE_UNK1 | SPELL_HIT_TYPE_UNK3
| SPELL_HIT_TYPE_UNK6;
if (CriticalHit) log.HitInfo |= SPELL_HIT_TYPE_CRIT;
SendSpellNonMeleeDamageLog(&log);
}
void Unit::ProcDamageAndSpell(Unit *pVictim, uint32 procAttacker,
uint32 procVictim, uint32 procExtra, uint32 amount,
WeaponAttackType attType, SpellEntry const *procSpell,
SpellEntry const * procAura)
{
// Not much to do if no flags are set.
if (procAttacker) ProcDamageAndSpellFor(false, pVictim, procAttacker,
procExtra, attType, procSpell, amount, procAura);
// Now go on with a victim's events'n'auras
// Not much to do if no flags are set or there is no victim
if (pVictim && pVictim->isAlive() && procVictim) pVictim->ProcDamageAndSpellFor(
true, this, procVictim, procExtra, attType, procSpell, amount,
procAura);
}
void Unit::SendPeriodicAuraLog(SpellPeriodicAuraLogInfo *pInfo)
{
AuraEffect const * aura = pInfo->auraEff;
WorldPacket data(SMSG_PERIODICAURALOG, 8 + 8 + 4 + 4 + 4 + 4 * 5 + 1);
data.append(GetPackGUID());
data.appendPackGUID(aura->GetCasterGUID());
data << uint32(aura->GetId()); // spellId
data << uint32(1); // count
data << uint32(aura->GetAuraType()); // auraId
switch (aura->GetAuraType())
{
case SPELL_AURA_PERIODIC_DAMAGE:
case SPELL_AURA_PERIODIC_DAMAGE_PERCENT:
data << uint32(pInfo->damage); // damage
data << uint32(pInfo->overDamage); // overkill?
data << uint32(GetSpellSchoolMask(aura->GetSpellProto()));
data << uint32(pInfo->absorb); // absorb
data << uint32(pInfo->resist); // resist
data << uint8(pInfo->critical); // new 3.1.2 critical tick
break;
case SPELL_AURA_PERIODIC_HEAL:
case SPELL_AURA_OBS_MOD_HEALTH:
data << uint32(pInfo->damage); // damage
data << uint32(pInfo->overDamage); // overheal
data << uint32(pInfo->absorb); // absorb
data << uint8(pInfo->critical); // new 3.1.2 critical tick
break;
case SPELL_AURA_OBS_MOD_POWER:
case SPELL_AURA_PERIODIC_ENERGIZE:
data << uint32(aura->GetMiscValue()); // power type
data << uint32(pInfo->damage); // damage
break;
case SPELL_AURA_PERIODIC_MANA_LEECH:
data << uint32(aura->GetMiscValue()); // power type
data << uint32(pInfo->damage); // amount
data << float(pInfo->multiplier); // gain multiplier
break;
default:
sLog->outError("Unit::SendPeriodicAuraLog: unknown aura %u",
uint32(aura->GetAuraType()));
return;
}
SendMessageToSet(&data, true);
}
void Unit::SendSpellMiss(Unit *target, uint32 spellID, SpellMissInfo missInfo)
{
WorldPacket data(SMSG_SPELLLOGMISS, 4 + 8 + 1 + 4 + 8 + 1);
data << uint32(spellID);
data << uint64(GetGUID());
data << uint8(0); // can be 0 or 1
data << uint32(1); // target count
// for (i = 0; i < target count; ++i)
data << uint64(target->GetGUID()); // target GUID
data << uint8(missInfo);
// end loop
SendMessageToSet(&data, true);
}
void Unit::SendSpellDamageImmune(Unit * target, uint32 spellId)
{
WorldPacket data(SMSG_SPELLORDAMAGE_IMMUNE, 8 + 8 + 4 + 1);
data << uint64(GetGUID());
data << uint64(target->GetGUID());
data << uint32(spellId);
data << uint8(0); // bool - log format: 0-default, 1-debug
SendMessageToSet(&data, true);
}
void Unit::SendAttackStateUpdate(CalcDamageInfo *damageInfo)
{
sLog->outDebug(LOG_FILTER_UNITS, "WORLD: Sending SMSG_ATTACKERSTATEUPDATE");
uint32 count = 1;
size_t maxsize = 4 + 5 + 5 + 4 + 4 + 1 + 4 + 4 + 4 + 4 + 4 + 1 + 4 + 4 + 4
+ 4 + 4 * 12;
WorldPacket data(SMSG_ATTACKERSTATEUPDATE, maxsize); // we guess size
data << uint32(damageInfo->HitInfo);
data.append(damageInfo->attacker->GetPackGUID());
data.append(damageInfo->target->GetPackGUID());
data << uint32(damageInfo->damage); // Full damage
int32 overkill = damageInfo->damage - damageInfo->target->GetHealth();
data << uint32(overkill < 0 ? 0 : overkill); // Overkill
data << uint8(count); // Sub damage count
for (uint32 i = 0; i < count; ++i)
{
data << uint32(damageInfo->damageSchoolMask); // School of sub damage
data << float(damageInfo->damage); // sub damage
data << uint32(damageInfo->damage); // Sub Damage
}
if (damageInfo->HitInfo & (HITINFO_ABSORB | HITINFO_ABSORB2))
{
for (uint32 i = 0; i < count; ++i)
data << uint32(damageInfo->absorb); // Absorb
}
if (damageInfo->HitInfo & (HITINFO_RESIST | HITINFO_RESIST2))
{
for (uint32 i = 0; i < count; ++i)
data << uint32(damageInfo->resist); // Resist
}
data << uint8(damageInfo->TargetState);
data << uint32(0);
data << uint32(0);
if (damageInfo->HitInfo & HITINFO_BLOCK) data
<< uint32(damageInfo->blocked_amount);
if (damageInfo->HitInfo & HITINFO_UNK3) data << uint32(0);
if (damageInfo->HitInfo & HITINFO_UNK1)
{
data << uint32(0);
data << float(0);
data << float(0);
data << float(0);
data << float(0);
data << float(0);
data << float(0);
data << float(0);
data << float(0);
data << float(0); // Found in a loop with 1 iteration
data << float(0); // ditto ^
data << uint32(0);
}
SendMessageToSet(&data, true);
}
void Unit::SendAttackStateUpdate(uint32 HitInfo, Unit *target,
uint8 /*SwingType*/, SpellSchoolMask damageSchoolMask, uint32 Damage,
uint32 AbsorbDamage, uint32 Resist, VictimState TargetState,
uint32 BlockedAmount)
{
CalcDamageInfo dmgInfo;
dmgInfo.HitInfo = HitInfo;
dmgInfo.attacker = this;
dmgInfo.target = target;
dmgInfo.damage = Damage - AbsorbDamage - Resist - BlockedAmount;
dmgInfo.damageSchoolMask = damageSchoolMask;
dmgInfo.absorb = AbsorbDamage;
dmgInfo.resist = Resist;
dmgInfo.TargetState = TargetState;
dmgInfo.blocked_amount = BlockedAmount;
SendAttackStateUpdate(&dmgInfo);
}
bool Unit::HandleModPowerRegenAuraProc(Unit *pVictim, uint32 damage,
AuraEffect* triggeredByAura, SpellEntry const * /*procSpell*/,
uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const *hasteSpell = triggeredByAura->GetSpellProto();
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
uint32 triggered_spell_id = 0;
Unit* target = pVictim;
int32 basepoints0 = 0;
switch (hasteSpell->SpellFamilyName)
{
case SPELLFAMILY_ROGUE:
{
switch (hasteSpell->Id)
{
// Blade Flurry
case 13877:
//case 33735:
{
target = SelectNearbyTarget();
if (!target || target == pVictim) return false;
basepoints0 = damage;
triggered_spell_id = 22482;
break;
}
}
break;
}
}
// processed charge only counting case
if (!triggered_spell_id) return true;
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(
triggered_spell_id);
if (!triggerEntry)
{
sLog->outError(
"Unit::HandleHasteAuraProc: Spell %u have not existed triggered spell %u",
hasteSpell->Id, triggered_spell_id);
return false;
}
// default case
if ((!target && !sSpellMgr->IsSrcTargetSpell(triggerEntry))
|| (target && target != this && !target->isAlive())) return false;
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& this->ToPlayer()->HasSpellCooldown(triggered_spell_id)) return false;
if (basepoints0) CastCustomSpell(target, triggered_spell_id, &basepoints0,
NULL, NULL, true, castItem, triggeredByAura);
else CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura);
if (cooldown && target->GetTypeId() == TYPEID_PLAYER) target->ToPlayer()->AddSpellCooldown(
triggered_spell_id, 0, time(NULL) + cooldown);
return true;
}
bool Unit::HandleSpellCritChanceAuraProc(Unit *pVictim, uint32 /*damage*/,
AuraEffect* triggeredByAura, SpellEntry const * /*procSpell*/,
uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const *triggeredByAuraSpell = triggeredByAura->GetSpellProto();
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
uint32 triggered_spell_id = 0;
Unit* target = pVictim;
int32 basepoints0 = 0;
switch (triggeredByAuraSpell->SpellFamilyName)
{
case SPELLFAMILY_MAGE:
{
switch (triggeredByAuraSpell->Id)
{
// Focus Magic
case 54646:
{
Unit* caster = triggeredByAura->GetCaster();
if (!caster) return false;
triggered_spell_id = 54648;
target = caster;
break;
}
}
}
}
// processed charge only counting case
if (!triggered_spell_id) return true;
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(
triggered_spell_id);
if (!triggerEntry)
{
sLog->outError(
"Unit::HandleHasteAuraProc: Spell %u have not existed triggered spell %u",
triggeredByAuraSpell->Id, triggered_spell_id);
return false;
}
// default case
if (!target || (target != this && !target->isAlive())) return false;
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& this->ToPlayer()->HasSpellCooldown(triggered_spell_id)) return false;
if (basepoints0) CastCustomSpell(target, triggered_spell_id, &basepoints0,
NULL, NULL, true, castItem, triggeredByAura);
else CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->AddSpellCooldown(
triggered_spell_id, 0, time(NULL) + cooldown);
return true;
}
bool Unit::HandleDummyAuraProc(Unit *pVictim, uint32 damage,
AuraEffect* triggeredByAura, SpellEntry const * procSpell,
uint32 procFlag, uint32 procEx, uint32 cooldown)
{
SpellEntry const *dummySpell = triggeredByAura->GetSpellProto();
uint32 effIndex = triggeredByAura->GetEffIndex();
int32 triggerAmount = triggeredByAura->GetAmount();
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
uint32 triggered_spell_id = 0;
uint32 cooldown_spell_id = 0; // for random trigger, will be one of the triggered spell to avoid repeatable triggers
// otherwise, it's the triggered_spell_id by default
Unit* target = pVictim;
int32 basepoints0 = 0;
uint64 originalCaster = 0;
switch (dummySpell->SpellFamilyName)
{
case SPELLFAMILY_GENERIC:
{
switch (dummySpell->Id)
{
// Bloodworms Health Leech
case 50453:
{
if (Unit *owner = this->GetOwner())
{
basepoints0 = int32(damage * 1.50);
target = owner;
triggered_spell_id = 50454;
break;
}
return false;
}
// Eye for an Eye
case 9799:
case 25988:
{
// return damage % to attacker but < 50% own total health
basepoints0 = int32((triggerAmount * damage) / 100);
int32 halfMaxHealth = int32(CountPctFromMaxHealth(50));
if (basepoints0 > halfMaxHealth) basepoints0 =
halfMaxHealth;
triggered_spell_id = 25997;
break;
}
// Sweeping Strikes
case 18765:
case 35429:
{
target = SelectNearbyTarget();
if (!target) return false;
triggered_spell_id = 26654;
break;
}
// Unstable Power
case 24658:
{
if (!procSpell || procSpell->Id == 24659) return false;
// Need remove one 24659 aura
RemoveAuraFromStack(24659);
return true;
}
// Restless Strength
case 24661:
{
// Need remove one 24662 aura
RemoveAuraFromStack(24662);
return true;
}
// Adaptive Warding (Frostfire Regalia set)
case 28764:
{
if (!procSpell) return false;
// find Mage Armor
if (!GetAuraEffect(SPELL_AURA_MOD_MANA_REGEN_INTERRUPT,
SPELLFAMILY_MAGE, 0x10000000, 0, 0)) return false;
switch (GetFirstSchoolInMask(GetSpellSchoolMask(procSpell)))
{
case SPELL_SCHOOL_NORMAL:
case SPELL_SCHOOL_HOLY:
return false; // ignored
case SPELL_SCHOOL_FIRE:
triggered_spell_id = 28765;
break;
case SPELL_SCHOOL_NATURE:
triggered_spell_id = 28768;
break;
case SPELL_SCHOOL_FROST:
triggered_spell_id = 28766;
break;
case SPELL_SCHOOL_SHADOW:
triggered_spell_id = 28769;
break;
case SPELL_SCHOOL_ARCANE:
triggered_spell_id = 28770;
break;
default:
return false;
}
target = this;
break;
}
// Obsidian Armor (Justice Bearer`s Pauldrons shoulder)
case 27539:
{
if (!procSpell) return false;
switch (GetFirstSchoolInMask(GetSpellSchoolMask(procSpell)))
{
case SPELL_SCHOOL_NORMAL:
return false; // ignore
case SPELL_SCHOOL_HOLY:
triggered_spell_id = 27536;
break;
case SPELL_SCHOOL_FIRE:
triggered_spell_id = 27533;
break;
case SPELL_SCHOOL_NATURE:
triggered_spell_id = 27538;
break;
case SPELL_SCHOOL_FROST:
triggered_spell_id = 27534;
break;
case SPELL_SCHOOL_SHADOW:
triggered_spell_id = 27535;
break;
case SPELL_SCHOOL_ARCANE:
triggered_spell_id = 27540;
break;
default:
return false;
}
target = this;
break;
}
// Mana Leech (Passive) (Priest Pet Aura)
case 28305:
{
// Cast on owner
target = GetOwner();
if (!target) return false;
triggered_spell_id = 34650;
break;
}
// Mark of Malice
case 33493:
{
// Cast finish spell at last charge
if (triggeredByAura->GetBase()->GetCharges() > 1) return false;
target = this;
triggered_spell_id = 33494;
break;
}
// Twisted Reflection (boss spell)
case 21063:
triggered_spell_id = 21064;
break;
// Vampiric Aura (boss spell)
case 38196:
{
basepoints0 = 3 * damage; // 300%
if (basepoints0 < 0) return false;
triggered_spell_id = 31285;
target = this;
break;
}
// Aura of Madness (Darkmoon Card: Madness trinket)
//=====================================================
// 39511 Sociopath: +35 strength (Paladin, Rogue, Druid, Warrior)
// 40997 Delusional: +70 attack power (Rogue, Hunter, Paladin, Warrior, Druid)
// 40998 Kleptomania: +35 agility (Warrior, Rogue, Paladin, Hunter, Druid)
// 40999 Megalomania: +41 damage/healing (Druid, Shaman, Priest, Warlock, Mage, Paladin)
// 41002 Paranoia: +35 spell/melee/ranged crit strike rating (All classes)
// 41005 Manic: +35 haste (spell, melee and ranged) (All classes)
// 41009 Narcissism: +35 intellect (Druid, Shaman, Priest, Warlock, Mage, Paladin, Hunter)
// 41011 Martyr Complex: +35 stamina (All classes)
// 41406 Dementia: Every 5 seconds either gives you +5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
// 41409 Dementia: Every 5 seconds either gives you -5% damage/healing. (Druid, Shaman, Priest, Warlock, Mage, Paladin)
case 39446:
{
if (GetTypeId() != TYPEID_PLAYER || !this->isAlive()) return false;
// Select class defined buff
switch (getClass())
{
case CLASS_PALADIN: // 39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409
case CLASS_DRUID: // 39511, 40997, 40998, 40999, 41002, 41005, 41009, 41011, 41409
triggered_spell_id = RAND(39511, 40997, 40998,
40999, 41002, 41005, 41009, 41011, 41409);
cooldown_spell_id = 39511;
break;
case CLASS_ROGUE: // 39511, 40997, 40998, 41002, 41005, 41011
case CLASS_WARRIOR: // 39511, 40997, 40998, 41002, 41005, 41011
triggered_spell_id = RAND(39511, 40997, 40998,
41002, 41005, 41011);
cooldown_spell_id = 39511;
break;
case CLASS_PRIEST: // 40999, 41002, 41005, 41009, 41011, 41406, 41409
case CLASS_SHAMAN: // 40999, 41002, 41005, 41009, 41011, 41406, 41409
case CLASS_MAGE: // 40999, 41002, 41005, 41009, 41011, 41406, 41409
case CLASS_WARLOCK: // 40999, 41002, 41005, 41009, 41011, 41406, 41409
triggered_spell_id = RAND(40999, 41002, 41005,
41009, 41011, 41406, 41409);
cooldown_spell_id = 40999;
break;
case CLASS_HUNTER: // 40997, 40999, 41002, 41005, 41009, 41011, 41406, 41409
triggered_spell_id = RAND(40997, 40999, 41002,
41005, 41009, 41011, 41406, 41409);
cooldown_spell_id = 40997;
break;
default:
return false;
}
target = this;
if (roll_chance_i(10)) this->ToPlayer()->Say(
"This is Madness!", LANG_UNIVERSAL); // TODO: It should be moved to database, shouldn't it?
break;
}
// Sunwell Exalted Caster Neck (??? neck)
// cast ??? Light's Wrath if Exalted by Aldor
// cast ??? Arcane Bolt if Exalted by Scryers
case 46569:
return false; // old unused version
// Sunwell Exalted Caster Neck (Shattered Sun Pendant of Acumen neck)
// cast 45479 Light's Wrath if Exalted by Aldor
// cast 45429 Arcane Bolt if Exalted by Scryers
case 45481:
{
if (GetTypeId() != TYPEID_PLAYER) return false;
// Get Aldor reputation rank
if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
{
target = this;
triggered_spell_id = 45479;
break;
}
// Get Scryers reputation rank
if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
{
// triggered at positive/self casts also, current attack target used then
if (IsFriendlyTo(target))
{
target = getVictim();
if (!target)
{
uint64 selected_guid =
ToPlayer()->GetSelection();
target = ObjectAccessor::GetUnit(*this,
selected_guid);
if (!target) return false;
}
if (IsFriendlyTo(target)) return false;
}
triggered_spell_id = 45429;
break;
}
return false;
}
// Sunwell Exalted Melee Neck (Shattered Sun Pendant of Might neck)
// cast 45480 Light's Strength if Exalted by Aldor
// cast 45428 Arcane Strike if Exalted by Scryers
case 45482:
{
if (GetTypeId() != TYPEID_PLAYER) return false;
// Get Aldor reputation rank
if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
{
target = this;
triggered_spell_id = 45480;
break;
}
// Get Scryers reputation rank
if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
{
triggered_spell_id = 45428;
break;
}
return false;
}
// Sunwell Exalted Tank Neck (Shattered Sun Pendant of Resolve neck)
// cast 45431 Arcane Insight if Exalted by Aldor
// cast 45432 Light's Ward if Exalted by Scryers
case 45483:
{
if (GetTypeId() != TYPEID_PLAYER) return false;
// Get Aldor reputation rank
if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
{
target = this;
triggered_spell_id = 45432;
break;
}
// Get Scryers reputation rank
if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
{
target = this;
triggered_spell_id = 45431;
break;
}
return false;
}
// Sunwell Exalted Healer Neck (Shattered Sun Pendant of Restoration neck)
// cast 45478 Light's Salvation if Exalted by Aldor
// cast 45430 Arcane Surge if Exalted by Scryers
case 45484:
{
if (GetTypeId() != TYPEID_PLAYER) return false;
// Get Aldor reputation rank
if (ToPlayer()->GetReputationRank(932) == REP_EXALTED)
{
target = this;
triggered_spell_id = 45478;
break;
}
// Get Scryers reputation rank
if (ToPlayer()->GetReputationRank(934) == REP_EXALTED)
{
triggered_spell_id = 45430;
break;
}
return false;
}
// Living Seed
case 48504:
{
triggered_spell_id = 48503;
basepoints0 = triggerAmount;
target = this;
break;
}
// Kill command
case 58914:
{
// Remove aura stack from pet
RemoveAuraFromStack(58914);
Unit* owner = GetOwner();
if (!owner) return true;
// reduce the owner's aura stack
owner->RemoveAuraFromStack(34027);
return true;
}
// Vampiric Touch (generic, used by some boss)
case 52723:
case 60501:
{
triggered_spell_id = 52724;
basepoints0 = damage / 2;
target = this;
break;
}
// Shadowfiend Death (Gain mana if pet dies with Glyph of Shadowfiend)
case 57989:
{
Unit *owner = GetOwner();
if (!owner || owner->GetTypeId() != TYPEID_PLAYER) return false;
// Glyph of Shadowfiend (need cast as self cast for owner, no hidden cooldown)
owner->CastSpell(owner, 58227, true, castItem,
triggeredByAura);
return true;
}
// Glyph of Life Tap
case 63320:
{
triggered_spell_id = 63321; // Life Tap
break;
}
case 71519: // Deathbringer's Will Normal
{
if (GetTypeId() != TYPEID_PLAYER) return false;
std::vector <uint32> RandomSpells;
switch (getClass())
{
case CLASS_WARRIOR:
case CLASS_PALADIN:
case CLASS_DEATH_KNIGHT:
RandomSpells.push_back(71484);
RandomSpells.push_back(71491);
RandomSpells.push_back(71492);
break;
case CLASS_SHAMAN:
case CLASS_ROGUE:
RandomSpells.push_back(71486);
RandomSpells.push_back(71485);
RandomSpells.push_back(71492);
break;
case CLASS_DRUID:
RandomSpells.push_back(71484);
RandomSpells.push_back(71485);
RandomSpells.push_back(71486);
break;
case CLASS_HUNTER:
RandomSpells.push_back(71486);
RandomSpells.push_back(71491);
RandomSpells.push_back(71485);
break;
default:
return false;
}
if (RandomSpells.empty()) //shouldn't happen
return false;
uint8 rand_spell = irand(0, (RandomSpells.size() - 1));
CastSpell(target, RandomSpells [rand_spell], true, castItem,
triggeredByAura, originalCaster);
for (std::vector <uint32>::iterator itr =
RandomSpells.begin(); itr != RandomSpells.end();
++itr)
{
if (!ToPlayer()->HasSpellCooldown(*itr)) ToPlayer()->AddSpellCooldown(
*itr, 0, time(NULL) + cooldown);
}
break;
}
case 71562: // Deathbringer's Will Heroic
{
if (GetTypeId() != TYPEID_PLAYER) return false;
std::vector <uint32> RandomSpells;
switch (getClass())
{
case CLASS_WARRIOR:
case CLASS_PALADIN:
case CLASS_DEATH_KNIGHT:
RandomSpells.push_back(71561);
RandomSpells.push_back(71559);
RandomSpells.push_back(71560);
break;
case CLASS_SHAMAN:
case CLASS_ROGUE:
RandomSpells.push_back(71558);
RandomSpells.push_back(71556);
RandomSpells.push_back(71560);
break;
case CLASS_DRUID:
RandomSpells.push_back(71561);
RandomSpells.push_back(71556);
RandomSpells.push_back(71558);
break;
case CLASS_HUNTER:
RandomSpells.push_back(71558);
RandomSpells.push_back(71559);
RandomSpells.push_back(71556);
break;
default:
return false;
}
if (RandomSpells.empty()) //shouldn't happen
return false;
uint8 rand_spell = irand(0, (RandomSpells.size() - 1));
CastSpell(target, RandomSpells [rand_spell], true, castItem,
triggeredByAura, originalCaster);
for (std::vector <uint32>::iterator itr =
RandomSpells.begin(); itr != RandomSpells.end();
++itr)
{
if (!ToPlayer()->HasSpellCooldown(*itr)) ToPlayer()->AddSpellCooldown(
*itr, 0, time(NULL) + cooldown);
}
break;
}
// Item - Shadowmourne Legendary
case 71903:
{
if (!pVictim || !pVictim->isAlive() || HasAura(73422)) // cant collect shards while under effect of Chaos Bane buff
return false;
CastSpell(this, 71905, true, NULL, triggeredByAura);
// this can't be handled in AuraScript because we need to know pVictim
Aura const* dummy = GetAura(71905);
if (!dummy || dummy->GetStackAmount() < 10) return false;
RemoveAurasDueToSpell(71905);
triggered_spell_id = 71904;
target = pVictim;
break;
}
// Shadow's Fate (Shadowmourne questline)
case 71169:
{
target = triggeredByAura->GetCaster();
Player* player = target->ToPlayer();
if (!player) return false;
// not checking Infusion auras because its in targetAuraSpell of credit spell
if (player->GetQuestStatus(24749)
== QUEST_STATUS_INCOMPLETE) // Unholy Infusion
{
if (GetEntry() != 36678) // Professor Putricide
return false;
CastSpell(target, 71518, true); // Quest Credit
return true;
}
else if (player->GetQuestStatus(24756)
== QUEST_STATUS_INCOMPLETE) // Blood Infusion
{
if (GetEntry() != 37955) // Blood-Queen Lana'thel
return false;
CastSpell(target, 72934, true); // Quest Credit
return true;
}
else if (player->GetQuestStatus(24757)
== QUEST_STATUS_INCOMPLETE) // Frost Infusion
{
if (GetEntry() != 36853) // Sindragosa
return false;
CastSpell(target, 72289, true); // Quest Credit
return true;
}
else if (player->GetQuestStatus(24547)
== QUEST_STATUS_INCOMPLETE) // A Feast of Souls
triggered_spell_id = 71203;
break;
}
// Gaseous Bloat (Professor Putricide add)
case 70215:
case 72858:
case 72859:
case 72860:
{
target = getVictim();
triggered_spell_id = 70701;
break;
}
// Item - Icecrown 25 Normal Heartpiece
case 71880:
{
switch (getPowerType())
{
case POWER_MANA:
triggered_spell_id = 71881;
break;
case POWER_RAGE:
triggered_spell_id = 71883;
break;
case POWER_ENERGY:
triggered_spell_id = 71882;
break;
case POWER_RUNIC_POWER:
triggered_spell_id = 71884;
break;
default:
return false;
}
break;
}
// Item - Icecrown 25 Heroic Heartpiece
case 71892:
{
switch (getPowerType())
{
case POWER_MANA:
triggered_spell_id = 71888;
break;
case POWER_RAGE:
triggered_spell_id = 71886;
break;
case POWER_ENERGY:
triggered_spell_id = 71887;
break;
case POWER_RUNIC_POWER:
triggered_spell_id = 71885;
break;
default:
return false;
}
break;
}
}
break;
}
case SPELLFAMILY_MAGE:
{
// Magic Absorption
if (dummySpell->SpellIconID == 459) // only this spell have SpellIconID == 459 and dummy aura
{
if (getPowerType() != POWER_MANA) return false;
// mana reward
basepoints0 = (triggerAmount * GetMaxPower(POWER_MANA) / 100);
target = this;
triggered_spell_id = 29442;
break;
}
// Master of Elements
if (dummySpell->SpellIconID == 1920)
{
if (!procSpell) return false;
// mana cost save
int32 cost = procSpell->manaCost
+ procSpell->ManaCostPercentage * GetCreateMana() / 100;
basepoints0 = cost * triggerAmount / 100;
if (basepoints0 <= 0) return false;
target = this;
triggered_spell_id = 29077;
break;
}
// Arcane Potency
if (dummySpell->SpellIconID == 2120)
{
if (!procSpell) return false;
target = this;
switch (dummySpell->Id)
{
case 31571:
triggered_spell_id = 57529;
break;
case 31572:
triggered_spell_id = 57531;
break;
default:
sLog->outError(
"Unit::HandleDummyAuraProc: non handled spell id: %u",
dummySpell->Id);
return false;
}
break;
}
// Hot Streak
if (dummySpell->SpellIconID == 2999)
{
if (effIndex != 0) return false;
AuraEffect *counter = triggeredByAura->GetBase()->GetEffect(1);
if (!counter) return true;
// Count spell criticals in a row in second aura
if (procEx & PROC_EX_CRITICAL_HIT)
{
counter->SetAmount(counter->GetAmount() * 2);
if (counter->GetAmount() < 100) // not enough
return true;
// Crititcal counted -> roll chance
if (roll_chance_i(triggerAmount)) CastSpell(this, 48108,
true, castItem, triggeredByAura);
}
counter->SetAmount(25);
return true;
}
// Burnout
if (dummySpell->SpellIconID == 2998)
{
if (!procSpell) return false;
int32 cost = procSpell->manaCost
+ procSpell->ManaCostPercentage * GetCreateMana() / 100;
basepoints0 = cost * triggerAmount / 100;
if (basepoints0 <= 0) return false;
triggered_spell_id = 44450;
target = this;
break;
}
// Incanter's Regalia set (add trigger chance to Mana Shield)
if (dummySpell->SpellFamilyFlags [0] & 0x8000)
{
if (GetTypeId() != TYPEID_PLAYER) return false;
target = this;
triggered_spell_id = 37436;
break;
}
switch (dummySpell->Id)
{
//Nether Vortex
case 86181:
case 86209:
{
AuraMap const &slowAura = GetOwnedAuras();
for (Unit::AuraMap::const_iterator itr = slowAura.begin();
itr != slowAura.end();)
if ((*itr).second->GetId() == 31589) // Found Slow, dont proc
break;
else itr++;
target = this;
triggered_spell_id = 86262;
if (pVictim) CastSpell(pVictim, 31589, false);
break;
}
// Glyph of Polymorph
case 56375:
{
if (!target) return false;
target->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE, 0,
target->GetAura(32409)); // SW:D shall not be removed.
target->RemoveAurasByType(
SPELL_AURA_PERIODIC_DAMAGE_PERCENT);
target->RemoveAurasByType(SPELL_AURA_PERIODIC_LEECH);
return true;
}
// Glyph of Icy Veins
case 56374:
{
RemoveAurasByType(SPELL_AURA_HASTE_SPELLS, 0, 0, true,
false);
RemoveAurasByType(SPELL_AURA_MOD_DECREASE_SPEED);
return true;
}
// Ignite
case 11119:
case 11120:
case 12846:
case 12847:
case 12848:
{
switch (dummySpell->Id)
{
case 11119:
basepoints0 = int32(0.04f * damage);
break;
case 11120:
basepoints0 = int32(0.08f * damage);
break;
case 12846:
basepoints0 = int32(0.12f * damage);
break;
case 12847:
basepoints0 = int32(0.16f * damage);
break;
case 12848:
basepoints0 = int32(0.20f * damage);
break;
default:
sLog->outError(
"Unit::HandleDummyAuraProc: non handled spell id: %u (IG)",
dummySpell->Id);
return false;
}
triggered_spell_id = 12654;
basepoints0 += pVictim->GetRemainingDotDamage(GetGUID(),
triggered_spell_id);
break;
}
// Glyph of Ice Block
case 56372:
{
if (GetTypeId() != TYPEID_PLAYER) return false;
SpellCooldowns const cooldowns =
this->ToPlayer()->GetSpellCooldowns();
// remove cooldowns on all ranks of Frost Nova
for (SpellCooldowns::const_iterator itr = cooldowns.begin();
itr != cooldowns.end(); ++itr)
{
SpellEntry const* cdSpell = sSpellStore.LookupEntry(
itr->first);
// Frost Nova
if (cdSpell
&& cdSpell->SpellFamilyName == SPELLFAMILY_MAGE
&& cdSpell->SpellFamilyFlags [0] & 0x00000040) this->ToPlayer()->RemoveSpellCooldown(
cdSpell->Id, true);
}
break;
}
}
break;
}
// Blessing of Ancient Kings (Val'anyr, Hammer of Ancient Kings)
case 64411:
{
if (!pVictim) return false;
basepoints0 = int32(CalculatePctN(damage, 15));
if (AuraEffect* aurEff = pVictim->GetAuraEffect(64413, 0, GetGUID()))
{
// The shield can grow to a maximum size of 20, 000 damage absorbtion
aurEff->SetAmount(
std::max < int32
> (aurEff->GetAmount() + basepoints0, 20000));
// Refresh and return to prevent replacing the aura
aurEff->GetBase()->RefreshDuration();
return true;
}
target = pVictim;
triggered_spell_id = 64413;
break;
}
case SPELLFAMILY_WARRIOR:
{
switch (dummySpell->Id)
{
// Sweeping Strikes
case 12328:
{
target = SelectNearbyTarget();
if (!target) return false;
triggered_spell_id = 26654;
break;
}
// Victorious
case 32216:
{
RemoveAura(dummySpell->Id);
return false;
}
// Improved Spell Reflection
case 59088:
case 59089:
{
triggered_spell_id = 59725;
target = this;
break;
}
}
// Retaliation
if (dummySpell->SpellFamilyFlags [1] & 0x8)
{
// check attack comes not from behind
if (!HasInArc(M_PI, pVictim)) return false;
triggered_spell_id = 22858;
break;
}
// Second Wind
if (dummySpell->SpellIconID == 1697)
{
// only for spells and hit/crit (trigger start always) and not start from self casted spells (5530 Mace Stun Effect for example)
if (procSpell == 0
|| !(procEx
& (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT))
|| this == pVictim) return false;
// Need stun or root mechanic
if (!(GetAllSpellMechanicMask(procSpell)
& ((1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN)))) return false;
switch (dummySpell->Id)
{
case 29838:
triggered_spell_id = 29842;
break;
case 29834:
triggered_spell_id = 29841;
break;
case 42770:
triggered_spell_id = 42771;
break;
default:
sLog->outError(
"Unit::HandleDummyAuraProc: non handled spell id: %u (SW)",
dummySpell->Id);
return false;
}
target = this;
break;
}
/* // Damage Shield
if (dummySpell->SpellIconID == 3214)
{
triggered_spell_id = 59653;
// % of amount blocked
basepoints0 = GetShieldBlockValue() * triggerAmount / 100;
break;
}*/
// Glyph of Blocking
if (dummySpell->Id == 58375)
{
triggered_spell_id = 58374;
break;
}
// Glyph of Sunder Armor
if (dummySpell->Id == 58387)
{
if (!pVictim || !pVictim->isAlive() || !procSpell) return false;
target = SelectNearbyTarget();
if (!target || target == pVictim) return false;
CastSpell(target, 58567, true);
return true;
}
break;
}
case SPELLFAMILY_WARLOCK:
{
// Seed of Corruption
if (dummySpell->SpellFamilyFlags [1] & 0x00000010)
{
if (procSpell && procSpell->SpellFamilyFlags [1] & 0x8000) return false;
// if damage is more than need or target die from damage deal finish spell
if (triggeredByAura->GetAmount() <= int32(damage)
|| GetHealth() <= damage)
{
// remember guid before aura delete
uint64 casterGuid = triggeredByAura->GetCasterGUID();
// Remove aura (before cast for prevent infinite loop handlers)
RemoveAurasDueToSpell(triggeredByAura->GetId());
uint32 spell = sSpellMgr->GetSpellWithRank(27285,
sSpellMgr->GetSpellRank(dummySpell->Id));
// Cast finish spell (triggeredByAura already not exist!)
if (Unit* caster = GetUnit(*this, casterGuid)) caster->CastSpell(
this, spell, true, castItem);
return true; // no hidden cooldown
}
// Damage counting
triggeredByAura->SetAmount(
triggeredByAura->GetAmount() - damage);
return true;
}
// Seed of Corruption (Mobs cast) - no die req
if (dummySpell->SpellFamilyFlags.IsEqual(0, 0, 0)
&& dummySpell->SpellIconID == 1932)
{
// if damage is more than need deal finish spell
if (triggeredByAura->GetAmount() <= int32(damage))
{
// remember guid before aura delete
uint64 casterGuid = triggeredByAura->GetCasterGUID();
// Remove aura (before cast for prevent infinite loop handlers)
RemoveAurasDueToSpell(triggeredByAura->GetId());
// Cast finish spell (triggeredByAura already not exist!)
if (Unit* caster = GetUnit(*this, casterGuid)) caster->CastSpell(
this, 32865, true, castItem);
return true; // no hidden cooldown
}
// Damage counting
triggeredByAura->SetAmount(
triggeredByAura->GetAmount() - damage);
return true;
}
// Fel Synergy
if (dummySpell->SpellIconID == 3222)
{
target = GetGuardianPet();
if (!target) return false;
basepoints0 = damage * triggerAmount / 100;
triggered_spell_id = 54181;
break;
}
switch (dummySpell->Id)
{
// Siphon Life
case 63108:
{
// Glyph of Siphon Life
if (HasAura(56216)) triggerAmount += triggerAmount / 4;
triggered_spell_id = 63106;
target = this;
basepoints0 = int32(damage * triggerAmount / 100);
break;
}
// Glyph of Shadowflame
case 63310:
{
triggered_spell_id = 63311;
break;
}
// Nightfall
case 18094:
case 18095:
// Glyph of corruption
case 56218:
{
target = this;
triggered_spell_id = 17941;
break;
}
//Soul Leech
case 30293:
case 30295:
case 30296:
{
// Improved Soul Leech
AuraEffectList const& SoulLeechAuras = GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (Unit::AuraEffectList::const_iterator i =
SoulLeechAuras.begin(); i != SoulLeechAuras.end();
++i)
{
if ((*i)->GetId() == 54117 || (*i)->GetId() == 54118)
{
if ((*i)->GetEffIndex() != 0) continue;
basepoints0 = int32((*i)->GetAmount());
target = GetGuardianPet();
if (target)
{
// regen mana for pet
CastCustomSpell(target, 54607, &basepoints0,
NULL, NULL, true, castItem,
triggeredByAura);
}
// regen mana for caster
CastCustomSpell(this, 59117, &basepoints0, NULL,
NULL, true, castItem, triggeredByAura);
// Get second aura of spell for replenishment effect on party
if (AuraEffect const * aurEff = (*i)->GetBase()->GetEffect(1))
{
// Replenishment - roll chance
if (roll_chance_i(aurEff->GetAmount()))
{
CastSpell(this, 57669, true, castItem,
triggeredByAura);
}
}
break;
}
}
// health
basepoints0 = int32(GetHealth() * triggerAmount / 100);
target = this;
triggered_spell_id = 30294;
break;
}
// Shadowflame (Voidheart Raiment set bonus)
case 37377:
{
triggered_spell_id = 37379;
break;
}
// Pet Healing (Corruptor Raiment or Rift Stalker Armor)
case 37381:
{
target = GetGuardianPet();
if (!target) return false;
// heal amount
basepoints0 = damage * triggerAmount / 100;
triggered_spell_id = 37382;
break;
}
// Shadowflame Hellfire (Voidheart Raiment set bonus)
case 39437:
{
triggered_spell_id = 37378;
break;
}
// Fel Armor
case 28176:
{
basepoints0 = int32(damage * triggerAmount / 100);
triggered_spell_id = 96379;
break;
}
}
break;
}
case SPELLFAMILY_PRIEST:
{
// Vampiric Touch
if (dummySpell->SpellFamilyFlags [1] & 0x00000400)
{
if (!pVictim || !pVictim->isAlive()) return false;
if (effIndex != 0) return false;
// pVictim is caster of aura
if (triggeredByAura->GetCasterGUID() != pVictim->GetGUID()) return false;
// Energize 0.25% of max. mana
pVictim->CastSpell(pVictim, 57669, true, castItem,
triggeredByAura);
return true; // no hidden cooldown
}
// Divine Aegis
if (dummySpell->SpellIconID == 2820)
{
if (!target) return false;
// Multiple effects stack, so let's try to find this aura.
int32 bonus = 0;
if (AuraEffect *aurEff = target->GetAuraEffect(47753, 0)) bonus =
aurEff->GetAmount();
basepoints0 = damage * triggerAmount / 100 + bonus;
if (basepoints0 > target->getLevel() * 125) basepoints0 =
target->getLevel() * 125;
triggered_spell_id = 47753;
break;
}
// Body and Soul
if (dummySpell->SpellIconID == 2218)
{
// Proc only from Abolish desease on self cast
if (procSpell->Id != 552 || pVictim != this
|| !roll_chance_i(triggerAmount)) return false;
triggered_spell_id = 64136;
target = this;
break;
}
switch (dummySpell->Id)
{
// Vampiric Embrace
case 15286:
{
if (!pVictim || !pVictim->isAlive()
|| procSpell->SpellFamilyFlags [1] & 0x80000) return false;
// heal amount
int32 team = triggerAmount * damage / 500;
int32 self = triggerAmount * damage / 100 - team;
CastCustomSpell(this, 15290, &team, &self, NULL, true,
castItem, triggeredByAura);
return true; // no hidden cooldown
}
// Priest Tier 6 Trinket (Ashtongue Talisman of Acumen)
case 40438:
{
// Shadow Word: Pain
if (procSpell->SpellFamilyFlags [0] & 0x8000) triggered_spell_id =
40441;
// Renew
else if (procSpell->SpellFamilyFlags [0] & 0x40) triggered_spell_id =
40440;
else return false;
target = this;
break;
}
// Glyph of Prayer of Healing
case 55680:
{
triggered_spell_id = 56161;
SpellEntry const* GoPoH = sSpellStore.LookupEntry(
triggered_spell_id);
if (!GoPoH) return false;
int EffIndex = 0;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
{
if (GoPoH->Effect [i] == SPELL_EFFECT_APPLY_AURA)
{
EffIndex = i;
break;
}
}
int32 tickcount = GetSpellMaxDuration(GoPoH)
/ GoPoH->EffectAmplitude [EffIndex];
if (!tickcount) return false;
basepoints0 = damage * triggerAmount / tickcount / 100;
break;
}
// Improved Shadowform
case 47570:
case 47569:
{
if (!roll_chance_i(triggerAmount)) return false;
RemoveMovementImpairingAuras();
break;
}
// Glyph of Dispel Magic
case 55677:
{
// Dispel Magic shares spellfamilyflag with abolish disease
if (procSpell->SpellIconID != 74) return false;
if (!target || !target->IsFriendlyTo(this)) return false;
basepoints0 = int32(
target->CountPctFromMaxHealth(triggerAmount));
triggered_spell_id = 56131;
break;
}
// Oracle Healing Bonus ("Garments of the Oracle" set)
case 26169:
{
// heal amount
basepoints0 = int32(damage * 10 / 100);
target = this;
triggered_spell_id = 26170;
break;
}
// Frozen Shadoweave (Shadow's Embrace set) warning! its not only priest set
case 39372:
{
if (!procSpell
|| (GetSpellSchoolMask(procSpell)
& (SPELL_SCHOOL_MASK_FROST
| SPELL_SCHOOL_MASK_SHADOW)) == 0) return false;
// heal amount
basepoints0 = damage * triggerAmount / 100;
target = this;
triggered_spell_id = 39373;
break;
}
// Greater Heal (Vestments of Faith (Priest Tier 3) - 4 pieces bonus)
case 28809:
{
triggered_spell_id = 28810;
break;
}
// Priest T10 Healer 2P Bonus
case 70770:
{
// Flash Heal
if (procSpell->SpellFamilyFlags [0] & 0x800)
{
triggered_spell_id = 70772;
SpellEntry const* blessHealing =
sSpellStore.LookupEntry(triggered_spell_id);
if (!blessHealing) return false;
basepoints0 =
int32(
triggerAmount * damage / 100
/ (GetSpellMaxDuration(
blessHealing)
/ blessHealing->EffectAmplitude [0]));
}
break;
}
//Mind Melt
case 87160:
case 81292:
{
if (procSpell->Id != 73510) return false;
break;
}
// Atonement
case 14523:
case 81749:
{
basepoints0 = int32(CalculatePctN(damage, triggerAmount));
triggered_spell_id = 81751;
target = this;
break;
}
// Train of Thought
case 92295:
case 92297:
if (procSpell->Id == 585)
{
if (Player* caster = triggeredByAura->GetCaster()->ToPlayer())
{
if (caster->HasSpellCooldown(47540))
{
uint32 newCooldownDelay = caster->GetSpellCooldownDelay(47540);
if (newCooldownDelay <= 0.5)
newCooldownDelay = 0;
else
newCooldownDelay -= 0.5;
caster->AddSpellCooldown(47540, 0, uint32(time(NULL) + newCooldownDelay));
WorldPacket data(SMSG_MODIFY_COOLDOWN, 4 + 8 + 4);
data << uint32(47540);
data << uint64(caster->GetGUID());
data << int32(-500);
caster->GetSession()->SendPacket(&data);
}
}
}
if (procSpell->Id == 2060)
{
if (Player* caster = triggeredByAura->GetCaster()->ToPlayer())
{
if (caster->HasSpellCooldown(89485))
{
uint32 newCooldownDelay = caster->GetSpellCooldownDelay(89485);
if (newCooldownDelay <= 5)
newCooldownDelay = 0;
else
newCooldownDelay -= 5;
caster->AddSpellCooldown(89485, 0, uint32(time(NULL) + newCooldownDelay));
WorldPacket data(SMSG_MODIFY_COOLDOWN, 4 + 8 + 4);
data << uint32(89485); // Spell ID
data << uint64(caster->GetGUID()); // Player GUID
data << int32(-5000); // Cooldown mod in milliseconds
caster->GetSession()->SendPacket(&data);
}
}
}
break;
}
break;
}
case SPELLFAMILY_DRUID:
{
switch (dummySpell->Id)
{
// Glyph of Innervate
case 54832:
{
if (procSpell->SpellIconID != 62) return false;
int32 mana_perc = SpellMgr::CalculateSpellEffectAmount(
triggeredByAura->GetSpellProto(),
triggeredByAura->GetEffIndex());
basepoints0 = uint32(
(GetCreatePowers(POWER_MANA) * mana_perc / 100)
/ 10);
triggered_spell_id = 54833;
target = this;
break;
}
// Glyph of Starfire
case 54845:
{
triggered_spell_id = 54846;
break;
}
// Glyph of Shred
case 54815:
{
if (!target) return false;
// try to find spell Rip on the target
if (AuraEffect const *AurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_DRUID, 0x00800000, 0x0, 0x0, GetGUID()))
{
// Rip's max duration, note: spells which modifies Rip's duration also counted like Glyph of Rip
uint32 CountMin = AurEff->GetBase()->GetMaxDuration();
// just Rip's max duration without other spells
uint32 CountMax = GetSpellMaxDuration(
AurEff->GetSpellProto());
// add possible auras' and Glyph of Shred's max duration
CountMax += 3 * triggerAmount * 1000; // Glyph of Shred -> +6 seconds
CountMax += HasAura(54818) ? 4 * 1000 : 0; // Glyph of Rip -> +4 seconds
CountMax += HasAura(60141) ? 4 * 1000 : 0; // Rip Duration/Lacerate Damage -> +4 seconds
// if min < max -> that means caster didn't cast 3 shred yet
// so set Rip's duration and max duration
if (CountMin < CountMax)
{
AurEff->GetBase()->SetDuration(
AurEff->GetBase()->GetDuration()
+ triggerAmount * 1000);
AurEff->GetBase()->SetMaxDuration(
CountMin + triggerAmount * 1000);
return true;
}
}
// if not found Rip
return false;
}
// Glyph of Rake
case 54821:
{
if (procSpell->SpellVisual [0] == 750
&& procSpell->EffectApplyAuraName [1] == 3)
{
if (target && target->GetTypeId() == TYPEID_UNIT)
{
triggered_spell_id = 54820;
break;
}
}
return false;
}
// Leader of the Pack
case 24932:
{
if (triggerAmount <= 0) return false;
basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
target = this;
triggered_spell_id = 34299;
if (triggeredByAura->GetCasterGUID() != GetGUID()) break;
int32 basepoints1 = triggerAmount * 2;
// Mana Part
CastCustomSpell(this, 68285, &basepoints1, 0, 0, true, 0,
triggeredByAura);
break;
}
// Healing Touch (Dreamwalker Raiment set)
case 28719:
{
// mana back
basepoints0 = int32(procSpell->manaCost * 30 / 100);
target = this;
triggered_spell_id = 28742;
break;
}
// Glyph of Rejuvenation
case 54754:
{
if (!pVictim
|| !pVictim->HealthBelowPct(uint32(triggerAmount))) return false;
basepoints0 = int32(triggerAmount * damage / 100);
triggered_spell_id = 54755;
break;
}
// Healing Touch Refund (Idol of Longevity trinket)
case 28847:
{
target = this;
triggered_spell_id = 28848;
break;
}
// Mana Restore (Malorne Raiment set / Malorne Regalia set)
case 37288:
case 37295:
{
target = this;
triggered_spell_id = 37238;
break;
}
// Druid Tier 6 Trinket
case 40442:
{
float chance;
// Starfire
if (procSpell->SpellFamilyFlags [0] & 0x4)
{
triggered_spell_id = 40445;
chance = 25.0f;
}
// Rejuvenation
else if (procSpell->SpellFamilyFlags [0] & 0x10)
{
triggered_spell_id = 40446;
chance = 25.0f;
}
// Mangle (Bear) and Mangle (Cat)
else if (procSpell->SpellFamilyFlags [1] & 0x00000440)
{
triggered_spell_id = 40452;
chance = 40.0f;
}
else return false;
if (!roll_chance_f(chance)) return false;
target = this;
break;
}
// Maim Interrupt
case 44835:
{
// Deadly Interrupt Effect
triggered_spell_id = 32747;
break;
}
// Tricks of the Trade
case 57934:
{
if (Unit* unitTarget = GetMisdirectionTarget())
{
RemoveAura(dummySpell->Id, GetGUID(), 0,
AURA_REMOVE_BY_DEFAULT);
CastSpell(this, 59628, true);
CastSpell(unitTarget, 57933, true);
return true;
}
return false;
}
// Item - Druid T10 Balance 4P Bonus
case 70723:
{
// Wrath & Starfire
if ((procSpell->SpellFamilyFlags [0] & 0x5)
&& (procEx & PROC_EX_CRITICAL_HIT))
{
triggered_spell_id = 71023;
SpellEntry const* triggeredSpell =
sSpellStore.LookupEntry(triggered_spell_id);
if (!triggeredSpell) return false;
basepoints0 =
int32(
triggerAmount * damage / 100
/ (GetSpellMaxDuration(
triggeredSpell)
/ triggeredSpell->EffectAmplitude [0]));
// Add remaining ticks to damage done
basepoints0 += pVictim->GetRemainingDotDamage(GetGUID(),
triggered_spell_id);
}
break;
}
// Item - Druid T10 Restoration 4P Bonus (Rejuvenation)
case 70664:
{
// Proc only from normal Rejuvenation
if (procSpell->SpellVisual [0] != 32) return false;
Player* caster = ToPlayer();
if (!caster) return false;
if (!caster->GetGroup() && pVictim == this) return false;
CastCustomSpell(70691, SPELLVALUE_BASE_POINT0, damage,
pVictim, true);
return true;
}
}
// Living Seed
if (dummySpell->SpellIconID == 2860)
{
triggered_spell_id = 48504;
basepoints0 = triggerAmount * damage / 100;
break;
}
// King of the Jungle
else if (dummySpell->SpellIconID == 2850)
{
// Effect 0 - mod damage while having Enrage
if (effIndex == 0)
{
if (!(procSpell->SpellFamilyFlags [0] & 0x00080000)) return false;
triggered_spell_id = 51185;
basepoints0 = triggerAmount;
target = this;
break;
}
// Effect 1 - Tiger's Fury restore energy
else if (effIndex == 1)
{
if (!(procSpell->SpellFamilyFlags [2] & 0x00000800)) return false;
triggered_spell_id = 51178;
basepoints0 = triggerAmount;
target = this;
break;
}
}
break;
}
case SPELLFAMILY_ROGUE:
{
switch (dummySpell->Id)
{
// Glyph of Backstab
case 56800:
{
triggered_spell_id = 63975;
break;
}
// Deadly Throw Interrupt
case 32748:
{
// Prevent cast Deadly Throw Interrupt on self from last effect (apply dummy) of Deadly Throw
if (this == pVictim) return false;
triggered_spell_id = 32747;
break;
}
case 51698: // Honor Among Thieves
case 51700:
case 51701:
{
if (Player* pTarget = triggeredByAura->GetCaster()->ToPlayer())
{
if (pTarget->HasSpellCooldown(51699))
break;
Unit* spellTarget = ObjectAccessor::GetUnit(*pTarget, pTarget->GetComboTarget());
if (!spellTarget)
spellTarget = pTarget->GetSelectedUnit();
if (spellTarget && pTarget->canAttack(spellTarget))
pTarget->CastSpell(spellTarget, 51699, true);
}
break;
}
}
// Cut to the Chase
if (dummySpell->SpellIconID == 2909)
{
// "refresh your Slice and Dice duration to its 5 combo point maximum"
// lookup Slice and Dice
if (AuraEffect const* aur = GetAuraEffect(SPELL_AURA_MOD_MELEE_HASTE, SPELLFAMILY_ROGUE, 0x40000, 0, 0))
{
aur->GetBase()->SetDuration(
GetSpellMaxDuration(aur->GetSpellProto()), true);
return true;
}
return false;
}
// Deadly Brew
else if (dummySpell->SpellIconID == 2963)
{
triggered_spell_id = 3409;
break;
}
// Quick Recovery
else if (dummySpell->SpellIconID == 2116)
{
if (!procSpell) return false;
// energy cost save
basepoints0 = procSpell->manaCost * triggerAmount / 100;
if (basepoints0 <= 0) return false;
target = this;
triggered_spell_id = 31663;
break;
}
break;
}
case SPELLFAMILY_HUNTER:
{
// Thrill of the Hunt
if (dummySpell->SpellIconID == 2236)
{
if (!procSpell) return false;
Spell * spell = ToPlayer()->m_spellModTakingSpell;
// Disable charge drop because of Lock and Load
ToPlayer()->SetSpellModTakingSpell(spell, false);
// Explosive Shot
if (procSpell->SpellFamilyFlags [2] & 0x200)
{
if (!pVictim) return false;
if (AuraEffect const* pEff = pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DUMMY, SPELLFAMILY_HUNTER, 0x0, 0x80000000, 0x0, GetGUID())) basepoints0 =
CalculatePowerCost(
pEff->GetSpellProto(),
this,
SpellSchoolMask(
pEff->GetSpellProto()->SchoolMask))
* 4 / 10 / 3;
}
else basepoints0 = CalculatePowerCost(procSpell, this,
SpellSchoolMask(procSpell->SchoolMask)) * 4 / 10;
ToPlayer()->SetSpellModTakingSpell(spell, true);
if (basepoints0 <= 0) return false;
target = this;
triggered_spell_id = 34720;
break;
}
// Hunting Party
if (dummySpell->SpellIconID == 3406)
{
triggered_spell_id = 57669;
target = this;
break;
}
// Improved Mend Pet
if (dummySpell->SpellIconID == 267)
{
int32 chance = SpellMgr::CalculateSpellEffectAmount(
triggeredByAura->GetSpellProto(),
triggeredByAura->GetEffIndex());
if (!roll_chance_i(chance)) return false;
triggered_spell_id = 24406;
break;
}
// Lock and Load
if (dummySpell->SpellIconID == 3579)
{
// Proc only from periodic (from trap activation proc another aura of this spell)
if (!(procFlag & PROC_FLAG_DONE_PERIODIC)
|| !roll_chance_i(triggerAmount)) return false;
triggered_spell_id = 56453;
target = this;
break;
}
// Rapid Recuperation
if (dummySpell->SpellIconID == 3560)
{
// This effect only from Rapid Killing (mana regen)
if (!(procSpell->SpellFamilyFlags [1] & 0x01000000)) return false;
target = this;
switch (dummySpell->Id)
{
case 53228: // Rank 1
triggered_spell_id = 56654;
break;
case 53232: // Rank 2
triggered_spell_id = 58882;
break;
}
break;
}
// Glyph of Mend Pet
if (dummySpell->Id == 57870)
{
pVictim->CastSpell(pVictim, 57894, true, NULL, NULL, GetGUID());
return true;
}
// Misdirection
if (dummySpell->Id == 34477)
{
RemoveAura(dummySpell->Id, GetGUID(), 0,
AURA_REMOVE_BY_DEFAULT);
CastSpell(this, 35079, true);
return true;
}
break;
}
case SPELLFAMILY_PALADIN:
{
// Seal of Righteousness - melee proc dummy (addition ${$MWS*(0.011*$AP+0.022*$SPH)} damage)
if (dummySpell->Id == 20154)
{
if (effIndex != 0) return false;
triggered_spell_id = 25742;
float ap = GetTotalAttackPowerValue(BASE_ATTACK);
int32 holy = SpellBaseDamageBonus(SPELL_SCHOOL_MASK_HOLY)
+ SpellBaseDamageBonusForVictim(SPELL_SCHOOL_MASK_HOLY,
pVictim);
basepoints0 = (int32) GetAttackTime(BASE_ATTACK)
* int32(ap * 0.011f + 0.022f * holy) / 1000;
break;
}
// Light's Beacon - Beacon of Light
if (dummySpell->Id == 53651)
{
// Get target of beacon of light
if (Unit * beaconTarget = triggeredByAura->GetBase()->GetCaster())
{
// do not proc when target of beacon of light is healed
if (beaconTarget == this) return false;
// check if it was heal by paladin which casted this beacon of light
if (beaconTarget->GetAura(53563, pVictim->GetGUID()))
{
if (beaconTarget->IsWithinLOSInMap(pVictim))
{
basepoints0 = damage;
triggered_spell_id = 53652;
target = beaconTarget;
break;
}
}
}
return false;
}
// Righteous Vengeance
if (dummySpell->SpellIconID == 3025)
{
// 4 damage tick
basepoints0 = triggerAmount * damage / 400;
triggered_spell_id = 61840;
// Add remaining ticks to damage done
basepoints0 += pVictim->GetRemainingDotDamage(GetGUID(),
triggered_spell_id);
break;
}
// Sheath of Light
if (dummySpell->SpellIconID == 3030)
{
// 4 healing tick
basepoints0 = triggerAmount * damage / 400;
triggered_spell_id = 54203;
break;
}
switch (dummySpell->Id)
{
// Judgements of the Bold
case 89901:
{
target = this;
triggered_spell_id = 89906;
break;
}
// Selfless Healer
case 85803:
case 85804:
{
if (pVictim == this) return false;
break;
}
// Ancient Healer
case 86674:
{
int32 bp0 = damage;
int32 bp1 = ((bp0 * 10) / 100);
if (!bp0 || !bp1) return false;
if (pVictim && pVictim->IsFriendlyTo(this)) CastCustomSpell(
pVictim, 86678, &bp0, &bp1, 0, true, NULL,
triggeredByAura, 0);
else CastCustomSpell(this, 86678, &bp0, &bp1, 0, true, NULL,
triggeredByAura, 0);
return true;
}
// Ancient Crusader - Player
case 86701:
{
target = this;
triggered_spell_id = 86700;
break;
}
// Uncomment this once the guardian is receiving the aura via
// creature template addon and redirect aura procs to the owner
// Ancient Crusader - Guardian
/*
case 86703:
{
Unit* owner = this->GetOwner();
if (!owner)
return false;
owner->CastSpell(owner, 86700, true);
return true;
}*/
// Long Arm of The law
case 87168:
case 87172:
{
if (roll_chance_f(triggerAmount)
&& !this->IsWithinDistInMap(pVictim, 15.0f))
{
target = this;
triggered_spell_id = 87173;
break;
}
}
// Divine purpose
case 85117:
case 86172:
{
if (roll_chance_f(triggerAmount))
{
target = this;
triggered_spell_id = 90174;
break;
}
}
// Judgement of Light
case 20185:
{
if (!pVictim) // Crash Fix in Unit::HandleDummyAuraProc.
return false;
// 2% of base mana
basepoints0 = int32(pVictim->CountPctFromMaxHealth(2));
pVictim->CastCustomSpell(pVictim, 20267, &basepoints0, 0, 0,
true, 0, triggeredByAura);
return true;
}
// Judgement of Wisdom
case 20186:
{
if (pVictim && pVictim->isAlive()
&& pVictim->getPowerType() == POWER_MANA)
{
// 2% of base mana
basepoints0 = int32(pVictim->GetCreateMana() * 2 / 100);
pVictim->CastCustomSpell(pVictim, 20268, &basepoints0,
NULL, NULL, true, 0, triggeredByAura);
}
return true;
}
// Holy Power (Redemption Armor set)
case 28789:
{
if (!pVictim) return false;
// Set class defined buff
switch (pVictim->getClass())
{
case CLASS_PALADIN:
case CLASS_PRIEST:
case CLASS_SHAMAN:
case CLASS_DRUID:
triggered_spell_id = 28795; // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
break;
case CLASS_MAGE:
case CLASS_WARLOCK:
triggered_spell_id = 28793; // Increases the friendly target's spell damage and healing by up to $s1 for $d.
break;
case CLASS_HUNTER:
case CLASS_ROGUE:
triggered_spell_id = 28791; // Increases the friendly target's attack power by $s1 for $d.
break;
case CLASS_WARRIOR:
triggered_spell_id = 28790; // Increases the friendly target's armor
break;
default:
return false;
}
break;
}
case 25899: // Greater Blessing of Sanctuary
case 20911: // Blessing of Sanctuary
{
target = this;
switch (target->getPowerType())
{
case POWER_MANA:
triggered_spell_id = 57319;
break;
default:
return false;
}
break;
}
// Seal of Vengeance (damage calc on apply aura)
case 31801:
{
if (effIndex != 0) // effect 1, 2 used by seal unleashing code
return false;
// At melee attack or Hammer of the Righteous spell damage considered as melee attack
bool stacker = !procSpell || procSpell->Id == 53595;
// spells with SPELL_DAMAGE_CLASS_MELEE excluding Judgements
bool damager = procSpell
&& procSpell->EquippedItemClass != -1;
if (!stacker && !damager) return false;
triggered_spell_id = 31803;
// On target with 5 stacks of Holy Vengeance direct damage is done
if (Aura * aur = pVictim->GetAura(triggered_spell_id, GetGUID()))
{
if (aur->GetStackAmount() == 5)
{
if (stacker) aur->RefreshDuration();
CastSpell(pVictim, 42463, true);
return true;
}
}
if (!stacker) return false;
break;
}
// Seal of Corruption
case 53736:
{
if (effIndex != 0) // effect 1, 2 used by seal unleashing code
return false;
// At melee attack or Hammer of the Righteous spell damage considered as melee attack
bool stacker = !procSpell || procSpell->Id == 53595;
// spells with SPELL_DAMAGE_CLASS_MELEE excluding Judgements
bool damager = procSpell
&& procSpell->EquippedItemClass != -1;
if (!stacker && !damager) return false;
triggered_spell_id = 31803;
// On target with 5 stacks of Blood Corruption direct damage is done
if (Aura * aur = pVictim->GetAura(triggered_spell_id, GetGUID()))
{
if (aur->GetStackAmount() == 5)
{
if (stacker) aur->RefreshDuration();
CastSpell(pVictim, 53739, true);
return true;
}
}
if (!stacker) return false;
break;
}
// Spiritual Attunement
case 31785:
case 33776:
{
// if healed by another unit (pVictim)
if (this == pVictim) return false;
// heal amount
basepoints0 = triggerAmount
* (std::min(damage, GetMaxHealth() - GetHealth()))
/ 100;
target = this;
if (basepoints0) triggered_spell_id = 31786;
break;
}
// Paladin Tier 6 Trinket (Ashtongue Talisman of Zeal)
case 40470:
{
if (!procSpell) return false;
float chance;
// Flash of light/Holy light
if (procSpell->SpellFamilyFlags [0] & 0xC0000000)
{
triggered_spell_id = 40471;
chance = 15.0f;
}
// Judgement (any)
else if (GetSpellSpecific(procSpell)
== SPELL_SPECIFIC_JUDGEMENT)
{
triggered_spell_id = 40472;
chance = 50.0f;
}
else return false;
if (!roll_chance_f(chance)) return false;
break;
}
// Glyph of Flash of Light
case 54936:
{
triggered_spell_id = 54957;
basepoints0 = triggerAmount * damage / 100;
break;
}
// Glyph of Holy Light
case 54937:
{
triggered_spell_id = 54968;
basepoints0 = triggerAmount * damage / 100;
break;
}
case 71406: // Tiny Abomination in a Jar
{
if (!pVictim || !pVictim->isAlive()) return false;
CastSpell(this, 71432, true, NULL, triggeredByAura);
Aura const* dummy = GetAura(71432);
if (!dummy || dummy->GetStackAmount() < 8) return false;
RemoveAurasDueToSpell(71432);
triggered_spell_id = 71433; // default main hand attack
// roll if offhand
if (Player const* player = ToPlayer()) if (player->GetWeaponForAttack(
OFF_ATTACK, true) && urand(0, 1)) triggered_spell_id =
71434;
target = pVictim;
break;
}
case 71545: // Tiny Abomination in a Jar (Heroic)
{
if (!pVictim || !pVictim->isAlive()) return false;
CastSpell(this, 71432, true, NULL, triggeredByAura);
Aura const* dummy = GetAura(71432);
if (!dummy || dummy->GetStackAmount() < 7) return false;
RemoveAurasDueToSpell(71432);
triggered_spell_id = 71433; // default main hand attack
// roll if offhand
if (Player const* player = ToPlayer()) if (player->GetWeaponForAttack(
OFF_ATTACK, true) && urand(0, 1)) triggered_spell_id =
71434;
target = pVictim;
break;
}
}
break;
}
case SPELLFAMILY_SHAMAN:
{
switch (dummySpell->Id)
{
// Earthen Power (Rank 1, 2)
case 51523:
case 51524:
{
// Totem itself must be a caster of this spell
Unit* caster = NULL;
for (ControlList::iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
{
if ((*itr)->GetEntry() != 2630) continue;
caster = (*itr);
break;
}
if (!caster) return false;
caster->CastSpell(caster, 59566, true, castItem,
triggeredByAura, originalCaster);
return true;
}
// Tidal Force
case 55198:
{
// Remove aura stack from caster
RemoveAuraFromStack(55166);
// drop charges
return false;
}
// Totemic Power (The Earthshatterer set)
case 28823:
{
if (!pVictim) return false;
// Set class defined buff
switch (pVictim->getClass())
{
case CLASS_PALADIN:
case CLASS_PRIEST:
case CLASS_SHAMAN:
case CLASS_DRUID:
triggered_spell_id = 28824; // Increases the friendly target's mana regeneration by $s1 per 5 sec. for $d.
break;
case CLASS_MAGE:
case CLASS_WARLOCK:
triggered_spell_id = 28825; // Increases the friendly target's spell damage and healing by up to $s1 for $d.
break;
case CLASS_HUNTER:
case CLASS_ROGUE:
triggered_spell_id = 28826; // Increases the friendly target's attack power by $s1 for $d.
break;
case CLASS_WARRIOR:
triggered_spell_id = 28827; // Increases the friendly target's armor
break;
default:
return false;
}
break;
}
// Lesser Healing Wave (Totem of Flowing Water Relic)
case 28849:
{
target = this;
triggered_spell_id = 28850;
break;
}
// Windfury Weapon (Passive) 1-5 Ranks
case 33757:
{
if (GetTypeId() != TYPEID_PLAYER || !castItem
|| !castItem->IsEquipped() || !pVictim
|| !pVictim->isAlive()) return false;
// custom cooldown processing case
if (cooldown
&& ToPlayer()->HasSpellCooldown(dummySpell->Id)) return false;
if (triggeredByAura->GetBase()
&& castItem->GetGUID()
!= triggeredByAura->GetBase()->GetCastItemGUID()) return false;
WeaponAttackType attType = WeaponAttackType(
this->ToPlayer()->GetAttackBySlot(
castItem->GetSlot()));
if ((attType != BASE_ATTACK && attType != OFF_ATTACK)
|| !isAttackReady(attType)) return false;
// Now compute real proc chance...
uint32 chance = 20;
this->ToPlayer()->ApplySpellMod(dummySpell->Id,
SPELLMOD_CHANCE_OF_SUCCESS, chance);
Item* addWeapon = this->ToPlayer()->GetWeaponForAttack(
attType == BASE_ATTACK ? OFF_ATTACK : BASE_ATTACK,
true);
uint32 enchant_id_add =
addWeapon ?
addWeapon->GetEnchantmentId(
EnchantmentSlot(
TEMP_ENCHANTMENT_SLOT)) :
0;
SpellItemEnchantmentEntry const *pEnchant =
sSpellItemEnchantmentStore.LookupEntry(
enchant_id_add);
if (pEnchant && pEnchant->spellid [0] == dummySpell->Id) chance +=
14;
if (!roll_chance_i(chance)) return false;
// Now amount of extra power stored in 1 effect of Enchant spell
// Get it by item enchant id
uint32 spellId;
switch (castItem->GetEnchantmentId(
EnchantmentSlot(TEMP_ENCHANTMENT_SLOT)))
{
case 283:
spellId = 8232;
break;
default:
{
sLog->outError(
"Unit::HandleDummyAuraProc: non handled item enchantment (rank?) %u for spell id: %u (Windfury)",
castItem->GetEnchantmentId(
EnchantmentSlot(
TEMP_ENCHANTMENT_SLOT)),
dummySpell->Id);
return false;
}
}
SpellEntry const* windfurySpellEntry =
sSpellStore.LookupEntry(spellId);
if (!windfurySpellEntry)
{
sLog->outError(
"Unit::HandleDummyAuraProc: non existed spell id: %u (Windfury)",
spellId);
return false;
}
int32 extra_attack_power = CalculateSpellDamage(pVictim,
windfurySpellEntry, 1);
// Value gained from additional AP
basepoints0 = int32(
extra_attack_power / 14.0f
* GetAttackTime(BASE_ATTACK) / 1000);
triggered_spell_id = 25504;
// apply cooldown before cast to prevent processing itself
if (cooldown) ToPlayer()->AddSpellCooldown(dummySpell->Id,
0, time(NULL) + cooldown);
// triggering three extra attacks
for (uint32 i = 0; i < 3; ++i)
CastCustomSpell(pVictim, triggered_spell_id,
&basepoints0, NULL, NULL, true, castItem,
triggeredByAura);
return true;
}
// Shaman Tier 6 Trinket
case 40463:
{
if (!procSpell) return false;
float chance;
if (procSpell->SpellFamilyFlags [0] & 0x1)
{
triggered_spell_id = 40465; // Lightning Bolt
chance = 15.0f;
}
else if (procSpell->SpellFamilyFlags [0] & 0x80)
{
triggered_spell_id = 40465; // Lesser Healing Wave
chance = 10.0f;
}
else if (procSpell->SpellFamilyFlags [1] & 0x00000010)
{
triggered_spell_id = 40466; // Stormstrike
chance = 50.0f;
}
else return false;
if (!roll_chance_f(chance)) return false;
target = this;
break;
}
// Glyph of Healing Wave
case 55440:
{
// Not proc from self heals
if (this == pVictim) return false;
basepoints0 = triggerAmount * damage / 100;
target = this;
triggered_spell_id = 55533;
break;
}
// Spirit Hunt
case 58877:
{
// Cast on owner
target = GetOwner();
if (!target) return false;
basepoints0 = triggerAmount * damage / 100;
triggered_spell_id = 58879;
break;
}
// Shaman T8 Elemental 4P Bonus
case 64928:
{
basepoints0 = int32(triggerAmount * damage / 100);
triggered_spell_id = 64930; // Electrified
break;
}
// Shaman T9 Elemental 4P Bonus
case 67228:
{
// Lava Burst
if (procSpell->SpellFamilyFlags [1] & 0x1000)
{
triggered_spell_id = 71824;
SpellEntry const* triggeredSpell =
sSpellStore.LookupEntry(triggered_spell_id);
if (!triggeredSpell) return false;
basepoints0 =
int32(
triggerAmount * damage / 100
/ (GetSpellMaxDuration(
triggeredSpell)
/ triggeredSpell->EffectAmplitude [0]));
}
break;
}
// Item - Shaman T10 Restoration 4P Bonus
case 70808:
{
// Chain Heal
if ((procSpell->SpellFamilyFlags [0] & 0x100)
&& (procEx & PROC_EX_CRITICAL_HIT))
{
triggered_spell_id = 70809;
SpellEntry const* triggeredSpell =
sSpellStore.LookupEntry(triggered_spell_id);
if (!triggeredSpell) return false;
basepoints0 =
int32(
triggerAmount * damage / 100
/ (GetSpellMaxDuration(
triggeredSpell)
/ triggeredSpell->EffectAmplitude [0]));
}
break;
}
// Item - Shaman T10 Elemental 2P Bonus
case 70811:
{
// Lightning Bolt & Chain Lightning
if (procSpell->SpellFamilyFlags [0] & 0x3)
{
if (ToPlayer()->HasSpellCooldown(16166))
{
uint32 newCooldownDelay =
ToPlayer()->GetSpellCooldownDelay(16166);
if (newCooldownDelay < 3) newCooldownDelay = 0;
else newCooldownDelay -= 2;
ToPlayer()->AddSpellCooldown(16166, 0,
uint32(time(NULL) + newCooldownDelay));
WorldPacket data(SMSG_MODIFY_COOLDOWN, 4 + 8 + 4);
data << uint32(16166); // Spell ID
data << uint64(GetGUID()); // Player GUID
data << int32(-2000); // Cooldown mod in milliseconds
ToPlayer()->GetSession()->SendPacket(&data);
return true;
}
}
return false;
}
// Item - Shaman T10 Elemental 4P Bonus
case 70817:
{
if (!target) return false;
// try to find spell Flame Shock on the target
if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_SHAMAN, 0x10000000, 0x0, 0x0, GetGUID()))
{
Aura* flameShock = aurEff->GetBase();
int32 maxDuration = flameShock->GetMaxDuration();
int32 newDuration = flameShock->GetDuration()
+ 2 * aurEff->GetAmplitude();
flameShock->SetDuration(newDuration);
// is it blizzlike to change max duration for FS?
if (newDuration > maxDuration) flameShock->SetMaxDuration(
newDuration);
return true;
}
// if not found Flame Shock
return false;
}
case 63280: // Glyph of Totem of Wrath
{
if (procSpell->SpellIconID != 2019) return false;
AuraEffect * aurEffA = NULL;
AuraEffectList const& auras = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE);
for (AuraEffectList::const_iterator i = auras.begin();
i != auras.end(); ++i)
{
SpellEntry const *spell = (*i)->GetSpellProto();
if (spell->SpellFamilyName == uint32(SPELLFAMILY_SHAMAN)
&& spell->SpellFamilyFlags.HasFlag(0,
0x02000000, 0))
{
if ((*i)->GetCasterGUID() != GetGUID()) continue;
if (spell->Id == 63283) continue;
aurEffA = (*i);
break;
}
}
if (aurEffA)
{
int32 bp0 = 0, bp1 = 0;
bp0 = aurEffA->GetAmount() * triggerAmount / 100;
if (AuraEffect * aurEffB = aurEffA->GetBase()->GetEffect(EFFECT_1)) bp1 =
aurEffB->GetAmount() * triggerAmount / 100;
CastCustomSpell(this, 63283, &bp0, &bp1, NULL, true,
NULL, triggeredByAura);
return true;
}
return false;
}
break;
}
// Frozen Power
if (dummySpell->SpellIconID == 3780)
{
if (this->GetDistance(target) < 15.0f) return false;
float chance = (float) triggerAmount;
if (!roll_chance_f(chance)) return false;
triggered_spell_id = 63685;
break;
}
// Storm, Earth and Fire
if (dummySpell->SpellIconID == 3063)
{
// Earthbind Totem summon only
if (procSpell->Id != 2484) return false;
float chance = (float) triggerAmount;
if (!roll_chance_f(chance)) return false;
triggered_spell_id = 64695;
break;
}
// Ancestral Awakening
if (dummySpell->SpellIconID == 3065)
{
triggered_spell_id = 52759;
basepoints0 = triggerAmount * damage / 100;
target = this;
break;
}
// Earth Shield
if (dummySpell->SpellFamilyFlags [1] & 0x00000400)
{
// 3.0.8: Now correctly uses the Shaman's own spell critical strike chance to determine the chance of a critical heal.
originalCaster = triggeredByAura->GetCasterGUID();
target = this;
basepoints0 = triggerAmount;
// Glyph of Earth Shield
if (AuraEffect* aur = GetAuraEffect(63279, 0))
{
int32 aur_mod = aur->GetAmount();
basepoints0 = int32(
basepoints0 * (aur_mod + 100.0f) / 100.0f);
}
triggered_spell_id = 379;
break;
}
// Flametongue Weapon (Passive)
if (dummySpell->SpellFamilyFlags [0] & 0x200000)
{
if (GetTypeId() != TYPEID_PLAYER || !pVictim
|| !pVictim->isAlive() || !castItem
|| !castItem->IsEquipped()) return false;
float fire_onhit =
(float) (SpellMgr::CalculateSpellEffectAmount(
dummySpell, 0) / 100.0);
float add_spellpower = (float) (SpellBaseDamageBonus(
SPELL_SCHOOL_MASK_FIRE)
+ SpellBaseDamageBonusForVictim(SPELL_SCHOOL_MASK_FIRE,
pVictim));
// 1.3speed = 5%, 2.6speed = 10%, 4.0 speed = 15%, so, 1.0speed = 3.84%
add_spellpower = add_spellpower / 100.0f * 3.84f;
// Enchant on Off-Hand and ready?
if (castItem->GetSlot() == EQUIPMENT_SLOT_OFFHAND
&& isAttackReady(OFF_ATTACK))
{
float BaseWeaponSpeed = GetAttackTime(OFF_ATTACK) / 1000.0f;
// Value1: add the tooltip damage by swingspeed + Value2: add spelldmg by swingspeed
basepoints0 = int32(
(fire_onhit * BaseWeaponSpeed)
+ (add_spellpower * BaseWeaponSpeed));
triggered_spell_id = 10444;
}
// Enchant on Main-Hand and ready?
else if (castItem->GetSlot() == EQUIPMENT_SLOT_MAINHAND
&& isAttackReady(BASE_ATTACK))
{
float BaseWeaponSpeed = GetAttackTime(BASE_ATTACK)
/ 1000.0f;
// Value1: add the tooltip damage by swingspeed + Value2: add spelldmg by swingspeed
basepoints0 = int32(
(fire_onhit * BaseWeaponSpeed)
+ (add_spellpower * BaseWeaponSpeed));
triggered_spell_id = 10444;
}
// If not ready, we should return, shouldn't we?!
else return false;
CastCustomSpell(pVictim, triggered_spell_id, &basepoints0, NULL,
NULL, true, castItem, triggeredByAura);
return true;
}
// Improved Water Shield
if (dummySpell->SpellIconID == 2287)
{
// Default chance for Healing Wave and Riptide
float chance = (float) triggeredByAura->GetAmount();
if (procSpell->SpellFamilyFlags [0] & 0x80)
// Lesser Healing Wave - 0.6 of default
chance *= 0.6f;
else if (procSpell->SpellFamilyFlags [0] & 0x100)
// Chain heal - 0.3 of default
chance *= 0.3f;
if (!roll_chance_f(chance)) return false;
// Water Shield
if (AuraEffect const * aurEff = GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_SHAMAN, 0, 0x00000020, 0))
{
uint32 spell =
aurEff->GetSpellProto()->EffectTriggerSpell [aurEff->GetEffIndex()];
CastSpell(this, spell, true, castItem, triggeredByAura);
return true;
}
return false;
}
// Lightning Overload
if (dummySpell->SpellIconID == 2018) // only this spell have SpellFamily Shaman SpellIconID == 2018 and dummy aura
{
if (!procSpell || GetTypeId() != TYPEID_PLAYER || !pVictim) return false;
// custom cooldown processing case
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& ToPlayer()->HasSpellCooldown(dummySpell->Id)) return false;
uint32 spellId = 0;
// Every Lightning Bolt and Chain Lightning spell have duplicate vs half damage and zero cost
switch (procSpell->Id)
{
// Lightning Bolt
case 403:
spellId = 45284;
break; // Rank 1
case 529:
spellId = 45286;
break; // Rank 2
case 548:
spellId = 45287;
break; // Rank 3
case 915:
spellId = 45288;
break; // Rank 4
case 943:
spellId = 45289;
break; // Rank 5
case 6041:
spellId = 45290;
break; // Rank 6
case 10391:
spellId = 45291;
break; // Rank 7
case 10392:
spellId = 45292;
break; // Rank 8
case 15207:
spellId = 45293;
break; // Rank 9
case 15208:
spellId = 45294;
break; // Rank 10
case 25448:
spellId = 45295;
break; // Rank 11
case 25449:
spellId = 45296;
break; // Rank 12
case 49237:
spellId = 49239;
break; // Rank 13
case 49238:
spellId = 49240;
break; // Rank 14
// Chain Lightning
case 421:
spellId = 45297;
break; // Rank 1
case 930:
spellId = 45298;
break; // Rank 2
case 2860:
spellId = 45299;
break; // Rank 3
case 10605:
spellId = 45300;
break; // Rank 4
case 25439:
spellId = 45301;
break; // Rank 5
case 25442:
spellId = 45302;
break; // Rank 6
case 49270:
spellId = 49268;
break; // Rank 7
case 49271:
spellId = 49269;
break; // Rank 8
default:
sLog->outError(
"Unit::HandleDummyAuraProc: non handled spell id: %u (LO)",
procSpell->Id);
return false;
}
// Chain Lightning
if (procSpell->SpellFamilyFlags [0] & 0x2)
{
// Chain lightning has [LightOverload_Proc_Chance] / [Max_Number_of_Targets] chance to proc of each individual target hit.
// A maxed LO would have a 33% / 3 = 11% chance to proc of each target.
// LO chance was already "accounted" at the proc chance roll, now need to divide the chance by [Max_Number_of_Targets]
float chance = 100.0f
/ procSpell->EffectChainTarget [effIndex];
if (!roll_chance_f(chance)) return false;
// Remove cooldown (Chain Lightning - have Category Recovery time)
ToPlayer()->RemoveSpellCooldown(spellId);
}
CastSpell(pVictim, spellId, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER) ToPlayer()->AddSpellCooldown(
dummySpell->Id, 0, time(NULL) + cooldown);
return true;
}
// Static Shock
if (dummySpell->SpellIconID == 3059)
{
// Lightning Shield
if (AuraEffect const * aurEff = GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_SHAMAN, 0x400, 0, 0))
{
uint32 spell = sSpellMgr->GetSpellWithRank(26364,
sSpellMgr->GetSpellRank(aurEff->GetId()));
// custom cooldown processing case
if (GetTypeId() == TYPEID_PLAYER
&& ToPlayer()->HasSpellCooldown(spell)) ToPlayer()->RemoveSpellCooldown(
spell);
CastSpell(target, spell, true, castItem, triggeredByAura);
aurEff->GetBase()->DropCharge();
return true;
}
return false;
}
break;
}
case SPELLFAMILY_DEATHKNIGHT:
{
// Blood-Caked Strike - Blood-Caked Blade
if (dummySpell->SpellIconID == 138)
{
if (!target || !target->isAlive()) return false;
triggered_spell_id = dummySpell->EffectTriggerSpell [effIndex];
break;
}
// Improved Blood Presence
if (dummySpell->SpellIconID == 2636)
{
if (GetTypeId() != TYPEID_PLAYER) return false;
basepoints0 = triggerAmount * damage / 100;
break;
}
// Butchery
if (dummySpell->SpellIconID == 2664)
{
basepoints0 = triggerAmount;
triggered_spell_id = 50163;
target = this;
break;
}
// Dancing Rune Weapon
if (dummySpell->Id == 49028)
{
// 1 dummy aura for dismiss rune blade
if (effIndex != 1) return false;
Unit* pPet = NULL;
for (ControlList::const_iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr) //Find Rune Weapon
if ((*itr)->GetEntry() == 27893)
{
pPet = (*itr);
break;
}
if (pPet && pPet->getVictim() && damage && procSpell)
{
uint32 procDmg = damage / 2;
pPet->SendSpellNonMeleeDamageLog(pPet->getVictim(),
procSpell->Id, procDmg,
GetSpellSchoolMask(procSpell), 0, 0, false, 0,
false);
pPet->DealDamage(pPet->getVictim(), procDmg, NULL,
SPELL_DIRECT_DAMAGE, GetSpellSchoolMask(procSpell),
procSpell, true);
break;
}
else return false;
}
// Mark of Blood
if (dummySpell->Id == 49005)
{
// TODO: need more info (cooldowns/PPM)
triggered_spell_id = 61607;
break;
}
// Unholy Blight
if (dummySpell->Id == 49194)
{
basepoints0 = triggerAmount * damage / 100;
// Glyph of Unholy Blight
if (AuraEffect *glyph=GetAuraEffect(63332, 0)) AddPctN(
basepoints0, glyph->GetAmount());
triggered_spell_id = 50536;
basepoints0 += pVictim->GetRemainingDotDamage(GetGUID(),
triggered_spell_id, SPELL_AURA_PERIODIC_DAMAGE);
break;
}
// Vendetta
if (dummySpell->SpellFamilyFlags [0] & 0x10000)
{
basepoints0 = int32(CountPctFromMaxHealth(triggerAmount));
triggered_spell_id = 50181;
target = this;
break;
}
// Necrosis
if (dummySpell->SpellIconID == 2709)
{
basepoints0 = triggerAmount * damage / 100;
triggered_spell_id = 51460;
break;
}
// Threat of Thassarian
if (dummySpell->SpellIconID == 2023)
{
// Must Dual Wield
if (!procSpell || !haveOffhandWeapon()) return false;
// Chance as basepoints for dummy aura
if (!roll_chance_i(triggerAmount)) return false;
switch (procSpell->Id)
{
// Obliterate
case 49020:
triggered_spell_id = 66198;
break;
// Frost Strike
case 49143:
triggered_spell_id = 66196;
break;
// Plague Strike
case 45462:
triggered_spell_id = 66216;
break;
// Death Strike
case 49998:
triggered_spell_id = 66188;
break;
// Rune Strike
case 56815:
triggered_spell_id = 66217;
break;
// Blood Strike
case 45902:
triggered_spell_id = 66215;
break;
default:
return false;
}
break;
}
// Runic Power Back on Snare/Root
if (dummySpell->Id == 61257)
{
// only for spells and hit/crit (trigger start always) and not start from self casted spells
if (procSpell == 0
|| !(procEx
& (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT))
|| this == pVictim) return false;
// Need snare or root mechanic
if (!(GetAllSpellMechanicMask(procSpell)
& ((1 << MECHANIC_ROOT) | (1 << MECHANIC_SNARE)))) return false;
triggered_spell_id = 61258;
target = this;
break;
}
// Wandering Plague
if (dummySpell->SpellIconID == 1614)
{
if (!roll_chance_f(GetUnitCriticalChance(BASE_ATTACK, pVictim))) return false;
basepoints0 = triggerAmount * damage / 100;
triggered_spell_id = 50526;
break;
}
// Sudden Doom
if (dummySpell->SpellIconID == 1939 && GetTypeId() == TYPEID_PLAYER)
{
SpellChainNode const* chain = NULL;
// get highest rank of the Death Coil spell
const PlayerSpellMap& sp_list = this->ToPlayer()->GetSpellMap();
for (PlayerSpellMap::const_iterator itr = sp_list.begin();
itr != sp_list.end(); ++itr)
{
// check if shown in spell book
if (!itr->second->active || itr->second->disabled
|| itr->second->state == PLAYERSPELL_REMOVED) continue;
SpellEntry const *spellProto = sSpellStore.LookupEntry(
itr->first);
if (!spellProto) continue;
if (spellProto->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT
&& spellProto->SpellFamilyFlags [0] & 0x2000)
{
SpellChainNode const* newChain =
sSpellMgr->GetSpellChainNode(itr->first);
// No chain entry or entry lower than found entry
if (!chain || !newChain
|| (chain->rank < newChain->rank))
{
triggered_spell_id = itr->first;
chain = newChain;
}
else continue;
// Found spell is last in chain - do not need to look more
// Optimisation for most common case
if (chain && chain->last == itr->first) break;
}
}
}
// Item - Death Knight T10 Melee 4P Bonus
if (dummySpell->Id == 70656)
{
if (!this->ToPlayer()) return false;
for (uint32 i = 0; i < MAX_RUNES; ++i)
if (this->ToPlayer()->GetRuneCooldown(i) == 0) return false;
}
break;
}
case SPELLFAMILY_POTION:
{
// alchemist's stone
if (dummySpell->Id == 17619)
{
if (procSpell->SpellFamilyName == SPELLFAMILY_POTION)
{
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
{
if (procSpell->Effect [i] == SPELL_EFFECT_HEAL)
{
triggered_spell_id = 21399;
}
else if (procSpell->Effect [i] == SPELL_EFFECT_ENERGIZE)
{
triggered_spell_id = 21400;
}
else continue;
basepoints0 = int32(
CalculateSpellDamage(this, procSpell, i)
* 0.4f);
CastCustomSpell(this, triggered_spell_id, &basepoints0,
NULL, NULL, true, NULL, triggeredByAura);
}
return true;
}
}
break;
}
case SPELLFAMILY_PET:
{
switch (dummySpell->SpellIconID)
{
// Guard Dog
case 201:
{
triggered_spell_id = 54445;
target = this;
float addThreat = SpellMgr::CalculateSpellEffectAmount(
procSpell, 0, this) * triggerAmount / 100.0f;
pVictim->AddThreat(this, addThreat);
break;
}
// Silverback
case 1582:
triggered_spell_id =
dummySpell->Id == 62765 ? 62801 : 62800;
target = this;
break;
}
break;
}
default:
break;
}
// if not handled by custom case, get triggered spell from dummySpell proto
if (!triggered_spell_id) triggered_spell_id =
dummySpell->EffectTriggerSpell [triggeredByAura->GetEffIndex()];
// processed charge only counting case
if (!triggered_spell_id) return true;
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(
triggered_spell_id);
if (!triggerEntry)
{
sLog->outError(
"Unit::HandleDummyAuraProc: Spell %u have not existed triggered spell %u",
dummySpell->Id, triggered_spell_id);
return false;
}
// default case
if ((!target && !sSpellMgr->IsSrcTargetSpell(triggerEntry))
|| (target && target != this && !target->isAlive())) return false;
if (cooldown_spell_id == 0) cooldown_spell_id = triggered_spell_id;
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& ToPlayer()->HasSpellCooldown(cooldown_spell_id)) return false;
if (basepoints0) CastCustomSpell(target, triggered_spell_id, &basepoints0,
NULL, NULL, true, castItem, triggeredByAura, originalCaster);
else CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura,
originalCaster);
if (cooldown && GetTypeId() == TYPEID_PLAYER) ToPlayer()->AddSpellCooldown(
cooldown_spell_id, 0, time(NULL) + cooldown);
return true;
}
bool Unit::HandleObsModEnergyAuraProc(Unit *pVictim, uint32 /*damage*/,
AuraEffect* triggeredByAura, SpellEntry const * /*procSpell*/,
uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const *dummySpell = triggeredByAura->GetSpellProto();
//uint32 effIndex = triggeredByAura->GetEffIndex();
//int32 triggerAmount = triggeredByAura->GetAmount();
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
uint32 triggered_spell_id = 0;
Unit* target = pVictim;
int32 basepoints0 = 0;
switch (dummySpell->SpellFamilyName)
{
case SPELLFAMILY_HUNTER:
{
// Aspect of the Viper
if (dummySpell->SpellFamilyFlags [1] & 0x40000)
{
uint32 maxmana = GetMaxPower(POWER_MANA);
basepoints0 = uint32(
maxmana * GetAttackTime(RANGED_ATTACK) / 1000.0f
/ 100.0f);
target = this;
triggered_spell_id = 34075;
break;
}
break;
}
}
// processed charge only counting case
if (!triggered_spell_id) return true;
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(
triggered_spell_id);
// Try handle unknown trigger spells
if (!triggerEntry)
{
sLog->outError(
"Unit::HandleObsModEnergyAuraProc: Spell %u have not existed triggered spell %u",
dummySpell->Id, triggered_spell_id);
return false;
}
// default case
if ((!target && !sSpellMgr->IsSrcTargetSpell(triggerEntry))
|| (target && target != this && !target->isAlive())) return false;
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& this->ToPlayer()->HasSpellCooldown(triggered_spell_id)) return false;
if (basepoints0) CastCustomSpell(target, triggered_spell_id, &basepoints0,
NULL, NULL, true, castItem, triggeredByAura);
else CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->AddSpellCooldown(
triggered_spell_id, 0, time(NULL) + cooldown);
return true;
}
bool Unit::HandleModDamagePctTakenAuraProc(Unit *pVictim, uint32 /*damage*/,
AuraEffect* triggeredByAura, SpellEntry const * /*procSpell*/,
uint32 /*procFlag*/, uint32 /*procEx*/, uint32 cooldown)
{
SpellEntry const *dummySpell = triggeredByAura->GetSpellProto();
//uint32 effIndex = triggeredByAura->GetEffIndex();
//int32 triggerAmount = triggeredByAura->GetAmount();
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
uint32 triggered_spell_id = 0;
Unit* target = pVictim;
int32 basepoints0 = 0;
switch (dummySpell->SpellFamilyName)
{
case SPELLFAMILY_PALADIN:
{
// Blessing of Sanctuary
if (dummySpell->SpellFamilyFlags [0] & 0x10000000)
{
switch (getPowerType())
{
case POWER_MANA:
triggered_spell_id = 57319;
break;
default:
return false;
}
}
break;
}
}
// processed charge only counting case
if (!triggered_spell_id) return true;
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(
triggered_spell_id);
if (!triggerEntry)
{
sLog->outError(
"Unit::HandleModDamagePctTakenAuraProc: Spell %u have not existed triggered spell %u",
dummySpell->Id, triggered_spell_id);
return false;
}
// default case
if ((!target && !sSpellMgr->IsSrcTargetSpell(triggerEntry))
|| (target && target != this && !target->isAlive())) return false;
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& this->ToPlayer()->HasSpellCooldown(triggered_spell_id)) return false;
if (basepoints0) CastCustomSpell(target, triggered_spell_id, &basepoints0,
NULL, NULL, true, castItem, triggeredByAura);
else CastSpell(target, triggered_spell_id, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->AddSpellCooldown(
triggered_spell_id, 0, time(NULL) + cooldown);
return true;
}
// Used in case when access to whole aura is needed
// All procs should be handled like this...
bool Unit::HandleAuraProc(Unit * pVictim, uint32 damage, Aura * triggeredByAura,
SpellEntry const * procSpell, uint32 /*procFlag*/, uint32 procEx,
uint32 cooldown, bool * handled)
{
SpellEntry const *dummySpell = triggeredByAura->GetSpellProto();
switch (dummySpell->SpellFamilyName)
{
case SPELLFAMILY_GENERIC:
switch (dummySpell->Id)
{
// Pursuit of Justice
//case 26022:
//case 26023: {
// *handled = true;
// Hack, we need the new spell dbcs implemented in
// order to add the missing spell 32733 wich i suppose,
// is the cooldown marker used by blizz to share the cd
// of Pursuit of justice and Blessed life proc.
//if (!HasAura(31828) && !HasAura(31829) && (GetAllSpellMechanicMask(procSpell) && ((1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN) | (1 << MECHANIC_FEAR)))) {
// CastSpell(pVictim, 89024, true);
// return true;
//}
//break;
//}
// Bone Shield cooldown
case 49222:
{
*handled = true;
if (cooldown && GetTypeId() == TYPEID_PLAYER)
{
if (ToPlayer()->HasSpellCooldown(100000)) return false;
ToPlayer()->AddSpellCooldown(100000, 0,
time(NULL) + cooldown);
}
return true;
}
// Nevermelting Ice Crystal
case 71564:
RemoveAuraFromStack(71564);
*handled = true;
break;
case 71756:
case 72782:
case 72783:
case 72784:
RemoveAuraFromStack(dummySpell->Id);
*handled = true;
break;
// Discerning Eye of the Beast
case 59915:
{
CastSpell(this, 59914, true); // 59914 already has correct basepoints in DBC, no need for custom bp
*handled = true;
break;
}
// Swift Hand of Justice
case 59906:
{
int32 bp0 = CalculatePctN(
GetMaxHealth(),
SpellMgr::CalculateSpellEffectAmount(dummySpell,
0));
CastCustomSpell(this, 59913, &bp0, NULL, NULL, true);
*handled = true;
break;
}
}
break;
case SPELLFAMILY_PALADIN:
{
// Judgements of the Just
if (dummySpell->SpellIconID == 3015)
{
*handled = true;
if (procSpell->Category == SPELLCATEGORY_JUDGEMENT)
{
CastSpell(pVictim, 68055, true);
return true;
}
}
// Light's Grace (temp solution)
else if (dummySpell->Id == 31834)
{
*handled = true;
int32 removeChance = 0;
if (AuraEffect* aurEff = GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_PALADIN, 2141, 0)) removeChance =
aurEff->GetSpellProto()->procChance;
if (!roll_chance_i(removeChance)) return true;
break;
}
// Glyph of Divinity
else if (dummySpell->Id == 54939)
{
*handled = true;
// Check if we are the target and prevent mana gain
if (triggeredByAura->GetCasterGUID() == pVictim->GetGUID()) return false;
// Lookup base amount mana restore
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; i++)
{
if (procSpell->Effect [i] == SPELL_EFFECT_ENERGIZE)
{
// value multiplied by 2 because you should get twice amount
int32 mana = SpellMgr::CalculateSpellEffectAmount(
procSpell, i) * 2;
CastCustomSpell(this, 54986, 0, &mana, NULL, true);
}
}
return true;
}
break;
}
case SPELLFAMILY_MAGE:
{
// Combustion
switch (dummySpell->Id)
{
case 11129:
{
*handled = true;
Unit *caster = triggeredByAura->GetCaster();
if (!caster || !damage) return false;
//last charge and crit
if (triggeredByAura->GetCharges() <= 1
&& (procEx & PROC_EX_CRITICAL_HIT))
{
RemoveAurasDueToSpell(28682); //-> remove Combustion auras
return true; // charge counting (will removed)
}
// This function can be called twice during one spell hit (Area of Effect spells)
// Make sure 28682 wasn't already removed by previous call
if (HasAura(28682)) this->CastSpell(this, 28682, true);
return false; // ordinary chrages will be removed during crit chance computations.
}
// Empowered Fire
case 31656:
case 31657:
case 31658:
{
*handled = true;
SpellEntry const *spInfo = sSpellStore.LookupEntry(67545);
if (!spInfo) return false;
int32 bp0 = this->GetCreateMana()
* SpellMgr::CalculateSpellEffectAmount(spInfo, 0)
/ 100;
this->CastCustomSpell(this, 67545, &bp0, NULL, NULL, true,
NULL, triggeredByAura->GetEffect(0),
this->GetGUID());
return true;
}
}
break;
}
case SPELLFAMILY_DEATHKNIGHT:
{
// Blood of the North
// Reaping
// Death Rune Mastery
if (dummySpell->SpellIconID == 3041 || dummySpell->SpellIconID == 22
|| dummySpell->SpellIconID == 2622)
{
*handled = true;
// Convert recently used Blood Rune to Death Rune
if (GetTypeId() == TYPEID_PLAYER)
{
if (this->ToPlayer()->getClass() != CLASS_DEATH_KNIGHT) return false;
RuneType rune = this->ToPlayer()->GetLastUsedRune();
AuraEffect * aurEff = triggeredByAura->GetEffect(0);
if (!aurEff) return false;
// Reset amplitude - set death rune remove timer to 30s
aurEff->ResetPeriodic(true);
uint32 runesLeft;
if (dummySpell->SpellIconID == 2622) runesLeft = 2;
else runesLeft = 1;
for (uint8 i = 0; i < MAX_RUNES && runesLeft; ++i)
{
if (dummySpell->SpellIconID == 2622)
{
if (((Player*) this)->GetCurrentRune(i)
== RUNE_DEATH
|| ((Player*) this)->GetBaseRune(i)
== RUNE_BLOOD) continue;
}
else
{
if (((Player*) this)->GetCurrentRune(i)
== RUNE_DEATH
|| ((Player*) this)->GetBaseRune(i)
!= RUNE_BLOOD) continue;
}
if (((Player*) this)->GetRuneCooldown(i)
!= ((Player*) this)->GetRuneBaseCooldown(i)) continue;
--runesLeft;
// Mark aura as used
((Player*) this)->AddRuneByAuraEffect(i, RUNE_DEATH,
aurEff);
}
return true;
}
return false;
}
switch (dummySpell->Id)
{
// Hungering Cold aura drop
case 51209:
*handled = true;
// Drop only in not disease case
if (procSpell && procSpell->Dispel == DISPEL_DISEASE) return false;
return true;
}
break;
}
}
return false;
}
bool Unit::HandleProcTriggerSpell(Unit *pVictim, uint32 damage,
AuraEffect* triggeredByAura, SpellEntry const *procSpell,
uint32 procFlags, uint32 procEx, uint32 cooldown)
{
// Get triggered aura spell info
SpellEntry const* auraSpellInfo = triggeredByAura->GetSpellProto();
// Basepoints of trigger aura
int32 triggerAmount = triggeredByAura->GetAmount();
// Set trigger spell id, target, custom basepoints
uint32 trigger_spell_id =
auraSpellInfo->EffectTriggerSpell [triggeredByAura->GetEffIndex()];
Unit* target = NULL;
int32 basepoints0 = 0;
if (triggeredByAura->GetAuraType()
== SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE) basepoints0 =
triggerAmount;
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
// Try handle unknown trigger spells
if (sSpellStore.LookupEntry(trigger_spell_id) == NULL)
{
switch (auraSpellInfo->SpellFamilyName)
{
case SPELLFAMILY_GENERIC:
switch (auraSpellInfo->Id)
{
case 56614: // Wrecking Crew
trigger_spell_id = 57522;
target = this;
break;
case 23780: // Aegis of Preservation (Aegis of Preservation trinket)
trigger_spell_id = 23781;
break;
case 33896: // Desperate Defense (Stonescythe Whelp, Stonescythe Alpha, Stonescythe Ambusher)
trigger_spell_id = 33898;
break;
case 43820: // Charm of the Witch Doctor (Amani Charm of the Witch Doctor trinket)
// Pct value stored in dummy
basepoints0 = pVictim->GetCreateHealth()
* SpellMgr::CalculateSpellEffectAmount(
auraSpellInfo, 1) / 100;
target = pVictim;
break;
case 57345: // Darkmoon Card: Greatness
{
float stat = 0.0f;
// strength
if (GetStat(STAT_STRENGTH) > stat)
{
trigger_spell_id = 60229;
stat = GetStat(STAT_STRENGTH);
}
// agility
if (GetStat(STAT_AGILITY) > stat)
{
trigger_spell_id = 60233;
stat = GetStat(STAT_AGILITY);
}
// intellect
if (GetStat(STAT_INTELLECT) > stat)
{
trigger_spell_id = 60234;
stat = GetStat(STAT_INTELLECT);
}
// spirit
if (GetStat(STAT_SPIRIT) > stat)
{
trigger_spell_id = 60235;
}
break;
}
case 64568: // Blood Reserve
{
if (GetHealth() - damage < GetMaxHealth() * 0.35)
{
basepoints0 = triggerAmount;
trigger_spell_id = 64569;
RemoveAura(64568);
}
break;
}
case 67702: // Death's Choice, Item - Coliseum 25 Normal Melee Trinket
{
float stat = 0.0f;
// strength
if (GetStat(STAT_STRENGTH) > stat)
{
trigger_spell_id = 67708;
stat = GetStat(STAT_STRENGTH);
}
// agility
if (GetStat(STAT_AGILITY) > stat)
{
trigger_spell_id = 67703;
}
break;
}
case 67771: // Death's Choice (heroic), Item - Coliseum 25 Heroic Melee Trinket
{
float stat = 0.0f;
// strength
if (GetStat(STAT_STRENGTH) > stat)
{
trigger_spell_id = 67773;
stat = GetStat(STAT_STRENGTH);
}
// agility
if (GetStat(STAT_AGILITY) > stat)
{
trigger_spell_id = 67772;
}
break;
}
// Mana Drain Trigger
case 27522:
case 40336:
{
// On successful melee or ranged attack gain $29471s1 mana and if possible drain $27526s1 mana from the target.
if (this && this->isAlive()) CastSpell(this, 29471,
true, castItem, triggeredByAura);
if (pVictim && pVictim->isAlive()) CastSpell(pVictim,
27526, true, castItem, triggeredByAura);
return true;
}
}
break;
case SPELLFAMILY_MAGE:
if (auraSpellInfo->SpellIconID == 2127) // Blazing Speed
{
switch (auraSpellInfo->Id)
{
case 31641: // Rank 1
case 31642: // Rank 2
trigger_spell_id = 31643;
break;
default:
sLog->outError(
"Unit::HandleProcTriggerSpell: Spell %u miss posibly Blazing Speed",
auraSpellInfo->Id);
return false;
}
}
break;
case SPELLFAMILY_WARRIOR:
switch (auraSpellInfo->Id)
{
case 50421: // Scent of Blood
trigger_spell_id = 50422;
break;
case 80128: // Impending Victory Rank 1
case 80129: // Impending Victory Rank 2
if (!pVictim->HealthBelowPct(20)) return false;
case 93098:
if (damage > 0)
{
int bp = damage * 0.05f; //5% from damage
CastCustomSpell(this, 76691, &bp, &bp, &bp, true, 0,
0, GetGUID());
}
break;
}
break;
case SPELLFAMILY_WARLOCK:
{
// Drain Soul
if (auraSpellInfo->SpellFamilyFlags [0] & 0x4000)
{
// Improved Drain Soul
Unit::AuraEffectList const& mAddFlatModifier =
GetAuraEffectsByType(SPELL_AURA_DUMMY);
for (Unit::AuraEffectList::const_iterator i =
mAddFlatModifier.begin();
i != mAddFlatModifier.end(); ++i)
{
if ((*i)->GetMiscValue() == SPELLMOD_CHANCE_OF_SUCCESS
&& (*i)->GetSpellProto()->SpellIconID == 113)
{
int32 value2 = CalculateSpellDamage(this,
(*i)->GetSpellProto(), 2);
basepoints0 = value2 * GetMaxPower(POWER_MANA)
/ 100;
// Drain Soul
CastCustomSpell(this, 18371, &basepoints0, NULL,
NULL, true, castItem, triggeredByAura);
break;
}
}
// Not remove charge (aura removed on death in any cases)
// Need for correct work Drain Soul SPELL_AURA_CHANNEL_DEATH_ITEM aura
return false;
}
// Nether Protection
else if (auraSpellInfo->SpellIconID == 1985)
{
if (!procSpell) return false;
switch (GetFirstSchoolInMask(GetSpellSchoolMask(procSpell)))
{
case SPELL_SCHOOL_NORMAL:
return false; // ignore
case SPELL_SCHOOL_HOLY:
trigger_spell_id = 54370;
break;
case SPELL_SCHOOL_FIRE:
trigger_spell_id = 54371;
break;
case SPELL_SCHOOL_NATURE:
trigger_spell_id = 54375;
break;
case SPELL_SCHOOL_FROST:
trigger_spell_id = 54372;
break;
case SPELL_SCHOOL_SHADOW:
trigger_spell_id = 54374;
break;
case SPELL_SCHOOL_ARCANE:
trigger_spell_id = 54373;
break;
default:
return false;
}
}
break;
}
case SPELLFAMILY_PRIEST:
{
// Greater Heal Refund
if (auraSpellInfo->Id == 37594) trigger_spell_id = 37595;
// Blessed Recovery
else if (auraSpellInfo->SpellIconID == 1875)
{
switch (auraSpellInfo->Id)
{
case 27811:
trigger_spell_id = 27813;
break;
case 27815:
trigger_spell_id = 27817;
break;
case 27816:
trigger_spell_id = 27818;
break;
default:
sLog->outError(
"Unit::HandleProcTriggerSpell: Spell %u not handled in BR",
auraSpellInfo->Id);
return false;
}
basepoints0 = CalculatePctN(int32(damage), triggerAmount)
/ 3;
target = this;
if (AuraEffect * aurEff = target->GetAuraEffect(trigger_spell_id, 0)) basepoints0 +=
aurEff->GetAmount();
}
break;
}
case SPELLFAMILY_DRUID:
{
switch (auraSpellInfo->Id)
{
// Druid Forms Trinket
case 37336:
{
switch (GetShapeshiftForm())
{
case FORM_NONE: trigger_spell_id = 37344; break;
case FORM_CAT: trigger_spell_id = 37341; break;
case FORM_BEAR:
case FORM_DIREBEAR: trigger_spell_id = 37340; break;
case FORM_TREE: trigger_spell_id = 37342; break;
case FORM_MOONKIN: trigger_spell_id = 37343; break;
default:
return false;
}
break;
}
// Druid T9 Feral Relic (Lacerate, Swipe, Mangle, and Shred)
case 67353:
{
switch (GetShapeshiftForm())
{
case FORM_CAT: trigger_spell_id = 67355; break;
case FORM_BEAR:
case FORM_DIREBEAR: trigger_spell_id = 67354; break;
default:
return false;
}
break;
}
// Shooting Stars
case 93398: // Rank 1
case 93399: // Rank 2
{
if (GetTypeId() == TYPEID_PLAYER)
ToPlayer()->RemoveSpellCooldown(78674, true); // Remove cooldown of Starsurge
break;
}
default:
break;
}
break;
}
case SPELLFAMILY_HUNTER:
{
if (auraSpellInfo->SpellIconID == 3247) // Piercing Shots 1, 2, 3
{
trigger_spell_id = 63468;
SpellEntry const *TriggerPS = sSpellStore.LookupEntry(
trigger_spell_id);
if (!TriggerPS) return false;
basepoints0 =
int32(
(damage
* (auraSpellInfo->EffectBasePoints [0]
/ 100))
/ (GetSpellMaxDuration(TriggerPS)
/ 1000));
basepoints0 += pVictim->GetRemainingDotDamage(GetGUID(),
trigger_spell_id);
break;
}
if (auraSpellInfo->SpellIconID == 2225) // Serpent Spread 1, 2
{
if (!(auraSpellInfo->procFlags == 0x1140)) return false;
switch (auraSpellInfo->Id)
{
case 87934:
trigger_spell_id = 88453;
break;
case 87935:
trigger_spell_id = 88466;
break;
default:
return false;
}
break;
}
if (auraSpellInfo->Id == 82661) // Aspect of the Fox: Focus bonus
{
if (!((auraSpellInfo->procFlags
& PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK)
|| (auraSpellInfo->procFlags
& PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS))) return false;
target = this;
basepoints0 = auraSpellInfo->EffectBasePoints [0];
trigger_spell_id = 82716;
break;
}
break;
}
case SPELLFAMILY_PALADIN:
{
switch (auraSpellInfo->Id)
{
// Healing Discount
case 37705:
{
trigger_spell_id = 37706;
target = this;
break;
}
// Soul Preserver
case 60510:
{
switch (getClass())
{
case CLASS_DRUID:
trigger_spell_id = 60512;
break;
case CLASS_PALADIN:
trigger_spell_id = 60513;
break;
case CLASS_PRIEST:
trigger_spell_id = 60514;
break;
case CLASS_SHAMAN:
trigger_spell_id = 60515;
break;
}
target = this;
break;
}
case 37657: // Lightning Capacitor
case 54841: // Thunder Capacitor
case 67712: // Item - Coliseum 25 Normal Caster Trinket
case 67758: // Item - Coliseum 25 Heroic Caster Trinket
{
if (!pVictim || !pVictim->isAlive() || GetTypeId() != TYPEID_PLAYER)
return false;
uint32 stack_spell_id = 0;
switch (auraSpellInfo->Id)
{
case 37657:
stack_spell_id = 37658;
trigger_spell_id = 37661;
break;
case 54841:
stack_spell_id = 54842;
trigger_spell_id = 54843;
break;
case 67712:
stack_spell_id = 67713;
trigger_spell_id = 67714;
break;
case 67758:
stack_spell_id = 67759;
trigger_spell_id = 67760;
break;
}
CastSpell(this, stack_spell_id, true, NULL, triggeredByAura);
Aura* dummy = GetAura(stack_spell_id);
if (!dummy || dummy->GetStackAmount() < triggerAmount)
return false;
RemoveAurasDueToSpell(stack_spell_id);
target = pVictim;
break;
}
default:
// Illumination
if (auraSpellInfo->SpellIconID == 241)
{
if (!procSpell) return false;
// procspell is triggered spell but we need mana cost of original casted spell
uint32 originalSpellId = procSpell->Id;
// Holy Shock heal
if (procSpell->SpellFamilyFlags [1] & 0x00010000)
{
switch (procSpell->Id)
{
case 25914:
originalSpellId = 20473;
break;
default:
sLog->outError(
"Unit::HandleProcTriggerSpell: Spell %u not handled in HShock",
procSpell->Id);
return false;
}
}
SpellEntry const *originalSpell =
sSpellStore.LookupEntry(originalSpellId);
if (!originalSpell)
{
sLog->outError(
"Unit::HandleProcTriggerSpell: Spell %u unknown but selected as original in Illu",
originalSpellId);
return false;
}
// percent stored in effect 1 (class scripts) base points
int32 cost = originalSpell->manaCost
+ originalSpell->ManaCostPercentage
* GetCreateMana() / 100;
basepoints0 = cost
* SpellMgr::CalculateSpellEffectAmount(
auraSpellInfo, 1) / 100;
trigger_spell_id = 20272;
target = this;
}
break;
}
break;
}
case SPELLFAMILY_SHAMAN:
{
switch (auraSpellInfo->Id)
{
// Lightning Shield (The Ten Storms set)
case 23551:
{
trigger_spell_id = 23552;
target = pVictim;
break;
}
// Damage from Lightning Shield (The Ten Storms set)
case 23552:
{
trigger_spell_id = 27635;
break;
}
// Mana Surge (The Earthfury set)
case 23572:
{
if (!procSpell) return false;
basepoints0 = procSpell->manaCost * 35 / 100;
trigger_spell_id = 23571;
target = this;
break;
}
default:
{
// Lightning Shield (overwrite non existing triggered spell call in spell.dbc
if (auraSpellInfo->SpellFamilyFlags [0] & 0x400)
{
trigger_spell_id = sSpellMgr->GetSpellWithRank(
26364,
sSpellMgr->GetSpellRank(auraSpellInfo->Id));
}
// Nature's Guardian
else if (auraSpellInfo->SpellIconID == 2013)
{
// Check health condition - should drop to less 30% (damage deal after this!)
if (!HealthBelowPctDamaged(30, damage)) return false;
if (pVictim && pVictim->isAlive()) pVictim->getThreatManager().modifyThreatPercent(
this, -10);
basepoints0 = int32(
CountPctFromMaxHealth(triggerAmount));
trigger_spell_id = 31616;
target = this;
}
}
}
break;
}
case SPELLFAMILY_DEATHKNIGHT:
{
// Acclimation
if (auraSpellInfo->SpellIconID == 1930)
{
if (!procSpell) return false;
switch (GetFirstSchoolInMask(GetSpellSchoolMask(procSpell)))
{
case SPELL_SCHOOL_NORMAL:
return false; // ignore
case SPELL_SCHOOL_HOLY:
trigger_spell_id = 50490;
break;
case SPELL_SCHOOL_FIRE:
trigger_spell_id = 50362;
break;
case SPELL_SCHOOL_NATURE:
trigger_spell_id = 50488;
break;
case SPELL_SCHOOL_FROST:
trigger_spell_id = 50485;
break;
case SPELL_SCHOOL_SHADOW:
trigger_spell_id = 50489;
break;
case SPELL_SCHOOL_ARCANE:
trigger_spell_id = 50486;
break;
default:
return false;
}
}
// Blood Presence (Improved)
else if (auraSpellInfo->Id == 63611)
{
if (GetTypeId() != TYPEID_PLAYER) return false;
trigger_spell_id = 50475;
basepoints0 = damage * triggerAmount / 100;
}
break;
}
default:
break;
}
}
// All ok. Check current trigger spell
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(trigger_spell_id);
if (triggerEntry == NULL)
{
// Not cast unknown spell
// sLog->outError("Unit::HandleProcTriggerSpell: Spell %u have 0 in EffectTriggered[%d], not handled custom case?", auraSpellInfo->Id, triggeredByAura->GetEffIndex());
return false;
}
// not allow proc extra attack spell at extra attack
if (m_extraAttacks
&& IsSpellHaveEffect(triggerEntry, SPELL_EFFECT_ADD_EXTRA_ATTACKS)) return false;
// Custom requirements (not listed in procEx) Warning! damage dealing after this
// Custom triggered spells
switch (auraSpellInfo->Id)
{
// Persistent Shield (Scarab Brooch trinket)
// This spell originally trigger 13567 - Dummy Trigger (vs dummy efect)
case 26467:
{
basepoints0 = damage * 15 / 100;
target = pVictim;
trigger_spell_id = 26470;
break;
}
// Unyielding Knights (item exploit 29108\29109)
case 38164:
{
if (!pVictim || pVictim->GetEntry() != 19457) // Proc only if your target is Grillok
return false;
break;
}
// Deflection
case 52420:
{
if (!HealthBelowPct(35)) return false;
break;
}
// Sacred Shield
case 85285:
{
if (!HealthBelowPct(30)) return false;
break;
}
// Improved Hamstring
case 12289:
case 12668:
{
if (!pVictim->HasAura(1715)) return false;
break;
}
// Brambles
case 50419:
{
if (!roll_chance_i(triggerAmount)) return false;
break;
}
// Cheat Death
case 28845:
{
// When your health drops below 20%
if (HealthBelowPctDamaged(20, damage) || HealthBelowPct(20)) return false;
break;
}
// Protector of the Innocent
case 20138:
case 20139:
case 20140:
{
if (pVictim == this) return false;
break;
}
// Deadly Swiftness (Rank 1)
case 31255:
{
// whenever you deal damage to a target who is below 20% health.
if (!pVictim || !pVictim->isAlive() || pVictim->HealthAbovePct(20)) return false;
target = this;
trigger_spell_id = 22588;
}
// Glyph of Shadow Word: Pain
case 55681:
{
// Shadow Word: Pain
if (!(procSpell->SpellFamilyFlags [0] & 0x8000)) return false;
break;
}
// Greater Heal Refund (Avatar Raiment set)
case 37594:
{
if (!pVictim || !pVictim->isAlive()) return false;
// Not give if target already have full health
if (pVictim->IsFullHealth()) return false;
// If your Greater Heal brings the target to full health, you gain $37595s1 mana.
if (pVictim->GetHealth() + damage < pVictim->GetMaxHealth()) return false;
break;
}
// Bonus Healing (Crystal Spire of Karabor mace)
case 40971:
{
// If your target is below $s1% health
if (!pVictim || !pVictim->isAlive()
|| pVictim->HealthAbovePct(triggerAmount)) return false;
break;
}
// Evasive Maneuvers (Commendation of Kael`thas trinket)
case 45057:
{
// reduce you below $s1% health
if (GetHealth() - damage > GetMaxHealth() * triggerAmount / 100) return false;
break;
}
// Rapid Recuperation
case 53228:
case 53232:
{
// This effect only from Rapid Fire (ability cast)
if (!(procSpell->SpellFamilyFlags [0] & 0x20)) return false;
break;
}
// Decimation
case 63156:
case 63158:
// Can proc only if target has hp below 35%
if (!pVictim
|| !pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT,
procSpell, this)) return false;
break;
// Deathbringer Saurfang - Rune of Blood
case 72408:
// can proc only if target is marked with rune
if (!pVictim->HasAura(72410)) return false;
break;
// Deathbringer Saurfang - Blood Beast's Blood Link
case 72176:
basepoints0 = 3;
break;
case 15337: // Improved Spirit Tap (Rank 1)
case 15338: // Improved Spirit Tap (Rank 2)
{
if (procSpell->SpellFamilyFlags [0] & 0x800000) if ((procSpell->Id
!= 58381) || !roll_chance_i(50)) return false;
target = pVictim;
break;
}
default:
break;
}
// Sword Specialization
if (auraSpellInfo->SpellFamilyName == SPELLFAMILY_GENERIC
&& auraSpellInfo->SpellIconID == 1462 && procSpell) if (Player * plr = ToPlayer())
{
if (cooldown && plr->HasSpellCooldown(16459)) return false;
// this required for attacks like Mortal Strike
plr->RemoveSpellCooldown(procSpell->Id);
CastSpell(pVictim, procSpell->Id, true);
if (cooldown) plr->AddSpellCooldown(16459, 0, time(NULL) + cooldown);
return true;
}
// Blade Barrier
if (auraSpellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT
&& auraSpellInfo->SpellIconID == 85)
{
Player * plr = this->ToPlayer();
if (this->GetTypeId() != TYPEID_PLAYER || !plr
|| plr->getClass() != CLASS_DEATH_KNIGHT) return false;
if (!plr->IsBaseRuneSlotsOnCooldown(RUNE_BLOOD)) return false;
}
// Rime
else if (auraSpellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT
&& auraSpellInfo->SpellIconID == 56)
{
if (GetTypeId() != TYPEID_PLAYER) return false;
// Howling Blast
this->ToPlayer()->RemoveSpellCategoryCooldown(1248, true);
}
// Death's Advance
if (auraSpellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT
&& auraSpellInfo->SpellIconID == 3315)
{
Player* player = ToPlayer();
if (!player || player->getClass() != CLASS_DEATH_KNIGHT) return false;
if (!player->IsBaseRuneSlotsOnCooldown(RUNE_UNHOLY)) return false;
}
// Custom basepoints/target for exist spell
// dummy basepoints or other customs
switch (trigger_spell_id)
{
// Strength of Soul
case 89490:
if (procSpell->Id == 2050 || procSpell->Id == 2060 || procSpell->Id == 2061)
{
if (pVictim->HasAura(6788))
{
uint32 newCooldownDelay = pVictim->GetAura(6788)->GetDuration();
if (newCooldownDelay <= (triggeredByAura->GetSpellProto()->GetSpellEffect(0)->EffectBasePoints)*1000)
newCooldownDelay = 0;
else
newCooldownDelay -= ((triggeredByAura->GetSpellProto()->GetSpellEffect(0)->EffectBasePoints)*1000);
pVictim->GetAura(6788)->SetDuration(newCooldownDelay, true);
}
}
break;
// Will of Necropolis
case 81162:
if (HealthBelowPct(29) || (!HealthBelowPctDamaged(30, damage))) return false;
else
{
if (!ToPlayer()->HasSpellCooldown(trigger_spell_id))
{
AddAura(trigger_spell_id, this);
ToPlayer()->AddSpellCooldown(trigger_spell_id, 0,
time(NULL) + 15);
}
}
break;
case 92184: // Lead Plating
case 92233: // Tectonic Shift
case 92355: // Turn of the Worm
case 92235: // Turn of the Worm
case 90996: // Crescendo of Suffering
case 91002: // Crescendo of Suffering
case 75477: // Scale Nimbleness
case 75480: // Scaly Nimbleness
case 71633: // Thick Skin
case 71639: // Thick Skin
if (HealthBelowPct(34) || (!HealthBelowPctDamaged(35, damage))) return false;
else
{
if (!ToPlayer()->HasSpellCooldown(trigger_spell_id))
{
AddAura(trigger_spell_id, this);
ToPlayer()->AddSpellCooldown(trigger_spell_id, 0,
time(NULL) + 30);
}
}
break;
// Die by the Sword
case 85386:
case 86624:
if (HealthBelowPct(19) || (!HealthBelowPctDamaged(20, damage))) return false;
else
{
if (!ToPlayer()->HasSpellCooldown(trigger_spell_id))
{
AddAura(trigger_spell_id, this);
ToPlayer()->AddSpellCooldown(trigger_spell_id, 0,
time(NULL) + 120);
}
}
break;
// Auras which should proc on area aura source (caster in this case):
// Turn the Tables
case 52914:
case 52915:
case 52910:
// Cast positive spell on enemy target
case 7099: // Curse of Mending
case 39703: // Curse of Mending
case 29494: // Temptation
case 20233: // Improved Lay on Hands (cast on target)
{
target = pVictim;
break;
}
// Combo points add triggers (need add combopoint only for main target, and after possible combopoints reset)
case 15250: // Rogue Setup
{
if (!pVictim || pVictim != getVictim()) // applied only for main target
return false;
break; // continue normal case
}
// Finish movies that add combo
case 14189: // Seal Fate (Netherblade set)
case 14157: // Ruthlessness
{
if (!pVictim || pVictim == this) return false;
// Need add combopoint AFTER finish movie (or they dropped in finish phase)
break;
}
// Bloodthirst (($m/100)% of max health)
case 23880:
{
basepoints0 = int32(CountPctFromMaxHealth(triggerAmount) / 1000);
break;
}
// Shamanistic Rage triggered spell
case 30824:
{
basepoints0 = int32(
GetTotalAttackPowerValue(BASE_ATTACK) * triggerAmount
/ 100);
break;
}
// Enlightenment (trigger only from mana cost spells)
case 35095:
{
if (!procSpell || procSpell->powerType != POWER_MANA
|| (procSpell->manaCost == 0
&& procSpell->ManaCostPercentage == 0
&& procSpell->manaCostPerlevel == 0)) return false;
break;
}
// Demonic Pact
case 48090:
{
// Get talent aura from owner
if (isPet()) if (Unit * owner = GetOwner())
{
if (AuraEffect * aurEff = owner->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 3220, 0))
{
basepoints0 = int32(
(aurEff->GetAmount()
* owner->SpellBaseDamageBonus(
SpellSchoolMask(
SPELL_SCHOOL_MASK_MAGIC))
+ 100.0f) / 100.0f);
CastCustomSpell(this, trigger_spell_id, &basepoints0,
&basepoints0, NULL, true, castItem,
triggeredByAura);
return true;
}
}
break;
}
// Sword and Board
case 50227:
{
// Remove cooldown on Shield Slam
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->RemoveSpellCategoryCooldown(
1209, true);
break;
}
// Maelstrom Weapon
case 53817:
{
// Item - Shaman T10 Enhancement 4P Bonus
if (AuraEffect const* aurEff = GetAuraEffect(70832, 0)) if (Aura const* maelstrom = GetAura(53817)) if ((maelstrom->GetStackAmount()
== maelstrom->GetSpellProto()->StackAmount)
&& roll_chance_i(aurEff->GetAmount())) CastSpell(this,
70831, true, castItem, triggeredByAura);
// have rank dependent proc chance, ignore too often cases
// PPM = 2.5 * (rank of talent),
uint32 rank = sSpellMgr->GetSpellRank(auraSpellInfo->Id);
// 5 rank -> 100% 4 rank -> 80% and etc from full rate
if (!roll_chance_i(20 * rank) + 1) return false;
break;
}
// Rolling Thunder
case 88765:
{
if (Aura * lightningShield = GetAura(324))
{
uint8 lsCharges = lightningShield->GetCharges();
if (lsCharges < 9)
{
lightningShield->SetCharges(lsCharges + 1);
}
}
break;
}
// Astral Shift
case 52179:
{
if (procSpell == 0
|| !(procEx & (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT))
|| this == pVictim) return false;
// Need stun, fear or silence mechanic
if (!(GetAllSpellMechanicMask(procSpell)
& ((1 << MECHANIC_SILENCE) | (1 << MECHANIC_STUN)
| (1 << MECHANIC_FEAR)))) return false;
break;
}
// Burning Determination
case 54748:
{
if (!procSpell) return false;
// Need Interrupt or Silenced mechanic
if (!(GetAllSpellMechanicMask(procSpell)
& ((1 << MECHANIC_INTERRUPT) | (1 << MECHANIC_SILENCE)))) return false;
break;
}
// Lock and Load
case 56453:
{
// Proc only from Frost/Freezing trap activation or from Freezing Arrow (the periodic dmg proc handled elsewhere)
if (!(procFlags & PROC_FLAG_DONE_TRAP_ACTIVATION) || !procSpell
|| !(procSpell->SchoolMask & SPELL_SCHOOL_MASK_FROST)
|| !roll_chance_i(triggerAmount)) return false;
break;
}
// Glyph of Death's Embrace
case 58679:
{
// Proc only from healing part of Death Coil. Check is essential as all Death Coil spells have 0x2000 mask in SpellFamilyFlags
if (!procSpell
|| !(procSpell->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT
&& procSpell->SpellFamilyFlags [0] == 0x80002000)) return false;
break;
}
// Glyph of Death Grip
case 58628:
{
// remove cooldown of Death Grip
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->RemoveSpellCooldown(
49576, true);
return true;
}
// Savage Defense
case 62606:
{
basepoints0 = int32(
GetTotalAttackPowerValue(BASE_ATTACK) * triggerAmount
/ 100.0f);
break;
}
// Body and Soul
case 64128:
case 65081:
{
// Proc only from PW:S cast
if (!(procSpell->SpellFamilyFlags [0] & 0x00000001)) return false;
break;
}
// Culling the Herd
case 70893:
{
// check if we're doing a critical hit
if (!(procSpell->SpellFamilyFlags [1] & 0x10000000)
&& (procEx != PROC_EX_CRITICAL_HIT)) return false;
// check if we're procced by Claw, Bite or Smack (need to use the spell icon ID to detect it)
if (!(procSpell->SpellIconID == 262
|| procSpell->SpellIconID == 1680
|| procSpell->SpellIconID == 473)) return false;
break;
}
// Deathbringer Saurfang - Blood Link
case 72202:
target = FindNearestCreature(37813, 75.0f); // NPC_DEATHBRINGER_SAURFANG = 37813
break;
// Shadow's Fate (Shadowmourne questline)
case 71169:
{
if (GetTypeId() != TYPEID_PLAYER) return false;
Player* player = this->ToPlayer();
if (player->GetQuestStatus(24749) == QUEST_STATUS_INCOMPLETE) // Unholy Infusion
{
if (!player->HasAura(71516) || pVictim->GetEntry() != 36678) // Shadow Infusion && Professor Putricide
return false;
}
else if (player->GetQuestStatus(24756) == QUEST_STATUS_INCOMPLETE) // Blood Infusion
{
if (!player->HasAura(72154) || pVictim->GetEntry() != 37955) // Thirst Quenched && Blood-Queen Lana'thel
return false;
}
else if (player->GetQuestStatus(24757) == QUEST_STATUS_INCOMPLETE) // Frost Infusion
{
if (!player->HasAura(72290) || pVictim->GetEntry() != 36853) // Frost-Imbued Blade && Sindragosa
return false;
}
else if (player->GetQuestStatus(24547) != QUEST_STATUS_INCOMPLETE) // A Feast of Souls
return false;
if (pVictim->GetTypeId() != TYPEID_UNIT) return false;
// critters are not allowed
if (pVictim->GetCreatureType() == CREATURE_TYPE_CRITTER) return false;
break;
}
// Incite:
// gives your Heroic Strike criticals a 100% chance to cause the next Heroic Strike to also be a critical strike.
// These guaranteed criticals cannot re-trigger the Incite effect.
case 86627:
{
if (HasAura(86627)) return false;
break;
}
// Demonic Circle: Summon
case 48018:
{
if (HasAura(48018)) target->RemoveAura(48018);
return false;
break;
}
// Seal of Insight
// giving each single-target melee attack a chance to heal the Paladin for (0.15 * AP + 0.15 * holy power) and restore 4% of the Paladin's base mana.
// Unleashing this Seal's energy will ... restore 15% of the Paladin's base mana.
case 20167:
{
int32 triggerAmount1 = 0;
if (procSpell && procSpell->Id == 54158) // Judgment, unleashing case
{
basepoints0 = 0; // no heal effect when unleashing Seal of Insight
triggerAmount1 = triggerAmount; // restore 15% base mana
}
else
{
basepoints0 = triggerAmount; // actual heal amount will be calculated in Spell::EffectHeal
if (SpellEntry const* triggeredSpellInfo = sSpellStore.LookupEntry(trigger_spell_id))
triggerAmount1 = triggeredSpellInfo->EffectBasePoints[1]; // restore 4% base mana
}
int32 basepoints1 = GetCreatePowers(POWER_MANA) * triggerAmount1 / 100;
CastCustomSpell(target, trigger_spell_id, &basepoints0, &basepoints1, NULL, true, castItem, triggeredByAura);
return true;
}
}
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& ToPlayer()->HasSpellCooldown(trigger_spell_id)) return false;
// try detect target manually if not set
if (target == NULL) target =
!(procFlags
& (PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS
| PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS))
&& IsPositiveSpell(trigger_spell_id) ? this : pVictim;
// default case
if ((!target && !sSpellMgr->IsSrcTargetSpell(triggerEntry))
|| (target && target != this && !target->isAlive())) return false;
if (basepoints0) CastCustomSpell(target, trigger_spell_id, &basepoints0,
NULL, NULL, true, castItem, triggeredByAura);
else CastSpell(target, trigger_spell_id, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER) ToPlayer()->AddSpellCooldown(
trigger_spell_id, 0, time(NULL) + cooldown);
return true;
}
bool Unit::HandleOverrideClassScriptAuraProc(Unit *pVictim, uint32 /*damage*/,
AuraEffect *triggeredByAura, SpellEntry const *procSpell,
uint32 cooldown)
{
int32 scriptId = triggeredByAura->GetMiscValue();
if (!pVictim || !pVictim->isAlive()) return false;
Item* castItem =
triggeredByAura->GetBase()->GetCastItemGUID()
&& GetTypeId() == TYPEID_PLAYER ?
this->ToPlayer()->GetItemByGuid(
triggeredByAura->GetBase()->GetCastItemGUID()) :
NULL;
uint32 triggered_spell_id = 0;
switch (scriptId)
{
case 836: // Improved Blizzard (Rank 1)
{
if (!procSpell || procSpell->SpellVisual [0] != 9487) return false;
triggered_spell_id = 12484;
break;
}
case 988: // Improved Blizzard (Rank 2)
{
if (!procSpell || procSpell->SpellVisual [0] != 9487) return false;
triggered_spell_id = 12485;
break;
}
case 989: // Improved Blizzard (Rank 3)
{
if (!procSpell || procSpell->SpellVisual [0] != 9487) return false;
triggered_spell_id = 12486;
break;
}
case 4533: // Dreamwalker Raiment 2 pieces bonus
{
// Chance 50%
if (!roll_chance_i(50)) return false;
switch (pVictim->getPowerType())
{
case POWER_MANA:
triggered_spell_id = 28722;
break;
case POWER_RAGE:
triggered_spell_id = 28723;
break;
case POWER_ENERGY:
triggered_spell_id = 28724;
break;
default:
return false;
}
break;
}
case 4537: // Dreamwalker Raiment 6 pieces bonus
triggered_spell_id = 28750; // Blessing of the Claw
break;
case 5497: // Improved Mana Gems
triggered_spell_id = 37445; // Mana Surge
break;
case 7010: // Revitalize - can proc on full hp target
case 7011:
case 7012:
{
if (!roll_chance_i(triggeredByAura->GetAmount())) return false;
switch (pVictim->getPowerType())
{
case POWER_MANA:
triggered_spell_id = 48542;
break;
case POWER_RAGE:
triggered_spell_id = 48541;
break;
case POWER_ENERGY:
triggered_spell_id = 48540;
break;
case POWER_RUNIC_POWER:
triggered_spell_id = 48543;
break;
default:
break;
}
break;
}
default:
break;
}
// not processed
if (!triggered_spell_id) return false;
// standard non-dummy case
SpellEntry const* triggerEntry = sSpellStore.LookupEntry(
triggered_spell_id);
if (!triggerEntry)
{
sLog->outError(
"Unit::HandleOverrideClassScriptAuraProc: Spell %u triggering for class script id %u",
triggered_spell_id, scriptId);
return false;
}
if (cooldown && GetTypeId() == TYPEID_PLAYER
&& this->ToPlayer()->HasSpellCooldown(triggered_spell_id)) return false;
CastSpell(pVictim, triggered_spell_id, true, castItem, triggeredByAura);
if (cooldown && GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->AddSpellCooldown(
triggered_spell_id, 0, time(NULL) + cooldown);
return true;
}
void Unit::setPowerType(Powers new_powertype)
{
SetByteValue(UNIT_FIELD_BYTES_0, 3, new_powertype);
if (GetTypeId() == TYPEID_PLAYER)
{
if (this->ToPlayer()->GetGroup()) this->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_POWER_TYPE);
}
else if (this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (pet->isControlled())
{
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup()) owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_POWER_TYPE);
}
}
switch (new_powertype)
{
default:
case POWER_MANA:
break;
case POWER_RAGE:
SetMaxPower(POWER_RAGE, GetCreatePowers(POWER_RAGE));
SetPower(POWER_RAGE, 0);
break;
case POWER_FOCUS:
SetMaxPower(POWER_FOCUS, GetCreatePowers(POWER_FOCUS));
SetPower(POWER_FOCUS, GetCreatePowers(POWER_FOCUS));
break;
case POWER_ENERGY:
SetMaxPower(POWER_ENERGY, GetCreatePowers(POWER_ENERGY));
break;
case POWER_HAPPINESS:
SetMaxPower(POWER_HAPPINESS, GetCreatePowers(POWER_HAPPINESS));
SetPower(POWER_HAPPINESS, GetCreatePowers(POWER_HAPPINESS));
break;
}
}
FactionTemplateEntry const* Unit::getFactionTemplateEntry() const
{
FactionTemplateEntry const* entry = sFactionTemplateStore.LookupEntry(
getFaction());
if (!entry)
{
static uint64 guid = 0; // prevent repeating spam same faction problem
if (GetGUID() != guid)
{
if (const Player *player = ToPlayer())
sLog->outError(
"Player %s has invalid faction (faction template id) #%u",
player->GetName(), getFaction());
else if (const Creature *creature = ToCreature())
sLog->outError(
"Creature (template id: %u) has invalid faction (faction template id) #%u",
creature->GetCreatureInfo()->Entry, getFaction());
else
sLog->outError(
"Unit (name=%s, type=%u) has invalid faction (faction template id) #%u",
GetName(), uint32(GetTypeId()), getFaction());
guid = GetGUID();
}
}
return entry;
}
// function based on function Unit::UnitReaction from 13850 client
ReputationRank Unit::GetReactionTo(Unit const* target) const
{
// always friendly to self
if (this == target) return REP_FRIENDLY;
// always friendly to charmer or owner
if (GetCharmerOrOwnerOrSelf() == target->GetCharmerOrOwnerOrSelf()) return REP_FRIENDLY;
if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE))
{
if (target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE))
{
Player const* selfPlayerOwner = GetAffectingPlayer();
Player const* targetPlayerOwner = target->GetAffectingPlayer();
if (selfPlayerOwner && targetPlayerOwner)
{
// always friendly to other unit controlled by player, or to the player himself
if (selfPlayerOwner == targetPlayerOwner) return REP_FRIENDLY;
// duel - always hostile to opponent
if (selfPlayerOwner->duel
&& selfPlayerOwner->duel->opponent == targetPlayerOwner
&& selfPlayerOwner->duel->startTime != 0) return REP_HOSTILE;
// same group - checks dependant only on our faction - skip FFA_PVP for example
if (selfPlayerOwner->IsInRaidWith(targetPlayerOwner)) return REP_FRIENDLY; // return true to allow config option AllowTwoSide.Interaction.Group to work
// however client seems to allow mixed group parties, because in 13850 client it works like:
// return GetFactionReactionTo(getFactionTemplateEntry(), target);
}
// check FFA_PVP
if (GetByteValue(UNIT_FIELD_BYTES_2, 1) & UNIT_BYTE2_FLAG_FFA_PVP
&& target->GetByteValue(UNIT_FIELD_BYTES_2, 1)
& UNIT_BYTE2_FLAG_FFA_PVP) return REP_HOSTILE;
if (selfPlayerOwner)
{
if (FactionTemplateEntry const* targetFactionTemplateEntry = target->getFactionTemplateEntry())
{
if (ReputationRank const* repRank = selfPlayerOwner->GetReputationMgr().GetForcedRankIfAny(targetFactionTemplateEntry)) return *repRank;
if (!selfPlayerOwner->HasFlag(UNIT_FIELD_FLAGS_2,
UNIT_FLAG2_IGNORE_REPUTATION))
{
if (FactionEntry const* targetFactionEntry = sFactionStore.LookupEntry(targetFactionTemplateEntry->faction))
{
if (targetFactionEntry->CanHaveReputation())
{
// check contested flags
if (targetFactionTemplateEntry->factionFlags
& FACTION_TEMPLATE_FLAG_CONTESTED_GUARD
&& selfPlayerOwner->HasFlag(
PLAYER_FLAGS,
PLAYER_FLAGS_CONTESTED_PVP)) return REP_HOSTILE;
// if faction have reputation then hostile state dependent only from at_war state
if (selfPlayerOwner->GetReputationMgr().IsAtWar(
targetFactionEntry)) return REP_HOSTILE;
return REP_FRIENDLY;
}
}
}
}
}
}
}
// do checks dependant only on our faction
return GetFactionReactionTo(getFactionTemplateEntry(), target);
}
ReputationRank Unit::GetFactionReactionTo(
FactionTemplateEntry const* factionTemplateEntry, Unit const* target)
{
// always neutral when no template entry found
if (!factionTemplateEntry) return REP_NEUTRAL;
FactionTemplateEntry const* targetFactionTemplateEntry =
target->getFactionTemplateEntry();
if (!targetFactionTemplateEntry) return REP_NEUTRAL;
if (Player const* targetPlayerOwner = target->GetAffectingPlayer())
{
// check contested flags
if (factionTemplateEntry->factionFlags
& FACTION_TEMPLATE_FLAG_CONTESTED_GUARD
&& targetPlayerOwner->HasFlag(PLAYER_FLAGS,
PLAYER_FLAGS_CONTESTED_PVP)) return REP_HOSTILE;
if (ReputationRank const* repRank = targetPlayerOwner->GetReputationMgr().GetForcedRankIfAny(factionTemplateEntry)) return *repRank;
if (!target->HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_IGNORE_REPUTATION))
{
if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplateEntry->faction))
{
if (factionEntry->CanHaveReputation())
{
// CvP case - check reputation, don't allow state higher than neutral when at war
ReputationRank repRank =
targetPlayerOwner->GetReputationMgr().GetRank(
factionEntry);
if (targetPlayerOwner->GetReputationMgr().IsAtWar(
factionEntry)) repRank = std::min(REP_NEUTRAL,
repRank);
return repRank;
}
}
}
}
// common faction based check
if (factionTemplateEntry->IsHostileTo(*targetFactionTemplateEntry)) return REP_HOSTILE;
if (factionTemplateEntry->IsFriendlyTo(*targetFactionTemplateEntry)) return REP_FRIENDLY;
if (targetFactionTemplateEntry->IsFriendlyTo(*factionTemplateEntry)) return REP_FRIENDLY;
if (factionTemplateEntry->factionFlags
& FACTION_TEMPLATE_FLAG_HOSTILE_BY_DEFAULT) return REP_HOSTILE;
// neutral by default
return REP_NEUTRAL;
}
bool Unit::IsHostileTo(Unit const* unit) const
{
if (!unit) return false;
// always non-hostile to self
if (unit == this) return false;
// always non-hostile to GM in GM mode
if (unit->GetTypeId() == TYPEID_PLAYER
&& ((Player const*) unit)->isGameMaster()) return false;
// always hostile to enemy
if (getVictim() == unit || unit->getVictim() == this) return true;
// test pet/charm masters instead pers/charmeds
Unit const* testerOwner = GetCharmerOrOwner();
Unit const* targetOwner = unit->GetCharmerOrOwner();
// always hostile to owner's enemy
if (testerOwner
&& (testerOwner->getVictim() == unit
|| unit->getVictim() == testerOwner)) return true;
// always hostile to enemy owner
if (targetOwner
&& (getVictim() == targetOwner || targetOwner->getVictim() == this)) return true;
// always hostile to owner of owner's enemy
if (testerOwner && targetOwner
&& (testerOwner->getVictim() == targetOwner
|| targetOwner->getVictim() == testerOwner)) return true;
Unit const* tester = testerOwner ? testerOwner : this;
Unit const* target = targetOwner ? targetOwner : unit;
// always non-hostile to target with common owner, or to owner/pet
if (tester == target) return false;
// special cases (Duel, etc)
if (tester->GetTypeId() == TYPEID_PLAYER
&& target->GetTypeId() == TYPEID_PLAYER)
{
Player const* pTester = (Player const*) tester;
Player const* pTarget = (Player const*) target;
// Duel
if (pTester->duel && pTester->duel->opponent == pTarget
&& pTester->duel->startTime != 0) return true;
// Group
if (pTester->GetGroup() && pTester->GetGroup() == pTarget->GetGroup()) return false;
// Sanctuary
if (pTarget->HasByteFlag(UNIT_FIELD_BYTES_2, 1,
UNIT_BYTE2_FLAG_SANCTUARY)
&& pTester->HasByteFlag(UNIT_FIELD_BYTES_2, 1,
UNIT_BYTE2_FLAG_SANCTUARY)) return false;
// PvP FFA state
if (pTester->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP)
&& pTarget->HasByteFlag(UNIT_FIELD_BYTES_2, 1,
UNIT_BYTE2_FLAG_FFA_PVP)) return true;
//= PvP states
// Green/Blue (can't attack)
if (!pTester->HasAuraType(SPELL_AURA_MOD_FACTION)
&& !pTarget->HasAuraType(SPELL_AURA_MOD_FACTION))
{
if (pTester->GetTeam() == pTarget->GetTeam()) return false;
// Red (can attack) if true, Blue/Yellow (can't attack) in another case
return pTester->IsPvP() && pTarget->IsPvP();
}
}
// faction base cases
FactionTemplateEntry const*tester_faction =
tester->getFactionTemplateEntry();
FactionTemplateEntry const*target_faction =
target->getFactionTemplateEntry();
if (!tester_faction || !target_faction) return false;
if (target->isAttackingPlayer() && tester->IsContestedGuard()) return true;
// PvC forced reaction and reputation case
if (tester->GetTypeId() == TYPEID_PLAYER
&& !tester->HasAuraType(SPELL_AURA_MOD_FACTION))
{
// forced reaction
if (target_faction->faction)
{
if (ReputationRank const* force =tester->ToPlayer()->GetReputationMgr().GetForcedRankIfAny(target_faction)) return *force
<= REP_HOSTILE;
// if faction have reputation then hostile state for tester at 100% dependent from at_war state
if (FactionEntry const* raw_target_faction = sFactionStore.LookupEntry(target_faction->faction)) if (FactionState const* factionState = tester->ToPlayer()->GetReputationMgr().GetState(raw_target_faction)) return (factionState->Flags
& FACTION_FLAG_AT_WAR);
}
}
// CvP forced reaction and reputation case
else if (target->GetTypeId() == TYPEID_PLAYER
&& !target->HasAuraType(SPELL_AURA_MOD_FACTION))
{
// forced reaction
if (tester_faction->faction)
{
if (ReputationRank const* force = target->ToPlayer()->GetReputationMgr().GetForcedRankIfAny(tester_faction)) return *force
<= REP_HOSTILE;
// apply reputation state
FactionEntry const* raw_tester_faction = sFactionStore.LookupEntry(
tester_faction->faction);
if (raw_tester_faction && raw_tester_faction->reputationListID >= 0) return ((Player const*) target)->GetReputationMgr().GetRank(
raw_tester_faction) <= REP_HOSTILE;
}
}
// common faction based case (CvC, PvC, CvP)
return tester_faction->IsHostileTo(*target_faction);
}
bool Unit::IsFriendlyTo(Unit const* unit) const
{
// always friendly to self
if (unit == this) return true;
// always friendly to GM in GM mode
if (unit->GetTypeId() == TYPEID_PLAYER
&& ((Player const*) unit)->isGameMaster()) return true;
// always non-friendly to enemy
if (getVictim() == unit || unit->getVictim() == this) return false;
// test pet/charm masters instead pers/charmeds
Unit const* testerOwner = GetCharmerOrOwner();
Unit const* targetOwner = unit->GetCharmerOrOwner();
// always non-friendly to owner's enemy
if (testerOwner
&& (testerOwner->getVictim() == unit
|| unit->getVictim() == testerOwner)) return false;
// always non-friendly to enemy owner
if (targetOwner
&& (getVictim() == targetOwner || targetOwner->getVictim() == this)) return false;
// always non-friendly to owner of owner's enemy
if (testerOwner && targetOwner
&& (testerOwner->getVictim() == targetOwner
|| targetOwner->getVictim() == testerOwner)) return false;
Unit const* tester = testerOwner ? testerOwner : this;
Unit const* target = targetOwner ? targetOwner : unit;
// always friendly to target with common owner, or to owner/pet
if (tester == target) return true;
// special cases (Duel)
if (tester->GetTypeId() == TYPEID_PLAYER
&& target->GetTypeId() == TYPEID_PLAYER)
{
Player const* pTester = (Player const*) tester;
Player const* pTarget = (Player const*) target;
// Duel
if (pTester->duel && pTester->duel->opponent == target
&& pTester->duel->startTime != 0) return false;
// Group
if (pTester->GetGroup() && pTester->GetGroup() == pTarget->GetGroup()) return true;
// Sanctuary
if (pTarget->HasByteFlag(UNIT_FIELD_BYTES_2, 1,
UNIT_BYTE2_FLAG_SANCTUARY)
&& pTester->HasByteFlag(UNIT_FIELD_BYTES_2, 1,
UNIT_BYTE2_FLAG_SANCTUARY)) return true;
// PvP FFA state
if (pTester->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP)
&& pTarget->HasByteFlag(UNIT_FIELD_BYTES_2, 1,
UNIT_BYTE2_FLAG_FFA_PVP)) return false;
//= PvP states
// Green/Blue (non-attackable)
if (!pTester->HasAuraType(SPELL_AURA_MOD_FACTION)
&& !pTarget->HasAuraType(SPELL_AURA_MOD_FACTION))
{
if (pTester->GetTeam() == pTarget->GetTeam()) return true;
// Blue (friendly/non-attackable) if not PVP, or Yellow/Red in another case (attackable)
return !pTarget->IsPvP();
}
}
// faction base cases
FactionTemplateEntry const *tester_faction =
tester->getFactionTemplateEntry();
FactionTemplateEntry const *target_faction =
target->getFactionTemplateEntry();
if (!tester_faction || !target_faction) return false;
if (target->isAttackingPlayer() && tester->IsContestedGuard()) return false;
// PvC forced reaction and reputation case
if (tester->GetTypeId() == TYPEID_PLAYER
&& !tester->HasAuraType(SPELL_AURA_MOD_FACTION))
{
// forced reaction
if (target_faction->faction)
{
if (ReputationRank const *force =tester->ToPlayer()->GetReputationMgr().GetForcedRankIfAny(target_faction)) return *force
>= REP_FRIENDLY;
// if faction have reputation then friendly state for tester at 100% dependent from at_war state
if (FactionEntry const *raw_target_faction = sFactionStore.LookupEntry(target_faction->faction)) if (FactionState const *factionState = tester->ToPlayer()->GetReputationMgr().GetState(raw_target_faction)) return !(factionState->Flags
& FACTION_FLAG_AT_WAR);
}
}
// CvP forced reaction and reputation case
else if (target->GetTypeId() == TYPEID_PLAYER
&& !target->HasAuraType(SPELL_AURA_MOD_FACTION))
{
// forced reaction
if (tester_faction->faction)
{
if (ReputationRank const *force =target->ToPlayer()->GetReputationMgr().GetForcedRankIfAny(tester_faction)) return *force
>= REP_FRIENDLY;
// apply reputation state
if (FactionEntry const *raw_tester_faction = sFactionStore.LookupEntry(tester_faction->faction)) if (raw_tester_faction->reputationListID
>= 0) return ((Player const*) target)->GetReputationMgr().GetRank(
raw_tester_faction) >= REP_FRIENDLY;
}
}
// common faction based case (CvC, PvC, CvP)
return tester_faction->IsFriendlyTo(*target_faction);
}
bool Unit::IsHostileToPlayers() const
{
FactionTemplateEntry const *my_faction = getFactionTemplateEntry();
if (!my_faction || !my_faction->faction) return false;
FactionEntry const *raw_faction = sFactionStore.LookupEntry(
my_faction->faction);
if (raw_faction && raw_faction->reputationListID >= 0) return false;
return my_faction->IsHostileToPlayers();
}
bool Unit::IsNeutralToAll() const
{
FactionTemplateEntry const *my_faction = getFactionTemplateEntry();
if (!my_faction || !my_faction->faction) return true;
FactionEntry const *raw_faction = sFactionStore.LookupEntry(
my_faction->faction);
if (raw_faction && raw_faction->reputationListID >= 0) return false;
return my_faction->IsNeutralToAll();
}
bool Unit::Attack(Unit *victim, bool meleeAttack)
{
if (!victim || victim == this) return false;
// dead units can neither attack nor be attacked
if (!isAlive() || !victim->IsInWorld() || !victim->isAlive()) return false;
// player cannot attack in mount state
if (GetTypeId() == TYPEID_PLAYER && IsMounted()) return false;
// nobody can attack GM in GM-mode
if (victim->GetTypeId() == TYPEID_PLAYER)
{
if (victim->ToPlayer()->isGameMaster()) return false;
}
else
{
//!creature -> WHO ARE U??
if (!victim->ToCreature() || victim->ToCreature()->IsInEvadeMode()) return false;
}
// remove SPELL_AURA_MOD_UNATTACKABLE at attack (in case non-interruptible spells stun aura applied also that not let attack)
if (HasAuraType(SPELL_AURA_MOD_UNATTACKABLE)) RemoveAurasByType(
SPELL_AURA_MOD_UNATTACKABLE);
if (m_attacking)
{
if (m_attacking == victim)
{
// switch to melee attack from ranged/magic
if (meleeAttack)
{
if (!HasUnitState(UNIT_STAT_MELEE_ATTACKING))
{
AddUnitState(UNIT_STAT_MELEE_ATTACKING);
SendMeleeAttackStart(victim);
return true;
}
}
else if (HasUnitState(UNIT_STAT_MELEE_ATTACKING))
{
ClearUnitState(UNIT_STAT_MELEE_ATTACKING);
SendMeleeAttackStop(victim);
return true;
}
return false;
}
//switch target
InterruptSpell(CURRENT_MELEE_SPELL);
if (!meleeAttack) ClearUnitState(UNIT_STAT_MELEE_ATTACKING);
}
if (m_attacking) m_attacking->_removeAttacker(this);
m_attacking = victim;
m_attacking->_addAttacker(this);
// Set our target
SetUInt64Value(UNIT_FIELD_TARGET, victim->GetGUID());
if (meleeAttack) AddUnitState(UNIT_STAT_MELEE_ATTACKING);
// set position before any AI calls/assistance
//if (GetTypeId() == TYPEID_UNIT)
// this->ToCreature()->SetCombatStartPosition(GetPositionX(), GetPositionY(), GetPositionZ());
if (GetTypeId() == TYPEID_UNIT && !this->ToCreature()->isPet())
{
// should not let player enter combat by right clicking target
SetInCombatWith(victim);
if (victim->GetTypeId() == TYPEID_PLAYER) victim->SetInCombatWith(this);
AddThreat(victim, 0.0f);
this->ToCreature()->SendAIReaction(AI_REACTION_HOSTILE);
this->ToCreature()->CallAssistance();
}
if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetEmoteState() != 0) ToPlayer()->SetEmoteState(
0);
// delay offhand weapon attack to next attack time
if (haveOffhandWeapon()) resetAttackTimer(OFF_ATTACK);
if (meleeAttack) SendMeleeAttackStart(victim);
return true;
}
bool Unit::AttackStop()
{
if (!m_attacking) return false;
Unit* victim = m_attacking;
m_attacking->_removeAttacker(this);
m_attacking = NULL;
// Clear our target
SetUInt64Value(UNIT_FIELD_TARGET, 0);
ClearUnitState(UNIT_STAT_MELEE_ATTACKING);
InterruptSpell(CURRENT_MELEE_SPELL);
// reset only at real combat stop
if (GetTypeId() == TYPEID_UNIT)
{
this->ToCreature()->SetNoCallAssistance(false);
if (this->ToCreature()->HasSearchedAssistance())
{
this->ToCreature()->SetNoSearchAssistance(false);
UpdateSpeed(MOVE_RUN, false);
}
}
SendMeleeAttackStop(victim);
if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->GetEmoteState() != 0) ToPlayer()->SetEmoteState(
0);
return true;
}
void Unit::CombatStop(bool includingCast)
{
if (includingCast && IsNonMeleeSpellCasted(false)) InterruptNonMeleeSpells(
false);
AttackStop();
RemoveAllAttackers();
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->SendAttackSwingCancelAttack(); // melee and ranged forced attack cancel
ClearInCombat();
}
void Unit::CombatStopWithPets(bool includingCast)
{
CombatStop(includingCast);
for (ControlList::const_iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
(*itr)->CombatStop(includingCast);
}
bool Unit::isAttackingPlayer() const
{
if (HasUnitState(UNIT_STAT_ATTACK_PLAYER)) return true;
for (ControlList::const_iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
if ((*itr)->isAttackingPlayer()) return true;
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
if (m_SummonSlot [i]) if (Creature *summon = GetMap()->GetCreature(m_SummonSlot[i])) if (summon->isAttackingPlayer()) return true;
return false;
}
void Unit::RemoveAllAttackers()
{
while (!m_attackers.empty())
{
AttackerSet::iterator iter = m_attackers.begin();
if (!(*iter)->AttackStop())
{
sLog->outError(
"WORLD: Unit has an attacker that isn't attacking it!");
m_attackers.erase(iter);
}
}
}
void Unit::ModifyAuraState(AuraState flag, bool apply)
{
if (apply)
{
if (!HasFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1)))
{
SetFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1));
if (GetTypeId() == TYPEID_PLAYER)
{
PlayerSpellMap const& sp_list = this->ToPlayer()->GetSpellMap();
for (PlayerSpellMap::const_iterator itr = sp_list.begin();
itr != sp_list.end(); ++itr)
{
if (itr->second->state == PLAYERSPELL_REMOVED
|| itr->second->disabled) continue;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(
itr->first);
if (!spellInfo || !IsPassiveSpell(itr->first)) continue;
if (spellInfo->CasterAuraState == uint32(flag)) CastSpell(
this, itr->first, true, NULL);
}
}
else if (this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
for (PetSpellMap::const_iterator itr = pet->m_spells.begin();
itr != pet->m_spells.end(); ++itr)
{
if (itr->second.state == PETSPELL_REMOVED) continue;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(
itr->first);
if (!spellInfo || !IsPassiveSpell(itr->first)) continue;
if (spellInfo->CasterAuraState == uint32(flag)) CastSpell(
this, itr->first, true, NULL);
}
}
}
}
else
{
if (HasFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1)))
{
RemoveFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1));
if (flag != AURA_STATE_ENRAGE) // enrage aura state triggering continues auras
{
Unit::AuraApplicationMap& tAuras = GetAppliedAuras();
for (Unit::AuraApplicationMap::iterator itr = tAuras.begin();
itr != tAuras.end();)
{
SpellEntry const* spellProto =
(*itr).second->GetBase()->GetSpellProto();
if (spellProto->CasterAuraState == uint32(flag)) RemoveAura(
itr);
else ++itr;
}
}
}
}
}
uint32 Unit::BuildAuraStateUpdateForTarget(Unit * target) const
{
uint32 auraStates = GetUInt32Value(UNIT_FIELD_AURASTATE)
& ~(PER_CASTER_AURA_STATE_MASK);
for (AuraStateAurasMap::const_iterator itr = m_auraStateAuras.begin();
itr != m_auraStateAuras.end(); ++itr)
if ((1 << (itr->first - 1)) & PER_CASTER_AURA_STATE_MASK) if (itr->second->GetBase()->GetCasterGUID()
== target->GetGUID()) auraStates |= (1 << (itr->first - 1));
return auraStates;
}
bool Unit::HasAuraState(AuraState flag, SpellEntry const *spellProto,
Unit const * Caster) const
{
if (Caster)
{
if (spellProto)
{
AuraEffectList const& stateAuras = Caster->GetAuraEffectsByType(
SPELL_AURA_ABILITY_IGNORE_AURASTATE);
for (AuraEffectList::const_iterator j = stateAuras.begin();
j != stateAuras.end(); ++j)
if ((*j)->IsAffectedOnSpell(spellProto)) return true;
}
// Check per caster aura state
// If aura with aurastate by caster not found return false
if ((1 << (flag - 1)) & PER_CASTER_AURA_STATE_MASK)
{
for (AuraStateAurasMap::const_iterator itr =
m_auraStateAuras.lower_bound(flag);
itr != m_auraStateAuras.upper_bound(flag); ++itr)
if (itr->second->GetBase()->GetCasterGUID()
== Caster->GetGUID()) return true;
return false;
}
}
return HasFlag(UNIT_FIELD_AURASTATE, 1 << (flag - 1));
}
Unit *Unit::GetOwner() const
{
if (uint64 ownerid = GetOwnerGUID())
{
return ObjectAccessor::GetUnit(*this, ownerid);
}
return NULL;
}
Unit *Unit::GetCharmer() const
{
if (uint64 charmerid = GetCharmerGUID()) return ObjectAccessor::GetUnit(
*this, charmerid);
return NULL;
}
Player* Unit::GetCharmerOrOwnerPlayerOrPlayerItself() const
{
uint64 guid = GetCharmerOrOwnerGUID();
if (IS_PLAYER_GUID(guid)) return ObjectAccessor::GetPlayer(*this, guid);
return GetTypeId() == TYPEID_PLAYER ? (Player*) this : NULL;
}
Player* Unit::GetAffectingPlayer() const
{
if (!GetCharmerOrOwnerGUID()) return
GetTypeId() == TYPEID_PLAYER ? (Player*) this : NULL;
if (Unit* owner = GetCharmerOrOwner()) return owner->GetCharmerOrOwnerPlayerOrPlayerItself();
return NULL;
}
Minion *Unit::GetFirstMinion() const
{
if (uint64 pet_guid = GetMinionGUID())
{
if (Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, pet_guid)) if (pet->HasUnitTypeMask(
UNIT_MASK_MINION)) return (Minion*) pet;
sLog->outError("Unit::GetFirstMinion: Minion %u not exist.",
GUID_LOPART(pet_guid));
const_cast <Unit*>(this)->SetMinionGUID(0);
}
return NULL;
}
Guardian* Unit::GetGuardianPet() const
{
if (uint64 pet_guid = GetPetGUID())
{
if (Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, pet_guid)) if (pet->HasUnitTypeMask(
UNIT_MASK_GUARDIAN)) return (Guardian*) pet;
sLog->outCrash("Unit::GetGuardianPet: Guardian " UI64FMTD " not exist.",
pet_guid);
const_cast <Unit*>(this)->SetPetGUID(0);
}
return NULL;
}
Unit* Unit::GetCharm() const
{
if (uint64 charm_guid = GetCharmGUID())
{
if (Unit* pet = ObjectAccessor::GetUnit(*this, charm_guid)) return pet;
sLog->outError("Unit::GetCharm: Charmed creature %u not exist.",
GUID_LOPART(charm_guid));
const_cast <Unit*>(this)->SetUInt64Value(UNIT_FIELD_CHARM, 0);
}
return NULL;
}
void Unit::SetMinion(Minion *minion, bool apply, PetSlot slot)
{
sLog->outDebug(LOG_FILTER_UNITS, "SetMinion %u for %u, apply %u",
minion->GetEntry(), GetEntry(), apply);
if (apply)
{
if (!minion->AddUInt64Value(UNIT_FIELD_SUMMONEDBY, GetGUID()))
{
sLog->outCrash("SetMinion: Minion %u is not the minion of owner %u",
minion->GetEntry(), GetEntry());
return;
}
m_Controlled.insert(minion);
if (GetTypeId() == TYPEID_PLAYER)
{
minion->m_ControlledByPlayer = true;
minion->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
}
// Can only have one pet. If a new one is summoned, dismiss the old one.
if (minion->IsGuardianPet())
{
if (Guardian* oldPet = GetGuardianPet())
{
if (oldPet != minion
&& (oldPet->isPet() || minion->isPet()
|| oldPet->GetEntry() != minion->GetEntry()))
{
// remove existing minion pet
if (oldPet->isPet()) ((Pet*) oldPet)->Remove(
PET_SLOT_ACTUAL_PET_SLOT);
else oldPet->UnSummon();
SetPetGUID(minion->GetGUID());
SetMinionGUID(0);
}
}
else
{
SetPetGUID(minion->GetGUID());
SetMinionGUID(0);
}
if (slot == PET_SLOT_UNK_SLOT)
{
if (minion->isPet()
&& minion->ToPet()->getPetType() == HUNTER_PET) assert(
false);
slot = PET_SLOT_OTHER_PET;
}
if (GetTypeId() == TYPEID_PLAYER)
{
if (!minion->isHunterPet()) //If its not a Hunter Pet, well lets not try to use it for hunters then.
{
ToPlayer()->m_currentPetSlot = slot;
ToPlayer()->m_petSlotUsed = 3452816845; // the same as 100 so that the pet is only that and nothing more
// ToPlayer()->setPetSlotUsed(slot, true);
}
if (slot >= PET_SLOT_HUNTER_FIRST
&& slot <= PET_SLOT_HUNTER_LAST) // Always save thoose spots where hunter is correct
{
ToPlayer()->m_currentPetSlot = slot;
ToPlayer()->setPetSlotUsed(slot, true);
}
}
}
if (minion->HasUnitTypeMask(UNIT_MASK_CONTROLABLE_GUARDIAN))
{
if (AddUInt64Value(UNIT_FIELD_SUMMON, minion->GetGUID()))
{
}
}
if (minion->m_Properties
&& minion->m_Properties->Type == SUMMON_TYPE_MINIPET)
{
SetCritterGUID(minion->GetGUID());
}
// PvP, FFAPvP
minion->SetByteValue(UNIT_FIELD_BYTES_2, 1,
GetByteValue(UNIT_FIELD_BYTES_2, 1));
// FIXME: hack, speed must be set only at follow
if (GetTypeId() == TYPEID_PLAYER && minion->isPet()) for (uint8 i = 0;
i < MAX_MOVE_TYPE; ++i)
minion->SetSpeed(UnitMoveType(i), m_speed_rate [i], true);
// Ghoul pets have energy instead of mana (is anywhere better place for this code?)
if (minion->IsPetGhoul()) minion->setPowerType(POWER_ENERGY);
if (GetTypeId() == TYPEID_PLAYER)
{
// Send infinity cooldown - client does that automatically but after relog cooldown needs to be set again
SpellEntry const *spellInfo = sSpellStore.LookupEntry(
minion->GetUInt32Value(UNIT_CREATED_BY_SPELL));
if (spellInfo
&& (spellInfo->Attributes
& SPELL_ATTR0_DISABLED_WHILE_ACTIVE)) this->ToPlayer()->AddSpellAndCategoryCooldowns(
spellInfo, 0, NULL, true);
}
}
else
{
if (minion->GetOwnerGUID() != GetGUID())
{
sLog->outCrash("SetMinion: Minion %u is not the minion of owner %u",
minion->GetEntry(), GetEntry());
return;
}
m_Controlled.erase(minion);
if (minion->m_Properties
&& minion->m_Properties->Type == SUMMON_TYPE_MINIPET)
{
if (GetCritterGUID() == minion->GetGUID()) SetCritterGUID(0);
}
if (minion->IsGuardianPet())
{
if (GetPetGUID() == minion->GetGUID()) SetPetGUID(0);
}
else if (minion->isTotem())
{
// All summoned by totem minions must disappear when it is removed.
if (const SpellEntry* spInfo = sSpellStore.LookupEntry(minion->ToTotem()->GetSpell())) for (int i =
0; i < MAX_SPELL_EFFECTS; ++i)
{
if (spInfo->Effect [i] != SPELL_EFFECT_SUMMON) continue;
this->RemoveAllMinionsByEntry(spInfo->EffectMiscValue [i]);
}
}
if (GetTypeId() == TYPEID_PLAYER)
{
SpellEntry const *spellInfo = sSpellStore.LookupEntry(
minion->GetUInt32Value(UNIT_CREATED_BY_SPELL));
// Remove infinity cooldown
if (spellInfo
&& (spellInfo->Attributes
& SPELL_ATTR0_DISABLED_WHILE_ACTIVE)) this->ToPlayer()->SendCooldownEvent(
spellInfo);
}
//if (minion->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
{
if (RemoveUInt64Value(UNIT_FIELD_SUMMON, minion->GetGUID()))
{
//Check if there is another minion
for (ControlList::iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
{
// do not use this check, creature do not have charm guid
//if (GetCharmGUID() == (*itr)->GetGUID())
if (GetGUID() == (*itr)->GetCharmerGUID()) continue;
//ASSERT((*itr)->GetOwnerGUID() == GetGUID());
if ((*itr)->GetOwnerGUID() != GetGUID())
{
OutDebugInfo();
(*itr)->OutDebugInfo();
ASSERT(false);
}
ASSERT((*itr)->GetTypeId() == TYPEID_UNIT);
if (!(*itr)->HasUnitTypeMask(
UNIT_MASK_CONTROLABLE_GUARDIAN)) continue;
if (AddUInt64Value(UNIT_FIELD_SUMMON, (*itr)->GetGUID()))
{
//show another pet bar if there is no charm bar
if (GetTypeId() == TYPEID_PLAYER && !GetCharmGUID())
{
if ((*itr)->isPet()) this->ToPlayer()->PetSpellInitialize();
else this->ToPlayer()->CharmSpellInitialize();
}
}
break;
}
}
}
}
}
void Unit::GetAllMinionsByEntry(std::list <Unit*>& Minions, uint32 entry)
{
for (Unit::ControlList::iterator itr = m_Controlled.begin();
itr != m_Controlled.end();)
{
Unit *unit = *itr;
++itr;
if (unit->GetEntry() == entry && unit->GetTypeId() == TYPEID_UNIT
&& unit->ToCreature()->isSummon()) // minion, actually
Minions.push_back(unit);
}
}
void Unit::RemoveAllMinionsByEntry(uint32 entry)
{
for (Unit::ControlList::iterator itr = m_Controlled.begin();
itr != m_Controlled.end();)
{
Unit *unit = *itr;
++itr;
if (unit->GetEntry() == entry && unit->GetTypeId() == TYPEID_UNIT
&& unit->ToCreature()->isSummon()) // minion, actually
unit->ToTempSummon()->UnSummon();
// i think this is safe because i have never heard that a despawned minion will trigger a same minion
}
}
void Unit::SetCharm(Unit* charm, bool apply)
{
if (apply)
{
if (GetTypeId() == TYPEID_PLAYER)
{
if (!AddUInt64Value(UNIT_FIELD_CHARM, charm->GetGUID()))
sLog->outCrash(
"Player %s is trying to charm unit %u, but it already has a charmed unit " UI64FMTD "",
GetName(), charm->GetEntry(), GetCharmGUID());
charm->m_ControlledByPlayer = true;
// TODO: maybe we can use this flag to check if controlled by player
charm->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
}
else charm->m_ControlledByPlayer = false;
// PvP, FFAPvP
charm->SetByteValue(UNIT_FIELD_BYTES_2, 1,
GetByteValue(UNIT_FIELD_BYTES_2, 1));
if (!charm->AddUInt64Value(UNIT_FIELD_CHARMEDBY, GetGUID()))
sLog->outCrash(
"Unit %u is being charmed, but it already has a charmer " UI64FMTD "",
charm->GetEntry(), charm->GetCharmerGUID());
if (charm->HasUnitMovementFlag(MOVEMENTFLAG_WALKING))
{
charm->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
charm->SendMovementFlagUpdate();
}
m_Controlled.insert(charm);
}
else
{
if (GetTypeId() == TYPEID_PLAYER)
{
if (!RemoveUInt64Value(UNIT_FIELD_CHARM, charm->GetGUID()))
sLog->outCrash(
"Player %s is trying to uncharm unit %u, but it has another charmed unit " UI64FMTD "",
GetName(), charm->GetEntry(), GetCharmGUID());
}
if (!charm->RemoveUInt64Value(UNIT_FIELD_CHARMEDBY, GetGUID()))
sLog->outCrash(
"Unit %u is being uncharmed, but it has another charmer " UI64FMTD "",
charm->GetEntry(), charm->GetCharmerGUID());
if (charm->GetTypeId() == TYPEID_PLAYER)
{
charm->m_ControlledByPlayer = true;
charm->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
charm->ToPlayer()->UpdatePvPState();
}
else if (Player *player = charm->GetCharmerOrOwnerPlayerOrPlayerItself())
{
charm->m_ControlledByPlayer = true;
charm->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
charm->SetByteValue(UNIT_FIELD_BYTES_2, 1,
player->GetByteValue(UNIT_FIELD_BYTES_2, 1));
}
else
{
charm->m_ControlledByPlayer = false;
charm->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
charm->SetByteValue(UNIT_FIELD_BYTES_2, 1, 0);
}
if (charm->GetTypeId() == TYPEID_PLAYER
|| !charm->ToCreature()->HasUnitTypeMask(UNIT_MASK_MINION)
|| charm->GetOwnerGUID() != GetGUID()) m_Controlled.erase(
charm);
}
}
int32 Unit::DealHeal(Unit *pVictim, uint32 addhealth)
{
int32 gain = 0;
if (pVictim->IsAIEnabled) pVictim->GetAI()->HealReceived(this, addhealth);
if (IsAIEnabled) GetAI()->HealDone(pVictim, addhealth);
if (addhealth) gain = pVictim->ModifyHealth(int32(addhealth));
Unit* unit = this;
m_heal_done [0] += addhealth;
if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->isTotem()) unit =
GetOwner();
if (unit->GetTypeId() == TYPEID_PLAYER)
{
if (Battleground *bg = unit->ToPlayer()->GetBattleground()) bg->UpdatePlayerScore(
(Player*) unit, SCORE_HEALING_DONE, gain);
// use the actual gain, as the overheal shall not be counted, skip gain 0 (it ignored anyway in to criteria)
if (gain) unit->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_HEALING_DONE, gain, 0, pVictim);
unit->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEAL_CASTED, addhealth);
}
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
pVictim->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_TOTAL_HEALING_RECEIVED, gain);
pVictim->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_HIGHEST_HEALING_RECEIVED, addhealth);
}
return gain;
}
Unit* Unit::SelectMagnetTarget(Unit *victim, SpellEntry const *spellInfo)
{
if (!victim) return NULL;
// Magic case
if (spellInfo
&& (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_NONE
|| spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC))
{
//I am not sure if this should be redirected.
if (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_NONE) return victim;
Unit::AuraEffectList const& magnetAuras = victim->GetAuraEffectsByType(
SPELL_AURA_SPELL_MAGNET);
for (Unit::AuraEffectList::const_iterator itr = magnetAuras.begin();
itr != magnetAuras.end(); ++itr)
if (Unit* magnet = (*itr)->GetBase()->GetUnitOwner()) if (magnet->isAlive()) if (Spell* spell = FindCurrentSpellBySpellId(spellInfo->Id))
{
// Store magnet aura to drop charge on hit
spell->SetMagnetingAura((*itr)->GetBase());
return magnet;
}
}
// Melee && ranged case
else
{
AuraEffectList const& hitTriggerAuras = victim->GetAuraEffectsByType(
SPELL_AURA_ADD_CASTER_HIT_TRIGGER);
for (AuraEffectList::const_iterator i = hitTriggerAuras.begin();
i != hitTriggerAuras.end(); ++i)
if (Unit* magnet = (*i)->GetBase()->GetCaster()) if (magnet->isAlive()
&& magnet->IsWithinLOSInMap(this)) if (roll_chance_i(
(*i)->GetAmount()))
{
(*i)->GetBase()->DropCharge();
return magnet;
}
}
return victim;
}
Unit* Unit::GetFirstControlled() const
{
//Sequence: charmed, pet, other guardians
Unit *unit = GetCharm();
if (!unit) if (uint64 guid = GetUInt64Value(UNIT_FIELD_SUMMON)) unit =
ObjectAccessor::GetUnit(*this, guid);
return unit;
}
void Unit::RemoveAllControlled()
{
//possessed pet and vehicle
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->StopCastingCharm();
while (!m_Controlled.empty())
{
Unit *target = *m_Controlled.begin();
m_Controlled.erase(m_Controlled.begin());
if (target->GetCharmerGUID() == GetGUID()) target->RemoveCharmAuras();
else if (target->GetOwnerGUID() == GetGUID() && target->isSummon()) target->ToTempSummon()->UnSummon();
else
sLog->outError(
"Unit %u is trying to release unit %u which is neither charmed nor owned by it",
GetEntry(), target->GetEntry());
}
if (GetPetGUID())
sLog->outCrash("Unit %u is not able to release its pet " UI64FMTD,
GetEntry(), GetPetGUID());
if (GetMinionGUID())
sLog->outCrash("Unit %u is not able to release its minion " UI64FMTD,
GetEntry(), GetMinionGUID());
if (GetCharmGUID())
sLog->outCrash("Unit %u is not able to release its charm " UI64FMTD,
GetEntry(), GetCharmGUID());
}
Unit* Unit::GetNextRandomRaidMemberOrPet(float radius)
{
Player* player = NULL;
if (GetTypeId() == TYPEID_PLAYER) player = (Player*) this;
// Should we enable this also for charmed units?
else if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->isPet()) player =
(Player*) GetOwner();
if (!player) return NULL;
Group *pGroup = player->GetGroup();
//When there is no group check pet presence
if (!pGroup)
{
// We are pet now, return owner
if (player != this) return
IsWithinDistInMap(player, radius) ? player : NULL;
Unit * pet = GetGuardianPet();
//No pet, no group, nothing to return
if (!pet) return NULL;
// We are owner now, return pet
return IsWithinDistInMap(pet, radius) ? pet : NULL;
}
std::vector <Unit*> nearMembers;
//reserve place for players and pets because resizing vector every unit push is unefficient (vector is reallocated then)
nearMembers.reserve(pGroup->GetMembersCount() * 2);
for (GroupReference *itr = pGroup->GetFirstMember(); itr != NULL;
itr = itr->next())
if (Player *Target = itr->getSource())
{
// IsHostileTo check duel and controlled by enemy
if (Target != this && Target->isAlive()
&& IsWithinDistInMap(Target, radius)
&& !IsHostileTo(Target)) nearMembers.push_back(Target);
// Push player's pet to vector
if (Unit *pet = Target->GetGuardianPet()) if (pet != this
&& pet->isAlive() && IsWithinDistInMap(pet, radius)
&& !IsHostileTo(pet)) nearMembers.push_back(pet);
}
if (nearMembers.empty()) return NULL;
uint32 randTarget = urand(0, nearMembers.size() - 1);
return nearMembers [randTarget];
}
//only called in Player::SetSeer
// so move it to Player?
void Unit::AddPlayerToVision(Player* plr)
{
if (m_sharedVision.empty())
{
setActive(true);
SetWorldObject(true);
}
m_sharedVision.push_back(plr);
}
//only called in Player::SetSeer
void Unit::RemovePlayerFromVision(Player* plr)
{
m_sharedVision.remove(plr);
if (m_sharedVision.empty())
{
setActive(false);
SetWorldObject(false);
}
}
void Unit::RemoveBindSightAuras()
{
RemoveAurasByType(SPELL_AURA_BIND_SIGHT);
}
void Unit::RemoveCharmAuras()
{
RemoveAurasByType(SPELL_AURA_MOD_CHARM);
RemoveAurasByType(SPELL_AURA_MOD_POSSESS_PET);
RemoveAurasByType(SPELL_AURA_MOD_POSSESS);
RemoveAurasByType(SPELL_AURA_AOE_CHARM);
}
void Unit::UnsummonAllTotems()
{
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
{
if (!m_SummonSlot [i]) continue;
if (Creature *OldTotem = GetMap()->GetCreature(m_SummonSlot[i])) if (OldTotem->isSummon()) OldTotem->ToTempSummon()->UnSummon();
}
}
void Unit::SendHealSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage,
uint32 OverHeal, uint32 Absorb, bool critical)
{
// we guess size
WorldPacket data(SMSG_SPELLHEALLOG, 8 + 8 + 4 + 4 + 4 + 4 + 1 + 1);
data.append(pVictim->GetPackGUID());
data.append(GetPackGUID());
data << uint32(SpellID);
data << uint32(Damage);
data << uint32(OverHeal);
data << uint32(Absorb); // Absorb amount
data << uint8(critical ? 1 : 0);
data << uint8(0); // unused
SendMessageToSet(&data, true);
}
int32 Unit::HealBySpell(Unit * pVictim, SpellEntry const * spellInfo,
uint32 addHealth, bool critical)
{
uint32 absorb = 0;
// calculate heal absorb and reduce healing
CalcHealAbsorb(pVictim, spellInfo, addHealth, absorb);
int32 gain = DealHeal(pVictim, addHealth);
SendHealSpellLog(pVictim, spellInfo->Id, addHealth,
uint32(addHealth - gain), absorb, critical);
return gain;
}
void Unit::SendEnergizeSpellLog(Unit *pVictim, uint32 SpellID, uint32 Damage,
Powers powertype)
{
WorldPacket data(SMSG_SPELLENERGIZELOG, 8 + 8 + 4 + 4 + 4 + 1);
data.append(pVictim->GetPackGUID());
data.append(GetPackGUID());
data << uint32(SpellID);
data << uint32(powertype);
data << uint32(Damage);
SendMessageToSet(&data, true);
}
void Unit::EnergizeBySpell(Unit *pVictim, uint32 SpellID, uint32 Damage,
Powers powertype)
{
SendEnergizeSpellLog(pVictim, SpellID, Damage, powertype);
// needs to be called after sending spell log
pVictim->ModifyPower(powertype, Damage);
}
uint32 Unit::SpellDamageBonus(Unit *pVictim, SpellEntry const *spellProto,
uint32 effIndex, uint32 pdamage, DamageEffectType damagetype,
uint32 stack)
{
if (!spellProto || !pVictim || damagetype == DIRECT_DAMAGE) return pdamage;
// For totems get damage bonus from owner
if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->isTotem()) if (Unit *owner = GetOwner()) return owner->SpellDamageBonus(
pVictim, spellProto, effIndex, pdamage, damagetype);
// Taken/Done total percent damage auras
float DoneTotalMod = 1.0f;
float ApCoeffMod = 1.0f;
int32 DoneTotal = 0;
int32 TakenTotal = 0;
// ..done
// Pet damage
if (GetTypeId() == TYPEID_UNIT && !this->ToCreature()->isPet()) DoneTotalMod *=
this->ToCreature()->GetSpellDamageMod(
this->ToCreature()->GetCreatureInfo()->rank);
AuraEffectList const &mModDamagePercentDone = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin();
i != mModDamagePercentDone.end(); ++i)
if (((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
&& (*i)->GetSpellProto()->EquippedItemClass == -1 && // -1 == any item class (not wand)
(*i)->GetSpellProto()->EquippedItemInventoryTypeMask == 0) // 0 == any inventory type (not wand)
DoneTotalMod *= ((*i)->GetAmount() + 100.0f) / 100.0f;
uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
// Add flat bonus from spell damage versus
DoneTotal += GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS, creatureTypeMask);
AuraEffectList const &mDamageDoneVersus = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
for (AuraEffectList::const_iterator i = mDamageDoneVersus.begin();
i != mDamageDoneVersus.end(); ++i)
if (creatureTypeMask & uint32((*i)->GetMiscValue())) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
// bonus against aurastate
AuraEffectList const &mDamageDoneVersusAurastate = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin();
i != mDamageDoneVersusAurastate.end(); ++i)
if (pVictim->HasAuraState(AuraState((*i)->GetMiscValue()))) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
// done scripted mod (take it from owner)
Unit * owner = GetOwner() ? GetOwner() : this;
AuraEffectList const &mOverrideClassScript = owner->GetAuraEffectsByType(
SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i = mOverrideClassScript.begin();
i != mOverrideClassScript.end(); ++i)
{
if (!(*i)->IsAffectedOnSpell(spellProto)) continue;
switch ((*i)->GetMiscValue())
{
case 4920: // Molten Fury
case 4919:
case 6917: // Death's Embrace
case 6926:
case 6928:
{
if (pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT,
spellProto, this)) DoneTotalMod *= (100.0f
+ (*i)->GetAmount()) / 100.0f;
break;
}
// Soul Siphon
case 4992:
case 4993:
{
// effect 1 m_amount
int32 maxPercent = (*i)->GetAmount();
// effect 0 m_amount
int32 stepPercent = CalculateSpellDamage(this,
(*i)->GetSpellProto(), 0);
// count affliction effects and calc additional damage in percentage
int32 modPercent = 0;
AuraApplicationMap const &victimAuras =
pVictim->GetAppliedAuras();
for (AuraApplicationMap::const_iterator itr =
victimAuras.begin(); itr != victimAuras.end(); ++itr)
{
Aura const * aura = itr->second->GetBase();
SpellEntry const *m_spell = aura->GetSpellProto();
if (m_spell->SpellFamilyName != SPELLFAMILY_WARLOCK
|| !(m_spell->SpellFamilyFlags [1] & 0x0004071B
|| m_spell->SpellFamilyFlags [0]
& 0x8044C402)) continue;
modPercent += stepPercent * aura->GetStackAmount();
if (modPercent >= maxPercent)
{
modPercent = maxPercent;
break;
}
}
DoneTotalMod *= (modPercent + 100.0f) / 100.0f;
break;
}
case 6916: // Death's Embrace
case 6925:
case 6927:
if (HasAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, spellProto,
this)) DoneTotalMod *= (100.0f + (*i)->GetAmount())
/ 100.0f;
break;
case 5481: // Starfire Bonus
{
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_DRUID, 0x200002, 0, 0)) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
case 4418: // Increased Shock Damage
case 4554: // Increased Lightning Damage
case 4555: // Improved Moonfire
case 5142: // Increased Lightning Damage
case 5147: // Improved Consecration / Libram of Resurgence
case 5148: // Idol of the Shooting Star
case 6008: // Increased Lightning Damage
case 8627: // Totem of Hex
{
DoneTotal += (*i)->GetAmount();
break;
}
// Tundra Stalker
// Merciless Combat
case 7277:
{
// Merciless Combat
if ((*i)->GetSpellProto()->SpellIconID == 2656)
{
if (!pVictim->HealthAbovePct(35)) DoneTotalMod *= (100.0f
+ (*i)->GetAmount()) / 100.0f;
}
// Tundra Stalker
else
{
// Frost Fever (target debuff)
if (pVictim->HasAura(55095)) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
break;
}
// Rage of Rivendare
case 7293:
{
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0))
{
if (SpellChainNode const *chain = sSpellMgr->GetSpellChainNode((*i)->GetId())) DoneTotalMod *=
(chain->rank * 2.0f + 100.0f) / 100.0f;
}
break;
}
// Twisted Faith
case 7377:
{
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID())) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
}
}
// Custom scripted damage
switch (spellProto->SpellFamilyName)
{
case SPELLFAMILY_MAGE:
// Ice Lance
if (spellProto->SpellIconID == 186)
{
if (pVictim->HasAuraState(AURA_STATE_FROZEN, spellProto, this))
{
// Glyph of Ice Lance
if (owner->HasAura(56377)
&& pVictim->getLevel() > owner->getLevel()) DoneTotalMod *=
1.05f;
// Damages doubled against frozen targets.
DoneTotalMod *= 2.0f;
}
}
// Torment the weak
if (spellProto->SpellFamilyFlags [0] & 0x20200021
|| spellProto->SpellFamilyFlags [1] & 0x9000) if (pVictim->HasAuraType(
SPELL_AURA_MOD_DECREASE_SPEED))
{
AuraEffectList const& mDumyAuras = GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDumyAuras.begin();
i != mDumyAuras.end(); ++i)
if ((*i)->GetSpellProto()->SpellIconID == 3263)
{
DoneTotalMod *= float((*i)->GetAmount() + 100.f)
/ 100.f;
break;
}
}
break;
case SPELLFAMILY_PRIEST:
// Mind Flay
if (spellProto->SpellFamilyFlags [0] & 0x800000)
{
// Glyph of Shadow Word: Pain
if (AuraEffect * aurEff = GetAuraEffect(55687, 0))
// Increase Mind Flay damage if Shadow Word: Pain present on target
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID())) DoneTotalMod *=
(aurEff->GetAmount() + 100.0f) / 100.f;
// Twisted Faith - Mind Flay part
if (AuraEffect * aurEff = GetAuraEffect(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS, SPELLFAMILY_PRIEST, 2848, 1))
// Increase Mind Flay damage if Shadow Word: Pain present on target
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetGUID())) DoneTotalMod *=
(aurEff->GetAmount() + 100.0f) / 100.f;
}
// Smite
else if (spellProto->SpellFamilyFlags [0] & 0x80)
{
// Glyph of Smite
if (AuraEffect * aurEff = GetAuraEffect(55692, 0)) if (pVictim->GetAuraEffect(
SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST,
0x100000, 0, 0, GetGUID())) AddPctN(DoneTotalMod,
aurEff->GetAmount());
}
break;
case SPELLFAMILY_PALADIN:
// Judgement of Vengeance/Judgement of Corruption
if ((spellProto->SpellFamilyFlags [1] & 0x400000)
&& spellProto->SpellIconID == 2292)
{
// Get stack of Holy Vengeance/Blood Corruption on the target added by caster
uint32 stacks = 0;
Unit::AuraEffectList const& auras =
pVictim->GetAuraEffectsByType(
SPELL_AURA_PERIODIC_DAMAGE);
for (Unit::AuraEffectList::const_iterator itr = auras.begin();
itr != auras.end(); ++itr)
if (((*itr)->GetId() == 31803 || (*itr)->GetId() == 53742)
&& (*itr)->GetCasterGUID() == GetGUID())
{
stacks = (*itr)->GetBase()->GetStackAmount();
break;
}
// + 10% for each application of Holy Vengeance/Blood Corruption on the target
if (stacks) DoneTotalMod *= (10.0f + float(stacks)) / 10.0f;
}
break;
case SPELLFAMILY_WARLOCK:
//Fire and Brimstone
if (spellProto->SpellFamilyFlags [1] & 0x00020040) if (pVictim->HasAuraState(
AURA_STATE_CONFLAGRATE))
{
AuraEffectList const& mDumyAuras = GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDumyAuras.begin();
i != mDumyAuras.end(); ++i)
if ((*i)->GetSpellProto()->SpellIconID == 3173)
{
DoneTotalMod *= float((*i)->GetAmount() + 100.f)
/ 100.f;
break;
}
}
// Drain Soul - increased damage for targets under 25 % HP
if (spellProto->SpellFamilyFlags [0] & 0x00004000) if (HasAura(
200000)) DoneTotalMod *= 2;
// Shadow Bite (15% increase from each dot)
if (spellProto->SpellFamilyFlags [1] & 0x00400000 && isPet()
&& GetOwner()) if (uint8 count = pVictim->GetDoTsByCaster(GetOwnerGUID())) AddPctN(
DoneTotalMod, 15 * count);
break;
case SPELLFAMILY_HUNTER:
// Steady Shot
if (spellProto->SpellFamilyFlags [1] & 0x1) if (AuraEffect * aurEff = GetAuraEffect(56826, 0)) // Glyph of Steady Shot
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_HUNTER, 0x00004000, 0, 0, GetGUID())) AddPctN(
DoneTotalMod, aurEff->GetAmount());
break;
case SPELLFAMILY_DEATHKNIGHT:
// Improved Icy Touch
if (spellProto->SpellFamilyFlags [0] & 0x2) if (AuraEffect * aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 2721, 0)) DoneTotalMod *=
(100.0f + aurEff->GetAmount()) / 100.0f;
// Sigil of the Vengeful Heart
if (spellProto->SpellFamilyFlags [0] & 0x2000) if (AuraEffect* aurEff = GetAuraEffect(64962, EFFECT_1)) AddPctN(
DoneTotal, aurEff->GetAmount());
// Glacier Rot
if (spellProto->SpellFamilyFlags [0] & 0x2
|| spellProto->SpellFamilyFlags [1] & 0x6) if (AuraEffect * aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 196, 0)) if (pVictim->GetDiseasesByCaster(
owner->GetGUID()) > 0) DoneTotalMod *= (100.0f
+ aurEff->GetAmount()) / 100.0f;
// Rune Strike
if (spellProto->SpellFamilyFlags [1] & 0x20000000)
{
float ApCoeffMod = 1.0f;
// Impurity (dummy effect)
if (GetTypeId() == TYPEID_PLAYER)
{
PlayerSpellMap playerSpells =
this->ToPlayer()->GetSpellMap();
for (PlayerSpellMap::const_iterator itr =
playerSpells.begin(); itr != playerSpells.end();
++itr)
{
if (itr->second->state == PLAYERSPELL_REMOVED
|| itr->second->disabled) continue;
switch (itr->first)
{
case 49220:
case 49633:
case 49635:
case 49636:
case 49638:
{
if (const SpellEntry *proto=sSpellStore.LookupEntry(itr->first)) AddPctN(
ApCoeffMod,
SpellMgr::CalculateSpellEffectAmount(
proto, 0));
}
break;
}
}
}
DoneTotalMod += GetTotalAttackPowerValue(BASE_ATTACK) * 0.2
* ApCoeffMod;
}
// Impurity (dummy effect)
if (GetTypeId() == TYPEID_PLAYER)
{
PlayerSpellMap playerSpells = this->ToPlayer()->GetSpellMap();
for (PlayerSpellMap::const_iterator itr = playerSpells.begin();
itr != playerSpells.end(); ++itr)
{
if (itr->second->state == PLAYERSPELL_REMOVED
|| itr->second->disabled) continue;
switch (itr->first)
{
case 49220:
case 49633:
case 49635:
case 49636:
case 49638:
{
if (const SpellEntry *proto=sSpellStore.LookupEntry(itr->first)) ApCoeffMod *=
(100.0f
+ SpellMgr::CalculateSpellEffectAmount(
proto, 0)) / 100.0f;
}
break;
}
}
}
break;
}
if (damagetype == SPELL_DIRECT_DAMAGE && spellProto->powerType == POWER_RAGE
&& HasAuraType(SPELL_AURA_MASTERY) && GetTypeId() == TYPEID_PLAYER
&& ToPlayer()->GetTalentBranchSpec(ToPlayer()->GetActiveSpec())
== BS_WARRIOR_FURY) DoneTotalMod *= float(
1.0f + (0.45f + (ToPlayer()->GetMasteryPoints() * 0.056f)));
// ..taken
int32 maxPositiveMod = 0; // max of the positive amount aura (that increase the damage taken)
int32 sumNegativeMod = 0; // sum the negative amount aura (that reduce the damage taken)
AuraEffectList const& mModDamagePercentTaken =
pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
for (AuraEffectList::const_iterator i = mModDamagePercentTaken.begin();
i != mModDamagePercentTaken.end(); ++i)
if ((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
{
if ((*i)->GetAmount() > 0)
{
if ((*i)->GetAmount() > maxPositiveMod) maxPositiveMod =
(*i)->GetAmount();
}
else sumNegativeMod += (*i)->GetAmount();
}
// .. taken pct: dummy auras
AuraEffectList const& mDummyAuras = pVictim->GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDummyAuras.begin();
i != mDummyAuras.end(); ++i)
{
switch ((*i)->GetSpellProto()->SpellIconID)
{
// Cheat Death
case 2109:
if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
{
// needs rework 4.0.6
/*if (pVictim->GetTypeId() != TYPEID_PLAYER)
continue;
float mod = pVictim->ToPlayer()->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE)*(-8.0f);
if (mod < (*i)->GetAmount())
mod = (float)(*i)->GetAmount();
sumNegativeMod += int32(mod);*/
}
break;
// Ebon Plague
case 1933:
if ((*i)->GetMiscValue()
& (spellProto ? GetSpellSchoolMask(spellProto) : 0))
{
if ((*i)->GetAmount() > maxPositiveMod) maxPositiveMod =
(*i)->GetAmount();
}
break;
}
}
// From caster spells
AuraEffectList const& mOwnerTaken = pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
for (AuraEffectList::const_iterator i = mOwnerTaken.begin();
i != mOwnerTaken.end(); ++i)
if ((*i)->GetCasterGUID() == GetGUID()
&& (*i)->IsAffectedOnSpell(spellProto)) sumNegativeMod +=
(*i)->GetAmount();
// Mod damage from spell mechanic
if (uint32 mechanicMask = GetAllSpellMechanicMask(spellProto))
{
AuraEffectList const& mDamageDoneMechanic =
pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin();
i != mDamageDoneMechanic.end(); ++i)
if (mechanicMask & uint32(1 << ((*i)->GetMiscValue()))) sumNegativeMod +=
(*i)->GetAmount();
}
float TakenTotalMod = (sumNegativeMod + maxPositiveMod + 100.0f) / 100.0f;
// Taken/Done fixed damage bonus auras
int32 DoneAdvertisedBenefit = SpellBaseDamageBonus(
GetSpellSchoolMask(spellProto));
int32 TakenAdvertisedBenefit = SpellBaseDamageBonusForVictim(
GetSpellSchoolMask(spellProto), pVictim);
// Pets just add their bonus damage to their spell damage
// note that their spell damage is just gain of their own auras
if (HasUnitTypeMask(UNIT_MASK_GUARDIAN)) if (!(GetSpellSchoolMask(
spellProto) & SPELL_SCHOOL_MASK_NORMAL)) // Do not add Spellpower to melee abilities
DoneAdvertisedBenefit += ((Guardian*) this)->GetBonusDamage();
else if (((Guardian*) this)->GetBonusDamage()) // Instead add a fixed amount of AP
DoneAdvertisedBenefit += GetTotalAttackPowerValue(BASE_ATTACK) * 0.2f;
// Check for table values
float coeff = 0;
SpellBonusEntry const *bonus = sSpellMgr->GetSpellBonusData(spellProto->Id);
if (bonus)
{
if (damagetype == DOT)
{
coeff = bonus->dot_damage;
if (bonus->ap_dot_bonus > 0)
{
WeaponAttackType attType =
(IsRangedWeaponSpell(spellProto)
&& spellProto->DmgClass
!= SPELL_DAMAGE_CLASS_MELEE) ?
RANGED_ATTACK : BASE_ATTACK;
float APbonus =
attType == BASE_ATTACK ?
pVictim->GetTotalAuraModifier(
SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS) :
pVictim->GetTotalAuraModifier(
SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
APbonus += GetTotalAttackPowerValue(attType);
DoneTotal += int32(
bonus->ap_dot_bonus * stack * ApCoeffMod * APbonus);
}
}
else
{
coeff = bonus->direct_damage;
if (bonus->ap_bonus > 0)
{
WeaponAttackType attType =
(IsRangedWeaponSpell(spellProto)
&& spellProto->DmgClass
!= SPELL_DAMAGE_CLASS_MELEE) ?
RANGED_ATTACK : BASE_ATTACK;
float APbonus =
attType == BASE_ATTACK ?
pVictim->GetTotalAuraModifier(
SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS) :
pVictim->GetTotalAuraModifier(
SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
APbonus += GetTotalAttackPowerValue(attType);
DoneTotal += int32(
bonus->ap_bonus * stack * ApCoeffMod * APbonus);
}
}
}
// Default calculation
if (DoneAdvertisedBenefit || TakenAdvertisedBenefit)
{
if (coeff <= 0)
{
if (effIndex < 4)
{
coeff = spellProto->EffectBonusCoefficient [effIndex];
}
else
{ // should never happen
coeff = 0;
}
}
// Formula based SP coefficient calculation is disabled cause all coeffs should be present in the DBC
// A few custom cases go into spell_bonus_data table
/*if (!bonus || coeff < 0)
{
// Damage Done from spell damage bonus
int32 CastingTime = IsChanneledSpell(spellProto) ? GetSpellDuration(spellProto) : GetSpellCastTime(spellProto);
// Damage over Time spells bonus calculation
float DotFactor = 1.0f;
if (damagetype == DOT)
{
int32 DotDuration = GetSpellDuration(spellProto);
// 200% limit
if (DotDuration > 0)
{
if (DotDuration > 30000)
DotDuration = 30000;
if (!IsChanneledSpell(spellProto))
DotFactor = DotDuration / 15000.0f;
uint8 x = 0;
for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
{
if (spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && (
spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_DAMAGE ||
spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH))
{
x = j;
break;
}
}
int32 DotTicks = 6;
if (spellProto->EffectAmplitude[x] != 0)
DotTicks = DotDuration / spellProto->EffectAmplitude[x];
if (DotTicks)
{
DoneAdvertisedBenefit /= DotTicks;
TakenAdvertisedBenefit /= DotTicks;
}
}
}
// Distribute Damage over multiple effects, reduce by AoE
CastingTime = GetCastingTimeForBonus(spellProto, damagetype, CastingTime);
// 50% for damage and healing spells for leech spells from damage bonus and 0% from healing
for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
{
if (spellProto->Effect[j] == SPELL_EFFECT_HEALTH_LEECH ||
(spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH))
{
CastingTime /= 2;
break;
}
}
if (spellProto->SchoolMask != SPELL_SCHOOL_MASK_NORMAL)
coeff = (CastingTime / 3500.0f) * DotFactor;
else
coeff = DotFactor;
}*/
float coeff2 = CalculateLevelPenalty(spellProto) * stack;
if (spellProto->SpellFamilyName) //TODO: fix this
TakenTotal += int32(TakenAdvertisedBenefit * coeff * coeff2);
if (Player* modOwner = GetSpellModOwner())
{
coeff *= 100.0f;
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER,
coeff);
coeff /= 100.0f;
// DoneAdvertisedBenefit should be modified by owner auras
if (isPet()) modOwner->ApplySpellMod(spellProto->Id,
SPELLMOD_ALL_EFFECTS, DoneAdvertisedBenefit);
}
DoneTotal += int32(DoneAdvertisedBenefit * coeff * coeff2);
}
// Some spells don't benefit from done mods
if (spellProto->AttributesEx3 & SPELL_ATTR3_NO_DONE_BONUS)
{
DoneTotal = 0;
DoneTotalMod = 1.0f;
}
float tmpDamage = (int32(pdamage) + DoneTotal) * DoneTotalMod;
// apply spellmod to Done damage (flat and pct)
if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE,
tmpDamage);
tmpDamage = (tmpDamage + TakenTotal) * TakenTotalMod;
return uint32(std::max(tmpDamage, 0.0f));
}
int32 Unit::SpellBaseDamageBonus(SpellSchoolMask schoolMask)
{
int32 DoneAdvertisedBenefit = 0;
// ..done
AuraEffectList const& mDamageDone = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE);
for (AuraEffectList::const_iterator i = mDamageDone.begin();
i != mDamageDone.end(); ++i)
if (((*i)->GetMiscValue() & schoolMask) != 0
&& (*i)->GetSpellProto()->EquippedItemClass == -1 &&
// -1 == any item class (not wand then)
(*i)->GetSpellProto()->EquippedItemInventoryTypeMask == 0)
// 0 == any inventory type (not wand then)
DoneAdvertisedBenefit += (*i)->GetAmount();
if (GetTypeId() == TYPEID_PLAYER)
{
// Base value
DoneAdvertisedBenefit += this->ToPlayer()->GetBaseSpellPowerBonus();
// Damage bonus from stats
AuraEffectList const& mDamageDoneOfStatPercent = GetAuraEffectsByType(
SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT);
for (AuraEffectList::const_iterator i =
mDamageDoneOfStatPercent.begin();
i != mDamageDoneOfStatPercent.end(); ++i)
{
if ((*i)->GetMiscValue() & schoolMask)
{
// stat used stored in miscValueB for this aura
Stats usedStat = Stats((*i)->GetMiscValueB());
DoneAdvertisedBenefit += int32(
GetStat(usedStat) * (*i)->GetAmount() / 100.0f);
}
}
// ... and attack power
AuraEffectList const& mDamageDonebyAP = GetAuraEffectsByType(
SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER);
for (AuraEffectList::const_iterator i = mDamageDonebyAP.begin();
i != mDamageDonebyAP.end(); ++i)
if ((*i)->GetMiscValue() & schoolMask) DoneAdvertisedBenefit +=
int32(
GetTotalAttackPowerValue(BASE_ATTACK)
* (*i)->GetAmount() / 100.0f);
// TODO this should modify PLAYER_FIELD_MOD_SPELL_POWER_PCT instead of all the separate power fields
int32 spModPct = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_SPELL_POWER_PCT);
// should it apply to non players as well?
DoneAdvertisedBenefit += DoneAdvertisedBenefit * spModPct / 100;
}
return DoneAdvertisedBenefit > 0 ? DoneAdvertisedBenefit : 0;
}
int32 Unit::SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask,
Unit *pVictim)
{
uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
int32 TakenAdvertisedBenefit = 0;
// ..done (for creature type by mask) in taken
AuraEffectList const& mDamageDoneCreature = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE_CREATURE);
for (AuraEffectList::const_iterator i = mDamageDoneCreature.begin();
i != mDamageDoneCreature.end(); ++i)
if (creatureTypeMask & uint32((*i)->GetMiscValue())) TakenAdvertisedBenefit +=
(*i)->GetAmount();
// ..taken
AuraEffectList const& mDamageTaken = pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_TAKEN);
for (AuraEffectList::const_iterator i = mDamageTaken.begin();
i != mDamageTaken.end(); ++i)
if (((*i)->GetMiscValue() & schoolMask) != 0) TakenAdvertisedBenefit +=
(*i)->GetAmount();
return TakenAdvertisedBenefit > 0 ? TakenAdvertisedBenefit : 0;
}
bool Unit::isSpellCrit(Unit *pVictim, SpellEntry const *spellProto,
SpellSchoolMask schoolMask, WeaponAttackType attackType) const
{
// Mobs can't crit with spells.
if (IS_CREATURE_GUID(GetGUID())) if (!((m_unitTypeMask
& (UNIT_MASK_SUMMON | UNIT_MASK_MINION | UNIT_MASK_GUARDIAN
| UNIT_MASK_TOTEM | UNIT_MASK_PET | UNIT_MASK_HUNTER_PET))
&& IS_PLAYER_GUID(GetOwnerGUID()))) return false;
// not critting spell
if ((spellProto->AttributesEx2 & SPELL_ATTR2_CANT_CRIT)) return false;
float crit_chance = 0.0f;
switch (spellProto->DmgClass)
{
case SPELL_DAMAGE_CLASS_NONE:
// We need more spells to find a general way (if there is any)
switch (spellProto->Id)
{
case 379: // Earth Shield
case 33778: // Lifebloom Final Bloom
case 64844: // Divine Hymn
break;
default:
return false;
}
case SPELL_DAMAGE_CLASS_MAGIC:
{
if (schoolMask & SPELL_SCHOOL_MASK_NORMAL) crit_chance = 0.0f;
// For other schools
else if (GetTypeId() == TYPEID_PLAYER) crit_chance = GetFloatValue(
PLAYER_SPELL_CRIT_PERCENTAGE1
+ GetFirstSchoolInMask(schoolMask));
else
{
crit_chance = (float) m_baseSpellCritChance;
crit_chance += GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
}
// taken
if (pVictim)
{
if (!IsPositiveSpell(spellProto->Id))
{
// Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE
crit_chance += pVictim->GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE,
schoolMask);
// Modify critical chance by victim SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE
crit_chance +=
pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE);
}
// scripted (increase crit chance ... against ... target by x%
AuraEffectList const& mOverrideClassScript =
GetAuraEffectsByType(SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i =
mOverrideClassScript.begin();
i != mOverrideClassScript.end(); ++i)
{
if (!((*i)->IsAffectedOnSpell(spellProto))) continue;
int32 modChance = 0;
switch ((*i)->GetMiscValue())
{
// Shatter
case 911:
modChance += 16;
case 910:
modChance += 17;
case 849:
modChance += 17;
if (!pVictim->HasAuraState(AURA_STATE_FROZEN,
spellProto, this)) break;
crit_chance += modChance;
break;
case 7917: // Glyph of Shadowburn
if (pVictim->HasAuraState(
AURA_STATE_HEALTHLESS_35_PERCENT,
spellProto, this)) crit_chance +=
(*i)->GetAmount();
break;
case 7997: // Renewed Hope
case 7998:
if (pVictim->HasAura(6788)) crit_chance +=
(*i)->GetAmount();
break;
case 21: // Test of Faith
case 6935:
case 6918:
if (pVictim->HealthBelowPct(50)) crit_chance +=
(*i)->GetAmount();
break;
default:
break;
}
}
// Custom crit by class
switch (spellProto->SpellFamilyName)
{
case SPELLFAMILY_MAGE:
// Glyph of Fire Blast
if ((spellProto->SpellFamilyFlags[0] & 0x2) == 0x2 && spellProto->SpellIconID == 12)
if (pVictim->HasAuraWithMechanic((1<<MECHANIC_STUN) | (1<<MECHANIC_KNOCKOUT)))
if (AuraEffect const* aurEff = GetAuraEffect(56369, EFFECT_0))
crit_chance += aurEff->GetAmount();
break;
case SPELLFAMILY_DRUID:
// Improved Faerie Fire
if (pVictim->HasAuraState(AURA_STATE_FAERIE_FIRE)) if (AuraEffect const * aurEff = GetDummyAuraEffect(SPELLFAMILY_DRUID, 109, 0)) crit_chance +=
aurEff->GetAmount();
// cumulative effect - don't break
// Starfire
if (spellProto->SpellFamilyFlags [0] & 0x4
&& spellProto->SpellIconID == 1485)
{
// Improved Insect Swarm
if (AuraEffect const * aurEff = GetDummyAuraEffect(SPELLFAMILY_DRUID, 1771, 0)) if (pVictim->GetAuraEffect(
SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_DRUID, 0x00000002, 0, 0)) crit_chance +=
aurEff->GetAmount();
break;
}
break;
case SPELLFAMILY_ROGUE:
// Shiv-applied poisons can't crit
if (FindCurrentSpellBySpellId(5938)) crit_chance = 0.0f;
break;
case SPELLFAMILY_PALADIN:
// Exorcism
if (spellProto->Category == 19)
{
if (pVictim->GetCreatureTypeMask()
& CREATURE_TYPEMASK_DEMON_OR_UNDEAD) return true;
break;
}
break;
case SPELLFAMILY_SHAMAN:
// Lava Burst
if (spellProto->SpellFamilyFlags [1] & 0x00001000)
{
if (pVictim->GetAuraEffect(
SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_SHAMAN, 0x10000000, 0, 0,
GetGUID())) if (pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_SPELL_AND_WEAPON_CRIT_CHANCE)
> -100) return true;
break;
}
break;
}
}
break;
}
case SPELL_DAMAGE_CLASS_MELEE:
if (pVictim)
{
// Custom crit by class
switch (spellProto->SpellFamilyName)
{
case SPELLFAMILY_DRUID:
// Rend and Tear - bonus crit chance for Ferocious Bite on bleeding targets
if (spellProto->SpellFamilyFlags [0] & 0x00800000
&& spellProto->SpellIconID == 1680
&& pVictim->HasAuraState(AURA_STATE_BLEEDING))
{
if (AuraEffect const *rendAndTear = GetDummyAuraEffect(SPELLFAMILY_DRUID, 2859, 1)) crit_chance +=
rendAndTear->GetAmount();
break;
}
break;
case SPELLFAMILY_PALADIN:
// Judgement of Command proc always crits on stunned target
if (spellProto->SpellFamilyName == SPELLFAMILY_PALADIN) if (spellProto->SpellFamilyFlags [0]
& 0x0000000000800000LL
&& spellProto->SpellIconID == 561) if (pVictim->HasUnitState(
UNIT_STAT_STUNNED)) return true;
}
}
case SPELL_DAMAGE_CLASS_RANGED:
{
if (pVictim)
{
crit_chance += GetUnitCriticalChance(attackType, pVictim);
crit_chance += GetTotalAuraModifierByMiscMask(
SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL, schoolMask);
}
break;
}
default:
return false;
}
// percent done
// only players use intelligence for critical chance computations
if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, SPELLMOD_CRITICAL_CHANCE, crit_chance);
crit_chance = crit_chance > 0.0f ? crit_chance : 0.0f;
if (roll_chance_f(crit_chance)) return true;
return false;
}
uint32 Unit::SpellCriticalDamageBonus(SpellEntry const *spellProto,
uint32 damage, Unit *pVictim)
{
// Calculate critical bonus
int32 crit_bonus;
Player* modOwner = GetSpellModOwner();
switch (spellProto->DmgClass)
{
case SPELL_DAMAGE_CLASS_MELEE: // for melee based spells is 100%
case SPELL_DAMAGE_CLASS_RANGED:
// TODO: write here full calculation for melee/ranged spells
crit_bonus = damage;
break;
default:
if (modOwner
&& (modOwner->getClass() == CLASS_MAGE
|| modOwner->getClass() == CLASS_WARLOCK))
{
crit_bonus = damage; // 100% bonus for Mages and Warlocks in Cataclysm
}
else
{
crit_bonus = damage / 2; // for spells is 50%
}
break;
}
// adds additional damage to crit_bonus (from talents)
if (modOwner) modOwner->ApplySpellMod(spellProto->Id,
SPELLMOD_CRIT_DAMAGE_BONUS, crit_bonus);
if (pVictim)
{
uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
crit_bonus = int32(
crit_bonus
* GetTotalAuraMultiplierByMiscMask(
SPELL_AURA_MOD_CRIT_PERCENT_VERSUS,
creatureTypeMask));
}
if (crit_bonus > 0) damage += crit_bonus;
return damage;
}
uint32 Unit::SpellCriticalHealingBonus(SpellEntry const *spellProto,
uint32 damage, Unit *pVictim)
{
// Calculate critical bonus
int32 crit_bonus;
switch (spellProto->DmgClass)
{
case SPELL_DAMAGE_CLASS_MELEE: // for melee based spells is 100%
case SPELL_DAMAGE_CLASS_RANGED:
// TODO: write here full calculation for melee/ranged spells
crit_bonus = damage;
break;
default:
crit_bonus = damage / 2; // for spells is 50%
break;
}
if (pVictim)
{
uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
crit_bonus = int32(
crit_bonus
* GetTotalAuraMultiplierByMiscMask(
SPELL_AURA_MOD_CRIT_PERCENT_VERSUS,
creatureTypeMask));
}
if (crit_bonus > 0) damage += crit_bonus;
damage = int32(
float(damage)
* GetTotalAuraMultiplier(
SPELL_AURA_MOD_CRITICAL_HEALING_AMOUNT));
return damage;
}
uint32 Unit::SpellHealingBonus(Unit *pVictim, SpellEntry const *spellProto,
uint32 effIndex, uint32 healamount, DamageEffectType damagetype,
uint32 stack)
{
// For totems get healing bonus from owner (statue isn't totem in fact)
if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->isTotem()) if (Unit* owner = GetOwner()) return owner->SpellHealingBonus(
pVictim, spellProto, effIndex, healamount, damagetype, stack);
// no bonus for heal potions/bandages
if (spellProto->SpellFamilyName == SPELLFAMILY_POTION) return healamount;
// and Warlock's Healthstones
if (spellProto->SpellFamilyName == SPELLFAMILY_WARLOCK
&& (spellProto->SpellFamilyFlags [0] & 0x10000))
{
healamount = 0.45 * (GetMaxHealth() - 10 * (STAT_STAMINA - 180));
return healamount;
}
// Healing Done
// Taken/Done total percent damage auras
float DoneTotalMod = 1.0f;
float TakenTotalMod = 1.0f;
int32 DoneTotal = 0;
int32 TakenTotal = 0;
// Healing done percent
AuraEffectList const& mHealingDonePct = GetAuraEffectsByType(
SPELL_AURA_MOD_HEALING_DONE_PERCENT);
for (AuraEffectList::const_iterator i = mHealingDonePct.begin();
i != mHealingDonePct.end(); ++i)
DoneTotalMod *= (100.0f + (*i)->GetAmount()) / 100.0f;
// done scripted mod (take it from owner)
Unit *owner = GetOwner() ? GetOwner() : this;
AuraEffectList const &mOverrideClassScript = owner->GetAuraEffectsByType(
SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i = mOverrideClassScript.begin();
i != mOverrideClassScript.end(); ++i)
{
if (!(*i)->IsAffectedOnSpell(spellProto)) continue;
switch ((*i)->GetMiscValue())
{
case 4415: // Increased Rejuvenation Healing
case 4953:
case 3736: // Hateful Totem of the Third Wind / Increased Lesser Healing Wave / LK Arena (4/5/6) Totem of the Third Wind / Savage Totem of the Third Wind
DoneTotal += (*i)->GetAmount();
break;
case 7997: // Renewed Hope
case 7998:
if (pVictim->HasAura(6788)) DoneTotalMod *= ((*i)->GetAmount()
+ 100.0f) / 100.0f;
break;
case 21: // Test of Faith
case 6935:
case 6918:
if (pVictim->HealthBelowPct(50)) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
case 7798: // Glyph of Regrowth
{
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL,
SPELLFAMILY_DRUID, 0x40, 0, 0)) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
case 8477: // Nourish Heal Boost
{
int32 stepPercent = (*i)->GetAmount();
int32 modPercent = 0;
AuraApplicationMap const& victimAuras =
pVictim->GetAppliedAuras();
for (AuraApplicationMap::const_iterator itr =
victimAuras.begin(); itr != victimAuras.end(); ++itr)
{
Aura const * aura = itr->second->GetBase();
if (aura->GetCasterGUID() != GetGUID()) continue;
SpellEntry const* m_spell = aura->GetSpellProto();
if (m_spell->SpellFamilyName != SPELLFAMILY_DRUID
|| !(m_spell->SpellFamilyFlags [1] & 0x00000010
|| m_spell->SpellFamilyFlags [0] & 0x50)) continue;
modPercent += stepPercent * aura->GetStackAmount();
}
DoneTotalMod *= (modPercent + 100.0f) / 100.0f;
break;
}
case 7871: // Glyph of Lesser Healing Wave
{
if (pVictim->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN,
0, 0x00000400, 0, GetGUID())) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
default:
break;
}
}
// Taken/Done fixed damage bonus auras
int32 DoneAdvertisedBenefit = SpellBaseHealingBonus(
GetSpellSchoolMask(spellProto));
int32 TakenAdvertisedBenefit = SpellBaseHealingBonusForVictim(
GetSpellSchoolMask(spellProto), pVictim);
// ignored now cause DBC should have the right info for nearly all effects
// delte if all goes well
bool scripted = false;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
switch (spellProto->EffectApplyAuraName [i])
{
// These auras do not use healing coeff
case SPELL_AURA_PERIODIC_LEECH:
case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
scripted = true;
break;
}
}
// Check for table values
SpellBonusEntry const* bonus =
!scripted ? sSpellMgr->GetSpellBonusData(spellProto->Id) : NULL;
float coeff = 0;
float factorMod = 1.0f;
if (bonus)
{
if (damagetype == DOT)
{
coeff = bonus->dot_damage;
if (bonus->ap_dot_bonus > 0) DoneTotal +=
int32(
bonus->ap_dot_bonus * stack
* GetTotalAttackPowerValue(
(IsRangedWeaponSpell(spellProto)
&& spellProto->DmgClass
!= SPELL_DAMAGE_CLASS_MELEE) ?
RANGED_ATTACK : BASE_ATTACK));
}
else
{
coeff = bonus->direct_damage;
if (bonus->ap_bonus > 0) DoneTotal +=
int32(
bonus->ap_bonus * stack
* GetTotalAttackPowerValue(
(IsRangedWeaponSpell(spellProto)
&& spellProto->DmgClass
!= SPELL_DAMAGE_CLASS_MELEE) ?
RANGED_ATTACK : BASE_ATTACK));
}
}
else // scripted bonus
{
// Gift of the Naaru
if (spellProto->SpellFamilyFlags [2] & 0x80000000
&& spellProto->SpellIconID == 329)
{
scripted = true;
int32 apBonus = int32(
std::max(GetTotalAttackPowerValue(BASE_ATTACK),
GetTotalAttackPowerValue(RANGED_ATTACK)));
if (apBonus > DoneAdvertisedBenefit) DoneTotal += int32(
apBonus * 0.22f); // 22% of AP per tick
else DoneTotal += int32(DoneAdvertisedBenefit * 0.377f); //37.7% of BH per tick
}
// Earthliving - 0.45% of normal hot coeff
else if (spellProto->SpellFamilyName == SPELLFAMILY_SHAMAN
&& spellProto->SpellFamilyFlags [1] & 0x80000) factorMod *=
0.45f;
// Already set to scripted? so not uses healing bonus coefficient
// No heal coeff for SPELL_DAMAGE_CLASS_NONE class spells by default
else if (scripted || spellProto->DmgClass == SPELL_DAMAGE_CLASS_NONE)
{
scripted = true;
coeff = 0.0f;
}
}
// Default calculation
if (DoneAdvertisedBenefit || TakenAdvertisedBenefit)
{
if (coeff <= 0)
{
if (effIndex < 4)
{
coeff = spellProto->EffectBonusCoefficient [effIndex];
}
else
{ // should never happen
coeff = 0;
}
}
// Formula based SP coefficient calculation is disabled cause all coeffs should be present in the DBC
// A few custom cases go into spell_bonus_data table
/*if ((!bonus && !scripted) || coeff < 0)
{
// Damage Done from spell damage bonus
int32 CastingTime = !IsChanneledSpell(spellProto) ? GetSpellCastTime(spellProto) : GetSpellDuration(spellProto);
// Damage over Time spells bonus calculation
float DotFactor = 1.0f;
if (damagetype == DOT)
{
int32 DotDuration = GetSpellDuration(spellProto);
// 200% limit
if (DotDuration > 0)
{
if (DotDuration > 30000) DotDuration = 30000;
if (!IsChanneledSpell(spellProto)) DotFactor = DotDuration / 15000.0f;
uint32 x = 0;
for (uint8 j = 0; j < MAX_SPELL_EFFECTS; j++)
{
if (spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && (
spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_DAMAGE ||
spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH))
{
x = j;
break;
}
}
int32 DotTicks = 6;
if (spellProto->EffectAmplitude[x] != 0)
DotTicks = DotDuration / spellProto->EffectAmplitude[x];
if (DotTicks)
{
DoneAdvertisedBenefit = DoneAdvertisedBenefit * int32(stack) / DotTicks;
TakenAdvertisedBenefit = TakenAdvertisedBenefit * int32(stack) / DotTicks;
}
}
}
// Distribute Damage over multiple effects, reduce by AoE
CastingTime = GetCastingTimeForBonus(spellProto, damagetype, CastingTime);
// 50% for damage and healing spells for leech spells from damage bonus and 0% from healing
for (uint8 j = 0; j < MAX_SPELL_EFFECTS; ++j)
{
if (spellProto->Effect[j] == SPELL_EFFECT_HEALTH_LEECH ||
(spellProto->Effect[j] == SPELL_EFFECT_APPLY_AURA && spellProto->EffectApplyAuraName[j] == SPELL_AURA_PERIODIC_LEECH))
{
CastingTime /= 2;
break;
}
}
// As wowwiki says: C = (Cast Time / 3.5) * 1.88 (for healing spells)
coeff = (CastingTime / 3500.0f) * DotFactor * 1.88f;
}*/
factorMod *= CalculateLevelPenalty(spellProto) * stack;
TakenTotal += int32(TakenAdvertisedBenefit * coeff * factorMod);
if (Player* modOwner = GetSpellModOwner())
{
coeff *= 100.0f;
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_BONUS_MULTIPLIER,
coeff);
coeff /= 100.0f;
}
DoneTotal += int32(DoneAdvertisedBenefit * coeff * factorMod);
}
// use float as more appropriate for negative values and percent applying
float heal = (int32(healamount) + DoneTotal) * DoneTotalMod;
// apply spellmod to Done amount
if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, damagetype == DOT ? SPELLMOD_DOT : SPELLMOD_DAMAGE,
heal);
// Nourish cast
if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID
&& spellProto->SpellFamilyFlags [1] & 0x2000000)
{
// Rejuvenation, Regrowth, Lifebloom, or Wild Growth
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_HEAL, SPELLFAMILY_DRUID,
0x50, 0x4000010, 0))
//increase healing by 20%
TakenTotalMod *= 1.2f;
}
// Taken mods
// Healing Wave
if (spellProto->SpellFamilyName == SPELLFAMILY_SHAMAN
&& spellProto->SpellFamilyFlags [0] & 0x40)
{
// Search for Healing Way on Victim
if (AuraEffect const* HealingWay = pVictim->GetAuraEffect(29203, 0)) TakenTotalMod *=
(HealingWay->GetAmount() + 100.0f) / 100.0f;
}
// Tenacity increase healing % taken
if (AuraEffect const* Tenacity = pVictim->GetAuraEffect(58549, 0)) TakenTotalMod *=
(Tenacity->GetAmount() + 100.0f) / 100.0f;
// Healing taken percent
float minval = (float) pVictim->GetMaxNegativeAuraModifier(
SPELL_AURA_MOD_HEALING_PCT);
if (minval) TakenTotalMod *= (100.0f + minval) / 100.0f;
float maxval = (float) pVictim->GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_HEALING_PCT);
if (maxval) TakenTotalMod *= (100.0f + maxval) / 100.0f;
if (damagetype == DOT)
{
// Healing over time taken percent
float minval_hot = (float) pVictim->GetMaxNegativeAuraModifier(
SPELL_AURA_MOD_HOT_PCT);
if (minval_hot) TakenTotalMod *= (100.0f + minval_hot) / 100.0f;
float maxval_hot = (float) pVictim->GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_HOT_PCT);
if (maxval_hot) TakenTotalMod *= (100.0f + maxval_hot) / 100.0f;
}
AuraEffectList const& mHealingGet = pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_HEALING_RECEIVED);
for (AuraEffectList::const_iterator i = mHealingGet.begin();
i != mHealingGet.end(); ++i)
if (GetGUID() == (*i)->GetCasterGUID()
&& (*i)->IsAffectedOnSpell(spellProto)) TakenTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
heal = (int32(heal) + TakenTotal) * TakenTotalMod;
return uint32(std::max(heal, 0.0f));
}
int32 Unit::SpellBaseHealingBonus(SpellSchoolMask schoolMask)
{
int32 AdvertisedBenefit = 0;
AuraEffectList const& mHealingDone = GetAuraEffectsByType(
SPELL_AURA_MOD_HEALING_DONE);
for (AuraEffectList::const_iterator i = mHealingDone.begin();
i != mHealingDone.end(); ++i)
if (!(*i)->GetMiscValue() || ((*i)->GetMiscValue() & schoolMask) != 0) AdvertisedBenefit +=
(*i)->GetAmount();
// Healing bonus of spirit, intellect and strength
if (GetTypeId() == TYPEID_PLAYER)
{
// Base value
AdvertisedBenefit += this->ToPlayer()->GetBaseSpellPowerBonus();
// Healing bonus from stats
AuraEffectList const& mHealingDoneOfStatPercent = GetAuraEffectsByType(
SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT);
for (AuraEffectList::const_iterator i =
mHealingDoneOfStatPercent.begin();
i != mHealingDoneOfStatPercent.end(); ++i)
{
// stat used dependent from misc value (stat index)
Stats usedStat =
Stats(
(*i)->GetSpellProto()->EffectMiscValue [(*i)->GetEffIndex()]);
AdvertisedBenefit += int32(
GetStat(usedStat) * (*i)->GetAmount() / 100.0f);
}
// ... and attack power
AuraEffectList const& mHealingDonebyAP = GetAuraEffectsByType(
SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER);
for (AuraEffectList::const_iterator i = mHealingDonebyAP.begin();
i != mHealingDonebyAP.end(); ++i)
if ((*i)->GetMiscValue() & schoolMask) AdvertisedBenefit += int32(
GetTotalAttackPowerValue(BASE_ATTACK) * (*i)->GetAmount()
/ 100.0f);
// TODO this should modify PLAYER_FIELD_MOD_SPELL_POWER_PCT instead of all the separate power fields
int32 spModPct = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_SPELL_POWER_PCT);
// should it apply to non players as well?
AdvertisedBenefit += AdvertisedBenefit * spModPct / 100;
}
return AdvertisedBenefit;
}
int32 Unit::SpellBaseHealingBonusForVictim(SpellSchoolMask schoolMask,
Unit *pVictim)
{
int32 AdvertisedBenefit = 0;
AuraEffectList const& mDamageTaken = pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_HEALING);
for (AuraEffectList::const_iterator i = mDamageTaken.begin();
i != mDamageTaken.end(); ++i)
if (((*i)->GetMiscValue() & schoolMask) != 0) AdvertisedBenefit +=
(*i)->GetAmount();
return AdvertisedBenefit;
}
bool Unit::IsImmunedToDamage(SpellSchoolMask shoolMask)
{
//If m_immuneToSchool type contain this school type, IMMUNE damage.
SpellImmuneList const& schoolList = m_spellImmune [IMMUNITY_SCHOOL];
for (SpellImmuneList::const_iterator itr = schoolList.begin();
itr != schoolList.end(); ++itr)
if (itr->type & shoolMask) return true;
//If m_immuneToDamage type contain magic, IMMUNE damage.
SpellImmuneList const& damageList = m_spellImmune [IMMUNITY_DAMAGE];
for (SpellImmuneList::const_iterator itr = damageList.begin();
itr != damageList.end(); ++itr)
if (itr->type & shoolMask) return true;
return false;
}
bool Unit::IsImmunedToDamage(SpellEntry const* spellInfo)
{
if (spellInfo->Attributes & SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY) return false;
uint32 shoolMask = GetSpellSchoolMask(spellInfo);
if (spellInfo->Id != 42292 && spellInfo->Id != 59752)
{
//If m_immuneToSchool type contain this school type, IMMUNE damage.
SpellImmuneList const& schoolList = m_spellImmune [IMMUNITY_SCHOOL];
for (SpellImmuneList::const_iterator itr = schoolList.begin();
itr != schoolList.end(); ++itr)
if (itr->type & shoolMask
&& !CanSpellPierceImmuneAura(spellInfo,
sSpellStore.LookupEntry(itr->spellId))) return true;
}
//If m_immuneToDamage type contain magic, IMMUNE damage.
SpellImmuneList const& damageList = m_spellImmune [IMMUNITY_DAMAGE];
for (SpellImmuneList::const_iterator itr = damageList.begin();
itr != damageList.end(); ++itr)
if (itr->type & shoolMask) return true;
return false;
}
bool Unit::IsImmunedToSpell(SpellEntry const* spellInfo)
{
if (!spellInfo) return false;
// Single spell immunity.
SpellImmuneList const& idList = m_spellImmune [IMMUNITY_ID];
for (SpellImmuneList::const_iterator itr = idList.begin();
itr != idList.end(); ++itr)
if (itr->type == spellInfo->Id) return true;
if (spellInfo->Attributes & SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY) return false;
if (spellInfo->Dispel)
{
SpellImmuneList const& dispelList = m_spellImmune [IMMUNITY_DISPEL];
for (SpellImmuneList::const_iterator itr = dispelList.begin();
itr != dispelList.end(); ++itr)
if (itr->type == spellInfo->Dispel) return true;
}
if (spellInfo->Mechanic)
{
SpellImmuneList const& mechanicList = m_spellImmune [IMMUNITY_MECHANIC];
for (SpellImmuneList::const_iterator itr = mechanicList.begin();
itr != mechanicList.end(); ++itr)
if (itr->type == spellInfo->Mechanic) return true;
}
for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
// State/effect immunities applied by aura expect full spell immunity
// Ignore effects with mechanic, they are supposed to be checked separately
if (!spellInfo->EffectMechanic [i]
&& spellInfo->Effect [i] != SPELL_EFFECT_KNOCK_BACK) if (IsImmunedToSpellEffect(
spellInfo, i)) return true;
}
if (spellInfo->Id != 42292 && spellInfo->Id != 59752)
{
SpellImmuneList const& schoolList = m_spellImmune [IMMUNITY_SCHOOL];
for (SpellImmuneList::const_iterator itr = schoolList.begin();
itr != schoolList.end(); ++itr)
if ((itr->type & GetSpellSchoolMask(spellInfo))
&& !(IsPositiveSpell(itr->spellId)
&& IsPositiveSpell(spellInfo->Id))
&& !CanSpellPierceImmuneAura(spellInfo,
sSpellStore.LookupEntry(itr->spellId))) return true;
}
return false;
}
bool Unit::IsImmunedToSpellEffect(SpellEntry const* spellInfo,
uint32 index) const
{
if (!spellInfo) return false;
//If m_immuneToEffect type contain this effect type, IMMUNE effect.
uint32 effect = spellInfo->Effect [index];
SpellImmuneList const& effectList = m_spellImmune [IMMUNITY_EFFECT];
for (SpellImmuneList::const_iterator itr = effectList.begin();
itr != effectList.end(); ++itr)
if (itr->type == effect) return true;
if (uint32 mechanic = spellInfo->EffectMechanic[index])
{
SpellImmuneList const& mechanicList = m_spellImmune [IMMUNITY_MECHANIC];
for (SpellImmuneList::const_iterator itr = mechanicList.begin();
itr != mechanicList.end(); ++itr)
if (itr->type == mechanic) return true;
}
if (uint32 aura = spellInfo->EffectApplyAuraName[index])
{
SpellImmuneList const& list = m_spellImmune [IMMUNITY_STATE];
for (SpellImmuneList::const_iterator itr = list.begin();
itr != list.end(); ++itr)
if (itr->type == aura) return true;
// Check for immune to application of harmful magical effects
AuraEffectList const& immuneAuraApply = GetAuraEffectsByType(
SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL);
for (AuraEffectList::const_iterator iter = immuneAuraApply.begin();
iter != immuneAuraApply.end(); ++iter)
if ((spellInfo->Dispel == DISPEL_MAGIC
|| spellInfo->Dispel == DISPEL_CURSE || // Magical debuff
spellInfo->Dispel == DISPEL_DISEASE
|| spellInfo->Dispel == DISPEL_POISON)
&& ((*iter)->GetMiscValue() & GetSpellSchoolMask(spellInfo))
&& // Check school
!IsPositiveEffect(spellInfo->Id, index)) // Harmful
return true;
}
return false;
}
bool Unit::IsDamageToThreatSpell(SpellEntry const * spellInfo) const
{
if (!spellInfo) return false;
switch (spellInfo->SpellFamilyName)
{
case SPELLFAMILY_WARLOCK:
if (spellInfo->SpellFamilyFlags [0] == 0x100) // Searing Pain
return true;
break;
case SPELLFAMILY_SHAMAN:
if (spellInfo->SpellFamilyFlags [0]
== SPELLFAMILYFLAG_SHAMAN_FROST_SHOCK) return true;
break;
case SPELLFAMILY_DEATHKNIGHT:
if (spellInfo->SpellFamilyFlags [1] == 0x20000000) // Rune Strike
return true;
if (spellInfo->SpellFamilyFlags [2] == 0x8) // Death and Decay
return true;
break;
case SPELLFAMILY_WARRIOR:
if (spellInfo->SpellFamilyFlags [0] == 0x80) // Thunder Clap
return true;
break;
}
return false;
}
void Unit::MeleeDamageBonus(Unit *pVictim, uint32 *pdamage,
WeaponAttackType attType, SpellEntry const *spellProto)
{
if (!pVictim) return;
if (*pdamage == 0) return;
uint32 creatureTypeMask = pVictim->GetCreatureTypeMask();
// Taken/Done fixed damage bonus auras
int32 DoneFlatBenefit = 0;
int32 TakenFlatBenefit = 0;
// ..done (for creature type by mask) in taken
AuraEffectList const& mDamageDoneCreature = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE_CREATURE);
for (AuraEffectList::const_iterator i = mDamageDoneCreature.begin();
i != mDamageDoneCreature.end(); ++i)
if (creatureTypeMask & uint32((*i)->GetMiscValue())) DoneFlatBenefit +=
(*i)->GetAmount();
// ..done
// SPELL_AURA_MOD_DAMAGE_DONE included in weapon damage
// ..done (base at attack power for marked target and base at attack power for creature type)
int32 APbonus = 0;
if (attType == RANGED_ATTACK)
{
APbonus += pVictim->GetTotalAuraModifier(
SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS);
// ..done (base at attack power and creature type)
AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(
SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS);
for (AuraEffectList::const_iterator i = mCreatureAttackPower.begin();
i != mCreatureAttackPower.end(); ++i)
if (creatureTypeMask & uint32((*i)->GetMiscValue())) APbonus +=
(*i)->GetAmount();
}
else
{
APbonus += pVictim->GetTotalAuraModifier(
SPELL_AURA_MELEE_ATTACK_POWER_ATTACKER_BONUS);
// ..done (base at attack power and creature type)
AuraEffectList const& mCreatureAttackPower = GetAuraEffectsByType(
SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS);
for (AuraEffectList::const_iterator i = mCreatureAttackPower.begin();
i != mCreatureAttackPower.end(); ++i)
if (creatureTypeMask & uint32((*i)->GetMiscValue())) APbonus +=
(*i)->GetAmount();
}
if (APbonus != 0) // Can be negative
{
bool normalized = false;
if (spellProto) for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
if (spellProto->Effect [i] == SPELL_EFFECT_NORMALIZED_WEAPON_DMG)
{
normalized = true;
break;
}
DoneFlatBenefit += int32(
APbonus / 14.0f * GetAPMultiplier(attType, normalized));
}
// ..taken
AuraEffectList const& mDamageTaken = pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_TAKEN);
for (AuraEffectList::const_iterator i = mDamageTaken.begin();
i != mDamageTaken.end(); ++i)
if ((*i)->GetMiscValue() & GetMeleeDamageSchoolMask()) TakenFlatBenefit +=
(*i)->GetAmount();
if (attType != RANGED_ATTACK) TakenFlatBenefit +=
pVictim->GetTotalAuraModifier(SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN);
else TakenFlatBenefit += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN);
// Done/Taken total percent damage auras
float DoneTotalMod = 1.0f;
float TakenTotalMod = 1.0f;
// ..done
// SPELL_AURA_MOD_DAMAGE_PERCENT_DONE included in weapon damage
// SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT included in weapon damage
// SPELL_AURA_MOD_DAMAGE_PERCENT_DONE for non-physical spells like Scourge Strike, Frost Strike, this is NOT included in weapon damage
if (spellProto) if (GetSpellSchoolMask(spellProto)
!= SPELL_SCHOOL_MASK_NORMAL)
{
AuraEffectList const &mModDamagePercentDone = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
for (AuraEffectList::const_iterator i = mModDamagePercentDone.begin();
i != mModDamagePercentDone.end(); ++i)
if (((*i)->GetMiscValue() & GetSpellSchoolMask(spellProto))
&& !((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
}
AuraEffectList const &mDamageDoneVersus = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE_VERSUS);
for (AuraEffectList::const_iterator i = mDamageDoneVersus.begin();
i != mDamageDoneVersus.end(); ++i)
if (creatureTypeMask & uint32((*i)->GetMiscValue())) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
// bonus against aurastate
AuraEffectList const &mDamageDoneVersusAurastate = GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_DONE_VERSUS_AURASTATE);
for (AuraEffectList::const_iterator i = mDamageDoneVersusAurastate.begin();
i != mDamageDoneVersusAurastate.end(); ++i)
if (pVictim->HasAuraState(AuraState((*i)->GetMiscValue()))) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
// done scripted mod (take it from owner)
Unit * owner = GetOwner() ? GetOwner() : this;
AuraEffectList const &mOverrideClassScript = owner->GetAuraEffectsByType(
SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i = mOverrideClassScript.begin();
i != mOverrideClassScript.end(); ++i)
{
if (!(*i)->IsAffectedOnSpell(spellProto)) continue;
switch ((*i)->GetMiscValue())
{
// Tundra Stalker
// Merciless Combat
case 7277:
{
// Merciless Combat
if ((*i)->GetSpellProto()->SpellIconID == 2656)
{
if (!pVictim->HealthAbovePct(35)) DoneTotalMod *= (100.0f
+ (*i)->GetAmount()) / 100.0f;
}
// Tundra Stalker
else
{
// Frost Fever (target debuff)
if (pVictim->HasAura(55095)) DoneTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
}
break;
}
// Rage of Rivendare
case 7293:
{
if (pVictim->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE,
SPELLFAMILY_DEATHKNIGHT, 0, 0x02000000, 0)) if (SpellChainNode const *chain = sSpellMgr->GetSpellChainNode((*i)->GetId())) DoneTotalMod *=
(chain->rank * 2.0f + 100.0f) / 100.0f;
break;
}
}
}
// Custom scripted damage
if (spellProto) switch (spellProto->SpellFamilyName)
{
case SPELLFAMILY_DEATHKNIGHT:
// Glacier Rot
if (spellProto->SpellFamilyFlags [0] & 0x2
|| spellProto->SpellFamilyFlags [1] & 0x6) if (AuraEffect * aurEff = GetDummyAuraEffect(SPELLFAMILY_DEATHKNIGHT, 196, 0)) if (pVictim->GetDiseasesByCaster(
owner->GetGUID()) > 0) DoneTotalMod *= (100.0f
+ aurEff->GetAmount()) / 100.0f;
break;
}
// ..taken
AuraEffectList const& mModDamagePercentTaken =
pVictim->GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
for (AuraEffectList::const_iterator i = mModDamagePercentTaken.begin();
i != mModDamagePercentTaken.end(); ++i)
if ((*i)->GetMiscValue() & GetMeleeDamageSchoolMask()) TakenTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
// From caster spells
AuraEffectList const& mOwnerTaken = pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_DAMAGE_FROM_CASTER);
for (AuraEffectList::const_iterator i = mOwnerTaken.begin();
i != mOwnerTaken.end(); ++i)
if ((*i)->GetCasterGUID() == GetGUID()
&& (*i)->IsAffectedOnSpell(spellProto)) TakenTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
// .. taken pct (special attacks)
if (spellProto)
{
// Mod damage from spell mechanic
uint32 mechanicMask = GetAllSpellMechanicMask(spellProto);
// Shred, Maul - "Effects which increase Bleed damage also increase Shred damage"
if (spellProto->SpellFamilyName == SPELLFAMILY_DRUID
&& spellProto->SpellFamilyFlags [0] & 0x00008800) mechanicMask |=
(1 << MECHANIC_BLEED);
if (mechanicMask)
{
AuraEffectList const& mDamageDoneMechanic =
pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT);
for (AuraEffectList::const_iterator i = mDamageDoneMechanic.begin();
i != mDamageDoneMechanic.end(); ++i)
if (mechanicMask & uint32(1 << ((*i)->GetMiscValue()))) TakenTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
}
}
// .. taken pct: dummy auras
AuraEffectList const& mDummyAuras = pVictim->GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator i = mDummyAuras.begin();
i != mDummyAuras.end(); ++i)
{
switch ((*i)->GetSpellProto()->SpellIconID)
{
//Cheat Death
case 2109:
if ((*i)->GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL)
{
// needs rework 4.0.6
/*if (pVictim->GetTypeId() != TYPEID_PLAYER)
continue;
float mod = pVictim->ToPlayer()->GetRatingBonusValue(CR_CRIT_TAKEN_MELEE)*(-8.0f);
if (mod < (*i)->GetAmount())
mod = (float)(*i)->GetAmount();
TakenTotalMod *= (mod+100.0f)/100.0f;*/
}
break;
// Blessing of Sanctuary
// Greater Blessing of Sanctuary
case 19:
case 1804:
{
if ((*i)->GetSpellProto()->SpellFamilyName
!= SPELLFAMILY_PALADIN) continue;
if ((*i)->GetMiscValue()
& (spellProto ? GetSpellSchoolMask(spellProto) : 0)) TakenTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
// Ebon Plague
case 1933:
if ((*i)->GetMiscValue()
& (spellProto ? GetSpellSchoolMask(spellProto) : 0)) TakenTotalMod *=
((*i)->GetAmount() + 100.0f) / 100.0f;
break;
}
}
// .. taken pct: class scripts
AuraEffectList const& mclassScritAuras = GetAuraEffectsByType(
SPELL_AURA_OVERRIDE_CLASS_SCRIPTS);
for (AuraEffectList::const_iterator i = mclassScritAuras.begin();
i != mclassScritAuras.end(); ++i)
{
switch ((*i)->GetMiscValue())
{
case 6427:
case 6428: // Dirty Deeds
if (pVictim->HasAuraState(AURA_STATE_HEALTHLESS_35_PERCENT,
spellProto, this))
{
AuraEffect* eff0 = (*i)->GetBase()->GetEffect(0);
if (!eff0 || (*i)->GetEffIndex() != 1)
{
sLog->outError("Spell structure of DD (%u) changed.",
(*i)->GetId());
continue;
}
// effect 0 have expected value but in negative state
TakenTotalMod *= (-eff0->GetAmount() + 100.0f) / 100.0f;
}
break;
}
}
if (attType != RANGED_ATTACK)
{
AuraEffectList const& mModMeleeDamageTakenPercent =
pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT);
for (AuraEffectList::const_iterator i =
mModMeleeDamageTakenPercent.begin();
i != mModMeleeDamageTakenPercent.end(); ++i)
TakenTotalMod *= ((*i)->GetAmount() + 100.0f) / 100.0f;
}
else
{
AuraEffectList const& mModRangedDamageTakenPercent =
pVictim->GetAuraEffectsByType(
SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT);
for (AuraEffectList::const_iterator i =
mModRangedDamageTakenPercent.begin();
i != mModRangedDamageTakenPercent.end(); ++i)
TakenTotalMod *= ((*i)->GetAmount() + 100.0f) / 100.0f;
}
float tmpDamage = float(int32(*pdamage) + DoneFlatBenefit) * DoneTotalMod;
// apply spellmod to Done damage
if (spellProto) if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, SPELLMOD_DAMAGE, tmpDamage);
tmpDamage = (tmpDamage + TakenFlatBenefit) * TakenTotalMod;
// bonus result can be negative
*pdamage = uint32(std::max(tmpDamage, 0.0f));
}
void Unit::ApplySpellImmune(uint32 spellId, uint32 op, uint32 type, bool apply)
{
if (apply)
{
for (SpellImmuneList::iterator itr = m_spellImmune [op].begin(), next;
itr != m_spellImmune [op].end(); itr = next)
{
next = itr;
++next;
if (itr->type == type)
{
m_spellImmune [op].erase(itr);
next = m_spellImmune [op].begin();
}
}
SpellImmune Immune;
Immune.spellId = spellId;
Immune.type = type;
m_spellImmune [op].push_back(Immune);
}
else
{
for (SpellImmuneList::iterator itr = m_spellImmune [op].begin();
itr != m_spellImmune [op].end(); ++itr)
{
if (itr->spellId == spellId)
{
m_spellImmune [op].erase(itr);
break;
}
}
}
}
void Unit::ApplySpellDispelImmunity(const SpellEntry * spellProto,
DispelType type, bool apply)
{
ApplySpellImmune(spellProto->Id, IMMUNITY_DISPEL, type, apply);
if (apply
&& spellProto->AttributesEx & SPELL_ATTR1_DISPEL_AURAS_ON_IMMUNITY)
{
// Create dispel mask by dispel type
uint32 dispelMask = GetDispellMask(type);
// Dispel all existing auras vs current dispel type
AuraApplicationMap& auras = GetAppliedAuras();
for (AuraApplicationMap::iterator itr = auras.begin();
itr != auras.end();)
{
SpellEntry const* spell = itr->second->GetBase()->GetSpellProto();
if ((1 << spell->Dispel) & dispelMask)
{
// Dispel aura
RemoveAura(itr);
}
else ++itr;
}
}
}
float Unit::GetWeaponProcChance() const
{
// normalized proc chance for weapon attack speed
// (odd formula...)
if (isAttackReady(BASE_ATTACK)) return (GetAttackTime(BASE_ATTACK) * 1.8f
/ 1000.0f);
else if (haveOffhandWeapon() && isAttackReady(OFF_ATTACK)) return (GetAttackTime(
OFF_ATTACK) * 1.6f / 1000.0f);
return 0;
}
float Unit::GetPPMProcChance(uint32 WeaponSpeed, float PPM,
const SpellEntry * spellProto) const
{
// proc per minute chance calculation
if (PPM <= 0) return 0.0f;
// Apply chance modifer aura
if (spellProto) if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, SPELLMOD_PROC_PER_MINUTE, PPM);
return floor((WeaponSpeed * PPM) / 600.0f); // result is chance in percents (probability = Speed_in_sec * (PPM / 60))
}
void Unit::Mount(uint32 mount, uint32 VehicleId, uint32 creatureEntry)
{
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MOUNT);
if (mount) SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, mount);
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT);
// unsummon pet
if (Player* plr = ToPlayer())
{
Pet* pet = plr->GetPet();
if (pet)
{
Battleground *bg = ToPlayer()->GetBattleground();
// don't unsummon pet in arena but SetFlag UNIT_FLAG_STUNNED to disable pet's interface
if (bg && bg->isArena()) pet->SetFlag(UNIT_FIELD_FLAGS,
UNIT_FLAG_STUNNED);
else plr->UnsummonPetTemporaryIfAny();
}
if (plr->GetEmoteState()) plr->SetEmoteState(0);
if (VehicleId)
{
if (CreateVehicleKit(VehicleId))
{
GetVehicleKit()->Reset();
// Send others that we now have a vehicle
WorldPacket data(SMSG_PLAYER_VEHICLE_DATA,
GetPackGUID().size() + 4);
data.appendPackGUID(GetGUID());
data << uint32(VehicleId);
SendMessageToSet(&data, true);
data.Initialize(SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA, 0);
plr->GetSession()->SendPacket(&data);
// mounts can also have accessories
GetVehicleKit()->InstallAllAccessories(creatureEntry);
}
}
}
}
void Unit::Unmount()
{
if (!IsMounted()) return;
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_NOT_MOUNTED);
SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 0);
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNT);
WorldPacket data(SMSG_DISMOUNT, 8);
data.appendPackGUID(GetGUID());
SendMessageToSet(&data, true);
// only resummon old pet if the player is already added to a map
// this prevents adding a pet to a not created map which would otherwise cause a crash
// (it could probably happen when logging in after a previous crash)
if (GetTypeId() == TYPEID_PLAYER)
{
if (Pet *pPet = this->ToPlayer()->GetPet())
{
if (pPet && pPet->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED)
&& !pPet->HasUnitState(UNIT_STAT_STUNNED)) pPet->RemoveFlag(
UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
}
else this->ToPlayer()->ResummonPetTemporaryUnSummonedIfAny();
}
if (GetTypeId() == TYPEID_PLAYER && GetVehicleKit())
{
// Send other players that we are no longer a vehicle
WorldPacket data(SMSG_PLAYER_VEHICLE_DATA, 8 + 4);
data.appendPackGUID(GetGUID());
data << uint32(0);
this->ToPlayer()->SendMessageToSet(&data, true);
// Remove vehicle class from player
RemoveVehicleKit();
}
}
void Unit::SetInCombatWith(Unit* enemy)
{
Unit* eOwner = enemy->GetCharmerOrOwnerOrSelf();
if (eOwner->IsPvP())
{
SetInCombatState(true, enemy);
return;
}
//check for duel
if (eOwner->GetTypeId() == TYPEID_PLAYER && eOwner->ToPlayer()->duel)
{
Unit const* myOwner = GetCharmerOrOwnerOrSelf();
if (((Player const*) eOwner)->duel->opponent == myOwner)
{
SetInCombatState(true, enemy);
return;
}
}
SetInCombatState(false, enemy);
}
void Unit::CombatStart(Unit* target, bool initialAggro)
{
if (initialAggro)
{
if (!target->IsStandState()) target->SetStandState(
UNIT_STAND_STATE_STAND);
if (!target->isInCombat() && target->GetTypeId() != TYPEID_PLAYER
&& !target->ToCreature()->HasReactState(REACT_PASSIVE)
&& target->ToCreature()->IsAIEnabled)
{
target->ToCreature()->AI()->AttackStart(this);
}
SetInCombatWith(target);
target->SetInCombatWith(this);
}
Unit *who = target->GetCharmerOrOwnerOrSelf();
if (who->GetTypeId() == TYPEID_PLAYER) SetContestedPvP(who->ToPlayer());
Player *me = GetCharmerOrOwnerPlayerOrPlayerItself();
if (me && who->IsPvP()
&& (who->GetTypeId() != TYPEID_PLAYER || !me->duel
|| me->duel->opponent != who))
{
me->UpdatePvP(true);
me->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
}
}
void Unit::SetInCombatState(bool PvP, Unit* enemy)
{
// only alive units can be in combat
if (!isAlive()) return;
if (PvP) m_CombatTimer = 5000;
if (isInCombat() || HasUnitState(UNIT_STAT_EVADE)) return;
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
if (GetTypeId() != TYPEID_PLAYER)
{
// Set home position at place of engaging combat for escorted creatures
if ((IsAIEnabled && this->ToCreature()->AI()->IsEscorted())
|| GetMotionMaster()->GetCurrentMovementGeneratorType()
== WAYPOINT_MOTION_TYPE
|| GetMotionMaster()->GetCurrentMovementGeneratorType()
== POINT_MOTION_TYPE) this->ToCreature()->SetHomePosition(
GetPositionX(), GetPositionY(), GetPositionZ(),
GetOrientation());
if (enemy)
{
if (IsAIEnabled)
{
this->ToCreature()->AI()->EnterCombat(enemy);
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE); //always remove Out of Combat Non Attackable flag if we enter combat and AI is enabled
}
if (this->ToCreature()->GetFormation()) this->ToCreature()->GetFormation()->MemberAttackStart(
this->ToCreature(), enemy);
}
if (isPet())
{
UpdateSpeed(MOVE_RUN, true);
UpdateSpeed(MOVE_SWIM, true);
UpdateSpeed(MOVE_FLIGHT, true);
}
if (!(ToCreature()->GetCreatureInfo()->type_flags
& CREATURE_TYPEFLAGS_MOUNTED_COMBAT)) Unmount();
}
if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->getRace() == RACE_WORGEN
&& HasAura(94293))
{
//TODO: make a hackfix for worgen starting zone.
ToPlayer()->setInWorgenForm(UNIT_FLAG2_WORGEN_TRANSFORM3);
}
for (Unit::ControlList::iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
{
(*itr)->SetInCombatState(PvP, enemy);
(*itr)->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
}
}
void Unit::ClearInCombat()
{
m_CombatTimer = 0;
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
// Player's state will be cleared in Player::UpdateContestedPvP
if (GetTypeId() != TYPEID_PLAYER)
{
Creature* creature = this->ToCreature();
if (creature->GetCreatureInfo()
&& creature->GetCreatureInfo()->unit_flags
& UNIT_FLAG_OOC_NOT_ATTACKABLE) SetFlag(
UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE); //re-apply Out of Combat Non Attackable flag if we leave combat, can be overriden in scripts in EnterEvadeMode()
ClearUnitState(UNIT_STAT_ATTACK_PLAYER);
if (HasFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED)) SetUInt32Value(
UNIT_DYNAMIC_FLAGS,
((Creature*) this)->GetCreatureInfo()->dynamicflags);
}
else this->ToPlayer()->UpdatePotionCooldown();
if (GetTypeId() != TYPEID_PLAYER && ((Creature*) this)->isPet())
{
if (Unit *owner = GetOwner()) for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
if (owner->GetSpeedRate(UnitMoveType(i))
> GetSpeedRate(UnitMoveType(i))) SetSpeed(UnitMoveType(i),
owner->GetSpeedRate(UnitMoveType(i)), true);
}
else if (!isCharmed()) return;
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PET_IN_COMBAT);
}
bool Unit::isTargetableForAttack(bool checkFakeDeath) const
{
if (!isAlive()) return false;
if (HasFlag(
UNIT_FIELD_FLAGS,
UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE
| UNIT_FLAG_OOC_NOT_ATTACKABLE)) return false;
if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->isGameMaster()) return false;
return !HasUnitState(UNIT_STAT_UNATTACKABLE)
&& (!checkFakeDeath || !HasUnitState(UNIT_STAT_DIED));
}
bool Unit::IsValidAttackTarget(Unit const* target) const
{
return canAttack(target, NULL);
}
bool Unit::canAttack(Unit const* target, bool force) const
{
ASSERT(target);
// can't attack self
if (this == target) return false;
if (force)
{
if (IsFriendlyTo(target)) return false;
if (GetTypeId() != TYPEID_PLAYER)
{
if (isPet())
{
if (Unit *owner = GetOwner()) if (!(owner->canAttack(target))) return false;
}
else if (!IsHostileTo(target)) return false;
}
}
else if (!IsHostileTo(target)) return false;
if (!target->isAttackableByAOE()) return false;
// can't attack unattackable units or GMs
if (target->HasUnitState(UNIT_STAT_UNATTACKABLE)
|| (target->GetTypeId() == TYPEID_PLAYER
&& target->ToPlayer()->isGameMaster())) return false;
// check flags
if (target->HasFlag(
UNIT_FIELD_FLAGS,
UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_TAXI_FLIGHT
| UNIT_FLAG_NOT_ATTACKABLE_1 | UNIT_FLAG_UNK_16)
|| (!HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE))
|| (!target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE))
|| (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& target->HasFlag(UNIT_FIELD_FLAGS,
UNIT_FLAG_OOC_NOT_ATTACKABLE))
|| (target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE))) return false;
// CvC case - can attack each other only when one of them is hostile
if (!HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& !target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)) return GetReactionTo(
target) <= REP_HOSTILE || target->GetReactionTo(this) <= REP_HOSTILE;
// PvP, PvC, CvP case
// can't attack friendly targets
if (GetReactionTo(target) > REP_NEUTRAL
|| target->GetReactionTo(this) > REP_NEUTRAL) return false;
if (target->HasUnitState(UNIT_STAT_DIED))
{
if (!ToCreature() || !ToCreature()->isGuard()) return false;
Player const* playerAffectingAttacker =
HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE) ?
GetAffectingPlayer() : NULL;
Player const* playerAffectingTarget =
target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE) ?
target->GetAffectingPlayer() : NULL;
// check duel - before sanctuary checks
if (playerAffectingAttacker && playerAffectingTarget) if (playerAffectingAttacker->duel
&& playerAffectingAttacker->duel->opponent
== playerAffectingTarget
&& playerAffectingAttacker->duel->startTime != 0) return true;
// additional checks - only PvP case
if (playerAffectingAttacker && playerAffectingTarget)
{
if (target->GetByteValue(UNIT_FIELD_BYTES_2, 1)
& UNIT_BYTE2_FLAG_PVP) return true;
if (GetByteValue(UNIT_FIELD_BYTES_2, 1) & UNIT_BYTE2_FLAG_FFA_PVP
&& target->GetByteValue(UNIT_FIELD_BYTES_2, 1)
& UNIT_BYTE2_FLAG_FFA_PVP) return true;
return (GetByteValue(UNIT_FIELD_BYTES_2, 1) & UNIT_BYTE2_FLAG_UNK1)
|| (target->GetByteValue(UNIT_FIELD_BYTES_2, 1)
& UNIT_BYTE2_FLAG_UNK1);
}
return true;
// PvP case - can't attack when attacker or target are in sanctuary
// however, 13850 client doesn't allow to attack when one of the unit's has sanctuary flag and is pvp
if (target->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE)
&& ((target->GetByteValue(UNIT_FIELD_BYTES_2, 1)
& UNIT_BYTE2_FLAG_SANCTUARY)
|| (GetByteValue(UNIT_FIELD_BYTES_2, 1)
& UNIT_BYTE2_FLAG_SANCTUARY))) return false;
// guards can detect fake death
if (!target->HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FEIGN_DEATH)) return false;
}
// can't attack own vehicle or passenger
if (m_vehicle) if (IsOnVehicle(target)
|| m_vehicle->GetBase()->IsOnVehicle(target)) return false;
if (!canSeeOrDetect(target)) return false;
return true;
}
bool Unit::isAttackableByAOE(bool requireDeadTarget) const
{
if (isAlive() == requireDeadTarget) return false;
if (HasFlag(
UNIT_FIELD_FLAGS,
UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE
| UNIT_FLAG_OOC_NOT_ATTACKABLE)) return false;
if (GetTypeId() == TYPEID_PLAYER && ToPlayer()->isGameMaster()) return false;
return !HasUnitState(UNIT_STAT_UNATTACKABLE);
}
int32 Unit::ModifyHealth(int32 dVal)
{
int32 gain = 0;
if (dVal == 0) return 0;
int32 curHealth = (int32) GetHealth();
int32 val = dVal + curHealth;
if (val <= 0)
{
SetHealth(0);
return -curHealth;
}
int32 maxHealth = (int32) GetMaxHealth();
if (val < maxHealth)
{
SetHealth(val);
gain = val - curHealth;
}
else if (curHealth != maxHealth)
{
SetHealth(maxHealth);
gain = maxHealth - curHealth;
}
return gain;
}
int32 Unit::GetHealthGain(int32 dVal)
{
int32 gain = 0;
if (dVal == 0) return 0;
int32 curHealth = (int32) GetHealth();
int32 val = dVal + curHealth;
if (val <= 0)
{
return -curHealth;
}
int32 maxHealth = (int32) GetMaxHealth();
if (val < maxHealth) gain = dVal;
else if (curHealth != maxHealth) gain = maxHealth - curHealth;
return gain;
}
int32 Unit::ModifyPower(Powers power, int32 dVal)
{
int32 gain = 0;
if (dVal == 0) return 0;
int32 curPower = (int32) GetPower(power);
int32 val = dVal + curPower;
if (val <= 0)
{
SetPower(power, 0);
return -curPower;
}
int32 maxPower = (int32) GetMaxPower(power);
if (val < maxPower)
{
SetPower(power, val);
gain = val - curPower;
}
else if (curPower != maxPower)
{
SetPower(power, maxPower);
gain = maxPower - curPower;
}
return gain;
}
// returns negative amount on power reduction
int32 Unit::ModifyPowerPct(Powers power, float pct, bool apply)
{
float amount = (float) GetMaxPower(power);
ApplyPercentModFloatVar(amount, pct, apply);
return ModifyPower(power, (int32) amount - (int32) GetMaxPower(power));
}
bool Unit::isAlwaysVisibleFor(WorldObject const* seer) const
{
if (WorldObject::isAlwaysVisibleFor(seer)) return true;
// Always seen by owner
if (uint64 guid = GetCharmerOrOwnerGUID()) if (seer->GetGUID() == guid) return true;
return false;
}
bool Unit::isAlwaysDetectableFor(WorldObject const* seer) const
{
if (WorldObject::isAlwaysDetectableFor(seer)) return true;
if (HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, seer->GetGUID())) return true;
return false;
}
void Unit::SetVisible(bool x)
{
if (!x) m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM,
SEC_GAMEMASTER);
else m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_PLAYER);
UpdateObjectVisibility();
}
void Unit::UpdateSpeed(UnitMoveType mtype, bool forced)
{
int32 main_speed_mod = 0;
float stack_bonus = 1.0f;
float non_stack_bonus = 1.0f;
switch (mtype)
{
// Only apply debuffs
case MOVE_FLIGHT_BACK:
case MOVE_RUN_BACK:
case MOVE_SWIM_BACK:
break;
case MOVE_WALK:
return;
case MOVE_RUN:
{
if (IsMounted()) // Use on mount auras
{
main_speed_mod = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED);
stack_bonus = GetTotalAuraMultiplier(
SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS);
non_stack_bonus = (100.0f
+ GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_MOUNTED_SPEED_NOT_STACK))
/ 100.0f;
}
else
{
main_speed_mod = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_INCREASE_SPEED);
stack_bonus = GetTotalAuraMultiplier(
SPELL_AURA_MOD_SPEED_ALWAYS);
non_stack_bonus = (100.0f
+ GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_SPEED_NOT_STACK)) / 100.0f;
}
break;
}
case MOVE_SWIM:
{
main_speed_mod = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_INCREASE_SWIM_SPEED);
break;
}
case MOVE_FLIGHT:
{
if (GetTypeId() == TYPEID_UNIT && IsControlledByPlayer()) // not sure if good for pet
{
main_speed_mod = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_INCREASE_VEHICLE_FLIGHT_SPEED);
stack_bonus = GetTotalAuraMultiplier(
SPELL_AURA_MOD_VEHICLE_SPEED_ALWAYS);
// for some spells this mod is applied on vehicle owner
int32 owner_speed_mod = 0;
if (Unit * owner = GetCharmer()) owner_speed_mod =
owner->GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_INCREASE_VEHICLE_FLIGHT_SPEED);
main_speed_mod = std::max(main_speed_mod, owner_speed_mod);
}
else if (IsMounted())
{
main_speed_mod = GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED);
stack_bonus = GetTotalAuraMultiplier(
SPELL_AURA_MOD_MOUNTED_FLIGHT_SPEED_ALWAYS);
}
else
// Use not mount (shapeshift for example) auras (should stack)
main_speed_mod = GetTotalAuraModifier(
SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED)
+ GetTotalAuraModifier(
SPELL_AURA_MOD_INCREASE_VEHICLE_FLIGHT_SPEED);
non_stack_bonus = (100.0f
+ GetMaxPositiveAuraModifier(
SPELL_AURA_MOD_FLIGHT_SPEED_NOT_STACK)) / 100.0f;
// Update speed for vehicle if available
if (GetTypeId() == TYPEID_PLAYER && GetVehicle()) GetVehicleBase()->UpdateSpeed(
MOVE_FLIGHT, true);
break;
}
default:
sLog->outError("Unit::UpdateSpeed: Unsupported move type (%d)",
mtype);
return;
}
float bonus = non_stack_bonus > stack_bonus ? non_stack_bonus : stack_bonus;
// now we ready for speed calculation
float speed =
main_speed_mod ? bonus * (100.0f + main_speed_mod) / 100.0f : bonus;
switch (mtype)
{
case MOVE_RUN:
case MOVE_SWIM:
case MOVE_FLIGHT:
{
// Set creature speed rate from CreatureInfo
if (GetTypeId() == TYPEID_UNIT) speed *=
this->ToCreature()->GetCreatureInfo()->speed_walk;
// Normalize speed by 191 aura SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED if need
// TODO: possible affect only on MOVE_RUN
if (int32 normalization = GetMaxPositiveAuraModifier(SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED))
{
// Use speed from aura
float max_speed = normalization
/ (IsControlledByPlayer() ?
playerBaseMoveSpeed [mtype] :
baseMoveSpeed [mtype]);
if (speed > max_speed) speed = max_speed;
}
break;
}
default:
break;
}
// for creature case, we check explicit if mob searched for assistance
if (GetTypeId() == TYPEID_UNIT)
{
if (this->ToCreature()->HasSearchedAssistance()) speed *= 0.66f; // best guessed value, so this will be 33% reduction. Based off initial speed, mob can then "run", "walk fast" or "walk".
}
// Apply strongest slow aura mod to speed
int32 slow = GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED);
if (slow)
{
speed *= (100.0f + slow) / 100.0f;
if (float minSpeedMod = (float)GetMaxPositiveAuraModifier(SPELL_AURA_MOD_MINIMUM_SPEED))
{
float min_speed = minSpeedMod / 100.0f;
if (speed < min_speed) speed = min_speed;
}
}
SetSpeed(mtype, speed, forced);
}
float Unit::GetSpeed(UnitMoveType mtype) const
{
return m_speed_rate [mtype]
* (IsControlledByPlayer() ?
playerBaseMoveSpeed [mtype] : baseMoveSpeed [mtype]);
}
void Unit::SetSpeed(UnitMoveType mtype, float rate, bool forced)
{
if (rate < 0) rate = 0.0f;
// Update speed only on change
if (m_speed_rate [mtype] == rate) return;
m_speed_rate [mtype] = rate;
propagateSpeedChange();
WorldPacket data;
if (!forced)
{
switch (mtype)
{
case MOVE_WALK:
data.Initialize(MSG_MOVE_SET_WALK_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_RUN:
data.Initialize(MSG_MOVE_SET_RUN_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_RUN_BACK:
data.Initialize(MSG_MOVE_SET_RUN_BACK_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_SWIM:
data.Initialize(MSG_MOVE_SET_SWIM_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_SWIM_BACK:
data.Initialize(MSG_MOVE_SET_SWIM_BACK_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_TURN_RATE:
data.Initialize(MSG_MOVE_SET_TURN_RATE,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_FLIGHT:
data.Initialize(MSG_MOVE_SET_FLIGHT_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_FLIGHT_BACK:
data.Initialize(MSG_MOVE_SET_FLIGHT_BACK_SPEED,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
case MOVE_PITCH_RATE:
data.Initialize(MSG_MOVE_SET_PITCH_RATE,
8 + 4 + 2 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
break;
default:
sLog->outError(
"Unit::SetSpeed: Unsupported move type (%d), data not sent to client.",
mtype);
return;
}
data.append(GetPackGUID());
data << uint32(0); // movement flags
data << uint16(0); // unk flags
data << uint32(getMSTime());
data << float(GetPositionX());
data << float(GetPositionY());
data << float(GetPositionZ());
data << float(GetOrientation());
data << uint32(0); // fall time
data << float(GetSpeed(mtype));
SendMessageToSet(&data, true);
}
else
{
if (GetTypeId() == TYPEID_PLAYER)
{
// register forced speed changes for WorldSession::HandleForceSpeedChangeAck
// and do it only for real sent packets and use run for run/mounted as client expected
++this->ToPlayer()->m_forced_speed_changes [mtype];
if (!isInCombat()) if (Pet* pet = this->ToPlayer()->GetPet()) pet->SetSpeed(
mtype, m_speed_rate [mtype], forced);
}
switch (mtype)
{
case MOVE_WALK:
data.Initialize(SMSG_FORCE_WALK_SPEED_CHANGE, 16);
break;
case MOVE_RUN:
data.Initialize(SMSG_FORCE_RUN_SPEED_CHANGE, 17);
break;
case MOVE_RUN_BACK:
data.Initialize(SMSG_FORCE_RUN_BACK_SPEED_CHANGE, 16);
break;
case MOVE_SWIM:
data.Initialize(SMSG_FORCE_SWIM_SPEED_CHANGE, 16);
break;
case MOVE_SWIM_BACK:
data.Initialize(SMSG_FORCE_SWIM_BACK_SPEED_CHANGE, 16);
break;
case MOVE_TURN_RATE:
data.Initialize(SMSG_FORCE_TURN_RATE_CHANGE, 16);
break;
case MOVE_FLIGHT:
data.Initialize(SMSG_FORCE_FLIGHT_SPEED_CHANGE, 16);
break;
case MOVE_FLIGHT_BACK:
data.Initialize(SMSG_FORCE_FLIGHT_BACK_SPEED_CHANGE, 16);
break;
case MOVE_PITCH_RATE:
data.Initialize(SMSG_FORCE_PITCH_RATE_CHANGE, 16);
break;
default:
sLog->outError(
"Unit::SetSpeed: Unsupported move type (%d), data not sent to client.",
mtype);
return;
}
data.append(GetPackGUID());
data << (uint32) 0; // moveEvent, NUM_PMOVE_EVTS = 0x39
if (mtype == MOVE_RUN) data << uint8(0); // new 2.1.0
data << float(GetSpeed(mtype));
SendMessageToSet(&data, true);
}
}
void Unit::SetHover(bool on)
{
if (on) CastSpell(this, 11010, true);
else RemoveAurasDueToSpell(11010);
}
void Unit::setDeathState(DeathState s)
{
// death state needs to be updated before RemoveAllAurasOnDeath() calls HandleChannelDeathItem(..) so that
// it can be used to check creation of death items (such as soul shards).
DeathState oldDeathState = m_deathState;
m_deathState = s;
if (s != ALIVE && s != JUST_ALIVED)
{
CombatStop();
DeleteThreatList();
getHostileRefManager().deleteReferences();
ClearComboPointHolders(); // any combo points pointed to unit lost at it death
if (IsNonMeleeSpellCasted(false)) InterruptNonMeleeSpells(false);
UnsummonAllTotems();
RemoveAllControlled();
RemoveAllAurasOnDeath();
ExitVehicle();
}
if (s == JUST_DIED)
{
ModifyAuraState(AURA_STATE_HEALTHLESS_20_PERCENT, false);
ModifyAuraState(AURA_STATE_HEALTHLESS_35_PERCENT, false);
// remove aurastates allowing special moves
ClearAllReactives();
ClearDiminishings();
GetMotionMaster()->Clear(false);
GetMotionMaster()->MoveIdle();
if (m_vehicleKit) m_vehicleKit->Die();
SendMonsterStop(true);
//without this when removing IncreaseMaxHealth aura player may stuck with 1 hp
//do not why since in IncreaseMaxHealth currenthealth is checked
SetHealth(0);
SetPower(getPowerType(), 0);
}
else if (s == JUST_ALIVED) RemoveFlag(UNIT_FIELD_FLAGS,
UNIT_FLAG_SKINNABLE); // clear skinnable for creature and player (at battleground)
if (oldDeathState != ALIVE && s == ALIVE)
{
// Reset display id on resurection - needed by corpse explosion to cleanup after display change
// TODO: fix this
if (!HasAuraType(SPELL_AURA_TRANSFORM)) SetDisplayId(
GetNativeDisplayId());
}
}
/*########################################
######## ########
######## AGGRO SYSTEM ########
######## ########
########################################*/
bool Unit::CanHaveThreatList() const
{
// only creatures can have threat list
if (GetTypeId() != TYPEID_UNIT) return false;
// only alive units can have threat list
if (!isAlive() || isDying()) return false;
// totems can not have threat list
if (this->ToCreature()->isTotem()) return false;
// vehicles can not have threat list
//if (this->ToCreature()->IsVehicle())
// return false;
// summons can not have a threat list, unless they are controlled by a creature
if (HasUnitTypeMask(UNIT_MASK_MINION))
{
assert(dynamic_cast <Minion*>(const_cast <Unit*>(this)));
if (IS_PLAYER_GUID(((Minion*)this)->GetOwnerGUID())) return false;
}
if (HasUnitTypeMask(UNIT_MASK_GUARDIAN | UNIT_MASK_CONTROLABLE_GUARDIAN))
{
assert(dynamic_cast <Guardian*>(const_cast <Unit*>(this)));
if (IS_PLAYER_GUID(((Guardian*)this)->GetOwnerGUID())) return false;
}
if (this->ToCreature()->isPet())
{
assert(dynamic_cast <Pet*>(const_cast <Unit*>(this)));
if (IS_PLAYER_GUID(((Pet*)this)->GetOwnerGUID())) return false;
}
return true;
}
//======================================================================
float Unit::ApplyTotalThreatModifier(float fThreat, SpellSchoolMask schoolMask)
{
if (!HasAuraType(SPELL_AURA_MOD_THREAT) || fThreat < 0) return fThreat;
SpellSchools school = GetFirstSchoolInMask(schoolMask);
return fThreat * m_threatModifier [school];
}
//======================================================================
void Unit::AddThreat(Unit* pVictim, float fThreat, SpellSchoolMask schoolMask,
SpellEntry const *threatSpell)
{
// Only mobs can manage threat lists
if (CanHaveThreatList()) m_ThreatManager.addThreat(pVictim, fThreat,
schoolMask, threatSpell);
}
//======================================================================
void Unit::DeleteThreatList()
{
if (CanHaveThreatList() && !m_ThreatManager.isThreatListEmpty()) SendClearThreatListOpcode();
m_ThreatManager.clearReferences();
}
//======================================================================
void Unit::TauntApply(Unit* taunter)
{
ASSERT(GetTypeId() == TYPEID_UNIT);
if (!taunter
|| (taunter->GetTypeId() == TYPEID_PLAYER
&& taunter->ToPlayer()->isGameMaster())) return;
if (!CanHaveThreatList()) return;
if (this->ToCreature()->HasReactState(REACT_PASSIVE)) return;
Unit *target = getVictim();
if (target && target == taunter) return;
SetInFront(taunter);
if (this->ToCreature()->IsAIEnabled) this->ToCreature()->AI()->AttackStart(
taunter);
//m_ThreatManager.tauntApply(taunter);
}
//======================================================================
void Unit::TauntFadeOut(Unit *taunter)
{
ASSERT(GetTypeId() == TYPEID_UNIT);
if (!taunter
|| (taunter->GetTypeId() == TYPEID_PLAYER
&& taunter->ToPlayer()->isGameMaster())) return;
if (!CanHaveThreatList()) return;
if (this->ToCreature()->HasReactState(REACT_PASSIVE)) return;
Unit *target = getVictim();
if (!target || target != taunter) return;
if (m_ThreatManager.isThreatListEmpty())
{
if (this->ToCreature()->IsAIEnabled) this->ToCreature()->AI()->EnterEvadeMode();
return;
}
//m_ThreatManager.tauntFadeOut(taunter);
target = m_ThreatManager.getHostilTarget();
if (target && target != taunter)
{
SetInFront(target);
if (this->ToCreature()->IsAIEnabled) this->ToCreature()->AI()->AttackStart(
target);
}
}
//======================================================================
Unit* Creature::SelectVictim()
{
//function provides main threat functionality
//next-victim-selection algorithm and evade mode are called
//threat list sorting etc.
Unit* target = NULL;
// First checking if we have some taunt on us
const AuraEffectList& tauntAuras = GetAuraEffectsByType(
SPELL_AURA_MOD_TAUNT);
if (!tauntAuras.empty())
{
Unit* caster = tauntAuras.back()->GetCaster();
// The last taunt aura caster is alive an we are happy to attack him
if (caster && caster->isAlive()) return getVictim();
else if (tauntAuras.size() > 1)
{
// We do not have last taunt aura caster but we have more taunt auras,
// so find first available target
// Auras are pushed_back, last caster will be on the end
AuraEffectList::const_iterator aura = --tauntAuras.end();
do
{
--aura;
caster = (*aura)->GetCaster();
if (caster && caster->IsInMap(this) && canAttack(caster)
&& caster->isInAccessiblePlaceFor(this->ToCreature()))
{
target = caster;
break;
}
}
while (aura != tauntAuras.begin());
}
else target = getVictim();
}
if (CanHaveThreatList())
{
if (!target && !m_ThreatManager.isThreatListEmpty())
// No taunt aura or taunt aura caster is dead standard target selection
target = m_ThreatManager.getHostilTarget();
}
else if (!HasReactState(REACT_PASSIVE))
{
// We have player pet probably
target = getAttackerForHelper();
if (!target && isSummon())
{
if (Unit * owner = this->ToTempSummon()->GetOwner())
{
if (owner->isInCombat()) target = owner->getAttackerForHelper();
if (!target)
{
for (ControlList::const_iterator itr =
owner->m_Controlled.begin();
itr != owner->m_Controlled.end(); ++itr)
{
if ((*itr)->isInCombat())
{
target = (*itr)->getAttackerForHelper();
if (target) break;
}
}
}
}
}
}
else return NULL;
if (target && _IsTargetAcceptable(target))
{
SetInFront(target);
return target;
}
// last case when creature don't must go to evade mode:
// it in combat but attacker not make any damage and not enter to aggro radius to have record in threat list
// for example at owner command to pet attack some far away creature
// Note: creature not have targeted movement generator but have attacker in this case
for (AttackerSet::const_iterator itr = m_attackers.begin();
itr != m_attackers.end(); ++itr)
{
if ((*itr) && !canCreatureAttack(*itr)
&& (*itr)->GetTypeId() != TYPEID_PLAYER
&& !(*itr)->ToCreature()->HasUnitTypeMask(
UNIT_MASK_CONTROLABLE_GUARDIAN)) return NULL;
}
// TODO: a vehicle may eat some mob, so mob should not evade
if (GetVehicle()) return NULL;
// search nearby enemy before enter evade mode
if (HasReactState(REACT_AGGRESSIVE))
{
target = SelectNearestTargetInAttackDistance();
if (target && _IsTargetAcceptable(target)) return target;
}
Unit::AuraEffectList const& iAuras = GetAuraEffectsByType(
SPELL_AURA_MOD_INVISIBILITY);
if (!iAuras.empty())
{
for (Unit::AuraEffectList::const_iterator itr = iAuras.begin();
itr != iAuras.end(); ++itr)
{
if ((*itr)->GetBase()->IsPermanent())
{
AI()->EnterEvadeMode();
break;
}
}
return NULL;
}
// enter in evade mode in other case
AI()->EnterEvadeMode();
return NULL;
}
//======================================================================
//======================================================================
//======================================================================
int32 Unit::ApplyEffectModifiers(SpellEntry const* spellProto,
uint8 effect_index, int32 value) const
{
if (Player* modOwner = GetSpellModOwner())
{
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_ALL_EFFECTS, value);
switch (effect_index)
{
case 0:
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT1,
value);
break;
case 1:
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT2,
value);
break;
case 2:
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_EFFECT3,
value);
break;
}
}
return value;
}
// function uses real base points (typically value - 1)
int32 Unit::CalculateSpellDamage(Unit const* target,
SpellEntry const* spellProto, uint8 effect_index,
int32 const* basePoints) const
{
return SpellMgr::CalculateSpellEffectAmount(spellProto, effect_index, this,
basePoints, target);
}
int32 Unit::CalcSpellDuration(SpellEntry const* spellProto)
{
uint8 comboPoints = m_movedPlayer ? m_movedPlayer->GetComboPoints() : 0;
int32 minduration = GetSpellDuration(spellProto);
int32 maxduration = GetSpellMaxDuration(spellProto);
int32 duration;
if (comboPoints && minduration != -1 && minduration != maxduration) duration =
minduration + int32((maxduration - minduration) * comboPoints / 5);
else duration = minduration;
return duration;
}
int32 Unit::ModSpellDuration(SpellEntry const* spellProto, Unit const* target,
int32 duration, bool positive)
{
//don't mod permament auras duration
if (duration < 0) return duration;
//cut duration only of negative effects
if (!positive)
{
int32 mechanic = GetAllSpellMechanicMask(spellProto);
int32 durationMod;
int32 durationMod_always = 0;
int32 durationMod_not_stack = 0;
for (uint8 i = 1; i <= MECHANIC_ENRAGED; ++i)
{
if (!(mechanic & 1 << i)) continue;
// Find total mod value (negative bonus)
int32 new_durationMod_always =
target->GetTotalAuraModifierByMiscValue(
SPELL_AURA_MECHANIC_DURATION_MOD, i);
// Find max mod (negative bonus)
int32 new_durationMod_not_stack =
target->GetMaxNegativeAuraModifierByMiscValue(
SPELL_AURA_MECHANIC_DURATION_MOD_NOT_STACK, i);
// Check if mods applied before were weaker
if (new_durationMod_always < durationMod_always) durationMod_always =
new_durationMod_always;
if (new_durationMod_not_stack < durationMod_not_stack) durationMod_not_stack =
new_durationMod_not_stack;
}
// Select strongest negative mod
if (durationMod_always > durationMod_not_stack) durationMod =
durationMod_not_stack;
else durationMod = durationMod_always;
if (durationMod != 0) duration = int32(
float(duration) * float(100.0f + durationMod) / 100.0f);
// there are only negative mods currently
durationMod_always = target->GetTotalAuraModifierByMiscValue(
SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL, spellProto->Dispel);
durationMod_not_stack = target->GetMaxNegativeAuraModifierByMiscValue(
SPELL_AURA_MOD_AURA_DURATION_BY_DISPEL_NOT_STACK,
spellProto->Dispel);
durationMod = 0;
if (durationMod_always > durationMod_not_stack) durationMod +=
durationMod_not_stack;
else durationMod += durationMod_always;
if (durationMod != 0) duration = int32(
float(duration) * float(100.0f + durationMod) / 100.0f);
}
else
{
//else positive mods here, there are no currently
//when there will be, change GetTotalAuraModifierByMiscValue to GetTotalPositiveAuraModifierByMiscValue
// Mixology - duration boost
if (target->GetTypeId() == TYPEID_PLAYER)
{
if (spellProto->SpellFamilyName == SPELLFAMILY_POTION
&& (sSpellMgr->IsSpellMemberOfSpellGroup(spellProto->Id,
SPELL_GROUP_ELIXIR_BATTLE)
|| sSpellMgr->IsSpellMemberOfSpellGroup(
spellProto->Id, SPELL_GROUP_ELIXIR_GUARDIAN)))
{
if (target->HasAura(53042)
&& target->HasSpell(spellProto->EffectTriggerSpell [0])) duration *=
2;
}
}
}
// Glyphs which increase duration of selfcasted buffs
if (target == this)
{
switch (spellProto->SpellFamilyName)
{
case SPELLFAMILY_DRUID:
if (spellProto->SpellFamilyFlags [0] & 0x100)
{
// Glyph of Thorns
if (AuraEffect * aurEff = GetAuraEffect(57862, 0)) duration +=
aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
}
break;
case SPELLFAMILY_PALADIN:
if (spellProto->SpellFamilyFlags [0] & 0x00000002)
{
// Glyph of Blessing of Might
if (AuraEffect * aurEff = GetAuraEffect(57958, 0)) duration +=
aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
}
else if (spellProto->SpellFamilyFlags [0] & 0x00010000)
{
// Glyph of Blessing of Wisdom
if (AuraEffect * aurEff = GetAuraEffect(57979, 0)) duration +=
aurEff->GetAmount() * MINUTE * IN_MILLISECONDS;
}
break;
}
}
return duration > 0 ? duration : 0;
}
void Unit::ModSpellCastTime(SpellEntry const* spellProto, int32 & castTime,
Spell * spell)
{
if (!spellProto || castTime < 0) return;
//called from caster
if (Player* modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, SPELLMOD_CASTING_TIME, castTime, spell);
if (!(spellProto->Attributes & (SPELL_ATTR0_UNK4 | SPELL_ATTR0_TRADESPELL))
&& spellProto->SpellFamilyName) castTime = int32(
float(castTime) * GetFloatValue(UNIT_MOD_CAST_SPEED));
else if (spellProto->Attributes & SPELL_ATTR0_REQ_AMMO
&& !(spellProto->AttributesEx2 & SPELL_ATTR2_AUTOREPEAT_FLAG)) castTime =
int32(float(castTime) * m_modAttackSpeedPct [RANGED_ATTACK]);
else if (spellProto->SpellVisual [0] == 3881 && HasAura(67556)) // cooking with Chef Hat.
castTime = 500;
}
DiminishingLevels Unit::GetDiminishing(DiminishingGroup group)
{
for (Diminishing::iterator i = m_Diminishing.begin();
i != m_Diminishing.end(); ++i)
{
if (i->DRGroup != group) continue;
if (!i->hitCount) return DIMINISHING_LEVEL_1;
if (!i->hitTime) return DIMINISHING_LEVEL_1;
// If last spell was casted more than 15 seconds ago - reset the count.
if (i->stack == 0 && getMSTimeDiff(i->hitTime, getMSTime()) > 15000)
{
i->hitCount = DIMINISHING_LEVEL_1;
return DIMINISHING_LEVEL_1;
}
// or else increase the count.
else return DiminishingLevels(i->hitCount);
}
return DIMINISHING_LEVEL_1;
}
void Unit::IncrDiminishing(DiminishingGroup group)
{
// Checking for existing in the table
for (Diminishing::iterator i = m_Diminishing.begin();
i != m_Diminishing.end(); ++i)
{
if (i->DRGroup != group) continue;
if (int32(i->hitCount) < GetDiminishingReturnsMaxLevel(group)) i->hitCount +=
1;
return;
}
m_Diminishing.push_back(
DiminishingReturn(group, getMSTime(), DIMINISHING_LEVEL_2));
}
float Unit::ApplyDiminishingToDuration(DiminishingGroup group, int32 &duration,
Unit *caster, DiminishingLevels Level, int32 limitduration)
{
if (duration == -1 || group == DIMINISHING_NONE) return 1.0f;
// test pet/charm masters instead pets/charmeds
Unit const* targetOwner = GetCharmerOrOwner();
Unit const* casterOwner = caster->GetCharmerOrOwner();
// Duration of crowd control abilities on pvp target is limited by 10 sec. (2.2.0)
if (limitduration > 0 && duration > limitduration)
{
Unit const* target = targetOwner ? targetOwner : this;
Unit const* source = casterOwner ? casterOwner : caster;
if ((target->GetTypeId() == TYPEID_PLAYER
|| ((Creature*) target)->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_ALL_DIMINISH)
&& source->GetTypeId() == TYPEID_PLAYER) duration =
limitduration;
}
float mod = 1.0f;
if (group == DIMINISHING_TAUNT)
{
if (GetTypeId() == TYPEID_UNIT
&& (((Creature*) this)->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_TAUNT_DIMINISH))
{
DiminishingLevels diminish = Level;
switch (diminish)
{
case DIMINISHING_LEVEL_1:
break;
case DIMINISHING_LEVEL_2:
mod = 0.65f;
break;
case DIMINISHING_LEVEL_3:
mod = 0.4225f;
break;
case DIMINISHING_LEVEL_4:
mod = 0.274625f;
break;
case DIMINISHING_LEVEL_TAUNT_IMMUNE:
mod = 0.0f;
break;
default:
break;
}
}
}
// Some diminishings applies to mobs too (for example, Stun)
else if ((GetDiminishingReturnsGroupType(group) == DRTYPE_PLAYER
&& ((targetOwner ?
(targetOwner->GetTypeId() == TYPEID_PLAYER) :
(GetTypeId() == TYPEID_PLAYER))
|| (GetTypeId() == TYPEID_UNIT
&& ((Creature*) this)->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_ALL_DIMINISH)))
|| GetDiminishingReturnsGroupType(group) == DRTYPE_ALL)
{
DiminishingLevels diminish = Level;
switch (diminish)
{
case DIMINISHING_LEVEL_1:
break;
case DIMINISHING_LEVEL_2:
mod = 0.5f;
break;
case DIMINISHING_LEVEL_3:
mod = 0.25f;
break;
case DIMINISHING_LEVEL_IMMUNE:
mod = 0.0f;
break;
default:
break;
}
}
duration = int32(duration * mod);
return mod;
}
void Unit::ApplyDiminishingAura(DiminishingGroup group, bool apply)
{
// Checking for existing in the table
for (Diminishing::iterator i = m_Diminishing.begin();
i != m_Diminishing.end(); ++i)
{
if (i->DRGroup != group) continue;
if (apply) i->stack += 1;
else if (i->stack)
{
i->stack -= 1;
// Remember time after last aura from group removed
if (i->stack == 0) i->hitTime = getMSTime();
}
break;
}
}
uint32 Unit::GetSpellMaxRangeForTarget(Unit* target,
const SpellRangeEntry * rangeEntry)
{
if (!rangeEntry) return 0;
if (rangeEntry->maxRangeHostile == rangeEntry->maxRangeFriend) return uint32(
rangeEntry->maxRangeFriend);
if (IsHostileTo(target)) return uint32(rangeEntry->maxRangeHostile);
return uint32(rangeEntry->maxRangeFriend);
}
;
uint32 Unit::GetSpellMinRangeForTarget(Unit* target,
const SpellRangeEntry * rangeEntry)
{
if (!rangeEntry) return 0;
if (rangeEntry->minRangeHostile == rangeEntry->minRangeFriend) return uint32(
rangeEntry->minRangeFriend);
if (IsHostileTo(target)) return uint32(rangeEntry->minRangeHostile);
return uint32(rangeEntry->minRangeFriend);
}
;
uint32 Unit::GetSpellRadiusForTarget(Unit* target,
const SpellRadiusEntry * radiusEntry)
{
if (!radiusEntry) return 0;
if (radiusEntry->radiusHostile == radiusEntry->radiusFriend) return uint32(
radiusEntry->radiusFriend);
if (IsHostileTo(target)) return uint32(radiusEntry->radiusHostile);
return uint32(radiusEntry->radiusFriend);
}
;
Unit* Unit::GetUnit(WorldObject& object, uint64 guid)
{
return ObjectAccessor::GetUnit(object, guid);
}
Player* Unit::GetPlayer(WorldObject& object, uint64 guid)
{
return ObjectAccessor::GetPlayer(object, guid);
}
Creature* Unit::GetCreature(WorldObject& object, uint64 guid)
{
return object.GetMap()->GetCreature(guid);
}
uint32 Unit::GetCreatureType() const
{
if (GetTypeId() == TYPEID_PLAYER)
{
ShapeshiftForm form = GetShapeshiftForm();
SpellShapeshiftFormEntry const* ssEntry =
sSpellShapeshiftFormStore.LookupEntry(form);
if (ssEntry && ssEntry->creatureType > 0) return ssEntry->creatureType;
else return CREATURE_TYPE_HUMANOID;
}
else return this->ToCreature()->GetCreatureInfo()->type;
}
/*#######################################
######## ########
######## STAT SYSTEM ########
######## ########
#######################################*/
bool Unit::HandleStatModifier(UnitMods unitMod, UnitModifierType modifierType,
float amount, bool apply)
{
if (unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
{
sLog->outError(
"ERROR in HandleStatModifier(): non existed UnitMods or wrong UnitModifierType!");
return false;
}
switch (modifierType)
{
case BASE_VALUE:
case TOTAL_VALUE:
m_auraModifiersGroup [unitMod] [modifierType] +=
apply ? amount : -amount;
break;
case BASE_PCT:
case TOTAL_PCT:
m_auraModifiersGroup [unitMod] [modifierType] += (
apply ? amount : -amount) / 100.0f;
break;
default:
break;
}
if (!CanModifyStats()) return false;
switch (unitMod)
{
case UNIT_MOD_STAT_STRENGTH:
case UNIT_MOD_STAT_AGILITY:
case UNIT_MOD_STAT_STAMINA:
case UNIT_MOD_STAT_INTELLECT:
case UNIT_MOD_STAT_SPIRIT:
UpdateStats(GetStatByAuraGroup(unitMod));
break;
case UNIT_MOD_ARMOR:
UpdateArmor();
break;
case UNIT_MOD_HEALTH:
UpdateMaxHealth();
break;
case UNIT_MOD_MANA:
case UNIT_MOD_RAGE:
case UNIT_MOD_FOCUS:
case UNIT_MOD_ENERGY:
case UNIT_MOD_HAPPINESS:
case UNIT_MOD_RUNE:
case UNIT_MOD_RUNIC_POWER:
UpdateMaxPower(GetPowerTypeByAuraGroup(unitMod));
break;
case UNIT_MOD_RESISTANCE_HOLY:
case UNIT_MOD_RESISTANCE_FIRE:
case UNIT_MOD_RESISTANCE_NATURE:
case UNIT_MOD_RESISTANCE_FROST:
case UNIT_MOD_RESISTANCE_SHADOW:
case UNIT_MOD_RESISTANCE_ARCANE:
UpdateResistances(GetSpellSchoolByAuraGroup(unitMod));
break;
case UNIT_MOD_ATTACK_POWER_POS:
case UNIT_MOD_ATTACK_POWER_NEG:
UpdateAttackPowerAndDamage();
break;
case UNIT_MOD_ATTACK_POWER_RANGED_POS:
case UNIT_MOD_ATTACK_POWER_RANGED_NEG:
UpdateAttackPowerAndDamage(true);
break;
case UNIT_MOD_DAMAGE_MAINHAND:
UpdateDamagePhysical(BASE_ATTACK);
break;
case UNIT_MOD_DAMAGE_OFFHAND:
UpdateDamagePhysical(OFF_ATTACK);
break;
case UNIT_MOD_DAMAGE_RANGED:
UpdateDamagePhysical(RANGED_ATTACK);
break;
default:
break;
}
return true;
}
float Unit::GetModifierValue(UnitMods unitMod,
UnitModifierType modifierType) const
{
if (unitMod >= UNIT_MOD_END || modifierType >= MODIFIER_TYPE_END)
{
sLog->outError(
"trial to access non existed modifier value from UnitMods!");
return 0.0f;
}
if (modifierType == TOTAL_PCT
&& m_auraModifiersGroup [unitMod] [modifierType] <= 0.0f) return 0.0f;
return m_auraModifiersGroup [unitMod] [modifierType];
}
float Unit::GetTotalStatValue(Stats stat) const
{
UnitMods unitMod = UnitMods(UNIT_MOD_STAT_START + stat);
if (m_auraModifiersGroup [unitMod] [TOTAL_PCT] <= 0.0f) return 0.0f;
// value = ((base_value * base_pct) + total_value) * total_pct
float value = m_auraModifiersGroup [unitMod] [BASE_VALUE]
+ GetCreateStat(stat);
value *= m_auraModifiersGroup [unitMod] [BASE_PCT];
value += m_auraModifiersGroup [unitMod] [TOTAL_VALUE];
value *= m_auraModifiersGroup [unitMod] [TOTAL_PCT];
return value;
}
float Unit::GetTotalAuraModValue(UnitMods unitMod) const
{
if (unitMod >= UNIT_MOD_END)
{
sLog->outError(
"trial to access non existed UnitMods in GetTotalAuraModValue()!");
return 0.0f;
}
if (m_auraModifiersGroup [unitMod] [TOTAL_PCT] <= 0.0f) return 0.0f;
float value = m_auraModifiersGroup [unitMod] [BASE_VALUE];
value *= m_auraModifiersGroup [unitMod] [BASE_PCT];
value += m_auraModifiersGroup [unitMod] [TOTAL_VALUE];
value *= m_auraModifiersGroup [unitMod] [TOTAL_PCT];
return value;
}
SpellSchools Unit::GetSpellSchoolByAuraGroup(UnitMods unitMod) const
{
SpellSchools school = SPELL_SCHOOL_NORMAL;
switch (unitMod)
{
case UNIT_MOD_RESISTANCE_HOLY:
school = SPELL_SCHOOL_HOLY;
break;
case UNIT_MOD_RESISTANCE_FIRE:
school = SPELL_SCHOOL_FIRE;
break;
case UNIT_MOD_RESISTANCE_NATURE:
school = SPELL_SCHOOL_NATURE;
break;
case UNIT_MOD_RESISTANCE_FROST:
school = SPELL_SCHOOL_FROST;
break;
case UNIT_MOD_RESISTANCE_SHADOW:
school = SPELL_SCHOOL_SHADOW;
break;
case UNIT_MOD_RESISTANCE_ARCANE:
school = SPELL_SCHOOL_ARCANE;
break;
default:
break;
}
return school;
}
Stats Unit::GetStatByAuraGroup(UnitMods unitMod) const
{
Stats stat = STAT_STRENGTH;
switch (unitMod)
{
case UNIT_MOD_STAT_STRENGTH:
stat = STAT_STRENGTH;
break;
case UNIT_MOD_STAT_AGILITY:
stat = STAT_AGILITY;
break;
case UNIT_MOD_STAT_STAMINA:
stat = STAT_STAMINA;
break;
case UNIT_MOD_STAT_INTELLECT:
stat = STAT_INTELLECT;
break;
case UNIT_MOD_STAT_SPIRIT:
stat = STAT_SPIRIT;
break;
default:
break;
}
return stat;
}
Powers Unit::GetPowerTypeByAuraGroup(UnitMods unitMod) const
{
switch (unitMod)
{
case UNIT_MOD_RAGE:
return POWER_RAGE;
case UNIT_MOD_FOCUS:
return POWER_FOCUS;
case UNIT_MOD_ENERGY:
return POWER_ENERGY;
case UNIT_MOD_HAPPINESS:
return POWER_HAPPINESS;
case UNIT_MOD_RUNE:
return POWER_RUNE;
case UNIT_MOD_RUNIC_POWER:
return POWER_RUNIC_POWER;
default:
case UNIT_MOD_MANA:
return POWER_MANA;
}
}
float Unit::GetTotalAttackPowerValue(WeaponAttackType attType) const
{
if (attType == RANGED_ATTACK)
{
int32 ap = GetInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER)
+ GetInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS)
- GetInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG);
if (ap < 0) return 0.0f;
return ap
* (1.0f
+ GetFloatValue(
UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER));
}
else
{
int32 ap = GetInt32Value(UNIT_FIELD_ATTACK_POWER)
+ GetInt32Value(UNIT_FIELD_ATTACK_POWER_MOD_POS)
- GetInt32Value(UNIT_FIELD_ATTACK_POWER_MOD_NEG);
if (ap < 0) return 0.0f;
return ap * (1.0f + GetFloatValue(UNIT_FIELD_ATTACK_POWER_MULTIPLIER));
}
}
float Unit::GetWeaponDamageRange(WeaponAttackType attType,
WeaponDamageRange type) const
{
if (attType == OFF_ATTACK && !haveOffhandWeapon()) return 0.0f;
return m_weaponDamage [attType] [type];
}
void Unit::SetLevel(uint8 lvl)
{
SetUInt32Value(UNIT_FIELD_LEVEL, lvl);
// group update
if (GetTypeId() == TYPEID_PLAYER && this->ToPlayer()->GetGroup()) this->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_LEVEL);
}
void Unit::SetHealth(uint32 val)
{
if (getDeathState() == JUST_DIED) val = 0;
else if (GetTypeId() == TYPEID_PLAYER
&& (getDeathState() == DEAD || getDeathState() == DEAD_FALLING)) val =
1;
else
{
uint32 maxHealth = GetMaxHealth();
if (maxHealth < val) val = maxHealth;
}
SetUInt32Value(UNIT_FIELD_HEALTH, val);
// group update
if (GetTypeId() == TYPEID_PLAYER)
{
if (this->ToPlayer()->GetGroup()) this->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_CUR_HP);
}
else if (this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (pet->isControlled())
{
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup()) owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_CUR_HP);
}
}
}
void Unit::SetMaxHealth(uint32 val)
{
if (!val) val = 1;
uint32 health = GetHealth();
SetUInt32Value(UNIT_FIELD_MAXHEALTH, val);
// group update
if (GetTypeId() == TYPEID_PLAYER)
{
if (this->ToPlayer()->GetGroup()) this->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_MAX_HP);
}
else if (this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (pet->isControlled())
{
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup()) owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_MAX_HP);
}
}
if (val < health) SetHealth(val);
}
void Unit::SetPower(Powers power, uint32 val)
{
if (GetPower(power) == val) return;
uint32 maxPower = GetMaxPower(power);
if (maxPower < val) val = maxPower;
SetStatInt32Value(UNIT_FIELD_POWER1 + power, val);
WorldPacket data(SMSG_POWER_UPDATE);
data.append(GetPackGUID());
data << uint32(1); // count of updates. uint8 and uint32 for each
data << uint8(power);
data << uint32(val);
SendMessageToSet(&data, GetTypeId() == TYPEID_PLAYER ? true : false);
// group update
if (GetTypeId() == TYPEID_PLAYER)
{
if (this->ToPlayer()->GetGroup()) this->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_CUR_POWER);
}
else if (this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (pet->isControlled())
{
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup()) owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_CUR_POWER);
}
// Update the pet's character sheet with happiness damage bonus
if (pet->getPetType() == HUNTER_PET && power == POWER_HAPPINESS) pet->UpdateDamagePhysical(
BASE_ATTACK);
}
}
void Unit::SetMaxPower(Powers power, uint32 val)
{
uint32 cur_power = GetPower(power);
SetStatInt32Value(UNIT_FIELD_MAXPOWER1 + power, val);
// group update
if (GetTypeId() == TYPEID_PLAYER)
{
if (this->ToPlayer()->GetGroup()) this->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_MAX_POWER);
}
else if (this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (pet->isControlled())
{
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup()) owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_MAX_POWER);
}
}
if (val < cur_power) SetPower(power, val);
}
uint32 Unit::GetCreatePowers(Powers power) const
{
// POWER_FOCUS and POWER_HAPPINESS only have hunter pet
switch (power)
{
case POWER_MANA:
if (getClass() == CLASS_HUNTER || getClass() == CLASS_WARRIOR
|| getClass() == CLASS_ROGUE
|| getClass() == CLASS_DEATH_KNIGHT) return false;
else return GetCreateMana();
case POWER_RAGE:
return 1000;
case POWER_FOCUS:
if (GetTypeId() == TYPEID_PLAYER
&& (ToPlayer()->getClass() == CLASS_HUNTER)) return 100;
return (GetTypeId() == TYPEID_PLAYER
|| !((Creature const*) this)->isPet()
|| ((Pet const*) this)->getPetType() != HUNTER_PET ? 0 : 100);
case POWER_ENERGY:
return 100;
case POWER_HAPPINESS:
return (GetTypeId() == TYPEID_PLAYER
|| !((Creature const*) this)->isPet()
|| ((Pet const*) this)->getPetType() != HUNTER_PET ?
0 : 1050000);
case POWER_RUNE:
return (GetTypeId() == TYPEID_PLAYER
&& ((Player const*) this)->getClass() == CLASS_DEATH_KNIGHT ?
8 : 0);
case POWER_RUNIC_POWER:
return (GetTypeId() == TYPEID_PLAYER
&& ((Player const*) this)->getClass() == CLASS_DEATH_KNIGHT ?
1000 : 0);
case POWER_SOUL_SHARDS:
return (GetTypeId() == TYPEID_PLAYER
&& ((Player const*) this)->getClass() == CLASS_WARLOCK ?
3 : 0);
case POWER_ECLIPSE:
return (GetTypeId() == TYPEID_PLAYER
&& ((Player const*) this)->getClass() == CLASS_DRUID ?
100 : 0);
case POWER_HOLY_POWER:
return (GetTypeId() == TYPEID_PLAYER
&& ((Player const*) this)->getClass() == CLASS_PALADIN ?
3 : 0);
case POWER_HEALTH:
return 0;
default:
break;
}
return 0;
}
void Unit::AddToWorld()
{
if (!IsInWorld())
{
WorldObject::AddToWorld();
}
}
void Unit::RemoveFromWorld()
{
// cleanup
ASSERT(GetGUID());
if (IsInWorld())
{
m_duringRemoveFromWorld = true;
if (IsVehicle()) GetVehicleKit()->Uninstall();
RemoveCharmAuras();
RemoveBindSightAuras();
RemoveNotOwnSingleTargetAuras();
RemoveAllGameObjects();
RemoveAllDynObjects();
ExitVehicle();
UnsummonAllTotems();
RemoveAllControlled();
RemoveAreaAurasDueToLeaveWorld();
if (GetCharmerGUID())
{
sLog->outCrash("Unit %u has charmer guid when removed from world",
GetEntry());
ASSERT(false);
}
if (Unit *owner = GetOwner())
{
if (owner->m_Controlled.find(this) != owner->m_Controlled.end())
{
sLog->outCrash(
"Unit %u is in controlled list of %u when removed from world",
GetEntry(), owner->GetEntry());
ASSERT(false);
}
}
WorldObject::RemoveFromWorld();
m_duringRemoveFromWorld = false;
}
}
void Unit::CleanupsBeforeDelete(bool finalCleanup)
{
// This needs to be before RemoveFromWorld to make GetCaster() return a valid pointer on aura removal
InterruptNonMeleeSpells(true);
if (IsInWorld()) RemoveFromWorld();
ASSERT(GetGUID());
//A unit may be in removelist and not in world, but it is still in grid
//and may have some references during delete
RemoveAllAuras();
RemoveAllGameObjects();
if (finalCleanup) m_cleanupDone = true;
m_Events.KillAllEvents(false); // non-delatable (currently casted spells) will not deleted now but it will deleted at call in Map::RemoveAllObjectsInRemoveList
CombatStop();
ClearComboPointHolders();
DeleteThreatList();
getHostileRefManager().setOnlineOfflineState(false);
GetMotionMaster()->Clear(false); // remove different non-standard movement generators.
if (Creature* thisCreature = ToCreature()) if (GetTransport()) GetTransport()->RemovePassenger(
thisCreature);
}
void Unit::UpdateCharmAI()
{
if (GetTypeId() == TYPEID_PLAYER) return;
if (i_disabledAI) // disabled AI must be primary AI
{
if (!isCharmed())
{
delete i_AI;
i_AI = i_disabledAI;
i_disabledAI = NULL;
}
}
else
{
if (isCharmed())
{
i_disabledAI = i_AI;
if (isPossessed() || IsVehicle()) i_AI = new PossessedAI(
this->ToCreature());
else i_AI = new PetAI(this->ToCreature());
}
}
}
CharmInfo* Unit::InitCharmInfo()
{
if (!m_charmInfo) m_charmInfo = new CharmInfo(this);
return m_charmInfo;
}
void Unit::DeleteCharmInfo()
{
if (!m_charmInfo) return;
m_charmInfo->RestoreState();
delete m_charmInfo;
m_charmInfo = NULL;
}
CharmInfo::CharmInfo(Unit* unit) :
m_unit(unit), m_CommandState(COMMAND_FOLLOW), m_petnumber(0), m_barInit(
false), m_isCommandAttack(false), m_isAtStay(false), m_isFollowing(
false), m_isReturning(false)
{
for (uint8 i = 0; i < MAX_SPELL_CHARM; ++i)
m_charmspells [i].SetActionAndType(0, ACT_DISABLED);
if (m_unit->GetTypeId() == TYPEID_UNIT)
{
m_oldReactState = m_unit->ToCreature()->GetReactState();
m_unit->ToCreature()->SetReactState(REACT_PASSIVE);
}
}
CharmInfo::~CharmInfo()
{
}
void CharmInfo::RestoreState()
{
if (m_unit->GetTypeId() == TYPEID_UNIT) if (Creature *pCreature = m_unit->ToCreature()) pCreature->SetReactState(
m_oldReactState);
}
void CharmInfo::InitPetActionBar()
{
// the first 3 SpellOrActions are attack, follow and stay
for (uint32 i = 0;
i < ACTION_BAR_INDEX_PET_SPELL_START - ACTION_BAR_INDEX_START; ++i)
SetActionBar(ACTION_BAR_INDEX_START + i, COMMAND_ATTACK - i,
ACT_COMMAND);
// middle 4 SpellOrActions are spells/special attacks/abilities
for (uint32 i = 0;
i
< ACTION_BAR_INDEX_PET_SPELL_END
- ACTION_BAR_INDEX_PET_SPELL_START; ++i)
SetActionBar(ACTION_BAR_INDEX_PET_SPELL_START + i, 0, ACT_PASSIVE);
// last 3 SpellOrActions are reactions
for (uint32 i = 0;
i < ACTION_BAR_INDEX_END - ACTION_BAR_INDEX_PET_SPELL_END; ++i)
SetActionBar(ACTION_BAR_INDEX_PET_SPELL_END + i, COMMAND_ATTACK - i,
ACT_REACTION);
}
void CharmInfo::InitEmptyActionBar(bool withAttack)
{
if (withAttack) SetActionBar(ACTION_BAR_INDEX_START, COMMAND_ATTACK,
ACT_COMMAND);
else SetActionBar(ACTION_BAR_INDEX_START, 0, ACT_PASSIVE);
for (uint32 x = ACTION_BAR_INDEX_START + 1; x < ACTION_BAR_INDEX_END; ++x)
SetActionBar(x, 0, ACT_PASSIVE);
}
void CharmInfo::InitPossessCreateSpells()
{
InitEmptyActionBar();
if (m_unit->GetTypeId() == TYPEID_UNIT)
{
for (uint32 i = 0; i < CREATURE_MAX_SPELLS; ++i)
{
uint32 spellId = m_unit->ToCreature()->m_spells [i];
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (spellInfo
&& spellInfo->Attributes & SPELL_ATTR0_CASTABLE_WHILE_DEAD) spellId =
0;
if (IsPassiveSpell(spellId)) m_unit->CastSpell(m_unit, spellId,
true);
else AddSpellToActionBar(m_unit->ToCreature()->m_spells [i],
ACT_PASSIVE);
}
}
}
void CharmInfo::InitCharmCreateSpells()
{
if (m_unit->GetTypeId() == TYPEID_PLAYER) //charmed players don't have spells
{
InitEmptyActionBar();
return;
}
InitPetActionBar();
for (uint32 x = 0; x < MAX_SPELL_CHARM; ++x)
{
uint32 spellId = m_unit->ToCreature()->m_spells [x];
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (spellInfo
&& spellInfo->Attributes & SPELL_ATTR0_CASTABLE_WHILE_DEAD) spellId =
0;
if (!spellId)
{
m_charmspells [x].SetActionAndType(spellId, ACT_DISABLED);
continue;
}
if (IsPassiveSpell(spellId))
{
m_unit->CastSpell(m_unit, spellId, true);
m_charmspells [x].SetActionAndType(spellId, ACT_PASSIVE);
}
else
{
m_charmspells [x].SetActionAndType(spellId, ACT_DISABLED);
ActiveStates newstate = ACT_PASSIVE;
if (spellInfo)
{
if (!IsAutocastableSpell(spellId)) newstate = ACT_PASSIVE;
else
{
bool autocast = false;
for (uint32 i = 0; i < MAX_SPELL_EFFECTS && !autocast; ++i)
if (SpellTargetType [spellInfo->EffectImplicitTargetA [i]]
== TARGET_TYPE_UNIT_TARGET) autocast = true;
if (autocast)
{
newstate = ACT_ENABLED;
ToggleCreatureAutocast(spellId, true);
}
else newstate = ACT_DISABLED;
}
}
AddSpellToActionBar(spellId, newstate);
}
}
}
bool CharmInfo::AddSpellToActionBar(uint32 spell_id, ActiveStates newstate)
{
uint32 first_id = sSpellMgr->GetFirstSpellInChain(spell_id);
// new spell rank can be already listed
for (uint8 i = 0; i < MAX_UNIT_ACTION_BAR_INDEX; ++i)
{
if (uint32 action = PetActionBar[i].GetAction())
{
if (PetActionBar [i].IsActionBarForSpell()
&& sSpellMgr->GetFirstSpellInChain(action) == first_id)
{
PetActionBar [i].SetAction(spell_id);
return true;
}
}
}
// or use empty slot in other case
for (uint8 i = 0; i < MAX_UNIT_ACTION_BAR_INDEX; ++i)
{
if (!PetActionBar [i].GetAction()
&& PetActionBar [i].IsActionBarForSpell())
{
SetActionBar(
i,
spell_id,
newstate == ACT_DECIDE ?
IsAutocastableSpell(spell_id) ?
ACT_DISABLED : ACT_PASSIVE
: newstate);
return true;
}
}
return false;
}
bool CharmInfo::RemoveSpellFromActionBar(uint32 spell_id)
{
uint32 first_id = sSpellMgr->GetFirstSpellInChain(spell_id);
for (uint8 i = 0; i < MAX_UNIT_ACTION_BAR_INDEX; ++i)
{
if (uint32 action = PetActionBar[i].GetAction())
{
if (PetActionBar [i].IsActionBarForSpell()
&& sSpellMgr->GetFirstSpellInChain(action) == first_id)
{
SetActionBar(i, 0, ACT_PASSIVE);
return true;
}
}
}
return false;
}
void CharmInfo::ToggleCreatureAutocast(uint32 spellid, bool apply)
{
if (IsPassiveSpell(spellid)) return;
for (uint32 x = 0; x < MAX_SPELL_CHARM; ++x)
if (spellid == m_charmspells [x].GetAction()) m_charmspells [x].SetType(
apply ? ACT_ENABLED : ACT_DISABLED);
}
void CharmInfo::SetPetNumber(uint32 petnumber, bool statwindow)
{
m_petnumber = petnumber;
if (statwindow) m_unit->SetUInt32Value(UNIT_FIELD_PETNUMBER, m_petnumber);
else m_unit->SetUInt32Value(UNIT_FIELD_PETNUMBER, 0);
}
void CharmInfo::LoadPetActionBar(const std::string& data)
{
InitPetActionBar();
Tokens tokens(data, ' ');
if (tokens.size() != (ACTION_BAR_INDEX_END - ACTION_BAR_INDEX_START) * 2) return; // non critical, will reset to default
uint8 index;
Tokens::iterator iter;
for (iter = tokens.begin(), index = ACTION_BAR_INDEX_START;
index < ACTION_BAR_INDEX_END; ++iter, ++index)
{
// use unsigned cast to avoid sign negative format use at long-> ActiveStates (int) conversion
ActiveStates type = ActiveStates(atol(*iter));
++iter;
uint32 action = uint32(atol(*iter));
PetActionBar [index].SetActionAndType(action, type);
// check correctness
if (PetActionBar [index].IsActionBarForSpell())
{
if (!sSpellStore.LookupEntry(PetActionBar [index].GetAction())) SetActionBar(
index, 0, ACT_PASSIVE);
else if (!IsAutocastableSpell(PetActionBar [index].GetAction())) SetActionBar(
index, PetActionBar [index].GetAction(), ACT_PASSIVE);
}
}
}
void CharmInfo::BuildActionBar(WorldPacket* data)
{
for (uint32 i = 0; i < MAX_UNIT_ACTION_BAR_INDEX; ++i)
*data << uint32(PetActionBar [i].packedData);
}
void CharmInfo::SetSpellAutocast(uint32 spell_id, bool state)
{
for (uint8 i = 0; i < MAX_UNIT_ACTION_BAR_INDEX; ++i)
{
if (spell_id == PetActionBar [i].GetAction()
&& PetActionBar [i].IsActionBarForSpell())
{
PetActionBar [i].SetType(state ? ACT_ENABLED : ACT_DISABLED);
break;
}
}
}
bool Unit::isFrozen() const
{
return HasAuraState(AURA_STATE_FROZEN);
}
struct ProcTriggeredData
{
ProcTriggeredData(Aura* _aura) :
aura(_aura)
{
effMask = 0;
spellProcEvent = NULL;
}
SpellProcEventEntry const *spellProcEvent;
Aura * aura;
uint32 effMask;
};
typedef std::list <ProcTriggeredData> ProcTriggeredList;
// List of auras that CAN be trigger but may not exist in spell_proc_event
// in most case need for drop charges
// in some types of aura need do additional check
// for example SPELL_AURA_MECHANIC_IMMUNITY - need check for mechanic
bool InitTriggerAuraData()
{
for (uint16 i = 0; i < TOTAL_AURAS; ++i)
{
isTriggerAura [i] = false;
isNonTriggerAura [i] = false;
isAlwaysTriggeredAura [i] = false;
}
isTriggerAura [SPELL_AURA_DUMMY] = true;
isTriggerAura [SPELL_AURA_MOD_CONFUSE] = true;
isTriggerAura [SPELL_AURA_MOD_THREAT] = true;
isTriggerAura [SPELL_AURA_MOD_STUN] = true; // Aura not have charges but need remove him on trigger
isTriggerAura [SPELL_AURA_MOD_DAMAGE_DONE] = true;
isTriggerAura [SPELL_AURA_MOD_DAMAGE_TAKEN] = true;
isTriggerAura [SPELL_AURA_MOD_RESISTANCE] = true;
isTriggerAura [SPELL_AURA_MOD_STEALTH] = true;
isTriggerAura [SPELL_AURA_MOD_FEAR] = true; // Aura not have charges but need remove him on trigger
isTriggerAura [SPELL_AURA_MOD_ROOT] = true;
isTriggerAura [SPELL_AURA_TRANSFORM] = true;
isTriggerAura [SPELL_AURA_REFLECT_SPELLS] = true;
isTriggerAura [SPELL_AURA_DAMAGE_IMMUNITY] = true;
isTriggerAura [SPELL_AURA_PROC_TRIGGER_SPELL] = true;
isTriggerAura [SPELL_AURA_PROC_TRIGGER_DAMAGE] = true;
isTriggerAura [SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK] = true;
isTriggerAura [SPELL_AURA_SCHOOL_ABSORB] = true; // Savage Defense untested
isTriggerAura [SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT] = true;
isTriggerAura [SPELL_AURA_MOD_POWER_COST_SCHOOL] = true;
isTriggerAura [SPELL_AURA_REFLECT_SPELLS_SCHOOL] = true;
isTriggerAura [SPELL_AURA_MECHANIC_IMMUNITY] = true;
isTriggerAura [SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN] = true;
isTriggerAura [SPELL_AURA_SPELL_MAGNET] = true;
isTriggerAura [SPELL_AURA_MOD_ATTACK_POWER] = true;
isTriggerAura [SPELL_AURA_ADD_CASTER_HIT_TRIGGER] = true;
isTriggerAura [SPELL_AURA_OVERRIDE_CLASS_SCRIPTS] = true;
isTriggerAura [SPELL_AURA_MOD_MECHANIC_RESISTANCE] = true;
isTriggerAura [SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS] = true;
isTriggerAura [SPELL_AURA_MOD_MELEE_HASTE] = true;
isTriggerAura [SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE] = true;
isTriggerAura [SPELL_AURA_RAID_PROC_FROM_CHARGE] = true;
isTriggerAura [SPELL_AURA_RAID_PROC_FROM_CHARGE_WITH_VALUE] = true;
isTriggerAura [SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE] = true;
isTriggerAura [SPELL_AURA_MOD_DAMAGE_FROM_CASTER] = true;
isTriggerAura [SPELL_AURA_MOD_SPELL_CRIT_CHANCE] = true;
isTriggerAura [SPELL_AURA_ABILITY_IGNORE_AURASTATE] = true;
isNonTriggerAura [SPELL_AURA_MOD_POWER_REGEN] = true;
isNonTriggerAura [SPELL_AURA_REDUCE_PUSHBACK] = true;
isAlwaysTriggeredAura [SPELL_AURA_OVERRIDE_CLASS_SCRIPTS] = true;
isAlwaysTriggeredAura [SPELL_AURA_MOD_FEAR] = true;
isAlwaysTriggeredAura [SPELL_AURA_MOD_ROOT] = true;
isAlwaysTriggeredAura [SPELL_AURA_MOD_STUN] = true;
isAlwaysTriggeredAura [SPELL_AURA_TRANSFORM] = true;
isAlwaysTriggeredAura [SPELL_AURA_SPELL_MAGNET] = true;
isAlwaysTriggeredAura [SPELL_AURA_SCHOOL_ABSORB] = true;
isAlwaysTriggeredAura [SPELL_AURA_MOD_STEALTH] = true;
return true;
}
uint32 createProcExtendMask(SpellNonMeleeDamage *damageInfo,
SpellMissInfo missCondition)
{
uint32 procEx = PROC_EX_NONE;
// Check victim state
if (missCondition != SPELL_MISS_NONE) switch (missCondition)
{
case SPELL_MISS_MISS:
procEx |= PROC_EX_MISS;
break;
case SPELL_MISS_RESIST:
procEx |= PROC_EX_RESIST;
break;
case SPELL_MISS_DODGE:
procEx |= PROC_EX_DODGE;
break;
case SPELL_MISS_PARRY:
procEx |= PROC_EX_PARRY;
break;
case SPELL_MISS_BLOCK:
procEx |= PROC_EX_BLOCK;
break;
case SPELL_MISS_EVADE:
procEx |= PROC_EX_EVADE;
break;
case SPELL_MISS_IMMUNE:
procEx |= PROC_EX_IMMUNE;
break;
case SPELL_MISS_IMMUNE2:
procEx |= PROC_EX_IMMUNE;
break;
case SPELL_MISS_DEFLECT:
procEx |= PROC_EX_DEFLECT;
break;
case SPELL_MISS_ABSORB:
procEx |= PROC_EX_ABSORB;
break;
case SPELL_MISS_REFLECT:
procEx |= PROC_EX_REFLECT;
break;
default:
break;
}
else
{
// On block
if (damageInfo->blocked) procEx |= PROC_EX_BLOCK;
// On absorb
if (damageInfo->absorb) procEx |= PROC_EX_ABSORB;
// On crit
if (damageInfo->HitInfo & SPELL_HIT_TYPE_CRIT) procEx |=
PROC_EX_CRITICAL_HIT;
else procEx |= PROC_EX_NORMAL_HIT;
}
return procEx;
}
void Unit::ProcDamageAndSpellFor(bool isVictim, Unit * pTarget, uint32 procFlag,
uint32 procExtra, WeaponAttackType attType,
SpellEntry const * procSpell, uint32 damage,
SpellEntry const * procAura)
{
// Player is loading now - do not allow passive spell casts to proc
if (GetTypeId() == TYPEID_PLAYER
&& this->ToPlayer()->GetSession()->PlayerLoading()) return;
// For melee/ranged based attack need update skills and set some Aura states if victim present
if (procFlag & MELEE_BASED_TRIGGER_MASK && pTarget)
{
// Update skills here for players
if (GetTypeId() == TYPEID_PLAYER)
{
// On melee based hit/miss/resist need update skill (for victim and attacker)
if (procExtra
& (PROC_EX_NORMAL_HIT | PROC_EX_MISS | PROC_EX_RESIST))
{
if (pTarget->GetTypeId() != TYPEID_PLAYER
&& pTarget->GetCreatureType() != CREATURE_TYPE_CRITTER) this->ToPlayer()->UpdateCombatSkills(
pTarget, attType, isVictim);
}
// Update defence if player is victim and parry/dodge/block
else if (isVictim
&& procExtra
& (PROC_EX_DODGE | PROC_EX_PARRY | PROC_EX_BLOCK)) this->ToPlayer()->UpdateCombatSkills(
pTarget, attType, true);
}
// If exist crit/parry/dodge/block need update aura state (for victim and attacker)
if (procExtra
& (PROC_EX_CRITICAL_HIT | PROC_EX_PARRY | PROC_EX_DODGE
| PROC_EX_BLOCK))
{
// for victim
if (isVictim)
{
// if victim and dodge attack
if (procExtra & PROC_EX_DODGE)
{
//Update AURA_STATE on dodge
if (getClass() != CLASS_ROGUE) // skip Rogue Riposte
{
ModifyAuraState(AURA_STATE_DEFENSE, true);
StartReactiveTimer(REACTIVE_DEFENSE);
}
}
// if victim and parry attack
if (procExtra & PROC_EX_PARRY)
{
// For Hunters only Counterattack (skip Mongoose bite)
if (getClass() == CLASS_HUNTER)
{
ModifyAuraState(AURA_STATE_HUNTER_PARRY, true);
StartReactiveTimer(REACTIVE_HUNTER_PARRY);
}
else
{
ModifyAuraState(AURA_STATE_DEFENSE, true);
StartReactiveTimer(REACTIVE_DEFENSE);
}
}
// if and victim block attack
if (procExtra & PROC_EX_BLOCK)
{
ModifyAuraState(AURA_STATE_DEFENSE, true);
StartReactiveTimer(REACTIVE_DEFENSE);
}
}
else //For attacker
{
// Overpower on victim dodge
if (procExtra & PROC_EX_DODGE && GetTypeId() == TYPEID_PLAYER
&& getClass() == CLASS_WARRIOR)
{
this->ToPlayer()->AddComboPoints(pTarget, 1);
StartReactiveTimer(REACTIVE_OVERPOWER);
}
}
}
}
ProcTriggeredList procTriggered;
// Fill procTriggered list
for (AuraApplicationMap::const_iterator itr = GetAppliedAuras().begin();
itr != GetAppliedAuras().end(); ++itr)
{
// Do not allow auras to proc from effect triggered by itself
if (procAura && procAura->Id == itr->first) continue;
ProcTriggeredData triggerData(itr->second->GetBase());
// Defensive procs are active on absorbs (so absorption effects are not a hindrance)
bool active = (damage > 0)
|| (procExtra & (PROC_EX_ABSORB | PROC_EX_BLOCK) && isVictim);
if (isVictim) procExtra &= ~PROC_EX_INTERNAL_REQ_FAMILY;
SpellEntry const* spellProto = itr->second->GetBase()->GetSpellProto();
if (!IsTriggeredAtSpellProcEvent(pTarget, triggerData.aura, procSpell,
procFlag, procExtra, attType, isVictim, active,
triggerData.spellProcEvent)) continue;
// Triggered spells not triggering additional spells
bool triggered =
!(spellProto->AttributesEx3
& SPELL_ATTR3_CAN_PROC_WITH_TRIGGERED) ?
(procExtra & PROC_EX_INTERNAL_TRIGGERED
&& !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION)) :
false;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (itr->second->HasEffect(i))
{
AuraEffect * aurEff = itr->second->GetBase()->GetEffect(i);
// Skip this auras
if (isNonTriggerAura [aurEff->GetAuraType()]) continue;
// If not trigger by default and spellProcEvent == NULL - skip
if (!isTriggerAura [aurEff->GetAuraType()]
&& triggerData.spellProcEvent == NULL) continue;
// Some spells must always trigger
if (!triggered || isAlwaysTriggeredAura [aurEff->GetAuraType()]) triggerData.effMask |=
1 << i;
}
}
if (triggerData.effMask) procTriggered.push_front(triggerData);
}
// Nothing found
if (procTriggered.empty()) return;
if (procExtra & (PROC_EX_INTERNAL_TRIGGERED | PROC_EX_INTERNAL_CANT_PROC)) SetCantProc(
true);
// Handle effects proceed this time
for (ProcTriggeredList::const_iterator i = procTriggered.begin();
i != procTriggered.end(); ++i)
{
// look for aura in auras list, it may be removed while proc event processing
if (i->aura->IsRemoved()) continue;
bool useCharges = i->aura->GetCharges() > 0;
bool takeCharges = false;
SpellEntry const *spellInfo = i->aura->GetSpellProto();
uint32 Id = i->aura->GetId();
// For players set spell cooldown if need
uint32 cooldown = 0;
if (GetTypeId() == TYPEID_PLAYER && i->spellProcEvent
&& i->spellProcEvent->cooldown) cooldown =
i->spellProcEvent->cooldown;
if (spellInfo->AttributesEx3 & SPELL_ATTR3_DISABLE_PROC) SetCantProc(
true);
// This bool is needed till separate aura effect procs are still here
bool handled = false;
if (HandleAuraProc(pTarget, damage, i->aura, procSpell, procFlag,
procExtra, cooldown, &handled))
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell %u (triggered with value by %s aura of spell %u)",
spellInfo->Id, (isVictim ? "a victim's" : "an attacker's"),
Id);
takeCharges = true;
}
if (!handled) for (uint8 effIndex = 0; effIndex < MAX_SPELL_EFFECTS;
++effIndex)
{
if (!(i->effMask & (1 << effIndex))) continue;
AuraEffect *triggeredByAura = i->aura->GetEffect(effIndex);
ASSERT(triggeredByAura);
switch (triggeredByAura->GetAuraType())
{
case SPELL_AURA_PROC_TRIGGER_SPELL:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell %u (triggered by %s aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
// Don`t drop charge or add cooldown for not started trigger
if (HandleProcTriggerSpell(pTarget, damage, triggeredByAura,
procSpell, procFlag, procExtra, cooldown)) takeCharges =
true;
break;
}
case SPELL_AURA_PROC_TRIGGER_DAMAGE:
{
if (!pTarget) return;
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: doing %u damage from spell id %u (triggered by %s aura of spell %u)",
triggeredByAura->GetAmount(), spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
SpellNonMeleeDamage damageInfo(this, pTarget, spellInfo->Id,
spellInfo->SchoolMask);
uint32 damage = SpellDamageBonus(pTarget, spellInfo,
triggeredByAura->GetEffIndex(),
triggeredByAura->GetAmount(), SPELL_DIRECT_DAMAGE);
CalculateSpellDamageTaken(&damageInfo, damage, spellInfo);
DealDamageMods(damageInfo.target, damageInfo.damage,
&damageInfo.absorb);
SendSpellNonMeleeDamageLog(&damageInfo);
DealSpellDamage(&damageInfo, true);
takeCharges = true;
break;
}
case SPELL_AURA_MANA_SHIELD:
case SPELL_AURA_DUMMY:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell id %u (triggered by %s dummy aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (HandleDummyAuraProc(pTarget, damage, triggeredByAura,
procSpell, procFlag, procExtra, cooldown)) takeCharges =
true;
break;
}
case SPELL_AURA_OBS_MOD_POWER:
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell id %u (triggered by %s aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (HandleObsModEnergyAuraProc(pTarget, damage,
triggeredByAura, procSpell, procFlag, procExtra,
cooldown)) takeCharges = true;
break;
case SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN:
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell id %u (triggered by %s aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (HandleModDamagePctTakenAuraProc(pTarget, damage,
triggeredByAura, procSpell, procFlag, procExtra,
cooldown)) takeCharges = true;
break;
case SPELL_AURA_MOD_POWER_REGEN_PERCENT:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell id %u (triggered by %s ModPowerRegenPCT of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (HandleModPowerRegenAuraProc(pTarget, damage,
triggeredByAura, procSpell, procFlag, procExtra,
cooldown)) takeCharges = true;
break;
}
case SPELL_AURA_OVERRIDE_CLASS_SCRIPTS:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell id %u (triggered by %s aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (HandleOverrideClassScriptAuraProc(pTarget, damage,
triggeredByAura, procSpell, cooldown)) takeCharges =
true;
break;
}
case SPELL_AURA_RAID_PROC_FROM_CHARGE_WITH_VALUE:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting mending (triggered by %s dummy aura of spell %u)",
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
HandleAuraRaidProcFromChargeWithValue(triggeredByAura);
takeCharges = true;
break;
}
case SPELL_AURA_RAID_PROC_FROM_CHARGE:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting mending (triggered by %s dummy aura of spell %u)",
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
HandleAuraRaidProcFromCharge(triggeredByAura);
takeCharges = true;
break;
}
case SPELL_AURA_PROC_TRIGGER_SPELL_WITH_VALUE:
{
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell %u (triggered with value by %s aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (HandleProcTriggerSpell(pTarget, damage, triggeredByAura,
procSpell, procFlag, procExtra, cooldown)) takeCharges =
true;
break;
}
case SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK:
// Skip melee hits or instant cast spells
if (procSpell && GetSpellCastTime(procSpell) != 0) takeCharges =
true;
break;
case SPELL_AURA_REFLECT_SPELLS_SCHOOL:
// Skip Melee hits and spells ws wrong school
if (procSpell
&& (triggeredByAura->GetMiscValue()
& procSpell->SchoolMask)) // School check
takeCharges = true;
break;
case SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT:
case SPELL_AURA_MOD_POWER_COST_SCHOOL:
// Skip melee hits and spells ws wrong school or zero cost
if (procSpell
&& (procSpell->manaCost != 0
|| procSpell->ManaCostPercentage != 0) && // Cost check
(triggeredByAura->GetMiscValue()
& procSpell->SchoolMask)) // School check
takeCharges = true;
break;
case SPELL_AURA_MECHANIC_IMMUNITY:
// Compare mechanic
if (procSpell
&& procSpell->Mechanic
== uint32(triggeredByAura->GetMiscValue())) takeCharges =
true;
break;
case SPELL_AURA_MOD_MECHANIC_RESISTANCE:
// Compare mechanic
if (procSpell
&& procSpell->Mechanic
== uint32(triggeredByAura->GetMiscValue())) takeCharges =
true;
break;
case SPELL_AURA_MOD_DAMAGE_FROM_CASTER:
// Compare casters
if (triggeredByAura->GetCasterGUID() == pTarget->GetGUID()) takeCharges =
true;
break;
case SPELL_AURA_MOD_SPELL_CRIT_CHANCE:
sLog->outDebug(
LOG_FILTER_SPELLS_AURAS,
"ProcDamageAndSpell: casting spell id %u (triggered by %s spell crit chance aura of spell %u)",
spellInfo->Id,
(isVictim ? "a victim's" : "an attacker's"),
triggeredByAura->GetId());
if (procSpell
&& HandleSpellCritChanceAuraProc(pTarget, damage,
triggeredByAura, procSpell, procFlag,
procExtra, cooldown)) takeCharges = true;
break;
// CC Auras which use their amount amount to drop
// Are there any more auras which need this?
case SPELL_AURA_MOD_CONFUSE:
case SPELL_AURA_MOD_FEAR:
case SPELL_AURA_MOD_STUN:
case SPELL_AURA_MOD_ROOT:
case SPELL_AURA_TRANSFORM:
{
// chargeable mods are breaking on hit
if (useCharges) takeCharges = true;
else
{
// Spell own direct damage at apply wont break the CC
if (procSpell
&& (procSpell->Id == triggeredByAura->GetId()))
{
Aura * aura = triggeredByAura->GetBase();
// called from spellcast, should not have ticked yet
if (aura->GetDuration() == aura->GetMaxDuration()) break;
}
int32 damageLeft = triggeredByAura->GetAmount();
// No damage left
if (damageLeft < int32(damage)) i->aura->Remove();
else triggeredByAura->SetAmount(damageLeft - damage);
}
break;
}
//case SPELL_AURA_ADD_FLAT_MODIFIER:
//case SPELL_AURA_ADD_PCT_MODIFIER:
// HandleSpellModAuraProc
//break;
default:
// nothing do, just charges counter
takeCharges = true;
break;
}
}
// Remove charge (aura can be removed by triggers)
if (useCharges && takeCharges) i->aura->DropCharge();
if (spellInfo->AttributesEx3 & SPELL_ATTR3_DISABLE_PROC) SetCantProc(
false);
}
// Cleanup proc requirements
if (procExtra & (PROC_EX_INTERNAL_TRIGGERED | PROC_EX_INTERNAL_CANT_PROC)) SetCantProc(
false);
}
SpellSchoolMask Unit::GetMeleeDamageSchoolMask() const
{
return SPELL_SCHOOL_MASK_NORMAL;
}
Player* Unit::GetSpellModOwner() const
{
if (GetTypeId() == TYPEID_PLAYER) return (Player*) this;
if (this->ToCreature()->isPet() || this->ToCreature()->isTotem())
{
Unit* owner = GetOwner();
if (owner && owner->GetTypeId() == TYPEID_PLAYER) return (Player*) owner;
}
return NULL;
}
///----------Pet responses methods-----------------
void Unit::SendPetCastFail(uint32 spellid, SpellCastResult msg)
{
if (msg == SPELL_CAST_OK) return;
Unit *owner = GetCharmerOrOwner();
if (!owner || owner->GetTypeId() != TYPEID_PLAYER) return;
WorldPacket data(SMSG_PET_CAST_FAILED, 1 + 4 + 1);
data << uint8(0); // cast count?
data << uint32(spellid);
data << uint8(msg);
// uint32 for some reason
// uint32 for some reason
owner->ToPlayer()->GetSession()->SendPacket(&data);
}
void Unit::SendPetActionFeedback(uint8 msg)
{
Unit* owner = GetOwner();
if (!owner || owner->GetTypeId() != TYPEID_PLAYER) return;
WorldPacket data(SMSG_PET_ACTION_FEEDBACK, 1);
data << uint8(msg);
owner->ToPlayer()->GetSession()->SendPacket(&data);
}
void Unit::SendPetTalk(uint32 pettalk)
{
Unit* owner = GetOwner();
if (!owner || owner->GetTypeId() != TYPEID_PLAYER) return;
WorldPacket data(SMSG_PET_ACTION_SOUND, 8 + 4);
data << uint64(GetGUID());
data << uint32(pettalk);
owner->ToPlayer()->GetSession()->SendPacket(&data);
}
void Unit::SendPetAIReaction(uint64 guid)
{
Unit* owner = GetOwner();
if (!owner || owner->GetTypeId() != TYPEID_PLAYER) return;
WorldPacket data(SMSG_AI_REACTION, 8 + 4);
data << uint64(guid);
data << uint32(AI_REACTION_HOSTILE);
owner->ToPlayer()->GetSession()->SendPacket(&data);
}
///----------End of Pet responses methods----------
void Unit::StopMoving()
{
ClearUnitState(UNIT_STAT_MOVING);
// send explicit stop packet
// rely on vmaps here because for example stormwind is in air
//float z = sMapMgr->GetBaseMap(GetMapId())->GetHeight(GetPositionX(), GetPositionY(), GetPositionZ(), true);
//if (fabs(GetPositionZ() - z) < 2.0f)
// Relocate(GetPositionX(), GetPositionY(), z);
//Relocate(GetPositionX(), GetPositionY(), GetPositionZ());
if (!(GetUnitMovementFlags() & MOVEMENTFLAG_ONTRANSPORT)) SendMonsterStop();
}
void Unit::SendMovementFlagUpdate()
{
WorldPacket data;
BuildHeartBeatMsg(&data);
SendMessageToSet(&data, false);
}
bool Unit::IsSitState() const
{
uint8 s = getStandState();
return s == UNIT_STAND_STATE_SIT_CHAIR
|| s == UNIT_STAND_STATE_SIT_LOW_CHAIR
|| s == UNIT_STAND_STATE_SIT_MEDIUM_CHAIR
|| s == UNIT_STAND_STATE_SIT_HIGH_CHAIR || s == UNIT_STAND_STATE_SIT;
}
bool Unit::IsStandState() const
{
uint8 s = getStandState();
return !IsSitState() && s != UNIT_STAND_STATE_SLEEP
&& s != UNIT_STAND_STATE_KNEEL;
}
void Unit::SetStandState(uint8 state)
{
SetByteValue(UNIT_FIELD_BYTES_1, 0, state);
if (IsStandState()) RemoveAurasWithInterruptFlags(
AURA_INTERRUPT_FLAG_NOT_SEATED);
if (GetTypeId() == TYPEID_PLAYER)
{
WorldPacket data(SMSG_STANDSTATE_UPDATE, 1);
data << (uint8) state;
this->ToPlayer()->GetSession()->SendPacket(&data);
}
}
bool Unit::IsPolymorphed() const
{
uint32 transformId = getTransForm();
if (!transformId) return false;
const SpellEntry *spellInfo = sSpellStore.LookupEntry(transformId);
if (!spellInfo) return false;
return GetSpellSpecific(spellInfo) == SPELL_SPECIFIC_MAGE_POLYMORPH;
}
void Unit::SetDisplayId(uint32 modelId)
{
SetUInt32Value(UNIT_FIELD_DISPLAYID, modelId);
if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (!pet->isControlled()) return;
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup()) owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_MODEL_ID);
}
}
void Unit::RestoreDisplayId()
{
AuraEffect* handledAura = NULL;
// try to receive model from transform auras
Unit::AuraEffectList const& transforms = GetAuraEffectsByType(
SPELL_AURA_TRANSFORM);
if (!transforms.empty())
{
// iterate over already applied transform auras - from newest to oldest
for (Unit::AuraEffectList::const_reverse_iterator i =
transforms.rbegin(); i != transforms.rend(); ++i)
{
if (AuraApplication const * aurApp = (*i)->GetBase()->GetApplicationOfTarget(GetGUID()))
{
if (!handledAura) handledAura = (*i);
// prefer negative auras
if (!aurApp->IsPositive())
{
handledAura = (*i);
break;
}
}
}
}
// transform aura was found
if (handledAura) handledAura->HandleEffect(this,
AURA_EFFECT_HANDLE_SEND_FOR_CLIENT, true);
// we've found shapeshift
else if (uint32 modelId = GetModelForForm(GetShapeshiftForm())) SetDisplayId(
modelId);
// no auras found - set modelid to default
else SetDisplayId(GetNativeDisplayId());
}
void Unit::ClearComboPointHolders()
{
while (!m_ComboPointHolders.empty())
{
uint32 lowguid = *m_ComboPointHolders.begin();
Player* plr = sObjectMgr->GetPlayer(
MAKE_NEW_GUID(lowguid, 0, HIGHGUID_PLAYER));
if (plr && plr->GetComboTarget() == GetGUID()) // recheck for safe
plr->ClearComboPoints(); // remove also guid from m_ComboPointHolders;
else m_ComboPointHolders.erase(lowguid); // or remove manually
}
}
void Unit::ClearAllReactives()
{
for (uint8 i = 0; i < MAX_REACTIVE; ++i)
m_reactiveTimer [i] = 0;
if (HasAuraState(AURA_STATE_DEFENSE)) ModifyAuraState(AURA_STATE_DEFENSE,
false);
if (getClass() == CLASS_HUNTER && HasAuraState(AURA_STATE_HUNTER_PARRY)) ModifyAuraState(
AURA_STATE_HUNTER_PARRY, false);
if (getClass() == CLASS_WARRIOR && GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->ClearComboPoints();
}
void Unit::UpdateReactives(uint32 p_time)
{
for (uint8 i = 0; i < MAX_REACTIVE; ++i)
{
ReactiveType reactive = ReactiveType(i);
if (!m_reactiveTimer [reactive]) continue;
if (m_reactiveTimer [reactive] <= p_time)
{
m_reactiveTimer [reactive] = 0;
switch (reactive)
{
case REACTIVE_DEFENSE:
if (HasAuraState(AURA_STATE_DEFENSE)) ModifyAuraState(
AURA_STATE_DEFENSE, false);
break;
case REACTIVE_HUNTER_PARRY:
if (getClass() == CLASS_HUNTER
&& HasAuraState(AURA_STATE_HUNTER_PARRY)) ModifyAuraState(
AURA_STATE_HUNTER_PARRY, false);
break;
case REACTIVE_OVERPOWER:
if (getClass() == CLASS_WARRIOR
&& GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->ClearComboPoints();
break;
default:
break;
}
}
else
{
m_reactiveTimer [reactive] -= p_time;
}
}
}
Unit* Unit::SelectNearbyTarget(float dist) const
{
std::list <Unit *> targets;
Trinity::AnyUnfriendlyUnitInObjectRangeCheck u_check(this, this, dist);
Trinity::UnitListSearcher <Trinity::AnyUnfriendlyUnitInObjectRangeCheck> searcher(
this, targets, u_check);
VisitNearbyObject(dist, searcher);
// remove current target
if (getVictim()) targets.remove(getVictim());
// remove not LoS targets
for (std::list <Unit*>::iterator tIter = targets.begin();
tIter != targets.end();)
{
if (!IsWithinLOSInMap(*tIter) || (*tIter)->isTotem()
|| (*tIter)->isSpiritService()
|| (*tIter)->GetCreatureType() == CREATURE_TYPE_CRITTER) targets.erase(
tIter++);
else ++tIter;
}
// no appropriate targets
if (targets.empty()) return NULL;
// select random
std::list <Unit*>::const_iterator tcIter = targets.begin();
std::advance(tcIter, urand(0, targets.size() - 1));
return *tcIter;
}
void Unit::ApplyAttackTimePercentMod(WeaponAttackType att, float val,
bool apply)
{
float remainingTimePct = (float) m_attackTimer [att]
/ (GetAttackTime(att) * m_modAttackSpeedPct [att]);
if (val > 0)
{
ApplyPercentModFloatVar(m_modAttackSpeedPct [att], val, !apply);
ApplyPercentModFloatValue(UNIT_FIELD_BASEATTACKTIME + att, val, !apply);
}
else
{
ApplyPercentModFloatVar(m_modAttackSpeedPct [att], -val, apply);
ApplyPercentModFloatValue(UNIT_FIELD_BASEATTACKTIME + att, -val, apply);
}
m_attackTimer [att] = uint32(
GetAttackTime(att) * m_modAttackSpeedPct [att] * remainingTimePct);
}
void Unit::ApplyCastTimePercentMod(float val, bool apply)
{
if (val > 0) ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, val, !apply);
else ApplyPercentModFloatValue(UNIT_MOD_CAST_SPEED, -val, apply);
}
uint32 Unit::GetCastingTimeForBonus(SpellEntry const *spellProto,
DamageEffectType damagetype, uint32 CastingTime)
{
// Not apply this to creature casted spells with casttime == 0
if (CastingTime == 0 && GetTypeId() == TYPEID_UNIT
&& !this->ToCreature()->isPet()) return 3500;
if (CastingTime > 7000) CastingTime = 7000;
if (CastingTime < 1500) CastingTime = 1500;
if (damagetype == DOT && !IsChanneledSpell(spellProto)) CastingTime = 3500;
int32 overTime = 0;
uint8 effects = 0;
bool DirectDamage = false;
bool AreaEffect = false;
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; i++)
{
switch (spellProto->Effect [i])
{
case SPELL_EFFECT_SCHOOL_DAMAGE:
case SPELL_EFFECT_POWER_DRAIN:
case SPELL_EFFECT_HEALTH_LEECH:
case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE:
case SPELL_EFFECT_POWER_BURN:
case SPELL_EFFECT_HEAL:
DirectDamage = true;
break;
case SPELL_EFFECT_APPLY_AURA:
switch (spellProto->EffectApplyAuraName [i])
{
case SPELL_AURA_PERIODIC_DAMAGE:
case SPELL_AURA_PERIODIC_HEAL:
case SPELL_AURA_PERIODIC_LEECH:
if (GetSpellDuration(spellProto)) overTime =
GetSpellDuration(spellProto);
break;
default:
// -5% per additional effect
++effects;
break;
}
default:
break;
}
if (IsAreaEffectTarget [spellProto->EffectImplicitTargetA [i]]
|| IsAreaEffectTarget [spellProto->EffectImplicitTargetB [i]]) AreaEffect =
true;
}
// Combined Spells with Both Over Time and Direct Damage
if (overTime > 0 && CastingTime > 0 && DirectDamage)
{
// mainly for DoTs which are 3500 here otherwise
uint32 OriginalCastTime = GetSpellCastTime(spellProto);
if (OriginalCastTime > 7000) OriginalCastTime = 7000;
if (OriginalCastTime < 1500) OriginalCastTime = 1500;
// Portion to Over Time
float PtOT = (overTime / 15000.0f)
/ ((overTime / 15000.0f) + (OriginalCastTime / 3500.0f));
if (damagetype == DOT) CastingTime = uint32(CastingTime * PtOT);
else if (PtOT < 1.0f) CastingTime = uint32(CastingTime * (1 - PtOT));
else CastingTime = 0;
}
// Area Effect Spells receive only half of bonus
if (AreaEffect) CastingTime /= 2;
// -5% of total per any additional effect
for (uint8 i = 0; i < effects; ++i)
{
if (CastingTime > 175)
{
CastingTime -= 175;
}
else
{
CastingTime = 0;
break;
}
}
return CastingTime;
}
void Unit::UpdateAuraForGroup(uint8 slot)
{
if (slot >= MAX_AURAS) // slot not found, return
return;
if (GetTypeId() == TYPEID_PLAYER)
{
Player* player = (Player*) this;
if (player->GetGroup())
{
player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_AURAS);
player->SetAuraUpdateMaskForRaid(slot);
}
}
else if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->isPet())
{
Pet *pet = ((Pet*) this);
if (pet->isControlled())
{
Unit *owner = GetOwner();
if (owner && (owner->GetTypeId() == TYPEID_PLAYER)
&& owner->ToPlayer()->GetGroup())
{
owner->ToPlayer()->SetGroupUpdateFlag(
GROUP_UPDATE_FLAG_PET_AURAS);
pet->SetAuraUpdateMaskForRaid(slot);
}
}
}
}
float Unit::GetAPMultiplier(WeaponAttackType attType, bool normalized)
{
if (!normalized || GetTypeId() != TYPEID_PLAYER) return float(
GetAttackTime(attType)) / 1000.0f;
Item *Weapon = this->ToPlayer()->GetWeaponForAttack(attType, true);
if (!Weapon) return 2.4f; // fist attack
switch (Weapon->GetProto()->InventoryType)
{
case INVTYPE_2HWEAPON:
return 3.3f;
case INVTYPE_RANGED:
case INVTYPE_RANGEDRIGHT:
case INVTYPE_THROWN:
return 2.8f;
case INVTYPE_WEAPON:
case INVTYPE_WEAPONMAINHAND:
case INVTYPE_WEAPONOFFHAND:
default:
return Weapon->GetProto()->SubClass == ITEM_SUBCLASS_WEAPON_DAGGER ?
1.7f : 2.4f;
}
}
bool Unit::IsUnderLastManaUseEffect() const
{
return getMSTimeDiff(m_lastManaUse, getMSTime()) < 5000;
}
void Unit::SetContestedPvP(Player *attackedPlayer)
{
Player* player = GetCharmerOrOwnerPlayerOrPlayerItself();
if (!player
|| (attackedPlayer
&& (attackedPlayer == player
|| (player->duel
&& player->duel->opponent == attackedPlayer)))) return;
player->SetContestedPvPTimer(30000);
if (!player->HasUnitState(UNIT_STAT_ATTACK_PLAYER))
{
player->AddUnitState(UNIT_STAT_ATTACK_PLAYER);
player->SetFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP);
// call MoveInLineOfSight for nearby contested guards
UpdateObjectVisibility();
}
if (!HasUnitState(UNIT_STAT_ATTACK_PLAYER))
{
AddUnitState(UNIT_STAT_ATTACK_PLAYER);
// call MoveInLineOfSight for nearby contested guards
UpdateObjectVisibility();
}
}
void Unit::AddPetAura(PetAura const* petSpell)
{
if (GetTypeId() != TYPEID_PLAYER) return;
m_petAuras.insert(petSpell);
if (Pet* pet = this->ToPlayer()->GetPet()) pet->CastPetAura(petSpell);
}
void Unit::RemovePetAura(PetAura const* petSpell)
{
if (GetTypeId() != TYPEID_PLAYER) return;
m_petAuras.erase(petSpell);
if (Pet* pet = this->ToPlayer()->GetPet()) pet->RemoveAurasDueToSpell(
petSpell->GetAura(pet->GetEntry()));
}
Pet* Unit::CreateTamedPetFrom(Creature* creatureTarget, uint32 spell_id)
{
if (GetTypeId() != TYPEID_PLAYER) return NULL;
Pet* pet = new Pet((Player*) this, HUNTER_PET);
if (!pet->CreateBaseAtCreature(creatureTarget))
{
delete pet;
return NULL;
}
uint8 level =
creatureTarget->getLevel() + 5 < getLevel() ?
(getLevel() - 5) : creatureTarget->getLevel();
InitTamedPet(pet, level, spell_id);
return pet;
}
Pet* Unit::CreateTamedPetFrom(uint32 creatureEntry, uint32 spell_id)
{
if (GetTypeId() != TYPEID_PLAYER) return NULL;
CreatureInfo const* creatureInfo = ObjectMgr::GetCreatureTemplate(
creatureEntry);
if (!creatureInfo) return NULL;
Pet* pet = new Pet((Player*) this, HUNTER_PET);
if (!pet->CreateBaseAtCreatureInfo(creatureInfo, this)
|| !InitTamedPet(pet, getLevel(), spell_id))
{
delete pet;
return NULL;
}
return pet;
}
bool Unit::InitTamedPet(Pet * pet, uint8 level, uint32 spell_id)
{
pet->SetCreatorGUID(GetGUID());
pet->setFaction(getFaction());
pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, spell_id);
if (GetTypeId() == TYPEID_PLAYER) pet->SetUInt32Value(UNIT_FIELD_FLAGS,
UNIT_FLAG_PVP_ATTACKABLE);
if (!pet->InitStatsForLevel(level))
{
sLog->outError(
"Pet::InitStatsForLevel() failed for creature (Entry: %u)!",
pet->GetEntry());
return false;
}
pet->GetCharmInfo()->SetPetNumber(sObjectMgr->GeneratePetNumber(), true);
// this enables pet details window (Shift+P)
pet->InitPetCreateSpells();
//pet->InitLevelupSpellsForLevel();
pet->SetFullHealth();
return true;
}
bool Unit::IsTriggeredAtSpellProcEvent(Unit *pVictim, Aura * aura,
SpellEntry const* procSpell, uint32 procFlag, uint32 procExtra,
WeaponAttackType attType, bool isVictim, bool active,
SpellProcEventEntry const *& spellProcEvent)
{
SpellEntry const *spellProto = aura->GetSpellProto();
// Get proc Event Entry
spellProcEvent = sSpellMgr->GetSpellProcEvent(spellProto->Id);
// Get EventProcFlag
uint32 EventProcFlag;
if (spellProcEvent && spellProcEvent->procFlags) // if exist get custom spellProcEvent->procFlags
EventProcFlag = spellProcEvent->procFlags;
else EventProcFlag = spellProto->procFlags; // else get from spell proto
// Continue if no trigger exist
if (!EventProcFlag) return false;
// Additional checks for triggered spells (ignore trap casts)
if (procExtra & PROC_EX_INTERNAL_TRIGGERED
&& !(procFlag & PROC_FLAG_DONE_TRAP_ACTIVATION))
{
if (!(spellProto->AttributesEx3 & SPELL_ATTR3_CAN_PROC_WITH_TRIGGERED)) return false;
}
// Check spellProcEvent data requirements
if (!sSpellMgr->IsSpellProcEventCanTriggeredBy(spellProcEvent,
EventProcFlag, procSpell, procFlag, procExtra, active)) return false;
// In most cases req get honor or XP from kill
if (EventProcFlag & PROC_FLAG_KILL && GetTypeId() == TYPEID_PLAYER)
{
bool allow = false;
if (pVictim) allow = ToPlayer()->isHonorOrXPTarget(pVictim);
// Shadow Word: Death - can trigger from every kill
if (aura->GetId() == 32409) allow = true;
if (!allow) return false;
}
// Aura added by spell can`t trigger from self (prevent drop charges/do triggers)
// But except periodic and kill triggers (can triggered from self)
if (procSpell && procSpell->Id == spellProto->Id
&& !(spellProto->procFlags
& (PROC_FLAG_TAKEN_PERIODIC | PROC_FLAG_KILL))) return false;
// Check if current equipment allows aura to proc
if (!isVictim && GetTypeId() == TYPEID_PLAYER)
{
if (spellProto->EquippedItemClass == ITEM_CLASS_WEAPON)
{
Item *item = NULL;
if (attType == BASE_ATTACK) item =
this->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0,
EQUIPMENT_SLOT_MAINHAND);
else if (attType == OFF_ATTACK) item =
this->ToPlayer()->GetUseableItemByPos(INVENTORY_SLOT_BAG_0,
EQUIPMENT_SLOT_OFFHAND);
else item = this->ToPlayer()->GetUseableItemByPos(
INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED);
if (this->ToPlayer()->IsInFeralForm()) return false;
if (!item || item->IsBroken()
|| item->GetProto()->Class != ITEM_CLASS_WEAPON
|| !((1 << item->GetProto()->SubClass)
& spellProto->EquippedItemSubClassMask)) return false;
}
else if (spellProto->EquippedItemClass == ITEM_CLASS_ARMOR)
{
// Check if player is wearing shield
Item *item = this->ToPlayer()->GetUseableItemByPos(
INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
if (!item || item->IsBroken()
|| item->GetProto()->Class != ITEM_CLASS_ARMOR
|| !((1 << item->GetProto()->SubClass)
& spellProto->EquippedItemSubClassMask)) return false;
}
}
// Get chance from spell
float chance = float(spellProto->procChance);
// If in spellProcEvent exist custom chance, chance = spellProcEvent->customChance;
if (spellProcEvent && spellProcEvent->customChance) chance =
spellProcEvent->customChance;
// Missile Barrage
if (spellProto->SpellFamilyName == SPELLFAMILY_MAGE
&& spellProto->SpellIconID == 3261) if (!(procSpell->SpellFamilyFlags [0]
& 0x20000000)) chance /= 2.0;
// If PPM exist calculate chance from PPM
if (spellProcEvent && spellProcEvent->ppmRate != 0)
{
if (!isVictim)
{
uint32 WeaponSpeed = GetAttackTime(attType);
chance = GetPPMProcChance(WeaponSpeed, spellProcEvent->ppmRate,
spellProto);
}
else
{
uint32 WeaponSpeed = pVictim->GetAttackTime(attType);
chance = pVictim->GetPPMProcChance(WeaponSpeed,
spellProcEvent->ppmRate, spellProto);
}
}
// Apply chance modifer aura
if (Player* modOwner = GetSpellModOwner())
{
modOwner->ApplySpellMod(spellProto->Id, SPELLMOD_CHANCE_OF_SUCCESS,
chance);
}
return roll_chance_f(chance);
}
bool Unit::HandleAuraRaidProcFromChargeWithValue(AuraEffect *triggeredByAura)
{
// aura can be deleted at casts
SpellEntry const *spellProto = triggeredByAura->GetSpellProto();
uint32 effIdx = triggeredByAura->GetEffIndex();
int32 heal = triggeredByAura->GetAmount();
uint64 caster_guid = triggeredByAura->GetCasterGUID();
//Currently only Prayer of Mending
if (!(spellProto->SpellFamilyName == SPELLFAMILY_PRIEST
&& spellProto->SpellFamilyFlags [1] & 0x20))
{
sLog->outDebug(
LOG_FILTER_UNITS,
"Unit::HandleAuraRaidProcFromChargeWithValue, received not handled spell: %u",
spellProto->Id);
return false;
}
// jumps
int32 jumps = triggeredByAura->GetBase()->GetCharges() - 1;
// current aura expire
triggeredByAura->GetBase()->SetCharges(1); // will removed at next charges decrease
// next target selection
if (jumps > 0)
{
float radius;
if (spellProto->EffectRadiusIndex [effIdx]) radius =
(float) GetSpellRadiusForTarget(
triggeredByAura->GetCaster(),
sSpellRadiusStore.LookupEntry(
spellProto->EffectRadiusIndex [effIdx]));
else radius = (float) GetSpellMaxRangeForTarget(
triggeredByAura->GetCaster(),
sSpellRangeStore.LookupEntry(spellProto->rangeIndex));
if (Unit * caster = triggeredByAura->GetCaster())
{
if (Player * modOwner = caster->GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, SPELLMOD_RADIUS, radius, NULL);
if (Unit *target = GetNextRandomRaidMemberOrPet(radius))
{
CastCustomSpell(target, spellProto->Id, &heal, NULL, NULL, true,
NULL, triggeredByAura, caster_guid);
if (Aura * aura = target->GetAura(spellProto->Id, caster->GetGUID())) aura->SetCharges(
jumps);
}
}
}
// heal
CastCustomSpell(this, 33110, &heal, NULL, NULL, true, NULL, NULL,
caster_guid);
return true;
}
bool Unit::HandleAuraRaidProcFromCharge(AuraEffect* triggeredByAura)
{
// aura can be deleted at casts
SpellEntry const* spellProto = triggeredByAura->GetSpellProto();
uint32 damageSpellId;
switch (spellProto->Id)
{
case 57949: //shiver
damageSpellId = 57952;
//animationSpellId = 57951; dummy effects for jump spell have unknown use (see also 41637)
break;
case 59978: //shiver
damageSpellId = 59979;
break;
case 43593: //Cold Stare
damageSpellId = 43594;
break;
default:
sLog->outError(
"Unit::HandleAuraRaidProcFromCharge, received not handled spell: %u",
spellProto->Id);
return false;
}
uint64 caster_guid = triggeredByAura->GetCasterGUID();
uint32 effIdx = triggeredByAura->GetEffIndex();
// jumps
int32 jumps = triggeredByAura->GetBase()->GetCharges() - 1;
// current aura expire
triggeredByAura->GetBase()->SetCharges(1); // will removed at next charges decrease
// next target selection
if (jumps > 0)
{
float radius;
if (spellProto->EffectRadiusIndex [effIdx]) radius =
(float) GetSpellRadiusForTarget(
triggeredByAura->GetCaster(),
sSpellRadiusStore.LookupEntry(
spellProto->EffectRadiusIndex [effIdx]));
else radius = (float) GetSpellMaxRangeForTarget(
triggeredByAura->GetCaster(),
sSpellRangeStore.LookupEntry(spellProto->rangeIndex));
if (Unit * caster = triggeredByAura->GetCaster())
{
if (Player * modOwner = caster->GetSpellModOwner()) modOwner->ApplySpellMod(
spellProto->Id, SPELLMOD_RADIUS, radius, NULL);
if (Unit* target= GetNextRandomRaidMemberOrPet(radius))
{
CastSpell(target, spellProto, true, NULL, triggeredByAura,
caster_guid);
if (Aura * aura = target->GetAura(spellProto->Id, caster->GetGUID())) aura->SetCharges(
jumps);
}
}
}
CastSpell(this, damageSpellId, true, NULL, triggeredByAura, caster_guid);
return true;
}
void Unit::Kill(Unit *pVictim, bool durabilityLoss)
{
// Prevent killing unit twice (and giving reward from kill twice)
if (!pVictim->GetHealth()) return;
// Inform pets (if any) when player kills target)
if (this->ToPlayer())
{
Pet *pPet = this->ToPlayer()->GetPet();
if (pPet && pPet->isAlive() && pPet->isControlled()) pPet->AI()->KilledUnit(
pVictim);
}
// find player: owner of controlled `this` or `this` itself maybe
Player *player = GetCharmerOrOwnerPlayerOrPlayerItself();
Creature *creature = pVictim->ToCreature();
bool bRewardIsAllowed = true;
if (creature)
{
bRewardIsAllowed = creature->IsDamageEnoughForLootingAndReward();
if (!bRewardIsAllowed) creature->SetLootRecipient(NULL);
}
if (bRewardIsAllowed && creature && creature->GetLootRecipient()) player =
creature->GetLootRecipient();
// Reward player, his pets, and group/raid members
// call kill spell proc event (before real die and combat stop to triggering auras removed at death/combat stop)
if (bRewardIsAllowed && player && player != pVictim)
{
WorldPacket data(SMSG_PARTYKILLLOG, (8 + 8)); //send event PARTY_KILL
data << uint64(player->GetGUID()); //player with killing blow
data << uint64(pVictim->GetGUID()); //victim
Player* pLooter = player;
if (Group *group = player->GetGroup())
{
group->BroadcastPacket(&data,
group->GetMemberGroup(player->GetGUID()));
if (creature)
{
group->UpdateLooterGuid(creature, true);
if (group->GetLooterGuid())
{
pLooter = sObjectMgr->GetPlayer(group->GetLooterGuid());
if (pLooter)
{
creature->SetLootRecipient(pLooter); // update creature loot recipient to the allowed looter.
group->SendLooter(creature, pLooter);
}
else group->SendLooter(creature, NULL);
}
else group->SendLooter(creature, NULL);
group->UpdateLooterGuid(creature);
}
}
else
{
player->SendDirectMessage(&data);
if (creature)
{
WorldPacket data2(SMSG_LOOT_LIST, (8 + 1 + 1));
data2 << uint64(creature->GetGUID());
data2 << uint8(0); // unk1
data2 << uint8(0); // no group looter
player->SendMessageToSet(&data2, true);
}
}
if (creature)
{
Loot* loot = &creature->loot;
if (creature->lootForPickPocketed) creature->lootForPickPocketed =
false;
loot->clear();
if (uint32 lootid = creature->GetCreatureInfo()->lootid) loot->FillLoot(
lootid, LootTemplates_Creature, pLooter, false, false,
creature->GetLootMode());
loot->generateMoneyLoot(creature->GetCreatureInfo()->mingold,
creature->GetCreatureInfo()->maxgold);
}
player->RewardPlayerAndGroupAtKill(pVictim, false);
}
// Do KILL and KILLED procs. KILL proc is called only for the unit who landed the killing blow (and its owner - for pets and totems) regardless of who tapped the victim
if (isPet() || isTotem()) if (Unit *owner = GetOwner()) owner->ProcDamageAndSpell(
pVictim, PROC_FLAG_KILL, PROC_FLAG_NONE, PROC_EX_NONE, 0);
if (pVictim->GetCreatureType() != CREATURE_TYPE_CRITTER) ProcDamageAndSpell(
pVictim, PROC_FLAG_KILL, PROC_FLAG_KILLED, PROC_EX_NONE, 0);
// Proc auras on death - must be before aura/combat remove
pVictim->ProcDamageAndSpell(NULL, PROC_FLAG_DEATH, PROC_FLAG_NONE,
PROC_EX_NONE, 0, BASE_ATTACK, 0);
// if talent known but not triggered (check priest class for speedup check)
bool SpiritOfRedemption = false;
if (pVictim->GetTypeId() == TYPEID_PLAYER
&& pVictim->getClass() == CLASS_PRIEST)
{
AuraEffectList const& vDummyAuras = pVictim->GetAuraEffectsByType(
SPELL_AURA_DUMMY);
for (AuraEffectList::const_iterator itr = vDummyAuras.begin();
itr != vDummyAuras.end(); ++itr)
{
if ((*itr)->GetSpellProto()->SpellIconID == 1654)
{
AuraEffect * aurEff = *itr;
// save value before aura remove
uint32 ressSpellId = pVictim->GetUInt32Value(
PLAYER_SELF_RES_SPELL);
if (!ressSpellId) ressSpellId =
pVictim->ToPlayer()->GetResurrectionSpellId();
//Remove all expected to remove at death auras (most important negative case like DoT or periodic triggers)
pVictim->RemoveAllAurasOnDeath();
// restore for use at real death
pVictim->SetUInt32Value(PLAYER_SELF_RES_SPELL, ressSpellId);
// FORM_SPIRITOFREDEMPTION and related auras
pVictim->CastSpell(pVictim, 27827, true, NULL, aurEff);
SpiritOfRedemption = true;
break;
}
}
}
if (!SpiritOfRedemption)
{
sLog->outStaticDebug("SET JUST_DIED");
pVictim->setDeathState(JUST_DIED);
}
// 10% durability loss on death
// clean InHateListOf
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
// remember victim PvP death for corpse type and corpse reclaim delay
// at original death (not at SpiritOfRedemtionTalent timeout)
pVictim->ToPlayer()->SetPvPDeath(player != NULL);
// only if not player and not controlled by player pet. And not at BG
if ((durabilityLoss && !player && !pVictim->ToPlayer()->InBattleground())
|| (player
&& sWorld->getBoolConfig(CONFIG_DURABILITY_LOSS_IN_PVP)))
{
sLog->outStaticDebug("We are dead, losing %f percent durability",
sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH));
pVictim->ToPlayer()->DurabilityLossAll(
sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH), false);
// durability lost message
WorldPacket data(SMSG_DURABILITY_DAMAGE_DEATH, 0);
pVictim->ToPlayer()->GetSession()->SendPacket(&data);
}
// Call KilledUnit for creatures
if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->IsAIEnabled) this->ToCreature()->AI()->KilledUnit(
pVictim);
// last damage from non duel opponent or opponent controlled creature
if (pVictim->ToPlayer()->duel)
{
pVictim->ToPlayer()->duel->opponent->CombatStopWithPets(true);
pVictim->ToPlayer()->CombatStopWithPets(true);
pVictim->ToPlayer()->DuelComplete(DUEL_INTERRUPTED);
}
}
else // creature died
{
sLog->outStaticDebug("DealDamageNotPlayer");
if (!creature->isPet())
{
creature->DeleteThreatList();
CreatureInfo const* cInfo = creature->GetCreatureInfo();
if (cInfo && (cInfo->lootid || cInfo->maxgold > 0)) creature->SetFlag(
UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
}
// Call KilledUnit for creatures, this needs to be called after the lootable flag is set
if (GetTypeId() == TYPEID_UNIT && this->ToCreature()->IsAIEnabled) this->ToCreature()->AI()->KilledUnit(
pVictim);
// Call creature just died function
if (creature->IsAIEnabled) creature->AI()->JustDied(this);
if (creature->ToTempSummon())
{
if (Unit* pSummoner = creature->ToTempSummon()->GetSummoner())
{
if (pSummoner->ToCreature()
&& pSummoner->ToCreature()->IsAIEnabled) pSummoner->ToCreature()->AI()->SummonedCreatureDies(
creature, this);
}
}
// Dungeon specific stuff, only applies to players killing creatures
if (creature->GetInstanceId())
{
Map *m = creature->GetMap();
Player *creditedPlayer = GetCharmerOrOwnerPlayerOrPlayerItself();
// TODO: do instance binding anyway if the charmer/owner is offline
if (m->IsDungeon() && creditedPlayer)
{
if (m->IsRaidOrHeroicDungeon())
{
if (creature->GetCreatureInfo()->flags_extra
& CREATURE_FLAG_EXTRA_INSTANCE_BIND) ((InstanceMap *) m)->PermBindAllPlayers(
creditedPlayer);
}
else
{
// the reset time is set but not added to the scheduler
// until the players leave the instance
time_t resettime = creature->GetRespawnTimeEx() + 2 * HOUR;
if (InstanceSave * save = sInstanceSaveMgr->GetInstanceSave(
creature->GetInstanceId())) if (save->GetResetTime()
< resettime) save->SetResetTime(resettime);
}
}
}
}
// outdoor pvp things, do these after setting the death state, else the player activity notify won't work... doh...
// handle player kill only if not suicide (spirit of redemption for example)
if (player && this != pVictim) if (OutdoorPvP * pvp = player->GetOutdoorPvP()) pvp->HandleKill(
player, pVictim);
//if (pVictim->GetTypeId() == TYPEID_PLAYER)
// if (OutdoorPvP * pvp = pVictim->ToPlayer()->GetOutdoorPvP())
// pvp->HandlePlayerActivityChangedpVictim->ToPlayer();
// battleground things (do this at the end, so the death state flag will be properly set to handle in the bg->handlekill)
if (player && player->InBattleground())
{
if (Battleground *bg = player->GetBattleground())
{
if (pVictim->GetTypeId() == TYPEID_PLAYER) bg->HandleKillPlayer(
(Player*) pVictim, player);
else bg->HandleKillUnit(pVictim->ToCreature(), player);
}
}
// achievement stuff
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
if (GetTypeId() == TYPEID_UNIT) pVictim->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_CREATURE, GetEntry());
else if (GetTypeId() == TYPEID_PLAYER && pVictim != this) pVictim->ToPlayer()->GetAchievementMgr().UpdateAchievementCriteria(
ACHIEVEMENT_CRITERIA_TYPE_KILLED_BY_PLAYER, 1,
this->ToPlayer()->GetTeam());
}
//Hook for OnPVPKill Event
if (this->GetTypeId() == TYPEID_PLAYER)
{
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
Player *killer = this->ToPlayer();
Player *killed = pVictim->ToPlayer();
sScriptMgr->OnPVPKill(killer, killed);
}
else if (pVictim->GetTypeId() == TYPEID_UNIT)
{
Player *killer = this->ToPlayer();
Creature *killed = pVictim->ToCreature();
sScriptMgr->OnCreatureKill(killer, killed);
}
}
else if (this->GetTypeId() == TYPEID_UNIT)
{
if (pVictim->GetTypeId() == TYPEID_PLAYER)
{
Creature *killer = this->ToCreature();
Player *killed = pVictim->ToPlayer();
sScriptMgr->OnPlayerKilledByCreature(killer, killed);
}
}
}
void Unit::SetControlled(bool apply, UnitState state)
{
if (apply)
{
if (HasUnitState(state)) return;
AddUnitState(state);
switch (state)
{
case UNIT_STAT_STUNNED:
SetStunned(true);
CastStop();
break;
case UNIT_STAT_ROOT:
if (!HasUnitState(UNIT_STAT_STUNNED)) SetRooted(true);
break;
case UNIT_STAT_CONFUSED:
if (!HasUnitState(UNIT_STAT_STUNNED))
{
SetConfused(true);
CastStop();
}
break;
case UNIT_STAT_FLEEING:
if (!HasUnitState(UNIT_STAT_STUNNED | UNIT_STAT_CONFUSED))
{
SetFeared(true);
CastStop();
}
break;
default:
break;
}
}
else
{
switch (state)
{
case UNIT_STAT_STUNNED:
if (HasAuraType(SPELL_AURA_MOD_STUN)) return;
else SetStunned(false);
break;
case UNIT_STAT_ROOT:
if (HasAuraType(SPELL_AURA_MOD_ROOT) || GetVehicle()) return;
else SetRooted(false);
break;
case UNIT_STAT_CONFUSED:
if (HasAuraType(SPELL_AURA_MOD_CONFUSE)) return;
else SetConfused(false);
break;
case UNIT_STAT_FLEEING:
if (HasAuraType(SPELL_AURA_MOD_FEAR)) return;
else SetFeared(false);
break;
default:
return;
}
ClearUnitState(state);
if (HasUnitState(UNIT_STAT_STUNNED)) SetStunned(true);
else
{
if (HasUnitState(UNIT_STAT_ROOT)) SetRooted(true);
if (HasUnitState(UNIT_STAT_CONFUSED)) SetConfused(true);
else if (HasUnitState(UNIT_STAT_FLEEING)) SetFeared(true);
}
}
}
void Unit::SetStunned(bool apply)
{
if (apply)
{
SetUInt64Value(UNIT_FIELD_TARGET, 0);
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
CastStop();
// AddUnitMovementFlag(MOVEMENTFLAG_ROOT);
// Creature specific
if (GetTypeId() != TYPEID_PLAYER) this->ToCreature()->StopMoving();
else SetStandState(UNIT_STAND_STATE_STAND);
if (Player * plr = ToPlayer()) plr->SetMovement(MOVE_ROOT);
}
else
{
if (isAlive() && getVictim()) SetUInt64Value(UNIT_FIELD_TARGET,
getVictim()->GetGUID());
// don't remove UNIT_FLAG_STUNNED for pet when owner is mounted (disabled pet's interface)
Unit *pOwner = GetOwner();
if (!pOwner
|| (pOwner->GetTypeId() == TYPEID_PLAYER
&& !pOwner->ToPlayer()->IsMounted())) RemoveFlag(
UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED);
if (!HasUnitState(UNIT_STAT_ROOT)) // prevent allow move if have also root effect
{
if (Player * plr = ToPlayer()) plr->SetMovement(MOVE_UNROOT);
}
}
}
void Unit::SetRooted(bool apply)
{
if (apply)
{
if (m_rootTimes > 0) //blizzard internal check?
m_rootTimes++;
// AddUnitMovementFlag(MOVEMENTFLAG_ROOT);
if (Player *plr = ToPlayer())
{
WorldPacket data(SMSG_FORCE_MOVE_ROOT, 10);
data.append(GetPackGUID());
data << m_rootTimes;
plr->GetSession()->SendPacket(&data);
}
else ToCreature()->StopMoving();
}
else
{
if (!HasUnitState(UNIT_STAT_STUNNED)) // prevent allow move if have also stun effect
{
m_rootTimes++; //blizzard internal check?
if (Player* plr = ToPlayer())
{
WorldPacket data(SMSG_FORCE_MOVE_UNROOT, 10);
data.append(GetPackGUID());
data << m_rootTimes;
plr->GetSession()->SendPacket(&data);
}
}
}
}
void Unit::SetFeared(bool apply)
{
if (apply)
{
SetUInt64Value(UNIT_FIELD_TARGET, 0);
Unit *caster = NULL;
Unit::AuraEffectList const& fearAuras = GetAuraEffectsByType(
SPELL_AURA_MOD_FEAR);
if (!fearAuras.empty()) caster = ObjectAccessor::GetUnit(*this,
fearAuras.front()->GetCasterGUID());
if (!caster) caster = getAttackerForHelper();
GetMotionMaster()->MoveFleeing(
caster,
fearAuras.empty() ?
sWorld->getIntConfig(
CONFIG_CREATURE_FAMILY_FLEE_DELAY) :
0); // caster == NULL processed in MoveFleeing
}
else
{
if (isAlive())
{
if (GetMotionMaster()->GetCurrentMovementGeneratorType()
== FLEEING_MOTION_TYPE) GetMotionMaster()->MovementExpired();
if (getVictim()) SetUInt64Value(UNIT_FIELD_TARGET,
getVictim()->GetGUID());
}
}
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->SetClientControl(this,
!apply);
}
void Unit::SetConfused(bool apply)
{
if (apply)
{
SetUInt64Value(UNIT_FIELD_TARGET, 0);
GetMotionMaster()->MoveConfused();
}
else
{
if (isAlive())
{
if (GetMotionMaster()->GetCurrentMovementGeneratorType()
== CONFUSED_MOTION_TYPE) GetMotionMaster()->MovementExpired();
if (getVictim()) SetUInt64Value(UNIT_FIELD_TARGET,
getVictim()->GetGUID());
}
}
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->SetClientControl(this,
!apply);
}
bool Unit::SetCharmedBy(Unit* charmer, CharmType type,
AuraApplication const * aurApp)
{
if (!charmer) return false;
// unmount players when charmed
if (GetTypeId() == TYPEID_PLAYER) Unmount();
ASSERT(type != CHARM_TYPE_POSSESS || charmer->GetTypeId() == TYPEID_PLAYER);
ASSERT((type == CHARM_TYPE_VEHICLE) == IsVehicle());
sLog->outDebug(
LOG_FILTER_UNITS,
"SetCharmedBy: charmer %u (GUID %u), charmed %u (GUID %u), type %u.",
charmer->GetEntry(), charmer->GetGUIDLow(), GetEntry(),
GetGUIDLow(), uint32(type));
if (this == charmer)
{
sLog->outCrash(
"Unit::SetCharmedBy: Unit %u (GUID %u) is trying to charm itself!",
GetEntry(), GetGUIDLow());
return false;
}
//if (HasUnitState(UNIT_STAT_UNATTACKABLE))
// return false;
if (GetTypeId() == TYPEID_PLAYER && this->ToPlayer()->GetTransport())
{
sLog->outCrash(
"Unit::SetCharmedBy: Player on transport is trying to charm %u (GUID %u)",
GetEntry(), GetGUIDLow());
return false;
}
// Already charmed
if (GetCharmerGUID())
{
sLog->outCrash(
"Unit::SetCharmedBy: %u (GUID %u) has already been charmed but %u (GUID %u) is trying to charm it!",
GetEntry(), GetGUIDLow(), charmer->GetEntry(),
charmer->GetGUIDLow());
return false;
}
CastStop();
CombatStop(); //TODO: CombatStop(true) may cause crash (interrupt spells)
DeleteThreatList();
// Charmer stop charming
if (charmer->GetTypeId() == TYPEID_PLAYER)
{
charmer->ToPlayer()->StopCastingCharm();
charmer->ToPlayer()->StopCastingBindSight();
}
// Charmed stop charming
if (GetTypeId() == TYPEID_PLAYER)
{
this->ToPlayer()->StopCastingCharm();
this->ToPlayer()->StopCastingBindSight();
}
// StopCastingCharm may remove a possessed pet?
if (!IsInWorld())
{
sLog->outCrash(
"Unit::SetCharmedBy: %u (GUID %u) is not in world but %u (GUID %u) is trying to charm it!",
GetEntry(), GetGUIDLow(), charmer->GetEntry(),
charmer->GetGUIDLow());
return false;
}
// charm is set by aura, and aura effect remove handler was called during apply handler execution
// prevent undefined behaviour
if (aurApp && aurApp->GetRemoveMode()) return false;
// Set charmed
Map* pMap = GetMap();
if (!IsVehicle() || (IsVehicle() && pMap && !pMap->IsBattleground())) setFaction(
charmer->getFaction());
charmer->SetCharm(this, true);
if (GetTypeId() == TYPEID_UNIT)
{
this->ToCreature()->AI()->OnCharmed(true);
GetMotionMaster()->MoveIdle();
}
else
{
if (this->ToPlayer()->isAFK()) this->ToPlayer()->ToggleAFK();
this->ToPlayer()->SetClientControl(this, 0);
}
// charm is set by aura, and aura effect remove handler was called during apply handler execution
// prevent undefined behaviour
if (aurApp && aurApp->GetRemoveMode()) return false;
// Pets already have a properly initialized CharmInfo, don't overwrite it.
if (type != CHARM_TYPE_VEHICLE && !GetCharmInfo())
{
CharmInfo *charmInfo = InitCharmInfo();
if (type == CHARM_TYPE_POSSESS) charmInfo->InitPossessCreateSpells();
else charmInfo->InitCharmCreateSpells();
}
if (charmer->GetTypeId() == TYPEID_PLAYER)
{
switch (type)
{
case CHARM_TYPE_VEHICLE:
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
charmer->ToPlayer()->SetClientControl(this, 1);
charmer->ToPlayer()->SetViewpoint(this, true);
charmer->ToPlayer()->VehicleSpellInitialize();
break;
case CHARM_TYPE_POSSESS:
AddUnitState(UNIT_STAT_POSSESSED);
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
charmer->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
charmer->ToPlayer()->SetClientControl(this, 1);
charmer->ToPlayer()->SetViewpoint(this, true);
charmer->ToPlayer()->PossessSpellInitialize();
break;
case CHARM_TYPE_CHARM:
if (GetTypeId() == TYPEID_UNIT
&& charmer->getClass() == CLASS_WARLOCK)
{
CreatureInfo const *cinfo =
this->ToCreature()->GetCreatureInfo();
if (cinfo && cinfo->type == CREATURE_TYPE_DEMON)
{
//to prevent client crash
SetByteValue(UNIT_FIELD_BYTES_0, 1, (uint8) CLASS_MAGE);
//just to enable stat window
if (GetCharmInfo()) GetCharmInfo()->SetPetNumber(
sObjectMgr->GeneratePetNumber(), true);
//if charmed two demons the same session, the 2nd gets the 1st one's name
SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP,
uint32(time(NULL))); // cast can't be helped
}
}
charmer->ToPlayer()->CharmSpellInitialize();
break;
default:
case CHARM_TYPE_CONVERT:
break;
}
}
return true;
}
void Unit::RemoveCharmedBy(Unit *charmer)
{
if (!isCharmed()) return;
if (!charmer) charmer = GetCharmer();
if (charmer != GetCharmer()) // one aura overrides another?
{
// sLog->outCrash("Unit::RemoveCharmedBy: this: " UI64FMTD " true charmer: " UI64FMTD " false charmer: " UI64FMTD,
// GetGUID(), GetCharmerGUID(), charmer->GetGUID());
// ASSERT(false);
return;
}
CharmType type;
if (HasUnitState(UNIT_STAT_POSSESSED)) type = CHARM_TYPE_POSSESS;
else if (charmer->IsOnVehicle(this)) type = CHARM_TYPE_VEHICLE;
else type = CHARM_TYPE_CHARM;
CastStop();
CombatStop(); //TODO: CombatStop(true) may cause crash (interrupt spells)
getHostileRefManager().deleteReferences();
DeleteThreatList();
Map* pMap = GetMap();
if (!IsVehicle() || (IsVehicle() && pMap && !pMap->IsBattleground())) RestoreFaction();
GetMotionMaster()->InitDefault();
if (type == CHARM_TYPE_POSSESS)
{
ClearUnitState(UNIT_STAT_POSSESSED);
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
}
if (GetTypeId() == TYPEID_UNIT)
{
this->ToCreature()->AI()->OnCharmed(false);
if (type != CHARM_TYPE_VEHICLE) //Vehicles' AI is never modified
{
this->ToCreature()->AIM_Initialize();
if (this->ToCreature()->AI() && charmer && charmer->isAlive()) this->ToCreature()->AI()->AttackStart(
charmer);
}
}
else this->ToPlayer()->SetClientControl(this, 1);
// If charmer still exists
if (!charmer) return;
ASSERT(type != CHARM_TYPE_POSSESS || charmer->GetTypeId() == TYPEID_PLAYER);
ASSERT(type != CHARM_TYPE_VEHICLE || (GetTypeId() == TYPEID_UNIT && IsVehicle()));
charmer->SetCharm(this, false);
if (charmer->GetTypeId() == TYPEID_PLAYER)
{
switch (type)
{
case CHARM_TYPE_VEHICLE:
charmer->ToPlayer()->SetClientControl(charmer, 1);
charmer->ToPlayer()->SetViewpoint(this, false);
break;
case CHARM_TYPE_POSSESS:
charmer->ToPlayer()->SetClientControl(charmer, 1);
charmer->ToPlayer()->SetViewpoint(this, false);
charmer->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
break;
case CHARM_TYPE_CHARM:
if (GetTypeId() == TYPEID_UNIT
&& charmer->getClass() == CLASS_WARLOCK)
{
CreatureInfo const *cinfo =
this->ToCreature()->GetCreatureInfo();
if (cinfo && cinfo->type == CREATURE_TYPE_DEMON)
{
SetByteValue(UNIT_FIELD_BYTES_0, 1,
uint8(cinfo->unit_class));
if (GetCharmInfo()) GetCharmInfo()->SetPetNumber(0,
true);
else
sLog->outError(
"Aura::HandleModCharm: target="UI64FMTD" with typeid=%d has a charm aura but no charm info!",
GetGUID(), GetTypeId());
}
}
break;
default:
case CHARM_TYPE_CONVERT:
break;
}
}
//a guardian should always have charminfo
if (charmer->GetTypeId() == TYPEID_PLAYER
&& this != charmer->GetFirstControlled()) charmer->ToPlayer()->SendRemoveControlBar();
else if (GetTypeId() == TYPEID_PLAYER
|| (GetTypeId() == TYPEID_UNIT && !this->ToCreature()->isGuardian())) DeleteCharmInfo();
}
void Unit::RestoreFaction()
{
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->setFactionForRace(
getRace());
else
{
if (HasUnitTypeMask(UNIT_MASK_MINION))
{
if (Unit* owner = GetOwner())
{
setFaction(owner->getFaction());
return;
}
}
if (CreatureInfo const *cinfo = this->ToCreature()->GetCreatureInfo()) // normal creature
{
FactionTemplateEntry const *faction = getFactionTemplateEntry();
setFaction(
(faction && faction->friendlyMask & 0x004) ?
cinfo->faction_H : cinfo->faction_A);
}
}
}
bool Unit::CreateVehicleKit(uint32 id)
{
VehicleEntry const *vehInfo = sVehicleStore.LookupEntry(id);
if (!vehInfo) return false;
m_vehicleKit = new Vehicle(this, vehInfo);
m_updateFlag |= UPDATEFLAG_VEHICLE;
m_unitTypeMask |= UNIT_MASK_VEHICLE;
return true;
}
void Unit::RemoveVehicleKit()
{
if (!m_vehicleKit) return;
m_vehicleKit->Uninstall();
delete m_vehicleKit;
m_vehicleKit = NULL;
m_updateFlag &= ~UPDATEFLAG_VEHICLE;
m_unitTypeMask &= ~UNIT_MASK_VEHICLE;
RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK);
RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_PLAYER_VEHICLE);
}
Unit *Unit::GetVehicleBase() const
{
return m_vehicle ? m_vehicle->GetBase() : NULL;
}
Creature *Unit::GetVehicleCreatureBase() const
{
if (Unit *veh = GetVehicleBase()) if (Creature *c = veh->ToCreature()) return c;
return NULL;
}
uint64 Unit::GetTransGUID() const
{
if (GetVehicle()) return GetVehicle()->GetBase()->GetGUID();
if (GetTransport()) return GetTransport()->GetGUID();
return 0;
}
bool Unit::IsInPartyWith(Unit const *unit) const
{
if (this == unit) return true;
const Unit *u1 = GetCharmerOrOwnerOrSelf();
const Unit *u2 = unit->GetCharmerOrOwnerOrSelf();
if (u1 == u2) return true;
if (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_PLAYER) return u1->ToPlayer()->IsInSameGroupWith(
u2->ToPlayer());
else return false;
}
bool Unit::IsInRaidWith(Unit const *unit) const
{
if (this == unit) return true;
const Unit *u1 = GetCharmerOrOwnerOrSelf();
const Unit *u2 = unit->GetCharmerOrOwnerOrSelf();
if (u1 == u2) return true;
if (u1->GetTypeId() == TYPEID_PLAYER && u2->GetTypeId() == TYPEID_PLAYER) return u1->ToPlayer()->IsInSameRaidWith(
u2->ToPlayer());
else return false;
}
void Unit::GetRaidMember(std::list <Unit*> &nearMembers, float radius)
{
Player *owner = GetCharmerOrOwnerPlayerOrPlayerItself();
if (!owner) return;
Group *pGroup = owner->GetGroup();
if (pGroup)
{
for (GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr =
itr->next())
{
Player* Target = itr->getSource();
if (Target && !IsHostileTo(Target))
{
if (Target->isAlive() && IsWithinDistInMap(Target, radius)) nearMembers.push_back(
Target);
if (Guardian* pet = Target->GetGuardianPet()) if (pet->isAlive()
&& IsWithinDistInMap(pet, radius)) nearMembers.push_back(
pet);
}
}
}
else
{
if (owner->isAlive()
&& (owner == this || IsWithinDistInMap(owner, radius))) nearMembers.push_back(
owner);
if (Guardian* pet = owner->GetGuardianPet()) if (pet->isAlive()
&& (pet == this && IsWithinDistInMap(pet, radius))) nearMembers.push_back(
pet);
}
}
void Unit::GetPartyMemberInDist(std::list <Unit*> &TagUnitMap, float radius)
{
Unit *owner = GetCharmerOrOwnerOrSelf();
Group *pGroup = NULL;
if (owner->GetTypeId() == TYPEID_PLAYER) pGroup =
owner->ToPlayer()->GetGroup();
if (pGroup)
{
uint8 subgroup = owner->ToPlayer()->GetSubGroup();
for (GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr =
itr->next())
{
Player* Target = itr->getSource();
// IsHostileTo check duel and controlled by enemy
if (Target && Target->GetSubGroup() == subgroup
&& !IsHostileTo(Target))
{
if (Target->isAlive() && IsWithinDistInMap(Target, radius)) TagUnitMap.push_back(
Target);
if (Guardian* pet = Target->GetGuardianPet()) if (pet->isAlive()
&& IsWithinDistInMap(pet, radius)) TagUnitMap.push_back(
pet);
}
}
}
else
{
if (owner->isAlive()
&& (owner == this || IsWithinDistInMap(owner, radius))) TagUnitMap.push_back(
owner);
if (Guardian* pet = owner->GetGuardianPet()) if (pet->isAlive()
&& (pet == this && IsWithinDistInMap(pet, radius))) TagUnitMap.push_back(
pet);
}
}
void Unit::GetPartyMembers(std::list <Unit*> &TagUnitMap)
{
Unit *owner = GetCharmerOrOwnerOrSelf();
Group *pGroup = NULL;
if (owner->GetTypeId() == TYPEID_PLAYER) pGroup =
owner->ToPlayer()->GetGroup();
if (pGroup)
{
uint8 subgroup = owner->ToPlayer()->GetSubGroup();
for (GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr =
itr->next())
{
Player* Target = itr->getSource();
// IsHostileTo check duel and controlled by enemy
if (Target && Target->GetSubGroup() == subgroup
&& !IsHostileTo(Target))
{
if (Target->isAlive() && IsInMap(Target)) TagUnitMap.push_back(
Target);
if (Guardian* pet = Target->GetGuardianPet()) if (pet->isAlive()
&& IsInMap(Target)) TagUnitMap.push_back(pet);
}
}
}
else
{
if (owner->isAlive() && (owner == this || IsInMap(owner))) TagUnitMap.push_back(
owner);
if (Guardian* pet = owner->GetGuardianPet()) if (pet->isAlive()
&& (pet == this || IsInMap(pet))) TagUnitMap.push_back(pet);
}
}
Aura * Unit::AddAura(uint32 spellId, Unit *target)
{
if (!target) return NULL;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo) return NULL;
if (!target->isAlive() && !(spellInfo->Attributes & SPELL_ATTR0_PASSIVE)
&& !(spellInfo->AttributesEx2 & SPELL_ATTR2_ALLOW_DEAD_TARGET)) return NULL;
return AddAura(spellInfo, MAX_EFFECT_MASK, target);
}
Aura * Unit::AddAura(SpellEntry const *spellInfo, uint8 effMask, Unit *target)
{
if (!spellInfo) return NULL;
if (target->IsImmunedToSpell(spellInfo)) return NULL;
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (!(effMask & (1 << i))) continue;
if (target->IsImmunedToSpellEffect(spellInfo, i)) effMask &= ~(1 << i);
}
if (Aura * aura = Aura::TryCreate(spellInfo, effMask, target, this))
{
aura->ApplyForTargets();
return aura;
}
return NULL;
}
void Unit::SetAuraStack(uint32 spellId, Unit *target, uint32 stack)
{
Aura *aura = target->GetAura(spellId, GetGUID());
if (!aura) aura = AddAura(spellId, target);
if (aura && stack) aura->SetStackAmount(stack);
}
void Unit::ApplyResilience(const Unit *pVictim, int32 *damage) const
{
if (IsVehicle() || pVictim->IsVehicle()) return;
const Unit *source = ToPlayer();
if (!source)
{
source = ToCreature();
if (source)
{
source = source->ToCreature()->GetOwner();
if (source) source = source->ToPlayer();
}
}
const Unit *target = pVictim->ToPlayer();
if (!target)
{
target = pVictim->ToCreature();
if (target)
{
target = target->ToCreature()->GetOwner();
if (target) target = target->ToPlayer();
}
}
if (!target) return;
if (source && damage)
{
*damage -= target->ToPlayer()->GetPlayerDamageReduction(*damage);
}
}
// Melee based spells can be miss, parry or dodge on this step
// Crit or block - determined on damage calculation phase! (and can be both in some time)
float Unit::MeleeSpellMissChance(const Unit *pVictim, WeaponAttackType attType,
int32 skillDiff, uint32 spellId) const
{
// Calculate hit chance (more correct for chance mod)
int32 HitChance;
// PvP - PvE melee chances
if (spellId || attType == RANGED_ATTACK || !haveOffhandWeapon()) HitChance =
95;
else HitChance = 76;
// Hit chance depends from victim auras
if (attType == RANGED_ATTACK) HitChance += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_RANGED_HIT_CHANCE);
else HitChance += pVictim->GetTotalAuraModifier(
SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE);
// Spellmod from SPELLMOD_RESIST_MISS_CHANCE
if (spellId)
{
if (Player *modOwner = GetSpellModOwner()) modOwner->ApplySpellMod(
spellId, SPELLMOD_RESIST_MISS_CHANCE, HitChance);
}
// Miss = 100 - hit
float miss_chance = 100.0f - HitChance;
// Bonuses from attacker aura and ratings
if (attType == RANGED_ATTACK) miss_chance -= m_modRangedHitChance;
else miss_chance -= m_modMeleeHitChance;
// bonus from skills is 0.04%
//miss_chance -= skillDiff * 0.04f;
int32 diff = -skillDiff;
if (pVictim->GetTypeId() == TYPEID_PLAYER) miss_chance +=
diff > 0 ? diff * 0.04f : diff * 0.02f;
else miss_chance += diff > 10 ? 2 + (diff - 10) * 0.4f : diff * 0.1f;
// Limit miss chance from 0 to 60%
if (miss_chance < 0.0f) return 0.0f;
if (miss_chance > 60.0f) return 60.0f;
return miss_chance;
}
void Unit::SetPhaseMask(uint32 newPhaseMask, bool update)
{
if (newPhaseMask == GetPhaseMask()) return;
if (IsInWorld()) RemoveNotOwnSingleTargetAuras(newPhaseMask); // we can lost access to caster or target
WorldObject::SetPhaseMask(newPhaseMask, update);
if (!IsInWorld()) return;
for (ControlList::const_iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
if ((*itr)->GetTypeId() == TYPEID_UNIT) (*itr)->SetPhaseMask(
newPhaseMask, true);
for (uint8 i = 0; i < MAX_SUMMON_SLOT; ++i)
if (m_SummonSlot [i]) if (Creature *summon = GetMap()->GetCreature(m_SummonSlot[i])) summon->SetPhaseMask(
newPhaseMask, true);
}
void Unit::UpdateObjectVisibility(bool forced)
{
if (!forced) AddToNotify(NOTIFY_VISIBILITY_CHANGED);
else
{
WorldObject::UpdateObjectVisibility(true);
// call MoveInLineOfSight for nearby creatures
Trinity::AIRelocationNotifier notifier(*this);
VisitNearbyObject(GetVisibilityRange(), notifier);
}
}
void Unit::KnockbackFrom(float x, float y, float speedXY, float speedZ)
{
Player *player = NULL;
if (GetTypeId() == TYPEID_PLAYER) player = (Player*) this;
else
{
player = dynamic_cast <Player*>(GetCharmer());
if (player && player->m_mover != this) player = NULL;
}
if (!player)
{
GetMotionMaster()->MoveKnockbackFrom(x, y, speedXY, speedZ);
}
else
{
float vcos, vsin;
GetSinCos(x, y, vsin, vcos);
WorldPacket data(SMSG_MULTIPLE_PACKETS, (2 + 8 + 4 + 4 + 4 + 4 + 4));
//WorldPacket data(/*SMSG_MOVE_KNOCK_BACK*/, (8+4+4+4+4+4));
data << uint16(SMSG_MOVE_KNOCK_BACK);
data.append(GetPackGUID());
data << uint32(0); // Sequence
data << float(vcos); // x direction
data << float(vsin); // y direction
data << float(speedXY); // Horizontal speed
data << float(-speedZ); // Z Movement speed (vertical)
player->GetSession()->SendPacket(&data);
}
}
float Unit::GetCombatRatingReduction(CombatRating cr) const
{
if (GetTypeId() == TYPEID_PLAYER) return ((Player const*) this)->GetRatingBonusValue(
cr);
else if (((Creature const*) this)->isPet())
{
// Player's pet get resilience from owner
if (Unit* owner = GetOwner()) if (owner->GetTypeId() == TYPEID_PLAYER) return ((Player*) owner)->GetRatingBonusValue(
cr);
}
return 0.0f;
}
uint32 Unit::GetCombatRatingDamageReduction(CombatRating cr, float rate,
float cap, uint32 damage) const
{
float percent = GetCombatRatingReduction(cr) * rate;
if (percent > cap) percent = cap;
return uint32(percent * damage / 100.0f);
}
uint32 Unit::GetModelForForm(ShapeshiftForm form)
{
switch (form)
{
case FORM_CAT:
// Based on Hair color
if (getRace() == RACE_NIGHTELF)
{
uint8 hairColor = GetByteValue(PLAYER_BYTES, 3);
switch (hairColor)
{
case 7: // Violet
case 8:
return 29405;
case 3: // Light Blue
return 29406;
case 0: // Green
case 1: // Light Green
case 2: // Dark Green
return 29407;
case 4: // White
return 29408;
default: // original - Dark Blue
return 892;
}
}
else if (getRace() == RACE_TROLL)
{
uint8 hairColor = GetByteValue(PLAYER_BYTES, 3);
switch (hairColor)
{
case 0: // Red
case 1:
return 33668;
case 2: // Yellow
case 3:
return 33667;
case 4: // Blue
case 5:
case 6:
return 33666;
case 7: // Purple
case 10:
return 33665;
default: // original - white
return 33669;
}
}
else if (getRace() == RACE_WORGEN)
{
// Based on Skin color
uint8 skinColor = GetByteValue(PLAYER_BYTES, 0);
// Male
if (getGender() == GENDER_MALE)
{
switch (skinColor)
{
case 1: // Brown
return 33662;
case 2: // Black
case 7:
return 33661;
case 4: // yellow
return 33664;
case 3: // White
case 5:
return 33663;
default: // original - Gray
return 33660;
}
}
// Female
else
{
switch (skinColor)
{
case 5: // Brown
case 6:
return 33662;
case 7: // Black
case 8:
return 33661;
case 3: // yellow
case 4:
return 33664;
case 2: // White
return 33663;
default: // original - Gray
return 33660;
}
}
}
// Based on Skin color
else if (getRace() == RACE_TAUREN)
{
uint8 skinColor = GetByteValue(PLAYER_BYTES, 0);
// Male
if (getGender() == GENDER_MALE)
{
switch (skinColor)
{
case 12: // White
case 13:
case 14:
case 18: // Completly White
return 29409;
case 9: // Light Brown
case 10:
case 11:
return 29410;
case 6: // Brown
case 7:
case 8:
return 29411;
case 0: // Dark
case 1:
case 2:
case 3: // Dark Grey
case 4:
case 5:
return 29412;
default: // original - Grey
return 8571;
}
}
// Female
else
{
switch (skinColor)
{
case 10: // White
return 29409;
case 6: // Light Brown
case 7:
return 29410;
case 4: // Brown
case 5:
return 29411;
case 0: // Dark
case 1:
case 2:
case 3:
return 29412;
default: // original - Grey
return 8571;
}
}
}
else if (Player::TeamForRace(getRace()) == ALLIANCE) return 892;
else return 8571;
case FORM_DIREBEAR:
case FORM_BEAR:
// Based on Hair color
if (getRace() == RACE_NIGHTELF)
{
uint8 hairColor = GetByteValue(PLAYER_BYTES, 3);
switch (hairColor)
{
case 0: // Green
case 1: // Light Green
case 2: // Dark Green
return 29413; // 29415?
case 6: // Dark Blue
return 29414;
case 4: // White
return 29416;
case 3: // Light Blue
return 29417;
default: // original - Violet
return 2281;
}
}
else if (getRace() == RACE_TROLL)
{
uint8 hairColor = GetByteValue(PLAYER_BYTES, 3);
switch (hairColor)
{
case 0: // Red
case 1:
return 33657;
case 2: // Yellow
case 3:
return 33659;
case 7: // Purple
case 10:
return 33656;
case 8: // White
case 9:
case 11:
case 12:
return 33658;
default: // original - Blue
return 33655;
}
}
else if (getRace() == RACE_WORGEN)
{
// Based on Skin color
uint8 skinColor = GetByteValue(PLAYER_BYTES, 0);
// Male
if (getGender() == GENDER_MALE)
{
switch (skinColor)
{
case 1: // Brown
return 33652;
case 2: // Black
case 7:
return 33651;
case 4: // Yellow
return 33653;
case 3: // White
case 5:
return 33654;
default: // original - Gray
return 33650;
}
}
// Female
else
{
switch (skinColor)
{
case 5: // Brown
case 6:
return 33652;
case 7: // Black
case 8:
return 33651;
case 3: // yellow
case 4:
return 33654;
case 2: // White
return 33653;
default: // original - Gray
return 33650;
}
}
}
// Based on Skin color
else if (getRace() == RACE_TAUREN)
{
uint8 skinColor = GetByteValue(PLAYER_BYTES, 0);
// Male
if (getGender() == GENDER_MALE)
{
switch (skinColor)
{
case 0: // Dark (Black)
case 1:
case 2:
return 29418;
case 3: // White
case 4:
case 5:
case 12:
case 13:
case 14:
return 29419;
case 9: // Light Brown/Grey
case 10:
case 11:
case 15:
case 16:
case 17:
return 29420;
case 18: // Completly White
return 29421;
default: // original - Brown
return 2289;
}
}
// Female
else
{
switch (skinColor)
{
case 0: // Dark (Black)
case 1:
return 29418;
case 2: // White
case 3:
return 29419;
case 6: // Light Brown/Grey
case 7:
case 8:
case 9:
return 29420;
case 10: // Completly White
return 29421;
default: // original - Brown
return 2289;
}
}
}
else if (Player::TeamForRace(getRace()) == ALLIANCE) return 2281;
else return 2289;
case FORM_FLIGHT:
switch (getRace())
{
case RACE_NIGHTELF:
return 20857;
case RACE_WORGEN:
return 37727;
case RACE_TROLL:
return 37728;
default: // RACE_TAUREN
return 20872;
}
case FORM_FLIGHT_EPIC:
switch (getRace())
{
case RACE_NIGHTELF:
return 21243;
case RACE_WORGEN:
return 37729;
case RACE_TROLL:
return 37730;
default: // RACE_TAUREN
return 21244;
}
default:
{
uint32 modelid = 0;
SpellShapeshiftFormEntry const* formEntry =
sSpellShapeshiftFormStore.LookupEntry(form);
if (formEntry && formEntry->modelID_A)
{
// Take the alliance modelid as default
if (GetTypeId() != TYPEID_PLAYER) return formEntry->modelID_A;
else
{
if (Player::TeamForRace(getRace()) == ALLIANCE) modelid =
formEntry->modelID_A;
else modelid = formEntry->modelID_H;
// If the player is horde but there are no values for the horde modelid - take the alliance modelid
if (!modelid && Player::TeamForRace(getRace()) == HORDE) modelid =
formEntry->modelID_A;
}
}
return modelid;
}
}
return 0;
}
uint32 Unit::GetModelForTotem(PlayerTotemType totemType)
{
switch (getRace())
{
case RACE_ORC:
{
switch (totemType)
{
case SUMMON_TYPE_TOTEM_FIRE: //fire
return 30758;
case SUMMON_TYPE_TOTEM_EARTH: //earth
return 30757;
case SUMMON_TYPE_TOTEM_WATER: //water
return 30759;
case SUMMON_TYPE_TOTEM_AIR: //air
return 30756;
}
break;
}
case RACE_DWARF:
{
switch (totemType)
{
case SUMMON_TYPE_TOTEM_FIRE: //fire
return 30754;
case SUMMON_TYPE_TOTEM_EARTH: //earth
return 30753;
case SUMMON_TYPE_TOTEM_WATER: //water
return 30755;
case SUMMON_TYPE_TOTEM_AIR: //air
return 30736;
}
break;
}
case RACE_TROLL:
{
switch (totemType)
{
case SUMMON_TYPE_TOTEM_FIRE: //fire
return 30762;
case SUMMON_TYPE_TOTEM_EARTH: //earth
return 30761;
case SUMMON_TYPE_TOTEM_WATER: //water
return 30763;
case SUMMON_TYPE_TOTEM_AIR: //air
return 30760;
}
break;
}
case RACE_TAUREN:
{
switch (totemType)
{
case SUMMON_TYPE_TOTEM_FIRE: //fire
return 4589;
case SUMMON_TYPE_TOTEM_EARTH: //earth
return 4588;
case SUMMON_TYPE_TOTEM_WATER: //water
return 4587;
case SUMMON_TYPE_TOTEM_AIR: //air
return 4590;
}
break;
}
case RACE_DRAENEI:
{
switch (totemType)
{
case SUMMON_TYPE_TOTEM_FIRE: //fire
return 19074;
case SUMMON_TYPE_TOTEM_EARTH: //earth
return 19073;
case SUMMON_TYPE_TOTEM_WATER: //water
return 19075;
case SUMMON_TYPE_TOTEM_AIR: //air
return 19071;
}
break;
}
case RACE_GOBLIN:
{
switch (totemType)
{
case SUMMON_TYPE_TOTEM_FIRE: //fire
return 30783;
case SUMMON_TYPE_TOTEM_EARTH: //earth
return 30782;
case SUMMON_TYPE_TOTEM_WATER: //water
return 30784;
case SUMMON_TYPE_TOTEM_AIR: //air
return 30781;
}
break;
}
}
return 0;
}
void Unit::JumpTo(float speedXY, float speedZ, bool forward)
{
float angle = forward ? 0 : M_PI;
if (GetTypeId() == TYPEID_UNIT) GetMotionMaster()->MoveJumpTo(angle,
speedXY, speedZ);
else
{
float vcos = cos(angle + GetOrientation());
float vsin = sin(angle + GetOrientation());
WorldPacket data(SMSG_MULTIPLE_PACKETS, (2 + 8 + 4 + 4 + 4 + 4 + 4));
//WorldPacket data(SMSG_MOVE_KNOCK_BACK, (8+4+4+4+4+4));
data << uint16(SMSG_MOVE_KNOCK_BACK);
data.append(GetPackGUID());
data << uint32(0); // Sequence
data << float(vcos); // x direction
data << float(vsin); // y direction
data << float(speedXY); // Horizontal speed
data << float(-speedZ); // Z Movement speed (vertical)
this->ToPlayer()->GetSession()->SendPacket(&data);
}
}
void Unit::JumpTo(WorldObject *obj, float speedZ)
{
float x, y, z;
obj->GetContactPoint(this, x, y, z);
float speedXY = GetExactDist2d(x, y) * 10.0f / speedZ;
GetMotionMaster()->MoveJump(x, y, z, speedXY, speedZ);
}
bool Unit::CheckPlayerCondition(Player* pPlayer)
{
switch (GetEntry())
{
case 35644: //Argent Warhorse
case 36558: //Argent Battleworg
if (!pPlayer->HasItemOrGemWithIdEquipped(46106, 1)) //Check item Argent Lance
return false;
default:
return true;
}
}
void Unit::EnterVehicle(Vehicle *vehicle, int8 seatId, bool byAura)
{
if (!isAlive() || GetVehicleKit() == vehicle) return;
if (m_vehicle)
{
if (m_vehicle == vehicle)
{
if (seatId >= 0 && seatId != GetTransSeat())
{
sLog->outDebug(
LOG_FILTER_UNITS,
"EnterVehicle: %u leave vehicle %u seat %d and enter %d.",
GetEntry(), m_vehicle->GetBase()->GetEntry(),
GetTransSeat(), seatId);
ChangeSeat(seatId, byAura);
}
return;
}
else
{
sLog->outDebug(LOG_FILTER_UNITS,
"EnterVehicle: %u exit %u and enter %u.", GetEntry(),
m_vehicle->GetBase()->GetEntry(),
vehicle->GetBase()->GetEntry());
ExitVehicle();
}
}
if (Player* plr = ToPlayer())
{
if (vehicle->GetBase()->GetTypeId() == TYPEID_PLAYER
&& plr->isInCombat()) return;
InterruptNonMeleeSpells(false);
plr->StopCastingCharm();
plr->StopCastingBindSight();
Unmount();
RemoveAurasByType(SPELL_AURA_MOUNTED);
// drop flag at invisible in bg
if (Battleground *bg = plr->GetBattleground()) bg->EventPlayerDroppedFlag(
plr);
}
ASSERT(!m_vehicle);
m_vehicle = vehicle;
if (!m_vehicle->AddPassenger(this, seatId, byAura))
{
m_vehicle = NULL;
return;
}
if (Player* thisPlr = this->ToPlayer())
{
WorldPacket data(SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA, 0);
thisPlr->GetSession()->SendPacket(&data);
thisPlr->SendClearFocus(vehicle->GetBase());
}
SetControlled(true, UNIT_STAT_ROOT);
//movementInfo is set in AddPassenger
//packets are sent in AddPassenger
}
void Unit::ChangeSeat(int8 seatId, bool next, bool byAura)
{
if (!m_vehicle) return;
if (seatId < 0)
{
seatId = m_vehicle->GetNextEmptySeat(GetTransSeat(), next, byAura);
if (seatId < 0) return;
}
else if (seatId == GetTransSeat() || !m_vehicle->HasEmptySeat(seatId)) return;
m_vehicle->RemovePassenger(this);
if (!m_vehicle->AddPassenger(this, seatId, byAura))
ASSERT(false);
}
void Unit::ExitVehicle()
{
if (!m_vehicle) return;
Unit *vehicleBase = m_vehicle->GetBase();
const AuraEffectList &modAuras = vehicleBase->GetAuraEffectsByType(
SPELL_AURA_CONTROL_VEHICLE);
for (AuraEffectList::const_iterator itr = modAuras.begin();
itr != modAuras.end(); ++itr)
{
if ((*itr)->GetBase()->GetOwner() == this)
{
vehicleBase->RemoveAura((*itr)->GetBase());
break; // there should be no case that a vehicle has two auras for one owner
}
}
if (!m_vehicle) return;
//sLog->outError("exit vehicle");
m_vehicle->RemovePassenger(this);
// This should be done before dismiss, because there may be some aura removal
Vehicle *vehicle = m_vehicle;
m_vehicle = NULL;
SetControlled(false, UNIT_STAT_ROOT);
RemoveUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT | MOVEMENTFLAG_ROOT);
m_movementInfo.t_pos.Relocate(0, 0, 0, 0);
m_movementInfo.t_time = 0;
m_movementInfo.t_seat = 0;
Relocate(vehicle->GetBase());
//Send leave vehicle, not correct
if (GetTypeId() == TYPEID_PLAYER)
{
//this->ToPlayer()->SetClientControl(this, 1);
this->ToPlayer()->SendTeleportAckPacket();
this->ToPlayer()->SetFallInformation(0, GetPositionZ());
}
WorldPacket data;
BuildHeartBeatMsg(&data);
SendMessageToSet(&data, false);
if (vehicle->GetBase()->HasUnitTypeMask(UNIT_MASK_MINION)) if (((Minion*) vehicle->GetBase())->GetOwner()
== this) vehicle->Dismiss();
}
void Unit::BuildMovementPacket(ByteBuffer *data) const
{
switch (GetTypeId())
{
case TYPEID_UNIT:
if (canFly()) const_cast <Unit*>(this)->AddUnitMovementFlag(
MOVEMENTFLAG_LEVITATING);
if (IsVehicle()) const_cast <Unit*>(this)->AddExtraUnitMovementFlag(
GetVehicleKit()->GetExtraMovementFlagsForBase());
break;
case TYPEID_PLAYER:
// remove unknown, unused etc flags for now
const_cast <Unit*>(this)->RemoveUnitMovementFlag(
MOVEMENTFLAG_SPLINE_ENABLED);
if (isInFlight())
{
WPAssert(
const_cast<Unit*>(this)->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE);
const_cast <Unit*>(this)->AddUnitMovementFlag(
MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_SPLINE_ENABLED);
}
break;
default:
break;
}
if (Vehicle* pVehicle = GetVehicle()) if (!HasUnitMovementFlag(
MOVEMENTFLAG_ROOT))
sLog->outError(
"Unit (GUID: " UI64FMTD ", entry: %u) does not have MOVEMENTFLAG_ROOT but is in vehicle (ID: %u)!",
GetGUID(), GetEntry(), pVehicle->GetVehicleInfo()->m_ID);
*data << uint32(GetUnitMovementFlags()); // movement flags
*data << uint16(m_movementInfo.flags2); // 2.3.0
*data << uint32(getMSTime()); // time
*data << GetPositionX();
*data << GetPositionY();
*data << GetPositionZ();
*data << GetOrientation();
// 0x00000200
if (GetUnitMovementFlags() & MOVEMENTFLAG_ONTRANSPORT)
{
if (m_vehicle) data->append(m_vehicle->GetBase()->GetPackGUID());
else if (GetTransport()) data->append(GetTransport()->GetPackGUID());
else *data << (uint8) 0;
*data << float(GetTransOffsetX());
*data << float(GetTransOffsetY());
*data << float(GetTransOffsetZ());
*data << float(GetTransOffsetO());
*data << uint32(GetTransTime());
*data << uint8(GetTransSeat());
if (m_movementInfo.flags2 & MOVEMENTFLAG2_INTERPOLATED_MOVEMENT) // & 0x400, 4.0.3
*data << uint32(m_movementInfo.t_time2);
}
// 0x02200000
if ((GetUnitMovementFlags() & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_FLYING))
|| (m_movementInfo.flags2 & MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING)) *data
<< (float) m_movementInfo.pitch;
//4.0.6
if (m_movementInfo.flags2 & MOVEMENTFLAG2_INTERPOLATED_TURNING) // & 0x800, 4.0.6
{
*data << (uint32) m_movementInfo.fallTime;
*data << (float) m_movementInfo.j_zspeed;
// 0x00001000
if (GetUnitMovementFlags() & MOVEMENTFLAG_JUMPING)
{
*data << (float) m_movementInfo.j_sinAngle;
*data << (float) m_movementInfo.j_cosAngle;
*data << (float) m_movementInfo.j_xyspeed;
}
}
// 0x04000000
if (GetUnitMovementFlags() & MOVEMENTFLAG_SPLINE_ELEVATION) *data
<< (float) m_movementInfo.splineElevation;
}
void Unit::SetFlying(bool apply)
{
if (apply)
{
SetByteFlag(UNIT_FIELD_BYTES_1, 3, 0x02);
AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_FLYING);
}
else
{
RemoveByteFlag(UNIT_FIELD_BYTES_1, 3, 0x02);
RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_FLYING);
}
}
void Unit::NearTeleportTo(float x, float y, float z, float orientation,
bool casting /*= false*/)
{
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->TeleportTo(
GetMapId(),
x,
y,
z,
orientation,
TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_LEAVE_COMBAT
| TELE_TO_NOT_UNSUMMON_PET | (casting ? TELE_TO_SPELL : 0));
else
{
// FIXME: this interrupts spell visual
DestroyForNearbyPlayers();
SetPosition(x, y, z, orientation, true);
}
}
bool Unit::SetPosition(float x, float y, float z, float orientation,
bool teleport)
{
// prevent crash when a bad coord is sent by the client
if (!Trinity::IsValidMapCoord(x, y, z, orientation))
{
sLog->outDebug(LOG_FILTER_UNITS,
"Unit::SetPosition(%f, %f, %f) .. bad coordinates!", x, y, z);
return false;
}
bool turn = (GetOrientation() != orientation);
bool relocated = (teleport || GetPositionX() != x || GetPositionY() != y
|| GetPositionZ() != z);
if (turn) RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TURNING);
if (relocated)
{
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MOVE);
// move and update visible state if need
if (GetTypeId() == TYPEID_PLAYER) GetMap()->PlayerRelocation(
(Player*) this, x, y, z, orientation);
else GetMap()->CreatureRelocation(this->ToCreature(), x, y, z,
orientation);
}
else if (turn) SetOrientation(orientation);
if ((relocated || turn) && IsVehicle()) GetVehicleKit()->RelocatePassengers(
x, y, z, orientation);
return (relocated || turn);
}
bool Unit::UpdatePosition(float x, float y, float z, float orientation,
bool teleport)
{
// prevent crash when a bad coord is sent by the client
if (!Trinity::IsValidMapCoord(x, y, z, orientation))
{
sLog->outDebug(LOG_FILTER_UNITS,
"Unit::UpdatePosition(%f, %f, %f) .. bad coordinates!", x, y,
z);
return false;
}
bool turn = (GetOrientation() != orientation);
bool relocated = (teleport || GetPositionX() != x || GetPositionY() != y
|| GetPositionZ() != z);
if (turn) RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TURNING);
if (relocated)
{
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_MOVE);
// move and update visible state if need
if (GetTypeId() == TYPEID_PLAYER) GetMap()->PlayerRelocation(ToPlayer(),
x, y, z, orientation);
else GetMap()->CreatureRelocation(ToCreature(), x, y, z, orientation);
}
else if (turn) SetOrientation(orientation);
if ((relocated || turn) && IsVehicle()) GetVehicleKit()->RelocatePassengers(
x, y, z, orientation);
return (relocated || turn);
}
void Unit::SendThreatListUpdate()
{
if (uint32 count = getThreatManager().getThreatList().size())
{
//sLog->outDebug(LOG_FILTER_UNITS, "WORLD: Send SMSG_THREAT_UPDATE Message");
WorldPacket data(SMSG_THREAT_UPDATE, 8 + count * 8);
data.append(GetPackGUID());
data << uint32(count);
std::list <HostileReference*>& tlist =
getThreatManager().getThreatList();
for (std::list <HostileReference*>::const_iterator itr = tlist.begin();
itr != tlist.end(); ++itr)
{
data.appendPackGUID((*itr)->getUnitGuid());
data << uint32((*itr)->getThreat() * 100);
}
SendMessageToSet(&data, false);
}
}
void Unit::SendChangeCurrentVictimOpcode(HostileReference* pHostileReference)
{
if (uint32 count = getThreatManager().getThreatList().size())
{
sLog->outDebug(LOG_FILTER_UNITS,
"WORLD: Send SMSG_HIGHEST_THREAT_UPDATE Message");
WorldPacket data(SMSG_HIGHEST_THREAT_UPDATE, 8 + 8 + count * 8);
data.append(GetPackGUID());
data.appendPackGUID(pHostileReference->getUnitGuid());
data << uint32(count);
std::list <HostileReference*>& tlist =
getThreatManager().getThreatList();
for (std::list <HostileReference*>::const_iterator itr = tlist.begin();
itr != tlist.end(); ++itr)
{
data.appendPackGUID((*itr)->getUnitGuid());
data << uint32((*itr)->getThreat());
}
SendMessageToSet(&data, false);
}
}
void Unit::SendClearThreatListOpcode()
{
sLog->outDebug(LOG_FILTER_UNITS, "WORLD: Send SMSG_THREAT_CLEAR Message");
WorldPacket data(SMSG_THREAT_CLEAR, 8);
data.append(GetPackGUID());
SendMessageToSet(&data, false);
}
void Unit::SendRemoveFromThreatListOpcode(HostileReference* pHostileReference)
{
sLog->outDebug(LOG_FILTER_UNITS, "WORLD: Send SMSG_THREAT_REMOVE Message");
WorldPacket data(SMSG_THREAT_REMOVE, 8 + 8);
data.append(GetPackGUID());
data.appendPackGUID(pHostileReference->getUnitGuid());
SendMessageToSet(&data, false);
}
void Unit::RewardRage(uint32 damage, uint32 weaponSpeedHitFactor, bool attacker)
{
float addRage;
float rageconversion = ((0.0091107836f * getLevel() * getLevel())
+ 3.225598133f * getLevel()) + 4.2652911f;
// Unknown if correct, but lineary adjust rage conversion above level 70
if (getLevel() > 70) rageconversion += 13.27f * (getLevel() - 70);
if (attacker)
{
addRage = ((damage / rageconversion * 7.5f + weaponSpeedHitFactor) / 2);
// talent who gave more rage on attack
addRage *= 1.0f
+ GetTotalAuraModifier(SPELL_AURA_MOD_RAGE_FROM_DAMAGE_DEALT)
/ 100.0f;
}
else
{
addRage = damage / rageconversion * 2.5f;
// Berserker Rage effect
if (HasAura(18499)) addRage *= 2.0f;
}
addRage *= sWorld->getRate(RATE_POWER_RAGE_INCOME);
ModifyPower(POWER_RAGE, uint32(addRage * 10));
}
void Unit::StopAttackFaction(uint32 faction_id)
{
if (Unit* victim = getVictim())
{
if (victim->getFactionTemplateEntry()->faction == faction_id)
{
AttackStop();
if (IsNonMeleeSpellCasted(false)) InterruptNonMeleeSpells(false);
// melee and ranged forced attack cancel
if (GetTypeId() == TYPEID_PLAYER) this->ToPlayer()->SendAttackSwingCancelAttack();
}
}
AttackerSet const& attackers = getAttackers();
for (AttackerSet::const_iterator itr = attackers.begin();
itr != attackers.end();)
{
if ((*itr)->getFactionTemplateEntry()->faction == faction_id)
{
(*itr)->AttackStop();
itr = attackers.begin();
}
else ++itr;
}
getHostileRefManager().deleteReferencesForFaction(faction_id);
for (ControlList::const_iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
(*itr)->StopAttackFaction(faction_id);
}
void Unit::OutDebugInfo() const
{
sLog->outError("Unit::OutDebugInfo");
sLog->outString("GUID "UI64FMTD", entry %u, type %u, name %s", GetGUID(),
GetEntry(), (uint32) GetTypeId(), GetName());
sLog->outString(
"OwnerGUID "UI64FMTD", MinionGUID "UI64FMTD", CharmerGUID "UI64FMTD", CharmedGUID "UI64FMTD,
GetOwnerGUID(), GetMinionGUID(), GetCharmerGUID(), GetCharmGUID());
sLog->outString("In world %u, unit type mask %u",
(uint32) (IsInWorld() ? 1 : 0), m_unitTypeMask);
if (IsInWorld())
sLog->outString("Mapid %u", GetMapId());
sLog->outStringInLine("Summon Slot: ");
for (uint32 i = 0; i < MAX_SUMMON_SLOT; ++i)
sLog->outStringInLine(UI64FMTD", ", m_SummonSlot [i]);
sLog->outString();
sLog->outStringInLine("Controlled List: ");
for (ControlList::const_iterator itr = m_Controlled.begin();
itr != m_Controlled.end(); ++itr)
sLog->outStringInLine(UI64FMTD", ", (*itr)->GetGUID());
sLog->outString();
sLog->outStringInLine("Aura List: ");
for (AuraApplicationMap::const_iterator itr = m_appliedAuras.begin();
itr != m_appliedAuras.end(); ++itr)
sLog->outStringInLine("%u, ", itr->first);
sLog->outString();
if (IsVehicle())
{
sLog->outStringInLine("Passenger List: ");
for (SeatMap::iterator itr = GetVehicleKit()->m_Seats.begin();
itr != GetVehicleKit()->m_Seats.end(); ++itr)
if (Unit *passenger = itr->second.passenger)
sLog->outStringInLine(UI64FMTD", ", passenger->GetGUID());
sLog->outString();
}
if (GetVehicle())
sLog->outString("On vehicle %u.", GetVehicleBase()->GetEntry());
}
void Unit::SendClearTarget()
{
WorldPacket data(SMSG_BREAK_TARGET, GetPackGUID().size());
data.append(GetPackGUID());
SendMessageToSet(&data, false);
}
uint32 Unit::GetResistance(SpellSchoolMask mask) const
{
int32 resist = -1;
for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
if (mask & (1 << i)
&& (resist < 0 || resist > int32(GetResistance(SpellSchools(i))))) resist =
int32(GetResistance(SpellSchools(i)));
// resist value will never be negative here
return uint32(resist);
}
uint32 Unit::GetRemainingDotDamage(uint64 caster, uint32 spellId,
uint8 effectIndex) const
{
uint32 amount = 0;
AuraEffectList const& DoTAuras = GetAuraEffectsByType(
SPELL_AURA_PERIODIC_DAMAGE);
for (AuraEffectList::const_iterator i = DoTAuras.begin();
i != DoTAuras.end(); ++i)
{
if ((*i)->GetCasterGUID() != caster || (*i)->GetId() != spellId
|| (*i)->GetEffIndex() != effectIndex) continue;
amount += ((*i)->GetAmount()
* ((*i)->GetTotalTicks() - ((*i)->GetTickNumber())))
/ (*i)->GetTotalTicks();
break;
}
return amount;
}
bool Unit::IsVisionObscured(Unit* pVictim)
{
Aura* victimAura = NULL;
Aura* myAura = NULL;
Unit* victimCaster = NULL;
Unit* myCaster = NULL;
AuraEffectList const& vAuras = pVictim->GetAuraEffectsByType(
SPELL_AURA_INTERFERE_TARGETTING);
for (AuraEffectList::const_iterator i = vAuras.begin(); i != vAuras.end();
++i)
{
victimAura = (*i)->GetBase();
victimCaster = victimAura->GetCaster();
break;
}
AuraEffectList const& myAuras = GetAuraEffectsByType(
SPELL_AURA_INTERFERE_TARGETTING);
for (AuraEffectList::const_iterator i = myAuras.begin(); i != myAuras.end();
++i)
{
myAura = (*i)->GetBase();
myCaster = myAura->GetCaster();
break;
}
if ((myAura != NULL && myCaster == NULL)
|| (victimAura != NULL && victimCaster == NULL)) return false; // Failed auras, will result in crash
// E.G. Victim is in smoke bomb, and I'm not
// Spells fail unless I'm friendly to the caster of victim's smoke bomb
if (victimAura != NULL && myAura == NULL)
{
if (IsFriendlyTo(victimCaster)) return false;
else return true;
}
// Victim is not in smoke bomb, while I am
// Spells fail if my smoke bomb aura's caster is my enemy
else if (myAura != NULL && victimAura == NULL)
{
if (IsFriendlyTo(myCaster)) return false;
else return true;
}
return false;
}
void CharmInfo::SetIsCommandAttack(bool val)
{
m_isCommandAttack = val;
}
bool CharmInfo::IsCommandAttack()
{
return m_isCommandAttack;
}
void CharmInfo::SaveStayPosition()
{
m_unit->GetPosition(m_stayX, m_stayY, m_stayZ);
}
void CharmInfo::GetStayPosition(float &x, float &y, float &z)
{
x = m_stayX;
y = m_stayY;
z = m_stayZ;
}
void CharmInfo::SetIsAtStay(bool val)
{
m_isAtStay = val;
}
bool CharmInfo::IsAtStay()
{
return m_isAtStay;
}
void CharmInfo::SetIsFollowing(bool val)
{
m_isFollowing = val;
}
bool CharmInfo::IsFollowing()
{
return m_isFollowing;
}
void CharmInfo::SetIsReturning(bool val)
{
m_isReturning = val;
}
bool CharmInfo::IsReturning()
{
return m_isReturning;
}
// Living Seed
void Unit::SetEclipsePower(int32 power)
{
eclipse = power;
if (eclipse == 0)
{
if (HasAura(67483)) RemoveAurasDueToSpell(67483);
if (HasAura(67484)) RemoveAurasDueToSpell(67484);
}
if (eclipse >= 100)
{
if (HasAura(48518)) RemoveAurasDueToSpell(48518);
eclipse = 100;
AddAura(48517, ToPlayer());
}
if (eclipse <= -100)
{
if (HasAura(48517)) RemoveAurasDueToSpell(48517);
eclipse = -100;
AddAura(48518, ToPlayer());
}
WorldPacket data(SMSG_POWER_UPDATE);
data.append(GetPackGUID());
data << int32(1);
data << int8(POWER_ECLIPSE);
data << int32(eclipse);
SendMessageToSet(&data, GetTypeId() == TYPEID_PLAYER ? true : false);
}
uint32 Unit::GetHealingDoneInPastSecs(uint32 secs)
{
uint32 heal = 0;
if (secs > 120) secs = 120;
for (uint32 i = 0; i < secs; i++)
heal += m_heal_done [i];
if (heal < 0) return 0;
return heal;
}
;
uint32 Unit::GetDamageDoneInPastSecs(uint32 secs)
{
uint32 damage = 0;
if (secs > 120) secs = 120;
for (uint32 i = 0; i < secs; i++)
damage += m_damage_done [i];
if (damage < 0) return 0;
return damage;
}
;
uint32 Unit::GetDamageTakenInPastSecs(uint32 secs)
{
uint32 tdamage = 0;
if (secs > 120) secs = 120;
for (uint32 i = 0; i < secs; i++)
tdamage += m_damage_taken [i];
if (tdamage < 0) return 0;
return tdamage;
}
;
void Unit::ResetDamageDoneInPastSecs(uint32 secs)
{
if (secs > 120) secs = 120;
for (uint32 i = 0; i < secs; i++)
m_damage_done [i] = 0;
}
;
void Unit::ResetHealingDoneInPastSecs(uint32 secs)
{
if (secs > 120) secs = 120;
for (uint32 i = 0; i < secs; i++)
m_heal_done [i] = 0;
}
;
| 29.441568 | 236 | 0.67334 | Zone-Emu |
9e34d01349b16f9e2820ca49771f3456afea1baa | 4,632 | cpp | C++ | shirabeengine/shirabeengine/modules/core/code/source/serialization/jsonobjectserializer.cpp | BoneCrasher/ShirabeEngine | 39b3aa2c5173084d59b96b7f60c15207bff0ad04 | [
"MIT"
] | 5 | 2019-12-02T12:28:57.000Z | 2021-04-07T21:21:13.000Z | shirabeengine/shirabeengine/modules/core/code/source/serialization/jsonobjectserializer.cpp | BoneCrasher/ShirabeEngine | 39b3aa2c5173084d59b96b7f60c15207bff0ad04 | [
"MIT"
] | null | null | null | shirabeengine/shirabeengine/modules/core/code/source/serialization/jsonobjectserializer.cpp | BoneCrasher/ShirabeEngine | 39b3aa2c5173084d59b96b7f60c15207bff0ad04 | [
"MIT"
] | 1 | 2020-01-09T14:25:42.000Z | 2020-01-09T14:25:42.000Z | #include <iostream>
#include "SEPUtil/Documents/JSON.h"
#include "SEPCore/ObjectModel/SR_SEPCore_Object.h"
#include "SEPCore/ObjectModel/SR_SEPCore_Property.h"
#include "SEPCore/ObjectModel/Serialization/SR_SEPCore_JSONObjectSerializer.h"
namespace sr {
namespace serialization {
using namespace sr::documents;
/**********************************************************************************************//**
* \fn template <typename TCollection> static bool serializeCollection( Shared<IObjectSerializer> &serializer, std::string const&name, TCollection const&collection)
*
* \brief Serialize collection
*
* \tparam TCollection Type of the collection.
* \param [in,out] serializer The serializer.
* \param name The name.
* \param collection The collection.
*
* \return True if it succeeds, false if it fails.
**************************************************************************************************/
template <typename TCollection>
static bool serializeCollection(
Shared<IObjectSerializer> &serializer,
std::string const&name,
TCollection const&collection)
{
for(typename TCollection::value_type const&item : collection) {
item.second->acceptSerializer(serializer);
}
return true;
}
/**********************************************************************************************//**
* \fn bool XMLSerializer::serializeObject(Shared<Object> const&object)
*
* \brief Serialize object
*
* \param object The object.
*
* \return True if it succeeds, false if it fails.
**************************************************************************************************/
bool JSONSerializer::serializeObject(Shared<Object> const&object) {
Shared<IObjectSerializer> serializer = SharedFromThis<IObjectSerializer>(this);
//
// Serialize an object at this point, applying the subsequent format:
//
// Serialize all it's properties!
Object::Properties const&properties = object->properties();
if(!serializeCollection<Object::Properties>(serializer, "properties", properties)) {
// Log
return false;
}
// Serialize all children
Object::Children const&children = object->children();
if(!serializeCollection<Object::Children>(serializer, "children", children)) {
// Log
return false;
}
return true;
}
/**********************************************************************************************//**
* \fn bool XMLSerializer::serializeProperty(Shared<Object> const&property)
*
* \brief Serialize property
*
* \param property The property.
*
* \return True if it succeeds, false if it fails.
**************************************************************************************************/
bool JSONSerializer::serializeProperty(Shared<Object> const&property) {
return true;
}
/**********************************************************************************************//**
* \fn bool XMLSerializer::deserializeObject(Shared<Object> &object)
*
* \brief Deserialize object/
*
* \param [in,out] object The object.
*
* \return True if it succeeds, false if it fails.
**************************************************************************************************/
bool JSONSerializer::deserializeObject(Shared<Object> &object) {
return true;
}
/**********************************************************************************************//**
* \fn bool XMLSerializer::deserializeProperty(Shared<Object> &property)
*
* \brief Deserialize property
*
* \param [in,out] property The property.
*
* \return True if it succeeds, false if it fails.
**************************************************************************************************/
bool JSONSerializer::deserializeProperty(Shared<Object> &property) {
return true;
}
/**********************************************************************************************//**
* \fn std::string XMLSerializer::serializeResultToString()
*
* \brief Serialize result to string
*
* \return A std::string.
**************************************************************************************************/
std::string JSONSerializer::serializeResultToString() {
return "";
}
}
}
| 37.658537 | 169 | 0.470207 | BoneCrasher |
9e3dee3c83418b383fa2f716ac4e8937f64ca1ca | 720 | cpp | C++ | Rotor.cpp | FreddieLindsey/ic_year_2_cpp_enigma | d7efebed5a135e46c09e18873f2ba2630c2e1701 | [
"MIT"
] | null | null | null | Rotor.cpp | FreddieLindsey/ic_year_2_cpp_enigma | d7efebed5a135e46c09e18873f2ba2630c2e1701 | [
"MIT"
] | null | null | null | Rotor.cpp | FreddieLindsey/ic_year_2_cpp_enigma | d7efebed5a135e46c09e18873f2ba2630c2e1701 | [
"MIT"
] | null | null | null | #include "Rotor.hpp"
Rotor::Rotor(string file_content)
: map_encode(ALPHABET_SIZE), map_decode(ALPHABET_SIZE), offset(0) {
// Initialise
istringstream content(file_content);
string num;
// Set map to input file given
for (int i = 0; i < ALPHABET_SIZE; i++) {
getline(content, num, INPUT_DELIM);
int diff = stoi(num) - i;
map_encode[i] = diff;
map_decode[i + diff] = -diff;
}
}
void Rotor::encode_decode(int& c, bool encode_decode) {
vector<int>& map = encode_decode ? map_encode : map_decode;
c = (c + map[(c + offset) % ALPHABET_SIZE] + ALPHABET_SIZE) % ALPHABET_SIZE;
}
bool Rotor::rotate(void) {
offset = (offset + 1 + ALPHABET_SIZE) % ALPHABET_SIZE;
return offset == 0;
}
| 26.666667 | 78 | 0.665278 | FreddieLindsey |
9e47ccaf7a7e2f41444b1879b89d0d60f96a3852 | 2,037 | cpp | C++ | Pinball_Project/ModuleWindow.cpp | rastabrandy02/Pinball_Project_Physics_2 | 60de6903882e29f7fb919ebc4eb0f92130a15afb | [
"MIT"
] | null | null | null | Pinball_Project/ModuleWindow.cpp | rastabrandy02/Pinball_Project_Physics_2 | 60de6903882e29f7fb919ebc4eb0f92130a15afb | [
"MIT"
] | null | null | null | Pinball_Project/ModuleWindow.cpp | rastabrandy02/Pinball_Project_Physics_2 | 60de6903882e29f7fb919ebc4eb0f92130a15afb | [
"MIT"
] | 1 | 2022-02-09T19:46:39.000Z | 2022-02-09T19:46:39.000Z | #include "Globals.h"
#include "Application.h"
#include "ModuleWindow.h"
ModuleWindow::ModuleWindow(Application* app, bool start_enabled) : Module(app, start_enabled)
{
window = NULL;
screen_surface = NULL;
}
// Destructor
ModuleWindow::~ModuleWindow()
{
}
// Called before render is available
bool ModuleWindow::Init()
{
LOG("Init SDL window & surface");
bool ret = true;
if(SDL_Init(SDL_INIT_VIDEO) < 0)
{
LOG("SDL_VIDEO could not initialize! SDL_Error: %s\n", SDL_GetError());
ret = false;
}
else
{
//Create window
float width = SCREEN_WIDTH * SCREEN_SIZE;
float height = SCREEN_HEIGHT * SCREEN_SIZE;
Uint32 flags = SDL_WINDOW_SHOWN;
if(WIN_FULLSCREEN == true)
{
flags |= SDL_WINDOW_FULLSCREEN;
}
if(WIN_RESIZABLE == true)
{
flags |= SDL_WINDOW_RESIZABLE;
}
if(WIN_BORDERLESS == true)
{
flags |= SDL_WINDOW_BORDERLESS;
}
if(WIN_FULLSCREEN_DESKTOP == true)
{
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
window = SDL_CreateWindow(TITLE, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, flags);
if(window == NULL)
{
LOG("Window could not be created! SDL_Error: %s\n", SDL_GetError());
ret = false;
}
else
{
//Get window surface
screen_surface = SDL_GetWindowSurface(window);
}
const char* image_path = "pinball/UI_elements/icon.bmp";
SDL_Surface* image = IMG_Load(image_path);
/* Let the user know if the file failed to load */
if (!image) {
printf("Failed to load image at %s: %s\n", image_path, SDL_GetError());
}
//SDL_Surface* iconSurface = SDL_LoadBMP("pinball/UI_elements/icon.bmp");
SDL_SetWindowIcon(window, image);
SDL_FreeSurface(image);
}
return ret;
}
// Called before quitting
bool ModuleWindow::CleanUp()
{
LOG("Destroying SDL window and quitting all SDL systems");
//Destroy window
if(window != NULL)
{
SDL_DestroyWindow(window);
}
//Quit SDL subsystems
SDL_Quit();
return true;
}
void ModuleWindow::SetTitle(const char* title)
{
SDL_SetWindowTitle(window, title);
} | 19.037383 | 107 | 0.693667 | rastabrandy02 |
eafc3169eba604acdb2d92cceed49073fc30be40 | 6,958 | cpp | C++ | packages/+GT/GenericTargetCode/source/GenericTarget/SignalObjectDoubles.cpp | RobertDamerius/GenericTarget | 6b26793c2d580797ac8104ca5368987cbb570ef8 | [
"MIT"
] | 1 | 2021-02-02T09:01:24.000Z | 2021-02-02T09:01:24.000Z | packages/+GT/GenericTargetCode/source/GenericTarget/SignalObjectDoubles.cpp | RobertDamerius/GenericTarget | 6b26793c2d580797ac8104ca5368987cbb570ef8 | [
"MIT"
] | null | null | null | packages/+GT/GenericTargetCode/source/GenericTarget/SignalObjectDoubles.cpp | RobertDamerius/GenericTarget | 6b26793c2d580797ac8104ca5368987cbb570ef8 | [
"MIT"
] | 2 | 2021-02-02T09:01:45.000Z | 2021-10-02T13:08:16.000Z | #include <SignalObjectDoubles.hpp>
#include <Console.hpp>
#include <SimulinkInterface.hpp>
#include <SignalManager.hpp>
#include <Common.hpp>
SignalObjectDoubles::SignalObjectDoubles(){
this->numSamplesPerFile = 0;
this->numSignals = 0;
this->labels = "";
this->started = false;
this->filename = "";
this->notified = false;
this->terminate = false;
this->threadLog = nullptr;
this->currentFileNumber = 0;
this->numSamplesWritten = 0;
this->currentFileStarted = false;
}
SignalObjectDoubles::~SignalObjectDoubles(){
Stop();
}
bool SignalObjectDoubles::Start(std::string filename){
// Make sure that the signal object is stopped
Stop();
// Set filename and start log thread
this->filename = filename;
threadLog = new std::thread(SignalObjectDoubles::ThreadLog, this);
struct sched_param param;
param.sched_priority = SimulinkInterface::priorityLog;
if(0 != pthread_setschedparam(threadLog->native_handle(), SCHED_FIFO, ¶m)){
LogE("[SIGNAL MANAGER] Could not set thread priority %d for logger thread\n", SimulinkInterface::priorityLog);
}
// Started, return success
return (this->started = true);
}
void SignalObjectDoubles::Stop(void){
// Stop thread
terminate = true;
if(threadLog){
this->Notify();
threadLog->join();
delete threadLog;
threadLog = nullptr;
}
terminate = false;
// If the signal object was started, check if there're remaining values in the buffer and write/append them to data files
if(this->started){
this->mtxBuffer.lock();
WriteBufferToDataFiles(std::ref(this->buffer));
if(this->buffer.size()){
std::string currentFileName = this->filename + std::string("_") + std::to_string(this->currentFileNumber);
LogW("[SIGNAL MANAGER] Some signal data is in the buffer (%ull samples) but could not be written to the data file \"%s\"!\n", this->buffer.size() / (size_t)(1 + this->numSignals), currentFileName.c_str());
this->buffer.clear();
}
this->mtxBuffer.unlock();
}
this->started = false;
this->currentFileNumber = 0;
this->numSamplesWritten = 0;
this->currentFileStarted = false;
}
void SignalObjectDoubles::Write(double simulationTime, double* values, uint32_t numValues){
// Just append data to buffer
if(this->numSignals == numValues){
this->mtxBuffer.lock();
this->buffer.push_back(simulationTime);
this->buffer.insert(this->buffer.end(), &values[0], &values[0] + this->numSignals);
this->mtxBuffer.unlock();
}
// Notify file logging thread that new data is available
this->Notify();
}
bool SignalObjectDoubles::WriteHeader(std::string name){
// Open file
FILE *file = fopen(name.c_str(), "wb");
if(!file)
return false;
// Header: "GTDBL" (5 bytes)
const uint8_t header[] = {'G','T', 'D', 'B', 'L'};
fwrite(&header[0], 1, 5, file);
// Zero-based offset to SampleData (4 bytes)
uint8_t bytes[4];
uint32_t offset = 15 + uint32_t(this->labels.length());
bytes[0] = uint8_t((offset >> 24) & 0x000000FF);
bytes[1] = uint8_t((offset >> 16) & 0x000000FF);
bytes[2] = uint8_t((offset >> 8) & 0x000000FF);
bytes[3] = uint8_t(offset & 0x000000FF);
fwrite(&bytes[0], 1, 4, file);
// numSignals (4 bytes)
bytes[0] = uint8_t((this->numSignals >> 24) & 0x000000FF);
bytes[1] = uint8_t((this->numSignals >> 16) & 0x000000FF);
bytes[2] = uint8_t((this->numSignals >> 8) & 0x000000FF);
bytes[3] = uint8_t(this->numSignals & 0x000000FF);
fwrite(&bytes[0], 1, 4, file);
// Labels + 0x00 (L + 1 bytes)
fwrite(&this->labels[0], 1, this->labels.length(), file);
bytes[0] = 0;
fwrite(&bytes[0], 1, 1, file);
// endianess (1 byte): litte endian (0x01) or big endian (0x80)
union {
uint16_t value;
uint8_t bytes[2];
} endian = {0x0100};
uint8_t byte = endian.bytes[0] ? 0x80 : 0x01;
fwrite(&byte, 1, 1, file);
// Close file and return success
fclose(file);
return true;
}
void SignalObjectDoubles::ThreadLog(SignalObjectDoubles* obj){
std::vector<double> localBuffer;
while(!obj->terminate){
// Wait for notification
{
std::unique_lock<std::mutex> lock(obj->mtxNotify);
obj->cvNotify.wait(lock, [obj](){ return (obj->notified || obj->terminate); });
obj->notified = false;
}
if(obj->terminate){
break;
}
// Copy to local buffer
obj->mtxBuffer.lock();
if(obj->buffer.size()){
localBuffer.insert(localBuffer.end(), obj->buffer.begin(), obj->buffer.end());
obj->buffer.clear();
}
obj->mtxBuffer.unlock();
// Write buffer data to files
obj->WriteBufferToDataFiles(std::ref(localBuffer));
}
// If there's data in the local buffer copy it to the beginning of the main buffer
if(localBuffer.size()){
obj->mtxBuffer.lock();
obj->buffer.insert(obj->buffer.begin(), localBuffer.begin(), localBuffer.end());
obj->mtxBuffer.unlock();
}
}
void SignalObjectDoubles::WriteBufferToDataFiles(std::vector<double>& values){
while(values.size()){
// The current file name of the active data file
std::string currentFileName = this->filename + std::string("_") + std::to_string(this->currentFileNumber);
// Check if new file should be started
if(!this->currentFileStarted){
if(!WriteHeader(currentFileName)){
return;
}
this->currentFileStarted = true;
this->numSamplesWritten = 0;
Log("[SIGNAL MANAGER] Created data log file \"%s\".\n", currentFileName.c_str());
}
// We have a started file, write samples
size_t numSamplesToWrite = values.size() / (size_t)(1 + this->numSignals);
if(this->numSamplesPerFile){
numSamplesToWrite = std::min(numSamplesToWrite, this->numSamplesPerFile);
}
if(!numSamplesToWrite){
return;
}
size_t numValuesToWrite = numSamplesToWrite * (size_t)(1 + this->numSignals);
std::fstream fs(currentFileName, std::ios::out | std::ios::app | std::ios::binary);
if(!fs.is_open()){
return;
}
fs.write(reinterpret_cast<const char*>(&values[0]), numValuesToWrite * 8);
fs.close();
this->numSamplesWritten += numSamplesToWrite;
values.erase(values.begin(), values.begin() + numValuesToWrite);
// File has been finished successfully, set markers to indicate that a new file should be started
if(this->numSamplesPerFile && (this->numSamplesWritten >= this->numSamplesPerFile)){
this->currentFileStarted = false;
this->currentFileNumber++;
}
}
}
| 34.445545 | 217 | 0.617275 | RobertDamerius |
eafd77087c1c81b106f4c7fcc8b6ced67bfdbc1d | 16,496 | cpp | C++ | src/zimg/depth/dither_avx2.cpp | dubhater/zimg | 59ca0556789656a439f32b4cdfc8e26db32b8252 | [
"WTFPL"
] | null | null | null | src/zimg/depth/dither_avx2.cpp | dubhater/zimg | 59ca0556789656a439f32b4cdfc8e26db32b8252 | [
"WTFPL"
] | null | null | null | src/zimg/depth/dither_avx2.cpp | dubhater/zimg | 59ca0556789656a439f32b4cdfc8e26db32b8252 | [
"WTFPL"
] | null | null | null | #ifdef ZIMG_X86
#include <cstdint>
#include <immintrin.h>
#ifdef __clang__
#include <x86intrin.h>
#endif
#include "common/align.h"
#include "common/ccdep.h"
#define HAVE_CPU_SSE2
#define HAVE_CPU_AVX2
#include "common/x86util.h"
#undef HAVE_CPU_SSE2
#undef HAVE_CPU_AVX2
namespace zimg {
namespace depth {
namespace {
struct LoadF16 {
typedef uint16_t type;
static __m256 load(const uint16_t *ptr) { return _mm256_cvtph_ps(_mm_load_si128((const __m128i *)ptr)); }
};
struct LoadF32 {
typedef float type;
static __m256 load(const float *ptr) { return _mm256_load_ps(ptr); }
};
inline FORCE_INLINE void mm_store_left_epi8(uint8_t *dst, __m128i x, unsigned count)
{
mm_store_left_si128((__m128i *)dst, x, count);
}
inline FORCE_INLINE void mm_store_right_epi8(uint8_t *dst, __m128i x, unsigned count)
{
mm_store_right_si128((__m128i *)dst, x, count);
}
inline FORCE_INLINE void mm256_store_left_epi16(uint16_t *dst, __m256i x, unsigned count)
{
mm256_store_left_si256((__m256i *)dst, x, count * 2);
}
inline FORCE_INLINE void mm256_store_right_epi16(uint16_t *dst, __m256i x, unsigned count)
{
mm256_store_right_si256((__m256i *)dst, x, count * 2);
}
inline FORCE_INLINE __m256i mm256_zeroextend_epi8(__m128i y)
{
__m256i x;
x = _mm256_permute4x64_epi64(_mm256_castsi128_si256(y), _MM_SHUFFLE(1, 1, 0, 0));
x = _mm256_unpacklo_epi8(x, _mm256_setzero_si256());
return x;
}
inline FORCE_INLINE __m128i mm256_packus_epi16_si256_si128(__m256i x)
{
x = _mm256_packus_epi16(x, x);
x = _mm256_permute4x64_epi64(x, _MM_SHUFFLE(3, 1, 2, 0));
return _mm256_castsi256_si128(x);
}
inline FORCE_INLINE void mm256_cvtepu16_ps(__m256i x, __m256 &lo, __m256 &hi)
{
__m256i lo_dw, hi_dw;
x = _mm256_permute4x64_epi64(x, _MM_SHUFFLE(3, 1, 2, 0));
lo_dw = _mm256_unpacklo_epi16(x, _mm256_setzero_si256());
hi_dw = _mm256_unpackhi_epi16(x, _mm256_setzero_si256());
lo = _mm256_cvtepi32_ps(lo_dw);
hi = _mm256_cvtepi32_ps(hi_dw);
}
inline FORCE_INLINE __m256i mm256_cvtps_epu16(__m256 lo, __m256 hi)
{
__m256i lo_dw = _mm256_cvtps_epi32(lo);
__m256i hi_dw = _mm256_cvtps_epi32(hi);
__m256i x;
x = _mm256_packus_epi32(lo_dw, hi_dw); // 0 1 2 3 8 9 a b | 4 5 6 7 c d e f
x = _mm256_permute4x64_epi64(x, _MM_SHUFFLE(3, 1, 2, 0));
return x;
}
inline FORCE_INLINE __m128i ordered_dither_b2b_avx2_xiter(unsigned j, const float *dither, unsigned dither_offset, unsigned dither_mask,
const uint8_t *src_p, __m256 scale, __m256 offset, __m128i out_max)
{
__m128i y = _mm_load_si128((const __m128i *)(src_p + j));
__m256i x = mm256_zeroextend_epi8(y);
__m256 lo, hi;
__m256 dith;
mm256_cvtepu16_ps(x, lo, hi);
dith = _mm256_load_ps(dither + ((dither_offset + j + 0) & dither_mask));
lo = _mm256_fmadd_ps(scale, lo, offset);
lo = _mm256_add_ps(lo, dith);
dith = _mm256_load_ps(dither + ((dither_offset + j + 8) & dither_mask));
hi = _mm256_fmadd_ps(scale, hi, offset);
hi = _mm256_add_ps(hi, dith);
x = mm256_cvtps_epu16(lo, hi);
y = mm256_packus_epi16_si256_si128(x);
y = _mm_min_epu8(y, out_max);
return y;
}
inline FORCE_INLINE __m256i ordered_dither_b2w_avx2_xiter(unsigned j, const float *dither, unsigned dither_offset, unsigned dither_mask,
const uint8_t *src_p, __m256 scale, __m256 offset, __m256i out_max)
{
__m128i y = _mm_load_si128((const __m128i *)(src_p + j));
__m256i x = mm256_zeroextend_epi8(y);
__m256 lo, hi;
__m256 dith;
mm256_cvtepu16_ps(x, lo, hi);
dith = _mm256_load_ps(dither + ((dither_offset + j + 0) & dither_mask));
lo = _mm256_fmadd_ps(scale, lo, offset);
lo = _mm256_add_ps(lo, dith);
dith = _mm256_load_ps(dither + ((dither_offset + j + 8) & dither_mask));
hi = _mm256_fmadd_ps(scale, hi, offset);
hi = _mm256_add_ps(hi, dith);
x = mm256_cvtps_epu16(lo, hi);
x = _mm256_min_epu16(x, out_max);
return x;
}
inline FORCE_INLINE __m128i ordered_dither_w2b_avx2_xiter(unsigned j, const float *dither, unsigned dither_offset, unsigned dither_mask,
const uint16_t *src_p, __m256 scale, __m256 offset, __m128i out_max)
{
__m256i x = _mm256_load_si256((const __m256i *)(src_p + j));
__m128i y;
__m256 lo, hi;
__m256 dith;
mm256_cvtepu16_ps(x, lo, hi);
dith = _mm256_load_ps(dither + ((dither_offset + j + 0) & dither_mask));
lo = _mm256_fmadd_ps(scale, lo, offset);
lo = _mm256_add_ps(lo, dith);
dith = _mm256_load_ps(dither + ((dither_offset + j + 8) & dither_mask));
hi = _mm256_fmadd_ps(scale, hi, offset);
hi = _mm256_add_ps(hi, dith);
x = mm256_cvtps_epu16(lo, hi);
y = mm256_packus_epi16_si256_si128(x);
y = _mm_min_epu8(y, out_max);
return y;
}
inline FORCE_INLINE __m256i ordered_dither_w2w_avx2_xiter(unsigned j, const float *dither, unsigned dither_offset, unsigned dither_mask,
const uint16_t *src_p, __m256 scale, __m256 offset, __m256i out_max)
{
__m256i x = _mm256_load_si256((const __m256i *)(src_p + j));
__m256 lo, hi;
__m256 dith;
mm256_cvtepu16_ps(x, lo, hi);
dith = _mm256_load_ps(dither + ((dither_offset + j + 0) & dither_mask));
lo = _mm256_fmadd_ps(scale, lo, offset);
lo = _mm256_add_ps(lo, dith);
dith = _mm256_load_ps(dither + ((dither_offset + j + 8) & dither_mask));
hi = _mm256_fmadd_ps(scale, hi, offset);
hi = _mm256_add_ps(hi, dith);
x = mm256_cvtps_epu16(lo, hi);
x = _mm256_min_epu16(x, out_max);
return x;
}
template <class Load>
inline FORCE_INLINE __m128i ordered_dither_f2b_avx2_xiter(unsigned j, const float *dither, unsigned dither_offset, unsigned dither_mask,
const typename Load::type *src_p, __m256 scale, __m256 offset, __m128i out_max)
{
__m256 lo = Load::load(src_p + j + 0);
__m256 hi = Load::load(src_p + j + 8);
__m256 dith;
__m256i x;
__m128i y;
dith = _mm256_load_ps(dither + ((dither_offset + j + 0) & dither_mask));
lo = _mm256_fmadd_ps(scale, lo, offset);
lo = _mm256_add_ps(lo, dith);
dith = _mm256_load_ps(dither + ((dither_offset + j + 8) & dither_mask));
hi = _mm256_fmadd_ps(scale, hi, offset);
hi = _mm256_add_ps(hi, dith);
x = mm256_cvtps_epu16(lo, hi);
y = mm256_packus_epi16_si256_si128(x);
y = _mm_min_epu8(y, out_max);
return y;
}
template <class Load>
inline FORCE_INLINE __m256i ordered_dither_f2w_avx2_xiter(unsigned j, const float *dither, unsigned dither_offset, unsigned dither_mask,
const typename Load::type *src_p, __m256 scale, __m256 offset, __m256i out_max)
{
__m256 lo = Load::load(src_p + j + 0);
__m256 hi = Load::load(src_p + j + 8);
__m256 dith;
__m256i x;
dith = _mm256_load_ps(dither + ((dither_offset + j + 0) & dither_mask));
lo = _mm256_fmadd_ps(scale, lo, offset);
lo = _mm256_add_ps(lo, dith);
dith = _mm256_load_ps(dither + ((dither_offset + j + 8) & dither_mask));
hi = _mm256_fmadd_ps(scale, hi, offset);
hi = _mm256_add_ps(hi, dith);
x = mm256_cvtps_epu16(lo, hi);
x = _mm256_min_epu16(x, out_max);
return x;
}
} // namespace
void ordered_dither_b2b_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const uint8_t *src_p = static_cast<const uint8_t *>(src);
uint8_t *dst_p = static_cast<uint8_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m128i out_max = _mm_set1_epi8((uint8_t)((1 << bits) - 1));
#define XITER ordered_dither_b2b_avx2_xiter
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m128i x = XITER(vec_left - 16, XARGS);
mm_store_left_epi8(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m128i x = XITER(j, XARGS);
_mm_store_si128((__m128i *)(dst_p + j), x);
}
if (right != vec_right) {
__m128i x = XITER(vec_right, XARGS);
mm_store_right_epi8(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_b2w_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const uint8_t *src_p = static_cast<const uint8_t *>(src);
uint16_t *dst_p = static_cast<uint16_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m256i out_max = _mm256_set1_epi16((uint16_t)((1 << bits) - 1));
#define XITER ordered_dither_b2w_avx2_xiter
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m256i x = XITER(vec_left - 16, XARGS);
mm256_store_left_epi16(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m256i x = XITER(j, XARGS);
_mm256_store_si256((__m256i *)(dst_p + j), x);
}
if (right != vec_right) {
__m256i x = XITER(vec_right, XARGS);
mm256_store_right_epi16(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_w2b_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const uint16_t *src_p = static_cast<const uint16_t *>(src);
uint8_t *dst_p = static_cast<uint8_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m128i out_max = _mm_set1_epi8((uint8_t)((1 << bits) - 1));
#define XITER ordered_dither_w2b_avx2_xiter
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m128i x = XITER(vec_left - 16, XARGS);
mm_store_left_epi8(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m128i x = XITER(j, XARGS);
_mm_store_si128((__m128i *)(dst_p + j), x);
}
if (right != vec_right) {
__m128i x = XITER(vec_right, XARGS);
mm_store_right_epi8(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_w2w_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const uint16_t *src_p = static_cast<const uint16_t *>(src);
uint16_t *dst_p = static_cast<uint16_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m256i out_max = _mm256_set1_epi16((uint16_t)((1 << bits) - 1));
#define XITER ordered_dither_w2w_avx2_xiter
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m256i x = XITER(vec_left - 16, XARGS);
mm256_store_left_epi16(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m256i x = XITER(j, XARGS);
_mm256_store_si256((__m256i *)(dst_p + j), x);
}
if (right != vec_right) {
__m256i x = XITER(vec_right, XARGS);
mm256_store_right_epi16(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_h2b_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const uint16_t *src_p = static_cast<const uint16_t *>(src);
uint8_t *dst_p = static_cast<uint8_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m128i out_max = _mm_set1_epi8((uint8_t)((1 << bits) - 1));
#define XITER ordered_dither_f2b_avx2_xiter<LoadF16>
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m128i x = XITER(vec_left - 16, XARGS);
mm_store_left_epi8(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m128i x = XITER(j, XARGS);
_mm_store_si128((__m128i *)(dst_p + j), x);
}
if (right != vec_right) {
__m128i x = XITER(vec_right, XARGS);
mm_store_right_epi8(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_h2w_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const uint16_t *src_p = static_cast<const uint16_t *>(src);
uint16_t *dst_p = static_cast<uint16_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m256i out_max = _mm256_set1_epi16((uint16_t)((1 << bits) - 1));
#define XITER ordered_dither_f2w_avx2_xiter<LoadF16>
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m256i x = XITER(vec_left - 16, XARGS);
mm256_store_left_epi16(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m256i x = XITER(j, XARGS);
_mm256_store_si256((__m256i *)(dst_p + j), x);
}
if (right != vec_right) {
__m256i x = XITER(vec_right, XARGS);
mm256_store_right_epi16(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_f2b_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const float *src_p = static_cast<const float *>(src);
uint8_t *dst_p = static_cast<uint8_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m128i out_max = _mm_set1_epi8((uint8_t)((1 << bits) - 1));
#define XITER ordered_dither_f2b_avx2_xiter<LoadF32>
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m128i x = XITER(vec_left - 16, XARGS);
mm_store_left_epi8(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m128i x = XITER(j, XARGS);
_mm_store_si128((__m128i *)(dst_p + j), x);
}
if (right != vec_right) {
__m128i x = XITER(vec_right, XARGS);
mm_store_right_epi8(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
void ordered_dither_f2w_avx2(const float *dither, unsigned dither_offset, unsigned dither_mask,
const void *src, void *dst, float scale, float offset, unsigned bits, unsigned left, unsigned right)
{
const float *src_p = static_cast<const float *>(src);
uint16_t *dst_p = static_cast<uint16_t *>(dst);
unsigned vec_left = ceil_n(left, 16);
unsigned vec_right = floor_n(right, 16);
const __m256 scale_ps = _mm256_set1_ps(scale);
const __m256 offset_ps = _mm256_set1_ps(offset);
const __m256i out_max = _mm256_set1_epi16((uint16_t)((1 << bits) - 1));
#define XITER ordered_dither_f2w_avx2_xiter<LoadF32>
#define XARGS dither, dither_offset, dither_mask, src_p, scale_ps, offset_ps, out_max
if (left != vec_left) {
__m256i x = XITER(vec_left - 16, XARGS);
mm256_store_left_epi16(dst_p + vec_left - 16, x, vec_left - left);
}
for (unsigned j = vec_left; j < vec_right; j += 16) {
__m256i x = XITER(j, XARGS);
_mm256_store_si256((__m256i *)(dst_p + j), x);
}
if (right != vec_right) {
__m256i x = XITER(vec_right, XARGS);
mm256_store_right_epi16(dst_p + vec_right, x, right - vec_right);
}
#undef XITER
#undef XARGS
}
} // namespace depth
} // namespace zimg
#endif // ZIMG_X86
| 32.093385 | 137 | 0.701443 | dubhater |
d80066e417bd53da3def109bc4936bb747115a6c | 60 | cpp | C++ | LoveLiveWallpaper/src/IPointerUp.cpp | Juvwxyz/LoveLiveWallpaper | a0eeac941b5ccd53af538192cb92b7df049839c4 | [
"MIT"
] | 2 | 2020-05-09T00:13:06.000Z | 2020-05-25T05:49:40.000Z | LoveLiveWallpaper/src/IPointerUp.cpp | Juvwxyz/LoveLiveWallpaper | a0eeac941b5ccd53af538192cb92b7df049839c4 | [
"MIT"
] | null | null | null | LoveLiveWallpaper/src/IPointerUp.cpp | Juvwxyz/LoveLiveWallpaper | a0eeac941b5ccd53af538192cb92b7df049839c4 | [
"MIT"
] | 1 | 2020-05-25T05:49:44.000Z | 2020-05-25T05:49:44.000Z | #include "IPointerUp.h"
LLWP::IPointerUp::IPointerUp()
{
}
| 10 | 30 | 0.7 | Juvwxyz |
d8010d8b2e5a912437b2d9292b01bfc1732a2f0f | 3,502 | hpp | C++ | include/RED4ext/Scripting/Natives/Generated/AtmosphereAreaSettings.hpp | flibX0r/RED4ext.SDK | 18d075ef7559e35d8b02dc2e00a03ccc7ff4d77b | [
"MIT"
] | 42 | 2020-12-25T08:33:00.000Z | 2022-03-22T14:47:07.000Z | include/RED4ext/Scripting/Natives/Generated/AtmosphereAreaSettings.hpp | flibX0r/RED4ext.SDK | 18d075ef7559e35d8b02dc2e00a03ccc7ff4d77b | [
"MIT"
] | 38 | 2020-12-28T22:36:06.000Z | 2022-02-16T11:25:47.000Z | include/RED4ext/Scripting/Natives/Generated/AtmosphereAreaSettings.hpp | flibX0r/RED4ext.SDK | 18d075ef7559e35d8b02dc2e00a03ccc7ff4d77b | [
"MIT"
] | 20 | 2020-12-28T22:17:38.000Z | 2022-03-22T17:19:01.000Z | #pragma once
// This file is generated from the Game's Reflection data
#include <cstdint>
#include <RED4ext/Common.hpp>
#include <RED4ext/NativeTypes.hpp>
#include <RED4ext/Scripting/Natives/Generated/HDRColor.hpp>
#include <RED4ext/Scripting/Natives/Generated/IAreaSettings.hpp>
namespace RED4ext
{
struct CBitmapTexture;
struct CCubeTexture;
struct AtmosphereAreaSettings : IAreaSettings
{
static constexpr const char* NAME = "AtmosphereAreaSettings";
static constexpr const char* ALIAS = NAME;
CurveData<HDRColor> skydomeColor; // 48
CurveData<HDRColor> skylightColor; // 80
CurveData<HDRColor> groundReflectance; // B8
CurveData<float> horizonMinZ; // F0
CurveData<float> sunMinZ; // 128
CurveData<float> horizonFalloff; // 160
CurveData<float> turbidity; // 198
CurveData<float> lutTurbidity; // 1D0
CurveData<HDRColor> artisticDarkeningColor; // 208
CurveData<float> artisticDarkeningStartPoint; // 240
CurveData<float> artisticDarkeningEndPoint; // 278
CurveData<float> artisticDarkeningExponent; // 2B0
CurveData<HDRColor> sunColor; // 2E8
CurveData<float> sunFalloff; // 320
CurveData<float> rayTracedSunShadowRange; // 358
CurveData<HDRColor> moonColor; // 390
CurveData<float> moonFalloff; // 3C8
CurveData<float> moonGlowIntensity; // 400
CurveData<float> moonGlowFalloff; // 438
Ref<CBitmapTexture> moonTexture; // 470
CurveData<float> galaxyIntensity; // 488
CurveData<float> starMapIntensity; // 4C0
CurveData<float> starMapBrightScale; // 4F8
CurveData<float> starMapDimScale; // 530
CurveData<float> starMapConstelationsScale; // 568
CurveData<float> starCornerLuminanceFix; // 5A0
Ref<CCubeTexture> starMapTexture; // 5D8
Ref<CBitmapTexture> galaxyTexture; // 5F0
CurveData<HDRColor> probeColorOverrideHorizon; // 608
CurveData<float> probeAlphaOverrideHorizon; // 640
CurveData<HDRColor> probeColorOverrideZenith; // 678
CurveData<float> probeAlphaOverrideZenith; // 6B0
CurveData<float> cloudSunShadowFaloff; // 6E8
CurveData<float> cloudSunScattering; // 720
CurveData<float> cloudMoonScattering; // 758
CurveData<float> cloudCirrusOpacity; // 790
CurveData<float> cloudAmbientIntensity; // 7C8
CurveData<float> cloudCirrusScale; // 800
CurveData<float> cloudCirrusAltitude; // 838
Ref<CBitmapTexture> cloudCirrusTexture; // 870
Ref<CBitmapTexture> volWeatherTexture; // 888
Ref<CBitmapTexture> volNoiseTexture; // 8A0
CurveData<float> volCoverage; // 8B8
float volHorizonCoverage; // 8F0
uint8_t unk8F4[0x8F8 - 0x8F4]; // 8F4
CurveData<float> volDensity; // 8F8
float cloudsBottom; // 930
float cloudsTop; // 934
float rayStartOffset; // 938
float rayStartFalloff; // 93C
CurveData<float> lightIntensity; // 940
CurveData<float> reflectionProbeLightIntensity; // 978
CurveData<float> shadowIntensity; // 9B0
CurveData<float> worldShadowIntensity; // 9E8
CurveData<float> ambientIntensity; // A20
float inScatter; // A58
float outScatter; // A5C
float inVsOutScatter; // A60
float silverLining; // A64
uint8_t unkA68[0xA70 - 0xA68]; // A68
CurveData<float> ambientOutscatter; // A70
float volCoverageWindInfluence; // AA8
float volNoiseWindInfluence; // AAC
float volDetailWindInfluence; // AB0
float volDistantFogOpacity; // AB4
};
RED4EXT_ASSERT_SIZE(AtmosphereAreaSettings, 0xAB8);
} // namespace RED4ext
| 39.348315 | 65 | 0.729298 | flibX0r |
d807cd0ff6bf9012a57b42dc97e65526bd31f6f3 | 1,053 | cpp | C++ | 232ImplementQueueUsingStacks.cpp | yuyangh/LeetCode | 5d81cbd975c0c1f2bbca0cb25cefe361a169e460 | [
"MIT"
] | 1 | 2020-10-11T08:10:53.000Z | 2020-10-11T08:10:53.000Z | 232ImplementQueueUsingStacks.cpp | yuyangh/LeetCode | 5d81cbd975c0c1f2bbca0cb25cefe361a169e460 | [
"MIT"
] | null | null | null | 232ImplementQueueUsingStacks.cpp | yuyangh/LeetCode | 5d81cbd975c0c1f2bbca0cb25cefe361a169e460 | [
"MIT"
] | null | null | null | #include "LeetCodeLib.h"
class MyQueue {
public:
/** Initialize your data structure here. */
stack<int> reverse, order;
MyQueue() {
}
/** Push element x to the back of queue. */
void push(int x) {
restoreReverseElements();
reverse.push(x);
}
/** Removes the element from in front of queue and returns that element. */
int pop() {
int result = peek();
order.pop();
return result;
}
/** Get the front element. */
int peek() {
restoreReverseElements();
while (!reverse.empty()) {
order.push(reverse.top());
reverse.pop();
}
int result = order.top();
return result;
}
/** Returns whether the queue is empty. */
bool empty() {
return reverse.empty() && order.empty();
}
void restoreReverseElements() {
while (!order.empty()) {
reverse.push(order.top());
order.pop();
}
}
};
/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue* obj = new MyQueue();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->peek();
* bool param_4 = obj->empty();
*/ | 18.803571 | 76 | 0.617284 | yuyangh |
d807d13dac6afc0d3daf1edd4ea8b1ded5b83f7b | 790 | cpp | C++ | 17-database-xml/17-13/myxmlstream/main.cpp | Franklin-Qi/qtcreator-example | 5d573f961c3255fbf740991996f935092cc62018 | [
"MIT"
] | null | null | null | 17-database-xml/17-13/myxmlstream/main.cpp | Franklin-Qi/qtcreator-example | 5d573f961c3255fbf740991996f935092cc62018 | [
"MIT"
] | null | null | null | 17-database-xml/17-13/myxmlstream/main.cpp | Franklin-Qi/qtcreator-example | 5d573f961c3255fbf740991996f935092cc62018 | [
"MIT"
] | null | null | null | #include <QCoreApplication>
#include <QFile>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QDebug>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QFile file("../myxmlstream/my2.xml");
if (!file.open(QFile::WriteOnly | QFile::Text))
{
qDebug() << "Error: cannot open file";
return 1;
}
QXmlStreamWriter stream(&file);
stream.setAutoFormatting(true);
stream.writeStartDocument();
stream.writeStartElement("bookmark");
stream.writeAttribute("href", "http://www.qt.io/");
stream.writeTextElement("title", "Qt Home");
stream.writeEndElement();
stream.writeEndDocument();
file.close();
qDebug() << "write finished!";
return a.exec();
}
| 23.235294 | 56 | 0.620253 | Franklin-Qi |
d809305893b9a98d5d664f8379a5c24bb29c0a46 | 2,323 | cc | C++ | src/proto/core/entity-system/interface.cc | kcpikkt/proto | 2d7458c2ce2f571303de040f660137dc0a1d33de | [
"MIT"
] | null | null | null | src/proto/core/entity-system/interface.cc | kcpikkt/proto | 2d7458c2ce2f571303de040f660137dc0a1d33de | [
"MIT"
] | null | null | null | src/proto/core/entity-system/interface.cc | kcpikkt/proto | 2d7458c2ce2f571303de040f660137dc0a1d33de | [
"MIT"
] | null | null | null | #include "proto/core/entity-system/interface.hh"
namespace proto {
// for doing things, that are usually done compile time, runtime
// i.e. type erasure at its best
struct _Runtime {
template<size_t I>
using CompAt = typename CompTList::template at_t<I>;
// get
template<typename...> struct _get_switch;
template<size_t...Is> struct _get_switch<meta::sequence<Is...>> {
Entity _ent;
size_t _idx;
void * _ret = nullptr;
template<size_t I> inline void _case() {
if(_ret) return;
// we compare runtime index with static I,
if(I == _idx)
if(auto comp = get_comp<CompAt<I>>(_ent)) _ret = (void*)comp;
}
// go through all the cases
_get_switch(Entity ent, size_t idx) : _ent(ent), _idx(idx) {
((_case<Is>()),...);
}
};
static void * get_comp_at(Entity ent, size_t idx) {
if(idx >= CompTList::size) return nullptr;
return _get_switch< meta::make_sequence<0, CompTList::size> >(ent, idx)._ret;
}
// add
template<typename...> struct _add_switch;
template<size_t...Is> struct _add_switch<meta::sequence<Is...>> {
Entity _ent;
size_t _idx;
void * _ret = nullptr;
template<size_t I> inline void _case() {
if(_ret) return;
// we compare runtime index with static I,
if(I == _idx)
if(auto comp = add_comp<CompAt<I>>(_ent)) _ret = (void*)comp;
}
// go through all the cases
_add_switch(Entity ent, size_t idx) : _ent(ent), _idx(idx) {
((_case<Is>()),...);
}
};
static void * add_comp_at(Entity ent, size_t idx) {
if(idx >= CompTList::size) return nullptr;
return _add_switch< meta::make_sequence<0, CompTList::size> >(ent, idx)._ret;
}
};
void * get_comp(Entity entity, u64 comp_idx) {
return _Runtime::get_comp_at(entity, comp_idx);
}
void * add_comp(Entity entity, u64 comp_idx) {
return _Runtime::add_comp_at(entity, comp_idx);
}
} //namespace proto
| 32.71831 | 89 | 0.530779 | kcpikkt |
d80da73ddb700e879f1359d3387ef87b329bd11e | 1,275 | cc | C++ | TrkFitter/TrkDeadMaker.cc | brownd1978/FastSim | 05f590d72d8e7f71856fd833114a38b84fc7fd48 | [
"Apache-2.0"
] | null | null | null | TrkFitter/TrkDeadMaker.cc | brownd1978/FastSim | 05f590d72d8e7f71856fd833114a38b84fc7fd48 | [
"Apache-2.0"
] | null | null | null | TrkFitter/TrkDeadMaker.cc | brownd1978/FastSim | 05f590d72d8e7f71856fd833114a38b84fc7fd48 | [
"Apache-2.0"
] | null | null | null | //--------------------------------------------------------------------------
// File and Version Information:
// $Id: TrkDeadMaker.cc 104 2010-01-15 12:13:14Z stroili $
//
// Description:
//
// Environment:
// Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Authors: Steve Schaffner
//
//------------------------------------------------------------------------
#include "BaBar/BaBar.hh"
#include "TrkFitter/TrkDeadMaker.hh"
#include "TrkFitter/TrkDeadRep.hh"
#include "TrkBase/TrkRecoTrk.hh"
#include <assert.h>
//------------------------------------------------------------------------
TrkDeadMaker::~TrkDeadMaker() {}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
TrkDeadMaker::TrkDeadMaker() {}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void
TrkDeadMaker::addHypo(TrkRecoTrk* trk, PdtPid::PidType hypo) {
//------------------------------------------------------------------------
assert (trk != 0);
TrkDeadRep* newRep = new TrkDeadRep(trk, hypo);
// Install via TrkFitMaker fcn
addHypoTo(*trk, newRep, hypo);
}
| 32.692308 | 76 | 0.370196 | brownd1978 |
d810e3d06ba7e8c537f455c21dbe790b83752c4a | 33 | hh | C++ | build/ARM/arch/registers.hh | magnuram/edelsten5 | 63de812a22142f07fa48c253636e5c96156d4da9 | [
"BSD-3-Clause"
] | null | null | null | build/ARM/arch/registers.hh | magnuram/edelsten5 | 63de812a22142f07fa48c253636e5c96156d4da9 | [
"BSD-3-Clause"
] | null | null | null | build/ARM/arch/registers.hh | magnuram/edelsten5 | 63de812a22142f07fa48c253636e5c96156d4da9 | [
"BSD-3-Clause"
] | null | null | null | #include "arch/arm/registers.hh"
| 16.5 | 32 | 0.757576 | magnuram |
d811e05fd7042c828b95a833e7567ea334f31190 | 29,688 | cpp | C++ | Libraries/RobsJuceModules/rosic/legacy/AggressorOscSection.cpp | RobinSchmidt/RS-MET-Preliminary | 6c01cbaad7cce3daa3293c444dd9e4b74e5ebfbe | [
"FTL"
] | 34 | 2017-04-19T18:26:02.000Z | 2022-02-15T17:47:26.000Z | Libraries/RobsJuceModules/rosic/legacy/AggressorOscSection.cpp | RobinSchmidt/RS-MET-Preliminary | 6c01cbaad7cce3daa3293c444dd9e4b74e5ebfbe | [
"FTL"
] | 307 | 2017-05-04T21:45:01.000Z | 2022-02-03T00:59:01.000Z | Libraries/RobsJuceModules/rosic/legacy/AggressorOscSection.cpp | RobinSchmidt/RS-MET-Preliminary | 6c01cbaad7cce3daa3293c444dd9e4b74e5ebfbe | [
"FTL"
] | 4 | 2017-09-05T17:04:31.000Z | 2021-12-15T21:24:28.000Z | #include "AggressorOscSection.h"
//construction/destruction
AggressorOscSection::AggressorOscSection()
{
//init member variables:
slideTime = 0.5; //init slieTime to 0.5 seconds
sampleRate = 44100;
slideSamples = slideTime*sampleRate;
slideSampCount = 0;
syncMode = 0;
modulationMode = 0;
currentNote = -1;
currentDetune = 0;
currentPitch = 64.0;
targetPitch = 64.0;
freqBend = 1.0;
currentFreq = PITCH2FREQ(currentPitch);
targetFreq = PITCH2FREQ(targetPitch);
osc1IsPlaying = true;
osc2IsPlaying = true;
osc3IsPlaying = true;
vibIsActive = true;
pwmIsActive = true;
modulationsOff = false;
syncIsActive = false;
tuneCoarse2 = 0.0;
tuneFine2 = 0.0;
tuneFactor2 = 1.0;
tuneCoarse3 = 0.0;
tuneFine3 = 0.0;
tuneFactor3 = 1.0;
pulseWidth1 = 0.5;
pulseWidth2 = 0.5;
pulseWidth3 = 0.5;
pitchIncPerSamp = 0.0;
freqFacPerSamp = 1.0;
accent = 1.0;
vibDepth = 0.0;
pwmDepth = 0.0;
phase1 = 0.0;
vol1Start = 0.0;
vol1StartByVel = 0.0;
vol1StartByVelAc = 0.0;
pitch1Start = 0.0;
pitch1StartByVel = 0.0;
pitch1StartByVelAc = 0.0;
amBy2Start = 0.0;
amBy2StartByVel = 0.0;
amBy2StartByVelAc = 0.0;
amBy3Start = 0.0;
amBy3StartByVel = 0.0;
amBy3StartByVelAc = 0.0;
fmBy1Start = 0.0;
fmBy1StartByVel = 0.0;
fmBy1StartByVelAc = 0.0;
fmBy2Start = 0.0;
fmBy2StartByVel = 0.0;
fmBy2StartByVelAc = 0.0;
fmBy3Start = 0.0;
fmBy3StartByVel = 0.0;
fmBy3StartByVelAc = 0.0;
phase2 = 0.0;
vol2Start = 0.0;
vol2StartByVel = 0.0;
vol2StartByVelAc = 0.0;
pitch2Start = 0.0;
pitch2StartByVel = 0.0;
pitch2StartByVelAc = 0.0;
phase3 = 0.0;
vol3Start = 0.0;
vol3StartByVel = 0.0;
vol3StartByVelAc = 0.0;
pitch3Start = 0.0;
pitch3StartByVel = 0.0;
pitch3StartByVelAc = 0.0;
rm12Start = 0.0;
rm12StartByVel = 0.0;
rm12StartByVelAc = 0.0;
rm13Start = 0.0;
rm13StartByVel = 0.0;
rm13StartByVelAc = 0.0;
rm23Start = 0.0;
rm23StartByVel = 0.0;
rm23StartByVelAc = 0.0;
flt1.setLpfCutoff(20000.0);
flt1.setHpfCutoff(20.0);
flt1.setApfCutoff(20000.0);
flt2.setLpfCutoff(20000.0);
flt2.setHpfCutoff(20.0);
flt2.setApfCutoff(20000.0);
flt3.setLpfCutoff(20000.0);
flt3.setHpfCutoff(20.0);
flt3.setApfCutoff(20000.0);
}
AggressorOscSection::~AggressorOscSection()
{}
//------------------------------------------------------------------------------------------------------------
//parameter settings:
//general:
void AggressorOscSection::setSampleRate(double SampleRate)
{
if(SampleRate>0)
sampleRate = SampleRate;
//tell the oscillators the new sample-rate:
osc1.setSampleRate(sampleRate);
osc2.setSampleRate(sampleRate);
osc3.setSampleRate(sampleRate);
//tell the lfo's the new sample-rate and let them
//re-calculate their increments:
vibLfo.setSampleRate(sampleRate);
pwmLfo.setSampleRate(sampleRate);
vibLfo.calcIncrements();
pwmLfo.calcIncrements();
//tell the filters the new sample-rate:
flt1.setSampleRate(sampleRate);
flt2.setSampleRate(sampleRate);
flt3.setSampleRate(sampleRate);
//tell the ramp-envelopes the new sample-rate:
ampRamp1.setSampleRate(sampleRate);
ampRamp2.setSampleRate(sampleRate);
ampRamp3.setSampleRate(sampleRate);
freqRamp1.setSampleRate(sampleRate);
freqRamp2.setSampleRate(sampleRate);
freqRamp3.setSampleRate(sampleRate);
rm12Ramp.setSampleRate(sampleRate);
rm13Ramp.setSampleRate(sampleRate);
rm23Ramp.setSampleRate(sampleRate);
detuneRamp.setSampleRate(sampleRate);
amBy2Ramp.setSampleRate(sampleRate);
amBy3Ramp.setSampleRate(sampleRate);
fmBy1Ramp.setSampleRate(sampleRate);
fmBy2Ramp.setSampleRate(sampleRate);
fmBy3Ramp.setSampleRate(sampleRate);
}
void AggressorOscSection::setMonoPoly(long MonoPoly)
{
}
void AggressorOscSection::setSlideTime(double SlideTime)
{
if(SlideTime>=0)
slideTime = SlideTime;
slideSamples = slideTime*sampleRate;
}
void AggressorOscSection::setAccent(double Accent)
{
accent = Accent;
vol1StartByVelAc = accent*vol1StartByVel;
vol2StartByVelAc = accent*vol2StartByVel;
vol3StartByVelAc = accent*vol3StartByVel;
pitch1StartByVelAc = accent*pitch1StartByVel;
pitch2StartByVelAc = accent*pitch2StartByVel;
pitch3StartByVelAc = accent*pitch3StartByVel;
amBy2StartByVelAc = accent*amBy2StartByVel;
amBy3StartByVelAc = accent*amBy3StartByVel;
fmBy1StartByVelAc = accent*fmBy1StartByVel;
fmBy2StartByVelAc = accent*fmBy2StartByVel;
fmBy3StartByVelAc = accent*fmBy3StartByVel;
}
void AggressorOscSection::setEnvSlope(double EnvSlope)
{
ampRamp1.setTauScale(EnvSlope);
ampRamp2.setTauScale(EnvSlope);
ampRamp3.setTauScale(EnvSlope);
freqRamp1.setTauScale(EnvSlope);
freqRamp2.setTauScale(EnvSlope);
freqRamp3.setTauScale(EnvSlope);
rm12Ramp.setTauScale(EnvSlope);
rm13Ramp.setTauScale(EnvSlope);
rm23Ramp.setTauScale(EnvSlope);
detuneRamp.setTauScale(EnvSlope);
amBy2Ramp.setTauScale(EnvSlope);
amBy3Ramp.setTauScale(EnvSlope);
fmBy1Ramp.setTauScale(EnvSlope);
fmBy2Ramp.setTauScale(EnvSlope);
fmBy3Ramp.setTauScale(EnvSlope);
}
void AggressorOscSection::setVibDepth(double VibDepth)
{vibDepth = 0.01*VibDepth;}
void AggressorOscSection::setVibRate(double VibRate)
{
vibLfo.setFreq(VibRate);
vibLfo.calcIncrements();
}
void AggressorOscSection::setVibWave(long VibWave)
{
if(VibWave>0)
vibIsActive = true;
else
vibIsActive = false;
vibLfo.setWaveForm(VibWave);
}
void AggressorOscSection::setPwmDepth(double PwmDepth)
{pwmDepth = 0.01*PwmDepth;}
void AggressorOscSection::setPwmRate(double PwmRate)
{
pwmLfo.setFreq(PwmRate);
pwmLfo.calcIncrements();
}
void AggressorOscSection::setPwmWave(long PwmWave)
{
if(PwmWave>0)
pwmIsActive = true;
else
pwmIsActive = false;
pwmLfo.setWaveForm(PwmWave);
}
//oscillator 1:
void AggressorOscSection::setWaveForm1(long WaveForm1)
{
if(WaveForm1>0)
osc1IsPlaying = true;
else
osc1IsPlaying = false;
osc1.setWaveForm(WaveForm1);
}
void AggressorOscSection::setStartPhase1(double StartPhase1)
{
phase1 = StartPhase1;
osc1.setStartPhase(StartPhase1);
}
void AggressorOscSection::setVol1Start(double Vol1Start)
{
vol1Start = Vol1Start;
ampRamp1.setStart(DB2AMP(vol1Start));
}
void AggressorOscSection::setVol1StartByVel(double Vol1StartByVel)
{
vol1StartByVel = Vol1StartByVel;
vol1StartByVelAc = accent*vol1StartByVel;
}
void AggressorOscSection::setVol1Time(double Vol1Time)
{ampRamp1.setTime(0.001*Vol1Time);}
void AggressorOscSection::setVol1End(double Vol1End)
{ampRamp1.setEnd(DB2AMP(Vol1End));}
void AggressorOscSection::setPitch1Start(double Pitch1Start)
{
pitch1Start = Pitch1Start;
freqRamp1.setStart(PITCHOFFSET2FREQFACTOR(pitch1Start));
}
void AggressorOscSection::setPitch1StartByVel(double Pitch1StartByVel)
{
pitch1StartByVel = Pitch1StartByVel;
pitch1StartByVelAc = accent*pitch1StartByVel;
}
void AggressorOscSection::setPitch1Time(double Pitch1Time)
{freqRamp1.setTime(0.001*Pitch1Time);}
void AggressorOscSection::setPitch1End(double Pitch1End)
{freqRamp1.setEnd(PITCHOFFSET2FREQFACTOR(Pitch1End));}
void AggressorOscSection::setOsc1Lpf(double Osc1Lpf)
{
flt1.setLpfCutoff(Osc1Lpf);
}
void AggressorOscSection::setOsc1Hpf(double Osc1Hpf)
{
flt1.setHpfCutoff(Osc1Hpf);
}
void AggressorOscSection::setOsc1Apf(double Osc1Apf)
{
flt1.setApfCutoff(Osc1Apf);
}
void AggressorOscSection::setPulseWidth1(double PulseWidth1)
{
if( (PulseWidth1>0.0) && (PulseWidth1<100.0) )
pulseWidth1 = 0.01*PulseWidth1;
osc1.setPulseWidth(pulseWidth1);
}
void AggressorOscSection::setDensity(double Density)
{
osc1.setNumVoices((long) Density);
}
void AggressorOscSection::setDetuneStart(double DetuneStart)
{
detuneRamp.setStart(DetuneStart);
}
void AggressorOscSection::setDetuneTime(double DetuneTime)
{
detuneRamp.setTime(0.001*DetuneTime);
}
void AggressorOscSection::setDetuneEnd(double DetuneEnd)
{
detuneRamp.setEnd(DetuneEnd);
}
void AggressorOscSection::setDetuneRatio(double DetuneRatio)
{
osc1.setDetuneRatio(DetuneRatio);
}
void AggressorOscSection::setDetunePhaseSpread(double DetunePhaseSpread)
{
osc1.setDetunePhaseSpread(DetunePhaseSpread);
}
void AggressorOscSection::setDetuneSpacing(int DetuneSpacing)
{
osc1.setFreqSpacing(DetuneSpacing);
}
//modulation:
void AggressorOscSection::setAmBy2Start(double AmBy2Start)
{
amBy2Start = AmBy2Start;
amBy2Ramp.setStart(amBy2Start);
}
void AggressorOscSection::setAmBy2StartByVel(double AmBy2StartByVel)
{
amBy2StartByVel = AmBy2StartByVel;
amBy2StartByVelAc = accent*amBy2StartByVel;
}
void AggressorOscSection::setAmBy2Time(double AmBy2Time)
{
amBy2Ramp.setTime(0.001*AmBy2Time);
}
void AggressorOscSection::setAmBy2End(double AmBy2End)
{
amBy2Ramp.setEnd(AmBy2End);
}
void AggressorOscSection::setAmBy3Start(double AmBy3Start)
{
amBy3Start = AmBy3Start;
amBy3Ramp.setStart(amBy3Start);
}
void AggressorOscSection::setAmBy3StartByVel(double AmBy3StartByVel)
{
amBy3StartByVel = AmBy3StartByVel;
amBy3StartByVelAc = accent*amBy3StartByVel;
}
void AggressorOscSection::setAmBy3Time(double AmBy3Time)
{
amBy3Ramp.setTime(0.001*AmBy3Time);
}
void AggressorOscSection::setAmBy3End(double AmBy3End)
{
amBy3Ramp.setEnd(AmBy3End);
}
void AggressorOscSection::setFmBy1Start(double FmBy1Start)
{
if(FmBy1Start>=0 && FmBy1Start<=100)
fmBy1Start = 0.5*FmBy1Start;
fmBy1Ramp.setStart(fmBy1Start);
}
void AggressorOscSection::setFmBy1StartByVel(double FmBy1StartByVel)
{
if(FmBy1StartByVel>=0 && FmBy1StartByVel<=100)
fmBy1StartByVel = 0.01*FmBy1StartByVel;
fmBy1StartByVelAc = accent*fmBy1StartByVel;
}
void AggressorOscSection::setFmBy1Time(double FmBy1Time)
{
fmBy1Ramp.setTime(0.001*FmBy1Time);
}
void AggressorOscSection::setFmBy1End(double FmBy1End)
{
if(FmBy1End>=0 && FmBy1End<=100)
fmBy1Ramp.setEnd(0.5*FmBy1End);
}
void AggressorOscSection::setFmBy2Start(double FmBy2Start)
{
fmBy2Start = FmBy2Start;
fmBy2Ramp.setStart(fmBy2Start);
}
void AggressorOscSection::setFmBy2StartByVel(double FmBy2StartByVel)
{
fmBy2StartByVel = FmBy2StartByVel;
fmBy2StartByVelAc = accent*fmBy2StartByVel;
}
void AggressorOscSection::setFmBy2Time(double FmBy2Time)
{
fmBy2Ramp.setTime(0.001*FmBy2Time);
}
void AggressorOscSection::setFmBy2End(double FmBy2End)
{
fmBy2Ramp.setEnd(FmBy2End);
//fm12Index = FmBy2End;
}
void AggressorOscSection::setFmBy3Start(double FmBy3Start)
{
fmBy3Start = FmBy3Start;
fmBy3Ramp.setStart(fmBy3Start);
}
void AggressorOscSection::setFmBy3StartByVel(double FmBy3StartByVel)
{
fmBy3StartByVel = FmBy3StartByVel;
fmBy3StartByVelAc = accent*fmBy3StartByVel;
}
void AggressorOscSection::setFmBy3Time(double FmBy3Time)
{
fmBy3Ramp.setTime(0.001*FmBy3Time);
}
void AggressorOscSection::setFmBy3End(double FmBy3End)
{
fmBy3Ramp.setEnd(FmBy3End);
}
void AggressorOscSection::setModulationMode(long ModulationMode)
{
if(ModulationMode==0)
modulationsOff = true;
else
modulationsOff = false;
modulationMode = ModulationMode;
}
void AggressorOscSection::setSyncMode(long SyncMode)
{
if(SyncMode==0)
syncIsActive = false;
else
syncIsActive = true;
syncMode = SyncMode;
}
//oscillator 2:
void AggressorOscSection::setWaveForm2(long WaveForm2)
{
if(WaveForm2>0)
osc2IsPlaying = true;
else
osc2IsPlaying = false;
osc2.setWaveForm(WaveForm2);
}
void AggressorOscSection::setStartPhase2(double StartPhase2)
{
phase2 = StartPhase2;
osc2.setStartPhase(StartPhase2);
}
void AggressorOscSection::setVol2Start(double Vol2Start)
{
vol2Start = Vol2Start;
ampRamp2.setStart(DB2AMP(vol2Start));
}
void AggressorOscSection::setVol2StartByVel(double Vol2StartByVel)
{
vol2StartByVel = Vol2StartByVel;
vol2StartByVelAc = accent*vol2StartByVel;
}
void AggressorOscSection::setVol2Time(double Vol2Time)
{ampRamp2.setTime(0.001*Vol2Time);}
void AggressorOscSection::setVol2End(double Vol2End)
{ampRamp2.setEnd(DB2AMP(Vol2End));}
void AggressorOscSection::setPitch2Start(double Pitch2Start)
{
pitch2Start = Pitch2Start;
freqRamp2.setStart(PITCHOFFSET2FREQFACTOR(pitch2Start));
}
void AggressorOscSection::setPitch2StartByVel(double Pitch2StartByVel)
{
pitch2StartByVel = Pitch2StartByVel;
pitch2StartByVelAc = accent*pitch2StartByVel;
}
void AggressorOscSection::setPitch2Time(double Pitch2Time)
{freqRamp2.setTime(0.001*Pitch2Time);}
void AggressorOscSection::setPitch2End(double Pitch2End)
{freqRamp2.setEnd(PITCHOFFSET2FREQFACTOR(Pitch2End));}
void AggressorOscSection::setOsc2Lpf(double Osc2Lpf)
{
flt2.setLpfCutoff(Osc2Lpf);
}
void AggressorOscSection::setOsc2Hpf(double Osc2Hpf)
{
flt2.setHpfCutoff(Osc2Hpf);
}
void AggressorOscSection::setOsc2Apf(double Osc2Apf)
{
flt2.setApfCutoff(Osc2Apf);
}
void AggressorOscSection::setPulseWidth2(double PulseWidth2)
{
if( (PulseWidth2>0.0) && (PulseWidth2<100.0) )
pulseWidth2 = 0.01*PulseWidth2;
osc2.setPulseWidth(pulseWidth2);
}
void AggressorOscSection::setTuneCoarse2(double TuneCoarse2)
{
tuneCoarse2 = TuneCoarse2;
tuneFactor2 = PITCHOFFSET2FREQFACTOR(tuneCoarse2 + 0.01*tuneFine2);
}
void AggressorOscSection::setTuneFine2(double TuneFine2)
{
tuneFine2 = TuneFine2;
tuneFactor2 = PITCHOFFSET2FREQFACTOR(tuneCoarse2 + 0.01*tuneFine2);
}
//oscillator 3:
void AggressorOscSection::setWaveForm3(long WaveForm3)
{
if(WaveForm3>0)
osc3IsPlaying = true;
else
osc3IsPlaying = false;
osc3.setWaveForm(WaveForm3);
}
void AggressorOscSection::setStartPhase3(double StartPhase3)
{
phase3 = StartPhase3;
osc3.setStartPhase(StartPhase3);
}
void AggressorOscSection::setVol3Start(double Vol3Start)
{
vol3Start = Vol3Start;
ampRamp3.setStart(DB2AMP(vol3Start));
}
void AggressorOscSection::setVol3StartByVel(double Vol3StartByVel)
{
vol3StartByVel = Vol3StartByVel;
vol3StartByVelAc = accent*vol3StartByVel;
}
void AggressorOscSection::setVol3Time(double Vol3Time)
{ampRamp3.setTime(0.001*Vol3Time);}
void AggressorOscSection::setVol3End(double Vol3End)
{ampRamp3.setEnd(DB2AMP(Vol3End));}
void AggressorOscSection::setPitch3Start(double Pitch3Start)
{
pitch3Start = Pitch3Start;
freqRamp3.setStart(PITCHOFFSET2FREQFACTOR(pitch3Start));
}
void AggressorOscSection::setPitch3StartByVel(double Pitch3StartByVel)
{
pitch3StartByVel = Pitch3StartByVel;
pitch3StartByVelAc = accent*pitch3StartByVel;
}
void AggressorOscSection::setPitch3Time(double Pitch3Time)
{freqRamp3.setTime(0.001*Pitch3Time);}
void AggressorOscSection::setPitch3End(double Pitch3End)
{freqRamp3.setEnd(PITCHOFFSET2FREQFACTOR(Pitch3End));}
void AggressorOscSection::setOsc3Lpf(double Osc3Lpf)
{
flt3.setLpfCutoff(Osc3Lpf);
}
void AggressorOscSection::setOsc3Hpf(double Osc3Hpf)
{
flt3.setHpfCutoff(Osc3Hpf);
}
void AggressorOscSection::setOsc3Apf(double Osc3Apf)
{
flt3.setApfCutoff(Osc3Apf);
}
void AggressorOscSection::setPulseWidth3(double PulseWidth3)
{
if( (PulseWidth3>0.0) && (PulseWidth3<100.0) )
pulseWidth3 = 0.01*PulseWidth3;
osc3.setPulseWidth(pulseWidth3);
}
void AggressorOscSection::setTuneCoarse3(double TuneCoarse3)
{
tuneCoarse3 = TuneCoarse3;
tuneFactor3 = PITCHOFFSET2FREQFACTOR(tuneCoarse3 + 0.01*tuneFine3);
}
void AggressorOscSection::setTuneFine3(double TuneFine3)
{
tuneFine3 = TuneFine3;
tuneFactor3 = PITCHOFFSET2FREQFACTOR(tuneCoarse3 + 0.01*tuneFine3);
}
//ringmodulation:
void AggressorOscSection::setRm12Start(double Rm12Start)
{
rm12Start = Rm12Start;
rm12Ramp.setStart(DB2AMP(rm12Start));
}
void AggressorOscSection::setRm12StartByVel(double Rm12StartByVel)
{
rm12StartByVel = Rm12StartByVel;
rm12StartByVelAc = accent*rm12StartByVel;
}
void AggressorOscSection::setRm12Time(double Rm12Time)
{rm12Ramp.setTime(0.001*Rm12Time);}
void AggressorOscSection::setRm12End(double Rm12End)
{rm12Ramp.setEnd(DB2AMP(Rm12End));}
void AggressorOscSection::setRm13Start(double Rm13Start)
{
rm13Start = Rm13Start;
rm13Ramp.setStart(DB2AMP(rm13Start));
}
void AggressorOscSection::setRm13StartByVel(double Rm13StartByVel)
{
rm13StartByVel = Rm13StartByVel;
rm13StartByVelAc = accent*rm13StartByVel;
}
void AggressorOscSection::setRm13Time(double Rm13Time)
{rm13Ramp.setTime(0.001*Rm13Time);}
void AggressorOscSection::setRm13End(double Rm13End)
{rm13Ramp.setEnd(DB2AMP(Rm13End));}
void AggressorOscSection::setRm23Start(double Rm23Start)
{
rm23Start = Rm23Start;
rm23Ramp.setStart(DB2AMP(rm23Start));
}
void AggressorOscSection::setRm23StartByVel(double Rm23StartByVel)
{
rm23StartByVel = Rm23StartByVel;
rm23StartByVelAc = accent*rm23StartByVel;
}
void AggressorOscSection::setRm23Time(double Rm23Time)
{rm23Ramp.setTime(0.001*Rm23Time);}
void AggressorOscSection::setRm23End(double Rm23End)
{rm23Ramp.setEnd(DB2AMP(Rm23End));}
//-------------------------------------------------------------------------------------------------------
//event processing:
//(re)triggers pitchEnvelope and set oscillator to the
//new frequency:
void AggressorOscSection::triggerNote(long NoteNumber, long Velocity, long Detune)
{
static double temp;
currentNote = NoteNumber;
currentPitch = NoteNumber + 0.01 * (double) Detune;
targetPitch = currentPitch;
currentFreq = PITCH2FREQ(currentPitch);
targetFreq = currentFreq;
//calculate the start values of the ramp-envelopes from the unscaled values, and the
//velocity dependence (which is in itselt dependent from accent):
//calculate start value of osc1's amplitude ramp and set it:
temp = DB2AMP(vol1Start + (Velocity-64)*vol1StartByVelAc/63);
ampRamp1.setStart(temp);
//calculate start value of osc1's amplitude ramp and set it:
temp = PITCHOFFSET2FREQFACTOR(pitch1Start + (Velocity-64)*pitch1StartByVelAc/63);
freqRamp1.setStart(temp);
//the same for osc2 and osc3:
temp = DB2AMP(vol2Start + (Velocity-64)*vol2StartByVelAc/63);
ampRamp2.setStart(temp);
temp = PITCHOFFSET2FREQFACTOR(pitch2Start + (Velocity-64)*pitch2StartByVelAc/63);
freqRamp2.setStart(temp);
temp = DB2AMP(vol3Start + (Velocity-64)*vol3StartByVelAc/63);
ampRamp3.setStart(temp);
temp = PITCHOFFSET2FREQFACTOR(pitch3Start + (Velocity-64)*pitch3StartByVelAc/63);
freqRamp3.setStart(temp);
//the same for the AM- and FM-ramp-envelopes:
temp = amBy2Start + (Velocity-64)*amBy2StartByVelAc/63;
amBy2Ramp.setStart(temp);
temp = amBy3Start + (Velocity-64)*amBy3StartByVelAc/63;
amBy3Ramp.setStart(temp);
/* velocity->feedback-fm has to be implemented here
temp = fmBy1Start + (Velocity-64)*fmBy1StartByVelAc/63;
fmBy1Ramp.setStart(temp);
*/
temp = fmBy2Start + (Velocity-64)*fmBy2StartByVelAc/63;
fmBy2Ramp.setStart(temp);
temp = fmBy3Start + (Velocity-64)*fmBy3StartByVelAc/63;
fmBy3Ramp.setStart(temp);
//the same for the ringmod-ramp-envelopes:
temp = DB2AMP(rm12Start + (Velocity-64)*rm12StartByVelAc/63);
rm12Ramp.setStart(temp);
temp = DB2AMP(rm13Start + (Velocity-64)*rm13StartByVelAc/63);
rm13Ramp.setStart(temp);
temp = DB2AMP(rm23Start + (Velocity-64)*rm23StartByVelAc/63);
rm23Ramp.setStart(temp);
//trigger the ramp-envelops:
ampRamp1.trigger();
ampRamp2.trigger();
ampRamp3.trigger();
freqRamp1.trigger();
freqRamp2.trigger();
freqRamp3.trigger();
rm12Ramp.trigger();
rm13Ramp.trigger();
rm23Ramp.trigger();
detuneRamp.trigger();
amBy2Ramp.trigger();
amBy3Ramp.trigger();
fmBy1Ramp.trigger();
fmBy2Ramp.trigger();
fmBy3Ramp.trigger();
}
//slide to the new pitch witchout retriggering envelope and oscillator:
void AggressorOscSection::slideToNote(long NoteNumber, long Velocity, long Detune)
{
currentNote = NoteNumber;
targetPitch = NoteNumber + 0.01 * (double) Detune;
targetFreq = PITCH2FREQ(targetPitch);
double pitchDiff = targetPitch - currentPitch;
if(slideSamples<1) //immediate slide
{
pitchIncPerSamp = 0;
freqFacPerSamp = 1;
currentFreq = targetFreq;
currentPitch = targetPitch;
osc1.setFreq(targetFreq);
}
else //scale frequency sample by sample (is done in getSample)
{
pitchIncPerSamp = pitchDiff/slideSamples;
freqFacPerSamp = PITCHOFFSET2FREQFACTOR(pitchIncPerSamp);
}
//reset the sampleCounter:
slideSampCount = 0;
}
void AggressorOscSection::noteOff(long NoteNumber)
{
currentNote = -1;
}
void AggressorOscSection::setPitchBend(double PitchBend)
{freqBend = PITCHOFFSET2FREQFACTOR(PitchBend);}
//------------------------------------------------------------------------------------------------------------
//audio processing:
/*
__forceinline sample AggressorOscSection::getSample()
{
static sample instFreq1, instFreq2, instFreq3; //frequency at this instant of time (for the 3 oscs)
static sample ampFactor1, ampFactor2, ampFactor3;
//factor for the amplitudes (comes from envelope and amplitude modulation)
static sample vibFactor;
static sample instPulseWidth1, instPulseWidth2, instPulseWidth3, pulseWidthOffset;
static sample freqDeviation; //for FM in osc1
//the audio signals (at different satges of the signal chain):
static sample osc1Out, osc2Out, osc3Out,
osc1WithFilter, osc2WithFilter, osc3WithFilter,
osc1WithFilterAndEnv, osc2WithFilterAndEnv, osc3WithFilterAndEnv;
static sample rm12Out, rm13Out, rm23Out;
rm12Out = 0;
rm13Out = 0;
rm23Out = 0;
static sample outputSample;
//update the frequency (slide):
if(currentFreq!=targetFreq)
{
currentPitch += pitchIncPerSamp;
currentFreq *= freqFacPerSamp;
slideSampCount++;
}
//compensate for roundoff-error in frequency after slide:
if(slideSampCount>=slideSamples)
{
currentFreq = targetFreq;
currentPitch = targetPitch;
}
//calculate freq-factor for vibrato:
//if(vibIsActive)
vibFactor = PITCHOFFSET2FREQFACTOR(vibLfo.getSample()*vibDepth); //linear vibrato would be more efficient
//else
vibFactor = 1.0;
//calculate an offset for the pulseWidths from the PWM-LFO:
if(pwmIsActive)
pulseWidthOffset = pwmDepth*pwmLfo.getSample();
else
pulseWidthOffset = 0.0;
if(osc2IsPlaying)
{
instFreq2 = currentFreq*freqRamp2.getSample(); //applies by the pitch ramp:
instFreq2 *= tuneFactor2; //applies tuning-factor:
instFreq2 *= vibFactor; //applies the vibrato
instFreq2 *= freqBend; //applies pitchbend
instPulseWidth2 = pulseWidth2 + pulseWidthOffset; //applies pwm to the static pulseWidth
ampFactor2 = ampRamp2.getSample(); //calculates the output amplitude
//set up the oscillator:
osc2.freq = instFreq2;
osc2.setPulseWidth(instPulseWidth2); //the function-call makes sure that pw is between 0.01 and 0.99
osc2.calcIncrements();
//calculate the oscillators output:
//osc2Out = osc2.getSample();
osc2Out = osc2.getSampleAntiAliased();
//apply the static filter:
osc2WithFilter = bpf2.getSample(osc2Out);
//apply the amp-ramp:
osc2WithFilterAndEnv = osc2WithFilter*ampFactor2;
}
else
{
osc2Out = 0.0;
osc2WithFilter = 0.0;
osc2WithFilterAndEnv = 0.0;
}
if(osc3IsPlaying)
{
instFreq3 = currentFreq*freqRamp3.getSample(); //applies by the pitch ramp:
instFreq3 *= tuneFactor3; //applies tuning-factor:
instFreq3 *= vibFactor; //applies the vibrato
instFreq3 *= freqBend; //applies pitchbend
instPulseWidth3 = pulseWidth3 + pulseWidthOffset; //applies pwm to the static pulseWidth
ampFactor3 = ampRamp3.getSample(); //calculates the output amplitude
//set up the oscillator:
osc3.freq = instFreq3;
osc3.setPulseWidth(instPulseWidth3); //the function-call makes sure that pw is between 0.01 and 0.99
osc3.calcIncrements();
//calculate the oscillators output:
//osc3Out = osc3.getSample();
osc3Out = osc3.getSampleAntiAliased();
//apply the static filter:
osc3WithFilter = bpf3.getSample(osc3Out);
//apply the amp-ramp:
osc3WithFilterAndEnv = osc3WithFilter*ampFactor3;
}
else
{
osc3Out = 0.0;
osc3WithFilter = 0.0;
osc3WithFilterAndEnv = 0.0;
}
if(osc1IsPlaying)
{
instFreq1 = currentFreq*freqRamp1.getSample(); //applies by the pitch ramp
instFreq1 *= vibFactor; //applies the vibrato
instFreq1 *= freqBend; //applies pitchbend
instPulseWidth1 = pulseWidth1 + pulseWidthOffset; //applies pwm to the static pulseWidth
ampFactor1 = ampRamp1.getSample(); //calculates the output amplitude
//apply the modulations:
if(modulationsOff)
{
//do nothing
}
else if(modulationMode==1) //the oscillator outputs directly modulate osc1
{
//feedback-FM doesn't work yet
//calculate frequency deviation of osc1 caused by osc1 (feedback-FM):
//freqDeviation = fmBy1Ramp.getSample()*instFreq1;
//use the previous output of osc1 (it keeps its value from one call to another because it is
//declared as a static variable) to modulate osc's frequency:
//instFreq1 += fmBy1Ramp.getSample() * osc1Out * sampleRate * osc1.tableLengthRec;
//calculate frequency deviation of osc1 caused by osc2 :
freqDeviation = fmBy2Ramp.getSample()*instFreq2;
//use also the previous output of osc2 :
instFreq1 += freqDeviation * osc2Out;
//calculate frequency deviation of osc1 caused by osc3 :
freqDeviation = fmBy3Ramp.getSample()*instFreq3;
//use also the previous output of osc3 :
instFreq1 += freqDeviation * osc3Out;
//calculate the freq-deviation caused by feedback-fm:
instFreq1 = instFreq1 + fmBy1Ramp.getSample()*instFreq1*osc1Out; //ranges from 0 to 2*instFreq1
//does not work this way -> pitch decreases when incresing amount
//osc1.modulateIncrement(fmBy1Ramp.getSample()*osc1Out);
//calculate amplitude factor for osc1 from its envelope and the amplitude modulation ramps:
ampFactor1 = ampFactor1 * (1 + amBy2Ramp.getSample()*osc2Out);
ampFactor1 = ampFactor1 * (1 + amBy3Ramp.getSample()*osc3Out);
//calculate the ringmodulations output values:
rm12Out = osc1Out*osc2Out*rm12Ramp.getSample();
rm13Out = osc1Out*osc3Out*rm13Ramp.getSample();
rm23Out = osc2Out*osc3Out*rm23Ramp.getSample();
}
else if(modulationMode==2)
{
//calculate frequency deviation of osc1 caused by osc2 :
freqDeviation = fmBy2Ramp.getSample()*instFreq2;
//use also the previous output of osc2 :
instFreq1 += freqDeviation * osc2WithFilter;
//calculate frequency deviation of osc1 caused by osc3 :
freqDeviation = fmBy3Ramp.getSample()*instFreq3;
//use also the previous output of osc3 :
instFreq1 += freqDeviation * osc3WithFilter;
//calculate the freq-deviation caused by feedback-fm:
instFreq1 = instFreq1 + fmBy1Ramp.getSample()*instFreq1*osc1WithFilter; //ranges from 0 to 2*instFreq1
//calculate amplitude factor for osc1 from its envelope and the amplitude modulation ramps:
ampFactor1 = ampFactor1 * (1 + amBy2Ramp.getSample()*osc2WithFilter);
ampFactor1 = ampFactor1 * (1 + amBy3Ramp.getSample()*osc3WithFilter);
//calculate the ringmodulations output values:
rm12Out = osc1WithFilter*osc2WithFilter*rm12Ramp.getSample();
rm13Out = osc1WithFilter*osc3WithFilter*rm13Ramp.getSample();
rm23Out = osc2WithFilter*osc3WithFilter*rm23Ramp.getSample();
}
else if(modulationMode==3)
{
//calculate frequency deviation of osc1 caused by osc2 :
freqDeviation = fmBy2Ramp.getSample()*instFreq2;
//use also the previous output of osc2 :
instFreq1 += freqDeviation * osc2WithFilterAndEnv;
//calculate frequency deviation of osc1 caused by osc3 :
freqDeviation = fmBy3Ramp.getSample()*instFreq3;
//use also the previous output of osc3 :
instFreq1 += freqDeviation * osc3WithFilterAndEnv;
//calculate amplitude factor for osc1 from its envelope and the amplitude modulation ramps:
ampFactor1 = ampFactor1 * (1 + amBy2Ramp.getSample()*osc2WithFilterAndEnv);
ampFactor1 = ampFactor1 * (1 + amBy3Ramp.getSample()*osc3WithFilterAndEnv);
//calculate the ringmodulations output values:
rm12Out = osc1WithFilterAndEnv*osc2WithFilterAndEnv*rm12Ramp.getSample();
rm13Out = osc1WithFilterAndEnv*osc3WithFilterAndEnv*rm13Ramp.getSample();
rm23Out = osc2WithFilterAndEnv*osc3WithFilterAndEnv*rm23Ramp.getSample();
}
//set up the oscillator:
osc1.setDetune(detuneRamp.getSample());
osc1.setPulseWidth(instPulseWidth1); //the function-call makes sure that pw is between 0.01 and 0.99
osc1.setFreq(instFreq1); //optimize here!
//osc1.calcIncrements();
//calculate the oscillators output:
//osc1Out = osc1.getSample();
osc1Out = osc1.getSampleAntiAliased();
//apply the static filter:
osc1WithFilter = bpf1.getSample(osc1Out);
//apply the amp-ramp:
osc1WithFilterAndEnv = osc1WithFilter*ampFactor1;
}
else
{
osc1Out = 0.0;
osc1WithFilter = 0.0;
osc1WithFilterAndEnv = 0.0;
}
//sync if sync is active:
if(syncIsActive)
{
if( osc1.wraparoundOccurred && (syncMode==1 || syncMode==3) )
osc2.resetPhase();
if( osc1.wraparoundOccurred && (syncMode==2 || syncMode==3) )
osc3.resetPhase();
}
//add the signals:
outputSample = osc1WithFilterAndEnv + osc2WithFilterAndEnv + osc3WithFilterAndEnv
+ rm12Out + rm13Out + rm23Out;
return outputSample;
}
*/
//------------------------------------------------------------------------------------------------------------
//others:
void AggressorOscSection::resetOscillators()
{
if( phase1 <= 359.99 )
osc1.resetPhase();
if( phase2 <= 359.99 )
osc2.resetPhase();
if( phase3 <= 359.99 )
osc3.resetPhase();
// lfo's are always re-trigeered:
vibLfo.resetPhase();
pwmLfo.resetPhase();
}
| 27.849906 | 110 | 0.737301 | RobinSchmidt |
d8161240d9a11919311d33cf5afd9081d4138df2 | 3,710 | hpp | C++ | modules/core/gallery/include/nt2/gallery/functions/gallery_impl/invhilb.hpp | psiha/nt2 | 5e829807f6b57b339ca1be918a6b60a2507c54d0 | [
"BSL-1.0"
] | 34 | 2017-05-19T18:10:17.000Z | 2022-01-04T02:18:13.000Z | modules/core/gallery/include/nt2/gallery/functions/gallery_impl/invhilb.hpp | psiha/nt2 | 5e829807f6b57b339ca1be918a6b60a2507c54d0 | [
"BSL-1.0"
] | null | null | null | modules/core/gallery/include/nt2/gallery/functions/gallery_impl/invhilb.hpp | psiha/nt2 | 5e829807f6b57b339ca1be918a6b60a2507c54d0 | [
"BSL-1.0"
] | 7 | 2017-12-02T12:59:17.000Z | 2021-07-31T12:46:14.000Z | //==============================================================================
// Copyright 2003 - 2012 LASMEA UMR 6602 CNRS/Univ. Clermont II
// Copyright 2009 - 2012 LRI UMR 8623 CNRS/Univ Paris Sud XI
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#ifndef NT2_GALLERY_FUNCTIONS_GALLERY_IMPL_INVHILB_HPP_INCLUDED
#define NT2_GALLERY_FUNCTIONS_GALLERY_IMPL_INVHILB_HPP_INCLUDED
#include <nt2/include/functions/rec.hpp>
#include <nt2/include/functions/minusone.hpp>
#include <nt2/include/functions/sqr.hpp>
#include <nt2/include/functions/rif.hpp>
#include <nt2/include/functions/cif.hpp>
#include <nt2/include/functions/round2even.hpp>
namespace nt2{ namespace ext
{
BOOST_DISPATCH_IMPLEMENT ( invhilb_, tag::cpu_
, (A0)(T)
, (scalar_<integer_<A0> >)
(target_< scalar_< unspecified_<T> > >
)
)
{
typedef typename boost::proto::
result_of::make_expr< nt2::tag::invhilb_
, container::domain
, T, _2D
>::type result_type;
BOOST_FORCEINLINE result_type operator()(A0 a0,T const& tgt) const
{
return boost::proto::
make_expr < nt2::tag::invhilb_
, container::domain
>( tgt, _2D(a0,a0) );
}
};
BOOST_DISPATCH_IMPLEMENT ( invhilb_, tag::cpu_
, (A0)
, (scalar_<integer_<A0> >)
)
{
typedef typename boost::proto::
result_of::make_expr< nt2::tag::invhilb_
, container::domain
, meta::as_<double>
, _2D
>::type result_type;
BOOST_FORCEINLINE result_type operator()(A0 a0) const
{
return boost::proto::
make_expr < nt2::tag::invhilb_
, container::domain
>( meta::as_<double>(), _2D(a0,a0) );
}
};
BOOST_DISPATCH_IMPLEMENT ( run_assign_, tag::cpu_
, (A0)(A1)(N)
, ((ast_<A0, nt2::container::domain>))
((node_<A1,nt2::tag::invhilb_,N,nt2::container::domain>))
)
{
typedef A0& result_type;
typedef typename A0::value_type value_type;
result_type operator()(A0& out, const A1& in) const
{
_2D sz = boost::proto::value(boost::proto::child_c<1>(in));
out.resize(sz);
value_type n = sz[0];
value_type p = n;
value_type r = nt2::sqr(p);
out(1, 1) = r;
for(std::size_t j = 2; j <= n; ++j)
{
r = -((n-j+1)*r*(n+j-1))/nt2::sqr(j-1);
out(1,j) = r/j;
out(j,1) = out(1, j);
}
for(std::size_t i = 2; i <= n; ++i)
{
p = ((n-i+1)*p*(n+i-1))/nt2::sqr(i-1);
r = nt2::sqr(p);
out(i,i) = r/(2*i-1);
for(std::size_t j = i+1; j <= n; ++j)
{
r = -((n-j+1)*r*(n+j-1))/nt2::sqr(j-1);
out(i,j) = r/(i+j-1);
out(j,i) = out(i, j);
}
}
return out = nt2::round2even(out);
}
};
} }
#endif
| 33.423423 | 87 | 0.437197 | psiha |
d81b16346a72dceed10f671c098d126f6f86c10c | 221 | hpp | C++ | include/jln/mp.hpp | jonathanpoelen/jln.mp | e5f05fc4467f14ac0047e3bdc75a04076e689985 | [
"MIT"
] | 9 | 2020-07-04T16:46:13.000Z | 2022-01-09T21:59:31.000Z | include/jln/mp.hpp | jonathanpoelen/jln.mp | e5f05fc4467f14ac0047e3bdc75a04076e689985 | [
"MIT"
] | null | null | null | include/jln/mp.hpp | jonathanpoelen/jln.mp | e5f05fc4467f14ac0047e3bdc75a04076e689985 | [
"MIT"
] | 1 | 2021-05-23T13:37:40.000Z | 2021-05-23T13:37:40.000Z | #pragma once
#include <jln/mp/algorithm.hpp>
#include <jln/mp/error.hpp>
#include <jln/mp/functional.hpp>
#include <jln/mp/list.hpp>
#include <jln/mp/number.hpp>
#include <jln/mp/utility.hpp>
#include <jln/mp/value.hpp>
| 22.1 | 32 | 0.728507 | jonathanpoelen |
d81e696d806073560d7545b44687dfc400d1ce63 | 1,874 | cpp | C++ | src/ping_pong.cpp | duclos-cavalcanti/OpenMPI-Tutorial | 5a1adeac3e0aaf9eae3e478b8479e5ddcdf08055 | [
"MIT"
] | null | null | null | src/ping_pong.cpp | duclos-cavalcanti/OpenMPI-Tutorial | 5a1adeac3e0aaf9eae3e478b8479e5ddcdf08055 | [
"MIT"
] | null | null | null | src/ping_pong.cpp | duclos-cavalcanti/OpenMPI-Tutorial | 5a1adeac3e0aaf9eae3e478b8479e5ddcdf08055 | [
"MIT"
] | null | null | null | // Author: Wes Kendall
// Copyright 2011 www.mpitutorial.com
// This code is provided freely with the tutorials on mpitutorial.com. Feel
// free to modify it for your own use. Any distribution of the code must
// either provide a link to www.mpitutorial.com or keep this header intact.
//
// Ping pong example with MPI_Send and MPI_Recv. Two processes ping pong a
// number back and forth, incrementing it until it reaches a given value.
//
#include <iostream>
#include <mpi.h>
int main(int argc, char* argv[])
{
const int PING_PONG_LIMIT = 5;
// Initialize the MPI environment
MPI_Init(&argc, &argv);
// Find out rank and size
int world_rank, world_size;
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
// We are assuming exactly 2 processors for this task
if (world_size != 2)
{
std::cerr << "World size must be two for " << argv[0] << std::endl;
MPI_Abort(MPI_COMM_WORLD, 1);
}
int ping_pong_count = 0;
int partner_rank = (world_rank + 1) % 2;
while (ping_pong_count < PING_PONG_LIMIT)
{
if (world_rank == ping_pong_count % 2)
{
// Increment the ping pong count before you send it
ping_pong_count++;
MPI_Send(&ping_pong_count, 1, MPI_INT, partner_rank, 0, MPI_COMM_WORLD);
std::cout
<< "Processor " << world_rank
<< " sent ++ping_pong_count " << ping_pong_count
<< " to " << partner_rank << std::endl;
}
else
{
MPI_Recv(&ping_pong_count, 1, MPI_INT, partner_rank, 0, MPI_COMM_WORLD,
MPI_STATUS_IGNORE);
std::cout
<< "Processor " << world_rank
<< " received ping_pong_count " << ping_pong_count
<< " from " << partner_rank << std::endl;
}
}
// Finalize the MPI environment. No more MPI calls can be made after this
MPI_Finalize();
return 0;
} | 27.970149 | 78 | 0.65635 | duclos-cavalcanti |
d820d5cb1a2fd4de7e367b5ff1c59aee6347e408 | 3,835 | hh | C++ | source/include/Algorithm/Calorimetry/HoughTransformAlgorithm.hh | rete/Baboon | e5b2cfe6b9e5b5a41c2c68feda84b8df109eb086 | [
"FSFAP"
] | null | null | null | source/include/Algorithm/Calorimetry/HoughTransformAlgorithm.hh | rete/Baboon | e5b2cfe6b9e5b5a41c2c68feda84b8df109eb086 | [
"FSFAP"
] | null | null | null | source/include/Algorithm/Calorimetry/HoughTransformAlgorithm.hh | rete/Baboon | e5b2cfe6b9e5b5a41c2c68feda84b8df109eb086 | [
"FSFAP"
] | null | null | null | /*
*
* HoughTransformAlgorithm.hh header template generated by fclass
* Creation date : Thu Mar 14 21:55:13 2013
* Copyright (c) CNRS / IPNL
* All Right Reserved.
*
* Use and copying of these libraries and preparation of derivative works
* based upon these libraries are permitted. Any copy of these libraries
* must include this copyright notice.
*
* Written by : R. Eté
*/
#ifndef HOUGHTRANSFORMALGORITHM_HH
#define HOUGHTRANSFORMALGORITHM_HH
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <numeric>
#include <map>
#include <vector>
#include <utility>
#include <algorithm>
// sdhcal includes
#include "Algorithm/AbstractAlgorithm.hh"
#include "Objects/Cluster.hh"
#include "Managers/ClusteringManager.hh"
#include "Managers/TrackManager.hh"
#include "Reconstruction/Tag.hh"
#include "Utilities/ReturnValues.hh"
#include "Reconstruction/Linear3DFit.hh"
#include "TH2D.h"
#include "TCanvas.h"
#include "TGraph.h"
namespace baboon {
/*!
* @brief Class HoughTransformAlgorithm.
* Inherit from 'AbstractAlgorithm' base class.
*/
class HoughTransformAlgorithm : public AbstractAlgorithm {
/*!
* @brief Hough tag used in HoughTransformAlgorithm to tag candidate clusters
*/
enum HoughTag {
fGood,
fBad
};
/*!
*
* @brief Cluster structure for Hough Transform algorithm. Allows to tag the clusters while processing
*
*/
typedef struct {
public :
Cluster *cluster;
std::vector<int> rhox;
std::vector<int> rhoy;
HoughTag tagx;
HoughTag tagy;
HoughTag finalTag;
} HoughCluster;
typedef std::vector<HoughCluster*> HoughClusterCollection;
typedef struct {
public :
CaloHit *caloHit;
std::vector<int> rhox;
std::vector<int> rhoy;
HoughTag tagx;
HoughTag tagy;
HoughTag finalTag;
} HoughHit;
typedef std::vector<HoughHit*> HoughHitCollection;
/*!
*
* HoughPoint struct for Hough Transform Algorithm
*
*/
typedef struct {
CaloHit* caloHit;
double theta;
double rho;
int pointID;
} HoughPoint;
typedef std::vector<HoughPoint*> HoughPointCollection;
public :
/*!
*
* @brief Default Constructor
*
*/
HoughTransformAlgorithm();
/*!
*
* @brief Default Destructor
*
*/
virtual ~HoughTransformAlgorithm();
protected :
/*!
*
* @brief Initialize the algorithm, i.e by initializing specific variables
*
*/
virtual Return Init();
/*!
*
* @brief Execute the algorithm
*
*/
virtual Return Execute();
/*!
*
* @brief Finalize the algorithm
*
*/
virtual Return End();
/*!
*
* @brief Allow to check if everything is well set in the algorithm before starting it
*
*/
virtual Return CheckConsistency();
/*!
*
* @brief Delete the Hough parameter space ( 2D array )
*
*/
void DeleteHoughSpace();
/*!
*
* @brief Allocate the Hough parameter space ( 2D array )
*
*/
void AllocateHoughSpace();
// Algorithm parameters
int thetaMax;
int rMax;
int clusterSizeLimit;
int minimumBinning;
int deltaPosMax;
int trackSegmentMinimumSize;
int maximumDistanceBetweenHitsInPlane;
int maximumDistanceBetweenHitsForLayers;
double maximumDistanceAllowedForHitsInTrack;
int minimumNumberOfLayersForTrack;
double normalizedChi2Limit;
double chi2DifferenceLimit;
int trackModel;
int minHitOnTrack;
double maxHitDistXY;
double maxHitDistZ;
int binningLevel;
int baseBinning;
// new hough transform
double deltaThetaCluster;
double deltaRhoCluster;
int houghPointCollectionMinimumSize;
int ** houghSpaceX;
int ** houghSpaceY;
};
}
#endif // HOUGHTRANSFORMALGORITHM_HH
| 17.75463 | 104 | 0.669622 | rete |
d829a305b5cf67d1a528e2212a9ee3910ce0443b | 1,485 | cpp | C++ | src/World/World.cpp | cristianglezm/AntFarm | df7551621ad6eda6dae43a2ede56222500be1ae1 | [
"Apache-2.0"
] | null | null | null | src/World/World.cpp | cristianglezm/AntFarm | df7551621ad6eda6dae43a2ede56222500be1ae1 | [
"Apache-2.0"
] | 1 | 2016-03-13T10:55:21.000Z | 2016-03-13T10:55:21.000Z | src/World/World.cpp | cristianglezm/AntFarm | df7551621ad6eda6dae43a2ede56222500be1ae1 | [
"Apache-2.0"
] | null | null | null | #include <World/World.hpp>
namespace ant{
World::World()
: id(0)
, eventQueue(std::make_shared<EventQueue>())
, entityManager(std::make_shared<EntityManager>())
, systemManager(std::make_unique<SystemManager>()){}
World::World(int id)
: id(id)
, eventQueue(std::make_shared<EventQueue>())
, entityManager(std::make_shared<EntityManager>())
, systemManager(std::make_unique<SystemManager>()){}
World::World(int id,std::shared_ptr<EntityManager> eM,std::unique_ptr<SystemManager> sM,std::shared_ptr<EventQueue> eQ)
: id(id)
, eventQueue(eQ)
, entityManager(eM)
, systemManager(std::move(sM)){}
void World::setEntityManager(std::shared_ptr<EntityManager> eM){
entityManager = eM;
systemManager->setEntityManager(entityManager);
}
void World::setSystemManager(std::unique_ptr<SystemManager> sM){
systemManager = std::move(sM);
systemManager->setEntityManager(entityManager);
systemManager->setEventQueue(eventQueue);
}
void World::setEventQueue(std::shared_ptr<EventQueue> eQ){
eventQueue = eQ;
}
void World::setGameEventDispatcher(std::shared_ptr<GameEventDispatcher> ged){
gameEventDispatcher = ged;
}
void World::setId(int id){
this->id = id;
}
void World::update(const sf::Time& dt){
systemManager->update(dt);
}
void World::render(sf::RenderWindow& win){
systemManager->render(win);
}
}
| 33.75 | 123 | 0.660606 | cristianglezm |
d82fb1ca4994fdfb13d600c1456309668abfb87b | 103 | cpp | C++ | src/examples/06_module/01_bank/customer.cpp | acc-cosc-1337-fall-2020/acc-cosc-1337-fall-2020-Grecia1813 | f356c1ed8f6e75b9e9d6164747a5c199bead8c95 | [
"MIT"
] | null | null | null | src/examples/06_module/01_bank/customer.cpp | acc-cosc-1337-fall-2020/acc-cosc-1337-fall-2020-Grecia1813 | f356c1ed8f6e75b9e9d6164747a5c199bead8c95 | [
"MIT"
] | null | null | null | src/examples/06_module/01_bank/customer.cpp | acc-cosc-1337-fall-2020/acc-cosc-1337-fall-2020-Grecia1813 | f356c1ed8f6e75b9e9d6164747a5c199bead8c95 | [
"MIT"
] | null | null | null | //customer.cpp
#include "customer.h"
Demo::Demo()
{
cout << "2. Now the constructor is running\n";
} | 14.714286 | 48 | 0.650485 | acc-cosc-1337-fall-2020 |
d834f7a7a0796bddd9d752b80cca8a55eb26e282 | 3,440 | cpp | C++ | Graph/310. Minimum Height Trees/main.cpp | Minecodecraft/LeetCode-Minecode | 185fd6efe88d8ffcad94e581915c41502a0361a0 | [
"MIT"
] | 1 | 2021-11-19T19:58:33.000Z | 2021-11-19T19:58:33.000Z | Graph/310. Minimum Height Trees/main.cpp | Minecodecraft/LeetCode-Minecode | 185fd6efe88d8ffcad94e581915c41502a0361a0 | [
"MIT"
] | null | null | null | Graph/310. Minimum Height Trees/main.cpp | Minecodecraft/LeetCode-Minecode | 185fd6efe88d8ffcad94e581915c41502a0361a0 | [
"MIT"
] | 2 | 2021-11-26T12:47:27.000Z | 2022-01-13T16:14:46.000Z | //
// main.cpp
// 310. Minimum Height Trees
//
// Created by 边俊林 on 2019/11/13.
// Copyright © 2019 边俊林. All rights reserved.
//
#include <map>
#include <set>
#include <queue>
#include <string>
#include <stack>
#include <vector>
#include <cstdio>
#include <numeric>
#include <cstdlib>
#include <utility>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
/// Solution:
//
// Solution 1: Not conciselly
/*
class Solution {
public:
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
if (n == 1) return {0};
vector<int> degree (n, 0);
unordered_map<int, vector<int>> mp;
for (auto& e: edges) {
degree[e[0]]++;
degree[e[1]]++;
mp[e[0]].push_back(e[1]);
mp[e[1]].push_back(e[0]);
}
int last = n;
queue<int> q;
for (int i = 0; i < n; ++i)
if (degree[i] == 1) q.push(i);
while (q.size() && last > 2) {
int p = q.front(); q.pop();
degree[p]--;
last--;
for (auto it = mp[p].begin(); it != mp[p].end(); ++it) {
if (--degree[*it] == 1)
q.push(*it);
}
}
map<int, vector<int>> cnt;
while (q.size()) {
int p = q.front(); q.pop();
int num = countstep(mp, p, n);
cnt[num].push_back(p);
}
return cnt.empty() ? vector<int>() : cnt.begin()->second;
}
private:
const long long SEED = 1e6;
int countstep(unordered_map<int, vector<int>>& mp, int idx, int n) {
queue<long long> q;
vector<bool> vis (n, false);
int maxlevel = 0;
q.push(idx + 1 * SEED);
while (q.size()) {
long cp = q.front(); q.pop();
int level = cp / SEED;
int p = cp % SEED;
if (vis[p]) continue;
vis[p] = true;
maxlevel = max(maxlevel, level);
for (auto it = mp[p].begin(); it != mp[p].end(); ++it) {
q.push(*it + (level+1) * SEED);
}
}
return maxlevel;
}
};
*/
// Solution 2: Conciselly code
class Solution {
public:
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
// corner case
if (n == 1) return {0};
unordered_map<int, unordered_set<int>> mp;
for (auto& e: edges) {
mp[e[0]].insert(e[1]);
mp[e[1]].insert(e[0]);
}
vector<int> curr;
for (int i = 0; i < n; ++i)
if (mp[i].size() == 1)
curr.push_back(i);
while (true) {
vector<int> next;
for (auto& cur: curr) {
for (auto& adj: mp[cur]) {
mp[adj].erase(cur);
if (mp[adj].size() == 1)
next.push_back(adj);
}
}
if (next.empty())
return curr;
curr = next;
}
}
};
int main() {
Solution sol = Solution();
// int n = 4;
// int n = 6;
int n = 1;
vector<vector<int>> mat = {
// {1, 0}, {1, 2}, {1, 3}
// [0, 3], [1, 3], [2, 3], [4, 3], [5, 4]
};
auto res = sol.findMinHeightTrees(n, mat);
for_each(begin(res), end(res), [](int ele) { cout << ele << ", "; });
cout << endl;
return 0;
}
| 24.571429 | 73 | 0.451163 | Minecodecraft |
d8352c55a668b2a9e176f2bd98cdb41746e4a0d7 | 3,938 | cxx | C++ | test/test_utility.cxx | cmbrandt/stl-algorithms | 9eb0bc664e8423fb066c29aa501a72f4e672be1d | [
"MIT"
] | null | null | null | test/test_utility.cxx | cmbrandt/stl-algorithms | 9eb0bc664e8423fb066c29aa501a72f4e672be1d | [
"MIT"
] | null | null | null | test/test_utility.cxx | cmbrandt/stl-algorithms | 9eb0bc664e8423fb066c29aa501a72f4e672be1d | [
"MIT"
] | null | null | null | #include <array>
#include <iostream>
#include <utility.hxx>
#include <test_helpers.hxx>
#include <test_utility.hxx>
void test_utility()
{
int fail = 0;
fail = test_swap(fail);
fail = test_exchange(fail);
fail = test_forward(fail);
fail = test_move(fail);
fail = test_move_if_noexcept(fail);
if (fail == 0)
std::cout << "\ntest_utility() passed with zero errors." << std::endl;
else
std::cout << "\ntest_utility() had " << fail << " errors." << std::endl;
}
//
// Utility component tests
int test_swap(int fail)
{
int x{0};
int y{5};
std::array<int, 5> a{ 0, 1, 2, 3, 4 };
std::array<int, 5> b{ 2, 2, 2, 2, 2 };
std::array<int, 5> soln1{ 2, 2, 2, 2, 2 };
std::array<int, 5> soln2{ 0, 1, 2, 3, 4 };
cmb::swap(x, y);
cmb::swap(a, b);
bool r3 = compare_numeric_sequences( a.begin(), a.end(), soln1.begin() );
bool r4 = compare_numeric_sequences( b.begin(), b.end(), soln2.begin() );
if (x != 5 or y != 0 or r3 != false or r4 != false) {
++fail;
std::cout << "\nERROR! cmb::swap()"
<< "\nx = " << x
<< "\nsoln = " << 5
<< "\ny = " << y
<< "\nsoln = " << 0 << std::endl;
print_sequence( "a", a.begin(), a.end() );
print_sequence( "soln1", soln1.begin(), soln1.end() );
print_sequence( "b", b.begin(), b.end() );
print_sequence( "soln2", soln2.begin(), soln2.end() );
}
return fail;
}
int test_exchange(int fail)
{
int x{0};
int y{5};
int z = cmb::exchange(x, y);
if (x != 5 or y != 5 or z != 0) {
++fail;
std::cout << "\nERROR! cmb::exchange()"
<< "\nx = " << x
<< "\nsoln = " << 5
<< "\ny = " << y
<< "\nsoln = " << 5
<< "\ny = " << z
<< "\nsoln = " << 0
<< std::endl;
}
return fail;
}
//
// Helper functions for test_forward
// Function with lvalue and rvalue overloads
int f(int const& x) { return x; } // denotes lvalue
int f(int&& x) { x = 1; return x; } // denotes rvalue
// Function template
template <class T>
int g(T&& x)
{
int a = f( x ); // always an lvalue
int b = f( cmb::forward<T>(x) ); // rvalue if argument is an rvalue
return a + b;
}
int test_forward(int fail)
{
int a{5};
int r1 = g(a);
int r2 = g(5);
if (r1 != 10 or r2 != 6) {
++fail;
std::cout << "\nERROR! cmb::move()"
<< "\nr1 = " << r1
<< "\ns1 = " << 10
<< "\nr2 = " << r2
<< "\ns2 = " << 6
<< std::endl;
}
return fail;
}
int test_move(int fail)
{
std::string s1 = "abc";
std::string s2 = cmb::move(s1);
std::string r1 = "";
std::string r2 = "abc";
if (s1 != r1 or s2 != r2) {
++fail;
std::cout << "\nERROR! cmb::move()"
<< "\nr1 = " << r1
<< "\ns1 = " << s1
<< "\nr2 = " << r2
<< "\ns2 = " << s2
<< std::endl;
}
return fail;
}
//
// Helper structs for test_move_if_noexcept
// struct with noexcept move ctor and noexcept copy ctor
struct Good {
Good() = default;
Good(Good&&) noexcept { i = 1; }
Good(Good const&) noexcept { i = 2; }
int i{0};
};
// struct with move ctor and copy ctor that may throw
struct Bad {
Bad() = default;
Bad(Bad&&) { i = 3; }
Bad(Bad const&) { i = 4; }
int i{0};
};
int test_move_if_noexcept(int fail)
{
Good g1;
Bad b1;
Good g2( cmb::move_if_noexcept(g1) );
Bad b2( cmb::move_if_noexcept(b1) );
int r1 = g2.i;
int r2 = b2.i;
if (r1 != 1 or r2 != 4) {
++fail;
std::cout << "\nERROR! cmb::move_if_noexcept()"
<< "\nr1 = " << r1
<< "\nsoln1 = " << 1
<< "\nr2 = " << r2
<< "\nsoln2 = " << 4
<< std::endl;
}
return fail;
} | 20.298969 | 79 | 0.466988 | cmbrandt |
d83a1e36cb59e58725c9d29e38d2b894d0e82387 | 1,134 | cpp | C++ | source/core.cpp | henrygouk/nnet | dd33ce43852d2deb33e6495c0c1b1ba2227d2aa5 | [
"BSD-3-Clause"
] | 1 | 2018-10-12T01:33:23.000Z | 2018-10-12T01:33:23.000Z | source/core.cpp | henrygouk/nnet | dd33ce43852d2deb33e6495c0c1b1ba2227d2aa5 | [
"BSD-3-Clause"
] | 4 | 2015-07-21T02:24:13.000Z | 2016-07-06T10:06:31.000Z | source/core.cpp | henrygouk/nnet | dd33ce43852d2deb33e6495c0c1b1ba2227d2aa5 | [
"BSD-3-Clause"
] | 2 | 2016-07-06T08:56:01.000Z | 2018-03-04T02:55:29.000Z | #include <cstring>
#include <mm_malloc.h>
#include <nnet/types.hpp>
nnet_float *nnet_malloc(size_t length)
{
return (nnet_float *)_mm_malloc(sizeof(nnet_float) * length, 32);
}
void nnet_free(nnet_float *ptr)
{
_mm_free(ptr);
}
void nnet_shuffle_instances(nnet_float *features, nnet_float *labels, size_t length, size_t num_features, size_t num_labels)
{
nnet_float *temp_features = nnet_malloc(num_features);
nnet_float *temp_labels = nnet_malloc(num_labels);
for(size_t i = length - 1; i > 0; i--)
{
size_t j = rand() % i;
memcpy(temp_features, features + i * num_features, num_features * sizeof(nnet_float));
memcpy(features + i * num_features, features + j * num_features, num_features * sizeof(nnet_float));
memcpy(features + j * num_features, temp_features, num_features * sizeof(nnet_float));
memcpy(temp_labels, labels + i * num_labels, num_labels * sizeof(nnet_float));
memcpy(labels + i * num_labels, labels + j * num_labels, num_labels * sizeof(nnet_float));
memcpy(labels + j * num_labels, temp_labels, num_labels * sizeof(nnet_float));
}
nnet_free(temp_features);
nnet_free(temp_labels);
}
| 30.648649 | 124 | 0.737213 | henrygouk |
d83b223c6b3268602c1be98587d5769b27e9b1c1 | 634 | cc | C++ | test/lib/nut_Test_Particle.cc | losalamos/NuT | 5c6e03c45a380ae24ea9ee8bc2e68c3748ddd4e0 | [
"BSD-3-Clause"
] | 4 | 2015-01-01T13:47:53.000Z | 2016-03-31T01:56:43.000Z | test/lib/nut_Test_Particle.cc | losalamos/NuT | 5c6e03c45a380ae24ea9ee8bc2e68c3748ddd4e0 | [
"BSD-3-Clause"
] | 1 | 2019-05-08T16:21:43.000Z | 2019-05-14T17:20:19.000Z | test/lib/nut_Test_Particle.cc | lanl/NuT | 5c6e03c45a380ae24ea9ee8bc2e68c3748ddd4e0 | [
"BSD-3-Clause"
] | 4 | 2017-06-21T20:26:30.000Z | 2020-03-19T07:05:00.000Z | // T. M. Kelley (c) 2011 LANS LLC
#include "Particle.hh"
#include "RNG.hh"
#include "gtest/gtest.h"
#include "meshes/mesh_common/Vector.h"
TEST(nut_Particle, instantiation)
{
// for a very simple test, we can use a totally bogus RNG
typedef uint32_t rng_t;
typedef double fp_t;
using Vector = nut_mesh::Vector;
typedef nut::Particle<fp_t, rng_t, Vector> part_t;
fp_t x(1.0);
fp_t omega(1.0);
fp_t e(1.0);
fp_t t(1.0);
fp_t wt(1.0);
nut::cell_t cell(1);
nut::Species s(nut::nu_e);
rng_t rng(42);
part_t particle({x}, {omega}, e, t, wt, cell, rng, s);
EXPECT_TRUE(true);
return;
}
// End of file
| 18.647059 | 59 | 0.652997 | losalamos |
d83c80cd46a0f68e4e9d5774401f5ddc453b84d9 | 2,859 | cpp | C++ | net/socket/SocketAddress.cpp | w20089527/Net | ca40f0d4a5aa94c64abb8ccc7306bc66bdf12584 | [
"MIT"
] | 1 | 2019-08-10T20:29:13.000Z | 2019-08-10T20:29:13.000Z | net/socket/SocketAddress.cpp | whrool/Net | ca40f0d4a5aa94c64abb8ccc7306bc66bdf12584 | [
"MIT"
] | null | null | null | net/socket/SocketAddress.cpp | whrool/Net | ca40f0d4a5aa94c64abb8ccc7306bc66bdf12584 | [
"MIT"
] | null | null | null | // The MIT License (MIT)
//
// Copyright(c) 2015 huan.wang
//
// 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 <cassert>
#include "net/socket/SocketAddress.h"
namespace net {
struct SocketAddressPrivate
{
std::string Host;
uint16_t Port;
sockaddr_in Address;
};
SocketAddress::SocketAddress()
{
}
SocketAddress::SocketAddress(const std::string& strHost, uint16_t port)
: m_data(std::make_shared<SocketAddressPrivate>())
{
sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.S_un.S_addr = strHost.empty() ? htonl(ADDR_ANY) : inet_addr(strHost.c_str());
addr.sin_port = htons(port);
m_data->Host = strHost;
m_data->Port = port;
m_data->Address = addr;
}
SocketAddress::SocketAddress(const struct sockaddr* addr, int length)
: m_data(std::make_shared<SocketAddressPrivate>())
{
assert(sizeof(sockaddr_in) == length);
memcpy(&m_data->Address, addr, length);
m_data->Host = inet_ntoa(m_data->Address.sin_addr);
m_data->Port = ntohs(m_data->Address.sin_port);
}
SocketAddress::SocketAddress(const SocketAddress& address)
: m_data(address.m_data)
{
}
SocketAddress::~SocketAddress()
{
}
SocketAddress::operator bool() const
{
return bool(m_data);
}
std::string SocketAddress::GetHost() const
{
if (m_data)
return m_data->Host;
return "";
}
uint16_t SocketAddress::GetPort() const
{
if (m_data)
return m_data->Port;
return 0;
}
const struct sockaddr* SocketAddress::GetAddress() const
{
if (m_data)
return reinterpret_cast<const struct sockaddr*>(&m_data->Address);
return nullptr;
}
int SocketAddress::GetLength() const
{
if (m_data)
return sizeof(m_data->Address);
return 0;
}
} //!net | 28.59 | 130 | 0.693949 | w20089527 |
d844f0cf73b3ac22ab589bfd4bca3af1cfb12a9e | 335 | cpp | C++ | source/dynamic_static/vulkan/framebuffer-utilities.cpp | dynamic-static/Dynamic_Static.Graphics | b4fcf3c53519d3a63448aa7d9a90e07ec68d69d4 | [
"MIT"
] | 3 | 2017-11-20T15:42:41.000Z | 2020-05-02T22:05:39.000Z | source/dynamic_static/vulkan/framebuffer-utilities.cpp | DynamicStatic/Dynamic_Static.Graphics | b4fcf3c53519d3a63448aa7d9a90e07ec68d69d4 | [
"MIT"
] | null | null | null | source/dynamic_static/vulkan/framebuffer-utilities.cpp | DynamicStatic/Dynamic_Static.Graphics | b4fcf3c53519d3a63448aa7d9a90e07ec68d69d4 | [
"MIT"
] | null | null | null |
/*
==========================================
Copyright (c) 2021 dynamic_static
Licensed under the MIT license
http://opensource.org/licenses/MIT
==========================================
*/
#include "dynamic_static/vulkan/framebuffer-utilities.hpp"
namespace dst {
namespace vk {
} // namespace vk
} // namespace dst
| 19.705882 | 58 | 0.531343 | dynamic-static |
d8466183e691dba7d2b2345b07a478a3e7372dcf | 12,130 | cpp | C++ | src/ossim/util/ossimSlopeUtil.cpp | rkanavath/ossim18 | d2e8204d11559a6a868755a490f2ec155407fa96 | [
"MIT"
] | null | null | null | src/ossim/util/ossimSlopeUtil.cpp | rkanavath/ossim18 | d2e8204d11559a6a868755a490f2ec155407fa96 | [
"MIT"
] | null | null | null | src/ossim/util/ossimSlopeUtil.cpp | rkanavath/ossim18 | d2e8204d11559a6a868755a490f2ec155407fa96 | [
"MIT"
] | 1 | 2019-09-25T00:43:35.000Z | 2019-09-25T00:43:35.000Z | //*******************************************************************
// Copyright (C) 2000 ImageLinks Inc.
//
// License: MIT
//
// See LICENSE.txt file in the top level directory for more details.
//
// Author: Oscar Kramer
//
//*******************************************************************
// $Id: ossimSlopeUtil.cpp 23664 2015-12-14 14:17:27Z dburken $
#include <ossim/util/ossimSlopeUtil.h>
#include <ossim/init/ossimInit.h>
#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimApplicationUsage.h>
#include <ossim/base/ossimNotify.h>
#include <ossim/base/ossimPreferences.h>
#include <ossim/base/ossimGrect.h>
#include <ossim/base/ossimIrect.h>
#include <ossim/elevation/ossimElevManager.h>
#include <ossim/projection/ossimEquDistCylProjection.h>
#include <ossim/projection/ossimImageViewProjectionTransform.h>
#include <ossim/imaging/ossimSlopeFilter.h>
#include <ossim/imaging/ossimImageHandlerRegistry.h>
#include <ossim/imaging/ossimImageWriterFactoryRegistry.h>
#include <ossim/imaging/ossimTiffWriter.h>
#include <ossim/imaging/ossimIndexToRgbLutFilter.h>
#include <ossim/imaging/ossimScalarRemapper.h>
#include <ossim/imaging/ossimImageGeometry.h>
#include <ossim/imaging/ossimImageRenderer.h>
#include <ossim/imaging/ossimImageMosaic.h>
#include <iostream>
using namespace std;
ossimSlopeUtil::ossimSlopeUtil()
: m_aoiRadius(0),
m_remapToByte(false)
{
m_centerGpt.makeNan();
}
ossimSlopeUtil::~ossimSlopeUtil()
{
}
void ossimSlopeUtil::usage(ossimArgumentParser& ap)
{
// Add global usage options.
ossimInit::instance()->addOptions(ap);
// Add options.
addArguments(ap);
// Write usage.
ap.getApplicationUsage()->write(ossimNotify(ossimNotifyLevel_INFO));
ossimNotify(ossimNotifyLevel_INFO)
<< "\nUtility for computing the slope at each elevation post and generating "
<< "a corresponding slope image. The output scalar type is a normalized float with 1.0 = 90 "
<< "degree angle from the local vertical. Optional 8-bit scalar type is available."
<< "Examples:\n\n"
<< " ossim-slope [options] --dem <input-dem> <output-slope-image-file>\n"
<< " ossim-slope [options] --center <lat> <lon> --roi <meters> <output-slope-image-file>\n"
<< std::endl;
}
void ossimSlopeUtil::addArguments(ossimArgumentParser& ap)
{
// Set the general usage:
ossimApplicationUsage* au = ap.getApplicationUsage();
ossimString usageString = ap.getApplicationName();
usageString += " [options] <output-image>";
au->setCommandLineUsage(usageString);
// Set the command line options:
au->addCommandLineOption(
"--center <lat> <lon>",
"The center position of the output product. Required if no input DEM is specified.");
au->addCommandLineOption(
"--dem <filename>",
"Specifies the input DEM filename. If none provided, the elevation database is referenced "
"as specified in prefs file for the center and ROI specified.");
au->addCommandLineOption(
"--remap",
"The range of slope angle (0.0 to 90.0) is remapped to 0-255 (one byte/pixel)");
au->addCommandLineOption(
"--lut <filename>",
"Specifies the optional lookup table filename for mapping the single-band output "
"image to an RGB. The LUT provided must be in the ossimIndexToRgbLutFilter format "
"and should accomodate the output pixel range. This option forces remap to 8-bit, "
"0-255 where 255 = 90 deg slope");
au->addCommandLineOption(
"--request-api",
"Causes applications API to be output as JSON to stdout. Accepts optional filename "
"to store JSON output.");
au->addCommandLineOption(
"--roi <meters>",
"radius of interest surrounding the center point. If absent, the product defaults to "
"1024 x 1024 pixels, with a radius of 512 * GSD. Alternatively, if a DEM file is "
"specified, the product ROI defaults to the full DEM coverage.");
}
bool ossimSlopeUtil::initialize(ossimArgumentParser& ap)
{
if ( (ap.argc() == 1) || ap.read("-h") || ap.read("--help") )
{
usage(ap);
return false;
}
std::string ts1;
ossimArgumentParser::ossimParameter sp1(ts1);
std::string ts2;
ossimArgumentParser::ossimParameter sp2(ts2);
if (ap.read("--center", sp1, sp2))
{
m_centerGpt.lat = ossimString(ts1).toDouble();
m_centerGpt.lon = ossimString(ts2).toDouble();
m_centerGpt.hgt = 0.0;
}
if (ap.read("--dem", sp1))
m_demFile = ts1;
if ( ap.read("--remap"))
{
m_remapToByte = true;
}
if ( ap.read("--lut", sp1) )
m_lutFile = ts1;
if ( ap.read("--request-api", sp1))
{
ofstream ofs ( ts1.c_str() );
printApiJson(ofs);
ofs.close();
return false;
}
if ( ap.read("--request-api"))
{
printApiJson(cout);
return false;
}
if (ap.read("--roi", sp1))
m_aoiRadius = ossimString(ts1).toDouble();
if (m_demFile.empty() && m_centerGpt.hasNans())
{
ossimNotify(ossimNotifyLevel_WARN)<<"No DEM file nor center point provided. Cannot "
<<"compute slope image."<<endl;
usage(ap);
return false;
}
// There should only be the required command line args left:
if (ap.argc() != 2)
{
usage(ap);
return false;
}
m_slopeFile = ap[1];
return initializeChain();
}
bool ossimSlopeUtil::initializeChain()
{
// Establish connection to elevation data. Image handler (or combiner) returned in m_procChain:
if (!m_demFile.empty())
{
if (!loadDemFile())
return false;
}
else if (!loadElevDb())
return false;
ossimRefPtr<ossimSlopeFilter> slope_filter = new ossimSlopeFilter(m_procChain.get());
slope_filter->setSlopeType(ossimSlopeFilter::NORMALIZED);
m_procChain = slope_filter.get();
// If remap to one byte per pixel selected, insert remapper here:
if (m_remapToByte || !m_lutFile.empty())
{
ossimRefPtr<ossimScalarRemapper> sr = new ossimScalarRemapper;
sr->connectMyInputTo(0, m_procChain.get());
m_procChain = sr.get();
sr->setOutputScalarType(OSSIM_UINT8);
}
// If LUT remap requested, insert here in the chain:
if (!m_lutFile.empty())
{
if (m_lutFile.isReadable())
{
ossimRefPtr<ossimIndexToRgbLutFilter> lut = new ossimIndexToRgbLutFilter;
lut->connectMyInputTo(0, m_procChain.get());
m_procChain = lut.get();
lut->setLut(m_lutFile);
}
else
{
ossimNotify(ossimNotifyLevel_WARN)<<"The LUT file specified, <"<<m_lutFile<<"> is "
"not readbale. The LUT remap will be ignored."<<endl;
}
}
m_procChain->initialize();
return true;
}
bool ossimSlopeUtil::loadDemFile()
{
m_procChain = ossimImageHandlerRegistry::instance()->open(m_demFile, true, false);
if (!m_procChain.valid())
{
ossimNotify(ossimNotifyLevel_FATAL) << "Could not open DEM file at <"<<m_demFile
<<">. Aborting..."<<endl;
return false;
}
return true;
}
bool ossimSlopeUtil::loadElevDb()
{
// Determine if default GSD needs to be computed. Query for target H so as to autoload cell:
ossimElevManager* elevMgr = ossimElevManager::instance();
elevMgr->getHeightAboveEllipsoid(m_centerGpt);
double gsd = elevMgr->getMeanSpacingMeters();
if (ossim::isnan(gsd))
{
ossimNotify(ossimNotifyLevel_FATAL) << "Could not establish DEM GSD at center point "
<<m_centerGpt<<". Verify that the elevation database provides coverage at this "
<<"location."<<endl;
return false;
}
// Establish output radius if not provided:
ossimIrect viewRect(0, 0, 1023, 1023);
if (m_aoiRadius == 0)
{
// The radius of interest can default given a GSD to achieve a specific output image size.
m_aoiRadius = (viewRect.size().x + viewRect.size().y -2) * gsd / 4.0;
}
// Establish ground-space AOI rectangle:
ossimDpt metersPerDeg (m_centerGpt.metersPerDegree());
double dlat = m_aoiRadius/metersPerDeg.y;
double dlon = m_aoiRadius/metersPerDeg.x;
ossimGrect gndRect (m_centerGpt.lat + dlat, m_centerGpt.lon - dlon,
m_centerGpt.lat - dlat, m_centerGpt.lon + dlon);
// Query elevation manager for cells providing needed coverage:
std::vector<std::string> cells;
elevMgr->getCellsForBounds(gndRect, cells);
// Open a raster image for each elevation source being considered:
ossimConnectableObject::ConnectableObjectList elevChains;
std::vector<std::string>::iterator fname_iter = cells.begin();
while (fname_iter != cells.end())
{
ossimRefPtr<ossimImageHandler> dem =
ossimImageHandlerRegistry::instance()->open(*fname_iter);
if (!dem.valid())
{
ossimNotify(ossimNotifyLevel_WARN)
<< "ossimHLZUtil::initElevSources() ERR: Cannot open DEM file at <"
<<*fname_iter<<">\n"<< std::endl;
return false;
}
elevChains.push_back(dem.get());
++fname_iter;
}
// Establish the output image's projection geometry:
ossimRefPtr<ossimEquDistCylProjection> mapProj = new ossimEquDistCylProjection();
mapProj->setOrigin(m_centerGpt);
mapProj->setMetersPerPixel(ossimDpt(gsd, gsd));
ossimDpt degPerPixel(mapProj->getDecimalDegreesPerPixel());
mapProj->setElevationLookupFlag(false);
mapProj->setUlTiePoints(gndRect.ul());
ossimRefPtr<ossimImageGeometry> productGeom = new ossimImageGeometry(0, mapProj.get());
ossimDpt viewPt;
productGeom->worldToLocal(gndRect.ul(), viewPt);
viewRect.set_ulx(ossim::round<ossim_int32, double>(viewPt.x));
viewRect.set_uly(ossim::round<ossim_int32, double>(viewPt.y));
productGeom->worldToLocal(gndRect.lr(), viewPt);
viewRect.set_lrx(ossim::round<ossim_int32, double>(viewPt.x));
viewRect.set_lry(ossim::round<ossim_int32, double>(viewPt.y));
ossimIpt image_size(viewRect.width(), viewRect.height());
productGeom->setImageSize(image_size);
// Now loop to add a renderer to each input cell to insure common output projection:
ossimConnectableObject::ConnectableObjectList::iterator cell_iter = elevChains.begin();
while (cell_iter != elevChains.end())
{
ossimImageSource* chain = (ossimImageSource*) cell_iter->get();
ossimRefPtr<ossimImageViewProjectionTransform> ivt = new ossimImageViewProjectionTransform(
chain->getImageGeometry().get(), productGeom.get());
chain = new ossimImageRenderer(chain, ivt.get());
chain->initialize();
*cell_iter = chain;
++cell_iter;
}
// Finally create the combiner:
m_procChain = new ossimImageMosaic(elevChains);
return true;
}
bool ossimSlopeUtil::execute()
{
if (!m_procChain.valid())
{
if (!initializeChain())
return false;
}
// Set up the writer:
bool all_good = false;
ossimRefPtr<ossimTiffWriter> tif_writer = new ossimTiffWriter();
tif_writer->setGeotiffFlag(true);
tif_writer->setFilename(m_slopeFile);
if (tif_writer.valid())
{
tif_writer->connectMyInputTo(0, m_procChain.get());
ossimIrect viewRect;
m_procChain->getImageGeometry()->getBoundingRect(viewRect);
tif_writer->setAreaOfInterest(viewRect);
all_good = tif_writer->execute();
if (all_good)
ossimNotify(ossimNotifyLevel_INFO)<<"Output written to <"<<m_slopeFile<<">"<<endl;
else
{
ossimNotify(ossimNotifyLevel_FATAL)<<"Error encountered writing out slope image to <"
<<m_slopeFile<<">."<<endl;
}
}
return all_good;
}
void ossimSlopeUtil::printApiJson(ostream& out) const
{
ossimFilename json_path (ossimPreferences::instance()->findPreference("ossim_share_directory"));
json_path += "/ossim/util/ossimSlopeApi.json";
if (json_path.isReadable())
{
char line[256];
ifstream ifs (json_path.chars());
ifs.getline(line, 256);
while (ifs.good())
{
out << line << endl;
ifs.getline(line, 256);
}
ifs.close();
}
}
| 32.346667 | 100 | 0.662737 | rkanavath |
d84b98c24c424c30b717045c425aeaf4f67144fc | 941 | cpp | C++ | Leetcode/res/Binary Tree Paths/1.cpp | AllanNozomu/CompetitiveProgramming | ac560ab5784d2e2861016434a97e6dcc44e26dc8 | [
"MIT"
] | 1 | 2022-03-04T16:06:41.000Z | 2022-03-04T16:06:41.000Z | Leetcode/res/Binary Tree Paths/1.cpp | AllanNozomu/CompetitiveProgramming | ac560ab5784d2e2861016434a97e6dcc44e26dc8 | [
"MIT"
] | null | null | null | Leetcode/res/Binary Tree Paths/1.cpp | AllanNozomu/CompetitiveProgramming | ac560ab5784d2e2861016434a97e6dcc44e26dc8 | [
"MIT"
] | null | null | null | \*
Author: allannozomu
Runtime: 4 ms
Memory: 11.5 MB*\
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
void binaryTreecPathsRec(TreeNode* root, vector<string>& paths, string path){
if (root->left == NULL && root->right == NULL){
paths.push_back(path + to_string(root->val));
return;
}
if (root->left != NULL)
binaryTreecPathsRec(root->left, paths, path + to_string(root->val) + "->");
if (root->right != NULL)
binaryTreecPathsRec(root->right, paths, path + to_string(root->val) + "->");
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> res;
if (!root) return res;
binaryTreecPathsRec(root, res, "");
return res;
}
}; | 27.676471 | 88 | 0.563231 | AllanNozomu |
d851b73d72148dc84f24876dd7036dca78269130 | 9,947 | cpp | C++ | ortc/services/cpp/services_DHPublicKey.cpp | ortclib/ortclib-services-cpp | f770d97044b1ffbff04b61fa1488eedc8ddc66e4 | [
"BSD-2-Clause"
] | 2 | 2016-10-12T09:16:32.000Z | 2016-10-13T03:49:47.000Z | ortc/services/cpp/services_DHPublicKey.cpp | ortclib/ortclib-services-cpp | f770d97044b1ffbff04b61fa1488eedc8ddc66e4 | [
"BSD-2-Clause"
] | 2 | 2017-11-24T09:18:45.000Z | 2017-11-24T09:20:53.000Z | ortc/services/cpp/services_DHPublicKey.cpp | ortclib/ortclib-services-cpp | f770d97044b1ffbff04b61fa1488eedc8ddc66e4 | [
"BSD-2-Clause"
] | null | null | null | /*
Copyright (c) 2014, Hookflash 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:
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.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
*/
#include <ortc/services/internal/services_DHPublicKey.h>
#include <ortc/services/internal/services_DHKeyDomain.h>
#include <ortc/services/IHelper.h>
#include <zsLib/XML.h>
#include <zsLib/eventing/IHasher.h>
namespace ortc { namespace services { ZS_DECLARE_SUBSYSTEM(ortc_services) } }
namespace ortc
{
namespace services
{
namespace internal
{
using CryptoPP::AutoSeededRandomPool;
using namespace zsLib::XML;
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#pragma mark
#pragma mark IDHPublicKeyForDHPublicKey
#pragma mark
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#pragma mark
#pragma mark DHPublicKey
#pragma mark
//-----------------------------------------------------------------------
DHPublicKey::DHPublicKey(const make_private &)
{
ZS_LOG_DEBUG(log("created"))
}
//-----------------------------------------------------------------------
DHPublicKey::~DHPublicKey()
{
if(isNoop()) return;
ZS_LOG_DEBUG(log("destroyed"))
}
//-----------------------------------------------------------------------
DHPublicKeyPtr DHPublicKey::convert(IDHPublicKeyPtr publicKey)
{
return ZS_DYNAMIC_PTR_CAST(DHPublicKey, publicKey);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#pragma mark
#pragma mark DHPublicKey => IDHPublicKey
#pragma mark
//-----------------------------------------------------------------------
ElementPtr DHPublicKey::toDebug(IDHPublicKeyPtr keyDomain)
{
if (!keyDomain) return ElementPtr();
return convert(keyDomain)->toDebug();
}
//-----------------------------------------------------------------------
DHPublicKeyPtr DHPublicKey::load(
const SecureByteBlock &staticPublicKey,
const SecureByteBlock &ephemeralPublicKey
)
{
DHPublicKeyPtr pThis(make_shared<DHPublicKey>(make_private{}));
pThis->mStaticPublicKey.Assign(staticPublicKey);
pThis->mEphemeralPublicKey.Assign(ephemeralPublicKey);
if (ZS_IS_LOGGING(Trace)) {
ZS_LOG_TRACE(pThis->debug("loaded"))
} else {
ZS_LOG_DEBUG(pThis->log("loaded"))
}
return pThis;
}
//-----------------------------------------------------------------------
void DHPublicKey::save(
SecureByteBlock *outStaticPublicKey,
SecureByteBlock *outEphemeralPublicKey
) const
{
ZS_LOG_TRACE(log("save called"))
if (outStaticPublicKey) {
(*outStaticPublicKey).Assign(mStaticPublicKey);
}
if (outEphemeralPublicKey) {
(*outEphemeralPublicKey).Assign(mEphemeralPublicKey);
}
}
//-----------------------------------------------------------------------
String DHPublicKey::getFingerprint() const
{
return IHelper::convertToHex(*IHasher::hash(mStaticPublicKey, IHasher::hmacSHA1(mEphemeralPublicKey)));
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#pragma mark
#pragma mark DHPublicKey => IDHPublicKeyForDHPrivateKey
#pragma mark
//-----------------------------------------------------------------------
const SecureByteBlock &DHPublicKey::getStaticPublicKey() const
{
return mStaticPublicKey;
}
//-----------------------------------------------------------------------
const SecureByteBlock &DHPublicKey::getEphemeralPublicKey() const
{
return mEphemeralPublicKey;
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#pragma mark
#pragma mark DHPublicKey => (internal)
#pragma mark
//-----------------------------------------------------------------------
Log::Params DHPublicKey::log(const char *message) const
{
ElementPtr objectEl = Element::create("DHPublicKey");
IHelper::debugAppend(objectEl, "id", mID);
return Log::Params(message, objectEl);
}
//-----------------------------------------------------------------------
Log::Params DHPublicKey::debug(const char *message) const
{
return Log::Params(message, toDebug());
}
//-----------------------------------------------------------------------
ElementPtr DHPublicKey::toDebug() const
{
ElementPtr resultEl = Element::create("DHPublicKey");
IHelper::debugAppend(resultEl, "id", mID);
IHelper::debugAppend(resultEl, "static public key", IHelper::convertToHex(mStaticPublicKey, true));
IHelper::debugAppend(resultEl, "ephemeral public key", IHelper::convertToHex(mEphemeralPublicKey, true));
return resultEl;
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#pragma mark
#pragma mark IDHPublicKeyFactory
#pragma mark
//-----------------------------------------------------------------------
IDHPublicKeyFactory &IDHPublicKeyFactory::singleton()
{
return DHPublicKeyFactory::singleton();
}
//-----------------------------------------------------------------------
DHPublicKeyPtr IDHPublicKeyFactory::load(
const SecureByteBlock &staticPublicKey,
const SecureByteBlock &ephemeralPublicKey
)
{
if (this) {}
return DHPublicKey::load(staticPublicKey, ephemeralPublicKey);
}
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#pragma mark
#pragma mark IDHPublicKey
#pragma mark
//-------------------------------------------------------------------------
ElementPtr IDHPublicKey::toDebug(IDHPublicKeyPtr keyDomain)
{
return internal::DHPublicKey::toDebug(keyDomain);
}
//-------------------------------------------------------------------------
IDHPublicKeyPtr IDHPublicKey::load(
const SecureByteBlock &staticPublicKey,
const SecureByteBlock &ephemeralPublicKey
)
{
return internal::IDHPublicKeyFactory::singleton().load(staticPublicKey, ephemeralPublicKey);
}
}
}
| 39.472222 | 113 | 0.41701 | ortclib |
d85306e3e2c87156f925039aeee4b27cf7bb7a15 | 3,509 | cc | C++ | test/unit/Eval/EvalSubgoalTest.cc | mnowotnik/fovris | 82f692743fa6c96fef05041e686d716b03c22f07 | [
"BSD-3-Clause"
] | 4 | 2017-01-04T17:22:55.000Z | 2018-12-08T02:10:18.000Z | test/unit/Eval/EvalSubgoalTest.cc | Mike-Now/fovris | 82f692743fa6c96fef05041e686d716b03c22f07 | [
"BSD-3-Clause"
] | null | null | null | test/unit/Eval/EvalSubgoalTest.cc | Mike-Now/fovris | 82f692743fa6c96fef05041e686d716b03c22f07 | [
"BSD-3-Clause"
] | 1 | 2022-03-24T05:26:13.000Z | 2022-03-24T05:26:13.000Z | #include "KB/KBHeadLiteral.h"
#include "Eval/EvalSubgoal.h"
#include "Eval/TestUtils.h"
#include "thirdparty/Catch/include/catch.hpp"
#include <string>
using namespace fovris;
TEST_CASE("Check subgoal evaluation result", "[EvalSubgoal]") {
// given
unsigned relId = 0xDEADBEEF;
KBRelation relation{
relId, {TermType::Integer, TermType::Integer, TermType::Integer}};
KBGroundTerm Id1{10}, Id2{20}, Id3{30};
KBTuple tup{{Id1, Id2, Id1}, TruthValue::True};
KBTuple tup2{{Id1, Id2, Id3}, TruthValue::True};
relation.addTuple(tup);
relation.addTuple(tup2);
KBVarTerm X{1}, Y{2}, Z{5};
KBRuleLiteral kbr{relId, {X, Y, X}, TruthValue::True};
SECTION("Check EvalSubgoalFirst") {
auto evalFirst = CreateEvalSubgoalFirst(kbr, EvalDestination{Y, X});
// then
auto result = evalFirst->evaluate({}, relation.getFacts());
REQUIRE(result.size() == 1);
REQUIRE(result[0].getTerms().length() == 2);
REQUIRE(result[0].getTerms()[0] == Id2);
REQUIRE(result[0].getTerms()[1] == Id1);
}
SECTION("Check EvalSubgoalNext") {
KBRuleLiteral tmpKbr{relId, {X, Y, Z}, TruthValue::True};
auto evalNext = CreateEvalSubgoalNext(tmpKbr, kbr, {Y, Z});
// given
// then
KBTuple tmpTup = {{Id1, Id2, Id3}, TruthValue::True};
auto result = evalNext->evaluate({tmpTup}, relation.getFacts());
REQUIRE(result.size() == 1);
REQUIRE(result[0].getTerms().length() == 2);
REQUIRE(result[0].getTerms()[0] == Id2);
REQUIRE(result[0].getTerms()[1] == Id3);
}
}
TEST_CASE("Check subgoal with function evaluation", "[EvalSubgoal]") {
unsigned relId = 0;
TermMapper termMapper;
KBGroundTerm foo{termMapper.internTerm("foo")};
KBGroundTerm bar{termMapper.internTerm("bar")};
KBGroundTerm baz{termMapper.internTerm("baz")};
KBRelation relation{relId, {TermType::Id, TermType::Id, TermType::Id}};
relation.addFact({foo, bar, baz}, TruthValue::True);
relation.addFact({foo, foo, baz}, TruthValue::True);
KBVarTerm X{1}, Y{2}, Z{5};
KBRuleLiteral kbr{relId, {X, Y, Z}, TruthValue::True};
// function predicates matche
std::vector<KBRuleFunction> functions;
functions.emplace_back([](const Array<Term> &terms) -> bool {
return terms[0].get<std::string>() == "foo" &&
terms[1].get<std::string>() == "bar";
},
std::vector<KBTerm>{X, Y},
std::vector<TermType>{TermType::Id, TermType::Id});
KBRuleLiteral tmpKbr{relId, {X, Y, Z}, TruthValue::True};
auto evalNext =
CreateEvalSubgoalLast(tmpKbr, kbr, {Y, Z}, functions, termMapper);
KBTuple tmpTup = {{foo, bar, baz}, TruthValue::True};
auto result = evalNext->evaluate({tmpTup}, relation.getFacts());
REQUIRE(result.size() == 1);
// function predicates don't match
functions.emplace_back([](const Array<Term> &terms) -> bool {
return terms[0].get<std::string>() == "baz";
},
std::vector<KBTerm>{X, Y},
std::vector<TermType>{TermType::Id, TermType::Id});
evalNext =
CreateEvalSubgoalLast(tmpKbr, kbr, {Y, Z}, functions, termMapper);
result = evalNext->evaluate({tmpTup}, relation.getFacts());
REQUIRE(result.size() == 0);
}
| 34.401961 | 78 | 0.588487 | mnowotnik |
d858b4d2863db23ed4f62818c5eaf13a6d571930 | 2,115 | cpp | C++ | uppsrc/ide/Debuggers/GdbUtils.cpp | UltimateScript/Forgotten | ac59ad21767af9628994c0eecc91e9e0e5680d95 | [
"BSD-3-Clause"
] | null | null | null | uppsrc/ide/Debuggers/GdbUtils.cpp | UltimateScript/Forgotten | ac59ad21767af9628994c0eecc91e9e0e5680d95 | [
"BSD-3-Clause"
] | null | null | null | uppsrc/ide/Debuggers/GdbUtils.cpp | UltimateScript/Forgotten | ac59ad21767af9628994c0eecc91e9e0e5680d95 | [
"BSD-3-Clause"
] | null | null | null | #include "GdbUtils.h"
#include <memory>
#include <ide/Core/Logger.h>
#include <ide/Common/CommandLineOptions.h>
using namespace Upp;
One<IGdbUtils> GdbUtilsFactory::Create()
{
#if defined(PLATFORM_WIN32)
return MakeOne<GdbWindowsUtils>();
#elif defined(PLATFORM_POSIX)
return MakeOne<GdbPosixUtils>();
#endif
}
#if defined(PLATFORM_WIN32)
#define METHOD_NAME UPP_METHOD_NAME("GdbWindowsUtils")
using DeleteHandleFun = std::function<void(HANDLE)>;
static void DeleteHandle(HANDLE handle)
{
if (handle)
{
CloseHandle(handle);
}
}
String GdbWindowsUtils::BreakRunning(int pid)
{
std::unique_ptr<void, DeleteHandleFun> handle(OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid), &DeleteHandle);
if(!handle)
return String().Cat() << "Failed to open process associated with " << pid << " PID.";
if(Is64BitIde() && !Is64BitProcess(handle.get())) {
auto path = String().Cat() << GetExeFolder() << "\\" << GetExeTitle() << "32.exe";
auto cmd = String().Cat() << path << " " << COMMAND_LINE_GDB_DEBUG_BREAK_PROCESS_OPTION << " " << pid;
String out;
if(Sys(cmd, out) == COMMAND_LINE_GDB_DEBUG_BREAK_PROCESS_FAILURE_STATUS) {
Logd() << METHOD_NAME << cmd;
return String().Cat() << "Failed to interrupt process via 32-bit TheIDE. Output from command is \"" << out << "\".";
}
return "";
}
if (!DebugBreakProcess(handle.get()))
return String().Cat() << "Failed to break process associated with " << pid << " PID.";
return "";
}
bool GdbWindowsUtils::Is64BitIde() const
{
return sizeof(void*) == 8;
}
bool GdbWindowsUtils::Is64BitProcess(HANDLE handle) const
{
BOOL is_wow_64 = FALSE;
if(!IsWow64Process(handle, &is_wow_64)) {
Loge() << METHOD_NAME << "Failed to check that process is under wow64 emulation layer.";
}
return !is_wow_64;
}
#undef METHOD_NAME
#elif defined(PLATFORM_POSIX)
String GdbPosixUtils::BreakRunning(int pid)
{
if(kill(pid, SIGINT) == -1)
return String().Cat() << "Failed to interrupt process associated with " << pid << " PID.";
return "";
}
#endif
| 24.593023 | 120 | 0.661466 | UltimateScript |
d8711fe5a8b2142a73751d6580651b63e075013b | 9,749 | cpp | C++ | src/wrappers/src/mfx_gst_frame_constructor.cpp | AntonGrishin/gstreamer-plugins | 6d86897e02b525da4bf1d3f8b4bb6472cc72eb2b | [
"BSD-3-Clause"
] | 20 | 2016-08-06T02:31:53.000Z | 2022-01-24T13:29:41.000Z | src/wrappers/src/mfx_gst_frame_constructor.cpp | AntonGrishin/gstreamer-plugins | 6d86897e02b525da4bf1d3f8b4bb6472cc72eb2b | [
"BSD-3-Clause"
] | 5 | 2016-08-01T15:35:36.000Z | 2021-07-15T10:33:59.000Z | src/wrappers/src/mfx_gst_frame_constructor.cpp | AntonGrishin/gstreamer-plugins | 6d86897e02b525da4bf1d3f8b4bb6472cc72eb2b | [
"BSD-3-Clause"
] | 14 | 2016-08-18T23:42:06.000Z | 2021-05-16T22:06:59.000Z | /**********************************************************************************
Copyright (C) 2005-2019 Intel Corporation. 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 Intel Corporation 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 INTEL CORPORATION "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 INTEL CORPORATION 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 "mfx_defs.h"
#include "mfx_gst_debug.h"
#include "mfx_gst_frame_constructor.h"
#include "mfx_utils.h"
#undef MFX_DEBUG_MODULE_NAME
#define MFX_DEBUG_MODULE_NAME "mfx_gst_frame_constructor"
/*------------------------------------------------------------------------------*/
IMfxGstFrameConstuctor::IMfxGstFrameConstuctor():
m_bs_state(MfxGstBS_HeaderAwaiting)
{
MFX_DEBUG_TRACE_FUNC;
}
/*------------------------------------------------------------------------------*/
IMfxGstFrameConstuctor::~IMfxGstFrameConstuctor(void)
{
MFX_DEBUG_TRACE_FUNC;
if (buffered_bst_.Data) {
MSDK_FREE(buffered_bst_.Data);
}
}
/*------------------------------------------------------------------------------*/
mfxStatus IMfxGstFrameConstuctor::Load(std::shared_ptr<mfxGstBitstreamBufferRef> bst_ref, bool header)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = LoadToNativeFormat(bst_ref, header);
if (MFX_ERR_NONE != sts) {
Unload();
}
MFX_DEBUG_TRACE_I32(sts);
return sts;
}
/*------------------------------------------------------------------------------*/
mfxStatus IMfxGstFrameConstuctor::Unload(void)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = Sync();
current_bst_.reset();
MFX_DEBUG_TRACE_I32(sts);
return sts;
}
/*------------------------------------------------------------------------------*/
mfxStatus IMfxGstFrameConstuctor::Sync(void)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = MFX_ERR_NONE;
if (buffered_bst_.DataLength && buffered_bst_.DataOffset) {
memmove(buffered_bst_.Data, buffered_bst_.Data + buffered_bst_.DataOffset, buffered_bst_.DataLength);
}
buffered_bst_.DataOffset = 0;
mfxBitstream * bst = current_bst_.get() ? current_bst_->bst() : NULL;
if (bst && bst->DataLength) {
sts = buffered_bst_.Append(bst);
}
MFX_DEBUG_TRACE_I32(sts);
return sts;
}
/*------------------------------------------------------------------------------*/
mfxStatus IMfxGstFrameConstuctor::Reset(void)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = MFX_ERR_NONE;
buffered_bst_.Reset();
if (m_bs_state >= MfxGstBS_HeaderCollecting) m_bs_state = MfxGstBS_Resetting;
MFX_DEBUG_TRACE_I32(sts);
return sts;
}
/*------------------------------------------------------------------------------*/
mfxBitstream * IMfxGstFrameConstuctor::GetMfxBitstream(void)
{
MFX_DEBUG_TRACE_FUNC;
mfxBitstream * bst = nullptr;
auto loaded_bst = current_bst_ ? current_bst_->bst() : nullptr;
if (buffered_bst_.Data && buffered_bst_.DataLength) {
bst = &buffered_bst_;
}
else if (loaded_bst && loaded_bst->Data && loaded_bst->DataLength) {
bst = loaded_bst;
}
else {
bst = &buffered_bst_;
}
MFX_DEBUG_TRACE_P(&buffered_bst_);
MFX_DEBUG_TRACE_P(&loaded_bst);
MFX_DEBUG_TRACE_P(bst);
return bst;
}
/*------------------------------------------------------------------------------*/
IMfxGstFrameConstuctor* MfxGstFrameConstuctorFactory::CreateFrameConstuctor(MfxGstFrameConstuctorType type)
{
IMfxGstFrameConstuctor* fc = nullptr;
if (MfxGstFC_NoChange == type) {
fc = new MfxGstFrameConstuctor;
} else if (MfxGstFC_AVCC == type) {
fc = new MfxGstAVCFrameConstuctorAVCC;
}
return fc;
}
/*------------------------------------------------------------------------------*/
mfxStatus MfxGstFrameConstuctor::LoadToNativeFormat(std::shared_ptr<mfxGstBitstreamBufferRef> bst_ref, bool /*header*/)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = MFX_ERR_NONE;
auto bst = bst_ref ? bst_ref->bst() : nullptr;
if (buffered_bst_.DataLength) {
sts = buffered_bst_.Append(bst);
current_bst_.reset();
}
else {
current_bst_ = bst_ref;
}
MFX_DEBUG_TRACE_I32(sts);
return sts;
}
/*------------------------------------------------------------------------------*/
mfxStatus MfxGstAVCFrameConstuctorAVCC::LoadToNativeFormat(std::shared_ptr<mfxGstBitstreamBufferRef> bst_ref, bool header)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = MFX_ERR_NONE;
if (header) {
ConstructHeader(bst_ref);
}
else {
auto * bst = bst_ref ? bst_ref->bst() : nullptr;
convert_avcc_to_bytestream(bst);
if (buffered_bst_.DataLength) {
sts = buffered_bst_.Append(bst);
current_bst_.reset();
}
else {
current_bst_ = bst_ref;
}
}
MFX_DEBUG_TRACE_I32(sts);
return sts;
}
mfxStatus MfxGstAVCFrameConstuctorAVCC::ConstructHeader(std::shared_ptr<mfxGstBitstreamBufferRef> bst_ref)
{
MFX_DEBUG_TRACE_FUNC;
mfxStatus sts = MFX_ERR_NONE;
mfxU8 * data = NULL;
mfxU32 size = 0;
mfxU32 numOfSequenceParameterSets = 0;
mfxU32 numOfPictureParameterSets = 0;
mfxU32 sequenceParameterSetLength = 0;
mfxU32 pictureParameterSetLength = 0;
static mfxU8 header[4] = {0x00, 0x00, 0x00, 0x01};
MfxBistreamBuffer bst_header;
mfxBitstream * in_bst = bst_ref.get() ? bst_ref->bst() : NULL;
if (!in_bst) {
sts = MFX_ERR_NULL_PTR;
goto _done;
}
if ((bst_header.Extend(1024) != MFX_ERR_NONE) || (!bst_header.Data)) {
sts = MFX_ERR_MEMORY_ALLOC;
goto _done;
}
data = in_bst->Data;
size = in_bst->DataLength;
/* AVCDecoderConfigurationRecord:
* - mfxU8 - configurationVersion = 1
* - mfxU8 - AVCProfileIndication
* - mfxU8 - profile_compatibility
* - mfxU8 - AVCLevelIndication
* - mfxU8 - '111111'b + lengthSizeMinusOne
* - mfxU8 - '111'b + numOfSequenceParameterSets
* - for (i = 0; i < numOfSequenceParameterSets; ++i) {
* - mfxU16 - sequenceParameterSetLength
* - mfxU8*sequenceParameterSetLength - SPS
* }
* - mfxU8 - numOfPictureParameterSets
* - for (i = 0; i < numOfPictureParameterSets; ++i) {
* - mfxU16 - pictureParameterSetLength
* - mfxU8*pictureParameterSetLength - PPS
* }
*/
if (size < 5) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
data += 5;
size -= 5;
if (size < 1) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
numOfSequenceParameterSets = data[0] & 0x1f;
++data;
--size;
for (mfxU32 i = 0; i < numOfSequenceParameterSets; ++i) {
if (size < 2) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
sequenceParameterSetLength = (data[0] << 8) | data[1];
data += 2;
size -= 2;
if (size < sequenceParameterSetLength) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
if (bst_header.MaxLength - bst_header.DataOffset + bst_header.DataLength < 4 + sequenceParameterSetLength) {
if (MFX_ERR_NONE != bst_header.Extend(4 + sequenceParameterSetLength)) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
}
mfxU8 * buf = bst_header.Data + bst_header.DataOffset + bst_header.DataLength;
memcpy(buf, header, sizeof(mfxU8)*4);
memcpy(&(buf[4]), data, sizeof(mfxU8)*sequenceParameterSetLength);
data += sequenceParameterSetLength;
size -= sequenceParameterSetLength;
bst_header.DataLength += 4 + sequenceParameterSetLength;
}
if (size < 1) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
numOfPictureParameterSets = data[0];
++data;
--size;
for (mfxU32 i = 0; i < numOfPictureParameterSets; ++i) {
if (size < 2) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
pictureParameterSetLength = (data[0] << 8) | data[1];
data += 2;
size -= 2;
if (size < pictureParameterSetLength) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
if (bst_header.MaxLength - bst_header.DataOffset + bst_header.DataLength < 4 + pictureParameterSetLength) {
if (MFX_ERR_NONE != bst_header.Extend(4 + pictureParameterSetLength)) {
sts = MFX_ERR_NOT_ENOUGH_BUFFER;
goto _done;
}
}
mfxU8 * buf = bst_header.Data + bst_header.DataOffset + bst_header.DataLength;
memcpy(buf, header, sizeof(mfxU8)*4);
memcpy(&(buf[4]), data, sizeof(mfxU8)*pictureParameterSetLength);
data += pictureParameterSetLength;
size -= pictureParameterSetLength;
bst_header.DataLength += 4 + pictureParameterSetLength;
}
sts = buffered_bst_.Append(bst_header);
_done:
return sts;
}
| 28.673529 | 122 | 0.637296 | AntonGrishin |
d871c04714b3c998d4d0f8f20d2f85a9bd6f8ce3 | 206 | cpp | C++ | Object Oriented Algo Design in C++/practice/height_heap.cpp | aishwaryamallampati/BTech-IIITDM | 4cfc25a4e6e066b848361cb92770cad3260c7d48 | [
"MIT"
] | null | null | null | Object Oriented Algo Design in C++/practice/height_heap.cpp | aishwaryamallampati/BTech-IIITDM | 4cfc25a4e6e066b848361cb92770cad3260c7d48 | [
"MIT"
] | null | null | null | Object Oriented Algo Design in C++/practice/height_heap.cpp | aishwaryamallampati/BTech-IIITDM | 4cfc25a4e6e066b848361cb92770cad3260c7d48 | [
"MIT"
] | null | null | null | int height(int i,int size)
{
int l,r;
if(i>size)
return 0;
else
{
l=height(2*i,size);
r=height(((2*i)+1),size);
if(l>r)
{
l=l+1;
return l;
}
else
{
r=r+1;
return r;
}
}
}
| 9.363636 | 27 | 0.475728 | aishwaryamallampati |
d872dad72aa20ff0381e61a47744ec79c79d5686 | 4,281 | hpp | C++ | src/nnfusion/core/kernels/cpu/eigen/softmax.hpp | lynex/nnfusion | 6332697c71b6614ca6f04c0dac8614636882630d | [
"MIT"
] | 639 | 2020-09-05T10:00:59.000Z | 2022-03-30T08:42:39.000Z | src/nnfusion/core/kernels/cpu/eigen/softmax.hpp | QPC-database/nnfusion | 99ada47c50f355ca278001f11bc752d1c7abcee2 | [
"MIT"
] | 252 | 2020-09-09T05:35:36.000Z | 2022-03-29T04:58:41.000Z | src/nnfusion/core/kernels/cpu/eigen/softmax.hpp | QPC-database/nnfusion | 99ada47c50f355ca278001f11bc752d1c7abcee2 | [
"MIT"
] | 104 | 2020-09-05T10:01:08.000Z | 2022-03-23T10:59:13.000Z | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#pragma once
#include "../cpu_kernel_emitter.hpp"
#include "nnfusion/core/operators/generic_op/generic_op.hpp"
namespace nnfusion
{
namespace kernels
{
namespace cpu
{
template <typename ElementType>
class SoftmaxEigen : public EigenKernelEmitter
{
public:
SoftmaxEigen(shared_ptr<KernelContext> ctx)
: EigenKernelEmitter(ctx)
{
auto pad = static_pointer_cast<nnfusion::op::Softmax>(ctx->gnode->get_op_ptr());
input_shape = nnfusion::Shape(ctx->inputs[0]->get_shape());
output_shape = nnfusion::Shape(ctx->outputs[0]->get_shape());
axes = pad->get_axes();
output_type = ctx->outputs[0]->get_element_type().c_type_string();
rank = static_cast<uint32_t>(input_shape.size());
std::stringstream tag;
tag << rank << "softmax_i" << join(input_shape, "_") << "softmax_o"
<< join(output_shape, "_") << "_axes" << join(axes, "_");
custom_tag = tag.str();
}
LanguageUnit_p emit_function_body() override
{
LanguageUnit_p _lu(new LanguageUnit(get_function_name()));
auto& lu = *_lu;
if (m_context->inputs[0]->get_element_type() == element::f32)
{
nnfusion::Shape rdims(rank);
nnfusion::Shape bcast(rank);
for (size_t i = 0; i < rank; ++i)
{
if (axes.count(i))
{
rdims[i] = 1;
}
else
{
rdims[i] = input_shape[i];
}
}
for (size_t i = 0; i < rank; ++i)
{
bcast[i] = input_shape[i] / rdims[i];
}
auto code = nnfusion::op::create_code_from_template(
R"(
Eigen::array<Eigen::Index, @Rank@> in_dims({@in_dims@});
Eigen::array<Eigen::Index, @Rank@> rdims({@rdims@});
Eigen::array<Eigen::Index, @Rank@> bcast({@bcast@});
Eigen::array<Eigen::Index, @AxisCount@> axes({@axes@});
Eigen::TensorMap<Eigen::Tensor<@ElementType@, @Rank@, Eigen::RowMajor>> out(
static_cast<@ElementType@ *>(output0), in_dims),
in(static_cast<@ElementType@ *>(input0), in_dims);
out.device(*(thread_pool->GetDevice())) =
(in - in.maximum(axes).eval().reshape(rdims).broadcast(bcast)).exp();
out.device(*(thread_pool->GetDevice())) =
out * out.sum(axes).inverse().eval().reshape(rdims).broadcast(bcast);
)",
{{"Rank", rank},
{"AxisCount", axes.size()},
{"in_dims", join(input_shape)},
{"rdims", join(rdims)},
{"bcast", join(bcast)},
{"axes", join(axes)},
{"ElementType", output_type}});
lu << code;
}
else
{
return nullptr;
}
return _lu;
}
LanguageUnit_p emit_dependency() override
{
LanguageUnit_p _lu(new LanguageUnit(get_function_name() + "_dep"));
_lu->require(header::thread);
_lu->require(header::eigen_tensor);
return _lu;
}
private:
shared_ptr<KernelContext> kernel_ctx;
nnfusion::Shape input_shape, output_shape;
nnfusion::AxisSet axes;
uint32_t rank;
string output_type;
};
} // namespace cpu
} // namespace kernels
} // namespace nnfusion
| 38.223214 | 100 | 0.443354 | lynex |
d874fed91ddb84f034e8e97d57a87d232bd6e028 | 2,108 | hpp | C++ | Core/DescriptorSet.hpp | Shmaug/vkCAVE | e502aedaf172047557f0454acb170a46b9d350f8 | [
"MIT"
] | 2 | 2019-10-01T22:55:47.000Z | 2019-10-04T20:25:29.000Z | Core/DescriptorSet.hpp | Shmaug/vkCAVE | e502aedaf172047557f0454acb170a46b9d350f8 | [
"MIT"
] | null | null | null | Core/DescriptorSet.hpp | Shmaug/vkCAVE | e502aedaf172047557f0454acb170a46b9d350f8 | [
"MIT"
] | null | null | null | #pragma once
#include <Util/Util.hpp>
class Device;
class Texture;
class Buffer;
class Sampler;
class DescriptorSet {
public:
ENGINE_EXPORT DescriptorSet(const std::string& name, Device* device, VkDescriptorSetLayout layout);
ENGINE_EXPORT ~DescriptorSet();
ENGINE_EXPORT void CreateStorageBufferDescriptor(Buffer* buffer, uint32_t index, VkDeviceSize offset, VkDeviceSize range, uint32_t binding);
ENGINE_EXPORT void CreateStorageBufferDescriptor(Buffer* buffer, VkDeviceSize offset, VkDeviceSize range, uint32_t binding);
ENGINE_EXPORT void CreateStorageTexelBufferDescriptor(Buffer* view, uint32_t binding);
ENGINE_EXPORT void CreateUniformBufferDescriptor(Buffer* buffer, VkDeviceSize offset, VkDeviceSize range, uint32_t binding);
ENGINE_EXPORT void CreateStorageTextureDescriptor(Texture* texture, uint32_t binding, VkImageLayout layout = VK_IMAGE_LAYOUT_GENERAL);
ENGINE_EXPORT void CreateStorageTextureDescriptor(Texture* texture, uint32_t index, uint32_t binding, VkImageLayout layout = VK_IMAGE_LAYOUT_GENERAL);
ENGINE_EXPORT void CreateSampledTextureDescriptor(Texture* texture, uint32_t binding, VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
ENGINE_EXPORT void CreateSampledTextureDescriptor(Texture* texture, uint32_t index, uint32_t binding, VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
ENGINE_EXPORT void CreateSamplerDescriptor(Sampler* sampler, uint32_t binding);
ENGINE_EXPORT void FlushWrites();
inline VkDescriptorSetLayout Layout() const { return mLayout; }
inline operator const VkDescriptorSet*() const { return &mDescriptorSet; }
inline operator VkDescriptorSet() const { return mDescriptorSet; }
private:
std::unordered_map<uint64_t, VkWriteDescriptorSet> mCurrent;
std::vector<VkWriteDescriptorSet> mPending;
std::queue<VkDescriptorBufferInfo*> mBufferInfoPool;
std::queue<VkDescriptorImageInfo*> mImageInfoPool;
std::vector<VkDescriptorBufferInfo*> mPendingBuffers;
std::vector<VkDescriptorImageInfo*> mPendingImages;
Device* mDevice;
VkDescriptorSet mDescriptorSet;
VkDescriptorSetLayout mLayout;
}; | 45.826087 | 168 | 0.833491 | Shmaug |
d875c03131f5d23004d3af46de9f475a03d9e566 | 2,102 | cc | C++ | TC-programs/STUFF/sort_excitationsa.cc | sklinkusch/scripts | a717cadb559db823a0d5172545661d5afa2715e7 | [
"MIT"
] | null | null | null | TC-programs/STUFF/sort_excitationsa.cc | sklinkusch/scripts | a717cadb559db823a0d5172545661d5afa2715e7 | [
"MIT"
] | null | null | null | TC-programs/STUFF/sort_excitationsa.cc | sklinkusch/scripts | a717cadb559db823a0d5172545661d5afa2715e7 | [
"MIT"
] | null | null | null | # include <iostream>
# include <fstream>
# include <string.h>
# include <stdio.h>
# include <stdlib.h>
# include <sstream>
# include <math.h>
using namespace std;
void swap_line(int &froma, int &toa, double &coeffa, int &fromb, int &tob, double &coeffb){
int tempfrom, tempto;
double tempcoeff;
tempfrom = froma;
froma = fromb;
fromb = tempfrom;
tempto = toa;
toa = tob;
tob = tempto;
tempcoeff = coeffa;
coeffa = coeffb;
coeffb = tempcoeff;
}
int main(int argc, char* argv[]){
if(argc != 2){
cerr << "Usage: ./sort_excitations <infile>\n";
exit(0);
}
ifstream inf;
inf.open(argv[1]);
int nros;
double gsenergy;
inf >> gsenergy >> nros;
double* excenergies = new double[nros];
for(int i = 0; i < nros; i++) inf >> excenergies[i];
int limit, state;
double dndum;
double* upcoeff = new double[500];
int* frommo = new int[500];
int* tomo = new int[500];
for(int i = 0; i < nros; i++){
inf >> limit;
if(limit > 0){
for(int j = 0; j < limit; j++){
inf >> state >> frommo[j] >> tomo[j] >> upcoeff[j] >> dndum;
cout << state << " " << frommo[j] << " " << tomo[j] << " " << upcoeff[j] << " " << dndum << "\n";
}
for(int k = 0; k < (limit-2); k++){
if(k%2 == 0){
#pragma omp parallel for
for(int j = 0; j < (limit/2); j++){
if(fabs(upcoeff[2*j]) < fabs(upcoeff[2*j+1])){
swap_line(frommo[2*j], tomo[2*j], upcoeff[2*j], frommo[2*j+1], tomo[2*j+1], upcoeff[2*j+1]);
}
}
}else{
#pragma omp parallel for
for(int j = 0; j < (nros/2-1); j++){
if(fabs(upcoeff[2*j+1]) < fabs(upcoeff[2*j+2])){
swap_line(frommo[2*j+1], tomo[2*j+1], upcoeff[2*j+1], frommo[2*j+2], tomo[2*j+2], upcoeff[2*j+2]);
}
}
}
}
}
cout << "State: " << i << "\n";
if(limit >= 3){
for(int j = 0; j < 3; j++) cout << frommo[j] << " " << tomo[j] << " " << upcoeff[j] << "\n";
}else if(limit > 0){
for(int j = 0; j < limit; j++) cout << frommo[j] << " " << tomo[j] << " " << upcoeff[j] << "\n";
}else{
cout << "0 0 1.00000\n";
}
}
}
| 26.607595 | 103 | 0.519029 | sklinkusch |
f21d904334a6c51d4a57974b32bc4313dfb92ad1 | 1,929 | hpp | C++ | src/pyprx/visualization/three_js_group_py.hpp | aravindsiv/ML4KP | 064015a7545e1713cbcad3e79807b5cec0849f54 | [
"MIT"
] | 3 | 2021-05-31T11:28:03.000Z | 2021-05-31T13:49:30.000Z | src/pyprx/visualization/three_js_group_py.hpp | aravindsiv/ML4KP | 064015a7545e1713cbcad3e79807b5cec0849f54 | [
"MIT"
] | 1 | 2021-09-03T09:39:32.000Z | 2021-12-10T22:17:56.000Z | src/pyprx/visualization/three_js_group_py.hpp | aravindsiv/ML4KP | 064015a7545e1713cbcad3e79807b5cec0849f54 | [
"MIT"
] | 2 | 2021-09-03T09:17:45.000Z | 2021-10-04T15:52:58.000Z | #include <iostream>
#include <boost/python.hpp>
#include "prx/visualization/three_js_group.hpp"
void (prx::three_js_group_t::*update_vis_infos_1_1)(prx::info_geometry_t, const prx::trajectory_t&, std::string, prx::space_t*, std::string color) = &prx::three_js_group_t::add_vis_infos;
void (prx::three_js_group_t::*update_vis_infos_2_1)(prx::info_geometry_t, std::vector<prx::vector_t>, std::string, double) = &prx::three_js_group_t::add_vis_infos;
// void (prx::three_js_group_t::*update_vis_infos_2_2)(prx::info_geometry_t, std::vector<prx::vector_t>, std::string) = &prx::three_js_group_t::add_vis_infos;
// void (prx::three_js_group_t::*update_vis_infos_2_3)(prx::info_geometry_t, std::vector<prx::vector_t>) = &prx::three_js_group_t::add_vis_infos;
void pyprx_visualization_three_js_group_py()
{
enum_<prx::info_geometry_t>("info_geometry")
.value("LINE", prx::info_geometry_t::LINE)
.value("QUAD", prx::info_geometry_t::QUAD)
.value("FULL_LINE", prx::info_geometry_t::FULL_LINE)
.value("CIRCLE", prx::info_geometry_t::CIRCLE)
.export_values()
;
class_<prx::three_js_group_t>("three_js_group", init<std::vector<prx::system_ptr_t>, std::vector<std::shared_ptr<prx::movable_object_t>>>())
.def("output_html", &prx::three_js_group_t::output_html)
.def("update_vis_infos", &prx::three_js_group_t::update_vis_infos)
.def("add_vis_infos", update_vis_infos_1_1)
// .def("add_vis_infos", update_vis_infos_1_2)
.def("add_vis_infos", update_vis_infos_2_1)
// .def("add_vis_infos", update_vis_infos_2_2)
// .def("add_vis_infos", update_vis_infos_2_3)
.def("add_detailed_vis_infos", &prx::three_js_group_t::add_detailed_vis_infos)
.def("snapshot_state", &prx::three_js_group_t::snapshot_state)
;
}
| 53.583333 | 191 | 0.6817 | aravindsiv |
f22dfd860b4d10bf32ddef2f1593e46d9b44ea93 | 3,276 | cpp | C++ | src/util/node.cpp | markhary/ctci | eb96014b779e2a7eca1229644300bae18caf328d | [
"Unlicense"
] | 1 | 2021-11-17T16:50:54.000Z | 2021-11-17T16:50:54.000Z | src/util/node.cpp | markhary/ctci | eb96014b779e2a7eca1229644300bae18caf328d | [
"Unlicense"
] | null | null | null | src/util/node.cpp | markhary/ctci | eb96014b779e2a7eca1229644300bae18caf328d | [
"Unlicense"
] | 1 | 2020-06-15T13:54:04.000Z | 2020-06-15T13:54:04.000Z | // Node object
//
#include <iostream>
#include <vector>
#include <gtest/gtest.h>
#include "args.h"
#include "macros.h"
#include "util/node.h"
using namespace std;
using namespace ctci;
using namespace ctci::util;
TEST(Node, Initialize)
{
int value = 5;
Node<int> node(value);
ASSERT_EQ(node.value, value);
ASSERT_EQ(node.visitState, UNVISITED);
}
TEST(Node, Cout)
{
// Simple test
string test = "test";
const NodeTypeEnum nodeType = DIRECTED;
Node<string> node(test, nodeType);
stringstream testOutput;
testOutput << node;
string testExpected = "test -> {}";
ASSERT_EQ(testOutput.str(), testExpected);
// Complicated test
string nodeOne = "a";
string nodeTwo = "b";
string nodeThree = "c";
shared_ptr<Node<string>> node1(new Node<string>(nodeOne, nodeType));
shared_ptr<Node<string>> node2(new Node<string>(nodeTwo, nodeType));
shared_ptr<Node<string>> node3(new Node<string>(nodeThree, nodeType));
vector<pair<string, shared_ptr<Node<string>>>> adjacencyList = {{nodeTwo, node2}, {nodeThree, node3}};
node1->insert(adjacencyList);
string expectedOne = "a -> {b c}";
stringstream outputOne;
string expectedTwo = "b -> {}";
stringstream outputTwo;
string expectedThree = "c -> {}";
stringstream outputThree;
outputOne << *node1;
outputTwo << *node2;
outputThree << *node3;
ASSERT_EQ(outputOne.str(), expectedOne);
ASSERT_EQ(outputTwo.str(), expectedTwo);
ASSERT_EQ(outputThree.str(), expectedThree);
// Make sure output was not affected
outputOne.str("");
outputTwo.str("");
outputThree.str("");
outputOne << *node1;
outputTwo << *node2;
outputThree << *node3;
ASSERT_EQ(outputOne.str(), expectedOne);
ASSERT_EQ(outputTwo.str(), expectedTwo);
ASSERT_EQ(outputThree.str(), expectedThree);
}
TEST(Node, Insert)
{
string nodeOne = "one";
string nodeTwo = "two";
string nodeThree = "three";
shared_ptr<Node<string>> node1(new Node<string>(nodeOne));
shared_ptr<Node<string>> node2(new Node<string>(nodeTwo));
shared_ptr<Node<string>> node3(new Node<string>(nodeThree));
vector<pair<string, shared_ptr<Node<string>>>> adjacencyList = {{nodeTwo, node2}, {nodeThree, node3}};
node1->insert(adjacencyList);
ASSERT_EQ(node1->value, nodeOne);
ASSERT_EQ(node2->value, nodeTwo);
ASSERT_EQ(node3->value, nodeThree);
// Check duplicates are not successful
ASSERT_EQ(node1->insert({nodeTwo, node2}), false);
auto c2 = node1->connections.find(nodeTwo);
if ( c2 == node1->connections.end() ) {
ASSERT_EQ(true, false);
} else {
ASSERT_EQ(c2->first, nodeTwo);
}
auto c3 = node1->connections.find(nodeThree);
if ( c3 == node1->connections.end() ) {
ASSERT_EQ(true, false);
} else {
ASSERT_EQ(c3->first, nodeThree);
}
}
TEST(Node, Templating)
{
int intValue = 5;
Node<int> nodeInt(intValue);
ASSERT_EQ(nodeInt.value, intValue);
string stringValue = "abc";
Node<string> nodeString(stringValue);
ASSERT_EQ(nodeString.value, stringValue);
double doubleValue = 3.14;
Node<double> nodeDouble(doubleValue);
ASSERT_EQ(nodeDouble.value, doubleValue);
}
| 25.395349 | 106 | 0.654762 | markhary |
f2460ca1daec1f6e64ac04dc64574fc70288c57d | 2,121 | hpp | C++ | include/open-bo-api-crc64.hpp | sokoliko/open-bo-api | ddcad19163532543ad13a0398f0b0119e55d4c3d | [
"MIT"
] | 6 | 2020-02-09T06:40:03.000Z | 2021-09-08T09:38:19.000Z | include/open-bo-api-crc64.hpp | sokoliko/open-bo-api | ddcad19163532543ad13a0398f0b0119e55d4c3d | [
"MIT"
] | 3 | 2020-02-28T11:30:43.000Z | 2020-06-05T12:50:33.000Z | include/open-bo-api-crc64.hpp | sokoliko/open-bo-api | ddcad19163532543ad13a0398f0b0119e55d4c3d | [
"MIT"
] | 7 | 2020-03-24T22:31:25.000Z | 2021-11-24T17:13:56.000Z | /*
* open-bo-api - C++ API for working with binary options brokers
*
* Copyright (c) 2020 Elektro Yar. Email: [email protected]
*
* 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 OPEN_BO_API_CRC64_HPP_INCLUDED
#define OPEN_BO_API_CRC64_HPP_INCLUDED
namespace open_bo_api {
class CRC64 {
public:
inline static const long long poly = 0xC96C5795D7870F42;
inline static long long crc64_table[256];
inline static void generate_table(){
for(int i=0; i<256; ++i) {
long long crc = i;
for(int j=0; j<8; ++j) {
if(crc & 1) {
crc >>= 1;
crc ^= poly;
} else {
crc >>= 1;
}
}
crc64_table[i] = crc;
}
}
inline static long long calc_crc64(long long crc, const unsigned char* stream, int n) {
for(int i=0; i< n; ++i) {
unsigned char index = stream[i] ^ crc;
long long lookup = crc64_table[index];
crc >>= 8;
crc ^= lookup;
}
return crc;
}
inline static long long calc_crc64(const std::string str) {
return calc_crc64(0, (const unsigned char*)str.c_str(), str.size());
}
};
}
#endif // CRC64_HPP_INCLUDED
| 32.630769 | 89 | 0.704856 | sokoliko |
f24a6059fe50be8a4a5f21d303f9a8b110248f99 | 233 | cpp | C++ | src/caller/executor/executor.cpp | czhj/caller | 1f749bc039e731478a2a2f766445b8a14ac13063 | [
"MIT"
] | 1 | 2022-03-09T01:02:25.000Z | 2022-03-09T01:02:25.000Z | src/caller/executor/executor.cpp | czhj/caller | 1f749bc039e731478a2a2f766445b8a14ac13063 | [
"MIT"
] | null | null | null | src/caller/executor/executor.cpp | czhj/caller | 1f749bc039e731478a2a2f766445b8a14ac13063 | [
"MIT"
] | null | null | null | #include <caller/executor/executor.hpp>
CALLER_BEGIN
ExecutionContext::ExecutionContext()
{
}
ExecutionContext::~ExecutionContext()
{
}
Executor::Executor()
{
}
Executor::~Executor()
{
}
CALLER_END
| 8.961538 | 40 | 0.643777 | czhj |
f24f3f3faf0695de76ce2b2b4d575af04e5f9c12 | 70,427 | hpp | C++ | Evolutionary_Strategy_Vulkan.hpp | Harri-Renney/Survival_of_the_Synthesis-GPU_Accelerated_Frequency_Modulation_Parameter_Matcher | c70f8f2f2961148a7639fad05b3cf0d87f895c0c | [
"MIT"
] | null | null | null | Evolutionary_Strategy_Vulkan.hpp | Harri-Renney/Survival_of_the_Synthesis-GPU_Accelerated_Frequency_Modulation_Parameter_Matcher | c70f8f2f2961148a7639fad05b3cf0d87f895c0c | [
"MIT"
] | null | null | null | Evolutionary_Strategy_Vulkan.hpp | Harri-Renney/Survival_of_the_Synthesis-GPU_Accelerated_Frequency_Modulation_Parameter_Matcher | c70f8f2f2961148a7639fad05b3cf0d87f895c0c | [
"MIT"
] | null | null | null | #ifndef EVOLUTIONARY_STRATEGY_VULKAN_HPP
#define EVOLUTIONARY_STRATEGY_VULKAN_HPP
#include <math.h>
#include <array>
#include <random>
#include <chrono>
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
//Graphic math types and functions//
#include <glm\glm.hpp>
#include "Evolutionary_Strategy.hpp"
#include "Benchmarker.hpp"
#include "Vulkan_Helper.hpp"
//#define CL_HPP_TARGET_OPENCL_VERSION 200
//#define CL_HPP_MINIMUM_OPENCL_VERSION 200
#define CL_HPP_TARGET_OPENCL_VERSION 120
#define CL_HPP_MINIMUM_OPENCL_VERSION 120
#include <CL/cl2.hpp>
#include <clFFT.h>
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
#endif
struct Evolutionary_Strategy_Vulkan_Arguments
{
//Generic Evolutionary Strategy arguments//
Evolutionary_Strategy_Arguments es_args;
//Shader workgroup details//
uint32_t workgroupX = 32;
uint32_t workgroupY = 1;
uint32_t workgroupZ = 1;
uint32_t workgroupSize = workgroupX * workgroupY * workgroupZ;
uint32_t numWorkgroupsPerParent;
VkPhysicalDeviceType deviceType;
};
struct Specialization_Constants
{
uint32_t workgroupX = 32;
uint32_t workgroupY = 1;
uint32_t workgroupZ = 1;
uint32_t workgroupSize = 32;
uint32_t numDimensions = 4;
uint32_t populationCount = 1536;
uint32_t numWorkgroupsPerParent = 1; //population->num_parents / cl->work_group_size
uint32_t chunkSizeFitness = 1;
uint32_t audioWaveFormSize = 1024;
uint32_t fftOutSize = 1;
uint32_t fftHalfSize = 1;
float fftOneOverSize = 1.0;
float fftOneOverWindowFactor = 1.0;
float mPI = 3.14159265358979323846;
float alpha = 1.4f;
float oneOverAlpha = 1.f / alpha;
float rootTwoOverPi = sqrtf(2.f / (float)mPI);
float betaScale = 1.f / numDimensions; //1.f / (float)population->num_dimensions;
float beta = sqrtf(betaScale);
uint32_t chunksPerWorkgroupSynth = 2;
uint32_t chunkSizeSynth = workgroupSize / chunksPerWorkgroupSynth;
float OneOverSampleRateTimeTwoPi = 0.00014247573;
uint32_t populationSize = 1536 * 4;
} specializationData;
class Evolutionary_Strategy_Vulkan : public Evolutionary_Strategy
{
private:
//Shader workgroup details//
uint32_t globalSize;
uint32_t localSize;
uint32_t workgroupX;
uint32_t workgroupY;
uint32_t workgroupZ;
uint32_t workgroupSize;
uint32_t numWorkgroupsX;
uint32_t numWorkgroupsY;
uint32_t numWorkgroupsZ;
uint32_t chunks;
uint32_t chunkSize;
uint32_t chunkSizeFitness = 1; //@ToDo - Need this? Or just define in shader/kernel. Only important to GPU implementations so in subclass.
float* populationAudioDate;
float* populationFFTData;
//////////
//Vulkan//
//Instance//
VkInstance instance_;
//Physical Device//
VkPhysicalDevice physicalDevice_;
VkPhysicalDeviceType deviceType_;
//Logical Device//
VkDevice logicalDevice_;
//Compute Queue//
VkQueue computeQueue_; //A queue supporting compute operations.
uint32_t queueFamilyIndex_;
//Pipeline//
//FFT comes inbetween applyWindowPopulation & fitnessPopulation//
static const int numPipelines_ = 9;
enum computePipelineNames_ { initPopulation = 0, recombinePopulation, mutatePopulation, synthesisePopulation, applyWindowPopulation, VulkanFFT, fitnessPopulation, sortPopulation, rotatePopulation};
std::vector<std::string> shaderNames_;
VkPipeline computePipelines_[numPipelines_];
VkPipelineLayout computePipelineLayouts_[numPipelines_];
//Command Buffer//
VkCommandPool commandPoolInit_;
VkCommandBuffer commandBufferInit_;
VkQueryPool queryPoolInit_;
VkCommandPool commandPoolESOne_;
VkCommandBuffer commandBufferESOne_;
VkQueryPool queryPoolESOne_[5];
VkCommandPool commandPoolESTwo_;
VkCommandBuffer commandBufferESTwo_;
VkQueryPool queryPoolESTwo_[3];
float shaderExecuteTime_[numPipelines_];
VkCommandPool commandPoolFFT_;
VkCommandBuffer commandBufferFFT_;
//Descriptor//
VkDescriptorPool descriptorPool_;
VkDescriptorSet descriptorSet_;
VkDescriptorSetLayout descriptorSetLayout_;
std::vector<VkDescriptorPool> descriptorPools_;
std::vector<VkDescriptorSetLayout> descriptorSetLayouts_;
std::vector<VkDescriptorSet> descriptorSets_;
VkDescriptorPool descriptorPoolFFT_;
VkDescriptorSet descriptorSetFFT_;
VkDescriptorSetLayout descriptorSetLayoutFFT_;
//Constants//
static const int numSpecializationConstants_ = 23;
void* specializationConstantData_;
std::array<VkSpecializationMapEntry, numSpecializationConstants_> specializationConstantEntries_;
VkSpecializationInfo specializationConstantInfo_;
//Fences//
std::vector<VkFence> fences_;
//Population Buffers//
static const int numBuffers_ = 14;
enum storageBufferNames_ { inputPopulationValueBuffer = 0, inputPopulationStepBuffer, inputPopulationFitnessBuffer, outputPopulationValueBuffer, outputPopulationStepBuffer, outputPopulationFitnessBuffer, randomStatesBuffer, paramMinBuffer, paramMaxBuffer, outputAudioBuffer, inputFFTDataBuffer, inputFFTTargetBuffer, rotationIndexBuffer, wavetableBuffer};
std::array<VkBuffer, numBuffers_> storageBuffers_;
std::array<VkDeviceMemory, numBuffers_> storageBuffersMemory_;
std::array<uint32_t, numBuffers_> storageBufferSizes_;
//Staging Buffer//
VkQueue bufferQueue; //A queue for supporting memory buffer operations.
VkCommandPool commandPoolStaging_;
uint32_t stagingBufferSrcSize_;
VkBuffer stagingBufferSrc;
VkDeviceMemory stagingBufferMemorySrc;
void* stagingBufferSrcPointer;
uint32_t stagingBufferDstSize_;
VkBuffer stagingBufferDst;
VkDeviceMemory stagingBufferMemoryDst;
void* stagingBufferDstPointer;
Benchmarker vkBenchmarker_;
uint32_t rotationIndex_;
//Validation & Debug Variables//
VkDebugReportCallbackEXT debugReportCallback_;
std::vector<const char *> enabledValidationLayers;
static VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallbackFn(
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char* pLayerPrefix,
const char* pMessage,
void* pUserData)
{
printf("Debug Report: %s: %s\n", pLayerPrefix, pMessage);
return VK_FALSE;
}
void initConstantsVK()
{
//Setup specialization constant entries//
specializationConstantEntries_[0].constantID = 1;
specializationConstantEntries_[0].size = sizeof(specializationData.workgroupX);
specializationConstantEntries_[0].offset = 0;
specializationConstantEntries_[1].constantID = 2;
specializationConstantEntries_[1].size = sizeof(specializationData.workgroupY);
specializationConstantEntries_[1].offset = offsetof(Specialization_Constants, workgroupY);
specializationConstantEntries_[2].constantID = 3;
specializationConstantEntries_[2].size = sizeof(specializationData.workgroupZ);
specializationConstantEntries_[2].offset = offsetof(Specialization_Constants, workgroupZ);
specializationConstantEntries_[3].constantID = 4;
specializationConstantEntries_[3].size = sizeof(specializationData.workgroupSize);
specializationConstantEntries_[3].offset = offsetof(Specialization_Constants, workgroupSize);
specializationConstantEntries_[4].constantID = 5;
specializationConstantEntries_[4].size = sizeof(specializationData.numDimensions);
specializationConstantEntries_[4].offset = offsetof(Specialization_Constants, numDimensions);
specializationConstantEntries_[5].constantID = 6;
specializationConstantEntries_[5].size = sizeof(specializationData.populationCount);
specializationConstantEntries_[5].offset = offsetof(Specialization_Constants, populationCount);
specializationConstantEntries_[6].constantID = 7;
specializationConstantEntries_[6].size = sizeof(specializationData.numWorkgroupsPerParent);
specializationConstantEntries_[6].offset = offsetof(Specialization_Constants, numWorkgroupsPerParent);
specializationConstantEntries_[7].constantID = 8;
specializationConstantEntries_[7].size = sizeof(specializationData.chunkSizeFitness);
specializationConstantEntries_[7].offset = offsetof(Specialization_Constants, chunkSizeFitness);
specializationConstantEntries_[8].constantID = 9;
specializationConstantEntries_[8].size = sizeof(specializationData.audioWaveFormSize);
specializationConstantEntries_[8].offset = offsetof(Specialization_Constants, audioWaveFormSize);
specializationConstantEntries_[9].constantID = 10;
specializationConstantEntries_[9].size = sizeof(specializationData.fftOutSize);
specializationConstantEntries_[9].offset = offsetof(Specialization_Constants, fftOutSize);
specializationConstantEntries_[10].constantID = 11;
specializationConstantEntries_[10].size = sizeof(specializationData.fftHalfSize);
specializationConstantEntries_[10].offset = offsetof(Specialization_Constants, fftHalfSize);
specializationConstantEntries_[11].constantID = 12;
specializationConstantEntries_[11].size = sizeof(specializationData.fftOneOverSize);
specializationConstantEntries_[11].offset = offsetof(Specialization_Constants, fftOneOverSize);
specializationConstantEntries_[12].constantID = 13;
specializationConstantEntries_[12].size = sizeof(specializationData.fftOneOverWindowFactor);
specializationConstantEntries_[12].offset = offsetof(Specialization_Constants, fftOneOverWindowFactor);
specializationConstantEntries_[13].constantID = 14;
specializationConstantEntries_[13].size = sizeof(specializationData.mPI);
specializationConstantEntries_[13].offset = offsetof(Specialization_Constants, mPI);
specializationConstantEntries_[14].constantID = 15;
specializationConstantEntries_[14].size = sizeof(specializationData.alpha);
specializationConstantEntries_[14].offset = offsetof(Specialization_Constants, alpha);
specializationConstantEntries_[15].constantID = 16;
specializationConstantEntries_[15].size = sizeof(specializationData.oneOverAlpha);
specializationConstantEntries_[15].offset = offsetof(Specialization_Constants, oneOverAlpha);
specializationConstantEntries_[16].constantID = 17;
specializationConstantEntries_[16].size = sizeof(specializationData.rootTwoOverPi);
specializationConstantEntries_[16].offset = offsetof(Specialization_Constants, rootTwoOverPi);
specializationConstantEntries_[17].constantID = 18;
specializationConstantEntries_[17].size = sizeof(specializationData.betaScale);
specializationConstantEntries_[17].offset = offsetof(Specialization_Constants, betaScale);
specializationConstantEntries_[18].constantID = 19;
specializationConstantEntries_[18].size = sizeof(specializationData.beta);
specializationConstantEntries_[18].offset = offsetof(Specialization_Constants, beta);
specializationConstantEntries_[19].constantID = 20;
specializationConstantEntries_[19].size = sizeof(specializationData.chunksPerWorkgroupSynth);
specializationConstantEntries_[19].offset = offsetof(Specialization_Constants, chunksPerWorkgroupSynth);
specializationConstantEntries_[20].constantID = 21;
specializationConstantEntries_[20].size = sizeof(specializationData.chunkSizeSynth);
specializationConstantEntries_[20].offset = offsetof(Specialization_Constants, chunkSizeSynth);
specializationConstantEntries_[21].constantID = 22;
specializationConstantEntries_[21].size = sizeof(specializationData.OneOverSampleRateTimeTwoPi);
specializationConstantEntries_[21].offset = offsetof(Specialization_Constants, OneOverSampleRateTimeTwoPi);
specializationConstantEntries_[22].constantID = 23;
specializationConstantEntries_[22].size = sizeof(specializationData.populationSize);
specializationConstantEntries_[22].offset = offsetof(Specialization_Constants, populationSize);
//Setup specialization constant data//
specializationData.workgroupX = workgroupX;
specializationData.workgroupY = workgroupY;
specializationData.workgroupZ = workgroupZ;
specializationData.workgroupSize = workgroupSize;
specializationData.numDimensions = population.numDimensions;
specializationData.populationCount = population.populationLength;
specializationData.numWorkgroupsPerParent = population.numParents / workgroupSize;
specializationData.chunkSizeFitness = workgroupSize / 2;
specializationData.audioWaveFormSize = objective.audioLength;
specializationData.fftOutSize = objective.fftOutSize;
specializationData.fftHalfSize = objective.fftHalfSize;
specializationData.fftOneOverSize = objective.fftOneOverSize;
specializationData.fftOneOverWindowFactor = objective.fftOneOverWindowFactor;
specializationData.mPI = mPI;
specializationData.alpha = alpha;
specializationData.oneOverAlpha = oneOverAlpha;
specializationData.rootTwoOverPi = rootTwoOverPi;
specializationData.betaScale = betaScale;
specializationData.beta = beta;
specializationData.chunksPerWorkgroupSynth = 2;
specializationData.chunkSizeSynth = workgroupSize / specializationData.chunksPerWorkgroupSynth;
specializationData.OneOverSampleRateTimeTwoPi = 0.00014247573;
specializationData.populationSize = population.populationLength * population.numDimensions;
}
//@ToDo - Use local memory buffers correctly//
void initBuffersVK()
{
//Creating each buffer at time//
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[inputPopulationValueBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, storageBuffers_[inputPopulationValueBuffer], storageBuffersMemory_[inputPopulationValueBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[inputPopulationStepBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, storageBuffers_[inputPopulationStepBuffer], storageBuffersMemory_[inputPopulationStepBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[inputPopulationFitnessBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, storageBuffers_[inputPopulationFitnessBuffer], storageBuffersMemory_[inputPopulationFitnessBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[outputPopulationValueBuffer], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[outputPopulationValueBuffer], storageBuffersMemory_[outputPopulationValueBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[outputPopulationStepBuffer], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[outputPopulationStepBuffer], storageBuffersMemory_[outputPopulationStepBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[outputPopulationFitnessBuffer], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[outputPopulationFitnessBuffer], storageBuffersMemory_[outputPopulationFitnessBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[outputAudioBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, storageBuffers_[outputAudioBuffer], storageBuffersMemory_[outputAudioBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[randomStatesBuffer], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[randomStatesBuffer], storageBuffersMemory_[randomStatesBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[paramMinBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[paramMinBuffer], storageBuffersMemory_[paramMinBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[paramMaxBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[paramMaxBuffer], storageBuffersMemory_[paramMaxBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[inputFFTDataBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[inputFFTDataBuffer], storageBuffersMemory_[inputFFTDataBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[inputFFTTargetBuffer], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[inputFFTTargetBuffer], storageBuffersMemory_[inputFFTTargetBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[rotationIndexBuffer], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, storageBuffers_[rotationIndexBuffer], storageBuffersMemory_[rotationIndexBuffer]);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, storageBufferSizes_[wavetableBuffer], VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, storageBuffers_[wavetableBuffer], storageBuffersMemory_[wavetableBuffer]);
//Create Staging Buffer//
stagingBufferSrcSize_ = storageBufferSizes_[inputFFTDataBuffer];
stagingBufferDstSize_ = storageBufferSizes_[inputFFTDataBuffer];
VKHelper::createBuffer(physicalDevice_, logicalDevice_, stagingBufferSrcSize_, VK_BUFFER_USAGE_TRANSFER_SRC_BIT
, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBufferSrc, stagingBufferMemorySrc);
VKHelper::createBuffer(physicalDevice_, logicalDevice_, stagingBufferDstSize_, VK_BUFFER_USAGE_TRANSFER_DST_BIT
, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBufferDst, stagingBufferMemoryDst);
}
void initRandomStateBuffer()
{
//Initialize random numbers in CPU buffer//
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
std::default_random_engine generator(seed);
//std::uniform_int_distribution<int> distribution(0, 2147483647);
std::uniform_int_distribution<int> distribution(0, 32767);
//std::uniform_real_distribution<float> distribution(0.0, 1.0);
glm::uvec2* rand_state = new glm::uvec2[population.populationLength];
for (int i = 0; i < population.populationLength; ++i)
{
rand_state[i].x = distribution(generator);
rand_state[i].y = distribution(generator);
}
void* data;
uint32_t cpySize = population.populationLength * sizeof(glm::uvec2);
vkMapMemory(logicalDevice_, storageBuffersMemory_[randomStatesBuffer], 0, cpySize, 0, &data);
memcpy(data, rand_state, static_cast<size_t>(cpySize));
vkUnmapMemory(logicalDevice_, storageBuffersMemory_[randomStatesBuffer]);
}
void createInstance()
{
std::vector<const char *> enabledExtensions;
/*
By enabling validation layers, Vulkan will emit warnings if the API
is used incorrectly. We shall enable the layer VK_LAYER_LUNARG_standard_validation,
which is basically a collection of several useful validation layers.
*/
if (enableValidationLayers)
{
//Get all supported layers with vkEnumerateInstanceLayerProperties//
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, NULL);
std::vector<VkLayerProperties> layerProperties(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, layerProperties.data());
//Check if VK_LAYER_LUNARG_standard_validation is among supported layers//
bool foundLayer = false;
if (std::find_if(layerProperties.begin(), layerProperties.end(), [](const VkLayerProperties& m) -> bool { return strcmp(m.layerName, "VK_LAYER_KHRONOS_validation"); }) != layerProperties.end())
foundLayer = true;
if (!foundLayer) {
throw std::runtime_error("Layer VK_LAYER_KHRONOS_validation not supported\n");
}
enabledValidationLayers.push_back("VK_LAYER_KHRONOS_validation");
/*
We need to enable an extension named VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
in order to be able to print the warnings emitted by the validation layer.
Check if the extension is among the supported extensions.
*/
uint32_t extensionCount;
vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
std::vector<VkExtensionProperties> extensionProperties(extensionCount);
vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensionProperties.data());
bool foundExtension = false;
if (std::find_if(extensionProperties.begin(), extensionProperties.end(), [](const VkExtensionProperties& m) -> bool { return strcmp(m.extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME); }) != extensionProperties.end())
foundExtension = true;
if (!foundExtension) {
throw std::runtime_error("Extension VK_EXT_DEBUG_REPORT_EXTENSION_NAME not supported\n");
}
enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
}
//Create Vulkan instance//
VkApplicationInfo applicationInfo = {};
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
applicationInfo.pApplicationName = "Hello world app";
applicationInfo.applicationVersion = 0;
applicationInfo.pEngineName = "VkSoundMatch";
applicationInfo.engineVersion = 0;
applicationInfo.apiVersion = VK_API_VERSION_1_2;
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.flags = 0;
createInfo.pApplicationInfo = &applicationInfo;
// Give our desired layers and extensions to vulkan.
createInfo.enabledLayerCount = enabledValidationLayers.size();
createInfo.ppEnabledLayerNames = enabledValidationLayers.data();
createInfo.enabledExtensionCount = enabledExtensions.size();
createInfo.ppEnabledExtensionNames = enabledExtensions.data();
/*
Actually create the instance.
Having created the instance, we can actually start using vulkan.
*/
VK_CHECK_RESULT(vkCreateInstance(&createInfo, NULL, &instance_));
/*
Register a callback function for the extension VK_EXT_DEBUG_REPORT_EXTENSION_NAME, so that warnings emitted from the validation
layer are actually printed.
*/
if (enableValidationLayers) {
VkDebugReportCallbackCreateInfoEXT createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
createInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
createInfo.pfnCallback = &debugReportCallbackFn;
// We have to explicitly load this function.
auto vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(instance_, "vkCreateDebugReportCallbackEXT");
if (vkCreateDebugReportCallbackEXT == nullptr) {
throw std::runtime_error("Could not load vkCreateDebugReportCallbackEXT");
}
// Create and register callback.
VK_CHECK_RESULT(vkCreateDebugReportCallbackEXT(instance_, &createInfo, NULL, &debugReportCallback_));
}
}
//@ToDo - Correctly find the AMD GPU, not use intel one.//
void findPhysicalDevice()
{
//Collect physical devices available to VUlkan//
uint32_t deviceCount;
vkEnumeratePhysicalDevices(instance_, &deviceCount, NULL);
if (deviceCount == 0) {
throw std::runtime_error("could not find a device with vulkan support");
}
std::vector<VkPhysicalDevice> devices(deviceCount);
vkEnumeratePhysicalDevices(instance_, &deviceCount, devices.data());
//Iterate through and choose appropriate device//
for (VkPhysicalDevice device : devices) {
if (true) { // As above stated, we do no feature checks, so just accept.
VkPhysicalDeviceProperties deviceProperties;
VkPhysicalDeviceFeatures deviceFeatures;
vkGetPhysicalDeviceProperties(device, &deviceProperties);
vkGetPhysicalDeviceFeatures(device, &deviceFeatures);
printf("Device found: %s\n", deviceProperties.deviceName);
printf("Device maxDescriptorSetStorageBuffers: %d\n", deviceProperties.limits.maxDescriptorSetStorageBuffers);
if(deviceProperties.deviceType == deviceType_)
{
physicalDevice_ = device;
break;
}
}
}
}
// Returns the index of a queue family that supports compute operations.
uint32_t getComputeQueueFamilyIndex()
{
uint32_t queueFamilyCount;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueFamilyCount, NULL);
// Retrieve all queue families.
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueFamilyCount, queueFamilies.data());
// Now find a family that supports compute.
uint32_t i = 0;
for (; i < queueFamilies.size(); ++i) {
VkQueueFamilyProperties props = queueFamilies[i];
if (props.queueCount > 0 && (props.queueFlags & VK_QUEUE_COMPUTE_BIT)) {
// found a queue with compute. We're done!
break;
}
}
if (i == queueFamilies.size()) {
throw std::runtime_error("could not find a queue family that supports operations");
}
return i;
}
void createDevice()
{
/*
We create the logical device in this function.
*/
/*
When creating the device, we also specify what queues it has.
*/
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueFamilyIndex_ = getComputeQueueFamilyIndex(); // find queue family with compute capability.
queueCreateInfo.queueFamilyIndex = queueFamilyIndex_;
queueCreateInfo.queueCount = 1; // create one queue in this family. We don't need more.
float queuePriorities = 1.0; // we only have one queue, so this is not that imporant.
queueCreateInfo.pQueuePriorities = &queuePriorities;
/*
Now we create the logical device. The logical device allows us to interact with the physical
device.
*/
VkDeviceCreateInfo deviceCreateInfo = {};
// Specify any desired device features here. We do not need any for this application, though.
VkPhysicalDeviceFeatures deviceFeatures = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.enabledLayerCount = enabledValidationLayers.size(); // need to specify validation layers here as well.
deviceCreateInfo.ppEnabledLayerNames = enabledValidationLayers.data();
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo; // when creating the logical device, we also specify what queues it has.
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
VK_CHECK_RESULT(vkCreateDevice(physicalDevice_, &deviceCreateInfo, NULL, &logicalDevice_)); // create logical device.
// Get a handle to the only member of the queue family.
vkGetDeviceQueue(logicalDevice_, queueFamilyIndex_, 0, &computeQueue_);
}
// find memory type with desired properties.
uint32_t findMemoryType(uint32_t memoryTypeBits, VkMemoryPropertyFlags properties)
{
VkPhysicalDeviceMemoryProperties memoryProperties;
vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &memoryProperties);
/*
How does this search work?
See the documentation of VkPhysicalDeviceMemoryProperties for a detailed description.
*/
for (uint32_t i = 0; i < memoryProperties.memoryTypeCount; ++i) {
if ((memoryTypeBits & (1 << i)) &&
((memoryProperties.memoryTypes[i].propertyFlags & properties) == properties))
return i;
}
return -1;
}
void createDescriptorSetLayout()
{
/*
Here we specify a descriptor set layout. This allows us to bind our descriptors to
resources in the shader.
*/
/*
Here we specify a binding of type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER to the binding point
0. This binds to
layout(std140, binding = 0) buffer buf
in the compute shader.
*/
VkDescriptorSetLayoutBinding populationValueLayoutBinding = {};
populationValueLayoutBinding.binding = 0; // binding = 0
populationValueLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
populationValueLayoutBinding.descriptorCount = 1;
populationValueLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding populationStepLayoutBinding = {};
populationStepLayoutBinding.binding = 1; // binding = 0
populationStepLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
populationStepLayoutBinding.descriptorCount = 1;
populationStepLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding populationFitnessLayoutBinding = {};
populationFitnessLayoutBinding.binding = 2; // binding = 0
populationFitnessLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
populationFitnessLayoutBinding.descriptorCount = 1;
populationFitnessLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding populationValueTempLayoutBinding = {};
populationValueTempLayoutBinding.binding = 3; // binding = 0
populationValueTempLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
populationValueTempLayoutBinding.descriptorCount = 1;
populationValueTempLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding populationStepTempLayoutBinding = {};
populationStepTempLayoutBinding.binding = 4; // binding = 0
populationStepTempLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
populationStepTempLayoutBinding.descriptorCount = 1;
populationStepTempLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding populationFitnessTempLayoutBinding = {};
populationFitnessTempLayoutBinding.binding = 5; // binding = 0
populationFitnessTempLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
populationFitnessTempLayoutBinding.descriptorCount = 1;
populationFitnessTempLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding randStateLayoutBinding = {};
randStateLayoutBinding.binding = 6; // binding = 0
randStateLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
randStateLayoutBinding.descriptorCount = 1;
randStateLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding paramMinLayoutBinding = {};
paramMinLayoutBinding.binding = 7; // binding = 0
paramMinLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
paramMinLayoutBinding.descriptorCount = 1;
paramMinLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding paramMaxLayoutBinding = {};
paramMaxLayoutBinding.binding = 8; // binding = 0
paramMaxLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
paramMaxLayoutBinding.descriptorCount = 1;
paramMaxLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding audioWaveLayoutBinding = {};
audioWaveLayoutBinding.binding = 9; // binding = 0
audioWaveLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
audioWaveLayoutBinding.descriptorCount = 1;
audioWaveLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding FFTOutputLayoutBinding = {};
FFTOutputLayoutBinding.binding = 10; // binding = 0
FFTOutputLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
FFTOutputLayoutBinding.descriptorCount = 1;
FFTOutputLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding FFTTargetLayoutBinding = {};
FFTTargetLayoutBinding.binding = 11; // binding = 0
FFTTargetLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
FFTTargetLayoutBinding.descriptorCount = 1;
FFTTargetLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding rotationIndexLayoutBinding = {};
rotationIndexLayoutBinding.binding = 12; // binding = 0
rotationIndexLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
rotationIndexLayoutBinding.descriptorCount = 1;
rotationIndexLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutBinding wavetableLayoutBinding = {};
wavetableLayoutBinding.binding = 13; // binding = 0
wavetableLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
wavetableLayoutBinding.descriptorCount = 1;
wavetableLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
//Layout create information from binding layouts//
std::array<VkDescriptorSetLayoutBinding, numBuffers_> bindings = { populationValueLayoutBinding, populationStepLayoutBinding, populationFitnessLayoutBinding, populationValueTempLayoutBinding, populationStepTempLayoutBinding, populationFitnessTempLayoutBinding, randStateLayoutBinding, paramMinLayoutBinding, paramMaxLayoutBinding, audioWaveLayoutBinding, FFTOutputLayoutBinding, FFTTargetLayoutBinding, rotationIndexLayoutBinding, wavetableLayoutBinding };
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {};
descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptorSetLayoutCreateInfo.bindingCount = static_cast<uint32_t>(bindings.size()); // only a single binding in this descriptor set layout.
descriptorSetLayoutCreateInfo.pBindings = bindings.data();
//Create the descriptor set layout//
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(logicalDevice_, &descriptorSetLayoutCreateInfo, NULL, &descriptorSetLayout_));
}
void createDescriptorSet()
{
/*
So we will allocate a descriptor set here.
But we need to first create a descriptor pool to do that.
*/
/*
Our descriptor pool can only allocate a single storage buffer.
*/
std::array<VkDescriptorPoolSize, numBuffers_> poolSizes = {};
poolSizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[0].descriptorCount = 1;
poolSizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[1].descriptorCount = 1;
poolSizes[2].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[2].descriptorCount = 1;
poolSizes[3].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[3].descriptorCount = 1;
poolSizes[4].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[4].descriptorCount = 1;
poolSizes[5].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[5].descriptorCount = 1;
poolSizes[6].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[6].descriptorCount = 1;
poolSizes[7].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[7].descriptorCount = 1;
poolSizes[8].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[8].descriptorCount = 1;
poolSizes[9].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[9].descriptorCount = 1;
poolSizes[10].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[10].descriptorCount = 1;
poolSizes[11].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[11].descriptorCount = 1;
poolSizes[12].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[12].descriptorCount = 1;
poolSizes[13].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
poolSizes[13].descriptorCount = 1;
VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {};
descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptorPoolCreateInfo.maxSets = 1; // we only need to allocate one descriptor set from the pool.
descriptorPoolCreateInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
descriptorPoolCreateInfo.pPoolSizes = poolSizes.data();
// create descriptor pool.
VK_CHECK_RESULT(vkCreateDescriptorPool(logicalDevice_, &descriptorPoolCreateInfo, NULL, &descriptorPool_));
/*
With the pool allocated, we can now allocate the descriptor set.
*/
VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = {};
descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
descriptorSetAllocateInfo.descriptorPool = descriptorPool_; // pool to allocate from.
descriptorSetAllocateInfo.descriptorSetCount = 1; // allocate a single descriptor set.
descriptorSetAllocateInfo.pSetLayouts = &descriptorSetLayout_;
// allocate descriptor set.
VK_CHECK_RESULT(vkAllocateDescriptorSets(logicalDevice_, &descriptorSetAllocateInfo, &descriptorSet_));
/*
Next, we need to connect our actual storage buffer with the descrptor.
We use vkUpdateDescriptorSets() to update the descriptor set.
*/
std::array<VkDescriptorBufferInfo, numBuffers_> descriptorBuffersInfo;
std::array<VkWriteDescriptorSet, numBuffers_> descriptorWrites = {};
for (uint32_t i = 0; i != numBuffers_; ++i)
{
descriptorBuffersInfo[i].buffer = storageBuffers_[i];
descriptorBuffersInfo[i].offset = 0;
descriptorBuffersInfo[i].range = storageBufferSizes_[i];
descriptorWrites[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrites[i].dstSet = descriptorSet_;
descriptorWrites[i].dstBinding = i;
descriptorWrites[i].dstArrayElement = 0;
descriptorWrites[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
descriptorWrites[i].descriptorCount = 1; //@ToDo - May need higher count.
descriptorWrites[i].pBufferInfo = &(descriptorBuffersInfo[i]);
}
// perform the update of the descriptor set.
vkUpdateDescriptorSets(logicalDevice_, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, NULL);
}
void createComputePipelines() //create pipelines
{
VkSpecializationInfo specializationInfo{};
specializationInfo.dataSize = sizeof(specializationData);
specializationInfo.mapEntryCount = static_cast<uint32_t>(specializationConstantEntries_.size());
specializationInfo.pMapEntries = specializationConstantEntries_.data();
specializationInfo.pData = &specializationData;
VkPushConstantRange pushConstantRange[1] = {};
pushConstantRange[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
pushConstantRange[0].offset = 0;
pushConstantRange[0].size = sizeof(uint32_t);
for (uint8_t i = 0; i != numPipelines_; ++i)
{
/*
Now let us actually create the compute pipeline.
A compute pipeline is very simple compared to a graphics pipeline.
It only consists of a single stage with a compute shader.
So first we specify the compute shader stage, and it's entry point(main).
*/
uint32_t filelength;
std::string fileName = "shaders/" + shaderNames_[i];
std::vector<char> code = VKHelper::readFile(fileName);
VkShaderModule shaderModule = VKHelper::createShaderModule(logicalDevice_, code);
VkPipelineShaderStageCreateInfo shaderStageCreateInfo = {};
shaderStageCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shaderStageCreateInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
shaderStageCreateInfo.module = shaderModule;
shaderStageCreateInfo.pName = "main";
shaderStageCreateInfo.pSpecializationInfo = &specializationInfo;
/*
The pipeline layout allows the pipeline to access descriptor sets.
So we just specify the descriptor set layout we created earlier.
All pipelines are going to access the same descriptors to start with.
*/
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {};
pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutCreateInfo.setLayoutCount = 1;
pipelineLayoutCreateInfo.pSetLayouts = &descriptorSetLayout_;
pipelineLayoutCreateInfo.pushConstantRangeCount = 1;
pipelineLayoutCreateInfo.pPushConstantRanges = pushConstantRange;
VK_CHECK_RESULT(vkCreatePipelineLayout(logicalDevice_, &pipelineLayoutCreateInfo, NULL, &(computePipelineLayouts_[i])));
VkComputePipelineCreateInfo pipelineCreateInfo = {};
pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
pipelineCreateInfo.stage = shaderStageCreateInfo;
pipelineCreateInfo.layout = (computePipelineLayouts_[i]);
VK_CHECK_RESULT(vkCreateComputePipelines(logicalDevice_, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &(computePipelines_[i])));
vkDestroyShaderModule(logicalDevice_, shaderModule, NULL);
std::cout << "Created shader: " << fileName.c_str() << std::endl;
}
}
void createCopyCommandPool()
{
VkCommandPoolCreateInfo commandPoolCreateInfo = {};
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
commandPoolCreateInfo.flags = 0;
// the queue family of this command pool. All command buffers allocated from this command pool,
// must be submitted to queues of this family ONLY.
commandPoolCreateInfo.queueFamilyIndex = queueFamilyIndex_;
VK_CHECK_RESULT(vkCreateCommandPool(logicalDevice_, &commandPoolCreateInfo, NULL, &commandPoolStaging_));
}
void calculateAudioFFT()
{
//int counter = 0;
//for (uint32_t i = 0; i != population.populationSize * objective.audioLength; i += objective.audioLength)
//{
// objective.calculateFFTSpecial(&populationAudioDate[i], &populationFFTData[counter]);
// counter += objective.fftHalfSize;
//}
executeOpenCLFFT();
}
//@ToDo - Right now pick platform. Can extend to pick best available.
int errorStatus_ = 0;
cl_uint num_platforms, num_devices;
cl::Platform platform_;
cl::Context context_;
cl::Device device_;
cl::CommandQueue commandQueue_;
cl::Program kernelProgram_;
std::string kernelSourcePath_;
cl::NDRange globalws_;
cl::NDRange localws_;
clfftPlanHandle planHandle;
void initContextCL(uint8_t aPlatform, uint8_t aDevice)
{
//Discover platforms//
std::vector <cl::Platform> platforms;
cl::Platform::get(&platforms);
//Create contex properties for first platform//
cl_context_properties contextProperties[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[aPlatform])(), 0 }; //Need to specify platform 3 for dedicated graphics - Harri Laptop.
//Create context context using platform for GPU device//
context_ = cl::Context(CL_DEVICE_TYPE_ALL, contextProperties);
//Get device list from context//
std::vector<cl::Device> devices = context_.getInfo<CL_CONTEXT_DEVICES>();
//Create command queue for first device - Profiling enabled//
commandQueue_ = cl::CommandQueue(context_, devices[aDevice], CL_QUEUE_PROFILING_ENABLE, &errorStatus_); //Need to specify device 1[0] of platform 3[2] for dedicated graphics - Harri Laptop.
if (errorStatus_)
std::cout << "ERROR creating command queue for device. Status code: " << errorStatus_ << std::endl;
globalws_ = cl::NDRange(globalSize);
localws_ = cl::NDRange(workgroupX, workgroupY, workgroupZ);
/* FFT library realted declarations */
clfftDim dim = CLFFT_1D;
size_t clLengths[1] = { objective.audioLength };
/* Setup clFFT. */
clfftSetupData fftSetup;
errorStatus_ = clfftInitSetupData(&fftSetup);
errorStatus_ = clfftSetup(&fftSetup);
/* Create a default plan for a complex FFT. */
errorStatus_ = clfftCreateDefaultPlan(&planHandle, context_(), dim, clLengths);
/* Set plan parameters. */
errorStatus_ = clfftSetPlanPrecision(planHandle, CLFFT_SINGLE);
errorStatus_ = clfftSetLayout(planHandle, CLFFT_REAL, CLFFT_HERMITIAN_INTERLEAVED);
errorStatus_ = clfftSetResultLocation(planHandle, CLFFT_OUTOFPLACE);
errorStatus_ = clfftSetPlanBatchSize(planHandle, (size_t)population.populationLength);
size_t in_strides[1] = { 1 };
size_t out_strides[1] = { 1 };
size_t in_dist = (size_t)objective.audioLength;
size_t out_dist = (size_t)objective.audioLength / 2 + 4;
objective.fftOutSize = out_dist * 2;
objective.fftHalfSize = 1 << (objective.audioLengthLog2 - 1);
storageBufferSizes_[inputFFTDataBuffer] = population.populationLength * objective.fftOutSize * sizeof(float);
storageBufferSizes_[inputFFTTargetBuffer] = objective.fftHalfSize * sizeof(float); //objective.fftSizeHalf
clfftSetPlanInStride(planHandle, dim, in_strides);
clfftSetPlanOutStride(planHandle, dim, out_strides);
clfftSetPlanDistance(planHandle, in_dist, out_dist);
/* Bake the plan. */
errorStatus_ = clfftBakePlan(planHandle, 1, &commandQueue_(), NULL, NULL);
}
cl::Buffer inputBuffer;
cl::Buffer outputBuffer;
void initBuffersCL()
{
inputBuffer = cl::Buffer(context_, CL_MEM_READ_WRITE, storageBufferSizes_[outputAudioBuffer]);
outputBuffer = cl::Buffer(context_, CL_MEM_READ_WRITE, storageBufferSizes_[inputFFTDataBuffer]);
}
public:
Evolutionary_Strategy_Vulkan(uint32_t aNumGenerations, uint32_t aNumParents, uint32_t aNumOffspring, uint32_t aNumDimensions, const std::vector<float> aParamMin, const std::vector<float> aParamMax, uint32_t aAudioLengthLog2) :
Evolutionary_Strategy(aNumGenerations, aNumParents, aNumOffspring, aNumDimensions, aParamMin, aParamMax, aAudioLengthLog2),
vkBenchmarker_("vulkanlog.csv", { "Test_Name", "Total_Time", "Average_Time", "Max_Time", "Min_Time", "Max_Difference", "Average_Difference" }),
shaderNames_({ "initPopulation.spv", "recombinePopulation.spv", "mutatePopulation.spv", "SynthesisePopulation.spv", "applyWindowPopulation.spv", "VulkanFFT.spv", "fitnessPopulation.spv", "sortPopulation.spv", "rotatePopulation.spv" })
{
}
Evolutionary_Strategy_Vulkan(Evolutionary_Strategy_Vulkan_Arguments args) :
Evolutionary_Strategy(args.es_args.numGenerations, args.es_args.pop.numParents, args.es_args.pop.numOffspring, args.es_args.pop.numDimensions, args.es_args.paramMin, args.es_args.paramMax, args.es_args.audioLengthLog2),
vkBenchmarker_("vulkanlog.csv", { "Test_Name", "Total_Time", "Average_Time", "Max_Time", "Min_Time", "Max_Difference", "Average_Difference" }),
shaderNames_({ "initPopulation.spv", "recombinePopulation.spv", "mutatePopulation.spv", "SynthesisePopulation.spv", "applyWindowPopulation.spv", "VulkanFFT.spv", "fitnessPopulation.spv", "sortPopulation.spv", "rotatePopulation.spv" }),
workgroupX(args.workgroupX),
workgroupY(args.workgroupY),
workgroupZ(args.workgroupZ),
workgroupSize(args.workgroupX*args.workgroupY*args.workgroupZ),
globalSize(population.populationLength),
numWorkgroupsX(globalSize / workgroupX),
numWorkgroupsY(1),
numWorkgroupsZ(1),
chunkSizeFitness(workgroupSize / 2),
deviceType_(args.deviceType)
{
for (int i = 0; i != randomStatesBuffer; ++i)
storageBufferSizes_[i] = (population.numParents + population.numOffspring) * population.numDimensions * sizeof(float) * 2;
storageBufferSizes_[randomStatesBuffer] = (population.numParents + population.numOffspring) * sizeof(glm::vec2);
storageBufferSizes_[inputPopulationFitnessBuffer] = (population.numParents + population.numOffspring) * sizeof(float) * 2;
storageBufferSizes_[outputPopulationFitnessBuffer] = (population.numParents + population.numOffspring) * sizeof(float) * 2;
storageBufferSizes_[paramMinBuffer] = population.numDimensions * sizeof(float);
storageBufferSizes_[paramMaxBuffer] = population.numDimensions * sizeof(float);
storageBufferSizes_[outputAudioBuffer] = population.populationLength * objective.audioLength * sizeof(float);
storageBufferSizes_[rotationIndexBuffer] = sizeof(uint32_t);
storageBufferSizes_[wavetableBuffer] = objective.wavetableSize * sizeof(float);
rotationIndex_ = 0;
initContextCL(0, 0);
initBuffersCL();
initCLFFT();
populationAudioDate = new float[population.populationLength * objective.audioLength];
populationFFTData = new float[population.populationLength * objective.fftOutSize];
createInstance();
findPhysicalDevice();
createDevice();
initBuffersVK();
createDescriptorSetLayout();
createDescriptorSet();
initConstantsVK();
createComputePipelines();
createCopyCommandPool();
std::vector<VkPipelineLayout> pipelineLayoutsTemp = { computePipelineLayouts_[initPopulation] };
std::vector<VkPipeline> pipelinesTemp = { computePipelines_[initPopulation] };
createCommandBuffer(commandPoolInit_, commandBufferInit_, pipelineLayoutsTemp, pipelinesTemp, &queryPoolInit_);
pipelineLayoutsTemp = { computePipelineLayouts_[recombinePopulation], computePipelineLayouts_[mutatePopulation], computePipelineLayouts_[synthesisePopulation], computePipelineLayouts_[applyWindowPopulation] };
pipelinesTemp = { computePipelines_[recombinePopulation], computePipelines_[mutatePopulation], computePipelines_[synthesisePopulation], computePipelines_[applyWindowPopulation] };
createCommandBuffer(commandPoolESOne_, commandBufferESOne_, pipelineLayoutsTemp, pipelinesTemp, queryPoolESOne_);
pipelineLayoutsTemp = { computePipelineLayouts_[fitnessPopulation], computePipelineLayouts_[sortPopulation] };
pipelinesTemp = { computePipelines_[fitnessPopulation], computePipelines_[sortPopulation] };
createCommandBuffer(commandPoolESTwo_, commandBufferESTwo_, pipelineLayoutsTemp, pipelinesTemp, queryPoolESTwo_);
//createPopulationInitialiseCommandBuffer();
//createESCommandBufferOne();
//createESCommandBufferTwo();
initRandomStateBuffer();
writeLocalBuffer(storageBuffers_[paramMinBuffer], 4 * sizeof(float), (void*)objective.paramMins.data());
writeLocalBuffer(storageBuffers_[paramMaxBuffer], 4 * sizeof(float), (void*)objective.paramMaxs.data());
VKHelper::writeBuffer(logicalDevice_, storageBufferSizes_[wavetableBuffer], stagingBufferMemorySrc, objective.wavetable);
copyBuffer(stagingBufferSrc, storageBuffers_[wavetableBuffer], storageBufferSizes_[wavetableBuffer]);
}
void initCLFFT()
{
//clFFT Variables//
clfftDim dim = CLFFT_1D;
size_t clLengths[1] = { objective.audioLength };
size_t in_strides[1] = { 1 };
size_t out_strides[1] = { 1 };
size_t in_dist = (size_t)objective.audioLength;
size_t out_dist = (size_t)objective.audioLength / 2 + 4;
//Update member variables with new information//
objective.fftOutSize = out_dist * 2;
storageBufferSizes_[inputFFTDataBuffer] = population.populationLength * objective.fftOutSize * sizeof(float);
storageBufferSizes_[inputFFTTargetBuffer] = objective.fftHalfSize * sizeof(float);
//Setup clFFT//
clfftSetupData fftSetup;
errorStatus_ = clfftInitSetupData(&fftSetup);
errorStatus_ = clfftSetup(&fftSetup);
//Create a default plan for a complex FFT//
errorStatus_ = clfftCreateDefaultPlan(&planHandle, context_(), dim, clLengths);
//Set plan parameters//
errorStatus_ = clfftSetPlanPrecision(planHandle, CLFFT_SINGLE);
errorStatus_ = clfftSetLayout(planHandle, CLFFT_REAL, CLFFT_HERMITIAN_INTERLEAVED);
errorStatus_ = clfftSetResultLocation(planHandle, CLFFT_OUTOFPLACE);
errorStatus_ = clfftSetPlanBatchSize(planHandle, (size_t)population.populationLength);
clfftSetPlanInStride(planHandle, dim, in_strides);
clfftSetPlanOutStride(planHandle, dim, out_strides);
clfftSetPlanDistance(planHandle, in_dist, out_dist);
//Bake clFFT plan//
errorStatus_ = clfftBakePlan(planHandle, 1, &commandQueue_(), NULL, NULL);
if (errorStatus_)
std::cout << "ERROR creating clFFT plan. Status code: " << errorStatus_ << std::endl;
}
void writePopulationData()
{
}
void readTestingData(void* aTestingData, size_t aTestingDataSize)
{
copyBuffer(storageBuffers_[inputPopulationValueBuffer], stagingBufferDst, aTestingDataSize);
VKHelper::readBuffer(logicalDevice_, aTestingDataSize, stagingBufferMemoryDst, aTestingData);
}
void readPopulationData(void* aInputPopulationValueData, void* aOutputPopulationValueData, uint32_t aPopulationValueSize, void* aInputPopulationStepData, void* aOutputPopulationStepData, uint32_t aPopulationStepSize, void* aInputPopulationFitnessData, void* aOutputPopulationFitnessData, uint32_t aPopulationFitnessSize)
{
copyBuffer(storageBuffers_[inputPopulationValueBuffer], stagingBufferDst, aPopulationValueSize);
VKHelper::readBuffer(logicalDevice_, aPopulationValueSize, stagingBufferMemoryDst, aInputPopulationValueData);
copyBuffer(storageBuffers_[inputPopulationStepBuffer], stagingBufferDst, aPopulationStepSize);
VKHelper::readBuffer(logicalDevice_, aPopulationStepSize, stagingBufferMemoryDst, aInputPopulationStepData);
copyBuffer(storageBuffers_[inputPopulationFitnessBuffer], stagingBufferDst, aPopulationFitnessSize);
VKHelper::readBuffer(logicalDevice_, aPopulationFitnessSize, stagingBufferMemoryDst, aInputPopulationFitnessData);
}
void writeSynthesizerData(void* aOutputAudioBuffer, uint32_t aOutputAudioSize, void* aInputFFTDataBuffer, void* aInputFFTTargetBuffer, uint32_t aInputFFTSize)
{
}
void readSynthesizerData(void* aOutputAudioBuffer, uint32_t aOutputAudioSize, void* aInputFFTDataBuffer, void* aInputFFTTargetBuffer, uint32_t aInputFFTSize)
{
VKHelper::readBuffer(logicalDevice_, aOutputAudioSize, storageBuffersMemory_[outputAudioBuffer], aOutputAudioBuffer);
VKHelper::readBuffer(logicalDevice_, aInputFFTSize, storageBuffersMemory_[inputFFTDataBuffer], aInputFFTDataBuffer);
VKHelper::readBuffer(logicalDevice_, aInputFFTSize/2, storageBuffersMemory_[inputFFTTargetBuffer], aInputFFTTargetBuffer);
}
void readParamData()
{
}
void writeParamData(void* aParamMinBuffer, void* aParamMaxBuffer)
{
VKHelper::writeBuffer(logicalDevice_, population.numDimensions*sizeof(float), storageBuffersMemory_[paramMinBuffer], aParamMinBuffer);
VKHelper::writeBuffer(logicalDevice_, population.numDimensions*sizeof(float), storageBuffersMemory_[paramMaxBuffer], aParamMaxBuffer);
}
void executeMutate()
{
//commandQueue_.enqueueNDRangeKernel(kernels_[mutatePopulation], cl::NullRange/*globaloffset*/, globalws_, localws_, NULL);
//commandQueue_.finish();
}
void executeFitness()
{
//commandQueue_.enqueueNDRangeKernel(kernels_[fitnessPopulation], cl::NullRange/*globaloffset*/, globalws_, localws_, NULL);
//commandQueue_.finish();
}
void executeSynthesise()
{
//commandQueue_.enqueueNDRangeKernel(kernels_[synthesisePopulation], cl::NullRange/*globaloffset*/, globalws_, localws_, NULL);
//commandQueue_.finish();
}
void executeGeneration()
{
VKHelper::runCommandBuffer(logicalDevice_, computeQueue_, commandBufferESOne_);
//VKHelper::readBuffer(logicalDevice_, storageBufferSizes_[outputAudioBuffer], storageBuffersMemory_[outputAudioBuffer], populationAudioDate);
//copyBuffer(storageBuffers_[outputAudioBuffer], stagingBufferDst, storageBufferSizes_[outputAudioBuffer]);
//VKHelper::readBuffer(logicalDevice_, storageBufferSizes_[outputAudioBuffer], stagingBufferMemoryDst, populationAudioDate);
std::chrono::time_point<std::chrono::steady_clock> start = std::chrono::steady_clock::now();
readLocalBuffer(storageBuffers_[outputAudioBuffer], storageBufferSizes_[outputAudioBuffer], populationAudioDate);
calculateAudioFFT(); //@ToDo - Work out how to calculate FFT for GPU acceptable format.
writeLocalBuffer(storageBuffers_[inputFFTDataBuffer], storageBufferSizes_[inputFFTDataBuffer], populationFFTData);
auto end = std::chrono::steady_clock::now();
auto diff = end - start;
shaderExecuteTime_[5] += diff.count() / (float)1e6;
//VKHelper::writeBuffer(logicalDevice_, storageBufferSizes_[outputAudioBuffer], stagingBufferMemorySrc, populationAudioDate);
//copyBuffer(stagingBufferSrc, storageBuffers_[outputAudioBuffer], storageBufferSizes_[outputAudioBuffer]);
//VKHelper::writeBuffer(logicalDevice_, storageBufferSizes_[inputFFTDataBuffer], storageBuffersMemory_[inputFFTDataBuffer], populationFFTData);
VKHelper::runCommandBuffer(logicalDevice_, computeQueue_, commandBufferESTwo_);
vkBenchmarker_.startTimer(shaderNames_[8]);
rotationIndex_ = (rotationIndex_ == 0 ? 1 : 0);
VKHelper::writeBuffer(logicalDevice_, sizeof(uint32_t), storageBuffersMemory_[rotationIndexBuffer], &rotationIndex_);
vkBenchmarker_.pauseTimer(shaderNames_[8]);
}
void executeAllGenerations()
{
rotationIndex_ = 0;
for (uint32_t i = 0; i != numGenerations; ++i)
{
executeGeneration();
//*rotationIndex_ = (*rotationIndex_ == 0 ? 1 : 0);
//
//VkCommandBuffer commandBuffer = beginSingleTimeCommands();
//for(uint32_t i = 0; i != numPipelines_; ++i)
// vkCmdPushConstants(commandBuffer, computePipelineLayouts_[i], VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(uint32_t), rotationIndex_);
////VkCmdPushConstants(commandBufferESOne_, computePipelineLayouts_[0], VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(uint32_t), rotationIndex_);
//endSingleTimeCommands(commandBuffer);
uint64_t timestamp[2];
vkGetQueryPoolResults(logicalDevice_, queryPoolInit_, 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolInit_, 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
uint64_t diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[0] += diff / (float)1e6;
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[0], 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[0], 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[1] += diff / (float)1e6;
vkBenchmarker_.addTimer(shaderNames_[1], diff / (float)1e6);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[1], 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[1], 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[2] += diff / (float)1e6;
vkBenchmarker_.addTimer(shaderNames_[2], diff / (float)1e6);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[2], 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[2], 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[3] += diff / (float)1e6;
vkBenchmarker_.addTimer(shaderNames_[3], diff / (float)1e6);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[3], 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolESOne_[3], 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[4] += diff / (float)1e6;
vkBenchmarker_.addTimer(shaderNames_[4], diff / (float)1e6);
vkGetQueryPoolResults(logicalDevice_, queryPoolESTwo_[0], 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolESTwo_[0], 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[6] += diff / (float)1e6;
vkBenchmarker_.addTimer(shaderNames_[6], diff / (float)1e6);
vkGetQueryPoolResults(logicalDevice_, queryPoolESTwo_[1], 0, 1, sizeof(uint64_t), &(timestamp[0]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
vkGetQueryPoolResults(logicalDevice_, queryPoolESTwo_[1], 1, 1, sizeof(uint64_t), &(timestamp[1]), 0, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
diff = timestamp[1] - timestamp[0];
shaderExecuteTime_[7] += diff / (float)1e6;
vkBenchmarker_.addTimer(shaderNames_[7], diff / (float)1e6);
}
float totalKernelRunTime = 0.0;
for (uint32_t i = 0; i != numPipelines_; ++i)
{
//executeTime = executeTime / numGenerations;
std::cout << "Time to complete kernel " << i << ": " << shaderExecuteTime_[i] << "ms\n";
totalKernelRunTime += shaderExecuteTime_[i];
}
std::cout << "Time to complete all kernels for this run: " << totalKernelRunTime << "ms\n";
}
void parameterMatchAudio(float* aTargetAudio, uint32_t aTargetAudioLength)
{
chunkSize = objective.audioLength;
chunks = aTargetAudioLength / chunkSize;
for (int i = 0; i < chunks; i++)
{
setTargetAudio(&aTargetAudio[i*chunkSize], chunkSize);
initPopulationVK();
uint32_t rI = 0;
VKHelper::writeBuffer(logicalDevice_, sizeof(uint32_t), storageBuffersMemory_[rotationIndexBuffer], &rI); //Need this?
executeAllGenerations();
uint32_t tempSize = 4 * sizeof(float);
float* tempData = new float[4];
float tempFitness;
copyBuffer(storageBuffers_[inputPopulationValueBuffer], stagingBufferDst, tempSize);
VKHelper::readBuffer(logicalDevice_, tempSize, stagingBufferMemoryDst, tempData);
//VKHelper::readBuffer(logicalDevice_, tempSize, storageBuffersMemory_[inputPopulationValueBuffer], tempData);
copyBuffer(storageBuffers_[inputPopulationFitnessBuffer], stagingBufferDst, sizeof(float));
VKHelper::readBuffer(logicalDevice_, sizeof(float), stagingBufferMemoryDst, &tempFitness);
//VKHelper::readBuffer(logicalDevice_, sizeof(float), storageBuffersMemory_[inputPopulationFitnessBuffer], &tempFitness);
printf("Generation %d parameters:\n Param0 = %f\n Param1 = %f\n Param2 = %f\n Param3 = %f\nFitness=%f\n\n\n", i, tempData[0] * 3520.0, tempData[1] * 8.0, tempData[2] * 3520.0, tempData[3] * 1.0, tempFitness);
}
vkBenchmarker_.elapsedTimer(shaderNames_[1]);
vkBenchmarker_.elapsedTimer(shaderNames_[2]);
vkBenchmarker_.elapsedTimer(shaderNames_[3]);
vkBenchmarker_.elapsedTimer(shaderNames_[4]);
vkBenchmarker_.elapsedTimer(shaderNames_[5]);
vkBenchmarker_.elapsedTimer(shaderNames_[6]);
vkBenchmarker_.elapsedTimer(shaderNames_[7]);
vkBenchmarker_.elapsedTimer(shaderNames_[8]);
}
void executeOpenCLFFT()
{
commandQueue_.enqueueWriteBuffer(inputBuffer, CL_TRUE, 0, storageBufferSizes_[outputAudioBuffer], populationAudioDate);
/* Execute the plan. */
errorStatus_ = clfftEnqueueTransform(planHandle, CLFFT_FORWARD, 1, &commandQueue_(), 0, NULL, NULL, &inputBuffer(), &outputBuffer(), NULL);
commandQueue_.finish();
commandQueue_.enqueueReadBuffer(outputBuffer, CL_TRUE, 0, storageBufferSizes_[inputFFTDataBuffer], populationFFTData);
}
void setTargetAudio(float* aTargetAudio, uint32_t aTargetAudioLength)
{
float* targetFFT = new float[objective.fftHalfSize];
objective.calculateFFT(aTargetAudio, targetFFT);
//@ToDo - Check this works. Not any problems with passing as values//
VKHelper::writeBuffer(logicalDevice_, objective.fftHalfSize * sizeof(float), storageBuffersMemory_[inputFFTTargetBuffer], targetFFT);
delete(targetFFT);
}
void initPopulationVK()
{
VKHelper::runCommandBuffer(logicalDevice_, computeQueue_, commandBufferInit_);
}
//Command execution functions//
VkCommandBuffer beginSingleTimeCommands()
{
//Memory transfer executed like drawing commands//
VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandPool = commandPoolStaging_; //@ToDo - Is this okay to be renderCommandPool only? Or need one for each??
allocInfo.commandBufferCount = 1;
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(logicalDevice_, &allocInfo, &commandBuffer);
//Start recording command buffer//
VkCommandBufferBeginInfo beginInfo = {};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
return commandBuffer;
}
void endSingleTimeCommands(VkCommandBuffer aCommandBuffer)
{
vkEndCommandBuffer(aCommandBuffer);
//Execute command buffer to complete transfer - Can use fences for synchronized, simultaneous execution//
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &aCommandBuffer;
vkQueueSubmit(computeQueue_, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(computeQueue_);
//Cleanup used comand pool//
vkFreeCommandBuffers(logicalDevice_, commandPoolStaging_, 1, &aCommandBuffer); //@ToDo - Is this okay to be renderCommandPool only? Or need one for each??
}
void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size)
{
VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandPool = commandPoolStaging_;
allocInfo.commandBufferCount = 1;
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(logicalDevice_, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo = {};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
VkBufferCopy copyRegion = {};
copyRegion.srcOffset = 0; // Optional
copyRegion.dstOffset = 0; // Optional
copyRegion.size = size;
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region);
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
vkQueueSubmit(computeQueue_, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(computeQueue_);
vkFreeCommandBuffers(logicalDevice_, commandPoolStaging_, 1, &commandBuffer);
}
void readLocalBuffer(VkBuffer aBuffer, uint32_t aSize, void* aOutput)
{
copyBuffer(aBuffer, stagingBufferDst, aSize);
VKHelper::readBuffer(logicalDevice_, aSize, stagingBufferMemoryDst, aOutput);
}
void writeLocalBuffer(VkBuffer aBuffer, uint32_t aSize, void* aInput)
{
VKHelper::writeBuffer(logicalDevice_, aSize, stagingBufferMemorySrc, aInput);
copyBuffer(stagingBufferSrc, aBuffer, aSize);
}
void createCommandBuffer(VkCommandPool& aCommandPool, VkCommandBuffer& aCommandBuffer, std::vector<VkPipelineLayout>& aPipelineLayouts, std::vector<VkPipeline>& aPipelines, /*std::vector<VkQueryPool>&*/ VkQueryPool aQueryPools[])
{
//Timestamp initilize//
VkQueryPoolCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
createInfo.pNext = nullptr;
createInfo.queryType = VK_QUERY_TYPE_TIMESTAMP;
createInfo.queryCount = 2;
for (uint32_t i = 0; i != aPipelineLayouts.size(); ++i)
{
VkResult res = vkCreateQueryPool(logicalDevice_, &createInfo, nullptr, &(aQueryPools[i]));
assert(res == VK_SUCCESS);
}
/*
We are getting closer to the end. In order to send commands to the device(GPU),
we must first record commands into a command buffer.
To allocate a command buffer, we must first create a command pool. So let us do that.
*/
VkCommandPoolCreateInfo commandPoolCreateInfo = {};
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
commandPoolCreateInfo.flags = 0;
// the queue family of this command pool. All command buffers allocated from this command pool,
// must be submitted to queues of this family ONLY.
commandPoolCreateInfo.queueFamilyIndex = queueFamilyIndex_;
VK_CHECK_RESULT(vkCreateCommandPool(logicalDevice_, &commandPoolCreateInfo, NULL, &aCommandPool));
/*
Now allocate a command buffer from the command pool.
*/
VkCommandBufferAllocateInfo commandBufferAllocateInfo = {};
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferAllocateInfo.commandPool = aCommandPool; // specify the command pool to allocate from.
// if the command buffer is primary, it can be directly submitted to queues.
// A secondary buffer has to be called from some primary command buffer, and cannot be directly
// submitted to a queue. To keep things simple, we use a primary command buffer.
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferAllocateInfo.commandBufferCount = 1; // allocate a single command buffer.
VK_CHECK_RESULT(vkAllocateCommandBuffers(logicalDevice_, &commandBufferAllocateInfo, &aCommandBuffer)); // allocate command buffer.
/*
Now we shall start recording commands into the newly allocated command buffer.
*/
VkCommandBufferBeginInfo beginInfo = {};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; // the buffer is only submitted and used once in this application.
VK_CHECK_RESULT(vkBeginCommandBuffer(aCommandBuffer, &beginInfo)); // start recording commands.
for (uint32_t i = 0; i != aPipelineLayouts.size(); ++i)
{
vkCmdResetQueryPool(aCommandBuffer, aQueryPools[i], 0, 2);
/*
We need to bind a pipeline, AND a descriptor set before we dispatch.
The validation layer will NOT give warnings if you forget these, so be very careful not to forget them.
*/
vkCmdBindDescriptorSets(aCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, aPipelineLayouts[i], 0, 1, &descriptorSet_, 0, NULL);
vkCmdBindPipeline(aCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, aPipelines[i]);
//Include loop and update push constants every iteration//
//vkCmdPushConstants(commandBufferInit_, computePipelineLayouts_[initPopulation], VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(uint32_t), rotationIndex_);
vkCmdWriteTimestamp(aCommandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, aQueryPools[i], 0);
/*
Calling vkCmdDispatch basically starts the compute pipeline, and executes the compute shader.
The number of workgroups is specified in the arguments.
If you are already familiar with compute shaders from OpenGL, this should be nothing new to you.
*/
vkCmdDispatch(aCommandBuffer, numWorkgroupsX, numWorkgroupsY, numWorkgroupsZ);
vkCmdPipelineBarrier(aCommandBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, NULL, 0, NULL, 0, NULL, 0, NULL);
vkCmdWriteTimestamp(aCommandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, aQueryPools[i], 1);
}
VK_CHECK_RESULT(vkEndCommandBuffer(aCommandBuffer)); // end recording commands.
}
};
#endif | 48.738408 | 458 | 0.799906 | Harri-Renney |
f25211b062c96bd4607d269177d7eee4e4c09c4a | 7,227 | cpp | C++ | Final/Dataset/B2016_Z2_Z3/student4982.cpp | Team-PyRated/PyRated | 1df171c8a5a98977b7a96ee298a288314d1b1b96 | [
"MIT"
] | null | null | null | Final/Dataset/B2016_Z2_Z3/student4982.cpp | Team-PyRated/PyRated | 1df171c8a5a98977b7a96ee298a288314d1b1b96 | [
"MIT"
] | null | null | null | Final/Dataset/B2016_Z2_Z3/student4982.cpp | Team-PyRated/PyRated | 1df171c8a5a98977b7a96ee298a288314d1b1b96 | [
"MIT"
] | null | null | null | #include <iostream>
#include <stdexcept>
#include <vector>
#include <deque>
#include <type_traits>
#include <cmath>
#include <algorithm>
#include <iomanip>
int SumaCifara(long long int x)
{
int suma=0;
while(x!=0)
{
suma+=std::abs(x%10);
x=x/10;
}
return suma;
}
int SumaDjelilaca(long long int x)
{
int suma=0;
if(x<0) x=-x;
for(long long int i=1;i<=x;i++)
{
if(x%i==0) suma+=i;
}
return suma;
}
bool DaLiJeProst(long long int x)
{
if(x<=1) return false;
long long int i=0;
for(i=2;i<=(int)sqrt(x);i++)
{
if(x%i==0) return false;
}
if(i==(int)sqrt(x)+1) return true;
}
int BrojProstihFaktora(long long int x)
{
if(x<=1) return 0;
if(DaLiJeProst(x)==true) return 1;
int i=2, suma=0, n=x;
while(1)
{
if(i==x) break;
if(DaLiJeProst(i)==false) i++;
if(DaLiJeProst(i)==true)
{
if(n==1) break;
if(n%i==0)
{
n=n/i;
suma++;
}
else i++;
}
}
return suma;
}
bool DaLiJeSavrsen(long long int x)
{
int suma=0;
for(long long int i=1;i<x;i++) if(x%i==0) suma+=i;
if(suma==x) return true;
else return false;
}
int BrojSavrsenihDjelilaca(long long int x)
{
if(x<0) x=-x;
int broj=0;
for(long long int i=1;i<=x;i++) if(x%i==0 && DaLiJeSavrsen(i)==true) broj++;
return broj;
}
template <typename Tip1, typename Tip2, typename Tip3, typename Tip4>
auto UvrnutiPresjek(Tip1 p1, Tip1 p2, Tip2 p3, Tip2 p4, Tip3 fun(Tip4)) -> std::vector<std::vector<typename std::remove_reference<decltype((*p1)+(*p3))>::type>>
{
typedef typename std::remove_reference<decltype((*p1)+(*p3))>::type Tip;
std::vector<std::vector<Tip>> matrica;
Tip2 poc2=p3;
while(p1!=p2)
{
while(p3!=p4)
{
if(fun(*p1)==fun(*p3))
{
std::vector<Tip> v;
v.push_back(*p1); v.push_back(*p3); v.push_back(fun(*p1));
matrica.push_back(v);
}
p3++;
}
p3=poc2;
p1++;
}
std::sort(matrica.begin(), matrica.end(), [](std::vector<Tip> x, std::vector<Tip> y) { return x[2]<y[2]; } );
if(matrica.size()>1) {
for(int i=0;i<matrica.size()-1;i++)
{
for(int j=i+1;j<matrica.size();j++)
{
if(matrica[i][2]==matrica[j][2]) std::sort(matrica.begin()+i,matrica.begin()+j+1, [](std::vector<Tip> x, std::vector<Tip> y) { return x[0]<y[0];});
}
}
for(int i=0;i<matrica.size()-1;i++)
{
for(int j=i+1;j<matrica.size();j++)
{
if(matrica[i][0]==matrica[j][0]) std::sort(matrica.begin()+i,matrica.begin()+j+1, [](std::vector<Tip> x, std::vector<Tip> y) { return x[1]<y[1];});
}
}
}
return matrica;
}
template <typename Tip1, typename Tip2>
auto UvrnutiPresjek(Tip1 p1, Tip1 p2, Tip2 p3, Tip2 p4) -> std::vector<std::vector<typename std::remove_reference<decltype((*p1)+(*p3))>::type>>
{
typedef typename std::remove_reference<decltype((*p1)+(*p3))>::type Tip;
std::vector<std::vector<Tip>> matrica;
Tip2 poc=p3;
while(p1!=p2)
{
while(p3!=p4)
{
if(*p1==*p3)
{
std::vector<Tip> v1;
v1.push_back(*p1); v1.push_back(0); v1.push_back(0);
matrica.push_back(v1);
}
p3++;
}
p3=poc;
p1++;
}
std::sort(matrica.begin(), matrica.end(), [] (std::vector<Tip> x, std::vector<Tip> y) { return x[0]<y[0]; });
return matrica;
}
template<typename Tip1, typename Tip2, typename Tip3, typename Tip4>
auto UvrnutaRazlika(Tip1 p1, Tip1 p2, Tip2 p3, Tip2 p4, Tip3 fun(Tip4)) -> std::vector<std::vector<typename std::remove_reference<decltype((*p1)+(*p3))>::type>>
{
typedef typename std::remove_reference<decltype((*p1)+(*p3))>::type Tip;
std::vector<std::vector<Tip>> matrica;
Tip1 poc=p1; Tip2 poc2=p3;
while(p1!=p2)
{
bool par=false;
while(p3!=p4)
{
if(fun(*p1)==fun(*p3)) par=true;
p3++;
}
p3=poc2;
if(par==false)
{
std::vector<Tip> v;
v.push_back(*p1); v.push_back(fun(*p1));
matrica.push_back(v);
}
p1++;
}
p1=poc;
p3=poc2;
while(p3!=p4)
{
bool par=false;
while(p1!=p2)
{
if(fun(*p3)==fun(*p1)) par=true;
p1++;
}
p1=poc;
if(par==false)
{
std::vector<Tip> v;
v.push_back(*p3); v.push_back(fun(*p3));
matrica.push_back(v);
}
p3++;
}
std::sort(matrica.begin(),matrica.end(),[] (std::vector<Tip> x, std::vector<Tip> y) {return x[0]>y[0];} );
if(matrica.size()>1) {
for(int i=0;i<matrica.size()-1;i++)
{
for(int j=i+1;j<matrica.size();j++)
{
if(matrica[i][0]==matrica[j][0]) std::sort(matrica.begin()+i,matrica.begin()+j+1, [] (std::vector<Tip> x, std::vector<Tip> y) {return x[1]>y[1];} );
}
}
}
return matrica;
}
template<typename Tip1, typename Tip2>
auto UvrnutaRazlika(Tip1 p1, Tip1 p2, Tip2 p3, Tip2 p4) -> std::vector<std::vector<typename std::remove_reference<decltype((*p1)+(*p3))>::type>>
{
typedef typename std::remove_reference<decltype((*p1)+(*p3))>::type Tip;
std::vector<std::vector<Tip>> matrica;
Tip1 poc=p1; Tip2 poc2=p3;
while(p1!=p2)
{
bool par=false;
while(p3!=p4)
{
if(*p1==*p3) par=true;
p3++;
}
p3=poc2;
if(par==false)
{
std::vector<Tip> v;
v.push_back(*p1); v.push_back(0);
matrica.push_back(v);
}
p1++;
}
p1=poc;
p3=poc2;
while(p3!=p4)
{
bool par=false;
while(p1!=p2)
{
if(*p3==*p1) par=true;
p1++;
}
p1=poc;
if(par==false)
{
std::vector<Tip> v;
v.push_back(*p3); v.push_back(0);
matrica.push_back(v);
}
p3++;
}
std::sort(matrica.begin(),matrica.end(),[](std::vector<Tip> x, std::vector<Tip> y){return x[0]>y[0];});
return matrica;
}
int main ()
{
try {
std::cout<<"Unesite broj elemenata prvog kontejnera: ";
int n;
std::cin>>n;
std::deque<int> d1;
std::cout<<"Unesite elemente prvog kontejnera: ";
while(d1.size()<n)
{
int x;
std::cin>>x;
if(d1.size()==0) d1.push_back(x);
else
{
bool ponavlja_se=false;
for(int i=0;i<d1.size();i++)
{
if(d1[i]==x)
{
ponavlja_se=true; break;
}
}
if(ponavlja_se==false) d1.push_back(x);
}
}
std::cout<<"Unesite broj elemenata drugog kontejnera: ";
std::deque<int> d2; int k;
std::cin>>k;
std::cout<<"Unesite elemente drugog kontejnera: ";
while(d2.size()<k)
{
int x;
std::cin>>x;
if(d2.size()==0) d2.push_back(x);
else
{
bool ponavlja_se=false;
for(int i=0;i<d2.size();i++)
{
if(d2[i]==x)
{
ponavlja_se=true; break;
}
}
if(ponavlja_se==false) d2.push_back(x);
}
}
std::vector<std::vector<int>> matrica=UvrnutiPresjek(d1.begin(),d1.end(),d2.begin(),d2.end(),SumaCifara);
std::vector<std::vector<int>> matrica2=UvrnutaRazlika(d1.begin(),d1.end(),d2.begin(),d2.end(),BrojProstihFaktora);
std::cout<<"Uvrnuti presjek kontejnera:"<<std::endl;
for(std::vector<int> red: matrica)
{
for(int x: red) std::cout<<std::setw(6)<<x<<" ";
std::cout<<std::endl;
}
std::cout<<"Uvrnuta razlika kontejnera:"<<std::endl;
for(std::vector<int> red: matrica2)
{
for(int x: red) std::cout<<std::setw(6)<<x<<" ";
std::cout<<std::endl;
}
std::cout<<"Dovidjenja!";
return 0;
}
catch(...)
{
std::cout<<"Izuzetak: nedovoljno memorije";
}
} | 22.100917 | 164 | 0.5705 | Team-PyRated |
f255aecf55b084a234b0747fedf0e3de15bf4980 | 7,619 | cpp | C++ | Necromancer/Terrain.cpp | myffx36/RenderingEngine | 38df29966b3126744fb40c2a97775ae44cea92f9 | [
"MIT"
] | null | null | null | Necromancer/Terrain.cpp | myffx36/RenderingEngine | 38df29966b3126744fb40c2a97775ae44cea92f9 | [
"MIT"
] | null | null | null | Necromancer/Terrain.cpp | myffx36/RenderingEngine | 38df29966b3126744fb40c2a97775ae44cea92f9 | [
"MIT"
] | null | null | null | #include "stdafx.h"
#include "Terrain.h"
const float height_base = 200.0f;
namespace Necromancer {
Terrain::Terrain(const char* file_name, ID3D11Device* device)
{
std::fstream terrain_file;
terrain_file.open(file_name, std::ios::binary | std::ios::in);
terrain_file.seekg(0, std::ios::beg);
auto start_point = terrain_file.tellg();
terrain_file.seekg(0, std::ios::end);
auto end_point = terrain_file.tellg();
unsigned long file_size = end_point;
m_terrain_size = sqrt(file_size / sizeof(float));
unsigned long data_size = file_size / sizeof(float);
m_data = new float[data_size];
terrain_file.seekg(0, std::ios::beg);
terrain_file.read(reinterpret_cast<char*>(m_data), file_size);
terrain_file.close();
//CImage image;
//const size_t cSize = strlen(file_name) + 1;
//wchar_t* wc = new wchar_t[cSize];
//mbstowcs(wc, file_name, cSize);
//image.Load(wc);
//delete[] wc;
//m_terrain_size = image.GetHeight();
//m_data = new float[image.GetHeight() * image.GetWidth()];
//for (int i = 0; i < image.GetWidth(); ++i) {
// for (int j = 0; j < image.GetHeight(); ++j) {
// int index = i * image.GetHeight() + j;
// m_data[index] = (GetRValue(image.GetPixel(i, j))) / 255.0f;
// }
//}
m_position = nullptr;
m_normal = nullptr;
m_indices = nullptr;
generate_position();
generate_indices();
generate_normal();
generate_vb_ib(device);
}
Terrain::~Terrain()
{
delete[] m_data;
if (m_position) delete[] m_position;
if (m_normal) delete[] m_normal;
if (m_indices) delete[] m_indices;
}
void Terrain::generate_position() {
m_position = new Vec3[m_terrain_size * m_terrain_size];
for (unsigned long i = 0; i < m_terrain_size; ++i) {
for (unsigned long j = 0; j < m_terrain_size; ++j) {
unsigned long offset = (i * m_terrain_size + j);
m_position[offset][0] = static_cast<float>(i);
m_position[offset][1] = height_base * m_data[i * m_terrain_size + j];
m_position[offset][2] = static_cast<float>(j);
}
}
}
void Terrain::generate_normal() {
m_normal = new Vec3[m_terrain_size * m_terrain_size];
for (unsigned long i = 0; i < m_terrain_size * m_terrain_size; ++i) {
m_normal[i] = Vec3(0.0f, 0.0f, 0.0f);
}
unsigned long triangle_num = (m_terrain_size - 1) * (m_terrain_size - 1) * 2;
for (unsigned long i = 0; i < triangle_num; ++i) {
unsigned long index_offset = i * 3;
unsigned long i1 = m_indices[index_offset];
unsigned long i2 = m_indices[index_offset + 1];
unsigned long i3 = m_indices[index_offset + 2];
Vec3 p1 = m_position[i1];
Vec3 p2 = m_position[i2];
Vec3 p3 = m_position[i3];
Vec3 l1 = p2 - p1;
Vec3 l2 = p3 - p2;
Vec3 normal = normalize(cross(l2, l1));
m_normal[i1] = m_normal[i1] + normal;
m_normal[i2] = m_normal[i2] + normal;
m_normal[i3] = m_normal[i3] + normal;
}
for (unsigned long i = 0; i < m_terrain_size * m_terrain_size; ++i) {
m_normal[i] = normalize(m_normal[i]);
}
}
void Terrain::generate_indices() {
unsigned long triangle_num = (m_terrain_size - 1) * (m_terrain_size - 1) * 2;
m_index_number = triangle_num * 3;
m_indices = new unsigned long[m_index_number];
for (unsigned long i = 0; i < m_terrain_size - 1; ++i) {
for (unsigned long j = 0; j < m_terrain_size - 1; ++j) {
unsigned long offset = (i * (m_terrain_size - 1) + j) * 6;
unsigned long left_bottom_index = i * m_terrain_size + j;
unsigned long left_top_index = left_bottom_index + 1;
unsigned long right_bottom_index = left_bottom_index + m_terrain_size;
unsigned long right_top_index = right_bottom_index + 1;
m_indices[offset + 0] = left_bottom_index;
m_indices[offset + 1] = right_bottom_index;
m_indices[offset + 2] = left_top_index;
m_indices[offset + 3] = left_top_index;
m_indices[offset + 4] = right_bottom_index;
m_indices[offset + 5] = right_top_index;
}
}
}
void Terrain::generate_vb_ib(ID3D11Device* d3d_device)
{
float *vertices = new float[8 * m_terrain_size * m_terrain_size];
for (unsigned long i = 0; i < m_terrain_size * m_terrain_size; ++i) {
unsigned long vertices_offset = i * 8;
vertices[vertices_offset + 0] = m_position[i].x;
vertices[vertices_offset + 1] = m_position[i].y;
vertices[vertices_offset + 2] = m_position[i].z;
vertices[vertices_offset + 3] = m_normal[i].x;
vertices[vertices_offset + 4] = m_normal[i].y;
vertices[vertices_offset + 5] = m_normal[i].z;
vertices[vertices_offset + 6] = 0.0f;
vertices[vertices_offset + 7] = 0.0f;
}
D3D11_BUFFER_DESC vb_desc;
ZeroMemory(&vb_desc, sizeof(vb_desc));
vb_desc.ByteWidth = 8 * m_terrain_size * m_terrain_size * sizeof(float);
vb_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vb_desc.CPUAccessFlags = 0;
vb_desc.Usage = D3D11_USAGE_DEFAULT;
vb_desc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA vb_init_data;
vb_init_data.pSysMem = vertices;
vb_init_data.SysMemPitch = 0;
vb_init_data.SysMemSlicePitch = 0;
HRESULT hr = d3d_device->CreateBuffer(&vb_desc, &vb_init_data, &m_vertex_buffer);
delete[]vertices;
D3D11_BUFFER_DESC ib_desc;
ZeroMemory(&vb_desc, sizeof(ib_desc));
ib_desc.ByteWidth = m_index_number * sizeof(unsigned long);
ib_desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
ib_desc.CPUAccessFlags = 0;
ib_desc.Usage = D3D11_USAGE_DEFAULT;
ib_desc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA ib_init_data;
ib_init_data.pSysMem = m_indices;
ib_init_data.SysMemPitch = 0;
ib_init_data.SysMemSlicePitch = 0;
hr = d3d_device->CreateBuffer(&ib_desc, &ib_init_data, &m_index_buffer);
char* vs_data;
unsigned long vs_data_size;
std::ifstream vs_file("VertexShader.cso", std::ios::binary | std::ios::ate);
vs_data_size = static_cast<unsigned long>(vs_file.tellg());
vs_file.seekg(std::ios::beg);
vs_data = new char[vs_data_size];
vs_file.read(vs_data, vs_data_size);
vs_file.close();
hr = d3d_device->CreateVertexShader(vs_data, vs_data_size, nullptr, &m_vertex_shader);
char* ps_data;
unsigned long ps_data_size;
std::ifstream ps_file("PixelShader.cso", std::ios::binary | std::ios::ate);
ps_data_size = static_cast<unsigned long>(ps_file.tellg());
ps_file.seekg(std::ios::beg);
ps_data = new char[ps_data_size];
ps_file.read(ps_data, ps_data_size);
ps_file.close();
hr = d3d_device->CreatePixelShader(ps_data, ps_data_size, nullptr, &m_pixel_shader);
D3D11_INPUT_ELEMENT_DESC input_layout_desc[3];
input_layout_desc[0].SemanticName = "POSITION";
input_layout_desc[0].SemanticIndex = 0;
input_layout_desc[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
input_layout_desc[0].InputSlot = 0;
input_layout_desc[0].AlignedByteOffset = 0;
input_layout_desc[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
input_layout_desc[0].InstanceDataStepRate = 0;
input_layout_desc[1].SemanticName = "NORMAL";
input_layout_desc[1].SemanticIndex = 0;
input_layout_desc[1].Format = DXGI_FORMAT_R32G32B32_FLOAT;
input_layout_desc[1].InputSlot = 0;
input_layout_desc[1].AlignedByteOffset = 3 * sizeof(float);
input_layout_desc[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
input_layout_desc[1].InstanceDataStepRate = 0;
input_layout_desc[2].SemanticName = "TEXCOORD";
input_layout_desc[2].SemanticIndex = 0;
input_layout_desc[2].Format = DXGI_FORMAT_R32G32_FLOAT;
input_layout_desc[2].InputSlot = 0;
input_layout_desc[2].AlignedByteOffset = 6 * sizeof(float);
input_layout_desc[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
input_layout_desc[2].InstanceDataStepRate = 0;
hr = d3d_device->CreateInputLayout(input_layout_desc, 3,
vs_data, vs_data_size, &m_input_layout);
}
} | 35.110599 | 88 | 0.708229 | myffx36 |
f25c4187bd60703c16fbcb4709293a8ec00f1145 | 101 | cpp | C++ | code/code-complete/test.cpp | peter-can-talk/cpp-london | e232bf98f28b1d8b56af3af23d43a3f565221ab0 | [
"MIT"
] | 3 | 2017-02-20T23:24:47.000Z | 2019-09-09T19:15:07.000Z | code/code-complete/test.cpp | peter-can-talk/cpp-london-2017 | e232bf98f28b1d8b56af3af23d43a3f565221ab0 | [
"MIT"
] | null | null | null | code/code-complete/test.cpp | peter-can-talk/cpp-london-2017 | e232bf98f28b1d8b56af3af23d43a3f565221ab0 | [
"MIT"
] | null | null | null | struct X {
/**
* foo does things.
*/
void foo(int x) {
}
};
int main() {
X x;
x.
}
| 7.214286 | 21 | 0.405941 | peter-can-talk |
f26663b27836b964aeaa957327dbff9365075dc0 | 12,757 | cpp | C++ | bin/windows/cpp/obj/src/openfl/display/Tilesheet.cpp | DrSkipper/twogames | 916e8af6cd45cf85fbca4a6ea8ee12e24dd6689b | [
"MIT"
] | null | null | null | bin/windows/cpp/obj/src/openfl/display/Tilesheet.cpp | DrSkipper/twogames | 916e8af6cd45cf85fbca4a6ea8ee12e24dd6689b | [
"MIT"
] | null | null | null | bin/windows/cpp/obj/src/openfl/display/Tilesheet.cpp | DrSkipper/twogames | 916e8af6cd45cf85fbca4a6ea8ee12e24dd6689b | [
"MIT"
] | null | null | null | #include <hxcpp.h>
#ifndef INCLUDED_flash_Lib
#include <flash/Lib.h>
#endif
#ifndef INCLUDED_flash_display_BitmapData
#include <flash/display/BitmapData.h>
#endif
#ifndef INCLUDED_flash_display_Graphics
#include <flash/display/Graphics.h>
#endif
#ifndef INCLUDED_flash_display_IBitmapDrawable
#include <flash/display/IBitmapDrawable.h>
#endif
#ifndef INCLUDED_flash_geom_Point
#include <flash/geom/Point.h>
#endif
#ifndef INCLUDED_flash_geom_Rectangle
#include <flash/geom/Rectangle.h>
#endif
#ifndef INCLUDED_openfl_display_Tilesheet
#include <openfl/display/Tilesheet.h>
#endif
namespace openfl{
namespace display{
Void Tilesheet_obj::__construct(::flash::display::BitmapData image)
{
HX_STACK_PUSH("Tilesheet::new","openfl/display/Tilesheet.hx",36);
{
HX_STACK_LINE(38)
this->__bitmap = image;
HX_STACK_LINE(39)
this->__handle = ::openfl::display::Tilesheet_obj::lime_tilesheet_create(image->__handle);
HX_STACK_LINE(41)
this->_bitmapWidth = this->__bitmap->get_width();
HX_STACK_LINE(42)
this->_bitmapHeight = this->__bitmap->get_height();
HX_STACK_LINE(44)
this->_tilePoints = Array_obj< ::Dynamic >::__new();
HX_STACK_LINE(45)
this->_tiles = Array_obj< ::Dynamic >::__new();
HX_STACK_LINE(46)
this->_tileUVs = Array_obj< ::Dynamic >::__new();
}
;
return null();
}
Tilesheet_obj::~Tilesheet_obj() { }
Dynamic Tilesheet_obj::__CreateEmpty() { return new Tilesheet_obj; }
hx::ObjectPtr< Tilesheet_obj > Tilesheet_obj::__new(::flash::display::BitmapData image)
{ hx::ObjectPtr< Tilesheet_obj > result = new Tilesheet_obj();
result->__construct(image);
return result;}
Dynamic Tilesheet_obj::__Create(hx::DynamicArray inArgs)
{ hx::ObjectPtr< Tilesheet_obj > result = new Tilesheet_obj();
result->__construct(inArgs[0]);
return result;}
::flash::geom::Rectangle Tilesheet_obj::getTileUVs( int index){
HX_STACK_PUSH("Tilesheet::getTileUVs","openfl/display/Tilesheet.hx",77);
HX_STACK_THIS(this);
HX_STACK_ARG(index,"index");
HX_STACK_LINE(77)
return this->_tileUVs->__get(index).StaticCast< ::flash::geom::Rectangle >();
}
HX_DEFINE_DYNAMIC_FUNC1(Tilesheet_obj,getTileUVs,return )
::flash::geom::Rectangle Tilesheet_obj::getTileRect( int index){
HX_STACK_PUSH("Tilesheet::getTileRect","openfl/display/Tilesheet.hx",73);
HX_STACK_THIS(this);
HX_STACK_ARG(index,"index");
HX_STACK_LINE(73)
return this->_tiles->__get(index).StaticCast< ::flash::geom::Rectangle >();
}
HX_DEFINE_DYNAMIC_FUNC1(Tilesheet_obj,getTileRect,return )
::flash::geom::Point Tilesheet_obj::getTileCenter( int index){
HX_STACK_PUSH("Tilesheet::getTileCenter","openfl/display/Tilesheet.hx",69);
HX_STACK_THIS(this);
HX_STACK_ARG(index,"index");
HX_STACK_LINE(69)
return this->_tilePoints->__get(index).StaticCast< ::flash::geom::Point >();
}
HX_DEFINE_DYNAMIC_FUNC1(Tilesheet_obj,getTileCenter,return )
Void Tilesheet_obj::drawTiles( ::flash::display::Graphics graphics,Array< Float > tileData,hx::Null< bool > __o_smooth,hx::Null< int > __o_flags){
bool smooth = __o_smooth.Default(false);
int flags = __o_flags.Default(0);
HX_STACK_PUSH("Tilesheet::drawTiles","openfl/display/Tilesheet.hx",62);
HX_STACK_THIS(this);
HX_STACK_ARG(graphics,"graphics");
HX_STACK_ARG(tileData,"tileData");
HX_STACK_ARG(smooth,"smooth");
HX_STACK_ARG(flags,"flags");
{
HX_STACK_LINE(62)
graphics->drawTiles(hx::ObjectPtr<OBJ_>(this),tileData,smooth,flags);
}
return null();
}
HX_DEFINE_DYNAMIC_FUNC4(Tilesheet_obj,drawTiles,(void))
int Tilesheet_obj::addTileRect( ::flash::geom::Rectangle rectangle,::flash::geom::Point centerPoint){
HX_STACK_PUSH("Tilesheet::addTileRect","openfl/display/Tilesheet.hx",51);
HX_STACK_THIS(this);
HX_STACK_ARG(rectangle,"rectangle");
HX_STACK_ARG(centerPoint,"centerPoint");
HX_STACK_LINE(53)
this->_tiles->push(rectangle);
HX_STACK_LINE(54)
if (((centerPoint == null()))){
HX_STACK_LINE(54)
this->_tilePoints->push(::openfl::display::Tilesheet_obj::defaultRatio);
}
else{
HX_STACK_LINE(55)
this->_tilePoints->push(::flash::geom::Point_obj::__new((Float(centerPoint->x) / Float(rectangle->width)),(Float(centerPoint->y) / Float(rectangle->height))));
}
HX_STACK_LINE(56)
this->_tileUVs->push(::flash::geom::Rectangle_obj::__new((Float(rectangle->get_left()) / Float(this->_bitmapWidth)),(Float(rectangle->get_top()) / Float(this->_bitmapHeight)),(Float(rectangle->get_right()) / Float(this->_bitmapWidth)),(Float(rectangle->get_bottom()) / Float(this->_bitmapHeight))));
HX_STACK_LINE(57)
return ::openfl::display::Tilesheet_obj::lime_tilesheet_add_rect(this->__handle,rectangle,centerPoint);
}
HX_DEFINE_DYNAMIC_FUNC2(Tilesheet_obj,addTileRect,return )
int Tilesheet_obj::TILE_SCALE;
int Tilesheet_obj::TILE_ROTATION;
int Tilesheet_obj::TILE_RGB;
int Tilesheet_obj::TILE_ALPHA;
int Tilesheet_obj::TILE_TRANS_2x2;
int Tilesheet_obj::TILE_BLEND_NORMAL;
int Tilesheet_obj::TILE_BLEND_ADD;
int Tilesheet_obj::TILE_BLEND_MULTIPLY;
int Tilesheet_obj::TILE_BLEND_SCREEN;
::flash::geom::Point Tilesheet_obj::defaultRatio;
Dynamic Tilesheet_obj::lime_tilesheet_create;
Dynamic Tilesheet_obj::lime_tilesheet_add_rect;
Tilesheet_obj::Tilesheet_obj()
{
}
void Tilesheet_obj::__Mark(HX_MARK_PARAMS)
{
HX_MARK_BEGIN_CLASS(Tilesheet);
HX_MARK_MEMBER_NAME(_tileUVs,"_tileUVs");
HX_MARK_MEMBER_NAME(_tiles,"_tiles");
HX_MARK_MEMBER_NAME(_tilePoints,"_tilePoints");
HX_MARK_MEMBER_NAME(_bitmapWidth,"_bitmapWidth");
HX_MARK_MEMBER_NAME(_bitmapHeight,"_bitmapHeight");
HX_MARK_MEMBER_NAME(__handle,"__handle");
HX_MARK_MEMBER_NAME(__bitmap,"__bitmap");
HX_MARK_END_CLASS();
}
void Tilesheet_obj::__Visit(HX_VISIT_PARAMS)
{
HX_VISIT_MEMBER_NAME(_tileUVs,"_tileUVs");
HX_VISIT_MEMBER_NAME(_tiles,"_tiles");
HX_VISIT_MEMBER_NAME(_tilePoints,"_tilePoints");
HX_VISIT_MEMBER_NAME(_bitmapWidth,"_bitmapWidth");
HX_VISIT_MEMBER_NAME(_bitmapHeight,"_bitmapHeight");
HX_VISIT_MEMBER_NAME(__handle,"__handle");
HX_VISIT_MEMBER_NAME(__bitmap,"__bitmap");
}
Dynamic Tilesheet_obj::__Field(const ::String &inName,bool inCallProp)
{
switch(inName.length) {
case 6:
if (HX_FIELD_EQ(inName,"_tiles") ) { return _tiles; }
break;
case 8:
if (HX_FIELD_EQ(inName,"_tileUVs") ) { return _tileUVs; }
if (HX_FIELD_EQ(inName,"__handle") ) { return __handle; }
if (HX_FIELD_EQ(inName,"__bitmap") ) { return __bitmap; }
break;
case 9:
if (HX_FIELD_EQ(inName,"drawTiles") ) { return drawTiles_dyn(); }
break;
case 10:
if (HX_FIELD_EQ(inName,"getTileUVs") ) { return getTileUVs_dyn(); }
break;
case 11:
if (HX_FIELD_EQ(inName,"getTileRect") ) { return getTileRect_dyn(); }
if (HX_FIELD_EQ(inName,"addTileRect") ) { return addTileRect_dyn(); }
if (HX_FIELD_EQ(inName,"_tilePoints") ) { return _tilePoints; }
break;
case 12:
if (HX_FIELD_EQ(inName,"defaultRatio") ) { return defaultRatio; }
if (HX_FIELD_EQ(inName,"_bitmapWidth") ) { return _bitmapWidth; }
break;
case 13:
if (HX_FIELD_EQ(inName,"getTileCenter") ) { return getTileCenter_dyn(); }
if (HX_FIELD_EQ(inName,"_bitmapHeight") ) { return _bitmapHeight; }
break;
case 21:
if (HX_FIELD_EQ(inName,"lime_tilesheet_create") ) { return lime_tilesheet_create; }
break;
case 23:
if (HX_FIELD_EQ(inName,"lime_tilesheet_add_rect") ) { return lime_tilesheet_add_rect; }
}
return super::__Field(inName,inCallProp);
}
Dynamic Tilesheet_obj::__SetField(const ::String &inName,const Dynamic &inValue,bool inCallProp)
{
switch(inName.length) {
case 6:
if (HX_FIELD_EQ(inName,"_tiles") ) { _tiles=inValue.Cast< Array< ::Dynamic > >(); return inValue; }
break;
case 8:
if (HX_FIELD_EQ(inName,"_tileUVs") ) { _tileUVs=inValue.Cast< Array< ::Dynamic > >(); return inValue; }
if (HX_FIELD_EQ(inName,"__handle") ) { __handle=inValue.Cast< Dynamic >(); return inValue; }
if (HX_FIELD_EQ(inName,"__bitmap") ) { __bitmap=inValue.Cast< ::flash::display::BitmapData >(); return inValue; }
break;
case 11:
if (HX_FIELD_EQ(inName,"_tilePoints") ) { _tilePoints=inValue.Cast< Array< ::Dynamic > >(); return inValue; }
break;
case 12:
if (HX_FIELD_EQ(inName,"defaultRatio") ) { defaultRatio=inValue.Cast< ::flash::geom::Point >(); return inValue; }
if (HX_FIELD_EQ(inName,"_bitmapWidth") ) { _bitmapWidth=inValue.Cast< int >(); return inValue; }
break;
case 13:
if (HX_FIELD_EQ(inName,"_bitmapHeight") ) { _bitmapHeight=inValue.Cast< int >(); return inValue; }
break;
case 21:
if (HX_FIELD_EQ(inName,"lime_tilesheet_create") ) { lime_tilesheet_create=inValue.Cast< Dynamic >(); return inValue; }
break;
case 23:
if (HX_FIELD_EQ(inName,"lime_tilesheet_add_rect") ) { lime_tilesheet_add_rect=inValue.Cast< Dynamic >(); return inValue; }
}
return super::__SetField(inName,inValue,inCallProp);
}
void Tilesheet_obj::__GetFields(Array< ::String> &outFields)
{
outFields->push(HX_CSTRING("_tileUVs"));
outFields->push(HX_CSTRING("_tiles"));
outFields->push(HX_CSTRING("_tilePoints"));
outFields->push(HX_CSTRING("_bitmapWidth"));
outFields->push(HX_CSTRING("_bitmapHeight"));
outFields->push(HX_CSTRING("__handle"));
outFields->push(HX_CSTRING("__bitmap"));
super::__GetFields(outFields);
};
static ::String sStaticFields[] = {
HX_CSTRING("TILE_SCALE"),
HX_CSTRING("TILE_ROTATION"),
HX_CSTRING("TILE_RGB"),
HX_CSTRING("TILE_ALPHA"),
HX_CSTRING("TILE_TRANS_2x2"),
HX_CSTRING("TILE_BLEND_NORMAL"),
HX_CSTRING("TILE_BLEND_ADD"),
HX_CSTRING("TILE_BLEND_MULTIPLY"),
HX_CSTRING("TILE_BLEND_SCREEN"),
HX_CSTRING("defaultRatio"),
HX_CSTRING("lime_tilesheet_create"),
HX_CSTRING("lime_tilesheet_add_rect"),
String(null()) };
static ::String sMemberFields[] = {
HX_CSTRING("getTileUVs"),
HX_CSTRING("getTileRect"),
HX_CSTRING("getTileCenter"),
HX_CSTRING("drawTiles"),
HX_CSTRING("addTileRect"),
HX_CSTRING("_tileUVs"),
HX_CSTRING("_tiles"),
HX_CSTRING("_tilePoints"),
HX_CSTRING("_bitmapWidth"),
HX_CSTRING("_bitmapHeight"),
HX_CSTRING("__handle"),
HX_CSTRING("__bitmap"),
String(null()) };
static void sMarkStatics(HX_MARK_PARAMS) {
HX_MARK_MEMBER_NAME(Tilesheet_obj::__mClass,"__mClass");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_SCALE,"TILE_SCALE");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_ROTATION,"TILE_ROTATION");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_RGB,"TILE_RGB");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_ALPHA,"TILE_ALPHA");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_TRANS_2x2,"TILE_TRANS_2x2");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_NORMAL,"TILE_BLEND_NORMAL");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_ADD,"TILE_BLEND_ADD");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_MULTIPLY,"TILE_BLEND_MULTIPLY");
HX_MARK_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_SCREEN,"TILE_BLEND_SCREEN");
HX_MARK_MEMBER_NAME(Tilesheet_obj::defaultRatio,"defaultRatio");
HX_MARK_MEMBER_NAME(Tilesheet_obj::lime_tilesheet_create,"lime_tilesheet_create");
HX_MARK_MEMBER_NAME(Tilesheet_obj::lime_tilesheet_add_rect,"lime_tilesheet_add_rect");
};
static void sVisitStatics(HX_VISIT_PARAMS) {
HX_VISIT_MEMBER_NAME(Tilesheet_obj::__mClass,"__mClass");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_SCALE,"TILE_SCALE");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_ROTATION,"TILE_ROTATION");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_RGB,"TILE_RGB");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_ALPHA,"TILE_ALPHA");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_TRANS_2x2,"TILE_TRANS_2x2");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_NORMAL,"TILE_BLEND_NORMAL");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_ADD,"TILE_BLEND_ADD");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_MULTIPLY,"TILE_BLEND_MULTIPLY");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::TILE_BLEND_SCREEN,"TILE_BLEND_SCREEN");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::defaultRatio,"defaultRatio");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::lime_tilesheet_create,"lime_tilesheet_create");
HX_VISIT_MEMBER_NAME(Tilesheet_obj::lime_tilesheet_add_rect,"lime_tilesheet_add_rect");
};
Class Tilesheet_obj::__mClass;
void Tilesheet_obj::__register()
{
hx::Static(__mClass) = hx::RegisterClass(HX_CSTRING("openfl.display.Tilesheet"), hx::TCanCast< Tilesheet_obj> ,sStaticFields,sMemberFields,
&__CreateEmpty, &__Create,
&super::__SGetClass(), 0, sMarkStatics, sVisitStatics);
}
void Tilesheet_obj::__boot()
{
TILE_SCALE= (int)1;
TILE_ROTATION= (int)2;
TILE_RGB= (int)4;
TILE_ALPHA= (int)8;
TILE_TRANS_2x2= (int)16;
TILE_BLEND_NORMAL= (int)0;
TILE_BLEND_ADD= (int)65536;
TILE_BLEND_MULTIPLY= (int)131072;
TILE_BLEND_SCREEN= (int)262144;
defaultRatio= ::flash::geom::Point_obj::__new((int)0,(int)0);
lime_tilesheet_create= ::flash::Lib_obj::load(HX_CSTRING("lime"),HX_CSTRING("lime_tilesheet_create"),(int)1);
lime_tilesheet_add_rect= ::flash::Lib_obj::load(HX_CSTRING("lime"),HX_CSTRING("lime_tilesheet_add_rect"),(int)3);
}
} // end namespace openfl
} // end namespace display
| 35.143251 | 300 | 0.767108 | DrSkipper |
f26b97db07cd2c2457a94eb2ed16d8becd085010 | 963 | cpp | C++ | package/statistics/statistics_gateway/deprecated/btp_deprecated_gateway_multiton.cpp | mambaru/wfc_core | 0c3e7fba82a9bb1580582968efae02ef7fabc87a | [
"MIT"
] | null | null | null | package/statistics/statistics_gateway/deprecated/btp_deprecated_gateway_multiton.cpp | mambaru/wfc_core | 0c3e7fba82a9bb1580582968efae02ef7fabc87a | [
"MIT"
] | 5 | 2019-12-06T01:01:01.000Z | 2021-04-20T21:16:34.000Z | package/statistics/statistics_gateway/deprecated/btp_deprecated_gateway_multiton.cpp | mambaru/wfc_core | 0c3e7fba82a9bb1580582968efae02ef7fabc87a | [
"MIT"
] | null | null | null | //
// Author: Vladimir Migashko <[email protected]>, (C) 2013-2015
//
// Copyright: See COPYING file that comes with this distribution
//
#include "btp_deprecated_gateway_multiton.hpp"
#include "btp_deprecated_gateway.hpp"
#include <wfc/module/multiton.hpp>
#include <wfc/module/instance.hpp>
#include <wfc/name.hpp>
namespace wfc{ namespace core{
namespace {
WFC_NAME2(component_name, "btp-deprecated-gateway")
class impl
: public ::wfc::jsonrpc::gateway_multiton<
component_name,
gateway::btp_deprecated_method_list,
gateway::btp_deprecated_interface
>
{
public:
virtual std::string interface_name() const override
{
return std::string("wfc::btp::ibtp");
}
virtual std::string description() const override
{
return "Gateway for BTP system";
}
};
}
btp_deprecated_gateway_multiton::btp_deprecated_gateway_multiton()
: wfc::component( std::make_shared<impl>() )
{
}
}}
| 20.934783 | 66 | 0.695742 | mambaru |
f26c536c9a9135d1e2875932cd0d32332bcb451f | 3,571 | cpp | C++ | game-emu-common/src/binarytreememorymap.cpp | Dudejoe870/game-emu | 153b7f9b7bc56042cc6d41187688aa1d9a612830 | [
"MIT"
] | 1 | 2022-03-28T21:03:10.000Z | 2022-03-28T21:03:10.000Z | game-emu-common/src/binarytreememorymap.cpp | Dudejoe870/game-emu | 153b7f9b7bc56042cc6d41187688aa1d9a612830 | [
"MIT"
] | null | null | null | game-emu-common/src/binarytreememorymap.cpp | Dudejoe870/game-emu | 153b7f9b7bc56042cc6d41187688aa1d9a612830 | [
"MIT"
] | null | null | null | #include <game-emu/common/physicalmemorymap.h>
namespace GameEmu::Common
{
PhysicalMemoryMap::Entry* BinaryTreeMemoryMap::Map(u8* hostReadMemory, u8* hostWriteMemory, u64 size, u64 baseAddress,
Entry::ReadEventFunction readEvent, Entry::WriteEventFunction writeEvent)
{
entries.push_back(Entry(baseAddress &addressMask, hostReadMemory, hostWriteMemory, size, readEvent, writeEvent));
return &entries[entries.size() - 1];
}
void BinaryTreeMemoryMap::Unmap(const Entry* entry)
{
std::vector<Entry>::iterator entryIndex = std::find(entries.begin(), entries.end(), *entry);
if (entryIndex == entries.end()) return;
entries.erase(entryIndex);
}
std::shared_ptr<BinaryTreeMemoryMap::BinaryTree::Node> BinaryTreeMemoryMap::sortedVectorToBinaryTree(std::vector<Entry>& entries, s64 start, s64 end)
{
if (start > end)
return nullptr;
else if (start == end)
return std::make_shared<BinaryTree::Node>(entries[start]);
s64 mid = (start + end) / 2;
std::shared_ptr<BinaryTree::Node> root = std::make_shared<BinaryTree::Node>(entries[mid]);
root->left = sortedVectorToBinaryTree(entries, start, mid - 1);
root->right = sortedVectorToBinaryTree(entries, mid + 1, end);
return root;
}
void BinaryTreeMemoryMap::Update()
{
if (!entries.empty())
{
std::sort(entries.begin(), entries.end());
// Rebalance the Binary Search Tree
tree.root = sortedVectorToBinaryTree(entries, 0, entries.size() - 1);
}
}
/*
8-bit Write
*/
void BinaryTreeMemoryMap::WriteU8(u8 value, u64 address)
{
WriteImpl<u8, std::endian::native>(static_cast<u64>(value), address);
}
/*
8-bit Read
*/
u8 BinaryTreeMemoryMap::ReadU8(u64 address)
{
return static_cast<u8>(ReadImpl<u8, std::endian::native>(address));
}
/*
16-bit Write
*/
void BinaryTreeMemoryMap::WriteU16BigEndianImpl(u16 value, u64 address)
{
WriteImpl<u16, std::endian::big>(static_cast<u64>(value), address);
}
void BinaryTreeMemoryMap::WriteU16LittleEndianImpl(u16 value, u64 address)
{
WriteImpl<u16, std::endian::little>(static_cast<u64>(value), address);
}
/*
16-bit Read
*/
u16 BinaryTreeMemoryMap::ReadU16BigEndianImpl(u64 address)
{
return static_cast<u16>(ReadImpl<u16, std::endian::big>(address));
}
u16 BinaryTreeMemoryMap::ReadU16LittleEndianImpl(u64 address)
{
return static_cast<u16>(ReadImpl<u16, std::endian::little>(address));
}
/*
32-bit Write
*/
void BinaryTreeMemoryMap::WriteU32BigEndianImpl(u32 value, u64 address)
{
WriteImpl<u32, std::endian::big>(static_cast<u64>(value), address);
}
void BinaryTreeMemoryMap::WriteU32LittleEndianImpl(u32 value, u64 address)
{
WriteImpl<u32, std::endian::little>(static_cast<u64>(value), address);
}
/*
32-bit Read
*/
u32 BinaryTreeMemoryMap::ReadU32BigEndianImpl(u64 address)
{
return static_cast<u32>(ReadImpl<u32, std::endian::big>(address));
}
u32 BinaryTreeMemoryMap::ReadU32LittleEndianImpl(u64 address)
{
return static_cast<u32>(ReadImpl<u32, std::endian::little>(address));
}
/*
64-bit Write
*/
void BinaryTreeMemoryMap::WriteU64BigEndianImpl(u64 value, u64 address)
{
WriteImpl<u64, std::endian::big>(value, address);
}
void BinaryTreeMemoryMap::WriteU64LittleEndianImpl(u64 value, u64 address)
{
WriteImpl<u64, std::endian::little>(value, address);
}
/*
64-bit Read
*/
u64 BinaryTreeMemoryMap::ReadU64BigEndianImpl(u64 address)
{
return ReadImpl<u64, std::endian::big>(address);
}
u64 BinaryTreeMemoryMap::ReadU64LittleEndianImpl(u64 address)
{
return ReadImpl<u64, std::endian::little>(address);
}
}
| 25.147887 | 150 | 0.720806 | Dudejoe870 |
f26e1bf69404f9ff4878ce369c1a86cdd8c60546 | 5,364 | hpp | C++ | patterns/2020_10_19/prefab/include/prefab/IEntity.hpp | liff-engineer/articles | ad3386ef9cda5083793f485e309a9f85ab36f664 | [
"MIT"
] | 2 | 2020-12-01T06:44:41.000Z | 2021-11-22T06:07:52.000Z | patterns/2020_10_19/prefab/include/prefab/IEntity.hpp | liff-engineer/articles | ad3386ef9cda5083793f485e309a9f85ab36f664 | [
"MIT"
] | null | null | null | patterns/2020_10_19/prefab/include/prefab/IEntity.hpp | liff-engineer/articles | ad3386ef9cda5083793f485e309a9f85ab36f664 | [
"MIT"
] | null | null | null | #pragma once
#include <vector>
#include <tuple>
#include <memory>
#include "IComponent.hpp"
namespace prefab
{
//用来操作tuple的foreach算法
template <typename Tuple, typename F, std::size_t ...Indices>
void for_each_impl(Tuple&& tuple, F&& f, std::index_sequence<Indices...>) {
using swallow = int[];
(void)swallow {
1,
(f(std::get<Indices>(std::forward<Tuple>(tuple))), void(), int{})...
};
}
template <typename Tuple, typename F>
void for_each(Tuple&& tuple, F&& f) {
constexpr std::size_t N = std::tuple_size<std::remove_reference_t<Tuple>>::value;
for_each_impl(std::forward<Tuple>(tuple), std::forward<F>(f),
std::make_index_sequence<N>{});
}
//实体基类
class IEntity
{
public:
virtual ~IEntity() = default;
//实现类型Code
virtual HashedStringLiteral implTypeCode() const noexcept = 0;
//根据类型获取数据组件
virtual IComponentBase* component(HashedStringLiteral typeCode) noexcept = 0;
};
//实体集合基类
class IEntitys
{
public:
virtual ~IEntitys() = default;
//实现类型Code
virtual HashedStringLiteral implTypeCode() const noexcept = 0;
//包含的实体(实体生命周期由集合类管理)
virtual std::vector<IEntity*> entitys() noexcept = 0;
};
//引用语义的实体类,不管理实体生命周期
template<typename... Ts>
class EntityView {
std::tuple<IComponent<Ts>* ...> m_components;
private:
//从实体中获取并设置组件接口
template<typename T>
void setComponentOf(IEntity* entity, IComponent<T>*& component)
{
auto typeCode = HashedTypeNameOf<T>();
auto componentBase = entity->component(typeCode);
if (componentBase == nullptr || componentBase->typeCode() != typeCode) {
component = nullptr;
return;
}
component = static_cast<IComponent<T>*>(componentBase);
}
public:
EntityView() = default;
explicit EntityView(IEntity* entity)
{
if (!entity) return;
for_each(m_components, [&](auto& component) {
this->setComponentOf(entity, component);
});
}
//判断是否所有组件都存在且有效
explicit operator bool() const noexcept {
bool result = true;
for_each(m_components, [&](auto component) {
result &= (component != nullptr);
});
return result;
}
template<typename T>
decltype(auto) component() const noexcept {
return std::get<IComponent<T>*>(m_components);
}
template<typename T>
decltype(auto) component() noexcept {
return std::get<IComponent<T>*>(m_components);
}
template<typename T>
decltype(auto) exist() const noexcept {
return component<T>()->exist();
}
template<typename T>
decltype(auto) view() const {
return component<T>()->view();
}
template<typename T>
decltype(auto) remove() noexcept {
return component<T>()->remove();
}
template<typename T>
decltype(auto) assign(T const& v) noexcept {
return component<T>()->assign(v);
}
template<typename T>
decltype(auto) replace(T const& v) noexcept {
return component<T>()->replace(v);
}
};
class IRepository;
//值语义的实体类,使用智能指针管理实体的生命周期
template<typename... Ts>
class Entity :public EntityView<Ts...>
{
friend class IRepository;
std::unique_ptr<IEntity> m_impl;
public:
Entity() = default;
explicit Entity(std::unique_ptr<IEntity>&& entity)
:EntityView(entity.get()), m_impl(std::move(entity))
{};
};
//实体容器
template<typename... Ts>
class Entitys
{
friend class IRepository;
using entity_t = EntityView<Ts...>;
std::vector<entity_t> m_entitys;
std::unique_ptr<IEntitys> m_impl;
public:
Entitys() = default;
explicit Entitys(std::unique_ptr<IEntitys>&& entitys)
:m_impl(std::move(entitys))
{
if (m_impl == nullptr) return;
auto items = m_impl->entitys();
m_entitys.reserve(items.size());
for (auto e : items) {
m_entitys.emplace_back(entity_t{ e });
}
}
decltype(auto) empty() const noexcept {
return m_entitys.empty();
}
decltype(auto) size() const noexcept {
return m_entitys.size();
}
decltype(auto) at(std::size_t i) const {
return m_entitys.at(i);
}
decltype(auto) operator[](std::size_t i) const noexcept {
return m_entitys[i];
}
decltype(auto) begin() const noexcept {
return m_entitys.begin();
}
decltype(auto) end() const noexcept {
return m_entitys.end();
}
decltype(auto) begin() noexcept {
return m_entitys.begin();
}
decltype(auto) end() noexcept {
return m_entitys.end();
}
explicit operator bool() const noexcept {
return (m_impl != nullptr);
}
};
}
| 27.228426 | 89 | 0.543624 | liff-engineer |
f271842da1c802a66058f6006e2a868b865d0c12 | 2,388 | hpp | C++ | include/Network/Session.hpp | Lisoph/MORL | f1c4f9a1c16df236495666fd46d76da6ac9a32af | [
"MIT"
] | 1 | 2015-05-24T17:20:06.000Z | 2015-05-24T17:20:06.000Z | include/Network/Session.hpp | Lisoph/MORL | f1c4f9a1c16df236495666fd46d76da6ac9a32af | [
"MIT"
] | 1 | 2015-05-15T20:29:58.000Z | 2015-05-15T20:29:58.000Z | include/Network/Session.hpp | Lisoph/MORL | f1c4f9a1c16df236495666fd46d76da6ac9a32af | [
"MIT"
] | null | null | null | #pragma once
#include "UdpSocket.hpp"
#include "IPEndpoint.hpp"
#include "Network/SessionState.hpp"
#include <cstdint>
#include <functional>
#include <stack>
namespace MORL {
class Game;
namespace Network {
class Session;
class StateNotRunning : public SessionState {
public:
StateNotRunning(Session &session)
: SessionState(session)
{}
void Update() override {}
};
class Session {
public:
static constexpr uint16_t ServerSocketPort = 5666;
using OwnedSessionState = std::unique_ptr<SessionState>;
using SessionStateStack = std::stack<OwnedSessionState>;
Session(MORL::Game &game);
Session(Session const &) = delete;
Session(Session && other);
~Session();
inline UdpSocket &Socket() {
return mSocket;
}
inline MORL::Game &Game() {
return mGame;
}
inline bool IsConnectedToServer() const {
return mConnectedToServer;
}
inline void ConnectedToServer(IPEndpoint const &server) {
mConnectedToServer = true;
mServer = server;
}
inline IPEndpoint const &Server() const {
return mServer;
}
template <typename S>
inline void PushState(S const &state) {
mStates.push(MakeUnique<S>(state));
}
template <typename S>
inline void PushState(S && state) {
mStates.push(MakeUnique<S>(std::move(state)));
}
template <typename S>
inline void ReplaceState(S const &state) {
if(mStates.size() >= 1) {
mStates.pop();
}
mStates.push(MakeUnique<S>(state));
}
template <typename S>
inline void ReplaceState(S && state) {
if(mStates.size() >= 1) {
mStates.pop();
}
mStates.push(MakeUnique<S>(std::move(state)));
}
void GoBack();
/**
* Update internal stuff, call this once a frame
*/
void Update();
private:
inline SessionState &CurrentState() {
return *(mStates.top().get());
}
private:
// How this socket is used varies from server to client side
UdpSocket mSocket;
MORL::Game &mGame;
SessionStateStack mStates;
// Only used by client
IPEndpoint mServer;
// Only used by client
bool mConnectedToServer = false;
};
}
} | 22.528302 | 66 | 0.588358 | Lisoph |
f27a190e89511dc1e7eaf4ac352322b7f0cc9244 | 9,108 | cpp | C++ | src/Player.cpp | osbixaodaunb/RGBender-2.0 | 9c5e33cba50541b8288e29f56562820b3d7b0e55 | [
"MIT"
] | 4 | 2017-05-15T19:33:28.000Z | 2017-05-15T23:33:04.000Z | src/Player.cpp | osbixaodaunb/RGBender-2.0 | 9c5e33cba50541b8288e29f56562820b3d7b0e55 | [
"MIT"
] | 4 | 2017-10-04T14:29:18.000Z | 2017-10-04T14:43:52.000Z | src/Player.cpp | unbgames/RGBender | 9c5e33cba50541b8288e29f56562820b3d7b0e55 | [
"MIT"
] | 4 | 2017-05-15T19:33:37.000Z | 2017-08-18T14:12:41.000Z | #include "Player.h"
#include "SDLGameObject.h"
#include "LoaderParams.h"
#include "InputHandler.h"
#include "Bullet.h"
#include "Game.h"
#include "Log.h"
#include "Enemy.h"
#include "PlayState.h"
#include "Physics.h"
#include "AudioManager.h"
#include "GameOverState.h"
#include "Childmaiden.h"
#include "Timer.h"
#include <string>
#include <SDL2/SDL.h>
#include <iostream>
#include <cmath>
using namespace std;
using namespace engine;
Player::Player() : SDLGameObject(){
m_fireRate = 500;
m_isShieldActive = false;
m_bulletVenemous = false;
for(int i=1; i<7; i++){
TextureManager::Instance().load("assets/player_health" + to_string(i) + ".png", "health" + to_string(i), Game::Instance().getRenderer());
}
TextureManager::Instance().load("assets/ataque_protagonista_preto.png", "bullet", Game::Instance().getRenderer());
TextureManager::Instance().load("assets/health.png", "health", Game::Instance().getRenderer());
TextureManager::Instance().load("assets/circle.png", "instance", Game::Instance().getRenderer());
TextureManager::Instance().load("assets/Cadeira_frente.png", "chairBullet", Game::Instance().getRenderer());
INFO("Player inicializado");
m_life = 6;
canMove = true;
}
void Player::load(const LoaderParams* pParams){
SDLGameObject::load(pParams);
}
void Player::draw(){
TextureManager::Instance().draw("instance", 100, 600, 100, 100, Game::Instance().getRenderer());
if(m_isShieldActive){
TextureManager::Instance().draw("shield", getPosition().getX()-17, getPosition().getY()-10, 110, 110, Game::Instance().getRenderer());
TextureManager::Instance().draw("brownskill", 110, 610, 80, 80, Game::Instance().getRenderer());
}
if(m_fireRate != 500){
TextureManager::Instance().draw("redskill", 110, 610, 80, 80, Game::Instance().getRenderer());
}
if(bullet!= NULL && bullet->getVenemous() == true){
TextureManager::Instance().draw("greenskill", 110, 610, 80, 80, Game::Instance().getRenderer());
}
TextureManager::Instance().draw("health" +to_string(m_life), 1000, 620, 180, 80, Game::Instance().getRenderer());
SDLGameObject::draw();
}
void Player::update(){
//std::cout << "Player top: " << getPosition().getX() << std::endl;
if(m_life <= 0){
Game::Instance().getStateMachine()->changeState(new GameOverState());
}
if(Game::Instance().getStateMachine()->currentState()->getStateID() == "PLAY"){
PlayState *playState = dynamic_cast<PlayState*>(Game::Instance().getStateMachine()->currentState());
if(playState->getLevel() != NULL && m_boss == NULL){
INFO("Xuxa is set");
m_boss = playState->getLevel()->getXuxa();
}
}
if(!canMove){
int time = Timer::Instance().step() - getStunTime();
if(time >= 700){
canMove = true;
}
rotateTowards();
}
if(shieldHits > 5 && m_isShieldActive){
TextureManager::Instance().clearFromTextureMap("shield");
shieldHits = 0;
m_isShieldActive = false;
}
setPoison();
if(canMove){
handleInput();
}
// if(m_bulletVenemous == true)
// INFO("FOI");
SDLGameObject::update();
}
void Player::setBulletVenemous(bool isVenemous){
m_bulletVenemous = isVenemous;
bullet->setVenemous(isVenemous);
if(isVenemous == false){
uint8_t* pixels = new uint8_t[3];
pixels[0] = 255;
pixels[1] = 255;
pixels[2] = 255;
TheTextureManager::Instance().changeColorPixels(pixels, "RAG");
}
}
void Player::setPoison(){
if(bullet != NULL && bullet->getVenemous() && bullet->isActive()){
if(Timer::Instance().step() <= m_boss->getEnemyTime() && bullet->m_collided){
m_boss->takeDamage(1);
int score = Game::Instance().getScore();
Game::Instance().setScore(score + 5);
TextureManager::Instance().loadText(std::to_string(Game::Instance().getScore()), "assets/fonts/Lato-Regular.ttf", "score", {255,255,255}, 50, Game::Instance().getRenderer());
INFO(m_boss->getHealth());
}else if(Timer::Instance().step() >= m_boss->getEnemyTime()){
//bullet->m_collided = false;
//bullet->setVenemous(false);
}
}
}
void Player::clean(){
SDLGameObject::clean();
}
void Player::handleInput(){
move();
m_numFrames = 4;
m_currentFrame = 1;
if(m_velocity == Vector2D(0, 0)){
rotateTowards();
} else {
Vector2D vec[] = {Vector2D(0,-1), Vector2D(1, -1).norm(), Vector2D(1, 0), Vector2D(1, 1).norm(), Vector2D(0, 1), Vector2D(-1, 1).norm(), Vector2D(-1, 0), Vector2D(-1, -1).norm()};
for(int i=0; i<8; i++){
if(m_velocity.norm() == vec[i]){
changeSprite(i);
}
}
int tmp = m_currentFrame;
m_currentFrame = 1 + int(((SDL_GetTicks() / 100) % (m_numFrames-1)));
}
useSkill();
if(InputHandler::Instance().getMouseButtonState(LEFT, m_fireRate)){
count = Timer::Instance().step() + 300;
AudioManager::Instance().playChunk("assets/sounds/spray.wav");
INFO("FIRE RATE: " + m_fireRate);
Vector2D pivot = Vector2D(m_width/2+m_position.getX(), m_height/2 + m_position.getY());
Vector2D target = InputHandler::Instance().getMousePosition() - pivot;
target = target.norm();
bullet = bulletCreator.create(m_boss);
//bullet->setVenemous(m_bulletVenemous);
bullet->load(target, Vector2D(m_width/2+m_position.getX(), m_height/2 + m_position.getY()));
Game::Instance().getStateMachine()->currentState()->addGameObject(bullet);
}
}
bool inside(double angle, double value){
return value > angle - 22.5 && value < angle + 22.5;
}
void Player::changeSprite(int index){
m_flip = false;
switch(index){
case 0: // UP
m_textureID = "up";
break;
case 1: // UP-RIGHT
m_textureID = "upright";
break;
case 2: // RIGHT
m_flip = true;
m_textureID = "left";
break;
case 3: // DOWN-RIGHT
m_flip = true;
m_textureID = "downleft";
break;
case 4: // DOWN
m_textureID = "down";
break;
case 5: // DOWN-LEFT
m_textureID = "downleft";
break;
case 6: // LEFT
m_textureID = "left";
break;
case 7: // UP-LEFT
m_flip = true;
m_textureID = "upright";
break;
}
if(!canMove){
m_textureID += "stun";
} else if(Timer::Instance().step() < count){
m_textureID += "attack";
}
}
void Player::rotateTowards(){
m_numFrames = 1;
m_currentFrame = 0;
Vector2D pivot = Vector2D(m_width/2+m_position.getX(), m_height/2 + m_position.getY());
Vector2D target = InputHandler::Instance().getMousePosition() - pivot;
target = target.norm();
double angle = Vector2D::angle(target, Vector2D(0, 1));
for(int i=0; i<8; i++){
if(inside(45 * i, angle)){
changeSprite(i);
break;
}
}
}
void Player::move(){
Vector2D movement(0, 0);
if(InputHandler::Instance().isKeyDown("w")){
movement += Vector2D(0, -1);
}
if(InputHandler::Instance().isKeyDown("s")){
movement += Vector2D(0, +1);
}
if(InputHandler::Instance().isKeyDown("d")){
movement += Vector2D(1, 0);
}
if(InputHandler::Instance().isKeyDown("a")){
movement += Vector2D(-1, 0);
}
movement = movement.norm();
if(!m_isDashing){
m_velocity = movement * 2;
}
dash();
if(getPosition().getY() + getHeight() >= 705){
if(m_velocity.getY() > 0)
m_velocity.setY(0);
} else if(getPosition().getY() <= 20){
if(m_velocity.getY() < 0)
m_velocity.setY(0);
}
if(getPosition().getX() + getWidth() >= 1365){
if(m_velocity.getX() > 0)
m_velocity.setX(0);
} else if(getPosition().getX() <= -6){
if(m_velocity.getX() < 0)
m_velocity.setX(0);
}
m_position += m_velocity;
if(Physics::Instance().checkCollision(this, m_boss)){
m_position -= m_velocity;
setLife(m_life - 1);
}
for(auto x: engine::Game::Instance().getStateMachine()->currentState()->getShieldObjects()){
if(Physics::Instance().checkCollision(this, x)){
if(dynamic_cast<Childmaiden*>(x)->getVisibility())
m_position -= m_velocity;
//setLife(m_life - 1);
}
}
}
void Player::useSkill(){
if(InputHandler::Instance().isKeyDown("1", 200)){
m_skillManager.setSkillPair(&m_pSkills, RED, &isFirstSkill);
}
if(InputHandler::Instance().isKeyDown("2", 200)){
m_skillManager.setSkillPair(&m_pSkills, GREEN, &isFirstSkill);
}
if(InputHandler::Instance().isKeyDown("3", 200)){
m_skillManager.setSkillPair(&m_pSkills, BLUE, &isFirstSkill);
}
if(InputHandler::Instance().isKeyDown("r", 100)){
std::map<std::pair<default_inks, default_inks>, bool>::iterator it = m_skillManager.getCoolDownMap()->find(m_pSkills);
if(it != m_skillManager.getCoolDownMap()->end()){
if(it->second == false){
m_skillManager.setCoolDownTrigger(m_pSkills);
if(m_pSkills.first != BLANK and m_pSkills.second != BLANK){
pixelColors = m_skillManager.getSkill(m_pSkills)();
TheTextureManager::Instance().changeColorPixels(pixelColors, "bullet");
//TheTextureManager::Instance().changeColorPixels(pixelColors, "instance");
}
}
else
INFO("TA EM CD");
m_pSkills.first = BLANK;
m_pSkills.second = BLANK;
isFirstSkill = true;
}
}
}
void Player::dash(){
if(InputHandler::Instance().isKeyDown("space", 1000)){
m_dashTime = Timer::Instance().step();
m_velocity = (m_velocity.norm() * 15);
m_isDashing = true;
}
if(m_isDashing && Timer::Instance().step() >= m_dashTime + 100){
m_isDashing = false;
}
}
void Player::setPlayerMoves(bool value){
canMove = value;
}
| 26.553936 | 181 | 0.664361 | osbixaodaunb |
f27b70324b23c204b5ef974c72beaadd47255450 | 414 | cpp | C++ | lecture5/task_6.cpp | zaneta-skiba/cpp | b02ce4252f9cf894370358fded7cfbfa3a317ead | [
"MIT"
] | null | null | null | lecture5/task_6.cpp | zaneta-skiba/cpp | b02ce4252f9cf894370358fded7cfbfa3a317ead | [
"MIT"
] | null | null | null | lecture5/task_6.cpp | zaneta-skiba/cpp | b02ce4252f9cf894370358fded7cfbfa3a317ead | [
"MIT"
] | null | null | null | #include<iostream>
using namespace std;
int main()
{
string names[4];
cout << "Enter 4 names:" << endl;
for (int i = 0; i < 4; i++) // user enters the names
{
cout << "name " << i+1 <<": ";
cin >> names[i];
}
for (int i = 0; i < 4; i++)
{
cout << names[i] << endl; // display names on the screen
}
return 0;
}
| 15.923077 | 79 | 0.417874 | zaneta-skiba |
f27be8659b0b452d8f4a3c58fde153b08c488f8c | 101 | hpp | C++ | source/windows.hpp | phwitti/elevate | 00e4718bcfbf2d5490a3059451d850d17c30d9b0 | [
"Unlicense"
] | 4 | 2021-02-24T23:50:18.000Z | 2021-08-08T11:56:49.000Z | src/shared/windows.hpp | phwitti/cmdhere | a8e7635780b043efb3e220c65366255d8529b615 | [
"Unlicense"
] | null | null | null | src/shared/windows.hpp | phwitti/cmdhere | a8e7635780b043efb3e220c65366255d8529b615 | [
"Unlicense"
] | null | null | null | #ifndef __PW_WINDOWS_HPP__
#define __PW_WINDOWS_HPP__
#define NOMINMAX
#include <Windows.h>
#endif
| 12.625 | 26 | 0.811881 | phwitti |
f27f8336710722dff65995ed0278c5e1a93f3a07 | 926 | cpp | C++ | ITK19_Summer_Training _2021/PreQNOI/21_08_21/e.cpp | hoanghai1803/CP_Training | 03495a21509fb3ab7fc64674b9a1b0c7d4327ecb | [
"MIT"
] | 4 | 2021-08-25T10:53:32.000Z | 2021-09-30T03:25:50.000Z | ITK19_Summer_Training _2021/PreQNOI/21_08_21/e.cpp | hoanghai1803/CP_Training | 03495a21509fb3ab7fc64674b9a1b0c7d4327ecb | [
"MIT"
] | null | null | null | ITK19_Summer_Training _2021/PreQNOI/21_08_21/e.cpp | hoanghai1803/CP_Training | 03495a21509fb3ab7fc64674b9a1b0c7d4327ecb | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, l, r;
cin >> x >> y >> l >> r;
long long powX = 1, powY = 1;
vector<long long> vecX, vecY, vecSum;
while (1) {
vecX.push_back(powX);
if (r / x < powX)
break;
powX *= x;
}
while (1) {
vecY.push_back(powY);
if (r / y < powY)
break;
powY *= y;
}
for (auto _x: vecX)
for (auto _y: vecY)
vecSum.push_back(_x + _y);
sort(vecSum.begin(), vecSum.end());
auto it = vecSum.begin();
while (*it < l)
it++;
if (*it >= r) {
cout << (r - l + (*it > r));
return 0;
}
long long res = *it - l;
it++;
for (; it < vecSum.end() && *it < r; it++)
res = max(res, *it - *(it - 1) - 1);
cout << max(res, r - *(it - 1) - (it != vecSum.end() && r == *it)) << "\n";
} | 21.045455 | 79 | 0.413607 | hoanghai1803 |
f28194fb10280e78290c1e8fd063a8815c6bae80 | 209 | cpp | C++ | src/stream/DirectStream.cpp | Lyatus/L | 0b594d722200d5ee0198b5d7b9ee72a5d1e12611 | [
"Unlicense"
] | 45 | 2018-08-24T12:57:38.000Z | 2021-11-12T11:21:49.000Z | src/stream/DirectStream.cpp | Lyatus/L | 0b594d722200d5ee0198b5d7b9ee72a5d1e12611 | [
"Unlicense"
] | null | null | null | src/stream/DirectStream.cpp | Lyatus/L | 0b594d722200d5ee0198b5d7b9ee72a5d1e12611 | [
"Unlicense"
] | 4 | 2019-09-16T02:48:42.000Z | 2020-07-10T03:50:31.000Z | #include "DirectStream.h"
#include "../container/Buffer.h"
using namespace L;
Buffer DirectStream::read_into_buffer() {
Buffer buffer(size());
seek(0);
read(buffer, buffer.size());
return buffer;
}
| 16.076923 | 41 | 0.69378 | Lyatus |
f28b6c86a411b6fa3e1472f751d8e4235d6aa694 | 1,294 | cpp | C++ | src/Editor/Dynamic/Fields/TexturePathEditor.cpp | Tristeon/Tristeon | 9052e87b743f1122ed4c81952f2bffda96599447 | [
"MIT"
] | 32 | 2018-06-16T20:50:15.000Z | 2022-03-26T16:57:15.000Z | src/Editor/Dynamic/Fields/TexturePathEditor.cpp | Tristeon/Tristeon2D | 9052e87b743f1122ed4c81952f2bffda96599447 | [
"MIT"
] | 2 | 2018-10-07T17:41:39.000Z | 2021-01-08T03:14:19.000Z | src/Editor/Dynamic/Fields/TexturePathEditor.cpp | Tristeon/Tristeon2D | 9052e87b743f1122ed4c81952f2bffda96599447 | [
"MIT"
] | 9 | 2018-06-12T21:00:58.000Z | 2021-01-08T02:18:30.000Z | #include "TexturePathEditor.h"
#include <qboxlayout.h>
#include <qdir.h>
#include <qfiledialog.h>
#include <Settings.h>
#include <AssetManagement/AssetDatabase.h>
namespace TristeonEditor
{
TexturePathEditor::TexturePathEditor(const nlohmann::json& pValue, const std::function<void(nlohmann::json)>& pCallback) : AbstractJsonEditor(pValue, pCallback)
{
const uint32_t guid = _value.value("guid", 0);
_button = new QPushButton(QString(std::to_string(guid).c_str()));
_widget = _button;
QWidget::connect(_button, &QPushButton::clicked,
[=]()
{
QDir const baseDir(Tristeon::Settings::assetPath().c_str());
auto const path = QFileDialog::getOpenFileName(nullptr, QWidget::tr("Find Texture"), Tristeon::Settings::assetPath().c_str(), QWidget::tr("Image Files (*.png *.jpg *.bmp)"));
if (!path.isEmpty())
{
auto const localPath = baseDir.relativeFilePath(path);
auto const fileName = QFileInfo(path).baseName();
_value["guid"] = Tristeon::AssetDatabase::guid("assets://" + localPath.toStdString());
_button->setText(fileName);
_callback(_value);
}
});
}
void TexturePathEditor::setValue(const nlohmann::json& pValue)
{
_value = pValue;
_button->setText(Tristeon::AssetDatabase::path(pValue.value("guid", 0)).c_str());
}
}
| 31.560976 | 178 | 0.697836 | Tristeon |
f290e9b9e1dfe6750502d56b139da0c12d11eefb | 2,707 | cpp | C++ | competitive_programming_3/2_data_structures_and_libraries/2.3_Non-Linear_DS_with_Built-in_Libraries/map(treemap)/978_Lemmings_Battle.cpp | FranciscoPigretti/onlinejudge_solutions | ec9368ade1faa403d0d26ad9321b030e128ae099 | [
"MIT"
] | null | null | null | competitive_programming_3/2_data_structures_and_libraries/2.3_Non-Linear_DS_with_Built-in_Libraries/map(treemap)/978_Lemmings_Battle.cpp | FranciscoPigretti/onlinejudge_solutions | ec9368ade1faa403d0d26ad9321b030e128ae099 | [
"MIT"
] | null | null | null | competitive_programming_3/2_data_structures_and_libraries/2.3_Non-Linear_DS_with_Built-in_Libraries/map(treemap)/978_Lemmings_Battle.cpp | FranciscoPigretti/onlinejudge_solutions | ec9368ade1faa403d0d26ad9321b030e128ae099 | [
"MIT"
] | null | null | null | #include <iostream> // cin, cout
#include <set>
#include <iterator>
using namespace std;
int main() {
int test_cases;
scanf("%d", &test_cases);
int B, SG, SB, current;
multiset <int, greater <int> > greens, blues;
multiset <int, greater <int> > temp_greens, temp_blues;
multiset <int, greater <int> >::iterator g_it, b_it;
while(test_cases--) {
int number_of_snowflakes;
scanf("%d %d %d", &B, &SG, &SB);
greens.clear();
blues.clear();
while(SG--) {
scanf("%d", ¤t);
greens.insert(current);
}
while(SB--) {
scanf("%d", ¤t);
blues.insert(current);
}
while(true) {
for (int i = 0; i < B; i++) {
// saco de cada uno si hay en ambos
if (greens.size() > 0 && blues.size() > 0) {
g_it = greens.begin();
b_it = blues.begin();
int g = *g_it;
int b = *b_it;
greens.erase(g_it);
blues.erase(b_it);
int res = g - b;
if (res > 0) {
temp_greens.insert(res);
} else if (res < 0) {
temp_blues.insert(-res);
} else {
// empate
}
} else {
break;
}
}
// vuelvo a insertar los ganadores
for (auto x : temp_greens) {
greens.insert(x);
}
for (auto x : temp_blues) {
blues.insert(x);
}
temp_greens.clear();
temp_blues.clear();
// si hay en ambos sigo, sino devuelvo el ganador o empate
if (greens.size() == 0 && blues.size() == 0) {
cout << "green and blue died" << endl << endl;
break;
} else if (greens.size() == 0) {
cout << "blue wins" << endl;
for (auto x : blues) {
cout << x << endl;
}
if (test_cases != 0) {
cout << endl;
}
break;
} else if (blues.size() == 0) {
cout << "green wins" << endl;
for (auto x : greens) {
cout << x << endl;
}
if (test_cases != 0) {
cout << endl;
}
break;
}
}
}
} | 27.907216 | 70 | 0.362763 | FranciscoPigretti |
f294481ff7e6dc8c20b6e4ea9d130ef1c07a09a1 | 12,105 | cpp | C++ | runtests.cpp | fguitton/mdipp | a79d207daa3bf6b2b730653d39cd270cf6295859 | [
"BSD-3-Clause"
] | 2 | 2017-11-01T16:45:16.000Z | 2021-02-24T08:29:14.000Z | runtests.cpp | fguitton/mdipp | a79d207daa3bf6b2b730653d39cd270cf6295859 | [
"BSD-3-Clause"
] | null | null | null | runtests.cpp | fguitton/mdipp | a79d207daa3bf6b2b730653d39cd270cf6295859 | [
"BSD-3-Clause"
] | 2 | 2018-03-22T16:40:51.000Z | 2018-07-16T13:05:10.000Z | #include <fstream>
#include <iostream>
#include <memory>
#include <Eigen/Dense>
#include "datatypes.hpp"
#include "utility.hpp"
std::default_random_engine generator;
template<typename T>
void
writeCsvMatrix (std::ostream &fd,
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &data,
const Eigen::VectorXi &alloc)
{
fd << "cluster";
for (int i = 0; i < data.cols(); i++) {
fd << ",f" << i+1;
}
fd << "\n";
for (int i = 0; i < data.rows(); i++) {
fd << "c" << alloc(i)+1;
for (int j = 0; j < data.cols(); j++) {
fd << "," << data(i,j);
}
fd << "\n";
}
}
template<typename T> void
checkEqualTemplate (T a, T b, const std::string &msg)
{
if (a == b)
return;
std::cerr
<< "Error: " << msg
<< " (expecting " << a << " == " << b << ")"
<< std::endl;
}
void checkEqual(int a, int b, const std::string &msg) {
return checkEqualTemplate(a, b, msg); }
template<typename T> void
checkApproxEqual(const T &a, const T &b,
const std::string &msg,
typename T::Scalar epsilon = 1e-6)
{
// Eigen::Array<bool, T::RowsAtCompileTime, T::ColsAtCompileTime>
// em = (a - b).array() <= a.array().abs().min(b.array().abs()) * epsilon;
if (a.isApprox(b, epsilon))
return;
std::cerr
<< "Error: " << msg
<< " (matrix equality check failed at epsilon=" << epsilon << ")"
<< " differences observed: " << std::endl
<< (a-b).array().abs() << std::endl
<< std::endl;
}
void
checkApproxEqual(const double a, const double b,
const std::string &msg, double epsilon = 1e-6)
{
using std::abs;
using std::min;
epsilon *= min(abs(a),abs(b));
if(abs(a-b) <= epsilon)
return;
std::cerr
<< "Error: " << msg
<< " (expecting ||" << a << " - " << b << "|| <= " << epsilon << ")"
<< std::endl;
}
template<typename T> void
checkProbItemMassGt(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> &prob,
int item, T mass, const std::string &msg)
{
// normalise, nans and infinities will propagate!
auto probnorm = prob.array() / prob.sum();
// check all positive
if ((probnorm < 0).any()) {
std::cerr
<< "Error: " << msg
<< " (some probabilities are not positive)\n";
}
if (probnorm(item) < mass) {
std::cerr
<< "Error: " << msg
<< " (mass of item " << item
<< " is " << probnorm(item)
<< ", i.e. < " << mass << ")\n";
}
}
double
nuConditionalAlphaOracle(const Eigen::MatrixXi &alloc)
{
return alloc.rows();
}
double
phiConditionalAlphaOracle(const Eigen::MatrixXi &alloc,
int m, int p)
{
int sum = 0;
for (int i = 0; i < alloc.rows(); i++) {
sum += alloc(i,m) == alloc(i,p);
}
return 1 + sum;
}
double
gammaConditionalAlphaOracle(const Eigen::MatrixXi &alloc,
int m, int jm)
{
int sum = 0;
for (int i = 0; i < alloc.rows(); i++) {
sum += alloc(i,m) == jm;
}
return 1 + sum;
}
/* the following set of functions work by having an @outer function
* that works "down" through the files, setting $j_i$ to the
* appropriate value and then calling the next @outer function. Once
* $j$ has been set for all $K$ files (i.e. @{i == K}), @outer defers
* to @inner and the product for the given $j$ is evaluated.
*/
// See Equation 2 in section "A.2 Normalising Constant" of Kirk et.al 2012
double
nuConditionalBetaOracle(const mdisampler &mdi)
{
const int N = mdi.nclus(), K = mdi.nfiles();
std::vector<int> j(mdi.nfiles());
auto inner = [K,&mdi,&j]() {
long double prod = 1;
for (int k = 0; k < K; k++) {
prod *= mdi.weight(j[k], k);
}
for (int k = 0; k < K-1; k++) {
for (int l = k+1; l < K; l++) {
prod *= 1 + mdi.phi(k, l) * (j[k] == j[l]);
}
}
return prod;
};
std::function<long double(int)> outer = [&outer, &inner, &j, N, K](int i) {
if (i == K)
return inner();
long double sum = 0;
for (j[i] = 0; j[i] < N; j[i]++)
sum += outer(i+1);
return sum;
};
return outer(0);
}
// See Kirk et.al 2012 $b_\phi$ from "Conditional for $\phi_{mp}$"
double
phiConditionalBetaOracle(const mdisampler &mdi,
int m, int p)
{
const int N = mdi.nclus(), K = mdi.nfiles();
std::vector<int> j(mdi.nfiles());
auto inner = [K,&mdi,&j,m,p]() {
long double prod = 1;
for (int k = 0; k < K; k++) {
prod *= mdi.weight(j[k], k);
}
for (int k = 0; k < K-1; k++) {
for (int l = k+1; l < K; l++) {
if (l != p)
prod *= 1 + mdi.phi(k, l) * (j[k] == j[l]);
}
}
for (int k = 0; k < p; k++) {
if (k != m)
prod *= 1 + mdi.phi(k, p) * (j[k] == j[p]);
}
return prod;
};
std::function<long double(int)> outer = [&outer,&inner,&j,N,K,m,p](int i) {
if (i == K)
return inner();
// $j_m$ and $j_p$ are set outside this iteration
if (i == m || i == p)
return outer(i+1);
long double sum = 0;
for (j[i] = 0; j[i] < N; j[i]++)
sum += outer(i+1);
return sum;
};
// iterate over $\sum_{j_m = j_p = 1}^N$
long double sum = 0;
for (int i = 0; i < N; i++) {
j[m] = j[p] = i;
sum += outer(0);
}
return mdi.nu() * sum;
}
// See Kirk et.al 2012 $b_\gamma$ from "Conditional for $\gamma_{j_m m}$"
double
gammaConditionalBetaOracle (const mdisampler &mdi,
const int m, const int jm)
{
const int N = mdi.nclus(), K = mdi.nfiles();
std::vector<int> j(mdi.nfiles());
// within data @m we are interested in cluster @jm
j[m] = jm;
auto inner = [K,m,&mdi,&j]() {
long double prod = 1;
for (int k = 0; k < K; k++) {
if(k != m)
prod *= mdi.weight(j[k], k);
}
for (int k = 0; k < K-1; k++) {
for (int l = k+1; l < K; l++) {
prod *= 1 + mdi.phi(k, l) * (j[k] == j[l]);
}
}
return prod;
};
std::function<long double(int)> outer = [&outer, &inner, &j, N, K, m](int i) {
if (i == K)
return inner();
if (i == m)
return outer(i+1);
long double sum = 0;
for (j[i] = 0; j[i] < N; j[i]++)
sum += outer(i+1);
return sum;
};
return mdi.nu() * outer(0);
}
int
main()
{
/* datatypes
*
* * loading data (CPU)
*
* * summarising data given cluster allocations (CPU GPU)
*
* * sampling cluster parameters given above summary (CPU GPU)
*
* * sampling cluster allocations given cluster parameters (CPU GPU)
*
* MDI prior
*
* * Sampling Nu given [weights and allocations]?
*
* * Sampling weights given [lots!]
*
* * Sampling DPs given weights and nu
*/
generator.seed(1);
// given a single "file" for each datatype, load it in define
// allocations (same for all four files), weights, nu, DP
// concentration
const int
nfiles = 4,
nitems = 5,
nclus = 10,
ngaussfeatures = 3;
// 5 items, cluster allocations [0 0 1 1 2]. one file for each
// datatype
Eigen::MatrixXi alloc(nitems, nfiles);
for (int i = 0; i < nfiles; i++)
alloc.col(i) << 0, 0, 1, 1, 2;
Eigen::MatrixXf
weights = alloc.cast<float>();
Eigen::VectorXf
dpmass = Eigen::VectorXf::Ones(nfiles);
Eigen::MatrixXf data_gaussian(nitems, ngaussfeatures);
data_gaussian <<
-2.1, -2.1, -2.1,
-1.9, -1.9, -1.9,
1.9, 1.9, 1.9,
2.1, 2.1, 2.1,
5.0, 5.0, 5.0;
// write dummy data out, load it back in and make sure it's the same
// as the original data
{
std::ofstream out("data_gauss.txt");
writeCsvMatrix (out, data_gaussian, alloc.col(0));
}
gaussianDatatype dt_gauss("data_gauss.txt");
checkEqual(nitems, dt_gauss.items().size(),
"number of items read from gaussian dataset");
checkEqual(ngaussfeatures, dt_gauss.features().size(),
"number of features read from gaussian dataset");
checkApproxEqual<Eigen::MatrixXf>(data_gaussian.transpose(), dt_gauss.rawdata(),
"gaussian data from file");
// given weights, allocations, nu:
shared shared(nfiles, nclus, nitems);
interdataset inter(nfiles);
mdisampler mdi(inter, nclus);
shared.sampleFromPrior();
mdi.sampleFromPrior();
shared.setAlloc(alloc);
cuda::sampler cuda(nfiles, nitems, nclus,
inter.getPhiOrd(), inter.getWeightOrd());
cuda.setNu(mdi.nu());
cuda.setDpMass(eigenMatrixToStdVector(mdi.dpmass()));
cuda.setAlloc(eigenMatrixToStdVector(alloc));
cuda.setPhis(eigenMatrixToStdVector(mdi.phis()));
cuda.setWeights(eigenMatrixToStdVector(mdi.weights()));
gaussianSampler * gauss_sampler = dt_gauss.newSampler(nclus, &cuda);
// given known allocations, calculate Gaussian summaries
{
gauss_sampler->cudaSampleParameters(alloc.col(0));
gauss_sampler->cudaAccumAllocProbs();
const std::vector<runningstats<> > state(gauss_sampler->accumState(alloc.col(0)));
checkEqual(nclus * ngaussfeatures, state.size(),
"number of accumulated gaussian stats");
// check Gaussian summaries are OK
const runningstats<> rs[nclus] = {{2,-2,0.02},{2,2,0.02},{1,5,0}};
bool ok = true;
for (int j = 0; j < nclus; j++) {
for (int i = 0; i < ngaussfeatures; i++) {
const runningstats<>
&a = state[j * ngaussfeatures + i],
&b = rs[j];
ok &= a.isApprox(b);
}
}
if (!ok) {
std::cout << "Error: some of the accumulated gaussian stats are incorrect\n";
}
}
// given known cluster parameters, ...
{
Eigen::MatrixXf mu(ngaussfeatures, nclus), tau(ngaussfeatures,nclus);
mu.fill(0); tau.fill(20);
mu.col(0).fill(-2);
mu.col(1).fill( 2);
mu.col(2).fill( 5);
gauss_sampler->debug_setMuTau(mu, tau);
}
// ... sample Gaussian cluster association probabilities
{
std::unique_ptr<sampler::item> is(gauss_sampler->newItemSampler());
for (int i = 0; i < nitems; i++) {
Eigen::VectorXf prob((*is)(i));
prob = (prob.array() - prob.maxCoeff()).exp();
checkProbItemMassGt<float>(prob, alloc(i,0), 0.5,
"gaussian cluster allocations");
}
}
{
double
oracle = nuConditionalBetaOracle(mdi);
checkApproxEqual(oracle, mdi.nuConditionalBeta(),
"MDI nu beta conditional, CPU code");
checkApproxEqual(oracle, cuda.collectNuConditionalBeta(),
"MDI nu beta conditional, GPU code");
oracle = nuConditionalAlphaOracle(alloc);
checkApproxEqual(oracle, shared.nuConditionalAlpha(),
"MDI nu alpha conditional, CPU code");
}
{
Eigen::MatrixXf oracle, cpu, gpu;
oracle = cpu = gpu = Eigen::MatrixXf::Zero(nfiles, nfiles);
std::vector<float> gpuv = cuda.collectPhiConditionalsBeta();
for (int k = 0, i = 0; k < nfiles; k++) {
for (int l = k+1; l < nfiles; l++) {
oracle(k,l) = phiConditionalBetaOracle(mdi, k, l);
cpu(k,l) = mdi.phiConditionalBeta(k, l);
gpu(k,l) = gpuv[i++];
}
}
checkApproxEqual(oracle, cpu, "MDI phi beta conditionals, CPU code");
checkApproxEqual(oracle, gpu, "MDI phi beta conditionals, GPU code");
gpuv = cuda.collectPhiConditionalsAlpha();
for (int k = 0, i = 0; k < nfiles; k++) {
for (int l = k+1; l < nfiles; l++) {
oracle(k,l) = phiConditionalAlphaOracle(alloc, k, l);
cpu(k,l) = shared.phiConditionalAlpha(k, l) + 1; // what to do about prior?
gpu(k,l) = gpuv[i++];
}
}
checkApproxEqual(oracle, cpu, "MDI phi alpha conditionals, CPU code");
checkApproxEqual(oracle, gpu, "MDI phi alpha conditionals, GPU code");
}
{
Eigen::MatrixXf oracle, cpu, gpu;
oracle = cpu = Eigen::MatrixXf::Zero(nclus, nfiles);
gpu = stdVectorToEigenMatrix(cuda.collectGammaConditionalsBeta(),
nclus, nfiles);
// take out the prior, not sure what to do about this. I think I
// should be checking priors as well, but conflating it in the
// test unnecessarily seems to make things more difficult to debug
// than it could... hum!
gpu.array() -= 1;
for (int k = 0; k < nfiles; k++) {
for (int j = 0; j < nclus; j++) {
oracle(j,k) = gammaConditionalBetaOracle(mdi, k, j);
cpu(j,k) = mdi.gammaConditionalBeta(k, j);
}
}
checkApproxEqual(oracle, cpu, "MDI gamma beta conditionals, CPU code");
checkApproxEqual(oracle, gpu, "MDI gamma beta conditionals, GPU code");
}
return 0;
}
| 26.546053 | 86 | 0.585378 | fguitton |
f29fee79be5f44a0dd5e04a95fd2201638ea63c1 | 4,862 | cpp | C++ | src/ECS/Systems/UpdateEntityPositionSystem.cpp | novuscore/NovusCore-World | 4c0639e251cac9ae0cef601b814c575a1bfb4f2e | [
"MIT"
] | null | null | null | src/ECS/Systems/UpdateEntityPositionSystem.cpp | novuscore/NovusCore-World | 4c0639e251cac9ae0cef601b814c575a1bfb4f2e | [
"MIT"
] | null | null | null | src/ECS/Systems/UpdateEntityPositionSystem.cpp | novuscore/NovusCore-World | 4c0639e251cac9ae0cef601b814c575a1bfb4f2e | [
"MIT"
] | 2 | 2021-12-20T22:16:11.000Z | 2022-03-10T20:59:10.000Z | #include "UpdateEntityPositionSystem.h"
#include <entt.hpp>
#include <tracy/Tracy.hpp>
#include <Utils/DebugHandler.h>
#include "../../Utils/ServiceLocator.h"
#include "../Components/Singletons/MapSingleton.h"
#include "../Components/Network/ConnectionComponent.h"
#include <Gameplay/Network/PacketWriter.h>
#include <Gameplay/ECS/Components/Transform.h>
#include <Gameplay/ECS/Components/GameEntity.h>
void UpdateEntityPositionSystem::Update(entt::registry& registry)
{
auto modelView = registry.view<Transform, GameEntity>();
if (modelView.size_hint() == 0)
return;
MapSingleton& mapSingleton = registry.ctx<MapSingleton>();
modelView.each([&](const auto entity, Transform& transform, GameEntity& gameEntity)
{
if (gameEntity.type != GameEntity::Type::Player)
return;
std::vector<Point2D> playersWithinDistance;
Tree2D& entityTress = mapSingleton.GetPlayerTree();
if (!entityTress.GetWithinDistance({transform.position.x, transform.position.y}, 500.f, entity, playersWithinDistance))
return;
std::vector<entt::entity>& seenEntities = gameEntity.seenEntities;
if (seenEntities.size() == 0 && playersWithinDistance.size() == 0)
return;
std::vector<entt::entity> newlySeenEntities(playersWithinDistance.size());
for (u32 i = 0; i < playersWithinDistance.size(); i++)
{
newlySeenEntities[i] = playersWithinDistance[i].GetPayload();
}
ConnectionComponent& connection = registry.get<ConnectionComponent>(entity);
// Send Delete Updates to no longer seen entites
{
for (auto it = seenEntities.begin(); it != seenEntities.end();)
{
entt::entity seenEntity = *it;
auto itr = std::find(newlySeenEntities.begin(), newlySeenEntities.end(), seenEntity);
if (itr != newlySeenEntities.end())
{
newlySeenEntities.erase(itr);
it++;
continue;
}
// Remove SeenEntity
{
it = seenEntities.erase(it);
std::shared_ptr<Bytebuffer> packetBuffer = nullptr;
if (PacketWriter::SMSG_DELETE_ENTITY(packetBuffer, seenEntity))
{
connection.AddPacket(packetBuffer, PacketPriority::IMMEDIATE);
}
else
{
DebugHandler::PrintError("Failed to build SMSG_DELETE_ENTITY");
}
}
}
}
// Send Movement Updates to seenEntities
if (seenEntities.size() > 0 && registry.all_of<TransformIsDirty>(entity))
{
std::shared_ptr<Bytebuffer> packetBuffer = nullptr;
if (PacketWriter::SMSG_UPDATE_ENTITY(packetBuffer, entity, transform))
{
for (u32 i = 0; i < seenEntities.size(); i++)
{
entt::entity& seenEntity = seenEntities[i];
if (!registry.valid(seenEntity))
continue;
const GameEntity& seenGameEntity = registry.get<GameEntity>(seenEntity);
if (seenGameEntity.type != GameEntity::Type::Player)
continue;
ConnectionComponent& seenConnection = registry.get<ConnectionComponent>(seenEntity);
seenConnection.AddPacket(packetBuffer, PacketPriority::IMMEDIATE);
}
}
}
// Check if there are any new entities
if (newlySeenEntities.size() == 0)
return;
// List of new entities within range
if (newlySeenEntities.size() > 0)
{
//DebugHandler::PrintSuccess("Preparing Data for Player (%u)", entt::to_integral(entity));
for (u32 i = 0; i < newlySeenEntities.size(); i++)
{
entt::entity newEntity = newlySeenEntities[i];
if (!registry.valid(newEntity))
continue;
const Transform& newTransform = registry.get<Transform>(newEntity);
const GameEntity& newGameEntity = registry.get<GameEntity>(newEntity);
std::shared_ptr<Bytebuffer> packetBuffer = nullptr;
if (PacketWriter::SMSG_CREATE_ENTITY(packetBuffer, newEntity, newGameEntity, newTransform))
{
connection.AddPacket(packetBuffer, PacketPriority::IMMEDIATE);
}
seenEntities.push_back(newEntity);
}
//DebugHandler::PrintSuccess("Finished Preparing Data for Player (%u)", entt::to_integral(entity));
}
});
} | 37.4 | 127 | 0.567668 | novuscore |
f2a21670e5d0d880491c390727879e089abf1476 | 7,027 | cpp | C++ | Operations/albaOpImporterLandmark.cpp | IOR-BIC/ALBA | b574968b05d9a3a2756dd2ac61d015a0d20232a4 | [
"Apache-2.0",
"BSD-3-Clause"
] | 9 | 2018-11-19T10:15:29.000Z | 2021-08-30T11:52:07.000Z | Operations/albaOpImporterLandmark.cpp | IOR-BIC/ALBA | b574968b05d9a3a2756dd2ac61d015a0d20232a4 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | Operations/albaOpImporterLandmark.cpp | IOR-BIC/ALBA | b574968b05d9a3a2756dd2ac61d015a0d20232a4 | [
"Apache-2.0",
"BSD-3-Clause"
] | 3 | 2018-06-10T22:56:29.000Z | 2019-12-12T06:22:56.000Z | /*=========================================================================
Program: ALBA (Agile Library for Biomedical Applications)
Module: albaOpImporterLandmark
Authors: Daniele Giunchi, Simone Brazzale
Copyright (c) BIC
All rights reserved. See Copyright.txt or
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "albaDefines.h"
//----------------------------------------------------------------------------
// NOTE: Every CPP file in the ALBA must include "albaDefines.h" as first.
// This force to include Window,wxWidgets and VTK exactly in this order.
// Failing in doing this will result in a run-time error saying:
// "Failure#0: The value of ESP was not properly saved across a function call"
//----------------------------------------------------------------------------
#include "albaOpImporterLandmark.h"
#include <wx/busyinfo.h>
#include "albaDecl.h"
#include "albaEvent.h"
#include "albaGUI.h"
#include "albaVME.h"
#include "albaVMELandmarkCloud.h"
#include "albaVMELandmark.h"
#include "albaTagArray.h"
#include "albaSmartPointer.h"
#include <fstream>
#include "albaProgressBarHelper.h"
const bool DEBUG_MODE = true;
//----------------------------------------------------------------------------
albaOpImporterLandmark::albaOpImporterLandmark(wxString label) : albaOp(label)
{
m_OpType = OPTYPE_IMPORTER;
m_Canundo = false;
m_TypeSeparation = 0;
m_VmeCloud = NULL;
m_OnlyCoordinates = false;
}
//----------------------------------------------------------------------------
albaOpImporterLandmark::~albaOpImporterLandmark( )
{
albaDEL(m_VmeCloud);
}
//----------------------------------------------------------------------------
albaOp* albaOpImporterLandmark::Copy()
{
albaOpImporterLandmark *cp = new albaOpImporterLandmark(m_Label);
cp->m_Canundo = m_Canundo;
cp->m_OpType = m_OpType;
cp->m_Listener = m_Listener;
cp->m_Next = NULL;
cp->m_OnlyCoordinates = m_OnlyCoordinates;
cp->m_VmeCloud = m_VmeCloud;
cp->m_TypeSeparation = m_TypeSeparation;
return cp;
}
//----------------------------------------------------------------------------
void albaOpImporterLandmark::OpRun()
{
wxString fileDir;
m_File = "";
wxString pgd_wildc = "Landmark (*.*)|*.*";
fileDir = albaGetLastUserFolder().c_str();
albaString f = albaGetOpenFile(fileDir,pgd_wildc).c_str();
if(f != "")
{
m_File = f;
if (!m_TestMode)
{
m_Gui = new albaGUI(this);
wxString choices[4] = { _("Comma"),_("Space"),_("Semicolon"),_("Tab") };
m_Gui->Radio(ID_TYPE_SEPARATION,"Separator",&m_TypeSeparation,4,choices,1,"");
m_Gui->Divider();
m_Gui->Bool(ID_TYPE_FILE,"Coordinates only",&m_OnlyCoordinates,true,"Check if the format is \"x y z\"");
m_Gui->Divider();
m_Gui->Label("");
m_Gui->Divider(1);
m_Gui->OkCancel();
ShowGui();
}
}
else
{
albaEventMacro(albaEvent(this, OP_RUN_CANCEL));
}
}
//----------------------------------------------------------------------------
void albaOpImporterLandmark:: OnEvent(albaEventBase *alba_event)
{
if (albaEvent *e = albaEvent::SafeDownCast(alba_event))
{
switch (e->GetId())
{
case wxOK:
OpStop(OP_RUN_OK);
break;
case wxCANCEL:
OpStop(OP_RUN_CANCEL);
break;
case ID_TYPE_FILE:
case ID_TYPE_SEPARATION:
break;
default:
albaEventMacro(*e);
}
}
}
//----------------------------------------------------------------------------
void albaOpImporterLandmark::OpDo()
{
Read();
wxString path, name, ext;
wxSplitPath(m_File.c_str(),&path,&name,&ext);
m_VmeCloud->SetName(name);
albaTagItem tag_Nature;
tag_Nature.SetName("VME_NATURE");
tag_Nature.SetValue("NATURAL");
m_VmeCloud->GetTagArray()->SetTag(tag_Nature);
GetLogicManager()->VmeAdd(m_VmeCloud);
}
//----------------------------------------------------------------------------
void albaOpImporterLandmark::OpStop(int result)
{
HideGui();
albaEventMacro(albaEvent(this,result));
}
//----------------------------------------------------------------------------
void albaOpImporterLandmark::Read()
{
// need the number of landmarks for the progress bar
std::ifstream landmarkNumberPromptFileStream(m_File);
int numberOfLines = 0;
char line[512], separator;
double x = 0, y = 0, z = 0, t = 0;
long counter = 0, linesReaded = 0;
wxString name;
while(!landmarkNumberPromptFileStream.fail())
{
landmarkNumberPromptFileStream.getline(line,512);
numberOfLines++;
}
landmarkNumberPromptFileStream.close();
albaNEW(m_VmeCloud);
if (m_TestMode == true)
{
m_VmeCloud->TestModeOn();
}
std::ifstream landmarkFileStream(m_File);
albaProgressBarHelper progressHelper(m_Listener);
progressHelper.SetTextMode(m_TestMode);
progressHelper.InitProgressBar("Reading Landmark Cloud");
switch (m_TypeSeparation) //_("Comma"),_("Space"),_("Semicolon"),_("Tab")
{
case 0:
separator = ',';
break;
case 1:
separator = ' ';
break;
case 2:
separator = ';';
case 3:
separator = '\t';
break;
}
while(!landmarkFileStream.fail())
{
landmarkFileStream.getline(line, 512);
if(line[0] == '#' || albaString(line) == "")
{
//skip comments and empty lines
linesReaded++;
continue;
}
else if(strncmp(line, "Time",4)==0)
{
char *time = line + 5;
t = atof(time);
counter = 0;
linesReaded++;
continue;
}
else
{
ConvertLine(line, counter, separator, name, x, y, z);
if (m_VmeCloud->GetLandmarkIndex(name.c_str()) == -1)
{
//New Landmark
m_VmeCloud->AppendLandmark(x, y, z, name);
if (t != 0)
{
//this landmark is present only
int idx = m_VmeCloud->GetLandmarkIndex(name);
m_VmeCloud->SetLandmarkVisibility(idx, false, 0);
}
}
else
{
//Set an existing landmark
m_VmeCloud->SetLandmark(name, x, y, z, t);
}
bool visibility = !(x == -9999 && y == -9999 && z == -9999);
m_VmeCloud->SetLandmarkVisibility(counter, visibility, t);
counter++;
linesReaded++;
progressHelper.UpdateProgressBar(linesReaded * 100 / numberOfLines);
}
}
m_VmeCloud->Modified();
m_VmeCloud->ReparentTo(m_Input);
landmarkFileStream.close();
m_Output = m_VmeCloud;
}
void albaOpImporterLandmark::ConvertLine(char *line, int count, char separator, wxString &name, double &x, double &y, double &z)
{
wxString str = wxString(line);
if (m_OnlyCoordinates)
{
name = "LM ";
name << count;
}
else
{
name = str.BeforeFirst(separator);
str = str.After(separator);
}
wxString xStr = str.BeforeFirst(separator);
str = str.AfterFirst(separator);
wxString yStr = str.BeforeFirst(separator);
wxString zStr = str.AfterFirst(separator);
xStr.ToDouble(&x);
yStr.ToDouble(&y);
zStr.ToDouble(&z);
}
| 25.18638 | 128 | 0.588587 | IOR-BIC |
f2a96756f9c5581c82820de3bde9780e0eaad7de | 3,500 | cpp | C++ | 09/smoke_basin.t.cpp | ComicSansMS/AdventOfCode2021 | 60902d14c356c3375266703e85aca991241afc84 | [
"Unlicense"
] | null | null | null | 09/smoke_basin.t.cpp | ComicSansMS/AdventOfCode2021 | 60902d14c356c3375266703e85aca991241afc84 | [
"Unlicense"
] | null | null | null | 09/smoke_basin.t.cpp | ComicSansMS/AdventOfCode2021 | 60902d14c356c3375266703e85aca991241afc84 | [
"Unlicense"
] | null | null | null | #include <smoke_basin.hpp>
#include <catch.hpp>
#include <sstream>
TEST_CASE("Smoke Basin")
{
char const sample_input[] = "2199943210" "\n"
"3987894921" "\n"
"9856789892" "\n"
"8767896789" "\n"
"9899965678" "\n";
Heightmap const map = parseInput(sample_input);
SECTION("Parse Input")
{
CHECK(map.width == 10);
CHECK(map.height == 5);
CHECK(map.map.size() == 50);
CHECK(fmt::format("{}", map) == sample_input);
}
SECTION("Lowest in Neighbourhood")
{
CHECK(!isLowerThan4Neighbourhood(map, 0, 0));
CHECK(isLowerThan4Neighbourhood(map, 1, 0));
CHECK(isLowerThan4Neighbourhood(map, 9, 0));
CHECK(!isLowerThan4Neighbourhood(map, 0, 4));
CHECK(!isLowerThan4Neighbourhood(map, 9, 4));
}
SECTION("Point Equality")
{
CHECK(Point{ .x = 1, .y = 2 } == Point{ .x = 1, .y = 2 });
CHECK(!(Point{ .x = 0, .y = 2 } == Point{ .x = 1, .y = 2 }));
CHECK(!(Point{ .x = 1, .y = 0 } == Point{ .x = 1, .y = 2 }));
CHECK(!(Point{ .x = 5, .y = 5 } == Point{ .x = 1, .y = 2 }));
}
SECTION("Get Low Points")
{
auto points = getLowPoints(map);
REQUIRE(points.size() == 4);
CHECK(points[0] == Point{ .x = 1, .y = 0 });
CHECK(points[1] == Point{ .x = 9, .y = 0 });
CHECK(points[2] == Point{ .x = 2, .y = 2 });
CHECK(points[3] == Point{ .x = 6, .y = 4 });
}
SECTION("Result 1")
{
CHECK(result1(map) == 15);
}
SECTION("Partition Basins")
{
auto basins = partitionBasins(map);
REQUIRE(basins.size() == 4);
CHECK(basins[0].points == std::vector{
Point{ .x = 0, .y = 0 },
Point{ .x = 1, .y = 0 },
Point{ .x = 0, .y = 1 },
});
CHECK(basins[1].points == std::vector{
Point{.x = 5, .y = 0 },
Point{.x = 6, .y = 0 },
Point{.x = 7, .y = 0 },
Point{.x = 8, .y = 0 },
Point{.x = 9, .y = 0 },
Point{.x = 6, .y = 1 },
Point{.x = 8, .y = 1 },
Point{.x = 9, .y = 1 },
Point{.x = 9, .y = 2 },
});
CHECK(basins[2].points == std::vector{
Point{.x = 2, .y = 1 },
Point{.x = 3, .y = 1 },
Point{.x = 4, .y = 1 },
Point{.x = 1, .y = 2 },
Point{.x = 2, .y = 2 },
Point{.x = 3, .y = 2 },
Point{.x = 4, .y = 2 },
Point{.x = 5, .y = 2 },
Point{.x = 0, .y = 3 },
Point{.x = 1, .y = 3 },
Point{.x = 2, .y = 3 },
Point{.x = 3, .y = 3 },
Point{.x = 4, .y = 3 },
Point{.x = 1, .y = 4 },
});
CHECK(basins[3].points == std::vector{
Point{.x = 7, .y = 2 },
Point{.x = 6, .y = 3 },
Point{.x = 7, .y = 3 },
Point{.x = 8, .y = 3 },
Point{.x = 5, .y = 4 },
Point{.x = 6, .y = 4 },
Point{.x = 7, .y = 4 },
Point{.x = 8, .y = 4 },
Point{.x = 9, .y = 4 },
});
}
SECTION("Result 2")
{
CHECK(result2(map) == 1134);
}
}
| 31.25 | 69 | 0.369429 | ComicSansMS |
f2ae2ff61ab14da82b661a799256e159355fbb26 | 1,054 | cpp | C++ | Source/PracticeVeter/Characters/Animations/BaseCharacterAnimInstance.cpp | mile634/ExperimentalUE | 20a7b13af43c79e7b53920b25b451da9212429e3 | [
"MIT"
] | null | null | null | Source/PracticeVeter/Characters/Animations/BaseCharacterAnimInstance.cpp | mile634/ExperimentalUE | 20a7b13af43c79e7b53920b25b451da9212429e3 | [
"MIT"
] | null | null | null | Source/PracticeVeter/Characters/Animations/BaseCharacterAnimInstance.cpp | mile634/ExperimentalUE | 20a7b13af43c79e7b53920b25b451da9212429e3 | [
"MIT"
] | null | null | null | // Fill out your copyright notice in the Description page of Project Settings.
#include "BaseCharacterAnimInstance.h"
#include "PracticeVeter/Characters/BaseCharacter.h"
#include "PracticeVeter/Components/MovementComponents/MyBaseCharacterMovementComponent.h"
void UBaseCharacterAnimInstance::NativeBeginPlay()
{
Super::NativeBeginPlay();
checkf(TryGetPawnOwner()->IsA<ABaseCharacter>(),
TEXT("UBaseCharacterAnimInstance::NativeBeginPlay() can be used only with BaseCharacter"));
CachedBaseCharacter = StaticCast<ABaseCharacter*>(TryGetPawnOwner());
}
void UBaseCharacterAnimInstance::NativeUpdateAnimation(float DeltaSeconds)
{
Super::NativeUpdateAnimation(DeltaSeconds);
if (!CachedBaseCharacter.IsValid())
{
return;
}
UMyBaseCharacterMovementComponent* CharacterMovement = CachedBaseCharacter->GetBaseCharacterMovementComponent();
Speed = CharacterMovement->Velocity.Size();
bIsFalling = CharacterMovement->IsFalling();
bIsCrouching = CharacterMovement->IsCrouching();
bIsSprinting = CharacterMovement->IsSprinting();
}
| 31.939394 | 113 | 0.805503 | mile634 |
f2b21addfdadd2d17c3507ad5a4b634ba8889390 | 741 | cpp | C++ | DataStructure/c++/Linked-list/Remove loop in Linked List.cpp | Sauradip07/DataStructures-and-Algorithm | d782e2e5cf2caedce7202c4aac43ee0ca3a0c285 | [
"MIT"
] | 17 | 2021-09-13T14:50:29.000Z | 2022-01-07T10:53:35.000Z | DataStructure/c++/Linked-list/Remove loop in Linked List.cpp | Manish4Kumar/DataStructures-and-Algorithm | 7f3b156af8b380a0a2785782e6437a6cc5835448 | [
"MIT"
] | 15 | 2021-10-01T04:13:32.000Z | 2021-11-05T07:49:55.000Z | DataStructure/c++/Linked-list/Remove loop in Linked List.cpp | Manish4Kumar/DataStructures-and-Algorithm | 7f3b156af8b380a0a2785782e6437a6cc5835448 | [
"MIT"
] | 11 | 2021-09-23T14:37:03.000Z | 2021-11-04T13:22:17.000Z | Remove loop in Linked List : https://practice.geeksforgeeks.org/problems/remove-loop-in-linked-list/1#
solution:
void removeLoop(Node* head)
{
Node* low=head;
Node* high=head;
while(low!=NULL and high!=NULL and high->next!=NULL){
low=low->next;
high=high->next->next;
if(low==high) break;
}
if(low==head){
while(high->next!=low){
high=high->next;
}
high->next=NULL;
}
else if(low==high){
low=head;
while(low->next!=high->next){
low=low->next;
high=high->next;
}
high->next=NULL;
}
}
| 25.551724 | 102 | 0.453441 | Sauradip07 |
f2b290c54fb16b4f60d60b2c9d8596e02023abc1 | 2,542 | cxx | C++ | periphery/gpio.cxx | trotill/11parts_CPP | 53a69d516fdcb5c92b591b5dadc49dfdd2a3b26b | [
"MIT"
] | null | null | null | periphery/gpio.cxx | trotill/11parts_CPP | 53a69d516fdcb5c92b591b5dadc49dfdd2a3b26b | [
"MIT"
] | null | null | null | periphery/gpio.cxx | trotill/11parts_CPP | 53a69d516fdcb5c92b591b5dadc49dfdd2a3b26b | [
"MIT"
] | null | null | null | /*
* gpio.cxx
*
* Created on: 30 июля 2014 г.
* Author: root
*/
#include "gpio.h"
eErrorTp GpioInInit(u8 gpio)
{
string str;
str= "echo \"" + intToString(gpio) + "\"> /sys/class/gpio/export";
printf("%s\n",str.c_str());
system(str.c_str());
str= "echo \"in\" > /sys/class/gpio/gpio"+intToString(gpio)+"/direction";
printf("%s\n",str.c_str());
system(str.c_str());
return NO_ERROR;
}
eErrorTp GpioOutInit(u8 gpio, u8 defval)
{
string str;
str= "echo \"" + intToString(gpio) + "\"> /sys/class/gpio/export";
system(str.c_str());
str= "echo \""+ intToString(defval) +"\" > /sys/class/gpio/gpio"+intToString(gpio)+"/value";
system(str.c_str());
str= "echo \"out\" > /sys/class/gpio/gpio"+intToString(gpio)+"/direction";
system(str.c_str());
return NO_ERROR;
}
u8 GpioInRead(u8 gpio)
{
string res=ExecResult("cat",(char*)string("/sys/class/gpio/gpio"+intToString(gpio)+"/value").c_str());
//printf("res %s\n",res.c_str());
if (res=="1\n")
return 1;
else
return 0;
}
eErrorTp GpioOnOff(u8 gpio,u8 val)
{
string str;
//if (val)
//val=(~val)&0x1;
str= "echo "+ intToString(val) +" > /sys/class/gpio/gpio"+intToString(gpio)+"/value";
system(str.c_str());
printf("%s\n",str.c_str());
return NO_ERROR;
}
gpio::gpio(string num,string direct,string value){
ngpio=num;
int fd = open("/sys/class/gpio/export", O_WRONLY);
write(fd, num.c_str(), num.size());
close(fd);
access=O_RDONLY;
if (direct=="out"){
access=O_WRONLY;
}
fd_val = open(string_format("/sys/class/gpio/gpio%s/value",num.c_str()).c_str(), access);
//write(fd_val, value.c_str(), value.size());
printf("open %s\n",string_format("/sys/class/gpio/gpio%s/value",num.c_str()).c_str());
//printf("Write %s size %d\n",value.c_str(),value.size());
fd_dir = open(string_format("/sys/class/gpio/gpio%s/direction",num.c_str()).c_str(), O_WRONLY);
write(fd_dir, direct.c_str(), direct.size());
if (direct=="out")
set((char*)value.c_str());
//set("1");
//printf("Write %s size %d\n",value.c_str(),value.size());
//sleep(5);
//int fd = open("/sys/class/gpio/gpio23/value", O_WRONLY);
}
gpio::~gpio(void){
close(fd_val);
close(fd_dir);
}
eErrorTp gpio::set(char * val){
write(fd_val, val, 1);
return NO_ERROR;
}
u32 gpio::get(void){
char buf[2]={0};
u32 len=read(fd_val, buf, 1);
//printf("get %d %d len %d\n",buf[0],buf[1],len);
close(fd_val);
fd_val = open(string_format("/sys/class/gpio/gpio%s/value",ngpio.c_str()).c_str(), access);
return atoi(buf);
}
| 21.542373 | 103 | 0.623131 | trotill |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.